@riverbankcms/sdk 0.125.0 → 0.127.0

package/dist/server/theme.mjs

@@ -431,7 +431,7 @@ const PALETTE_TOKEN_NAMES = [
 	"text",
 	"border"
 ];
-z$1.enum(PALETTE_TOKEN_NAMES);
+const paletteTokenNameSchema = z$1.enum(PALETTE_TOKEN_NAMES);
 const themeColorBaseTokenNames = [
 	...PALETTE_TOKEN_NAMES,
 	...blockColorTokenNames,
@@ -478,6 +478,144 @@ function parseThemeColorToken(value) {
 }
 const themeColorTokenSchema = z$1.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
 //#endregion
+//#region ../theme-core/src/palette/colors.ts
+const HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
+const NORMALIZABLE_HEX_REGEX = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+const THEME_PALETTE_COLOR_ORDER = [
+	"primary",
+	"secondary",
+	"accent",
+	"success",
+	"warning",
+	"destructive",
+	"background",
+	"surface",
+	"surfaceAlt",
+	"muted",
+	"text",
+	"primaryForeground",
+	"border"
+];
+const hexColorSchema = z$1.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+const paletteModeSchema = z$1.enum(["light", "dark"]);
+const PALETTE_VALUE_KEY_PREFIX = "palette-value:v1|";
+z$1.string().regex(/^[0-9a-f]{64}$/, "Palette hash must be a lowercase SHA-256 value").transform((value) => value);
+const paletteColorsSchema = z$1.object({
+	primary: hexColorSchema,
+	primaryForeground: hexColorSchema,
+	secondary: hexColorSchema,
+	accent: hexColorSchema,
+	success: hexColorSchema,
+	warning: hexColorSchema,
+	destructive: hexColorSchema,
+	background: hexColorSchema,
+	surface: hexColorSchema,
+	surfaceAlt: hexColorSchema,
+	muted: hexColorSchema,
+	text: hexColorSchema,
+	border: hexColorSchema
+}).strict().transform((value) => value);
+function normalizePaletteHex(value) {
+	if (!NORMALIZABLE_HEX_REGEX.test(value)) return null;
+	const normalized = value.toLowerCase();
+	if (normalized.length === 7) return normalized;
+	const triplet = normalized.slice(1);
+	const red = triplet.charAt(0);
+	const green = triplet.charAt(1);
+	const blue = triplet.charAt(2);
+	return `#${red}${red}${green}${green}${blue}${blue}`;
+}
+function paletteColorsFromEntries(entries) {
+	const values = {};
+	for (const entry of entries) {
+		const parsedRole = paletteTokenNameSchema.safeParse(entry.name);
+		if (!parsedRole.success) return {
+			ok: false,
+			error: {
+				kind: "unknown-role",
+				role: entry.name
+			}
+		};
+		const role = parsedRole.data;
+		if (values[role] !== void 0) return {
+			ok: false,
+			error: {
+				kind: "duplicate-role",
+				role
+			}
+		};
+		const hex = normalizePaletteHex(entry.hex);
+		if (!hex) return {
+			ok: false,
+			error: {
+				kind: "invalid-color",
+				role,
+				value: entry.hex
+			}
+		};
+		values[role] = hex;
+	}
+	const missing = PALETTE_TOKEN_NAMES.filter((role) => values[role] === void 0);
+	if (missing.length > 0) return {
+		ok: false,
+		error: {
+			kind: "missing-roles",
+			roles: missing
+		}
+	};
+	return {
+		ok: true,
+		colors: paletteColorsSchema.parse(values)
+	};
+}
+function paletteColorEntries(colors) {
+	return THEME_PALETTE_COLOR_ORDER.map((name) => ({
+		name,
+		hex: colors[name]
+	}));
+}
+function paletteColorFingerprint(colors) {
+	return PALETTE_TOKEN_NAMES.map((name) => `${name}:${colors[name]}`).join("|");
+}
+function canonicalPaletteHashInput(colors, mode) {
+	return `${mode}|${paletteColorFingerprint(colors)}`;
+}
+/**
+* Stable curated-catalogue identity. Do not reorder roles: the order comes
+* from PALETTE_TOKEN_NAMES through canonicalPaletteHashInput.
+*/
+function paletteValueKey(colors, mode) {
+	return `${PALETTE_VALUE_KEY_PREFIX}${canonicalPaletteHashInput(colors, mode)}`;
+}
+/** Parses only the exact v1 canonical form emitted by paletteValueKey. */
+function parsePaletteValueKey(value) {
+	if (typeof value !== "string" || !value.startsWith(PALETTE_VALUE_KEY_PREFIX)) return null;
+	const [rawMode, ...rawRoles] = value.slice(17).split("|");
+	const mode = paletteModeSchema.safeParse(rawMode);
+	if (!mode.success || rawRoles.length !== PALETTE_TOKEN_NAMES.length) return null;
+	const colors = paletteColorsFromEntries(rawRoles.map((roleValue) => {
+		const separator = roleValue.indexOf(":");
+		return separator === -1 ? {
+			name: "",
+			hex: ""
+		} : {
+			name: roleValue.slice(0, separator),
+			hex: roleValue.slice(separator + 1)
+		};
+	}));
+	if (!colors.ok || paletteValueKey(colors.colors, mode.data) !== value) return null;
+	return value;
+}
+z$1.string().transform((value, ctx) => {
+	const parsed = parsePaletteValueKey(value);
+	if (parsed) return parsed;
+	ctx.addIssue({
+		code: "custom",
+		message: "Invalid canonical palette value key"
+	});
+	return z$1.NEVER;
+});
+//#endregion
 //#region ../theme-core/src/lib/media.ts
 const hotspotSchema = z.object({
 	x: z.number().min(0).max(1),
@@ -535,6 +673,34 @@ const mediaSchema = z.object({
 	transform: transformSchema.optional()
 });
 //#endregion
+//#region ../theme-core/src/palette/schema.ts
+const colourHexString = z$1.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+const paletteColorSchema = z$1.object({
+	name: z$1.string().min(1),
+	hex: colourHexString
+});
+const paletteMetaSchema = z$1.object({ mode: z$1.enum(["light", "dark"]) });
+const paletteSchema = z$1.object({
+	colors: z$1.array(paletteColorSchema),
+	meta: paletteMetaSchema
+}).transform((palette, ctx) => {
+	const colors = paletteColorsFromEntries(palette.colors);
+	if (!colors.ok) {
+		ctx.addIssue({
+			code: "custom",
+			message: `Invalid complete palette: ${colors.error.kind}`
+		});
+		return z$1.NEVER;
+	}
+	return {
+		colors: paletteColorEntries(colors.colors).map(({ name, hex }) => ({
+			name: String(name),
+			hex: String(hex)
+		})),
+		meta: palette.meta
+	};
+});
+//#endregion
 //#region ../theme-core/src/buttons/types.ts
 /**
 * Standard semantic variant roles a theme exposes.
@@ -547,8 +713,6 @@ const VARIANT_ROLES = [
 	"secondary",
 	"outline",
 	"ghost",
-	"link",
-	"tertiary",
 	"accent"
 ];
 /**
@@ -557,7 +721,7 @@ const VARIANT_ROLES = [
 * IDs become class selectors, so keep the contract deliberately narrower than
 * an arbitrary string and shared with every authoring/runtime boundary.
 */
-const buttonVariantIdSchema = z$1.string().min(1).max(50).regex(/^[a-z0-9-]+$/, "Button variant IDs may contain lowercase letters, numbers, and hyphens only");
+const buttonVariantIdSchema = z$1.string().min(1).max(50).regex(/^[a-z0-9-]+$/, "Button variant IDs may contain lowercase letters, numbers, and hyphens only").refine((value) => value !== "link" && value !== "tertiary", { message: "Retired button role IDs are not valid variant IDs" });
 function parseOpaqueButtonColourToken(value) {
 	const token = parseThemeColorToken(value);
 	if (token === null) return null;
@@ -1472,6 +1636,59 @@ function parseThemeForPersistence(value) {
 		value: theme
 	};
 }
+shadeBackgroundEffect({
+	id: "darken-background",
+	name: "Darken on Hover",
+	description: "Darkens the background color on hover",
+	label: "Darken Amount (shade step)",
+	shadeDirection: 1
+});
+shadeBackgroundEffect({
+	id: "lighten-background",
+	name: "Lighten on Hover",
+	description: "Lightens the background color on hover",
+	label: "Lighten Amount (shade step)",
+	shadeDirection: -1
+});
+function shadeBackgroundEffect(config) {
+	return {
+		id: config.id,
+		name: config.name,
+		description: config.description,
+		category: "background",
+		pseudoElement: "none",
+		applicableTo: ["button"],
+		customizableOption: {
+			name: "amount",
+			type: "select",
+			label: config.label,
+			default: 100,
+			options: [
+				0,
+				100,
+				200,
+				300,
+				400,
+				500,
+				600,
+				700,
+				800,
+				900
+			]
+		},
+		isApplicable: (buttonConfig) => buttonConfig.background.type === "solid",
+		generateCSS: ({ themeId, variantId, options, tokens, buttonConfig }) => {
+			if (buttonConfig.background.type !== "solid") return "";
+			const amount = (options.amount || 100) * config.shadeDirection;
+			const baseToken = buttonConfig.background.colorToken ?? "primary-500";
+			return `
+      :where([data-theme-scope="${themeId}"]) .${variantId}:hover {
+        background-color: ${tokens.getColor(tokens.adjustShade(baseToken, amount))};
+      }
+    `;
+		}
+	};
+}
 buttonSizeNameSchema.options;
 //#endregion
 //#region ../theme-core/src/buttons/styles/domain.ts
@@ -4021,6 +4238,60 @@ const siteChromeBackgroundOverrideOwner = "site-chrome-editor";
 * palette context and happens in `parseThemeColorReference`.
 */
 const tokenOrCssColorValueSchema = z$1.string();
+const BREAKPOINT_LG = 1024;
+const BREAKPOINT_XL = 1280;
+const BREAKPOINT_LG_DOWN = BREAKPOINT_LG - 1;
+function mqUp(px) {
+	return `(min-width: ${px}px)`;
+}
+function mqDown(px) {
+	return `(max-width: ${px}px)`;
+}
+function mqBetween(minPx, maxPx) {
+	return `${mqUp(minPx)} and ${mqDown(maxPx)}`;
+}
+mqUp(640);
+mqUp(768);
+mqUp(BREAKPOINT_LG);
+mqUp(BREAKPOINT_XL);
+mqDown(639);
+mqDown(767);
+mqDown(BREAKPOINT_LG_DOWN);
+mqBetween(640, BREAKPOINT_LG_DOWN);
+mqDown(640);
+mqDown(768);
+//#endregion
+//#region ../theme-core/src/header/scrollTreatment.ts
+const headerScrollTreatmentSchema = z$1.discriminatedUnion("kind", [z$1.object({
+	kind: z$1.literal("contrast-glass"),
+	backgroundTone: z$1.enum(["light", "dark"])
+})]).optional();
+//#endregion
+//#region ../theme-core/src/header/containerSchema.ts
+const headerContainerSchema = z$1.object({
+	rounded: z$1.enum([
+		"none",
+		"sm",
+		"md",
+		"lg",
+		"xl",
+		"2xl"
+	]).default("xl"),
+	border: z$1.boolean().default(true),
+	shadow: z$1.boolean().default(true),
+	padding: z$1.enum([
+		"sm",
+		"md",
+		"lg"
+	]).default("md"),
+	tint: z$1.string().nullable().optional(),
+	opacity: z$1.number().min(0).max(1).default(.12)
+}).optional();
+const headerInteractionPaletteSchema = z$1.enum([
+	"primary",
+	"secondary",
+	"accent"
+]);
 //#endregion
 //#region ../theme-core/src/schema.ts
 const axesSchema = z$1.object({
@@ -4051,16 +4322,6 @@ const axesSchema = z$1.object({
 		"expressive"
 	])
 });
-const colourHexString = z$1.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-const paletteColorSchema = z$1.object({
-	name: z$1.string().min(1),
-	hex: colourHexString
-});
-const paletteMetaSchema = z$1.object({ mode: z$1.enum(["light", "dark"]) });
-const paletteSchema = z$1.object({
-	colors: z$1.array(paletteColorSchema),
-	meta: paletteMetaSchema
-});
 const typographyStyleSchema = z$1.object({
 	family: z$1.string().min(1),
 	weight: z$1.enum([
@@ -4440,25 +4701,6 @@ const navFontWeight = z$1.enum([
 ]);
 const headerMaxWidth = z$1.enum(["container", "full"]);
 const headerBarFrame = z$1.enum(["full-bleed", "inset-shell"]);
-const headerContainerSchema = z$1.object({
-	rounded: z$1.enum([
-		"none",
-		"sm",
-		"md",
-		"lg",
-		"xl",
-		"2xl"
-	]).default("xl"),
-	border: z$1.boolean().default(true),
-	shadow: z$1.boolean().default(true),
-	padding: z$1.enum([
-		"sm",
-		"md",
-		"lg"
-	]).default("md"),
-	tint: z$1.string().nullable().optional(),
-	opacity: z$1.number().min(0).max(1).default(.12)
-}).optional();
 const headerBorderSchema = componentBorderSchema.extend({ position: z$1.enum([
 	"bottom",
 	"top",
@@ -4585,6 +4827,7 @@ const headerSchema = z$1.object({
 	shrinkOnScroll: z$1.boolean(),
 	maxWidth: headerMaxWidth,
 	barFrame: headerBarFrame.optional(),
+	scrollTreatment: headerScrollTreatmentSchema,
 	logoOverride: mediaSchema.nullable().optional(),
 	background: headerBackgroundSchema.default({
 		type: "color",
@@ -4597,6 +4840,7 @@ const headerSchema = z$1.object({
 	navFontRole: z$1.enum(["body", "heading"]).optional(),
 	navTypography: z$1.enum(["body", "heading"]).optional(),
 	navTextSize: navLinkStyleSchema.shape.textSize,
+	interactionPalette: headerInteractionPaletteSchema.optional(),
 	navPlacement: z$1.enum(["end", "center"]).optional(),
 	container: headerContainerSchema,
 	border: headerBorderSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riverbankcms/sdk",
-  "version": "0.125.0",
+  "version": "0.127.0",
   "description": "Riverbank CMS SDK for headless content consumption",
   "main": "./dist/server/index.mjs",
   "module": "./dist/server/index.mjs",

package/dist/_dts/editor-blocks/src/widgets/rich-text/ensureRichTextImageAssetIdentifier.d.ts

@@ -1,8 +0,0 @@
-import type { ApiClient } from '../../../../api/src/request';
-import type { MediaAssetWithLabels } from '@riverbankcms/media-storage-supabase';
-type EnsureRichTextImageAssetIdentifierArgs = {
-    apiClient: ApiClient;
-    asset: MediaAssetWithLabels;
-};
-export declare function ensureRichTextImageAssetIdentifier({ apiClient, asset, }: EnsureRichTextImageAssetIdentifierArgs): Promise<MediaAssetWithLabels>;
-export {};

package/dist/_dts/theme-core/src/palette/editorState.d.ts

@@ -1,75 +0,0 @@
-import type { PaletteColors, PaletteMode } from './colors';
-import type { KnownCuratedPaletteValueKey } from './curated';
-import type { ResolvedPaletteSelection } from './resolveSelection';
-import type { PaletteCommand, PaletteSelection, SitePaletteId, SitePaletteVersion } from './selection';
-export type PalettePreview = Readonly<{
-    kind: 'clean';
-    resolved: ResolvedPaletteSelection;
-}> | Readonly<{
-    kind: 'selected';
-    resolved: ResolvedPaletteSelection;
-}> | Readonly<{
-    kind: 'edited-curated';
-    sourceValueKey: KnownCuratedPaletteValueKey;
-    colors: PaletteColors;
-    mode: PaletteMode;
-}> | Readonly<{
-    kind: 'edited-site';
-    paletteId: SitePaletteId;
-    expectedVersion: SitePaletteVersion;
-    colors: PaletteColors;
-    mode: PaletteMode;
-}> | Readonly<{
-    kind: 'new-site';
-    colors: PaletteColors;
-    mode: PaletteMode;
-}>;
-export type PaletteEditorState = Readonly<{
-    committed: ResolvedPaletteSelection;
-    preview: PalettePreview;
-}>;
-/**
- * A complete palette projection for consumers which render a draft. Unlike a
- * command, this is always enough to compile the preview without reaching back
- * to a curated base plus a sparse overrides map.
- */
-export type CompletePaletteEditorPreview = Readonly<{
-    kind: 'selected';
-    selection: PaletteSelection;
-    colors: PaletteColors;
-    mode: PaletteMode;
-    version: SitePaletteVersion | null;
-}> | Readonly<{
-    kind: 'edited-curated';
-    sourceValueKey: KnownCuratedPaletteValueKey;
-    colors: PaletteColors;
-    mode: PaletteMode;
-}> | Readonly<{
-    kind: 'edited-site';
-    selection: Extract<PaletteSelection, {
-        kind: 'site';
-    }>;
-    expectedVersion: SitePaletteVersion;
-    colors: PaletteColors;
-    mode: PaletteMode;
-}> | Readonly<{
-    kind: 'new-site';
-    colors: PaletteColors;
-    mode: PaletteMode;
-}>;
-export type PaletteEditorAction = Readonly<{
-    kind: 'select';
-    resolved: ResolvedPaletteSelection;
-}> | Readonly<{
-    kind: 'edit';
-    colors: PaletteColors;
-    mode: PaletteMode;
-}> | Readonly<{
-    kind: 'create';
-}> | Readonly<{
-    kind: 'cancel';
-}>;
-export declare function createPaletteEditorState(committed: ResolvedPaletteSelection): PaletteEditorState;
-export declare function reducePaletteEditorState(state: PaletteEditorState, action: PaletteEditorAction): PaletteEditorState;
-export declare function planPaletteCommand(state: PaletteEditorState): PaletteCommand;
-export declare function completePaletteEditorPreview(state: PaletteEditorState): CompletePaletteEditorPreview;

package/dist/_dts/theme-core/src/palette/libraryModel.d.ts

@@ -1,64 +0,0 @@
-import type { CuratedPalette, KnownCuratedPaletteValueKey } from './curated';
-import type { PaletteColors, PaletteMode } from './colors';
-import type { PaletteSelection, SitePalette, SitePaletteId, SitePaletteOrigin, SitePaletteVersion } from './selection';
-export type PaletteSwatch = readonly [
-    PaletteColors['background'],
-    PaletteColors['surface'],
-    PaletteColors['primary'],
-    PaletteColors['secondary'],
-    PaletteColors['accent']
-];
-export type CuratedPaletteLibraryItem = Readonly<{
-    kind: 'curated';
-    valueKey: KnownCuratedPaletteValueKey;
-    colors: PaletteColors;
-    mode: PaletteMode;
-    swatch: PaletteSwatch;
-    accessibleLabel: string;
-    selected: boolean;
-}>;
-export type SitePaletteLibraryItem = Readonly<{
-    kind: 'site';
-    paletteId: SitePaletteId;
-    colors: PaletteColors;
-    mode: PaletteMode;
-    origin: SitePaletteOrigin;
-    version: SitePaletteVersion;
-    swatch: PaletteSwatch;
-    accessibleLabel: string;
-    selected: boolean;
-}>;
-export type PaletteLibraryItem = CuratedPaletteLibraryItem | SitePaletteLibraryItem;
-export type PaletteLibraryReadModel = Readonly<{
-    active: PaletteLibraryAuthority;
-    yours: readonly SitePaletteLibraryItem[];
-    suggested: readonly CuratedPaletteLibraryItem[];
-    more: readonly CuratedPaletteLibraryItem[];
-}>;
-export type PaletteLibraryAuthority = Readonly<{
-    kind: 'available';
-    selection: PaletteSelection;
-}> | Readonly<{
-    kind: 'invalid';
-}>;
-export type PaletteLibraryReadModelError = Readonly<{
-    kind: 'active-curated-palette-missing';
-    valueKey: KnownCuratedPaletteValueKey;
-}> | Readonly<{
-    kind: 'active-site-palette-missing';
-    paletteId: SitePaletteId;
-}>;
-export type PaletteLibraryReadModelResult = Readonly<{
-    ok: true;
-    model: PaletteLibraryReadModel;
-}> | Readonly<{
-    ok: false;
-    error: PaletteLibraryReadModelError;
-}>;
-export declare function buildPaletteLibraryReadModel(input: Readonly<{
-    active: PaletteLibraryAuthority;
-    sitePalettes: readonly SitePalette[];
-    curatedPalettes: readonly CuratedPalette[];
-    recommendations: readonly KnownCuratedPaletteValueKey[];
-}>): PaletteLibraryReadModelResult;
-export declare function paletteSelectionForItem(item: PaletteLibraryItem): PaletteSelection;

package/dist/_dts/theme-core/src/palette/persistenceReadSource.d.ts

@@ -1,81 +0,0 @@
-import { type PaletteValueKey } from './curated';
-import { resolvedCuratedPaletteSelection, resolvedSitePaletteSelection, type ResolvedPaletteSelection } from './resolveSelection';
-import { type PaletteSelection, type SitePalette } from './selection';
-import type { SitePaletteParseError } from './sitePalettePersistence';
-/** The post-backfill product boundary: exactly one active reference is required. */
-export type AuthoritativePaletteSelectionParseError = Readonly<{
-    kind: 'missing-active-palette-reference';
-}> | Readonly<{
-    kind: 'dual-active-reference';
-}> | Readonly<{
-    kind: 'unknown-active-curated-palette';
-    value: string;
-}> | Readonly<{
-    kind: 'invalid-active-site-palette-id';
-    value: string;
-}>;
-export type AuthoritativePaletteSelectionParseResult = Readonly<{
-    ok: true;
-    selection: PaletteSelection;
-}> | Readonly<{
-    ok: false;
-    error: AuthoritativePaletteSelectionParseError;
-}>;
-export declare function parseAuthoritativePaletteSelection(input: Readonly<{
-    activePaletteValueKey: string | null;
-    activeSitePaletteId: string | null;
-}>): AuthoritativePaletteSelectionParseResult;
-/** Runtime state is authority-backed or explicitly invalid; legacy is migration-only. */
-export type RuntimePaletteState = Readonly<{
-    kind: 'migrated';
-    authority: 'curated';
-    selection: Extract<PaletteSelection, {
-        kind: 'curated';
-    }>;
-    colors: ReturnType<typeof resolvedCuratedPaletteSelection>['colors'];
-    mode: ReturnType<typeof resolvedCuratedPaletteSelection>['mode'];
-    sitePaletteVersion: null;
-}> | Readonly<{
-    kind: 'migrated';
-    authority: 'site';
-    selection: Extract<PaletteSelection, {
-        kind: 'site';
-    }>;
-    colors: ReturnType<typeof resolvedSitePaletteSelection>['colors'];
-    mode: ReturnType<typeof resolvedSitePaletteSelection>['mode'];
-    sitePaletteVersion: ReturnType<typeof resolvedSitePaletteSelection>['version'];
-}> | Readonly<{
-    kind: 'invalid';
-    reason: AuthoritativePaletteSelectionParseError['kind'] | 'invalid-saved-theme-palette' | 'active-site-palette-missing' | 'invalid-active-site-palette' | 'active-site-palette-mismatch' | 'active-curated-palette-missing';
-}>;
-export type AuthoritativeRuntimePaletteState = RuntimePaletteState;
-export type ActiveSitePaletteAuthority = Readonly<{
-    kind: 'missing';
-}> | Readonly<{
-    kind: 'malformed';
-    error: SitePaletteParseError;
-}> | Readonly<{
-    kind: 'resolved';
-    palette: SitePalette;
-}>;
-export type RuntimePaletteResolutionError = Readonly<{
-    kind: 'runtime-curated-palette-missing';
-    paletteId: PaletteValueKey;
-}> | Readonly<{
-    kind: 'runtime-curated-palette-mismatch';
-    paletteId: PaletteValueKey;
-}>;
-export type RuntimePaletteResolution = Readonly<{
-    ok: true;
-    resolved: ResolvedPaletteSelection;
-}> | Readonly<{
-    ok: false;
-    error: RuntimePaletteResolutionError;
-}>;
-export declare function resolveMigratedRuntimePaletteState(state: Extract<RuntimePaletteState, {
-    kind: 'migrated';
-}>): RuntimePaletteResolution;
-export declare function runtimePaletteStateFromAuthoritativeSelection(input: Readonly<{
-    selection: PaletteSelection;
-    activeSitePaletteAuthority: ActiveSitePaletteAuthority;
-}>): AuthoritativeRuntimePaletteState;

package/dist/_dts/theme-core/src/palette/resolveSelection.d.ts

@@ -1,75 +0,0 @@
-import type { PaletteColors, PaletteMode, PaletteValueKey } from './colors';
-import { type CuratedPalette } from './curated';
-import type { PaletteSelection, SitePalette, SitePaletteId } from './selection';
-declare const resolvedPaletteSelectionBrand: unique symbol;
-export type ResolvedCuratedPaletteSelection = Readonly<{
-    kind: 'curated';
-    selection: Extract<PaletteSelection, {
-        kind: 'curated';
-    }>;
-    colors: PaletteColors;
-    mode: PaletteMode;
-    [resolvedPaletteSelectionBrand]: true;
-}>;
-export type ResolvedSitePaletteSelection = Readonly<{
-    kind: 'site';
-    selection: Extract<PaletteSelection, {
-        kind: 'site';
-    }>;
-    colors: PaletteColors;
-    mode: PaletteMode;
-    version: SitePalette['version'];
-    [resolvedPaletteSelectionBrand]: true;
-}>;
-export type ResolvedPaletteSelection = ResolvedCuratedPaletteSelection | ResolvedSitePaletteSelection;
-/**
- * A complete palette that exists only in an editor preview. It deliberately
- * has no persisted selection: a new palette must not pretend to be the first
- * curated recommendation merely to satisfy a renderer.
- */
-export type ResolvedDraftPaletteSelection = Readonly<{
-    kind: 'draft';
-    selection: null;
-    colors: PaletteColors;
-    mode: PaletteMode;
-    [resolvedPaletteSelectionBrand]: true;
-}>;
-/** A persisted palette selection or a complete, unsaved editor draft. */
-export type CompleteResolvedPaletteSelection = ResolvedPaletteSelection | ResolvedDraftPaletteSelection;
-export type PaletteSelectionResolutionError = Readonly<{
-    kind: 'curated-palette-not-found';
-    valueKey: PaletteValueKey;
-}> | Readonly<{
-    kind: 'site-palette-not-found';
-    paletteId: SitePaletteId;
-}>;
-export type PaletteSelectionResolution = Readonly<{
-    ok: true;
-    resolved: ResolvedPaletteSelection;
-}> | Readonly<{
-    ok: false;
-    error: PaletteSelectionResolutionError;
-}>;
-/** Core-owned constructors keep the resolved marker out of application code. */
-export declare function resolvedCuratedPaletteSelection(palette: CuratedPalette): ResolvedCuratedPaletteSelection;
-export declare function resolvedSitePaletteSelection(palette: SitePalette): ResolvedSitePaletteSelection;
-/** Builds a resolved site-owned preview from the record fields it owns. */
-export declare function resolvedSitePaletteSelectionFromPreview(input: Readonly<{
-    paletteId: SitePalette['id'];
-    colors: PaletteColors;
-    mode: PaletteMode;
-    version: SitePalette['version'];
-}>): ResolvedSitePaletteSelection;
-export declare function resolvedDraftPaletteSelection(input: Readonly<{
-    colors: PaletteColors;
-    mode: PaletteMode;
-}>): ResolvedDraftPaletteSelection;
-/** Resolves a persisted selection against the records that actually own it. */
-export declare function resolvePaletteSelection(input: Readonly<{
-    selection: PaletteSelection;
-    curatedPalettes: readonly CuratedPalette[];
-    sitePalettes: readonly SitePalette[];
-}>): PaletteSelectionResolution;
-/** Resolves catalog authority without asking callers to manufacture a brand. */
-export declare function resolveCuratedPaletteSelection(valueKey: PaletteValueKey): PaletteSelectionResolution;
-export {};