@everfur/sdk 0.3.0 → 0.5.0

package/dist/tokens-CIngRkvt.d.ts

@@ -0,0 +1,362 @@
+/** The fixed set of slot names, in the order the surfaces list them. */
+declare const THEME_SLOT_NAMES: readonly ["composerInput", "sendButton", "userBubble", "assistantBubble", "recordCard", "vetVisitButton", "primaryButton", "link"];
+type EverfurThemeSlotName = (typeof THEME_SLOT_NAMES)[number];
+/** The allow-listed paint keys a slot accepts. */
+declare const THEME_SLOT_KEYS: readonly ["backgroundColor", "borderColor", "borderRadius", "textColor"];
+type EverfurThemeSlotKey = (typeof THEME_SLOT_KEYS)[number];
+/** One slot's paint: every key optional; a key that is absent keeps the surface's own token. */
+interface EverfurThemeSlot {
+    /** Normalized colour (`#RRGGBB` or `rgba(...)`). */
+    readonly backgroundColor?: string;
+    readonly borderColor?: string;
+    /** A corner radius in dp/px; never negative. */
+    readonly borderRadius?: number;
+    /**
+     * Normalized colour; guarded at 4.5:1 against `backgroundColor`, or against the slot's default ground when the
+     * slot sets no background (see `guardSlotContrast`).
+     */
+    readonly textColor?: string;
+}
+/** The slot map a resolved theme carries: only the slots that were set, each frozen. */
+type EverfurThemeSlots = Readonly<Partial<Record<EverfurThemeSlotName, EverfurThemeSlot>>>;
+/** The minimum text-on-background ratio a slot may paint (WCAG AA body text). */
+declare const SLOT_MIN_CONTRAST = 4.5;
+/**
+ * Parse an untrusted `slots` blob into the typed slot map. Unknown slot names and unknown keys are ignored, a
+ * malformed colour or radius is dropped, and a slot left with no valid key is dropped. Returns null when nothing
+ * valid remains (callers read null as "unset"). Never throws.
+ */
+declare function parseThemeSlots(json: unknown): EverfurThemeSlots | null;
+/**
+ * Overlay `over` onto `base` slot by slot: a slot the overlay names REPLACES the base slot whole (the backend's
+ * overlay unit, so `slots.<name>` locks and overlays agree); a slot it does not name is kept. Either side may be
+ * null. Returns a frozen map (the same reference when one side is null or empty).
+ */
+declare function mergeThemeSlots(base: EverfurThemeSlots | null, over: EverfurThemeSlots | null): EverfurThemeSlots;
+/** The minimum ratio a slot's edge may reach on its ground (WCAG 1.4.11, the boundary of a control). */
+declare const SLOT_MIN_BORDER_CONTRAST = 3;
+/**
+ * The ground each slot's text sits on when the slot sets no background of its own: the surface's default paint
+ * at that place, as the resolver knows it. Every slot lists at least one ground; a text colour must read on all
+ * of them (the link list names every ground a text link is drawn on).
+ */
+type SlotGrounds = Readonly<Record<EverfurThemeSlotName, readonly string[]>>;
+/**
+ * The contrast guard: every text colour a slot paints must reach `SLOT_MIN_CONTRAST` on the ground it is drawn on,
+ * and every edge `SLOT_MIN_BORDER_CONTRAST` on the fill it bounds.
+ *   - A TRANSLUCENT background whose seats straddle the white/black crossover is collapsed to the opaque colour
+ *     it shows over the slot's primary ground FIRST (`collapseUnsatisfiableFill`), because such a slot has no
+ *     readable ink while it means two colours at once. Everything below then measures against one seat.
+ *   - A slot that supplies a background: its ink is measured on that fill AS THE EYE SEES IT (`seatsOf`, the fill
+ *     composited onto the surface's default ground at that slot), and a missing or failing one is replaced by the
+ *     ink that fill is guaranteed to carry (`legibleOn`), then pushed until it reads on every seat.
+ *   - A slot without one: its `textColor` is measured on the slot's DEFAULT ground (`grounds`, the surface's own
+ *     paint there) and, when it fails, pushed toward the legible pole of that ground until it reads, so a text-only
+ *     slot can never paint invisible text either. Without `grounds` such a slot keeps its colour as supplied.
+ *   - An edge (`borderColor`) is measured on the fill it bounds (the same seats) and pushed the same way when it
+ *     reads below 3:1.
+ * Returns the same reference when nothing changes.
+ */
+declare function guardSlotContrast(slots: EverfurThemeSlots, grounds?: SlotGrounds): EverfurThemeSlots;
+
+/** Recursively freeze a plain object/array tree in place and return it (typed as the input). */
+declare function deepFreeze<T>(value: T): T;
+/** Foreground text tokens; the semantic text ramp over surfaces. */
+interface EverfurTextColorTokens {
+    readonly primary: string;
+    readonly secondary: string;
+    readonly muted: string;
+    /** The composer placeholder ink (the Everfur app's `rgba(61,61,61,0.75)`, 5:1 on cream; a lifted twin on dark). */
+    readonly placeholder: string;
+    /** Text drawn on the brand fill (a compiled default; resolve recomputes onPrimary/onAccent via WCAG). */
+    readonly onBrand: string;
+    readonly metaCool: string;
+    /** The message timestamp and copy glyph under a bubble (the Everfur app's footer ink; a lifted twin on dark). */
+    readonly timestamp: string;
+}
+/** The Everfur color system: brand + surfaces + text ramp + semantic palette + component washes. */
+interface EverfurColorTokens {
+    readonly brand: string;
+    readonly brandSoft: string;
+    readonly brandSofter: string;
+    readonly brandBorder: string;
+    readonly borderHairlineGreen: string;
+    /**
+     * The brand at 55%: the edge of a FORM CONTROL (a text field, a text area, a radio) and of a floating card over
+     * the chat (the attachment popover, the Everfur app's). The resolver guarantees it reads at 3:1 (WCAG 1.4.11) on
+     * every ground a control sits on, pushing a partner brand that does not; `brandBorder` and `borderHairlineGreen`
+     * are decorative hairlines (1.4:1 and 1.6:1) and never the only edge of a control.
+     */
+    readonly brandBorderStrong: string;
+    /**
+     * The brand as TEXT or ICON ink. The resolver derives it from `brand`, pushed toward black (light palette) or
+     * white (dark palette) until it reads at 4.5:1 on every ground of the palette, so a light partner colour
+     * (yellow, mint, sky) keeps its hue as a fill and still reads as a label. Never use `brand` itself as ink.
+     */
+    readonly brandInk: string;
+    /**
+     * The ink of a TEXT LINK (citation titles, the disclaimer's links, "earlier messages", record document
+     * links): the `link` slot's text colour, else `accent`, guarded by the resolver at 4.5:1 on every ground a
+     * link sits on. `accent` is the link and highlight colour; this is its legible ink.
+     */
+    readonly linkInk: string;
+    readonly surface: string;
+    readonly surfaceCream: string;
+    readonly surfaceSubtle: string;
+    readonly background: string;
+    readonly borderRingCream: string;
+    /**
+     * The chat ground: the surface the thread, the empty state and the composer sit on. White by default (the
+     * Everfur app's shell); `surface_style` picks it. Kept apart from `surfaceCream` so choosing a ground never
+     * repaints the composer or the record cards.
+     */
+    readonly chatGround: string;
+    /** The composer pill's fill: the Everfur app's fixed cream, whatever `surface_style` picks for the ground. */
+    readonly composerFill: string;
+    /** The composer pill's edge: the brand at 75% (the Everfur app's, 5:1 on white). */
+    readonly composerBorder: string;
+    /** The colour of the soft lift under a floating control (the composer, the popover): the Everfur app's. */
+    readonly shadow: string;
+    readonly text: EverfurTextColorTokens;
+    /** The primary CTA fill (server-overridable via primary_color). Foreground is `onPrimary`. */
+    readonly primary: string;
+    /** WCAG-legible foreground for `primary` (computed by resolveTheme, never passed through). */
+    readonly onPrimary: string;
+    /** The user/CTA accent fill (server-overridable via accent_color). Foreground is `onAccent`. */
+    readonly accent: string;
+    /** WCAG-legible foreground for `accent` (computed by resolveTheme). */
+    readonly onAccent: string;
+    /** The 0.5px bubble edge (a lightened brand / success green for the default). */
+    readonly accentEdge: string;
+    readonly success: string;
+    readonly danger: string;
+    readonly errorRed: string;
+    readonly warningStrong: string;
+    readonly cautionAccent: string;
+    readonly riskConcern: string;
+    /**
+     * The three feedback thumbs under an assistant reply, the Everfur app's Figma strokes: `up` (helpful) green,
+     * `neutral` amber, `down` (not helpful) red. The stroke at rest and the fill once recorded.
+     */
+    readonly sentiment: {
+        readonly up: string;
+        readonly neutral: string;
+        readonly down: string;
+    };
+    readonly badgeBgPositive: string;
+    readonly badgeBgCaution: string;
+    readonly badgeBgCritical: string;
+    readonly badgeBgNeutral: string;
+    /** user bubble = accent fill; assistant bubble = bare surface (the mobile/Flutter asymmetry). */
+    readonly bubbleUser: string;
+    readonly bubbleAssistant: string;
+    readonly skeleton: string;
+    readonly scanButtonPink: string;
+    readonly checkupCardLowRiskBg: string;
+    readonly checkupCardConcernBg: string;
+}
+/** Spacing scale (dp). */
+interface EverfurSpaceTokens {
+    readonly xs: number;
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+    readonly xl: number;
+    readonly xxl: number;
+}
+/** Corner-radius scale (dp); `pill` is an effectively-infinite radius. */
+interface EverfurRadiusTokens {
+    readonly tile: number;
+    readonly xs: number;
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+    readonly xl: number;
+    readonly pill: number;
+}
+interface EverfurTypeSizeTokens {
+    readonly nano: number;
+    readonly small: number;
+    readonly micro: number;
+    readonly tiny: number;
+    readonly caption: number;
+    readonly bodyTight: number;
+    readonly body: number;
+    readonly subtitle: number;
+    readonly heading: number;
+    readonly verdict: number;
+}
+/** Line-height multipliers (applied to a size to derive an absolute lineHeight). */
+interface EverfurLineHeightTokens {
+    readonly tight: number;
+    readonly snug: number;
+    readonly normal: number;
+    readonly relaxed: number;
+}
+/**
+ * RN-assignable font-weight literals. Typed as the exact string literals we ship (not bare `string`) so a
+ * consumer can spread a weight token straight into a `Text` style: React Native's `TextStyle['fontWeight']`
+ * accepts these, but rejects `string`. Kept framework-free (no react-native import) to hold the client layer's
+ * no-framework boundary - these three literals are a subset of RN's fontWeight union.
+ */
+type EverfurFontWeight = '400' | '500' | '700';
+/** RN fontWeight tokens. */
+interface EverfurWeightTokens {
+    readonly regular: EverfurFontWeight;
+    readonly medium: EverfurFontWeight;
+    readonly bold: EverfurFontWeight;
+}
+interface EverfurLetterSpacingTokens {
+    readonly eyebrow: number;
+    readonly monoWide: number;
+    readonly headerBrand: number;
+    readonly tight: number;
+}
+/**
+ * The faces a theme names: the three text weights and the three mono weights (the Everfur app registers
+ * `AzeretMono-Regular`, `-Medium` and `-Bold`). A missing weight falls back along its chain: bold -> medium ->
+ * regular, monoBold -> monoMedium -> mono.
+ */
+type EverfurFontFaceKey = 'regular' | 'medium' | 'bold' | 'mono' | 'monoMedium' | 'monoBold';
+/**
+ * The text-scale tiers of the Everfur app (`fontScaling.ts`): how far a class of text may follow the user's text
+ * size. Flowing `content` (message bodies, card bodies, list rows) is never capped; the bounded chrome is:
+ * `heading` 2x, `control` (buttons) 1.8x, `compact` (chips, pills, inline meta) 1.5x, `badge` 1.3x.
+ */
+type EverfurTextScaleTier = 'content' | 'heading' | 'control' | 'compact' | 'badge';
+/**
+ * The cap of each tier, React Native's `maxFontSizeMultiplier` semantics: 0 means no maximum. The Everfur app's
+ * values, verbatim. A tenant's `accessibility_max_font_scale` may lower the chrome tiers further, never content.
+ */
+declare const TEXT_SCALE_TIER_CAPS: Readonly<Record<EverfurTextScaleTier, number>>;
+/** The family rendered at each face. Every entry is populated (the compiled default is the platform font). */
+type EverfurFontFamilies = Readonly<Record<EverfurFontFaceKey, string>>;
+/**
+ * Typography tokens. `families` is the family per face; a branding sets them through `fonts` (one registered
+ * face per weight, the Everfur app's own scheme) or the legacy single `font_family`, else the platform font.
+ * `family` / `mono` / `fontUrl` are aliases of the regular and mono entries, kept for every reader of the
+ * pre-`families` shape. A surface never reads these raw: `face(theme, weight)` (typeStyle.ts) picks the
+ * family and decides whether a numeric `fontWeight` belongs beside it.
+ */
+interface EverfurTypeTokens {
+    /** Alias of `families.regular`. */
+    readonly family: string;
+    /** Alias of `families.mono`. */
+    readonly mono: string;
+    /** Alias of `fontUrls.regular`; null unless an override supplies an https URL. */
+    readonly fontUrl: string | null;
+    readonly families: EverfurFontFamilies;
+    /**
+     * Per face: true when `families[face]` is a NAMED face from a `fonts` map (the weight is baked into the
+     * registered face, so `face()` sets no `fontWeight`); false when it is a base family (`font_family` or the
+     * platform font) that carries every weight and takes the numeric `weight` token.
+     */
+    readonly namedFaces: Readonly<Record<EverfurFontFaceKey, boolean>>;
+    /** The brand-font URL per face (web only, `font_urls` / `font_url`); absent or null when none applies. */
+    readonly fontUrls: Readonly<Partial<Record<EverfurFontFaceKey, string | null>>>;
+    /**
+     * The type scale. On the web it ALREADY carries `scale` (CSS px do not follow the user's text setting on their
+     * own); on React Native it is the authored size, which the platform scales natively up to `maxScale`.
+     */
+    readonly size: EverfurTypeSizeTokens;
+    readonly lineHeight: EverfurLineHeightTokens;
+    readonly weight: EverfurWeightTokens;
+    readonly letterSpacing: EverfurLetterSpacingTokens;
+    /**
+     * `size` per text-scale tier (`EverfurTextScaleTier`). On the web each tier carries the user's scale up to that
+     * tier's cap (`content` is `size` itself, uncapped); on React Native every tier is the authored `size` and the
+     * platform scales it natively under the tier's `maxFontSizeMultiplier` (`scaleCaps`, applied by the SDK's `Text`).
+     */
+    readonly tierSizes: Readonly<Record<'content' | 'heading' | 'control' | 'compact' | 'badge', EverfurTypeSizeTokens>>;
+    /** The end user's effective text scale (their device setting, floored at `TEXT_SCALE_FLOOR`); 1 when unknown. */
+    readonly scale: number;
+    /**
+     * The tenant's cap on the CHROME tiers (`accessibility_max_font_scale`): 0 means none (the default), so the
+     * tier caps alone bound headings, controls, chips and badges. Flowing content is never capped.
+     */
+    readonly maxScale: number;
+    /**
+     * The effective cap of each tier (`EverfurTextScaleTier`): the tier's own cap, lowered by `maxScale` for the
+     * chrome tiers; 0 means none (React Native's `maxFontSizeMultiplier` semantics).
+     */
+    readonly scaleCaps: Readonly<Record<'content' | 'heading' | 'control' | 'compact' | 'badge', number>>;
+}
+interface EverfurSpringToken {
+    readonly damping: number;
+    readonly stiffness: number;
+}
+interface EverfurMotionDurationTokens {
+    readonly instant: number;
+    readonly fast: number;
+    readonly normal: number;
+    readonly slow: number;
+}
+/** Motion tokens. Under reduced-motion, resolveTheme collapses durations to 0 and stiffens the spring. */
+interface EverfurMotionTokens {
+    readonly duration: EverfurMotionDurationTokens;
+    readonly spring: {
+        readonly gentle: EverfurSpringToken;
+    };
+    /**
+     * The Everfur app's curves as CSS `cubic-bezier()` values: `standard` for most transitions, `emphasized` for an
+     * entrance that should draw the eye, `exit` for a leave. `EASING_CURVES` holds the same curves as numbers.
+     */
+    readonly easing: {
+        readonly standard: string;
+        readonly emphasized: string;
+        readonly exit: string;
+    };
+    /** true when the resolved theme has collapsed motion (AccessibilityInfo reduced-motion). */
+    readonly reducedMotion: boolean;
+}
+/** Non-visual identity + partner copy carried on the theme (server display_name/logo_url/placeholder overlay). */
+interface EverfurThemeMeta {
+    readonly displayName: string;
+    readonly logoUrl: string | null;
+    /** Server-overridable composer placeholder (chat_placeholder/placeholder); null keeps Everfur's neutral default. */
+    readonly placeholder: string | null;
+    /** White-label switch (hide_powered_by): drop the "powered by everfur" attribution. Default false (shown). */
+    readonly hidePoweredBy: boolean;
+}
+/**
+ * The frozen, never-null theme the rn layer renders. Read a token as `theme.color.brand`,
+ * `theme.space.md`, `theme.type.size.body`, `theme.radius.lg`, `theme.motion.duration.fast`; a slot's paint
+ * as `theme.slots.userBubble?.backgroundColor`.
+ */
+interface EverfurTheme {
+    readonly brightness: 'light' | 'dark';
+    /** true when the user asked for more contrast (`prefers-contrast: more`) and the palette was derived for it. */
+    readonly highContrast: boolean;
+    readonly meta: EverfurThemeMeta;
+    readonly color: EverfurColorTokens;
+    readonly space: EverfurSpaceTokens;
+    readonly radius: EverfurRadiusTokens;
+    readonly type: EverfurTypeTokens;
+    readonly motion: EverfurMotionTokens;
+    /** Paint overrides at the named slots (empty by default); each text colour is contrast-guarded. */
+    readonly slots: EverfurThemeSlots;
+}
+/**
+ * The tenant's chrome cap when it sets none (`accessibility_max_font_scale`): 0, no cap beyond the tiers of
+ * `TEXT_SCALE_TIER_CAPS`, the Everfur app's own policy.
+ */
+declare const DEFAULT_MAX_FONT_SCALE = 0;
+/** The RN token that means "the platform font"; every face of the compiled default. */
+declare const SYSTEM_FONT_FAMILY = "System";
+/**
+ * The generic mono keyword of the compiled default. React Native on iOS has no family of that name, so the
+ * React Native host maps it per platform (Menlo on iOS); the web host maps it to its mono stack.
+ */
+declare const SYSTEM_MONO_FAMILY = "monospace";
+/** A cubic-bezier as its four control values (`[x1, y1, x2, y2]`). */
+type EverfurEasingCurve = readonly [number, number, number, number];
+/** The Everfur app's easing curves (`src/motion/tokens.ts`), as numbers; `motion.easing` holds them as CSS. */
+declare const EASING_CURVES: Readonly<Record<'standard' | 'emphasized' | 'exit', EverfurEasingCurve>>;
+/** `cubic-bezier(x1, y1, x2, y2)` for a curve. */
+declare function cssCubicBezier(curve: EverfurEasingCurve): string;
+/** The compiled LIGHT default (deeply frozen). */
+declare const EVERFUR_LIGHT: EverfurTheme;
+/** The compiled DARK default (deeply frozen). */
+declare const EVERFUR_DARK: EverfurTheme;
+
+export { SLOT_MIN_CONTRAST as A, SYSTEM_FONT_FAMILY as B, SYSTEM_MONO_FAMILY as C, DEFAULT_MAX_FONT_SCALE as D, type EverfurTheme as E, type SlotGrounds as F, TEXT_SCALE_TIER_CAPS as G, cssCubicBezier as H, deepFreeze as I, guardSlotContrast as J, mergeThemeSlots as K, parseThemeSlots as L, SLOT_MIN_BORDER_CONTRAST as S, THEME_SLOT_KEYS as T, type EverfurFontWeight as a, type EverfurFontFaceKey as b, type EverfurThemeSlotName as c, type EverfurThemeSlots as d, type EverfurColorTokens as e, type EverfurFontFamilies as f, type EverfurLetterSpacingTokens as g, type EverfurLineHeightTokens as h, type EverfurMotionDurationTokens as i, type EverfurMotionTokens as j, type EverfurRadiusTokens as k, type EverfurSpaceTokens as l, type EverfurSpringToken as m, type EverfurTextColorTokens as n, type EverfurThemeMeta as o, type EverfurThemeSlot as p, type EverfurThemeSlotKey as q, type EverfurTypeSizeTokens as r, type EverfurTypeTokens as s, type EverfurWeightTokens as t, THEME_SLOT_NAMES as u, EASING_CURVES as v, EVERFUR_DARK as w, EVERFUR_LIGHT as x, type EverfurEasingCurve as y, type EverfurTextScaleTier as z };

