@phont-ai/subtitles-core 0.1.10 → 0.2.2

package/dist/index.d.mts

@@ -45,6 +45,128 @@ interface PhontClientOptions {
     apiBaseUrl?: string;
 }
 
+/**
+ * Animation Types
+ *
+ * Type definitions for animation parameter states, curves, and animation state
+ */
+interface CurvePoint {
+    time: number;
+    value: number | string;
+}
+interface ParameterState {
+    points: CurvePoint[];
+    currentValue?: number | string;
+}
+interface ParameterStates {
+    [key: string]: ParameterState;
+}
+interface AnimationParameterStates {
+    parameterStates: ParameterStates;
+    duration?: number;
+    format?: 'normalized' | 'absolute';
+    fontData?: {
+        style?: {
+            fontFamily?: string;
+            [key: string]: unknown;
+        };
+        config?: unknown;
+        fontId?: string | null;
+        fontName?: string | null;
+    };
+    text?: string;
+    name?: string;
+}
+interface AnimationState {
+    fontSize: number;
+    scale: number;
+    opacity: number;
+    slant: number;
+    weight: number;
+    width: number;
+    textColor: string;
+    translateX: number;
+    translateY: number;
+    stretchY: number;
+    rotation?: number;
+    skewX?: number;
+    fontVariationAxes?: Record<string, number>;
+    letterShake?: number;
+    shadowColor?: string;
+}
+interface SentenceAnimationState extends AnimationState {
+    text: string;
+    emotion: string;
+    emotionIntensity: number;
+    fontFamily: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    isActive: boolean;
+}
+interface WordAnimationState {
+    text: string;
+    words: Array<{
+        word: string;
+        start: number;
+        end: number;
+        animationEnd: number;
+        isActive: boolean;
+        emotion: string;
+        emotionIntensity: number;
+        originalEmotionIntensity?: number;
+        fontFamily: string;
+        emphasis: number;
+        emphasisEffect?: any;
+        strongEmphasis?: any;
+        animationParameters: AnimationState;
+        joyAnimationMode?: 'letter' | 'letter-bulge' | 'word' | null;
+        joyProgress?: number | null;
+    }>;
+    currentWordIndex: number;
+    emotion: string;
+    emotionIntensity: number;
+    fontFamily: string;
+    startTime: number;
+    endTime: number;
+    isActive: boolean;
+}
+interface SubtitleSegment {
+    start_time: number;
+    end_time: number;
+    text?: string;
+    subtitle?: string;
+    emotion?: string;
+    emotion_intensity?: number;
+    animation_url?: string;
+    /** Per-cue expressiveness (0–1); combined with global GTS slider at playback. */
+    gts?: number;
+    words?: Array<{
+        word: string;
+        start: number;
+        end: number;
+        emphasis?: number;
+        emotion?: string;
+        emotion_intensity?: number;
+        animation_url?: string;
+        animations?: Record<string, number>;
+        gts?: number;
+    }>;
+    animations?: Record<string, number>;
+    volume?: number;
+    speech_rate?: number;
+    merged_subtitles?: SubtitleSegment[];
+}
+interface AnimationOptions {
+    maxExpression?: number;
+    threshold?: number;
+    isRTL?: boolean;
+    volume?: number;
+    speechRate?: number;
+    nextSegmentStartTime?: number;
+    extendedEndTime?: number;
+}
+
 /**
  * ============================================
  * SUBTITLE STATE MANAGER
@@ -164,12 +286,12 @@ declare class SubtitleStateManager {
  *
  * STATUS: Phase 2 Complete - All 8 classes extracted, clean architecture, no duplication
  */
