onda-engine 0.1.0

package/dist/cinema.d.ts

@@ -0,0 +1,580 @@
+import { ComponentType, ReactElement } from 'react';
+
+/** A time: seconds (number) or a spec string — `"2s"`, `"500ms"`, `"0:02"`, `"90f"`. */
+type TimeSpec = string | number;
+/** An entry's motion: an `@onda-engine/components` choreography pattern name + params. */
+interface EntryAnimation {
+    pattern: string;
+    params?: Record<string, unknown>;
+}
+/** Per-entry cinematic EFFECTS — the same sugar props @onda-engine/react's `<Group>`
+ *  accepts (each maps 1:1 to the engine `Effect` enum). The renderer spreads
+ *  these onto a wrapping `<Group>` so they render on Vello in EXPORT (twin of the
+ *  Studio preview renderer's `entryEffectsSchema`). */
+interface EntryEffects {
+    blur?: number;
+    directionalBlur?: {
+        sigma: number;
+        angle?: number;
+    };
+    bloom?: number | {
+        sigma: number;
+        threshold?: number;
+        intensity?: number;
+    };
+    grade?: {
+        exposure?: number;
+        contrast?: number;
+        saturation?: number;
+        temperature?: number;
+        tint?: number;
+    };
+    grain?: number | {
+        intensity: number;
+        size?: number;
+        seed?: number;
+    };
+    vignette?: number | {
+        amount: number;
+        softness?: number;
+    };
+    chromaticAberration?: number;
+    posterize?: number;
+    duotone?: {
+        shadow: string;
+        highlight: string;
+    };
+    chromaKey?: {
+        color: string;
+        threshold?: number;
+        smoothness?: number;
+    };
+    goo?: number | {
+        sigma: number;
+        threshold?: number;
+    };
+    backdropBlur?: number | {
+        sigma: number;
+        tint?: string;
+        brightness?: number;
+        saturation?: number;
+    };
+    lightWrap?: number | {
+        sigma: number;
+        strength?: number;
+    };
+    blendMode?: string;
+    shadow?: {
+        color: string;
+        blur: number;
+        offsetX?: number;
+        offsetY?: number;
+        spread?: number;
+    };
+}
+/** AE-style 3D placement for an entry (rendered inside a `<Scene3D>`). */
+interface Transform3D {
+    position3d?: [number, number, number];
+    rotation3d?: [number, number, number];
+    anchor3d?: [number, number];
+    extrude?: number | {
+        depth: number;
+    };
+}
+/** Track matte: reveal an entry through a stencil component subtree. */
+interface EntryMatte {
+    component: string;
+    props?: Record<string, unknown>;
+    mode?: 'alpha' | 'luminance';
+}
+/** Clip an entry to a region. */
+interface EntryClip {
+    shape: 'rect' | 'ellipse' | 'path';
+    width?: number;
+    height?: number;
+    cornerRadius?: number;
+    data?: string;
+}
+/** An entry's attention weight — the contract the inspector's hierarchy,
+ *  collision, and density checks run on. Consumers (the Studio director)
+ *  ASSIGN roles; nothing infers them. */
+type EntryRole = 'focal' | 'support' | 'ambient';
+/** One element on a track: a component placed at `at` for `for`, with optional motion. */
+interface Entry {
+    at: TimeSpec;
+    for: TimeSpec;
+    component: string;
+    /** Attention weight: `'focal'` = the one thing the viewer should be reading /
+     *  watching right now (≤1 visible at a time; entrances must not collide),
+     *  `'support'` = secondary content, `'ambient'` = atmosphere (backgrounds,
+     *  grain, washes — exempt from density budgets). Drives the inspector's
+     *  hierarchy / collision / density checks. Absent = `'support'`. */
+    role?: EntryRole;
+    props?: Record<string, unknown>;
+    animate?: EntryAnimation[];
+    /** Per-entry cinematic effects (bloom/grade/grain/blur/vignette/…). */
+    effects?: EntryEffects;
+    /** 2.5D depth for composition `dof` rack-focus. */
+    depth?: number;
+    /** AE-style 3D placement (position3d / rotation3d / extrude). */
+    transform3d?: Transform3D;
+    /** Track matte: reveal through a stencil component (media-through-type). */
+    matte?: EntryMatte;
+    /** Clip to a rect/ellipse/path region. */
+    clip?: EntryClip;
+    /** Magic-move continuity key. When the SAME `morphKey` appears on an entry in
+     *  two ADJACENT scenes, the element MORPHS its position/scale across the cut
+     *  (one continuous move) instead of cross-fading — Keynote Magic Move / a
+     *  matched cut. The morphing instance is built from the destination scene's
+     *  entry (same component + props). */
+    morphKey?: string;
+    id?: string;
+    label?: string;
+}
+interface Track {
+    id?: string;
+    label?: string;
+    entries: Entry[];
+}
+interface SceneTransition {
+    /** A transition slug, e.g. `"cross-fade"`, `"iris"`, `"push"`. */
+    type: string;
+    durationInFrames?: number;
+    /** Per-transition options forwarded to the presentation factory (direction /
+     *  color / scaleAmount / bars) — each transition reads what it knows. */
+    options?: {
+        direction?: string;
+        color?: string;
+        scaleAmount?: number;
+        bars?: number;
+    };
+}
+/** A camera keyframe: zoom (1 = neutral), focus x/y (canvas fractions, 0.5 =
+ *  center), rotate (deg). Omitted keys default. */
+interface CameraKeyframe {
+    zoom?: number;
+    x?: number;
+    y?: number;
+    rotate?: number;
+}
+/** A camera move eased over a scene's duration (push-in / pan / roll). */
+interface CameraMove {
+    from?: CameraKeyframe;
+    to?: CameraKeyframe;
+}
+interface Scene {
+    id: string;
+    label?: string;
+    for?: TimeSpec;
+    transition?: SceneTransition;
+    tracks: Track[];
+    /** A cinematic camera move over this scene. */
+    camera?: CameraMove;
+    /** The canvas this scene's content was AUTHORED for. When it differs from the
+     *  composition canvas, the renderer uniformly scales + centers the scene's
+     *  content to `fit` the output (e.g. a 4:3 template scene into a 16:9 video). */
+    designWidth?: number;
+    designHeight?: number;
+    /** How to re-frame the design canvas into the output:
+     *  - `contain` — uniformly scale + center, letterbox.
+     *  - `cover` — uniformly scale + center, fill + crop.
+     *  - `responsive` — "Magic Resize": re-anchor each element individually (pin to
+     *    edge / center per axis, size scaled uniformly) so one master adapts to any
+     *    aspect ratio without per-format variants. */
+    fit?: 'contain' | 'cover' | 'responsive';
+}
+/** A composition-level layer entry — absolute-timed, spans scene cuts. */
+interface LayerEntry {
+    at?: TimeSpec;
+    for?: TimeSpec;
+    component: string;
+    props?: Record<string, unknown>;
+    animate?: EntryAnimation[];
+    /** Per-entry cinematic effects (bloom/grade/grain/blur/vignette/…). */
+    effects?: EntryEffects;
+    /** 2.5D depth for composition `dof` rack-focus. */
+    depth?: number;
+    /** AE-style 3D placement (position3d / rotation3d / extrude). */
+    transform3d?: Transform3D;
+    /** Track matte: reveal through a stencil component (media-through-type). */
+    matte?: EntryMatte;
+    /** Clip to a rect/ellipse/path region. */
+    clip?: EntryClip;
+    id?: string;
+    label?: string;
+}
+interface Layer {
+    id?: string;
+    label?: string;
+    /** `true` = behind the scene spine (a background); else over it (an overlay). */
+    under?: boolean;
+    entries: LayerEntry[];
+}
+/** Optional brand override — surface tokens, mapped to the engine theme. */
+interface Brand {
+    bg?: string;
+    surface?: string;
+    surface2?: string;
+    border?: string;
+    borderLit?: string;
+    text?: string;
+    dim?: string;
+    faint?: string;
+    accent?: string;
+    accentSoft?: string;
+    fontDisplay?: string;
+    fontBody?: string;
+}
+/** Composition-level cinematic FINISH — the linear-HDR + ACES "looks-shot"
+ *  output transform (GPU/export-only). Twin of the Studio `compositionFinishSchema`. */
+interface CompositionFinish {
+    exposure?: number;
+    bloom?: {
+        sigma: number;
+        threshold?: number;
+        intensity?: number;
+    };
+    halation?: number;
+    temperature?: number;
+    contrast?: number;
+    saturation?: number;
+    vignette?: number;
+    grain?: number;
+    /** A cinematic 3D color LUT applied as the FINAL finish step (after grade + ACES
+     *  + sRGB), as a trilinear lookup. `table` holds `size³` RGB triples in 0..1 with
+     *  RED varying fastest, then green, then blue. Honored by BOTH backends. */
+    lut?: {
+        size: number;
+        table: number[];
+    };
+}
+interface CompositionPayload {
+    fps: number;
+    width: number;
+    height: number;
+    scenes: Scene[];
+    layers?: Layer[];
+    brand?: Brand;
+    /** Opt into the cinematic LINEAR + ACES color pipeline (GPU/export only). */
+    linear?: boolean;
+    /** Composition-level cinematic finish (ACES tone-map look; GPU/export only). */
+    finish?: CompositionFinish;
+    /** Per-object motion blur via temporal supersampling (export only). */
+    motionBlur?: boolean | {
+        shutter?: number;
+        samples?: number;
+    };
+    /** Depth-of-field / rack-focus over per-layer `depth`. */
+    dof?: {
+        focus: number;
+        aperture?: number;
+        range?: number;
+        maxBlur?: number;
+    };
+}
+
+/** Parse a TimeSpec to seconds. `fps` is needed for frame specs (`"90f"`). */
+declare function timeSpecToSeconds(spec: TimeSpec | undefined, fps: number): number;
+/** A TimeSpec in frames. */
+declare function toFrames(spec: TimeSpec | undefined, fps: number): number;
+/** A scene's resolved position on the composition timeline, in frames. */
+interface ScenePlacement {
+    /** Absolute frame the scene starts (the start of its incoming overlap). */
+    start: number;
+    /** Scene duration in frames. */
+    durationInFrames: number;
+    /** Frames the scene's incoming transition overlaps the previous scene
+     *  (0 for the first scene / no transition). The transition window is
+     *  `[start, start + overlapIn)` in absolute frames. */
+    overlapIn: number;
+}
+/** Resolve every scene's absolute start + duration — the SAME placement
+ *  `buildComposition`'s `<TransitionSeries>` computes (a scene starts where the
+ *  previous one ends MINUS its incoming transition overlap). Shared by the
+ *  renderer (magic-move planning) and the inspector so the two can't drift. */
+declare function scenePlacements(scenes: Scene[], fps: number): ScenePlacement[];
+/** The composition's total length in frames (scene durations minus overlaps). */
+declare function totalFrames(payload: CompositionPayload, fps: number): number;
+
+/** Minimum contrast ratio for body-size text (WCAG 2.x SC 1.4.3 AA). */
+declare const CONTRAST_MIN_BODY = 4.5;
+/** Minimum contrast ratio for large text (WCAG 2.x SC 1.4.3 AA). */
+declare const CONTRAST_MIN_LARGE = 3;
+/** Seconds of display per word (240 wpm — Brysbaert 2019 silent-reading mean). */
+declare const READ_SECONDS_PER_WORD = 0.25;
+/** Fixed orientation beat: find the text + ride out its entrance. PRODUCT DECISION. */
+declare const READ_ORIENTATION_SECONDS = 0.6;
+/** Absolute floor for any readable text. PRODUCT DECISION (BBC-consistent). */
+declare const READ_MIN_SECONDS = 1.2;
+/** Seconds a text of `wordCount` words must stay visible:
+ *  `max(1.2, 0.25 × words + 0.6)`. */
+declare function readingTimeSeconds(wordCount: number): number;
+/** The delivery formats the inspector knows safe areas for. */
+type FormatId = '16:9' | '9:16' | '1:1' | '4:5';
+/** Per-side safe-area inset as a FRACTION of the canvas axis. */
+interface SafeAreaPreset {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/** Safe-area presets per format.
+ *
+ *  - `16:9` — EBU R95 / SMPTE ST 2046-1 GRAPHICS-safe for 16:9 TV: 5% vertical,
+ *    10% horizontal (action-safe is 3.5%; graphics/title content uses the
+ *    stricter band) — https://tech.ebu.ch/publications/r095.
+ *  - `9:16` — the UNION of the three vertical-social UI overlays at 1080×1920,
+ *    so one preset clears TikTok + Instagram Reels + YouTube Shorts
+ *    (per-platform 2025/26 overlay guides — kreatli.com/guides/safe-zone-guide,
+ *    zeely.ai/blog/tiktok-safe-zones):
+ *      · TikTok: top ~140px (profile bar), bottom ~324px (caption/sound, ~370px
+ *        with an ad CTA), right ~164px (like/comment/share rail), left ~60px.
+ *      · Reels: top ~108–220px, bottom ~320–420px (caption + CTA), right ~120px.
+ *      · Shorts: top ~180px, bottom ~390px (channel + CTA), right ~120px.
+ *    Union: top 220 / bottom 420 / left 60 / right 164 px.
+ *  - `1:1`, `4:5` — feed placements; platforms overlay far less UI in-feed, but
+ *    Meta crops covers and overlays the caption/CTA strip at the bottom.
+ *    PRODUCT DECISION informed by the 9:16 research (no platform publishes
+ *    feed-overlay pixel specs). */
+declare const SAFE_AREAS: Record<FormatId, SafeAreaPreset>;
+/** Nearest known format for a canvas size (by aspect-ratio distance). */
+declare function inferFormat(width: number, height: number): FormatId;
+/** Minimum body font size in px AT a 1080 min-dimension canvas, per format. */
+declare const FONT_FLOOR_PX: Record<FormatId, number>;
+/** The font floor in px for a format on an actual canvas. */
+declare function fontFloorPx(format: FormatId, width: number, height: number): number;
+/** Two FOCAL entrances beginning within this window compete for one attention
+ *  slot. Backed by the attentional-blink literature: a second target appearing
+ *  200–500ms after a first is frequently missed outright (Raymond, Shapiro &
+ *  Arnell 1992; review: Dux & Marois 2009, Atten Percept Psychophys 71:1683).
+ *  250ms sits inside that window. */
+declare const FOCAL_COLLISION_WINDOW_SECONDS = 0.25;
+/** Scene-transition duration budget. Material Design caps complex multi-element
+ *  transitions at 500–700ms and finds >400ms "too slow" for simple ones
+ *  (https://m2.material.io/design/motion/speed.html); film dissolves run longer,
+ *  so 0.6s — inside Material's complex band — is the PRODUCT DECISION budget. */
+declare const TRANSITION_BUDGET_SECONDS = 0.6;
+/** Max non-ambient entries visible at once in a scene. */
+declare const DENSITY_MAX_NON_AMBIENT = 5;
+/** Max FOCAL entries visible at once (one thing to look at). */
+declare const DENSITY_MAX_FOCAL = 1;
+
+/** A scene with its absolute timeline placement (frames). */
+interface ResolvedScene {
+    scene: Scene;
+    index: number;
+    /** Absolute start frame (= the start of its incoming transition overlap). */
+    start: number;
+    durationInFrames: number;
+}
+/** One entry resolved onto the absolute timeline. */
+interface ResolvedEntry {
+    /** `'scene'` = a track entry; `'layer'` = a composition-level layer entry. */
+    kind: 'scene' | 'layer';
+    component: string;
+    /** Raw payload props. */
+    props: Record<string, unknown>;
+    /** Effective props after the Studio→engine translation (size roles → px,
+     *  prop-name aliases) — what the component actually receives. */
+    adapted: Record<string, unknown>;
+    /** Attention role; absent = `'support'` (the contract on `Entry.role`). */
+    role: EntryRole;
+    /** `entry.id` when present, else the payload path (stable + addressable). */
+    targetId: string;
+    /** Payload path (`scenes[0].tracks[1].entries[2]`). */
+    path: string;
+    sceneId?: string;
+    sceneIndex?: number;
+    trackIndex?: number;
+    entryIndex?: number;
+    /** Start frame: scene-local for scene entries, absolute for layer entries. */
+    localStart: number;
+    /** Absolute start frame on the composition timeline. */
+    absStart: number;
+    /** Requested duration in frames. */
+    durationInFrames: number;
+    /** Frames actually on screen: duration clamped to the scene window (scene
+     *  entries) / composition end (layer entries). */
+    visibleFrames: number;
+    /** Layer entries only: `true` = renders UNDER the scene spine (a background). */
+    under?: boolean;
+    raw: Entry | LayerEntry;
+}
+/** A transition's absolute capture window. */
+interface TransitionWindow {
+    /** Index of the scene the transition leads INTO. */
+    sceneIndex: number;
+    sceneId: string;
+    type: string;
+    /** Absolute first frame of the overlap. */
+    start: number;
+    /** Effective overlap length in frames (after the ⅓-of-shorter-scene clamp). */
+    durationInFrames: number;
+}
+/** The payload resolved to frames — everything the checks consume. */
+interface ResolvedComposition {
+    payload: CompositionPayload;
+    fps: number;
+    width: number;
+    height: number;
+    totalFrames: number;
+    scenes: ResolvedScene[];
+    /** Scene (track) entries. */
+    entries: ResolvedEntry[];
+    /** Composition-level layer entries (absolute-timed). */
+    layerEntries: ResolvedEntry[];
+    transitions: TransitionWindow[];
+}
+/** Resolve `payload` the way `buildComposition` does (same helpers), producing
+ *  the measurable timeline model. Assumes a structurally valid payload — run
+ *  `validateComposition` first for structural diagnostics. */
+declare function resolveComposition(payload: CompositionPayload): ResolvedComposition;
+
+/** Brand-resolved theme colors the blocks fall back to. */
+interface InspectTheme {
+    text: string;
+    textMuted: string;
+    background: string;
+}
+/** One readable string on an entry. */
+interface TextBlock {
+    /** The prop carrying the string (`title`, `text`, …). */
+    textProp: string;
+    content: string;
+    /** Resolved px font size (explicit > manifest default > 48). */
+    fontSize: number;
+    /** The prop that carries the size — the mechanical `fix` target. */
+    sizeProp?: string;
+    /** Resolved color string, when determinable. */
+    color?: string;
+    /** True when the color came from an explicit prop (vs a theme fallback). */
+    colorExplicit: boolean;
+    fontWeight: number;
+    fontFamily?: string;
+    letterSpacing?: number;
+    /** The component's own auto-fit contract, when it has one. */
+    fit?: 'none' | 'frame';
+    maxWidth?: number;
+}
+/** Total word count across an entry's text blocks. */
+declare function totalWords(blocks: TextBlock[]): number;
+/** Extract the readable text blocks of an entry, with sizes/colors resolved
+ *  (explicit props win; manifest defaults and theme tokens fill the gaps).
+ *  Empty for unknown components or entries with no string text props. */
+declare function textBlocks(entry: ResolvedEntry, theme: InspectTheme): TextBlock[];
+
+/** Every check the inspector runs. */
+type CheckId = 'text.legibility' | 'layout.overflow' | 'timing.readingTime' | 'timing.collisions' | 'density.score' | 'frames.transitionCapture';
+/** One measured violation. `fix` is MECHANICAL metadata only (a minimum font
+ *  size, a safe frame index) — never a taste call. */
+interface Violation {
+    check: CheckId;
+    severity: 'error' | 'warn' | 'info';
+    /** The offending entry's `id` (when set) else its payload path; a scene id
+     *  for scene-level violations. */
+    targetId: string;
+    sceneId?: string;
+    message: string;
+    fix?: {
+        prop: string;
+        suggested: unknown;
+    };
+}
+/** Inspector options. */
+interface InspectOptions {
+    /** Delivery format (drives safe areas + font floors). Default: inferred from
+     *  the canvas aspect ratio. */
+    format?: FormatId;
+    /** Frame indices a consumer intends to capture (thumbnails) — checked
+     *  against transition windows. */
+    frames?: number[];
+}
+/** Per-scene density metrics (always reported, violation or not). */
+interface SceneDensity {
+    sceneId: string;
+    /** Peak concurrently-visible non-ambient entries. */
+    peakNonAmbient: number;
+    /** Peak concurrently-visible focal entries. */
+    peakFocal: number;
+    /** Scene-local frame where the non-ambient peak first occurs. */
+    peakFrame: number;
+}
+/** What `inspect` returns: the violations plus the measured context. */
+interface InspectReport {
+    violations: Violation[];
+    summary: {
+        error: number;
+        warn: number;
+        info: number;
+    };
+    format: FormatId;
+    fps: number;
+    totalFrames: number;
+    density: SceneDensity[];
+}
+/** Everything a check family gets to measure against. */
+interface CheckContext {
+    payload: CompositionPayload;
+    resolved: ResolvedComposition;
+    format: FormatId;
+    safe: SafeAreaPreset;
+    theme: InspectTheme;
+    opts: InspectOptions;
+}
+/** A check family: context in, violations out. */
+type Check = (ctx: CheckContext) => Violation[];
+
+/** An sRGB color, channels 0..1. */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+    /** Alpha 0..1 (1 when the hex had no alpha channel). */
+    a: number;
+}
+/** Parse `#rgb` / `#rrggbb` / `#rrggbbaa` (case-insensitive). Null otherwise. */
+declare function parseColor(value: unknown): Rgb | null;
+/** WCAG relative luminance of an sRGB color (0 = black, 1 = white). */
+declare function relativeLuminance(c: Rgb): number;
+/** WCAG contrast ratio between two colors — 1:1 (identical) to 21:1 (B/W). */
+declare function contrastRatio(a: Rgb, b: Rgb): number;
+
+/** The check registry, in the order they run. */
+declare const CHECKS: Record<CheckId, Check>;
+/**
+ * Measure a composition payload against the quality checks. Deterministic —
+ * the same payload + options always yields the same report. Assumes a
+ * structurally valid payload (run `validateComposition` first; `inspect`
+ * tolerates but does not re-diagnose structural errors).
+ */
+declare function inspect(payload: CompositionPayload, opts?: InspectOptions): InspectReport;
+
+type Registry = Record<string, ComponentType<Record<string, unknown>>>;
+interface BuildOptions {
+    /** Component lookup. Default: every `@onda-engine/components` component. */
+    registry?: Registry;
+}
+declare function buildComposition(payload: CompositionPayload, opts?: BuildOptions): ReactElement;
+interface Diagnostic {
+    /** `error` = won't render correctly (fix it); `warning` = renders, but off or
+     *  fragile; `info` = an FYI an agent should weigh (e.g. a degraded component). */
+    level: 'error' | 'warning' | 'info';
+    path: string;
+    message: string;
+}
+/**
+ * Check a payload before rendering — the tight feedback loop an agent (ONDA
+ * Studio's MCP) self-corrects against. Flags structural issues, unknown
+ * components (with a did-you-mean), unknown patterns/transitions, malformed
+ * timing, and — from the fidelity contract — components that are GPU-only,
+ * degraded, or imitate a browser feature, so the agent picks engine-native
+ * components and avoids surprises. Returns `[]` when the composition is clean.
+ *
+ * Unknown-props policy: WARN, don't strip. An unknown prop on a known
+ * component yields a `warning` diagnostic and the prop is PRESERVED through
+ * `buildComposition` (the component ignores what it doesn't know) — never
+ * silently dropped. Unknown COMPONENTS stay errors (with a did-you-mean).
+ */
+declare function validateComposition(payload: CompositionPayload, opts?: BuildOptions): Diagnostic[];
+
+export { type Brand, type BuildOptions, CHECKS, CONTRAST_MIN_BODY, CONTRAST_MIN_LARGE, type CameraKeyframe, type CameraMove, type Check, type CheckContext, type CheckId, type CompositionFinish, type CompositionPayload, DENSITY_MAX_FOCAL, DENSITY_MAX_NON_AMBIENT, type Diagnostic, type Entry, type EntryAnimation, type EntryClip, type EntryEffects, type EntryMatte, type EntryRole, FOCAL_COLLISION_WINDOW_SECONDS, FONT_FLOOR_PX, type FormatId, type InspectOptions, type InspectReport, type Layer, type LayerEntry, READ_MIN_SECONDS, READ_ORIENTATION_SECONDS, READ_SECONDS_PER_WORD, type Registry, type ResolvedComposition, type ResolvedEntry, type ResolvedScene, type Rgb, SAFE_AREAS, type SafeAreaPreset, type Scene, type SceneDensity, type ScenePlacement, type SceneTransition, TRANSITION_BUDGET_SECONDS, type TextBlock, type TimeSpec, type Track, type Transform3D, type TransitionWindow, type Violation, buildComposition, contrastRatio, fontFloorPx, inferFormat, inspect, parseColor, readingTimeSeconds, relativeLuminance, resolveComposition, scenePlacements, textBlocks, timeSpecToSeconds, toFrames, totalFrames, totalWords, validateComposition };