@cueframe/kernel 0.0.1

package/dist/_members/composition/primitive-catalog/types.d.ts

@@ -0,0 +1,123 @@
+export type PrimitiveCategory = 'text' | 'effects' | 'transitions' | 'layouts' | 'backgrounds' | 'ui-blocks' | 'scenes';
+export type PrimitiveKind = 'component' | 'transition' | 'scene';
+/** Curation tier — mirrors the public ComponentResponse contract. */
+export type PrimitiveTier = 'recommended' | 'standard' | 'niche';
+/** Editorial use-case tags — mirrors the public ComponentResponse contract. */
+export type PrimitiveUseCase = 'intro' | 'outro' | 'full-scene' | 'title-over-footage' | 'transition' | 'background' | 'grade' | 'emphasis' | 'explainer' | 'social-cut';
+/** A JSON-Schema (draft-07 subset) object describing a primitive's props. */
+export type JsonSchemaObject = Record<string, unknown>;
+/**
+ * A theme-token binding declared by a primitive (the React-free mirror of the
+ * execution-side `TokenBinding`). `brandKitPath` (when set) is the
+ * `ResolvedBrandKit` dot-path the param tracks — i.e. the param accepts a
+ * `$brand:<brandKitPath>` value to follow the project brand kit. The catalog
+ * projection turns these into the public `brandBindings` hint.
+ */
+export interface PrimitiveTokenBinding {
+    /** The param field this token themes (e.g. 'accent'). */
+    propPath: string;
+    /** CSS custom property the render binds (e.g. '--cf-accent'). */
+    cssVar: string;
+    /** Value used when neither a brand kit nor an explicit param is supplied. */
+    fallback?: string;
+    /** ResolvedBrandKit dot-path the param brand-binds to (e.g. 'colors.accent'). */
+    brandKitPath?: string;
+}
+export interface PrimitiveExample {
+    name: string;
+    mood?: string[];
+    params?: Record<string, unknown>;
+    description?: string;
+}
+export interface PrimitiveCatalogMeta {
+    /** Stable kebab-case id, globally unique in the registry. */
+    id: string;
+    name: string;
+    category: PrimitiveCategory;
+    kind: PrimitiveKind;
+    version: string;
+    /**
+     * SELECTION CONTRACT (mirrored to the public ComponentResponse facets):
+     * a verb naming what this primitive accomplishes (e.g. 'reveal-text',
+     * 'product-trailer'). Match it against the beat you are authoring.
+     */
+    intent?: string;
+    description?: string;
+    /**
+     * When to reach for this primitive AND when not to. The negative guidance
+     * is load-bearing — it stops a wrong pick before a render proves it wrong.
+     */
+    useWhen?: string;
+    /** Other primitive ids that COMPOSE well after/around this one (authoring guidance). */
+    pairsWith?: string[];
+    /** Other primitive ids that CONFLICT with this one — do not place together. */
+    avoidWith?: string[];
+    tags?: string[];
+    /** Mood/vibe tags — filter to match the edit's tone (e.g. 'cinematic', 'minimal'). */
+    mood?: string[];
+    /**
+     * Curation tier — a QUALITY/applicability RANKING, not a flag. Prefer
+     * `recommended` (battle-tested, broadly applicable); reach for `niche` only
+     * when its specific use-case is exactly the beat. Set on a config when curated.
+     */
+    tier?: PrimitiveTier;
+    /**
+     * Editorial use-case tags — the edit ROLE(s) this primitive fills (the
+     * dimension to filter by for a beat: 'intro' / 'title-over-footage' /
+     * 'full-scene' / 'grade' / …). Set on a config when curated.
+     */
+    useCase?: PrimitiveUseCase[];
+    /**
+     * On-screen strings this primitive BAKES — the read-side counterpart to
+     * `propSchema`. These literals render regardless of params; no param can
+     * change them (fork the source via get_component_source to edit them). The
+     * machine signal that "not in propSchema = baked" copy actually exists, so
+     * an agent sees someone-else's marketing copy at author time, not at render.
+     */
+    fixedCopy?: string[];
+    /**
+     * Param field accepting the primitive's primary text payload.
+     * `null` = primitive explicitly declines a single text slot (e.g. karaoke).
+     * `undefined` = no declared text contract.
+     *
+     * ABI NOTE — this is a TWO-STRING contract (textParam + subtextParam) for the
+     * canonical title/subtitle slots only. MULTI-ELEMENT / STRUCTURED scene copy
+     * (tiers, feature lines, code lines, beats) is NOT expressed here — it is
+     * expressed via the primitive's OWN `propSchema` params (e.g. changelog-bite's
+     * `oldLines`/`newLines: string[]`). When you need rich copy, read the
+     * `propSchema` for an array/object param; don't expect it on this 2-string ABI.
+     */
+    textParam?: string | null;
+    /** Same contract for a secondary text payload (subtitle/byline). See textParam's ABI note. */
+    subtextParam?: string | null;
+    /**
+     * Theme-token bindings declared by this primitive (mirrored from its config's
+     * `tokens`). The catalog projection derives the public `brandBindings` hint
+     * from the entries whose `brandKitPath` is set.
+     */
+    tokens?: PrimitiveTokenBinding[];
+    /** Materialized literal defaults (literal-extractable subset). */
+    propDefaults?: Record<string, unknown>;
+    /** Few-shot examples (literal-extractable subset). */
+    examples?: PrimitiveExample[];
+    /** JSON Schema (draft-07) for this primitive's params, generated from its Zod paramsSchema. */
+    propSchema?: JsonSchemaObject;
+    /**
+     * Explicit per-primitive opt-out from the write-boundary CLOSED-KEY param
+     * check (see paramValidation.ts). Set on a config ONLY when the primitive
+     * legitimately accepts free-form / caller-defined keys beyond its declared
+     * `propSchema.properties`. NOT a blanket bypass — typed checks on declared
+     * keys still run. No first-party config sets this today (every primitive
+     * declares a closed prop set); the hook exists so a future free-form
+     * primitive opts out declaratively instead of weakening the guard globally.
+     */
+    freeformParams?: boolean;
+    /** Scene/primitive intrinsic runtime in frames (scenes set this; overlays omit). */
+    durationInFrames?: number;
+    /** Intrinsic fps (scenes). */
+    fps?: number;
+    /** Canonical authoring width in px (scenes). */
+    width?: number;
+    /** Canonical authoring height in px (scenes). */
+    height?: number;
+}

