/* /Components/Layout/AuthLayout.razor.rz.scp.css */
.vx-auth-shell[b-8i7nb94ey5] {
    position: relative;
    min-height: 100vh;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    gap: 1rem;
    padding: 1.5rem;
}

/* RadzenAppearanceToggle also renders without the scope attribute
   (ADR-014) — same ::deep anchoring as the card below. */
[b-8i7nb94ey5] .vx-auth-toggle {
    position: absolute;
    top: 0.75rem;
    right: 0.75rem;
}

.vx-auth-brand[b-8i7nb94ey5] {
    font-weight: 700;
    font-size: 1.25rem;
    text-decoration: none;
    color: var(--vx-text);
}

/* RadzenCard renders without this file's scope attribute (ADR-014); ::deep
   anchored on the class placed directly on the component reaches it. */
[b-8i7nb94ey5] .vx-auth-card {
    width: 100%;
    max-width: 26.25rem;
}
/* /Components/Layout/MainLayout.razor.rz.scp.css */
/* App chrome: header bar, brand, drawer. Owned by MainLayout, which renders
   every element styled here (issue #86).

   Two rules below target DOM that Radzen renders — the appearance toggle's
   button and the sidebar — so they need `::deep` anchored on this file's own
   `.vx-app` root (ADR-014). Everything else is native markup from this
   component and carries the scope attribute, which also holds for rules whose
   *ancestor* is Radzen DOM (`.rz-header a.vx-brand`): the attribute lands on
   the subject, not on the ancestors. */

.vx-header-bar[b-stbgpp2kvx] {
    display: flex;
    align-items: center;
    gap: 0.75rem;
    min-width: 0;
    padding-inline-end: 0.75rem;
}

.vx-header-spacer[b-stbgpp2kvx] {
    flex: 1 1 auto;
}

/* Written as .rz-header a.vx-brand: the dark material theme colors header
   anchors with `.rz-header a { color: var(--rz-primary) }` (0,1,1), which
   would beat a bare class selector — the brand is chrome, not a link. */
.rz-header a.vx-brand[b-stbgpp2kvx] {
    font-weight: 700;
    font-size: 1.1rem;
    text-decoration: none;
    color: var(--rz-header-color);
}

.vx-user[b-stbgpp2kvx] {
    color: var(--rz-header-color);
    opacity: 0.85;
    font-size: 0.9rem;
    min-width: 0;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}

/* The tour's help button (D-075) is the one header control that must meet the
   44px touch target (docs/dev/07 rule 6). Radzen's own button, hence ::deep. */
.vx-app[b-stbgpp2kvx]  .rz-header .rz-button.vx-header-help {
    min-width: 44px;
    min-height: 44px;
}

/* A phone has no room for the full header: with the help button the toggle,
   brand, help, user name, logout and appearance toggle overran 375px (theme
   toggle ended at 406). Tighter gaps, the brand may truncate, and the user
   name — redundant next to the logout button — gives way below 480px. */
@media (max-width: 480px) {
    .vx-header-bar[b-stbgpp2kvx] {
        gap: 0.25rem;
        padding-inline-end: 0.25rem;
    }

    .rz-header a.vx-brand[b-stbgpp2kvx] {
        min-width: 0;
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
    }

    .vx-user[b-stbgpp2kvx] {
        display: none;
    }
}

/* The appearance toggle renders a text-variant base button; the material
   light header is primary-colored, so its icon must follow the header
   color to stay visible. Radzen's own button markup, hence ::deep. */
.vx-app[b-stbgpp2kvx]  .rz-header .rz-button.rz-variant-text.rz-base {
    color: var(--rz-header-color);
}

/* Ghost buttons on the (possibly primary-colored) header follow the header
   color instead of the body text color. */
.rz-header .vx-btn-ghost[b-stbgpp2kvx] {
    color: var(--rz-header-color);
    border-color: currentcolor;
}

/* On narrow viewports the expanded sidebar overlays the body as a drawer.
   Radzen's Responsive default only collapses it; without this the open
   drawer squeezes RadzenBody to a sliver instead of covering it. Radzen's
   own sidebar element, hence ::deep.

   The overlay range is Radzen's own responsive range: RadzenSidebar
   .ResponsiveMaxWidth defaults to "768px" and its stylesheet docks the sidebar
   (`.rz-layout .rz-sidebar { position: static }`) above that width, so 768px is
   the one breakpoint of drawer, scrim and Radzen's collapse. The zen themes
   leave --rz-sidebar-background-color transparent for the docked column, so the
   drawer takes the opaque surface token (issue 829). */
@media (max-width: 768px) {
    /* radzen: RadzenSidebar.Style, ResponsiveMaxWidth — neither sets the overlay
       position or a background, and the theme's sidebar color is transparent. */
    .vx-app[b-stbgpp2kvx]  .rz-layout .rz-sidebar {
        background-color: var(--vx-surface);
        position: absolute;
        top: var(--rz-header-height);
        bottom: 0;
        left: 0;
        z-index: 10;
        box-shadow: var(--rz-shadow-4, var(--vx-shadow-drawer));
    }
}

/* Drawer scrim (issue #55): the overlay drawer had no way out — tapping the
   page did nothing and the toggle that opened it sits behind the overlay.
   Rendered by MainLayout whenever the sidebar is expanded, but only ever
   visible where the sidebar actually overlays the body. */
.vx-drawer-scrim[b-stbgpp2kvx] {
    display: none;
}

@media (max-width: 768px) {
    .vx-drawer-scrim[b-stbgpp2kvx] {
        display: block;
        position: fixed;
        top: var(--rz-header-height);
        right: 0;
        bottom: 0;
        left: 0;
        z-index: 9;
        background: var(--vx-scrim);
    }
}
/* /Components/Layout/ReconnectModal.razor.rz.scp.css */
/* This modal sits outside .vx-app, so it cannot see the vx-dark class set by
   the in-app theme toggle. It reads the same --vx-* custom properties off
   :root (see wwwroot/app.css), which follow the OS color-scheme preference
   instead — the only theme signal reachable from here. */

.components-reconnect-first-attempt-visible[b-rnr8wolpr0],
.components-reconnect-repeated-attempt-visible[b-rnr8wolpr0],
.components-reconnect-failed-visible[b-rnr8wolpr0],
.components-pause-visible[b-rnr8wolpr0],
.components-resume-failed-visible[b-rnr8wolpr0],
.components-rejoining-animation[b-rnr8wolpr0] {
    display: none;
}

/* scoped-css: Blazor's reconnect script sets the components-reconnect-* state classes on the native <dialog> at runtime */
#components-reconnect-modal.components-reconnect-show .components-reconnect-first-attempt-visible[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-show .components-rejoining-animation[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-paused .components-pause-visible[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-resume-failed .components-resume-failed-visible[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-retrying[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-retrying .components-reconnect-repeated-attempt-visible[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-retrying .components-rejoining-animation[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-failed[b-rnr8wolpr0],
#components-reconnect-modal.components-reconnect-failed .components-reconnect-failed-visible[b-rnr8wolpr0] {
    display: block;
}


#components-reconnect-modal[b-rnr8wolpr0] {
    background-color: var(--vx-surface);
    color: var(--vx-text);
    width: 20rem;
    margin: 20vh auto;
    padding: 2rem;
    border: 0;
    border-radius: 0.5rem;
    box-shadow: var(--vx-shadow-modal);
    opacity: 0;
    transition: display 0.5s allow-discrete, overlay 0.5s allow-discrete;
    animation: components-reconnect-modal-fadeOutOpacity-b-rnr8wolpr0 0.5s both;
    &[open]

{
    animation: components-reconnect-modal-slideUp-b-rnr8wolpr0 1.5s cubic-bezier(.05, .89, .25, 1.02) 0.3s, components-reconnect-modal-fadeInOpacity-b-rnr8wolpr0 0.5s ease-in-out 0.3s;
    animation-fill-mode: both;
}

}

#components-reconnect-modal[b-rnr8wolpr0]::backdrop {
    background-color: var(--vx-scrim);
    animation: components-reconnect-modal-fadeInOpacity-b-rnr8wolpr0 0.5s ease-in-out;
    opacity: 1;
}

@keyframes components-reconnect-modal-slideUp-b-rnr8wolpr0 {
    0% {
        transform: translateY(30px) scale(0.95);
    }

    100% {
        transform: translateY(0);
    }
}

@keyframes components-reconnect-modal-fadeInOpacity-b-rnr8wolpr0 {
    0% {
        opacity: 0;
    }

    100% {
        opacity: 1;
    }
}

@keyframes components-reconnect-modal-fadeOutOpacity-b-rnr8wolpr0 {
    0% {
        opacity: 1;
    }

    100% {
        opacity: 0;
    }
}

.components-reconnect-container[b-rnr8wolpr0] {
    display: flex;
    flex-direction: column;
    align-items: center;
    gap: 1rem;
}

#components-reconnect-modal p[b-rnr8wolpr0] {
    margin: 0;
    text-align: center;
}

#components-reconnect-modal button[b-rnr8wolpr0] {
    border: 0;
    background-color: var(--vx-primary);
    color: var(--vx-primary-contrast);
    padding: 4px 24px;
    border-radius: 4px;
}

    #components-reconnect-modal button:hover[b-rnr8wolpr0] {
        opacity: 0.85;
    }

    #components-reconnect-modal button:active[b-rnr8wolpr0] {
        opacity: 1;
    }

.components-rejoining-animation[b-rnr8wolpr0] {
    position: relative;
    width: 80px;
    height: 80px;
}

    .components-rejoining-animation div[b-rnr8wolpr0] {
        position: absolute;
        border: 3px solid var(--vx-primary);
        opacity: 1;
        border-radius: 50%;
        animation: components-rejoining-animation-b-rnr8wolpr0 1.5s cubic-bezier(0, 0.2, 0.8, 1) infinite;
    }

        .components-rejoining-animation div:nth-child(2)[b-rnr8wolpr0] {
            animation-delay: -0.5s;
        }

@keyframes components-rejoining-animation-b-rnr8wolpr0 {
    0% {
        top: 40px;
        left: 40px;
        width: 0;
        height: 0;
        opacity: 0;
    }

    4.9% {
        top: 40px;
        left: 40px;
        width: 0;
        height: 0;
        opacity: 0;
    }

    5% {
        top: 40px;
        left: 40px;
        width: 0;
        height: 0;
        opacity: 1;
    }

    100% {
        top: 0px;
        left: 0px;
        width: 80px;
        height: 80px;
        opacity: 0;
    }
}
/* /Components/Pages/Help/HelpVideos.razor.rz.scp.css */
/* Cards of the help video overview (issue 703): a grid on desktop, one column on a phone. */
.vx-help-video-grid[b-alltvf3429] {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(18rem, 1fr));
    gap: 1rem;
}

.vx-help-video-card[b-alltvf3429] {
    display: flex;
    flex-direction: column;
    gap: 0.5rem;
    padding: 0.5rem;
    text-align: start;
    cursor: pointer;
    font: inherit;
    color: var(--rz-text-color);
    background: var(--rz-base-background-color);
    border: 1px solid var(--rz-base-300);
    border-radius: var(--rz-border-radius);
}

.vx-help-video-card:hover[b-alltvf3429],
.vx-help-video-card:focus-visible[b-alltvf3429] {
    border-color: var(--rz-primary);
}

.vx-help-video-card img[b-alltvf3429] {
    display: block;
    width: 100%;
    aspect-ratio: 16 / 9;
    object-fit: cover;
    border-radius: var(--rz-border-radius);
    background: var(--rz-base-900);
}

.vx-help-video-card-title[b-alltvf3429] {
    font-weight: 600;
}

@media (max-width: 768px) {
    .vx-help-video-grid[b-alltvf3429] {
        grid-template-columns: 1fr;
    }
}
/* /Components/Pages/Portal/OfferEditor.razor.rz.scp.css */
/* The full summary is a normal section after the LV (issue 623); the slim
   .offer-bar below is what stays in view. */
[b-3yed4fppjq] .offer-summary {
    border-color: var(--vx-primary);
    scroll-margin-top: 1rem;
}

[b-3yed4fppjq] .summary-progress {
    margin-bottom: 0.75rem;
}

[b-3yed4fppjq] .summary-line.summary-total {
    border-top: 1px solid var(--vx-border);
    padding-top: 0.4rem;
    font-size: 1.05rem;
}

[b-3yed4fppjq] .summary-progressbar {
    width: 220px;
}

[b-3yed4fppjq] .summary-input-narrow {
    width: 90px;
}

[b-3yed4fppjq] .summary-input-wide {
    width: 120px;
}

[b-3yed4fppjq] .summary-actions {
    margin-top: 0.9rem;
}

/* Nachlass/Skonto rows at 375px (issue #79): the row was built for a wide,
   single-line layout — label, input group, computed amount shared one flex
   row, and once it ran out of width each item wrapped independently, so the
   "% oder"/"€" glue text and the computed amount ended up as orphan lines.
   Below 640px (the `.vx-form-row` stacking threshold, docs/dev/07) the row
   becomes a column instead: label, then the input group (still free to wrap
   its own children), then the computed amount, each readable on its own. */
