@cueframe/kernel 0.0.1

package/dist/_members/composition/brief/contract.js

@@ -0,0 +1,209 @@
+/**
+ * The BRIEF CONTRACT — what the customer pinned, and what no downstream stage may undo.
+ *
+ * ── AUTHORITY ────────────────────────────────────────────────────────────────────────────
+ * The brief owns WHAT CONTENT EXISTS. The planner owns HOW IT IS FRAMED. A planner that
+ * deletes footage is not making a framing decision — it is exercising the brief's authority,
+ * and no downstream guard can ever repair that.
+ *
+ * On 2026-07-13 the planner shipped 52.9s against a brief pinning 87.1s. It deleted the
+ * product demo and the call-to-action, reasoning "No subject detected — cut for pace". Nothing
+ * objected, because the contract was never even THREADED to the director: the beats are
+ * resolved by `deriveBriefComposeSource` and then thrown away, and `DirectorInput.compose`
+ * carries the brief flattened into a "suggestion" (caption / hook / motionStyle). The planner
+ * could not honor a contract it was never shown.
+ *
+ * A beat's `source` window is documented as "honored TO THE FRAME or refused". So on the brief
+ * path, deleting pinned footage is a contract violation, full stop.
+ *
+ * ── WHY 'trim' IS EFFECTIVELY FORBIDDEN HERE ─────────────────────────────────────────────
+ * Brief creation ALREADY refuses a `durationSec` that differs from the pinned window by more
+ * than ±1.5s (`brief_duration_unhonorable`). So by construction the contracted duration IS the
+ * pinned window — the customer has declared there is no filler. Any deletion beyond the
+ * tolerance therefore breaks the duration contract. A customer who wants footage cut pins
+ * tighter beats; that is the channel for it.
+ *
+ * `'keep'` (SHOW this span AS-IS, no reframe) is the legal move for footage with nothing to
+ * track. It was added 2026-07-12 for exactly this, and the planner still reaches for 'trim'.
+ * A vocabulary the model may ignore is not a constraint — hence this module.
+ *
+ * Pure arithmetic, zero runtime imports (structural param types only), so it is safe in BOTH
+ * the Convex V8 isolate (brief-creation gate) and the Temporal workflow sandbox (the plan
+ * gate). One definition of the tolerances, no drift.
+ */
+// ── Tolerances — the SINGLE definition ──────────────────────────────────────────────────
+// Both chokepoints read these: brief CREATION (is this brief self-consistent?) and the PLAN
+// gate (does this plan honor it?). They were previously duplicated inside the Convex module,
+// where the director could not reach them.
+/** Gap tolerance between adjacent pinned beats — a larger gap means the [min,max] hull would
+ *  include footage the client never pinned. */
+export const BEAT_CONTIGUITY_TOLERANCE_S = 0.75;
+/** Per-beat tolerance used by BRIEF CREATION: a sourced beat's own `durationSec` must match its
+ *  own window to within this. (Not the plan gate's rule — see BEAT_MAX_LOSS_FRACTION.) */
+export const BEAT_DURATION_TOLERANCE_S = 0.5;
+/** How far the whole output may drift from the contracted duration. THE contract (documented,
+ *  customer-facing) — and, because deletions only ever shrink the output, it already caps how
+ *  much a plan can remove in ABSOLUTE terms. */
+export const BRIEF_DURATION_TOLERANCE_S = 1.5;
+/**
+ * The most of ITSELF a single pinned beat may lose. A FRACTION, deliberately — not an absolute.
+ *
+ * Rule B already caps total deletion at ±1.5s, so no beat can lose much in absolute terms. What
+ * Rule B cannot see is a SHORT beat being erased outright: a 1.5s beat deleted whole still
+ * clears the aggregate. That is the only gap Rule A exists to close, so it must be expressed as
+ * "did this beat survive recognisably", not as a stopwatch.
+ *
+ * An absolute 0.5s was tried first and was WRONG — it refused the planner's removal of a 1.44s
+ * HARD PAUSE between two sentences (measured 2026-07-13). Cutting dead air is editing, which the
+ * planner owns; deleting the product demo is content, which it does not. A rule that cannot tell
+ * those apart is not enforcing authority, it is just being obstructive.
+ */
+export const BEAT_MAX_LOSS_FRACTION = 0.5;
+/** Total length of a set of spans after merging overlaps (a cut inside a trim is deleted once,
+ *  not twice — double-counting would manufacture a violation). */
+function unionLength(spans) {
+    const sorted = [...spans]
+        .filter((s) => s.endSec > s.startSec)
+        .sort((a, b) => a.startSec - b.startSec);
+    let total = 0;
+    let cur = null;
+    for (const s of sorted) {
+        if (!cur || s.startSec > cur.endSec) {
+            if (cur)
+                total += cur.endSec - cur.startSec;
+            cur = { startSec: s.startSec, endSec: s.endSec };
+        }
+        else if (s.endSec > cur.endSec) {
+            cur.endSec = s.endSec;
+        }
+    }
+    if (cur)
+        total += cur.endSec - cur.startSec;
+    return total;
+}
+function overlap(a, b) {
+    return Math.max(0, Math.min(a.endSec, b.endSec) - Math.max(a.startSec, b.startSec));
+}
+const s1 = (n) => n.toFixed(1);
+/**
+ * Every way this plan breaks the brief's content contract, as planner-addressed messages.
+ * Empty array ⇒ the plan honors the brief.
+ *
+ * Three rules, and ALL are needed:
+ *  - Rule A (per beat): a pinned beat may not be deleted. Catches surgical beat removal that
+ *    Rule B could mask by keeping filler elsewhere.
+ *  - Rule B (aggregate): the contracted duration must survive. Catches death by a thousand
+ *    cuts that individually clear the per-beat tolerance.
+ *  - Rule C (per mandated beat): a beat's graphics MANDATE must be planned — same
+ *    honor-or-refuse as A/B. Before this, a graphics-less plan against a graphics-mandating
+ *    brief sailed through and cost a full plan→assemble→eval cycle for the judge to discover
+ *    what the brief said in writing (prod 2026-07-14, rs7fanev…) — and with one candidate
+ *    attempt there is no critique retry to rescue it: this gate is the only line of defense.
+ *
+ * The messages ARE the fix: each names the beat, quotes the planner's own reason back at it,
+ * and prescribes the exact shape — because `runPlanPhase` feeds these straight back as the
+ * planner's next-turn instruction.
+ */
+export function planBriefViolations(plan, contract) {
+    if (contract.beats.length === 0)
+        return []; // nothing pinned ⇒ nothing to protect
+    const errors = [];
+    // ── Rule C — every mandated graphic must be planned (runs even with zero deletions) ──
+    for (const beat of contract.beats) {
+        if (!beat.graphic)
+            continue;
+        const clipBeat = {
+            startSec: beat.startSec - contract.windowStartSec,
+            endSec: beat.endSec - contract.windowStartSec,
+        };
+        const role = beat.graphic.role;
+        const sameRole = (plan.graphics ?? []).filter((g) => g.role === role);
+        const match = sameRole.find((g) => overlap(clipBeat, { startSec: g.atSec, endSec: g.atSec + g.durSec }) > 0);
+        if (!match) {
+            const where = sameRole.length === 0
+                ? `your plan has NO '${role}' graphics request at all`
+                : `your plan's '${role}' request(s) (${sameRole
+                    .map((g) => `${s1(g.atSec)}–${s1(g.atSec + g.durSec)}s`)
+                    .join(", ")}) never overlap the beat`;
+            errors.push(`brief: beat "${beat.id}" (${s1(clipBeat.startSec)}–${s1(clipBeat.endSec)}s clip-relative) ` +
+                `MANDATES a '${role}' graphic — ${where}. The customer pinned this graphic; add a graphics ` +
+                `entry { role: '${role}', atSec within ${s1(clipBeat.startSec)}–${s1(clipBeat.endSec)}, durSec, copy, intent }` +
+                (beat.graphic.items?.length
+                    ? ` with copy.items carrying VERBATIM: ${beat.graphic.items.map((i) => `"${i}"`).join(", ")}`
+                    : "") +
+                `.`);
+            continue;
+        }
+        // Mandated items are the customer's words — verbatim (trim/casefold only).
+        const wanted = beat.graphic.items ?? [];
+        if (wanted.length > 0) {
+            const norm = (s) => s.trim().toLowerCase();
+            const have = new Set((match.copy?.items ?? []).map(norm));
+            const missing = wanted.filter((w) => !have.has(norm(w)));
+            if (missing.length > 0) {
+                errors.push(`brief: beat "${beat.id}" — the '${role}' graphic "${match.id}" is planned but its ` +
+                    `copy.items drop the customer's mandated item(s): ${missing.map((i) => `"${i}"`).join(", ")}. ` +
+                    `These are the customer's words; carry each one verbatim in copy.items.`);
+            }
+        }
+    }
+    const deletions = [
+        ...plan.framing
+            .filter((f) => f.action === "trim")
+            .map((f) => ({
+            startSec: f.startSec,
+            endSec: f.endSec,
+            kind: "trim",
+            reason: f.intent ?? "(no reason given)",
+        })),
+        ...(plan.cuts ?? []).map((c) => ({
+            startSec: c.startSec,
+            endSec: c.endSec,
+            kind: "cut",
+            reason: c.reason ?? "(no reason given)",
+        })),
+    ];
+    if (deletions.length === 0)
+        return errors;
+    // ── Rule A — no pinned beat may be deleted ──
+    for (const beat of contract.beats) {
+        // The plan is CLIP-RELATIVE; the brief is SOURCE-absolute.
+        const clipBeat = {
+            startSec: beat.startSec - contract.windowStartSec,
+            endSec: beat.endSec - contract.windowStartSec,
+        };
+        const hits = deletions
+            .map((d) => ({ d, lost: overlap(clipBeat, d) }))
+            .filter((h) => h.lost > 0);
+        const lost = unionLength(hits.map((h) => h.d).map((d) => ({
+            startSec: Math.max(d.startSec, clipBeat.startSec),
+            endSec: Math.min(d.endSec, clipBeat.endSec),
+        })));
+        const beatLen = Math.max(1e-6, clipBeat.endSec - clipBeat.startSec);
+        // Did the beat SURVIVE RECOGNISABLY? Cutting dead air out of a beat is editing (the
+        // planner's job). Erasing the beat is content deletion (the brief's call, not its).
+        if (lost / beatLen <= BEAT_MAX_LOSS_FRACTION)
+            continue;
+        const why = hits
+            .map((h) => `${h.d.kind} "${h.d.reason}" (−${s1(h.lost)}s)`)
+            .join("; ");
+        errors.push(`brief: beat "${beat.id}" (${s1(beat.startSec)}–${s1(beat.endSec)}s source, ${s1(beatLen)}s long) — ` +
+            `your plan DELETES ${s1(lost)}s of it (${Math.round((lost / beatLen) * 100)}%) via ${why}. ` +
+            `The customer PINNED this beat and it would not survive. Trimming dead air inside a beat ` +
+            `is fine; ERASING the beat is not — that is content, and the brief owns content. ` +
+            `A span with nothing to track is NOT filler: use action:'keep' (SHOW as-is, no reframe).`);
+    }
+    // ── Rule B — the contracted duration survives ──
+    const deleted = unionLength(deletions.map((d) => ({
+        startSec: Math.max(0, d.startSec),
+        endSec: Math.min(contract.targetDurationSec, d.endSec),
+    })));
+    const surviving = contract.targetDurationSec - deleted;
+    if (Math.abs(surviving - contract.targetDurationSec) > BRIEF_DURATION_TOLERANCE_S) {
+        errors.push(`brief: durationSec contract — your plan leaves ${s1(surviving)}s but the brief pins ` +
+            `${s1(contract.targetDurationSec)}s (tolerance ±${BRIEF_DURATION_TOLERANCE_S}s). You deleted ` +
+            `${s1(deleted)}s. The pinned beats ARE the video — there is no filler to cut. Re-plan with ` +
+            `action:'keep' instead of 'trim' for any span you cannot track.`);
+    }
+    return errors;
+}