package/dist/_members/composition/primitive-catalog/types.js

@@ -0,0 +1,14 @@
+// @cueframe/primitive-registry — the React-free catalog-metadata contract.
+//
+// This is the AUTHORING-facing view of "what primitives exist and their param
+// contract" — distinct from:
+//   - @cueframe/primitives PrimitiveMeta (the RUNTIME catalog entry: React
+//     component + zod paramsSchema + createPresentation), which is execution-side.
+//   - @cueframe/composition PrimitiveRegistryEntry (the MARKETPLACE/distribution
+//     registry: origin class, modes, OTIO mapping), which is a different layer.
+//
+// The metadata here is generated from each primitive's config.ts (see
+// scripts/build-primitive-meta.mjs) so authoring can read the catalog without
+// importing the renderer (which would be an authoring -> execution boundary
+// violation). Mirror of the JSON-serializable subset of PrimitiveMeta.
+export {};

package/dist/_members/composition/projection/behind-placement.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Launch-grade behind-text placement (spec §6). Derives a SCENE-space anchor from
+ * the matte geometry sidecar: lateral center of the clip-union silhouette; vertical
+ * in the shoulder band (head-top + a fraction) so the bite is rounded and partial,
+ * never the flat torso wall; minTextWidth guarantees the line reads past the
+ * silhouette on both sides. Pure; all values source-normalized [0,1].
+ *
+ * The sidecar is the person-matte bake's `.geometry.json` artifact (one record
+ * per frame: subject bbox + 16-bucket column/row coverage marginals, computed
+ * from the smoothed alpha — see person_matting.py `_frame_geometry`). The
+ * orchestration activity downloads + camelCases it into `MatteGeometryLike`;
+ * this module never does I/O.
+ */
+/** Minimum fraction of bake-window frames with a detected subject before the
+ *  behind treatment is even considered (relocated `captionsBehindEligible`
+ *  principle — composition-floor's MIN_ACTIVE_SPEAKER_PRESENCE sibling). Below
+ *  this the clip reads as b-roll / no-speaker → no anchor, degrade to front. */
+export declare const MIN_PRESENCE_FOR_BEHIND = 0.6;
+/** Shoulder-band shape. `headLambda` drops the anchor a frame-height fraction
+ *  below the union head-top so the silhouette bites the line from below-the-chin
+ *  (rounded head + shoulders), not the flat torso wall. `widthPad` widens the
+ *  minimum text width past the union silhouette so the line reads on BOTH sides
+ *  of the body. Calibration constants — Phase-7 fixtures tune them. */
+export declare const BEHIND_BAND: {
+    readonly headLambda: 0.18;
+    readonly widthPad: 1.25;
+};
+/** One frame of the matte geometry sidecar. `bbox` is [x0, y0, x1, y1]
+ *  source-normalized, x1/y1 exclusive; null when no subject that frame.
+ *  `cols`/`rows` are 16-bucket coverage marginals: cols[i] = fraction of that
+ *  column band covered by the subject (and rows[j] likewise per row band). */
+export interface MatteGeometryFrame {
+    f: number;
+    present: boolean;
+    bbox: [number, number, number, number] | null;
+    cols: number[];
+    rows: number[];
+}
+/** The sidecar's geometry payload, camelCased by the consuming activity. */
+export interface MatteGeometryLike {
+    srcW: number;
+    srcH: number;
+    presenceFraction: number;
+    frames: MatteGeometryFrame[];
+}
+/** A derived behind-text anchor, source-normalized. `x`/`y` center the line;
+ *  `minTextWidth` is the floor on the rendered line's width so it clears the
+ *  silhouette laterally (already clamped ≤ 0.95). */
+export interface BehindAnchor {
+    x: number;
+    y: number;
+    minTextWidth: number;
+}
+/**
+ * Derive the behind-text anchor from a clip's matte geometry. Returns null when
+ * the clip has no stable subject to be behind (presence below the floor, or no
+ * frame ever produced a bbox) — the caller degrades the overlay to front.
+ *
+ * Placement: lateral center of the UNION bbox across all present frames (stable
+ * against per-frame jitter); vertical at union head-top + the shoulder-band
+ * lambda, capped at MAX_ANCHOR_Y; minTextWidth = union silhouette width padded
+ * by `widthPad` so the line extends past the body on both sides.
+ */
+export declare function deriveBehindAnchor(g: MatteGeometryLike): BehindAnchor | null;

