@cutcraft/kit 0.0.0-stage → 0.2.0

package/dist/index-BYYpzZuS.d.mts

@@ -0,0 +1,1305 @@
+import { ZodObject, z } from "zod";
+/**
+ * What the ingest service knows about an asset. The model never sees pixels;
+ * it edits against this, and the resolver turns `word:`/`shot:` references
+ * into seconds with it.
+ */
+interface AssetManifest {
+  readonly assets: Readonly<Record<string, AssetEntry>>;
+}
+interface AssetEntry {
+  readonly id: string;
+  readonly kind: "video" | "audio" | "image";
+  /** Seconds. Images report 0 and may be held for any duration. */
+  readonly duration: number;
+  readonly fps?: number;
+  readonly width?: number;
+  readonly height?: number;
+  readonly audio?: {
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly streams: number;
+  };
+  readonly transcript?: {
+    readonly words: readonly TranscriptWord[];
+  };
+  readonly shots?: readonly Shot[];
+  readonly silences?: readonly Silence[];
+  readonly waveform?: WaveformSummary;
+  /** Where the subject (a face, a person) sits in the picture, sampled over time; several boxes may share a `t`. */
+  readonly subjects?: readonly SubjectBox[];
+}
+/** A subject's box at source second `t`, as fractions of the source picture (0..1 from its top left). */
+interface SubjectBox {
+  readonly t: number;
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+interface TranscriptWord {
+  readonly i: number;
+  readonly text: string;
+  readonly start: number;
+  readonly end: number;
+  readonly speaker?: string;
+  /**
+   * The times are shared out from a longer span (an SRT or VTT cue, a segment without word times), not measured per
+   * word: a cut on this word lands near it, not exactly on it.
+   */
+  readonly estimated?: boolean;
+}
+interface Shot {
+  readonly i: number;
+  readonly start: number;
+  readonly end: number;
+}
+interface Silence {
+  readonly i: number;
+  readonly start: number;
+  readonly end: number;
+}
+interface WaveformSummary {
+  readonly binSeconds: number;
+  readonly peaks: readonly number[];
+  readonly rms: readonly number[];
+}
+declare const EMPTY_MANIFEST: AssetManifest;
+declare function assetIdOf(ref: string): string;
+declare function lookupAsset(manifest: AssetManifest, ref: string): AssetEntry | null;
+interface ShaderDefinition {
+  readonly kind: "effect" | "transition";
+  readonly name: string;
+  /** The params `<Effect params>` or `<Transition params>` takes, validated and given defaults by this schema. */
+  readonly params: ZodObject;
+  /**
+   * GLSL ES 3.00 that defines `vec4 effect(vec2 uv)` (an effect) or `vec4 transition(vec2 uv)` (a transition). It may
+   * read `image` (an effect's picture) or `from` and `to` (a transition's two pictures) as `sampler2D`, `resolution`
+   * (vec2, pixels), `time` (seconds into the element), `progress` (0..1 through a transition), and each param by its
+   * name: a number as a float, a boolean as a bool, an array of 2 to 4 numbers as a vec, a colour string as a vec3.
+   */
+  readonly shader: string;
+}
+/** The shaders a module loaded by `loadModule` declared, stored on its exports under this key. */
+declare const MODULE_SHADERS: unique symbol;
+interface DefineOptions {
+  readonly name: string;
+  readonly params?: ZodObject;
+  readonly shader: string;
+}
+/**
+ * Declares an effect drawn by a GLSL function, and returns its name for `<Effect type>`. Call it at the top of the file.
+ *
+ *   const glitch = defineEffect({
+ *     name: "glitch",
+ *     params: z.object({ amount: z.number().min(0).max(1).default(0.3) }),
+ *     shader: `vec4 effect(vec2 uv) {
+ *       float shift = amount * 0.02 * sin(time * 40.0 + uv.y * 80.0);
+ *       return vec4(texture(image, uv + vec2(shift, 0)).r, texture(image, uv).g, texture(image, uv - vec2(shift, 0)).b,
+ *                   texture(image, uv).a);
+ *     }`,
+ *   });
+ *   <Clip id="city" src="asset:city"><Effect id="g" type={glitch} params={{ amount: 0.5 }} /></Clip>
+ */
+declare function defineEffect(options: DefineOptions): string;
+/**
+ * Declares a transition drawn by a GLSL function of the two pictures, and returns its name for `<Transition type>`.
+ *
+ *   const sweep = defineTransition({
+ *     name: "sweep",
+ *     shader: `vec4 transition(vec2 uv) { return uv.x < progress ? texture(to, uv) : texture(from, uv); }`,
+ *   });
+ */
+declare function defineTransition(options: DefineOptions): string;
+/** Runs `load` and returns the shaders declared while it ran: how `loadModule` keeps each file's apart. */
+declare function collectShaders(load: () => void): ShaderDefinition[];
+/** The shaders a module declared: those `loadModule` recorded for it, or else every one declared outside a load. */
+declare function shadersOf(mod: object): readonly ShaderDefinition[];
+/** The shader a file declares under this name for an `<Effect>` or `<Transition>`, if any. */
+declare function shaderFor(shaders: readonly ShaderDefinition[], kind: ShaderDefinition["kind"], type: unknown): ShaderDefinition | undefined;
+/** Whether a file draws anything with a shader it declares: what only a renderer with WebGL draws. */
+declare function usesShaders(state: {
+  readonly shaders: readonly ShaderDefinition[];
+  readonly items: ReadonlyMap<string, {
+    readonly kind: string;
+    readonly props: Readonly<Record<string, unknown>>;
+  }>;
+}): boolean;
+/**
+ * The font families the player ships: the preview and the export load them
+ * from `@cutcraft/player/fonts.css`. All are under the SIL
+ * Open Font License, from the `@fontsource` packages named here. Each comes in
+ * regular and bold, and italic where the family has one.
+ */
+interface BundledFont {
+  readonly family: string;
+  /** The `@fontsource` package, and the file prefix inside its `files/` directory. */
+  readonly id: string;
+  readonly italic: boolean;
+}
+declare const BUNDLED_FONTS: readonly BundledFont[];
+declare const BUNDLED_FONT_WEIGHTS: readonly [400, 700];
+declare function isBundledFont(family: string): boolean;
+type FontStyle = "normal" | "italic";
+/** Where a declared face's file comes from. */
+type FontSource =
+/** A file found the way an asset is: `<id>.ttf` (`.otf`, `.woff`, `.woff2`) in the media folder, or the player's `media`. */
+{
+  readonly kind: "asset";
+  readonly id: string;
+} |
+/** Google Fonts: the export downloads it once into a local cache; the player loads it from Google. */
+{
+  readonly kind: "google";
+};
+/** One face a file declares with `font()` or `googleFont()`. */
+interface DeclaredFont {
+  readonly family: string;
+  readonly weight: number;
+  readonly style: FontStyle;
+  readonly source: FontSource;
+}
+/** The faces a module loaded by `loadModule` declared, stored on its exports under this key. */
+declare const MODULE_FONTS: unique symbol;
+/**
+ * Declares a face from a font file and returns its family, to pass as a `font` prop, a theme font or a CSS
+ * `fontFamily`. Call it at the top of the file with literal arguments, as the editor and lint read them from the source.
+ *
+ *   const brand = font({ family: "Brand Sans", src: "asset:brand", weight: 700 });
+ *   <Title id="hello" font={brand}>Hello</Title>
+ *
+ * `src: "asset:brand"` finds `brand.ttf` (or `.otf`, `.woff`, `.woff2`) where the export finds media, and asks the
+ * player's `media` for `brand`.
+ */
+declare function font(options: {
+  readonly family: string;
+  readonly src: string;
+  readonly weight?: number;
+  readonly style?: FontStyle;
+}): string;
+/**
+ * Declares a Google Fonts family, in each weight and style given (default 400, normal), and returns the family. The
+ * export downloads the files once into `~/.cache/cutcraft/fonts` (`CUTCRAFT_FONT_CACHE` moves it) and reads them from
+ * there; the player loads them from Google.
+ *
+ *   const titan = googleFont("Titan One");
+ *   const inter = googleFont("Inter Tight", { weights: [400, 700], styles: ["normal", "italic"] });
+ */
+declare function googleFont(family: string, options?: {
+  readonly weights?: readonly number[];
+  readonly styles?: readonly FontStyle[];
+}): string;
+/** Runs `load` and returns the faces declared while it ran: how `loadModule` keeps each file's faces apart. */
+declare function collectFonts(load: () => void): DeclaredFont[];
+/** The faces a module declared: those `loadModule` recorded for it, or else every face declared outside a load. */
+declare function fontsOf(mod: object): readonly DeclaredFont[];
+type ResolveErrorCode = "DANGLING_ANCHOR" |
+/** `at` names a moment the anchor does not play: trimmed out, or the anchor is not footage. */
+"INVALID_ANCHOR" |
+/** `at` on an anchor the first version cannot map: reversed, or with speed keys or freezes. */
+"UNSUPPORTED_ANCHOR" | "CYCLE" | "TRIM_PAST_SOURCE" | "UNKNOWN_REF" | "NOT_ADJACENT" | "INSUFFICIENT_HANDLES" | "NO_VISUAL_PARENT" | "DUPLICATE_ID" | "MISSING_ASSET" | "START_ON_SEQUENCE" | "MISSING_START" | "AMBIGUOUS_DURATION" | "INVALID_CHILD" | "INVALID_TIME_RANGE" | "UNKNOWN_TOKEN" | "UNKNOWN_STYLE" | "SCHEMA";
+interface ResolveError {
+  readonly code: ResolveErrorCode;
+  readonly id: string;
+  readonly prop?: string;
+  readonly message: string;
+}
+declare function isResolveError(value: unknown): value is ResolveError;
+type Editable = "literal" | "generated" | "opaque";
+/** Prop keys under this prefix address a Layer's handles rather than the Layer's own props. */
+declare const INTERIOR_PREFIX = "interior.";
+/**
+ * One vocabulary element as collected from the React element tree, before
+ * schema parsing and before placement. `props` are the raw JSX props minus
+ * `children`.
+ */
+interface CollectedNode {
+  readonly id: string;
+  readonly kind: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly children: readonly CollectedNode[];
+  /** Text content for elements whose children are text (Title). */
+  readonly text?: string;
+  readonly parent: string | null;
+  readonly editable: Editable;
+  /** Props whose source value is an expression the editor cannot write (known only when a SourceIndex was supplied). */
+  readonly lockedProps: readonly string[];
+  /** Prop → `schema` key for props that read the file's props; a write to one rewrites `defaults`. */
+  readonly boundProps: Readonly<Record<string, string>>;
+  /** For helper output: which helper produced the node, under which parent, and the helper's nth use in the file. */
+  readonly origin?: {
+    readonly helper: string;
+    readonly callerId: string | null;
+    readonly callIndex: number;
+  };
+  /** A Layer's handles: the one component inside it and its props. The component's body stays opaque. */
+  readonly interior?: LayerInterior;
+}
+interface LayerInterior {
+  readonly component: string;
+  readonly props: Readonly<Record<string, unknown>>;
+}
+interface CollectedTree {
+  readonly root: CollectedNode;
+  readonly byId: ReadonlyMap<string, CollectedNode>;
+  readonly errors: readonly ResolveError[];
+  /** The faces the file declares (`font()`, `googleFont()`); set by `collectModule`. */
+  readonly fonts?: readonly DeclaredFont[];
+  /** The effects and transitions the file declares (`defineEffect()`, `defineTransition()`); set by `collectModule`. */
+  readonly shaders?: readonly ShaderDefinition[];
+}
+declare function walk(node: CollectedNode, visit: (node: CollectedNode, depth: number) => void, depth?: number): void;
+declare function findParentOf(tree: CollectedTree, id: string): CollectedNode | null;
+type Json = null | boolean | number | string | Json[] | {
+  [key: string]: Json;
+};
+/** One change recorded by an action. Patches address elements by id, never by position in the file. */
+type Patch = {
+  readonly op: "set";
+  readonly id: string;
+  readonly prop: string;
+  readonly value: Json | undefined;
+} | {
+  readonly op: "text";
+  readonly id: string;
+  readonly text: string;
+} | {
+  readonly op: "insert";
+  readonly id: string;
+  readonly parent: string;
+  readonly after: string | null;
+  readonly node: CollectedNode;
+} | {
+  readonly op: "remove";
+  readonly id: string;
+} | {
+  readonly op: "move";
+  readonly id: string;
+  readonly parent: string;
+  readonly after: string | null;
+} | {
+  readonly op: "bake";
+  readonly id: string;
+};
+type Presence = "present" | "inserted" | "removed";
+/** The reduced effect of every patch on one element. */
+interface NetPatch {
+  readonly id: string;
+  presence: Presence;
+  readonly props: Map<string, Json | undefined>;
+  text?: string;
+  place?: {
+    parent: string;
+    after: string | null;
+  };
+  node?: CollectedNode;
+  bake: boolean;
+}
+interface PatchLog {
+  readonly entries: readonly Patch[];
+  readonly net: ReadonlyMap<string, NetPatch>;
+  /** Increments on every append or truncate; resolve() memoises on it. */
+  readonly version: number;
+  append(patch: Patch): void;
+  /** Current length, for history entries to remember what they appended. */
+  mark(): number;
+  /** Drop every entry at or after `mark` and rebuild `net`. */
+  truncate(mark: number): void;
+  clear(): void;
+}
+declare const TRACK_LAYOUTS: readonly ["sequence", "free"];
+declare const TRACK_ROLES: readonly ["general", "captions", "dialogue", "music", "effects", "ambience"];
+declare const FIT_MODES: readonly ["contain", "cover", "stretch", "none"];
+declare const BLEND_MODES: readonly ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity", "add", "linear-dodge"];
+declare const EASINGS: readonly ["linear", "ease", "ease-in", "ease-out", "ease-in-out", "hold", "bezier", "smoothstep", "smootherstep", "snappy", "smooth", "spring", "easeInQuad", "easeOutQuad", "easeInOutQuad", "easeInCubic", "easeOutCubic", "easeInOutCubic", "easeInQuart", "easeOutQuart", "easeInOutQuart", "easeInQuint", "easeOutQuint", "easeInOutQuint", "easeInSine", "easeOutSine", "easeInOutSine", "easeInExpo", "easeOutExpo", "easeInOutExpo", "easeInCirc", "easeOutCirc", "easeInOutCirc", "easeInBack", "easeOutBack", "easeInOutBack", "easeInBackStrong", "easeOutBackStrong", "easeInOutBackStrong", "easeInElastic", "easeOutElastic", "easeInOutElastic", "easeInElasticSoft", "easeOutElasticSoft", "easeInOutElasticSoft", "easeInBounce", "easeOutBounce", "easeInOutBounce", "easeInBounceSmall", "easeOutBounceSmall", "easeInOutBounceSmall"];
+declare const MASK_EASINGS: readonly ["linear", "ease-in", "ease-out", "ease-in-out"];
+declare const TRANSITION_TYPES: readonly ["crossfade", "dipToBlack", "dipToWhite", "wipe", "slide", "push"];
+declare const VIDEO_EFFECT_TYPES: readonly ["brightness", "contrast", "saturation", "hue", "temperature", "tint", "blur", "vignette", "grain", "shadow", "grayscale", "sepia", "invert", "levels"];
+declare const TEXT_ANIMATION_PRESETS: readonly ["none", "typewriter", "fade", "slide-up", "slide-down", "slide-left", "slide-right", "scale", "word-by-word"];
+declare const CAPTION_ANIMATIONS: readonly ["none", "word-highlight", "word-by-word", "karaoke", "typewriter"];
+declare const GRAPHIC_ANIMATIONS: readonly ["none", "fade", "slide-left", "slide-right", "slide-up", "slide-down", "scale", "rotate", "bounce", "pop", "draw", "wipe-left", "wipe-right", "wipe-up", "wipe-down", "reveal-center", "reveal-edges", "elastic", "flip-horizontal", "flip-vertical"];
+declare const SHAPE_TYPES: readonly ["rectangle", "circle", "ellipse", "triangle", "arrow", "line", "polygon", "path", "star"];
+declare const KEYFRAME_PROPERTIES: readonly ["transform.position.x", "transform.position.y", "transform.scale.x", "transform.scale.y", "transform.rotation", "transform.opacity", "transform.anchor.x", "transform.anchor.y", "transform.borderRadius", "transform.crop.x", "transform.crop.y", "transform.crop.width", "transform.crop.height", "audio.volume", "audio.pan", "colorGrade.temperature", "colorGrade.tint"];
+/** `effect.<effectId>.<param>` is also a valid keyframe property; see `isKeyframeProperty`. */
+declare const KEYFRAME_PROPERTY_PATTERN: RegExp;
+declare function isKeyframeProperty(value: string): boolean;
+declare const CAPTION_POSITIONS: readonly ["top", "center", "bottom"];
+declare const TEXT_ALIGNS: readonly ["left", "center", "right", "justify"];
+declare const TEXT_VALIGNS: readonly ["top", "middle", "bottom"];
+declare const TEXT_DECORATIONS: readonly ["none", "underline", "line-through", "overline"];
+declare const ANIMATION_UNITS: readonly ["character", "word", "line"];
+declare const MASK_TYPES: readonly ["shape", "drawn"];
+declare const SVG_COLOR_MODES: readonly ["none", "tint", "replace"];
+declare const AUTOMATION_LANES: readonly ["volume", "pan"];
+declare const TRACK_FLAGS: readonly ["locked", "hidden", "muted", "solo"];
+declare const zTrackLayout: z.ZodEnum<{
+  sequence: "sequence";
+  free: "free";
+}>;
+declare const zTrackRole: z.ZodEnum<{
+  general: "general";
+  captions: "captions";
+  dialogue: "dialogue";
+  music: "music";
+  effects: "effects";
+  ambience: "ambience";
+}>;
+declare const zFitMode: z.ZodEnum<{
+  contain: "contain";
+  cover: "cover";
+  stretch: "stretch";
+  none: "none";
+}>;
+declare const zBlendMode: z.ZodEnum<{
+  normal: "normal";
+  multiply: "multiply";
+  screen: "screen";
+  overlay: "overlay";
+  darken: "darken";
+  lighten: "lighten";
+  "color-dodge": "color-dodge";
+  "color-burn": "color-burn";
+  "hard-light": "hard-light";
+  "soft-light": "soft-light";
+  difference: "difference";
+  exclusion: "exclusion";
+  hue: "hue";
+  saturation: "saturation";
+  color: "color";
+  luminosity: "luminosity";
+  add: "add";
+  "linear-dodge": "linear-dodge";
+}>;
+declare const zEasing: z.ZodEnum<{
+  linear: "linear";
+  ease: "ease";
+  "ease-in": "ease-in";
+  "ease-out": "ease-out";
+  "ease-in-out": "ease-in-out";
+  hold: "hold";
+  bezier: "bezier";
+  smoothstep: "smoothstep";
+  smootherstep: "smootherstep";
+  snappy: "snappy";
+  smooth: "smooth";
+  spring: "spring";
+  easeInQuad: "easeInQuad";
+  easeOutQuad: "easeOutQuad";
+  easeInOutQuad: "easeInOutQuad";
+  easeInCubic: "easeInCubic";
+  easeOutCubic: "easeOutCubic";
+  easeInOutCubic: "easeInOutCubic";
+  easeInQuart: "easeInQuart";
+  easeOutQuart: "easeOutQuart";
+  easeInOutQuart: "easeInOutQuart";
+  easeInQuint: "easeInQuint";
+  easeOutQuint: "easeOutQuint";
+  easeInOutQuint: "easeInOutQuint";
+  easeInSine: "easeInSine";
+  easeOutSine: "easeOutSine";
+  easeInOutSine: "easeInOutSine";
+  easeInExpo: "easeInExpo";
+  easeOutExpo: "easeOutExpo";
+  easeInOutExpo: "easeInOutExpo";
+  easeInCirc: "easeInCirc";
+  easeOutCirc: "easeOutCirc";
+  easeInOutCirc: "easeInOutCirc";
+  easeInBack: "easeInBack";
+  easeOutBack: "easeOutBack";
+  easeInOutBack: "easeInOutBack";
+  easeInBackStrong: "easeInBackStrong";
+  easeOutBackStrong: "easeOutBackStrong";
+  easeInOutBackStrong: "easeInOutBackStrong";
+  easeInElastic: "easeInElastic";
+  easeOutElastic: "easeOutElastic";
+  easeInOutElastic: "easeInOutElastic";
+  easeInElasticSoft: "easeInElasticSoft";
+  easeOutElasticSoft: "easeOutElasticSoft";
+  easeInOutElasticSoft: "easeInOutElasticSoft";
+  easeInBounce: "easeInBounce";
+  easeOutBounce: "easeOutBounce";
+  easeInOutBounce: "easeInOutBounce";
+  easeInBounceSmall: "easeInBounceSmall";
+  easeOutBounceSmall: "easeOutBounceSmall";
+  easeInOutBounceSmall: "easeInOutBounceSmall";
+}>;
+declare const zMaskEasing: z.ZodEnum<{
+  linear: "linear";
+  "ease-in": "ease-in";
+  "ease-out": "ease-out";
+  "ease-in-out": "ease-in-out";
+}>;
+declare const zTransitionType: z.ZodEnum<{
+  crossfade: "crossfade";
+  dipToBlack: "dipToBlack";
+  dipToWhite: "dipToWhite";
+  wipe: "wipe";
+  slide: "slide";
+  push: "push";
+}>;
+declare const zVideoEffectType: z.ZodEnum<{
+  hue: "hue";
+  saturation: "saturation";
+  brightness: "brightness";
+  contrast: "contrast";
+  temperature: "temperature";
+  tint: "tint";
+  blur: "blur";
+  vignette: "vignette";
+  grain: "grain";
+  shadow: "shadow";
+  grayscale: "grayscale";
+  sepia: "sepia";
+  invert: "invert";
+  levels: "levels";
+}>;
+declare const zTextAnimationPreset: z.ZodEnum<{
+  none: "none";
+  typewriter: "typewriter";
+  fade: "fade";
+  "slide-up": "slide-up";
+  "slide-down": "slide-down";
+  "slide-left": "slide-left";
+  "slide-right": "slide-right";
+  scale: "scale";
+  "word-by-word": "word-by-word";
+}>;
+declare const zCaptionAnimation: z.ZodEnum<{
+  none: "none";
+  typewriter: "typewriter";
+  "word-by-word": "word-by-word";
+  "word-highlight": "word-highlight";
+  karaoke: "karaoke";
+}>;
+declare const zGraphicAnimation: z.ZodEnum<{
+  none: "none";
+  fade: "fade";
+  "slide-up": "slide-up";
+  "slide-down": "slide-down";
+  "slide-left": "slide-left";
+  "slide-right": "slide-right";
+  scale: "scale";
+  rotate: "rotate";
+  bounce: "bounce";
+  pop: "pop";
+  draw: "draw";
+  "wipe-left": "wipe-left";
+  "wipe-right": "wipe-right";
+  "wipe-up": "wipe-up";
+  "wipe-down": "wipe-down";
+  "reveal-center": "reveal-center";
+  "reveal-edges": "reveal-edges";
+  elastic: "elastic";
+  "flip-horizontal": "flip-horizontal";
+  "flip-vertical": "flip-vertical";
+}>;
+declare const zShapeType: z.ZodEnum<{
+  rectangle: "rectangle";
+  circle: "circle";
+  ellipse: "ellipse";
+  triangle: "triangle";
+  arrow: "arrow";
+  line: "line";
+  polygon: "polygon";
+  path: "path";
+  star: "star";
+}>;
+declare const zKeyframeProperty: z.ZodString;
+type TrackLayout = (typeof TRACK_LAYOUTS)[number];
+type TrackRole = (typeof TRACK_ROLES)[number];
+type FitMode = (typeof FIT_MODES)[number];
+type BlendMode = (typeof BLEND_MODES)[number];
+type Easing = (typeof EASINGS)[number];
+type TransitionType = (typeof TRANSITION_TYPES)[number];
+type VideoEffectType = (typeof VIDEO_EFFECT_TYPES)[number];
+type TrackFlag = (typeof TRACK_FLAGS)[number];
+/**
+ * The built-in themes and motion styles a file can name. A theme is a palette,
+ * fonts, a corner radius, a motion style and named presets per element kind;
+ * presets refer to the palette and fonts through tokens, so one set of presets
+ * serves every theme.
+ */
+declare const THEME_NAMES: readonly ["midnight", "paper", "neon", "pastel", "mono", "bold"];
+type ThemeName = (typeof THEME_NAMES)[number];
+declare const MOTION_NAMES: readonly ["none", "calm", "snappy", "bouncy", "editorial"];
+type MotionName = (typeof MOTION_NAMES)[number];
+/** The palette names every built-in theme fills. `onPrimary` is text drawn on a `primary` fill. */
+declare const PALETTE_KEYS: readonly ["primary", "secondary", "accent", "background", "surface", "text", "muted", "onPrimary"];
+declare const FONT_KEYS: readonly ["heading", "body", "mono"];
+interface MotionAnimation {
+  readonly type: string;
+  readonly duration: number;
+  readonly easing: string;
+}
+/** What a motion style fills where an element says nothing: its entrance, its exit, and a transition's type and length. */
+interface MotionStyle {
+  readonly enter?: MotionAnimation | undefined;
+  readonly exit?: MotionAnimation | undefined;
+  readonly transition?: {
+    readonly type?: string | undefined;
+    readonly duration?: number | undefined;
+  } | undefined;
+}
+type Presets = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
+interface ThemeDefinition {
+  readonly palette: Readonly<Record<(typeof PALETTE_KEYS)[number], string>>;
+  readonly fonts: Readonly<Record<(typeof FONT_KEYS)[number], string>>;
+  readonly radius: number;
+  readonly motion: MotionName;
+  readonly styles: Presets;
+}
+declare const MOTIONS: Readonly<Record<MotionName, MotionStyle>>;
+declare const THEMES: Readonly<Record<ThemeName, ThemeDefinition>>;
+/** The theme tokens resolve against when a file declares none. Its motion and default presets apply only when declared. */
+declare const DEFAULT_THEME: ThemeName;
+/** A file's theme with its base theme merged in: what tokens, presets and motion defaults resolve against. */
+interface ResolvedTheme {
+  /** Whether the file declares a theme. Without one, tokens and named presets still resolve against the default theme; motion and `default` presets do not apply. */
+  readonly declared: boolean;
+  readonly base: string;
+  readonly palette: Readonly<Record<string, string>>;
+  readonly fonts: Readonly<Record<string, string>>;
+  readonly radius: number;
+  /** Null when the motion style fills nothing. */
+  readonly motion: MotionStyle | null;
+  readonly styles: Presets;
+  /** Every token by name, without the `$`. */
+  readonly tokens: Readonly<Record<string, string | number>>;
+}
+/** Where a themed prop's value came from: `$primary`, `style:h1`, `motion` or `theme`. */
+type ThemeOrigin = string;
+interface ThemeIssue {
+  readonly code: "UNKNOWN_TOKEN" | "UNKNOWN_STYLE";
+  readonly prop: string;
+  readonly message: string;
+}
+interface Themed {
+  readonly props: Record<string, unknown>;
+  /** Prop path (dot-separated) → where its value came from. Empty when nothing was themed. */
+  readonly from: Readonly<Record<string, ThemeOrigin>>;
+  readonly issues: readonly ThemeIssue[];
+}
+/** The theme a composition's raw `theme` prop describes. Memoised per object; an invalid theme falls back to its base (the schema reports why). */
+declare function resolveTheme(raw: unknown): ResolvedTheme;
+/** The value of `$name`, or undefined. */
+declare function themeToken(theme: ResolvedTheme, name: string): string | number | undefined;
+/**
+ * An element's raw props with its theme applied, before the schema parses them:
+ * the preset its `style` names (or the kind's `default` preset) fills the props
+ * the element leaves out, the motion style fills `enter`/`exit` (a transition's
+ * type and duration), and whole-string `$token` values become theme values. The
+ * element's own props always win. Returns the input object when nothing was themed.
+ */
+declare function applyTheme(kind: string, raw: Readonly<Record<string, unknown>>, theme: ResolvedTheme): Themed;
+interface Placement {
+  readonly id: string;
+  readonly kind: string;
+  readonly track: string | null;
+  readonly parent: string | null;
+  readonly children: readonly string[];
+  readonly start: number;
+  readonly end: number;
+  readonly duration: number;
+  readonly source?: {
+    readonly in: number;
+    readonly out: number;
+    readonly speed: number;
+    readonly asset: string;
+  };
+  /** Schema-parsed props with defaults applied, after patches. Raw props when the schema rejected them. */
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly editable: Editable;
+  readonly lockedProps: readonly string[];
+  /** Prop → `schema` key; editable, but the fold writes the value into `defaults` rather than the element. */
+  readonly boundProps: Readonly<Record<string, string>>;
+  readonly errors: readonly ResolveError[];
+  /** For transitions between siblings: the two clips. */
+  readonly between?: readonly [string, string];
+  /** A Layer's handles: the component inside it and its current props. */
+  readonly interior?: LayerInterior;
+  /** Props the theme supplied, by dot path: `$primary`, `style:h1`, `motion` or `theme`. Absent when none did. */
+  readonly themed?: Readonly<Record<string, ThemeOrigin>>;
+}
+interface ResolvedTrack {
+  readonly id: string;
+  readonly layout: TrackLayout;
+  readonly order: number;
+  readonly locked: boolean;
+  readonly hidden: boolean;
+  readonly muted: boolean;
+  readonly solo: boolean;
+  readonly role?: TrackRole;
+  readonly group?: string;
+  readonly items: readonly string[];
+}
+interface ResolvedState {
+  readonly composition: {
+    readonly id: string;
+    readonly fps: number;
+    readonly width: number;
+    readonly height: number;
+    readonly duration: number;
+  };
+  readonly tracks: readonly ResolvedTrack[];
+  readonly items: ReadonlyMap<string, Placement>;
+  readonly errors: readonly ResolveError[];
+  readonly tree: CollectedTree;
+  readonly manifest: AssetManifest;
+  readonly log: PatchLog | undefined;
+  /** The composition's theme, its base merged in; the default theme when the file declares none. */
+  readonly theme: ResolvedTheme;
+  /** The faces the file declares (`font()`, `googleFont()`), which every renderer loads. */
+  readonly fonts: readonly DeclaredFont[];
+  /** The effects and transitions the file declares (`defineEffect()`, `defineTransition()`). */
+  readonly shaders: readonly ShaderDefinition[];
+}
+/** Absolute placements for every element, computed from the tree, the manifests and the patch log. Memoised per log on its version. */
+declare function resolve(tree: CollectedTree, manifest: AssetManifest, log?: PatchLog): ResolvedState;
+/** Whether two placements would render and edit the same; used to hand back the previous object. */
+declare function samePlacement(a: Placement, b: Placement): boolean;
+type TimeRef = number | `word:${number}` | `word:${number}.end` | `shot:${number}` | `shot:${number}.end` | `silence:${number}` | `silence:${number}.end` | `marker:${string}`;
+type ParsedTimeRef = {
+  readonly kind: "seconds";
+  readonly value: number;
+} | {
+  readonly kind: "word" | "shot" | "silence";
+  readonly index: number;
+  readonly edge: "start" | "end";
+} | {
+  readonly kind: "marker";
+  readonly id: string;
+} | {
+  readonly kind: "invalid";
+  readonly reason: string;
+};
+declare function isTimeRefString(value: unknown): value is string;
+declare function parseTimeRef(ref: unknown): ParsedTimeRef;
+/**
+ * Turn a reference into seconds. Word, shot and silence references are source
+ * times on the asset; marker references are composition times.
+ */
+declare function resolveTimeRef(ref: unknown, asset: AssetEntry | null, markers: ReadonlyMap<string, number>, ctx: {
+  readonly id: string;
+  readonly prop: string;
+}): number | ResolveError;
+type ActionErrorCode = "ELEMENT_NOT_FOUND" | "TRACK_LOCKED" | "LOCKED_PROP" | "OPAQUE_TARGET" | "INVALID_PARAMS" | "INVALID_TIME_RANGE" | "OUT_OF_BOUNDS" | "NOT_ADJACENT" | "INSUFFICIENT_HANDLES" | "CYCLE" | "DUPLICATE_ID" | "UNSUPPORTED_ON_LAYOUT" | "UNKNOWN_ACTION" | "NOT_IMPLEMENTED";
+interface ActionError {
+  readonly code: ActionErrorCode;
+  readonly message: string;
+  readonly path?: string;
+}
+interface ValidationResult {
+  readonly valid: boolean;
+  readonly errors: readonly ActionError[];
+}
+declare const ok: ValidationResult;
+declare function invalid(...errors: ActionError[]): ValidationResult;
+/** Where a new element goes. Sequence tracks take `after`; free tracks take `start`; overlays may anchor. */
+type PlacementSpec = {
+  readonly after: string | null;
+} | {
+  readonly start: number;
+} | {
+  readonly anchor: string;
+  readonly offset?: number;
+};
+/** A serialisable element to insert: raw JSX props, optional text, optional children. */
+interface NodeSpec {
+  readonly id: string;
+  readonly kind: string;
+  readonly props: Readonly<Record<string, Json | undefined>>;
+  readonly text?: string;
+  readonly children?: readonly NodeSpec[];
+}
+declare function nodeSpecOf(node: CollectedNode): NodeSpec;
+declare function nodeOfSpec(spec: NodeSpec, parent: string | null): CollectedNode;
+type Id = string;
+type Props = Readonly<Record<string, Json | undefined>>;
+interface CompositionActions {
+  "composition/updateSettings": {
+    fps?: number;
+    width?: number;
+    height?: number;
+    sampleRate?: number;
+    channels?: number;
+  };
+  "composition/setBackground": {
+    mode?: "color" | "blur";
+    color?: string;
+  };
+  /** The tweaks panel: rewrites the file's `defaults` literal. */
+  "composition/setProps": {
+    defaults: Readonly<Record<string, Json>>;
+  };
+  /** Swap the theme (or remove it with null); with `merge`, lay the given parts over the current theme instead. */
+  "composition/setTheme": {
+    theme: Readonly<Record<string, Json>> | null;
+    merge?: boolean;
+  };
+  /** One theme value: a palette colour, a font role or `radius`, by token name without the `$`. */
+  "theme/setToken": {
+    token: string;
+    value: string | number;
+  };
+  "batch/apply": {
+    actions: readonly ActionInput[];
+  };
+}
+interface TrackActions {
+  "track/add": {
+    trackId: Id;
+    position?: number;
+    layout?: TrackLayout;
+    role?: TrackRole;
+    name?: string;
+  };
+  "track/remove": {
+    trackId: Id;
+  };
+  "track/restore": {
+    trackId: Id;
+    node: NodeSpec;
+    position: number;
+  };
+  "track/duplicate": {
+    sourceTrackId: Id;
+    trackId: Id;
+    idMap: Readonly<Record<Id, Id>>;
+    position?: number;
+  };
+  "track/rename": {
+    trackId: Id;
+    name: string;
+  };
+  "track/reorder": {
+    trackId: Id;
+    position: number;
+  };
+  "track/setFlag": {
+    trackId: Id;
+    flag: TrackFlag;
+    value: boolean;
+  };
+  "track/setLayout": {
+    trackId: Id;
+    layout: TrackLayout;
+  };
+  "track/setGroup": {
+    trackId: Id;
+    group?: Id;
+  };
+  "track/consolidate": {
+    trackId: Id;
+  };
+  "track/restorePositions": {
+    trackId: Id;
+    positions: readonly {
+      id: Id;
+      start: number;
+    }[];
+  };
+}
+interface ClipActions {
+  "clip/add": {
+    id: Id;
+    trackId: Id;
+    src: string;
+    place: PlacementSpec;
+    in?: TimeRef;
+    out?: TimeRef;
+    duration?: number;
+  };
+  /** An <Audio> (sound only: music, a voice-over), placed like a clip; `duration: "fill"` runs to the composition's end. */
+  "audio/add": {
+    id: Id;
+    trackId: Id;
+    src: string;
+    place: PlacementSpec;
+    in?: TimeRef;
+    out?: TimeRef;
+    duration?: number | "fill";
+  };
+  "clip/remove": {
+    id: Id;
+  };
+  "clip/restore": {
+    id: Id;
+    node: NodeSpec;
+    trackId: Id;
+    place: PlacementSpec;
+  };
+  "clip/rippleDelete": {
+    id: Id;
+  };
+  "clip/rippleRestore": {
+    id: Id;
+    node: NodeSpec;
+    trackId: Id;
+    place: PlacementSpec;
+    affected: readonly {
+      id: Id;
+      start: number;
+    }[];
+  };
+  "clip/move": {
+    id: Id;
+    trackId?: Id;
+    place: PlacementSpec;
+  };
+  "clip/trim": {
+    id: Id;
+    edge: "in" | "out";
+    value: TimeRef;
+  };
+  "clip/split": {
+    id: Id;
+    at: number;
+    newId: Id;
+  };
+  "clip/merge": {
+    id: Id;
+    rightId: Id;
+    original: NodeSpec;
+  };
+  "clip/slip": {
+    id: Id;
+    delta: number;
+  };
+  "clip/slide": {
+    id: Id;
+    delta: number;
+  };
+  "clip/roll": {
+    leftId: Id;
+    rightId: Id;
+    delta: number;
+  };
+  "clip/trimToPlayhead": {
+    id: Id;
+    at: number;
+    edge: "in" | "out";
+  };
+  "clip/restoreTiming": {
+    id: Id;
+    in?: TimeRef;
+    out?: TimeRef;
+    duration?: Json;
+    start?: number;
+  };
+  "clip/closeGapBefore": {
+    id: Id;
+  };
+  "clip/setSpeed": {
+    id: Id;
+    speed: number;
+  };
+  "clip/setReverse": {
+    id: Id;
+    value: boolean;
+  };
+  "clip/setBlend": {
+    id: Id;
+    mode?: string;
+    opacity?: number;
+  };
+  "clip/setFit": {
+    id: Id;
+    value?: string;
+  };
+  "clip/setSource": {
+    id: Id;
+    src: string;
+  };
+  "clip/setAnchor": {
+    id: Id;
+    anchor?: Id | "start";
+    offset?: number;
+  };
+}
+interface SpeedActions {
+  "speed/setKeys": {
+    id: Id;
+    keys: readonly NodeSpec[];
+    after?: Id | null;
+  };
+  "speed/setFreezes": {
+    id: Id;
+    freezes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface TransformActions {
+  "transform/update": {
+    id: Id;
+    transform: Readonly<Record<string, Json>>;
+  };
+}
+interface ChildStack<K extends string> {
+  add: {
+    id: Id;
+    childId: Id;
+    type: K;
+    params?: Readonly<Record<string, Json>>;
+    index?: number;
+  };
+  remove: {
+    id: Id;
+    childId: Id;
+  };
+  restore: {
+    id: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  update: {
+    id: Id;
+    childId: Id;
+    params: Readonly<Record<string, Json>>;
+  };
+  toggle: {
+    id: Id;
+    childId: Id;
+    enabled: boolean;
+  };
+  setOrder: {
+    id: Id;
+    childIds: readonly Id[];
+  };
+  setStack: {
+    id: Id;
+    nodes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface EffectActions {
+  "effect/add": ChildStack<string>["add"];
+  "effect/remove": ChildStack<string>["remove"];
+  "effect/restore": ChildStack<string>["restore"];
+  "effect/update": ChildStack<string>["update"];
+  "effect/toggle": ChildStack<string>["toggle"];
+  "effect/setOrder": ChildStack<string>["setOrder"];
+  "effect/setStack": ChildStack<string>["setStack"];
+  "colorGrade/set": {
+    id: Id;
+    grading?: Readonly<Record<string, Json>>;
+  };
+}
+interface KeyframeActions {
+  "keyframe/add": {
+    id: Id;
+    keyId: Id;
+    property: string;
+    at: number;
+    value: Json;
+    easing?: string;
+  };
+  "keyframe/remove": {
+    id: Id;
+    keyId: Id;
+  };
+  "keyframe/restore": {
+    id: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "keyframe/update": {
+    id: Id;
+    keyId: Id;
+    value?: Json;
+    easing?: string;
+  };
+  "keyframe/move": {
+    id: Id;
+    keyId: Id;
+    at: number;
+  };
+  "keyframe/setAll": {
+    id: Id;
+    nodes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface TransitionActions {
+  "transition/add": {
+    transitionId: Id;
+    between: readonly [Id, Id] | {
+      on: Id;
+      edge: "in" | "out";
+    };
+    /** A built-in transition, or one the file declares with `defineTransition()`. */
+    type: TransitionType | (string & {});
+    duration: number;
+    params?: Readonly<Record<string, Json>>;
+  };
+  "transition/remove": {
+    transitionId: Id;
+  };
+  "transition/restore": {
+    transitionId: Id;
+    node: NodeSpec;
+    trackId: Id;
+    after: Id | null;
+  };
+  "transition/update": {
+    transitionId: Id;
+    type?: TransitionType | (string & {});
+    duration?: number;
+    params?: Readonly<Record<string, Json>>;
+  };
+}
+interface AudioActions {
+  "audio/setVolume": {
+    id: Id;
+    volume: number;
+  };
+  "audio/setFade": {
+    id: Id;
+    in?: number;
+    out?: number;
+  };
+  "audio/setAutomation": {
+    id: Id;
+    lane: "volume" | "pan";
+    points: readonly (readonly [number, number])[];
+  };
+  "audio/setDuck": {
+    id: Id;
+    duck?: {
+      under: Id;
+      to: number;
+      attack?: number;
+      release?: number;
+    };
+  };
+}
+interface Overlay {
+  create: {
+    id: Id;
+    kind: string;
+    trackId: Id;
+    place: PlacementSpec;
+    props: Props;
+    text?: string;
+    children?: readonly NodeSpec[];
+    after?: Id | null;
+  };
+  update: {
+    id: Id;
+    props: Props;
+  };
+  remove: {
+    id: Id;
+  };
+}
+interface OverlayActions {
+  "text/create": Overlay["create"];
+  "text/update": Overlay["update"];
+  "text/remove": Overlay["remove"];
+  "text/setContent": {
+    id: Id;
+    text: string;
+  };
+  "shape/create": Overlay["create"];
+  "shape/update": Overlay["update"];
+  "shape/remove": Overlay["remove"];
+  "svg/create": Overlay["create"];
+  "svg/update": Overlay["update"];
+  "svg/remove": Overlay["remove"];
+  "sticker/create": Overlay["create"];
+  "sticker/update": Overlay["update"];
+  "sticker/remove": Overlay["remove"];
+  "graphic/create": Overlay["create"];
+  "graphic/update": Overlay["update"];
+  "graphic/remove": Overlay["remove"];
+  "adjustment/create": Overlay["create"];
+  "adjustment/update": Overlay["update"];
+  "adjustment/remove": Overlay["remove"];
+  "nested/create": Overlay["create"];
+  "nested/update": Overlay["update"];
+  "nested/remove": Overlay["remove"];
+  "nested/extract": {
+    id: Id;
+  };
+}
+interface CaptionActions {
+  "caption/import": {
+    captionsId: Id;
+    src?: string;
+    items?: readonly NodeSpec[];
+  };
+  "caption/add": {
+    captionsId: Id;
+    captionId: Id;
+    start: TimeRef;
+    end: TimeRef;
+    text: string;
+    words?: Json;
+  };
+  "caption/update": {
+    captionId: Id;
+    text?: string;
+    start?: TimeRef;
+    end?: TimeRef;
+    words?: Json;
+  };
+  "caption/remove": {
+    captionId: Id;
+  };
+  "caption/restore": {
+    captionsId: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "caption/setStyle": {
+    captionsId: Id;
+    style?: Readonly<Record<string, Json>>;
+  };
+  "caption/setAnimation": {
+    captionsId: Id;
+    animation: string;
+  };
+  "caption/setAll": {
+    captionsId: Id;
+    nodes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface MarkerActions {
+  "marker/add": {
+    markerId: Id;
+    at: number;
+    label?: string;
+    color?: string;
+  };
+  "marker/update": {
+    markerId: Id;
+    at?: number;
+    label?: string;
+    color?: string;
+  };
+  "marker/remove": {
+    markerId: Id;
+  };
+  "marker/restore": {
+    node: NodeSpec;
+    after: Id | null;
+  };
+}
+interface MaskActions {
+  "mask/create": {
+    id: Id;
+    parentId: Id;
+    props: Props;
+  };
+  "mask/update": {
+    id: Id;
+    props: Props;
+  };
+  "mask/remove": {
+    id: Id;
+  };
+  "mask/restore": {
+    id: Id;
+    parentId: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "mask/setPath": {
+    id: Id;
+    path: Json;
+  };
+}
+interface MulticamActions {
+  "multicam/create": {
+    id: Id;
+    trackId: Id;
+    place: PlacementSpec;
+    angles: readonly NodeSpec[];
+    sync?: number;
+  };
+  "multicam/remove": {
+    id: Id;
+  };
+  "multicam/restore": {
+    id: Id;
+    node: NodeSpec;
+    trackId: Id;
+    place: PlacementSpec;
+  };
+  "multicam/setActiveAngle": {
+    id: Id;
+    angle: Id;
+  };
+  "multicam/addCut": {
+    id: Id;
+    cutId: Id;
+    at: number;
+    angle: Id;
+  };
+  "multicam/moveCut": {
+    cutId: Id;
+    at: number;
+  };
+  "multicam/removeCut": {
+    cutId: Id;
+  };
+  "multicam/restoreCut": {
+    id: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "multicam/flatten": {
+    id: Id;
+  };
+}
+interface LayerActions {
+  "layer/setTiming": {
+    id: Id;
+    duration?: Json;
+    anchor?: Id | "start";
+    offset?: number;
+    start?: number;
+  };
+  "layer/setProps": {
+    id: Id;
+    props: Readonly<Record<string, Json | undefined>>;
+  };
+  "layer/setTransform": {
+    id: Id;
+    transform: Readonly<Record<string, Json>>;
+  };
+}
+interface SourceActions {
+  "source/bake": {
+    id: Id;
+  };
+  "source/setProp": {
+    id: Id;
+    prop: string;
+    value: Json | undefined;
+  };
+  /** Several literal props at once; the inverse of every prop-writing action. */
+  "source/setProps": {
+    id: Id;
+    props: Readonly<Record<string, Json | undefined>>;
+  };
+}
+type ActionMap = CompositionActions & TrackActions & ClipActions & SpeedActions & TransformActions & EffectActions & KeyframeActions & TransitionActions & AudioActions & OverlayActions & CaptionActions & MarkerActions & MaskActions & MulticamActions & LayerActions & SourceActions;
+type ActionType = keyof ActionMap;
+interface Action<T extends ActionType = ActionType> {
+  readonly type: T;
+  readonly actionId: string;
+  readonly ts: number;
+  readonly params: ActionMap[T];
+}
+type ActionInput<T extends ActionType = ActionType> = {
+  readonly type: T;
+  readonly params: ActionMap[T];
+};
+type Namespace = ActionType extends `${infer N}/${string}` ? N : never;
+/** Rapid repeats of these on the same target collapse into one undo step (OpenReel's rule). */
+declare const AUTO_GROUP_TYPES: ReadonlySet<ActionType>;
+declare const TARGET_PARAM_KEYS: readonly ["id", "leftId", "trackId", "transitionId", "childId", "keyId", "captionId", "captionsId", "cutId", "markerId"];
+declare function targetIdOf(action: ActionInput): string | null;
+declare function describeAction(action: ActionInput): string;
+export { FONT_KEYS as $, zTrackRole as $t, ValidationResult as A, ShaderDefinition as An, TEXT_DECORATIONS as At, Placement as B, Shot as Bn, VIDEO_EFFECT_TYPES as Bt, TransitionActions as C, MODULE_FONTS as Cn, KEYFRAME_PROPERTY_PATTERN as Ct, ActionErrorCode as D, googleFont as Dn, SVG_COLOR_MODES as Dt, ActionError as E, fontsOf as En, SHAPE_TYPES as Et, ParsedTimeRef as F, shadersOf as Fn, TRANSITION_TYPES as Ft, ResolvedTheme as G, assetIdOf as Gn, zEasing as Gt, ResolvedTrack as H, SubjectBox as Hn, isKeyframeProperty as Ht, TimeRef as I, usesShaders as In, TrackFlag as It, Themed as J, zKeyframeProperty as Jt, ThemeIssue as K, lookupAsset as Kn, zFitMode as Kt, isTimeRefString as L, AssetEntry as Ln, TrackLayout as Lt, nodeOfSpec as M, defineEffect as Mn, TRACK_FLAGS as Mt, nodeSpecOf as N, defineTransition as Nn, TRACK_LAYOUTS as Nt, NodeSpec as O, isBundledFont as On, TEXT_ALIGNS as Ot, ok as P, shaderFor as Pn, TRACK_ROLES as Pt, DEFAULT_THEME as Q, zTrackLayout as Qt, parseTimeRef as R, AssetManifest as Rn, TrackRole as Rt, TransformActions as S, FontStyle as Sn, KEYFRAME_PROPERTIES as St, targetIdOf as T, font as Tn, MASK_TYPES as Tt, resolve as U, TranscriptWord as Un, zBlendMode as Ut, ResolvedState as V, Silence as Vn, VideoEffectType as Vt, samePlacement as W, WaveformSummary as Wn, zCaptionAnimation as Wt, resolveTheme as X, zShapeType as Xt, applyTheme as Y, zMaskEasing as Yt, themeToken as Z, zTextAnimationPreset as Zt, OverlayActions as _, BUNDLED_FONTS as _n, EASINGS as _t, ActionType as a, PatchLog as an, PALETTE_KEYS as at, TARGET_PARAM_KEYS as b, DeclaredFont as bn, FitMode as bt, ClipActions as c, CollectedTree as cn, THEME_NAMES as ct, KeyframeActions as d, LayerInterior as dn, ANIMATION_UNITS as dt, zTransitionType as en, MOTIONS as et, LayerActions as f, findParentOf as fn, AUTOMATION_LANES as ft, Namespace as g, isResolveError as gn, CAPTION_POSITIONS as gt, MulticamActions as h, ResolveErrorCode as hn, CAPTION_ANIMATIONS as ht, ActionMap as i, Patch as in, MotionStyle as it, invalid as j, collectShaders as jn, TEXT_VALIGNS as jt, PlacementSpec as k, MODULE_SHADERS as kn, TEXT_ANIMATION_PRESETS as kt, CompositionActions as l, Editable as ln, ThemeDefinition as lt, MaskActions as m, ResolveError as mn, BlendMode as mt, Action as n, Json as nn, MotionAnimation as nt, AudioActions as o, Presence as on, Presets as ot, MarkerActions as p, walk as pn, BLEND_MODES as pt, ThemeOrigin as q, zGraphicAnimation as qt, ActionInput as r, NetPatch as rn, MotionName as rt, CaptionActions as s, CollectedNode as sn, THEMES as st, AUTO_GROUP_TYPES as t, zVideoEffectType as tn, MOTION_NAMES as tt, EffectActions as u, INTERIOR_PREFIX as un, ThemeName as ut, SourceActions as v, BUNDLED_FONT_WEIGHTS as vn, Easing as vt, describeAction as w, collectFonts as wn, MASK_EASINGS as wt, TrackActions as x, FontSource as xn, GRAPHIC_ANIMATIONS as xt, SpeedActions as y, BundledFont as yn, FIT_MODES as yt, resolveTimeRef as z, EMPTY_MANIFEST as zn, TransitionType as zt };