@cueframe/kernel 0.0.1

package/dist/chunk-WZTTZHNR.js

@@ -0,0 +1,3339 @@
+import {
+  recolor
+} from "./chunk-DLF4WVSE.js";
+import {
+  TextStage
+} from "./chunk-U4V4FZGE.js";
+import {
+  resolveTypeface
+} from "./chunk-BDMTUEEZ.js";
+import {
+  FLOOR_SHADOW,
+  FLOOR_TEXT,
+  resolveContrast
+} from "./chunk-EMGFZ3PR.js";
+import {
+  resolveEasing,
+  staggerRise,
+  staggerUp
+} from "./chunk-ZFEXATWN.js";
+import {
+  FitText,
+  resolveFitFontSize
+} from "./chunk-DSNG6WLU.js";
+import {
+  fitTextOnNLines
+} from "./chunk-YA3OR2KK.js";
+import {
+  ACCENT,
+  ACCENT_STRONG,
+  BG,
+  BLUE,
+  DANGER,
+  SUCCESS,
+  SURFACE,
+  TEAL,
+  TEXT_HI,
+  TEXT_MUTED,
+  VIOLET,
+  WARNING
+} from "./chunk-CX2IIQ4R.js";
+
+// ../execution/primitives/src/text/blur-reveal/index.tsx
+import { interpolate, useCurrentFrame, useVideoConfig } from "remotion";
+var BLUR_REVEAL_TEXT_WIDTH = 1500;
+function BlurReveal({
+  text,
+  blur = 10,
+  fontSize = 48,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 600,
+  speed = 1
+}) {
+  const frame = useCurrentFrame() * speed;
+  const { durationInFrames } = useVideoConfig();
+  const opacity = interpolate(frame, [0, durationInFrames * 0.6], [0, 1], {
+    extrapolateRight: "clamp"
+  });
+  const blurAmount = interpolate(
+    frame,
+    [0, durationInFrames * 0.6],
+    [blur, 0],
+    { extrapolateRight: "clamp" }
+  );
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    FitText,
+    {
+      maxFontSize: fontSize,
+      maxWidth: BLUR_REVEAL_TEXT_WIDTH,
+      maxLines: 2,
+      fontFamily,
+      fontWeight,
+      letterSpacing: "-0.05em",
+      style: {
+        opacity,
+        filter: `blur(${blurAmount}px)`,
+        color,
+        textShadow: resolveContrast().textShadow,
+        textAlign: "center"
+      }
+    },
+    text
+  ));
+}
+
+// ../execution/primitives/src/text/cinematic-title/index.tsx
+import React2 from "react";
+import { useCurrentFrame as useCurrentFrame2, useVideoConfig as useVideoConfig2, spring, interpolate as interpolate2, AbsoluteFill } from "remotion";
+var TITLE_TEXT_WIDTH = 1600;
+var CinematicTitle = ({
+  text,
+  subtitle,
+  variant = "default",
+  position = "center",
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame2();
+  const { fps, height, durationInFrames } = useVideoConfig2();
+  const {
+    fontFamily = resolveTypeface("display"),
+    fontSize: baseFontSize = 72,
+    subtextFontSize = 18,
+    textColor = FLOOR_TEXT,
+    accentColor = WARNING,
+    letterSpacing: baseLetterSpacing = 6
+  } = tokens;
+  const barHeight = height * 0.13;
+  const barSlide = interpolate2(frame, [0, 20], [barHeight, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const exitStart = durationInFrames - 20;
+  const exitOpacity = interpolate2(
+    frame,
+    [exitStart, durationInFrames],
+    [1, 0],
+    { extrapolateLeft: "clamp", extrapolateRight: "clamp" }
+  );
+  let textOpacity;
+  let textScale;
+  let textBlur;
+  let fontSize;
+  let fontWeight;
+  let currentLetterSpacing;
+  if (variant === "zoom") {
+    const enterSpring = spring({ fps, frame, config: { damping: 12, stiffness: 80 } });
+    textOpacity = interpolate2(frame, [10, 30], [0, 1], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp"
+    });
+    textScale = interpolate2(enterSpring, [0, 1], [2.5, 1]);
+    textBlur = interpolate2(frame, [10, 35], [12, 0], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp"
+    });
+    fontSize = baseFontSize;
+    fontWeight = 700;
+    currentLetterSpacing = baseLetterSpacing;
+  } else if (variant === "bold") {
+    const enterSpring = spring({ fps, frame: Math.max(0, frame - 5), config: { damping: 14, stiffness: 100 } });
+    textOpacity = interpolate2(enterSpring, [0, 1], [0, 1]);
+    textScale = interpolate2(enterSpring, [0, 1], [1.4, 1]);
+    textBlur = 0;
+    fontSize = Math.round(baseFontSize * 1.3);
+    fontWeight = 900;
+    currentLetterSpacing = baseLetterSpacing;
+  } else {
+    textOpacity = interpolate2(frame, [18, 40], [0, 1], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp"
+    });
+    currentLetterSpacing = interpolate2(frame, [18, 45], [20, baseLetterSpacing], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp"
+    });
+    textScale = 1;
+    textBlur = 0;
+    fontSize = baseFontSize;
+    fontWeight = 700;
+  }
+  const subtextOpacity = interpolate2(frame, [35, 55], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const justifyContent = position === "top" ? "flex-start" : position === "bottom" ? "flex-end" : "center";
+  const padding = position === "center" ? 0 : barHeight + 48;
+  const textShadow = resolveContrast().textShadow;
+  const barStyle = {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    height: barHeight,
+    backgroundColor: BG,
+    zIndex: 2
+  };
+  return /* @__PURE__ */ React2.createElement(AbsoluteFill, { style: { backgroundColor: "transparent", opacity: exitOpacity } }, /* @__PURE__ */ React2.createElement("div", { style: { ...barStyle, top: 0, transform: `translateY(-${barSlide}px)` } }), /* @__PURE__ */ React2.createElement("div", { style: { ...barStyle, bottom: 0, transform: `translateY(${barSlide}px)` } }), /* @__PURE__ */ React2.createElement(
+    AbsoluteFill,
+    {
+      style: {
+        justifyContent,
+        alignItems: "center",
+        zIndex: 1,
+        paddingTop: padding,
+        paddingBottom: padding
+      }
+    },
+    /* @__PURE__ */ React2.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          textAlign: "center",
+          opacity: textOpacity,
+          transform: `scale(${textScale})`,
+          filter: textBlur > 0 ? `blur(${textBlur}px)` : "none"
+        }
+      },
+      /* @__PURE__ */ React2.createElement(
+        FitText,
+        {
+          maxFontSize: fontSize,
+          maxWidth: TITLE_TEXT_WIDTH,
+          fontFamily,
+          fontWeight,
+          letterSpacing: `${baseLetterSpacing}px`,
+          textTransform: "uppercase",
+          style: {
+            color: textColor,
+            textShadow,
+            textAlign: "center",
+            letterSpacing: `${currentLetterSpacing}px`
+          }
+        },
+        text
+      ),
+      subtitle ? /* @__PURE__ */ React2.createElement(
+        FitText,
+        {
+          maxFontSize: subtextFontSize,
+          maxWidth: TITLE_TEXT_WIDTH,
+          maxLines: 2,
+          fontFamily,
+          fontWeight: 300,
+          letterSpacing: "3px",
+          textTransform: "uppercase",
+          style: {
+            marginTop: 16,
+            color: accentColor,
+            textShadow,
+            opacity: subtextOpacity,
+            textAlign: "center"
+          }
+        },
+        subtitle
+      ) : null
+    )
+  ));
+};
+
+// ../execution/primitives/src/text/inline-highlight/index.tsx
+import { interpolate as interpolate3, useCurrentFrame as useCurrentFrame3, useVideoConfig as useVideoConfig3 } from "remotion";
+function InlineHighlight({
+  before,
+  highlight,
+  after = "",
+  baseColor = FLOOR_TEXT,
+  highlightColor = ACCENT_STRONG,
+  fontFamily = resolveTypeface("display"),
+  fontSize = 48,
+  fontWeight = 600,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame3() * speed;
+  const { durationInFrames } = useVideoConfig3();
+  const progress = interpolate3(
+    frame,
+    [durationInFrames * 0.2, durationInFrames * 0.7],
+    [0, 1],
+    { extrapolateLeft: "clamp", extrapolateRight: "clamp" }
+  );
+  const color = recolor(progress, baseColor, highlightColor);
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize,
+        fontWeight,
+        color: baseColor,
+        letterSpacing: "-0.03em",
+        fontFamily,
+        textShadow: resolveContrast().textShadow
+      }
+    },
+    before,
+    /* @__PURE__ */ React.createElement("span", { style: { color } }, highlight),
+    after
+  ));
+}
+
+// ../execution/primitives/src/text/karaoke/index.tsx
+import React3 from "react";
+import { useCurrentFrame as useCurrentFrame4, useVideoConfig as useVideoConfig4, spring as spring2, interpolate as interpolate4, AbsoluteFill as AbsoluteFill2 } from "remotion";
+var Karaoke = ({
+  words,
+  position = "center",
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame4();
+  const { fps, durationInFrames } = useVideoConfig4();
+  const {
+    fontFamily = resolveTypeface("caption"),
+    fontSize = 56,
+    textColor = FLOOR_TEXT,
+    activeColor = ACCENT,
+    activeScale = 1.15
+  } = tokens;
+  const currentTimeMs = frame / fps * 1e3;
+  const fadeOut = interpolate4(
+    frame,
+    [durationInFrames - 15, durationInFrames],
+    [1, 0],
+    { extrapolateLeft: "clamp", extrapolateRight: "clamp" }
+  );
+  const justifyContent = position === "center" ? "center" : position === "right" ? "flex-end" : "flex-start";
+  const alignItems = position === "bottom" ? "flex-end" : position === "center" ? "center" : position === "right" ? "flex-end" : "flex-start";
+  return /* @__PURE__ */ React3.createElement(
+    AbsoluteFill2,
+    {
+      style: {
+        justifyContent: position === "bottom" ? "flex-end" : "center",
+        alignItems,
+        padding: 60,
+        paddingBottom: position === "bottom" ? 120 : 60
+      }
+    },
+    /* @__PURE__ */ React3.createElement("div", { style: { opacity: fadeOut } }, /* @__PURE__ */ React3.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexWrap: "wrap",
+          justifyContent,
+          gap: "4px 12px"
+        }
+      },
+      words.map((word, i) => {
+        const isActive = currentTimeMs >= word.startMs && currentTimeMs < word.endMs;
+        const isPast = currentTimeMs >= word.endMs;
+        const isFuture = currentTimeMs < word.startMs;
+        const activeFrame = isActive ? Math.round((currentTimeMs - word.startMs) / 1e3 * fps) : 0;
+        const scaleSpr = isActive ? spring2({
+          fps,
+          frame: activeFrame,
+          config: { damping: 14, stiffness: 200 }
+        }) : isPast ? 1 : 0;
+        const scale = isActive ? interpolate4(scaleSpr, [0, 1], [1, activeScale]) : 1;
+        const opacity = isFuture ? 0.4 : 1;
+        const color = isActive ? activeColor : textColor;
+        return /* @__PURE__ */ React3.createElement(
+          "span",
+          {
+            key: i,
+            style: {
+              fontSize,
+              fontWeight: isActive ? 800 : 600,
+              fontFamily,
+              color,
+              opacity,
+              transform: `scale(${scale})`,
+              display: "inline-block",
+              transition: "color 0.1s",
+              textShadow: FLOOR_SHADOW
+            }
+          },
+          word.text
+        );
+      })
+    ))
+  );
+};
+
+// ../execution/primitives/src/text/kinetic-type/index.tsx
+import React4 from "react";
+import { useCurrentFrame as useCurrentFrame5, useVideoConfig as useVideoConfig5, spring as spring3, interpolate as interpolate5, AbsoluteFill as AbsoluteFill3 } from "remotion";
+var PHRASE_TEXT_WIDTH = 1600;
+var KineticType = ({
+  text,
+  animation = "fly-in",
+  position = "center",
+  accentColor = ACCENT,
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame5();
+  const { fps, durationInFrames } = useVideoConfig5();
+  const {
+    fontFamily = resolveTypeface("display"),
+    fontSize = 110,
+    textColor = FLOOR_TEXT
+  } = tokens;
+  const words = text.split(" ").filter(Boolean);
+  const staggerFrames = 4;
+  const fittedFontSize = React4.useMemo(() => {
+    if (text.trim().length === 0) return fontSize;
+    try {
+      const { fontSize: fit } = fitTextOnNLines({
+        text,
+        maxLines: 2,
+        maxBoxWidth: PHRASE_TEXT_WIDTH,
+        fontFamily,
+        fontWeight: 700,
+        maxFontSize: fontSize,
+        validateFontIsLoaded: false
+      });
+      return resolveFitFontSize({
+        singleLineFitFontSize: fit,
+        minFontSize: Math.round(fontSize * 0.55),
+        maxFontSize: fontSize
+      }).fontSize;
+    } catch {
+      return fontSize;
+    }
+  }, [text, fontFamily, fontSize]);
+  const fadeOut = interpolate5(
+    frame,
+    [durationInFrames - 15, durationInFrames],
+    [1, 0],
+    { extrapolateLeft: "clamp", extrapolateRight: "clamp" }
+  );
+  const justifyContent = position === "center" ? "center" : position === "right" ? "flex-end" : "flex-start";
+  const getWordStyle = (index) => {
+    const delay = index * staggerFrames;
+    const spr = spring3({
+      fps,
+      frame: Math.max(0, frame - delay),
+      config: animation === "scale-bounce" ? { damping: 9, stiffness: 130, mass: 0.7 } : { damping: 12, stiffness: 110, mass: 0.8 }
+    });
+    const opacity = interpolate5(spr, [0, 0.3], [0, 1], {
+      extrapolateRight: "clamp"
+    });
+    switch (animation) {
+      case "fly-in": {
+        const translateY = interpolate5(spr, [0, 1], [130, 0]);
+        const blur = interpolate5(spr, [0, 0.7], [7, 0], { extrapolateRight: "clamp" });
+        const scale = interpolate5(spr, [0, 1], [0.92, 1]);
+        return { opacity, filter: `blur(${blur}px)`, transform: `translateY(${translateY}px) scale(${scale})` };
+      }
+      case "rotate": {
+        const rotate = interpolate5(spr, [0, 1], [-24, 0]);
+        const translateY = interpolate5(spr, [0, 1], [70, 0]);
+        return {
+          opacity,
+          transform: `translateY(${translateY}px) rotate(${rotate}deg)`,
+          transformOrigin: "bottom left"
+        };
+      }
+      case "scale-bounce": {
+        const scale = interpolate5(spr, [0, 1], [0.2, 1]);
+        return { opacity, transform: `scale(${scale})` };
+      }
+      case "cascade": {
+        const translateY = interpolate5(spr, [0, 1], [-150, 0]);
+        const blur = interpolate5(spr, [0, 0.7], [7, 0], { extrapolateRight: "clamp" });
+        return { opacity, filter: `blur(${blur}px)`, transform: `translateY(${translateY}px)` };
+      }
+      default:
+        return { opacity };
+    }
+  };
+  return /* @__PURE__ */ React4.createElement(
+    AbsoluteFill3,
+    {
+      style: {
+        justifyContent: "center",
+        alignItems: position === "center" ? "center" : position === "right" ? "flex-end" : "flex-start",
+        padding: 60
+      }
+    },
+    /* @__PURE__ */ React4.createElement(
+      "div",
+      {
+        style: {
+          opacity: fadeOut,
+          // Idle life: the settled phrase breathes imperceptibly.
+          transform: `scale(${1 + Math.sin(2 * Math.PI * 0.06 * frame / fps) * 8e-3})`
+        }
+      },
+      /* @__PURE__ */ React4.createElement(
+        "div",
+        {
+          style: {
+            display: "flex",
+            flexWrap: "wrap",
+            justifyContent,
+            gap: "0 14px"
+          }
+        },
+        words.map((word, i) => /* @__PURE__ */ React4.createElement(
+          "span",
+          {
+            key: i,
+            style: {
+              fontSize: fittedFontSize,
+              fontWeight: 800,
+              fontFamily,
+              color: accentColor && i === words.length - 1 ? accentColor : textColor,
+              display: "inline-block",
+              textShadow: FLOOR_SHADOW,
+              ...getWordStyle(i)
+            }
+          },
+          word
+        ))
+      )
+    )
+  );
+};
+
+// ../execution/primitives/src/text/lower-third/index.tsx
+import React5 from "react";
+import { useCurrentFrame as useCurrentFrame6, useVideoConfig as useVideoConfig6, spring as spring4, interpolate as interpolate6, AbsoluteFill as AbsoluteFill4 } from "remotion";
+var BAR_TEXT_WIDTH = 820;
+var LowerThird = ({
+  text,
+  subtitle,
+  variant = "classic",
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame6();
+  const { fps, durationInFrames } = useVideoConfig6();
+  const {
+    fontFamily = resolveTypeface("caption"),
+    fontSize = 28,
+    subtitleFontSize = 20,
+    textColor = FLOOR_TEXT,
+    accentColor = ACCENT_STRONG,
+    backgroundColor = "rgba(0, 0, 0, 0.7)"
+  } = tokens;
+  const enterSpring = spring4({
+    fps,
+    frame,
+    config: { damping: 15, stiffness: 100 }
+  });
+  const exitFrame = Math.max(0, frame - (durationInFrames - 15));
+  const exitSpring = durationInFrames - frame <= 15 ? spring4({
+    fps,
+    frame: exitFrame,
+    config: { damping: 15, stiffness: 120 }
+  }) : 0;
+  const slideIn = interpolate6(enterSpring, [0, 1], [-100, 0]);
+  const slideOut = interpolate6(exitSpring, [0, 1], [0, 100]);
+  const translateX = slideIn + slideOut;
+  const opacity = interpolate6(enterSpring, [0, 0.3], [0, 1], {
+    extrapolateRight: "clamp"
+  }) * (1 - exitSpring);
+  const renderContent = () => {
+    switch (variant) {
+      case "modern":
+        return /* @__PURE__ */ React5.createElement(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              gap: 2,
+              background: accentColor,
+              padding: "10px 24px",
+              borderRadius: 8
+            }
+          },
+          /* @__PURE__ */ React5.createElement(
+            FitText,
+            {
+              maxFontSize: fontSize,
+              maxWidth: BAR_TEXT_WIDTH,
+              fontFamily,
+              fontWeight: 700,
+              style: { color: textColor }
+            },
+            text
+          ),
+          subtitle && /* @__PURE__ */ React5.createElement(
+            FitText,
+            {
+              maxFontSize: subtitleFontSize,
+              maxWidth: BAR_TEXT_WIDTH,
+              maxLines: 2,
+              fontFamily,
+              fontWeight: 400,
+              style: { color: `${textColor}CC` }
+            },
+            subtitle
+          )
+        );
+      case "cinematic":
+        return /* @__PURE__ */ React5.createElement(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              gap: 4,
+              background: backgroundColor,
+              padding: "12px 24px",
+              borderLeft: `3px solid ${accentColor}`
+            }
+          },
+          /* @__PURE__ */ React5.createElement(
+            FitText,
+            {
+              maxFontSize: fontSize,
+              maxWidth: BAR_TEXT_WIDTH,
+              fontFamily,
+              fontWeight: 600,
+              letterSpacing: "1px",
+              textTransform: "uppercase",
+              style: { color: textColor }
+            },
+            text
+          ),
+          subtitle && /* @__PURE__ */ React5.createElement(
+            FitText,
+            {
+              maxFontSize: subtitleFontSize,
+              maxWidth: BAR_TEXT_WIDTH,
+              maxLines: 2,
+              fontFamily,
+              fontWeight: 300,
+              letterSpacing: "0.5px",
+              style: { color: `${textColor}99` }
+            },
+            subtitle
+          )
+        );
+      case "classic":
+      default:
+        return /* @__PURE__ */ React5.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 4 } }, /* @__PURE__ */ React5.createElement(
+          FitText,
+          {
+            maxFontSize: fontSize,
+            maxWidth: BAR_TEXT_WIDTH,
+            fontFamily,
+            fontWeight: 700,
+            style: { background: accentColor, padding: "8px 20px", borderRadius: 4, color: textColor }
+          },
+          text
+        ), subtitle && /* @__PURE__ */ React5.createElement(
+          FitText,
+          {
+            maxFontSize: subtitleFontSize,
+            maxWidth: BAR_TEXT_WIDTH,
+            maxLines: 2,
+            fontFamily,
+            fontWeight: 400,
+            style: { background: backgroundColor, padding: "6px 20px", borderRadius: 4, color: `${textColor}E6` }
+          },
+          subtitle
+        ));
+    }
+  };
+  return /* @__PURE__ */ React5.createElement(AbsoluteFill4, null, /* @__PURE__ */ React5.createElement(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        bottom: 80,
+        left: 40,
+        transform: `translateX(${translateX}%)`,
+        opacity
+      }
+    },
+    renderContent()
+  ));
+};
+
+// ../execution/primitives/src/text/marker-highlight/index.tsx
+import { interpolate as interpolate7, spring as spring5, useCurrentFrame as useCurrentFrame7, useVideoConfig as useVideoConfig7 } from "remotion";
+function MarkerHighlight({
+  before = "",
+  highlight,
+  after = "",
+  markerColor = WARNING,
+  baseColor = FLOOR_TEXT,
+  highlightedTextColor = SURFACE,
+  fontFamily = resolveTypeface("display"),
+  fontSize = 72,
+  fontWeight = 600,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame7() * speed;
+  const { fps } = useVideoConfig7();
+  const markerScale = spring5({
+    frame: frame - 15,
+    fps,
+    config: { damping: 14 }
+  });
+  const textColor = recolor(
+    interpolate7(markerScale, [0.5, 0.8], [0, 1], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp"
+    }),
+    baseColor,
+    highlightedTextColor
+  );
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize,
+        fontWeight,
+        color: baseColor,
+        letterSpacing: "-0.03em",
+        fontFamily
+      }
+    },
+    before,
+    /* @__PURE__ */ React.createElement("span", { style: { position: "relative", display: "inline-block" } }, /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        "aria-hidden": true,
+        style: {
+          position: "absolute",
+          inset: "0 -0.1em",
+          background: markerColor,
+          transformOrigin: "left center",
+          transform: `scaleX(${markerScale})`,
+          zIndex: 0
+        }
+      }
+    ), /* @__PURE__ */ React.createElement("span", { style: { position: "relative", zIndex: 1, color: textColor } }, highlight)),
+    after
+  ));
+}
+
+// ../execution/primitives/src/text/shimmer-sweep/index.tsx
+import { useMemo } from "react";
+import { interpolate as interpolate8, useCurrentFrame as useCurrentFrame8, useVideoConfig as useVideoConfig8 } from "remotion";
+function ShimmerSweep({
+  text,
+  baseColor = "#a1a1aa",
+  shineColor = "#ffffff",
+  fontFamily = resolveTypeface("display"),
+  fontSize = 96,
+  fontWeight = 700,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame8() * speed;
+  const { durationInFrames } = useVideoConfig8();
+  const position = interpolate8(
+    frame,
+    [0, durationInFrames * 0.8],
+    [200, -100],
+    { extrapolateLeft: "clamp", extrapolateRight: "clamp" }
+  );
+  const fittedFontSize = useMemo(() => {
+    const t = (text ?? "").trim();
+    if (!t) return fontSize;
+    try {
+      const { fontSize: fs } = fitTextOnNLines({
+        text: t,
+        maxLines: 1,
+        maxBoxWidth: 1500,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        maxFontSize: fontSize,
+        validateFontIsLoaded: false
+      });
+      return resolveFitFontSize({
+        singleLineFitFontSize: fs,
+        minFontSize: Math.round(fontSize * 0.5),
+        maxFontSize: fontSize
+      }).fontSize;
+    } catch {
+      return fontSize;
+    }
+  }, [text, fontFamily, fontSize, fontWeight]);
+  const textStyle = {
+    fontSize: fittedFontSize,
+    fontWeight,
+    letterSpacing: "-0.03em",
+    fontFamily,
+    margin: 0,
+    lineHeight: 1
+  };
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement("div", { style: { position: "relative", display: "inline-block" } }, /* @__PURE__ */ React.createElement("span", { style: { ...textStyle, color: baseColor } }, text), /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        ...textStyle,
+        position: "absolute",
+        inset: 0,
+        color: "transparent",
+        backgroundClip: "text",
+        WebkitBackgroundClip: "text",
+        backgroundImage: `linear-gradient(110deg, transparent 30%, ${shineColor} 50%, transparent 70%)`,
+        backgroundSize: "200% 100%",
+        backgroundPosition: `${position}% 50%`
+      }
+    },
+    text
+  )));
+}
+
+// ../execution/primitives/src/text/staggered-fade-up/index.tsx
+import { useCurrentFrame as useCurrentFrame9, useVideoConfig as useVideoConfig9 } from "remotion";
+function StaggeredFadeUp({
+  text,
+  staggerDelay = 4,
+  staggerMs,
+  easing,
+  distance = 20,
+  fontSize = 72,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 600,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame9() * speed;
+  const { fps } = useVideoConfig9();
+  const staggerFrames = staggerMs != null ? Math.round(staggerMs / 1e3 * fps) : staggerDelay;
+  const ease = resolveEasing(easing);
+  const words = text.split(" ");
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize,
+        fontWeight,
+        color,
+        letterSpacing: "-0.03em",
+        fontFamily,
+        textShadow: resolveContrast().textShadow
+      }
+    },
+    words.map((word, i) => {
+      const { opacity: linearO } = staggerUp(frame, i, staggerFrames, 12, distance);
+      const opacity = ease(linearO);
+      const y = staggerRise(distance, linearO, ease);
+      return /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          key: i,
+          style: {
+            display: "inline-block",
+            marginRight: "0.25em",
+            opacity,
+            transform: `translateY(${y}px)`
+          }
+        },
+        word
+      );
+    })
+  ));
+}
+
+// ../execution/primitives/src/text/text-effect/index.tsx
+import React6 from "react";
+var TextEffect = ({
+  type,
+  colors = [DANGER, TEAL, BLUE],
+  color = ACCENT,
+  intensity = 0.8,
+  children,
+  text
+}) => {
+  const getEffectStyle = () => {
+    const spread = Math.round(intensity * 30);
+    const blur = Math.round(intensity * 20);
+    switch (type) {
+      case "gradient": {
+        const gradient = `linear-gradient(90deg, ${colors.join(", ")})`;
+        return {
+          background: gradient,
+          WebkitBackgroundClip: "text",
+          WebkitTextFillColor: "transparent",
+          backgroundClip: "text"
+        };
+      }
+      case "neon":
+        return {
+          textShadow: [
+            `0 0 ${Math.round(blur * 0.3)}px ${color}`,
+            `0 0 ${Math.round(blur * 0.6)}px ${color}`,
+            `0 0 ${blur}px ${color}`,
+            `0 0 ${spread}px ${color}80`
+          ].join(", ")
+        };
+      case "glow":
+        return {
+          textShadow: `0 0 ${blur}px ${color}, 0 0 ${spread}px ${color}60`
+        };
+      case "wave": {
+        const gradient = `linear-gradient(90deg, ${colors[0]}, ${colors[1] ?? colors[0]}, ${colors[2] ?? colors[0]}, ${colors[0]})`;
+        return {
+          background: gradient,
+          backgroundSize: "200% 100%",
+          WebkitBackgroundClip: "text",
+          WebkitTextFillColor: "transparent",
+          backgroundClip: "text"
+        };
+      }
+      case "outline":
+        return {
+          WebkitTextStroke: `${Math.max(1, Math.round(intensity * 3))}px ${color}`,
+          color: "transparent"
+        };
+      case "shadow":
+        return {
+          textShadow: `${Math.round(intensity * 4)}px ${Math.round(intensity * 4)}px ${Math.round(intensity * 8)}px ${color}`
+        };
+      default:
+        return {};
+    }
+  };
+  const bareStage = children ? {} : {
+    position: "absolute",
+    inset: 0,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    textAlign: "center",
+    padding: "0 6%",
+    fontSize: 140,
+    fontWeight: 800,
+    letterSpacing: "-0.02em",
+    color: TEXT_HI,
+    fontFamily: "inherit"
+  };
+  return /* @__PURE__ */ React6.createElement("div", { style: { ...bareStage, ...getEffectStyle() } }, children ?? text);
+};
+
+// ../execution/primitives/src/text/text-fade-replace/index.tsx
+import { interpolate as interpolate9, useCurrentFrame as useCurrentFrame10, useVideoConfig as useVideoConfig10 } from "remotion";
+function TextFadeReplace({
+  from,
+  to,
+  fontSize = 48,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 600,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame10() * speed;
+  const { durationInFrames } = useVideoConfig10();
+  const stops = [
+    0,
+    durationInFrames * 0.4,
+    durationInFrames * 0.6,
+    durationInFrames
+  ];
+  const fromOpacity = interpolate9(frame, stops, [1, 1, 0, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const fromY = interpolate9(frame, stops, [0, 0, -12, -12], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const toOpacity = interpolate9(frame, stops, [0, 0, 1, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const toY = interpolate9(frame, stops, [12, 12, 0, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const baseSpanStyle = {
+    position: "absolute",
+    left: "50%",
+    top: "50%",
+    fontSize,
+    fontWeight,
+    color,
+    letterSpacing: "-0.03em",
+    fontFamily,
+    textShadow: resolveContrast().textShadow,
+    whiteSpace: "nowrap"
+  };
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement("div", { style: { position: "relative", width: 0, height: 0 } }, /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        ...baseSpanStyle,
+        opacity: fromOpacity,
+        transform: `translate(-50%, calc(-50% + ${fromY}px))`
+      }
+    },
+    from
+  ), /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        ...baseSpanStyle,
+        opacity: toOpacity,
+        transform: `translate(-50%, calc(-50% + ${toY}px))`
+      }
+    },
+    to
+  )));
+}
+
+// ../execution/primitives/src/text/tracking-in/index.tsx
+import React7 from "react";
+import { interpolate as interpolate10, spring as spring6, useCurrentFrame as useCurrentFrame11, useVideoConfig as useVideoConfig11 } from "remotion";
+var TRACKING_IN_TEXT_WIDTH = 1500;
+var TRACKING_IN_SETTLED_SPACING = "-0.03em";
+function TrackingIn({
+  text,
+  startTracking = 0.5,
+  startBlur = 12,
+  fontSize = 96,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 700,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame11() * speed;
+  const { fps } = useVideoConfig11();
+  const t = spring6({
+    frame,
+    fps,
+    config: { damping: 18, stiffness: 90 }
+  });
+  const letterSpacing = interpolate10(t, [0, 1], [startTracking, -0.03]) + "em";
+  const blurAmount = interpolate10(t, [0, 1], [startBlur, 0]);
+  const opacity = interpolate10(frame, [0, 15], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const fittedFontSize = React7.useMemo(() => {
+    if (text.trim().length === 0) return fontSize;
+    try {
+      const { fontSize: fit } = fitTextOnNLines({
+        text,
+        maxLines: 1,
+        maxBoxWidth: TRACKING_IN_TEXT_WIDTH,
+        fontFamily,
+        fontWeight,
+        letterSpacing: TRACKING_IN_SETTLED_SPACING,
+        maxFontSize: fontSize,
+        validateFontIsLoaded: false
+      });
+      return resolveFitFontSize({
+        singleLineFitFontSize: fit,
+        minFontSize: Math.round(fontSize * 0.55),
+        maxFontSize: fontSize
+      }).fontSize;
+    } catch {
+      return fontSize;
+    }
+  }, [text, fontFamily, fontWeight, fontSize]);
+  return /* @__PURE__ */ React7.createElement(TextStage, null, /* @__PURE__ */ React7.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize: fittedFontSize,
+        fontWeight,
+        color,
+        letterSpacing,
+        opacity,
+        filter: `blur(${blurAmount}px)`,
+        fontFamily,
+        textShadow: resolveContrast().textShadow,
+        maxWidth: TRACKING_IN_TEXT_WIDTH,
+        whiteSpace: "nowrap"
+      }
+    },
+    text
+  ));
+}
+
+// ../execution/primitives/src/text/typewriter/index.tsx
+import React8 from "react";
+import { interpolate as interpolate11, useCurrentFrame as useCurrentFrame12, useVideoConfig as useVideoConfig12 } from "remotion";
+var TYPEWRITER_TEXT_WIDTH = 1500;
+var TYPEWRITER_MAX_LINES = 3;
+var TYPEWRITER_LETTER_SPACING = "-0.03em";
+function Typewriter({
+  text,
+  cursor = true,
+  charsPerSecond = 20,
+  speed = 1,
+  fontSize = 48,
+  color = FLOOR_TEXT,
+  cursorColor = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 600,
+  className
+}) {
+  const frame = useCurrentFrame12() * speed;
+  const { fps } = useVideoConfig12();
+  const charsToRevealOver = text.length / charsPerSecond * fps;
+  const revealed = Math.floor(
+    interpolate11(frame, [0, charsToRevealOver], [0, text.length], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp"
+    })
+  );
+  const visibleText = text.substring(0, revealed);
+  const isCursorVisible = Math.floor(frame / fps * 2) % 2 === 0;
+  const fittedFontSize = React8.useMemo(() => {
+    if (text.trim().length === 0) return fontSize;
+    try {
+      const { fontSize: fit } = fitTextOnNLines({
+        text,
+        maxLines: TYPEWRITER_MAX_LINES,
+        maxBoxWidth: TYPEWRITER_TEXT_WIDTH,
+        fontFamily,
+        fontWeight,
+        letterSpacing: TYPEWRITER_LETTER_SPACING,
+        maxFontSize: fontSize,
+        validateFontIsLoaded: false
+      });
+      return resolveFitFontSize({
+        singleLineFitFontSize: fit,
+        minFontSize: Math.round(fontSize * 0.55),
+        maxFontSize: fontSize
+      }).fontSize;
+    } catch {
+      return fontSize;
+    }
+  }, [text, fontFamily, fontWeight, fontSize]);
+  return /* @__PURE__ */ React8.createElement(TextStage, null, /* @__PURE__ */ React8.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize: fittedFontSize,
+        fontWeight,
+        color,
+        letterSpacing: TYPEWRITER_LETTER_SPACING,
+        fontFamily,
+        textShadow: resolveContrast().textShadow,
+        maxWidth: TYPEWRITER_TEXT_WIDTH,
+        whiteSpace: "pre-wrap",
+        overflowWrap: "break-word",
+        textAlign: "center"
+      }
+    },
+    visibleText,
+    cursor && /* @__PURE__ */ React8.createElement(
+      "span",
+      {
+        style: {
+          display: "inline-block",
+          width: "0.08em",
+          height: "1em",
+          marginLeft: "0.04em",
+          verticalAlign: "text-bottom",
+          background: cursorColor,
+          opacity: isCursorVisible ? 1 : 0
+        }
+      }
+    )
+  ));
+}
+
+// ../execution/primitives/src/text/matrix-decode/index.tsx
+import { random, useCurrentFrame as useCurrentFrame13, useVideoConfig as useVideoConfig13 } from "remotion";
+var DECODE_TEXT_WIDTH = 1500;
+function MatrixDecode({
+  text,
+  charset = "!@#$%^&*()_+-=<>?/\\|",
+  fontSize = 72,
+  color = SUCCESS,
+  fontFamily = resolveTypeface("mono"),
+  fontWeight = 600,
+  revealDuration = 60,
+  speed = 1
+}) {
+  const frame = useCurrentFrame13() * speed;
+  useVideoConfig13();
+  let output = "";
+  for (let i = 0; i < text.length; i++) {
+    const revealFrame = i / Math.max(text.length, 1) * revealDuration;
+    if (text[i] === " ") {
+      output += " ";
+    } else if (frame >= revealFrame) {
+      output += text[i];
+    } else {
+      const r = random(`${i}-${Math.floor(frame / 2)}`);
+      const ch = charset[Math.floor(r * charset.length)];
+      output += ch;
+    }
+  }
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    FitText,
+    {
+      maxFontSize: fontSize,
+      maxWidth: DECODE_TEXT_WIDTH,
+      fontFamily,
+      fontWeight,
+      letterSpacing: "0.05em",
+      style: { color, whiteSpace: "pre" }
+    },
+    output
+  ));
+}
+
+// ../execution/primitives/src/text/rgb-glitch-text/index.tsx
+import { random as random2, useCurrentFrame as useCurrentFrame14 } from "remotion";
+var GLITCH_TEXT_WIDTH = 1500;
+function RGBGlitchText({
+  text,
+  fontSize = 96,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 700,
+  glitchAt = 20,
+  glitchDuration = 8,
+  intensity = 6,
+  seed = "glitch",
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame14() * speed;
+  const isGlitching = frame >= glitchAt && frame < glitchAt + glitchDuration;
+  const offset = (axisSeed, scale) => (random2(`${seed}-${axisSeed}-${frame}`) * 2 - 1) * scale;
+  const rX = isGlitching ? offset("r-x", intensity) : 0;
+  const rY = isGlitching ? offset("r-y", intensity * 0.4) : 0;
+  const gX = isGlitching ? offset("g-x", intensity) : 0;
+  const gY = isGlitching ? offset("g-y", intensity * 0.4) : 0;
+  const bX = isGlitching ? offset("b-x", intensity) : 0;
+  const bY = isGlitching ? offset("b-y", intensity * 0.4) : 0;
+  const copyOpacity = isGlitching ? 1 : 0;
+  const copyBaseStyle = {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    whiteSpace: "pre",
+    mixBlendMode: "screen"
+  };
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className,
+      style: { position: "relative", display: "inline-block" }
+    },
+    /* @__PURE__ */ React.createElement(
+      FitText,
+      {
+        maxFontSize: fontSize,
+        maxWidth: GLITCH_TEXT_WIDTH,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        style: {
+          position: "relative",
+          color,
+          whiteSpace: "pre",
+          textShadow: resolveContrast().textShadow
+        }
+      },
+      text
+    ),
+    /* @__PURE__ */ React.createElement(
+      FitText,
+      {
+        maxFontSize: fontSize,
+        maxWidth: GLITCH_TEXT_WIDTH,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        style: {
+          ...copyBaseStyle,
+          color: "#ff0040",
+          opacity: copyOpacity,
+          transform: `translateX(${rX}px) translateY(${rY}px)`
+        }
+      },
+      text
+    ),
+    /* @__PURE__ */ React.createElement(
+      FitText,
+      {
+        maxFontSize: fontSize,
+        maxWidth: GLITCH_TEXT_WIDTH,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        style: {
+          ...copyBaseStyle,
+          color: "#00ff80",
+          opacity: copyOpacity,
+          transform: `translateX(${gX}px) translateY(${gY}px)`
+        }
+      },
+      text
+    ),
+    /* @__PURE__ */ React.createElement(
+      FitText,
+      {
+        maxFontSize: fontSize,
+        maxWidth: GLITCH_TEXT_WIDTH,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        style: {
+          ...copyBaseStyle,
+          color: "#0080ff",
+          opacity: copyOpacity,
+          transform: `translateX(${bX}px) translateY(${bY}px)`
+        }
+      },
+      text
+    )
+  ));
+}
+
+// ../execution/primitives/src/text/quote-card/index.tsx
+import React9 from "react";
+import { AbsoluteFill as AbsoluteFill5, interpolate as interpolate12, spring as spring7, useCurrentFrame as useCurrentFrame15, useVideoConfig as useVideoConfig14 } from "remotion";
+var QuoteCard = ({
+  quote,
+  author = "",
+  role = "",
+  accentColor = ACCENT,
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame15();
+  const { fps } = useVideoConfig14();
+  const t = frame / fps;
+  const {
+    fontFamily = resolveTypeface("display"),
+    fontSize = 62,
+    textColor = FLOOR_TEXT
+  } = tokens;
+  const markIn = spring7({ frame, fps, config: { damping: 13, stiffness: 140, mass: 1.1 } });
+  const markSettled = markIn > 0.98;
+  const markScale = interpolate12(markIn, [0, 1], [1.6, 1]) * (markSettled ? 1 + Math.sin(2 * Math.PI * 0.07 * t) * 0.012 : 1);
+  const words = quote.split(" ").filter(Boolean);
+  const wordStyle = (i) => {
+    const s = spring7({
+      frame: frame - 6 - i * 2,
+      fps,
+      config: { damping: 15, stiffness: 130, mass: 0.7 }
+    });
+    return {
+      display: "inline-block",
+      opacity: interpolate12(s, [0, 0.4], [0, 1], { extrapolateRight: "clamp" }),
+      transform: `translateY(${interpolate12(s, [0, 1], [26, 0])}px)`
+    };
+  };
+  const attribStart = 6 + words.length * 2 + 8;
+  const ruleP = interpolate12(frame, [attribStart, attribStart + 16], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const attribIn = spring7({
+    frame: frame - attribStart - 6,
+    fps,
+    config: { damping: 15, stiffness: 110, mass: 0.8 }
+  });
+  return /* @__PURE__ */ React9.createElement(AbsoluteFill5, { style: { justifyContent: "center", alignItems: "center" } }, /* @__PURE__ */ React9.createElement("div", { style: { maxWidth: "72%", textAlign: "left" } }, /* @__PURE__ */ React9.createElement(
+    "div",
+    {
+      style: {
+        fontFamily,
+        fontSize: fontSize * 2.6,
+        fontWeight: 800,
+        lineHeight: 0.6,
+        color: accentColor,
+        opacity: interpolate12(markIn, [0, 0.3], [0, 1], { extrapolateRight: "clamp" }),
+        transform: `scale(${markScale})`,
+        transformOrigin: "left bottom",
+        marginBottom: fontSize * 0.2,
+        textShadow: FLOOR_SHADOW
+      }
+    },
+    "\u201C"
+  ), /* @__PURE__ */ React9.createElement(
+    "div",
+    {
+      style: {
+        fontFamily,
+        fontSize,
+        fontWeight: 600,
+        lineHeight: 1.32,
+        letterSpacing: "-0.01em",
+        color: textColor,
+        textShadow: FLOOR_SHADOW,
+        display: "flex",
+        flexWrap: "wrap",
+        gap: "0 0.28em"
+      }
+    },
+    words.map((w, i) => /* @__PURE__ */ React9.createElement("span", { key: i, style: wordStyle(i) }, w))
+  ), (author || role) && /* @__PURE__ */ React9.createElement("div", { style: { marginTop: fontSize * 0.7 } }, /* @__PURE__ */ React9.createElement(
+    "div",
+    {
+      style: {
+        height: 3,
+        width: `${ruleP * 12}%`,
+        background: accentColor,
+        borderRadius: 2,
+        marginBottom: fontSize * 0.3
+      }
+    }
+  ), /* @__PURE__ */ React9.createElement(
+    "div",
+    {
+      style: {
+        fontFamily,
+        opacity: interpolate12(attribIn, [0, 1], [0, 1]),
+        transform: `translateY(${interpolate12(attribIn, [0, 1], [14, 0])}px)`,
+        textShadow: FLOOR_SHADOW
+      }
+    },
+    author && /* @__PURE__ */ React9.createElement("span", { style: { fontSize: fontSize * 0.42, fontWeight: 700, color: textColor } }, author),
+    role && /* @__PURE__ */ React9.createElement(
+      "span",
+      {
+        style: {
+          fontSize: fontSize * 0.38,
+          fontWeight: 400,
+          color: textColor,
+          opacity: 0.6,
+          marginLeft: author ? "0.8em" : 0
+        }
+      },
+      role
+    )
+  ))));
+};
+
+// ../execution/primitives/src/text/slot-machine-roll/index.tsx
+import { spring as spring8, useCurrentFrame as useCurrentFrame16, useVideoConfig as useVideoConfig15 } from "remotion";
+function SlotMachineRoll({
+  from = "$99",
+  to = "$199",
+  fontSize = 120,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 700,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame16() * speed;
+  const { fps } = useVideoConfig15();
+  const len = Math.max(from.length, to.length);
+  const paddedFrom = from.padStart(len, " ");
+  const paddedTo = to.padStart(len, " ");
+  const columns = [];
+  for (let i = 0; i < len; i++) {
+    const raw = spring8({
+      frame: frame - i * 4,
+      fps,
+      config: { damping: 14 }
+    });
+    const t = Math.max(0, Math.min(1, raw));
+    columns.push(
+      /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          key: i,
+          style: {
+            display: "inline-block",
+            overflow: "hidden",
+            height: "1.1em",
+            lineHeight: "1.1em",
+            verticalAlign: "top",
+            width: "0.7em",
+            textAlign: "center"
+          }
+        },
+        /* @__PURE__ */ React.createElement(
+          "span",
+          {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              transform: `translateY(${-t * fontSize * 1.1}px)`
+            }
+          },
+          /* @__PURE__ */ React.createElement("span", null, paddedFrom[i]),
+          /* @__PURE__ */ React.createElement("span", null, paddedTo[i])
+        )
+      )
+    );
+  }
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize,
+        fontWeight,
+        color,
+        letterSpacing: "-0.03em",
+        fontFamily,
+        textShadow: resolveContrast().textShadow,
+        lineHeight: 1.1
+      }
+    },
+    columns
+  ));
+}
+
+// ../execution/primitives/src/text/stat-counter/index.tsx
+import React10 from "react";
+import { AbsoluteFill as AbsoluteFill6, Easing, interpolate as interpolate13, spring as spring9, useCurrentFrame as useCurrentFrame17, useVideoConfig as useVideoConfig16 } from "remotion";
+var StatCounter = ({
+  value,
+  prefix = "",
+  suffix = "",
+  label = "",
+  accentColor = ACCENT,
+  decimals = 0,
+  countFrames = 45,
+  position = "center",
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame17();
+  const { fps } = useVideoConfig16();
+  const t = frame / fps;
+  const {
+    fontFamily = resolveTypeface("display"),
+    fontSize = 190,
+    textColor = FLOOR_TEXT
+  } = tokens;
+  const countP = interpolate13(frame, [0, countFrames], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp",
+    easing: Easing.out(Easing.exp)
+  });
+  const shown = (value * countP).toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+  const enter = spring9({ frame, fps, config: { damping: 16, stiffness: 120, mass: 0.9 } });
+  const scale = interpolate13(enter, [0, 1], [0.94, 1]);
+  const opacity = interpolate13(enter, [0, 0.4], [0, 1], { extrapolateRight: "clamp" });
+  const lineP = interpolate13(frame, [countFrames * 0.6, countFrames * 1.2], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp",
+    easing: Easing.bezier(0.65, 0, 0.35, 1)
+  });
+  const idleGlow = 0.55 + Math.sin(2 * Math.PI * 0.4 * t) * 0.2;
+  const labelIn = spring9({
+    frame: frame - countFrames * 0.7,
+    fps,
+    config: { damping: 15, stiffness: 110, mass: 0.8 }
+  });
+  const align = position === "center" ? "center" : position === "right" ? "flex-end" : "flex-start";
+  const textAlign = position === "center" ? "center" : position === "right" ? "right" : "left";
+  return /* @__PURE__ */ React10.createElement(AbsoluteFill6, { style: { justifyContent: "center", alignItems: align, padding: 80 } }, /* @__PURE__ */ React10.createElement("div", { style: { opacity, transform: `scale(${scale})`, textAlign } }, /* @__PURE__ */ React10.createElement(
+    "div",
+    {
+      style: {
+        fontFamily,
+        fontSize,
+        fontWeight: 800,
+        letterSpacing: "-0.03em",
+        color: textColor,
+        textShadow: FLOOR_SHADOW,
+        fontVariantNumeric: "tabular-nums",
+        lineHeight: 1.05,
+        whiteSpace: "nowrap"
+      }
+    },
+    prefix,
+    shown,
+    /* @__PURE__ */ React10.createElement("span", { style: { color: accentColor } }, suffix)
+  ), /* @__PURE__ */ React10.createElement(
+    "div",
+    {
+      style: {
+        height: Math.max(4, fontSize * 0.035),
+        width: `${lineP * 100}%`,
+        marginTop: fontSize * 0.08,
+        marginLeft: position === "right" ? "auto" : position === "center" ? "auto" : 0,
+        marginRight: position === "left" ? "auto" : position === "center" ? "auto" : 0,
+        background: accentColor,
+        borderRadius: 4,
+        opacity: lineP >= 1 ? idleGlow : 0.9
+      }
+    }
+  ), label && /* @__PURE__ */ React10.createElement(
+    "div",
+    {
+      style: {
+        fontFamily,
+        fontSize: Math.round(fontSize * 0.19),
+        fontWeight: 500,
+        letterSpacing: "0.14em",
+        textTransform: "uppercase",
+        color: textColor,
+        opacity: interpolate13(labelIn, [0, 1], [0, 0.75]),
+        transform: `translateY(${interpolate13(labelIn, [0, 1], [18, 0])}px)`,
+        marginTop: fontSize * 0.12,
+        textShadow: FLOOR_SHADOW
+      }
+    },
+    label
+  )));
+};
+
+// ../execution/primitives/src/text/token-stream/index.tsx
+import React11 from "react";
+import { AbsoluteFill as AbsoluteFill7, interpolate as interpolate14, useCurrentFrame as useCurrentFrame18, useVideoConfig as useVideoConfig17 } from "remotion";
+function jitter(i, seed) {
+  let h = Math.imul(i + 1, 374761393) + Math.imul(seed, 668265263);
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  return ((h ^ h >>> 16) >>> 0) / 4294967295;
+}
+var TokenStream = ({
+  text,
+  tokensPerSecond = 9,
+  accentColor = ACCENT,
+  startAt = 8,
+  tokens = {}
+}) => {
+  const frame = useCurrentFrame18();
+  const { fps } = useVideoConfig17();
+  const {
+    fontFamily = resolveTypeface("display"),
+    fontSize = 54,
+    textColor = FLOOR_TEXT
+  } = tokens;
+  const words = text.split(" ").filter(Boolean);
+  const base = fps / tokensPerSecond;
+  const arrivals = [];
+  let tAcc = startAt;
+  for (let i = 0; i < words.length; i++) {
+    const j = jitter(i, 7);
+    tAcc += base * (0.55 + j * 0.9) + (j > 0.86 ? base * 2.2 : 0);
+    arrivals.push(tAcc);
+  }
+  const done = arrivals.length ? arrivals[arrivals.length - 1] + 6 : startAt;
+  const streaming = frame < done;
+  const cursorOpacity = streaming ? 0.55 + Math.sin(2 * Math.PI * 2.2 * frame / fps) * 0.45 : frame < done + 24 ? Math.round((frame - done) / 8 % 2) === 0 ? 1 : 0.1 : interpolate14(frame, [done + 24, done + 36], [1, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const arrivedCount = arrivals.filter((a) => frame >= a).length;
+  const cursorAt = Math.max(0, arrivedCount - 1);
+  return /* @__PURE__ */ React11.createElement(AbsoluteFill7, { style: { justifyContent: "center", alignItems: "center" } }, /* @__PURE__ */ React11.createElement(
+    "div",
+    {
+      style: {
+        maxWidth: "68%",
+        fontFamily,
+        fontSize,
+        fontWeight: 500,
+        lineHeight: 1.42,
+        letterSpacing: "-0.005em",
+        color: textColor,
+        textShadow: FLOOR_SHADOW
+      }
+    },
+    words.map((w, i) => {
+      const a = arrivals[i];
+      const o = interpolate14(frame, [a, a + 4], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const rise = interpolate14(frame, [a, a + 5], [6, 0], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return /* @__PURE__ */ React11.createElement(
+        "span",
+        {
+          key: i,
+          style: {
+            display: "inline-block",
+            position: "relative",
+            transform: `translateY(${rise}px)`,
+            marginRight: "0.26em"
+          }
+        },
+        /* @__PURE__ */ React11.createElement("span", { style: { opacity: o } }, w),
+        i === cursorAt && /* @__PURE__ */ React11.createElement(
+          "span",
+          {
+            style: {
+              position: "absolute",
+              left: arrivedCount === 0 ? 0 : "100%",
+              marginLeft: arrivedCount === 0 ? 0 : "0.13em",
+              bottom: fontSize * -0.08,
+              width: fontSize * 0.5,
+              height: fontSize * 1.02,
+              background: accentColor,
+              borderRadius: 3,
+              opacity: cursorOpacity
+            }
+          }
+        )
+      );
+    })
+  ));
+};
+
+// ../execution/primitives/src/text/strikethrough-replace/index.tsx
+import { useMemo as useMemo2 } from "react";
+import { interpolate as interpolate15, useCurrentFrame as useCurrentFrame19, useVideoConfig as useVideoConfig18 } from "remotion";
+function StrikethroughReplace({
+  from,
+  to,
+  lineColor = "#ff5e3a",
+  fontSize = 48,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 600,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame19() * speed;
+  const { durationInFrames } = useVideoConfig18();
+  const strikeEnd = durationInFrames * 0.4;
+  const fadeStart = durationInFrames * 0.4;
+  const fadeEnd = durationInFrames * 0.6;
+  const linePct = interpolate15(frame, [0, strikeEnd], [0, 100], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const fromOpacity = interpolate15(frame, [fadeStart, fadeEnd], [1, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const toOpacity = interpolate15(frame, [fadeStart, fadeEnd], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const toY = interpolate15(frame, [fadeStart, fadeEnd], [8, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  });
+  const fittedFontSize = useMemo2(() => {
+    const longest = [from, to].map((s) => (s ?? "").trim()).sort((a, b) => b.length - a.length)[0] || "";
+    if (!longest) return fontSize;
+    try {
+      const { fontSize: fs } = fitTextOnNLines({
+        text: longest,
+        maxLines: 1,
+        maxBoxWidth: 1400,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        maxFontSize: fontSize,
+        validateFontIsLoaded: false
+      });
+      return resolveFitFontSize({
+        singleLineFitFontSize: fs,
+        minFontSize: Math.round(fontSize * 0.5),
+        maxFontSize: fontSize
+      }).fontSize;
+    } catch {
+      return fontSize;
+    }
+  }, [from, to, fontFamily, fontSize, fontWeight]);
+  const textStyle = {
+    fontSize: fittedFontSize,
+    fontWeight,
+    color,
+    letterSpacing: "-0.03em",
+    fontFamily,
+    whiteSpace: "nowrap",
+    textShadow: resolveContrast().textShadow
+  };
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        position: "relative",
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "center"
+      }
+    },
+    /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        className,
+        style: {
+          ...textStyle,
+          position: "absolute",
+          opacity: fromOpacity
+        }
+      },
+      from,
+      /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          "aria-hidden": true,
+          style: {
+            position: "absolute",
+            left: 0,
+            top: "50%",
+            height: Math.max(2, Math.round(fittedFontSize * 0.08)),
+            width: `${linePct}%`,
+            background: lineColor,
+            transform: "translateY(-50%)",
+            borderRadius: 2
+          }
+        }
+      )
+    ),
+    /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        className,
+        style: {
+          ...textStyle,
+          opacity: toOpacity,
+          transform: `translateY(${toY}px)`
+        }
+      },
+      to
+    )
+  ));
+}
+
+// ../execution/primitives/src/text/masked-slide-reveal/index.tsx
+import { useMemo as useMemo3 } from "react";
+import { spring as spring10, useCurrentFrame as useCurrentFrame20, useVideoConfig as useVideoConfig19 } from "remotion";
+function MaskedSlideReveal({
+  text,
+  staggerDelay = 3,
+  fontSize = 72,
+  color = FLOOR_TEXT,
+  fontFamily = resolveTypeface("display"),
+  fontWeight = 700,
+  speed = 1,
+  className
+}) {
+  const frame = useCurrentFrame20() * speed;
+  const { fps } = useVideoConfig19();
+  const words = text.split(" ");
+  const fittedFontSize = useMemo3(() => {
+    const t = (text ?? "").trim();
+    if (!t) return fontSize;
+    try {
+      const { fontSize: fs } = fitTextOnNLines({
+        text: t,
+        maxLines: 2,
+        maxBoxWidth: 1500,
+        fontFamily,
+        fontWeight,
+        letterSpacing: "-0.03em",
+        maxFontSize: fontSize,
+        validateFontIsLoaded: false
+      });
+      return resolveFitFontSize({
+        singleLineFitFontSize: fs,
+        minFontSize: Math.round(fontSize * 0.5),
+        maxFontSize: fontSize
+      }).fontSize;
+    } catch {
+      return fontSize;
+    }
+  }, [text, fontFamily, fontSize, fontWeight]);
+  return /* @__PURE__ */ React.createElement(TextStage, null, /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className,
+      style: {
+        fontSize: fittedFontSize,
+        fontWeight,
+        color,
+        letterSpacing: "-0.03em",
+        fontFamily,
+        textShadow: resolveContrast().textShadow
+      }
+    },
+    words.map((word, i) => {
+      const t = spring10({
+        frame: frame - i * staggerDelay,
+        fps,
+        config: { damping: 14 }
+      });
+      return /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          key: i,
+          style: {
+            display: "inline-block",
+            overflow: "hidden",
+            verticalAlign: "bottom",
+            lineHeight: 1,
+            marginRight: "0.25em"
+          }
+        },
+        /* @__PURE__ */ React.createElement(
+          "span",
+          {
+            style: {
+              display: "inline-block",
+              transform: `translateY(${(1 - t) * 100}%)`
+            }
+          },
+          word
+        )
+      );
+    })
+  ));
+}
+
+// ../execution/primitives/src/text/blur-reveal/config.ts
+import { z } from "zod";
+var paramsSchema = z.object({
+  text: z.string().min(1).max(160).describe(
+    "The text to reveal. Shorter reads best \u2014 longer strings make the focus-pull feel slow. Auto-fits: long copy shrinks to fit the frame (then wraps), so it no longer overflows."
+  ),
+  blur: z.number().min(0).max(40).default(10).describe(
+    "Initial blur radius in pixels. Higher = more dramatic focus-pull. 6\u201314 is the sweet spot."
+  ),
+  fontSize: z.number().min(16).max(240).default(96).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame."
+  ),
+  fontWeight: z.number().min(100).max(900).default(600).describe(
+    "CSS font weight. 600 reads as confident; 800+ feels like a headline."
+  ),
+  color: z.string().default(FLOOR_TEXT).describe(
+    "Text color. Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."
+  ),
+  fontFamily: z.string().default(resolveTypeface("display")).describe(
+    "Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme it."
+  ),
+  speed: z.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier. 1 = normal; 2 = twice as fast."
+  )
+}).passthrough();
+var config = {
+  id: "blur-reveal",
+  component: BlurReveal,
+  name: "Blur Reveal",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "reveal-text",
+  description: 'Single line of text fades in from a heavy gaussian blur into sharp focus. The "focus pull" feel makes it ideal for cinematic title cards, brand reveals, and product taglines where the audience should land on one phrase.',
+  useWhen: "Hero opens, brand statements, single-line callouts. Avoid for >40-character strings (the blur duration scales with content and starts feeling sluggish), and avoid combining with another text primitive that also fades \u2014 pick one focal element per beat.",
+  pairsWith: ["mesh-gradient-bg", "dynamic-grid", "success-confetti"],
+  avoidWith: ["typewriter", "staggered-fade-up"],
+  tier: "standard",
+  useCase: ["title-over-footage", "full-scene"],
+  tags: ["text", "reveal", "blur", "cinematic", "title", "hero"],
+  mood: ["cinematic", "editorial", "minimal", "soft"],
+  paramsSchema,
+  propDefaults: { blur: 10, fontSize: 96, fontWeight: 600, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), speed: 1 },
+  examples: [
+    {
+      name: "editorial",
+      mood: ["editorial", "minimal"],
+      params: { text: "A film by someone", blur: 8, fontSize: 96, fontWeight: 600, color: FLOOR_TEXT, speed: 1 },
+      description: "Calm, magazine-style reveal over footage. Default values; safest pick."
+    },
+    {
+      name: "cinematic-bold",
+      mood: ["cinematic", "aggressive"],
+      params: { text: "CINEMATIC", blur: 14, fontSize: 144, fontWeight: 800, color: TEXT_HI, speed: 0.85 },
+      description: "Heavier blur + bigger weight + slower speed \u2014 feels like a film opening."
+    },
+    {
+      name: "product-tagline",
+      mood: ["corporate", "minimal"],
+      params: { text: "Built for builders.", blur: 6, fontSize: 72, fontWeight: 500, color: FLOOR_TEXT, speed: 1.2 },
+      description: "Subtle product-page tagline. Lower blur, lighter weight, slightly faster."
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "editorial" }
+};
+
+// ../execution/primitives/src/text/cinematic-title/config.ts
+import { z as z2 } from "zod";
+var tokensSchema = z2.object({
+  fontFamily: z2.string().default(resolveTypeface("display")),
+  fontSize: z2.number().optional(),
+  subtextFontSize: z2.number().optional(),
+  textColor: z2.string().default(FLOOR_TEXT),
+  accentColor: z2.string().optional(),
+  letterSpacing: z2.number().optional()
+}).passthrough();
+var paramsSchema2 = z2.object({
+  text: z2.string().min(1).max(80).describe("Primary title text. Auto-fits: long copy shrinks to fit the frame (then wraps/ellipsizes), so you are not capped at a cramped line."),
+  subtitle: z2.string().max(140).optional().describe('Optional subtitle line. Used for byline / film-credit style ("a film by ..."). Auto-fits and wraps to 2 lines.'),
+  variant: z2.enum(["default", "bold", "zoom"]).default("default").describe(
+    "Visual variant. default: letterboxed fade with letter-spacing tighten. bold: heavier weight + spring entrance. zoom: scale-from-blur with overshoot."
+  ),
+  position: z2.enum(["center", "top", "bottom"]).default("center").describe("Vertical position of the title block."),
+  tokens: tokensSchema.default({}).describe("Visual tokens. fontFamily, fontSize, textColor, accentColor, letterSpacing.")
+}).passthrough();
+var config2 = {
+  id: "cinematic-title",
+  component: CinematicTitle,
+  name: "Cinematic Title",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "name-card",
+  description: "Full-screen title card with cinematic letterbox bars sliding in, primary text fading up, and optional subtitle. Three variants tune the entrance physics: default (subtle), bold (heavy spring), zoom (scale-from-blur with overshoot).",
+  useWhen: "Film opens, brand intros, dramatic chapter cards. Avoid for in-story callouts or quick beats \u2014 the letterbox bars and exit animation eat 40+ frames.",
+  pairsWith: ["light-leak", "mesh-gradient-bg", "parallax", "vignette"],
+  avoidWith: ["lower-third", "kinetic-type"],
+  tier: "standard",
+  useCase: ["intro", "full-scene"],
+  tags: ["text", "title", "cinematic", "letterbox", "hero", "card"],
+  mood: ["cinematic", "editorial"],
+  paramsSchema: paramsSchema2,
+  propDefaults: { variant: "default", position: "center" },
+  examples: [
+    {
+      name: "classic",
+      mood: ["cinematic"],
+      params: { text: "CINEMATIC", subtitle: "A film by someone", variant: "default", position: "center" }
+    },
+    {
+      name: "bold-impact",
+      mood: ["cinematic", "aggressive"],
+      params: { text: "CHAPTER ONE", variant: "bold", position: "center" }
+    },
+    {
+      name: "zoom-reveal",
+      mood: ["cinematic"],
+      params: { text: "NEXT", variant: "zoom", position: "center" }
+    }
+  ],
+  textParam: "text",
+  subtextParam: "subtitle",
+  tokens: [
+    { propPath: "tokens.textColor", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "tokens.accentColor", cssVar: "--cf-accent", fallback: WARNING, brandKitPath: "colors.accent" },
+    { propPath: "tokens.fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 120,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "classic" }
+};
+
+// ../execution/primitives/src/text/inline-highlight/config.ts
+import { z as z3 } from "zod";
+var paramsSchema3 = z3.object({
+  // `before` was required; relaxed to optional with empty default so a
+  // degenerate "single highlighted word, no preceding context" pick is
+  // valid. The renderer treats empty `before` as no-op text. Agent
+  // picks where the highlighted word is the entire phrase (a common
+  // editorial choice on short hooks) no longer crash the render with
+  // `inline-highlight: invalid params — before: Required`. See Block 2
+  // (editorial intelligence) for the upstream fix: validate agent tool
+  // calls against the registry's paramsSchema before accepting them,
+  // so the agent self-corrects instead of relying on schema relaxation.
+  before: z3.string().default("").describe('Text leading up to the highlighted word, including trailing space if any. Empty string is valid for "single word" picks.'),
+  highlight: z3.string().min(1).describe("The single word or phrase to emphasize."),
+  after: z3.string().default("").describe("Text after the highlight, including leading space if any."),
+  baseColor: z3.string().default(FLOOR_TEXT).describe("Color of the surrounding (non-highlighted) text. Defaults to a video-safe off-white so it survives over footage; pass $brand:colors.textOnMedia to theme it."),
+  highlightColor: z3.string().default(ACCENT_STRONG).describe("Color of the emphasized word. A warm accent by default; use a brand-kit accent for cascade."),
+  fontSize: z3.number().min(16).max(180).default(72).describe("Font size in pixels at 1920\xD71080."),
+  fontWeight: z3.number().min(100).max(900).default(600).describe("CSS font weight applied uniformly."),
+  speed: z3.number().min(0.25).max(4).default(1).describe("Playback speed multiplier."),
+  fontFamily: z3.string().default(resolveTypeface("display")).describe("Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme it.")
+}).passthrough();
+var config3 = {
+  id: "inline-highlight",
+  component: InlineHighlight,
+  name: "Inline Highlight",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "emphasize-word",
+  description: "Single sentence with one word color-shifting from a muted base color to a brand accent. The eye lands on the highlighted word naturally because the surrounding text fades to background.",
+  useWhen: 'Caption callouts (e.g., "the user said {important_word}"), pull-quotes from a transcript, when you want to draw the eye to one specific word in a longer phrase. Avoid for short text where the highlight has nothing to contrast against.',
+  pairsWith: ["marker-highlight", "shimmer-sweep", "mesh-gradient-bg"],
+  avoidWith: ["marker-highlight"],
+  tier: "standard",
+  useCase: ["emphasis"],
+  tags: ["text", "highlight", "emphasis", "word", "caption", "callout"],
+  mood: ["editorial", "minimal", "corporate"],
+  paramsSchema: paramsSchema3,
+  propDefaults: { before: "", after: "", baseColor: FLOOR_TEXT, highlightColor: ACCENT_STRONG, fontSize: 72, fontWeight: 600, speed: 1, fontFamily: resolveTypeface("display") },
+  examples: [
+    {
+      name: "product-emphasis",
+      mood: ["corporate"],
+      params: { before: "Built for ", highlight: "builders", after: ".", baseColor: FLOOR_TEXT, highlightColor: ACCENT_STRONG, fontSize: 80, fontWeight: 700, speed: 1 }
+    },
+    {
+      name: "quote-pull",
+      mood: ["editorial"],
+      params: { before: "It just ", highlight: "works", after: ".", baseColor: TEXT_MUTED, highlightColor: TEAL, fontSize: 96, fontWeight: 500, speed: 0.9 }
+    }
+  ],
+  textParam: "highlight",
+  subtextParam: null,
+  tokens: [
+    { propPath: "baseColor", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "highlightColor", cssVar: "--cf-accent", fallback: ACCENT_STRONG, brandKitPath: "colors.accent" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "product-emphasis" }
+};
+
+// ../execution/primitives/src/text/karaoke/config.ts
+import { z as z4 } from "zod";
+var wordSchema = z4.object({
+  text: z4.string().min(1),
+  startMs: z4.number().min(0),
+  endMs: z4.number().min(0)
+});
+var tokensSchema2 = z4.object({
+  fontFamily: z4.string().default(resolveTypeface("caption")),
+  fontSize: z4.number().optional(),
+  textColor: z4.string().default(FLOOR_TEXT),
+  activeColor: z4.string().optional(),
+  activeScale: z4.number().optional()
+}).passthrough();
+var paramsSchema4 = z4.object({
+  words: z4.array(wordSchema).min(1).describe(
+    "Array of timed words. Each word has text + startMs/endMs in milliseconds relative to the clip start. Source from the transcript."
+  ),
+  position: z4.enum(["center", "left", "right", "bottom"]).default("center").describe('Block position. "bottom" is canonical for caption-style overlays.'),
+  tokens: tokensSchema2.default({}).describe("Visual tokens. fontFamily, fontSize, textColor, activeColor, activeScale.")
+}).passthrough();
+var config4 = {
+  id: "karaoke",
+  component: Karaoke,
+  name: "Karaoke",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "caption-sync",
+  description: "Word-by-word highlighted captions synced to speech timing. Each word gets a spring scale boost and accent color when its timestamp is active. Past words stay full-opacity; future words dim to 0.4. Reads as confident, transcript-backed captioning.",
+  useWhen: "Podcast clips, interview reels, any video where the audio is the source and the captions need to land word-perfect. Requires structured `words[]` from a transcript pipeline (Groq Whisper, AssemblyAI, etc.) \u2014 do NOT use plain text. For non-synced text, use typewriter or staggered-fade-up.",
+  pairsWith: ["lower-third", "mesh-gradient-bg", "pulsing-indicator"],
+  avoidWith: ["typewriter", "staggered-fade-up", "kinetic-type"],
+  tier: "niche",
+  useCase: ["title-over-footage"],
+  tags: ["text", "captions", "karaoke", "synced", "transcript", "word-level", "podcast"],
+  mood: ["editorial", "breaking-news", "minimal"],
+  paramsSchema: paramsSchema4,
+  propDefaults: { position: "center" },
+  examples: [
+    {
+      name: "podcast-bottom",
+      mood: ["editorial"],
+      params: {
+        words: [
+          { text: "The", startMs: 0, endMs: 200 },
+          { text: "whole", startMs: 200, endMs: 500 },
+          { text: "point", startMs: 500, endMs: 800 },
+          { text: "is", startMs: 800, endMs: 1e3 },
+          { text: "distribution.", startMs: 1e3, endMs: 1600 }
+        ],
+        position: "bottom"
+      },
+      description: "Standard podcast-clip caption position with 5 words sample."
+    }
+  ],
+  textParam: null,
+  subtextParam: null,
+  tokens: [
+    { propPath: "tokens.textColor", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "tokens.activeColor", cssVar: "--cf-accent", fallback: ACCENT, brandKitPath: "colors.accent" },
+    { propPath: "tokens.fontFamily", cssVar: "--cf-font-caption", fallback: resolveTypeface("caption"), brandKitPath: "fonts.caption" }
+  ],
+  durationInFrames: 60,
+  fps: 30,
+  width: 1080,
+  height: 1920,
+  preview: { thumbnailFrame: 30, mode: "loop", defaultExample: "podcast-bottom" }
+};
+
+// ../execution/primitives/src/text/kinetic-type/config.ts
+import { z as z5 } from "zod";
+var tokensSchema3 = z5.object({
+  fontFamily: z5.string().default(resolveTypeface("display")),
+  fontSize: z5.number().optional(),
+  textColor: z5.string().default(FLOOR_TEXT)
+}).passthrough();
+var paramsSchema5 = z5.object({
+  text: z5.string().min(1).max(200).describe("Multi-word phrase. Each word animates independently with stagger. Auto-fits: the phrase shrinks to fit the frame (then wraps) so you are not capped at a short line."),
+  animation: z5.enum(["fly-in", "rotate", "scale-bounce", "cascade"]).default("fly-in").describe(
+    "Per-word animation style. fly-in: slide up. rotate: rotate from tilt. scale-bounce: spring scale pop. cascade: drop from above."
+  ),
+  position: z5.enum(["center", "left", "right"]).default("center").describe("Horizontal alignment of the word block."),
+  accentColor: z5.string().default(ACCENT).describe("Accent for the payoff (last) word. Empty string disables."),
+  tokens: tokensSchema3.default({}).describe("Visual tokens. fontFamily, fontSize, textColor.")
+}).passthrough();
+var config5 = {
+  id: "kinetic-type",
+  component: KineticType,
+  name: "Kinetic Type",
+  category: "text",
+  kind: "component",
+  version: "0.2.1",
+  intent: "reveal-text",
+  description: "Per-word motion typography with four animation styles. Each word springs in with stagger, bringing energy and pace to multi-word phrases. Different from staggered-fade-up: words have actual rotation/scale dynamics, not just position+fade.",
+  useWhen: "Hype reels, kinetic intros, brand statements that need movement. 3\u201310 words is the sweet spot. Avoid for read-along captions (use karaoke) or single words (use blur-reveal/tracking-in). The cascade and rotate variants feel playful \u2014 pick fly-in for editorial work.",
+  pairsWith: ["mesh-gradient-bg", "success-confetti", "spring-pop-in"],
+  avoidWith: ["karaoke", "cinematic-title", "staggered-fade-up"],
+  tier: "niche",
+  useCase: ["emphasis", "intro"],
+  tags: ["text", "kinetic", "typography", "motion", "words", "energetic"],
+  mood: ["playful", "aggressive", "breaking-news"],
+  paramsSchema: paramsSchema5,
+  propDefaults: { animation: "fly-in", position: "center", accentColor: ACCENT },
+  examples: [
+    {
+      name: "fly-in-statement",
+      mood: ["editorial"],
+      params: { text: "Built for builders", animation: "fly-in", position: "center" }
+    },
+    {
+      name: "cascade-drama",
+      mood: ["cinematic", "aggressive"],
+      params: { text: "EVERYTHING CHANGES NOW", animation: "cascade", position: "center" }
+    },
+    {
+      name: "playful-bounce",
+      mood: ["playful"],
+      params: { text: "It just works!", animation: "scale-bounce", position: "center" }
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "tokens.textColor", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "tokens.fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 45, mode: "oneshot", defaultExample: "fly-in-statement" }
+};
+
+// ../execution/primitives/src/text/lower-third/config.ts
+import { z as z6 } from "zod";
+var tokensSchema4 = z6.object({
+  fontFamily: z6.string().default(resolveTypeface("caption")),
+  fontSize: z6.number().optional(),
+  subtitleFontSize: z6.number().optional(),
+  textColor: z6.string().default(FLOOR_TEXT),
+  accentColor: z6.string().optional(),
+  backgroundColor: z6.string().optional()
+}).passthrough();
+var paramsSchema6 = z6.object({
+  text: z6.string().min(1).max(80).describe("Primary line \u2014 speaker name or topic. Auto-fits (shrinks) to the bar."),
+  subtitle: z6.string().max(120).optional().describe("Secondary line \u2014 title, role, or affiliation. Auto-fits (shrinks + wraps to 2 lines)."),
+  variant: z6.enum(["classic", "modern", "cinematic"]).default("classic").describe(
+    "Visual variant. classic: split accent + dark sub bar. modern: full accent rounded bg. cinematic: borderLeft accent + translucent dark."
+  ),
+  tokens: tokensSchema4.default({}).describe("Visual tokens. fontFamily, fontSize, subtitleFontSize, textColor, accentColor, backgroundColor.")
+}).passthrough();
+var config6 = {
+  id: "lower-third",
+  component: LowerThird,
+  name: "Lower Third",
+  category: "text",
+  kind: "component",
+  version: "0.1.2",
+  intent: "name-card",
+  description: "Broadcast-style speaker identification bar at the lower-left. Spring slide-in from the left, spring slide-out at end. Three variants for different aesthetics: classic (TV news split-bar), modern (rounded accent block), cinematic (translucent with accent stripe).",
+  useWhen: "Identify the on-screen speaker, attribute a quote, name a location. Persistent throughout a 4\u20138 second beat. Avoid for content that needs full attention to the imagery \u2014 lower-thirds anchor the eye to the bottom-left.",
+  pairsWith: ["karaoke", "parallax", "vignette", "color-grade"],
+  avoidWith: ["cinematic-title", "changelog-bite"],
+  tier: "standard",
+  useCase: ["title-over-footage"],
+  tags: ["text", "lower-third", "broadcast", "speaker", "name", "attribution"],
+  mood: ["editorial", "corporate", "breaking-news"],
+  paramsSchema: paramsSchema6,
+  propDefaults: { variant: "classic" },
+  examples: [
+    {
+      name: "classic-broadcast",
+      mood: ["breaking-news"],
+      params: { text: "Maya Alvarez", subtitle: "Head of Product", variant: "classic" }
+    },
+    {
+      name: "modern-rounded",
+      mood: ["corporate"],
+      params: { text: "Karan", subtitle: "MindPump Podcast", variant: "modern" }
+    },
+    {
+      name: "cinematic-stripe",
+      mood: ["cinematic"],
+      params: { text: "The Speaker", subtitle: "Topic of the moment", variant: "cinematic" }
+    }
+  ],
+  textParam: "text",
+  subtextParam: "subtitle",
+  tokens: [
+    { propPath: "tokens.textColor", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "tokens.accentColor", cssVar: "--cf-accent", fallback: ACCENT_STRONG, brandKitPath: "colors.accent" },
+    { propPath: "tokens.backgroundColor", cssVar: "--cf-overlay", fallback: "rgba(0, 0, 0, 0.7)", brandKitPath: "colors.overlay" },
+    { propPath: "tokens.fontFamily", cssVar: "--cf-font-sans", fallback: resolveTypeface("caption"), brandKitPath: "fonts.body" }
+  ],
+  durationInFrames: 150,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "loop", defaultExample: "classic-broadcast" }
+};
+
+// ../execution/primitives/src/text/marker-highlight/config.ts
+import { z as z7 } from "zod";
+var paramsSchema7 = z7.object({
+  before: z7.string().default("").describe("Text leading up to the highlighted phrase."),
+  highlight: z7.string().min(1).describe("The phrase to highlight with a swept marker."),
+  after: z7.string().default("").describe("Text after the highlight."),
+  markerColor: z7.string().default(WARNING).describe("Marker/highlighter background color. Yellow is the canonical choice."),
+  baseColor: z7.string().default(FLOOR_TEXT).describe("Color of unhighlighted text (sits over footage before the marker sweeps \u2014 video-safe off-white). The marker then recolors it to highlightedTextColor."),
+  highlightedTextColor: z7.string().default(SURFACE).describe("Color of text inside the marker (often same as base for contrast)."),
+  fontSize: z7.number().min(16).max(180).default(72).describe("Font size in pixels at 1920\xD71080."),
+  fontWeight: z7.number().min(100).max(900).default(600).describe("CSS font weight applied uniformly."),
+  speed: z7.number().min(0.25).max(4).default(1).describe("Playback speed multiplier."),
+  fontFamily: z7.string().default(resolveTypeface("display")).describe("Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme it.")
+}).passthrough();
+var config7 = {
+  id: "marker-highlight",
+  component: MarkerHighlight,
+  name: "Marker Highlight",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "emphasize-word",
+  description: "A highlighter-style colored bar sweeps across a phrase, leaving a marker background behind it. Feels like physically marking up a transcript or note.",
+  useWhen: "Transcript callouts, quote highlighting, study/educational content. Pairs naturally with podcast clips where you want to flag a specific phrase the speaker said. Avoid combining with inline-highlight (both emphasize words; pick one).",
+  pairsWith: ["typewriter", "mesh-gradient-bg", "pulsing-indicator"],
+  avoidWith: ["inline-highlight"],
+  tier: "standard",
+  useCase: ["emphasis"],
+  tags: ["text", "highlight", "marker", "emphasis", "caption", "transcript"],
+  mood: ["editorial", "playful"],
+  paramsSchema: paramsSchema7,
+  propDefaults: { before: "", after: "", markerColor: WARNING, baseColor: FLOOR_TEXT, highlightedTextColor: SURFACE, fontSize: 72, fontWeight: 600, speed: 1, fontFamily: resolveTypeface("display") },
+  examples: [
+    {
+      name: "classic-yellow",
+      mood: ["editorial"],
+      params: { before: "The whole point is ", highlight: "distribution", after: ".", markerColor: WARNING, baseColor: FLOOR_TEXT, highlightedTextColor: SURFACE, fontSize: 80, fontWeight: 600, speed: 1 }
+    },
+    {
+      name: "brand-accent",
+      mood: ["corporate"],
+      params: { before: "It needs to be ", highlight: "fast", after: " and reliable.", markerColor: TEAL, baseColor: FLOOR_TEXT, highlightedTextColor: TEXT_HI, fontSize: 72, fontWeight: 700, speed: 0.9 },
+      description: "Brand-color marker with white text inside. Higher-contrast than the yellow default."
+    }
+  ],
+  textParam: "highlight",
+  subtextParam: null,
+  tokens: [
+    { propPath: "markerColor", cssVar: "--cf-accent", fallback: WARNING, brandKitPath: "colors.accent" },
+    { propPath: "baseColor", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "classic-yellow" }
+};
+
+// ../execution/primitives/src/text/shimmer-sweep/config.ts
+import { z as z8 } from "zod";
+var paramsSchema8 = z8.object({
+  text: z8.string().min(1).max(160).describe("The text to shimmer across. Auto-fits (shrinks) to the stage."),
+  baseColor: z8.string().default("#a1a1aa").describe("Resting color of the text. Muted/desaturated reads best."),
+  shineColor: z8.string().default("#ffffff").describe("Color of the sweeping shine. White or near-white feels metallic."),
+  fontSize: z8.number().min(16).max(240).default(96).describe("Font size in pixels at 1920\xD71080."),
+  fontWeight: z8.number().min(100).max(900).default(700).describe("CSS font weight. Bold weights catch the shimmer better."),
+  speed: z8.number().min(0.25).max(4).default(1).describe("Playback speed multiplier \u2014 controls sweep tempo."),
+  fontFamily: z8.string().default(resolveTypeface("display")).describe("Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme it.")
+}).passthrough();
+var config8 = {
+  id: "shimmer-sweep",
+  component: ShimmerSweep,
+  name: "Shimmer Sweep",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "emphasize-word",
+  description: "A bright shine sweeps left-to-right across the text, briefly catching like light on metal. Subtle motion that adds polish without competing with the content.",
+  useWhen: 'Loop-friendly emphasis when the text needs to feel "alive" but not distract. Logo treatments, premium product names, awards-show vibes. Avoid for time-pressured content (the loop reads as slow).',
+  pairsWith: ["mesh-gradient-bg", "success-confetti", "spring-pop-in"],
+  avoidWith: [],
+  tier: "standard",
+  useCase: ["background", "emphasis"],
+  tags: ["text", "shimmer", "sweep", "shine", "metallic", "loop", "polish"],
+  mood: ["cinematic", "corporate", "minimal"],
+  paramsSchema: paramsSchema8,
+  propDefaults: { baseColor: "#a1a1aa", shineColor: "#ffffff", fontSize: 96, fontWeight: 700, speed: 1, fontFamily: resolveTypeface("display") },
+  examples: [
+    {
+      name: "silver-loop",
+      mood: ["cinematic"],
+      params: { text: "PREMIUM", baseColor: "#a1a1aa", shineColor: "#ffffff", fontSize: 144, fontWeight: 800, speed: 1 }
+    },
+    {
+      name: "brand-shine",
+      mood: ["corporate"],
+      params: { text: "cueframe", baseColor: TEXT_MUTED, shineColor: ACCENT, fontSize: 96, fontWeight: 700, speed: 0.9 }
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "baseColor", cssVar: "--cf-text-muted", fallback: "#a1a1aa", brandKitPath: "colors.textMuted" },
+    { propPath: "shineColor", cssVar: "--cf-accent", fallback: "#ffffff", brandKitPath: "colors.accent" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 45, mode: "loop", defaultExample: "silver-loop" }
+};
+
+// ../execution/primitives/src/text/staggered-fade-up/config.ts
+import { z as z9 } from "zod";
+var paramsSchema9 = z9.object({
+  text: z9.string().min(1).describe("Text to split into words and reveal one at a time."),
+  staggerDelay: z9.number().min(0.5).max(20).default(3).describe("Frames between each word's entrance. Lower = faster cascade."),
+  // coerce: a $brand:motion.staggerMs MISS (no kit) falls back to the string '90'; coercion keeps it a number.
+  staggerMs: z9.coerce.number().nonnegative().optional().describe("Per-word stagger gap in ms (overrides staggerDelay). Bind to $brand:motion.staggerMs."),
+  easing: z9.string().optional().describe("Easing keyword for each word's fade/rise (linear/ease/ease-in/ease-out/ease-in-out). Bind to $brand:motion.easing."),
+  distance: z9.number().min(0).max(200).default(40).describe("Pixels each word travels upward as it fades in. 30\u201360 is the sweet spot."),
+  fontSize: z9.number().min(16).max(240).default(96).describe("Font size in pixels at 1920\xD71080."),
+  fontWeight: z9.number().min(100).max(900).default(600).describe("CSS font weight applied uniformly."),
+  color: z9.string().default(FLOOR_TEXT).describe("Text color. Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."),
+  fontFamily: z9.string().default(resolveTypeface("display")).describe("Display typeface; pass $brand:fonts.heading to theme."),
+  speed: z9.number().min(0.25).max(4).default(1).describe("Playback speed multiplier.")
+}).passthrough();
+var config9 = {
+  id: "staggered-fade-up",
+  component: StaggeredFadeUp,
+  name: "Staggered Fade Up",
+  category: "text",
+  kind: "component",
+  version: "0.1.0",
+  intent: "reveal-text",
+  description: "Words rise into view one at a time, each fading in with an upward translation. Reads as deliberate, considered prose \u2014 every word lands.",
+  useWhen: "Multi-word headlines (3\u20138 words), poetry/quote reveals, cinematic title cards where each word should register. Avoid for single words (use blur-reveal) or runs longer than ~10 words (cascade gets tedious).",
+  pairsWith: ["mesh-gradient-bg", "dynamic-grid", "success-confetti"],
+  avoidWith: ["blur-reveal", "tracking-in"],
+  tier: "standard",
+  useCase: ["title-over-footage"],
+  tags: ["text", "stagger", "reveal", "fade", "words", "cascade", "cinematic"],
+  mood: ["cinematic", "editorial", "soft"],
+  paramsSchema: paramsSchema9,
+  propDefaults: { staggerDelay: 3, distance: 40, fontSize: 96, fontWeight: 600, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), speed: 1 },
+  examples: [
+    {
+      name: "cinematic-headline",
+      mood: ["cinematic"],
+      params: { text: "Built for builders", staggerDelay: 4, distance: 50, fontSize: 120, fontWeight: 700, color: FLOOR_TEXT, speed: 1 }
+    },
+    {
+      name: "poetic",
+      mood: ["editorial", "soft"],
+      params: { text: "A film by someone, somewhere", staggerDelay: 6, distance: 30, fontSize: 80, fontWeight: 400, color: FLOOR_TEXT, speed: 0.85 }
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" },
+    { propPath: "staggerMs", cssVar: "--cf-motion-stagger", fallback: "90", brandKitPath: "motion.staggerMs" },
+    { propPath: "easing", cssVar: "--cf-motion-ease", fallback: "ease-out", brandKitPath: "motion.easing" }
+  ],
+  durationInFrames: 120,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 90, mode: "oneshot", defaultExample: "cinematic-headline" }
+};
+
+// ../execution/primitives/src/text/text-fade-replace/config.ts
+import { z as z10 } from "zod";
+var paramsSchema10 = z10.object({
+  from: z10.string().min(1).describe("Initial text shown for the first half of the duration."),
+  to: z10.string().min(1).describe("Replacement text shown for the second half."),
+  fontSize: z10.number().min(16).max(240).default(96).describe("Font size in pixels at 1920\xD71080."),
+  color: z10.string().default(FLOOR_TEXT).describe("Text color (applied to both from and to). Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."),
+  fontFamily: z10.string().default(resolveTypeface("display")).describe("Display typeface; pass $brand:fonts.heading to theme."),
+  fontWeight: z10.number().min(100).max(900).default(700).describe("CSS font weight."),
+  speed: z10.number().min(0.25).max(4).default(1).describe("Playback speed multiplier.")
+}).passthrough();
+var config10 = {
+  id: "text-fade-replace",
+  component: TextFadeReplace,
+  name: "Text Fade Replace",
+  category: "text",
+  kind: "component",
+  version: "0.1.0",
+  intent: "cycle-text",
+  description: "Cross-fade between two strings on the same line without layout shift. The first text fades out exactly as the second fades in, both centered on the same baseline.",
+  useWhen: 'Caption beat changes ("Question:" \u2192 "Answer:"), product feature cycles ("for everyone" \u2192 "for engineers"), before/after labels. Avoid for >2 strings (use multiple in sequence) and for strings with very different widths (the lack of layout shift makes the longer one feel cramped).',
+  pairsWith: ["mesh-gradient-bg", "pulsing-indicator", "shimmer-sweep"],
+  avoidWith: ["blur-reveal"],
+  tier: "standard",
+  useCase: ["title-over-footage"],
+  tags: ["text", "cycle", "fade", "replace", "caption", "binary"],
+  mood: ["editorial", "minimal", "corporate"],
+  paramsSchema: paramsSchema10,
+  propDefaults: { fontSize: 96, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), fontWeight: 700, speed: 1 },
+  examples: [
+    {
+      name: "q-to-a",
+      mood: ["editorial"],
+      params: { from: "Question.", to: "Answer.", fontSize: 120, color: FLOOR_TEXT, fontWeight: 800, speed: 1 }
+    },
+    {
+      name: "before-after",
+      mood: ["corporate"],
+      params: { from: "Before", to: "After", fontSize: 144, color: FLOOR_TEXT, fontWeight: 700, speed: 0.9 }
+    }
+  ],
+  textParam: "from",
+  subtextParam: "to",
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "loop", defaultExample: "q-to-a" }
+};
+
+// ../execution/primitives/src/text/tracking-in/config.ts
+import { z as z11 } from "zod";
+var paramsSchema11 = z11.object({
+  text: z11.string().min(1).max(90).describe("Text to reveal. 1\u20133 words works best \u2014 letter-tracking changes are most legible at short lengths. Auto-fits: longer copy shrinks to fit the frame so it no longer overflows."),
+  startTracking: z11.number().min(-0.5).max(2).default(0.5).describe("Initial letter-spacing in em units. Higher = more spread at the start of the reveal."),
+  startBlur: z11.number().min(0).max(20).default(8).describe("Initial blur radius in pixels. Cleared as letters condense into place."),
+  fontSize: z11.number().min(16).max(240).default(120).describe("Font size in pixels at 1920\xD71080."),
+  fontWeight: z11.number().min(100).max(900).default(700).describe("CSS font weight."),
+  color: z11.string().default(FLOOR_TEXT).describe("Text color. Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."),
+  fontFamily: z11.string().default(resolveTypeface("display")).describe("Display typeface; pass $brand:fonts.heading to theme."),
+  speed: z11.number().min(0.25).max(4).default(1).describe("Playback speed multiplier.")
+}).passthrough();
+var config11 = {
+  id: "tracking-in",
+  component: TrackingIn,
+  name: "Tracking In",
+  category: "text",
+  kind: "component",
+  version: "0.1.0",
+  intent: "reveal-text",
+  description: 'Letters start spread apart and slightly blurred, then condense into final position with sharp focus. The "from-distance-into-place" feel.',
+  useWhen: "Brand reveals, single-word titles, awards-style intros where the letters should feel like they're assembling themselves. Best for 1\u20133 words; longer strings make tracking changes feel jittery.",
+  pairsWith: ["mesh-gradient-bg", "success-confetti", "shimmer-sweep"],
+  avoidWith: ["blur-reveal", "staggered-fade-up"],
+  tier: "standard",
+  useCase: ["intro"],
+  tags: ["text", "tracking", "letter-spacing", "reveal", "condense", "brand"],
+  mood: ["cinematic", "corporate", "minimal"],
+  paramsSchema: paramsSchema11,
+  propDefaults: { startTracking: 0.5, startBlur: 8, fontSize: 120, fontWeight: 700, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), speed: 1 },
+  examples: [
+    {
+      name: "brand-reveal",
+      mood: ["cinematic", "corporate"],
+      params: { text: "CUEFRAME", startTracking: 0.6, startBlur: 10, fontSize: 144, fontWeight: 800, color: FLOOR_TEXT, speed: 0.9 }
+    },
+    {
+      name: "subtle-title",
+      mood: ["minimal"],
+      params: { text: "Welcome", startTracking: 0.3, startBlur: 5, fontSize: 96, fontWeight: 500, color: FLOOR_TEXT, speed: 1 }
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "brand-reveal" }
+};
+
+// ../execution/primitives/src/text/typewriter/config.ts
+import { z as z12 } from "zod";
+var paramsSchema12 = z12.object({
+  text: z12.string().min(1).max(400).describe(
+    "The text to type out. 20\u201380 characters reads best; longer strings risk losing attention before the cursor finishes. Auto-fits: the text shrinks to fit the frame and wraps to a few lines, so length no longer overflows."
+  ),
+  cursor: z12.boolean().default(true).describe(
+    "Show a blinking cursor at the end of the revealed text."
+  ),
+  charsPerSecond: z12.number().min(2).max(60).default(20).describe(
+    "Typing rate. 20 cps is conversational; 30+ feels urgent; <10 feels deliberate."
+  ),
+  speed: z12.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier independent of charsPerSecond."
+  ),
+  fontSize: z12.number().min(16).max(240).default(72).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame."
+  ),
+  fontWeight: z12.number().min(100).max(900).default(500).describe(
+    "CSS font weight. 500 keeps a terminal/code feel; 700+ skews toward dramatic quote."
+  ),
+  color: z12.string().default(FLOOR_TEXT).describe(
+    "Text color. Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."
+  ),
+  cursorColor: z12.string().optional().describe("Cursor color. Falls back to text color if unset."),
+  fontFamily: z12.string().default(resolveTypeface("display")).describe(
+    "Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme it."
+  )
+}).passthrough();
+var config12 = {
+  id: "typewriter",
+  component: Typewriter,
+  name: "Typewriter",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "reveal-text",
+  description: "Character-by-character text reveal with a deterministic blinking cursor. The classic terminal/typing aesthetic \u2014 feels like the audience is reading along as it types.",
+  useWhen: 'Tech demos, code captions, "the AI is generating something" beats, dialogue/quote reveals. Avoid for hero titles longer than ~80 chars (typing time exceeds attention span) and avoid pairing with another character-by-character animation (matrix-decode, glitch text).',
+  pairsWith: ["glass-code-block", "terminal-simulator", "cursor-flow", "pulsing-indicator"],
+  avoidWith: ["blur-reveal"],
+  tier: "standard",
+  useCase: ["title-over-footage"],
+  tags: ["text", "typewriter", "typing", "terminal", "monospace", "reveal", "progressive"],
+  mood: ["tech-demo", "editorial", "minimal"],
+  paramsSchema: paramsSchema12,
+  propDefaults: { cursor: true, charsPerSecond: 20, speed: 1, fontSize: 72, fontWeight: 500, color: FLOOR_TEXT, fontFamily: resolveTypeface("display") },
+  examples: [
+    {
+      name: "terminal-prompt",
+      mood: ["tech-demo"],
+      params: { text: "$ npm install cueframe", cursor: true, charsPerSecond: 24, fontSize: 64, fontWeight: 500, color: SUCCESS },
+      description: "Green-on-dark terminal prompt feel."
+    },
+    {
+      name: "dialogue",
+      mood: ["editorial", "cinematic"],
+      params: { text: "Hello, world.", cursor: true, charsPerSecond: 12, fontSize: 96, fontWeight: 600, color: FLOOR_TEXT },
+      description: "Slower, larger, dialogue-paced reveal."
+    },
+    {
+      name: "urgent-news",
+      mood: ["breaking-news"],
+      params: { text: "BREAKING:", cursor: false, charsPerSecond: 40, fontSize: 120, fontWeight: 800, color: "#dc2626" },
+      description: "Fast type, no cursor, red. Breaking-news tickers."
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "cursorColor", cssVar: "--cf-accent", fallback: SUCCESS, brandKitPath: "colors.accent" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 120,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 90, mode: "loop", defaultExample: "terminal-prompt" }
+};
+
+// ../execution/primitives/src/text/matrix-decode/config.ts
+import { z as z13 } from "zod";
+var paramsSchema13 = z13.object({
+  text: z13.string().min(1).max(220).describe(
+    "The final text that decodes into place. Auto-fits (shrinks to the frame, then ellipsizes). 6\u201340 characters reads cleanly; longer strings spend too long in the scrambled state."
+  ),
+  charset: z13.string().min(1).max(80).default("!@#$%^&*()_+-=<>?/\\|").describe(
+    "Pool of characters to scramble through before each glyph resolves. Symbol-heavy charsets feel hacker; alphanumeric feels softer."
+  ),
+  fontSize: z13.number().min(16).max(240).default(72).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame. 64\u201396 reads as headline; 120+ as hero."
+  ),
+  fontWeight: z13.number().min(100).max(900).default(600).describe(
+    "CSS font weight. 600 keeps the monospace decode feel; 700+ leans dramatic; 400 feels terminal-quiet."
+  ),
+  color: z13.string().default(SUCCESS).describe(
+    "Text color of the resolved glyphs. Green-on-white is the canonical Matrix vibe; high-contrast brand colors also work."
+  ),
+  revealDuration: z13.number().min(15).max(240).default(60).describe(
+    "Frames for all glyphs to finish resolving. Shorter (30\u201345) feels snappy; longer (90+) lets the audience savor the scramble."
+  ),
+  speed: z13.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier independent of revealDuration."
+  ),
+  fontFamily: z13.string().default(resolveTypeface("mono")).describe("Monospace typeface. Fixed to the bundled mono face (Space Mono floor) \u2014 the decode column-shuffle depends on fixed-width glyphs, so brand fonts (serif/display) intentionally do NOT override it.")
+}).passthrough();
+var config13 = {
+  id: "matrix-decode",
+  component: MatrixDecode,
+  name: "Matrix Decode",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "glitch-decode",
+  description: "Per-character scramble that resolves left-to-right into the final text. Each glyph cycles through a charset of symbols before snapping to its true character. Hacker/cypherpunk aesthetic \u2014 feels like the system is being decrypted in real time.",
+  useWhen: 'Tech demos, "AI is thinking" beats, hacker/cypherpunk reveals, codename or version-string drops. Best with monospace-friendly content (commands, hashes, hostnames). Avoid for emotional/editorial copy (wrong tone) and avoid pairing with another character-by-character animation like typewriter or rgb-glitch-text on the same beat.',
+  pairsWith: ["glass-code-block", "terminal-simulator", "pulsing-indicator", "grain"],
+  avoidWith: ["typewriter", "rgb-glitch-text", "blur-reveal"],
+  tier: "niche",
+  useCase: ["emphasis"],
+  tags: ["text", "matrix", "decode", "scramble", "hacker", "cypherpunk", "monospace", "glitch"],
+  mood: ["tech-demo", "glitchy", "aggressive"],
+  paramsSchema: paramsSchema13,
+  propDefaults: {
+    charset: "!@#$%^&*()_+-=<>?/\\|",
+    fontSize: 72,
+    fontWeight: 600,
+    color: SUCCESS,
+    revealDuration: 60,
+    speed: 1,
+    fontFamily: resolveTypeface("mono")
+  },
+  examples: [
+    {
+      name: "classic-matrix",
+      mood: ["tech-demo", "glitchy"],
+      params: { text: "ACCESS GRANTED", charset: "01!@#$%&*<>/\\|", fontSize: 88, fontWeight: 600, color: SUCCESS, revealDuration: 60 },
+      description: "Green-on-white symbol-heavy decode \u2014 the canonical Matrix vibe."
+    },
+    {
+      name: "hash-reveal",
+      mood: ["tech-demo"],
+      params: { text: "0xCAFEBABE", charset: "0123456789abcdef", fontSize: 96, fontWeight: 500, color: FLOOR_TEXT, revealDuration: 45 },
+      description: "Snappy hex decode for hash/address reveals."
+    },
+    {
+      name: "aggressive-codename",
+      mood: ["aggressive", "breaking-news"],
+      params: { text: "PROJECT NEMESIS", charset: "!@#$%^&*()_+-=<>?/\\|", fontSize: 120, fontWeight: 800, color: DANGER, revealDuration: 36 },
+      description: "Fast, large, red \u2014 codename or product reveal."
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-accent", fallback: SUCCESS, brandKitPath: "colors.accent" }
+    // No fontFamily brand binding: the decode effect requires fixed-width mono
+    // (Space Mono floor). There is no fonts.mono brand path, and binding to
+    // fonts.heading would let a serif/display brand face break the column shuffle.
+  ],
+  durationInFrames: 120,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 45, mode: "oneshot", defaultExample: "classic-matrix" }
+};
+
+// ../execution/primitives/src/text/rgb-glitch-text/config.ts
+import { z as z14 } from "zod";
+var paramsSchema14 = z14.object({
+  text: z14.string().min(1).max(220).describe(
+    "Text to display. The base text holds steady; RGB-split copies offset on top during the glitch window. 4\u201330 chars reads punchiest."
+  ),
+  fontSize: z14.number().min(24).max(320).default(96).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame. Glitch reads best at hero scale (96\u2013160)."
+  ),
+  fontWeight: z14.number().min(100).max(900).default(700).describe(
+    "CSS font weight. 700+ gives the chunky chromatic-split look; lighter weights wash out under the offset copies."
+  ),
+  color: z14.string().default(FLOOR_TEXT).describe("Base text color (video-safe off-white). The R/G/B copies are fixed (#ff0040, #00ff80, #0080ff) and screen-blend (additive) so the chromatic split glows over footage."),
+  glitchAt: z14.number().min(0).max(600).default(20).describe(
+    "Frame at which the glitch window begins. Set ~10\u201330 frames in so the audience reads the title before it cracks."
+  ),
+  glitchDuration: z14.number().min(2).max(60).default(8).describe(
+    "Length of the glitch window in frames. 6\u201312 frames is a sharp punch; 20+ feels like sustained corruption."
+  ),
+  intensity: z14.number().min(0).max(40).default(6).describe(
+    "Pixel offset magnitude for the R/G/B copies. 4\u20138 reads as crisp glitch; 12+ becomes near-illegible. Use sparingly."
+  ),
+  seed: z14.string().min(1).max(32).default("glitch").describe(
+    "Deterministic seed for the per-frame jitter. Change it to get a different glitch pattern with the same params."
+  ),
+  speed: z14.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier. Note: glitchAt and glitchDuration are in source frames before the speed multiplier."
+  ),
+  fontFamily: z14.string().default(resolveTypeface("display")).describe("Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme it.")
+}).passthrough();
+var config14 = {
+  id: "rgb-glitch-text",
+  component: RGBGlitchText,
+  name: "RGB Glitch Text",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "glitch-text",
+  description: "Static text that fractures into red/green/blue chromatic-aberration copies during a configurable glitch window. The base text never moves; the offset color copies appear, jitter for `glitchDuration` frames, then disappear. Crisp cyberpunk/CRT-failure aesthetic.",
+  useWhen: 'Hard cuts, beat-drops, "system corrupted" moments, breaking-news stings, hype-reel punctuation. Place the glitch on the audio hit. Avoid for sustained titles (the eye gets tired in <1 second of glitch) and avoid pairing with matrix-decode or another glitch primitive on the same beat \u2014 the effects fight for attention.',
+  pairsWith: ["glitch-cut", "chromatic-aberration-wipe", "grain", "mesh-gradient-bg"],
+  avoidWith: ["matrix-decode", "typewriter", "blur-reveal"],
+  tier: "niche",
+  useCase: ["emphasis"],
+  tags: ["text", "glitch", "rgb", "chromatic-aberration", "cyberpunk", "crt", "corruption"],
+  mood: ["glitchy", "aggressive", "breaking-news", "tech-demo"],
+  paramsSchema: paramsSchema14,
+  propDefaults: {
+    fontSize: 96,
+    fontWeight: 700,
+    color: FLOOR_TEXT,
+    glitchAt: 20,
+    glitchDuration: 8,
+    intensity: 6,
+    seed: "glitch",
+    speed: 1,
+    fontFamily: resolveTypeface("display")
+  },
+  examples: [
+    {
+      name: "beat-drop",
+      mood: ["aggressive", "glitchy"],
+      params: { text: "SYSTEM ONLINE", fontSize: 128, fontWeight: 800, color: FLOOR_TEXT, glitchAt: 24, glitchDuration: 10, intensity: 8 },
+      description: "Hero text that cracks on the audio hit."
+    },
+    {
+      name: "sustained-corruption",
+      mood: ["glitchy"],
+      params: { text: "CORRUPTED", fontSize: 144, fontWeight: 800, color: DANGER, glitchAt: 0, glitchDuration: 30, intensity: 5 },
+      description: 'Long glitch window for "system failure" beats. Use carefully \u2014 eye fatigue.'
+    },
+    {
+      name: "breaking-news-sting",
+      mood: ["breaking-news"],
+      params: { text: "LIVE", fontSize: 160, fontWeight: 900, color: DANGER, glitchAt: 12, glitchDuration: 6, intensity: 7 },
+      description: "Short, hard glitch on a one-word breaking-news ID."
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 28, mode: "oneshot", defaultExample: "beat-drop" }
+};
+
+// ../execution/primitives/src/text/quote-card/config.ts
+import { z as z15 } from "zod";
+var paramsSchema15 = z15.object({
+  quote: z15.string().min(1).max(220).describe("The quote text (no quote marks \u2014 the card draws its own oversized mark). 8\u201324 words reads best."),
+  author: z15.string().max(60).default("").describe("Attribution name."),
+  role: z15.string().max(80).default("").describe("Attribution role/company line."),
+  accentColor: z15.string().default(ACCENT).describe("Quote mark + attribution rule accent.")
+}).passthrough();
+var config15 = {
+  id: "quote-card",
+  component: QuoteCard,
+  name: "Quote Card",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "name-card",
+  description: "Attributed testimonial: an oversized accent quote mark drops in with weight, the quote reveals word-by-word on a masked rise, an accent rule draws, and the attribution fades up. Idles on a quiet hold with a breathing mark.",
+  useWhen: "Customer testimonials, press quotes, founder statements \u2014 the social-proof beat of a launch video. Over footage of the speaker or a background primitive. For speaker NAME captions during footage use lower-third instead.",
+  pairsWith: ["silk-flow-bg", "dither-gradient-bg", "vignette", "color-grade"],
+  avoidWith: ["lower-third", "cinematic-title"],
+  tier: "recommended",
+  useCase: ["full-scene", "title-over-footage"],
+  tags: ["text", "quote", "testimonial", "attribution", "social-proof"],
+  mood: ["editorial", "corporate", "cinematic"],
+  paramsSchema: paramsSchema15,
+  propDefaults: {
+    quote: "It replaced our entire editing pipeline in a week.",
+    author: "Maya Alvarez",
+    role: "Head of Product",
+    accentColor: ACCENT
+  },
+  examples: [
+    { name: "customer-proof", mood: ["corporate"], params: { quote: "It replaced our entire editing pipeline in a week.", author: "Maya Alvarez", role: "Head of Product", accentColor: ACCENT } },
+    { name: "press-pull", mood: ["editorial"], params: { quote: "The most opinionated take on programmatic video yet.", author: "The Weekly Build", role: "", accentColor: SUCCESS } }
+  ],
+  textParam: "quote",
+  subtextParam: "author",
+  tokens: [
+    { propPath: "accentColor", cssVar: "--cf-accent", fallback: ACCENT, brandKitPath: "colors.accent" }
+  ],
+  durationInFrames: 150,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 80, mode: "oneshot", defaultExample: "customer-proof" }
+};
+
+// ../execution/primitives/src/text/slot-machine-roll/config.ts
+import { z as z16 } from "zod";
+var paramsSchema16 = z16.object({
+  from: z16.string().min(1).max(20).default("$99").describe(
+    "Starting value (top of the column). Numbers, prices, scores, or short codes work best \u2014 long strings break the slot-reel feel."
+  ),
+  to: z16.string().min(1).max(20).default("$199").describe(
+    "Ending value (bottom of the column, where the reel lands). Should be the same character class as `from` for visual coherence."
+  ),
+  fontSize: z16.number().min(24).max(320).default(120).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame. Slot-machine reads as a hero element \u2014 96\u2013160 is the sweet spot."
+  ),
+  fontWeight: z16.number().min(100).max(900).default(700).describe(
+    "CSS font weight. 700+ gives the chunky scoreboard look; 500 reads more editorial."
+  ),
+  color: z16.string().default(FLOOR_TEXT).describe("Text color. Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."),
+  fontFamily: z16.string().default(resolveTypeface("display")).describe("Display typeface; pass $brand:fonts.heading to theme."),
+  speed: z16.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier. Slower (0.5\u20130.75) emphasizes the roll; faster (1.5+) makes it incidental."
+  )
+}).passthrough();
+var config16 = {
+  id: "slot-machine-roll",
+  component: SlotMachineRoll,
+  name: "Slot Machine Roll",
+  category: "text",
+  kind: "component",
+  version: "0.1.0",
+  intent: "roll-numbers",
+  description: "Per-column vertical roll from a starting value to an ending value, like a slot reel landing. Each column springs in with stagger, so the rightmost digits land last. Feels like a counter, scoreboard, or price update.",
+  useWhen: 'Price changes, score updates, version bumps, follower-count flips, before/after stat reveals. Both `from` and `to` should be short and the same character class (numbers\u2192numbers, prices\u2192prices). Avoid for prose or multi-word phrases \u2014 use kinetic-type or staggered-fade-up instead. Avoid pairing with strikethrough-replace on the same beat (both communicate "value changed" and read as redundant).',
+  pairsWith: ["lower-third", "success-confetti", "spring-pop-in", "pulsing-indicator"],
+  avoidWith: ["strikethrough-replace", "text-fade-replace"],
+  tier: "standard",
+  useCase: ["emphasis"],
+  tags: ["text", "slot-machine", "roll", "counter", "numbers", "price", "scoreboard", "stat"],
+  mood: ["playful", "corporate", "editorial"],
+  paramsSchema: paramsSchema16,
+  propDefaults: { from: "$99", to: "$199", fontSize: 120, fontWeight: 700, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), speed: 1 },
+  examples: [
+    {
+      name: "price-bump",
+      mood: ["corporate", "editorial"],
+      params: { from: "$99", to: "$199", fontSize: 160, fontWeight: 800, color: FLOOR_TEXT },
+      description: "Classic price-change reveal for promo or pricing-page video."
+    },
+    {
+      name: "follower-count",
+      mood: ["playful"],
+      params: { from: "10K", to: "100K", fontSize: 140, fontWeight: 700, color: "#2563eb" },
+      description: "Milestone counter flip \u2014 followers, downloads, signups."
+    },
+    {
+      name: "version-bump",
+      mood: ["tech-demo"],
+      params: { from: "v2.0", to: "v3.0", fontSize: 120, fontWeight: 600, color: FLOOR_TEXT },
+      description: "Version reveal for changelog/release video."
+    }
+  ],
+  textParam: "to",
+  subtextParam: "from",
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 70, mode: "oneshot", defaultExample: "price-bump" }
+};
+
+// ../execution/primitives/src/text/stat-counter/config.ts
+import { z as z17 } from "zod";
+var paramsSchema17 = z17.object({
+  value: z17.number().min(0).max(1e12).describe("The number that lands. Counts up from 0 with an expo settle."),
+  prefix: z17.string().max(4).default("").describe("Glyphs before the number ('$', '\u20AC', '~')."),
+  suffix: z17.string().max(6).default("").describe("Glyphs after the number ('+', '%', 'k', 'M') \u2014 rendered in the accent color."),
+  label: z17.string().max(60).default("").describe("Uppercase caption under the number ('ACTIVE USERS', 'ARR'). Rises in after the count lands."),
+  accentColor: z17.string().default(ACCENT).describe("Underline + suffix accent."),
+  decimals: z17.number().int().min(0).max(2).default(0).describe("Decimal places (99.99% \u2192 2)."),
+  countFrames: z17.number().int().min(10).max(150).default(45).describe("Frames the count-up takes."),
+  position: z17.enum(["center", "left", "right"]).default("center").describe("Horizontal placement.")
+}).passthrough();
+var config17 = {
+  id: "stat-counter",
+  component: StatCounter,
+  name: "Stat Counter",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "reveal-text",
+  description: 'The launch-video staple: a big number counts up and LANDS \u2014 expo-eased so the final digits settle, tabular numerals (no jitter), an accent underline that draws in as the count completes and glows gently at idle, and an uppercase label that rises in after. "$2M ARR", "10k+ users", "99.99% uptime".',
+  useWhen: "Traction beats, metric reveals, pricing anchors \u2014 any moment the video needs a number to land with weight. Pair over footage or a background primitive. One stat per beat; for dashboards of many numbers use dashboard-populate instead.",
+  pairsWith: ["silk-flow-bg", "mesh-gradient-bg", "dither-gradient-bg", "vignette", "staggered-fade-up"],
+  avoidWith: ["slot-machine-roll", "dashboard-populate"],
+  tier: "recommended",
+  useCase: ["emphasis", "title-over-footage"],
+  tags: ["text", "number", "counter", "stat", "metric", "count-up", "launch"],
+  mood: ["corporate", "tech-demo", "editorial"],
+  paramsSchema: paramsSchema17,
+  propDefaults: {
+    value: 1e4,
+    prefix: "",
+    suffix: "+",
+    label: "ACTIVE USERS",
+    accentColor: ACCENT,
+    decimals: 0,
+    countFrames: 45,
+    position: "center"
+  },
+  examples: [
+    { name: "users-landed", mood: ["corporate"], params: { value: 1e4, suffix: "+", label: "ACTIVE USERS", accentColor: ACCENT, countFrames: 45, position: "center" } },
+    { name: "arr", mood: ["corporate", "editorial"], params: { value: 2, prefix: "$", suffix: "M", label: "ANNUAL RECURRING REVENUE", accentColor: SUCCESS, countFrames: 40, position: "center" } },
+    { name: "uptime", mood: ["tech-demo"], params: { value: 99.99, suffix: "%", label: "UPTIME", accentColor: ACCENT, decimals: 2, countFrames: 50, position: "center" } }
+  ],
+  textParam: "label",
+  subtextParam: null,
+  tokens: [
+    { propPath: "accentColor", cssVar: "--cf-accent", fallback: ACCENT, brandKitPath: "colors.accent" }
+  ],
+  durationInFrames: 120,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 70, mode: "oneshot", defaultExample: "users-landed" }
+};
+
+// ../execution/primitives/src/text/token-stream/config.ts
+import { z as z18 } from "zod";
+var paramsSchema18 = z18.object({
+  text: z18.string().min(1).max(400).describe("The response text that streams in token-by-token. 15\u201350 words reads best."),
+  tokensPerSecond: z18.number().min(2).max(30).default(9).describe("Average streaming cadence. 8\u201312 feels like a fast model; 4\u20136 deliberate."),
+  accentColor: z18.string().default(ACCENT).describe("Cursor accent."),
+  startAt: z18.number().int().min(0).max(90).default(8).describe("Frames of hold before the first token.")
+}).passthrough();
+var config18 = {
+  id: "token-stream",
+  component: TokenStream,
+  name: "Token Stream",
+  category: "text",
+  kind: "component",
+  version: "0.1.1",
+  intent: "reveal-text",
+  description: "THE AI visual: a response streams in token-by-token on an irregular, human-feeling cadence \u2014 deterministic jitter with occasional micro-pauses, each token fading up, a block cursor pulsing at the head. On completion the cursor blinks twice and fades. Running text, not a terminal gimmick (that is typewriter).",
+  useWhen: 'Model output reveals, copilot answer beats, "watch it respond" moments in AI product launches. Over footage or a background primitive. For monospace CLI streaming use typewriter; for a full conversation use chat-exchange.',
+  pairsWith: ["dither-gradient-bg", "vector-field", "silk-flow-bg", "vignette"],
+  avoidWith: ["typewriter", "chat-exchange"],
+  tier: "recommended",
+  useCase: ["title-over-footage", "full-scene", "explainer"],
+  tags: ["text", "ai", "llm", "streaming", "tokens", "cursor", "response"],
+  mood: ["tech-demo", "minimal"],
+  paramsSchema: paramsSchema18,
+  propDefaults: {
+    text: "Here is the summary you asked for \u2014 three risks, two of them already mitigated, and one decision that needs you today.",
+    tokensPerSecond: 9,
+    accentColor: ACCENT,
+    startAt: 8
+  },
+  examples: [
+    { name: "assistant-answer", mood: ["tech-demo"], params: { text: "Here is the summary you asked for \u2014 three risks, two of them already mitigated, and one decision that needs you today.", tokensPerSecond: 9, accentColor: ACCENT } },
+    { name: "deliberate-reasoning", mood: ["minimal"], params: { text: "Thinking through the tradeoffs: speed favors the cache, correctness favors the queue. Recommending the queue.", tokensPerSecond: 5, accentColor: VIOLET } }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "accentColor", cssVar: "--cf-accent", fallback: ACCENT, brandKitPath: "colors.accent" }
+  ],
+  durationInFrames: 180,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 60, mode: "oneshot", defaultExample: "assistant-answer" }
+};
+
+// ../execution/primitives/src/text/strikethrough-replace/config.ts
+import { z as z19 } from "zod";
+var paramsSchema19 = z19.object({
+  from: z19.string().min(1).max(140).describe(
+    'Original phrase. A line draws across it during the first 40% of duration. Keep short \u2014 this is the "wrong/old" half of a comparison.'
+  ),
+  to: z19.string().min(1).max(140).describe(
+    'Replacement phrase that fades up after the strikethrough completes. Often the "new/correct/better" half of the comparison.'
+  ),
+  lineColor: z19.string().default("#ff5e3a").describe(
+    'Color of the strikethrough bar. Hot orange/red reads as "rejected"; brand color softens the verdict.'
+  ),
+  fontSize: z19.number().min(16).max(240).default(48).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame. 48\u201372 is the lower-third / caption sweet spot for this effect."
+  ),
+  fontWeight: z19.number().min(100).max(900).default(600).describe(
+    "CSS font weight. 600 gives editorial weight without overpowering the line."
+  ),
+  color: z19.string().default(FLOOR_TEXT).describe("Text color for both `from` and `to` (video-safe off-white over footage); pass $brand:colors.textOnMedia to theme."),
+  fontFamily: z19.string().default(resolveTypeface("display")).describe("Display typeface. Defaults to the brand display face (Bricolage Grotesque floor); pass $brand:fonts.heading to theme."),
+  speed: z19.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier. The effect divides duration into strike (0\u201340%), fade (40\u201360%), hold (60\u2013100%) regardless of speed."
+  )
+}).passthrough();
+var config19 = {
+  id: "strikethrough-replace",
+  component: StrikethroughReplace,
+  name: "Strikethrough Replace",
+  category: "text",
+  kind: "component",
+  version: "0.1.0",
+  intent: "replace-text",
+  description: 'Draws a strikethrough across the `from` text, then fades it to the `to` text in place. Three phases: line draws (0\u201340%), crossfade with slight rise (40\u201360%), hold (60\u2013100%). Communicates "this, not that" \u2014 myth-busting, before/after, correction.',
+  useWhen: 'Myth-vs-fact captions, "no, actually" reveals, before/after framing, debunking pull-quotes, marketing comparisons (their thing \u2192 our thing). Both phrases should be roughly the same length so the eye sees the same slot getting overwritten. Avoid for emotional reveals (use blur-reveal or cinematic-title) and avoid pairing with slot-machine-roll on the same beat \u2014 both say "value changed" and read as redundant.',
+  pairsWith: ["lower-third", "inline-highlight", "marker-highlight", "pulsing-indicator"],
+  avoidWith: ["slot-machine-roll", "text-fade-replace"],
+  tier: "standard",
+  useCase: ["emphasis", "title-over-footage"],
+  tags: ["text", "strikethrough", "replace", "before-after", "comparison", "myth-bust", "correction"],
+  mood: ["editorial", "breaking-news", "corporate"],
+  paramsSchema: paramsSchema19,
+  propDefaults: { lineColor: "#ff5e3a", fontSize: 48, fontWeight: 600, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), speed: 1 },
+  examples: [
+    {
+      name: "myth-vs-fact",
+      mood: ["editorial"],
+      params: { from: "AI replaces engineers", to: "AI augments engineers", lineColor: "#ff5e3a", fontSize: 56, fontWeight: 600, color: FLOOR_TEXT },
+      description: "Classic myth-busting caption."
+    },
+    {
+      name: "before-after-pricing",
+      mood: ["corporate"],
+      params: { from: "$199/month", to: "$49/month", lineColor: "#dc2626", fontSize: 72, fontWeight: 700, color: FLOOR_TEXT },
+      description: "Pricing comparison with a hard red line."
+    },
+    {
+      name: "soft-correction",
+      mood: ["editorial", "minimal"],
+      params: { from: "fast", to: "instant", lineColor: "#94a3b8", fontSize: 96, fontWeight: 500, color: FLOOR_TEXT },
+      description: "Subtle gray strike for editorial copy upgrades."
+    }
+  ],
+  textParam: "to",
+  subtextParam: "from",
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" },
+    { propPath: "lineColor", cssVar: "--cf-accent", fallback: "#ff5e3a", brandKitPath: "colors.accent" }
+  ],
+  durationInFrames: 120,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 90, mode: "oneshot", defaultExample: "myth-vs-fact" }
+};
+
+// ../execution/primitives/src/text/masked-slide-reveal/config.ts
+import { z as z20 } from "zod";
+var paramsSchema20 = z20.object({
+  text: z20.string().min(1).max(280).describe(
+    "Phrase to reveal. Words are split on whitespace and each slides up from below its own clipping mask. 3\u201310 words reads cleanest."
+  ),
+  staggerDelay: z20.number().min(0).max(20).default(3).describe(
+    "Frames between successive word reveals. 2\u20134 feels brisk; 6+ feels deliberate, almost choreographed."
+  ),
+  fontSize: z20.number().min(24).max(320).default(72).describe(
+    "Font size in pixels at the canonical 1920\xD71080 frame. The masked-slide effect needs hero scale to read \u2014 72\u2013120 is the sweet spot."
+  ),
+  fontWeight: z20.number().min(100).max(900).default(700).describe(
+    "CSS font weight. 700+ gives the chunky editorial feel that the reveal pattern is built for."
+  ),
+  color: z20.string().default(FLOOR_TEXT).describe("Text color. Defaults to a video-safe off-white (text sits over footage); pass $brand:colors.textOnMedia to theme it."),
+  fontFamily: z20.string().default(resolveTypeface("display")).describe("Display typeface; pass $brand:fonts.heading to theme."),
+  speed: z20.number().min(0.25).max(4).default(1).describe(
+    "Playback speed multiplier independent of staggerDelay."
+  )
+}).passthrough();
+var config20 = {
+  id: "masked-slide-reveal",
+  component: MaskedSlideReveal,
+  name: "Masked Slide Reveal",
+  category: "text",
+  kind: "component",
+  version: "0.1.0",
+  intent: "reveal-text",
+  description: "Per-word slide-up from a clipping mask, with spring damping and stagger. Each word emerges from beneath an invisible bottom edge, so glyphs appear to be cut by a hard line until they snap into place. Editorial/award-show typography feel.",
+  useWhen: "Hero titles, intro statements, manifesto-style declarations, lecture/conference card reveals. 3\u201310 words is the sweet spot. Avoid for read-along captions (use karaoke), for single words (use blur-reveal or tracking-in), and for content where the bottom edge of the canvas is busy with other elements (the mask becomes visible and looks broken). Don't pair with kinetic-type \u2014 both are per-word reveals and read as competing.",
+  pairsWith: ["mesh-gradient-bg", "cinematic-title", "lower-third", "grain"],
+  avoidWith: ["kinetic-type", "staggered-fade-up", "karaoke"],
+  tier: "recommended",
+  useCase: ["title-over-footage", "intro"],
+  tags: ["text", "masked", "slide", "reveal", "per-word", "editorial", "spring", "hero"],
+  mood: ["editorial", "cinematic", "minimal"],
+  paramsSchema: paramsSchema20,
+  propDefaults: { staggerDelay: 3, fontSize: 72, fontWeight: 700, color: FLOOR_TEXT, fontFamily: resolveTypeface("display"), speed: 1 },
+  examples: [
+    {
+      name: "manifesto-statement",
+      mood: ["editorial", "cinematic"],
+      params: { text: "Built for the next decade", staggerDelay: 4, fontSize: 96, fontWeight: 700, color: FLOOR_TEXT },
+      description: "Hero title with deliberate per-word stagger."
+    },
+    {
+      name: "snappy-intro",
+      mood: ["minimal"],
+      params: { text: "A new way to ship", staggerDelay: 2, fontSize: 80, fontWeight: 600, color: FLOOR_TEXT },
+      description: "Quick stagger for intro/opener cards."
+    },
+    {
+      name: "cinematic-pull-quote",
+      mood: ["cinematic"],
+      params: { text: "The future is uneven", staggerDelay: 6, fontSize: 120, fontWeight: 800, color: FLOOR_TEXT },
+      description: "Slow, large, editorial pull-quote."
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-text-onmedia", fallback: FLOOR_TEXT, brandKitPath: "colors.textOnMedia" },
+    { propPath: "fontFamily", cssVar: "--cf-font-display", fallback: resolveTypeface("display"), brandKitPath: "fonts.heading" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 50, mode: "oneshot", defaultExample: "manifesto-statement" }
+};
+
+// ../execution/primitives/src/text/text-effect/config.ts
+import { z as z21 } from "zod";
+var paramsSchema21 = z21.object({
+  text: z21.string().min(1).max(80).optional().describe(
+    "Text to style. Required in practice \u2014 the component renders nothing without it (or children in code use)."
+  ),
+  type: z21.enum(["gradient", "neon", "glow", "wave", "outline", "shadow"]).describe(
+    "CSS treatment to apply to the wrapped text. gradient/wave bake a color sweep into the glyphs; neon/glow add radial light bleed; outline strokes the glyphs; shadow drops a soft offset shadow."
+  ),
+  colors: z21.array(z21.string()).min(2).max(6).default([DANGER, TEAL, BLUE]).describe(
+    "Palette for gradient and wave effects. 2\u20134 colors read cleanly; more becomes a smear. Ignored by neon/glow/outline/shadow."
+  ),
+  color: z21.string().default(ACCENT).describe(
+    "Single color for neon/glow/outline/shadow effects. Ignored by gradient/wave."
+  ),
+  intensity: z21.number().min(0).max(1).default(0.8).describe(
+    "Effect strength 0\u20131. 0.6\u20130.8 keeps text readable; 1.0 maxes the glow/stroke and starts losing edges."
+  )
+}).passthrough();
+var config21 = {
+  id: "text-effect",
+  component: TextEffect,
+  name: "Text Effect",
+  category: "text",
+  kind: "component",
+  version: "0.1.2",
+  intent: "style-text",
+  description: "Composable CSS-only treatment that wraps another text primitive (cinematic-title, kinetic-type, etc.) and applies a styled appearance \u2014 gradient fill, neon glow, color-cycle wave, stroke outline, or drop shadow. Static styling layer; carries no animation of its own. Pairs with any text primitive that renders glyphs.",
+  useWhen: "When a text primitive needs a vibe shift (neon arcade, gradient hype, outline-only minimalism) without rebuilding the underlying animation. Wrap, don't embed. Avoid stacking multiple TextEffect wrappers on the same content (the inner one wins or both fight). Skip for content where readability matters more than vibe (lower-thirds, captions).",
+  pairsWith: ["cinematic-title", "kinetic-type", "tracking-in", "staggered-fade-up"],
+  avoidWith: ["lower-third", "karaoke", "inline-highlight"],
+  tier: "niche",
+  useCase: ["title-over-footage"],
+  tags: ["text", "effect", "style", "gradient", "neon", "glow", "outline", "shadow", "wrapper"],
+  mood: ["playful", "aggressive", "cinematic", "tech-demo"],
+  paramsSchema: paramsSchema21,
+  propDefaults: {
+    colors: [DANGER, TEAL, BLUE],
+    color: ACCENT,
+    intensity: 0.8
+  },
+  examples: [
+    {
+      name: "neon-arcade",
+      mood: ["playful", "aggressive"],
+      params: { text: "GAME ON", type: "neon", color: ACCENT, intensity: 0.9 },
+      description: "Mandarin neon glow \u2014 arcade/synthwave wrapper."
+    },
+    {
+      name: "sunset-gradient",
+      mood: ["cinematic", "editorial"],
+      params: { text: "Golden hour", type: "gradient", colors: [DANGER, ACCENT, WARNING], intensity: 0.8 },
+      description: "Warm gradient fill across the glyphs."
+    },
+    {
+      name: "minimal-outline",
+      mood: ["minimal", "editorial"],
+      params: { text: "MONOCHROME", type: "outline", color: FLOOR_TEXT, intensity: 0.7 },
+      description: "Stroke-only text \u2014 gallery/editorial feel."
+    }
+  ],
+  textParam: "text",
+  subtextParam: null,
+  tokens: [
+    { propPath: "color", cssVar: "--cf-accent", fallback: ACCENT, brandKitPath: "colors.accent" }
+  ],
+  durationInFrames: 90,
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  preview: { thumbnailFrame: 45, mode: "loop", defaultExample: "neon-arcade" }
+};
+
+// ../execution/primitives/src/text/index.ts
+var catalog = [
+  config,
+  config2,
+  config3,
+  config4,
+  config5,
+  config6,
+  config7,
+  config8,
+  config9,
+  config10,
+  config11,
+  config12,
+  config13,
+  config14,
+  config16,
+  config19,
+  config20,
+  config21,
+  config15,
+  config17,
+  config18
+];
+
+export {
+  BlurReveal,
+  CinematicTitle,
+  InlineHighlight,
+  Karaoke,
+  KineticType,
+  LowerThird,
+  MarkerHighlight,
+  ShimmerSweep,
+  StaggeredFadeUp,
+  TextEffect,
+  TextFadeReplace,
+  TrackingIn,
+  Typewriter,
+  MatrixDecode,
+  RGBGlitchText,
+  QuoteCard,
+  SlotMachineRoll,
+  StatCounter,
+  TokenStream,
+  StrikethroughReplace,
+  MaskedSlideReveal,
+  catalog
+};