package/dist/_members/composition/projection/behind-placement.js

@@ -0,0 +1,62 @@
+/**
+ * Launch-grade behind-text placement (spec §6). Derives a SCENE-space anchor from
+ * the matte geometry sidecar: lateral center of the clip-union silhouette; vertical
+ * in the shoulder band (head-top + a fraction) so the bite is rounded and partial,
+ * never the flat torso wall; minTextWidth guarantees the line reads past the
+ * silhouette on both sides. Pure; all values source-normalized [0,1].
+ *
+ * The sidecar is the person-matte bake's `.geometry.json` artifact (one record
+ * per frame: subject bbox + 16-bucket column/row coverage marginals, computed
+ * from the smoothed alpha — see person_matting.py `_frame_geometry`). The
+ * orchestration activity downloads + camelCases it into `MatteGeometryLike`;
+ * this module never does I/O.
+ */
+/** Minimum fraction of bake-window frames with a detected subject before the
+ *  behind treatment is even considered (relocated `captionsBehindEligible`
+ *  principle — composition-floor's MIN_ACTIVE_SPEAKER_PRESENCE sibling). Below
+ *  this the clip reads as b-roll / no-speaker → no anchor, degrade to front. */
+export const MIN_PRESENCE_FOR_BEHIND = 0.6;
+/** Shoulder-band shape. `headLambda` drops the anchor a frame-height fraction
+ *  below the union head-top so the silhouette bites the line from below-the-chin
+ *  (rounded head + shoulders), not the flat torso wall. `widthPad` widens the
+ *  minimum text width past the union silhouette so the line reads on BOTH sides
+ *  of the body. Calibration constants — Phase-7 fixtures tune them. */
+export const BEHIND_BAND = { headLambda: 0.18, widthPad: 1.25 };
+/** Anchors never sink below this — past mid-frame the "behind" read collapses
+ *  into a lower-third (the silhouette no longer frames the line from above). */
+const MAX_ANCHOR_Y = 0.55;
+/** Hard ceiling on any text width estimate (frame fraction). */
+const MAX_TEXT_WIDTH = 0.95;
+/**
+ * Derive the behind-text anchor from a clip's matte geometry. Returns null when
+ * the clip has no stable subject to be behind (presence below the floor, or no
+ * frame ever produced a bbox) — the caller degrades the overlay to front.
+ *
+ * Placement: lateral center of the UNION bbox across all present frames (stable
+ * against per-frame jitter); vertical at union head-top + the shoulder-band
+ * lambda, capped at MAX_ANCHOR_Y; minTextWidth = union silhouette width padded
+ * by `widthPad` so the line extends past the body on both sides.
+ */
+export function deriveBehindAnchor(g) {
+    if (g.presenceFraction < MIN_PRESENCE_FOR_BEHIND)
+        return null;
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let hasBbox = false;
+    for (const frame of g.frames) {
+        if (!frame.bbox)
+            continue;
+        hasBbox = true;
+        x0 = Math.min(x0, frame.bbox[0]);
+        y0 = Math.min(y0, frame.bbox[1]);
+        x1 = Math.max(x1, frame.bbox[2]);
+    }
+    if (!hasBbox)
+        return null;
+    return {
+        x: (x0 + x1) / 2,
+        y: Math.min(MAX_ANCHOR_Y, y0 + BEHIND_BAND.headLambda),
+        minTextWidth: Math.min(MAX_TEXT_WIDTH, (x1 - x0) * BEHIND_BAND.widthPad),
+    };
+}