package/dist/typeStyle-DHJzDaUo.d.cts

@@ -0,0 +1,112 @@
+import { C as ClientBranding, E as EverfurThemeInput } from './branding-Xb_wL8N1.cjs';
+import { E as EverfurTheme, a as EverfurFontWeight, b as EverfurFontFaceKey } from './tokens-CIngRkvt.cjs';
+
+/**
+ * Overlay `b` onto `base`, field by field: a non-null branding field WINS; a null field KEEPS the base. A
+ * valid brightness re-selects the matching compiled palette (light/dark); an invalid/absent brightness leaves
+ * the base palette untouched. Slots merge per slot, per key. Returns a NEW deeply-frozen theme; `base` and `b`
+ * are never mutated.
+ *
+ * The name is historical (the server was once the only overlay); `resolveTheme` applies it twice, server then
+ * client, which is how the client wins per field. NOTE: foreground legibility (onPrimary/onAccent, the slot
+ * guard) and URL hardening are applied by `resolveTheme`, the total entry point. Call this directly only when
+ * you will finalize the result yourself.
+ */
+declare function withServerBranding(base: EverfurTheme, b: ClientBranding | null): EverfurTheme;
+/**
+ * Inputs to the total theme resolve. All optional; `resolveTheme(undefined)` yields the compiled Everfur
+ * default. Merge order: compiled default <- server branding (render_hints) <- client theme prop, per field, with
+ * the tenant's locked fields and the attribution kept from the server (see `resolveTheme`).
+ */
+interface ResolveThemeInput {
+    /** Server-driven branding from the live entitlements render_hints (the tenant's console branding). */
+    readonly branding?: ClientBranding | null;
+    /**
+     * The clamped client `theme` prop. It WINS per cosmetic field over the server branding, except the fields the
+     * server lists in `locked_fields`. Its hidePoweredBy is IGNORED: whether the Everfur attribution shows is
+     * decided by server branding alone.
+     */
+    readonly clientOverride?: ClientBranding | null;
+    /**
+     * The device color scheme (useColorScheme / `prefers-color-scheme`). Read ONLY when the settled brightness is
+     * `auto` (an explicit opt-in); with no brightness set anywhere the theme is light, as Everfur's own apps are.
+     */
+    readonly colorScheme?: 'light' | 'dark' | null;
+    /** AccessibilityInfo reduced-motion / `prefers-reduced-motion`: collapses the motion tokens. */
+    readonly reducedMotion?: boolean;
+    /**
+     * The user's text scale as the host reads it (React Native: `PixelRatio.getFontScale()`; the browser: the
+     * browser's default font size over 16px). Floored at `TEXT_SCALE_FLOOR`; absent or junk reads as 1. Flowing
+     * content follows it uncapped; each chrome tier follows it up to that tier's cap (`type.scaleCaps`).
+     */
+    readonly textScale?: number;
+    /**
+     * Multiply the type sizes by the effective scale, per tier (`type.size` for content, `type.tierSizes` for every
+     * tier). A browser host passes true (CSS px do not follow the user's setting on their own); a React Native host
+     * leaves it false and lets the platform scale every Text natively, capped per tier by `maxFontSizeMultiplier`.
+     */
+    readonly scaleTypeSizes?: boolean;
+    /** The user asked for more contrast (`prefers-contrast: more`): the palette is derived by `deriveHighContrast`. */
+    readonly highContrast?: boolean;
+    /**
+     * The family the platform's generic mono keyword (`SYSTEM_MONO_FAMILY`) maps to on this host. React Native on iOS
+     * has no family named `monospace` (a Text asking for it renders proportional, and the legacy architecture
+     * red-boxes in development), so the React Native host passes `Menlo` there. Applied to the compiled default mono
+     * only: a partner's own mono face is never touched. Absent or blank, the keyword stands (the web maps it to its
+     * mono stack in CSS).
+     */
+    readonly platformMonoFamily?: string;
+    /**
+     * Whether a family name is registered with the platform, when the host can tell: true or false, else null. A
+     * NAMED face (one per-weight name, rendered without a weight) that the host reports unregistered falls back to
+     * the platform font of its group WITH its numeric weight, so medium and bold survive instead of every weight
+     * collapsing to the platform's regular. Only named faces are asked about; a throw reads as null.
+     */
+    readonly isFontRegistered?: (family: string) => boolean | null;
+}
+/** The smallest effective text scale the resolver will report (a device may ask for less; the surfaces stop here). */
+declare const TEXT_SCALE_FLOOR = 0.5;
+/**
+ * Resolve the final, legible, deeply-frozen theme. Never throws, never returns null/transparent.
+ *
+ * PRECEDENCE (per field, owner decision of 18 September 2026; the same rule EFBackend render_hint_fold states):
+ * a field in `locked_fields` (plus `hide_powered_by` always) is server-wins; every other cosmetic field is
+ * client-wins.
+ *   - A server branding with an unknown `schema_version` is dropped whole (default plus client theme).
+ *   - `hide_powered_by`, and every name the server lists in `locked_fields`, are SERVER-WINS: the client's value
+ *     for such a field is discarded before the merge, so the server's value or the compiled default stands.
+ *     `slots` in the list locks every slot; `slots.<name>` locks one.
+ *   - Every other cosmetic field is CLIENT-WINS: the client `theme` prop overrides the console value, and the
+ *     console fills the fields the prop leaves unset. Brightness is settled the same way; set nowhere, it is
+ *     LIGHT (owner decision OD28: Everfur's own apps are light-only), and `auto` follows the device scheme.
+ *   - Slots overlay slot by slot (a named slot replaces the one below it whole) in the same order, after the
+ *     field precedence.
+ * Then the total-resolve guarantees: onPrimary/onAccent via WCAG, the slot contrast guard, https-only logo/font
+ * URLs, a non-empty displayName, the text scale (floored; tiered caps on the chrome), motion collapsed under reduced
+ * motion, and the high-contrast derivation when the user asked for it.
+ */
+declare function resolveTheme(input?: ResolveThemeInput): EverfurTheme;
+/**
+ * The console's preview helper: resolve a draft branding exactly as the device would, from the raw shapes (the
+ * partner's `theme` prop and the server-shaped branding object the console is about to publish), with the device
+ * inputs of the preview. Pure and total: any shape is tolerated, nothing throws.
+ */
+declare function previewTheme(input: EverfurThemeInput | null, hints: unknown, options?: Omit<ResolveThemeInput, 'branding' | 'clientOverride'>): EverfurTheme;
+
+/**
+ * The text style a surface spreads for one face. `fontWeight` is present ONLY for a base family (the platform
+ * font, the legacy `font_family`, or a `fonts` name repeated across weights); a named face carries its weight
+ * itself. The regular mono face carries no weight (code renders in the regular mono face); its medium and bold
+ * twins (`monoMedium`, `monoBold`) take theirs when the mono family is a base family.
+ */
+interface EverfurFaceStyle {
+    readonly fontFamily: string;
+    readonly fontWeight?: EverfurFontWeight;
+}
+/**
+ * The family (and, for a base family, the numeric weight) of one face of the theme. Spread it into a style:
+ * `{ ...face(theme, 'bold'), fontSize: theme.type.size.body }`. Pure and total over any resolved theme.
+ */
+declare function face(theme: EverfurTheme, weight: EverfurFontFaceKey): EverfurFaceStyle;
+
+export { type EverfurFaceStyle as E, type ResolveThemeInput as R, TEXT_SCALE_FLOOR as T, face as f, previewTheme as p, resolveTheme as r, withServerBranding as w };