@media (max-width: 640px) {
    [b-3yed4fppjq] .summary-line.discount-line {
        flex-direction: column;
        align-items: stretch;
        gap: 0.3rem;
    }

    [b-3yed4fppjq] .summary-line.discount-line > span:last-child {
        text-align: right;
        font-weight: 600;
    }
}

/* Slim sticky bar (issue 623, replaces the sticky summary card and the phone
   action bar of issue #79): progress, the sum after Nachlass and the submit
   action. One mechanism at every width: sticky `bottom: 0` inside the scroll
   container. Never `position: fixed` -- RadzenBody carries an identity
   transform, so `.rz-body` is the containing block of fixed elements and the
   bar would stay parked instead of following the viewport (docs/concepts/20, "Stacking").
   A sticky inset is measured inside the container's padding, so app.css drops
   `.rz-body`'s bottom padding on this page; otherwise the bar floats above the
   edge with the LV scrolling past underneath. Radzen markup, hence ::deep
   anchored on this native root (ADR-014). */
.offer-bar[b-3yed4fppjq] {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 1rem;
    position: sticky;
    bottom: 0;
    z-index: 8;
    padding: 0.4rem 1rem;
    background: var(--vx-surface);
    border-top: 1px solid var(--vx-primary);
    box-shadow: var(--rz-shadow-4);
}

.offer-bar-progress[b-3yed4fppjq],
.offer-bar-total[b-3yed4fppjq] {
    display: flex;
    flex-direction: column;
    line-height: 1.2;
    min-width: 0;
}

.offer-bar-progress[b-3yed4fppjq] {
    font-size: 0.85rem;
    gap: 0.2rem;
}

.offer-bar[b-3yed4fppjq]  .offer-bar-progressbar {
    width: 180px;
    height: 6px;
}

.offer-bar-actions[b-3yed4fppjq] {
    display: flex;
    align-items: center;
    gap: 1rem;
}

.offer-bar-link[b-3yed4fppjq] {
    font-size: 0.85rem;
    white-space: nowrap;
}

.offer-bar[b-3yed4fppjq]  .rz-button {
    flex-shrink: 0;
}

/* Compact bar, at most two lines and never overlapping: the label of the sum
   goes (the amount stays), progress and amount share the first line, link and
   button the second. Wider than the sidebar's overlay breakpoint (768px)
   because the docked sidebar leaves the content column narrow up to ~1100px. */
@media (max-width: 1100px) {
    .offer-bar[b-3yed4fppjq] {
        display: grid;
        grid-template-columns: minmax(0, 1fr) auto;
        align-items: center;
        gap: 0.2rem 0.5rem;
        padding: 0.3rem 0.75rem;
    }

    .offer-bar[b-3yed4fppjq]  .offer-bar-progressbar {
        width: 80px;
    }

    .offer-bar-total[b-3yed4fppjq] {
        align-items: flex-end;
        text-align: right;
    }

    .offer-bar-total .vx-muted[b-3yed4fppjq] {
        display: none;
    }

    /* The actions wrapper drops out so link and button are grid items. */
    .offer-bar-actions[b-3yed4fppjq] {
        display: contents;
    }

    /* The link is a grid item, so its box is the column; its text must stay
       inside that box (clipped as a last resort) or it runs under the button. */
    .offer-bar-link[b-3yed4fppjq] {
        line-height: 1.2;
        min-width: 0;
        overflow: hidden;
        text-overflow: ellipsis;
    }

    .offer-bar[b-3yed4fppjq]  .rz-button {
        justify-self: end;
    }
}

/* Phone widths (320-414px): smaller link text and a tighter, icon-free button leave the
   link its own room in the second line. */
@media (max-width: 480px) {
    .offer-bar-link[b-3yed4fppjq] {
        font-size: 0.8rem;
    }

    .offer-bar[b-3yed4fppjq]  .rz-button {
        padding-inline: 0.6rem;
        font-size: 0.85rem;
    }

    /* The icon goes: the label alone leaves the link its full text width at 320px,
       where the clipped link otherwise reached under the button. */
    .offer-bar[b-3yed4fppjq]  .rz-button .rz-button-icon-left {
        display: none;
    }
}

.save-indicator[b-3yed4fppjq] {
    min-width: 6rem;
    font-size: 0.85rem;
}

[b-3yed4fppjq] .counting-row td {
    background: var(--vx-success-bg);
}

/* The change notice's text wraps anywhere: position texts carry long product names. */
[b-3yed4fppjq] .version-notice .rz-text-body2 {
    overflow-wrap: anywhere;
}

/* OfferCollapsible panels on this page (change notice lists, tender documents): the header bar
   takes the panel's width, its title part toggles. RadzenPanel has no native root of ours,
   hence ::deep from the page. */
[b-3yed4fppjq] .offer-grid-collapsible {
    width: 100%;
}

[b-3yed4fppjq] .offer-grid-collapsible-bar {
    flex: 1 1 auto;
}

[b-3yed4fppjq] .offer-grid-collapsible-head {
    cursor: pointer;
}

/* The change notice's two lists: panels on the page's surface inside the tinted notice, so their
   text has the page's contrast rather than a half-transparent fill (owner, 2026-10-31). */
[b-3yed4fppjq] .version-notice .offer-grid-collapsible {
    background: var(--vx-surface);
    color: var(--vx-text);
}

/* Submissions: short values, but every one of them readable -- wrap instead of an ellipsis. */
[b-3yed4fppjq] .offer-submissions-grid .rz-cell-data {
    white-space: normal;
    overflow-wrap: anywhere;
}

/* The clause is free text with line breaks (D-084); no Radzen parameter keeps them. */
[b-3yed4fppjq] .offer-service-clause {
    white-space: pre-wrap;
}
/* /Components/Pages/Portal/OfferLvGrid.razor.rz.scp.css */
/* Offer grid (issues 635, 641). Radzen markup, hence ::deep anchored on the native
   root of this component (ADR-014). Theme tokens only (D-005). */

/* Short texts wrap instead of being cut with an ellipsis: the position text is what
   the bidder prices. */
[b-vqtypi4mq3] .offer-grid .rz-cell-data {
    white-space: normal;
    overflow: visible;
}

/* In a card the input takes the value side of the line, never more. */
[b-vqtypi4mq3] .vx-responsive-list-value .offer-grid-input {
    width: 100%;
    min-width: 0;
}

/* Denser inputs than Radzen's default field height: a row is as tall as two lines of
   text, not as tall as a form field. */
[b-vqtypi4mq3] .offer-grid .offer-grid-input,
[b-vqtypi4mq3] .offer-grid-nested .offer-grid-input {
    width: 100%;
    height: 2rem;
    min-height: 2rem;
}

[b-vqtypi4mq3] .offer-grid .offer-grid-input input,
[b-vqtypi4mq3] .offer-grid-nested .offer-grid-input input,
[b-vqtypi4mq3] .offer-grid .offer-grid-input.rz-textbox {
    font-size: var(--rz-text-body2-font-size, 0.875rem);
    padding-block: 0;
}

/* Markers: small icons next to the number, the full text is the tooltip. */
[b-vqtypi4mq3] .offer-grid-marker {
    font-size: 1rem;
    cursor: help;
}

[b-vqtypi4mq3] .offer-grid-oz-number {
    font-variant-numeric: tabular-nums;
    white-space: nowrap;
}

/* A position that still needs a price: bar at the left edge of the OZ cell, as in the
   current offer view. */
[b-vqtypi4mq3] .offer-grid-oz-incomplete {
    box-shadow: inset 3px 0 0 var(--vx-primary);
    padding-left: 0.5rem;
}

/* Row details start where the row starts (under the expander), not indented further,
   and use the full width of the grid. */
[b-vqtypi4mq3] .offer-grid .rz-expanded-row-template {
    padding-inline: 0.75rem;
}

[b-vqtypi4mq3] .offer-grid .offer-grid-details {
    padding: 0.25rem 0 0.5rem;
    max-width: 100%;
}

[b-vqtypi4mq3] .offer-grid-longtext {
    white-space: pre-wrap;
    overflow-wrap: anywhere;
    max-width: 60rem;
}

[b-vqtypi4mq3] .offer-grid-short {
    white-space: normal;
    overflow-wrap: anywhere;
}

/* The variants' grid spans the row from edge to edge, so its columns (same widths as the
   grid's) line up with the grid's: the expanded cell's own padding (8 px, measured) is
   removed and the template's 0.75 rem is taken back by a negative margin. Its header is not
   shown, the grid's header names the columns. */
[b-vqtypi4mq3] .offer-grid .rz-expanded-row-content > td {
    padding-inline: 0;
}

[b-vqtypi4mq3] .offer-grid-nested {
    margin-inline: -0.75rem;
    width: auto;
    border-inline: 0;
    border-radius: 0;
}

[b-vqtypi4mq3] .offer-grid-nested thead {
    display: none;
}

/* Phone cards: a border on each card and on its details panel, so they stand off the LV card
   behind them in dark as well (owner, 2026-10-31: in dark the cards ran together into one
   block; in light the surfaces differ anyway). */
[b-vqtypi4mq3] .vx-responsive-list-card,
[b-vqtypi4mq3] .vx-responsive-list-card .rz-panel {
    border: 1px solid var(--vx-border);
}

[b-vqtypi4mq3] .offer-grid-remark-field {
    width: 100%;
    max-width: 40rem;
}

/* The note title names the position (OZ and short text), so it must wrap. */
[b-vqtypi4mq3] .offer-grid-notes .rz-alert-title {
    white-space: normal;
    overflow-wrap: anywhere;
}

/* Title rows (rows of the list, see OfferLvRow.cs): one wide cell from OZ to EP (OnCellRender) on
   a tinted band, the sum under GP; the title text starts left of the positions' OZ, over the
   expander column (owner, 2026-10-31). The subtotal row closes the section with a stronger rule. */
[b-vqtypi4mq3] .offer-grid .offer-grid-title-text {
    margin-left: -1.5rem;
}

/* The band takes the column headers' colour, not a base step: in the dark theme the light end
   of the base ramp (--rz-base-200, a light grey there) is meant for text and made the band glare (owner,
   2026-10-31). The table selector out-ranks Radzen's row striping, which painted over it. */
[b-vqtypi4mq3] .offer-grid .rz-grid-table tbody tr.offer-grid-title-row > td {
    background: var(--rz-grid-header-background-color);
}

[b-vqtypi4mq3] .offer-grid .offer-grid-subtotal-row > td {
    border-bottom: 2px solid var(--vx-border);
}

[b-vqtypi4mq3] .offer-grid .offer-grid-head-icon {
    font-size: 1.1rem;
}

[b-vqtypi4mq3] .offer-grid-nowrap {
    white-space: nowrap;
    font-variant-numeric: tabular-nums;
}

/* Fullscreen (FocusFrame): the grid's own fill height (vergixFillViewport) is what fits the
   card, so the frame does not scroll. */
/* Scoped one level up: the frame's own rule has the same specificity and comes later in the bundle. */
.offer-grid-scope[b-vqtypi4mq3]  .offer-grid-card.vx-focus-frame-active {
    overflow: hidden;
}

/* Phone: a title's header sticks to the top of the scrolled body while its block of cards is in
   view; the block ends where the next title starts, so that header takes over. Opaque, so the
   cards scroll under it. */
[b-vqtypi4mq3] .vx-responsive-list-group {
    position: sticky;
    /* Flush with the header bar: sticky offsets start inside RadzenBody's padding (16 px,
       measured), which left a strip where the cards showed above the stuck title. */
    top: -1rem;
    z-index: 3;
    background: var(--vx-surface);
}

[b-vqtypi4mq3] .offer-grid-card-group {
    padding: 0.35rem 0;
    border-bottom: 1px solid var(--vx-border);
    scroll-margin-top: 0;
}

[b-vqtypi4mq3] .offer-grid-card-group-title {
    min-width: 0;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}

[b-vqtypi4mq3] .offer-grid-card-variant {
    padding-top: 0.35rem;
    border-top: 1px solid var(--vx-border);
}

[b-vqtypi4mq3] .offer-grid-collapsible {
    width: 100%;
}

[b-vqtypi4mq3] .offer-grid-collapsible-head {
    cursor: pointer;
    flex: 1;
}

/* A text column right of a right-aligned number column: a gap, so "Menge" and "Einh." (and
   "GP" and "Anmerkung") do not run into each other. */
[b-vqtypi4mq3] .offer-grid .offer-grid-col-gap,
[b-vqtypi4mq3] .offer-grid-nested .offer-grid-col-gap {
    padding-left: 0.75rem;
}

/* The sticky title above the column headers (StickyTitle): the same band as a title row, the
   sum over the GP column. What follows GP is the remark icon column or the remark column, plus
   the body's scrollbar gutter. */
[b-vqtypi4mq3] .offer-grid .rz-group-header:has(.offer-grid-sticky-title) {
    padding: 0;
    min-height: 0;
    background: var(--rz-grid-header-background-color);
    border-bottom: 1px solid var(--vx-border);
}

[b-vqtypi4mq3] .offer-grid .rz-group-header:has(.offer-grid-sticky-title) .rz-custom-header {
    flex: 1 1 auto;
}

