/* App chrome tokens (D-005: every color goes through tokens).

   Token mapping — vx token → Radzen theme variable (docs/dev/07):
   | vx token              | rz variable / vx-only               |
   |-----------------------|-------------------------------------|
   | --vx-bg               | var(--rz-body-background-color)     |
   | --vx-surface          | --rz-base-background-color, opaque  |
   | --vx-text             | var(--rz-text-color)                |
   | --vx-muted            | var(--rz-text-secondary-color)      |
   | --vx-border           | var(--rz-base-300) / -500 in dark   |
   | --vx-primary          | var(--rz-primary)                   |
   | --vx-primary-contrast | var(--rz-on-primary)                |
   | --vx-danger           | vx-only                             |
   | --vx-danger-bg        | vx-only                             |
   | --vx-success          | vx-only                             |
   | --vx-success-bg       | vx-only                             |
   | --vx-warning          | vx-only                             |
   | --vx-warning-bg       | vx-only                             |

   --vx-surface: zen's base-background-color is translucent (rgba over the
   page, light and dark), which is right for its own cards but not for the
   sticky and fixed parts that use --vx-surface (offer bar, tour popover,
   reconnect modal, full-screen grid): scrolled content would show through.
   Relative color syntax keeps its RGB and forces alpha to 1 (the explicit
   `/ 1` matters: without it the origin's alpha carries over, measured
   2026-10-31), so the token still follows the theme and the tenant palette.
   --vx-border: there is no single --rz-* border color (the --rz-border-*
   variables are full border shorthands). The zen theme draws card and grid
   borders with --rz-base-300 in light and --rz-base-500 in dark, so the
   alias switches with the mode in the light/dark blocks below instead of
   resolving once on :root.
   --vx-danger/--vx-success/--vx-warning stay vx-only: --rz-danger/--rz-success
   exist but are theme-invariant (same hex in light and dark), while the vx
   pairs are tuned per theme to stay readable on the vx-only *-bg tints.
   --vx-warning (#185, owner round 5) is the "look at this" amber the
   evaluation matrix marks outliers with — deliberately a separate token from
   --vx-danger so a conspicuous figure never reads as an error.

   The aliased tokens resolve against the active Radzen theme stylesheet
   (zen-base.css / zen-dark-base.css, premium themes served from
   wwwroot/css — ADR-020, revised 2026-10-31), which defines --rz-* on
   :root. RadzenTheme (explicit choice) or the OS-scheme head script
   (no cookie, ADR-008) swaps that stylesheet, so the aliases follow
   light/dark automatically — no per-theme redefinition needed, and the
   reconnect modal outside .vx-app is covered too. Only the vx-only tokens
   and --vx-border still need the explicit light/dark blocks below: without a stored choice
   (no "vx-explicit" marker) they follow the OS color scheme; the manual
   toggle mirrors dark mode as vx-dark on the app wrapper and wins once a
   cookie exists (ADR-008, revised 2026-08-29). */
/* Shell header height (issue #86). Radzen's own CSS references
   `var(--rz-header-height, 3.5rem)` in a dozen places but never defines it,
   and neither did we — so the mobile nav drawer and the drawer scrim (both in
   MainLayout.razor.css, the only two consumers) positioned themselves 3.5rem
   (56px) from the top while the real header is 66px there. The LV assistant
   overlay used to read it too and no longer does: RadzenBody's identity
   transform makes `.rz-body` its containing block, so it anchors with
   `top: 0` instead (LvEditor.razor.css). Measured under Material 3 it was
   50px from 769px up and 66px below, where the brand line wrapped; the 10px
   gap put the open drawer *over* the header (verified: sidebar top 56 under
   a 66px header; with the value defined it sat at 66). The zen base theme
   (ADR-020, revised 2026-10-31) pads the header by 8px around a 56px bar
   that no longer wraps: 72px at 390, 600, 760, 800 and 1280px wide
   (measured 2026-10-31, sidebar top 72 at 1280).

   Radzen does not use the variable for its own layout — setting it moved the
   sidebar and nothing else — so this defines it for those two rules only.
   Re-measure with getBoundingClientRect on `.rz-header` if the header's
   content ever changes. */
