@riverbankcms/sdk 0.136.0 → 0.137.0

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { type SiteChromeBackgroundColorToken } from './siteChromeBackgrounds';
+import type { HeaderPreferences } from './headerPreferences';
+/**
+ * The persisted shape of `HeaderPreferences`, closed at every field.
+ *
+ * `.strict()` throughout is deliberate: an unknown key in the stored blob means
+ * the writer knew about a field this reader does not, and silently dropping it
+ * would let a save round-trip away someone else's intent. Every field is
+ * required for the same reason a default would be a hidden authority: a stored
+ * record that omits one is not a record this reader may complete.
+ */
+export declare const headerPreferencesSchema: z.ZodType<HeaderPreferences>;
+/** Only controls the client can edit may cross the write boundary. */
+export declare const headerPreferencesWireSchema: z.ZodObject<{
+    background: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"default">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"color">;
+        token: z.ZodType<SiteChromeBackgroundColorToken, unknown, z.core.$ZodTypeInternals<SiteChromeBackgroundColorToken, unknown>>;
+    }, z.core.$strict>], "kind">;
+    navTextSize: z.ZodEnum<{
+        base: "base";
+        sm: "sm";
+        lg: "lg";
+        xl: "xl";
+        inherit: "inherit";
+    }>;
+    navFontRole: z.ZodEnum<{
+        heading: "heading";
+        body: "body";
+        inherit: "inherit";
+    }>;
+    interactionPalette: z.ZodUnion<readonly [z.ZodLiteral<"recommended">, z.ZodEnum<{
+        accent: "accent";
+        primary: "primary";
+        secondary: "secondary";
+        quiet: "quiet";
+    }>]>;
+    brandDisplay: z.ZodEnum<{
+        auto: "auto";
+        "logo-only": "logo-only";
+        "logo-plus-title": "logo-plus-title";
+        "title-only": "title-only";
+    }>;
+    logoSize: z.ZodEnum<{
+        auto: "auto";
+        display: "display";
+        standard: "standard";
+        compact: "compact";
+        generous: "generous";
+    }>;
+}, z.core.$strict>;
+/**
+ * The read boundary for `site_theme_selections.header_preferences`.
+ *
+ * Three outcomes, never a throw and never a silent default: the column is
+ * nullable while the Phase 4c backfill is outstanding, so "absent" is a real
+ * and expected state that a caller must handle by deriving from the legacy
+ * theme with `readHeaderPreferences`. "Invalid" is separate from "absent"
+ * because the two want different responses — one is a backlog item, the other
+ * is a bug or a hand-edited row.
+ */
+export type PersistedHeaderPreferences = Readonly<{
+    kind: 'present';
+    preferences: HeaderPreferences;
+}> | Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'invalid';
+    issues: readonly string[];
+}>;
+export declare function parsePersistedHeaderPreferences(value: unknown): PersistedHeaderPreferences;

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: "accent" | "primary" | "secondary" | "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/client/{BookingConsentAgreement-DCch21a6.mjs → BookingConsentAgreement--_fUCZe-.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 { Kt as formatCurrencyAmount, yt as assertNever$2 } from "./propsDecoder-pYvx_Srl.mjs";
+import { a as CheckIcon } from "./scrollToBlock-ByQv96M2.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-BMipSoDJ.mjs}

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