@scalewing/react 1.31.0 → 1.33.0

package/dist/css/css-denomination-appearance.d.ts

@@ -0,0 +1,21 @@
+export declare const denominationGridFrames: readonly ["none", "table"];
+/**
+ * How a strip sits on the page: `none` (the default) is open rows on the
+ * page's own surface; `table` is a framed table: the surface inside a
+ * hairline with rounded corners, the heading row on the subtle fill, a
+ * rule between columns, and the counts at label size, centred under
+ * their heads.
+ */
+export type DenominationGridFrame = (typeof denominationGridFrames)[number];
+export declare const denominationTotalEmphases: readonly ["default", "strong"];
+/**
+ * How the row totals read: `default` is data type in the row's tone (a
+ * neutral row's muted); `strong` is label type in bold, a neutral row's in
+ * the text color and a toned row's in its tone.
+ */
+export type DenominationTotalEmphasis = (typeof denominationTotalEmphases)[number];
+export declare const denominationFramedClass = "sw-denomination-framed";
+export declare const denominationScrollFramedClass = "sw-denomination-scroll-framed";
+export declare const denominationTotalsStrongClass = "sw-denomination-totals-strong";
+export declare function cssDenominationAppearanceClasses(): string;
+export declare function denominationAppearanceClassCatalog(): string[];

package/dist/css/css-denomination-appearance.js

@@ -0,0 +1,114 @@
+import { typographyVariants } from '@scalewing/tokens';
+import { breakpointQuery } from './breakpoints.js';
+const label = typographyVariants.label;
+export const denominationGridFrames = ['none', 'table'];
+export const denominationTotalEmphases = ['default', 'strong'];
+export const denominationFramedClass = 'sw-denomination-framed';
+export const denominationScrollFramedClass = 'sw-denomination-scroll-framed';
+export const denominationTotalsStrongClass = 'sw-denomination-totals-strong';
+const framed = `.sw-denomination-strip.${denominationFramedClass}`;
+const strong = `.${denominationTotalsStrongClass}`;
+/*
+ * A framed strip. The frame is the scroll region's border, so it stays put
+ * while a wide strip scrolls inside it and its shades still draw on the
+ * region's own shadow. The cells pad a space-3 step across (space-2 below
+ * md) and the body cells a space-4 step down, so a read-only row is about
+ * as tall as an entry row; the cell padding is zero-specificity past the
+ * frame class, so an entry cell keeps its own space-1 padding and, below
+ * md, the collapsed total column is collapsed again. The row labels pad
+ * the same step whatever their appearance. The pinned label sits on the
+ * surface at the same low specificity, so a quiet row's label keeps the
+ * subtle fill; the pinned corner takes the heading row's fill. The column
+ * rule is a border on every cell after a row's first, so forced colours
+ * keep it and RTL mirrors it; the collapsed total column draws none.
+ * Emitted after the grid's own rules, its label appearances and its
+ * narrow-screen padding, so it wins at every width.
+ */
+function frameRules() {
+    return `.${denominationScrollFramedClass} {
+  background: var(--sw-color-surface);
+  border: 1px solid var(--sw-color-border);
+  border-radius: var(--sw-radius-sm);
+  box-sizing: border-box;
+}
+
+${framed} :where(th, td) {
+  padding: var(--sw-space-4) var(--sw-space-3);
+}
+
+${framed} thead :where(th, td),
+${framed} thead .sw-denomination-corner:first-child {
+  background: var(--sw-color-subtle);
+  padding-block: var(--sw-space-2);
+}
+
+${framed} :is(th, td) + :is(th, td) {
+  border-inline-start: 1px solid var(--sw-color-border);
+}
+
+${framed} :where(.sw-denomination-label) {
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+  background: var(--sw-color-surface);
+}
+
+${framed} .sw-denomination-label {
+  padding-inline: var(--sw-space-3);
+}
+
+${framed} .sw-denomination-head:not(.sw-denomination-total-head),
+${framed} .sw-denomination-cell {
+  text-align: center;
+}
+
+${framed} .sw-denomination-cell {
+  font-size: ${label.fontSize}px;
+  letter-spacing: ${label.letterSpacing}px;
+  line-height: ${label.lineHeight}px;
+}
+
+@media ${breakpointQuery('below', 'md')} {
+  ${framed} :where(th, td),
+  ${framed} .sw-denomination-label { padding-inline: var(--sw-space-2); }
+  ${framed} .sw-denomination-total,
+  ${framed} .sw-denomination-total-head { border-inline-start: 0; padding: 0; }
+}
+
+@media (forced-colors: active) {
+  .${denominationScrollFramedClass},
+  ${framed} :is(th, td) + :is(th, td) { border-color: CanvasText; }
+}`;
+}
+/*
+ * Strong totals: label type in bold, a neutral row's in the text color
+ * (its tone is the muted color) and a toned row's left in its tone, under
+ * the label on a phone too. One class more specific than the plain
+ * labels' inline total, so a neutral row's total is the text color there.
+ */
+function totalRules() {
+    return `${strong} .sw-denomination-total {
+  font-size: ${label.fontSize}px;
+  font-weight: 700;
+  letter-spacing: ${label.letterSpacing}px;
+  line-height: ${label.lineHeight}px;
+}
+
+${strong} .sw-denomination-total-inline { font-weight: 700; }
+
+${strong} .sw-denomination-row-neutral .sw-denomination-total,
+${strong} .sw-denomination-row-neutral .sw-denomination-total-inline {
+  color: var(--sw-color-text);
+}`;
+}
+export function cssDenominationAppearanceClasses() {
+    return `${frameRules()}
+
+${totalRules()}`;
+}
+export function denominationAppearanceClassCatalog() {
+    return [
+        denominationScrollFramedClass,
+        denominationFramedClass,
+        denominationTotalsStrongClass,
+    ];
+}