:root {
    --rz-header-height: 72px;

    --vx-bg: var(--rz-body-background-color);
    --vx-surface: rgb(from var(--rz-base-background-color) r g b / 1);
    --vx-text: var(--rz-text-color);
    --vx-muted: var(--rz-text-secondary-color);
    --vx-border: var(--rz-base-300);
    --vx-primary: var(--rz-primary);
    --vx-primary-contrast: var(--rz-on-primary);
    /* vx-only tokens — light values. Mirrored on :root so markup outside
       .vx-app (Blazor's reconnect modal) has themed colors too; there the
       OS scheme is the only theme signal available. */
    --vx-danger: #b3261e;
    --vx-danger-bg: #fdecea;
    --vx-success: #1e7d3c;
    --vx-success-bg: #e8f5ec;
    --vx-warning: #7a4f00;
    --vx-warning-bg: #fae7c4;
    /* Scrim and elevation shadows are black at a fixed alpha in both themes
       (a dimming layer does not follow the palette); named here so the scoped
       stylesheets carry no colour literal (D-005, colour-literal rule). */
    --vx-scrim: rgb(0 0 0 / 0.45);
    --vx-shadow-drawer: 0 0 24px rgb(0 0 0 / 0.4);
    --vx-shadow-modal: 0 3px 6px 2px rgb(0 0 0 / 0.3);
}

/* Disabled inputs are read-only displays of real content (the master data of
   a published tender), not dimmed chrome: zen's 50 % opacity on top of the
   disabled text color measured 1.37:1 (issue 900). Full opacity, the secondary
   text color and a tinted fill keep the text readable; the fill and a border
   of its own step (not the enabled one, not the fill's) keep the field visibly
   read-only. Defined here, in the neutral layer, so an installation without a
   tenant stylesheet gets them too (docs/dev/07); a tenant theme overrides
   them only where its palette needs it. Dark is declared twice like the
   tenant themes do: the OS media query while no explicit choice exists, the
   scheme class when there is one. */
:root {
    --rz-input-disabled-color: var(--rz-text-secondary-color);
    --rz-input-disabled-opacity: 1;
    --rz-input-disabled-background-color: var(--rz-base-200);
    --rz-input-disabled-border: var(--rz-border-width) solid var(--rz-base-600);
    --rz-input-disabled-border-block-end: var(--rz-border-width) solid var(--rz-base-600);
}

@media (prefers-color-scheme: dark) {
    :root:not(.vx-scheme-light) {
        --rz-input-disabled-background-color: var(--rz-base-600);
        --rz-input-disabled-border: var(--rz-border-width) solid var(--rz-base-300);
        --rz-input-disabled-border-block-end: var(--rz-border-width) solid var(--rz-base-300);
    }
}

:root.vx-scheme-dark {
    --rz-input-disabled-background-color: var(--rz-base-600);
    --rz-input-disabled-border: var(--rz-border-width) solid var(--rz-base-300);
    --rz-input-disabled-border-block-end: var(--rz-border-width) solid var(--rz-base-300);
}

@media (prefers-color-scheme: dark) {
    :root {
        --vx-border: var(--rz-base-500);
        --vx-danger: #f2938c;
        --vx-danger-bg: #3a1f1d;
        --vx-success: #7ed09a;
        --vx-success-bg: #1c3325;
        --vx-warning: #e8b563;
        --vx-warning-bg: #3a2e18;
    }
}

/* Explicit theme choice: the vx-dark class (or its absence) on the app
   wrapper overrides the OS fallback for the vx-only tokens; color-scheme
   keeps native form controls and scrollbars in sync (ADR-008). */
.vx-app {
    color-scheme: light;
    --vx-border: var(--rz-base-300);
    --vx-danger: #b3261e;
    --vx-danger-bg: #fdecea;
    --vx-success: #1e7d3c;
    --vx-success-bg: #e8f5ec;
    --vx-warning: #7a4f00;
    --vx-warning-bg: #fae7c4;
}

.vx-app.vx-dark {
    color-scheme: dark;
    --vx-border: var(--rz-base-500);
    --vx-danger: #f2938c;
    --vx-danger-bg: #3a1f1d;
    --vx-success: #7ed09a;
    --vx-success-bg: #1c3325;
    --vx-warning: #e8b563;
    --vx-warning-bg: #3a2e18;
}

/* No stored choice yet: follow the OS color scheme (ADR-008 revision). */
@media (prefers-color-scheme: dark) {
    .vx-app:not(.vx-explicit) {
        color-scheme: dark;
        --vx-border: var(--rz-base-500);
        --vx-danger: #f2938c;
        --vx-danger-bg: #3a1f1d;
        --vx-success: #7ed09a;
        --vx-success-bg: #1c3325;
        --vx-warning: #e8b563;
        --vx-warning-bg: #3a2e18;
    }
}

