@riverbankcms/sdk 0.60.16 → 0.62.4

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

@@ -114,6 +114,7 @@ export declare const blockDesignPlanSchema: z.ZodObject<{
         base: "base";
         "muted-band": "muted-band";
         "accent-band": "accent-band";
+        "brand-depth-band": "brand-depth-band";
         "hero-image": "hero-image";
     }>;
     contentFrame: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -224,6 +225,11 @@ export declare const blockDesignPlanSchema: z.ZodObject<{
         default: "default";
         "accent-quote": "accent-quote";
     }>>;
+    tileTreatment: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        quiet: "quiet";
+        "brand-depth": "brand-depth";
+    }>>;
     eyebrowTreatment: z.ZodOptional<z.ZodEnum<{
         pill: "pill";
         plain: "plain";
@@ -302,6 +308,7 @@ export declare const persistedPageDesignStateV1Schema: z.ZodObject<{
             base: "base";
             "muted-band": "muted-band";
             "accent-band": "accent-band";
+            "brand-depth-band": "brand-depth-band";
             "hero-image": "hero-image";
         }>;
         contentFrame: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -412,6 +419,11 @@ export declare const persistedPageDesignStateV1Schema: z.ZodObject<{
             default: "default";
             "accent-quote": "accent-quote";
         }>>;
+        tileTreatment: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            quiet: "quiet";
+            "brand-depth": "brand-depth";
+        }>>;
         eyebrowTreatment: z.ZodOptional<z.ZodEnum<{
             pill: "pill";
             plain: "plain";

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

@@ -0,0 +1,59 @@
+import type { Theme } from '../schema';
+import { type SiteChromeLookDiagnostics } from './customizableSurfaces';
+import { type Brand } from './types';
+export declare const footerLookIdValues: readonly ["footer-muted-grounding", "site-footer-brand-two-band"];
+export type FooterLookIdValue = typeof footerLookIdValues[number];
+export type FooterLookId = Brand<FooterLookIdValue, 'FooterLookId'>;
+export declare function asFooterLookId(value: FooterLookIdValue): FooterLookId;
+export type FooterLookDefinition = Readonly<{
+    id: FooterLookId;
+    label: string;
+    maxRecommendedNavDensity?: Extract<FooterSelectionContext['navDensity'], 'sparse' | 'balanced'>;
+    allowedContentPresence?: readonly Exclude<FooterSelectionContext['contentPresence'], 'unknown'>[];
+    compile: (theme: Theme) => Theme['footer'];
+}>;
+export type FooterSelectionContext = Readonly<{
+    navDensity: 'unknown' | 'sparse' | 'balanced' | 'dense';
+    contentPresence: 'unknown' | 'default-footer' | 'footer-blocks' | 'default-and-blocks';
+}>;
+export type RejectedFooterLookReason = 'footer-nav-too-dense' | 'footer-content-incompatible';
+export type RejectedFooterLook = Readonly<{
+    lookId: FooterLookId;
+    reasons: readonly RejectedFooterLookReason[];
+}>;
+export type FooterSelectionResult = Readonly<{
+    selectedLookId: FooterLookId;
+    selectedLook: FooterLookDefinition;
+    footer: Theme['footer'];
+    rejected: readonly RejectedFooterLook[];
+}>;
+export type FooterLookDiagnostics = SiteChromeLookDiagnostics<FooterLookId, RejectedFooterLookReason>;
+export type FooterLookResolutionInput = Readonly<{
+    theme: Theme;
+    recommendedLookIds: readonly FooterLookId[];
+    context?: Partial<FooterSelectionContext>;
+}>;
+export declare const defaultFooterSelectionContext: FooterSelectionContext;
+export declare const guaranteedFallbackFooterLookId: FooterLookId;
+/** Uses the generated theme's footer branch as-is: the canonical calm Look. */
+declare function mutedGroundingFooter(theme: Theme): Theme['footer'];
+/** Applies a high-contrast brand band with a darker full-bleed bottom bar. */
+declare function brandTwoBandFooter(theme: Theme): Theme['footer'];
+export declare const footerLookCatalog: readonly [{
+    readonly id: FooterLookId;
+    readonly label: "Muted grounding footer";
+    readonly compile: typeof mutedGroundingFooter;
+}, {
+    readonly id: FooterLookId;
+    readonly label: "Two-band brand footer";
+    readonly maxRecommendedNavDensity: "balanced";
+    readonly allowedContentPresence: readonly ["default-footer", "default-and-blocks"];
+    readonly compile: typeof brandTwoBandFooter;
+}];
+export declare function getFooterLook(id: FooterLookId): FooterLookDefinition | null;
+export declare function findFooterLook(id: FooterLookId): FooterLookDefinition | undefined;
+export declare function getFooterLookOrThrow(id: FooterLookId): FooterLookDefinition;
+export declare function resolveFooterLook(input: FooterLookResolutionInput): FooterSelectionResult;
+export declare function footerLookDiagnosticsFromSelectionResult(result: FooterSelectionResult): FooterLookDiagnostics;
+export declare function footerLookRejectionReasonLabel(reason: RejectedFooterLookReason): string;
+export {};

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

@@ -1,6 +1,8 @@
 import { type CompositionBudgetIssue } from './compositionBudget';
 import { type ThemeV2StyleAuthority } from './designState';
 import { type PageDesignIntent } from './pageDesignIntent';
+import { type HeaderOpeningSectionRepair } from './headerOpeningSection';
+import type { HeaderOpeningSectionContext } from './headerLooks';
 import { type CompiledPageRuntime } from './runtimeCompiler';
 import { type BlockDesignCapabilityMap, type BlockDesignPlan, type DesignBlockId, type DesignRepairResult, type DesignResolutionIssue, type GeneratedPageDesignIntent, type ResolvedPageDesignPlan, type SiteStyleId } from './types';
 import type { CuratedSiteStyle } from './curatedSiteStyles';
@@ -41,6 +43,8 @@ export type GeneratedDesignPipelineSuccess<TBlockId extends DesignBlockId = Desi
     intent: GeneratedPageDesignIntent<TBlockId>;
     plan: readonly BlockDesignPlan<TBlockId>[];
     resolved: ResolvedPageDesignPlan<TBlockId>;
+    headerOpeningSectionContext: HeaderOpeningSectionContext;
+    headerOpeningSectionRepairs: readonly HeaderOpeningSectionRepair[];
     repairs: readonly DesignRepairResult<TBlockId>[];
     compositionIssues: readonly [];
     compiledRuntime: CompiledPageRuntime<TBlockId>;

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

@@ -39,6 +39,7 @@ export declare const generatedBlockDesignIntentSchema: z.ZodObject<{
             base: "base";
             "muted-band": "muted-band";
             "accent-band": "accent-band";
+            "brand-depth-band": "brand-depth-band";
             "hero-image": "hero-image";
         }>;
     }, z.core.$strict>], "kind">;
