@cueframe/kernel 0.0.1 → 0.1.1

package/dist/_members/composition/graphics-plan/compile.js

@@ -1,221 +0,0 @@
-import { resolveBrandRefsDeep } from "../projection/brandKit.js";
-// Brand-ref leaves (see brandKit ResolvedBrandKit). Fonts MUST use `.family`.
-const B = {
-    textOnMedia: "$brand:colors.textOnMedia",
-    textOnAccent: "$brand:colors.textOnAccent",
-    textOnSurface: "$brand:colors.textOnSurface",
-    accent: "$brand:colors.accent",
-    overlay: "$brand:colors.overlay",
-    surface: "$brand:colors.surface",
-    fontHeading: "$brand:fonts.heading.family",
-    fontBody: "$brand:fonts.body.family",
-    motionEasing: "$brand:motion.easing",
-    motionEntrance: "$brand:motion.entrance",
-};
-function textColorRef(styleRole) {
-    return styleRole === "on-accent" ? B.textOnAccent : styleRole === "on-surface" ? B.textOnSurface : B.textOnMedia;
-}
-function fontRef(styleRole) {
-    return styleRole === "body" ? B.fontBody : B.fontHeading;
-}
-/** Font px from a box's height so the text FITS its box (leaves line room). */
-function fontPx(boxH, frameH, fill = 0.62) {
-    return Math.round(Math.max(16, Math.min(240, boxH * frameH * fill)));
-}
-/** Bounding box of the front element boxes (clear of the face iff each is). */
-function unionBox(rects) {
-    const x = Math.min(...rects.map((r) => r.x));
-    const y = Math.min(...rects.map((r) => r.y));
-    const x2 = Math.max(...rects.map((r) => r.x + r.w));
-    const y2 = Math.max(...rects.map((r) => r.y + r.h));
-    return { x, y, w: x2 - x, h: y2 - y };
-}
-/** Parse a stat string ("5 yrs", "100%", "$0 raised", "3,000 downloads") into
- *  stat-counter's numeric value + prefix/suffix. Non-digit prefix is greedy so a
- *  hyphen after letters ("Top-10") is NOT read as a negative; thousands commas
- *  are stripped from the number. null ⇒ no leading number. */
-export function parseStatValue(raw) {
-    const m = raw.trim().match(/^(\D*)(\d[\d,]*(?:\.\d+)?)(.*)$/);
-    if (!m)
-        return null;
-    const value = Number(m[2].replace(/,/g, ""));
-    if (!Number.isFinite(value))
-        return null;
-    return { value, prefix: m[1].trim(), suffix: m[3] };
-}
-const asSource = (s) => s;
-/** True iff two rects overlap. */
-const overlaps = (a, b) => a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
-/** Compile one beat (its content role + solved layout) into overlay clips. */
-export function compileBeat(beat, layout, _motion, opts = {}) {
-    const prefix = opts.idPrefix ?? "gfx";
-    const frameH = layout.frame.h;
-    const kit = opts.brandKit;
-    // Resolve nested $brand: refs to literals at compile time when a kit is given
-    // (the render inflater only does top-level). Identity passthrough otherwise.
-    const finalize = (s) => kit ? { ...s, params: resolveBrandRefsDeep(s.params, kit) } : s;
-    const src = (s) => asSource(finalize(s));
-    // The behind-subject hero (heroText) — RE-ENABLED 2026-07-29. It was
-    // denylisted 2026-07-08 for "matte compositing desyncs lip movement"; the
-    // root cause was the matte bake re-timing the co-view at average fps (fixed
-    // by the CFR timing invariant — plan 2026-07-28-cfr-timing-invariant), not
-    // this emission. heroText is world-locked (zPlane, no authored anchor) so
-    // the silhouette gate places it — not the plan. Cross-beat duplicate
-    // protection (the OTHER disable reason: an agent plan authored two
-    // overlapping hero beats 0.14s apart) lives in compileGraphicsPlan.
-    // Text is REQUIRED: heroText's schema is min(1), and a Copy.headline of ""
-    // is schema-legal upstream (the solver omits `text` for falsy copy) — an
-    // unguarded emission would compile a clip the write boundary/render rejects
-    // for the whole plan. A textless hero drops out like other non-emitted roles.
-    const hero = layout.elements.find((e) => e.z === "behind-subject" && e.text?.trim());
-    // Only TEXT-emitting front roles composite here; logo/accent-shape/backdrop
-    // are non-text decoration (P1 skips them rather than emitting a blank title).
-    const front = layout.elements.filter((e) => e.z !== "behind-subject" && e.role !== "logo" && e.role !== "accent-shape" && e.role !== "backdrop");
-    const clips = [];
-    if (hero) {
-        clips.push({
-            id: `${prefix}-${beat.id}-hero`,
-            startTime: beat.atSec,
-            duration: beat.durSec,
-            kind: "overlay",
-            source: src({
-                kind: "overlay",
-                primitiveId: "heroText",
-                params: { text: hero.text, fontSizePct: 14, textColor: B.textOnMedia, fontFamily: B.fontHeading, entrance: B.motionEntrance, easing: B.motionEasing },
-                zPlane: "behind-subject",
-            }),
-        });
-    }
-    if (front.length === 0)
-        return clips;
-    const region = unionBox(front.map((e) => e.box));
-    // GUARD: the union of individually-clear boxes could still span the face (a
-    // split layout). If it does, skip the front graphic rather than composite it
-    // OVER the speaker — the invariant holds even when the solver doesn't stack
-    // contiguously (e.g. a future agent-proposed layout).
-    if (layout.keepOut.some((ko) => overlaps(region, ko)))
-        return clips;
-    // A text graphic MUST have a primary line (headline/value). No fallback to
-    // front[0] — a beat with only a subtitle is malformed; fail loud.
-    const head = front.find((e) => e.role === "headline" || e.role === "value");
-    if (!head) {
-        throw new Error(`graphics-plan: beat "${beat.id}" (role ${beat.role}) has front elements but no headline/value line — malformed copy.`);
-    }
-    // sub must be a DISTINCT element from head (else a subtitle-only beat would
-    // render the same string twice).
-    const sub = front.find((e) => (e.role === "sublabel" || e.role === "label") && e !== head);
-    const headFont = fontPx(head.box.h, frameH);
-    // Subtitle never larger than the headline (hierarchy), regardless of box math.
-    const subFont = sub ? Math.min(fontPx(sub.box.h, frameH), Math.round(headFont * 0.8)) : undefined;
-    const base = { id: `${prefix}-${beat.id}`, startTime: beat.atSec, duration: beat.durSec, kind: "overlay", region };
-    const titleSource = (styleRole) => ({
-        kind: "overlay",
-        primitiveId: "cinematic-title",
-        params: {
-            text: head.text ?? "",
-            ...(sub?.text ? { subtitle: sub.text } : {}),
-            tokens: { fontSize: headFont, ...(subFont ? { subtextFontSize: subFont } : {}), textColor: textColorRef(styleRole), accentColor: B.accent, fontFamily: fontRef(styleRole) },
-        },
-    });
-    switch (beat.role) {
-        case "title-card":
-            clips.push({ ...base, source: src(titleSource(head.styleRole)) });
-            break;
-        case "lower-third":
-            clips.push({
-                ...base,
-                source: src({
-                    kind: "overlay",
-                    primitiveId: "lower-third",
-                    params: {
-                        text: head.text ?? "",
-                        ...(sub?.text ? { subtitle: sub.text } : {}),
-                        tokens: { fontSize: headFont, ...(subFont ? { subtitleFontSize: subFont } : {}), textColor: B.textOnMedia, accentColor: B.accent, backgroundColor: B.overlay, fontFamily: B.fontBody },
-                    },
-                }),
-            });
-            break;
-        case "stat": {
-            const parsed = head.text ? parseStatValue(head.text) : null;
-            if (parsed) {
-                clips.push({
-                    ...base,
-                    source: src({
-                        kind: "overlay",
-                        primitiveId: "stat-counter",
-                        params: { value: parsed.value, ...(parsed.prefix ? { prefix: parsed.prefix } : {}), ...(parsed.suffix ? { suffix: parsed.suffix } : {}), ...(sub?.text ? { label: sub.text } : {}), accentColor: B.accent },
-                    }),
-                });
-            }
-            else {
-                // A stat REQUIRES a leading number — no silent degrade to a title card.
-                throw new Error(`graphics-plan: beat "${beat.id}" role "stat" has non-numeric value "${head.text}" — a stat needs a leading number (e.g. "5 yrs", "100%", "498").`);
-            }
-            break;
-        }
-        case "pull-quote":
-            clips.push({ ...base, source: src({ kind: "overlay", primitiveId: "quote-card", params: { text: head.text ?? "", ...(sub?.text ? { subtext: sub.text } : {}), accentColor: B.accent } }) });
-            break;
-        case "enumeration":
-        case "sequence":
-        case "comparison":
-            // The ARGUMENT roles are DESIGNER-AUTHORED, by design. There is no deterministic
-            // role→primitive mapping for them and there should not be: an `enumeration` might be
-            // three badges, a numbered list or a build-on-reveal, and a `sequence` might be
-            // `reasoning-trace`, `tool-call-stack` or a bespoke component — that choice is the
-            // designer's job, made with eyes on the frame and the whole catalog in hand.
-            //
-            // This deterministic FC5 compiler was DEMOTED to critics in any case (director.ts: "they
-            // no longer COMPILE the design") and `compilePlanGraphics` has no live callers. It is kept
-            // for an optional deterministic seed. Failing loud HERE — rather than silently rendering a
-            // title card — is the honest behaviour if it is ever re-promoted.
-            throw new Error(`graphics-plan: beat "${beat.id}" role "${beat.role}" is a DESIGNER-AUTHORED argument role ` +
-                `(enumeration / sequence / comparison). It has no deterministic primitive mapping by ` +
-                `design — the designer picks the component from the catalog or writes one. This ` +
-                `compiler only handles the text-shaped roles.`);
-        default:
-            // hero/logo-tag never reach here (no front text elements); any role that
-            // does is unhandled — fail loud instead of silently rendering a title.
-            throw new Error(`graphics-plan: beat "${beat.id}" role "${beat.role}" reached the compiler with front text but no handler.`);
-    }
-    return clips;
-}
-/** Compile a whole GraphicsPlan (all beats) into overlay clips. */
-export function compileGraphicsPlan(plan, opts = {}) {
-    const motionByBeat = new Map(plan.motions.map((m) => [m.beatId, m]));
-    const layoutByBeat = new Map(plan.layouts.map((l) => [l.beatId, l]));
-    const clips = [];
-    for (const beat of plan.content.beats) {
-        const layout = layoutByBeat.get(beat.id);
-        if (!layout)
-            continue;
-        clips.push(...compileBeat(beat, layout, motionByBeat.get(beat.id), opts));
-    }
-    return dedupeOverlappingHeroes(clips);
-}
-/**
- * MECHANICAL guard for the hero param-snag that co-motivated the 2026-07-08
- * disable: the 2026-07-07 prod e2e produced TWO overlapping heroText beats
- * (7.93s & 8.07s) — stacked display phrases rendering over each other. One
- * hero at a time is the grammar ("ration it hard: ONE hero beat per clip"),
- * so enforce it here rather than trusting the planner prompt: when two
- * compiled heroText windows overlap in time, the EARLIER one wins and the
- * later duplicate is dropped. Non-overlapping heroes (distinct moments in a
- * long film) all survive.
- */
-function dedupeOverlappingHeroes(clips) {
-    const isHero = (c) => c.source?.primitiveId === "heroText";
-    const heroes = clips
-        .filter(isHero)
-        .sort((a, b) => a.startTime - b.startTime || a.id.localeCompare(b.id));
-    const dropped = new Set();
-    let lastEnd = -Infinity;
-    for (const h of heroes) {
-        if (h.startTime < lastEnd) {
-            dropped.add(h.id);
-            continue;
-        }
-        lastEnd = h.startTime + h.duration;
-    }
-    return dropped.size === 0 ? clips : clips.filter((c) => !dropped.has(c.id));
-}