* {
    box-sizing: border-box;
}

html, body {
    margin: 0;
    font-family: "Segoe UI", system-ui, -apple-system, sans-serif;
}

.vx-app {
    min-height: 100vh;
    background: var(--vx-bg);
    color: var(--vx-text);
}

/* Config-driven tenant logo (D-004): sizing is structural and stays
   neutral here; tenant-specific treatment (e.g. tinting a white asset on
   light surfaces) lives in the tenant stylesheet. */
.vx-brand-logo {
    display: block;
    height: 1.75rem;
    width: auto;
}

.vx-auth-brand-logo {
    display: block;
    height: 2.5rem;
    width: auto;
    margin-inline: auto;
}

/* Dual-variant logo (D-004): when the tenant configures a dark variant,
   exactly one of the pair is visible per effective scheme — the html
   scheme class pins an explicit choice, otherwise the OS decides (same
   contract as the tenant palette, see App.razor). */
.vx-logo-dark {
    display: none;
}

:root.vx-scheme-dark .vx-logo-light {
    display: none;
}

:root.vx-scheme-dark .vx-logo-dark {
    display: block;
}

@media (prefers-color-scheme: dark) {
    :root:not(.vx-scheme-light) .vx-logo-light {
        display: none;
    }

    :root:not(.vx-scheme-light) .vx-logo-dark {
        display: block;
    }
}

/* Platform brand line (D-007) — deliberately quiet: platform identity,
   never tenant-themed beyond the muted text token. In MainLayout it lives
   in a slim RadzenFooter outside the content area; on the auth screen it
   sits below the card. */
.vx-footer {
    padding: 0.375rem 1rem;
    height: auto;
}

.vx-powered {
    text-align: center;
    font-size: 0.75rem;
    color: var(--vx-muted);
    opacity: 0.7;
}

.vx-auth-shell .vx-auth-footer {
    margin-top: 2rem;
    display: flex;
    flex-direction: column;
    gap: 0.5rem;
}

/* Legal links (D-041), shared by the app/portal footer (MainLayout) and the
   login footer (AuthLayout) — quiet like the powered-by line above/below it. */
.vx-footer-links {
    display: flex;
    justify-content: center;
    gap: 1rem;
    font-size: 0.75rem;
}

.vx-footer-links a {
    color: var(--vx-muted);
}

/* Tenant-authored legal content (D-041): a prose column, capped narrower
   than the page's own 72rem measure (issue #78's rule) for readability. */
.vx-legal-content {
    max-width: 60ch;
}

h1 { font-size: 1.5rem; }
h2 { font-size: 1.15rem; }

h1:focus {
    outline: none;
}

a {
    color: var(--vx-primary);
}

code {
    word-break: break-all;
}


/* Radzen mounts dialogs and side sheets at the app root, outside every
   component's scope — global is the only place these can live (issue #86).

   Bottom sheets (D-045 responsive dialogs) default to ~30% of the viewport,
   which clipped the confirm button of the submit-offer flow (issue #55).
   Size to content instead, capped so the page stays visible behind it. */
.rz-dialog-side.rz-dialog-side-position-bottom {
    height: auto;
    max-height: 88vh;
}

/* The LV assistant in Radzen's side panel (issue 805, opened by LvEditor from the
   right edge, no mask). Below, three rules make the panel one flush, full-height
   surface whose only child, the assistant, takes all of it. */

/* radzen: SideDialogOptions Width, Position, ShowMask, ShowTitle, ShowClose, CssClass, ContentCssClass — none makes the panel a flush column, drops the rounded corners or sets `top`; the right position sets only `right: 0` and `height: 100%`, so the fixed panel sat at its static position below the page */
.rz-dialog-side.vx-lv-assistant-side {
    top: 0;
    display: flex;
    flex-direction: column;
    border-radius: 0;
    overflow: hidden;
}

/* radzen: SideDialogOptions ContentCssClass — it only adds a class, and `.rz-dialog-side-content` sizes to its content instead of filling the panel's height */
.rz-dialog-side.vx-lv-assistant-side > .rz-dialog-side-content {
    flex: 1 1 auto;
    min-height: 0;
    display: flex;
    flex-direction: column;
}