@@ -181,6 +182,7 @@ export declare const generatedPageDesignIntentSchema: z.ZodObject<{
                     base: "base";
                     "muted-band": "muted-band";
                     "accent-band": "accent-band";
+                    "brand-depth-band": "brand-depth-band";
                     "hero-image": "hero-image";
                 }>;
             }, z.core.$strict>], "kind">;

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

@@ -0,0 +1,3 @@
+import type { Theme } from '../schema';
+export type HeaderCtaTreatment = 'default' | 'primary' | 'secondary' | 'inverted' | 'outline' | 'ghost';
+export declare function resolveHeaderCtaVariant(theme: Theme, treatment: HeaderCtaTreatment): string | undefined;

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

@@ -0,0 +1,155 @@
+import type { Theme } from '../schema';
+import { type SiteChromeLookDiagnostics } from './customizableSurfaces';
+import { type Brand } from './types';
+export declare const headerLookIdValues: readonly ["clean-base", "brand-solid", "editorial-line", "centered-calm", "practical-utility", "minimal-transparent", "transparent-overlay", "floating-glass"];
+export type HeaderLookIdValue = typeof headerLookIdValues[number];
+export type HeaderLookId = Brand<HeaderLookIdValue, 'HeaderLookId'>;
+export declare function asHeaderLookId(value: HeaderLookIdValue): HeaderLookId;
+export type HeaderLookVisualTreatment = 'solid-neutral' | 'solid-brand' | 'light-editorial' | 'minimal-transparent' | 'transparent-overlay' | 'floating-glass';
+export type HeaderLookLayoutBehavior = 'normal-flow' | 'sticky' | 'sticky-shrink' | 'fixed-overlay' | 'fixed-floating';
+export type HeaderLookOpeningRequirement = 'none' | 'reserved-space-ok' | 'requires-image-hero-with-contrast-overlay';
+export type HeaderLogoShape = 'none' | 'text-only' | 'horizontal' | 'square' | 'tall';
+export type HeaderLookDefinition = Readonly<{
+    id: HeaderLookId;
+    label: string;
+    visualTreatment: HeaderLookVisualTreatment;
+    layoutBehavior: HeaderLookLayoutBehavior;
+    openingRequirement: HeaderLookOpeningRequirement;
+    maxRecommendedNavItems?: number;
+    allowedLogoShapes?: readonly HeaderLogoShape[];
+    requiresProminentCta?: boolean;
+    compile: (theme: Theme) => Theme['header'];
+}>;
+export type HeaderOpeningSectionContext = Readonly<{
+    kind: 'unknown';
+    canAdjust: false;
+}> | Readonly<{
+    kind: 'plain';
+    canAdjust: false;
+}> | Readonly<{
+    kind: 'image-hero';
+    hasContrastOverlay: boolean;
+    hasTopSpacing: boolean;
+    canAdjust: false;
+}>;
+export type HeaderLogoContext = Readonly<{
+    shape: HeaderLogoShape;
+}>;
+export type HeaderNavigationContext = Readonly<{
+    itemCount: number;
+}>;
+export type HeaderCtaContext = Readonly<{
+    importance: 'low' | 'medium' | 'high';
+}>;
+export type HeaderBannerContext = Readonly<{
+    persistentVisibility: 'none' | 'possible' | 'visible';
+    shellCanOffsetOverlayHeader: boolean;
+}>;
+export type HeaderSelectionContext = Readonly<{
+    openingSection: HeaderOpeningSectionContext;
+    logo: HeaderLogoContext;
+    navigation: HeaderNavigationContext;
+    cta: HeaderCtaContext;
+    banner: HeaderBannerContext;
+}>;
+export type RejectedHeaderLookReason = 'requires-image-hero-with-contrast-overlay' | 'requires-opening-section-top-spacing' | 'requires-banner-offset-shell' | 'too-many-nav-items' | 'logo-shape-incompatible' | 'cta-treatment-unavailable';
+export type RejectedHeaderLook = Readonly<{
+    lookId: HeaderLookId;
+    reasons: readonly RejectedHeaderLookReason[];
+}>;
+export type HeaderSelectionResult = Readonly<{
+    selectedLookId: HeaderLookId;
+    selectedLook: HeaderLookDefinition;
+    header: Theme['header'];
+    rejected: readonly RejectedHeaderLook[];
+}>;
+export type HeaderLookDiagnostics = SiteChromeLookDiagnostics<HeaderLookId, RejectedHeaderLookReason>;
+export type HeaderLookResolutionInput = Readonly<{
+    theme: Theme;
+    recommendedLookIds: readonly HeaderLookId[];
+    context?: Partial<HeaderSelectionContext>;
+}>;
+export declare const defaultHeaderSelectionContext: HeaderSelectionContext;
+declare function solidBrandHeader(theme: Theme): Theme['header'];
+declare function cleanBaseHeader(theme: Theme): Theme['header'];
+declare function editorialLineHeader(theme: Theme): Theme['header'];
+declare function centeredCalmHeader(theme: Theme): Theme['header'];
+declare function practicalUtilityHeader(theme: Theme): Theme['header'];
+declare function minimalTransparentHeader(theme: Theme): Theme['header'];
+declare function transparentOverlayHeader(theme: Theme): Theme['header'];
+declare function floatingGlassHeader(theme: Theme): Theme['header'];
+export declare const headerLookCatalog: readonly [{
+    readonly id: HeaderLookId;
+    readonly label: "Clean base";
+    readonly visualTreatment: "solid-neutral";
+    readonly layoutBehavior: "sticky";
+    readonly openingRequirement: "none";
+    readonly compile: typeof cleanBaseHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Brand solid";
+    readonly visualTreatment: "solid-brand";
+    readonly layoutBehavior: "sticky-shrink";
+    readonly openingRequirement: "none";
+    readonly compile: typeof solidBrandHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Editorial line";
+    readonly visualTreatment: "light-editorial";
+    readonly layoutBehavior: "sticky";
+    readonly openingRequirement: "none";
+    readonly maxRecommendedNavItems: 6;
+    readonly compile: typeof editorialLineHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Centered calm";
+    readonly visualTreatment: "light-editorial";
+    readonly layoutBehavior: "normal-flow";
+    readonly openingRequirement: "none";
+    readonly maxRecommendedNavItems: 5;
+    readonly allowedLogoShapes: readonly ["none", "text-only", "horizontal", "square"];
+    readonly compile: typeof centeredCalmHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Practical utility";
+    readonly visualTreatment: "solid-neutral";
+    readonly layoutBehavior: "sticky-shrink";
+    readonly openingRequirement: "none";
+    readonly requiresProminentCta: true;
+    readonly compile: typeof practicalUtilityHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Minimal transparent";
+    readonly visualTreatment: "minimal-transparent";
+    readonly layoutBehavior: "normal-flow";
+    readonly openingRequirement: "reserved-space-ok";
+    readonly compile: typeof minimalTransparentHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Transparent overlay";
+    readonly visualTreatment: "transparent-overlay";
+    readonly layoutBehavior: "fixed-overlay";
+    readonly openingRequirement: "requires-image-hero-with-contrast-overlay";
+    readonly maxRecommendedNavItems: 5;
+    readonly allowedLogoShapes: readonly ["none", "text-only", "horizontal"];
+    readonly compile: typeof transparentOverlayHeader;
+}, {
+    readonly id: HeaderLookId;
+    readonly label: "Floating glass";
+    readonly visualTreatment: "floating-glass";
+    readonly layoutBehavior: "fixed-floating";
+    readonly openingRequirement: "requires-image-hero-with-contrast-overlay";
+    readonly maxRecommendedNavItems: 5;
+    readonly allowedLogoShapes: readonly ["none", "text-only", "horizontal"];
+    readonly compile: typeof floatingGlassHeader;
+}];
+export declare const guaranteedFallbackHeaderLookId: HeaderLookId;
+export declare function getHeaderLook(id: HeaderLookId): HeaderLookDefinition | null;
+export declare function findHeaderLook(id: HeaderLookId): HeaderLookDefinition | undefined;
+export declare function getHeaderLookOrThrow(id: HeaderLookId): HeaderLookDefinition;
+export declare function headerLookRequiresImageHeroOpening(look: HeaderLookDefinition): boolean;
+export declare function headerLookUsesOverlayLayout(look: HeaderLookDefinition): boolean;
+export declare function resolveHeaderLook(input: HeaderLookResolutionInput): HeaderSelectionResult;
+export declare function headerLookDiagnosticsFromSelectionResult(result: HeaderSelectionResult): HeaderLookDiagnostics;
+export declare function headerLookRejectionReasonLabel(reason: RejectedHeaderLookReason): string;
+export {};

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

