@cutcraft/player 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bohdan Snisar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,103 @@
-# Temporary Holding Version
+<p align="center"><img src="../../docs/public/logo.svg" width="64" alt="cutcut logo"></p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @cutcraft/player
+
+The browser player for cut files. It takes a `ResolvedState` from `@cutcraft/kit`
+and plays it: footage decoded with WebCodecs through mediabunny and composited
+on one canvas, overlays rendered as React DOM above it, sound mixed and
+clocked by Web Audio. The editor's preview and the model's filmstrip drive the
+same `PlayerCore`; the export (`@cutcraft/render`) runs the same engine in Node
+through `@cutcraft/player/engine` and `@cutcraft/player/overlays`, which have no
+React layer, DOM or Web Audio in them.
+
+```tsx
+import { collectModule, resolve } from "@cutcraft/kit";
+import { Player } from "@cutcraft/player";
+import * as file from "./video";          // the TSX file the model wrote
+
+const state = resolve(collectModule(file), manifest);
+<Player state={state} element={file.default(file.defaults)} media={{ interview: blob, bed: "/bed.ogg" }} controls />
+```
+
+`media` maps asset ids to Blobs or URLs (or implements `MediaResolver`).
+`element` is only needed for `<Layer>` interiors, which the resolver drops.
+
+## What it does
+
+- **Clock.** Composition time is an anchor on `AudioContext.currentTime`
+  (`anchorTime + (now − anchorClock) × rate`), re-anchored on play, pause, seek
+  and rate change; it never accumulates drift. The render loop is
+  `requestAnimationFrame`; a tick that lands while a frame is in flight is
+  coalesced, and a tick on the same frame index only keeps decoders prefetching.
+- **Decoding.** One mediabunny `Input` per asset, shared by every clip of it
+  and by nested compositions, ref-counted and closed when idle. Each clip near
+  the play head has a `ClipDecoder`: a `VideoSampleSink` stream feeding a
+  short queue for forward play, pre-decoded windows for reverse, single-frame
+  fetches at high speeds and while scrubbing, one retained frame per freeze.
+  A playing tick never waits for a frame; a seek does. A trim or speed drag
+  updates the decoder in place rather than reopening it, and a paused preview
+  repaints each drag step with what is decoded, then fetches the exact frame
+  once the gesture has been quiet for 120 ms.
+- **Compositing.** `buildFramePlan(state, t)` is pure and deterministic: tracks
+  in document order (the first track is the bottom), each clip with its
+  animated transform, crop, fit, opacity, blend, filter and mask; transitions
+  draw the incoming clip over the outgoing one; adjustments re-filter what is
+  below them. `CanvasPainter` executes it. Titles, shapes, SVG, stickers,
+  layers and captions are DOM elements positioned with the same matrix math.
+- **Audio.** `buildAudioPlan` lists every audio-bearing chunk in a window with
+  its gain envelope (volume, fades, automation, ducking, keyframes, mute and
+  solo). `AudioEngine` schedules each chunk once per play session, 200 ms
+  ahead, as an `AudioBufferSourceNode` with the right offset, duration and
+  `playbackRate = clipSpeed × rate`, automated along a speed-key ramp and
+  split around freeze holds, which are silent; PCM is decoded per source range with
+  `AudioBufferSink` and cached. Pause stops everything; seek reschedules once.
+- **Addressability.** Every DOM element carries `data-el` and `data-kind`; the
+  root carries `data-time` and `data-frame`; the canvas is
+  `[data-el="composition"]`.
+- **Determinism.** `seekTo(t)` and `renderFrame(t)` draw the exact frame for
+  `t`, paused or playing. The exporter steps through frames with
+  `Compositor.step(t)`, which keeps every decoder streaming.
+- **Looking at the result.** `captureSheet(times, { columns })` returns a
+  labelled contact sheet of those frames, the way an agent or a test checks
+  a cut without exporting.
+
+## API
+
+`PlayerCore` (framework-free): `play`, `pause`, `toggle`, `seekTo`,
+`seekToFrame`, `renderFrame`, `captureSheet`, `getCurrentTime`,
+`getCurrentFrame`, `isPlaying`, `duration`, `playbackRate` (0.25–4), `loop`, `muted`, `volume`,
+`setState`, `attachCanvas`, `addEventListener` (`frameupdate`, `play`,
+`pause`, `seeked`, `ended`, `ratechange`, `volumechange`, `error`),
+`subscribeTime`, `dispose`. Every browser dependency is injectable
+(`clock`, `audioOutput`, `frameSourceFactory`, `audioSourceFactory`,
+`createCanvas`, `raf`, `setInterval`), which is how the unit tests run in jsdom.
+
+React: `<Player>` with `controls`, `loop`, `autoPlay`, `initiallyMuted`,
+`playbackRate`, `fit`, `onError`, `onFrame` and a `PlayerRef`; hooks
+`usePlayer`, `useCompositionTime`, `useCompositionFrame`, `useLayerT`.
+Mounting a Player installs the kit's `useT()` and `useLayer()`.
+
+## Not rendered yet
+
+Transition types other than crossfade, dips to black or white, wipe, slide and push (drawn as a crossfade), effects that
+have no CSS filter equivalent (sharpen, glow, …; vignette and grain are drawn),
+colour wheels, curves and LUTs, matte masks, audio effects, pitch correction,
+3D text, most text animation presets (shown as a fade),
+`background.mode: "blur"` under overlays that sit beneath the footage (the
+plain colour), sticker packs and `file:` nested references. The
+kit's `not-rendered` lint warning reports these in the file before anything
+plays, from the same table (`RENDERED_*` in `@cutcraft/kit`) the player reads.
+
+## Tests
+
+```
+pnpm --filter @cutcraft/player test        # vitest over jsdom with fakes (part of `pnpm check`)
+pnpm --filter @cutcraft/player test:e2e    # Playwright: ffmpeg-generated media, Vite, headless Chromium
+```
+
+The browser suite generates `bars.webm` (frame number encoded in a binary
+strip), `tone.ogg`, `logo.png` and `solid.webm` into `e2e/app/public/`, then
+checks seek accuracy, real-time playback on the audio clock, rate changes,
+crossfade blending, DOM overlays and `useT`, image clips, ended/loop and
+determinism. It needs `ffmpeg` and Playwright's Chromium (pinned to 1.56.1 to
+match the preinstalled browser).

