@riverbankcms/sdk 0.144.0 → 0.145.0

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

@@ -0,0 +1,132 @@
+import { type PageDesignDecisions } from './pageDesignIntent';
+import type { PageDesignEditorIssue } from './pageDesignEditorModel';
+import { type SectionBoundaryTreatment } from './sectionTransitions';
+import type { DecorativeTransitionIntent } from './transitionCatalogue';
+import { type BoundaryOptionId, type DesignBlockId, type DesignBoundaryId, type GeneratedPageDesignBlockIntent, type PageFlowPresetId, type SiteStyleId } from './types';
+/**
+ * Where a page-design join's default treatment came from. Derived at read
+ * time and never persisted (issue 1422).
+ */
+export type PageDesignDefaultJoinSource = Readonly<{
+    kind: 'site-style-default';
+    siteStyleId: SiteStyleId;
+}> | Readonly<{
+    kind: 'page-flow-default';
+    /** Null when the page's preset id is unknown and the first option applies. */
+    pageFlowPresetId: PageFlowPresetId | null;
+}>;
+export type PageDesignJoinSource = Readonly<{
+    kind: 'user-pinned';
+}> | PageDesignDefaultJoinSource;
+export type GeneratedJoinSource = Readonly<{
+    kind: 'generated';
+    origin: 'boundary-intent' | 'block-design' | 'automatic';
+}>;
+/**
+ * Where a join's treatment came from. Only `user-pinned` is a stored choice.
+ */
+export type JoinTreatmentSource = PageDesignJoinSource | GeneratedJoinSource;
+/**
+ * One source's opinion about a join, in the persisted vocabulary. Adapters
+ * translate their inputs into these; they never decide support or fallback.
+ */
+export type JoinTreatmentCandidate<TSource extends JoinTreatmentSource = JoinTreatmentSource> = Readonly<{
+    source: TSource;
+    treatment: SectionBoundaryTreatment;
+}>;
+/**
+ * A resolved break between two adjacent blocks: which treatment, and where it
+ * came from. Whether it draws is composition's call (`composeBoundary`), made
+ * from the content that finally renders. Joins that resolve to `none` are
+ * absent rather than carried with a `none` treatment.
+ */
+export type JoinIntent<TBlockId extends DesignBlockId = DesignBlockId, TSource extends JoinTreatmentSource = JoinTreatmentSource> = Readonly<{
+    boundaryId: DesignBoundaryId;
+    previousBlockId: TBlockId;
+    nextBlockId: TBlockId;
+    treatment: DecorativeTransitionIntent;
+    source: TSource;
+}>;
+/**
+ * The public, intent-only form of a join sent to renderers. The boundary id is
+ * derivable from the two block ids (`makeBoundaryId`), and the source stays
+ * internal. The renderer decides whether each join draws, from final content.
+ */
+export type PageRuntimeJoin<TBlockId extends string = string> = Readonly<{
+    previousBlockId: TBlockId;
+    nextBlockId: TBlockId;
+    treatment: DecorativeTransitionIntent;
+}>;
+/** Narrows any join (a resolved intent included) to its public, intent-only form. */
+export declare function toPageRuntimeJoin<TBlockId extends string>(join: PageRuntimeJoin<TBlockId>): PageRuntimeJoin<TBlockId>;
+export type JoinIssue = Extract<PageDesignEditorIssue, Readonly<{
+    kind: 'pinned-boundary-option-unavailable';
+}>>;
+/**
+ * What became of the user's pin, if the candidates carried one. The editor
+ * shows a pin by this status; the unavailable-pin issue is built from it.
+ */
+export type JoinPinStatus = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'supported';
+}> | Readonly<{
+    kind: 'unsupported';
+    /** The pin's own option id, or the option the join fell back to. */
+    optionId: BoundaryOptionId;
+}>;
+export type JoinTreatmentResolution<TBlockId extends DesignBlockId = DesignBlockId, TSource extends JoinTreatmentSource = JoinTreatmentSource> = Readonly<{
+    join: JoinIntent<TBlockId, TSource> | null;
+    /**
+     * The source of the winning candidate, kept even when that candidate was
+     * `none` and so yields no join. Null only when no candidate was usable.
+     */
+    selectedSource: TSource | null;
+    pin: JoinPinStatus;
+    issues: readonly JoinIssue[];
+}>;
+/**
+ * The single rule set for which treatment a join gets. Candidates arrive in
+ * priority order; the first supported one wins.
+ *
+ * - `none` ends the search and yields no join.
+ * - An unsupported candidate (a legacy option id, or a structured treatment the
+ *   catalogue lacks) falls through to the next one. When it was the user's
+ *   pin, the pin is reported unsupported and the existing
+ *   `pinned-boundary-option-unavailable` issue is raised.
+ */
+export declare function resolveJoinTreatment<TBlockId extends DesignBlockId, TSource extends JoinTreatmentSource>(input: Readonly<{
+    candidates: readonly JoinTreatmentCandidate<TSource>[];
+    previousBlockId: TBlockId;
+    nextBlockId: TBlockId;
+}>): JoinTreatmentResolution<TBlockId, TSource>;
+/**
+ * The page-design defaults for a join, in priority order: the site style's
+ * default break after the previous block, then the page-flow default, which
+ * is always last.
+ */
+export declare function pageDesignDefaultJoinCandidates(input: Readonly<{
+    siteStyleId: SiteStyleId;
+    pageFlowPresetId: PageDesignDecisions['pageFlowPresetId'];
+    previousBlockKind: string;
+}>): readonly JoinTreatmentCandidate<PageDesignDefaultJoinSource>[];
+/** The last-resort page-design default, also the source of a fully unsupported join. */
+export declare function pageFlowDefaultJoinCandidate(pageFlowPresetId: PageDesignDecisions['pageFlowPresetId']): JoinTreatmentCandidate<Extract<PageDesignDefaultJoinSource, {
+    kind: 'page-flow-default';
+}>>;
+/**
+ * Page-design source adapter. Priority: the user's pin, then the defaults.
+ * The pin is offered even when unsupported so the rule function can report it.
+ */
+export declare function joinCandidatesFromPageDesign<TBlockId extends DesignBlockId>(intent: PageDesignDecisions<TBlockId>, siteStyleId: SiteStyleId, previous: Readonly<{
+    blockId: TBlockId;
+    blockKind: string;
+}>, next: Readonly<{
+    blockId: TBlockId;
+}>): readonly JoinTreatmentCandidate<PageDesignJoinSource>[];
+/**
+ * Generated-design source adapter. Mirrors today's materialisation: the
+ * boundary intent's explicit choice, then the block design's explicit choice,
+ * then the automatic default of no break.
+ */
+export declare function joinCandidatesFromGeneratedIntent(block: GeneratedPageDesignBlockIntent): readonly JoinTreatmentCandidate<GeneratedJoinSource>[];

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

