@riverbankcms/sdk 0.130.0 → 0.132.0

package/dist/_dts/theme-core/src/buttons/styles/registry.d.ts

@@ -1,5 +1,6 @@
 import type { ButtonSystem } from '../types';
-import { type ResolveButtonStyleError } from './domain';
+import type { VariantRole } from '../types';
+import { type ButtonHoverTreatmentValue, type ResolveButtonStyleError } from './domain';
 import { type ButtonStyleId, type ButtonStyleSelection, type ButtonStyleSelectionFor } from './selection';
 export declare const buttonStyleRecipes: readonly [Readonly<{
     id: "soft-pill";
@@ -12,15 +13,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -71,15 +64,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -130,15 +115,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -189,15 +166,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -248,15 +217,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -307,15 +268,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -364,18 +317,50 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
         motion: import("../../../../blocks/src/index").StyleMotion;
         era: import("../../../../blocks/src/index").StyleEra;
     }>>>;
-    parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
-    defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
+    parameterSchema: import("zod").ZodType<{
+        hoverPreferences?: {
+            outline?: "accent" | "secondary" | "contextual" | undefined;
+            accent?: "accent" | "secondary" | "contextual" | undefined;
+            primary?: "accent" | "secondary" | "contextual" | undefined;
+            secondary?: "accent" | "secondary" | "contextual" | undefined;
+            ghost?: "accent" | "secondary" | "contextual" | undefined;
+        } | undefined;
+    }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+        hoverPreferences?: {
+            outline?: "accent" | "secondary" | "contextual" | undefined;
+            accent?: "accent" | "secondary" | "contextual" | undefined;
+            primary?: "accent" | "secondary" | "contextual" | undefined;
+            secondary?: "accent" | "secondary" | "contextual" | undefined;
+            ghost?: "accent" | "secondary" | "contextual" | undefined;
+        } | undefined;
+    }, unknown>>;
+    defaultParameters: {
+        hoverPreferences?: {
+            outline?: "accent" | "secondary" | "contextual" | undefined;
+            accent?: "accent" | "secondary" | "contextual" | undefined;
+            primary?: "accent" | "secondary" | "contextual" | undefined;
+            secondary?: "accent" | "secondary" | "contextual" | undefined;
+            ghost?: "accent" | "secondary" | "contextual" | undefined;
+        } | undefined;
+    };
+    controls: readonly import("./domain").ButtonStyleControl<{
+        hoverPreferences?: {
+            outline?: "accent" | "secondary" | "contextual" | undefined;
+            accent?: "accent" | "secondary" | "contextual" | undefined;
+            primary?: "accent" | "secondary" | "contextual" | undefined;
+            secondary?: "accent" | "secondary" | "contextual" | undefined;
+            ghost?: "accent" | "secondary" | "contextual" | undefined;
+        } | undefined;
     }>[];
