@pixerate/editor 0.115.0 → 0.116.0

package/dist/export/index.cjs

@@ -12,9 +12,11 @@
 
 
 
+var _chunkJSSBHMMUcjs = require('../chunk-JSSBHMMU.cjs');
 
 
-var _chunkFV5AXTSFcjs = require('../chunk-FV5AXTSF.cjs');
+
+var _chunkCOAMRKVIcjs = require('../chunk-COAMRKVI.cjs');
 require('../chunk-O6FO6VI3.cjs');
 require('../chunk-5PTR7HTL.cjs');
 require('../chunk-CKRNELPO.cjs');
@@ -35,5 +37,5 @@ require('../chunk-EMQWJA3G.cjs');
 
 
 
-exports.DOCX_ANONYMOUS_AUTHOR = _chunkFV5AXTSFcjs.DOCX_ANONYMOUS_AUTHOR; exports.DOCX_EXPORT_MIME_TYPE = _chunkFV5AXTSFcjs.DOCX_EXPORT_MIME_TYPE; exports.DocxExportController = _chunkFV5AXTSFcjs.DocxExportController; exports.XmlWriter = _chunkFV5AXTSFcjs.XmlWriter; exports.createDocxExportController = _chunkFV5AXTSFcjs.createDocxExportController; exports.createDocxParts = _chunkFV5AXTSFcjs.createDocxParts; exports.deflateRaw = _chunkFV5AXTSFcjs.deflateRaw; exports.docxFileName = _chunkFV5AXTSFcjs.docxFileName; exports.downloadBlob = _chunkFV5AXTSFcjs.downloadBlob; exports.escapeXmlAttr = _chunkFV5AXTSFcjs.escapeXmlAttr; exports.escapeXmlText = _chunkFV5AXTSFcjs.escapeXmlText; exports.exportDocx = _chunkFV5AXTSFcjs.exportDocx; exports.exportDocxBlob = _chunkFV5AXTSFcjs.exportDocxBlob; exports.stripInvalidXmlChars = _chunkFV5AXTSFcjs.stripInvalidXmlChars; exports.writeZip = _chunkFV5AXTSFcjs.writeZip;
+exports.DOCX_ANONYMOUS_AUTHOR = _chunkJSSBHMMUcjs.DOCX_ANONYMOUS_AUTHOR; exports.DOCX_EXPORT_MIME_TYPE = _chunkJSSBHMMUcjs.DOCX_EXPORT_MIME_TYPE; exports.DocxExportController = _chunkJSSBHMMUcjs.DocxExportController; exports.XmlWriter = _chunkJSSBHMMUcjs.XmlWriter; exports.createDocxExportController = _chunkJSSBHMMUcjs.createDocxExportController; exports.createDocxParts = _chunkJSSBHMMUcjs.createDocxParts; exports.deflateRaw = _chunkCOAMRKVIcjs.deflateRaw; exports.docxFileName = _chunkJSSBHMMUcjs.docxFileName; exports.downloadBlob = _chunkJSSBHMMUcjs.downloadBlob; exports.escapeXmlAttr = _chunkJSSBHMMUcjs.escapeXmlAttr; exports.escapeXmlText = _chunkJSSBHMMUcjs.escapeXmlText; exports.exportDocx = _chunkJSSBHMMUcjs.exportDocx; exports.exportDocxBlob = _chunkJSSBHMMUcjs.exportDocxBlob; exports.stripInvalidXmlChars = _chunkJSSBHMMUcjs.stripInvalidXmlChars; exports.writeZip = _chunkCOAMRKVIcjs.writeZip;
 //# sourceMappingURL=index.cjs.map

package/dist/export/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/export/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,g5BAAC","file":"/home/runner/work/editor/editor/packages/core/dist/export/index.cjs"}
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/export/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,g5BAAC","file":"/home/runner/work/editor/editor/packages/core/dist/export/index.cjs"}

package/dist/export/index.js

@@ -5,16 +5,18 @@ import {
   XmlWriter,
   createDocxExportController,
   createDocxParts,
-  deflateRaw,
   docxFileName,
   downloadBlob,
   escapeXmlAttr,
   escapeXmlText,
   exportDocx,
   exportDocxBlob,
-  stripInvalidXmlChars,
+  stripInvalidXmlChars
+} from "../chunk-VJUML33I.js";
+import {
+  deflateRaw,
   writeZip
-} from "../chunk-FGW5OWJ4.js";
+} from "../chunk-LF4WOZXZ.js";
 import "../chunk-AGGUNWT6.js";
 import "../chunk-2GFUA4X5.js";
 import "../chunk-633QC34G.js";

