@cueframe/kernel 0.1.0 → 0.1.2

package/dist/_members/composition/audio/palette.js

@@ -1,134 +0,0 @@
-/**
- * The org sound palette (audio-substrate Phase 2) — ONE browse surface over the
- * union of every sound an org can reach: the curated CC0 packs (SFX + music
- * beds), the org's own audio-kind uploads/imports, and its generated audio. The
- * uniform entry shape lets a driving agent pick a sound by role + envelope class
- * without caring where it came from — provenance rides every entry.
- *
- * PURE: raw org audio rows in → palette entries out. The pack halves come from
- * the closed catalogs (SFX_PACK_ENTRIES / MUSIC_PACK_ENTRIES); the org/generated
- * halves are projected from the caller's org audio rows. Consumed by BOTH the
- * `list_catalog` audio section (the agent browse) and the director's compose
- * org-first SFX draw (which reads only the sfx-role org subset). One assembler,
- * so the two surfaces can never disagree on what the org owns.
- */
-import { SFX_PACK_ENTRIES } from "./pack";
-import { MUSIC_PACK_ENTRIES } from "./musicPack";
-/** The pack SFX half of the palette (source:"pack", role:"sfx"). */
-function packSfxEntries() {
-    return SFX_PACK_ENTRIES.map((e) => ({
-        ref: e.soundId,
-        role: "sfx",
-        envelopeClass: e.envelopeClass,
-        description: e.description,
-        durationSec: e.durationSec,
-        evidence: { envelopeClass: e.envelopeClass },
-        source: "pack",
-        license: e.source.license,
-        provenance: e.attribution,
-    }));
-}
-/** The pack MUSIC half of the palette (source:"pack", role:"music", carries bpm). */
-function packMusicEntries() {
-    return MUSIC_PACK_ENTRIES.map((e) => ({
-        ref: e.bedId,
-        role: "music",
-        // A bed is an unbounded loop — envelope class "ambient" in the browse grouping.
-        envelopeClass: "ambient",
-        description: e.description,
-        durationSec: e.durationSec,
-        evidence: { envelopeClass: "ambient" },
-        source: "pack",
-        license: e.source.license,
-        provenance: e.attribution,
-        bpm: e.bpm,
-        mood: e.mood,
-    }));
-}
-/** True when a row is a curated-pack org row (minted by the pack import/compose
- *  lanes over shared bytes). Those are ALREADY represented by the pack half of
- *  the palette, so they're excluded from the org half — a placement artifact,
- *  not a distinct library item. */
-function isPackRow(row) {
-    return row.mediaSource === "cueframe-pack";
-}
-/** Project one org audio row → a palette entry. Requires envelope evidence (the
- *  browse grouping key) — a row without it is not yet palette-ready. Returns null
- *  to skip such rows AND minted pack rows. */
-function orgRowToEntry(row) {
-    if (isPackRow(row))
-        return null;
-    const envelope = row.envelope;
-    const role = row.audioRole;
-    // The browse groups by envelope class; a music/ambience bed with a beatGrid but
-    // no envelope still classes as "ambient" (an unbounded bed).
-    const envelopeClass = envelope?.envelopeClass ??
-        (role === "music" || role === "ambience" ? "ambient" : undefined);
-    if (!role || !envelopeClass)
-        return null;
-    const generated = Boolean(row.generator);
-    const source = generated ? "generated" : "org";
-    const license = generated
-        ? "generated"
-        : row.license ?? "org-owned";
-    const provenance = generated
-        ? `${row.generator}${row.generationPrompt ? `: ${row.generationPrompt}` : ""}`
-        : row.license
-            ? `org-owned (${row.license})`
-            : "org-owned";
-    const bpm = row.beatGrid?.bpm;
-    return {
-        ref: row.mediaId,
-        role,
-        envelopeClass,
-        description: row.name ?? row.mediaId,
-        durationSec: row.durationSec ?? 0,
-        evidence: envelope ?? { envelopeClass },
-        source,
-        license,
-        provenance,
-        ...(bpm !== undefined ? { bpm } : {}),
-    };
-}
-/**
- * Assemble the full org sound palette: pack (SFX ∪ music beds) ∪ org-owned ∪
- * generated. Deterministic given the input rows (pack halves are catalog-ordered;
- * org rows keep their input order). Every entry carries source + license +
- * provenance; music entries carry bpm.
- */
-export function assembleAudioPalette(orgAudioRows) {
-    const org = [];
-    for (const row of orgAudioRows) {
-        const e = orgRowToEntry(row);
-        if (e)
-            org.push(e);
-    }
-    return [...packSfxEntries(), ...packMusicEntries(), ...org];
-}
-/**
- * The org-owned SFX subset for the compose org-first draw: every org/generated
- * (NOT pack) sound of role "sfx" that carries an envelope class, in a STABLE
- * order (by mediaId) so the draw is deterministic. The director substitutes one
- * of these for a pack pick when the org has a sound of the requested class — the
- * grounding move (an org that uploads its product's real UI sounds hears ITS
- * product), mirroring how a brand kit overrides the default font.
- */
-export function orgSfxPalette(orgAudioRows) {
-    const out = [];
-    for (const row of orgAudioRows) {
-        if (isPackRow(row))
-            continue;
-        if (row.audioRole !== "sfx")
-            continue;
-        const envelopeClass = row.envelope?.envelopeClass;
-        if (!envelopeClass)
-            continue;
-        out.push({
-            mediaId: row.mediaId,
-            envelopeClass,
-            durationSec: row.durationSec ?? 0,
-            ...(row.filePath ? { filePath: row.filePath } : {}),
-        });
-    }
-    return out.sort((a, b) => a.mediaId.localeCompare(b.mediaId));
-}

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