/* radzen: SideDialogOptions Height, ContentCssClass — no parameter reaches the chat inside the content, which has to take the remaining height */
.rz-dialog-side.vx-lv-assistant-side .vx-chat {
    flex: 1 1 auto;
    height: auto;
}

/* A modal opened on top of a bottom sheet (nested client dialog, issue 758)
   shares the sheet's z-index and Radzen renders the sheet later in the DOM, so
   the sheet would cover it and swallow its clicks. The centred modal goes one
   layer above. */
.rz-dialog-wrapper {
    z-index: calc(var(--rz-dialog-zindex) + 1);
}

/* Rows that navigate on click must read as clickable (issue #55). */
.vx-grid-clickable .rz-data-row {
    cursor: pointer;
}

/* A page with a sticky bottom bar closes flush with the scroll container: the
   sticky inset is measured inside the padding, so the bottom padding goes
   (bidder offer view, issue 623). */
.rz-body:has([data-vx-offer-bar]) {
    padding-bottom: 0;
}

.vx-container {
    max-width: 72rem;
    margin: 0 auto;
}

/* Width strategy (#78): table-shaped pages opt in and use the full shell
   width; form/prose pages keep the 72rem measure. Long read-only prose
   inside a wide page caps its own column (max-width in ch), not the page. */
.vx-container-wide {
    max-width: none;
}

.vx-narrow {
    max-width: 28rem;
}

.vx-muted {
    color: var(--vx-muted);
}

/* Shared primitives — deliberately global: each of these is used by three or
   more components, so a scoped copy would mean duplicating it per component
   (docs/dev/07). Anything used by exactly one component belongs in that
   component's own stylesheet instead. */

/* Cards, forms, tables */

.vx-card {
    background: var(--vx-surface);
    border: 1px solid var(--vx-border);
    border-radius: 0.5rem;
    padding: 1rem 1.25rem;
    margin: 1rem 0;
}

.vx-form {
    display: flex;
    flex-direction: column;
    gap: 0.75rem;
    margin-top: 0.75rem;
}

.vx-form-row {
    display: flex;
    gap: 0.75rem;
    flex-direction: row;
    align-items: flex-end;
    flex-wrap: wrap;
}

/* Phones (issue #55): the row never wrapped, because every field carries
   `width: 100%` on a flex item that may shrink — four fields shared a
   375px viewport at ~60px each ("B", "V" …). Stack them instead. */
@media (max-width: 640px) {
    .vx-form-row {
        flex-direction: column;
        align-items: stretch;
    }

    .vx-form-row > * {
        width: 100%;
    }
}

.vx-form-actions {
    display: flex;
    align-items: flex-end;
}

.vx-label {
    display: block;
    font-size: 0.85rem;
    color: var(--vx-muted);
    margin-bottom: 0.25rem;
}

.vx-input {
    padding: 0.5rem 0.6rem;
    border: 1px solid var(--vx-border);
    border-radius: 0.375rem;
    background: var(--vx-surface);
    color: var(--vx-text);
    font: inherit;
    min-width: 12rem;
}

.vx-input-compact {
    min-width: 8rem;
    padding: 0.25rem 0.4rem;
}

.vx-btn {
    padding: 0.5rem 0.9rem;
    border-radius: 0.375rem;
    border: 1px solid transparent;
    font: inherit;
    cursor: pointer;
}

.vx-btn:disabled {
    opacity: 0.5;
    cursor: default;
}

.vx-btn-primary {
    background: var(--vx-primary);
    color: var(--vx-primary-contrast);
}

.vx-btn-ghost {
    background: transparent;
    border-color: var(--vx-border);
    color: var(--vx-text);
}

.vx-login-code {
    margin: 0;
    font-size: 2rem;
    font-weight: 600;
    letter-spacing: 0.4em;
    font-variant-numeric: tabular-nums;
    color: var(--vx-text);
}

.vx-inline-form {
    display: inline;
}

.vx-table {
    width: 100%;
    border-collapse: collapse;
    margin-top: 0.5rem;
}

.vx-table th,
.vx-table td {
    text-align: left;
    padding: 0.5rem 0.6rem;
    border-bottom: 1px solid var(--vx-border);
    vertical-align: middle;
}

.vx-table th {
    color: var(--vx-muted);
    font-weight: 600;
    font-size: 0.85rem;
}

