@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/_dts/theme-core/src/site-styles/headerRecompile.d.ts

@@ -0,0 +1,118 @@
+import type { Theme, ThemeHeader } from '../schema';
+import { type CuratedSiteStyle } from './curatedSiteStyles';
+import { type HeaderLayoutStyleResolution, type HeaderLayoutStyleSelection } from './headerLayoutStyles';
+import { type HeaderPreferences } from './headerPreferences';
+import { type HeaderInteractionPaletteBytesClassification, type HeaderInteractionPaletteOptionGroup } from './headerInteractionPalette';
+import { type HeaderBrandPresentationBytesClassification } from './headerBrandPresentation';
+import type { HeaderInteractionPalettePreference } from '../header/interactionPalette';
+import type { HeaderBrandPresentationSelection } from './logoBranding';
+import type { ReplacementBrandPresentation } from './compilationPlan';
+export type CuratedHeaderSelectionRepair = Readonly<{
+    kind: 'exact';
+}> | Readonly<{
+    kind: 'repaired';
+    reason: 'style-not-curated-for-layout' | 'layout-not-curated-for-site-style';
+}>;
+export type CuratedHeaderSelectionResolution = Readonly<{
+    resolution: HeaderLayoutStyleResolution;
+    repair: CuratedHeaderSelectionRepair;
+}>;
+/**
+ * Curated repair followed by catalogue repair — the first two steps of the
+ * header compilation pipeline, in one place so no caller re-derives them.
+ */
+export declare function resolveCuratedHeaderSelection(siteStyle: CuratedSiteStyle, requested: HeaderLayoutStyleSelection): CuratedHeaderSelectionResolution;
+/**
+ * Which interaction palette a compilation should use.
+ *
+ * `derive-from-persisted-bytes` is the backfill's answer, and it is a request
+ * rather than a value because the derivation needs the option list the resolved
+ * recipe offers, which only the compilation knows. It mirrors
+ * `ReplacementBrandPresentation`: the caller states what it wants, the
+ * composition resolves it.
+ */
+export type HeaderInteractionPaletteRequest = Readonly<{
+    kind: 'preference';
+    preference: HeaderInteractionPalettePreference;
+}> | Readonly<{
+    kind: 'derive-from-persisted-bytes';
+}>;
+export type CompiledCuratedHeader = Readonly<{
+    /** Recipe and interaction palette only — the structure-derivation baseline. */
+    baseline: ThemeHeader;
+    /** `baseline` with the brand presentation applied, when there is one. */
+    header: ThemeHeader;
+    /** The presentation the request resolved to against the chosen layout. */
+    brandPresentation: HeaderBrandPresentationSelection | null;
+    /**
+     * The palette the resolved recipe offers, so a caller deriving intent from
+     * persisted bytes has the option list without re-resolving the recipe or
+     * guessing at it (#1318 Phase 4c decision 2).
+     */
+    interactionPalette: HeaderInteractionPaletteOptionGroup | undefined;
+    resolution: HeaderLayoutStyleResolution;
+    repair: CuratedHeaderSelectionRepair;
+}>;
+/**
+ * Curated repair → catalogue repair → recipe → interaction palette → brand
+ * presentation. Everything that runs before the preference record, in one
+ * place: `previewCompiler.compileHeaderDirective` and the recompile below are
+ * both callers, so the middle of the pipeline has a single composition.
+ *
+ * `baseline` and `header` are both returned because they answer different
+ * questions. `header` is what a preview wants to render. `baseline` is what
+ * `readHeaderPreferences` compares the persisted bytes against for every field
+ * the presentation does not touch.
+ *
+ * The interaction-palette preference is threaded in through `theme.header`
+ * because that is where `compileHeaderLayoutStyleSelection` reads it from
+ * today; 4b can pass it explicitly once the preferences column exists.
+ */
+export declare function compileHeaderForCuratedSelection(theme: Theme, siteStyle: CuratedSiteStyle, requested: HeaderLayoutStyleSelection, requestedBrandPresentation: ReplacementBrandPresentation, requestedInteractionPalette: HeaderInteractionPaletteRequest): CompiledCuratedHeader;
+export type RecompileSiteChromeHeaderInput = Readonly<{
+    theme: Theme;
+    siteStyle: CuratedSiteStyle;
+    requested: HeaderLayoutStyleSelection;
+    preferences: HeaderPreferences;
+    brandPresentation: ReplacementBrandPresentation;
+}>;
+export type RecompiledSiteChromeHeader = Readonly<{
+    header: ThemeHeader;
+    resolution: HeaderLayoutStyleResolution;
+    repair: CuratedHeaderSelectionRepair;
+}>;
+/**
+ * The whole header pipeline, in one named function so 4b, 4c and 4d cannot
+ * drift into three orders (#1318 Phase 4):
+ *
+ *   curated repair → catalogue repair → recipe → layout defaults
+ *   → interaction palette → structure preferences → brand presentation
+ *   → nav/logo/background preferences
+ */
+export declare function recompileSiteChromeHeader(input: RecompileSiteChromeHeaderInput): RecompiledSiteChromeHeader;
+/**
+ * The read-then-recompile round trip: derive the row's intent from its own
+ * persisted bytes, then rebuild the header from that intent. On a row whose
+ * bytes are compiler output this returns the persisted header unchanged, which
+ * is what the Phase 4c divergence report measures.
+ */
+export declare function recompileSiteChromeHeaderFromPersistedIntent(theme: Theme, siteStyle: CuratedSiteStyle, requested: HeaderLayoutStyleSelection, brandPresentation: ReplacementBrandPresentation): Readonly<{
+    recompiled: RecompiledSiteChromeHeader;
+    preferences: HeaderPreferences;
+    /**
+     * How the row's own bytes answered the interaction-palette question. Reported
+     * rather than folded into `preferences`, because `'unrecognised'` has no
+     * representation there: the record falls back to the marker field, and a
+     * caller that cares — the Phase 4c divergence report — needs to say so rather
+     * than let a pill nobody recognises be dropped on the next recompile.
+     */
+    interactionPaletteBytes: HeaderInteractionPaletteBytesClassification;
+    /**
+     * How the row's own bytes answered the brand-presentation question, reported
+     * for the same reason as the palette: `'unrecognised'` has no representation
+     * in the record, and a caller that cares — the Phase 4c divergence report and
+     * the repair generator — must be able to say so rather than let a logo
+     * treatment nobody recognises be written or dropped.
+     */
+    brandPresentationBytes: HeaderBrandPresentationBytesClassification;
+}>;