package/dist/typeStyle-YPS_MXeI.d.ts

@@ -0,0 +1,112 @@
+import { C as ClientBranding, E as EverfurThemeInput } from './branding-xpQ056sM.js';
+import { E as EverfurTheme, a as EverfurFontWeight, b as EverfurFontFaceKey } from './tokens-CIngRkvt.js';
+
+/**
+ * Overlay `b` onto `base`, field by field: a non-null branding field WINS; a null field KEEPS the base. A
+ * valid brightness re-selects the matching compiled palette (light/dark); an invalid/absent brightness leaves
+ * the base palette untouched. Slots merge per slot, per key. Returns a NEW deeply-frozen theme; `base` and `b`
+ * are never mutated.
+ *
+ * The name is historical (the server was once the only overlay); `resolveTheme` applies it twice, server then
+ * client, which is how the client wins per field. NOTE: foreground legibility (onPrimary/onAccent, the slot
+ * guard) and URL hardening are applied by `resolveTheme`, the total entry point. Call this directly only when
+ * you will finalize the result yourself.
+ */
+declare function withServerBranding(base: EverfurTheme, b: ClientBranding | null): EverfurTheme;
+/**
+ * Inputs to the total theme resolve. All optional; `resolveTheme(undefined)` yields the compiled Everfur
+ * default. Merge order: compiled default <- server branding (render_hints) <- client theme prop, per field, with
+ * the tenant's locked fields and the attribution kept from the server (see `resolveTheme`).
+ */
+interface ResolveThemeInput {
+    /** Server-driven branding from the live entitlements render_hints (the tenant's console branding). */
+    readonly branding?: ClientBranding | null;
+    /**
+     * The clamped client `theme` prop. It WINS per cosmetic field over the server branding, except the fields the
+     * server lists in `locked_fields`. Its hidePoweredBy is IGNORED: whether the Everfur attribution shows is
+     * decided by server branding alone.
+     */
+    readonly clientOverride?: ClientBranding | null;
+    /**
+     * The device color scheme (useColorScheme / `prefers-color-scheme`). Read ONLY when the settled brightness is
+     * `auto` (an explicit opt-in); with no brightness set anywhere the theme is light, as Everfur's own apps are.
+     */
+    readonly colorScheme?: 'light' | 'dark' | null;
+    /** AccessibilityInfo reduced-motion / `prefers-reduced-motion`: collapses the motion tokens. */
+    readonly reducedMotion?: boolean;
+    /**
+     * The user's text scale as the host reads it (React Native: `PixelRatio.getFontScale()`; the browser: the
+     * browser's default font size over 16px). Floored at `TEXT_SCALE_FLOOR`; absent or junk reads as 1. Flowing
+     * content follows it uncapped; each chrome tier follows it up to that tier's cap (`type.scaleCaps`).
+     */
+    readonly textScale?: number;
+    /**
+     * Multiply the type sizes by the effective scale, per tier (`type.size` for content, `type.tierSizes` for every
+     * tier). A browser host passes true (CSS px do not follow the user's setting on their own); a React Native host
+     * leaves it false and lets the platform scale every Text natively, capped per tier by `maxFontSizeMultiplier`.
+     */
+    readonly scaleTypeSizes?: boolean;
+    /** The user asked for more contrast (`prefers-contrast: more`): the palette is derived by `deriveHighContrast`. */
+    readonly highContrast?: boolean;
+    /**
+     * The family the platform's generic mono keyword (`SYSTEM_MONO_FAMILY`) maps to on this host. React Native on iOS
+     * has no family named `monospace` (a Text asking for it renders proportional, and the legacy architecture
+     * red-boxes in development), so the React Native host passes `Menlo` there. Applied to the compiled default mono
+     * only: a partner's own mono face is never touched. Absent or blank, the keyword stands (the web maps it to its
+     * mono stack in CSS).
+     */
+    readonly platformMonoFamily?: string;
+    /**
+     * Whether a family name is registered with the platform, when the host can tell: true or false, else null. A
+     * NAMED face (one per-weight name, rendered without a weight) that the host reports unregistered falls back to
+     * the platform font of its group WITH its numeric weight, so medium and bold survive instead of every weight
+     * collapsing to the platform's regular. Only named faces are asked about; a throw reads as null.
+     */
+    readonly isFontRegistered?: (family: string) => boolean | null;
+}
+/** The smallest effective text scale the resolver will report (a device may ask for less; the surfaces stop here). */
+declare const TEXT_SCALE_FLOOR = 0.5;
+/**
+ * Resolve the final, legible, deeply-frozen theme. Never throws, never returns null/transparent.
+ *
+ * PRECEDENCE (per field, owner decision of 18 September 2026; the same rule EFBackend render_hint_fold states):
+ * a field in `locked_fields` (plus `hide_powered_by` always) is server-wins; every other cosmetic field is
+ * client-wins.
+ *   - A server branding with an unknown `schema_version` is dropped whole (default plus client theme).
+ *   - `hide_powered_by`, and every name the server lists in `locked_fields`, are SERVER-WINS: the client's value
+ *     for such a field is discarded before the merge, so the server's value or the compiled default stands.
+ *     `slots` in the list locks every slot; `slots.<name>` locks one.
+ *   - Every other cosmetic field is CLIENT-WINS: the client `theme` prop overrides the console value, and the
+ *     console fills the fields the prop leaves unset. Brightness is settled the same way; set nowhere, it is
+ *     LIGHT (owner decision OD28: Everfur's own apps are light-only), and `auto` follows the device scheme.
+ *   - Slots overlay slot by slot (a named slot replaces the one below it whole) in the same order, after the
+ *     field precedence.
+ * Then the total-resolve guarantees: onPrimary/onAccent via WCAG, the slot contrast guard, https-only logo/font
+ * URLs, a non-empty displayName, the text scale (floored; tiered caps on the chrome), motion collapsed under reduced
+ * motion, and the high-contrast derivation when the user asked for it.
+ */
+declare function resolveTheme(input?: ResolveThemeInput): EverfurTheme;
+/**
+ * The console's preview helper: resolve a draft branding exactly as the device would, from the raw shapes (the
+ * partner's `theme` prop and the server-shaped branding object the console is about to publish), with the device
+ * inputs of the preview. Pure and total: any shape is tolerated, nothing throws.
+ */
+declare function previewTheme(input: EverfurThemeInput | null, hints: unknown, options?: Omit<ResolveThemeInput, 'branding' | 'clientOverride'>): EverfurTheme;
+
+/**
+ * The text style a surface spreads for one face. `fontWeight` is present ONLY for a base family (the platform
+ * font, the legacy `font_family`, or a `fonts` name repeated across weights); a named face carries its weight
+ * itself. The regular mono face carries no weight (code renders in the regular mono face); its medium and bold
+ * twins (`monoMedium`, `monoBold`) take theirs when the mono family is a base family.
+ */
+interface EverfurFaceStyle {
+    readonly fontFamily: string;
+    readonly fontWeight?: EverfurFontWeight;
+}
+/**
+ * The family (and, for a base family, the numeric weight) of one face of the theme. Spread it into a style:
+ * `{ ...face(theme, 'bold'), fontSize: theme.type.size.body }`. Pure and total over any resolved theme.
+ */
+declare function face(theme: EverfurTheme, weight: EverfurFontFaceKey): EverfurFaceStyle;
+
+export { type EverfurFaceStyle as E, type ResolveThemeInput as R, TEXT_SCALE_FLOOR as T, face as f, previewTheme as p, resolveTheme as r, withServerBranding as w };