-    defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
+    defineSystem: (parameters: {
+        hoverPreferences?: {
+            outline?: "accent" | "secondary" | "contextual" | undefined;
+            accent?: "accent" | "secondary" | "contextual" | undefined;
+            primary?: "accent" | "secondary" | "contextual" | undefined;
+            secondary?: "accent" | "secondary" | "contextual" | undefined;
+            ghost?: "accent" | "secondary" | "contextual" | undefined;
+        } | undefined;
+    }) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
         roles: Readonly<{
@@ -425,15 +410,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -484,15 +461,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -543,15 +512,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -602,15 +563,7 @@ export declare const buttonStyleRecipes: readonly [Readonly<{
     }>>>;
     parameterSchema: import("zod").ZodType<Readonly<Record<string, never>>, unknown, import("zod/v4/core").$ZodTypeInternals<Readonly<Record<string, never>>, unknown>>;
     defaultParameters: Readonly<Record<string, never>>;
-    controls: readonly Readonly<{
-        kind: "choice";
-        parameter: string;
-        label: string;
-        options: readonly Readonly<{
-            value: never;
-            label: string;
-        }>[];
-    }>[];
+    controls: readonly import("./domain").ButtonStyleControl<Readonly<Record<string, never>>>[];
     defineSystem: (parameters: Readonly<Record<string, never>>) => Readonly<{
         global: import("../../../../blocks/src/index").ButtonGlobalSettings;
         sizes?: import("..").ButtonSizes;
@@ -744,4 +697,6 @@ export type UpdateButtonStyleSelectionChoiceResult = Readonly<{
  * selection. Preview controls never need recipe-specific parameter branches.
  */
 export declare function updateButtonStyleSelectionChoice(selection: ButtonStyleSelection, parameter: string, value: string): UpdateButtonStyleSelectionChoiceResult;
+export declare function buttonStyleHoverPreferenceValue(selection: ButtonStyleSelection, parameter: string, role: VariantRole): ButtonHoverTreatmentValue | null;
+export declare function updateButtonStyleHoverPreference(selection: ButtonStyleSelection, parameter: string, role: VariantRole, value: ButtonHoverTreatmentValue | null): UpdateButtonStyleSelectionChoiceResult;
 export {};

package/dist/_dts/theme-core/src/buttons/styles/selection.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type VariantRole } from '../types';
 export declare const BUTTON_STYLE_IDS: readonly ["soft-pill", "earth-pill", "confident-chip", "editorial-link", "pebble", "ink-stamp", "flat-ink", "brushed-wash", "showtime-pill", "joy-stamp", "ornate-ritual", "quiet-arrow"];
 export type ButtonStyleId = (typeof BUTTON_STYLE_IDS)[number];
 export declare const quietArrowParametersSchema: z.ZodObject<{
@@ -8,6 +9,38 @@ export declare const quietArrowParametersSchema: z.ZodObject<{
     }>;
 }, z.core.$strict>;
 export type QuietArrowParameters = z.infer<typeof quietArrowParametersSchema>;
+export declare const FLAT_INK_HOVER_TREATMENT_VALUES: readonly ["contextual", "secondary", "accent"];
+export declare const flatInkHoverTreatmentSchema: z.ZodEnum<{
+    accent: "accent";
+    secondary: "secondary";
+    contextual: "contextual";
+}>;
+export declare const flatInkHoverPreferencesSchema: z.ZodObject<Record<"outline" | "accent" | "primary" | "secondary" | "ghost", z.ZodOptional<z.ZodEnum<{
+    accent: "accent";
+    secondary: "secondary";
+    contextual: "contextual";
+}>>>, z.core.$strict>;
+export declare const flatInkParametersSchema: z.ZodObject<{
+    hoverPreferences: z.ZodOptional<z.ZodObject<Record<"outline" | "accent" | "primary" | "secondary" | "ghost", z.ZodOptional<z.ZodEnum<{
+        accent: "accent";
+        secondary: "secondary";
+        contextual: "contextual";
+    }>>>, z.core.$strict>>;
+}, z.core.$strict>;
+export type FlatInkHoverTreatment = z.infer<typeof flatInkHoverTreatmentSchema>;
+export type FlatInkParameters = z.infer<typeof flatInkParametersSchema>;
+export type ButtonHoverTreatmentPreference = Readonly<{
+    kind: 'recommended';
+}> | Readonly<{
+    kind: 'explicit';
+    treatment: Readonly<{
+        kind: 'contextual-shade-shift';
+    }> | Readonly<{
+        kind: 'palette-role';
+        role: 'secondary' | 'accent';
+    }>;
+}>;
+export type ButtonHoverPreferences = Readonly<Record<VariantRole, ButtonHoverTreatmentPreference>>;
 export declare const buttonStyleSelectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     styleId: z.ZodLiteral<"soft-pill">;
     parameters: z.ZodObject<{}, z.core.$strict>;
@@ -28,7 +61,13 @@ export declare const buttonStyleSelectionSchema: z.ZodDiscriminatedUnion<[z.ZodO
     parameters: z.ZodObject<{}, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     styleId: z.ZodLiteral<"flat-ink">;
-    parameters: z.ZodObject<{}, z.core.$strict>;
+    parameters: z.ZodObject<{
+        hoverPreferences: z.ZodOptional<z.ZodObject<Record<"outline" | "accent" | "primary" | "secondary" | "ghost", z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            secondary: "secondary";
+            contextual: "contextual";
+        }>>>, z.core.$strict>>;
+    }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     styleId: z.ZodLiteral<"brushed-wash">;
     parameters: z.ZodObject<{}, z.core.$strict>;
@@ -62,9 +101,18 @@ export declare function createDefaultButtonStyleSelection(styleId: ButtonStyleId
 export declare function isButtonStyleId(value: string): value is ButtonStyleId;
 export type PersistedButtonStyleSelectionResult = Readonly<{
     selection: ButtonStyleSelection;
-    warning: 'invalid-persisted-button-style-selection' | null;
+    warning: 'invalid-persisted-button-style-selection' | 'repaired-persisted-button-style-selection' | null;
+    repairs: readonly ButtonStyleSelectionRepair[];
+}>;
+export type ButtonStyleSelectionRepair = Readonly<{
+    kind: 'repaired-option';
+    styleId: ButtonStyleId;
+    parameter: string;
+    role: VariantRole | null;
+    reason: 'invalid-option-shape' | 'unsupported-option';
 }>;
 export declare function parsePersistedButtonStyleSelection(value: unknown, fallback?: ButtonStyleSelection): PersistedButtonStyleSelectionResult;
+export declare function normalizeFlatInkHoverPreferences(parameters: FlatInkParameters): ButtonHoverPreferences;
 /**
  * Stable identity for a validated style selection. Parsing first canonicalises
  * parameter key order, so future recipe parameters do not require editor-core

package/dist/_dts/theme-core/src/buttons/types.d.ts

@@ -117,6 +117,16 @@ export type ButtonColourTreatment = {
     role: 'link';
 };
 export type ButtonBackground = ButtonColourTreatment;
+export declare const contextualButtonHoverSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"shade-shift">;
+    seedToken: z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>;
+    fallbackDirection: z.ZodEnum<{
+        lighter: "lighter";
+        darker: "darker";
+    }>;
+    preferredToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>>;
+}, z.core.$strict>;
+export type ContextualButtonHover = z.infer<typeof contextualButtonHoverSchema>;
 /**
  * The complete persisted button-effect contract.
  *
@@ -1115,6 +1125,15 @@ export declare const buttonVariantSchema: z.ZodObject<{
         widthClass: z.ZodString;
     }, z.core.$strict>>;
     hoverBackgroundToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>>;
+    contextualHover: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"shade-shift">;
+        seedToken: z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>;
+        fallbackDirection: z.ZodEnum<{
+            lighter: "lighter";
+            darker: "darker";
+        }>;
+        preferredToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>>;
+    }, z.core.$strict>>;
     effects: z.ZodOptional<z.ZodObject<{
         base: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             effectId: z.ZodLiteral<"darken-background">;
@@ -1749,6 +1768,15 @@ export declare const buttonSystemSchema: z.ZodObject<{
             widthClass: z.ZodString;
         }, z.core.$strict>>;
         hoverBackgroundToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>>;
+        contextualHover: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"shade-shift">;
+            seedToken: z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>;
+            fallbackDirection: z.ZodEnum<{
+                lighter: "lighter";
+                darker: "darker";
+            }>;
+            preferredToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<OpaqueButtonColourToken, string>>>;
+        }, z.core.$strict>>;
         effects: z.ZodOptional<z.ZodObject<{
             base: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 effectId: z.ZodLiteral<"darken-background">;
@@ -2350,6 +2378,7 @@ export interface ButtonVariant {
     shadow?: Shadow;
     border?: ButtonBorder;
     hoverBackgroundToken?: OpaqueButtonColourToken;
+    contextualHover?: ContextualButtonHover;
     effects?: VariantEffects;
     /** Per-variant size overrides. See VariantSizeOverrides. */
     sizes?: VariantSizeOverrides;

package/dist/_dts/theme-core/src/cards/core.d.ts

@@ -4,6 +4,7 @@
  * Pure functions for generating card CSS without requiring the full Theme type.
  * Used by both the full CMS theme system and the SDK theme bridge.
  */
+import type { CardEdgeRule } from './types';
 export type CardBackgroundType = 'solid' | 'transparent' | 'gradient';
 export type CardSpacingCore = 'none' | 'compact' | 'cozy' | 'medium' | 'comfortable' | 'spacious';
 export type CardCornerValueCore = 'square' | 'soft' | 'rounded' | 'pill' | 'expressive';
@@ -15,14 +16,20 @@ export interface CardCornerRadiiCore {
     bottomLeft?: CardCornerValueCore;
     bottomRight?: CardCornerValueCore;
 }
-export interface CardAccentEdgeCore {
-    edge: CardEdgeCore;
-    colorToken: string;
-    width: CardEdgeWidthCore;
-}
 export interface CardVariantCore {
-    /** Unique variant identifier (e.g., 'default', 'elevated') */
+    /** Unique variant identifier (e.g., 'default', 'alternative') */
     id: string;
+    /**
+     * Which card role this variant implements. Generated CSS addresses the
+     * variant by its stable `.card-role-*` alias as well as its id, so content
+     * compiled against the role contract renders on a bridge theme too.
+     */
+    role?: CardRoleCore;
+    /**
+     * Ids this variant used to ship under. They keep emitting their `.card-{id}`
+     * class so SDK sites that address an older variant name keep their surface.
+     */
+    legacyIds?: readonly string[];
     /** Background style */
     background: CardBackgroundType;
     /** Background color token for solid backgrounds */
@@ -41,10 +48,17 @@ export interface CardVariantCore {
     borderToken?: string;
     /** Border width */
     borderWidth?: 'none' | 'thin' | 'medium' | 'thick';
-    /** Single accent edge; replaces the full border when set */
-    accentEdge?: CardAccentEdgeCore;
+    /** Edge rules drawn on the card; coexists with the border */
+    decorations?: CardEdgeRule[];
     /** Per-corner radius override; wins over the global corners setting */
     cornerRadii?: CardCornerRadiiCore;
+    /**
+     * Opts a variant out of the theme's global card shadow. A boxless card has
+     * no box to cast one, so `open` sets it; every other variant inherits the
+     * setting as before. Named for what it does rather than mirroring
+     * `CardVariant.shadow`, which is an object describing a shadow.
+     */
+    suppressShadow?: true;
 }
 export interface CardCoreSettings {
     /** Corner radius style */
@@ -65,8 +79,38 @@ export interface CardCoreSettings {
  * @param settings - Global card settings
  * @returns CSS string
  */
-export declare function generateCardCoreCss(scopeId: string, variants: CardVariantCore[], settings: CardCoreSettings): string;
+export declare function generateCardCoreCss(scopeId: string, variants: CardVariantCore[], settings: CardCoreSettings, scope?: CardClassScope): string;
+/** The roles a bridge card variant can implement. `none` is never a variant. */
+export type CardRoleCore = 'default' | 'alternative' | 'open';
+/**
+ * Which half of a variant's class list to address.
+ *
+ * The split exists because the two halves have different lifecycles on a
+ * bridge theme. `.card-role-*` is the *contract*: compiled content names a
+ * role and expects a surface, so the aliases are emitted unconditionally.
+ * `.card-{id}` and its legacy ids are the *catalogue*: an SDK consumer opts
+ * into those by name through `components.cards`.
+ */
+export type CardClassScope = 'all' | 'role-aliases' | 'named';
+/** Every class a variant's rule is addressed by, within a scope. */
+export declare function cardVariantClasses(variant: CardVariantCore, scope?: CardClassScope): string[];
 /**
- * Get default card variants for SDK usage.
+ * The default card variants for SDK/bridge themes — one per surface-backed
+ * role, so a bridge theme implements the same card contract a site style does
+ * and compiled `_cardStyles.role` renders on it.
+ *
+ * Two of the pre-role trio survive as legacy ids: `.card-elevated` is the
+ * `alternative` card under its old name, and both were the same surface before
+ * the rename. `outlined` is different — a fully bordered box is not what the
+ * `open` role means (boxless but marked), so it keeps its own variant and its
+ * own declarations as a *compatibility class only*. It carries no role, which
+ * means:
+ *
+ * - `.card-outlined` renders exactly what it always did;
+ * - `role: 'open'` renders the boxless marked card on a bridge theme, the same
+ *   thing it renders under a site style;
+ * - naming `outlined` in `components.cards.variants` enables the compatibility
+ *   class and nothing else — it does not publish `.card-role-open`, because
+ *   selecting a legacy name is not a claim on a semantic role.
  */
 export declare function getDefaultCardVariants(): CardVariantCore[];

package/dist/_dts/theme-core/src/cards/decorations.d.ts

@@ -0,0 +1,33 @@
+import type { CardEdgeRule, CardEdgeRuleWidth } from './types';
+/**
+ * Card decoration CSS — the single implementation shared by the Theme-driven
+ * generator (`generateCardCss`) and the dependency-free core generator
+ * (`core.ts`). Both used to carry their own accent-edge emitter; they now
+ * differ only in how a colour token resolves to a CSS colour.
+ */
+/** Resolves a palette token name to a CSS colour value. */
+export type CardColorResolver = (token: string) => string;
+export declare const CARD_EDGE_RULE_WIDTH_MAP: Record<CardEdgeRuleWidth, string>;
+/**
+ * The one short-rule length in the corpus (the editorial-rule accent). A fixed
+ * constant keeps `length: 'short'` a semantic choice rather than a free number.
+ */
+export declare const SHORT_CARD_EDGE_RULE_LENGTH = "2.75rem";
+/** Apply a decoration's optional alpha to its resolved colour. */
+export declare function cardDecorationColor(rule: CardEdgeRule, resolveColor: CardColorResolver): string;
+/**
+ * Container border declarations for a variant's border and its full-length
+ * edge rules. The two are independent: a card may be outlined *and* carry an
+ * accent edge. A variant with edge rules and no border still zeroes the box so
+ * only the decorated sides draw.
+ */
+export declare function cardBorderDeclarations(borderDeclaration: string | null, decorations: readonly CardEdgeRule[] | undefined, resolveColor: CardColorResolver): string[];
+/**
+ * Complete pseudo-element rules for a variant's short edge rules.
+ *
+ * `cardDecorationsSchema` caps the list at two, which makes the two pseudos
+ * sufficient for anything that parsed. The dependency-free core types carry a
+ * plain array with no such cap, so short rules past the second are dropped
+ * here rather than silently overwriting `::after`.
+ */
+export declare function cardDecorationPseudoRules(containerSelectors: readonly string[], decorations: readonly CardEdgeRule[] | undefined, resolveColor: CardColorResolver): string[];

package/dist/_dts/theme-core/src/cards/generateDefaultCardSystem.d.ts

@@ -6,9 +6,14 @@ import type { CardSystem } from './types';
  * Creates the baseline card roles that blocks can request:
  * - `default` for everyday surfaced cards
  * - `alternative` for emphasised cards
+ * - `open` for boxless-but-marked cards
  *
- * Both variants explicitly set theme.shadow and theme.corners for runtime
- * transform access, and both use theme.border when it has meaningful width.
+ * This is the terminal arm of the role fallback chain, so every theme
+ * implements every surface role whether or not its site style defines cards.
+ *
+ * The surfaced variants explicitly set theme.shadow and theme.corners for
+ * runtime transform access, and both use theme.border when it has meaningful
+ * width.
  *
  * This ensures cards have sensible defaults even when theme.cards is undefined.
  *

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

@@ -1,5 +1,8 @@
 export * from './types';
 export * from './constants';
+export * from './decorations';
+export * from './roles';
+export * from './openCardVariant';
 export * from './generateCardCss';
 export * from './generateDefaultCardSystem';
 export * from './core';

package/dist/_dts/theme-core/src/cards/openCardVariant.d.ts

@@ -0,0 +1,24 @@
+import type { CardEdgeRuleWidth, CardVariant } from './types';
+/**
+ * The boxless `open` card, as data.
+ *
+ * Every implementation of the role is the same shape — no fill, no box, square
+ * corners, an inline-flush content edge, a full hairline rule across the top
+ * and a short brand accent sitting on it. This absorbed the legacy
+ * `editorial-rule` treatment class, which Phase 3 deleted; the treatment's
+ * bundled `margin-top: 1rem` is deliberately absent, because outer rhythm is
+ * composition, not card identity. Pinned by `openCardVariant.test.ts`.
+ *
+ * What a site style gets to change is the *marking*: which token the accent
+ * uses and how heavy it is. Anna Raven's grounded-practice style takes her
+ * ochre `accent` where the generated baseline takes `primary`.
+ */
+export declare function boxlessOpenCardVariant(marking: Readonly<{
+    /** Token for the short accent rule riding on the hairline. */
+    accentToken: string;
+    accentWidth: CardEdgeRuleWidth;
+    /** Token for the full-width hairline. Defaults to `border`. */
+    ruleToken?: string;
+    /** Opacity for the hairline, when it should sit back from the border colour. */
+    ruleAlpha?: number;
+}>): CardVariant;

package/dist/_dts/theme-core/src/cards/roles.d.ts

@@ -0,0 +1,38 @@
+import type { Theme } from '../schema';
+import type { CardRole, CardSystem, CardVariant, SurfaceCardRole } from './types';
+/**
+ * Card role resolution — the closed interface between Looks (which say *which
+ * role*) and site styles (which say *what the role looks like*).
+ *
+ * The fallback chain is total, so a Look never has to know which variants a
+ * site style happens to define.
+ */
+/** Where a resolved surface came from. */
+export type CardSurfaceSource = 'site-style' | 'generated-baseline';
+export type ResolvedCardSurface = {
+    kind: 'none';
+    requestedRole: CardRole;
+} | {
+    kind: 'surface';
+    requestedRole: CardRole;
+    /** The role whose variant actually supplied the surface. */
+    resolvedRole: SurfaceCardRole;
+    variant: CardVariant;
+    source: CardSurfaceSource;
+};
+/**
+ * Resolve a card role against a site style's card system.
+ *
+ * - `none` — terminal, no surface.
+ * - `open` — site style's `open` variant → generated baseline `open`.
+ * - `default` — site style's `default` → generated baseline `default`.
+ * - `alternative` — site style's `alternative` → site style's `default` →
+ *   generated baseline `default`.
+ *
+ * The `theme` argument exists solely so the chain can reach the generated
+ * baseline without the caller synthesizing one. Pass `null` for `cardSystem`
+ * when the site style declares none — resolving against a baseline the caller
+ * synthesized would report `source: 'site-style'` for a surface no site style
+ * chose.
+ */
+export declare function resolveCardRole(theme: Theme, cardSystem: CardSystem | null, role: CardRole): ResolvedCardSurface;