package/dist/_members/composition/color-grade.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Derive a `colorMood` (fed to `pickColorGradePreset`) from a brand kit's
+ * signature colour, so a compose with NO explicit `motionStyle.colorMood` still
+ * anchors the footage toward the brand instead of shipping ungraded (the Waverly
+ * bug: empty colorMood → no grade → bright off-brand footage never anchored).
+ *
+ * Reads the brand's PRIMARY hue (falls back to accent): warm hues → "warm",
+ * cool hues → "cool", else "cinematic" (a mild, safe default). Achromatic /
+ * unparseable → "cinematic". Deliberately coarse — a mild anchor, not a
+ * palette-exact regrade (that would need a brand-tint param on the primitive).
+ */
+export declare function colorMoodFromBrand(colors: {
+    primary?: string;
+    accent?: string;
+    background?: string;
+}): string;
+export declare function pickColorGradePreset(colorMood: string): string | null;

package/dist/_members/composition/color-grade.js

@@ -0,0 +1,80 @@
+/**
+ * Color-grade derivation — the SINGLE home for `motionStyle.colorMood` →
+ * color-grade preset. Both compose paths agree on the effect because they
+ * import THIS function:
+ *   - the deterministic "cheap" path (`services/convex/composition/fromSuggestion.ts`)
+ *   - the Director agent path (`services/temporal/director/src/convexStore.ts`)
+ *
+ * Previously duplicated in both (a director-side `colorGrade.ts` "kept in
+ * lockstep" by hand). Composition is a leaf both packages already depend on,
+ * so the mapping lives here once. Pure string logic — isolate-safe.
+ *
+ * Returns `null` for "natural" / empty / unrecognised vocabulary so the effect
+ * track is omitted entirely (a no-op renders cleanly).
+ */
+/** Parse a `#rgb`/`#rrggbb` hex → hue in [0,360), or null if unparseable. */
+function hexHue(hex) {
+    const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m)
+        return null;
+    let h = m[1];
+    if (h.length === 3)
+        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    const r = parseInt(h.slice(0, 2), 16) / 255;
+    const g = parseInt(h.slice(2, 4), 16) / 255;
+    const b = parseInt(h.slice(4, 6), 16) / 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const d = max - min;
+    if (d === 0)
+        return null; // achromatic (grey/black/white) → no temperature signal
+    let hue;
+    if (max === r)
+        hue = ((g - b) / d) % 6;
+    else if (max === g)
+        hue = (b - r) / d + 2;
+    else
+        hue = (r - g) / d + 4;
+    hue *= 60;
+    return hue < 0 ? hue + 360 : hue;
+}
+/**
+ * Derive a `colorMood` (fed to `pickColorGradePreset`) from a brand kit's
+ * signature colour, so a compose with NO explicit `motionStyle.colorMood` still
+ * anchors the footage toward the brand instead of shipping ungraded (the Waverly
+ * bug: empty colorMood → no grade → bright off-brand footage never anchored).
+ *
+ * Reads the brand's PRIMARY hue (falls back to accent): warm hues → "warm",
+ * cool hues → "cool", else "cinematic" (a mild, safe default). Achromatic /
+ * unparseable → "cinematic". Deliberately coarse — a mild anchor, not a
+ * palette-exact regrade (that would need a brand-tint param on the primitive).
+ */
+export function colorMoodFromBrand(colors) {
+    const hue = hexHue(colors.primary ?? "") ?? hexHue(colors.accent ?? "");
+    if (hue === null)
+        return "cinematic";
+    if (hue < 45 || hue >= 330)
+        return "warm"; // reds / oranges / warm yellows
+    if (hue >= 150 && hue < 270)
+        return "cool"; // teals / blues / indigos
+    return "cinematic"; // greens + magentas → neutral cinematic anchor
+}
+export function pickColorGradePreset(colorMood) {
+    const v = colorMood.toLowerCase();
+    if (v === "" || v.includes("natural") || v.includes("neutral") || v.includes("none")) {
+        return null;
+    }
+    if (v.includes("warm") || v.includes("orange") || v.includes("golden"))
+        return "warm";
+    if (v.includes("cool") || v.includes("blue") || v.includes("cold"))
+        return "cool";
+    if (v.includes("vintage") || v.includes("retro") || v.includes("aged"))
+        return "vintage";
+    if (v.includes("sepia"))
+        return "sepia";
+    if (v.includes("bleach"))
+        return "bleach-bypass";
+    if (v.includes("cinematic") || v.includes("punchy") || v.includes("vibrant"))
+        return "cinematic";
+    return "cinematic"; // safe default — most production moods read as "cinematic"
+}