package/dist/_members/composition/projection/brandKit.d.ts

@@ -0,0 +1,308 @@
+import type { BrandKit, EasingValue, FontRef, Motif } from "../validators/brandKit.js";
+/**
+ * A brand font the render must MATERIALIZE — the render sandbox installs only the
+ * Liberation faces and has no font egress, so every brand face is staged like any
+ * other asset (renderInputAssets `font` role → materializeSources → @font-face).
+ * This is the manifest TYPE only. The director's `resolveRenderEnvironment` maps
+ * the resolved kit's font families → their woff2 R2 keys (the curated font
+ * library) and presigns them — env-specific resolution (storage + creds) that does
+ * NOT belong in this pure deriver. `url`: R2 key → presigned URL → loopback URL
+ * across resolve → materialize, same lifecycle as a source/matte URL.
+ */
+export interface FontAsset {
+    family: string;
+    weight: number;
+    style?: "normal" | "italic";
+    url: string;
+}
+/**
+ * A reproduced inspiration motif, carried untransformed from the wire kit onto
+ * the resolved kit's `language`. Identical to the wire `Motif` shape — the
+ * language payload is exemplar/motif REFERENCE data the maker + judge condition
+ * on, not a derived design token, so the cascade never rewrites it.
+ */
+export type ResolvedBrandMotif = Motif;
+/**
+ * The language payload of a kit built FROM INSPIRATION (spec 2026-07-14) —
+ * exemplar frame keys, reproduced motifs, the style rubric, and density
+ * budget. Present on `ResolvedBrandKit.language` only when the kit carries
+ * exemplars; carried through resolution untransformed (NOT a `$brand:` token
+ * root — see BRAND_TOKEN_ROOT_KEYS).
+ */
+export interface ResolvedBrandLanguage {
+    exemplarKeys: string[];
+    contactSheetKey?: string;
+    motifs: ResolvedBrandMotif[];
+    styleRubric?: string;
+    density?: {
+        graphicsPerMin: number;
+        maxSimultaneous: number;
+    };
+}
+/**
+ * A fully-materialized BrandKit. Every token has a value: either the
+ * author's explicit setting, or the derived/default value the brand
+ * cascade computed. Primitives consume this shape directly via
+ * `$brand:<path>` resolution.
+ */
+export interface ResolvedBrandKit {
+    id: string;
+    name: string;
+    colors: {
+        primary: string;
+        secondary: string;
+        accent: string;
+        background: string;
+        text: string;
+        textMuted: string;
+        border: string;
+        textOnMedia: string;
+        surface: string;
+        card: string;
+        gridLine: string;
+        accentMuted: string;
+        textOnAccent: string;
+        textOnSurface: string;
+    };
+    caption: {
+        fg: string;
+        scrim: string;
+        color?: string;
+        highlightColor?: string;
+        plate?: "glass" | "solid" | "none";
+        entrance?: "none" | "fade" | "word-pop" | "stagger-up";
+        entranceMs?: number;
+        entranceStaggerMs?: number;
+        exitMs?: number;
+        fontFamily?: string;
+        emphasisFontFamily?: string;
+        emphasisScale?: number;
+        emphasisFontWeight?: number;
+        emphasisFontStyle?: "normal" | "italic";
+        emphasisTextTransform?: "none" | "uppercase";
+        emphasisLetterSpacing?: number;
+        emphasisPlate?: boolean;
+        emphasisPlateColor?: string;
+        emphasisPlateTextColor?: string;
+    };
+    fonts: {
+        heading: FontRef;
+        body: FontRef;
+        caption: FontRef;
+    };
+    /**
+     * Brand faces the render must MATERIALIZE — a render manifest the harness' `font`
+     * role + materializeSources stage and the renderer @font-faces. POPULATED by the
+     * director's `resolveRenderEnvironment` (family → R2 key → presigned), NOT by this
+     * pure deriver — undefined until the render environment is resolved.
+     */
+    fontAssets?: FontAsset[];
+    spacing: {
+        base: number;
+        lg: number;
+        sm: number;
+    };
+    sizing: {
+        fontSizeHeading: number;
+        fontSizeBody: number;
+        fontSizeLabel: number;
+        borderRadius: number;
+    };
+    motion: {
+        duration: number;
+        easing: EasingValue;
+        entrance: "none" | "fade" | "word-pop" | "stagger-up";
+        staggerMs: number;
+        exitMs: number;
+    };
+    /**
+     * Brand overlay assets — present only when the kit declares them. The cascade
+     * NORMALIZES (defaults placement/sizePct/durationMs/opacity) but does NOT
+     * place-render: pixel placement is the render binding's job (a later task).
+     * Missing on the wire kit → `undefined` here (never an error). A `kind:'video'`
+     * intro/outro with no `src` carries through unchanged — PUT-time validation,
+     * not render-time resolution, is where a missing video source fails loud.
+     */
+    logo?: {
+        src: string;
+        alt?: string;
+        placement: "tl" | "tr" | "bl" | "br";
+        sizePct: number;
+    };
+    intro?: {
+        kind: "card" | "video";
+        src?: string;
+        title?: string;
+        subtitle?: string;
+        durationMs?: number;
+    };
+    outro?: {
+        kind: "card" | "video";
+        src?: string;
+        title?: string;
+        subtitle?: string;
+        durationMs?: number;
+    };
+    watermark?: {
+        src: string;
+        opacity: number;
+        placement: "tl" | "tr" | "bl" | "br";
+    };
+    /**
+     * Language payload (built FROM INSPIRATION) — present only when the wire kit
+     * carries exemplar frames. Carried untransformed (see resolveBrandKit); NOT a
+     * `$brand:` token root, so invisible to resolveBrandRefsDeep.
+     */
+    language?: ResolvedBrandLanguage;
+    /**
+     * Brand audio identity (audio design spec 2026-07-20) — carried VERBATIM from
+     * the wire kit (like `language`; not a `$brand:` token root). Consumed by the
+     * compose sfx/music pass, never by the renderer directly.
+     *
+     * Brand SOUND kit (audio-substrate Phase 5): the sonic logo, UI-sound-set
+     * overrides, and the bed/ambience preferences ride through untransformed —
+     * refs are resolved to placeable clips at compose time (sonicLogo/uiSoundSet)
+     * or surfaced for driving agents (bedStyle/ambiencePreference).
+     */
+    audio?: {
+        sfxIntensity?: "off" | "light" | "standard" | "dense";
+        musicEnabled?: boolean;
+        musicMood?: string;
+        sonicLogo?: {
+            ref: string;
+            placement: "intro" | "outro" | "both";
+            offsetMs?: number;
+        };
+        uiSoundSet?: {
+            tick?: string;
+            pop?: string;
+            impact?: string;
+            confirm?: string;
+            error?: string;
+            whoosh?: string;
+            riser?: string;
+        };
+        bedStyle?: {
+            bedId?: string;
+            genre?: string;
+            bpmRange?: {
+                min: number;
+                max: number;
+            };
+        };
+        ambiencePreference?: {
+            ref: string;
+        } | null;
+    };
+}
+/**
+ * Resolve a sparse BrandKit against a composition's render width.
+ * The width drives the spacing + sizing derivations (font sizes
+ * scale to the canvas, not absolute pixels).
+ */
+export declare function resolveBrandKit(kit: BrandKit, compositionWidth: number): ResolvedBrandKit;
+/**
+ * The DESIGN-TOKEN sub-trees of a ResolvedBrandKit whose leaves are bindable as
+ * `$brand:<path>` param values. We deliberately exclude `id`/`name` (metadata,
+ * not design tokens) and the optional overlay assets (`logo`/`intro`/`outro`/
+ * `watermark`/`fontAssets` — present only when a kit declares them, and not a
+ * param-binding surface).
+ */
+export declare const BRAND_TOKEN_ROOT_KEYS: readonly ["colors", "caption", "fonts", "spacing", "sizing", "motion"];
+/**
+ * The canonical set of bindable `$brand:` token refs a param value may carry —
+ * the COMPLETE design-token leaf vocabulary of a ResolvedBrandKit, DERIVED at
+ * module load from a reference resolution so it can NEVER drift from the
+ * resolver: add a token to ResolvedBrandKit and it appears here automatically;
+ * remove one and it disappears. Surfaced on the component catalog as
+ * `brandTokens` so an agent discovers e.g. `$brand:colors.accent` (a valid value
+ * for an accent-color param) without reading source. Colors + fonts are the
+ * common bindings; spacing/sizing/motion/caption round out the full vocabulary.
+ */
+export declare const BRAND_TOKEN_REFS: readonly string[];
+/**
+ * Mix two hex colors by ratio. ratio=0 returns `a` unchanged;
+ * ratio=1 returns `b`; ratio=0.4 returns a 60% a + 40% b mix.
+ *
+ * Accepts both `#RRGGBB` and `#RGB` short form. Rejects non-hex
+ * inputs (rgb()/hsl()/named colors) by returning `a` unchanged —
+ * the brand cascade NEVER crashes on a malformed input; primitives
+ * fall back to their declared fallback for the affected token.
+ *
+ * Returns `#RRGGBB` form, lowercase.
+ */
+export declare function colorMix(a: string, b: string, ratio: number): string;
+/**
+ * Resolve a `$brand:<dot-path>` reference against a ResolvedBrandKit.
+ * Returns the value at the path, or `null` if the path doesn't exist
+ * or the value isn't a primitive. Primitives use the returned `null`
+ * to fall back to their declared `PrimitiveRegistryEntry.tokens[].fallback`.
+ *
+ * Examples:
+ *   resolveBrandRef("$brand:colors.accent", kit) → "#ff0066"
+ *   resolveBrandRef("$brand:fonts.heading.family", kit) → "Inter" | undefined
+ *   resolveBrandRef("$brand:motion.duration", kit) → 200
+ *   resolveBrandRef("not-a-ref", kit) → null (not a ref form)
+ *   resolveBrandRef("$brand:colors.nonexistent", kit) → null
+ *
+ * Escape rule (per data-model.md § `$brand:` ref syntax): a value
+ * starting with `\$brand:` is the literal string — strip the leading
+ * `\` and treat as text, not a ref. This function returns `null` for
+ * escaped forms; the caller (params resolver) handles the strip.
+ */
+export declare function resolveBrandRef(refOrValue: unknown, kit: ResolvedBrandKit): unknown;
+/**
+ * Walk an arbitrary value tree (typically `OverlaySource.params` or
+ * `EffectSource.params`) and replace every `$brand:` ref string with
+ * its resolved value from the kit. Non-string leaves pass through.
+ * Refs that don't resolve are replaced with the provided per-token
+ * fallback if any, else the original ref string is preserved so the
+ * primitive's tokens[].fallback can apply at render time.
+ *
+ * Operates immutably — does NOT mutate the input.
+ */
+export declare function resolveBrandRefsDeep(value: unknown, kit: ResolvedBrandKit): unknown;
+/**
+ * Card token layer → CSS custom properties. Resolves `$brand:` refs through
+ * `resolveBrandRefsDeep`, then emits every resolved string leaf as a `--cf-<k>`
+ * var; unresolved refs are DROPPED (the card html's own `var(--cf-x, fallback)`
+ * applies). The ONE copy of this logic — the render's OverlayContent card
+ * branch and the local harness both consume it (extracted 2026-07-16; each
+ * previously carried a mirror).
+ */
+export declare function cssLayoutVars(tokens: Record<string, unknown> | undefined, kit: ResolvedBrandKit | undefined): Record<string, string>;
+/** The flat brand palette an authored `create_component` graphic reads from
+ *  `props.brand.*` — the COMPONENT analog of a card's `var(--cf-*)`. */
+export interface ComponentBrandPalette {
+    primary: string;
+    secondary: string;
+    accent: string;
+    accentMuted: string;
+    background: string;
+    surface: string;
+    card: string;
+    border: string;
+    gridLine: string;
+    text: string;
+    textMuted: string;
+    textOnMedia: string;
+    textOnAccent: string;
+    textOnSurface: string;
+    /** Resolved font FAMILIES (not FontRefs) — drop straight into `fontFamily`. */
+    heading: string;
+    body: string;
+    caption: string;
+}
+/**
+ * Component brand palette — the resolved kit an authored `create_component`
+ * graphic reads from `props.brand.*`. This is the COMPONENT-medium analog of a
+ * card's `cssLayoutVars` (`var(--cf-*)`): a card is freeform HTML that cascades
+ * CSS custom properties; a component receives brand through its PROPS, so we hand
+ * it one FLAT, already-resolved object. AUTO-INJECTED at the brand-meets-props
+ * seam (`resolveBrandProps` / the ship snapshot) so a component binds to the kit
+ * with ZERO prop declaration — `style={{ color: props.brand.accent, fontFamily:
+ * props.brand.heading }}`. Flat by design: one dereference, no nested paths to
+ * author, no `$brand:` refs to declare (the authoring cost that made the
+ * ref-per-token approach ~2.4× slower per design attempt).
+ */
+export declare function componentBrandPalette(kit: ResolvedBrandKit): ComponentBrandPalette;