package/dist/_dts/theme-core/src/site-styles/headerStyleCompiler.d.ts

@@ -1,4 +1,5 @@
 import type { Theme } from '../schema';
+import type { HeaderInteractionPalettePreference } from '../header/interactionPalette';
 import type { HeaderLayoutStyleResolution } from './headerLayoutTypes';
 import { type HeaderStyleRecipeOwner } from './headerStyleDefaults';
 /**
@@ -13,5 +14,13 @@ import { type HeaderStyleRecipeOwner } from './headerStyleDefaults';
  * site style has to say so, because silently falling back to the catalogue
  * default is exactly the ownership leak this slice closes. Pass `null` when
  * there genuinely is no site style (initial site provisioning).
+ *
+ * `interactionPalette` is a parameter rather than a read off
+ * `theme.header.interactionPalette` (#1318 Phase 4c). The marker field on the
+ * header is where the preference is *persisted*, but taking it from there made
+ * the palette the one preference the compiler could not be told about — which
+ * is invisible while the marker always equals what was compiled and wrong the
+ * moment a backfill supplies a different one. The caller that owns the
+ * preference record now says which palette to compile.
  */
-export declare function compileHeaderLayoutStyleSelection(theme: Theme, resolution: HeaderLayoutStyleResolution, siteStyle: HeaderStyleRecipeOwner | null): Theme['header'];
+export declare function compileHeaderLayoutStyleSelection(theme: Theme, resolution: HeaderLayoutStyleResolution, siteStyle: HeaderStyleRecipeOwner | null, interactionPalette: HeaderInteractionPalettePreference): Theme['header'];

package/dist/_dts/theme-core/src/site-styles/headerStyleDefaults.d.ts

