@oxy.so/bloom 2.10.0 → 2.11.0

package/lib/typescript/commonjs/stay-filters/FilterChip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilterChip.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/FilterChip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmC,MAAM,OAAO,CAAC;AACxD,OAAO,EAAmB,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAU/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAuCnD,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAGrC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gGAAgG;IAChG,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iBAAS,mBAAmB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAgB,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,EAAE,eAAe,2CA8D3I;AAED,eAAO,MAAM,UAAU,uDAA4B,CAAC"}
+{"version":3,"file":"FilterChip.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/FilterChip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,eAAO,MAAM,kBAAkB,QAA8B,CAAC;AAG9D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gGAAgG;IAChG,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iBAAS,mBAAmB,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,IAAI,EAAE,IAAI,EACV,QAAgB,EAChB,KAAK,EACL,MAAM,GACP,EAAE,eAAe,2CAiBjB;AAuBD,eAAO,MAAM,UAAU,uDAA4B,CAAC"}

package/lib/typescript/commonjs/stay-filters/FilterFooter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilterFooter.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/FilterFooter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwB,MAAM,OAAO,CAAC;AAO7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,iBAAS,qBAAqB,CAAC,EAC7B,YAAY,EACZ,OAAO,EACP,OAAO,EACP,UAAwB,EACxB,aAAqB,EACrB,OAAe,EACf,aAAqB,EACrB,KAAK,EACL,MAAM,GACP,EAAE,iBAAiB,2CA2CnB;AAED,eAAO,MAAM,YAAY,yDAA8B,CAAC"}
+{"version":3,"file":"FilterFooter.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/FilterFooter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwB,MAAM,OAAO,CAAC;AAM7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,iBAAS,qBAAqB,CAAC,EAC7B,YAAY,EACZ,OAAO,EACP,OAAO,EACP,UAAwB,EACxB,aAAqB,EACrB,OAAe,EACf,aAAqB,EACrB,KAAK,EACL,MAAM,GACP,EAAE,iBAAiB,2CAkDnB;AAED,eAAO,MAAM,YAAY,yDAA8B,CAAC"}

package/lib/typescript/commonjs/stay-filters/PropertyTypeTiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PropertyTypeTiles.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/PropertyTypeTiles.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAuB,YAAY,EAAsB,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAE7G;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAO1C,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAuBvC,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAGvE;AAoED,MAAM,WAAW,8BAA8B,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,sBAAsB,CAAC,CAAC,CAAC;IACjG,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,YAAY,EAAE,EACjE,KAAK,EACL,aAAa,EACb,OAAO,EACP,MAAM,EACN,OAAO,EACP,kBAAoC,EACpC,QAAgB,EAChB,IAAI,EACJ,KAAK,EACL,MAAM,GACP,EAAE,8BAA8B,CAAC,CAAC,CAAC,2CAmDnC"}
+{"version":3,"file":"PropertyTypeTiles.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/PropertyTypeTiles.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAuB,YAAY,EAAsB,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAG7G;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAO1C,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAuBvC,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAGvE;AAsED,MAAM,WAAW,8BAA8B,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,sBAAsB,CAAC,CAAC,CAAC;IACjG,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,YAAY,EAAE,EACjE,KAAK,EACL,aAAa,EACb,OAAO,EACP,MAAM,EACN,OAAO,EACP,kBAAoC,EACpC,QAAgB,EAChB,IAAI,EACJ,KAAK,EACL,MAAM,GACP,EAAE,8BAA8B,CAAC,CAAC,CAAC,2CAiDnC"}