@@ -1,83 +0,0 @@
-/** CueFrame-owned look presets. The caller picks a name; never the numbers. */
-export const STYLE = {
-    subtle: { zoom: 0.80, prePad: 0.5, postPad: 1.2, minZoom: 1.2, mergeGap: 1.0 },
-    standard: { zoom: 0.67, prePad: 0.4, postPad: 1.0, minZoom: 1.0, mergeGap: 0.8 },
-    punchy: { zoom: 0.55, prePad: 0.3, postPad: 0.8, minZoom: 0.8, mergeGap: 0.6 },
-};
-const median = (xs) => {
-    const s = [...xs].sort((a, b) => a - b);
-    const m = Math.floor(s.length / 2);
-    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
-};
-const neutral = (startSec, endSec) => ({
-    startSec, endSec, intent: "auto-zoom:neutral",
-    focus: { mode: "frame-center" }, zoom: 1.0,
-});
-/** Core: a list of focused (t,x,y) anchors + clip duration → gapless tiling. */
-function tile(anchors, durationSec, t) {
-    if (durationSec <= 0 || anchors.length === 0)
-        return [];
-    const sorted = [...anchors].sort((a, b) => a.t - b.t);
-    // group temporally-adjacent anchors
-    const groups = [];
-    let cur = [sorted[0]];
-    for (let i = 1; i < sorted.length; i++) {
-        if (sorted[i].t - sorted[i - 1].t <= t.mergeGap)
-            cur.push(sorted[i]);
-        else {
-            groups.push(cur);
-            cur = [sorted[i]];
-        }
-    }
-    groups.push(cur);
-    // pad → clamp → drop too-short → median focal point
-    const windows = groups.map((g) => ({
-        start: Math.max(0, g[0].t - t.prePad),
-        end: Math.min(durationSec, g[g.length - 1].t + t.postPad),
-        x: median(g.map((e) => e.x)),
-        y: median(g.map((e) => e.y)),
-    })).filter((w) => w.end - w.start >= t.minZoom);
-    if (windows.length === 0)
-        return [];
-    // merge overlapping padded windows (keep earlier focal point)
-    const merged = [windows[0]];
-    for (let i = 1; i < windows.length; i++) {
-        const prev = merged[merged.length - 1];
-        if (windows[i].start <= prev.end)
-            prev.end = Math.max(prev.end, windows[i].end);
-        else
-            merged.push(windows[i]);
-    }
-    // emit gapless tiling: neutral fills gaps, point punch-ins cover windows
-    const out = [];
-    let cursor = 0;
-    for (const w of merged) {
-        if (w.start > cursor)
-            out.push(neutral(cursor, w.start));
-        out.push({
-            startSec: w.start, endSec: w.end, intent: "auto-zoom:punch-in",
-            focus: { mode: "point", x: w.x, y: w.y }, zoom: t.zoom,
-        });
-        cursor = w.end;
-    }
-    if (cursor < durationSec)
-        out.push(neutral(cursor, durationSec));
-    return out;
-}
-/**
- * Timed focus points (e.g. cursor/click positions — every point a
- * high-confidence anchor) → reframe segments. No detection.
- */
-export function autoZoom(points, durationSec, style = "standard") {
-    return tile(points, durationSec, STYLE[style]);
-}
-/**
- * Pixel-derived activity track → reframe segments. Keeps only focused,
- * low-global-change samples (rejects pan/scroll) before tiling.
- */
-export function autoZoomFromActivity(activity, durationSec, style = "standard", thresholds = {}) {
-    const minC = thresholds.minConcentration ?? 0.6;
-    const maxCh = thresholds.maxChangePct ?? 0.12;
-    const anchors = activity.filter((s) => s.concentration >= minC && s.changePct <= maxCh);
-    return tile(anchors, durationSec, STYLE[style]);
-}