package/dist/{export-BJE8T0YA.d.cts → export-BXxSGBCq.d.cts}

@@ -4,8 +4,8 @@ import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as
 import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.cjs';
 import { B as BezierPath } from './bezier-BfwIbVTl.cjs';
 import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-B39VsOtd.cjs';
-import { w as VectorSubpath, o as Vec2 } from './types-yINF17Ta.cjs';
-import { B as BrushSettings, M as MixerSettings, d as MixerLoad, f as RetouchSettings, g as StrokeCoverage, h as MixerTarget, i as MixerStroke, j as RetouchApply, c as StrokePoint, k as RetouchPaint, C as CoverageMap, P as PaintTileTarget, l as StrokeApply } from './retouch-Bxkuc0KH.cjs';
+import { w as VectorSubpath, o as Vec2 } from './types-Tfly4Aya.cjs';
+import { B as BrushSettings, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, P as PaintTileTarget, g as StrokeApply } from './flow-COCB42TP.cjs';
 
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully

package/dist/{export-Con3UKkm.d.ts → export-Dm44YUvS.d.ts}

@@ -4,8 +4,8 @@ import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as
 import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.js';
 import { B as BezierPath } from './bezier-DYBvLgUH.js';
 import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-DMN30aY6.js';
-import { w as VectorSubpath, o as Vec2 } from './types-1SUQKDAw.js';
-import { B as BrushSettings, M as MixerSettings, d as MixerLoad, f as RetouchSettings, g as StrokeCoverage, h as MixerTarget, i as MixerStroke, j as RetouchApply, c as StrokePoint, k as RetouchPaint, C as CoverageMap, P as PaintTileTarget, l as StrokeApply } from './retouch-Do6tBs2H.js';
+import { w as VectorSubpath, o as Vec2 } from './types-CDLGhAZp.js';
+import { B as BrushSettings, M as MixerSettings, a as MixerLoad, R as RetouchSettings, S as StrokeCoverage, b as MixerTarget, c as MixerStroke, d as RetouchApply, e as StrokePoint, f as RetouchPaint, C as CoverageMap, P as PaintTileTarget, g as StrokeApply } from './flow-BMtHAmg4.js';
 
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully

package/dist/export-Dv0-ZVrV.d.cts