package/dist/_members/composition/depth.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Behind-subject depth predicate — the SINGLE source of truth for "does this clip
+ * source render at behind-subject depth (under the subject matte)". Pure and
+ * zod-free, so it's safe to import into the CF-Worker / Temporal bundles that
+ * deliberately keep the zod validators out (see variant-keys.ts type-only imports).
+ *
+ * BOTH designed text overlays (`kind:'overlay'`) and baked custom graphics
+ * (`kind:'alpha-layer'`) carry `zPlane` and MUST gate the subject matte
+ * identically. Every behind-subject consumer routes through this predicate so the
+ * gates can never diverge again:
+ *   - collectBehindWindows / detectMattelessBehindOverlays  (@cueframe/shared)
+ *   - isBehindSubjectOverlay  (@cueframe/evaluation composeEval)
+ *   - resolveBehindPlacement  (director — degrade-to-front occlusion budget)
+ * Anchor world-locking stays overlay-only INSIDE resolveBehindPlacement:
+ * alpha-layer graphics self-position and carry no `anchor` field.
+ *
+ * See plan 2026-07-03-alpha-layer-behind-subject-lockstep.
+ */
+import type { ClipSource } from './validators/composition.js';
+/** The two depth-bearing source kinds (text overlay + baked custom graphic). */
+export type BehindSubjectDepthSource = Extract<ClipSource, {
+    kind: 'overlay' | 'alpha-layer';
+}>;
+export declare function isBehindSubjectDepthSource(source: unknown): source is BehindSubjectDepthSource;