@@ -0,0 +1,15 @@
+import type { BlockDesignPlan, DesignBlockId, ResolvedBlockDesignPlan } from './types';
+import type { HeaderLookId, HeaderOpeningSectionContext } from './headerLooks';
+export type HeaderOpeningSectionRepair = 'promote-opening-hero-surface' | 'add-opening-contrast-overlay' | 'add-opening-top-spacing';
+export type HeaderOpeningSectionPlan<TBlockId extends DesignBlockId = DesignBlockId> = Readonly<{
+    plan: readonly BlockDesignPlan<TBlockId>[];
+    repairs: readonly HeaderOpeningSectionRepair[];
+}>;
+export declare function planGeneratedHeaderOpeningSection<TBlockId extends DesignBlockId>(input: Readonly<{
+    plan: readonly BlockDesignPlan<TBlockId>[];
+    recommendedHeaderLookIds: readonly HeaderLookId[];
+}>): HeaderOpeningSectionPlan<TBlockId>;
+export declare function deriveHeaderOpeningSectionContext(input: Readonly<{
+    openingBlock: ResolvedBlockDesignPlan | null;
+    openingContent?: Record<string, unknown> | null;
+}>): HeaderOpeningSectionContext;

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

@@ -5,9 +5,13 @@ export * from './contentTemplateDesignIntent';
 export * from './contentTemplateRuntimeCompiler';
 export * from './curatedChoices';
 export * from './curatedSiteStyles';