@@ -0,0 +1,501 @@
+/**
+ * Keyframes for a clip's opacity, volume and transform. A property is either a plain number or
+ * `{ keys }`: values at clip-relative times (ms from the clip's start), each with the easing of the
+ * segment that leaves it. Pure functions only, so previews, renders and exports agree.
+ *
+ * Easing is stored as CSS `cubic-bezier(x1, y1, x2, y2)` control points (named easings are the CSS
+ * ones), which is also what After Effects / Lottie speed-and-influence handles convert to exactly.
+ */
+/** How a segment moves from its key to the next: a named curve, `hold` (jump at the next key) or CSS cubic-bezier points. */
+type VideoEase = 'linear' | 'hold' | 'ease-in' | 'ease-out' | 'ease-in-out' | [number, number, number, number];
+declare const VIDEO_EASE_NAMES: readonly ["linear", "hold", "ease-in", "ease-out", "ease-in-out"];
+interface VideoKey {
+    /** Clip-relative time (ms from the clip's start). */
+    t: number;
+    v: number;
+    /** The segment from this key to the next (default linear). Ignored on the last key. */
+    ease?: VideoEase;
+}
+interface VideoKeyframes {
+    /** In time order, at least one. */
+    keys: VideoKey[];
+}
+/** A number, or keyframes for it. */
+type VideoAnimatable = number | VideoKeyframes;
+/** The clip properties that can be keyframed: `opacity`, `volume` (media) and the transform's fields. */
+type VideoKeyframeProperty = 'opacity' | 'volume' | 'x' | 'y' | 'scale' | 'rotation';
+declare const VIDEO_KEYFRAME_PROPERTIES: readonly ["opacity", "volume", "x", "y", "scale", "rotation"];
+declare const VIDEO_TRANSFORM_PROPERTIES: readonly ["x", "y", "scale", "rotation"];
+/** Each property's default and allowed range. */
+declare const VIDEO_KEYFRAME_LIMITS: Record<VideoKeyframeProperty, {
+    default: number;
+    min?: number;
+    max?: number;
+}>;
+declare const isVideoKeyframes: (v: unknown) => v is VideoKeyframes;
+/** The cubic-bezier points for an ease (`null` for linear and hold). */
+declare function videoEaseBezier(ease: VideoEase | undefined): [number, number, number, number] | null;
+/** How far (0–1 in, any y out) an ease has got at progress `p` (0–1) through its segment. */
+declare function videoEaseProgress(ease: VideoEase | undefined, p: number): number;
+/**
+ * A property's value at clip-relative time `clipTime` (ms): the number itself, or the keys
+ * interpolated (held before the first and after the last). `fallback` is used when it is unset.
+ */
+declare function videoValueAt(prop: VideoAnimatable | undefined, clipTime: number, fallback?: number): number;
+/** A property's keys (a plain number or unset gives none). */
+declare const videoKeysOf: (prop: VideoAnimatable | undefined) => VideoKey[];
+/** Shifts every key by `dt` ms (or scales times by `k` first); numbers pass through. */
+declare function retimeVideoAnimatable<T extends VideoAnimatable | undefined>(prop: T, dt: number, k?: number): T;
+/**
+ * Splits keyframes at clip time `at`: the keys before it (with a key added at `at`) and the keys
+ * after it, moved to start at 0 (with a key added at 0). Eased segments across the cut are split
+ * into two curves that trace the same path, so the two halves play exactly as the whole did.
+ */
+declare function splitVideoAnimatable<T extends VideoAnimatable | undefined>(prop: T, at: number): [T, T];
+/** The keys sorted by time, refusing two at the same time. */
+declare function sortVideoKeys(keys: readonly VideoKey[]): VideoKey[];
+/**
+ * Keys with one set (or replaced) at `t`: a plain value becomes keys holding it and the new one.
+ * For a keyframe toggle or "add key at playhead".
+ */
+declare function setVideoKey(prop: VideoAnimatable | undefined, key: VideoKey, fallback: number): VideoKeyframes;
+/** Keys with the one at `t` removed; the value it then holds when none are left. */
+declare function removeVideoKey(prop: VideoKeyframes, t: number): VideoAnimatable;
+/**
+ * Breakpoints `[clipTime, value]` tracing a property as straight lines: linear segments as they
+ * are, holds as steps, eased segments sampled every `step` ms (about two frames).
+ */
+declare function videoKeyframeBreakpoints(prop: VideoKeyframes, step: number): {
+    points: [number, number][];
+    holds: Set<number>;
+};
+/**
+ * An ffmpeg expression for a property, given `time`: an expression for the clip-relative time in
+ * ms (e.g. `(t*1000-1500)`). Piecewise linear `if(lt(…))` chains; eased segments are baked to
+ * breakpoints every `step` ms.
+ */
+declare function videoKeyframeFfmpegExpr(prop: VideoAnimatable | undefined, time: string, fallback: number, step: number): string;
+
+/**
+ * A video project is plain JSON: the media it uses (assets), tracks of clips placed on a timeline,
+ * and markers. Every time is in milliseconds; `fps` sets the frame grid edits snap to and exports use.
+ *
+ * Tracks are listed top to bottom as a timeline shows them: on screen, a clip on an earlier video
+ * track draws over one on a later track. Clips on one track never overlap.
+ */
+
+type VideoAssetKind = 'video' | 'audio' | 'image';
+/** A spoken word in an asset's transcript, timed in the source (ms). */
+interface VideoTranscriptWord {
+    word: string;
+    start: number;
+    end: number;
+}
+/** A smaller copy of an asset's media for the preview (see `VideoAsset.proxies`). */
+interface VideoAssetProxy {
+    /** Its size as a fraction of the original (0.5 = half width and height). */
+    scale: number;
+    /** What the preview loads instead of the original. */
+    src: string;
+    width?: number;
+    height?: number;
+}
+/** A piece of source media. The project refers to it by id; `src` is whatever the host can load. */
+interface VideoAsset {
+    id: string;
+    kind: VideoAssetKind;
+    /** URL, blob URL, path or data URL (whatever the playback engine and exporter can open). */
+    src: string;
+    name?: string;
+    /** Length of the source (ms). Required for video and audio; images have none. */
+    duration?: number;
+    /** Intrinsic size in pixels (video and image). Placement assumes the project size when missing. */
+    width?: number;
+    height?: number;
+    /** Whether a video asset has sound (default true). */
+    hasAudio?: boolean;
+    /** A still to show for a video where its frames cannot be drawn (SVG renders, thumbnails). */
+    poster?: string;
+    /** What is said in it, word by word, timed in the source (see `parseVideoTranscript`). */
+    transcript?: VideoTranscriptWord[];
+    /**
+     * Smaller copies of a video for smooth editing (see `videoProxyFfmpeg`). The preview plays the
+     * one its preview scale picks; exports and EDLs always use `src`. A proxy must have the same
+     * length and timing as the original.
+     */
+    proxies?: VideoAssetProxy[];
+}
+type VideoTrackKind = 'video' | 'audio';
+interface VideoTrack {
+    id: string;
+    kind: VideoTrackKind;
+    name?: string;
+    /** Silences every clip on the track. */
+    muted?: boolean;
+    /** Leaves the track's pictures out of the frame. */
+    hidden?: boolean;
+    /** Refuses edits to the track's clips. */
+    locked?: boolean;
+    /**
+     * Moves with ripple edits made on other sync-locked tracks, so it stays in sync (default true).
+     * Turn it off for a track that should stay put while the others ripple (e.g. a music bed).
+     */
+    syncLocked?: boolean;
+    /** Gain applied to every clip on the track (1 = unchanged, default 1). */
+    volume?: number;
+    clips: VideoClip[];
+}
+/** Where a picture sits in the frame, after it has been fitted. Each field may be keyframed. */
+interface VideoTransform {
+    /** Offset of the centre from the frame's centre, in pixels (default 0). */
+    x?: VideoAnimatable;
+    y?: VideoAnimatable;
+    /** 1 = fitted size (default 1). */
+    scale?: VideoAnimatable;
+    /** Degrees clockwise (default 0). */
+    rotation?: VideoAnimatable;
+}
+/** How a picture is fitted to the frame before its transform: like CSS `object-fit`. */
+type VideoFit = 'contain' | 'cover' | 'fill' | 'none';
+declare const VIDEO_FITS: readonly ["contain", "cover", "fill", "none"];
+/**
+ * - `crossfade`: this clip fades up over the one before.
+ * - `dip`: down into a colour and up out of it.
+ * - `wipe`: an edge travels across, revealing this clip.
+ * - `push`: this clip slides in, pushing the one before out.
+ * - `slide`: this clip slides in over the one before, which stays put.
+ * - `iris`: a circle opens from the centre, revealing this clip.
+ */
+type VideoTransitionType = 'crossfade' | 'dip' | 'wipe' | 'push' | 'slide' | 'iris';
+declare const VIDEO_TRANSITION_TYPES: readonly ["crossfade", "dip", "wipe", "push", "slide", "iris"];
+type VideoWipeDirection = 'left' | 'right' | 'up' | 'down';
+declare const VIDEO_WIPE_DIRECTIONS: readonly ["left", "right", "up", "down"];
+/**
+ * A transition into a clip from the clip that ends where it starts on the same track. It plays over
+ * the cut, half before and half after, so both clips run past the cut into their handles (media
+ * beyond the out point of the one before, before the in point of this one).
+ */
+interface VideoTransition {
+    type: VideoTransitionType;
+    /** Length (ms), centred on the cut. */
+    duration: number;
+    /** For dip: the colour passed through (default black). */
+    color?: string;
+    /** For wipe, push and slide: the way the edge or picture travels (default right: in from the left). */
+    direction?: VideoWipeDirection;
+    /**
+     * Shape of the sound's fades through the transition (see `VideoFadeCurve`). Default
+     * `equal-power` for crossfades and wipes, where two sounds overlap and a linear mix dips in
+     * loudness halfway; `linear` for dips, where one sound fades out before the other fades in.
+     */
+    audioCurve?: VideoFadeCurve;
+}
+/** The curve a transition's sound fades follow (its `audioCurve`, else the default for its type). */
+declare const videoTransitionAudioCurve: (t: VideoTransition) => VideoFadeCurve;
+/**
+ * How a clip's picture mixes with what is beneath it, as in CSS `mix-blend-mode` (`add` sums the
+ * colours, `plus-lighter` in CSS). These are the modes the canvas preview, SVG frames and ffmpeg's
+ * `blend` filter all share.
+ */
+type VideoBlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'add';
+declare const VIDEO_BLEND_MODES: readonly ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "add"];
+/** A 3D LUT a grade applies after its other steps (see `VideoGrade.lut`). */
+interface VideoGradeLut {
+    /** A `.cube` file: whatever the host can load (URL, path) and the exporter can open. */
+    src: string;
+    /** How much of the LUT's change to apply, 0–1 (default 1). */
+    strength?: number;
+    /** A label for the look (default the file's TITLE or name). */
+    name?: string;
+}
+/**
+ * Colour correction for a clip's picture (see `VIDEO_GRADE_CONTROLS` for ranges). Applied in a fixed
+ * order: exposure, contrast, saturation, hue, white balance (temperature and tint), then the LUT.
+ */
+interface VideoGrade {
+    /** Stops: +1 doubles every channel (default 0). */
+    exposure?: number;
+    /** -1 (flat grey) to 1 (twice as steep), around mid grey (default 0). */
+    contrast?: number;
+    /** -1 (black and white) to 1 (twice as saturated); default 0. */
+    saturation?: number;
+    /** Hue rotation in degrees (default 0). */
+    hue?: number;
+    /** -1 (cool) to 1 (warm); default 0. */
+    temperature?: number;
+    /** -1 (green) to 1 (magenta); default 0. */
+    tint?: number;
+    /** A 3D LUT (a `.cube` file) applied last, mixed in at its `strength`. */
+    lut?: VideoGradeLut;
+}
+/**
+ * How a clip enters or leaves: `fade`; `rise` (up into place) or `drop` (down into place);
+ * `slide-left` / `slide-right` (in moving that way); `zoom` (grows into place); `pop` (grows past its
+ * size and settles). Each also fades. An exit plays the same movement backwards.
+ */
+type VideoClipAnimationEffect = 'fade' | 'rise' | 'drop' | 'slide-left' | 'slide-right' | 'zoom' | 'pop';
+declare const VIDEO_CLIP_ANIMATION_EFFECTS: readonly ["fade", "rise", "drop", "slide-left", "slide-right", "zoom", "pop"];
+/** An entrance or exit animation (see `VideoClipAnimationEffect`). */
+interface VideoClipAnimation {
+    effect: VideoClipAnimationEffect;
+    /** Length (ms, default 500). */
+    duration?: number;
+}
+interface VideoClipBase {
+    id: string;
+    name?: string;
+    /** Where it starts on the timeline (ms). */
+    start: number;
+    /** How long it lasts on the timeline (ms). */
+    duration: number;
+    /** 0–1 (default 1), or keyframes (`{ keys: [{ t, v, ease }] }`, `t` in ms from the clip's start). */
+    opacity?: VideoAnimatable;
+    transform?: VideoTransform;
+    /** Default contain. */
+    fit?: VideoFit;
+    /** How the picture mixes with what is beneath it (default normal). */
+    blend?: VideoBlendMode;
+    /** Colour correction of the picture. */
+    grade?: VideoGrade;
+    /** How the picture enters, from the clip's start (on top of any fade in). */
+    animateIn?: VideoClipAnimation;
+    /** How the picture leaves, up to the clip's end. */
+    animateOut?: VideoClipAnimation;
+    /** Fade in from nothing over this long (ms), pictures and sound. */
+    fadeIn?: number;
+    /** Fade out over this long (ms). */
+    fadeOut?: number;
+    /** Transition from the clip before (see `VideoTransition`). */
+    transition?: VideoTransition;
+}
+/**
+ * The shape of a sound fade, the same curves ffmpeg's `afade` draws, so previews and exports agree.
+ * With `x` running 0→1 through a fade in (1→0 through a fade out), the gain is:
+ * - `linear`: x (ffmpeg `tri`). Dips in loudness in the middle of a crossfade.
+ * - `equal-power`: sin(x·π/2) (`qsin`). Keeps loudness steady; the usual choice for crossfades.
+ * - `s-curve`: (1 − cos(x·π))/2 (`hsin`). Gentle at both ends.
+ * - `exponential`: x³ (`cub`). Slow start; a natural-sounding fade in from silence.
+ * - `logarithmic`: 1 − (1 − x)² (`ipar`). Fast start, slow finish.
+ */
+type VideoFadeCurve = 'linear' | 'equal-power' | 's-curve' | 'exponential' | 'logarithmic';
+declare const VIDEO_FADE_CURVES: readonly ["linear", "equal-power", "s-curve", "exponential", "logarithmic"];
+/** A stretch of an asset. */
+interface VideoMediaClip extends VideoClipBase {
+    type: 'media';
+    asset: string;
+    /** Where in the source it starts (ms, default 0). */
+    in?: number;
+    /** Playback speed (default 1): it uses `duration × speed` of the source. */
+    speed?: number;
+    /**
+     * A speed ramp: keys mapping clip time to source time after the in point (`v` ms from `in`), so
+     * a key's slope is the speed there, a flat stretch is a freeze frame and eased keys ramp between
+     * speeds. Never runs backwards. Before the first key and after the last the picture holds. Takes
+     * the place of `speed` (see `videoSpeedRampKeys` for building one from speeds).
+     */
+    timeRemap?: VideoKeyframes;
+    /** Gain (1 = unchanged, default 1), or keyframes. */
+    volume?: VideoAnimatable;
+    /** Silences this clip. */
+    muted?: boolean;
+    /** Shape of the sound's fade in (default linear). The picture always fades linearly. */
+    fadeInCurve?: VideoFadeCurve;
+    /** Shape of the sound's fade out (default linear). */
+    fadeOutCurve?: VideoFadeCurve;
+}
+/** A title. */
+interface VideoTextClip extends VideoClipBase {
+    type: 'text';
+    text: string;
+    /** CSS colour (default white). */
+    color?: string;
+    /** Pixels (default 64). */
+    fontSize?: number;
+    /** Default sans-serif. */
+    fontFamily?: string;
+    /** Default 700. */
+    fontWeight?: number;
+    /** Box behind the text (CSS colour); none by default. */
+    background?: string;
+}
+/** A solid colour filling the frame. */
+interface VideoColorClip extends VideoClipBase {
+    type: 'color';
+    color: string;
+}
+/**
+ * A compound clip: a nested sequence (see `VideoProject.sequences`) played as one picture and one
+ * sound. It plays the sequence's own time from `in`, at normal speed. Its opacity, transform, blend,
+ * grade, fades, transitions and animations apply to the sequence's composite, not to each of its
+ * clips; its volume and fades apply to the sequence's mixed sound.
+ */
+interface VideoSequenceClip extends VideoClipBase {
+    type: 'sequence';
+    /** The id of the sequence it plays (in `project.sequences`). */
+    sequence: string;
+    /** Where in the sequence's time it starts (ms, default 0). */
+    in?: number;
+    /** Gain on the sequence's sound (1 = unchanged, default 1), or keyframes. */
+    volume?: VideoAnimatable;
+    /** Silences the sequence's sound. */
+    muted?: boolean;
+    /** Shape of the sound's fade in (default linear). */
+    fadeInCurve?: VideoFadeCurve;
+    /** Shape of the sound's fade out (default linear). */
+    fadeOutCurve?: VideoFadeCurve;
+}
+type VideoClip = VideoMediaClip | VideoTextClip | VideoColorClip | VideoSequenceClip;
+type VideoClipType = VideoClip['type'];
+/**
+ * How a clip is placed where others already are: `refuse` an overlap (the default), `overwrite`
+ * what is underneath (cutting, trimming or removing it), or `insert` (cut everything across the
+ * point and push later material along on every sync-locked track).
+ */
+type VideoPlacementMode = 'refuse' | 'overwrite' | 'insert';
+declare const VIDEO_PLACEMENT_MODES: readonly ["refuse", "overwrite", "insert"];
+declare const VIDEO_CLIP_TYPES: readonly ["media", "text", "color", "sequence"];
+interface VideoMarker {
+    id: string;
+    time: number;
+    label?: string;
+    /** CSS colour. */
+    color?: string;
+}
+/**
+ * A nested sequence: tracks of clips with their own timeline from 0, played inside the project by
+ * compound clips (`type: 'sequence'`). Its frame is the project's frame size, transparent where no
+ * clip covers it. A sequence may hold compound clips of other sequences, but never itself (directly
+ * or through others).
+ */
+interface VideoSequence {
+    id: string;
+    name?: string;
+    tracks: VideoTrack[];
+}
+interface VideoProject {
+    version: 1;
+    name?: string;
+    /** Frame size in pixels. */
+    width: number;
+    height: number;
+    /** Frames per second: the grid edits snap to and exports use. */
+    fps: number;
+    /** What shows where no clip covers the frame (default black). */
+    background?: string;
+    assets: VideoAsset[];
+    tracks: VideoTrack[];
+    /** Nested sequences that compound clips play (see `VideoSequence`). */
+    sequences?: VideoSequence[];
+    markers?: VideoMarker[];
+}
+
+interface VideoEdlOptions {
+    /** Track to export (default: the bottom video track, V1 in most NLEs). */
+    track?: string;
+    /** Record timecode of the timeline's start (ms; default timecode 01:00:00:00, the usual start). */
+    recordStart?: number;
+    /** Title line (default: the project's name). */
+    title?: string;
+    /** Drop-frame timecode (default on at 29.97 and 59.94 fps, where it is the norm; ignored at other rates). */
+    dropFrame?: boolean;
+}
+/**
+ * One track as a CMX 3600 edit decision list, for conforming in another NLE: an event per clip with
+ * source and record timecode at the project's frame rate (drop-frame at 29.97 and 59.94), dissolves (`D`) for crossfades, dips and
+ * wipes (`W001`), `M2` lines for speed changes, and `* FROM CLIP NAME` comments. Titles, colour
+ * clips and compound clips (not flattened yet) become black (`BL`) events.
+ */
+declare function toVideoEdl(project: VideoProject, options?: VideoEdlOptions): string;
+interface VideoFfmpegOptions {
+    /** Output file (default `output.mp4`). */
+    output?: string;
+    /** The path or URL ffmpeg should open for an asset (default its `src`). */
+    resolve?: (asset: VideoAsset) => string;
+    /** The path ffmpeg's `lut3d` should read for a grade's LUT `src` (default the `src`; it must be a local file). */
+    resolveLut?: (src: string) => string;
+    /** Default `libx264`. */
+    videoCodec?: string;
+    /** Default `aac`. */
+    audioCodec?: string;
+    /** x264 quality (default 18). */
+    crf?: number;
+    /** A font file for titles (drawtext's `fontfile`); default the system's font for the family. */
+    fontFile?: string;
+    /**
+     * Titles as images instead of `drawtext` (which needs an ffmpeg built with libfreetype; Homebrew's
+     * is not): return the path or URL of a transparent PNG the size of the frame showing the title as
+     * the preview draws it (`videoTitleFrame` + `drawVideoFrame`). It is overlaid like a still, with
+     * the title's opacity and fades.
+     */
+    titleImage?: (clip: VideoTextClip, size: {
+        width: number;
+        height: number;
+    }) => string;
+    /** Normalise the mix's loudness with ffmpeg's `loudnorm` (EBU R128). */
+    loudness?: VideoLoudnessTarget;
+}
+/** A loudness to normalise the mix to (`loudnorm`'s I, TP and LRA). */
+interface VideoLoudnessTarget {
+    /** Integrated loudness, in LUFS (default -14, as streaming services play; -16 for podcasts, -23 for EBU R128 broadcast). */
+    integrated?: number;
+    /** Highest true peak, in dBTP (default -1). */
+    truePeak?: number;
+    /** Loudness range, in LU (default 11). */
+    range?: number;
+    /**
+     * The mix as a first pass measured it (`toVideoLoudnessMeasure` then
+     * `parseVideoLoudnessMeasurement`). With it the second pass applies one fixed gain where it can
+     * (linear), so the dynamics are kept; without it `loudnorm` adjusts as it goes in one pass.
+     */
+    measured?: VideoLoudnessMeasurement;
+}
+/** What a measuring pass found (`loudnorm`'s input_i, input_tp, input_lra, input_thresh and target_offset). */
+interface VideoLoudnessMeasurement {
+    /** Integrated loudness (LUFS). */
+    integrated: number;
+    /** True peak (dBTP). */
+    truePeak: number;
+    /** Loudness range (LU). */
+    range: number;
+    /** Gating threshold (LUFS). */
+    threshold: number;
+    /** Offset for the second pass (LU). */
+    offset: number;
+}
+/**
+ * Reads the loudness a measuring pass printed (the JSON `loudnorm` writes to stderr at the end of
+ * `toVideoLoudnessMeasure`'s command). Throws when there is none, or when the mix is silent.
+ */
+declare function parseVideoLoudnessMeasurement(output: string): VideoLoudnessMeasurement;
+interface VideoFfmpegExport {
+    /** Arguments after `ffmpeg` (pass to `spawn('ffmpeg', args)`; no shell quoting needed). */
+    args: string[];
+    /** The same as one shell command line, quoted for a POSIX shell. */
+    command: string;
+    /** The `-filter_complex` graph on its own. */
+    filterComplex: string;
+    /** Length rendered (ms). */
+    duration: number;
+    /** Anything the render only approximates. */
+    notes: string[];
+}
+/** Escapes a value for a filter option inside a filtergraph (option level, then graph level). */
+declare const ffmpegFilterValue: (s: string) => string;
+/** Quotes an argument for a POSIX shell when it needs it. */
+declare const videoShellQuote: (s: string) => string;
+/**
+ * The project as an ffmpeg command: each clip an input trimmed to what it plays (plus transition
+ * overlap), scaled and placed as `videoFrameAt` places it, faded, and overlaid on a background in
+ * track order between its start and end; titles with `drawtext`; sound delayed into place, faded,
+ * mixed and trimmed to the project's length. Render on a server or with ffmpeg.wasm.
+ */
+declare function toVideoFfmpeg(project: VideoProject, options?: VideoFfmpegOptions): VideoFfmpegExport;
+/**
+ * The first pass of a two-pass loudness normalisation: an ffmpeg command that mixes only the sound,
+ * as `toVideoFfmpeg` would, and prints its loudness as JSON on stderr instead of writing a file.
+ * Read it with `parseVideoLoudnessMeasurement` and pass it as `loudness.measured` to
+ * `toVideoFfmpeg`. Throws when nothing on the timeline makes a sound.
+ */
+declare function toVideoLoudnessMeasure(project: VideoProject, options?: Pick<VideoFfmpegOptions, 'resolve' | 'loudness'>): VideoFfmpegExport;
+
+export { removeVideoKey as $, type VideoFfmpegExport as A, type VideoEdlOptions as B, type VideoAssetKind as C, type VideoClipAnimationEffect as D, type VideoTransitionType as E, VIDEO_BLEND_MODES as F, VIDEO_CLIP_ANIMATION_EFFECTS as G, VIDEO_CLIP_TYPES as H, VIDEO_EASE_NAMES as I, VIDEO_FADE_CURVES as J, VIDEO_FITS as K, VIDEO_KEYFRAME_LIMITS as L, VIDEO_KEYFRAME_PROPERTIES as M, VIDEO_PLACEMENT_MODES as N, VIDEO_TRANSFORM_PROPERTIES as O, VIDEO_TRANSITION_TYPES as P, VIDEO_WIPE_DIRECTIONS as Q, type VideoClipType as R, type VideoColorClip as S, type VideoEase as T, type VideoLoudnessMeasurement as U, type VideoProject as V, type VideoLoudnessTarget as W, type VideoSequenceClip as X, ffmpegFilterValue as Y, isVideoKeyframes as Z, parseVideoLoudnessMeasurement as _, type VideoAnimatable as a, retimeVideoAnimatable as a0, setVideoKey as a1, sortVideoKeys as a2, splitVideoAnimatable as a3, toVideoEdl as a4, toVideoFfmpeg as a5, toVideoLoudnessMeasure as a6, videoEaseBezier as a7, videoEaseProgress as a8, videoKeyframeBreakpoints as a9, videoKeyframeFfmpegExpr as aa, videoShellQuote as ab, videoTransitionAudioCurve as ac, videoValueAt as ad, type VideoAsset as b, type VideoAssetProxy as c, type VideoClip as d, type VideoClipAnimation as e, type VideoGrade as f, type VideoGradeLut as g, type VideoKeyframes as h, type VideoMarker as i, type VideoSequence as j, type VideoTrack as k, type VideoTranscriptWord as l, type VideoTransform as m, type VideoTransition as n, type VideoTrackKind as o, type VideoPlacementMode as p, type VideoKeyframeProperty as q, type VideoKey as r, type VideoWipeDirection as s, type VideoBlendMode as t, type VideoFit as u, videoKeysOf as v, type VideoFadeCurve as w, type VideoTextClip as x, type VideoMediaClip as y, type VideoFfmpegOptions as z };