package/dist/css/css-denomination-cell-tones.d.ts

@@ -1,4 +1,12 @@
 import { type BadgeTone } from './css-data.js';
+export declare const denominationCellToneAppearances: readonly ["text", "pill"];
+/**
+ * How a toned count shows its tone: `text` sets the count in the tone;
+ * `pill` sets it on a rounded tint of the tone in the tone's ink, the
+ * Notice's fill and words, in a strip's read-only counts.
+ */
+export type DenominationCellToneAppearance = (typeof denominationCellToneAppearances)[number];
+export declare const denominationCellTonesPillClass = "sw-denomination-cell-tones-pill";
 /**
  * The classes that tone one count: a marker that applies the shared rules and
  * the tone that sets their color. A strip cell (`td`) and a tile (`li`) take

package/dist/css/css-denomination-cell-tones.js

@@ -1,4 +1,7 @@
 import { badgeTones } from './css-data.js';
+import { toneTintFill, toneTintInk } from './tone-tint.js';
+export const denominationCellToneAppearances = ['text', 'pill'];
+export const denominationCellTonesPillClass = 'sw-denomination-cell-tones-pill';
 /**
  * The tones a single count can take. `neutral` is the cell's own look, so it
  * adds no class: a cell is toned only by a tone that says something.
@@ -21,11 +24,15 @@ export function denominationCellToneClassNames(tone) {
  * carries meaning alone: the consumer's words say why a count is toned.
  * Forced colors replace the tone with the system text color, and a toned
  * zero keeps the zero's GrayText there, so it does not read as a count.
+ * Under the `pill` appearance a strip's read-only count sits on a rounded
+ * tint of its tone in the tone's ink (the Notice's fill and words); forced
+ * colors outline the pill instead, so the mark survives without its fill.
  */
 export function cssDenominationCellToneClasses() {
     const toneRules = cellTones
-        .map((tone) => `.sw-denomination-cell-tone-${tone} { --sw-denomination-cell-tone: var(--sw-color-${tone}); }`)
+        .map((tone) => `.sw-denomination-cell-tone-${tone} { --sw-denomination-cell-tone: var(--sw-color-${tone}); --sw-denomination-cell-fill: ${toneTintFill(tone)}; --sw-denomination-cell-ink: ${toneTintInk(tone)}; }`)
         .join('\n');
+    const pill = `.${denominationCellTonesPillClass} .sw-denomination-cell-toned .sw-denomination-cell-value:not(:empty)`;
     return `${toneRules}
 
 .sw-denomination-grid .sw-denomination-cell.sw-denomination-cell-toned,
@@ -39,13 +46,25 @@ export function cssDenominationCellToneClasses() {
   box-shadow: inset 0 0 0 1px var(--sw-denomination-cell-tone);
 }
 
+/* A pill: the count on its tone's tint, in the tone's ink (a Notice's words: 4.5:1 on the tint unless the palette's own tone is under it). */
+${pill} {
+  background: var(--sw-denomination-cell-fill);
+  border-radius: var(--sw-radius-sm);
+  color: var(--sw-denomination-cell-ink);
+  display: inline-block;
+  padding: calc(var(--sw-space-1) / 2) var(--sw-space-2);
+}
+
 @media (forced-colors: active) {
   .sw-denomination-grid .sw-denomination-cell-zero.sw-denomination-cell-toned,
   .sw-denomination-grid .sw-denomination-cell-toned .sw-denomination-cell-zero { color: GrayText; }
+  ${pill} { color: inherit; outline: 1px solid CanvasText; }
 }`;
 }
 export function denominationCellToneClassCatalog() {
     return [
+        'sw-denomination-cell-value',
+        denominationCellTonesPillClass,
         'sw-denomination-cell-toned',
         ...cellTones.map((tone) => `sw-denomination-cell-tone-${tone}`),
     ];

package/dist/css/css-denomination-grid.js

@@ -1,6 +1,7 @@
 import { typographyVariants } from '@scalewing/tokens';
 import { breakpointQuery } from './breakpoints.js';
 import { badgeTones } from './css-data.js';
+import { cssDenominationAppearanceClasses, denominationAppearanceClassCatalog, } from './css-denomination-appearance.js';
 import { cssDenominationLabelClasses, denominationLabelClassCatalog, } from './css-denomination-label.js';
 import { cssDenominationAlignedClasses, denominationAlignedClassCatalog, } from './css-denomination-aligned.js';
 import { cssDenominationEntryClasses, denominationEntryClassCatalog, } from './css-denomination-entry.js';
@@ -257,6 +258,8 @@ ${cssDenominationAlignedClasses()}
 
 ${cssDenominationLabelClasses()}
 
+${cssDenominationAppearanceClasses()}
+
 @media (forced-colors: active) {
   .sw-denomination-label { border-inline-start-color: CanvasText; color: CanvasText; }
   .sw-denomination-strip .sw-denomination-label::before { background: CanvasText; forced-color-adjust: none; }
@@ -299,5 +302,6 @@ export function denominationGridClassCatalog() {
         ...denominationEntryClassCatalog(),
         ...denominationAlignedClassCatalog(),
         ...denominationLabelClassCatalog(),
+        ...denominationAppearanceClassCatalog(),
     ];
 }

package/dist/css/css-dialog-banded.d.ts

@@ -0,0 +1,11 @@
+export declare const dialogAppearances: readonly ["glass", "banded"];
+/**
+ * How the dialog's surface reads: `glass` (the default) is one frosted
+ * panel; `banded` is a solid surface whose title row and footer are bands
+ * across its full width, ruled off from the content by hairlines, with the
+ * close button on a quiet round fill.
+ */
+export type DialogAppearance = (typeof dialogAppearances)[number];
+export declare const dialogBandedClass = "sw-dialog-banded";
+export declare function cssDialogBandedClasses(): string;
+export declare function dialogBandedClassCatalog(): string[];

package/dist/css/css-dialog-banded.js

@@ -0,0 +1,84 @@
+import { breakpointQuery, breakpoints } from './breakpoints.js';
+import { dialogSheetClass } from './css-dialog.js';
+import { zIndex } from './stacking.js';
+import { quietFill } from './quiet-fill.js';
+export const dialogAppearances = ['glass', 'banded'];
+export const dialogBandedClass = 'sw-dialog-banded';
+const banded = `.${dialogBandedClass}`;
+/* The dialog's own padding, which a band steps past to reach its edges. */
+const bleed = 'calc(-1 * var(--sw-space-5))';
+/* A bottom sheet's side padding, which clears a wide safe area. */
+const sheetSide = (side) => `max(var(--sw-space-5), env(safe-area-inset-${side}, 0px))`;
+/*
+ * In a bottom sheet the dialog's side padding clears the safe areas, so
+ * the band steps past that padding instead of space-5, and pads itself
+ * the same, so its hairline still meets both edges.
+ */
+function sheetBandRules() {
+    return breakpoints
+        .map((breakpoint) => `@media ${breakpointQuery('below', breakpoint)} {
+  .${dialogSheetClass(breakpoint)}${banded} .sw-dialog-header {
+    margin-left: calc(-1 * ${sheetSide('left')});
+    margin-right: calc(-1 * ${sheetSide('right')});
+    padding-left: ${sheetSide('left')};
+    padding-right: ${sheetSide('right')};
+  }
+}`)
+        .join('\n\n');
+}
+/*
+ * A banded dialog: the solid surface (no blur) with the medium elevation in
+ * place of the glass border, so it reads as a sheet over the page. The
+ * title row bleeds to the top and side edges as a band, a space-4 step
+ * down and the dialog's space-5 across, over a hairline, and stays at the
+ * top while the content scrolls under it (the top-chrome layer, under any
+ * popup the content opens); the pinned footer is already such a band at
+ * the bottom. The close button sits on the muted 16 % fill as a circle
+ * inside the band's padding, in the text color, and keeps its square size
+ * and touch target; a hover darkens the fill where the pointer can hover.
+ * Forced colors keep the hairline and outline the dialog, since its shadow
+ * is not drawn there.
+ */
+export function cssDialogBandedClasses() {
+    return `${banded} {
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+  background: var(--sw-color-surface);
+  border-color: transparent;
+  box-shadow: var(--sw-elevation-md);
+}
+
+${banded} .sw-dialog-header {
+  align-items: center;
+  background: var(--sw-color-surface);
+  border-bottom: 1px solid var(--sw-color-border);
+  margin: ${bleed} ${bleed} 0;
+  padding: var(--sw-space-4) var(--sw-space-5);
+  position: sticky;
+  top: ${bleed};
+  ${zIndex('topChrome')}
+}
+
+${sheetBandRules()}
+
+${banded} .sw-button.sw-dialog-close {
+  background: ${quietFill};
+  border-radius: var(--sw-radius-pill);
+  color: var(--sw-color-text);
+  margin: 0;
+}
+
+@media (hover: hover) {
+  ${banded} .sw-button.sw-dialog-close:hover {
+    background: color-mix(in srgb, var(--sw-color-muted) 24%, transparent);
+  }
+}
+
+@media (forced-colors: active) {
+  ${banded} { border-color: CanvasText; }
+  ${banded} .sw-dialog-header { border-bottom-color: CanvasText; }
+}`;
+}
+export function dialogBandedClassCatalog() {
+    return [dialogBandedClass];
+}

package/dist/css/css-document.js

@@ -1,4 +1,5 @@
 import { typographyVariants } from '@scalewing/tokens';
+import { cssBoxLinkClasses } from './css-box-link.js';
 const body = typographyVariants.body;
 /** The native controls that take typed text: the canvas's text controls. */
 export const typedInputs = [
@@ -97,6 +98,8 @@ body {
   outline-offset: var(--sw-focus-ring-offset);
 }
 
+${cssBoxLinkClasses()}
+
 /*
  * A programmatic focus target (tabindex="-1": a notice, a card or a heading
  * that a script focuses after a save) takes the accent ring past the ring

package/dist/css/css-multi-select.js

@@ -1,6 +1,7 @@
 import { typographyVariants } from '@scalewing/tokens';
 import { chevronStroke } from './chevron.js';
 import { zIndex } from './stacking.js';
+import { quietFill } from './quiet-fill.js';
 const label = typographyVariants.label;
 const body = typographyVariants.body;
 /*
@@ -120,7 +121,7 @@ export function cssMultiSelectClasses() {
 }
 
 .sw-multi-select-option:hover {
-  background: color-mix(in srgb, var(--sw-color-muted) 16%, transparent);
+  background: ${quietFill};
 }
 
 .sw-multi-select-icon {

package/dist/css/css-nav-words.d.ts

@@ -0,0 +1,13 @@
+export declare const navAppearances: readonly ["default", "words"];
+/**
+ * How a Nav draws its destinations: `default` keeps each link or Button's
+ * own look; `words` sets every destination as plain words, the others in
+ * the muted color at medium weight and the current one (`aria-current`)
+ * in the text color at label weight, with no fill, visible border or
+ * underline. The words must be visible: a glyph-only destination keeps
+ * `default`.
+ */
+export type NavAppearance = (typeof navAppearances)[number];
+export declare const navWordsClass = "sw-nav-words";
+export declare function cssNavWordsClasses(): string;
+export declare function navWordsClassCatalog(): string[];

package/dist/css/css-nav-words.js

@@ -0,0 +1,51 @@
+import { typographyVariants } from '@scalewing/tokens';
+const label = typographyVariants.label;
+export const navAppearances = ['default', 'words'];
+export const navWordsClass = 'sw-nav-words';
+const words = `.sw-nav.${navWordsClass}`;
+const destinations = `:is(a, .sw-button)`;
+const current = `[aria-current]:not([aria-current='false'])`;
+/*
+ * Words-only destinations. A Button keeps its size, padding, touch target
+ * and focus ring; only its fill, border color and color go, so a primary
+ * or ghost Button in the Nav reads the same. Links lose the canvas's accent
+ * and underline, and take a transparent hairline border like a Button's.
+ * `:is()` counts as its most specific argument, so the selector is three
+ * classes (0,3,0): it outranks a Button's variant and the canvas's link
+ * rules. The current destination differs by color and weight, so the
+ * words must be visible: a glyph-only destination has no weight to change
+ * (keep `default` for those). Hover lifts the color only where the pointer
+ * hovers, and never on a disabled destination. Forced colors draw the
+ * current one's border in Highlight and underline its words, since color
+ * and weight may not show there.
+ */
+export function cssNavWordsClasses() {
+    return `${words} ${destinations} {
+  background: transparent;
+  border: 1px solid transparent;
+  color: var(--sw-color-muted);
+  font-size: ${label.fontSize}px;
+  font-weight: 500;
+  letter-spacing: ${label.letterSpacing}px;
+  line-height: ${label.lineHeight}px;
+  text-decoration: none;
+}
+
+@media (hover: hover) {
+  ${words} ${destinations}:hover:not(:disabled, [aria-disabled='true']) {
+    color: var(--sw-color-text);
+  }
+}
+
+${words} ${destinations}${current} {
+  color: var(--sw-color-text);
+  font-weight: ${label.fontWeight};
+}
+
+@media (forced-colors: active) {
+  ${words} ${destinations}${current} { border-color: Highlight; text-decoration: underline; }
+}`;
+}
+export function navWordsClassCatalog() {
+    return [navWordsClass];
+}

package/dist/css/css-notice.d.ts

@@ -1,22 +1,15 @@
+import { type TintColor } from './tone-tint.js';
 export declare const noticeTones: readonly ["info", "success", "warning", "danger"];
 export declare const noticeVariants: readonly ["default", "band"];
 /** `default` is a rounded note in the flow; `band` a full-width strip of page chrome. */
 export type NoticeVariant = (typeof noticeVariants)[number];
 /** The notice's meaning: information, a good outcome, a caution, a refusal. */
 export type NoticeTone = (typeof noticeTones)[number];
-/**
- * How much of a tone's color the notice's fill mixes into the surface. Info
- * uses the derived accent tint instead (ADR 0011), which already keeps the
- * accent readable on every palette.
- */
+/** How much of a tone's color the notice's fill mixes into the surface. */
 export declare const noticeTintShare = 0.1;
-/**
- * How far the notice's words move from the tone's color toward the text
- * color, so they read darker than the tone on a light fill (lighter on a
- * dark one) and keep 4.5:1 on the tint (`notice.test.tsx`).
- */
+/** How far the notice's words move from the tone's color toward the text color. */
 export declare const noticeInkTextShare = 0.3;
 /** The semantic color a tone is drawn from. */
-export declare function noticeToneColor(tone: NoticeTone): string;
+export declare function noticeToneColor(tone: NoticeTone): TintColor;
 export declare function cssNoticeClasses(): string;
 export declare function noticeClassCatalog(): string[];

package/dist/css/css-notice.js

@@ -1,34 +1,18 @@
 import { typographyVariants } from '@scalewing/tokens';
+import { toneInkTextShare, toneTintFill, toneTintInk, toneTintShare, } from './tone-tint.js';
 export const noticeTones = ['info', 'success', 'warning', 'danger'];
 export const noticeVariants = ['default', 'band'];
-/**
- * How much of a tone's color the notice's fill mixes into the surface. Info
- * uses the derived accent tint instead (ADR 0011), which already keeps the
- * accent readable on every palette.
- */
-export const noticeTintShare = 0.1;
-/**
- * How far the notice's words move from the tone's color toward the text
- * color, so they read darker than the tone on a light fill (lighter on a
- * dark one) and keep 4.5:1 on the tint (`notice.test.tsx`).
- */
-export const noticeInkTextShare = 0.3;
+/** How much of a tone's color the notice's fill mixes into the surface. */
+export const noticeTintShare = toneTintShare;
+/** How far the notice's words move from the tone's color toward the text color. */
+export const noticeInkTextShare = toneInkTextShare;
 /** The semantic color a tone is drawn from. */
 export function noticeToneColor(tone) {
     return tone === 'info' ? 'accent' : tone;
 }
-function toneFill(tone) {
-    if (tone === 'info')
-        return 'var(--sw-color-accentSubtle)';
-    return `color-mix(in srgb, var(--sw-color-${tone}) ${noticeTintShare * 100}%, var(--sw-color-surface))`;
-}
-function toneInk(tone) {
-    const toneShare = Math.round((1 - noticeInkTextShare) * 100);
-    return `color-mix(in srgb, var(--sw-color-${noticeToneColor(tone)}) ${toneShare}%, var(--sw-color-text))`;
-}
 function toneRules() {
     return noticeTones
-        .map((tone) => `.sw-notice-${tone} { --sw-notice-fill: ${toneFill(tone)}; --sw-notice-ink: ${toneInk(tone)}; }`)
+        .map((tone) => `.sw-notice-${tone} { --sw-notice-fill: ${toneTintFill(noticeToneColor(tone))}; --sw-notice-ink: ${toneTintInk(noticeToneColor(tone))}; }`)
         .join('\n');
 }
 const label = typographyVariants.label;

package/dist/css/css-scroll-region.d.ts

@@ -9,9 +9,13 @@ export declare function scrollShadeRules(selector: string): string;
 /**
  * A scroll region is a full-width box that scrolls its own content when the
  * content is wider (or taller) than the box, so a wide table never widens the
- * page. It is a keyboard stop, so its focus ring is drawn inside its edge
- * where an ancestor's clipping cannot hide it. While its content is scrolled
- * out past an inline edge, `ScrollRegion` adds `sw-scroll-more-start` or
+ * page. It is positioned, so it is the containing block of anything
+ * absolutely placed inside it that no nearer box holds, such as a visually
+ * hidden label (`sw-sr-only`) in a cell past its edge: that stays inside the
+ * scroll, not placed against the page, where it would widen it. It is a
+ * keyboard stop, so its focus ring is drawn inside its edge where an
+ * ancestor's clipping cannot hide it. While its content is scrolled out past
+ * an inline edge, `ScrollRegion` adds `sw-scroll-more-start` or
  * `sw-scroll-more-end`, and that edge draws a shade: the cue that the content
  * goes on, which overlay scrollbars (phones, macOS) do not give. In forced
  * colors the shade is not drawn and the system's scrollbar is the cue. Table

package/dist/css/css-scroll-region.js

@@ -34,9 +34,13 @@ export function scrollShadeRules(selector) {
 /**
  * A scroll region is a full-width box that scrolls its own content when the
  * content is wider (or taller) than the box, so a wide table never widens the
- * page. It is a keyboard stop, so its focus ring is drawn inside its edge
- * where an ancestor's clipping cannot hide it. While its content is scrolled
- * out past an inline edge, `ScrollRegion` adds `sw-scroll-more-start` or
+ * page. It is positioned, so it is the containing block of anything
+ * absolutely placed inside it that no nearer box holds, such as a visually
+ * hidden label (`sw-sr-only`) in a cell past its edge: that stays inside the
+ * scroll, not placed against the page, where it would widen it. It is a
+ * keyboard stop, so its focus ring is drawn inside its edge where an
+ * ancestor's clipping cannot hide it. While its content is scrolled out past
+ * an inline edge, `ScrollRegion` adds `sw-scroll-more-start` or
  * `sw-scroll-more-end`, and that edge draws a shade: the cue that the content
  * goes on, which overlay scrollbars (phones, macOS) do not give. In forced
  * colors the shade is not drawn and the system's scrollbar is the cue. Table
@@ -45,6 +49,7 @@ export function scrollShadeRules(selector) {
 export function scrollRegionRules(selector) {
     return `${selector} {
   overflow: auto;
+  position: relative;
   width: 100%;
 }
 

package/dist/css/css-segmented-raised.d.ts

@@ -0,0 +1,3 @@
+export declare const segmentedRaisedClass = "sw-segmented-raised";
+export declare function cssSegmentedRaisedClasses(): string;
+export declare function segmentedRaisedClassCatalog(): string[];

package/dist/css/css-segmented-raised.js

@@ -0,0 +1,72 @@
+import { trackInset, typographyVariants } from '@scalewing/tokens';
+import { quietFill } from './quiet-fill.js';
+const label = typographyVariants.label;
+export const segmentedRaisedClass = 'sw-segmented-raised';
+const raised = `.sw-segmented.${segmentedRaisedClass}`;
+/*
+ * The raised track: the quiet grey fill (no border) with corners one track
+ * inset rounder than the segments' small radius, so the two curves stay
+ * concentric, sized to its segments even in a Stack (unlike compact).
+ * Every segment is the md control height in label type with its words in
+ * the text color at medium weight; with marks, a segment pads a step less
+ * before its mark. The selected one is the surface raised by the small
+ * elevation, its words at label weight. In the dark scheme a shadow does
+ * not show and the surface is about the track's grey, so the selected
+ * segment draws a hairline ring in the muted color instead (3:1 or more
+ * against the track in every dark palette, on the canvas or a card). Two classes,
+ * so these win over the compact track's rules and the reduced-transparency
+ * surface; the track's transparent border would also win over the error
+ * outline (`.sw-segmented[aria-invalid='true']`, the same specificity,
+ * earlier), so the danger border, and Mark in forced colors, is restated
+ * last. Forced colors outline the track and the selected segment.
+ */
+export function cssSegmentedRaisedClasses() {
+    return `${raised} {
+  background: ${quietFill};
+  border-color: transparent;
+  border-radius: calc(var(--sw-radius-sm) + ${trackInset}px);
+}
+
+/* Sized to its segments even where the field is stretched (a Stack). */
+.sw-segmented-field > ${raised} {
+  align-self: flex-start;
+}
+
+${raised} .sw-segmented-item {
+  border-radius: var(--sw-radius-sm);
+  color: var(--sw-color-text);
+  font-size: ${label.fontSize}px;
+  font-weight: 500;
+  letter-spacing: ${label.letterSpacing}px;
+  line-height: ${label.lineHeight}px;
+  min-height: var(--sw-control-md-min-height);
+  padding-inline: var(--sw-space-4);
+}
+
+${raised}.sw-segmented-with-icons .sw-segmented-item {
+  padding-inline: var(--sw-space-2) var(--sw-space-3);
+}
+
+${raised} .sw-segmented-item-selected {
+  background: var(--sw-color-surface);
+  box-shadow: var(--sw-elevation-sm);
+  font-weight: ${label.fontWeight};
+}
+
+[data-theme='dark'] ${raised} .sw-segmented-item-selected {
+  box-shadow: inset 0 0 0 1px var(--sw-color-muted);
+}
+
+${raised}[aria-invalid='true'] {
+  border-color: var(--sw-color-danger);
+}
+
+@media (forced-colors: active) {
+  ${raised} { border-color: CanvasText; }
+  ${raised} .sw-segmented-item-selected { outline: 2px solid Highlight; }
+  ${raised}[aria-invalid='true'] { border-color: Mark; }
+}`;
+}
+export function segmentedRaisedClassCatalog() {
+    return [segmentedRaisedClass];
+}

package/dist/css/css-segmented.js

@@ -1,4 +1,5 @@
 import { trackInset, typographyVariants } from '@scalewing/tokens';
+import { cssSegmentedRaisedClasses, segmentedRaisedClassCatalog, } from './css-segmented-raised.js';
 const body = typographyVariants.body;
 const data = typographyVariants.data;
 const label = typographyVariants.label;
@@ -9,13 +10,15 @@ const label = typographyVariants.label;
  * the row stays even; the track is the subtle fill (two classes, so
  * reduced transparency keeps it) and the selected item is the surface
  * raised by the small elevation, so the choice shows on a white canvas
- * too. A filled track keeps its own look and only gains the marks. The
- * error outline is restated after these rules so an icon track keeps it.
+ * too. A filled or raised track keeps its own look and only gains the
+ * marks (one `:not()` of both, so the compact rules keep their
+ * specificity). The error outline is restated after these rules so an
+ * icon track keeps it.
  * In forced colours the selected item is outlined in Highlight; a focused
  * selected item keeps that outline, offset by the focus ring's offset.
  */
 function iconRules() {
-    const compact = '.sw-segmented-with-icons:not(.sw-segmented-filled)';
+    const compact = '.sw-segmented-with-icons:not(.sw-segmented-filled, .sw-segmented-raised)';
     return `.sw-segmented${compact} {
   background: var(--sw-color-subtle);
   border-color: transparent;
@@ -162,6 +165,8 @@ export function cssSegmentedClasses() {
 
 ${iconRules()}
 
+${cssSegmentedRaisedClasses()}
+
 .sw-segmented-disabled {
   opacity: var(--sw-disabled-opacity);
 }
@@ -181,5 +186,6 @@ export function segmentedClassCatalog() {
         'sw-segmented-with-icons',
         'sw-segmented-item-icon',
         'sw-segmented-disabled',
+        ...segmentedRaisedClassCatalog(),
     ];
 }