+export * from './customizableSurfaces';
 export * from './designState';
+export * from './footerLooks';
 export * from './generatedSchemas';
 export * from './generatedDesignPipeline';
+export * from './headerLooks';
+export * from './headerOpeningSection';
 export * from './lookResolution';
 export * from './pageDesignAuthority';
 export * from './pageDesignEditorErrors';
@@ -15,8 +19,10 @@ export * from './pageDesignEditorModel';
 export * from './pageDesignIntent';
 export * from './previewCustomization';
 export * from './rawStyleFields';
+export * from './records';
 export * from './resolver';
 export * from './runtimeCompiler';
+export * from './siteStyleBlockPolicies';
 export * from './sourceCatalogs';
 export * from './styleTags';
 export * from './tokenRecipes';

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

@@ -36,6 +36,9 @@ export type PageDesignPublishPlan = Readonly<{
     /** Persisted as content_versions.data for the page-owned published design row. */
     versionData: PublishedPageDesignVersionDataV1;
 }>;
+export type PublishedPageDesignVersionDataPlan = Result<PublishedPageDesignVersionDataV1, Extract<PageDesignPublishBlocker, {
+    kind: 'missing-published-block-content';
+}>>;
 export type PageDesignRuntimePairingIssue = Readonly<{
     kind: 'missing-current-block';
     persisted: PublishedPageBlockSnapshot;
@@ -258,6 +261,10 @@ export declare function buildPageDesignPublishPlan(input: Readonly<{
     authority: PageDesignAuthority;
     blockSequence: readonly PageBlockSnapshot[];
 }>): Result<PageDesignPublishPlan, PageDesignPublishBlocker>;
+export declare function buildPublishedPageDesignVersionData(input: Readonly<{
+    pageId: DesignPageId;
+    blockSequence: readonly PageBlockSnapshot[];
+}>): PublishedPageDesignVersionDataPlan;
 export declare function buildPageDesignRuntimePairingPlan(input: Readonly<{
     versionData: PublishedPageDesignVersionDataV1;
     currentBlockSequence: readonly PageBlockSnapshot[];

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

@@ -53,6 +53,10 @@ export type PageDesignEditorLayoutOption = Readonly<{
     label: string;
     profile: BlockLayoutDesignProfile;
 }>;
+export type PageDesignEditorLooksForLayout = Readonly<{
+    layoutVariantKey: LayoutVariantKey;
+    availableLooks: readonly PageDesignEditorLookOption[];
+}>;
 export type PageDesignEditorBlockContentRevision = Readonly<{
     contentId: string | null;
 }>;
@@ -62,6 +66,7 @@ export type PageDesignEditorBlock<TBlockId extends DesignBlockId = DesignBlockId
     contentRevision?: PageDesignEditorBlockContentRevision;
     layout: PageDesignEditorSelection<LayoutVariantKey> | null;
     availableLayouts: readonly PageDesignEditorLayoutOption[];
+    availableLooksByLayout: readonly PageDesignEditorLooksForLayout[];
     look: PageDesignEditorChoice<AppearancePresetId>;
     availableLooks: readonly PageDesignEditorLookOption[];
 }>;
@@ -164,3 +169,23 @@ export declare function resolveVisiblePromotedFieldPathsForEditorBlock(input: Re
     block: PageDesignEditorBlock;
     promotedFieldPaths?: readonly string[];
 }>): readonly string[];
+export type PageDesignLayoutLookIntentChange = Readonly<{
+    kind: 'preserve-auto';
+}> | Readonly<{
+    kind: 'preserve-supported-pin';
+    appearancePresetId: AppearancePresetId;
+}> | Readonly<{
+    kind: 'reset-incompatible-pin';
+    previousAppearancePresetId: AppearancePresetId;
+}>;
+export type PageDesignLayoutLookCompatibilityPlan = Readonly<{
+    kind: 'layout-unavailable';
+    layoutVariantKey: LayoutVariantKey;
+}> | Readonly<{
+    kind: 'layout-supported';
+    layout: PageDesignEditorSelection<LayoutVariantKey>;
+    availableLooks: readonly PageDesignEditorLookOption[];
+    look: PageDesignEditorChoice<AppearancePresetId>;
+    lookIntentChange: PageDesignLayoutLookIntentChange;
+}>;
+export declare function planPageDesignLayoutLookCompatibility(block: PageDesignEditorBlock, layoutVariantKey: LayoutVariantKey): PageDesignLayoutLookCompatibilityPlan;

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

@@ -3,6 +3,8 @@ import { type Theme } from '../schema';
 import { type ButtonPersonalityId } from '../buttons/personalities';
 import { type PaletteOverrides, type PaletteVariantId } from '../palette/variants';
 import { type CuratedSiteStyle } from './curatedSiteStyles';
+import { type FooterLookId, type FooterSelectionContext, type FooterSelectionResult } from './footerLooks';
+import { type HeaderSelectionContext, type HeaderLookId, type HeaderSelectionResult } from './headerLooks';
 import { type CompiledBlockRuntimeFields, type CompiledPageRuntime, type ComponentRuntimeRules, type DesignRuntimeRules, type SemanticSpacing } from './runtimeCompiler';
 import type { AppearancePresetId, DesignBlockId, SiteStyleId } from './types';
 /**
@@ -16,7 +18,7 @@ import type { AppearancePresetId, DesignBlockId, SiteStyleId } from './types';
 export { defineBlockDesignMetadata, type BlockDesignMetadata, type BlockDesignMetadataInput, type BlockDesignMetadataMap, type BlockFlowBoundaryPreference, type BlockFlowContract, type BlockFlowSurfaceBehavior, type BlockFlowWeight, type BlockLayoutBoundaryBias, type BlockLayoutDesignProfile, type BlockLayoutDesignProfileInput, type BlockLayoutFamily, type BlockLayoutVisualWeight, type PageFlowRole, } from './blockFlow';
 export { buildPageDesignEditorReadModel, boundaryOptions, pageFlowPresets, type BoundaryOption, type PageDesignEditorBlock, type PageDesignEditorBoundary, type PageDesignEditorChoice, type PageDesignEditorIssue, type PageDesignEditorReadModel, type PageDesignEditorSelection, type PageFlowPreset, } from './pageDesignEditorModel';
 export { autoDesignChoice, reducePageDesignIntentForUserAction, resolvePageDesignBlockLookChoice, resolvePageDesignBoundaryChoice, userPinnedDesignChoice, type PageDesignChoice, type PageDesignIntent, type PageDesignUserAction, } from './pageDesignIntent';
-export { repairDesignIssue, resolveBlockDesignPlan, } from './resolver';
+export { repairDesignIssue, resolveBlockDesignPlan } from './resolver';
 export { cycleableOptionsFromResolved, deriveDesignCustomizationScope, recommendedDesignOption, type CycleableDesignOption, type CycleableOptions, type DesignCustomizationAuthority, type DesignCustomizationScope, type DesignCustomizationSurface, type DesignCustomizationUnsupportedReason, type DesignOptionIssue, type ResolvedDesignOption, } from './previewCustomization';
 export { compileBlockRuntimeFields, compilePageRuntimeFields, compileTokenRecipes, compiledRuntimeStyleFieldNames, defaultComponentRuntimeRules, defaultDesignRuntimeRules, stripCompiledRuntimeStyleFields, type CompiledBlockRuntime, type CompiledBlockRuntimeFields, type CompiledPageRuntime, type CompileBlockRuntimeInput, type ComponentRuntimeRules, type DesignRuntimeRules, type SemanticSpacing, } from './runtimeCompiler';
 export { defaultCuratedChoice, requireEntriesForCuratedChoices, resolveCuratedChoice, type CuratedChoice, type CuratedChoiceResolution, } from './curatedChoices';
@@ -52,13 +54,25 @@ export type SiteThemeSelectionsInput = Readonly<{
     buttonPersonalityId: ButtonPersonalityId | null;
     paletteVariantId: PaletteVariantId | null;
     paletteOverrides: PaletteOverrides | null;
+    headerLookId?: HeaderLookId | null;
+    footerLookId?: FooterLookId | null;
+    headerSelectionContext?: Partial<HeaderSelectionContext>;
+    footerSelectionContext?: Partial<FooterSelectionContext>;
 }>;
 export type SiteThemeSelectionsResult = Readonly<{
     theme: CuratedSiteStyleTheme;
+    requestedSelections: Readonly<{
+        headerLookId: HeaderLookId | null;
+        footerLookId: FooterLookId | null;
+    }>;
     resolvedSelections: Readonly<{
         buttonPersonalityId: ButtonPersonalityId;
         paletteVariantId: PaletteVariantId;
+        headerLookId: HeaderLookId;
+        footerLookId: FooterLookId;
     }>;
+    headerSelection: HeaderSelectionResult;
+    footerSelection: FooterSelectionResult;
     warnings: ReadonlyArray<SelectionFallbackWarning>;
 }>;
 /**

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

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

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

@@ -74,6 +74,14 @@ export declare const defaultDesignRuntimeRules: {
                 readonly headingColor: "primaryForeground";
             };
         };
+        readonly 'brand-depth-band': {
+            readonly background: {
+                readonly type: "color";
+                readonly color: "primary-800";
+                readonly textColor: "primaryForeground";
+                readonly headingColor: "primaryForeground";
+            };
+        };
         readonly 'hero-image': {
             readonly background: {
                 readonly type: "image";

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

@@ -0,0 +1,96 @@
+import type { BlockLayoutDesignProfile } from './blockFlow';
+import { autoDesignChoice, type PageDesignBlockDescriptor, type PageDesignIntent, type PageDesignUserPinnedChoice } from './pageDesignIntent';
+import { type AppearancePresetId, type BoundaryOptionId, type DesignBlockId, type LayoutVariantKey, type SiteStyleId } from './types';
+export declare const defaultPolicyPageFlowPresetId: import("@riverbankcms/blocks").PageFlowPresetId;
+export type OpenSiteStyleBlockPolicy = Readonly<{
+    kind: 'open';
+}>;
+export type LockedLookAndLayoutsSiteStyleBlockPolicy = Readonly<{
+    kind: 'locked-look-and-layouts';
+    blockKind: string;
+    lookId: AppearancePresetId;
+    allowedLayoutVariantKeys: readonly LayoutVariantKey[];
+    defaultLayoutVariantKey: LayoutVariantKey;
+    defaultBoundaryAfter?: Readonly<{
+        optionId: BoundaryOptionId;
+        mode: 'default-only';
+    }>;
+    customize: Readonly<{
+        hideDisallowedLooks: true;
+        hideDisallowedLayouts: true;
+    }>;
+}>;
+export type SiteStyleBlockPolicy = OpenSiteStyleBlockPolicy | LockedLookAndLayoutsSiteStyleBlockPolicy;
+type RegisteredSiteStyleBlockPolicy = LockedLookAndLayoutsSiteStyleBlockPolicy & Readonly<{
+    siteStyleId: SiteStyleId;
+}>;
+export type BlockPolicyDescriptor<TBlockId extends DesignBlockId = DesignBlockId> = PageDesignBlockDescriptor<TBlockId> & Readonly<{
+    currentLayoutVariantKey?: LayoutVariantKey | null;
+    layoutProfiles?: readonly BlockLayoutDesignProfile[] | null;
+}>;
+export type BlockContentVariantPolicyPlan = Readonly<{
+    kind: 'unchanged';
+}> | Readonly<{
+    kind: 'set-variant';
+    variantKey: LayoutVariantKey;
+}>;
+export type PageDesignPolicyAuditIssue<TBlockId extends DesignBlockId = DesignBlockId> = Readonly<{
+    kind: 'missing-page-design-authority';
+    siteStyleId: SiteStyleId;
+    policyBlockCount: number;
+}> | Readonly<{
+    kind: 'missing-required-look-pin';
+    blockId: TBlockId;
+    blockKind: string;
+    requiredLookId: AppearancePresetId;
+}> | Readonly<{
+    kind: 'unsupported-look-pin';
+    blockId: TBlockId;
+    blockKind: string;
+    actualLookId: AppearancePresetId;
+    requiredLookId: AppearancePresetId;
+}> | Readonly<{
+    kind: 'unsupported-layout-variant';
+    blockId: TBlockId;
+    blockKind: string;
+    actualLayoutVariantKey: LayoutVariantKey;
+    defaultLayoutVariantKey: LayoutVariantKey;
+}>;
+export declare function siteStyleBlockPolicies(): readonly RegisteredSiteStyleBlockPolicy[];
+export declare function buildInitialPolicyPageDesignIntent(siteStyleId: SiteStyleId): PageDesignIntent;
+export declare function hasPolicyForBlocks(input: Readonly<{
+    siteStyleId: SiteStyleId;
+    blocks: readonly PageDesignBlockDescriptor[];
+}>): boolean;
+export declare function deriveSiteStyleBlockPolicy(input: Readonly<{
+    siteStyleId: SiteStyleId;
+    blockKind: string;
+}>): SiteStyleBlockPolicy;
+export declare function isLayoutVariantAllowedByPolicy(policy: SiteStyleBlockPolicy, layoutVariantKey: LayoutVariantKey): boolean;
+export declare function normalizeLayoutVariantForPolicy(policy: SiteStyleBlockPolicy, layoutVariantKey: LayoutVariantKey | null | undefined): LayoutVariantKey | null;
+export declare function filterLayoutProfilesForPolicy(policy: SiteStyleBlockPolicy, layoutProfiles: readonly BlockLayoutDesignProfile[]): readonly BlockLayoutDesignProfile[];
+export declare function isLookAllowedByPolicy(policy: SiteStyleBlockPolicy, lookId: AppearancePresetId): boolean;
+export declare function filterLookIdsForPolicy<TLook extends Readonly<{
+    id: AppearancePresetId;
+}>>(policy: SiteStyleBlockPolicy, looks: readonly TLook[]): readonly TLook[];
+export declare function applySiteStyleBlockPoliciesToPageDesignIntent<TBlockId extends DesignBlockId>(intent: PageDesignIntent<TBlockId>, blocks: readonly PageDesignBlockDescriptor<TBlockId>[]): PageDesignIntent<TBlockId>;
+export declare function planBlockContentVariantPolicyUpdate(input: Readonly<{
+    policy: SiteStyleBlockPolicy;
+    content: Readonly<Record<string, unknown>>;
+}>): BlockContentVariantPolicyPlan;
+export declare function applyBlockContentVariantPolicy(input: Readonly<{
+    policy: SiteStyleBlockPolicy;
+    content: Readonly<Record<string, unknown>>;
+}>): Readonly<Record<string, unknown>>;
+export declare function auditPageDesignIntentPolicy<TBlockId extends DesignBlockId>(input: Readonly<{
+    intent: PageDesignIntent<TBlockId>;
+    blocks: readonly BlockPolicyDescriptor<TBlockId>[];
+}>): readonly PageDesignPolicyAuditIssue<TBlockId>[];
+export declare function auditPageDesignAuthorityPolicy<TBlockId extends DesignBlockId>(input: Readonly<{
+    siteStyleId: SiteStyleId;
+    intent: PageDesignIntent<TBlockId> | null;
+    blocks: readonly BlockPolicyDescriptor<TBlockId>[];
+}>): readonly PageDesignPolicyAuditIssue<TBlockId>[];
+export declare function assertRegisteredSiteStyleBlockPoliciesAreValid(): void;
+export declare function autoChoiceAllowedByPolicy(policy: SiteStyleBlockPolicy): ReturnType<typeof autoDesignChoice> | PageDesignUserPinnedChoice<AppearancePresetId>;
+export {};

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

@@ -21,7 +21,7 @@ export type AdvancedDesignOptionCatalog = DesignOptionCatalog<'advanced', SiteSt
 export type DesignOptionCatalogForSource<TSource extends DesignChoiceSource> = TSource extends 'generated' ? GeneratedDesignOptionCatalog : TSource extends 'user' ? UserDesignOptionCatalog : TSource extends 'advanced' ? AdvancedDesignOptionCatalog : never;
 export declare const generatedDesignOptionCatalog: {
     readonly source: "generated";
-    readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "hero-image"];
+    readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"];
     readonly contentFrames: readonly [{
         readonly kind: "plain";
     }, Readonly<{
@@ -42,7 +42,7 @@ export declare const generatedDesignOptionCatalog: {
 };
 export declare const userDesignOptionCatalog: {
     readonly source: "user";
-    readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "hero-image"];
+    readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"];
     readonly contentFrames: readonly [{
         readonly kind: "plain";
     }, Readonly<{
@@ -74,7 +74,7 @@ export declare const userDesignOptionCatalog: {
 };
 export declare const advancedDesignOptionCatalog: {
     readonly source: "advanced";
-    readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "hero-image"];
+    readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"];
     readonly contentFrames: readonly [{
         readonly kind: "plain";
     }, Readonly<{
@@ -107,7 +107,7 @@ export declare const advancedDesignOptionCatalog: {
 export declare const designOptionCatalogs: {
     readonly generated: {
         readonly source: "generated";
-        readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "hero-image"];
+        readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"];
         readonly contentFrames: readonly [{
             readonly kind: "plain";
         }, Readonly<{
@@ -128,7 +128,7 @@ export declare const designOptionCatalogs: {
     };
     readonly user: {
         readonly source: "user";
-        readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "hero-image"];
+        readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"];
         readonly contentFrames: readonly [{
             readonly kind: "plain";
         }, Readonly<{
@@ -160,7 +160,7 @@ export declare const designOptionCatalogs: {
     };
     readonly advanced: {
         readonly source: "advanced";
-        readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "hero-image"];
+        readonly sectionSurfaces: readonly ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"];
         readonly contentFrames: readonly [{
             readonly kind: "plain";
         }, Readonly<{