@nldd/design-system 0.8.85 → 0.8.86

package/dist/types/vue.d.ts

@@ -583,7 +583,7 @@ declare module 'vue' {
 	};
 
 	type NLDDCollectionProps = {
-		/** Layout mode: 'grid' | 'stack' | 'horizontal-scroll' (default: 'grid') */
+		/** Layout mode: 'grid' | 'stack' | 'lanes' | 'horizontal-scroll' (default: 'grid') */
 		'layout'?: NLDDCollection['layout'];
 		/** Show load-more button in grid/stack (default: false) */
 		'show-load-more'?: NLDDCollection['showLoadMore'];
@@ -597,12 +597,24 @@ declare module 'vue' {
 		'lazy-load'?: NLDDCollection['lazyLoad'];
 		/** Automatically load more items when the button becomes visible */
 		'lazyLoad'?: NLDDCollection['lazyLoad'];
-		/** Preferred width for each item (e.g. '280px', '20rem'). In grid layout used as the minimum column width (columns will be at least this wide; 1fr if container allows more). In horizontal scroll used as flex-basis. Never forces horizontal overflow — the value is clamped to container width. */
+		/** Preferred width for each item (e.g. '280px', '20rem'). In grid and lanes layouts used as the minimum column width (columns will be at least this wide; 1fr if container allows more). In horizontal scroll used as flex-basis. Never forces horizontal overflow — the value is clamped to container width. */
 		'item-width'?: NLDDCollection['itemWidth'];
-		/** Preferred width for each item (e.g. '280px', '20rem'). In grid layout used as the minimum column width (columns will be at least this wide; 1fr if container allows more). In horizontal scroll used as flex-basis. Never forces horizontal overflow — the value is clamped to container width. */
+		/** Preferred width for each item (e.g. '280px', '20rem'). In grid and lanes layouts used as the minimum column width (columns will be at least this wide; 1fr if container allows more). In horizontal scroll used as flex-basis. Never forces horizontal overflow — the value is clamped to container width. */
 		'itemWidth'?: NLDDCollection['itemWidth'];
-		/** Custom gap between items (any CSS length, e.g. '8px'). Overrides the responsive default at every breakpoint; unset keeps the default. */
+		/** Gap between items, as a step of the spacing scale ('0', '2', '4', '6', '8', '10', '12', '16', '20', '24', '28', '32', '40', '44', '48', '56', '64', '80', '96'). Overrides the responsive default at every breakpoint; unset keeps the default. */
 		'gap'?: NLDDCollection['gap'];
+		/** Gap at sm, overriding `gap` there */
+		'sm-gap'?: NLDDCollection['smGap'];
+		/** Gap at sm, overriding `gap` there */
+		'smGap'?: NLDDCollection['smGap'];
+		/** Gap at md, overriding `gap` there */
+		'md-gap'?: NLDDCollection['mdGap'];
+		/** Gap at md, overriding `gap` there */
+		'mdGap'?: NLDDCollection['mdGap'];
+		/** Gap at lg, overriding `gap` there */
+		'lg-gap'?: NLDDCollection['lgGap'];
+		/** Gap at lg, overriding `gap` there */
+		'lgGap'?: NLDDCollection['lgGap'];
 		/** Translation overrides; unset keys fall back to Dutch. Available keys: 'components.collection.previous-action', 'components.collection.next-action', 'components.collection.load-more-action' */
 		'translations'?: NLDDCollection['translations'];
 		/** When the load-more button is clicked */
@@ -1529,7 +1541,9 @@ declare module 'vue' {
 		'button'?: NLDDListItem['button'];
 		/** Makes the whole row a `role="checkbox"` control. Wins over `button`, loses to `href`. */
 		'checkbox'?: NLDDListItem['checkbox'];
-		/** Checked state of a `checkbox` row; the item toggles it on activation */
+		/** Makes the whole row one radio of a group: the action becomes a `role="radio"` button carrying `aria-checked`, and activation sets `checked` (never clears it) and fires `change`. Put the rows in an `nldd-list type="radiogroup"`, which is what makes them a set. Wins over `button`, loses to `href` and `checkbox`. The arrow keys move focus without checking, where a native radio group and `nldd-radio-button-group` check as they go: a row can carry more than a label, so stepping past one should not commit it. */
+		'radio'?: NLDDListItem['radio'];
+		/** Checked state of a `checkbox` or `radio` row. A checkbox row toggles it on activation, a radio row only ever sets it */
 		'checked'?: NLDDListItem['checked'];
 		/** Switches the row's own control off: a `button` or `checkbox` row stops responding and dims, a `href` row gets `aria-disabled` and its click is blocked (a link cannot be disabled natively). A row without a control of its own has nothing to switch off, and segments carry their own `disabled`. The arrow keys skip a disabled row. */
 		'disabled'?: NLDDListItem['disabled'];
@@ -1548,7 +1562,7 @@ declare module 'vue' {
 		'childRows'?: NLDDListItem['childRows'];
 		/** The branch this row hangs under, or undefined for a top-level row. */
 		'parentRow'?: NLDDListItem['parentRow'];
-		/** On a `checkbox` row after it toggles; detail: { checked: boolean } */
+		/** On a `checkbox` row after it toggles, and on a `radio` row when it becomes checked; detail: { checked: boolean } */
 		'onChange'?: (event: CustomEvent) => void;
 	};
 
@@ -3622,11 +3636,11 @@ declare module 'vue' {
 		'nldd-code-editor': DefineComponent<NLDDCodeEditorProps>;
 		/** A read-only block of code/text built on a non-editable CodeMirror 6 view. Visually pairs with nldd-code-editor (same engine, same token palette). Whitespace is preserved; long lines scroll horizontally by default. Set `wrap` to break long lines onto the next visual line. Set `language` to one of the supported grammars (yaml, json, javascript, typescript, css, html, xml, bash, markdown, rust, gherkin, toml, sql, python) to highlight the content. Without `language` the content renders plain. Grammars are loaded lazily on first use, so a page that never sets `language` ships zero grammar code. Token colors are the `--components-code-viewer-token-*` custom properties (shared with the editor via the CodeMirror highlight style). Override them per-instance to swap the theme. */
 		'nldd-code-viewer': DefineComponent<NLDDCodeViewerProps>;
-		/** A container for displaying collections of items. Supports grid, stack, and horizontal scroll layouts. In grid and stack modes, items are paginated via a load-more button. In horizontal scroll, the prev/next controls and the edge fade appear only when the items overflow the container. With `lazy-load`, the next items are automatically loaded when the load-more button comes into view. */
+		/** A container for displaying collections of items. Supports grid, stack, lanes and horizontal scroll layouts. In grid and stack modes, items are paginated via a load-more button. In horizontal scroll, the prev/next controls and the edge fade appear only when the items overflow the container. With `lazy-load`, the next items are automatically loaded when the load-more button comes into view. */
 		'nldd-collection': DefineComponent<NLDDCollectionProps>;
 		/** A text input with autocomplete dropdown via nldd-menu. Add a slotted nldd-menu with nldd-menu-item children to provide options. The slotted nldd-menu keeps its default focus behavior (menu container receives focus) so that typing keeps focus on the input. The picker button moves focus to the menu explicitly on activation. Note: Only nldd-menu-item type="button" is supported. Radio and checkbox types are not supported in this context. */
 		'nldd-combo-box': DefineComponent<NLDDComboBoxProps>;
-		/** A simple layout primitive: pick a layout mode, give it a gap, optionally align contents, and add padding. Padding can be set for all sides, per axis (inline/block), or per individual side. Specificity: per side > per axis > all sides. Responsive padding and gap have sm/md/lg variants. Each variant emits both an @media (viewport) and @container (layout-container) query. When inside a layout-container the @container query wins; otherwise the @media query provides the viewport-based fallback. Layout modes: - `stack` (default): block items, stacked vertically. The "what you expect from DOM flow" mode. - `row`: flex row, no wrapping. Items shrink or overflow. - `wrap`: flex row, items wrap to new lines. - `grid`: CSS grid, auto-fit columns at min 280px wide. - `columns`: CSS multi-column flow, 280px minimum column width, items don't split across column breaks. Alignment maps to the layout's natural axis: - `stack`: vertical = main-axis (justify-content), horizontal = cross-axis (align-items) - `row` / `wrap`: horizontal = main-axis, vertical = cross-axis - `grid`: horizontal = justify-items, vertical = align-items (per cell) - `columns`: alignment props have no effect (CSS multicol doesn't expose alignment) Item order is set per-child via attributes on the slotted children themselves: `<child order="3">` for a fixed position, or `<child sm-order="N">` / `<child md-order="N">` / `<child lg-order="N">` to override per breakpoint (resolved against THIS container's width via @container queries, same scope as the responsive padding/gap). The container observes slot changes and child attribute mutations and bridges these to `--_slot-order` / `--_slot-sm-order` / etc. custom properties on each child's inline style, which the container's CSS then reads via `::slotted(*)` inside @container queries. Cascade: `sm-order` falls back to `order` falls back to `0` at sm (and analogously for md/lg). No-op for `layout="columns"` (CSS multicol has no per-item ordering hook). The `column-count` attribute (1-8) forces an exact column count for `layout="grid"` (overrides auto-fit) and `layout="columns"` (overrides the natural width-driven count). `sm-column-count` / `md-column-count` / `lg-column-count` resolve against this container's OWN width via an `@container (...)` query on the host — not against the viewport. That lets a footer in a narrow sidebar choose its own column count independent of the surrounding page width. `layout="lanes"` packs items into balanced columns using native CSS grid lanes where supported, falling back to CSS multicol (column-order) elsewhere. CSS-only, no JS. Honours `gap` on both axes and `column-count`. */
+		/** A simple layout primitive: pick a layout mode, give it a gap, optionally align contents, and add padding. Padding can be set for all sides, per axis (inline/block), or per individual side. Specificity: per side > per axis > all sides. Responsive padding and gap have sm/md/lg variants. Each variant emits both an @media (viewport) and @container (layout-container) query. When inside a layout-container the @container query wins; otherwise the @media query provides the viewport-based fallback. Layout modes: - `stack` (default): block items, stacked vertically. The "what you expect from DOM flow" mode. - `row`: flex row, no wrapping. Items shrink or overflow. - `wrap`: flex row, items wrap to new lines. - `grid`: CSS grid, auto-fit columns at min 280px wide. - `columns`: CSS multi-column flow, 280px minimum column width, items don't split across column breaks. Alignment maps to the layout's natural axis: - `stack`: vertical = main-axis (justify-content), horizontal = cross-axis (align-items) - `row` / `wrap`: horizontal = main-axis, vertical = cross-axis - `grid`: horizontal = justify-items, vertical = align-items (per cell) - `columns`: alignment props have no effect (CSS multicol doesn't expose alignment) Item order is set per-child via attributes on the slotted children themselves: `<child order="3">` for a fixed position, or `<child sm-order="N">` / `<child md-order="N">` / `<child lg-order="N">` to override per breakpoint (resolved against THIS container's width via @container queries, same scope as the responsive padding/gap). The container observes slot changes and child attribute mutations and bridges these to `--_slot-order` / `--_slot-sm-order` / etc. custom properties on each child's inline style, which the container's CSS then reads via `::slotted(*)` inside @container queries. Cascade: `sm-order` falls back to `order` falls back to `0` at sm (and analogously for md/lg). No-op for `layout="columns"` (CSS multicol has no per-item ordering hook). The `column-count` attribute (1-8) forces an exact column count for `layout="grid"` (overrides auto-fit) and `layout="columns"` (overrides the natural width-driven count). `sm-column-count` / `md-column-count` / `lg-column-count` resolve against this container's OWN width via an `@container (...)` query on the host — not against the viewport. That lets a footer in a narrow sidebar choose its own column count independent of the surrounding page width. `layout="lanes"` packs items into balanced columns using native CSS grid lanes where supported, falling back to CSS multicol (column-order) elsewhere. CSS-only, no JS. Honours `gap` on both axes and `column-count`. Note that nldd-collection's lanes falls back to its own grid rather than to multicol: that component pages, and multicol redistributes the whole set every time load-more adds to it. */
 		'nldd-container': DefineComponent<NLDDContainerProps>;
 		/** A text field for a date, with an optional calendar in a popover. The value is always ISO (yyyy-mm-dd); on screen it shows the Dutch notation (dd-mm-yyyy). Typing is not masked: input is accepted generously and normalized only when the field is left. Error messages belong to nldd-form-field, not here. This field reflects only `invalid` / `valid`, like nldd-text-field. */
 		'nldd-date-field': DefineComponent<NLDDDateFieldProps>;
@@ -3674,7 +3688,7 @@ declare module 'vue' {
 		'nldd-keyboard-shortcut': DefineComponent<NLDDKeyboardShortcutProps>;
 		/** Hyperlink component with two modes: 1. **Standalone (sized)**: set `size="xs"|"sm"|"md"|"lg"` for menus, action areas or overviews. Fixed text size, `display: inline-flex` with `gap` for icon spacing. 2. **Inline (inherit)**: leave `size` out or set `size="inherit"` explicitly. The link inherits `font-size`, `line-height` and `font-family` from its surroundings. Text wraps naturally across lines (`display: inline`). Icons work here too; the natural whitespace between icon and text provides the spacing. For links in CMS or markdown output, where the `<a>` arrives as HTML, `<nldd-rich-text>` with a raw `<a>` remains the route to take. */
 		'nldd-link': DefineComponent<NLDDLinkProps>;
-		/** A container for `nldd-list-item` elements. The `type` attribute switches the list's a11y role and behavior: - `list` (default) — `role="list"`, items `role="listitem"`. Reorderable allowed. - `tree` — `role="tree"`, items `role="treeitem"`. Branch rows put their child rows in their own `slot="children"`, which the item renders as a `role="group"`. Level, position and set size are NOT authored: the nesting represents the hierarchy, so assistive technology derives them. A branch row must carry `expanded`; the group is hidden while it is false. Visual indentation is the consumer's — repeat a spacer-cell per level. Comes with its own keyboard, see "Tree" below. - `navigation` — host `role="navigation"`, items with `selected` get `aria-current="page"` on their inner `<a>` or `<button>`. - `form` — rows that are not actions themselves: the controls inside them are. A row of a label and a field, a switch, a menu button, or a value you cannot change at all. Semantically the same as `list` (`role="list"`, `role="listitem"`), and everything visual is unchanged; what falls away is the keyboard of a list you walk through. No arrow navigation, so no promise of it either, and no tab stop on the row: Tab goes straight to the controls, in source order, the way it does in any form. Rows that ARE actions (`href`, `button`, `checkbox`, or a segment) contradict that and warn in development. SwiftUI draws the same line between `List` and `Form`, for the same reason. - `listbox` — an accessible, filterable listbox (combobox pattern). The list renders its OWN search input (`role="combobox"`) pinned above the options; `.list__items` becomes `role="listbox"` and items become `role="option"`. Focus stays in the input, the active option moves via `aria-activedescendant`, and filtering is consumer-managed via the `input` event (toggle `[hidden]` on items). See "Listbox" below. Selection state is consumer-managed: the list never mutates `selected` itself. A list you walk through answers to the arrow keys, and there is no attribute to switch that on. Whether the keys do something is not a property of one list: it is what a reader may assume about all of them, and a per-list setting made that unknowable from the outside. It follows the type, which you can see before you touch a key. - ArrowUp / ArrowDown — move focus between the rows there is something to do with. A row of nothing but text is skipped, because focus that leads nowhere is a dead end. - Home / End — the first / last of those rows. - Tab — the list is ONE tab stop, so Tab moves past it rather than through it. Within the current row Tab walks that row's own controls: a chevron beside a checkbox, a menu button at the end. The same controls in the other rows are held out of the tab order (`tabindex="-1"`, or `no-tab` on a design-system control that keeps its tab stop in its own shadow root), and so are this row's once focus leaves the list, so tabbing back in lands on the row again. - Escape — out of a control the row holds, back onto the row. One level up, where Shift+Tab is one step back. On the row itself the list claims nothing, so Escape carries on to whatever holds the list, and a control showing a menu keeps the first press for closing that menu. While focus sits in a control a row holds, the list stands down: those keys are the control's, and a list that took them anyway would pull focus out of a combo box or a text field mid-word. What the row IS — its own link, button or segments — keeps answering here. Arrows move focus only; selection stays consumer-managed. Three types answer differently, and all three say so on screen before you touch a key: a listbox runs its keyboard from its search field, a reorderable list moves rows with the arrows, and a form has no rows to move between at all. In `type="listbox"` the list owns a native `<input role="combobox">` (mirroring how `nldd-combo-box` wires an input to a slotted listbox). Keyboard, handled on the input so focus never leaves it: - ArrowDown / ArrowUp — move the active option among the VISIBLE (non-`[hidden]`) options (wrap around). - Home / End — first / last visible option. - Enter — activate the active option by triggering its inner action (a link navigates, a button fires the consumer's handler). Selection stays consumer-managed. - Escape — clear the search value (and refire `input`). On every active change the input's `aria-activedescendant` is set to the active option's id and the option is scrolled into view. The active option (`_highlighted` on the item, a highlight) is distinct from `selected`. Filtering is the consumer's job: listen to `input` (`{ detail: { value } }`) and toggle `[hidden]` on items; after the visible set changes the list resets the active option to the first visible one. `reorderable` and the roving arrow keys are ignored in listbox mode (listbox has its own keyboard). A tree adds to that keyboard, and counts the rows of an open branch as part of the order the arrows walk: - ArrowRight — opens a closed branch; on an open one it steps to its first child. - ArrowLeft — closes an open branch; on a leaf it steps out to the parent row. - Enter — follows the row: its own link or button, or on a segmented branch the first action that is not the chevron. A branch with only a chevron folds instead. - Space — open and close, the same as Right and Left. Only while focus sits on the row itself: a row that is its own control, and a segmented action you tabbed into, handle both keys themselves. Opening and closing runs through the row's own disclosure control — the segment marked `disclosure`, or the row itself when it is a button. The list activates that control rather than writing `expanded`, so the state keeps being set in one place: the consumer's handler. A row that is a link is never activated this way, since that would navigate away. The tree is one tab stop. Focus lands on the row itself when the row has no control of its own, because that is where `treeitem` sits and it makes assistive technology announce the row rather than a button inside it. Tab then walks the controls of THAT row (a chevron beside a checkbox, say) and leaves the list after the last one. A deliberate deviation: strictly speaking a row with several controls is a `treegrid`, not a `tree`. We keep the tree semantics — level and set size are what matters here, not rows and columns — and borrow the "Tab within the row" behavior from the grid pattern. Should a tree with real columns come up, that is when `treegrid` earns its own type. On reorder (type="list" + reorderable), the list dispatches `nldd-reorder` with `fromIndex` / `toIndex` and expects the consumer to mutate the DOM (or their data model that renders the DOM). Focus is restored to the moved item's drag handle via a single `requestAnimationFrame` — this assumes the consumer reorders **synchronously** in the event handler. Async renderers (React, Vue, …) that update the DOM on a later tick will miss the focus restore and should manage focus themselves after their render commits. */
+		/** A container for `nldd-list-item` elements. The `type` attribute switches the list's a11y role and behavior: - `list` (default) — `role="list"`, items `role="listitem"`. Reorderable allowed. - `radiogroup` — `role="radiogroup"`, for a set of `nldd-list-item radio` rows: one choice, laid out as rows so each option can carry a count or a second line. The rows step out of the accessibility tree themselves (`role="none"`), so the radios are the group's own children. The arrows move focus here and activation checks, rather than the selection following focus as it does in `nldd-radio-button-group`. - `tree` — `role="tree"`, items `role="treeitem"`. Branch rows put their child rows in their own `slot="children"`, which the item renders as a `role="group"`. Level, position and set size are NOT authored: the nesting represents the hierarchy, so assistive technology derives them. A branch row must carry `expanded`; the group is hidden while it is false. Visual indentation is the consumer's — repeat a spacer-cell per level. Comes with its own keyboard, see "Tree" below. - `navigation` — host `role="navigation"`, items with `selected` get `aria-current="page"` on their inner `<a>` or `<button>`. - `form` — rows that are not actions themselves: the controls inside them are. A row of a label and a field, a switch, a menu button, or a value you cannot change at all. Semantically the same as `list` (`role="list"`, `role="listitem"`), and everything visual is unchanged; what falls away is the keyboard of a list you walk through. No arrow navigation, so no promise of it either, and no tab stop on the row: Tab goes straight to the controls, in source order, the way it does in any form. Rows that ARE actions (`href`, `button`, `checkbox`, or a segment) contradict that and warn in development. SwiftUI draws the same line between `List` and `Form`, for the same reason. - `listbox` — an accessible, filterable listbox (combobox pattern). The list renders its OWN search input (`role="combobox"`) pinned above the options; `.list__items` becomes `role="listbox"` and items become `role="option"`. Focus stays in the input, the active option moves via `aria-activedescendant`, and filtering is consumer-managed via the `input` event (toggle `[hidden]` on items). See "Listbox" below. Selection state is consumer-managed: the list never mutates `selected` itself. A list you walk through answers to the arrow keys, and there is no attribute to switch that on. Whether the keys do something is not a property of one list: it is what a reader may assume about all of them, and a per-list setting made that unknowable from the outside. It follows the type, which you can see before you touch a key. - ArrowUp / ArrowDown — move focus between the rows there is something to do with. A row of nothing but text is skipped, because focus that leads nowhere is a dead end. - Home / End — the first / last of those rows. - Tab — the list is ONE tab stop, so Tab moves past it rather than through it. Within the current row Tab walks that row's own controls: a chevron beside a checkbox, a menu button at the end. The same controls in the other rows are held out of the tab order (`tabindex="-1"`, or `no-tab` on a design-system control that keeps its tab stop in its own shadow root), and so are this row's once focus leaves the list, so tabbing back in lands on the row again. - Escape — out of a control the row holds, back onto the row. One level up, where Shift+Tab is one step back. On the row itself the list claims nothing, so Escape carries on to whatever holds the list, and a control showing a menu keeps the first press for closing that menu. While focus sits in a control a row holds, the list stands down: those keys are the control's, and a list that took them anyway would pull focus out of a combo box or a text field mid-word. What the row IS — its own link, button or segments — keeps answering here. Arrows move focus only; selection stays consumer-managed. Three types answer differently, and all three say so on screen before you touch a key: a listbox runs its keyboard from its search field, a reorderable list moves rows with the arrows, and a form has no rows to move between at all. In `type="listbox"` the list owns a native `<input role="combobox">` (mirroring how `nldd-combo-box` wires an input to a slotted listbox). Keyboard, handled on the input so focus never leaves it: - ArrowDown / ArrowUp — move the active option among the VISIBLE (non-`[hidden]`) options (wrap around). - Home / End — first / last visible option. - Enter — activate the active option by triggering its inner action (a link navigates, a button fires the consumer's handler). Selection stays consumer-managed. - Escape — clear the search value (and refire `input`). On every active change the input's `aria-activedescendant` is set to the active option's id and the option is scrolled into view. The active option (`_highlighted` on the item, a highlight) is distinct from `selected`. Filtering is the consumer's job: listen to `input` (`{ detail: { value } }`) and toggle `[hidden]` on items; after the visible set changes the list resets the active option to the first visible one. `reorderable` and the roving arrow keys are ignored in listbox mode (listbox has its own keyboard). A tree adds to that keyboard, and counts the rows of an open branch as part of the order the arrows walk: - ArrowRight — opens a closed branch; on an open one it steps to its first child. - ArrowLeft — closes an open branch; on a leaf it steps out to the parent row. - Enter — follows the row: its own link or button, or on a segmented branch the first action that is not the chevron. A branch with only a chevron folds instead. - Space — open and close, the same as Right and Left. Only while focus sits on the row itself: a row that is its own control, and a segmented action you tabbed into, handle both keys themselves. Opening and closing runs through the row's own disclosure control — the segment marked `disclosure`, or the row itself when it is a button. The list activates that control rather than writing `expanded`, so the state keeps being set in one place: the consumer's handler. A row that is a link is never activated this way, since that would navigate away. The tree is one tab stop. Focus lands on the row itself when the row has no control of its own, because that is where `treeitem` sits and it makes assistive technology announce the row rather than a button inside it. Tab then walks the controls of THAT row (a chevron beside a checkbox, say) and leaves the list after the last one. A deliberate deviation: strictly speaking a row with several controls is a `treegrid`, not a `tree`. We keep the tree semantics — level and set size are what matters here, not rows and columns — and borrow the "Tab within the row" behavior from the grid pattern. Should a tree with real columns come up, that is when `treegrid` earns its own type. On reorder (type="list" + reorderable), the list dispatches `nldd-reorder` with `fromIndex` / `toIndex` and expects the consumer to mutate the DOM (or their data model that renders the DOM). Focus is restored to the moved item's drag handle via a single `requestAnimationFrame` — this assumes the consumer reorders **synchronously** in the event handler. Async renderers (React, Vue, …) that update the DOM on a later tick will miss the focus restore and should manage focus themselves after their render commits. */
 		'nldd-list': DefineComponent<NLDDListProps>;
 		/** A row within an `nldd-list`. Renders as a link when `href` is set, as a checkbox when `checkbox` is set, as a button when `button` is set, or as a plain container otherwise. All cells and segments share one flat slot, in source order. Two rules govern every row: 1. State fills always paint the WIDENED row geometry — the row box extended by the indicator inline inset on both sides — whether or not the row is interactive. Paint never differs between a selected plain row and a selected interactive row. 2. The widened strip belongs to the ROW, never to a segment. A row with any action (its own `href`/`button`/`checkbox`, or a slotted segment) pulls itself outward (`is-interactive` host class → negative inline margin) and pads the row block back by the same amount, so content stays on the grid. A row-wide action owns that padding itself, making the whole widened box one hit area; slotted segments stay in the grid, so their footprint is position-independent and tree columns line up at any depth. By default the divider starts at the row's first text or title cell, so the line lands on the words rather than on whatever leads up to them — an icon, an avatar, a checkbox, or the spacers a tree indents with. Rows of different shapes then still line their dividers up with each other, and a tree's dividers step inward with its indentation. Text inside an `nldd-list-item-segment` counts as the row's content, and the marker is that text cell rather than the action: the action carries its own inline padding, so its edge sits before the words. A row with no text or title cell keeps the full content width. Mark a cell with `divider-start` and/or `divider-end` to place it yourself instead — an explicit marker replaces the derived one entirely, so `divider-start` on the leading cell restores the full-width line. Multiple markers resolve as the union: first `divider-start` through last `divider-end`. A start past the last end is an authoring error — the item DEV-warns and falls back to the full content width. A branch row can disclose its children in two ways: a dedicated `nldd-list-item-segment[disclosure]` segment (only the chevron is clickable), or the row itself as the control (`button` + `expanded`, the whole row toggles). In the second case, mark the chevron's `nldd-icon-cell` with `disclosure` and the row turns it with `expanded` — the same affordance, without having to trade a clickable row for a turning chevron. `checkbox` makes the WHOLE row the control: the inner action becomes a `role="checkbox"` button carrying `aria-checked`, it toggles `checked` on activation and fires `change`. Slot a visual `nldd-checkbox` (or any glyph) before the text and mark it `aria-hidden` + non-focusable — the row already conveys role and state, and a second focusable control would double the tab stops. Do NOT nest a real `<input type="checkbox">` in the action: interactive content inside a `<button>` is invalid HTML and AT announces the button, not the checked state. A `<label>` variant is not offered for the same reason it cannot work — label-to-input association walks the DOM tree, and a slotted input is not a descendant of a label in the shadow root. When it renders as a link, `target` and `rel` are forwarded to the inner `<a>` (e.g. `target="_blank" rel="noopener noreferrer"`). With `target="_blank"` the item also injects a visually hidden "opens in new tab" announcement for assistive technology (WCAG 2.1 SC 3.2.2). The item synchronizes its ARIA with its parent `nldd-list`'s `type`: - `list` parent → `role="listitem"` - `navigation` parent → `role="listitem"` + `aria-current="page"` on the inner `<a>` / `<button>` when `selected` - `listbox` parent → `role="option"` + `aria-selected` reflecting `selected`. The list points its search input's `aria-activedescendant` at the active option via `_highlighted` (separate from `selected`). */
 		'nldd-list-item': DefineComponent<NLDDListItemProps>;
@@ -3705,7 +3719,7 @@ declare module 'vue' {
 		'nldd-one-half-one-half-section': DefineComponent<NLDDOneHalfOneHalfSectionProps>;
 		/** A section with a 1/3 sidebar on the left and 2/3 main content on the right. The columns wrap automatically when they become smaller than 280px. Padding and gap adjust via container queries. */
 		'nldd-one-third-two-thirds-section': DefineComponent<NLDDOneThirdTwoThirdsSectionProps>;
-		/** A page layout with optional sticky header and footer. Without sticky-header, the host is the scroll container and the header is in normal flow. With sticky-header, the header becomes absolute and .page__scroll takes over scrolling. A ResizeObserver on the header sets padding-top on the scroll wrapper (only when not scrolled). In root-scroll mode (--context-scroll-mode: root, derived upstream by nldd-app-view) the page stops owning a scroller: the document scrolls and the sticky header/footer become position:sticky layers offset by --context-layer-top/bottom. The mode is read on connect/resize and reflected to [data-scroll] so the CSS can branch. */
+		/** A page layout with optional sticky header and footer. Without sticky-header, the host is the scroll container and the header is in normal flow. With sticky-header, the header becomes absolute and .page__scroll takes over scrolling. A ResizeObserver on the header sets padding-top on the scroll wrapper (only when not scrolled). In root-scroll mode (--context-scroll-mode: root, derived upstream by nldd-app-view) the page stops owning a scroller: the document scrolls and the sticky header/footer stick against the document, offset by --context-inset-top/bottom. The mode is read on connect/resize and reflected to [data-scroll] so the CSS can branch. The page passes those insets on to its own content, with its sticky header and footer added: anything sticky inside (an nldd-sidebar-section, a sticky table head) reads --context-inset-top / --context-inset-bottom and clears every bar above and below it without being told a number. The heights are measured, because a top title bar shrinks as you scroll past its anchor. While the page owns the scroller, only its own bars count: the chrome above the page sits outside that scroller and does not push sticky content down. */
 		'nldd-page': DefineComponent<NLDDPageProps>;
 		/** The footer band at the bottom of a page. Hosts three optional rows in a fixed order: breadcrumbs (top), consumer-defined main content (middle), and a legal-bar (bottom). Dividers are drawn automatically between non-empty rows. Establishes its own container query (`page-footer-container`) so the responsive padding and gap react to the footer's own width, not the viewport. The host has `id="page-footer"` so a skip-link can target it directly. Use the sub-components `nldd-page-footer-legal-bar` and `nldd-page-footer-legal-bar-item` for the bottom row. */
 		'nldd-page-footer': DefineComponent<NLDDPageFooterProps>;

package/dist/utilities/spacing-scale.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The spacing scale, for the attributes that take a step of it.
+ *
+ * Spacing is rhythm: the point of a scale is that the space between things is
+ * the same handful of numbers on every page, so a value beside it is not a
+ * finer choice but a break in the pattern. These attributes take a step and
+ * nothing else, and this is the one place that turns a step into its token.
+ *
+ * Which also settles what the attribute means. `gap="16"` in a component that
+ * expected a CSS length wrote `--_gap: 16`, which is not one: the declaration
+ * fell away and the gap became zero with nothing said. Anything this cannot
+ * place is refused and named in dev instead, a length included — writing an
+ * unplaceable value is that same silent zero.
+ */
+/** Every step there is. `'0'` is a value, not the absence of one. */
+export declare const SPACING_SCALE: readonly ["0", "2", "4", "6", "8", "10", "12", "16", "20", "24", "28", "32", "40", "44", "48", "56", "64", "80", "96"];
+export type SpacingSize = (typeof SPACING_SCALE)[number];
+/**
+ * A step of the scale as the token it stands for.
+ *
+ * Returns null when there is nothing to set, so a caller can remove the
+ * property rather than write an empty one. `element` and `attribute` are only
+ * there to name the offender in a dev warning.
+ */
+export declare function spacingToValue(value: string | undefined, element: string, attribute: string): string | null;
+//# sourceMappingURL=spacing-scale.d.ts.map

package/dist/utilities/spacing-scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacing-scale.d.ts","sourceRoot":"","sources":["../../src/utilities/spacing-scale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,qEAAqE;AACrE,eAAO,MAAM,aAAa,wHAGhB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAgBzD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAiBf"}

package/dist/utilities/spacing-scale.js

@@ -0,0 +1,54 @@
+/**
+ * The spacing scale, for the attributes that take a step of it.
+ *
+ * Spacing is rhythm: the point of a scale is that the space between things is
+ * the same handful of numbers on every page, so a value beside it is not a
+ * finer choice but a break in the pattern. These attributes take a step and
+ * nothing else, and this is the one place that turns a step into its token.
+ *
+ * Which also settles what the attribute means. `gap="16"` in a component that
+ * expected a CSS length wrote `--_gap: 16`, which is not one: the declaration
+ * fell away and the gap became zero with nothing said. Anything this cannot
+ * place is refused and named in dev instead, a length included — writing an
+ * unplaceable value is that same silent zero.
+ */
+/** Every step there is. `'0'` is a value, not the absence of one. */
+export const SPACING_SCALE = [
+    '0', '2', '4', '6', '8', '10', '12', '16', '20', '24',
+    '28', '32', '40', '44', '48', '56', '64', '80', '96',
+];
+/** Anything that is not a bare number: a length, a percentage, a calc(). */
+function looksLikeLength(value) {
+    return /[a-z%()]/i.test(value.trim());
+}
+const warned = new Set();
+function warnOnce(element, attribute, message) {
+    const key = `${element}.${attribute}.${message}`;
+    if (warned.has(key))
+        return;
+    warned.add(key);
+    console.warn(`<${element}>: ${message}`);
+}
+/**
+ * A step of the scale as the token it stands for.
+ *
+ * Returns null when there is nothing to set, so a caller can remove the
+ * property rather than write an empty one. `element` and `attribute` are only
+ * there to name the offender in a dev warning.
+ */
+export function spacingToValue(value, element, attribute) {
+    if (value === undefined || value === '')
+        return null;
+    const step = String(value).trim();
+    if (SPACING_SCALE.includes(step)) {
+        return step === '0' ? '0' : `var(--primitives-space-${step})`;
+    }
+    if (import.meta.env?.DEV) {
+        const why = looksLikeLength(step)
+            ? 'is a CSS length, and these attributes take a step of the spacing scale so the rhythm holds across the page'
+            : 'is not a step of the spacing scale';
+        warnOnce(element, attribute, `${attribute}="${step}" ${why} (${SPACING_SCALE.join(', ')}). Nothing is written, so the default stands.`);
+    }
+    return null;
+}
+//# sourceMappingURL=spacing-scale.js.map

package/dist/utilities/spacing-scale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacing-scale.js","sourceRoot":"","sources":["../../src/utilities/spacing-scale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,qEAAqE;AACrE,MAAM,CAAC,MAAM,aAAa,GAAG;IAC5B,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IACrD,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;CAC3C,CAAC;AAIX,4EAA4E;AAC5E,SAAS,eAAe,CAAC,KAAa;IACrC,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;AAEjC,SAAS,QAAQ,CAAC,OAAe,EAAE,SAAiB,EAAE,OAAe;IACpE,MAAM,GAAG,GAAG,GAAG,OAAO,IAAI,SAAS,IAAI,OAAO,EAAE,CAAC;IACjD,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO;IAC5B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAChB,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,MAAM,OAAO,EAAE,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC7B,KAAyB,EACzB,OAAe,EACf,SAAiB;IAEjB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IACrD,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;IAClC,IAAK,aAAmC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACzD,OAAO,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,0BAA0B,IAAI,GAAG,CAAC;IAC/D,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC;YAChC,CAAC,CAAC,4GAA4G;YAC9G,CAAC,CAAC,oCAAoC,CAAC;QACxC,QAAQ,CACP,OAAO,EACP,SAAS,EACT,GAAG,SAAS,KAAK,IAAI,KAAK,GAAG,KAAK,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,+CAA+C,CACzG,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC"}

package/dist/utilities/visibility-mixin.d.ts

@@ -4,8 +4,8 @@ type Constructor<T = LitElement> = new (...args: any[]) => T;
  * Adds `hide-below` and `hide-above` attributes that toggle visibility based
  * on the inline-size of an ancestor CSS container.
  *
- * Without a `containerName` argument the generated rule is an anonymous
- * `@container (…)` query — it matches the nearest ancestor that declares
+ * Without a `containerName` argument the rule is an anonymous `@container (…)`
+ * query — it matches the nearest ancestor that declares
  * `container-type: inline-size`. Pass a name to target a specific container
  * (e.g. `'cells-container'` for cells inside `nldd-list`, which sets that
  * name inline on its host as a Safari shadow-DOM workaround).
@@ -14,12 +14,15 @@ type Constructor<T = LitElement> = new (...args: any[]) => T;
  * (e.g. '320px', '20rem'). Named values resolve to the standard breakpoint
  * thresholds: `hide-below` uses the breakpoint's lower bound (e.g.
  * `hide-below="lg"` hides in sm+md and shows in lg), `hide-above` its upper
- * bound; the open edges (below sm, above lg) are no-ops. Container queries can't
- * read CSS variables in their conditions, so the query rule is generated at
- * runtime and injected as a <style> element in the component's shadow root,
- * wrapped in `:host { @container <name>? (…) { display: none !important; } }`
- * (nested form — the flattened `@container { :host { … } }` is unreliable in
- * Safari).
+ * bound; the open edges (below sm, above lg) are no-ops.
+ *
+ * The named values are static CSS (see `visibility-mixin.styles.ts`), added
+ * through `finalizeStyles` so that a component's own `static styles` does not
+ * have to know about them. A custom length has no static form: the threshold
+ * is only known at runtime and a container query cannot read one from a CSS
+ * variable, so its rule is written at runtime into a constructable stylesheet
+ * the shadow root adopts. Neither path is an inline stylesheet, so no consumer
+ * needs `'unsafe-inline'` in its `style-src` for either.
  *
  * @mixin VisibilityMixin
  *

package/dist/utilities/visibility-mixin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visibility-mixin.d.ts","sourceRoot":"","sources":["../../src/utilities/visibility-mixin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAuB,MAAM,KAAK,CAAC;AAGtD,KAAK,WAAW,CAAC,CAAC,GAAG,UAAU,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AA0C7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,eAAe,CAAC,KAAK,SAAS,WAAW,CAAC,UAAU,CAAC,EACpE,IAAI,EAAE,KAAK,EACX,aAAa,CAAC,EAAE,MAAM,GAgDc,KAAK,GACxC,WAAW,CAAC,UAAU,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CACrE"}
+{"version":3,"file":"visibility-mixin.d.ts","sourceRoot":"","sources":["../../src/utilities/visibility-mixin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAoE,MAAM,KAAK,CAAC;AAGnG,KAAK,WAAW,CAAC,CAAC,GAAG,UAAU,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAuC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,eAAe,CAAC,KAAK,SAAS,WAAW,CAAC,UAAU,CAAC,EACpE,IAAI,EAAE,KAAK,EACX,aAAa,CAAC,EAAE,MAAM,GA0Ec,KAAK,GACxC,WAAW,CAAC,UAAU,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CACrE"}

package/dist/utilities/visibility-mixin.js

@@ -5,37 +5,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { property } from 'lit/decorators.js';
-import { breakpoints } from '../assets/styles/breakpoints.js';
-// Resolve a hide-below/hide-above value to a container-query threshold. A named
-// breakpoint (sm/md/lg) maps to the standard boundary; the open edges (below
-// sm, above lg) are no-ops (null); any other value passes through as a length.
-function resolveHideBelow(value) {
-    if (value === 'md')
-        return breakpoints.smMax; // hidden in sm
-    if (value === 'lg')
-        return breakpoints.mdMax; // hidden in sm + md
-    if (value === 'sm')
-        return null; // nothing below sm
-    return value;
-}
-function resolveHideAbove(value) {
-    if (value === 'sm')
-        return breakpoints.mdMin; // hidden in md + lg
-    if (value === 'md')
-        return breakpoints.lgMin; // hidden in lg
-    if (value === 'lg')
-        return null; // nothing above lg
+import { visibilityStyles } from './visibility-mixin.styles.js';
+const NAMED_BREAKPOINTS = new Set(['sm', 'md', 'lg']);
+// A named breakpoint is already covered by the static stylesheet. Only a custom
+// CSS length has to become a rule at runtime, because a container query cannot
+// read its threshold from a variable.
+function customThreshold(value) {
+    if (value === undefined || NAMED_BREAKPOINTS.has(value))
+        return null;
     return value;
 }
 /**
- * The open edges resolve to null, so the attribute is written but nothing ever
- * hides. That reads like a working value, and the name invites it: `hide-below`
+ * The open edges hide nothing, so the attribute is written but never applies.
+ * That reads like a working value, and the name invites it: `hide-below`
  * names the breakpoint you hide BELOW, so "hide it at sm" comes out as
  * `hide-below="md"` and `hide-below="sm"` does nothing at all. Say so once,
  * rather than let it look applied.
  */
-function warnNoOp(host, attribute, value, resolved, openEdge, edgeLabel) {
-    if (value !== openEdge || resolved !== null)
+function warnNoOp(host, attribute, value, openEdge, edgeLabel) {
+    if (value !== openEdge)
         return;
     console.warn(`[${host.localName}] ${attribute}="${openEdge}" never hides anything: there is no `
         + `breakpoint ${edgeLabel}. The value names the breakpoint you hide below, so the `
@@ -46,8 +34,8 @@ function warnNoOp(host, attribute, value, resolved, openEdge, edgeLabel) {
  * Adds `hide-below` and `hide-above` attributes that toggle visibility based
  * on the inline-size of an ancestor CSS container.
  *
- * Without a `containerName` argument the generated rule is an anonymous
- * `@container (…)` query — it matches the nearest ancestor that declares
+ * Without a `containerName` argument the rule is an anonymous `@container (…)`
+ * query — it matches the nearest ancestor that declares
  * `container-type: inline-size`. Pass a name to target a specific container
  * (e.g. `'cells-container'` for cells inside `nldd-list`, which sets that
  * name inline on its host as a Safari shadow-DOM workaround).
@@ -56,12 +44,15 @@ function warnNoOp(host, attribute, value, resolved, openEdge, edgeLabel) {
  * (e.g. '320px', '20rem'). Named values resolve to the standard breakpoint
  * thresholds: `hide-below` uses the breakpoint's lower bound (e.g.
  * `hide-below="lg"` hides in sm+md and shows in lg), `hide-above` its upper
- * bound; the open edges (below sm, above lg) are no-ops. Container queries can't
- * read CSS variables in their conditions, so the query rule is generated at
- * runtime and injected as a <style> element in the component's shadow root,
- * wrapped in `:host { @container <name>? (…) { display: none !important; } }`
- * (nested form — the flattened `@container { :host { … } }` is unreliable in
- * Safari).
+ * bound; the open edges (below sm, above lg) are no-ops.
+ *
+ * The named values are static CSS (see `visibility-mixin.styles.ts`), added
+ * through `finalizeStyles` so that a component's own `static styles` does not
+ * have to know about them. A custom length has no static form: the threshold
+ * is only known at runtime and a container query cannot read one from a CSS
+ * variable, so its rule is written at runtime into a constructable stylesheet
+ * the shadow root adopts. Neither path is an inline stylesheet, so no consumer
+ * needs `'unsafe-inline'` in its `style-src` for either.
  *
  * @mixin VisibilityMixin
  *
@@ -79,37 +70,59 @@ function warnNoOp(host, attribute, value, resolved, openEdge, edgeLabel) {
  */
 export function VisibilityMixin(Base, containerName) {
     class WithVisibility extends Base {
+        // Lit calls this from finalize() with whatever the most-derived class put
+        // in `static styles`, which is why the mixin can add its sheet here and a
+        // component's own `static styles =` never clobbers it.
+        //
+        // `Base` is the direct superclass, so this is `super.finalizeStyles` with
+        // the receiver kept; it is reached through the cast because a
+        // `Constructor<LitElement>` type parameter does not carry Lit's statics.
+        /** @internal */
+        static finalizeStyles(styles) {
+            const inherited = Base.finalizeStyles.call(this, styles);
+            return [...inherited, visibilityStyles(containerName)];
+        }
         updated(changed) {
             super.updated(changed);
             if (changed.has('hideBelow') || changed.has('hideAbove')) {
-                this._updateVisibilityStyle();
+                this._updateVisibilityRules();
             }
         }
-        _updateVisibilityStyle() {
-            if (!this.shadowRoot)
+        // The rule for a custom length is built here, into a stylesheet the shadow
+        // root adopts rather than a <style> element written into it. A CSP judges
+        // the element and leaves the CSSOM alone, so this path needs no
+        // 'unsafe-inline' either.
+        _updateVisibilityRules() {
+            const root = this.shadowRoot;
+            if (!root)
                 return;
             const containerPrefix = containerName ? `${containerName} ` : '';
             const rules = [];
-            const below = this.hideBelow ? resolveHideBelow(this.hideBelow) : null;
-            warnNoOp(this, 'hide-below', this.hideBelow, below, 'sm', 'below sm');
+            warnNoOp(this, 'hide-below', this.hideBelow, 'sm', 'below sm');
+            const below = customThreshold(this.hideBelow);
             if (below) {
                 rules.push(`:host { @container ${containerPrefix}(max-width: ${below}) { display: none !important; } }`);
             }
-            const above = this.hideAbove ? resolveHideAbove(this.hideAbove) : null;
-            warnNoOp(this, 'hide-above', this.hideAbove, above, 'lg', 'above lg');
+            warnNoOp(this, 'hide-above', this.hideAbove, 'lg', 'above lg');
+            const above = customThreshold(this.hideAbove);
             if (above) {
                 rules.push(`:host { @container ${containerPrefix}(min-width: ${above}) { display: none !important; } }`);
             }
             if (rules.length === 0) {
-                this._visibilityStyle?.remove();
-                this._visibilityStyle = undefined;
+                if (this._visibilitySheet) {
+                    const dropped = this._visibilitySheet;
+                    root.adoptedStyleSheets = Array.from(root.adoptedStyleSheets)
+                        .filter((sheet) => sheet !== dropped);
+                    this._visibilitySheet = undefined;
+                }
                 return;
             }
-            if (!this._visibilityStyle) {
-                this._visibilityStyle = document.createElement('style');
-                this.shadowRoot.appendChild(this._visibilityStyle);
+            if (!this._visibilitySheet) {
+                this._visibilitySheet = new CSSStyleSheet();
+                // Last, so it outranks the static sheet on a tie.
+                root.adoptedStyleSheets = [...root.adoptedStyleSheets, this._visibilitySheet];
             }
-            this._visibilityStyle.textContent = rules.join('\n');
+            this._visibilitySheet.replaceSync(rules.join('\n'));
         }
     }
     __decorate([

package/dist/utilities/visibility-mixin.js.map

@@ -1 +1 @@
-{"version":3,"file":"visibility-mixin.js","sourceRoot":"","sources":["../../src/utilities/visibility-mixin.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"visibility-mixin.js","sourceRoot":"","sources":["../../src/utilities/visibility-mixin.ts"],"names":[],"mappings":"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"}

package/dist/utilities/visibility-mixin.styles.d.ts

@@ -0,0 +1,14 @@
+import { type CSSResult } from 'lit';
+/**
+ * The `@container` rules for the named `hide-below` / `hide-above` values.
+ *
+ * Static, so they reach the shadow root through `adoptedStyleSheets` instead
+ * of a `<style>` element. That keeps consumers on a `style-src` without
+ * `'unsafe-inline'`; a custom CSS length has no static form and gets its rule
+ * from the mixin at runtime, into an adopted sheet of its own.
+ *
+ * The rules are nested (`:host { @container … }`) rather than flattened, because
+ * `@container { :host { … } }` is unreliable in Safari.
+ */
+export declare function visibilityStyles(containerName?: string): CSSResult;
+//# sourceMappingURL=visibility-mixin.styles.d.ts.map

package/dist/utilities/visibility-mixin.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility-mixin.styles.d.ts","sourceRoot":"","sources":["../../src/utilities/visibility-mixin.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,KAAK,CAAC;AAYrD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CA+BlE"}

package/dist/utilities/visibility-mixin.styles.js

@@ -0,0 +1,52 @@
+import { css, unsafeCSS } from 'lit';
+import { breakpoints } from '../assets/styles/breakpoints.js';
+const smMax = unsafeCSS(breakpoints.smMax);
+const mdMin = unsafeCSS(breakpoints.mdMin);
+const mdMax = unsafeCSS(breakpoints.mdMax);
+const lgMin = unsafeCSS(breakpoints.lgMin);
+// One sheet per container name, so every component passing the same name
+// shares a single constructable stylesheet instead of each adopting its own.
+const sheets = new Map();
+/**
+ * The `@container` rules for the named `hide-below` / `hide-above` values.
+ *
+ * Static, so they reach the shadow root through `adoptedStyleSheets` instead
+ * of a `<style>` element. That keeps consumers on a `style-src` without
+ * `'unsafe-inline'`; a custom CSS length has no static form and gets its rule
+ * from the mixin at runtime, into an adopted sheet of its own.
+ *
+ * The rules are nested (`:host { @container … }`) rather than flattened, because
+ * `@container { :host { … } }` is unreliable in Safari.
+ */
+export function visibilityStyles(containerName) {
+    const key = containerName ?? '';
+    const cached = sheets.get(key);
+    if (cached)
+        return cached;
+    const container = unsafeCSS(containerName ? `${containerName} ` : '');
+    const sheet = css `
+		/* # Hide below: the value names the breakpoint you hide BELOW */
+
+		:host([hide-below="md"]) {
+			@container ${container}(max-width: ${smMax}) { display: none !important; }
+		}
+
+		:host([hide-below="lg"]) {
+			@container ${container}(max-width: ${mdMax}) { display: none !important; }
+		}
+
+
+		/* # Hide above */
+
+		:host([hide-above="sm"]) {
+			@container ${container}(min-width: ${mdMin}) { display: none !important; }
+		}
+
+		:host([hide-above="md"]) {
+			@container ${container}(min-width: ${lgMin}) { display: none !important; }
+		}
+	`;
+    sheets.set(key, sheet);
+    return sheet;
+}
+//# sourceMappingURL=visibility-mixin.styles.js.map

package/dist/utilities/visibility-mixin.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility-mixin.styles.js","sourceRoot":"","sources":["../../src/utilities/visibility-mixin.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAkB,MAAM,KAAK,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAE3C,yEAAyE;AACzE,6EAA6E;AAC7E,MAAM,MAAM,GAAG,IAAI,GAAG,EAAqB,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,aAAsB;IACtD,MAAM,GAAG,GAAG,aAAa,IAAI,EAAE,CAAC;IAChC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC/B,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAE1B,MAAM,SAAS,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACtE,MAAM,KAAK,GAAG,GAAG,CAAA;;;;gBAIF,SAAS,eAAe,KAAK;;;;gBAI7B,SAAS,eAAe,KAAK;;;;;;;gBAO7B,SAAS,eAAe,KAAK;;;;gBAI7B,SAAS,eAAe,KAAK;;EAE3C,CAAC;IAEF,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACvB,OAAO,KAAK,CAAC;AACd,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nldd/design-system",
-  "version": "0.8.85",
+  "version": "0.8.86",
   "description": "Design System voor Nederlandse Digitale Dienst",
   "type": "module",
   "main": "dist/components/components.js",
@@ -455,6 +455,8 @@
     "./styles/variables": "./dist/css/variables.css",
     "./styles/tokens": "./dist/css/tokens.css",
     "./styles/fouc": "./dist/css/fouc.css",
+    "./favicon.svg": "./dist/favicon.svg",
+    "./touch-icon.png": "./dist/touch-icon.png",
     "./breakpoints": {
       "types": "./dist/assets/styles/breakpoints.d.ts",
       "default": "./dist/assets/styles/breakpoints.js"
@@ -478,8 +480,9 @@
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
-    "build": "npm run build:styles && npm run validate:styles && npm run validate:host-styles && npm run build:components",
+    "build": "npm run build:styles && npm run build:assets && npm run validate:styles && npm run validate:host-styles && npm run build:components",
     "build:styles": "rm -rf dist/css dist/fonts && mkdir -p dist/css dist/fonts && cp src/assets/styles/variables.css src/assets/styles/colors.generated.css src/assets/styles/rijksoverheid-fonts.css src/assets/styles/document-reset.css src/assets/styles/fouc.css dist/css/ && cp src/components/content/rich-text/rich-text.css src/components/forms/form/form.css src/components/forms/form-section/form-section.css dist/css/ && printf '@import \"./rijksoverheid-fonts.css\";\\n@import \"./variables.css\";\\n@import \"./document-reset.css\";\\n@import \"./rich-text.css\";\\n@import \"./form-section.css\";\\n@import \"./form.css\";\\n@import \"./fouc.css\";\\n' > dist/css/global.css && printf '@import \"./variables.css\";\\n@import \"./document-reset.css\";\\n@import \"./rich-text.css\";\\n@import \"./form-section.css\";\\n@import \"./form.css\";\\n@import \"./fouc.css\";\\n' > dist/css/global-system-font.css && printf '@import \"./rijksoverheid-fonts.css\";\\n@import \"./variables.css\";\\n' > dist/css/tokens.css && cp src/assets/fonts/*.woff2 dist/fonts/",
+    "build:assets": "mkdir -p dist && cp src/assets/favicon/favicon.svg src/assets/favicon/touch-icon.png dist/",
     "generate:colors": "node scripts/generate-colors.js",
     "generate:component-reference": "node scripts/generate-component-reference.js",
     "generate:cem": "cem analyze && npm run generate:vue-types",