package/dist/_members/composition/brand-kit.js

@@ -1,45 +0,0 @@
-// @cueframe/composition/brand-kit — the editor-side Brand Kit (composition-level fact).
-//
-// Brand is a composition-level fact per the architecture spec ("composition-level
-// facts: format, brand, captions"), so the editor's brand kit lives in the
-// composition contract — imported by Authoring to build context, never reaching
-// into the renderer.
-//
-// Reconciled with the wire `BrandKit` (zod, ./validators/brandKit): the
-// render-relevant overlay assets — `logo`, `intro`, `outro`, `watermark` — are
-// the SAME shapes the wire schema defines, re-used here directly so they project
-// onto the wire/render contract with no lossy re-map. The wire schema is the
-// single source of truth for those fields; the fully-materialized read shape is
-// `ResolvedBrandKit` (./projection). Everything else on this type is the editor's
-// authored INPUT (flat colors / typography the dashboard collects, plus
-// authoring-only metadata that never reaches render — see below).
-// Moved from @cueframe/core/types.ts in Phase-3 Slice 1 (decouple authoring from
-// the renderer): its only consumer is the authoring agent.
-export const DEFAULT_BRAND_KIT = {
-    name: 'CueFrame',
-    description: 'AI-native video editor. Spend less time editing, more time creating stories that matter.',
-    tagline: 'Your Story Deserves Better Than a Timeline',
-    colors: {
-        primary: '#7C3AED',
-        secondary: '#4F46E5',
-        accent: '#7C3AED',
-        background: '#121212',
-        text: '#ffffff',
-    },
-    extraColors: [
-        { hex: '#1a1a1a', label: 'Surface', usage: 'Cards, elevated backgrounds' },
-        { hex: '#262626', label: 'Muted', usage: 'Borders, subtle backgrounds' },
-        { hex: '#a3a3a3', label: 'Muted Text', usage: 'Secondary text, captions' },
-    ],
-    // Vendored families only (`VENDORED_FONT_FAMILIES`): the picker lists exactly
-    // those, and the render sandbox has no font egress, so a default outside the
-    // list is a value the user cannot re-select and a face that rasterizes as
-    // the generic fallback. The previous defaults ('DM Serif Display', 'Geist')
-    // were both.
-    headingFont: { fontFamily: 'Instrument Serif', fontWeight: 400 },
-    bodyFont: { fontFamily: 'Inter', fontWeight: 400 },
-    syncCaptions: false,
-    captionProfile: {},
-    customFonts: [],
-    voiceGuidelines: 'Premium and sophisticated. Focus on storytelling over technical complexity. Approachable but confident. Emphasize the creative process, not the tool. Minimal, clear language.',
-};

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

@@ -1,209 +0,0 @@
-/**
- * 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.js

@@ -1,80 +0,0 @@
-/**
- * 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.js

@@ -1,8 +0,0 @@
-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';
-}