package/dist/_members/composition/graphics-plan/index.js

@@ -1,10 +0,0 @@
-/**
- * Graphics-plan IR — public surface. See ./schemas.ts for the contract and
- * brain/Projects/CueFrame/plans/2026-07-07-structure-first-graphics-pipeline.md
- * for the design.
- */
-export * from "./schemas.js";
-export * from "./solve.js";
-export * from "./motion.js";
-export * from "./compile.js";
-export { instantiateMotif, MotifInstantiationError } from "./instantiateMotif.js";

package/dist/_members/composition/graphics-plan/instantiateMotif.js

@@ -1,44 +0,0 @@
-/**
- * Deterministic instantiation of a REPRODUCED brand-kit motif skin — Lane A of
- * the two-lane graphics agent (plan 2026-07-16). A skin is the motif's verified
- * authored form (`brandMotif.body`, pixel-diffed against the reference at
- * ingestion); at compose time the graphic's copy is slotted into it with NO
- * LLM: pure text replacement under the slot convention.
- *
- * SLOT CONVENTION (defined here, enforced here, authored by the reproduction
- * loop): copy-bearing elements carry `data-slot="<copyKey>"` and contain ONLY
- * text. That constraint is what makes regex replacement sound — no HTML parser
- * dependency enters the composition leaf. Every violation FAILS LOUD; a silent
- * redesign is exactly the variance this lane exists to remove.
- */
-export class MotifInstantiationError extends Error {
-}
-const SLOT_RE = /(<[^>]*\bdata-slot="([^"]+)"[^>]*>)([\s\S]*?)(<\/)/g;
-const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-/** Fill a reproduced card skin's slots with the graphic's copy. Throws
- *  MotifInstantiationError on any deviation from the convention. */
-export function instantiateMotif(motif, copy) {
-    if (motif.coverage !== "reproduced") {
-        throw new MotifInstantiationError(`motif coverage is '${motif.coverage}' — only 'reproduced' skins instantiate; approximated/skipped motifs go to the designer`);
-    }
-    if (motif.body.kind !== "card") {
-        throw new MotifInstantiationError(`v1 instantiates card bodies only (got '${motif.body.kind}')`);
-    }
-    const seen = new Set();
-    const html = motif.body.html.replace(SLOT_RE, (_m, open, slot, inner, close) => {
-        if (/[<>]/.test(inner)) {
-            throw new MotifInstantiationError(`slot '${slot}' contains nested markup — skins must keep slots text-only`);
-        }
-        if (!(slot in copy)) {
-            throw new MotifInstantiationError(`slot '${slot}' not filled — copy carries [${Object.keys(copy).join(", ")}]`);
-        }
-        seen.add(slot);
-        return `${open}${escapeHtml(copy[slot])}${close}`;
-    });
-    for (const key of Object.keys(copy)) {
-        if (!seen.has(key)) {
-            throw new MotifInstantiationError(`copy has no slot '${key}' in the skin`);
-        }
-    }
-    return { html, ...(motif.body.tokens ? { tokens: motif.body.tokens } : {}) };
-}