-type AnimationMode = "Sentence" | "Word" | string;
+type AnimationMode$1 = "Sentence" | "Word" | string;
 interface SubtitleState {
     isVisible: boolean;
     isKaraokeMode: boolean;
     isSpeaker: boolean;
-    animationMode: AnimationMode;
+    animationMode: AnimationMode$1;
     currentSubtitle: string;
     currentSequence: number | null;
     subtitles: any[];
@@ -242,7 +364,7 @@ declare class SubtitleManager {
     toggleSoundbiteAnimations(isVisible: boolean): void;
     mapEventLabelToAnimation(eventLabel: string): string | null;
     processSoundbiteAnimations(soundbites: any[]): any[];
-    setAnimationMode(mode: AnimationMode): void;
+    setAnimationMode(mode: AnimationMode$1): void;
     toggleTransition(enabled: boolean): void;
     updateSubtitle(text: string): void;
     updateLiveTime(videoTime?: number | null): number;
@@ -262,7 +384,7 @@ declare class SubtitleManager {
     getInitialLiveSequenceNumber(): Promise<number>;
     fetchSubtitles(sequenceNumber: number): Promise<any | null>;
     loadVodSubtitles(urlOrVodId: string, languageCode?: string | null): Promise<void>;
-    _processVodData(data: any, url: string, languageCode: string | null): void;
+    _processVodData(data: any, url: string, languageCode: string | null, originalSubtitles?: any[]): void;
     getSubtitleForTime(time: number): any;
     getLiveSubtitleForTime(): any;
     getCurrentSubtitleData(): any | null;
@@ -293,106 +415,191 @@ declare class SubtitleManager {
 declare const subtitleManager: SubtitleManager;
 
 /**
- * Animation Types
+ * URL Decoder for Animation Parameters
  *
- * Type definitions for animation parameter states, curves, and animation state
+ * Extracted from app/playground/utils/urlEncoding.js
+ * Decodes animation URLs into parameter states
+ *
+ * Supports both full URLs and query strings:
+ * - Full URL: https://stage-dev.phont.ai/playground/shared?name=...&scale=0,1|1,1.2
+ * - Query string: ?name=...&scale=0,1|1,1.2
  */
-interface CurvePoint {
-    time: number;
-    value: number | string;
-}
-interface ParameterState {
-    points: CurvePoint[];
-    currentValue?: number | string;
-}
-interface ParameterStates {
-    [key: string]: ParameterState;
-}
-interface AnimationParameterStates {
-    parameterStates: ParameterStates;
-    duration?: number;
-    format?: 'normalized' | 'absolute';
-}
-interface AnimationState {
-    fontSize: number;
+
+/**
+ * Decode animation data from URL or query string
+ * @param urlOrQuery - Full URL (https://...) or query string (?name=... or name=...)
+ * @returns Decoded animation data object with parameterStates
+ */
+declare function decodeAnimationUrl(urlOrQuery: string): AnimationParameterStates;
+
+/**
+ * Animation parameter calculation -- the unified rendering pipeline.
+ * TypeScript port of app/utils/animation/animationParameters.js.
+ *
+ * Samples authored URL curves with linear interpolation, then scales deviations
+ * proportionally from a reference point (REFERENCE_INTENSITY × REFERENCE_GTS).
+ * At the reference point the authored curve is rendered 1:1.
+ */
+
+/**
+ * Exponential variance curve (hockey stick)
+ *
+ * Creates an exponential curve that accelerates dramatically after 0.7 intensity.
+ * Low intensities (0.0-0.7): Subtle effects (gradual rise)
+ * High intensities (0.7-1.0): Dramatic effects (exponential acceleration)
+ *
+ * @param i - Input intensity (0-1)
+ * @returns Transformed intensity (0-1) with exponential variance
+ */
+declare function hockeyStickIntensity(i: number): number;
+/**
+ * Sample a parameter curve at a given time
+ *
+ * Interpolates between keyframe points to get the value at a specific time.
+ * Supports both normalized (0-1) and absolute time formats.
+ * For color parameters, uses RGB interpolation for smooth color transitions.
+ *
+ * @param points - Array of {time, value} points or [time, value] arrays
+ * @param t - Normalized time (0-1)
+ * @param duration - Animation duration in seconds
+ * @param isNormalized - Whether points are in normalized (0-1) or absolute time
+ * @param parameterName - Name of the parameter (e.g., 'color', 'shadowColor', 'outlineColor') for color interpolation
+ * @returns Sampled value or null if no points
+ */
+declare function sampleParameterCurve(points: Array<{
+    time?: number;
+    value?: number | string;
+} | [number, number | string]> | undefined | null, t: number, duration: number, isNormalized?: boolean, parameterName?: string | null): number | string | null;
+interface AnimationParameterState {
+    rawIntensity: number;
+    scaleFactor: number;
     scale: number;
-    opacity: number;
     slant: number;
+    stretchY: number;
+    translateX: number;
+    translateY: number;
     weight: number;
     width: number;
+    fontFamily: string;
     textColor: string;
-    translateX: number;
-    translateY: number;
-    stretchY: number;
-    rotation?: number;
-    skewX?: number;
-    fontVariationAxes?: Record<string, number>;
-    letterShake?: number;
-    letterSpacingOffsets?: number[];
-    shadowColor?: string;
-}
-interface SentenceAnimationState extends AnimationState {
+    opacity: number;
+    textShadow: string;
+    blur: number;
+    outlineWidth: number;
+    outlineColor: string;
+    outline2Width?: number;
+    outline2Color?: string;
+    outline3Width?: number;
+    outline3Color?: string;
+    outlineShadowWidth?: number;
+    outlineShadowColor?: string;
+    outlineShadowBlur?: number;
+    glowIntensity?: number;
+    glowColor?: string;
+    snakeWave?: number;
+    karaoke?: number;
+    stretchX?: number;
+    letterSpacing: string;
+    fontVariationAxes: Record<string, number>;
     text: string;
-    emotion: string;
-    emotionIntensity: number;
-    fontFamily: string;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    isActive: boolean;
+    joy: number;
+    fear: number;
+    standardEmphasis: number;
+    strongEmphasis: number;
+    joyWaveProgress: number;
 }
-interface WordAnimationState {
-    text: string;
-    words: Array<{
-        word: string;
-        start: number;
-        end: number;
-        animationEnd: number;
-        isActive: boolean;
-        emotion: string;
-        emotionIntensity: number;
-        originalEmotionIntensity?: number;
-        fontFamily: string;
-        emphasis: number;
-        emphasisEffect?: any;
-        strongEmphasis?: any;
-        animationParameters: AnimationState;
-        joyAnimationMode?: 'letter' | 'letter-bulge' | 'word' | null;
-        joyProgress?: number | null;
-    }>;
-    currentWordIndex: number;
+declare const REFERENCE_INTENSITY = 0.7;
+declare const REFERENCE_GTS = 0.7;
+/** Play authored URL curves 1:1 — matches main playground preview (no intensity/GTS scaling). */
+/** Playground / converter preview only — bypasses GTS scaling (1:1 at reference). */
+declare const AUTHORED_PLAYBACK_OPTIONS: {
+    rawMode: boolean;
+};
+/**
+ * Sample all animation parameters at time `t` with proportional intensity scaling.
+ *
+ * The authored curve represents the animation at REFERENCE_INTENSITY × REFERENCE_GTS.
+ * At those values you see exactly what was authored. Other intensity × GTS values
+ * scale linearly from there.
+ */
+declare function calculateAnimationParameters(animationData: AnimationParameterStates | null, rawIntensity: number, t: number, gts: number, subtitleDuration?: number | null, { rawMode }?: {
+    rawMode?: boolean;
+}): AnimationParameterState | null;
+
+type AnimationMode = 'sentence' | 'word';
+type AnimationStateOptions = AnimationOptions & {
+    transparentUntilSpoken?: boolean;
+};
+declare function calculateAnimationState(segment: SubtitleSegment | null, currentTime: number, modeOrOptions?: AnimationMode | AnimationStateOptions, maybeOptions?: AnimationStateOptions): SentenceAnimationState | WordAnimationState;
+
+/**
+ * Emotion Animation URLs
+ *
+ * Config mapping emotion → animation URL
+ * Uses full playground URLs from app/gallery/config/animations.js
+ *
+ * SYNCED FROM: app/gallery/config/emotionMapping.js
+ *
+ * To update these URLs:
+ * 1. Update app/gallery/config/animations.js with new URLs
+ * 2. Update app/gallery/config/emotionMapping.js to map emotions to indices
+ * 3. Run: node scripts/sync-animation-urls.js
+ *    OR manually copy the URLs based on the mapping
+ *
+ * The decodeAnimationUrl() function now supports both full URLs and query strings.
+ */
+declare const ANIMATION_URLS: string[];
+/**
+ * Emotion to Animation URL mapping
+ * Based on app/gallery/config/emotionMapping.js
+ *
+ * Maps each emotion to an index in ANIMATION_URLS array
+ */
+declare const EMOTION_ANIMATION_URLS: Record<string, string>;
+/**
+ * Get animation URL for an emotion
+ * @param emotion - Emotion name (case-insensitive)
+ * @returns Full animation URL or query string fallback
+ */
+declare function getAnimationUrlForEmotion(emotion: string): string;
+
+/**
+ * Published Animation Resolver (framework-agnostic)
+ *
+ * Fetches the active published animation URL for each emotion from the backend,
+ * caches the results, and provides sync/async accessors.
+ *
+ * Any consumer (app, SDK, extension) creates an instance by supplying a fetcher
+ * that returns an array of animation objects for a given stylesheet.
+ *
+ * USAGE:
+ *   import { createPublishedAnimationResolver } from '@phont-ai/subtitles-core';
+ *
+ *   const resolver = createPublishedAnimationResolver(
+ *     async (stylesheet) => fetch(`/animations?stylesheet_name=${stylesheet}&is_active=true`).then(r => r.json())
+ *   );
+ *
+ *   await resolver.prefetch('default');          // warm the cache
+ *   const url = resolver.getSync('lust');         // sync (returns null if not cached)
+ *   const url = await resolver.get('lust');       // async (fetches if needed)
+ *   resolver.invalidate();                        // bust after publishing
+ */
+interface AnimationRecord {
     emotion: string;
-    emotionIntensity: number;
-    fontFamily: string;
-    startTime: number;
-    endTime: number;
-    isActive: boolean;
-}
-interface SubtitleSegment {
-    start_time: number;
-    end_time: number;
-    text?: string;
-    subtitle?: string;
-    words?: Array<{
-        word: string;
-        start: number;
-        end: number;
-        emphasis?: number;
-    }>;
-    animations?: Record<string, number>;
-    volume?: number;
-    speech_rate?: number;
-    merged_subtitles?: SubtitleSegment[];
+    url: string;
+    is_active: boolean;
+    [key: string]: unknown;
 }
-interface AnimationOptions {
-    maxExpression?: number;
-    threshold?: number;
-    isRTL?: boolean;
-    volume?: number;
-    speechRate?: number;
-    nextSegmentStartTime?: number;
-    extendedEndTime?: number;
+type AnimationFetcher = (stylesheetName: string) => Promise<AnimationRecord[]>;
+interface PublishedAnimationResolver {
+    prefetch: (stylesheetName?: string) => Promise<Map<string, string>>;
+    get: (emotion: string, stylesheetName?: string) => Promise<string | null>;
+    getSync: (emotion: string, stylesheetName?: string) => string | null;
+    invalidate: () => void;
 }
+declare function createPublishedAnimationResolver(fetcher: AnimationFetcher, { ttlMs }?: {
+    ttlMs?: number;
+}): PublishedAnimationResolver;
 
 /**
  * Emotion Selector
@@ -421,86 +628,24 @@ interface EmotionSelectionResult {
 declare function selectEmotion(animationsObject: Record<string, number> | null | undefined, threshold?: number): EmotionSelectionResult;
 
 /**
- * Animation Engine
+ * Timing Utilities
  *
- * Pure functions that calculate animation state from emotion curves
- * Uses function-based EMOTION_ANIMATIONS (identical to monorepo)
+ * Pure functions for calculating subtitle timing
  */
 
 /**
- * Calculate sentence animation state
- *
- * Pure function version of useSentenceAnimation - uses function-based EMOTION_ANIMATIONS (identical to monorepo)
+ * Get subtitle timing information
  */
-declare function calculateSentenceAnimation(segment: SubtitleSegment | null, currentTime: number, options?: AnimationOptions): SentenceAnimationState;
+declare function getSubtitleTiming(subtitle: SubtitleSegment | null): {
+    startTime: number;
+    endTime: number;
+    duration: number;
+};
 /**
- * Calculate word animation state
- *
- * Pure function version of useWordAnimation - uses function-based EMOTION_ANIMATIONS (identical to monorepo)
- */
-declare function calculateWordAnimation(segment: SubtitleSegment | null, currentTime: number, options?: AnimationOptions): WordAnimationState;
-/**
- * Main function: Calculate animation state from segment and emotion
- *
- * This is the main entry point that uses function-based EMOTION_ANIMATIONS (identical to monorepo)
- */
-declare function calculateAnimationState(segment: SubtitleSegment | null, currentTime: number, mode: 'sentence' | 'word', options?: AnimationOptions): SentenceAnimationState | WordAnimationState;
-
-/**
- * Timing Utilities
- *
- * Pure functions for calculating subtitle timing
- */
-
-/**
- * Get subtitle timing information
- */
-declare function getSubtitleTiming(subtitle: SubtitleSegment | null): {
-    startTime: number;
-    endTime: number;
-    duration: number;
-};
-/**
- * Get subtitle text content
- */
-declare function getSubtitleText(subtitle: SubtitleSegment | null): string;
-/**
- * Calculate normalized time (t: 0→1) through subtitle duration
+ * Calculate normalized time (t: 0→1) through subtitle duration
  */
 declare function calculateNormalizedTime(currentTime: number, startTime: number, duration: number): number;
 
-/**
- * **EMOTION_CURVES_DEFINITION** - Animation DNA
- *
- * Emotion Curves - Animation Parameter Definitions
- *
- * These curves define how subtitle text animates over time based on emotion.
- * Each emotion has time-based functions that return values for visual parameters.
- *
- * PARAMETERS:
- * - fontSize: Always constant (ANIMATION_STYLING.fontSize) for layout stability
- * - scale: Size multiplier applied via CSS transform (prevents text wrapping)
- * - slant: Italic/skew effect in degrees (applied as CSS skewX)
- * - weight: Font weight (100-900) - overridden by VariableFontContext in practice
- * - translateX/Y: Movement in pixels (direct CSS values)
- * - textColor: Text color (rgba)
- * - stretchY: Vertical stretch multiplier (CSS scaleY)
- * - letterShakeIntensity: Per-letter shake amount in pixels (fear)
- *
- * WHY SCALE INSTEAD OF FONTSIZE:
- * Using transform: scale() instead of fontSize changes allows the layout engine
- * to calculate word positions ONCE at the base fontSize, preventing words from
- * wrapping to new lines mid-animation. Scale is GPU-accelerated and doesn't trigger reflow.
- *
- * ⚠️ Parameters NOT included (handled elsewhere):
- * - opacity: Always 1.0 (fade in/out handled by controllers)
- * - shadows: Handled by styling.js ANIMATION_STYLING.shadow (emotion-specific for disgust/angry)
- * - font family: Handled by fontSelection.js based on emotion + intensity
- * - transitions: Handled by styling.js ANIMATION_STYLING.transition
- * - marginRight: Handled by calculateDynamicWordSpacing() based on current scale
- */
-declare const EMOTION_ANIMATIONS: Record<string, any>;
-
 /**
  * Animation Defaults - Visual Styling Layer
  *
@@ -572,6 +717,11 @@ declare const ANIMATION_STYLING: {
             wordSpacingMultiplier: number;
             fontSizeOffset: number;
         };
+        'Bricolage Grotesque': {
+            letterSpacing: string;
+            wordSpacingMultiplier: number;
+            fontSizeOffset: number;
+        };
         Rakkas: {
             letterSpacing: string;
             wordSpacingMultiplier: number;
@@ -607,6 +757,9 @@ declare const RENDERING_CONTROL: {
         breathingRoomDuration: number;
         breathingRoomMinGap: number;
         breathingRoomLargeGap: number;
+        breathingRoomSafetyBuffer: number;
+        breathingRoomNoNextHold: number;
+        fadeOutDuration: number;
         timeRangeTolerance: number;
     };
     emotion: {
@@ -703,81 +856,22 @@ declare const RENDERING_CONTROL: {
     };
 };
 
-/**
- * Shared Animation Parameter Calculation Utility
- *
- * Calculates animation parameters from emotion curves.
- * Shared by calculateWordAnimation and calculateSentenceAnimation to eliminate duplication.
- *
- * This utility extracts all animation parameters defined in EMOTION_ANIMATIONS
- * including variation axes (YOPQ, YTAS) that are separate from voice axes (wght, wdth).
- *
- * TERMINOLOGY:
- * - **Voice Axes**: Font axes driven by audio analysis (volume→wght, speech_rate→wdth)
- * - **Variation Axes**: Font axes driven by emotion animations (YOPQ, YTAS from emotion curves)
- */
-interface VariableFontStyle {
-    fontWeight?: number;
-    fontStretch?: string;
-}
-interface AnimationParameters {
-    fontSize: number;
-    scale: number;
-    opacity: number;
-    slant: number;
-    weight: number;
-    width: number;
-    textColor: string;
-    translateX: number;
-    translateY: number;
-    stretchY: number;
-    letterShake?: number;
-    fontVariationAxes?: Record<string, number>;
-    shadowColor?: string | ((t: number, intensity: number) => string);
-}
-interface EmotionCurve {
-    fontSize?: number | ((t: number, intensity: number) => number);
-    scale?: number | ((t: number, intensity: number) => number);
-    opacity?: number | ((t: number, intensity: number) => number);
-    slant?: number | ((t: number, intensity?: number) => number);
-    weight?: number | ((t: number, intensity?: number) => number);
-    translateX?: number | ((t: number, intensity: number) => number);
-    translateY?: number | ((t: number, intensity: number) => number);
-    stretchY?: number | ((t: number, intensity: number) => number);
-    textColor?: string | ((t: number, intensity: number) => string);
-    shadowColor?: string | ((t: number, intensity: number) => string);
-    thinStroke?: (t: number, intensity: number, gtsValue: number) => number;
-    ascenderHeight?: (t: number, intensity: number, gtsValue: number) => number;
-    letterShake?: (t: number, intensity: number, gtsValue: number) => number;
-}
-/**
- * Calculate animation parameters from emotion curve
- *
- * @param emotionCurve - Emotion curve from EMOTION_ANIMATIONS
- * @param t - Normalized time (0-1) through animation
- * @param intensity - Emotion intensity (0-1), capped by GTS (maxExpression)
- * @param variableFontStyle - Font style from variable font calculations
- * @param gtsValue - GTS maxExpression value (0.2-1.0) for scaling ranges
- * @param selectedFontFamily - The selected font family (e.g., 'Cormorant', 'Roboto Flex')
- * @returns Complete animation parameters including fontVariationAxes (variation axes, not voice axes)
- */
-declare function calculateAnimationParameters(emotionCurve: EmotionCurve, t: number, intensity: number, variableFontStyle?: VariableFontStyle | null, gtsValue?: number, selectedFontFamily?: string): AnimationParameters;
-
 /**
  * Shadow Generator
  *
- * Generates CSS text-shadow strings from shadow colors and emotion-specific styling
+ * Generates CSS text-shadow strings from shadow colors
+ * All emotion-specific shadows are now controlled by URL animations
  */
 /**
  * Generate CSS text-shadow string from shadow color
  *
  * @param shadowColor - Shadow color in hex format (e.g., '#ff3232')
- * @param fontFamily - Font family to determine shadow style
- * @param emotion - Current emotion to determine shadow style
- * @param intensity - Emotion intensity (0-1) to scale glow effects
- * @returns CSS text-shadow value
+ * @param _fontFamily - Unused (kept for API compatibility)
+ * @param _emotion - Unused (kept for API compatibility)
+ * @param _intensity - Unused (kept for API compatibility)
+ * @returns CSS text-shadow value or empty string if no shadow
  */
-declare function generateTextShadow(shadowColor: string | undefined, fontFamily?: string, emotion?: string, intensity?: number): string;
+declare function generateTextShadow(shadowColor: string | undefined, _fontFamily?: string, _emotion?: string, _intensity?: number): string;
 
 /**
  * Dynamic Word Spacing Calculator
@@ -796,6 +890,27 @@ declare function generateTextShadow(shadowColor: string | undefined, fontFamily?
  */
 declare function calculateDynamicWordSpacing(currentScale?: number, fontFamily?: string, gtsIntensity?: number, emotion?: string): string;
 
+/**
+ * Prosody Weight — Natural Voice Intonation for Animations
+ *
+ * Only ~20% of words get motion animation, mimicking how natural speech
+ * stresses only a few key words per phrase. Font styling (color, weight,
+ * slant) is unaffected — this only gates movement.
+ *
+ * Selection criteria:
+ *   1. Function words (the, a, is, and…) → always quiet
+ *   2. Content words are scored by length + deterministic hash
+ *   3. Only the top ~35% of content words animate
+ *      (since function/short words are ~55% of text,
+ *       35% of remaining 45% ≈ 16-20% of all words)
+ */
+/**
+ * Compute a prosody importance weight for a single word.
+ *
+ * @returns 0 (no motion) or 1 (full motion).
+ */
+declare function computeProsodyWeight(word: any, _emotionIntensity: number, _gts: number): number;
+
 /**
  * Joy Animation Effects
  *
@@ -841,11 +956,140 @@ declare function getJoyTransform(joyEffect: JoyEffect | null): string;
  */
 declare function getJoyFilter(joyEffect: JoyEffect | null): string;
 
+/**
+ * Word Emphasis Effects
+ *
+ * Calculates emphasis effects (standard and strong) for words based on confidence levels.
+ *
+ * USED BY:
+ * - calculateWordAnimation: Main word animation orchestrator
+ *
+ * HOW IT WORKS:
+ * 1. Standard Emphasis (50-70%): Quick "pop" effect at word start
+ * 2. Strong Emphasis (70%+): Per-letter dramatic effects throughout word
+ * 3. Both scale with GTS (expressiveness level) and word confidence
+ *
+ * KEY FEATURES:
+ * - Confidence-based thresholds (50-70% vs 70%+)
+ * - GTS-scaled intensity
+ * - Emotion slant inheritance
+ * - Smooth transitions
+ */
+interface Word {
+    emphasis?: number;
+    start: number;
+    end: number;
+    animationEnd?: number;
+}
+interface EmphasisEffect {
+    scaleMultiplier: number;
+    slantAdditive: number;
+    weightBoost: number;
+    scaleProgress: number;
+    gtsMultiplier: number;
+    emphasis: number;
+    emphasisMultiplier: number;
+    elapsed: number;
+    scaleActive: boolean;
+}
+interface StrongEmphasisData {
+    emphasis: number;
+    rawEmphasis: number;
+    scale: number;
+    rotation: number;
+    translateX: number;
+    translateY: number;
+    skewX: number;
+    stretchY: number;
+    brightness: number;
+    contrast: number;
+    shadowBlur: number;
+    shadowOpacity: number;
+    zIndex: number;
+    weightBoost: number;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    gtsMultiplier: number;
+    emphasisMultiplier: number;
+    fadeFactor: number;
+    isInTail: boolean;
+}
+/**
+ * Calculate emphasis effects for a word
+ *
+ * @param params - Emphasis calculation parameters
+ * @returns Emphasis effects { emphasisEffect, strongEmphasisData }
+ */
+declare function calculateWordEmphasisEffects({ word, currentTime, maxExpression, emotionAnimationDuration, wordBaseSlant, isActive, wordEmotion, }: {
+    word: Word;
+    currentTime: number;
+    maxExpression: number;
+    emotionAnimationDuration: number;
+    wordBaseSlant: number;
+    isActive: boolean;
+    wordEmotion?: string;
+}): {
+    emphasisEffect: EmphasisEffect | null;
+    strongEmphasisData: StrongEmphasisData | null;
+};
+
+/**
+ * ============================================
+ * WORD LETTER SPACING
+ * ============================================
+ *
+ * PURPOSE:
+ * Calculates per-letter translateX offsets for GPU-accelerated spacing (no layout reflow).
+ * Extracted from animationEngine for better maintainability.
+ *
+ * USED BY:
+ * - animationEngine: Main word animation orchestrator
+ *
+ * HOW IT WORKS:
+ * 1. Detects active effects (fear shake only - emphasis spacing is disabled)
+ * 2. Calculates per-letter translateX offsets to create spacing between letters
+ * 3. Returns array of translateX values in pixels (one per letter)
+ *
+ * KEY FEATURES:
+ * - Transform-based spacing (GPU-accelerated, no layout reflow)
+ * - Letter spacing disabled for emphasis effects (standard and strong)
+ * - Only fear shake effects get letter spacing (if needed)
+ * - Zero baseline for clean transitions
+ *
+ * PERFORMANCE BENEFITS:
+ * - Uses translateX (compositor property) instead of letter-spacing (layout property)
+ * - Smooth CSS transitions without triggering layout reflow
+ * - All spacing animations run on GPU compositor layer
+ */
+interface WordLetterSpacingParams {
+    strongEmphasisData?: any;
+    emphasisEffect?: any;
+    wordLetterShakeIntensity: number | null;
+    wordFontFamily: string;
+    currentTime: number;
+    word: any;
+    emotionAnimationDuration: number;
+    wordEmotion?: string;
+    totalLetters: number;
+    fontSize: number;
+}
+/**
+ * Calculate per-letter translateX offsets for GPU-accelerated spacing
+ *
+ * @param params - Spacing calculation parameters
+ * @returns Array of translateX offsets in pixels (one per letter)
+ */
+declare function calculateWordLetterSpacing({ strongEmphasisData, emphasisEffect, wordLetterShakeIntensity, wordFontFamily, currentTime, word, emotionAnimationDuration, wordEmotion, totalLetters, fontSize, }: WordLetterSpacingParams): number[];
+
 /**
  * GTS (Global Text Style) Calculations
  *
  * Centralized logic for GTS-derived values and emotion threshold calculations
  */
+/**
+ * Combine global GTS slider with optional per-segment / per-word authored gts.
+ */
+declare function resolveEffectiveGts(sliderGts: number, segmentGts?: number, wordGts?: number): number;
 /**
  * Calculate all GTS-derived values from slider position
  *
@@ -871,11 +1115,16 @@ declare function calculateGTSValues(gts: number): {
  */
 declare function meetsEmotionThreshold(intensity: number, threshold: number): boolean;
 /**
- * Calculate capped emotion intensity based on GTS maxExpression
+ * Calculate scaled emotion intensity based on GTS maxExpression
+ *
+ * GTS acts as a scaling multiplier (final layer) to preserve variance in emotion values
+ * while controlling overall expressiveness.
+ *
+ * When GTS=0.0 (maxExpression=0.2), animations are completely disabled.
  *
  * @param rawIntensity - Raw emotion intensity from backend (0-1)
- * @param maxExpression - GTS-derived max expression cap (0-1)
- * @returns Capped emotion intensity (0-1)
+ * @param maxExpression - GTS-derived max expression multiplier (0.2-1.0)
+ * @returns Scaled emotion intensity (0-1), or 0 if GTS=0.0
  */
 declare function capEmotionIntensity(rawIntensity: number, maxExpression: number): number;
 /**
@@ -903,14 +1152,6 @@ declare function isInEmphasisRange(emphasis: number): boolean;
  */
 declare function isInStrongEmphasisRange(emphasis: number): boolean;
 
-/**
- * Emotion Animation URLs
- *
- * Config mapping emotion → animation URL
- * Replaces hardcoded EMOTION_ANIMATIONS config with URL-based parameters
- */
-declare const EMOTION_ANIMATION_URLS: Record<string, string>;
-
 /**
  * Font Selection Utilities
  *
@@ -985,129 +1226,33 @@ interface Letter {
 declare function splitTextIntoLetters(text: string): Letter[];
 
 /**
- * Word Emphasis Effects
- *
- * Calculates emphasis effects (standard and strong) for words based on confidence levels.
- *
- * USED BY:
- * - calculateWordAnimation: Main word animation orchestrator
- *
- * HOW IT WORKS:
- * 1. Standard Emphasis (50-70%): Quick "pop" effect at word start
- * 2. Strong Emphasis (70%+): Per-letter dramatic effects throughout word
- * 3. Both scale with GTS (expressiveness level) and word confidence
- *
- * KEY FEATURES:
- * - Confidence-based thresholds (50-70% vs 70%+)
- * - GTS-scaled intensity
- * - Emotion slant inheritance
- * - Smooth transitions
- */
-interface Word {
-    emphasis?: number;
-    start: number;
-    end: number;
-    animationEnd?: number;
-}
-interface EmphasisEffect {
-    scaleMultiplier: number;
-    slantAdditive: number;
-    weightBoost: number;
-    scaleProgress: number;
-    gtsMultiplier: number;
-    emphasis: number;
-    emphasisMultiplier: number;
-    elapsed: number;
-    scaleActive: boolean;
-}
-interface StrongEmphasisData {
-    emphasis: number;
-    rawEmphasis: number;
-    scale: number;
-    rotation: number;
-    translateX: number;
-    translateY: number;
-    skewX: number;
-    stretchY: number;
-    brightness: number;
-    contrast: number;
-    shadowBlur: number;
-    shadowOpacity: number;
-    zIndex: number;
-    weightBoost: number;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    gtsMultiplier: number;
-    emphasisMultiplier: number;
-    fadeFactor: number;
-    isInTail: boolean;
-}
-/**
- * Calculate emphasis effects for a word
- *
- * @param params - Emphasis calculation parameters
- * @returns Emphasis effects { emphasisEffect, strongEmphasisData }
+ * Motion blur from scale deviation — matches main app WordRenderer during movement.
+ * Authored `blur` from animation curves is separate.
  */
-declare function calculateWordEmphasisEffects({ word, currentTime, maxExpression, emotionAnimationDuration, wordBaseSlant, isActive, wordEmotion, }: {
-    word: Word;
-    currentTime: number;
-    maxExpression: number;
-    emotionAnimationDuration: number;
-    wordBaseSlant: number;
-    isActive: boolean;
-    wordEmotion?: string;
-}): {
-    emphasisEffect: EmphasisEffect | null;
-    strongEmphasisData: StrongEmphasisData | null;
-};
+declare function getMotionBlurAmount(scale: number, { minDeviation, maxBlur, multiplier }?: {
+    minDeviation?: number | undefined;
+    maxBlur?: number | undefined;
+    multiplier?: number | undefined;
+}): number;
+declare function getCombinedBlurAmount(authoredBlur?: number, scale?: number, gts?: number): number;
 
 /**
- * ============================================
- * WORD LETTER SPACING
- * ============================================
- *
- * PURPOSE:
- * Calculates per-letter translateX offsets for GPU-accelerated spacing (no layout reflow).
- * Extracted from animationEngine for better maintainability.
- *
- * USED BY:
- * - animationEngine: Main word animation orchestrator
- *
- * HOW IT WORKS:
- * 1. Detects active effects (fear shake only - emphasis spacing is disabled)
- * 2. Calculates per-letter translateX offsets to create spacing between letters
- * 3. Returns array of translateX values in pixels (one per letter)
- *
- * KEY FEATURES:
- * - Transform-based spacing (GPU-accelerated, no layout reflow)
- * - Letter spacing disabled for emphasis effects (standard and strong)
- * - Only fear shake effects get letter spacing (if needed)
- * - Zero baseline for clean transitions
+ * Emotion Importance Processing
  *
- * PERFORMANCE BENEFITS:
- * - Uses translateX (compositor property) instead of letter-spacing (layout property)
- * - Smooth CSS transitions without triggering layout reflow
- * - All spacing animations run on GPU compositor layer
+ * Core emotions (anger, fear, sadness, joy) are prioritized over secondary emotions
+ * by multiplying their intensity by 1.5 before selection.
+ * Identical to monorepo app/utils/data/emotionImportance.js
  */
-interface WordLetterSpacingParams {
-    strongEmphasisData?: any;
-    emphasisEffect?: any;
-    wordLetterShakeIntensity: number | null;
-    wordFontFamily: string;
-    currentTime: number;
-    word: any;
-    emotionAnimationDuration: number;
-    wordEmotion?: string;
-    totalLetters: number;
-    fontSize: number;
-}
 /**
- * Calculate per-letter translateX offsets for GPU-accelerated spacing
+ * Process emotions with importance factors
  *
- * @param params - Spacing calculation parameters
- * @returns Array of translateX offsets in pixels (one per letter)
+ * Core emotions (anger, fear, sadness, joy) get ×1.5 multiplier
+ * Secondary emotions get ×1.0 multiplier
+ *
+ * @param emotions - Array of [emotion, intensity] tuples
+ * @returns Array of [emotion, originalIntensity, adjustedIntensity, importanceFactor, isCore] tuples
  */
-declare function calculateWordLetterSpacing({ strongEmphasisData, emphasisEffect, wordLetterShakeIntensity, wordFontFamily, currentTime, word, emotionAnimationDuration, wordEmotion, totalLetters, fontSize, }: WordLetterSpacingParams): number[];
+declare function processEmotionsWithImportance(emotions: Array<[string, number]>): Array<[string, number, number, number, boolean]>;
 
 /**
  * Backend Data Accessors
@@ -1117,6 +1262,21 @@ declare function calculateWordLetterSpacing({ strongEmphasisData, emphasisEffect
  * Identical to monorepo app/utils/data/backendDataAccessors.js
  */
 
+/**
+ * Get word emphasis data
+ */
+declare function getWordEmphasis(word: any): {
+    confidence: any;
+    emphasis: any;
+    hasEmphasis: boolean;
+    hasStrongEmphasis: boolean;
+};
+/**
+ * Get subtitle text content
+ *
+ * Handles both 'subtitle' and 'text' properties
+ */
+declare function getSubtitleText(subtitle: SubtitleSegment | null): string;
 /**
  * Get subtitle words array
  */
@@ -1140,24 +1300,6 @@ declare function getMergedSubtitles(subtitle: SubtitleSegment | null): SubtitleS
  */
 declare function findSubtitleForWord(subtitles: SubtitleSegment[], word: any): SubtitleSegment | null;
 
-/**
- * Emotion Importance Processing
- *
- * Core emotions (anger, fear, sadness, joy) are prioritized over secondary emotions
- * by multiplying their intensity by 1.5 before selection.
- * Identical to monorepo app/utils/data/emotionImportance.js
- */
-/**
- * Process emotions with importance factors
- *
- * Core emotions (anger, fear, sadness, joy) get ×1.5 multiplier
- * Secondary emotions get ×1.0 multiplier
- *
- * @param emotions - Array of [emotion, intensity] tuples
- * @returns Array of [emotion, originalIntensity, adjustedIntensity, importanceFactor, isCore] tuples
- */
-declare function processEmotionsWithImportance(emotions: Array<[string, number]>): Array<[string, number, number, number, boolean]>;
-
 /**
  * Variable Font Calculations
  *
@@ -1204,34 +1346,8 @@ declare function calculateWeightFromVolume(volume: number | undefined, weightAxi
  */
 declare function calculateWidthFromSpeechRate(speechRate: number | undefined, widthAxis: FontAxisConfig | undefined, baseWidth?: number): number;
 
-/**
- * Subtitle Engine
- *
- * TODO: Extract from app/hooks/subtitle/useSentenceAnimation.js and useWordAnimation.js
- *
- * This module should provide:
- * - createSubtitleEngine(track) - creates engine instance
- * - engine.at(time) - returns SubtitleEngineState for given time
- * - Handle karaoke mode (word-by-word) and sentence mode
- * - Handle edge cases: gaps, overlaps, end-of-video
- */
-
-declare function createSubtitleEngine(track: SubtitleTrack): {
-    at(time: number): SubtitleEngineState;
-};
-
-/**
- * Emotion → Style Mapper
- *
- * TODO: Extract from app/config/animation/ directory
- *
- * This module should provide:
- * - getEmotionStyle(emotion, intensity) - maps emotion to CSS styles
- * - Handle all 6 emotions: joy, anger, sadness, fear, disgust, surprise
- * - Support intensity scaling (0-1)
- */
-
-declare function getEmotionStyle(emotion: Emotion, intensity: number): EmotionStyle;
+declare function ensureFont(fontFamily: string | undefined | null): void;
+declare function preloadAnimationFonts(): void;
 
 /**
  * PHONT API Client
@@ -1287,7 +1403,11 @@ declare class PhontClient {
     /**
      * Register a new user
      */
-    register(username: string, email: string, password: string): Promise<RegisterResponse>;
+    register(username: string, email: string, password: string, profile: {
+        company: string;
+        first_name: string;
+        last_name: string;
+    }): Promise<RegisterResponse>;
     /**
      * Get subtitle track for a VOD
      * Requires: Session token authentication
@@ -1343,4 +1463,4 @@ declare class PhontClient {
     clearCredentials(): void;
 }
 
-export { ANIMATION_STYLING, type AnimationOptions, type AnimationParameterStates, type AnimationParameters, type AnimationState, type CurvePoint, EMOTION_ANIMATIONS, EMOTION_ANIMATION_URLS, type Emotion, type EmotionCurve, type EmotionSelectionResult, type EmotionStyle, type EmphasisEffect, type FontAxisConfig, type FontConfig, type JoyEffect, type Letter, type LoginResponse, type ParameterState, type ParameterStates, PhontClient, type PhontClientOptions, RENDERING_CONTROL, type RegisterResponse, type SentenceAnimationState, type StateCallback, type StrongEmphasisData, type Stylesheet, type SubtitleEngineState, type SubtitleLine, SubtitleManager, type SubtitleSegment, type SubtitleState$1 as SubtitleState, SubtitleStateManager, type SubtitleTrack, type SubtitleWord, type VariableFontStyle, type VodMetadata, type VodState$1 as VodState, type Word, type WordAnimationState, type WordLetterSpacingParams, calculateAnimationParameters, calculateAnimationState, calculateDynamicWordSpacing, calculateEmphasisMultiplier, calculateGTSValues, calculateJoy, calculateJoyBulge, calculateNormalizedTime, calculateSentenceAnimation, calculateWeightFromVolume, calculateWidthFromSpeechRate, calculateWordAnimation, calculateWordEmphasisEffects, calculateWordLetterSpacing, capEmotionIntensity, createSubtitleEngine, findSubtitleForWord, generateTextShadow, getEmotionStyle, getFontFamilyCSS, getJoyAnimationMode, getJoyFilter, getJoyTransform, getMergedSubtitles, getSubtitleAnimations, getSubtitleText, getSubtitleTiming, getSubtitleWords, hasMergedSubtitles, isInEmphasisRange, isInStrongEmphasisRange, meetsEmotionThreshold, processEmotionsWithImportance, selectEmotion, selectFontFamily, shouldUseAngryFont, shouldUseJoyFont, shouldUseSadnessFont, splitTextIntoLetters, subtitleManager };
+export { ANIMATION_STYLING, ANIMATION_URLS, AUTHORED_PLAYBACK_OPTIONS, type AnimationFetcher, type AnimationOptions, type AnimationParameterState, type AnimationParameterStates, type AnimationRecord, type AnimationState, type CurvePoint, EMOTION_ANIMATION_URLS, type Emotion, type EmotionSelectionResult, type EmotionStyle, type EmphasisEffect, type FontAxisConfig, type FontConfig, type JoyEffect, type Letter, type LoginResponse, type ParameterState, type ParameterStates, PhontClient, type PhontClientOptions, type PublishedAnimationResolver, REFERENCE_GTS, REFERENCE_INTENSITY, RENDERING_CONTROL, type RegisterResponse, type SentenceAnimationState, type StateCallback, type StrongEmphasisData, type Stylesheet, type SubtitleEngineState, type SubtitleLine, SubtitleManager, type SubtitleSegment, type SubtitleState$1 as SubtitleState, SubtitleStateManager, type SubtitleTrack, type SubtitleWord, type VodMetadata, type VodState$1 as VodState, type Word, type WordAnimationState, type WordLetterSpacingParams, calculateAnimationParameters, calculateAnimationState, calculateDynamicWordSpacing, calculateEmphasisMultiplier, calculateGTSValues, calculateJoy, calculateJoyBulge, calculateNormalizedTime, calculateWeightFromVolume, calculateWidthFromSpeechRate, calculateWordEmphasisEffects, calculateWordLetterSpacing, capEmotionIntensity, computeProsodyWeight, createPublishedAnimationResolver, decodeAnimationUrl, ensureFont, findSubtitleForWord, generateTextShadow, getAnimationUrlForEmotion, getCombinedBlurAmount, getFontFamilyCSS, getJoyAnimationMode, getJoyFilter, getJoyTransform, getMergedSubtitles, getMotionBlurAmount, getSubtitleAnimations, getSubtitleText, getSubtitleTiming, getSubtitleWords, getWordEmphasis, hasMergedSubtitles, hockeyStickIntensity, isInEmphasisRange, isInStrongEmphasisRange, meetsEmotionThreshold, preloadAnimationFonts, processEmotionsWithImportance, resolveEffectiveGts, sampleParameterCurve, selectEmotion, selectFontFamily, shouldUseAngryFont, shouldUseJoyFont, shouldUseSadnessFont, splitTextIntoLetters, subtitleManager };