package/lib/typescript/commonjs/stay-filters/RangeFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RangeFields.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/RangeFields.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAK3D;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;AAEvE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,gEAAgE;IAChE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC;IACzD,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK1E;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK5D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,CAAC,GAAG,CAAC,EACZ,MAAM,EAAE,MAAM,EACd,EAAE,GAAe,EAAE,GAAc,EAAE,IAAQ,EAAE,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3F,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAOhC;AAED,iBAAS,oBAAoB,CAAC,EAC5B,KAAK,EACL,QAAQ,EACR,MAAM,EACN,MAAM,EACN,GAAG,EACH,GAAG,EACH,IAAI,EACJ,QAAgB,EAChB,QAAgB,EAChB,MAAM,GACP,EAAE,gBAAgB,2CA+ClB;AAED,eAAO,MAAM,WAAW,wDAA6B,CAAC"}
+{"version":3,"file":"RangeFields.d.ts","sourceRoot":"","sources":["../../../../src/stay-filters/RangeFields.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAM3D;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;AAEvE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,gEAAgE;IAChE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC;IACzD,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK1E;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK5D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,CAAC,GAAG,CAAC,EACZ,MAAM,EAAE,MAAM,EACd,EAAE,GAAe,EAAE,GAAc,EAAE,IAAQ,EAAE,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3F,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAOhC;AAED,iBAAS,oBAAoB,CAAC,EAC5B,KAAK,EACL,QAAQ,EACR,MAAM,EACN,MAAM,EACN,GAAG,EACH,GAAG,EACH,IAAI,EACJ,QAAgB,EAChB,QAAgB,EAChB,MAAM,GACP,EAAE,gBAAgB,2CA+ClB;AAED,eAAO,MAAM,WAAW,wDAA6B,CAAC"}

package/lib/typescript/commonjs/stay-search/DateFlexibilityChips.d.ts

@@ -1,10 +1,13 @@
 import React from 'react';
 import type { DateFlexibilityChipsProps } from './types';
 /**
- * A single-select row of Bloom `Chip`s (`large`, `outlined`; the selected one
+ * A single-select row of Bloom `Chip`s (`xl`, `outlined`; the selected one
  * takes the brand tone) that says how flexible the chosen dates are. Put it
  * under a `RangeCalendar` or `DateRangePicker` — this part does not draw a
  * calendar.
+ *
+ * It used to be `large` with `{ paddingHorizontal: 12, height: 32 }` written on
+ * every pill, because `Chip`'s scale stopped at 28. `xl` IS that pill.
  */
 declare function DateFlexibilityChipsComponent({ value, onChange, options, accessibilityLabel, style, testID, }: DateFlexibilityChipsProps): import("react/jsx-runtime").JSX.Element;
 export declare const DateFlexibilityChips: React.MemoExoticComponent<typeof DateFlexibilityChipsComponent>;

package/lib/typescript/commonjs/stay-search/DateFlexibilityChips.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DateFlexibilityChips.d.ts","sourceRoot":"","sources":["../../../../src/stay-search/DateFlexibilityChips.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAC;AAKpC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;GAKG;AACH,iBAAS,6BAA6B,CAAC,EACrC,KAAK,EACL,QAAQ,EACR,OAA0C,EAC1C,kBAAuC,EACvC,KAAK,EACL,MAAM,GACP,EAAE,yBAAyB,2CAwB3B;AAED,eAAO,MAAM,oBAAoB,iEAAsC,CAAC"}
+{"version":3,"file":"DateFlexibilityChips.d.ts","sourceRoot":"","sources":["../../../../src/stay-search/DateFlexibilityChips.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAC;AAKpC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;GAQG;AACH,iBAAS,6BAA6B,CAAC,EACrC,KAAK,EACL,QAAQ,EACR,OAA0C,EAC1C,kBAAuC,EACvC,KAAK,EACL,MAAM,GACP,EAAE,yBAAyB,2CAsB3B;AAED,eAAO,MAAM,oBAAoB,iEAAsC,CAAC"}

package/lib/typescript/commonjs/stepper/Stepper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Stepper.d.ts","sourceRoot":"","sources":["../../../../src/stepper/Stepper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgD,MAAM,OAAO,CAAC;AAcrE,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,SAAS,CAAC;AAuDzD,iBAAS,gBAAgB,CAAC,EACxB,KAAK,EACL,aAAa,EACb,GAAO,EACP,GAAG,EACH,IAAQ,EACR,QAAgB,EAChB,IAAe,EACf,WAAW,EACX,kBAAkB,EAClB,cAA2B,EAC3B,cAA2B,EAC3B,KAAK,EACL,MAAM,GACP,EAAE,YAAY,2CAwId;AAED,eAAO,MAAM,OAAO,oDAAyB,CAAC"}
+{"version":3,"file":"Stepper.d.ts","sourceRoot":"","sources":["../../../../src/stepper/Stepper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAe1D,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,SAAS,CAAC;AA0DzD,iBAAS,gBAAgB,CAAC,EACxB,KAAK,EACL,aAAa,EACb,GAAO,EACP,GAAG,EACH,IAAQ,EACR,QAAgB,EAChB,IAAe,EACf,WAAW,EACX,kBAAkB,EAClB,cAA2B,EAC3B,cAA2B,EAC3B,KAAK,EACL,MAAM,GACP,EAAE,YAAY,2CAwId;AAED,eAAO,MAAM,OAAO,oDAAyB,CAAC"}

package/lib/typescript/commonjs/styles/clamp.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The two clamps every family writes for itself. Pure, no dependencies.
+ *
+ * Five copies of `clamp` and three of `clamp01` existed under four names
+ * (`clamp01`, `clampFraction`, and the 0–100 `clampProgress`, which is a
+ * different function and stays where it is).
+ */
+/**
+ * `value` held inside `[min, max]`.
+ *
+ * An INVERTED range (`min > max`) resolves to `min`, and that is load-bearing
+ * rather than incidental: `overlay/dropdown-placement.ts` inverts the range
+ * exactly when a surface is larger than the viewport minus its gutters, and
+ * preferring `min` pins the surface to the top/left gutter so its FIRST rows
+ * stay reachable. Preferring `max` would push its start off-screen and strand
+ * every row. Three of the five copies agreed with `min`; the ordering here is
+ * the one that keeps that true.
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * `value` held inside `[0, 1]` — a fraction, a progress share, a scroll ratio.
+ *
+ * `undefined`, `NaN` and the infinities all answer `0`, so an unmeasured or
+ * not-yet-loaded value reads as "none of it" rather than propagating a
+ * non-finite number into a width or an opacity.
+ */
+export declare function clamp01(value: number | undefined): number;
+//# sourceMappingURL=clamp.d.ts.map

package/lib/typescript/commonjs/styles/clamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../../../../src/styles/clamp.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAGzD"}

package/lib/typescript/commonjs/styles/color-contrast.d.ts

@@ -1,5 +1,80 @@
 /** WCAG relative luminance (0..1) of an opaque colour; `null` if it does not parse. */
 export declare function relativeLuminance(color: string): number | null;
+/** Composite `top` at `alpha` over opaque `base` — CSS `color-mix(in srgb)`. */
+export declare function mixColors(base: string, top: string, alpha: number): string;
+/**
+ * The quietest blend of `text` over `surface` that still clears `minRatio`.
+ *
+ * Contrast rises monotonically with the blend, so a bisection finds the rung —
+ * and then the QUANTIZED colour is re-checked and nudged upward, because an
+ * 8-bit round turns a nominal 4.50 into a measured 4.49. What a caller gets back
+ * therefore clears the floor as RENDERED, not as computed.
+ *
+ * This is the one way Bloom builds a quiet text colour. A ramp STOP cannot do
+ * the job: `neutral-400` clears AA on the page and measures 2.42:1 on a chart
+ * card, because the card is not the page. Reading the rung off the fill it
+ * actually lands on is the whole difference — and it needs no new colours, since
+ * every rung is the theme's own `text` over the theme's own surface.
+ */
+export declare function quietText(surface: string, text: string, minRatio: number): string;
+/**
+ * One quiet colour for SEVERAL surfaces — the rung that clears `minRatio` on the
+ * hardest of them.
+ *
+ * A family's caption grey usually lands on more than one fill: a chart card's
+ * ticks sit on the card AND on the stat tiles inset into it, and those two are
+ * on opposite sides of the text in dark mode. Flooring against one of them is
+ * how `2.42:1` happened in the first place, one level up.
+ *
+ * Each surface proposes its own rung and the one with the best WORST case wins,
+ * rather than assuming which surface is hardest — that assumption flips between
+ * light and dark for exactly these pairs. Falls back to `text` if no rung clears
+ * every surface, which is the honest answer: there is no quiet colour there.
+ */
+export declare function quietTextOver(surfaces: readonly string[], text: string, minRatio: number): string;
 /** WCAG contrast ratio between two opaque colours (1..21); `1` if either does not parse. */
 export declare function contrastRatio(a: string, b: string): number;
+/** WCAG AA for body text. The bar every label on a computed surface is held to. */
+export declare const AA_TEXT_CONTRAST = 4.5;
+/** WCAG AA for LARGE text — 24px and up, or 19px bold. */
+export declare const AA_LARGE_TEXT_CONTRAST = 3;
+/** WCAG AAA for body text. What a surface holds its most important line to. */
+export declare const AAA_TEXT_CONTRAST = 7;
+/**
+ * Of `candidates`, the colour whose WORST contrast over every surface in `over`
+ * is highest — text laid over a gradient has to read at both ends, and text on
+ * a computed tint has to read on whatever the tint turned out to be.
+ *
+ * Returns the first candidate when none is better than another, so the caller's
+ * order is its preference order.
+ */
+export declare function readableOn(over: string | readonly string[], candidates: readonly string[]): string;
+/**
+ * `color` pulled toward black by `amount` (0..1), as `#rrggbb`; `null` if it
+ * does not parse.
+ *
+ * Scaling every channel by the same factor keeps their RATIO, so the hue and
+ * the saturation survive — this is why a darkened teal is still teal. It is
+ * exactly `mixColor(color, '#000000', amount)`, which is how two of the copies
+ * spelled it.
+ */
+export declare function darken(color: string, amount: number): string | null;
+/**
+ * The lightest shade of `color` on which EVERY colour in `foreground` clears
+ * `ratio`: the colour itself when it already does, else pulled toward black in
+ * `1 / steps` increments until it does.
+ *
+ * `null` when `color` does not parse — the caller falls back to its own
+ * neutral surface rather than being handed a colour it did not ask for. Black
+ * clears any light foreground, so the walk always ends somewhere.
+ *
+ * **Darken the COLOUR, never walk its ramp.** A generated ramp re-derives every
+ * stop's lightness and chroma from the hue, so a near-black input comes back
+ * ten times lighter than it went in and a vivid one has a channel zeroed. This
+ * keeps what it was handed and only removes light from it.
+ */
+export declare function darkenUntilContrast(color: string, foreground: string | readonly string[], ratio?: number, steps?: number): {
+    color: string;
+    amount: number;
+} | null;
 //# sourceMappingURL=color-contrast.d.ts.map

package/lib/typescript/commonjs/styles/color-contrast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"color-contrast.d.ts","sourceRoot":"","sources":["../../../../src/styles/color-contrast.ts"],"names":[],"mappings":"AAYA,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9D;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAM1D"}
+{"version":3,"file":"color-contrast.d.ts","sourceRoot":"","sources":["../../../../src/styles/color-contrast.ts"],"names":[],"mappings":"AAYA,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9D;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAcjF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,MAAM,CAYR;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAM1D;AAWD,mFAAmF;AACnF,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,0DAA0D;AAC1D,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,+EAA+E;AAC/E,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYlG;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACtC,KAAK,GAAE,MAAyB,EAChC,KAAK,SAAK,GACT;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAS1C"}

package/lib/typescript/commonjs/styles/index.d.ts

@@ -6,5 +6,10 @@ export type { Breakpoint } from './breakpoints';
 export { Z_INDEX } from './z-index';
 export { web, native, ios, android, platform, select } from './platform';
 export { SUPPORTS_NATIVE_DRIVER } from './native-driver';
-export { contrastRatio, relativeLuminance } from './color-contrast';
+export { contrastRatio, relativeLuminance, readableOn, darken, darkenUntilContrast, AA_TEXT_CONTRAST, AA_LARGE_TEXT_CONTRAST, AAA_TEXT_CONTRAST, } from './color-contrast';
+export { webDataSet } from './web-data';
+export { clamp, clamp01 } from './clamp';
+export { mixColors, quietText, quietTextOver } from './color-contrast';
+export { AA_GRAPHICAL, AA_TEXT, AA_TEXT_STRONG, hairlineOn, resolveSurfaceLevel, SURFACE_FILL_CSS, SURFACE_FILL_VAR, SURFACE_LEVELS, SurfaceLevelProvider, surfaceFillOn, surfaceFillVars, surfaceTextOn, useSurfaceFill, useSurfaceLevel, useSurfaceLevelValue, } from './surface-levels';
+export type { SurfaceLevel, SurfaceLevelPaint, SurfaceLevelProviderProps, SurfaceTextPaint, } from './surface-levels';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/styles/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/styles/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACzC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/styles/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACzC,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,MAAM,EACN,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EACL,YAAY,EACZ,OAAO,EACP,cAAc,EACd,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,aAAa,EACb,cAAc,EACd,eAAe,EACf,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC"}

package/lib/typescript/commonjs/styles/interactive-web-css.d.ts

@@ -1,3 +1,44 @@
+/**
+ * The custom property every Bloom focus ring reads its GAP colour from.
+ *
+ * Three ring mechanisms existed: the canonical `outline` + `outline-offset`, a
+ * two-step `box-shadow` whose gap was the literal `#FFFFFF`, and an inset
+ * shadow. The literal is the one that broke — `ring-offset-color` defaults to
+ * white in Tailwind and was never overridden, so in DARK mode a focused filter
+ * chip, filter text button, stepper value or slider thumb drew a 2px white halo
+ * against a near-black page. A gap is meant to be a hole in the ring, and a hole
+ * is the colour of whatever is behind it.
+ *
+ * So the gap is a variable, set inline from the surface the control sits on
+ * (`useRingOffsetStyle()` in `styles/surface-levels.ts`). The fallback below is
+ * only for a control that sets nothing.
+ */
+export declare const RING_OFFSET_VAR = "--bloom-ring-offset";
+/** What the gap falls back to when nothing sets {@link RING_OFFSET_VAR}. */
+export declare const RING_OFFSET_FALLBACK = "#FFFFFF";
+/** The two-step ring: a `gap`px hole in the surface colour, then a `width`px ring. */
+export interface FocusRingSpec {
+    /**
+     * `outline` is the canonical recipe — a real `outline` with `outline-offset`,
+     * which follows a rounded corner and never joins the paint. `ring` is the
+     * `box-shadow` form, for a control whose ring must sit on a CHILD element (a
+     * slider thumb, a checkbox glyph) where an outline on the focusable ancestor
+     * would draw round the wrong box.
+     */
+    mode?: 'outline' | 'ring';
+    /** The gap, in px, between the control's edge and the ring. */
+    offset?: number;
+    /** The ring's own thickness, in px. */
+    width?: number;
+}
+/**
+ * The `box-shadow` value of a `ring`-mode focus ring.
+ *
+ * `ringVar` is the full custom-property name the family already sets inline for
+ * its accent, e.g. `--bloom-stepper-ring`. Anything in `extra` is appended, for
+ * a control that also carries a resting shadow the ring must not erase.
+ */
+export declare function focusRingShadow(ringVar: string, { offset, width }?: FocusRingSpec, extra?: string): string;
 /**
  * The filter every interactive rule carries: a control that is disabled by
  * either spelling reacts to nothing. Exported so a family-specific `extraRules`
@@ -23,16 +64,32 @@ export interface InteractiveWebCssOptions {
      * `bloom-btn` yields `--bloom-btn-ring` and `--bloom-btn-press-scale`.
      */
     varPrefix: string;
+    /**
+     * `button` (the default) emits the `<button>` reset — `appearance`,
+     * `display: inline-flex`, `cursor`, `user-select`. It is right for a raw-DOM
+     * fork and WRONG for a react-native-web control: RNW lays a `View` out with
+     * `display: flex`, so `inline-flex` from a stylesheet silently changes how the
+     * control participates in its parent's layout. A `dataSet`-hooked caller
+     * passes `none` and keeps its geometry in the inline style, where RNW can see
+     * it on native too.
+     */
+    reset?: 'button' | 'none';
     /**
      * The family's own base declarations, appended after the shared reset — its
      * layout (`flex-direction`, `gap`, `padding`), border, font and anything else
      * that is not common to all three. A declaration here overrides the reset.
+     * Optional: a control whose geometry lives entirely in its inline style (every
+     * react-native-web one does, so native gets it too) has nothing to put here.
      */
-    base: string;
+    base?: string;
     /** Value of the base rule's `transition` shorthand. */
     transition: string;
-    /** The hover rule. */
-    hover: {
+    /**
+     * The hover rule. Optional: a react-native-web control gets `onHoverIn` in JS
+     * and paints hover through its inline style, so it has no hover rule to emit —
+     * and a CSS one would then be a second source of truth for the same state.
+     */
+    hover?: {
         /** Extra selector filter appended after {@link NOT_DISABLED}, e.g. `:not([data-active="true"])`. */
         filter?: string;
         /** Declarations the hover state sets. */
@@ -47,8 +104,36 @@ export interface InteractiveWebCssOptions {
      * depending on which selector happens to win.
      */
     pressDeclarations?: string;
-    /** `outline-offset` for the focus ring, in px. */
-    outlineOffset: number;
+    /**
+     * Whether to emit the `:active` press-scale rule. Defaults to true for the
+     * `button` reset and false for `none` — Bloom's controls change COLOUR on
+     * press, and the scale exists only for the three raw-DOM forks that shipped
+     * with it.
+     */
+    pressScale?: boolean;
+    /**
+     * `outline-offset` for the focus ring, in px — shorthand for `focus.offset`.
+     * Defaults to 2, the canonical gap.
+     */
+    outlineOffset?: number;
+    /**
+     * The focus ring, when the family needs the `ring` form or a thicker ring.
+     * Omitted, it is `{ mode: 'outline', offset: outlineOffset }` — the canonical
+     * recipe, unchanged.
+     */
+    focus?: FocusRingSpec;
+    /**
+     * The disabled block. Omitted, the control takes `cursor: default` and
+     * {@link DISABLED_OPACITY}.
+     *
+     * `opacity: null` opts a family OUT of the opacity convention — for a control
+     * that RECOLOURS when disabled (`Button` does, by token) and must not also
+     * fade, which would apply the dimming twice.
+     */
+    disabled?: {
+        opacity?: number | null;
+        declarations?: string;
+    };
     /** Rules appended verbatim, for a family-specific modifier class. */
     extraRules?: string;
 }
@@ -58,7 +143,7 @@ export interface InteractiveWebCssOptions {
  * Pure — the caller adopts the result, which is what makes it testable without
  * a DOM.
  */
-export declare function interactiveWebCss({ selector, varPrefix, base, transition, hover, pressDeclarations, outlineOffset, extraRules, }: InteractiveWebCssOptions): string;
+export declare function interactiveWebCss({ selector, varPrefix, reset, base, transition, hover, pressDeclarations, pressScale, outlineOffset, focus, disabled, extraRules, }: InteractiveWebCssOptions): string;
 /**
  * Adopt a control family's stylesheet once, on mount.
  *

package/lib/typescript/commonjs/styles/interactive-web-css.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactive-web-css.d.ts","sourceRoot":"","sources":["../../../../src/styles/interactive-web-css.ts"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,eAAO,MAAM,YAAY,kDAAgD,CAAC;AAE1E,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;;;OAWG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB;IACtB,KAAK,EAAE;QACL,oGAAoG;QACpG,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,yCAAyC;QACzC,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAYD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,UAAU,EACV,KAAK,EACL,iBAAiB,EACjB,aAAa,EACb,UAAU,GACX,EAAE,wBAAwB,GAAG,MAAM,CAmCnC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAIvE"}
+{"version":3,"file":"interactive-web-css.d.ts","sourceRoot":"","sources":["../../../../src/styles/interactive-web-css.ts"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,wBAAwB,CAAC;AAErD,4EAA4E;AAC5E,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAE9C,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,EAAE,MAAU,EAAE,KAAS,EAAE,GAAE,aAAkB,EAC7C,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,CAIR;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,kDAAgD,CAAC;AAE1E,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;;;OAWG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QACN,oGAAoG;QACpG,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,yCAAyC;QACzC,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9D,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAYD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,SAAS,EACT,KAAgB,EAChB,IAAS,EACT,UAAU,EACV,KAAK,EACL,iBAAiB,EACjB,UAA+B,EAC/B,aAAa,EACb,KAAK,EACL,QAAQ,EACR,UAAU,GACX,EAAE,wBAAwB,GAAG,MAAM,CAoDnC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAIvE"}

package/lib/typescript/commonjs/styles/panel-chrome.d.ts

@@ -0,0 +1,24 @@
+import type { Theme } from '../theme/types';
+export declare const PANEL_SHADOW: {
+    readonly light: "0 1px 0 0 rgba(0, 0, 0, 0.0196), 0 1px 12px 0 rgba(0, 0, 0, 0.0588), 0 0 1px 0 rgba(0, 0, 0, 0.3216)";
+    readonly dark: "0 1px 0 0 rgba(0, 0, 0, 0.1), 0 1px 12px 0 rgba(0, 0, 0, 0.16), 0 0 1px 0 rgba(0, 0, 0, 0.42)";
+};
+export interface PanelChrome {
+    /** The panel's own fill. */
+    surface: string;
+    /** Its 1px edge. */
+    border: string;
+    /** The `box-shadow` string (web and RN ≥ 0.76 both take it). */
+    shadow: string;
+}
+export declare function resolvePanelChrome(theme: Theme): PanelChrome;
+/**
+ * The chrome for the current theme, or `null` outside a `BloomThemeProvider`.
+ *
+ * Optional on purpose: `ContentPanel` draws its own surface and had never
+ * touched the theme, so a consumer (or a test) rendering one without the
+ * provider used to work. Making the shadow mandatory would have turned that
+ * into a thrown error at the moment the panel merely got prettier.
+ */
+export declare function useOptionalPanelChrome(): PanelChrome | null;
+//# sourceMappingURL=panel-chrome.d.ts.map

package/lib/typescript/commonjs/styles/panel-chrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-chrome.d.ts","sourceRoot":"","sources":["../../../../src/styles/panel-chrome.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,eAAO,MAAM,YAAY;;;CAGf,CAAC;AAEX,MAAM,WAAW,WAAW;IAC1B,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,CAQ5D;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,WAAW,GAAG,IAAI,CAG3D"}

package/lib/typescript/commonjs/styles/surface-levels.d.ts

@@ -0,0 +1,271 @@
+/**
+ * The surface LADDER: one answer to "what colour is the thing I am sitting on,
+ * and what colour is the thing I put on top of it".
+ *
+ * Thirty families had each resolved that themselves, and the result was four
+ * different dark "card on a page" fills in one tree — `#14171c` (chart cards),
+ * `#23262b` (menus, fields, tab rails), `#2e353e` (`theme.colors.card`) and a
+ * per-family mix — plus two light ones. Two of those collisions are not a
+ * cosmetic drift but a disappearing act: a dark text field painted `n[800]`
+ * inside a menu painted `n[800]` measured 1.000:1, and a tab rail painted
+ * `n[800]` inside a queue panel painted `n[800]` measured ΔE 0. In both cases
+ * the control had no shell at all.
+ *
+ * The fix is not another table of hexes. A control cannot know its own parent,
+ * so the only durable form of the answer is RELATIVE: every step is computed
+ * from the fill it lands on.
+ *
+ *   surfaceFillOn(theme, parent)   the next surface up — a field, a track, a tile
+ *   hairlineOn(theme, parent)      the line that separates them
+ *   surfaceTextOn(theme, parent)   text rungs that clear AA *on that fill*
+ *
+ * A step moves the parent fill toward the theme's own `text` colour by a fixed
+ * alpha. That is deliberately the same move the neutral ramp makes, so nothing
+ * new enters the palette — but it is anchored on the ACTUAL parent instead of a
+ * ramp stop that happens to match one page colour.
+ *
+ * **Light and dark are one rule here, not two.** Moving toward `text` darkens a
+ * light surface and lightens a dark one, which is what each mode wants; the
+ * alphas differ only because a dark page has more headroom above it than a light
+ * page has below white.
+ *
+ * ## The named rungs
+ *
+ * `resolveSurfaceLevel(theme, level)` names the four rungs a screen actually
+ * uses, and the first two land on what Bloom already paints, so adopting the
+ * API is not a repaint:
+ *
+ *   0  page          `theme.colors.background`
+ *   1  card on page  light `theme.colors.card` (white), dark one step off the
+ *                    page — `#212327` against the `#23262b` that
+ *                    `floating/menu-palette` has always used, 1.03:1 apart
+ *   2  card on card  one step off level 1 — a popover's inner tile, a field
+ *   3  deep          one step off level 2
+ *
+ * The ladder is NOT monotonic in lightness. In light mode the first step goes
+ * UP to white and every step after goes down; in dark every step goes up. What
+ * is monotonic — and what the gate pins — is the SEPARATION between neighbours:
+ * measured on `blue`, every adjacent pair separates by fill alone (light 1.11 /
+ * 1.15 / 1.15, dark 1.23 / 1.30 / 1.30).
+ *
+ * 1.11:1 is a thin margin, and that is why every rung ALSO carries the `border`
+ * that separates it from its parent (light 1.21 / 1.53 / 1.50). A surface either
+ * separates by fill or it draws its hairline, and on a light page a card needs
+ * the hairline. `surface-levels.test.ts` pins both mechanisms over every preset,
+ * so losing either one goes red.
+ *
+ * ## Ambient level
+ *
+ * `SurfaceLevelProvider` publishes "the fill my children are sitting on", and
+ * `useSurfaceLevel()` reads it. A container that paints a surface raises it;
+ * everything inside then steps off the right parent without being told.
+ * Defaulting to level 0 keeps every unwrapped consumer on the page rung, which
+ * is what it was already assuming.
+ *
+ * ## The rung is a derivation; `fill` is the fact
+ *
+ * A rung ANSWERS the question from the page down, and for a control that only
+ * needs a legible step off its parent that is enough. It is not enough for the
+ * other question a surface gets asked — "paint yourself the same colour as me"
+ * — because a container may paint something the ladder would not have chosen.
+ * `ContentPanel` is exactly that case: it paints `bg-card`, and in DARK mode
+ * `theme.colors.card` is not rung 1 (which is a computed step off the page,
+ * pinned within 1.03:1 of the menu surface). A sticky header that took the rung
+ * would sit a visible shade off the column it is supposed to disappear into.
+ *
+ * So a container that knows exactly what it painted publishes it —
+ * `<SurfaceLevelProvider level={1} fill={colors.card}>` — and `useSurfaceFill()`
+ * returns that colour verbatim. Everything derived (the hairline, the raised
+ * fill, the text rungs) is then computed off the REAL parent, which is what the
+ * relative primitives always wanted and could not have while the parent was
+ * inferred. A provider with no `fill` behaves exactly as it did.
+ *
+ * ## The same answer on web, for CSS that cannot call a hook
+ *
+ * {@link SURFACE_FILL_VAR} (`--bloom-surface`) carries the published fill down
+ * the DOM, so a stylesheet, a `::after` seam or an arbitrary Tailwind value can
+ * follow the surface without the consumer threading a colour through props.
+ * It is set by the same containers, on the element they paint, with
+ * {@link surfaceFillVars} — never at `:root`, which would resolve once for the
+ * whole document and defeat both this and `BloomColorScope` (a subtree scoped
+ * to another preset paints its own `--background`; a root-computed alias keeps
+ * the app-wide one — `theme/color-scope/seed-scope.ts` has the mechanism).
+ *
+ * It is WEB-ONLY, and deliberately: propagating a custom property to a native
+ * subtree means react-native-css's `VariableContextProvider`, i.e. the
+ * `nativewind` OPTIONAL peer, and a panel's own surface must not depend on
+ * whether a consumer installed it. Native's answer is the hook, which is also
+ * the only form that is correct on both platforms — so cross-platform code
+ * reads `useSurfaceFill()` and a web-only fork may read the variable.
+ */
+import { type ReactNode } from 'react';
+import { type ViewStyle } from 'react-native';
+import type { Theme } from '../theme/types';
+/** WCAG AA for body-size text. */
+export declare const AA_TEXT = 4.5;
+/** WCAG AAA-ish: the rung a SECONDARY label sits at, clearly quieter than the primary one. */
+export declare const AA_TEXT_STRONG = 7;
+/** WCAG AA for large text, icons and graphical objects (gridlines, tracks, rules). */
+export declare const AA_GRAPHICAL = 3;
+/**
+ * The next surface up from `parent` — a text field's fill, a progress track, a
+ * stat tile, a hovered row. Always a visible step off whatever it is given.
+ */
+export declare function surfaceFillOn(theme: Theme, parent: string): string;
+/** The hairline that reads on `parent` — a divider, a card edge, a tab rail. */
+export declare function hairlineOn(theme: Theme, parent: string): string;
+/** The text rungs legible on one fill. Every member is floored against that fill. */
+export interface SurfaceTextPaint {
+    /** The primary label — the theme's own text colour. */
+    text: string;
+    /** A secondary label: clearly quieter, still {@link AA_TEXT_STRONG}. */
+    textSecondary: string;
+    /** The quietest TEXT rung — captions, axis ticks, placeholders, counters. {@link AA_TEXT}. */
+    textTertiary: string;
+    /** Not text: gridlines, rules, a disabled glyph, a chart's own furniture. {@link AA_GRAPHICAL}. */
+    textGraphical: string;
+}
+/**
+ * The three text rungs plus the graphical one, resolved against `parent`.
+ *
+ * A ramp stop cannot do this job: `n[400]` clears AA on the page and measures
+ * 2.42:1 on a chart card, because the card is not the page. Reading the rungs
+ * off the fill they land on is the whole difference.
+ */
+export declare function surfaceTextOn(theme: Theme, parent: string): SurfaceTextPaint;
+/** The four rungs a screen stacks. See the module comment for what each one is. */
+export type SurfaceLevel = 0 | 1 | 2 | 3;
+export declare const SURFACE_LEVELS: readonly SurfaceLevel[];
+export interface SurfaceLevelPaint extends SurfaceTextPaint {
+    level: SurfaceLevel;
+    /** The fill at this rung. */
+    background: string;
+    /** The hairline that separates this rung from the one below it, and divides it internally. */
+    border: string;
+    /** The next fill UP — what a control placed on this rung paints itself. */
+    raised: string;
+}
+/** Everything one rung paints. Pure, so it can be walked over every preset × mode. */
+export declare function resolveSurfaceLevel(theme: Theme, level: SurfaceLevel): SurfaceLevelPaint;
+/**
+ * The CSS custom property carrying the published surface fill to a web subtree.
+ *
+ * Named like `--bloom-ring-offset` (its opposite number: a CONTAINER publishes
+ * this one, a CONTROL consumes that one, and they are the same colour) rather
+ * than like a palette token — it is not one. `--surface` is already a token, and
+ * this deliberately does not shadow it.
+ */
+export declare const SURFACE_FILL_VAR = "--bloom-surface";
+/**
+ * How to REFERENCE the published fill from CSS or an arbitrary Tailwind value:
+ *
+ * ```
+ * background-color: var(--bloom-surface, var(--background));
+ * className="bg-[var(--bloom-surface,var(--background))]"   // web-only
+ * ```
+ *
+ * The fallback is what makes it safe: the variable exists only where a container
+ * published one, so outside every surface — and in a `BloomColorScope` subtree
+ * that owns no surface of its own — this resolves to the page. Both halves
+ * substitute at the USING element, so a scoped subtree gets the scope's
+ * `--background`, not the document root's.
+ */
+export declare const SURFACE_FILL_CSS = "var(--bloom-surface, var(--background))";
+/**
+ * The style a surface OWNER puts on the element it paints, so web CSS below it
+ * can read {@link SURFACE_FILL_CSS}. `undefined` on native, where the variable
+ * has no propagation mechanism that does not go through an optional peer (see
+ * the module comment) — the hook is native's answer, and the owner passes this
+ * unconditionally either way.
+ *
+ * It belongs on the SAME element that carries the fill, so the two can never
+ * disagree, and a container that publishes the context publishes this with it.
+ *
+ * `undefined` in, `undefined` out: a container that cannot name its own colour
+ * (see `content-panel/shared.ts`) publishes no variable rather than a wrong one,
+ * and the call site stays one unconditional expression.
+ */
+export declare function surfaceFillVars(fill: string | undefined): ViewStyle | undefined;
+/** What a container publishes: the rung, and the fill if it knows it exactly. */
+interface AmbientSurface {
+    level: SurfaceLevel;
+    /** The colour the container actually painted, or `null` to use the rung's. */
+    fill: string | null;
+}
+export interface SurfaceLevelProviderProps {
+    /** The rung the children are sitting ON. A card on a page publishes `1`. */
+    level: SurfaceLevel;
+    /**
+     * The colour this container actually painted, when it is not the rung's own
+     * fill. `ContentPanel` paints `theme.colors.card`, which in dark mode is NOT
+     * rung 1 — chrome that must vanish into the panel needs the fact, not the
+     * derivation (module comment). Everything derived below is then computed off
+     * this colour, so a hairline or a field inside still steps off the real
+     * parent. Omit it and the rung answers, exactly as before.
+     */
+    fill?: string;
+    children?: ReactNode;
+}
+/**
+ * Publish the rung this subtree sits on.
+ *
+ * A container that paints a surface wraps its content in this; every descendant
+ * then steps off the right parent. Without it a control assumes level 0, which
+ * is what it assumed before this existed — so adopting it is additive.
+ *
+ * On web, publish {@link surfaceFillVars} on the painted element in the same
+ * breath: the DOM inherits the variable independently of React context, so a
+ * container that sets one and not the other leaves CSS below it reading the
+ * ENCLOSING surface's colour — which is the wrong colour, silently.
+ */
+export declare function SurfaceLevelProvider({ level, fill, children }: SurfaceLevelProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<AmbientSurface>>;
+/** The ambient rung, as a number. `0` when nothing published one. */
+export declare function useSurfaceLevelValue(): SurfaceLevel;
+/**
+ * The ambient rung's paint, optionally `delta` rungs above it.
+ *
+ * `useSurfaceLevel()` is "the surface I am on"; `useSurfaceLevel(1)` is "the
+ * surface one level above the current one" — the question every one of those
+ * thirty families was answering by hand.
+ *
+ * When the container published an exact `fill`, every rung above it is STEPPED
+ * off that colour instead of read from the ladder: one step above a real panel
+ * is a step above what the panel actually painted, not a rung that assumed a
+ * different parent.
+ *
+ * Two edges, both resolved by counting the steps the CLAMPED rung actually
+ * costs rather than the delta that was asked for:
+ *
+ *  - a delta that runs off the top asks for the rung it landed on, not for more
+ *    steps than the ladder has (`level 1 + 3` is rung 3, i.e. two steps);
+ *  - a NEGATIVE delta is a question about what is BELOW the published surface,
+ *    and an exact fill says nothing about that — the ladder is the only thing
+ *    that can answer, so it does, instead of clamping to the fill and labelling
+ *    it with a rung it is not.
+ */
+export declare function useSurfaceLevel(delta?: number): SurfaceLevelPaint;
+/**
+ * Just the ambient fill — for a control that only needs to know what is behind
+ * it, and for chrome that has to BE that colour (an opaque sticky header over a
+ * scrolling column, a tab bar, a search field's backing).
+ *
+ * This is the one to reach for over `theme.colors.card`: `card` is a palette
+ * token — the colour a CARD paints — and it is right only for as long as the
+ * surface you happen to be inside is a card. This answers what the surface
+ * around you actually painted, whatever that surface turns out to be, so the
+ * app does not repeat a guess at every call site and does not have to be swept
+ * when a container changes what it paints.
+ */
+export declare function useSurfaceFill(): string;
+/**
+ * The inline style that gives a focus ring's GAP the colour of the surface
+ * behind the control.
+ *
+ * `styles/interactive-web-css.ts` `RING_OFFSET_VAR` explains why the gap is a
+ * variable at all: as the literal `#FFFFFF` it drew a 2px white halo around
+ * every focused chip, stepper and slider thumb in dark mode. Spread it into the
+ * control's own `style` alongside its accent ring variable.
+ */
+export declare function useRingOffsetStyle(): Record<string, string>;
+export {};
+//# sourceMappingURL=surface-levels.d.ts.map