@cueframe/kernel 0.0.1

package/dist/chunk-OIRUO5P7.js

@@ -0,0 +1,397 @@
+import {
+  activeFaceKeepOutSeries,
+  boundingBox,
+  resolveBrandRefsDeep
+} from "./chunk-BRKJKB33.js";
+import {
+  CueframeError,
+  encodeError
+} from "./chunk-37NJ27UU.js";
+
+// ../composition/src/projection/cardTokens.ts
+var CARD_MOTION_VAR_NAMES = [
+  "--cf-frame",
+  "--cf-t",
+  "--cf-fps",
+  "--cf-duration",
+  "--cf-progress",
+  "--cf-ease",
+  "--cf-enter",
+  "--cf-exit"
+];
+var VAR_REF = /var\(\s*(--[A-Za-z0-9_-]+)\s*(,?)/g;
+var VAR_DECL = /(--[A-Za-z0-9_-]+)\s*:/g;
+var MAX_NAMED = 8;
+function collectCards(value, nearestId, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectCards(v, nearestId, out);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  const obj = value;
+  const id = typeof obj.id === "string" ? obj.id : nearestId;
+  if (obj.kind === "card" && typeof obj.html === "string") {
+    const tokens = {};
+    if (obj.tokens !== null && typeof obj.tokens === "object") {
+      for (const [k, v] of Object.entries(obj.tokens)) {
+        if (typeof v === "string") tokens[k] = v;
+      }
+    }
+    out.push({ html: obj.html, tokens, ...id !== void 0 ? { id } : {} });
+    return;
+  }
+  for (const v of Object.values(obj)) collectCards(v, id, out);
+}
+var list = (names) => {
+  const all = [...names];
+  const shown = all.slice(0, MAX_NAMED).map((n) => `\`${n}\``).join(", ");
+  return all.length > MAX_NAMED ? `${shown} (+${all.length - MAX_NAMED} more)` : shown;
+};
+var cards = (n) => `${n} card clip${n === 1 ? "" : "s"}`;
+function detectDroppedBrandTokens(value, kit) {
+  const found = [];
+  collectCards(value, void 0, found);
+  if (found.length === 0) return [];
+  const droppedKeys = /* @__PURE__ */ new Set();
+  const droppedCards = /* @__PURE__ */ new Set();
+  found.forEach((card, i) => {
+    const resolved = kit ? resolveBrandRefsDeep(card.tokens, kit) : card.tokens;
+    for (const [key, v] of Object.entries(resolved)) {
+      if (typeof v === "string" && v.startsWith("$brand:")) {
+        droppedKeys.add(`--cf-${key}`);
+        droppedCards.add(card.id ?? `#${i + 1}`);
+      }
+    }
+  });
+  if (droppedKeys.size === 0) return [];
+  return [
+    `card_brand_tokens_dropped \u2014 ${cards(droppedCards.size)} bind ${list(droppedKeys)} to a \`$brand:\` reference that ${kit ? "this brand kit does not define" : "cannot resolve, because no brand kit is bound"}. \`cssLayoutVars\` drops an unresolved ref, so those custom properties are absent at render and CSS treats them as invalid at computed-value time: the card draws with browser defaults \u2014 16px text, transparent background \u2014 and looks like the styling was ignored. ${kit ? "Bind a key the kit defines" : "Bind a brand kit that defines them"}, or give each reference a literal fallback: \`var(--cf-x, #fff)\`.`
+  ];
+}
+function detectUnresolvedCardTokens(value) {
+  const found = [];
+  collectCards(value, void 0, found);
+  if (found.length === 0) return [];
+  const dashKeys = /* @__PURE__ */ new Set();
+  const dashCards = /* @__PURE__ */ new Set();
+  const missingVars = /* @__PURE__ */ new Set();
+  const missingCards = /* @__PURE__ */ new Set();
+  found.forEach((card, i) => {
+    const label = card.id ?? `#${i + 1}`;
+    const defined = new Set(CARD_MOTION_VAR_NAMES);
+    for (const key of Object.keys(card.tokens)) {
+      defined.add(`--cf-${key}`);
+      if (key.startsWith("--")) {
+        dashKeys.add(key);
+        dashCards.add(label);
+      }
+    }
+    for (const m of card.html.matchAll(VAR_DECL)) defined.add(m[1]);
+    for (const m of card.html.matchAll(VAR_REF)) {
+      if (m[2] === ",") continue;
+      if (defined.has(m[1])) continue;
+      missingVars.add(m[1]);
+      missingCards.add(label);
+    }
+  });
+  const advisories = [];
+  if (dashKeys.size > 0) {
+    advisories.push(
+      `card_token_prefix \u2014 ${cards(dashCards.size)} declare token key(s) ${list(dashKeys)} that already begin with "--". A tokens key \`x\` is projected to the CSS custom property \`--cf-x\`, so \`--p\` becomes \`--cf---p\` and the card's \`var(--p)\` resolves to nothing. Drop the leading dashes \u2014 \`tokens: {"p": "#f00"}\` is read as \`var(--cf-p)\`.`
+    );
+  }
+  if (missingVars.size > 0) {
+    advisories.push(
+      `card_token_unresolved \u2014 ${cards(missingCards.size)} read ${list(missingVars)}, which nothing defines: not a \`--cf-<tokens key>\`, not a card motion var, and not declared in the card's own CSS. CSS treats an undefined custom property as "invalid at computed-value time", so the property falls back silently \u2014 \`background\` to transparent, \`color\` to inherited (usually black) \u2014 and the card renders broken with no error. Bind it through \`tokens\` and read it as \`var(--cf-<key>)\`, or give the reference a fallback: \`var(--x, #fff)\`.`
+    );
+  }
+  return advisories;
+}
+
+// ../composition/src/projection/behind-placement.ts
+var MIN_PRESENCE_FOR_BEHIND = 0.6;
+var BEHIND_BAND = { headLambda: 0.18, widthPad: 1.25 };
+var MAX_ANCHOR_Y = 0.55;
+var MAX_TEXT_WIDTH = 0.95;
+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)
+  };
+}
+
+// ../composition/src/projection/occlusion-budget.ts
+var BUDGET = { minBite: 0.15, maxCoverage: 0.65, maxTopHalf: 0.35 };
+var BEHIND_TEXT_EXTENT = { heightFrac: 0.18 };
+function evaluateOcclusionBudget(samples, opts = { textBearing: true }) {
+  let maxTotal = 0;
+  for (const s of samples) {
+    if (opts.textBearing && s.topHalf > BUDGET.maxTopHalf) {
+      return { verdict: "tops-occluded", worstFrame: s.f };
+    }
+    if (s.total > BUDGET.maxCoverage) {
+      return { verdict: "swallow", worstFrame: s.f };
+    }
+    if (s.total > maxTotal) maxTotal = s.total;
+  }
+  if (maxTotal < BUDGET.minBite) return { verdict: "no-depth" };
+  return { verdict: "pass" };
+}
+function estimateCoverage(textRect, frame) {
+  if (!frame.bbox) return { total: 0, topHalf: 0 };
+  const subject = {
+    x: frame.bbox[0],
+    y: frame.bbox[1],
+    w: frame.bbox[2] - frame.bbox[0],
+    h: frame.bbox[3] - frame.bbox[1]
+  };
+  const total = coverageOfRect(textRect, subject, frame.cols);
+  const topRect = { x: textRect.x, y: textRect.y, w: textRect.w, h: textRect.h / 2 };
+  const topHalf = coverageOfRect(topRect, subject, frame.cols, frame.rows);
+  return { total: clamp01(total), topHalf: clamp01(topHalf) };
+}
+var clamp01 = (v) => Math.max(0, Math.min(1, v));
+function intersect(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.w, b.x + b.w);
+  const y1 = Math.min(a.y + a.h, b.y + b.h);
+  if (x1 <= x0 || y1 <= y0) return null;
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+function meanBuckets(buckets, lo, hi) {
+  const n = buckets.length;
+  if (n === 0 || hi <= lo) return 0;
+  const i0 = Math.max(0, Math.min(n - 1, Math.floor(lo * n)));
+  const i1 = Math.max(0, Math.min(n - 1, Math.ceil(hi * n) - 1));
+  let sum = 0;
+  for (let i = i0; i <= i1; i++) sum += buckets[i];
+  return sum / (i1 - i0 + 1);
+}
+function coverageOfRect(rect, subject, cols, rows) {
+  const rectArea = rect.w * rect.h;
+  if (rectArea <= 0) return 0;
+  const inter = intersect(rect, subject);
+  if (!inter) return 0;
+  const areaFrac = inter.w * inter.h / rectArea;
+  const meanCol = meanBuckets(cols, inter.x, inter.x + inter.w);
+  const rowWeight = rows ? meanBuckets(rows, inter.y, inter.y + inter.h) : 1;
+  return areaFrac * meanCol * rowWeight;
+}
+
+// ../composition/src/projection/cropProjection.ts
+var FRAME_ROUNDING_TOLERANCE = 2;
+function resolveSegmentAt(traj, srcFrame) {
+  for (const seg of traj.segments) {
+    const segStartFrame = Math.round(seg.start_sec * traj.src_fps);
+    const segEndFrame = Math.round(seg.end_sec * traj.src_fps);
+    if (srcFrame >= segStartFrame && srcFrame < segEndFrame) {
+      const inSegIdx = Math.max(0, Math.min(srcFrame - segStartFrame, seg.centers.length - 1));
+      return { seg, inSegIdx };
+    }
+  }
+  if (traj.segments.length === 0) {
+    throw new Error(
+      encodeError(new CueframeError("trajectory_unresolved", "trajectory has no segments"))
+    );
+  }
+  let best = traj.segments[0];
+  let bestInIdx = 0;
+  let bestDist = Infinity;
+  for (const seg of traj.segments) {
+    const a = Math.round(seg.start_sec * traj.src_fps);
+    const b = Math.round(seg.end_sec * traj.src_fps);
+    const before = srcFrame < a;
+    const dist = before ? a - srcFrame : srcFrame - (b - 1);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = seg;
+      bestInIdx = before ? 0 : Math.max(0, seg.centers.length - 1);
+    }
+  }
+  if (bestDist > FRAME_ROUNDING_TOLERANCE) {
+    throw new Error(
+      encodeError(
+        new CueframeError(
+          "trajectory_coverage_gap",
+          `srcFrame ${srcFrame} is ${bestDist} frames outside every trajectory segment (nearest [${best.start_sec.toFixed(2)}\u2013${best.end_sec.toFixed(2)}s]). A coverage/mapping bug (a cropIntent gap with no excludedRange, or an output\u2192trajectory frame mismatch) \u2014 refusing to silently clamp a crop onto the wrong frames.`,
+          { srcFrame, gapFrames: bestDist, nearest: [best.start_sec, best.end_sec] }
+        )
+      )
+    );
+  }
+  return { seg: best, inSegIdx: Math.max(0, Math.min(bestInIdx, best.centers.length - 1)) };
+}
+function outputToTrajectoryFrame(sections, trimStartFrames, outFrame, srcFps, fps) {
+  let cum = 0;
+  for (const s of sections) {
+    if (outFrame < cum + s.durationInFrames) {
+      const clipFramesAtFps2 = s.sourceInFrames - trimStartFrames + (outFrame - cum);
+      return Math.round(clipFramesAtFps2 * srcFps / fps);
+    }
+    cum += s.durationInFrames;
+  }
+  const last = sections[sections.length - 1];
+  const clipFramesAtFps = last.sourceInFrames - trimStartFrames + (last.durationInFrames - 1);
+  return Math.round(clipFramesAtFps * srcFps / fps);
+}
+function computeCropTransform(input) {
+  const {
+    traj,
+    outW,
+    outH,
+    cx,
+    cy,
+    zoomScale,
+    verticalBias,
+    lateralBias,
+    reframe = { kind: "transform", dy: 0, zoom: 1 }
+  } = input;
+  const reframeDy = reframe.kind === "transform" ? reframe.dy : 0;
+  const faceScale = reframe.kind === "transform" ? reframe.zoom : 1;
+  const outAR = outW / outH;
+  const srcAR = traj.src_w / traj.src_h;
+  let cropW;
+  let cropH;
+  if (srcAR > outAR) {
+    cropH = traj.src_h;
+    cropW = traj.src_h * outAR;
+  } else {
+    cropW = traj.src_w;
+    cropH = traj.src_w / outAR;
+  }
+  const bakedZoom = Math.max(0.4, Math.min(1, zoomScale));
+  const effectiveZoom = Math.min(1, bakedZoom / Math.max(faceScale, 0.01));
+  cropW *= effectiveZoom;
+  cropH *= effectiveZoom;
+  const scale = outW / cropW;
+  const scaledSrcW = traj.src_w * scale;
+  const scaledSrcH = traj.src_h * scale;
+  const biasXPx = cropW * lateralBias * scale;
+  const biasYPx = cropH * verticalBias * scale;
+  const txRaw = outW / 2 - cx * scaledSrcW + biasXPx;
+  const tyNoShift = outH / 2 - cy * scaledSrcH + biasYPx;
+  const tyRaw = tyNoShift + reframeDy * outH;
+  const tx = Math.min(0, Math.max(outW - scaledSrcW, txRaw));
+  const ty = Math.min(0, Math.max(outH - scaledSrcH, tyRaw));
+  return { tx, ty, tyNoShift, scaledSrcW, scaledSrcH };
+}
+function sourceRectToOutput(src, t, outW, outH) {
+  return {
+    x: (t.tx + src.x * t.scaledSrcW) / outW,
+    y: (t.ty + src.y * t.scaledSrcH) / outH,
+    w: src.w * t.scaledSrcW / outW,
+    h: src.h * t.scaledSrcH / outH
+  };
+}
+function buildSubjectsOutput(args) {
+  const { traj, sections, trimStartFrames, durationInFrames, outW, outH, fps } = args;
+  const series = /* @__PURE__ */ new Map();
+  const activeBySubject = /* @__PURE__ */ new Map();
+  const order = [];
+  const emptySeries = () => Array(durationInFrames).fill(null);
+  for (let f = 0; f < durationInFrames; f++) {
+    const srcFrame = outputToTrajectoryFrame(sections, trimStartFrames, f, traj.src_fps, fps);
+    const { seg, inSegIdx } = resolveSegmentAt(traj, srcFrame);
+    const [cx, cy] = seg.centers[inSegIdx];
+    const transform = computeCropTransform({
+      traj: { src_w: traj.src_w, src_h: traj.src_h },
+      outW,
+      outH,
+      cx,
+      cy,
+      zoomScale: seg.zoom_scale,
+      verticalBias: seg.vertical_bias,
+      lateralBias: seg.lateral_bias
+    });
+    for (const subj of seg.subjects) {
+      if (!series.has(subj.face_id)) {
+        series.set(subj.face_id, emptySeries());
+        activeBySubject.set(subj.face_id, subj.active_windows ?? []);
+        order.push(subj.face_id);
+      }
+      const srcBox = subj.face_box_series[inSegIdx];
+      if (!srcBox) continue;
+      const [x, y, w, h] = srcBox;
+      series.get(subj.face_id)[f] = sourceRectToOutput({ x, y, w, h }, transform, outW, outH);
+    }
+  }
+  return order.map((id) => ({
+    id,
+    faceBoxSeries: series.get(id),
+    activeWindows: (activeBySubject.get(id) ?? []).map(([startFrame, endFrame]) => ({ startFrame, endFrame }))
+  }));
+}
+function faceKeepOutForWindow(subjects, startFrame, endFrame, depthMode = false) {
+  const series = activeFaceKeepOutSeries(subjects, depthMode);
+  const inWindow = series.slice(Math.max(0, startFrame), Math.max(0, endFrame)).filter((r) => r != null);
+  return inWindow.length ? [boundingBox(inWindow)] : [];
+}
+function buildSilhouetteKeepOutOutput(args) {
+  const { traj, silhouette, sections, trimStartFrames, durationInFrames, outW, outH, fps } = args;
+  const series = new Array(durationInFrames).fill(null);
+  for (let f = 0; f < durationInFrames; f++) {
+    const srcFrame = outputToTrajectoryFrame(sections, trimStartFrames, f, traj.src_fps, fps);
+    const srcBox = silhouette.bboxAtSourceFrame(srcFrame);
+    if (!srcBox) continue;
+    const { seg, inSegIdx } = resolveSegmentAt(traj, srcFrame);
+    const [cx, cy] = seg.centers[inSegIdx];
+    const transform = computeCropTransform({
+      traj: { src_w: traj.src_w, src_h: traj.src_h },
+      outW,
+      outH,
+      cx,
+      cy,
+      zoomScale: seg.zoom_scale,
+      verticalBias: seg.vertical_bias,
+      lateralBias: seg.lateral_bias
+    });
+    const out = sourceRectToOutput(srcBox, transform, outW, outH);
+    const x = Math.max(0, Math.min(1, out.x));
+    const y = Math.max(0, Math.min(1, out.y));
+    const right = Math.max(0, Math.min(1, out.x + out.w));
+    const bot = Math.max(0, Math.min(1, out.y + out.h));
+    series[f] = { x, y, w: Math.max(0, right - x), h: Math.max(0, bot - y) };
+  }
+  return series;
+}
+function silhouetteKeepOutForWindow(series, startFrame, endFrame) {
+  const inWindow = series.slice(Math.max(0, startFrame), Math.max(0, endFrame)).filter((r) => r != null && r.w > 0 && r.h > 0);
+  return inWindow.length ? [boundingBox(inWindow)] : [];
+}
+
+export {
+  CARD_MOTION_VAR_NAMES,
+  detectDroppedBrandTokens,
+  detectUnresolvedCardTokens,
+  MIN_PRESENCE_FOR_BEHIND,
+  BEHIND_BAND,
+  deriveBehindAnchor,
+  BUDGET,
+  BEHIND_TEXT_EXTENT,
+  evaluateOcclusionBudget,
+  estimateCoverage,
+  FRAME_ROUNDING_TOLERANCE,
+  resolveSegmentAt,
+  outputToTrajectoryFrame,
+  computeCropTransform,
+  sourceRectToOutput,
+  buildSubjectsOutput,
+  faceKeepOutForWindow,
+  buildSilhouetteKeepOutOutput,
+  silhouetteKeepOutForWindow
+};