@@ -0,0 +1,31 @@
+import { type PageDesignChoice, type PageDesignDecisions } from './pageDesignIntent';
+import type { PageDesignEditorBlock, PageDesignEditorBoundary, PageDesignEditorIssue, PageDesignEditorReadModel } from './pageDesignEditorModel';
+import { type SectionBoundaryTreatment } from './sectionTransitions';
+import { type DesignBlockId, type SiteStyleId } from './types';
+/**
+ * The editor's boundary read models. Each join's treatment, and where it came
+ * from, is decided by `resolveJoinTreatment`; this module only projects that
+ * resolution onto what the editor shows (issue 1422).
+ */
+type BoundaryReadModelResult<TBlockId extends DesignBlockId> = Readonly<{
+    boundary: PageDesignEditorBoundary<TBlockId>;
+    issues: readonly PageDesignEditorIssue<TBlockId>[];
+}>;
+export declare function buildBoundaryReadModels<TBlockId extends DesignBlockId>(input: Readonly<{
+    siteStyleId: SiteStyleId;
+    intent: PageDesignDecisions<TBlockId>;
+    blocks: readonly PageDesignEditorBlock<TBlockId>[];
+}>): readonly BoundaryReadModelResult<TBlockId>[];
+/**
+ * Re-resolves one boundary of an editor model for a changed break choice,
+ * through the same rules the model was built with. The preview uses it for
+ * optimistic updates, so a reset lands on whichever default the rules pick
+ * (site style or Page Flow). Null when either block is not in the model.
+ */
+export declare function resolvePageDesignEditorBoundaryForChoice<TBlockId extends DesignBlockId>(input: Readonly<{
+    editorModel: Pick<PageDesignEditorReadModel<TBlockId>, 'siteStyleId' | 'pageFlow' | 'blocks'>;
+    previousBlockId: TBlockId;
+    nextBlockId: TBlockId;
+    choice: PageDesignChoice<SectionBoundaryTreatment>;
+}>): PageDesignEditorBoundary<TBlockId> | null;
+export {};

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

@@ -2,17 +2,14 @@ import { type PageDesignEditorBackgroundSupport } from './pageDesignEditorCapabi
 import type { BlockDesignMetadata } from './blockFlow';
 import { type PageDesignDecisions } from './pageDesignIntent';
 import { type AppearancePresetId, type BlockDesignCapability, type CardRoleCapability, type BoundaryOptionId, type DesignBlockId, type DesignBoundaryId, type LayoutVariantKey, type NonEmptyReadonlyArray, type PageFlowPresetId, type SiteStyleId } from './types';