package/dist/_members/composition/depth.js

@@ -0,0 +1,8 @@
+export function isBehindSubjectDepthSource(source) {
+    if (!source || typeof source !== 'object')
+        return false;
+    const kind = source.kind;
+    if (kind !== 'overlay' && kind !== 'alpha-layer')
+        return false;
+    return source.zPlane === 'behind-subject';
+}

package/dist/_members/composition/fixtures/agentErrored.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Compositions authored by a gateway agent on 2026-06-17 that were
+ * REJECTED by `PUT /v1/projects/:id/composition` (and would be by the
+ * `POST /v1/composition/validate` dry-run verb) with the canonical
+ * `Composition` validator.
+ *
+ * The API surfaced only `{"code":"validation_error","message":"","details":{}}`
+ * — an EMPTY error — because `zodJson` (the API layer)
+ * runs the Standard-Schema issues through `fromError(new ZodError(issues)).toString()`
+ * which collapses to "". The per-field reasons exist server-side but never reach
+ * the wire, so the agent could not self-correct.
+ *
+ * These fixtures are the raw wire payloads, captured verbatim. They are typed as
+ * `unknown` (NOT `Composition`) because they are invalid by design — feed them to
+ * `Composition.safeParse` to read the real `issues[]` the API swallowed, and to
+ * pin the behaviour both before and after the empty-message fix.
+ */
+/** First attempt — three separate portrait clips, each with its own reframe segment. */
+export declare const agentErroredCompositionV1: unknown;
+/**
+ * Second attempt — the gateway agent's own "fixed" version after we reported the failure:
+ * merged the three portrait clips into one 27s clip carrying all three reframe
+ * segments, renamed the tracks. Still rejected with the same empty error.
+ */
+export declare const agentErroredCompositionV2: unknown;