package/dist/{useRecordsDepth-BHBzJ76R.d.cts → useRecordsDepth-Bnw36jPr.d.cts}

@@ -1,7 +1,8 @@
 import { R as RecordsRequestId, P as PetRef } from './ids-B2GAAifq.cjs';
-import { a5 as RecordsClinicSearchInput, a6 as RecordsClinicSearchPage, a7 as RecordsRecentClinicsInput, a8 as RecordsAuthorizationCopy, a9 as CreateClinicRequestInput, aa as RecordsSignatureUploadPolicy, l as RecordsClinic, O as RecordsClinicBatch, P as RecordsClinicBatchClient, m as RecordsDepthClient } from './depth-CErXCU8J.cjs';
-import { c as EverfurResult, E as EverfurError } from './EverfurResult-DN9pL2Ab.cjs';
-import { f as RecordsRequestGroupView, d as RecordsRequestView } from './models-D2EUxPZY.cjs';
+import { a6 as RecordsClinicSearchInput, a7 as RecordsClinicSearchPage, a8 as RecordsRecentClinicsInput, a9 as RecordsAuthorizationCopy, aa as CreateClinicRequestInput, ab as RecordsSignatureUploadPolicy, l as RecordsClinic, P as RecordsClinicBatch, Q as RecordsClinicBatchClient, m as RecordsDepthClient } from './depth-B3NFKlF9.cjs';
+import { E as EverfurResult } from './EverfurResult-ZtH-YV1h.cjs';
+import { f as RecordsRequestGroupView, d as RecordsRequestView } from './models-Bn2z0NNo.cjs';
+import { E as EverfurError } from './EverfurError-DmELDpXp.cjs';
 
 interface RecordsClinicController {
     searchClinics(input?: RecordsClinicSearchInput): Promise<EverfurResult<RecordsClinicSearchPage>>;
@@ -126,6 +127,15 @@ type RecordsScreen = {
     readonly clinic: ClinicDraft;
 } | {
     readonly name: 'upload';
+}
+/**
+ * Every upload and clinic request for the pet, each with its own status: the consumer's
+ * `RecordsRequestListScreen` (everfur-mobile src/features/records/ui/RecordsRequestListScreen.tsx, the
+ * `/records/requests` route the dashboard's `RecordsRequestsStatusCard` opens). On the web it is the
+ * records page's own request list.
+ */
+ | {
+    readonly name: 'requests';
 };
 interface RecordsNavState {
     readonly stack: readonly RecordsScreen[];
@@ -187,9 +197,18 @@ type RecordsAskHandler = (prompt: string, entityRef: RecordsAskEntityRef) => voi
 
 type ClinicLocation = NonNullable<RecordsClinicSearchInput['location']>;
 
-type RecordsUrlKind = 'share_link' | 'record_pdf';
+/**
+ * What a URL handed to `onOpenUrl` is: a revocable share link, the full record PDF (a short-lived presigned
+ * GET), or one file the member uploaded onto a request (`request_document`, web only; also short-lived).
+ */
+type RecordsUrlKind = 'share_link' | 'record_pdf' | 'request_document';
 interface RecordsHostSeams {
-    /** Open a share link or the record PDF. Default: `Linking.openURL` on React Native, `window.open` on the web. */
+    /**
+     * Share a link, or save or preview a file, your app's way. Default, which never leaves your app: React
+     * Native shares the link through the OS share sheet (`Share.share`) and offers the PDF's short-lived link
+     * the same way (pass this seam to share the FILE, e.g. expo-file-system + expo-sharing); the web shares
+     * the link with `navigator.share`, else copies it, and saves a file in place with no new tab.
+     */
     readonly onOpenUrl?: (url: string, kind: RecordsUrlKind) => void | Promise<void>;
     /** Copy a share link. Web default: `navigator.clipboard.writeText`; React Native has no default (see above). */
     readonly onCopy?: (text: string) => Promise<void>;