package/dist/chunk-P43IE4WB.js

@@ -0,0 +1,181 @@
+import {
+  resolveTypeface
+} from "./chunk-BDMTUEEZ.js";
+import {
+  resolveContrast
+} from "./chunk-EMGFZ3PR.js";
+import {
+  fadeProgress,
+  resolveEasing,
+  staggerUp,
+  wordPop
+} from "./chunk-ZFEXATWN.js";
+import {
+  resolveFitFontSize
+} from "./chunk-DSNG6WLU.js";
+import {
+  fitTextOnNLines
+} from "./chunk-YA3OR2KK.js";
+
+// ../execution/primitives/src/hero-text/HeroText.tsx
+import { useCurrentFrame, useVideoConfig } from "remotion";
+var REVEAL_WINDOW_MS = 240;
+function HeroText({
+  text,
+  fontSizePct,
+  revealAtMs,
+  durationMs,
+  easing,
+  entrance,
+  textColor,
+  fontFamily,
+  fontWeight
+}) {
+  const frame = useCurrentFrame();
+  const { fps, height, width } = useVideoConfig();
+  const designFontSize = Math.round(height * (fontSizePct ?? 14) / 100);
+  const resolvedFontFamily = fontFamily ?? resolveTypeface("display");
+  const resolvedFontWeight = fontWeight ?? 800;
+  const HERO_MAX_WIDTH = 1700;
+  const maxBoxWidth = Math.min(width, HERO_MAX_WIDTH);
+  let singleLineFit = designFontSize;
+  if (text.trim().length > 0) {
+    try {
+      const { fontSize: fit } = fitTextOnNLines({
+        text,
+        maxLines: 2,
+        maxBoxWidth,
+        fontFamily: resolvedFontFamily,
+        fontWeight: resolvedFontWeight,
+        letterSpacing: "-0.02em",
+        maxFontSize: designFontSize,
+        validateFontIsLoaded: false
+      });
+      singleLineFit = fit;
+    } catch {
+      singleLineFit = designFontSize;
+    }
+  }
+  const { fontSize } = resolveFitFontSize({
+    singleLineFitFontSize: singleLineFit,
+    minFontSize: Math.round(designFontSize * 0.55),
+    maxFontSize: designFontSize
+  });
+  const tMs = frame / fps * 1e3;
+  const hasReveal = revealAtMs != null && revealAtMs.length > 0;
+  const words = text.split(/\s+/).filter(Boolean);
+  const mode = entrance ?? "fade";
+  const ease = resolveEasing(easing);
+  const windowMs = durationMs ?? REVEAL_WINDOW_MS;
+  const windowFrames = Math.max(1, Math.round(windowMs / 1e3 * fps));
+  const entranceOf = (i) => {
+    if (!hasReveal || mode === "none") return { opacity: 1, ty: 0, scale: 1 };
+    const startFrame = Math.round((revealAtMs[i] ?? 0) / 1e3 * fps);
+    if (mode === "word-pop") {
+      const { opacity, scale } = wordPop(frame, fps, startFrame, windowFrames, 0.92);
+      return { opacity, ty: 0, scale };
+    }
+    if (mode === "stagger-up") {
+      const local = frame - startFrame;
+      const { opacity, y } = staggerUp(local, 0, 0, windowFrames, fontSize * 0.25);
+      return { opacity: ease(opacity), ty: y, scale: 1 };
+    }
+    const k = ease(fadeProgress(tMs, revealAtMs[i] ?? 0, windowMs));
+    return { opacity: k, ty: (1 - k) * fontSize * 0.25, scale: 1 };
+  };
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexWrap: "wrap",
+        justifyContent: "center",
+        gap: "0.28em",
+        fontSize,
+        fontWeight: fontWeight ?? 800,
+        letterSpacing: "-0.02em",
+        // behind-subject host: a real off-white color, NO contrast shadow — the
+        // subject silhouette biting the letters supplies the depth.
+        color: textColor ?? resolveContrast({ behindSubject: true }).textColor,
+        fontFamily: fontFamily ?? resolveTypeface("display")
+      }
+    },
+    words.map((word, i) => {
+      const { opacity, ty, scale } = entranceOf(i);
+      const animating = opacity < 1 || ty !== 0 || scale !== 1;
+      return /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          key: i,
+          style: {
+            display: "inline-block",
+            ...animating ? { opacity, transform: `translateY(${ty}px) scale(${scale})` } : {}
+          }
+        },
+        word
+      );
+    })
+  );
+}
+
+// ../execution/primitives/src/hero-text/config.ts
+import { z } from "zod";
+var paramsSchema = z.object({
+  text: z.string().min(1).max(220).describe("Short bold phrase \u2014 product name, value prop, or the number that lands. 2\u20135 words. Auto-fits (shrinks + wraps to 2 lines)."),
+  fontSizePct: z.number().positive().optional().describe("Font size as % of composition height. Default 14 (display scale)."),
+  revealAtMs: z.array(z.number()).optional().describe("Per-word reveal offsets in ms relative to overlay start (authored from word timings/beats). Absent \u2192 static."),
+  durationMs: z.coerce.number().positive().optional().describe("Per-word reveal window in ms. Bind to $brand:motion.duration."),
+  easing: z.string().optional().describe("Easing keyword for the per-word reveal (linear/ease/ease-in/ease-out/ease-in-out). Bind to $brand:motion.easing."),
+  entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional().describe("Per-word entrance treatment. Default fade (the hero reveal). Bind to $brand:motion.entrance so the brand drives the motion identity."),
+  fontWeight: z.number().optional().describe("Default 800 (display weight)."),
+  textColor: z.string().default(resolveContrast({ behindSubject: true }).textColor).describe("Text color; defaults to a video-safe off-white. Bind to $brand:colors.textOnMedia."),
+  fontFamily: z.string().default(resolveTypeface("display")).describe("Display family; defaults to the brand display face (Bricolage Grotesque floor). Bind to $brand:fonts.heading.family.")
+}).passthrough();
+var config = {
+  id: "heroText",
+  component: HeroText,
+  name: "Hero Text",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "reveal-text",
+  description: "Launch-grade display text for the text-behind-subject depth grammar: display weight, negative tracking at display sizes, per-word staggered entrance from beat timings. The subject silhouette bites the letters.",
+  useWhen: 'Behind-subject hero moments \u2014 the product name, value prop, or a number that lands ("498 REJECTIONS", "WE SHIP DAILY"). Authored as a behind-subject overlay; the system world-locks + places it on the silhouette. 2\u20135 words.',
+  pairsWith: ["subject-foreground"],
+  avoidWith: ["karaoke", "kinetic-type"],
+  tier: "standard",
+  useCase: ["full-scene", "title-over-footage"],
+  tags: ["text", "hero", "display", "behind-subject", "launch"],
+  mood: ["editorial", "cinematic", "aggressive"],
+  paramsSchema,
+  propDefaults: {},
+  examples: [
+    {
+      name: "rejections-stat",
+      mood: ["editorial", "aggressive"],
+      params: { text: "498 REJECTIONS", fontSizePct: 8 }
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "textColor", cssVar: "--cf-text-onmedia", fallback: resolveContrast({ behindSubject: true }).textColor, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" },
+    { propPath: "durationMs", cssVar: "--cf-motion-dur", fallback: "240", brandKitPath: "motion.duration" },
+    { propPath: "easing", cssVar: "--cf-motion-ease", fallback: "ease-out", brandKitPath: "motion.easing" },
+    { propPath: "entrance", cssVar: "--cf-motion-entrance", fallback: "fade", brandKitPath: "motion.entrance" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1080,
+  height: 1920,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "rejections-stat" }
+};
+
+// ../execution/primitives/src/hero-text/index.ts
+var catalog = [config];
+
+export {
+  HeroText,
+  catalog
+};

package/dist/chunk-QGAWDLYX.js

@@ -0,0 +1,92 @@
+// ../execution/primitives/src/transitions/frosted-glass-wipe/index.tsx
+import React from "react";
+import { Easing, interpolate } from "remotion";
+var FrostedGlassWipePresentation = ({ children, presentationDirection, presentationProgress, passedProps }) => {
+  const { glassBlur = 24 } = passedProps;
+  const isEntering = presentationDirection === "entering";
+  const p = interpolate(presentationProgress, [0, 1], [0, 1], {
+    easing: Easing.bezier(0.6, 0, 0.2, 1)
+  });
+  const visible = isEntering ? p >= 0.5 : p < 0.5;
+  const glassX = interpolate(p, [0, 1], [-110, 110]);
+  return /* @__PURE__ */ React.createElement("div", { style: { position: "absolute", inset: 0, overflow: "hidden" } }, /* @__PURE__ */ React.createElement("div", { style: { position: "absolute", inset: 0, opacity: visible ? 1 : 0 } }, children), isEntering && /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        top: 0,
+        bottom: 0,
+        left: 0,
+        width: "100%",
+        transform: `translateX(${glassX}%)`,
+        backdropFilter: `blur(${glassBlur}px)`,
+        WebkitBackdropFilter: `blur(${glassBlur}px)`,
+        background: "rgba(255,255,255,0.05)",
+        borderLeft: "1px solid rgba(255,255,255,0.2)",
+        borderRight: "1px solid rgba(255,255,255,0.2)",
+        willChange: "transform"
+      }
+    }
+  ));
+};
+var frostedGlassWipe = (props) => ({
+  component: FrostedGlassWipePresentation,
+  props: props ?? {}
+});
+var FrostedGlassWipe = FrostedGlassWipePresentation;
+
+// ../execution/primitives/src/transitions/spatial-push/index.tsx
+import React2 from "react";
+import { interpolate as interpolate2 } from "remotion";
+var SpatialPushPresentation = ({ children, presentationDirection, presentationProgress, passedProps }) => {
+  const { direction = "up" } = passedProps;
+  const p = presentationProgress;
+  if (presentationDirection === "exiting") {
+    const scale = interpolate2(p, [0, 1], [1, 0.92]);
+    const brightness = interpolate2(p, [0, 1], [1, 0.5]);
+    const radius = interpolate2(p, [0, 1], [0, 16]);
+    return /* @__PURE__ */ React2.createElement(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          transform: `scale(${scale})`,
+          filter: `brightness(${brightness})`,
+          borderRadius: `${radius}px`,
+          overflow: "hidden",
+          willChange: "transform"
+        }
+      },
+      children
+    );
+  }
+  const t = (1 - p) * 100;
+  const transform = direction === "up" ? `translateY(${t}%)` : direction === "down" ? `translateY(${-t}%)` : direction === "left" ? `translateX(${t}%)` : `translateX(${-t}%)`;
+  const shadow = direction === "up" ? "0 -40px 100px rgba(0,0,0,0.8)" : direction === "down" ? "0 40px 100px rgba(0,0,0,0.8)" : direction === "left" ? "-40px 0 100px rgba(0,0,0,0.8)" : "40px 0 100px rgba(0,0,0,0.8)";
+  return /* @__PURE__ */ React2.createElement(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        inset: 0,
+        transform,
+        boxShadow: shadow,
+        willChange: "transform"
+      }
+    },
+    children
+  );
+};
+var spatialPush = (props) => ({
+  component: SpatialPushPresentation,
+  props: props ?? {}
+});
+var SpatialPush = SpatialPushPresentation;
+
+export {
+  frostedGlassWipe,
+  FrostedGlassWipe,
+  spatialPush,
+  SpatialPush
+};