/* Modifier for a RadzenTable used as a simple table (docs/dev/07, rule 13).
   RadzenTable brings data-grid styling: a fixed layout, nowrap/ellipsis cells and
   a span.rz-cell-data that sets its own colour and font. Undo what hides content
   or defeats the cell classes; the class lands on the .rz-datatable wrapper. */
/* The class lands on the .rz-datatable wrapper, which clips (overflow: hidden)
   and holds an inner .rz-data-grid-data scroller. The wrapper itself must be the
   one scroller: its children let the table overflow into it instead of
   clipping it at the wrapper's width. Doubled class: beats .rz-datatable. */
.vx-radzen-table.vx-radzen-table {
    overflow-x: auto;
    overflow-y: visible;
}

.vx-radzen-table.vx-radzen-table > * {
    overflow: visible;
    min-width: 0;
}

.vx-radzen-table table {
    table-layout: auto;
    width: 100%;
}

.vx-radzen-table td {
    padding: 0.5rem 0.6rem;
    vertical-align: middle;
}

/* RadzenTableHeaderCell sets its padding inline. */
.vx-radzen-table th {
    padding: 0.5rem 0.6rem !important;
    vertical-align: middle;
}

.vx-radzen-table td .rz-cell-data {
    color: inherit;
    font: inherit;
    display: inline;
    overflow: visible;
    text-overflow: clip;
    white-space: normal;
}

.vx-row-inactive td,
.vx-responsive-list-card.vx-row-inactive,
.vx-responsive-list-card.vx-row-inactive a {
    color: var(--vx-muted);
}

.vx-actions {
    display: flex;
    gap: 0.5rem;
    flex-wrap: wrap;
}

/* Suggested-category chips below the category text box (tender documents card). */
.vx-doc-category .vx-actions {
    margin-top: 0.5rem;
}

/* Action buttons inside table rows: the flex container must be an inner
   div — display:flex directly on a td pulls the cell out of the table's
   row model, so its bottom border no longer aligns with the row's. */
.vx-actions-cell {
    width: 1%;
    white-space: nowrap;
}

.vx-actions-cell .vx-actions {
    flex-wrap: nowrap;
}

/* Coarse-pointer touch targets for icon-only row/toolbar actions (issue #76,
   viewport audit #55 finding M-03): `--rz-button-size-sm` is 28px — below
   every touch-target guideline (Apple HIG 44px, Material 48px) — and the LV
   position row packs four of them ~8px apart, which makes mis-taps the
   normal case on a phone. `pointer: coarse`, not a width breakpoint: a
   touch-first tablet/laptop above the mobile breakpoint has the same
   problem, and this must leave the fine-pointer desktop mouse density
   (docs/dev/07 rule 9) untouched. Radzen adds `.rz-button-icon-only`
   automatically whenever a button has no Text, so this reaches exactly the
   icon-only buttons with no markup change — scoped to `.vx-actions` (this
   primitive, not every button on the page) so a future icon-only action
   gets the same target for free just by living in a `.vx-actions` row.
   Padding grows symmetrically instead of forcing min-height/min-width,
   which would fight the icon's existing center-via-padding layout — same
   mechanism Radzen already uses for the 28px case, just bigger. */
@media (pointer: coarse) {
    .vx-actions .rz-button-sm.rz-button-icon-only {
        padding: 0.875rem;
        min-width: 44px;
        min-height: 44px;
    }

    .vx-actions {
        gap: 0.75rem;
    }
}

/* Page-level primitives shared by tenant and portal pages (page head,
   section head) plus the small utilities several components reach for. The
   LV editor's own layout moved to LvEditor.razor.css (issue #86). */

.vx-page-head {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 1rem;
    flex-wrap: wrap;
    margin-bottom: 1rem;
}

.vx-page-head h1 {
    margin: 0;
}

.vx-section-head {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 1rem;
    flex-wrap: wrap;
}

.vx-section-head h2 {
    margin: 0;
}

.vx-table-scroll {
    overflow-x: auto;
}

.vx-badge-gap {
    margin-left: 0.4rem;
}

.vx-checkbox-label {
    margin-left: 0.4rem;
}

.vx-ai-busy {
    display: flex;
    flex-direction: column;
    align-items: center;
    gap: 1rem;
    padding: 2rem 1rem;
    text-align: center;
}

.vx-ai-preview {
    max-height: 50vh;
    overflow-y: auto;
}