package/dist/_members/composition/graphics-plan/motion.js

@@ -1,66 +0,0 @@
-/**
- * Motion stage: LayoutPlan → MotionPlan. Assigns a sensible default
- * entrance/emphasis/exit per element role, staggered so elements don't all
- * arrive at once. This is the inspectable MOTION artifact of the plan (a
- * checkpoint surface, and what an agent revises).
- *
- * NOTE (honest status): the compiler does NOT yet consume MotionPlan — the
- * primitives currently animate from their own `$brand:motion` defaults
- * (entrance/duration/easing). Wiring MotionPlan → per-primitive animation
- * params is a follow-up (FC3). Until then this plan is descriptive, not
- * yet the driver.
- */
-import { GRAPHICS_PLAN_VERSION, } from "./schemas.js";
-/** Per-role entrance intent. Values (the number to remember) count up; supporting
- *  text rises; the primary headline reveals; decoration fades. */
-const ENTER = {
-    headline: { type: "reveal", atMs: 0, durMs: 600, ease: "spring" },
-    value: { type: "count-up", atMs: 0, durMs: 800, ease: "spring" },
-    label: { type: "rise", atMs: 0, durMs: 500, ease: "ease-out" },
-    sublabel: { type: "fade", atMs: 0, durMs: 500, ease: "ease-out" },
-    logo: { type: "fade", atMs: 0, durMs: 400, ease: "ease-out" },
-    "accent-shape": { type: "wipe", atMs: 0, durMs: 500, ease: "ease-out" },
-    backdrop: { type: "fade", atMs: 0, durMs: 300, ease: "linear" },
-};
-/** Per-element entrance stagger (ms), applied in element order. */
-const STAGGER_MS = 120;
-/**
- * Build the motion plan for a laid-out beat. Entrances stagger by element order;
- * everything fades out together in the last ~350ms of the beat so a graphic never
- * hard-cuts. `durSec` is the beat length (from the ContentPlan beat).
- */
-export function planMotion(layout, durSec) {
-    const beatMs = Math.max(0, durSec * 1000);
-    const exitDur = Math.min(350, beatMs * 0.2);
-    const exitAt = Math.max(0, beatMs - exitDur);
-    const n = layout.elements.length;
-    // Fit ALL entrances within [0, exitAt]: an entrance must finish before the
-    // fade starts (on a short beat the nominal 800ms count-up + stagger would
-    // otherwise run past the exit or start after the beat ends). Scale the
-    // nominal durations + stagger by whatever factor makes the last entrance land
-    // by exitAt. `scale === 0` (zero-length beat) yields instantaneous entrances.
-    let nominalMaxEnd = 0;
-    layout.elements.forEach((el, i) => {
-        nominalMaxEnd = Math.max(nominalMaxEnd, i * STAGGER_MS + ENTER[el.role].durMs);
-    });
-    const scale = nominalMaxEnd > 0 && nominalMaxEnd > exitAt ? exitAt / nominalMaxEnd : 1;
-    const elements = layout.elements.map((el, i) => {
-        const base = ENTER[el.role];
-        const atMs = Math.round(i * STAGGER_MS * scale);
-        const durMs = Math.max(1, Math.round(base.durMs * scale));
-        const enter = { ...base, atMs, durMs };
-        const me = { elId: el.elId, enter };
-        // Emphasis pulse only if it fully FITS between the entrance and the exit
-        // fade (start AND end before exitAt — a pulse overrunning the fade jitters).
-        if (n > 0 && (el.role === "value" || el.role === "headline")) {
-            const emphAt = atMs + durMs + Math.round(150 * scale);
-            const emphDur = Math.round(300 * scale);
-            if (emphDur > 0 && emphAt + emphDur <= exitAt)
-                me.emphasis = { type: "pulse", atMs: emphAt, durMs: emphDur };
-        }
-        if (exitDur > 0)
-            me.exit = { type: "fade", atMs: exitAt, durMs: exitDur };
-        return me;
-    });
-    return { version: GRAPHICS_PLAN_VERSION, beatId: layout.beatId, elements };
-}