package/dist/_members/composition/fixtures/index.d.ts

@@ -0,0 +1,7 @@
+import type { Composition } from "../validators/composition.js";
+export declare const minimalComposition: Composition;
+export declare const overlappingClips: Composition;
+export declare const transitionWithoutPredecessor: Composition;
+export declare const overlappingSceneMarkers: Composition;
+export declare const idCollision: Composition;
+export declare const clipWithExcludedRanges: Composition;

package/dist/_members/composition/fixtures/index.js

@@ -0,0 +1,143 @@
+export const minimalComposition = {
+    v: 1,
+    format: { aspectRatio: "9:16", fps: 30, resolution: "fhd" },
+    tracks: [
+        {
+            id: "V1",
+            kind: "video",
+            contents: [
+                {
+                    id: "clip-1",
+                    startTime: 0,
+                    duration: 10,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx0000000000000000000000",
+                    },
+                },
+            ],
+        },
+    ],
+};
+export const overlappingClips = {
+    v: 1,
+    format: { aspectRatio: "16:9", fps: 30 },
+    tracks: [
+        {
+            id: "V1",
+            kind: "video",
+            contents: [
+                {
+                    id: "clip-1",
+                    startTime: 0,
+                    duration: 10,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx0000000000000000000000",
+                    },
+                },
+                {
+                    id: "clip-2",
+                    startTime: 5,
+                    duration: 10,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx1111111111111111111111",
+                    },
+                },
+            ],
+        },
+    ],
+};
+export const transitionWithoutPredecessor = {
+    v: 1,
+    format: { aspectRatio: "9:16", fps: 30 },
+    tracks: [
+        {
+            id: "V1",
+            kind: "video",
+            contents: [
+                {
+                    id: "clip-1",
+                    startTime: 0,
+                    duration: 10,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx0000000000000000000000",
+                    },
+                    transitionIn: { type: "fade", duration: 1 },
+                },
+            ],
+        },
+    ],
+};
+export const overlappingSceneMarkers = {
+    v: 1,
+    format: { aspectRatio: "9:16", fps: 30 },
+    tracks: [
+        {
+            id: "V1",
+            kind: "video",
+            contents: [
+                {
+                    id: "clip-1",
+                    startTime: 0,
+                    duration: 30,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx0000000000000000000000",
+                    },
+                },
+            ],
+        },
+    ],
+    markers: [
+        { id: "s1", kind: "scene", startTime: 0, endTime: 15, name: "intro" },
+        { id: "s2", kind: "scene", startTime: 10, endTime: 25, name: "middle" },
+    ],
+};
+export const idCollision = {
+    v: 1,
+    format: { aspectRatio: "9:16", fps: 30 },
+    tracks: [
+        {
+            id: "V1",
+            kind: "video",
+            contents: [
+                {
+                    id: "shared-id",
+                    startTime: 0,
+                    duration: 5,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx0000000000000000000000",
+                    },
+                },
+            ],
+        },
+    ],
+    markers: [{ id: "shared-id", kind: "note", startTime: 2 }],
+};
+export const clipWithExcludedRanges = {
+    v: 1,
+    format: { aspectRatio: "9:16", fps: 30 },
+    tracks: [
+        {
+            id: "V1",
+            kind: "video",
+            contents: [
+                {
+                    id: "clip-1",
+                    startTime: 0,
+                    duration: 4,
+                    source: {
+                        kind: "media",
+                        mediaId: "kx0000000000000000000000",
+                        trim: { start: 0, end: 5 },
+                        excludedRanges: [{ start: 1, end: 2, reason: "filler" }],
+                    },
+                },
+            ],
+        },
+    ],
+};