-import { type BoundaryOption } from './sectionTransitions';
+import type { BoundaryOption } from './sectionTransitions';
+import { type PageFlowPreset } from './pageFlowPresets';
+import type { PageDesignDefaultJoinSource } from './joinTreatment';
 import type { PageDesignEditorBlockContentRevision, PageDesignEditorLayoutOption, PageDesignEditorLookOption, PageDesignEditorLooksForLayout } from './pageDesignEditorOptions';
 export { boundaryOptions, type BoundaryOption } from './sectionTransitions';
+export { resolvePageDesignEditorBoundaryForChoice } from './pageDesignEditorBoundaries';
+export { pageFlowPresets, type PageFlowBoundaryStrategy, type PageFlowPreset, } from './pageFlowPresets';
 export type { PageDesignEditorBlockContentRevision, PageDesignEditorLayoutOption, PageDesignEditorLookOption, PageDesignEditorLooksForLayout, } from './pageDesignEditorOptions';
-export type PageFlowBoundaryStrategy = 'quiet' | 'balanced' | 'expressive';
-export type PageFlowPreset = Readonly<{
-    id: PageFlowPresetId;
-    label: string;
-    boundaryStrategy: PageFlowBoundaryStrategy;
-    defaultBoundaryOptionId: BoundaryOptionId;
-}>;
 export type PageDesignEditorBlockInput<TBlockId extends DesignBlockId = DesignBlockId> = Readonly<{
     blockId: TBlockId;
     blockKind: string;
@@ -35,7 +32,9 @@ export declare function autoEditorChoice<TValue>(effectiveValue: TValue | null):
 export declare function userPinnedEditorChoice<TValue>(value: TValue, input?: Readonly<{
     status?: 'supported' | 'unsupported';
     effectiveValue?: TValue | null;
-}>): PageDesignEditorChoice<TValue>;
+}>): Extract<PageDesignEditorChoice<TValue>, Readonly<{
+    kind: 'user-pinned';
+}>>;
 export type PageDesignEditorSelection<TValue> = Readonly<{
     kind: 'selected';
     value: TValue;
@@ -79,11 +78,35 @@ export declare const backgroundImagePromotedFieldPath: "_sectionStyles.backgroun
  */
 export declare const normalEditorCuratedPromotedFieldPaths: readonly ["_sectionStyles.background.image"];
 export type NormalEditorCuratedPromotedFieldPath = (typeof normalEditorCuratedPromotedFieldPaths)[number];
+/**
+ * Where an `auto` break comes from. A site-style default and a page-flow
+ * default are both defaults, not user choices, but the editor labels them
+ * differently.
+ */
+export type PageDesignEditorBoundaryDefaultSource = PageDesignDefaultJoinSource;
+/**
+ * A break choice as the editor shows it. It is assignable to
+ * `PageDesignEditorChoice<BoundaryOptionId>`; `auto` additionally says which
+ * default applies.
+ */
+export type PageDesignEditorBoundaryChoice = Readonly<{
+    kind: 'auto';
+    source: PageDesignEditorBoundaryDefaultSource;
+    effectiveValue: BoundaryOptionId | null;
+}> | Extract<PageDesignEditorChoice<BoundaryOptionId>, Readonly<{
+    kind: 'user-pinned';
+}>>;
 export type PageDesignEditorBoundary<TBlockId extends DesignBlockId = DesignBlockId> = Readonly<{
     boundaryId: DesignBoundaryId;
     previousBlockId: TBlockId;
     nextBlockId: TBlockId;
-    breakChoice: PageDesignEditorChoice<BoundaryOptionId>;
+    breakChoice: PageDesignEditorBoundaryChoice;
+    /**
+     * `breakChoice.effectiveValue` is the one effective break, decided by
+     * `resolveJoinTreatment`; the render compiler derives the join's treatment
+     * from it. Whether the break draws is decided by the renderer from final
+     * content.
+     */
     availableBreaks: readonly BoundaryOption[];
 }>;
 export type PageDesignEditorIssue<TBlockId extends DesignBlockId = DesignBlockId> = Readonly<{
@@ -126,25 +149,6 @@ export type PageDesignEditorReadModel<TBlockId extends DesignBlockId = DesignBlo
     boundaries: readonly PageDesignEditorBoundary<TBlockId>[];
     issues: readonly PageDesignEditorIssue<TBlockId>[];
 }>;
-/**
- * Must remain non-empty; downstream code indexes `[0]` as the documented default.
- */
-export declare const pageFlowPresets: readonly [{
-    readonly id: PageFlowPresetId;
-    readonly label: "Quiet";
-    readonly boundaryStrategy: "quiet";
-    readonly defaultBoundaryOptionId: BoundaryOptionId;
-}, {
-    readonly id: PageFlowPresetId;
-    readonly label: "Balanced";
-    readonly boundaryStrategy: "balanced";
-    readonly defaultBoundaryOptionId: BoundaryOptionId;
-}, {
-    readonly id: PageFlowPresetId;
-    readonly label: "Expressive";
-    readonly boundaryStrategy: "expressive";
-    readonly defaultBoundaryOptionId: BoundaryOptionId;
-}];
 export declare function buildPageDesignEditorReadModel<TBlockId extends DesignBlockId>(input: Readonly<{
     siteStyleId: SiteStyleId;
     intent: PageDesignDecisions<TBlockId>;

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

@@ -176,9 +176,9 @@ export declare const pageDesignBoundaryTreatmentSchema: z.ZodDiscriminatedUnion<
         double: "double";
     }>;
     symmetry: z.ZodEnum<{
+        drift: "drift";
         symmetrical: "symmetrical";
         asymmetrical: "asymmetrical";
-        drift: "drift";
     }>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"angle-edge">;
@@ -234,9 +234,9 @@ export declare const pageDesignUserPinnedBoundaryTreatmentChoiceSchema: z.ZodObj
             double: "double";
         }>;
         symmetry: z.ZodEnum<{
+            drift: "drift";
             symmetrical: "symmetrical";
             asymmetrical: "asymmetrical";
-            drift: "drift";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"angle-edge">;
@@ -305,9 +305,9 @@ export declare const pageDesignBoundaryPinSchema: z.ZodObject<{
                 double: "double";
             }>;
             symmetry: z.ZodEnum<{
+                drift: "drift";
                 symmetrical: "symmetrical";
                 asymmetrical: "asymmetrical";
-                drift: "drift";
             }>;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"angle-edge">;
@@ -417,9 +417,9 @@ export declare const pageDesignIntentV2Schema: z.ZodObject<{
                     double: "double";
                 }>;
                 symmetry: z.ZodEnum<{
+                    drift: "drift";
                     symmetrical: "symmetrical";
                     asymmetrical: "asymmetrical";
-                    drift: "drift";
                 }>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"angle-edge">;

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

@@ -0,0 +1,36 @@
+import { type BoundaryOptionId, type PageFlowPresetId } from './types';
+export type PageFlowBoundaryStrategy = 'quiet' | 'balanced' | 'expressive';
+export type PageFlowPreset = Readonly<{
+    id: PageFlowPresetId;
+    label: string;
+    boundaryStrategy: PageFlowBoundaryStrategy;
+    defaultBoundaryOptionId: BoundaryOptionId;
+}>;
+/**
+ * Must remain non-empty; downstream code indexes `[0]` as the documented default.
+ */
+export declare const pageFlowPresets: readonly [{
+    readonly id: PageFlowPresetId;
+    readonly label: "Quiet";
+    readonly boundaryStrategy: "quiet";
+    readonly defaultBoundaryOptionId: BoundaryOptionId;
+}, {
+    readonly id: PageFlowPresetId;
+    readonly label: "Balanced";
+    readonly boundaryStrategy: "balanced";
+    readonly defaultBoundaryOptionId: BoundaryOptionId;
+}, {
+    readonly id: PageFlowPresetId;
+    readonly label: "Expressive";
+    readonly boundaryStrategy: "expressive";
+    readonly defaultBoundaryOptionId: BoundaryOptionId;
+}];
+/**
+ * The break a join gets when nothing more specific applies. An unknown preset
+ * id (a stale or policy-owned one) falls back to the first boundary option,
+ * and `preset` is null so callers can tell the two apart.
+ */
+export declare function pageFlowDefaultBoundary(pageFlowPresetId: PageFlowPresetId): Readonly<{
+    preset: PageFlowPreset | null;
+    boundaryOptionId: BoundaryOptionId;
+}>;

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

@@ -5,7 +5,7 @@ import { type CuratedSiteStyle } from './curatedSiteStyles';
 import { type FooterLookId } from './footerLooks';
 import type { SiteThemeCompilationPlan } from './compilationPlan';
 import type { HeaderLayoutStyleSelection } from './headerLayoutStyles';
-import { type CompiledBlockRuntimeFields, type CompiledBoundaryRuntime, type CompiledPageRuntime, type ComponentRuntimeRules, type DesignRuntimeRules, type SemanticSpacing, type SurfaceResolutionContext } from './runtimeCompiler';
+import { type CompiledBlockRuntimeFields, 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';
 import type { SelectionFallbackWarning } from './selectionFallbackWarning';
@@ -20,13 +20,14 @@ export type { CuratedSiteStyleTheme } from './siteStyleThemeCompiler';
  * enforced by `previewCompiler.client-boundary.test.ts`.
  */
 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 { buildPageDesignEditorReadModel, boundaryOptions, pageFlowPresets, type BoundaryOption, type PageDesignEditorBlock, type PageDesignEditorBoundary, type PageDesignEditorBoundaryChoice, type PageDesignEditorBoundaryDefaultSource, 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 { cycleableOptionsFromResolved, deriveDesignCustomizationScope, recommendedDesignOption, type CycleableDesignOption, type CycleableOptions, type DesignCustomizationAuthority, type DesignCustomizationScope, type DesignCustomizationSurface, type DesignCustomizationUnsupportedReason, type DesignOptionIssue, type ResolvedDesignOption, } from './previewCustomization';
-export { compileBlockRuntimeFields, compileBoundaryRuntime, compilePageRuntimeFields, compileTokenRecipes, compileTransitionRuntime, compiledRuntimeStyleFieldNames, defaultComponentRuntimeRules, defaultDesignRuntimeRules, surfaceResolutionContextFromPalette, surfaceResolutionContextFromTheme, stripCompiledRuntimeStyleFields, type CompiledBlockRuntime, type CompiledBlockRuntimeFields, type CompiledBoundaryRuntime, type CompiledPageRuntime, type CompileBlockRuntimeInput, type ComponentRuntimeRules, type DesignRuntimeRules, type SemanticSpacing, type SurfaceResolutionContext, } from './runtimeCompiler';
+export { compileBlockRuntimeFields, compilePageRuntimeFields, compileTokenRecipes, compiledRuntimeStyleFieldNames, defaultComponentRuntimeRules, defaultDesignRuntimeRules, surfaceResolutionContextFromPalette, surfaceResolutionContextFromTheme, stripCompiledRuntimeStyleFields, type CompiledBlockRuntime, type CompiledBlockRuntimeFields, type CompiledPageRuntime, type CompileBlockRuntimeInput, type ComponentRuntimeRules, type DesignRuntimeRules, type SemanticSpacing, type SurfaceResolutionContext, } from './runtimeCompiler';
 export { defaultCuratedChoice, requireEntriesForCuratedChoices, resolveCuratedChoice, type CuratedChoice, type CuratedChoiceResolution, } from './curatedChoices';
 export { curatedSiteStyles, defaultButtonStyleSelectionForSiteStyle, defaultPaletteForSiteStyle, getCuratedSiteStyle, type CuratedSiteStyle, } from './curatedSiteStyles';
+export { toPageRuntimeJoin, type PageRuntimeJoin, } from './joinTreatment';
 export { asDesignBlockId, asSiteStyleId, makeBoundaryId, type AppearancePresetId, type BoundaryOptionId, type DesignBlockId, type DesignBoundaryId, type LayoutVariantKey, type NonEmptyReadonlyArray, type PageFlowPresetId, type ResolvedPageDesignPlan, type SiteStyleId, } from './types';
 export declare const previewCustomizePurpose: "preview-customize";
 /**
@@ -99,15 +100,8 @@ export type CompileEditorModelRuntimeInput<TBlockId extends DesignBlockId = Desi
  */
 export declare function compileEditorModelRuntime<TBlockId extends DesignBlockId>(input: CompileEditorModelRuntimeInput<TBlockId>): CompiledPageRuntime<TBlockId>;
 export declare function buildEditorModelRuntimeFieldsByBlockId<TBlockId extends DesignBlockId>(input: CompileEditorModelRuntimeInput<TBlockId>): ReadonlyMap<TBlockId, CompiledBlockRuntimeFields>;
-export declare function buildEditorModelRuntimeBoundaries<TBlockId extends DesignBlockId>(input: CompileEditorModelRuntimeInput<TBlockId>): readonly CompiledBoundaryRuntime<TBlockId>[];
 export declare function compileEditorModelRuntimeFieldsForBlock<TBlockId extends DesignBlockId>(input: CompileEditorModelRuntimeInput<TBlockId> & Readonly<{
     blockId: TBlockId;
 }>): CompiledBlockRuntimeFields | null;
 export declare function applyCompiledRuntimeFieldsToContent<TContent extends Record<string, unknown>>(content: TContent, fields: CompiledBlockRuntimeFields | null | undefined): Record<string, unknown>;
-export type RuntimeContentAdjacency = Readonly<{
-    currentContent: Record<string, unknown> | null | undefined;
-    nextContent: Record<string, unknown> | null | undefined;
-}>;
-export declare function retargetCompiledRuntimeFieldsForContentAdjacency(fields: CompiledBlockRuntimeFields | null | undefined, adjacency: RuntimeContentAdjacency): CompiledBlockRuntimeFields | null | undefined;
-export declare function retargetCompiledBoundaryRuntimeForContentAdjacency<TBlockId extends string>(boundary: CompiledBoundaryRuntime<TBlockId>, adjacency: RuntimeContentAdjacency): CompiledBoundaryRuntime<TBlockId>;
 export declare function restoreCompiledRuntimeFieldsFromContent<TCurrentContent extends Record<string, unknown>, TPreviousContent extends Record<string, unknown>>(currentContent: TCurrentContent, previousContent: TPreviousContent): Record<string, unknown>;

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

@@ -1,14 +1,27 @@
-export declare const themeV2RuntimeStyleFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_cardStyles", "_transitionStyles", "styleGroup"];
+export declare const themeV2RuntimeStyleFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_cardStyles"];
 export type ThemeV2RuntimeStyleFieldName = typeof themeV2RuntimeStyleFieldNames[number];
 export declare const themeV2BlockSpecificRawStyleFieldNames: readonly ["_contentCardStyles", "_heroLayoutStyles", "_textCardStyles"];
 export type ThemeV2BlockSpecificRawStyleFieldName = typeof themeV2BlockSpecificRawStyleFieldNames[number];
-export type ThemeV2NormalEditorRawStyleFieldName = ThemeV2RuntimeStyleFieldName | ThemeV2BlockSpecificRawStyleFieldName;
+/**
+ * `styleGroup` is authored content (a theme's style-group select, or an SDK
+ * site's own value), not compiler output, so it is neither a runtime field
+ * nor compiler-owned. Normal editors still never show it directly.
+ */
+export type ThemeV2NormalEditorRawStyleFieldName = ThemeV2RuntimeStyleFieldName | ThemeV2BlockSpecificRawStyleFieldName | 'styleGroup';
 export type ThemeV2CompilerOwnedFieldName = ThemeV2RuntimeStyleFieldName | ThemeV2BlockSpecificRawStyleFieldName;
-export declare const themeV2NormalEditorRawStyleFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_cardStyles", "_transitionStyles", "styleGroup", "_contentCardStyles", "_heroLayoutStyles", "_textCardStyles"];
-export declare const themeV2CompilerOwnedFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_cardStyles", "_transitionStyles", "styleGroup", "_contentCardStyles", "_heroLayoutStyles", "_textCardStyles"];
+export declare const themeV2NormalEditorRawStyleFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_cardStyles", "_contentCardStyles", "_heroLayoutStyles", "_textCardStyles", "styleGroup"];
+export declare const themeV2CompilerOwnedFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_cardStyles", "_contentCardStyles", "_heroLayoutStyles", "_textCardStyles"];
 export declare const pageDesignEditorBackgroundOverrideOwner: "page-design-editor";
 export type PageDesignEditorBackgroundOverrideOwner = typeof pageDesignEditorBackgroundOverrideOwner;
 export declare const siteChromeBackgroundOverrideOwner: "site-chrome-editor";
 export type SiteChromeBackgroundOverrideOwner = typeof siteChromeBackgroundOverrideOwner;
 export declare function isThemeV2NormalEditorRawStyleFieldName(fieldName: string): boolean;
 export declare function isThemeV2NormalEditorRawStylePath(fieldPath: string): boolean;
+/**
+ * A `styleGroup` in the retired `site-style-transition-*` namespace is residue
+ * from the old per-block transition path (issue 1422). Any other value is
+ * authored and must survive.
+ */
+export declare function isStaleTransitionStyleGroup(value: unknown): boolean;
+/** Drops a stale transition `styleGroup`, leaving authored values untouched. */
+export declare function stripStaleTransitionStyleGroup(content: Readonly<Record<string, unknown>>): Record<string, unknown>;

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

@@ -2,8 +2,8 @@ import { type CardStylesOverride, type ContainerStylesOverride, type SectionStyl
 import { type ExpandedPalette } from '../palette/expandPalette';
 import { type ButtonStyleSelection } from '../buttons/styles';
 import { type RuntimeStyleWriteResultForFields, type StyleAuthority } from './designState';
-import { type ContentFrameIntent, type BlockCompositionIntent, type EyebrowTreatment, type FlushFrameTreatment, type DesignBoundaryId, type PanelFrameTreatment, type ResolvedBlockDesignPlan, type ResolvedPageDesignPlan, type SiteStyleSectionTransitionIntent, type SiteStyleSurfaceIntent, type ThemeTokenRecipes } from './types';
-import { type SectionBoundaryRuntimeMetrics } from './sectionTransitions';
+import { type ContentFrameIntent, type BlockCompositionIntent, type EyebrowTreatment, type FlushFrameTreatment, type DesignBlockId, type PanelFrameTreatment, type ResolvedBlockDesignPlan, type ResolvedPageDesignPlan, type SiteStyleSurfaceIntent, type ThemeTokenRecipes } from './types';
+import { type PageRuntimeJoin } from './joinTreatment';
 import { type ThemeColorToken } from '../tokens';
 import { type GradientPresetId } from '../gradients';
 export type SemanticSpacing = 'none' | 'compact' | 'cozy' | 'medium' | 'comfortable' | 'spacious';
@@ -39,7 +39,6 @@ export type DesignRuntimeRules = Readonly<{
     sectionSurfaces: Readonly<Record<SiteStyleSurfaceIntent, SectionSurfaceRuntimeRule>>;
     defaultEyebrowTreatment?: EyebrowTreatment;
     heroLegibility: Readonly<Record<Exclude<NonNullable<ResolvedBlockDesignPlan['appliedHeroLegibility']>, 'none'>, NonNullable<ImageSectionBackgroundOverride['overlay']>>>;
-    transitionClassName: (transition: SiteStyleSectionTransitionIntent, fromSurface: SiteStyleSurfaceIntent, toSurface: SiteStyleSurfaceIntent) => string | null;
 }>;
 export type ComponentRuntimeRules = Readonly<{
     panelFrames: Readonly<Record<PanelFrameTreatment, ContainerStylesOverride>>;
@@ -52,40 +51,8 @@ export type CompiledBlockRuntimeFields = Readonly<{
     _contentCardStyles?: ContainerStylesOverride;
     _heroLayoutStyles?: HeroLayoutStylesOverride;
     _cardStyles?: CardStylesOverride;
-    _transitionStyles?: CompiledTransitionRuntime;
     blockLook?: string;
     blockComposition?: BlockCompositionIntent;
-    styleGroup?: string;
-}>;
-export type CompiledTransitionEndpoint = Readonly<{
-    kind: 'surface';
-    surface: SiteStyleSurfaceIntent;
-}> | Readonly<{
-    kind: 'color-token';
-    token: ThemeColorToken;
-}>;
-export type CompiledTransitionRuntime = Readonly<{
-    treatment: SiteStyleSectionTransitionIntent;
-    from: CompiledTransitionEndpoint;
-    to: CompiledTransitionEndpoint;
-    cssVars: Readonly<{
-        from: string;
-        to: string;
-    }>;
-}>;
-export type CompiledBoundaryRuntime<TBlockId extends string = string> = Readonly<{
-    boundaryId: DesignBoundaryId | string;
-    previousBlockId: TBlockId;
-    nextBlockId: TBlockId;
-    treatment: SiteStyleSectionTransitionIntent;
-    metrics: SectionBoundaryRuntimeMetrics;
-    from: CompiledTransitionEndpoint;
-    to: CompiledTransitionEndpoint;
-    cssVars: Readonly<{
-        from: string;
-        to: string;
-    }>;
-    styleGroup: string;
 }>;
 export type HeroLayoutStylesOverride = Readonly<{
     contentAlignment?: 'left' | 'center' | 'right';
@@ -93,7 +60,11 @@ export type HeroLayoutStylesOverride = Readonly<{
     contentMaxWidth?: 'default' | 'narrow' | 'medium' | 'wide';
     typographyScale?: NonNullable<ResolvedBlockDesignPlan['heroTypographyScale']>;
 }>;
-export declare const compiledRuntimeStyleFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_contentCardStyles", "_heroLayoutStyles", "_cardStyles", "_transitionStyles", "blockLook", "blockComposition", "styleGroup"];
+export declare const compiledRuntimeStyleFieldNames: readonly ["_frameStyles", "_sectionStyles", "_containerStyles", "_contentCardStyles", "_heroLayoutStyles", "_cardStyles", "blockLook", "blockComposition"];
+/**
+ * Removes every compiler-owned field, plus a stale transition `styleGroup`.
+ * An authored `styleGroup` is content and survives.
+ */
 export declare function stripCompiledRuntimeStyleFields<TContent extends Record<string, unknown>>(content: TContent): Record<string, unknown>;
 export type CompiledBlockRuntime = Readonly<{
     blockId: string;
@@ -113,12 +84,6 @@ export type CompileBlockRuntimeInput<TBlockId extends string, TPurpose extends s
     designRules?: DesignRuntimeRules;
     componentRules?: ComponentRuntimeRules;
     sectionSpacing?: SemanticSpacing;
-    sectionAdjacency?: SectionAdjacency;
-    /**
-     * @deprecated Prefer `sectionAdjacency`. Kept for isolated block callers that
-     * compile one block with an explicit following section surface.
-     */
-    nextSectionSurface?: SiteStyleSurfaceIntent;
 }>;
 export type CompileBlockRuntimeIntoContentInput<TBlockId extends string, TPurpose extends string, TContent extends Record<string, unknown>> = CompileBlockRuntimeInput<TBlockId, TPurpose> & Readonly<{
     content: TContent;
@@ -128,25 +93,13 @@ export type CompiledPageRuntime<TBlockId extends string = string> = Readonly<{
     blocks: readonly (CompiledBlockRuntime & Readonly<{
         blockId: TBlockId;
     }>)[];
-    boundaries: readonly CompiledBoundaryRuntime<TBlockId>[];
+    joins: readonly PageRuntimeJoin<TBlockId>[];
 }>;
-export type SectionAdjacency = Readonly<{
-    kind: 'next-section';
-    surface: SiteStyleSurfaceIntent;
-}> | Readonly<{
-    kind: 'terminal-surface';
-    surface: SiteStyleSurfaceIntent;
-}> | Readonly<{
-    kind: 'page-end';
-}>;
-export type TerminalSectionAdjacency = Extract<SectionAdjacency, Readonly<{
-    kind: 'terminal-surface' | 'page-end';
-}>>;
 export declare function defineDesignRuntimeRules<const TRules extends DesignRuntimeRules>(rules: TRules): TRules;
 export declare function defineComponentRuntimeRules<const TRules extends ComponentRuntimeRules>(rules: TRules): TRules;
 /**
  * Default design rules translate semantic page-level choices into the current
- * runtime's section background and transition style-group vocabulary.
+ * runtime's section background vocabulary.
  */
 export declare const defaultDesignRuntimeRules: {
     readonly sectionSurfaces: {
@@ -193,7 +146,6 @@ export declare const defaultDesignRuntimeRules: {
             readonly opacity: 0.88;
         };
     };
-    readonly transitionClassName: (transition: SiteStyleSectionTransitionIntent, fromSurface: SiteStyleSurfaceIntent, toSurface: SiteStyleSurfaceIntent) => string | null;
 };
 /**
  * Default component rules translate frame and item-surface semantics into the
@@ -245,33 +197,27 @@ export declare const defaultComponentRuntimeRules: {
 export declare function compileBlockRuntimeFields<TBlockId extends string, TPurpose extends string>(input: CompileBlockRuntimeInput<TBlockId, TPurpose>): CompiledBlockRuntime & Readonly<{
     blockId: TBlockId;
 }>;
-export declare function compileTransitionRuntime(input: Readonly<{
-    treatment: SiteStyleSectionTransitionIntent;
-    from: CompiledTransitionEndpoint;
-    to: CompiledTransitionEndpoint;
-}>): CompiledTransitionRuntime;
-export declare function compileBoundaryRuntime<TBlockId extends string>(input: Readonly<{
-    boundaryId: DesignBoundaryId | string;
-    previousBlockId: TBlockId;
-    nextBlockId: TBlockId;
-    treatment: SiteStyleSectionTransitionIntent;
-    fromSurface: SiteStyleSurfaceIntent;
-    toSurface: SiteStyleSurfaceIntent;
-    rules?: DesignRuntimeRules;
-}>): CompiledBoundaryRuntime<TBlockId> | null;
 /**
  * Compiles block runtime fields and writes them into content only when Theme V2
  * owns that block's runtime-style fields.
  */
 export declare function compileBlockRuntimeFieldsIntoContent<TBlockId extends string, TPurpose extends string, TContent extends Record<string, unknown>>(input: CompileBlockRuntimeIntoContentInput<TBlockId, TPurpose, TContent>): RuntimeStyleWriteResultForFields<TContent, CompiledBlockRuntimeFields>;
-/** Compiles a resolved page plan into legacy runtime fields for each resolved block. */
-export declare function compilePageRuntimeFields<TBlockId extends string, TPurpose extends string>(input: Readonly<{
+/**
+ * Compiles a resolved page plan into legacy runtime fields for each resolved
+ * block, plus the public runtime joins between them.
+ *
+ * Joins come from `resolveJoinTreatment`; plans no longer carry a treatment.
+ * Only joins whose two blocks were compiled are kept, and they leave as intent
+ * only: the blocks renderer composes each one from final content after
+ * omission, including whether it draws at all (issue 1422).
+ */
+export declare function compilePageRuntimeFields<TBlockId extends DesignBlockId, TPurpose extends string>(input: Readonly<{
     resolved: ResolvedPageDesignPlan<TBlockId, TPurpose>;
+    joins: readonly PageRuntimeJoin<TBlockId>[];
     surfaceResolutionContext: SurfaceResolutionContext;
     designRules?: DesignRuntimeRules;
     componentRules?: ComponentRuntimeRules;
     sectionSpacing?: SemanticSpacing;
-    terminalSectionAdjacency?: TerminalSectionAdjacency;
 }>): CompiledPageRuntime<TBlockId>;
 type PaletteCompileOptions = Readonly<{
     /** A complete concrete palette supplied by the theme/editor boundary. */