package/dist/_members/composition/graphics-plan/schemas.js

@@ -1,261 +0,0 @@
-/**
- * Graphics-plan IR — the structure-first authoring contract (plan
- * 2026-07-07-structure-first-graphics-pipeline). Instead of the designer
- * authoring Remotion JSX blind, it produces these three inspectable,
- * versioned artifacts; a compiler turns them into brand-bound, animatable
- * Remotion. The SAME schema is the client-agent CHECKPOINT payload AND the
- * compiler input — no translation layer to drift.
- *
- * Split by concern so each stage boundary is a review/edit point:
- *   ContentPlan  — WHAT to say (editorial, text-owned; never pixels).
- *   LayoutPlan   — WHERE it sits (spatial structure, content-aware: element
- *                  boxes are solved CLEAR of the face keep-outs the
- *                  composition-floor already computes → text-over-face is
- *                  impossible by construction, not by prompt).
- *   MotionPlan   — HOW it animates (entrance / emphasis / exit intent).
- *
- * `styleRole` binds to brand tokens (never a raw hex/font) so off-brand
- * output is impossible; the compiler resolves it via the same `$brand:`
- * mechanism as packages/authoring/src/tools/brandTokens.ts.
- */
-import { z } from "zod";
-import { Region } from "../validators/composition.js";
-/** Bump when a field's meaning changes; the compiler + checkpoint clients
- *  branch on it. Kept a literal so an old client sees a hard mismatch, not a
- *  silent misread. */
-export const GRAPHICS_PLAN_VERSION = "gp-1";
-const Version = z.literal(GRAPHICS_PLAN_VERSION);
-/** A rect in output-frame fractions [0,1] — the SAME placement vocabulary as
- *  the composition-floor `Rect` and the wire `Region` (reused so a plan box and
- *  a rendered layer can never disagree about coordinates). */
-export const PlanRect = Region;
-// ── ContentPlan ────────────────────────────────────────────────────────────
-/**
- * What the beat must COMMUNICATE. An EDITORIAL vocabulary — deliberately not a list of
- * primitive names.
- *
- * The first six are named after primitive families, and that was the bug: the DESIGNER's
- * decision (which component draws this) had leaked into the PLANNER's schema. It meant the
- * vocabulary could only grow by adding primitive names, so it could never keep up with the
- * catalog — and on 2026-07-13 a brief demanding a chain-trace, comparison bars and a
- * three-item build got exactly ONE lower-third, because a lower-third was close to the most
- * the planner was ABLE to say. It was not being lazy. It had no word for what the brief wanted.
- *
- * The last three are the fix, and they name a JOB, not a picture:
- *   the planner says "this beat must show a sequence"; the DESIGNER decides whether that is
- *   `reasoning-trace`, `tool-call-stack`, or something it writes itself.
- *
- * Closed on purpose (the critics and the layout solver switch on it) — but closed around
- * editorial intent, which is a small and stable set, instead of around a 103-component catalog,
- * which is neither.
- */
-export const GraphicRole = z.enum([
-    "title-card", // topic-setter / opener card
-    "stat", // a single headline number + label
-    "lower-third", // name/title tag over the speaker
-    "pull-quote", // a short quoted line
-    "hero", // big behind-subject phrase (zPlane: behind-subject)
-    "logo-tag", // small brand mark / watermark beat
-    // ── the beat carries an ARGUMENT, not a caption ──
-    "enumeration", // a list of short items ("LBO modelling / VDR diligence / customer cubes")
-    "sequence", // an ordered chain of steps — often the POINT is that it is too long
-    "comparison", // labelled values set against each other (a benchmark, a before/after)
-]);
-/**
- * The words for a beat — ALWAYS plan-owned (a text-to-image model can't spell; the Remotion code
- * renders these crisply). All optional; a role uses the subset it needs
- * (stat → value+label; title-card → headline+sub; enumeration/sequence → items; comparison → series).
- *
- * `items` and `series` exist because the plan OWNS the words, and a role it cannot supply the
- * words for is a role it cannot actually request. Four scalars could not carry a list or a
- * labelled series, so even a widened role vocabulary would have had nowhere to put its content —
- * the second half of the same 2026-07-13 bug, and the one that would have silently defeated the
- * fix for the first half.
- */
-export const Copy = z
-    .object({
-    headline: z.string().max(120).optional(),
-    sub: z.string().max(200).optional(),
-    value: z.string().max(40).optional(),
-    label: z.string().max(80).optional(),
-    /** Ordered short items — an `enumeration`'s bullets, a `sequence`'s steps. */
-    items: z.array(z.string().max(80)).max(8).optional(),
-    /**
-     * Labelled values for a `comparison`.
-     *
-     * `value` is a STRING, deliberately — not `number | string`. The plan owns the words, and a
-     * comparison's words include their units: a planner writes "10 min", "98%", "$4.2M", never
-     * 600. A number would have to be re-unitised downstream by someone who doesn't know what it
-     * meant.
-     *
-     * It is also a hard constraint: `submit_compose_plan` is a STRICT Anthropic tool
-     * (`strict: true`, schemas.ts), and a `z.union` here becomes an `anyOf` in the tool schema.
-     * That is what stalled the planner on 2026-07-13 — it ran, could not satisfy the schema, and
-     * never called the tool at all. Keep every field in this schema a single concrete type.
-     */
-    series: z
-        .array(z.object({ label: z.string().max(40), value: z.string().max(16) }))
-        .max(8)
-        .optional(),
-})
-    .strict();
-export const ContentBeat = z
-    .object({
-    id: z.string().min(1),
-    /** Clip-relative seconds. */
-    atSec: z.number().min(0),
-    durSec: z.number().positive(),
-    role: GraphicRole,
-    copy: Copy,
-    /** Editorial WHY — the beat this graphic serves (for review + the judge). */
-    intent: z.string().min(1).max(400),
-    /** Higher = more important; drives drop order under budget. */
-    priority: z.number().int().min(0).max(10).default(5),
-})
-    .strict();
-export const ContentPlan = z
-    .object({
-    version: Version,
-    beats: z.array(ContentBeat),
-})
-    .strict();
-// ── LayoutPlan ───────────────────────────────────────────────────────────────
-/** The role of ONE element within a graphic — maps to a primitive slot. */
-export const ElementRole = z.enum([
-    "headline", // primary large text
-    "value", // the stat number / the one word to remember
-    "label", // supporting text
-    "sublabel", // secondary supporting text
-    "logo", // brand mark
-    "accent-shape", // decorative block/line/underline
-    "backdrop", // solid fill (takeover cards only)
-]);
-/** Semantic style binding → resolved to `$brand:` refs by the compiler; NEVER a
- *  raw hex/font. This is the guarantee that on-brand is the only option.
- *  Mapping (compiler): heading→fonts.heading+colors.text, accent→colors.accent,
- *  body→fonts.body+colors.text, surface→colors.surface/background,
- *  on-accent→colors.textOnAccent, on-surface→colors.textOnSurface. */
-export const StyleRole = z.enum([
-    "heading",
-    "body",
-    "accent",
-    "surface",
-    "on-accent",
-    "on-surface",
-]);
-/** Depth plane — matches OverlayClipSource.zPlane. `behind-subject` is the
- *  intentional hero look (the subject cut-out bites the letters). */
-export const ZPlane = z.enum(["front", "behind-subject"]);
-export const LayoutElement = z
-    .object({
-    elId: z.string().min(1),
-    role: ElementRole,
-    /** Solved CLEAR of `keepOut` (except intentional behind-subject heroes). */
-    box: PlanRect,
-    styleRole: StyleRole,
-    z: ZPlane.default("front"),
-    /** The text this element renders (from the ContentPlan). Omitted for
-     *  logo / accent-shape / backdrop. */
-    text: z.string().max(200).optional(),
-    /** Index into the editorial type scale (mirrors composition-floor
-     *  Treatment.typeScaleStep) — a SCALE STEP, not a raw px guess. */
-    typeScaleStep: z.number().int().min(0).max(8).optional(),
-})
-    .strict();
-const EPS = 1e-6;
-const rectsOverlapEps = (a, b) => a.x < b.x + b.w - EPS && a.x + a.w > b.x + EPS && a.y < b.y + b.h - EPS && a.y + a.h > b.y + EPS;
-export const LayoutPlan = z
-    .object({
-    version: Version,
-    beatId: z.string().min(1),
-    /** Output aspect context (pixels); placement itself is in [0,1] fractions. */
-    frame: z.object({ w: z.number().positive(), h: z.number().positive() }).strict(),
-    /** INPUT (not authored): face keep-out rects at this beat, from the
-     *  composition-floor. The layout stage MUST place `front` elements clear of
-     *  these — carried on the plan so a reviewer/compiler can verify it. */
-    keepOut: z.array(PlanRect),
-    /** INPUT: safe-zone insets (title-safe / action-safe fractions). */
-    safe: z
-        .object({
-        titleSafe: z.number().min(0).max(1),
-        actionSafe: z.number().min(0).max(1),
-    })
-        .strict(),
-    elements: z.array(LayoutElement),
-    /** Set when the solver could NOT place a beat's graphic legally (e.g. the
-     *  face fills the legal area). Makes a drop OBSERVABLE — distinct from a
-     *  beat that legitimately had no copy (both yield elements:[]). The producer
-     *  can surface it; the compiler skips it. */
-    dropped: z.object({ reason: z.string().min(1) }).strict().optional(),
-})
-    .strict()
-    // The IR ENFORCES its own headline invariant: a `front` element box must be
-    // in-frame AND clear of every face keep-out. A mis-solved OR (P4) agent-
-    // proposed plan that puts text on the speaker FAILS parse — the guarantee is
-    // structural, not just solver-code-dependent. behind-subject heroes are
-    // exempt (the subject intentionally occludes them).
-    .superRefine((plan, ctx) => {
-    for (const el of plan.elements) {
-        if (el.z === "behind-subject")
-            continue;
-        const b = el.box;
-        if (b.x + b.w > 1 + EPS || b.y + b.h > 1 + EPS) {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: `element ${el.elId} box spills past the frame`, path: ["elements"] });
-        }
-        for (const ko of plan.keepOut) {
-            if (rectsOverlapEps(b, ko)) {
-                ctx.addIssue({ code: z.ZodIssueCode.custom, message: `element ${el.elId} overlaps a face keep-out (text on the speaker)`, path: ["elements"] });
-            }
-        }
-    }
-});
-// ── MotionPlan ───────────────────────────────────────────────────────────────
-export const EnterType = z.enum(["reveal", "fade", "rise", "count-up", "wipe"]);
-export const EmphasisType = z.enum(["pulse", "underline", "color-shift"]);
-export const ExitType = z.enum(["fade", "fall", "wipe", "cut"]);
-/** Ease vocabulary → compiler maps to real spring/interpolate. Named, not raw
- *  bezier/ms, so the brand's motion pace stays a decision not a magic number. */
-export const Ease = z.enum(["spring", "ease-out", "ease-in-out", "linear"]);
-export const EnterMotion = z
-    .object({
-    type: EnterType,
-    atMs: z.number().min(0),
-    durMs: z.number().positive(),
-    ease: Ease.default("spring"),
-    /** Per-child stagger (ms) for multi-part reveals. */
-    stagger: z.number().min(0).optional(),
-})
-    .strict();
-export const EmphasisMotion = z
-    .object({ type: EmphasisType, atMs: z.number().min(0), durMs: z.number().positive() })
-    .strict();
-export const ExitMotion = z
-    .object({ type: ExitType, atMs: z.number().min(0), durMs: z.number().positive() })
-    .strict();
-export const MotionElement = z
-    .object({
-    elId: z.string().min(1),
-    enter: EnterMotion,
-    emphasis: EmphasisMotion.optional(),
-    exit: ExitMotion.optional(),
-})
-    .strict();
-export const MotionPlan = z
-    .object({
-    version: Version,
-    beatId: z.string().min(1),
-    elements: z.array(MotionElement),
-})
-    .strict();
-// ── Bundle ───────────────────────────────────────────────────────────────────
-/** The full graphics plan for a compose run: one ContentPlan, and a
- *  Layout+Motion pair per beat (keyed by beatId). This is the object a
- *  checkpoint returns and the compiler consumes. */
-export const GraphicsPlan = z
-    .object({
-    version: Version,
-    content: ContentPlan,
-    layouts: z.array(LayoutPlan),
-    motions: z.array(MotionPlan),
-})
-    .strict();