package/dist/backdrop-BqrzCzTB.d.mts

@@ -0,0 +1,131 @@
+import { FitMode, LayerClock, Placement, ResolvedState, ResolvedTrack, Transform } from "@cutcraft/kit";
+declare function frameIndex(t: number, fps: number): number;
+declare function frameTime(frame: number, fps: number): number;
+/** `mm:ss.ff` for a composition time, what the controls show and the contact sheet labels. */
+declare function timecode(t: number, fps: number): string;
+/** 0..1 progress through a placement, what `useT()` returns inside a Layer. */
+declare function localT(p: Placement, t: number): number;
+/** What `useLayer()` returns inside a Layer: progress plus real seconds. */
+declare function layerClock(p: Placement, t: number, fps: number): LayerClock;
+/**
+ * Source seconds a media placement shows at composition time `t`: in/out
+ * trim, constant speed or a speed-key ramp, reverse, and freeze holds.
+ * A freeze is an insert hold: it shows `at` over its window, then the clip
+ * resumes from where it stopped; the result is clamped to the trimmed range.
+ */
+declare function placementSourceTime(p: Placement, children: readonly Placement[], t: number): number;
+declare function nestedSourceTime(p: Placement, t: number): number;
+interface TransitionRole {
+  readonly placement: Placement;
+  readonly role: "out" | "in";
+  /** 0..1 through the transition, eased by its curve. */
+  readonly progress: number;
+}
+interface VisibleItem {
+  readonly placement: Placement;
+  readonly track: ResolvedTrack;
+  readonly children: readonly Placement[];
+  readonly transition?: TransitionRole;
+}
+/** Visual, timed placements that show at `t`: tracks in document order (the first track is the bottom), items in track order. */
+declare function visiblePlacements(state: ResolvedState, t: number): VisibleItem[];
+declare function isVisibleAt(p: Placement, t: number, compositionDuration: number): boolean;
+/** Placements that sit on a track, in track order; a multicam's generated clips follow their parent. */
+declare function trackItems(state: ResolvedState, track: ResolvedTrack): Placement[];
+interface DrawRect {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+/** Row-major 2D affine matrix in the canvas/CSS `matrix(a, b, c, d, e, f)` convention. */
+interface Matrix2D {
+  readonly a: number;
+  readonly b: number;
+  readonly c: number;
+  readonly d: number;
+  readonly e: number;
+  readonly f: number;
+}
+interface Layout {
+  /** Where the element lands in composition pixels before its transform. */
+  readonly rect: DrawRect;
+  /** Maps local element coordinates (0..rect.w, 0..rect.h) to composition coordinates. */
+  readonly matrix: Matrix2D;
+  /** Source sub-rectangle in source pixels, when cropped. */
+  readonly crop?: DrawRect;
+  readonly opacity: number;
+}
+declare const IDENTITY: Matrix2D;
+declare function multiply(m: Matrix2D, n: Matrix2D): Matrix2D;
+declare const translate: (x: number, y: number) => Matrix2D;
+declare const scaleM: (sx: number, sy: number) => Matrix2D;
+declare function rotate(deg: number): Matrix2D;
+declare function matrixToCss(m: Matrix2D): string;
+interface Box {
+  readonly width: number;
+  readonly height: number;
+}
+/** The fitted rectangle of a source inside the composition, centred. */
+declare function fitRect(comp: Box, src: Box, fit: FitMode): DrawRect;
+/**
+ * Lay out a source of `src` pixels in the composition: crop, fit, then the
+ * element transform (position offset, scale, rotation about the anchor).
+ */
+declare function layoutRect(comp: Box, src: Box, fit: FitMode, transform?: Transform | undefined): Layout;
+/** The matrix mapping an element's local pixels to the composition, given its untransformed rect. */
+declare function transformMatrix(rect: DrawRect, t: Transform | undefined): Matrix2D;
+/** The upright box around `rect` after `m`: where a rectangle of an element's local pixels lands in the composition. */
+declare function boundsOf(rect: DrawRect, m: Matrix2D): DrawRect;
+/** The transform with its keyframed properties evaluated at element-relative time `rel`. */
+declare function animatedTransform(base: Transform | undefined, children: readonly Placement[], rel: number): Transform;
+/** CSS for a DOM element laid out like `layoutRect` does: it sits at the origin with `transform-origin: 0 0`. */
+declare function cssTransform(layout: Layout): string;
+/** An entrance or exit as the schema writes it. */
+interface GraphicAnimation {
+  readonly type: string;
+  readonly duration?: number;
+  readonly easing?: string;
+}
+/** A rectangle in the element's own pixels. */
+interface ClipRect {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+/**
+ * What an element's entrance and exit do to it at one moment, in its own pixels:
+ * an opacity factor, a matrix applied before its layout, the part of it shown
+ * (null for all of it) and how much of its strokes are drawn (null when not drawing).
+ */
+interface Motion {
+  readonly opacity: number;
+  readonly matrix: Matrix2D;
+  readonly clip: readonly ClipRect[] | null;
+  readonly draw: number | null;
+}
+declare const STILL: Motion;
+/**
+ * The entrance and exit of an element `rel` seconds into its `duration`, for a
+ * `width` by `height` box. Both can play at once on a short element; their
+ * effects multiply. Pop, bounce and elastic carry their own curve; the others
+ * follow the animation's easing (default ease-out).
+ */
+declare function motionAt(enter: GraphicAnimation | undefined, exit: GraphicAnimation | undefined, rel: number, duration: number, width: number, height: number): Motion;
+/** One animation at raw progress `x` (0 hidden, 1 fully shown). */
+declare function effect(anim: GraphicAnimation, x: number, w: number, h: number): Motion;
+/** Both effects at once: opacities and draw amounts multiply, matrices compose, clips intersect. */
+declare function combine(a: Motion, b: Motion): Motion;
+/** Kinds the overlay plane draws (as DOM in the preview, through Satori and skia in the export) rather than the canvas. */
+declare const OVERLAY_KINDS: ReadonlySet<string>;
+/**
+ * The tracks whose overlays draw beneath the footage: those below every
+ * visible track that holds footage, when one of them holds an overlay (a
+ * background graphic under the cut, say). Empty otherwise, and then every
+ * overlay draws above the footage as before. When it is not empty, the canvas
+ * holds only the footage over a transparent ground, and the composition
+ * background is painted beneath the backdrop instead.
+ */
+declare function backdropTracks(state: ResolvedState): ReadonlySet<string>;
+export { visiblePlacements as A, scaleM as C, VisibleItem as D, TransitionRole as E, nestedSourceTime as F, placementSourceTime as I, timecode as L, frameTime as M, layerClock as N, isVisibleAt as O, localT as P, rotate as S, translate as T, cssTransform as _, Motion as a, matrixToCss as b, effect as c, DrawRect as d, IDENTITY as f, boundsOf as g, animatedTransform as h, GraphicAnimation as i, frameIndex as j, trackItems as k, motionAt as l, Matrix2D as m, backdropTracks as n, STILL as o, Layout as p, ClipRect as r, combine as s, OVERLAY_KINDS as t, Box as u, fitRect as v, transformMatrix as w, multiply as x, layoutRect as y };

package/dist/engine.d.mts

@@ -0,0 +1,3 @@
+import { $ as postEffects, A as ImageFrameSource, At as FRAME_EPS, B as buildGainEnvelope, Bt as QUEUE_MAX, C as ClipDecoder, Ct as devWarn, D as ErrorFrame, Dt as DUCK_ATTACK_S, E as AssetSources, Et as AUDIO_PRIME_S, F as ManualClock, Ft as MAX_RATE, G as MaskSpec, Gt as SEEK_MODE_SPEED, H as BackgroundGradient, Ht as REVERSE_WINDOW_FRAMES, I as PerformanceClock, It as MIN_RATE, J as buildFramePlan, K as ResolveNested, Kt as SETTLE_MS, L as AudioOccurrence, Lt as MOUNT_AHEAD_S, M as defaultCreateCanvas, Mt as INPUT_IDLE_CLOSE_S, N as fromMap, Nt as LOOKAHEAD_S, O as ErrorFrameSource, Ot as DUCK_RELEASE_S, P as toResolver, Pt as MAX_OPEN_INPUTS, Q as filterString, R as GainPoint, Rt as PICK_EPS, S as DecoderPool, St as captureWarnings, T as AssetSourceDeps, Tt as AUDIO_CHUNK_S, U as DrawOp, Ut as REVERSE_WINDOW_S, V as duckIntervals, Vt as QUEUE_TARGET, W as FramePlan, Wt as SCHEDULER_MS, X as FilterResult, Y as compositionBackground, Z as PostEffect, _ as FrameSourceHooks, _t as MediaHandle, a as TickOptions, at as AudioOutput, b as mediabunnyFrameSourceFactory, bt as PlayerEvents, c as backgroundCss, ct as AudioSourceInfo, d as paintBackground, dt as Ctx2D, et as EASING_FN, f as setMatrix, ft as EnvelopePoint, g as mediabunnyAudioSourceFactory, gt as FrameSourceInfo, h as MediabunnyAudioSource, ht as FrameSourceFactory, i as FrameIntercept, it as AnyCanvas, j as copyFrame, jt as FRAME_WAIT_MS, k as ImageFrame, kt as ENVELOPE_STEP_S, l as backgroundFill, lt as Clock, m as traceMask, mt as FrameSource, n as Compositor, nt as hasKeyframes, o as CanvasPainter, ot as AudioSource, p as roundedRect, pt as Frame, q as blendOf, qt as UNMOUNT_BEHIND_S, r as CompositorDeps, rt as keyframedValue, s as PaintInputs, st as AudioSourceFactory, t as makeNestedResolver, tt as ease, u as coversCanvas, ut as CreateCanvas, v as MediabunnyFrameSource, vt as MediaResolver, w as DecodeMode, wt as AUDIO_CACHE_S, x as MediabunnyInputs, xt as ScheduledSource, y as SampleFrame, yt as PlayerErrorEvent, z as buildAudioPlan, zt as PLAY_PRIME_TIMEOUT_MS } from "./nested-Bd4Y7qrF.mjs";
+import { A as visiblePlacements, C as scaleM, D as VisibleItem, E as TransitionRole, F as nestedSourceTime, I as placementSourceTime, L as timecode, M as frameTime, N as layerClock, O as isVisibleAt, P as localT, S as rotate, T as translate, _ as cssTransform, a as Motion, b as matrixToCss, c as effect, d as DrawRect, f as IDENTITY, g as boundsOf, h as animatedTransform, i as GraphicAnimation, j as frameIndex, k as trackItems, l as motionAt, m as Matrix2D, n as backdropTracks, o as STILL, p as Layout, r as ClipRect, s as combine, t as OVERLAY_KINDS, u as Box, v as fitRect, w as transformMatrix, x as multiply, y as layoutRect } from "./backdrop-BqrzCzTB.mjs";
+export { AUDIO_CACHE_S, AUDIO_CHUNK_S, AUDIO_PRIME_S, AnyCanvas, AssetSourceDeps, AssetSources, AudioOccurrence, AudioOutput, AudioSource, AudioSourceFactory, AudioSourceInfo, BackgroundGradient, Box, CanvasPainter, ClipDecoder, ClipRect, Clock, Compositor, CompositorDeps, CreateCanvas, Ctx2D, DUCK_ATTACK_S, DUCK_RELEASE_S, DecodeMode, DecoderPool, DrawOp, DrawRect, EASING_FN, ENVELOPE_STEP_S, EnvelopePoint, ErrorFrame, ErrorFrameSource, FRAME_EPS, FRAME_WAIT_MS, FilterResult, Frame, FrameIntercept, FramePlan, FrameSource, FrameSourceFactory, FrameSourceHooks, FrameSourceInfo, GainPoint, GraphicAnimation, IDENTITY, INPUT_IDLE_CLOSE_S, ImageFrame, ImageFrameSource, LOOKAHEAD_S, Layout, MAX_OPEN_INPUTS, MAX_RATE, MIN_RATE, MOUNT_AHEAD_S, ManualClock, MaskSpec, Matrix2D, MediaHandle, MediaResolver, MediabunnyAudioSource, MediabunnyFrameSource, MediabunnyInputs, Motion, OVERLAY_KINDS, PICK_EPS, PLAY_PRIME_TIMEOUT_MS, PaintInputs, PerformanceClock, PlayerErrorEvent, PlayerEvents, PostEffect, QUEUE_MAX, QUEUE_TARGET, REVERSE_WINDOW_FRAMES, REVERSE_WINDOW_S, ResolveNested, SCHEDULER_MS, SEEK_MODE_SPEED, SETTLE_MS, STILL, SampleFrame, ScheduledSource, TickOptions, TransitionRole, UNMOUNT_BEHIND_S, VisibleItem, animatedTransform, backdropTracks, backgroundCss, backgroundFill, blendOf, boundsOf, buildAudioPlan, buildFramePlan, buildGainEnvelope, captureWarnings, combine, compositionBackground, copyFrame, coversCanvas, cssTransform, defaultCreateCanvas, devWarn, duckIntervals, ease, effect, filterString, fitRect, frameIndex, frameTime, fromMap, hasKeyframes, isVisibleAt, keyframedValue, layerClock, layoutRect, localT, makeNestedResolver, matrixToCss, mediabunnyAudioSourceFactory, mediabunnyFrameSourceFactory, motionAt, multiply, nestedSourceTime, paintBackground, placementSourceTime, postEffects, rotate, roundedRect, scaleM, setMatrix, timecode, toResolver, traceMask, trackItems, transformMatrix, translate, visiblePlacements };

package/dist/engine.mjs

@@ -0,0 +1,3 @@
+import { $ as MIN_RATE, A as hasKeyframes, B as devWarn, C as transformMatrix, D as visiblePlacements, E as trackItems, F as localT, G as DUCK_RELEASE_S, H as AUDIO_CHUNK_S, I as nestedSourceTime, J as FRAME_WAIT_MS, K as ENVELOPE_STEP_S, L as placementSourceTime, M as frameIndex, N as frameTime, O as EASING_FN, P as layerClock, Q as MAX_RATE, R as timecode, S as scaleM, T as isVisibleAt, U as AUDIO_PRIME_S, V as AUDIO_CACHE_S, W as DUCK_ATTACK_S, X as LOOKAHEAD_S, Y as INPUT_IDLE_CLOSE_S, Z as MAX_OPEN_INPUTS, _ as fitRect, a as backdropTracks, at as REVERSE_WINDOW_FRAMES, b as multiply, c as combine, ct as SEEK_MODE_SPEED, d as filterString, et as MOUNT_AHEAD_S, f as postEffects, g as cssTransform, h as boundsOf, i as OVERLAY_KINDS, it as QUEUE_TARGET, j as keyframedValue, k as ease, l as effect, lt as SETTLE_MS, m as animatedTransform, n as buildFramePlan, nt as PLAY_PRIME_TIMEOUT_MS, ot as REVERSE_WINDOW_S, p as IDENTITY, q as FRAME_EPS, r as compositionBackground, rt as QUEUE_MAX, s as STILL, st as SCHEDULER_MS, t as blendOf, tt as PICK_EPS, u as motionAt, ut as UNMOUNT_BEHIND_S, v as layoutRect, w as translate, x as rotate, y as matrixToCss, z as captureWarnings } from "./frame-plan-BNwblf1s.mjs";
+import { A as buildAudioPlan, C as ImageFrameSource, D as toResolver, E as fromMap, M as duckIntervals, O as ManualClock, S as ImageFrame, T as defaultCreateCanvas, _ as DecoderPool, a as backgroundFill, b as ErrorFrame, c as setMatrix, d as MediabunnyAudioSource, f as mediabunnyAudioSourceFactory, g as MediabunnyInputs, h as mediabunnyFrameSourceFactory, i as backgroundCss, j as buildGainEnvelope, k as PerformanceClock, l as roundedRect, m as SampleFrame, n as Compositor, o as coversCanvas, p as MediabunnyFrameSource, r as CanvasPainter, s as paintBackground, t as makeNestedResolver, u as traceMask, v as ClipDecoder, w as copyFrame, x as ErrorFrameSource, y as AssetSources } from "./nested-DSXA1q8d.mjs";
+export { AUDIO_CACHE_S, AUDIO_CHUNK_S, AUDIO_PRIME_S, AssetSources, CanvasPainter, ClipDecoder, Compositor, DUCK_ATTACK_S, DUCK_RELEASE_S, DecoderPool, EASING_FN, ENVELOPE_STEP_S, ErrorFrame, ErrorFrameSource, FRAME_EPS, FRAME_WAIT_MS, IDENTITY, INPUT_IDLE_CLOSE_S, ImageFrame, ImageFrameSource, LOOKAHEAD_S, MAX_OPEN_INPUTS, MAX_RATE, MIN_RATE, MOUNT_AHEAD_S, ManualClock, MediabunnyAudioSource, MediabunnyFrameSource, MediabunnyInputs, OVERLAY_KINDS, PICK_EPS, PLAY_PRIME_TIMEOUT_MS, PerformanceClock, QUEUE_MAX, QUEUE_TARGET, REVERSE_WINDOW_FRAMES, REVERSE_WINDOW_S, SCHEDULER_MS, SEEK_MODE_SPEED, SETTLE_MS, STILL, SampleFrame, UNMOUNT_BEHIND_S, animatedTransform, backdropTracks, backgroundCss, backgroundFill, blendOf, boundsOf, buildAudioPlan, buildFramePlan, buildGainEnvelope, captureWarnings, combine, compositionBackground, copyFrame, coversCanvas, cssTransform, defaultCreateCanvas, devWarn, duckIntervals, ease, effect, filterString, fitRect, frameIndex, frameTime, fromMap, hasKeyframes, isVisibleAt, keyframedValue, layerClock, layoutRect, localT, makeNestedResolver, matrixToCss, mediabunnyAudioSourceFactory, mediabunnyFrameSourceFactory, motionAt, multiply, nestedSourceTime, paintBackground, placementSourceTime, postEffects, rotate, roundedRect, scaleM, setMatrix, timecode, toResolver, traceMask, trackItems, transformMatrix, translate, visiblePlacements };