@@ -372,7 +372,7 @@ export declare const defaultHeaderStyleRecipes: {
             id: "interaction-palette";
             label: string;
             options: readonly [import("../../../blocks/src/index").HeaderInteractionPaletteOption, ...import("../../../blocks/src/index").HeaderInteractionPaletteOption[]];
-            defaultOptionId: "accent" | "primary" | "secondary";
+            defaultOptionId: "primary" | "secondary" | "accent" | "quiet";
         }>;
     };
     readonly 'soft-shell': {

package/dist/_dts/theme-core/src/site-styles/headerStyleRecipe.d.ts

@@ -156,6 +156,13 @@ export type HeaderStyleRecipe = HeaderStyleRecipeCore & Readonly<{
 /**
  * The single header interpreter. Pure and total: same `(theme, layout, recipe)`
  * in, same object out, no throws of its own.
+ *
+ * It **constructs** a `ThemeHeader` rather than starting from one (#1318 Phase
+ * 4e). `theme` is read for the palette-dependent facets only — the themed
+ * shadow and the CTA variant — never for `theme.header`, so no value can
+ * survive a recompile by accident. Every required field of `headerSchema` is
+ * produced by a named branch here or in `headerForLayout`; the type is the
+ * check.
  */
 export declare function compileHeaderRecipe(theme: Theme, layout: HeaderLayoutDefinition, recipe: HeaderStyleRecipe): ThemeHeader;
 export {};

package/dist/_dts/theme-core/src/site-styles/index.d.ts

@@ -16,6 +16,11 @@ export * from './generatedSchemas';
 export * from './generatedDesignPipeline';
 export * from './headerLayoutStyles';
 export * from './headerInteractionPalette';
+export * from './headerBrandPresentation';
+export { applyHeaderPreferences, defaultHeaderPreferences, defaultHeaderStructurePreferences, type HeaderLogoTextIntent, type HeaderPreferences, type HeaderQuickControlPreferences, type HeaderStructurePreferences, } from './headerPreferences';
+export { headerPreferencesSchema, headerPreferencesWireSchema, parsePersistedHeaderPreferences, type PersistedHeaderPreferences, } from './headerPreferencesPersistence';
+export { compareCompiledHeaders, type CompiledHeaderComparison, type HeaderFieldDiff, } from './headerBytesComparison';
+export { compileHeaderForCuratedSelection, recompileSiteChromeHeader, recompileSiteChromeHeaderFromPersistedIntent, type CuratedHeaderSelectionRepair, type CompiledCuratedHeader, type HeaderInteractionPaletteRequest, type RecompileSiteChromeHeaderInput, type RecompiledSiteChromeHeader, } from './headerRecompile';
 export * from './headerOpeningForeground';
 export * from './headerOpeningSection';
 export * from './lookResolution';

package/dist/_dts/theme-core/src/site-styles/previewCompiler.d.ts

@@ -4,7 +4,7 @@ import { type ButtonStyleSelection } from '../buttons/styles';
 import { type CuratedSiteStyle } from './curatedSiteStyles';
 import { type FooterLookId } from './footerLooks';
 import type { SiteThemeCompilationPlan } from './compilationPlan';
-import { type HeaderLayoutStyleSelection } from './headerLayoutStyles';
+import type { HeaderLayoutStyleSelection } from './headerLayoutStyles';
 import { type CompiledBlockRuntimeFields, type CompiledBoundaryRuntime, type CompiledPageRuntime, type ComponentRuntimeRules, type DesignRuntimeRules, type SemanticSpacing, type SurfaceResolutionContext } from './runtimeCompiler';
 import { type AppearancePresetId, type DesignBlockId, type SiteStyleId } from './types';
 import { type CuratedSiteStyleTheme } from './siteStyleThemeCompiler';

package/dist/_dts/theme-core/src/site-styles/siteChromeBackgrounds.d.ts

@@ -1,4 +1,4 @@
-import type { Theme } from '../schema';
+import type { Theme, ThemeFooter, ThemeHeader } from '../schema';
 import type { ThemeColorToken } from '../tokens';
 export type SiteChromeSurface = 'header' | 'footer';
 export type SiteChromeBackgroundColorToken = ThemeColorToken & {
@@ -28,3 +28,22 @@ export declare function siteChromeBackgroundOverrideLabel(override: SiteChromeBa
 export declare function formatSiteChromeBackgroundTokenLabel(token: SiteChromeBackgroundColorToken): string;
 export declare function siteChromeBackgroundOverrideEquals(left: SiteChromeBackgroundOverride, right: SiteChromeBackgroundOverride): boolean;
 export declare function cycleSiteChromeBackgroundOverride(current: SiteChromeBackgroundOverride, direction: SiteChromeBackgroundCycleDirection): SiteChromeBackgroundOverride;
+/**
+ * Reads the header background override back out of persisted bytes. Exported
+ * for `readHeaderPreferences`, which needs the header half on its own.
+ */
+export declare function siteChromeBackgroundOverrideFromHeader(header: ThemeHeader): SiteChromeBackgroundOverride;
+/**
+ * Header-only background applier. Exported so the header preference pipeline
+ * can apply the header override without going through
+ * `applySiteChromeBackgroundPreferences`, which also writes the footer and
+ * would clobber footer intent (#1318 Correction 20).
+ */
+export declare function applyHeaderBackgroundOverride(theme: Theme, header: ThemeHeader, override: SiteChromeBackgroundOverride): ThemeHeader;
+/**
+ * Footer-only background applier, the counterpart of
+ * `applyHeaderBackgroundOverride`. Exported so a caller that owns one surface
+ * can write that surface rather than passing a no-op override for the other
+ * (#1318 Correction 20).
+ */
+export declare function applyFooterBackgroundOverride(theme: Theme, footer: ThemeFooter, override: SiteChromeBackgroundOverride): ThemeFooter;

package/dist/_dts/theme-core/src/site-styles/siteChromeNavPreferences.d.ts

@@ -1,6 +1,6 @@
 import type { NavLinkStyle, NavLinkTextSize } from '../navigation/types';
-import type { Theme } from '../schema';
-import type { HeaderInteractionPalettePreference } from '../header/interactionPalette';
+import type { Theme, ThemeHeader } from '../schema';
+import { type HeaderInteractionPalettePreference } from '../header/interactionPalette';
 export declare const headerNavTypographyPreferenceValues: readonly ["inherit", "body", "heading"];
 export type HeaderNavTypographyPreference = (typeof headerNavTypographyPreferenceValues)[number];
 export declare const headerNavFontSizePreferenceValues: readonly ["inherit", "sm", "base", "lg", "xl"];
@@ -61,3 +61,44 @@ export declare function withHeaderNavThemePreferences(theme: Theme, preferences:
  */
 export declare function mergeHeaderNavTypographyPreference(style: NavLinkStyle, preferences: Pick<HeaderNavPreferences, 'typography' | 'fontSize'>): NavLinkStyle;
 export declare function readHeaderNavFontSizePreference(value: NavLinkTextSize | undefined): HeaderNavFontSizePreference;
+/**
+ * `navTextSize` derived as a preference by baseline comparison (#1318 Phase 4c
+ * decision 1) — the same rule the structure fields already use: compare the
+ * persisted value against what the row's own (layout, recipe) compiles, emit
+ * `'inherit'` when they agree and the explicit value when they do not.
+ *
+ * The reason it needs the rule at all is that nav size is one of the fields a
+ * pre-preferences row could only express by carrying it in the compiled bytes:
+ * `heart-led-yoga` and `therese-millar-yoga` persist `navLinkStyle.textSize:
+ * 'lg'` under a `serif-line` recipe that compiles no size, which is a user's
+ * choice sitting in the wrong place. Reading only `header.navTextSize` derives
+ * `'inherit'` there and a recompile would shrink their nav.
+ *
+ * Backfilling the derived value is pixel-preserving because the CSS merge above
+ * makes `{navTextSize: 'lg'}` over a size-less nav link style render exactly
+ * what `{navLinkStyle: {textSize: 'lg'}}` renders.
+ *
+ * **Two cases lose information, and both are accepted rather than accidental.**
+ * The preference vocabulary is `inherit | sm | base | lg | xl` — there is no
+ * value meaning "no size at all" — so `'inherit'` has to carry both of them:
+ *
+ * 1. *Persisted size equals the baseline.* Nothing in the bytes distinguishes
+ *    "chose the size the recipe already compiles" from "never chose", so the
+ *    marker field is dropped on recompile. **Pixel-neutral**: the recipe puts
+ *    the same size back.
+ * 2. *Persisted has no size and the baseline compiles one.* The row renders at
+ *    the browser default and the recipe wants, say, `'sm'`; `'inherit'` is the
+ *    only representable answer, so **the recompile adopts the baseline size and
+ *    the row's sizeless-ness is lost**. This one is *not* pixel-neutral, and
+ *    representing it properly would mean adding a `'none'` arm to the
+ *    preference the way `HeaderStructurePreferences.logoText` has one.
+ *
+ * Case 2 is not silent. Adopting the baseline size is a byte change, so such a
+ * row shows up as divergent in the Phase 4c report (`navLinkStyle.textSize
+ * undefined -> "sm"`) and cannot reach Phase 4e unclassified — the report's
+ * zero-rows gate is the safety net for exactly this. No row in either corpus is
+ * in that state today; if one appears, it is a classification decision (widen
+ * the vocabulary, or accept the size) rather than something this function may
+ * guess at.
+ */
+export declare function readHeaderNavFontSizeAgainstBaseline(persisted: ThemeHeader, compiled: ThemeHeader): HeaderNavFontSizePreference;

package/dist/_dts/theme-core/src/site-styles/tokenRecipes.d.ts

@@ -17,8 +17,8 @@ export declare const themeTokenRecipesSchema: z.ZodObject<{
         "soft-natural": "soft-natural";
     }>;
     contrast: z.ZodEnum<{
-        standard: "standard";
         maximum: "maximum";
+        standard: "standard";
         strong: "strong";
     }>;
     radius: z.ZodEnum<{

package/dist/_dts/theme-core/src/tokens/themeColorTokens.d.ts

@@ -12,14 +12,14 @@ export declare const paletteTokenNameSchema: z.ZodEnum<{
     success: "success";
     warning: "warning";
     background: "background";
-    accent: "accent";
-    muted: "muted";
-    border: "border";
     primary: "primary";
     secondary: "secondary";
+    accent: "accent";
     destructive: "destructive";
     surfaceAlt: "surfaceAlt";
+    muted: "muted";
     primaryForeground: "primaryForeground";
+    border: "border";
 }>;
 export declare const themeColorBaseTokenNames: readonly ["primary", "primaryForeground", "secondary", "accent", "success", "warning", "destructive", "background", "surface", "surfaceAlt", "muted", "text", "border", "text", "heading", "mutedText", "surface", "background", "foreground", "border", "primary", "secondary", "accent", "success", "warning", "info", "error", "destructive", "scrim", "shadow", "onPrimary", "onSecondary", "onAccent", "onSuccess", "onWarning", "onInfo", "onError", "onDestructive", "onSurface", "white", "neutral", "primaryText", "secondaryForeground", "accentForeground"];
 export declare const themeColorShadeSteps: readonly ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];

package/dist/_dts/ui/src/badge.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const badgeVariants: (props?: ({
-    variant?: "success" | "warning" | "default" | "outline" | "secondary" | "destructive" | null | undefined;
+    variant?: "success" | "warning" | "default" | "secondary" | "destructive" | "outline" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }

package/dist/_dts/ui/src/button.d.ts

@@ -1,8 +1,8 @@
 import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonVariants: (props?: ({
-    variant?: "default" | "link" | "outline" | "secondary" | "destructive" | "ghost" | "onDark" | "onDarkOutline" | "heroGlass" | null | undefined;
-    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+    variant?: "link" | "default" | "secondary" | "destructive" | "outline" | "ghost" | "onDark" | "onDarkOutline" | "heroGlass" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;

package/dist/client/{BookingConsentAgreement-DCch21a6.mjs → BookingConsentAgreement-DQUik1Mx.mjs}

@@ -1,7 +1,7 @@
 "use client";
 import { D as clsx } from "./colorStyles-CrxJrPjJ.mjs";
-import { At as assertNever$2, tn as formatCurrencyAmount } from "./propsDecoder-pzBeCh14.mjs";
-import { a as CheckIcon } from "./scrollToBlock-CduAKf8T.mjs";
+import { Nt as assertNever$2, un as formatCurrencyAmount } from "./propsDecoder-CY9gGEF7.mjs";
+import { a as CheckIcon } from "./scrollToBlock--BFV6kl-.mjs";
 import { n as RichText } from "./checkoutUrls-BuseL0dw.mjs";
 import { useCallback, useEffect, useReducer, useRef } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";

package/dist/client/{DiscountCodeDisclosure-DIj1T59K.mjs → DiscountCodeDisclosure-CU67Q4vH.mjs}

@@ -1,5 +1,5 @@
 "use client";
-import { st as themeButtonClassName } from "./propsDecoder-pzBeCh14.mjs";
+import { ut as themeButtonClassName } from "./propsDecoder-CY9gGEF7.mjs";
 import { useId } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region ../blocks/src/system/runtime/api/types/discounts.ts