/* Fill-height dialog frame (issue #162 owner round). A desktop dialog opened
   with `cssClass: "vx-dialog-fill"` takes the viewport height minus a margin
   (the page behind stays visible), and its Radzen content area stops
   scrolling: the height is handed down to the component, which owns the
   single scroll region while its own header/footer rows stay pinned — the
   fix for the double-scroll (dialog content *and* an inner list). Lives here
   because it styles the Radzen dialog frame, which no component scope can
   reach (ADR-014); the mobile bottom sheet is unaffected (sizes to content,
   issue #55). */
.rz-dialog.vx-dialog-fill {
    display: flex;
    flex-direction: column;
    height: calc(100vh - 4rem);
    max-height: calc(100vh - 4rem);
}

.rz-dialog.vx-dialog-fill .rz-dialog-content {
    flex: 1 1 auto;
    display: flex;
    flex-direction: column;
    min-height: 0;
    overflow: hidden;
}

.vx-label-row {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 0.5rem;
}

.vx-label-row .vx-label {
    margin-bottom: 0;
}

/* Blazor's own DOM: validation classes and the error UI are rendered by the
   framework, not by any component of ours, so no scoped file can reach them
   (issue #86). */

/* Blazor plumbing */

.valid.modified:not([type=checkbox]) {
    outline: 1px solid var(--vx-success);
}

.invalid {
    outline: 1px solid var(--vx-danger);
}

.validation-message {
    color: var(--vx-danger);
}

#blazor-error-ui {
    display: none;
    position: fixed;
    bottom: 0;
    left: 0;
    right: 0;
    background: var(--vx-danger);
    color: #ffffff;
    padding: 0.75rem 1.25rem;
    z-index: 1000;
}

#blazor-error-ui .reload {
    color: #ffffff;
}

#blazor-error-ui .dismiss {
    cursor: pointer;
    float: right;
}

/* ALTCHA widget (issue #495, D-005): every colour comes from the vx tokens, so the
   widget follows the light/dark theme with the rest of the page. The widget's own
   defaults use light-dark() and would follow only the OS scheme, not the explicit
   theme choice. Error and success follow one pairing: the strong token as the frame, the
   light token as the text on it. Custom properties inherit into the widget's shadow root. */
altcha-widget {
    --altcha-color-base: var(--vx-surface);
    --altcha-color-base-content: var(--vx-text);
    --altcha-color-neutral: var(--vx-border);
    --altcha-color-neutral-content: var(--vx-muted);
    --altcha-color-primary: var(--vx-primary);
    --altcha-color-primary-content: var(--vx-primary-contrast);
    --altcha-color-error: var(--vx-danger);
    --altcha-color-error-content: var(--vx-danger-bg);
    --altcha-color-success: var(--vx-success);
    --altcha-color-success-content: var(--vx-success-bg);
    --altcha-checkbox-border-color: var(--vx-border);
    --altcha-max-width: 100%;
    display: block;
}

/* Focus mode (issues 635, 765): RadzenBody carries an identity transform (sidebar
   animation), which makes it the containing block of position: fixed descendants, so
   a fullscreen frame covered only the body, not the viewport (measured 2026-10-31:
   card at x 312 / y 66 under the header and beside the sidebar). Drop the transform
   only while a frame is fullscreen, and lock the body's own scrolling so the page
   behind stays put (FocusFrame.razor.css styles the frame itself). The layer derives from
   Radzen's dialog z-index, so a theme that moves it cannot put the frame above its dialogs. */
:root {
    --vx-focus-layer: calc(var(--rz-dialog-zindex) + 99);
}

.rz-body:has(.vx-focus-frame-active) {
    transform: none;
    z-index: var(--vx-focus-layer);
    overflow: hidden;
}

/* What opens on top of the raised body while a frame is fullscreen: dialogs (Radzen mounts
   them at the app root; the wrapper holds the dialog and its mask, so only the wrapper is
   raised, the mask keeps its place below the dialog), bottom sheets (a dialog below 769 px),
   notifications and the error bar. The wrapper stays one layer above the sheet: a modal
   opened on a sheet must cover it (issue 758). */
body:has(.vx-focus-frame-active) .rz-dialog-side {
    z-index: calc(var(--vx-focus-layer) + 1);
}

body:has(.vx-focus-frame-active) .rz-dialog-wrapper {
    z-index: calc(var(--vx-focus-layer) + 2);
}

body:has(.vx-focus-frame-active) .rz-notification,
body:has(.vx-focus-frame-active) #blazor-error-ui {
    z-index: calc(var(--vx-focus-layer) + 3);
}