/* Same box as a title row, so the switch between them does not jump (owner, 2026-10-31):
   the row's cell padding (4 px top and bottom, measured; 20 px line, so 29 px with the rule)
   and its text 40 px from the grid's left edge (expander column, cell padding and the title's
   own pull to the left, measured at 1440 px). */
[b-vqtypi4mq3] .offer-grid-sticky-title {
    width: 100%;
    padding: 0.25rem 0.5rem 0.25rem 2.5rem;
}

[b-vqtypi4mq3] .offer-grid-sticky-title-icon {
    padding-right: calc(2.75rem + 1.5rem);
}

[b-vqtypi4mq3] .offer-grid-sticky-title-remark {
    padding-right: calc(12rem + 1.5rem);
}

/* Phone cards: the card's fields form one grid, a label column as wide as the longest label
   ("nicht angeboten") and a value column with the rest, so all inputs line up and share one width
   (owner, 2026-10-31: the fields' differing widths drew the eye). Each field dissolves into the
   grid; anything else in the card (variant blocks, the details panel) spans both columns, and a
   variant block lays out its own fields the same way. */
[b-vqtypi4mq3] .vx-responsive-list-card .vx-responsive-list-card-fields,
[b-vqtypi4mq3] .vx-responsive-list-card .offer-grid-card-variant {
    display: grid;
    grid-template-columns: max-content minmax(0, 1fr);
    align-items: center;
    gap: 0.4rem 0.75rem;
}

[b-vqtypi4mq3] .vx-responsive-list-card .vx-responsive-list-field {
    display: contents;
}

[b-vqtypi4mq3] .vx-responsive-list-card .vx-responsive-list-card-fields > :not(.vx-responsive-list-field),
[b-vqtypi4mq3] .vx-responsive-list-card .offer-grid-card-variant > :not(.vx-responsive-list-field) {
    grid-column: 1 / -1;
}

[b-vqtypi4mq3] .vx-responsive-list-card .vx-responsive-list-value {
    text-align: right;
}

[b-vqtypi4mq3] .vx-responsive-list-card .vx-responsive-list-value .offer-grid-input {
    width: 100%;
}
/* /Components/Pages/Portal/PortalQaSection.razor.rz.scp.css */
/* Native anchor of the ::deep rules below (ADR-014); no layout effect of its own. */
.qa-scope[b-uiusnhdimu] {
    display: contents;
}

[b-uiusnhdimu] .qa-ask-form {
    margin-bottom: 1rem;
}

[b-uiusnhdimu] .qa-item {
    border: 1px solid var(--vx-border);
    border-radius: 6px;
    padding: 0.6rem 0.8rem;
}

[b-uiusnhdimu] .qa-item.qa-own {
    border-left: 3px solid var(--vx-primary);
}

.qa-question-text[b-uiusnhdimu] {
    font-weight: 600;
}

[b-uiusnhdimu] .qa-meta {
    font-size: 0.85rem;
    margin: 0.15rem 0 0;
}

[b-uiusnhdimu] .qa-answer {
    margin-top: 0.5rem;
    padding: 0.5rem 0.7rem;
    background: var(--vx-success-bg);
    border-radius: 4px;
}

[b-uiusnhdimu] .qa-answer-label {
    font-weight: 600;
    margin: 0 0 0.15rem;
}

/* Mobile card layout (D-005): the list is already single-column card rows,
   so only the question/badge row needs to stack below the width where two
   badges plus the question text stop fitting on one line. */
@media (max-width: 480px) {
    [b-uiusnhdimu] .qa-question-row {
        flex-direction: column;
        align-items: flex-start;
        gap: 0.25rem !important; /* the stack's own gap is inline */
    }
}
/* /Components/Pages/Portal/SubmitOfferDialog.razor.rz.scp.css */
.submit-summary[b-yiyage8zgy]  .amount {
    text-align: right;
    white-space: nowrap;
}

/* The span inside the cell carries its own white-space (vx-radzen-table). */
.submit-summary[b-yiyage8zgy]  .amount .rz-cell-data {
    white-space: nowrap;
}
/* /Components/Pages/Tenders/AiAssistantPanel.razor.rz.scp.css */
/* Title row spans the header width so the mic sits at its right end. */
[b-9imdjnwagq] .vx-chat-title {
    flex: 1 1 auto;
}

/* Close control (issue #75): only meaningful where the panel covers the
   toolbar's "KI-Assistent" toggle (the phone drawer below) or sits in Radzen's
   side panel (issue 805, `Dismissible`, no Radzen title bar) — side by side the
   toggle that opened it stays reachable, so a second close control there would
   be redundant chrome. */
[b-9imdjnwagq] .vx-chat-close {
    display: none;
}

@media (max-width: 768px) {
    [b-9imdjnwagq] .vx-chat-close {
        display: inline-flex;
    }
}

.vx-chat-dismissible[b-9imdjnwagq]  .vx-chat-close {
    display: inline-flex;
}

/* In the side panel the dialog is the one surface: the chat widget drops its own
   frame (border, rounded corners, shadow) and the panel pads itself so the header
   and the composer do not touch the window edge. Radzen parameters checked: searched
   the Radzen docs (tag api) for RadzenChat members for border, radius or variant;
   none exists, so CSS is the only way to reach the widget's frame. */
.vx-chat-dismissible[b-9imdjnwagq] {
    padding: 0.5rem 0.75rem;
    box-sizing: border-box;
}

.vx-chat-dismissible[b-9imdjnwagq]  .vx-chat-widget {
    border: 0;
    border-radius: 0;
    box-shadow: none;
    background: transparent;
}

/* Conversational LV assistant panel. All colors come from the vx theming
   tokens (D-005) so light and dark theme both work without overrides. */

.vx-chat[b-9imdjnwagq] {
    min-width: 0;
    display: flex;
    flex-direction: column;
    gap: 0.5rem;
    /* Fills the splitter pane, which is viewport-bound since the
       full-height content restructure (issue #51). */
    height: 100%;
    min-height: 0;
    overflow: hidden;
}

/* Empty-state hint rendered via RadzenChat's EmptyTemplate (a RadzenStack:
   column and gap come from its parameters). */
[b-9imdjnwagq] .vx-chat-empty {
    padding: 1.5rem 1rem;
    text-align: center;
}

/* 1:1 assistant chat: the participant avatar chips in the chat header are
   noise — hide them there (message avatars are untouched). Header = the
   widget's first stack row (ADR-014: ::deep, Radzen markup). */
/* !important: the strip carries Radzen's rz-display-flex utility class,
   which itself sets display with !important. */
[b-9imdjnwagq] .rz-chat-header-title + .rz-stack {
    display: none !important;
}

/* RadzenChat renders without this file's scope attribute (ADR-014) — the
   class sits on the component, so the rule needs ::deep to apply. Fills
   .vx-chat-composer-wrap; transcript scrolls internally, composer pinned. */
[b-9imdjnwagq] .vx-chat-widget {
    flex: 1 1 auto;
    min-height: 0;
}

/* Markdown headings in an answer stay close to the bubble text instead of page size, and a long
   word that would overflow the bubble is broken by overflow-wrap; ordinary words stay whole
   (hyphens: auto hyphenated them too, "Positi-on", issue 960). */

/* radzen: RadzenChat, RadzenAIChat members for text wrapping, hyphenation or heading size (docs, tag api) — only MessageTemplate exists, which would replace the bubble; the theme sets heading sizes from the --rz-text-h1..h6-font-size tokens, so they are lowered here; colours stay untouched */
[b-9imdjnwagq] .rz-chat-message-text {
    --rz-text-h1-font-size: var(--rz-text-subtitle1-font-size);
    --rz-text-h2-font-size: var(--rz-text-subtitle1-font-size);
    --rz-text-h3-font-size: var(--rz-text-subtitle1-font-size);
    --rz-text-h4-font-size: var(--rz-text-subtitle1-font-size);
    --rz-text-h5-font-size: var(--rz-text-subtitle1-font-size);
    --rz-text-h6-font-size: var(--rz-text-subtitle1-font-size);
    hyphens: manual;
    overflow-wrap: anywhere;
}

.vx-chat-composer-wrap[b-9imdjnwagq] {
    position: relative;
    display: flex;
    flex-direction: column;
    flex: 1 1 auto;
    min-height: 0;
}

/* Overlaid on top of RadzenChat's composer row (no composer slot to render
   into, ADR-018) — left of the send button, vertically resting on the
   composer's own bottom padding. Re-check this offset whenever the Radzen
   package is upgraded. */
/* Docked inside the composer field's right edge, vertically centered on
   the send-button row — the contemporary in-field mic. A true position
   BETWEEN field and send button would require moving the element into
   Radzen's internal composer grid (DOM surgery Blazor's renderer does not
   tolerate reliably). */

/* A RadzenStack root carries no scope attribute (ADR-014), hence ::deep;
   flex layout and gap come from the stack's parameters. */
[b-9imdjnwagq] .vx-chat-pending {
    padding: 0.6rem 0.9rem;
    border-radius: 0.375rem;
    border: 1px solid var(--vx-success);
    background: var(--vx-success-bg);
    color: var(--vx-success);
}
/* /Components/Pages/Tenders/AiDraftDialog.razor.rz.scp.css */
/* Quantity column of the draft preview: fixed width, right-aligned (issue 762:
   moved out of an inline style). The cell is a Radzen component root, so the rule
   is anchored on the dialog's native section (ADR-014). */
.vx-ai-preview[b-m766q6ee9u]  .vx-ai-quantity {
    width: 130px;
    text-align: right;
}
/* /Components/Pages/Tenders/AiReviseSectionDialog.razor.rz.scp.css */
/* Rows the AI revision added, highlighted in the preview (issue #86: moved
   out of app.css). Anchored on the native section, the rows are Radzen
   component roots (ADR-014). */
.vx-ai-preview[b-mxw4nmbu1g]  .vx-row-new > * {
    background: var(--vx-success-bg);
}

/* Quantity column of the preview: fixed width, right-aligned (issue 762:
   moved out of an inline style). */
.vx-ai-preview[b-mxw4nmbu1g]  .vx-ai-quantity {
    width: 130px;
    text-align: right;
}
/* /Components/Pages/Tenders/AwardOfferDialog.razor.rz.scp.css */
/* Zuschlag offer picker (#260). Structure only — every color comes from
   the Radzen theme tokens (D-005). */

.vx-eval-award-picker .vx-eval-confirm-lead[b-5lp2owsb08] {
    margin: 0;
    font-weight: 600;
}

.vx-eval-award-picker .vx-eval-confirm-hint[b-5lp2owsb08] {
    margin: 0.35rem 0 0;
    font-size: 0.8125rem;
}
/* /Components/Pages/Tenders/BidderDocumentRequirementsCard.razor.rz.scp.css */
/* Rule 16 (docs/dev/07): the card shows its grid only where the grid's columns fit the width the
   card has, and its card list otherwise, whatever the viewport or the navigation state. The
   wrapper is the size container; the thresholds are the sums of the column widths in the markup
   (200 + 150 + 200 [+ 240 with the actions column]). */
.vx-bidder-docs-list[b-sbblx3mzrd] {
    container-type: inline-size;
}

@container (max-width: 789px) {
    .vx-bidder-docs-list.vx-bidder-docs-editable[b-sbblx3mzrd]  .vx-responsive-list-grid {
        display: none;
    }

    .vx-bidder-docs-list.vx-bidder-docs-editable[b-sbblx3mzrd]  .vx-responsive-list-cards {
        display: flex;
        flex-direction: column;
        gap: 0.75rem;
    }
}

@container (max-width: 549px) {
    .vx-bidder-docs-list:not(.vx-bidder-docs-editable)[b-sbblx3mzrd]  .vx-responsive-list-grid {
        display: none;
    }

    .vx-bidder-docs-list:not(.vx-bidder-docs-editable)[b-sbblx3mzrd]  .vx-responsive-list-cards {
        display: flex;
        flex-direction: column;
        gap: 0.75rem;
    }
}
/* /Components/Pages/Tenders/LvCommentsDialog.razor.rz.scp.css */
/* The comment thread's own markup (ul, li, p) carries the scope attribute; the
   head row, the compose block and the action rows are RadzenStacks laid out
   through their parameters and rz-* utilities, so no rule here targets them. */
.vx-lv-comment-list[b-w324shu87l] {
    list-style: none;
    margin: 0;
    padding: 0;
}

.vx-lv-comment[b-w324shu87l] {
    padding: 0.5rem 0;
    border-bottom: 1px solid var(--vx-border);
}

.vx-lv-comment-text[b-w324shu87l] {
    margin: 0.25rem 0;
    white-space: pre-wrap;
}

.vx-lv-comment-superseded .vx-lv-comment-text[b-w324shu87l] {
    color: var(--vx-muted);
    text-decoration: line-through;
}
/* /Components/Pages/Tenders/LvEditor.razor.rz.scp.css */
/* The LV editor's private layout: toolbar, splitter, panes, assistant drawer
   (issue #86 — these were the largest single group in app.css).

   Everything here is Radzen markup (RadzenStack, RadzenSplitter,
   RadzenSplitterPane), so every rule goes through `::deep` from the
   `.vx-lv-editor` root this component renders itself (ADR-014). That root is
   `display: contents`, so it adds no box to the layout. */