package/dist/_members/composition/fixtures/vaayaErrored.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Compositions authored by the Vaaya gateway agent on 2026-06-17 that were
+ * REJECTED by `PUT /v1/projects/:id/composition` (and would be by the
+ * `POST /v1/composition/validate` dry-run verb) with the canonical
+ * `Composition` validator.
+ *
+ * The API surfaced only `{"code":"validation_error","message":"","details":{}}`
+ * — an EMPTY error — because `zodJson` (services/convex/api/openapi/validate.ts)
+ * runs the Standard-Schema issues through `fromError(new ZodError(issues)).toString()`
+ * which collapses to "". The per-field reasons exist server-side but never reach
+ * the wire, so the agent could not self-correct.
+ *
+ * These fixtures are the raw wire payloads, captured verbatim. They are typed as
+ * `unknown` (NOT `Composition`) because they are invalid by design — feed them to
+ * `Composition.safeParse` to read the real `issues[]` the API swallowed, and to
+ * pin the behaviour both before and after the empty-message fix.
+ */
+/** First attempt — three separate portrait clips, each with its own reframe segment. */
+export declare const vaayaErroredCompositionV1: unknown;
+/**
+ * Second attempt — Vaaya's own "fixed" version after we reported the failure:
+ * merged the three portrait clips into one 27s clip carrying all three reframe
+ * segments, renamed the tracks. Still rejected with the same empty error.
+ */
+export declare const vaayaErroredCompositionV2: unknown;