.vx-lv-editor[b-zsabpjvtqx] {
    display: contents;

    /* The assistant's pane limits side by side. LvAssistantLayout (C#) names them
       once and drives the placement check; a stylesheet cannot read it, so
       LvEditorLayoutTests keeps these two equal to it. */
    --vx-lv-assistant-min: 340px;
    --vx-lv-assistant-max: 640px;
    /* Kurztext is the column a reader needs: the table scrolls before it drops below this. */
    --vx-lv-shorttext-min: 18rem;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-toolbar {
    display: flex;
    align-items: center;
    gap: 0.75rem;
    flex-wrap: wrap;
    margin: 0.5rem 0 1rem;
}

/* Narrow-viewport toolbar shape (issue #77, viewport audit #55 finding
   M-04): at 375px the full five/six-button row wrapped into a ragged,
   ~450px-tall column of shrink-wrapped pills that pushed the whole LV below
   the fold. Export and the two AI-draft actions are secondary/occasional
   here, so they collapse into the `.vx-lv-toolbar-overflow` kebab button
   (opened via ContextMenuService in code-behind, not a separate Radzen
   component — no extra popup markup to theme). The version dropdown (the
   editor's context switch, not an action) and whichever contextual primary
   action applies (publish/create-version, KI-Assistent) stay as buttons on
   both sides of the breakpoint. Same 768px threshold as the shell's other
   mobile affordances in this file. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-toolbar-overflow {
    display: none;
}

/* The version selector's fixed width (issue 762: out of the inline style). */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-version-select {
    width: 280px;
}

@media (max-width: 768px) {
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-toolbar-collapsible {
        display: none;
    }

    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-toolbar-overflow {
        display: inline-flex;
    }
}

/* RadzenSplitter (issue #51): a genuine two-pane, resizable/collapsible
   companion layout, replacing the sticky-then-overlay pane from #46.
   `.rz-splitter` ships `height: 100%`, but nothing here gives its parent
   an explicit height, so the percentage resolves to `auto` (CSS2.1 10.5)
   and the row simply stretches (align-items' default) both panes to the
   taller of the two — i.e. the LV content's own height. That is the "full
   height of the LV editor content area" the product asked for, without
   pinning the splitter to the viewport or touching RadzenBody's own
   scrolling (ADR-016) — issue #51 explicitly rules that layout surgery
   out.

   app.css carried a second `.vx-lv-splitter { min-height: 24rem }` block
   here, written as a floor for the near-empty-LV case. It never took effect:
   an identical-specificity block further down set `min-height: 0`, so the
   floor was dead. Preserved as dead — reinstating it would be a behaviour
   change, which this refactor is not (noted in the PR). */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-splitter {
    flex: 1 1 auto;
    min-height: 0;
}

/* The host of the splitter; LvEditor observes its width to place the assistant. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-split-host {
    flex: 1 1 auto;
    min-height: 0;
    display: flex;
    flex-direction: column;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main-pane {
    /* Radzen grows only the *last* pane (.rz-splitter-pane-lastresizable
       gets flex: 1 1 auto); flip that so the LV content — not the
       assistant — absorbs the remaining width. */
    flex: 1 1 auto;
    min-width: 0;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main {
    padding-right: 0.5rem;
    min-width: 0;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-assistant,
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-assistant > .vx-chat {
    height: 100%;
    min-height: 0;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-assistant {
    /* Cancel the lastresizable auto-grow above: this pane's width is the
       user's drag/Size choice (persisted in _assistantPaneSize), not
       flex-grow. flex column so the chat below can flex:1 to the pane's
       full (stretched) height. */
    flex: 0 0 auto;
    min-width: 0;
    display: flex;
    flex-direction: column;
}

/* The LV pane scrolls instead of the tab panel; the panel's own opt-out
   lives with the page that renders it (TenderDetail.razor.css). Same
   breakpoint as the full-height chain (issue #55, ADR-021) — on a phone the
   LV list is part of the page flow. */
@media (min-width: 769px) {
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main {
        height: 100%;
        overflow-y: auto;
    }
}

/* Where the assistant lives (issue 805), decided in LvEditor, not here: side by
   side in the splitter when the LV table needs no horizontal scrolling next to
   it, else in Radzen's own side panel (DialogService.OpenSideAsync, right edge,
   no mask — nothing to style, it is not inside this component), at every width
   including a phone. Radzen parameters checked: RadzenSplitterPane Min/Max/Size
   only clamp a pane's size and cannot move it out of the splitter, hence the
   side panel instead of CSS.

   Side by side: hard CSS clamps, since Radzen's own Min/Max enforcement is
   bypassed by the pane flex overrides (observed live: a drag blew past Max=640px
   and crushed the LV to ~300px). */
@media (min-width: 769px) {
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-assistant {
        min-width: var(--vx-lv-assistant-min);
        max-width: var(--vx-lv-assistant-max);
    }
}

@media (max-width: 768px) {
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-splitter .rz-splitter-bar {
        display: none;
    }
}

/* ── LV visual redesign (issue #62, decided live with the product owner
   2026-08-30) ──────────────────────────────────────────────────────────

   All rules below deliberately override the shared `.vx-table`/`.vx-card`
   primitives *for the LV editor only* — the compact density is an LV
   decision, not an app-wide one, so nothing here touches app.css. Every
   selector goes through `.vx-lv-main`, which also keeps the assistant
   pane (a sibling inside `.vx-lv-editor`) out of reach. */

/* 1 — Compact density, uniform across draft and published (~32px rows).
   Line-height is pinned so the math is deterministic instead of theme-
   dependent: read-only rows are 0.875rem × 1.5 (21px) + 2 × 4.8px padding
   + 1px border ≈ 32px; editable rows are governed by the 22px action
   buttons below (22 + 9.6 + 1 ≈ 32px). Inline badges (Freimenge, type
   tags) are 16px tall (--rz-badge-line-height 1rem, zero vertical
   padding), so they fit the 21px line box without stretching it. Header
   cells keep app.css's 0.85rem. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-table {
    font-size: 0.875rem;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-table th,
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-table td {
    padding: 0.3rem 0.5rem;
    line-height: 1.5;
}

/* Fixed widths of the narrow, known-size columns (issue 762: out of the
   inline styles); Kurztext and Kommentare share the rest. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-lv-col-oz {
    width: 70px;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-lv-col-quantity {
    width: 110px;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-lv-col-unit {
    width: 90px;
}

/* Kurztext never gets narrower than a reader needs (issue 805): the table
   scrolls inside its .vx-table-scroll before this column wraps word by word. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-lv-col-shorttext {
    min-width: var(--vx-lv-shorttext-min);
}

/* The section and orphan cards are RadzenCards (issue 762); a filled
   RadzenCard adds the theme's card shadow, which the `.vx-card` primitive in
   app.css never had. The section-head band below relies on the card's
   unchanged border and padding. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-card {
    box-shadow: none;
}

/* 2 — Row actions revealed on hover/focus (desktop). Gated on a genuine
   hover-capable fine pointer: on `hover: none` devices (phones, touch
   tablets) none of this applies, so the actions stay permanently visible
   at the 44px coarse-pointer size app.css guarantees (#76 — the 375px
   E2E assertion from #136 measures exactly that). `pointer: fine` is in
   the gate too so a hover-reporting coarse-pointer device never gets the
   #76 target shrunk away.

   Only `.vx-actions-cell` (the per-position actions) participates — the
   section-head actions stay visible: they are the entry point to
   AI-revise/rename and would be undiscoverable behind a hover.

   Hiding is `opacity`, never `display`/`visibility`: the column keeps
   its space (nothing may jump) and the buttons stay focusable, which is
   what makes the `tr:focus-within` keyboard path work at all. Buttons
   shrink via min-size + padding (0.875rem icon + 2 × 0.1875rem = 20px),
   not a fixed width, so a transient BusyText can still widen the edit
   button instead of clipping. */
@media (hover: hover) and (pointer: fine) {
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-actions-cell .rz-button-sm.rz-button-icon-only {
        /* 20px total (14px icon + 2×3px padding) — deliberately one pixel
           UNDER the 21px text line box, so the row height is governed by
           the text in draft mode exactly as in the read-only view: the
           owner compared both versions in the #62 live round and wanted
           draft rows at the published height (32px), not 33. */
        min-width: 1.25rem;
        min-height: 1.25rem;
        /* 0.125rem, not 0.1875rem: the filled button carries a 1px border
           per side — 14px icon + 2×2px padding + 2×1px border = 20px. */
        padding: 0.125rem;
    }

    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-actions-cell .rz-button-sm.rz-button-icon-only .rzi {
        /* line-height 1: the material-icon box otherwise stays 16px for a
           14px glyph, which pushes the button to 22px and the draft row one
           pixel above the published one — the exact pixel the owner vetoed. */
        font-size: 0.875rem;
        line-height: 1;
        width: 0.875rem;
        height: 0.875rem;
    }

    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-actions-cell .vx-actions {
        gap: 0.25rem;
    }

    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-actions-cell .rz-button {
        opacity: 0;
        transition: opacity 0.12s ease;
    }

    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main tr:hover .vx-actions-cell .rz-button,
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main tr:focus-within .vx-actions-cell .rz-button,
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-actions-cell.driver-active-element .rz-button {
        /* The product tour highlights the cell (D-075): its buttons must show. */
        opacity: 1;
    }
}

/* 3 — Section heads as a distinct band, sticky on desktop. The band is
   pulled to the card's border edges (negative margins mirror .vx-card's
   1rem/1.25rem padding) and painted with the *page* background token:
   lighter than the card surface in both themes (light #FAF8F6 on
   #F1ECE9, dark #1B1815 on #0E0D0C — see docs/dev/07 palette), so the
   separation holds in light and dark without a hard-coded color. The
   top radius matches the card's inner border radius (0.5rem − 1px) so
   the band fills the rounded corners exactly at rest; while stuck this
   leaves a ~7px transparent corner sliver — accepted as invisible in
   practice (judgement call, noted in the PR).

   Sticky only ≥769px, where `.vx-lv-main` is the scroll container
   (ADR-021); below that the page scrolls and sticking is pointless.
   z-index 2 beats the row buttons, which are position:relative (ripple)
   with z-index auto. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-section-head {
    margin: -1rem -1.25rem 0.25rem;
    padding: 0.375rem 1.25rem;
    background: var(--vx-bg);
    border-bottom: 1px solid var(--vx-border);
    border-radius: calc(0.5rem - 1px) calc(0.5rem - 1px) 0 0;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-section-head h2 {
    font-size: 1.0625rem;
    font-weight: 600;
}

@media (min-width: 769px) {
    .vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-section-head {
        position: sticky;
        top: 0;
        z-index: 2;
    }
}

/* 4 — "Position hinzufügen" gets clear breathing room above (product-
   owner finding: it sat glued to the last row). 1rem mirrors the card's
   own bottom padding, so the button floats evenly between the table and
   the card edge. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-lv-add-position {
    margin-top: 1rem;
}

/* 5 — Long prose caps its own column at ~70ch inside the full-width LV
   pane (docs/dev/07 width rule, #78): the draft hint and the muted empty-
   state lines, not the table. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .rz-alert,
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main p.vx-muted {
    max-width: 70ch;
}

/* 6 — Draft-visibility marker beside the version selector (#62 live round,
   third iteration: icon-only — a text chip fought the toolbar row height).
   The span is the component's own markup; the icon inside is
   Radzen-rendered and needs ::deep. */
.vx-lv-draft-marker[b-zsabpjvtqx] {
    display: inline-flex;
    align-items: center;
    color: var(--vx-muted);
}

.vx-lv-draft-marker[b-zsabpjvtqx]  .rzi {
    font-size: 1.25rem;
    line-height: 1;
}

/* 7 — Market-price research (D-057/#273): a per-section info line ("Stand:
   <date>" + source popup trigger + fixed disclaimer) and the run's own
   progress indicator, both between the section head and the positions
   table. Small/muted by design — informational context, never mistaken for
   an editable field. Both are RadzenStacks; their layout and the 0.5rem
   below them are the stacks' parameters and `rz-mb-2` (issue 762). */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-market-disclaimer {
    font-size: 0.75rem;
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-main .vx-market-range {
    font-size: 0.8125rem;
}

/* Comment button and orphaned-comment block (D-070); colours via tokens only (D-005).
   The group is a RadzenStack (issue 762), so it is reached through ::deep. */
.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-orphan-group {
    padding: 0.5rem 0;
    border-top: 1px solid var(--vx-border);
}

.vx-lv-editor[b-zsabpjvtqx]  .vx-lv-orphan-group ul {
    margin: 0 0 0.5rem;
    padding-left: 1.25rem;
}
/* /Components/Pages/Tenders/MarketBenchmarkSourcesDialog.razor.rz.scp.css */
/* The root div is the scoping anchor: the dialog body is a RadzenStack, whose root carries no scope
   attribute (ADR-014). display: contents keeps the anchor out of the layout. */
.vx-eval-benchmark-sources-root[b-9s0e4egl8d] {
    display: contents;
}

.vx-eval-benchmark-source-list[b-9s0e4egl8d] {
    margin: 0;
    padding-left: 1.1rem;
}

.vx-eval-benchmark-sources-root[b-9s0e4egl8d]  .vx-eval-benchmark-disclaimer {
    font-size: 0.8125rem;
}
/* /Components/Pages/Tenders/MarketResearchSourcesDialog.razor.rz.scp.css */
.vx-market-source-list[b-w77ic8no1z] {
    margin: 0;
    padding-left: 1.25rem;
}

.vx-market-source-list li[b-w77ic8no1z] {
    margin: 0.25rem 0;
}

/* Shell: the component caps its own height (no Radzen DialogOptions or
   SideDialogOptions parameter caps a height — `Height` fixes it) and owns the
   one scroll region. The margin leaves room for the title bar and the content
   padding, so Radzen's own content area (desktop) or the sheet itself (bottom
   sheet, capped at 88vh in app.css) never overflows and never adds a second
   scrollbar. Desktop: 10rem also covers the page margin around the dialog.
   Bottom sheet: a deliberate exception to "sizes to content, scrolls as one
   document" (docs/dev/07): the title bar and the footer stay visible. */
.vx-market-sources-dialog--capped[b-w77ic8no1z],
.vx-market-sources-dialog--sheet[b-w77ic8no1z] {
    display: flex;
    flex-direction: column;
}

.vx-market-sources-dialog--capped[b-w77ic8no1z] {
    max-height: calc(100vh - 10rem);
}

.vx-market-sources-dialog--sheet[b-w77ic8no1z] {
    max-height: calc(88vh - 9rem);
}

.vx-market-sources-dialog--capped[b-w77ic8no1z]  .vx-market-sources-body,
.vx-market-sources-dialog--sheet[b-w77ic8no1z]  .vx-market-sources-body {
    flex: 1 1 auto;
    min-height: 0;
    overflow-y: auto;
}

/* The footer is a RadzenStack, whose root carries no scope attribute
   (ADR-014): reached through ::deep from the shell div. */
.vx-market-sources-dialog[b-w77ic8no1z]  .vx-market-sources-footer {
    flex: 0 0 auto;
}

.vx-market-sources-dialog--capped[b-w77ic8no1z]  .vx-market-sources-footer,
.vx-market-sources-dialog--sheet[b-w77ic8no1z]  .vx-market-sources-footer {
    border-top: 1px solid var(--vx-border);
    padding-top: 0.75rem;
}
/* /Components/Pages/Tenders/PositionDialog.razor.rz.scp.css */
/* The position dialog's own layout (issue #86: moved out of app.css; issue
   762: sizes out of inline styles). Rows, field groups and the variants card
   are Radzen components, which never carry the scope attribute, so every rule
   goes through ::deep from the dialog's native `.vx-form` root (ADR-014). */

/* Fixed input widths of the type/quantity/unit row. */
.vx-form[b-djkwp2aqeg]  .vx-position-type {
    width: 220px;
}

.vx-form[b-djkwp2aqeg]  .vx-position-quantity {
    width: 160px;
}

.vx-form[b-djkwp2aqeg]  .vx-position-unit {
    width: 120px;
}

/* The variant editor's row: the label field takes the width between the
   radio and the delete button. The row's alignment is the stack's own
   AlignItems; the gap is set here because the shared `.vx-form-row` gap in
   app.css outranks the stack's. */
.vx-form[b-djkwp2aqeg]  .vx-variant-row {
    gap: 0.5rem;
}

.vx-form[b-djkwp2aqeg]  .vx-variant-label {
    flex: 1;
}

/* A filled RadzenCard adds the theme's card shadow; the `.vx-card` primitive
   in app.css has none, and the variants card keeps its look. */
.vx-form[b-djkwp2aqeg]  .vx-card {
    box-shadow: none;
}

/* Phones (issue #55): `.vx-form-row` stacks below 640px (app.css). The stack
   sets its row direction and alignment through Radzen's `!important` utility
   classes (inferred from the theme CSS, not observed on the rendered markup),
   which would outrank that shared rule, so it is repeated here at the same
   weight. */
@media (max-width: 640px) {
    .vx-form[b-djkwp2aqeg]  .vx-form-row {
        flex-direction: column !important;
        align-items: stretch !important;
    }
}
/* /Components/Pages/Tenders/RejectionMailDialog.razor.rz.scp.css */
/* Rejection send dialog (#189). Tokens only (D-005) — the list is plain
   structure, the state colors come from the badges. */

.vx-eval-recipients[b-5p2i1qmaur] {
    display: flex;
    flex-direction: column;
    gap: 0.25rem;
    /* Fewer than 20 bidders per tender (D-010), so the list rarely scrolls —
       the cap exists so a full field cannot push the subject/body fields and
       the send button out of a laptop-height dialog. */
    max-height: 16rem;
    overflow-y: auto;
}

.vx-eval-recipient-group[b-5p2i1qmaur] {
    margin: 0.5rem 0 0.1rem;
    font-size: 0.8125rem;
}

.vx-eval-recipient-group:first-of-type[b-5p2i1qmaur] {
    margin-top: 0.25rem;
}

/* ── Confirmation step (owner round 1, 2026-09-01) ────────────────────

   The prose version named every company in up to three roles in one
   sentence. Labelled groups instead: lead line, then only the blocks that
   apply, one company per line, then the question. Everything inherits the
   alert's own token colors — no color is set here. The lines are <p>s
   (issue 762), so their margins are set here explicitly. */

.vx-eval-confirm-lead[b-5p2i1qmaur] {
    margin: 0;
    font-weight: 600;
}

.vx-eval-confirm-group[b-5p2i1qmaur] {
    margin-top: 0.6rem;
}

.vx-eval-confirm-caption[b-5p2i1qmaur] {
    margin: 0;
    font-size: 0.8125rem;
    font-weight: 600;
}

.vx-eval-confirm-list[b-5p2i1qmaur] {
    margin: 0.15rem 0 0;
    padding-left: 1.25rem;
}

.vx-eval-confirm-list li[b-5p2i1qmaur] {
    line-height: 1.5;
}

.vx-eval-confirm-question[b-5p2i1qmaur] {
    margin: 0.75rem 0 0;
    font-weight: 600;
}
/* /Components/Pages/Tenders/TenderBidderTab.razor.rz.scp.css */
/* Bidder tab (#62 step 2). Template-rendered markup is the component's own
   and takes plain scoped selectors; the grid's cells are Radzen-rendered
   and need ::deep from the native .vx-card anchor (ADR-014). Colors stay
   with the badge/button theme styles — nothing hard-coded here (D-005). */

/* The section head needs air before the grid ("Bieter einladen" sat glued
   to the header row — #62 live round). */
.vx-card .vx-section-head[b-scu5wca4t6] {
    margin-bottom: 0.75rem;
}

/* Compact grid rows (#62 live round: same spirit as the LV's 32px). */
.vx-card[b-scu5wca4t6]  .rz-grid-table {
    font-size: 0.875rem;
}

.vx-card[b-scu5wca4t6]  .rz-grid-table td,
.vx-card[b-scu5wca4t6]  .rz-grid-table th {
    padding: 0.3rem 0.5rem;
}

/* Single-letter status chips (grid branch): a fixed minimum keeps A/G/E/X/N
   optically equal and hoverable; the full wording lives in the badge's own
   tooltip. ::deep — RadzenBadge renders the span itself, so the plain
   scoped selector never matched (found in the #62 live round: 16px chips,
   unreachable tooltips). */
.vx-card[b-scu5wca4t6]  .vx-status-letter {
    min-width: 1.375rem;
    text-align: center;
}

/* The status chip row (letter chip plus the optional Nachfrist badge) is a
   RadzenStack: Orientation, AlignItems, Gap and Wrap carry its layout. */

/* The primary action and the overflow trigger share one calm line inside
   the grid cell; the shared .vx-actions primitive wraps by default. The
   card list keeps the wrapping default for narrow viewports. The row is a
   RadzenStack (Wrap="NoWrap"), so its root carries no scope attribute —
   ::deep from the native .vx-card section keeps the override against the
   .vx-actions primitive. */
.vx-card[b-scu5wca4t6]  .vx-invitation-actions {
    flex-wrap: nowrap;
}
/* /Components/Pages/Tenders/TenderCreateDialog.razor.rz.scp.css */
/* The shell div is the scoping root: the body, the footer and the rows inside
   are RadzenStacks, whose root carries no scope attribute (ADR-014), so the
   rules below reach them through `::deep` anchored on the shell. */

.vx-create-divider[b-r5e41ojksz] {
    border: none;
    border-top: 1px solid var(--vx-border);
    margin: 0.25rem 0;
}

/* Shell (owner round 3): the dialog frame (`vx-dialog-fill`, app.css) hands
   its height down; the body is the single scroll region and the footer with
   the phase actions stays pinned. */
.vx-create-shell--fill[b-r5e41ojksz] {
    height: 100%;
    min-height: 0;
    display: flex;
    flex-direction: column;
}

/* Mobile bottom sheet: the shell caps its own height instead, the
   MarketResearchSourcesDialog pattern (docs/dev/07, no SideDialogOptions
   parameter caps a height). 88vh is the sheet cap in app.css; 6rem is the
   title bar (48px) plus the content padding (2 x 24px), measured at 375x812.
   With the "Ausgehend von" row the entry form outgrew the sheet, the sheet
   scrolled as one document and the footer buttons lay below the viewport. */
.vx-create-shell:not(.vx-create-shell--fill)[b-r5e41ojksz] {
    max-height: calc(88vh - 6rem);
    display: flex;
    flex-direction: column;
}

.vx-create-shell[b-r5e41ojksz]  .vx-create-body {
    flex: 1 1 auto;
    min-height: 0;
    overflow-y: auto;
}

/* While generating, the busy block centers in the free height. */
.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body > .vx-ai-busy {
    margin: auto;
}

/* The preview step delegates scrolling to the tab panels — the same height
   plumbing as TenderDetail's .vx-page-fill chain (issues #51/#86). */
.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body--tabs {
    overflow: hidden;
}

.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body--tabs .rz-tabview {
    flex: 1 1 auto;
    min-height: 0;
    display: flex;
    flex-direction: column;
}

.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body--tabs .rz-tabview-panels {
    flex: 1 1 auto;
    min-height: 0;
    overflow: hidden;
}

/* The panel itself never scrolls — the tab content wrappers below are the
   scroll containers, so the sticky section bands sit directly in their own
   scrollport (a Radzen box in between mispinned them: the band floated
   mid-list, owner finding in round 3). Same structure as the LV editor's
   .vx-lv-main. */
.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body--tabs .rz-tabview-panel {
    height: 100%;
    min-height: 0;
    overflow: hidden;
    display: flex;
    flex-direction: column;
}

.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body--tabs .vx-create-md-tab,
.vx-create-shell--fill[b-r5e41ojksz]  .vx-create-body--tabs .vx-create-lv {
    flex: 1 1 auto;
    min-height: 0;
    overflow-y: auto;
}

.vx-create-shell[b-r5e41ojksz]  .vx-create-preview-alert {
    flex: 0 0 auto;
}

.vx-create-shell[b-r5e41ojksz]  .vx-create-footer {
    flex: 0 0 auto;
    border-top: 1px solid var(--vx-border);
    padding-top: 0.75rem;
    margin-top: 0.75rem;
}

/* Refine composer: the textarea takes the free width of its row. */
.vx-create-shell[b-r5e41ojksz]  .vx-create-refine-input {
    flex: 1 1 auto;
}

/* Section title bands stick while their section scrolls past — the pattern
   of the LV editor's .vx-section-head (issue #62): page background token on
   the dialog surface, so the separation holds in both themes. */
.vx-create-lv-section + .vx-create-lv-section[b-r5e41ojksz] {
    margin-top: 0.75rem;
}

.vx-create-lv-title[b-r5e41ojksz] {
    position: sticky;
    top: 0;
    z-index: 2;
    background: var(--vx-bg);
    border-bottom: 1px solid var(--vx-border);
    padding: 0.375rem 0.5rem;
    font-weight: 600;
}

/* Quantity column of the LV preview table. */
.vx-create-lv-section[b-r5e41ojksz]  .vx-create-lv-qty {
    width: 130px;
    text-align: right;
}

/* Compact AI block (owner round 1: the entry state must fit without
   scrolling) — heading and hint on one line, tight margins. */
.vx-create-ai-heading[b-r5e41ojksz] {
    display: flex;
    align-items: baseline;
    gap: 0.75rem;
    flex-wrap: wrap;
}

.vx-create-ai-heading[b-r5e41ojksz]  .vx-create-ai-title {
    margin: 0;
    font-size: 1.0625rem;
    font-weight: 700;
    color: var(--vx-text);
}

.vx-create-ai-note[b-r5e41ojksz] {
    font-size: 0.875rem;
}

.vx-create-shell[b-r5e41ojksz]  .vx-create-file-row {
    font-size: 0.875rem;
}

/* Attachment list (issue #172): file name + remove button per pending file. */
.vx-create-file-items[b-r5e41ojksz] {
    display: flex;
    flex-direction: column;
    gap: 0.25rem;
    margin: 0;
    padding: 0;
    list-style: none;
}

.vx-create-file-item[b-r5e41ojksz] {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 0.5rem;
    font-size: 0.875rem;
    padding: 0.125rem 0.5rem;
    border: 1px solid var(--vx-border);
    border-radius: 4px;
}

.vx-create-file-item-name[b-r5e41ojksz] {
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}

/* The titles carry their own number; the block is left-aligned inside the
   centered busy view so the items do not wrap raggedly with it. */
.vx-create-live-structure[b-r5e41ojksz] {
    display: inline-block;
    text-align: left;
}

.vx-create-live-structure .vx-create-live-list[b-r5e41ojksz] {
    list-style: none;
    margin: 0.25rem 0 0;
    padding: 0;
}

/* One past turn of the conversation; the history stack sets the spacing.
   The body is the scroll region, so the history flows instead of nesting a
   second scrollbar (owner round 3: no double scroll). */
.vx-create-turn[b-r5e41ojksz] {
    margin: 0;
}

/* Master-data preview: label column + value column (D-052 date marking);
   the top margin comes from rz-mt-3 on the list. */
.vx-create-md[b-r5e41ojksz] {
    display: grid;
    grid-template-columns: max-content 1fr;
    gap: 0.25rem 0.75rem;
    margin: 0;
}

.vx-create-md dd[b-r5e41ojksz] {
    margin: 0;
}

.vx-create-shell[b-r5e41ojksz]  .vx-create-parties {
    margin-top: 1rem;
    padding-top: 0.75rem;
    border-top: 1px solid var(--rz-base-300);
}

.vx-create-parties-title[b-r5e41ojksz] {
    margin: 0;
}
/* /Components/Pages/Tenders/TenderDetail.razor.rz.scp.css */
/* The full-height page chain (issue #86: owned by the page that renders it).

   `.vx-page-fill` is this page's own root section, so it carries the scope
   attribute; everything below it — the tabview and its panels — is Radzen's
   markup and is reached through `::deep` from that root (ADR-014). */

/* App-style full-height content (issue #51): the tender-detail page fills
   RadzenBody's fixed height; the active tab panel becomes the scroll
   region, so the page itself never scrolls. The rz-tabview chain needs
   explicit height plumbing (Radzen's own dashboard pattern).

   Desktop/tablet only (issue #55): on a phone the toolbar and the draft
   banner already eat the viewport, and pinning the panel to the remaining
   height left the LV list a ~170px scroll window for ~14.000px of content.
   Below the breakpoint the page scrolls as a normal document instead
   (ADR-021). */
@media (min-width: 769px) {
    .vx-page-fill[b-mzwlwtqqwa] {
        height: 100%;
        display: flex;
        flex-direction: column;
        min-height: 0;
    }

    .vx-page-fill[b-mzwlwtqqwa]  .rz-tabview {
        flex: 1 1 auto;
        min-height: 0;
        display: flex;
        flex-direction: column;
    }

    /* Basis 0, not auto: since the tab bar scrolls (Overflow="Scroll", #903)
       it has overflow hidden and so a minimum height of 0, and with an
       auto basis the flex shrink took the overflow of a long panel out of
       the 40px tab bar too -- squeezed to 12px, the tab titles were cut
       off on desktop (Stammdaten of AUS-26-9008 at 1440x900, measured
       2026-11-19). With basis 0 the panels take only the height left. */
    .vx-page-fill[b-mzwlwtqqwa]  .rz-tabview-panels {
        flex: 1 1 0;
        min-height: 0;
        overflow: hidden;
    }

    .vx-page-fill[b-mzwlwtqqwa]  .rz-tabview-panel {
        height: 100%;
        display: flex;
        flex-direction: column;
        min-height: 0;
        overflow-y: auto;
    }

    /* The LV tab opts out of the panel's own scrolling: the left pane
       scrolls instead, the assistant pane stands full height beside it.
       The panel belongs to this page, the marker class inside it to
       LvEditor — a structural relationship, so the rule lives with the
       element it styles. */
    .vx-page-fill[b-mzwlwtqqwa]  .rz-tabview-panel:has(.vx-lv-splitter) {
        overflow: hidden;
    }

}
/* /Components/Pages/Tenders/TenderEvaluationTab.razor.rz.scp.css */
/* Auswertung tab (#185). Every color goes through theme tokens (docs/dev/07,
   D-005); the matrix follows the LV editor's ~32px density convention
   (#62): 0.875rem × 1.5 line-height (21px) + 2 × 4.8px padding + 1px border
   ≈ 32px, pinned so the sticky offsets below are deterministic instead of
   theme-dependent.

   Rule 13 (issue 762): the cards and stacks are Radzen components now, whose
   rendered root carries no scope attribute. A selector whose last part targets
   one of them goes through `.vx-eval-tab ::deep` (the tab root stays a scoped
   element for exactly that); the flex direction, gap, wrap and alignment of a
   stack come from its own parameters in the markup, not from here. */

.vx-eval-tab[b-6i82pik6tu] {
    display: flex;
    flex-direction: column;
    gap: 0.75rem;
    padding-bottom: 0.75rem;
}

/* ── Height shape (owner round 3, revising D5's panel opt-out) ─────────

   Round 2 made the whole tab the height owner (panel opt-out, matrix
   absorbing the rest). On real screens that squeezed every section into a
   letterbox. Owner call: the tab panel scrolls normally like every other
   tab, and the matrix keeps its own vertical scroll window — bounded by a
   min-height (sticky headers need room to be useful) and a max-height (the
   panel must stay scrollable past the matrix to reach the legend/footer).

   Desktop/tablet only (ADR-021): below the breakpoint the page scrolls as a
   plain document and the matrix is hidden anyway. */
@media (min-width: 769px) {
    .vx-eval-matrix-card .vx-eval-matrix-scroll[b-6i82pik6tu] {
        min-height: 20rem;
        /* 54vh, tuned live by the owner (round 4): the matrix keeps a working
           window while the legend below it stays reachable without a long
           scroll on a laptop screen. */
        max-height: 54vh;
        overflow-y: auto;
    }
}

/* ── Toolbar / meta line ─────────────────────────────────────────────── */

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-toolbar {
    flex: 0 0 auto;
}

.vx-eval-meta[b-6i82pik6tu] {
    color: var(--vx-muted);
    font-size: 0.875rem;
}

/* ── 1 · Ranking strip ───────────────────────────────────────────────── */

.vx-eval-ranking[b-6i82pik6tu] {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(270px, 1fr));
    gap: 0.75rem;
    flex: 0 0 auto;
}

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-rank-card {
    background: var(--vx-surface);
    border: 1px solid var(--vx-border);
    border-radius: 0.5rem;
    padding: 0.6rem 0.85rem;
    min-width: 0;
}

/* Cheapest offer: token-colored ring, no threshold coloring beyond it (F-4). */
.vx-eval-tab[b-6i82pik6tu]  .vx-eval-rank-card.vx-eval-cheapest {
    border-color: var(--vx-success);
    box-shadow: inset 0.25rem 0 0 var(--vx-success);
}

/* A <p> laid out as a flex line: baseline alignment of rank and name, and the
   min-width that lets the name's ellipsis clip. */
.vx-eval-rank-head[b-6i82pik6tu] {
    display: flex;
    align-items: baseline;
    gap: 0.5rem;
    min-width: 0;
}

.vx-eval-rank-number[b-6i82pik6tu] {
    font-weight: 700;
    color: var(--vx-muted);
}

.vx-eval-rank-name[b-6i82pik6tu] {
    font-weight: 600;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}

.vx-eval-rank-total[b-6i82pik6tu] {
    font-size: 1.25rem;
    font-weight: 700;
    font-variant-numeric: tabular-nums;
}

.vx-eval-rank-total-label[b-6i82pik6tu] {
    color: var(--vx-muted);
    font-size: 0.8125rem;
    margin: 0 0 0.2rem;
}

.vx-eval-rank-line[b-6i82pik6tu] {
    font-size: 0.8125rem;
}

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-rank-badges {
    margin-top: 0.4rem;
}

/* ── 2 · Overview row: section sums beside the totals chart ───────────

   Side by side rather than stacked: both are read at a glance, and every
   pixel they spend vertically is a pixel the matrix below loses (D5). They
   stack again once the viewport is too narrow for two readable columns. */

.vx-eval-overview[b-6i82pik6tu] {
    display: grid;
    grid-template-columns: minmax(0, 1.4fr) minmax(320px, 1fr);
    gap: 0.75rem;
    align-items: stretch;
    flex: 0 0 auto;
}

@media (max-width: 1199px) {
    .vx-eval-overview[b-6i82pik6tu] {
        grid-template-columns: minmax(0, 1fr);
    }
}


/* The tab is a flex column with its own gap, so `.vx-card`'s stock 1rem
   block margin is double spacing — and it is charged against the matrix
   twice over (measured: 32px per card, 96px across the tab). */
.vx-eval-tab[b-6i82pik6tu]  .vx-card {
    margin: 0;
}

/* Tighter card chrome in the overview row: these two are supporting views,
   and every pixel they spend is one the matrix below loses (D5). */
.vx-eval-overview[b-6i82pik6tu]  .vx-card {
    padding: 0.75rem;
}

.vx-eval-overview[b-6i82pik6tu]  .vx-section-head {
    margin-bottom: 0.35rem;
}

/* #62 density for the sums table too — four Gewerke at the shared table's
   default row height already cost the matrix a third of its window. */
.vx-eval-overview[b-6i82pik6tu]  .vx-eval-sums th,
.vx-eval-overview[b-6i82pik6tu]  .vx-eval-sums td {
    padding: 0.25rem 0.5rem !important;
    font-size: 0.8125rem;
    line-height: 1.4;
}

/* ── Shared table bits (Gewerksummen + Matrix) ──────────────────────── */

.vx-eval-num[b-6i82pik6tu],
.vx-eval-overview[b-6i82pik6tu]  .vx-eval-num {
    text-align: right;
    font-variant-numeric: tabular-nums;
    white-space: nowrap;
}

/* Cheapest cell highlight — the *-bg tint pair is tuned per theme (docs/dev/07).
   The second selector out-specifies the matrix's own cell background. */
.vx-eval-cell-cheapest[b-6i82pik6tu],
.vx-eval-overview[b-6i82pik6tu]  .vx-eval-cell-cheapest,
.vx-eval-matrix td.vx-eval-cell-cheapest[b-6i82pik6tu] {
    background: var(--vx-success-bg);
    color: var(--vx-success);
    font-weight: 600;
}

/* ── Outlier markers (owner round 5) ──────────────────────────────────

   Both use the warning token, never the danger one: an outlier is worth a
   second look, not an error, and red would claim more than the data says.
   They are deliberately different in weight, because they are differently
   rare — a quantity far off the bidders' median is a single conspicuous
   number and gets the amber figure plus the tint, while an expensive price
   can occur on a whole column and gets the wash alone, so the figures in it
   stay readable. Tune the intensity here; the thresholds live in
   TenderEvaluationView. */

/* Price outlier: >= PriceOutlierThresholdPercent above the cheapest
   comparable EP or Gewerkesumme. The second selector out-specifies the
   matrix's own cell background, as with the cheapest mark above. */
.vx-eval-cell-expensive[b-6i82pik6tu],
.vx-eval-overview[b-6i82pik6tu]  .vx-eval-cell-expensive,
.vx-eval-matrix td.vx-eval-cell-expensive[b-6i82pik6tu] {
    background: var(--vx-warning-bg);
}

/* Quantity outlier: the bidder's own quantity disagrees with the median of
   the other bidders'. The bold comes from .vx-eval-qty-dev, which every
   bidder quantity carries — this adds the color that singles one out. */
.vx-eval-matrix td.vx-eval-qty-outlier[b-6i82pik6tu],
.vx-eval-legend-sample.vx-eval-qty-outlier[b-6i82pik6tu] {
    background: var(--vx-warning-bg);
    color: var(--vx-warning);
    font-weight: 700;
}

/* Incomplete section sum (owner decision on #185): the bidder skipped a
   position, so the sum is real but not comparable — it takes no part in the
   cheapest or outlier marks. Muted dagger rather than a color: the figure is
   not wrong, it just answers a different question, and the two amber markers
   above already own "look at this". The tooltip on the cell names the gap. */
.vx-eval-gap-hint[b-6i82pik6tu] {
    color: var(--vx-muted);
    font-weight: 400;
    margin-left: 0.1em;
}

/* D-072: a unit price mapped from an older LV version. Font style only, so it
   composes with the cheapest/expensive tints in both themes. */
.vx-eval-cell-older-version[b-6i82pik6tu] {
    font-style: italic;
}

.vx-eval-cell-gap[b-6i82pik6tu] {
    color: var(--vx-muted);
    font-style: italic;
}

/* D4: the Bedarfssumme line is a companion to the section sum, not a peer. */
.vx-eval-overview[b-6i82pik6tu]  .vx-eval-eventual-row td,
.vx-eval-eventual-row td[b-6i82pik6tu] {
    color: var(--vx-muted);
    font-style: italic;
}

.vx-eval-footnote[b-6i82pik6tu] {
    font-size: 0.8125rem;
    max-width: 90ch;
    margin: 0.5rem 0 0;
}

/* ── Matrix legend (owner round 4) ────────────────────────────────────

   Round 3 squeezed the whole legend into one line in the heading row to
   save the matrix three text lines. It saved the pixels and lost the
   meaning: even the owner needed the terms explained. It is now a
   structured definition grid *below* the matrix — grouped, one short
   German sentence per entry, and every sample rendered with the very same
   badge/cell classes the matrix uses, so a mark can be matched by eye. */

.vx-eval-legend[b-6i82pik6tu] {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(17rem, 1fr));
    gap: 0.75rem 2rem;
    margin-top: 0.75rem;
    padding-top: 0.75rem;
    border-top: 1px solid var(--vx-border);
}

.vx-eval-legend-title[b-6i82pik6tu] {
    margin: 0 0 0.35rem;
    font-size: 0.75rem;
    font-weight: 600;
    letter-spacing: 0.04em;
    text-transform: uppercase;
    color: var(--vx-muted);
}

/* Two columns: the sample (badge/cell chip) and its one-line explanation.
   #62 density — 0.8125rem, the same scale as the sums table. */
.vx-eval-legend-list[b-6i82pik6tu] {
    display: grid;
    grid-template-columns: auto minmax(0, 1fr);
    align-items: baseline;
    column-gap: 0.6rem;
    row-gap: 0.3rem;
    margin: 0;
    font-size: 0.8125rem;
    line-height: 1.45;
}

.vx-eval-legend-list dt[b-6i82pik6tu] {
    white-space: nowrap;
}

.vx-eval-legend-list dd[b-6i82pik6tu] {
    margin: 0;
    color: var(--vx-muted);
}

/* The green/n. a./"—"/quantity samples reuse the matrix cell classes; this
   only gives them the padding a table cell would have provided. */
.vx-eval-legend-sample[b-6i82pik6tu] {
    display: inline-block;
    padding: 0.05rem 0.35rem;
    border-radius: 0.25rem;
    font-variant-numeric: tabular-nums;
}

/* Mirrors `td.vx-eval-qty-dev`, which is scoped to the matrix table. */
.vx-eval-legend-qty[b-6i82pik6tu] {
    font-weight: 700;
}

.vx-eval-legend-note[b-6i82pik6tu] {
    margin: 0.5rem 0 0;
    font-size: 0.8125rem;
    grid-column: 1 / -1;
}

.vx-eval-overview[b-6i82pik6tu]  .vx-eval-sums th.vx-eval-num {
    white-space: nowrap;
}

/* The modifier's `.rz-cell-data { white-space: normal }` wins on the span over the
   cell's own nowrap, so figures say so on the span (docs/dev/07, rule 13). */
.vx-eval-overview[b-6i82pik6tu]  td.vx-eval-num .rz-cell-data {
    white-space: nowrap;
}

/* ── 3 · Hand-built matrix ───────────────────────────────────────────── */

/* One scroll container for both axes (docs/dev/07: wide content scrolls in a
   container, never the page): the sticky header rows, section bands and
   OZ/Kurztext columns all stick against this box. Its height comes from the
   D5 chain above; on mobile it is hidden entirely. */
.vx-eval-matrix-scroll[b-6i82pik6tu] {
    overflow: auto;
    border: 1px solid var(--vx-border);
    border-radius: 0.375rem;
}

.vx-eval-matrix[b-6i82pik6tu] {
    width: 100%;
    border-collapse: separate; /* border-collapse breaks sticky headers in Chromium */
    border-spacing: 0;
    font-size: 0.875rem;
}

.vx-eval-matrix th[b-6i82pik6tu],
.vx-eval-matrix td[b-6i82pik6tu] {
    box-sizing: border-box;
    padding: 0.3rem 0.5rem;
    line-height: 1.5;
    border-bottom: 1px solid var(--vx-border);
    text-align: left;
    white-space: nowrap;
    background: var(--vx-surface);
    vertical-align: middle;
}

/* Sticky two-row header: 32px + 28px, pinned for the band offset below. */
.vx-eval-matrix thead th[b-6i82pik6tu] {
    position: sticky;
    top: 0;
    z-index: 3;
    height: 32px;
    background: var(--vx-bg);
    color: var(--vx-muted);
    font-weight: 600;
    font-size: 0.8125rem;
}

.vx-eval-matrix thead tr.vx-eval-subhead th[b-6i82pik6tu] {
    top: 32px;
    height: 28px;
}

.vx-eval-matrix th.vx-eval-bidder-head[b-6i82pik6tu] {
    text-align: center;
    max-width: 220px;
    overflow: hidden;
    text-overflow: ellipsis;
}

/* Light separator after each bidder's last column keeps the groups readable. */
.vx-eval-matrix .vx-eval-bidder-sep[b-6i82pik6tu] {
    border-right: 1px solid var(--vx-border);
}

/* Sticky section band, directly below the 60px header stack. The inner span
   re-sticks horizontally so the title stays readable while scrolling right
   (the colspan cell itself scrolls with the columns). */
.vx-eval-matrix tr.vx-eval-band td[b-6i82pik6tu] {
    position: sticky;
    top: 60px;
    z-index: 2;
    background: var(--vx-bg);
    font-weight: 600;
    font-size: 0.9375rem;
}

.vx-eval-matrix tr.vx-eval-band td span[b-6i82pik6tu] {
    position: sticky;
    left: 0.5rem;
    display: inline-block;
}

/* Sticky identity columns (OZ + Kurztext) for horizontal scrolling. */
.vx-eval-matrix .vx-eval-sticky-oz[b-6i82pik6tu] {
    position: sticky;
    left: 0;
    z-index: 1;
    min-width: 64px;
    width: 64px;
}

.vx-eval-matrix .vx-eval-sticky-text[b-6i82pik6tu] {
    position: sticky;
    left: 64px;
    z-index: 1;
    min-width: 240px;
    max-width: 340px;
    /* The short text wraps instead of being cut: a cut would hide the badges that follow it (frequency, type). */
    overflow-wrap: anywhere;
}

/* Header corner cells stick on both axes and must beat everything. */
.vx-eval-matrix thead th.vx-eval-sticky-oz[b-6i82pik6tu],
.vx-eval-matrix thead th.vx-eval-sticky-text[b-6i82pik6tu] {
    z-index: 4;
}

.vx-eval-matrix tr.vx-eval-info-row td[b-6i82pik6tu] {
    color: var(--vx-muted);
}

.vx-eval-matrix tr.vx-eval-section-total td[b-6i82pik6tu] {
    font-weight: 600;
    border-bottom-width: 2px;
}

/* A bidder quantity that differs from the LV quantity: weight plus the "*"
   the legend explains — deliberately quieter than a color, which is
   reserved for the cheapest marking (F-4). */
.vx-eval-matrix td.vx-eval-qty-dev[b-6i82pik6tu] {
    font-weight: 700;
}

/* ── 4 · Chart ───────────────────────────────────────────────────────── */

/* Horizontal bars since owner round 5. The height is set inline per bidder
   count (ChartHeightStyle) — this is only the floor for the moment before
   the model is loaded. */
.vx-eval-tab[b-6i82pik6tu]  .vx-eval-chart {
    min-height: 150px;
    width: 100%;
}

/* A caption instead of a second `.vx-section-head` h2: the chart repeats the
   ranking's figures, and every pixel it spends is one the matrix loses (D5). */
.vx-eval-chart-caption[b-6i82pik6tu] {
    font-size: 0.8125rem;
    margin: 0 0 0.25rem;
}

/* ── Mobile (≤768px): the matrix is a desktop working tool (issue #185); the
   ranking cards above stay as the phone view. ─────────────────────────── */

.vx-eval-matrix-mobile-hint[b-6i82pik6tu] {
    display: none;
}

@media (max-width: 768px) {
    .vx-eval-matrix-scroll[b-6i82pik6tu],
    .vx-eval-legend[b-6i82pik6tu] {
        display: none;
    }

    .vx-eval-matrix-mobile-hint[b-6i82pik6tu] {
        display: block;
        margin: 0;
    }

    .vx-eval-ranking[b-6i82pik6tu] {
        grid-template-columns: 1fr;
    }

    .vx-eval-overview .vx-table-scroll[b-6i82pik6tu] {
        max-height: none;
    }
}

/* ── 0 · Lifecycle / award / rejection card (#189, #260, D-029) ───────

   Sits above the ranking so the outcome of the evaluation — where the
   tender stands, who holds the award and which mails already went out — is
   the first thing on the tab. Colors are tokens only (D-005); the badges
   carry their own semantics from the docs/dev/07 rule 7 table. */

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-award {
    flex: 0 0 auto;
}

.vx-eval-award-line[b-6i82pik6tu] {
    margin: 0;
}

/* Owner round 1: the chip row used to sit almost on the buttons, so state
   and actions read as one block. The three rows — sentence, state chips,
   actions — now step apart clearly, and the action row keeps the larger
   gap because it is a different kind of thing, not more status. The steps
   are spacing utilities in the markup: rz-mt-3 on the chip row, rz-mt-5 on
   the action row. */

.vx-eval-reviewer-note[b-6i82pik6tu] {
    margin-top: 1rem;
}

/* ── Internal evaluation note on the rank card (#260, D-027) ──────────

   A preview, not the note: two lines at card width, the rest in the dialog.
   Clamping rather than truncating on one line — most notes are a sentence
   or two, and a one-liner would cut nearly all of them mid-word. */

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-rank-note {
    margin-top: 0.5rem;
    padding-top: 0.5rem;
    border-top: 1px solid var(--vx-border);
    min-width: 0;
}

.vx-eval-rank-note-text[b-6i82pik6tu],
.vx-eval-rank-note-empty[b-6i82pik6tu] {
    flex: 1 1 auto;
    min-width: 0;
    font-size: 0.8125rem;
    line-height: 1.4;
    display: -webkit-box;
    -webkit-line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
}

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-rank-note .vx-actions {
    flex: 0 0 auto;
    margin: 0;
}

/* Revoke sits last in the action row, set apart from the routine buttons
   (owner round 2, 2026-09-01). ::deep because the class rides on a
   Radzen-rendered <button>, which carries no scope attribute (docs/dev/07
   rule 7).

   A fixed gap rather than `margin-left: auto`: the four buttons of an
   awarded tender need ~766px of row width, so the row already wraps below
   roughly 1210px viewport — on any ordinary laptop. Pinning to the right
   edge would then strand a lone red button, right-aligned, on its own
   line, which reads as a layout accident rather than as separation. This
   gap looks the same whether the row wraps or not. */
.vx-eval-tab[b-6i82pik6tu]  .vx-eval-action-row .vx-eval-award-revoke {
    margin-left: 1.5rem;
}

/* Stacked on mobile: the buttons sit one per line, so a left inset would
   indent the red one out of alignment with the rest instead of separating
   it. Being last and Danger-colored carries the separation there. */
@media (max-width: 768px) {
    .vx-eval-tab[b-6i82pik6tu]  .vx-eval-action-row .vx-eval-award-revoke {
        margin-left: 0;
    }
}

/* ── Market benchmark (D-057, #274) ───────────────────────────────────
   Display-only overlay: absent entirely from the DOM when the tender's LV
   carries no research (the razor guards every block on `_benchmark`), so
   none of this can shift a figure any test above already asserts on. */

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-benchmark {
    margin-top: 0.3rem;
}

.vx-eval-benchmark-track[b-6i82pik6tu] {
    position: relative;
    height: 0.4rem;
    border-radius: 0.2rem;
    background: var(--vx-border);
    margin: 0.2rem 0;
}

/* A dot, not a fill bar: the range itself carries no "how much of it"
   meaning (unlike a load/progress gauge) — only where the total sits in it. */
.vx-eval-benchmark-marker[b-6i82pik6tu] {
    position: absolute;
    top: 50%;
    width: 0.55rem;
    height: 0.55rem;
    border-radius: 50%;
    background: var(--vx-primary);
    transform: translate(-50%, -50%);
}

.vx-eval-benchmark-cell[b-6i82pik6tu] {
    color: var(--vx-muted);
}

/* LV status and comment indicators next to a position or section (D-070). */
.vx-eval-matrix[b-6i82pik6tu]  .vx-eval-comment-btn {
    vertical-align: middle;
}

.vx-eval-matrix[b-6i82pik6tu]  .vx-eval-comment-external {
    color: var(--vx-warning);
}

/* Focus mode (issue 765): fullscreen the matrix card takes the height the frame has left
   (the frame body is a bounded flex column, FocusFrame.razor.css) and the matrix scrolls
   inside its own box, so the sticky header rows, section bands and OZ/Kurztext columns keep
   sticking and the horizontal scrollbar stays at the bottom of the card. Everything above
   the card keeps its natural height; the frame scrolls only when they leave less than the
   card's minimum. That minimum is the frame's height less its vertical padding (2 x 1rem,
   FocusFrame.razor.css), so scrolling the frame down to the matrix shows a window at least as
   tall as the page's own (54vh), never the sliver the rows above leave. The scroll box keeps
   the page's own floor (max(20rem, 54vh)) instead of 0: the toolbar, legend and padding keep
   their natural height, so with min-height 0 a short viewport squeezed the box to a sliver
   (31 px at 1440x600, E2E). The card may then outgrow the frame, and the frame scrolls. */
@media (min-width: 769px) {
    .vx-eval-tab[b-6i82pik6tu]  .vx-focus-frame-active .vx-eval-matrix-card {
        display: flex;
        flex: 1 1 auto;
        flex-direction: column;
        min-height: max(20rem, calc(100dvh - 2rem));
    }

    .vx-eval-tab[b-6i82pik6tu]  .vx-focus-frame-active .vx-eval-matrix-scroll {
        flex: 1 1 auto;
        min-height: max(20rem, 54vh);
        max-height: none;
    }
}

/* ── 3b · Bieterunterlagen (D-083 point 4) ───────────────────────────────

   Table on a wide container, one card per bidder on a narrow one (docs/dev/07
   rules 14/16): the switch is a container query on the card's own width, not
   the viewport. The card list is a plain element: a RadzenStack carries
   `rz-display-flex` (!important), which beat the `display: none` here and showed
   both presentations on desktop (issue 899). Its inner stacks are Radzen
   components (rule 13), so their selectors go through `.vx-eval-tab ::deep`;
   their direction and gap are parameters in the markup. Colors come from the badges (rule 7), none are set here. */

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-docs {
    container-type: inline-size;
}

.vx-eval-docs-cards[b-6i82pik6tu] {
    display: none;
}

.vx-eval-doc-file[b-6i82pik6tu] {
    font-size: 0.875rem;
    overflow-wrap: anywhere;
}

.vx-eval-tab[b-6i82pik6tu]  .vx-eval-docs-line {
    padding: 0.5rem 0;
    border-top: 1px solid var(--vx-border);
}

.vx-eval-docs-name[b-6i82pik6tu] {
    font-weight: 600;
}

@container (max-width: 40rem) {
    .vx-eval-docs-table[b-6i82pik6tu] {
        display: none;
    }

    .vx-eval-docs-cards[b-6i82pik6tu] {
        display: flex;
        flex-direction: column;
        gap: 0.75rem;
    }
}
/* /Components/Pages/Tenders/TenderQuestionTab.razor.rz.scp.css */
/* Fragen tab (#178) — same compact-grid rhythm as the Bieter tab
   (TenderBidderTab.razor.css); Radzen-rendered cells need ::deep from the
   native .vx-card anchor (ADR-014). Colors stay with badge/button theme
   styles — nothing hard-coded here (D-005). */

.vx-qa-tab.vx-card .vx-section-head[b-g9u66bqphx] {
    margin-bottom: 0.75rem;
}

.vx-qa-tab.vx-card[b-g9u66bqphx]  .rz-grid-table {
    font-size: 0.875rem;
}

.vx-qa-tab.vx-card[b-g9u66bqphx]  .rz-grid-table td,
.vx-qa-tab.vx-card[b-g9u66bqphx]  .rz-grid-table th {
    padding: 0.3rem 0.5rem;
}
/* /Components/Shared/AiProgressIndicator.razor.rz.scp.css */
/* Streamed character count ticks upward during a call (issues #72/#114);
   tabular figures keep the label from jittering in width per update. */
.vx-ai-progress[b-dpdtzejq8c] {
    font-variant-numeric: tabular-nums;
}
/* /Components/Shared/FileUploadButton.razor.rz.scp.css */
.vx-file-upload[b-b8lljvfgk3] {
    display: inline-flex;
    align-items: center;
    gap: 0.5rem;
    flex-wrap: wrap;
}

.vx-file-upload-control[b-b8lljvfgk3] {
    position: relative;
    display: inline-flex;
}

/* InputFile renders its own <input>, not markup written in this file, so
   ::deep is required to reach it at all (ADR-014's rule, which applies to
   any child-rendered root, not just Radzen). It stays the real, focusable
   control — stretched over the decorative button and made invisible, not
   display:none, so its native tab stop and keyboard activation survive. */
.vx-file-upload-control[b-b8lljvfgk3]  .vx-file-upload-input {
    position: absolute;
    inset: 0;
    width: 100%;
    height: 100%;
    margin: 0;
    opacity: 0;
    cursor: pointer;
}

.vx-file-upload-control[b-b8lljvfgk3]  .vx-file-upload-input:disabled {
    cursor: default;
}

/* The real control above is opacity:0, so its native focus outline is
   invisible too — redraw it on the decorative button underneath whenever
   the input has focus (`:focus-within` on the wrapper, since the input and
   the button are siblings, not ancestor/descendant). */
.vx-file-upload-control:focus-within[b-b8lljvfgk3]  .vx-file-upload-button {
    outline: 2px solid var(--rz-primary, currentColor);
    outline-offset: 2px;
}

.vx-file-upload-name[b-b8lljvfgk3] {
    word-break: break-all;
}
/* /Components/Shared/FocusFrame.razor.rz.scp.css */
/* Focus mode (issue 765). Theme tokens only (D-005). The frame and its stacks are Radzen
   components without a scope attribute, so every rule goes through ::deep from the native
   anchor FocusFrame.razor renders. The rule that frees the shell from the transform and
   keeps the page behind from scrolling is global (app.css): it targets RadzenBody. */

.vx-focus-frame-scope[b-jc95dhxko5] {
    display: contents;
}

/* The frame is a flex item of whatever holds it and passes the height on to its content, so a
   view that fills the page (the LV editor's splitter) keeps its full-height chain (ADR-021). */
.vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame,
.vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame-body {
    flex: 1 1 auto;
    min-height: 0;
}

.vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame-header {
    flex: 0 0 auto;
}

/* The page's own toolbar takes the room the toggle button leaves. */
.vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame-header > :first-child:not(.vx-focus-frame-toggle) {
    flex: 1 1 auto;
}

/* The button sits at the end of the header row, also when the toolbar wraps. */
.vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame-toggle {
    margin-left: auto;
}

/* Fullscreen: the frame covers the viewport and scrolls inside itself; the shell's scroller
   is locked behind it (app.css). */
.vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame-active {
    position: fixed;
    inset: 0;
    z-index: 1000;
    margin: 0;
    padding: 1rem 1.25rem;
    border: 0;
    border-radius: 0;
    background: var(--vx-surface);
    overflow: auto;
    overscroll-behavior: contain;
}

/* The toggle is a desktop feature; on a phone the screen is the viewport already. */
@media (max-width: 768px) {
    .vx-focus-frame-scope[b-jc95dhxko5]  .vx-focus-frame-toggle {
        display: none;
    }
}
/* /Components/Shared/HelpVideoDialog.razor.rz.scp.css */
.vx-help-video video[b-54nur9wskl] {
    display: block;
    width: 100%;
    height: auto;
    max-height: 70vh;
    background: var(--rz-base-900);
}
/* /Components/Shared/ListToolbar.razor.rz.scp.css */
/* The search line takes the free width up to a readable maximum; the switch stays at the right
   edge, wrapping under it on a phone. RadzenTextBox renders the class onto its own input, which
   carries no scope attribute of this component, so the rule reaches it through ::deep from the
   native wrapper (ADR-014). */
[b-qbfb6yf15v] .vx-list-search {
    flex: 1 1 16rem;
    max-width: 28rem;
}
/* /Components/Shared/PageHeader.razor.rz.scp.css */
/* Self-contained header styles: theme tokens only (D-005). Slotted fragments
   (breadcrumb links, Radzen badge/buttons) come from other files and lack this
   scope attribute, so cross-file rules would need ::deep (ADR-014). Rules on
   elements PageHeader.razor renders itself are plain; rules on the RadzenStack
   and RadzenText roots it renders are reached via ::deep from its own <header>. */

.vx-page-header[b-wkddi7n5ik] {
    margin-bottom: 1rem;
}

/* As an item of a RadzenStack the stack's gap already provides the spacing;
   flex-item margins do not collapse into it, so the margin would double. */
.rz-stack > .vx-page-header[b-wkddi7n5ik] {
    margin-bottom: 0;
}

.vx-page-header-breadcrumb[b-wkddi7n5ik] {
    margin-bottom: 0.25rem;
    font-size: 0.85rem;
    color: var(--vx-muted);
}

/* The row, the title group and the actions are RadzenStacks (no scope attribute
   on their root), so the rules below that RadzenStack's parameters cannot
   express are reached via ::deep from this component's own <header>. */
.vx-page-header[b-wkddi7n5ik]  .vx-page-header-title {
    min-width: 0;
}

/* The h1 itself is a RadzenText child component (no scope attribute here);
   its typography comes from TextStyle, the wrap rule lives in app.css. */

.vx-page-header[b-wkddi7n5ik]  .vx-page-header-actions {
    margin-left: auto;
}

/* The title: RadzenText renders the h1, so the scope attribute never lands on
   it (ADR-014) — reached via ::deep from this component's own root. Long
   tender titles must wrap instead of overflowing. */
.vx-page-header[b-wkddi7n5ik]  .vx-page-header-h1 {
    overflow-wrap: anywhere;
}
/* /Components/Shared/PageTour.razor.rz.scp.css */
.vx-tour-hint[b-f43e6kswns] {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    justify-content: space-between;
    gap: 0.5rem 1rem;
    margin-bottom: 1rem;
    padding: 0.5rem 0.75rem;
    color: var(--rz-text-color);
    background: var(--rz-info-lighter);
    border: 1px solid var(--rz-info-light);
    border-radius: var(--rz-border-radius);
}
/* /Components/Shared/ResponsiveList.razor.rz.scp.css */
/* Grid stays exactly as it is at >=769px; below the shell's drawer
   breakpoint (768px, same threshold as MainLayout.razor.css and
   LvEditor.razor.css) the grid becomes an unreachable scrolling table, so
   the card list replaces it there (issue #74). Both are always rendered;
   only visibility toggles, so the grid keeps sorting/RowSelect/IsLoading
   untouched above the breakpoint. */
.vx-responsive-list-cards[b-er7cxfj3mg] {
    display: none;
}

@media (max-width: 768px) {
    .vx-responsive-list-grid[b-er7cxfj3mg] {
        display: none;
    }

    .vx-responsive-list-cards[b-er7cxfj3mg] {
        display: flex;
        flex-direction: column;
        gap: 0.75rem;
    }
}

.vx-responsive-list-card-title[b-er7cxfj3mg] {
    font-weight: 600;
    margin-bottom: 0.5rem;
}

/* Tight rows: with label and value on one line (ResponsiveListField), a
   generous gap is what pushes the card back to the height it had when they
   were stacked. */
.vx-responsive-list-card-fields[b-er7cxfj3mg] {
    display: flex;
    flex-direction: column;
    gap: 0.2rem;
    margin-bottom: 0.5rem;
}

/* A group (GroupKey/GroupHeader): header and its cards in one block, with the same gap as
   between cards; extra space between two blocks separates the groups. */
.vx-responsive-list-group-block[b-er7cxfj3mg] {
    display: flex;
    flex-direction: column;
    gap: 0.75rem;
}

.vx-responsive-list-group-block + .vx-responsive-list-group-block[b-er7cxfj3mg] {
    margin-top: 0.75rem;
}
/* /Components/Shared/ResponsiveListField.razor.rz.scp.css */
/* Label left, value right on one line — the dense form. A card with four
   fields is then ~4 lines tall instead of ~8, which is what makes a phone
   list scannable (integrator review of #74). */
.vx-responsive-list-field[b-hmljsm01li] {
    display: flex;
    align-items: baseline;
    justify-content: space-between;
    gap: 0.75rem;
    min-height: 1.5rem;
}

.vx-responsive-list-field .vx-label[b-hmljsm01li] {
    margin-bottom: 0;
    flex: 0 0 auto;
}

/* The value takes the rest and wraps within it; right-aligned so the column
   of values reads as a column. */
.vx-responsive-list-value[b-hmljsm01li] {
    flex: 1 1 auto;
    min-width: 0;
    text-align: right;
    overflow-wrap: anywhere;
}
/* /Components/Shared/TenderDocumentList.razor.rz.scp.css */
.vx-doc-group + .vx-doc-group[b-lb6rwsafx9] {
    margin-top: 0.75rem;
}

.vx-doc-group h3[b-lb6rwsafx9] {
    margin: 0 0 0.25rem;
}

.vx-doc-list[b-lb6rwsafx9] {
    list-style: none;
    margin: 0;
    padding: 0;
}

.vx-doc-row[b-lb6rwsafx9] {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    gap: 0.25rem 1rem;
    padding: 0.4rem 0;
    border-bottom: 1px solid var(--vx-border);
}

.vx-doc-name[b-lb6rwsafx9] {
    flex: 1 1 14rem;
    min-width: 0;
    overflow-wrap: anywhere;
}

.vx-doc-meta[b-lb6rwsafx9] {
    white-space: nowrap;
}

.vx-doc-actions[b-lb6rwsafx9] {
    display: inline-flex;
    flex-wrap: wrap;
    align-items: center;
    gap: 0.25rem 0.75rem;
}
