motionrender 0.0.0-stage → 0.2.0

package/dist/types/packages/core/src/index.d.ts

@@ -0,0 +1,63 @@
+import { outputFormats, type Composition } from '../../schema/src/index.js';
+import { type X264Preset } from '../../ffmpeg/src/index.js';
+export * from '../../schema/src/index.js';
+export * from '../../timeline/src/index.js';
+export { planAudio } from './audio.js';
+export { masterAudio, measureMix, measureLoudness, sfxFile } from './audio.js';
+export { cacheRoot, cacheUsage, cleanCache, type CacheUsage } from '../../assets/src/index.js';
+export { reviewComposition, type ReviewIssue, type ReviewResult, type ReviewOptions } from './review.js';
+export { measureMedia, attachCaptions, prepareComposition, captionTrack } from './media.js';
+export * from './distributed.js';
+export { createRenderer, renderFrames, defaultConcurrency, launchBrowser, describeBrowser, browserInstallHint, type Renderer } from '../../renderer/src/index.js';
+export { x264Presets, defaultPreset, checkFfmpeg, requiredEncoders, ffmpegPath, ffprobePath, type X264Preset } from '../../ffmpeg/src/index.js';
+export type OutputFormat = typeof outputFormats[number];
+export type LoadedComposition = {
+    composition: Composition;
+    baseDir: string;
+};
+export declare function loadCompositionFile(path: string, values?: Record<string, unknown>): Promise<LoadedComposition>;
+export type RenderProgress = {
+    frame: number;
+    rendered: number;
+    total: number;
+};
+export type RenderMediaOptions = {
+    output: string;
+    baseDir?: string;
+    /** Run the composition's code layers (JavaScript). Only for compositions you trust. */
+    allowCode?: boolean;
+    /** Overrides the composition's export settings. When format is left out it follows the output's extension, then export.format. */
+    format?: OutputFormat;
+    codec?: 'h264' | 'h265';
+    transparent?: boolean;
+    /** Overrides export.crf / bitrate / audioBitrate / scale / loudness. */ crf?: number;
+    bitrate?: string;
+    audioBitrate?: string;
+    scale?: number;
+    loudness?: number;
+    /** false renders without the composition's motion blur, for quick drafts. */ motionBlur?: boolean;
+    /** First and last frame to render, inclusive. Defaults to the whole composition. */
+    frameRange?: [number, number];
+    concurrency?: number;
+    preset?: X264Preset;
+    onProgress?: (progress: RenderProgress) => void;
+    signal?: AbortSignal;
+    /** false renders silent video; distributed chunks use this and the audio is mixed once when they are joined. */
+    audio?: boolean;
+};
+export type RenderMediaResult = {
+    output: string;
+    format: OutputFormat;
+    frames: number;
+    durationSeconds: number;
+};
+export declare const formatForOutput: (output: string, fallback: OutputFormat) => OutputFormat;
+export declare function renderMedia(composition: Composition, options: RenderMediaOptions): Promise<RenderMediaResult>;
+export type RenderStillOptions = {
+    frame?: number;
+    output?: string;
+    baseDir?: string;
+    transparent?: boolean;
+    allowCode?: boolean;
+};
+export declare function renderStill(composition: Composition, options?: RenderStillOptions): Promise<Buffer>;

package/dist/types/packages/core/src/media.d.ts

@@ -0,0 +1,11 @@
+import { type Composition, type MediaInfo, type CaptionCue } from '../../schema/src/index.js';
+type Measured = {
+    duration: number;
+    sounds: [number, number][];
+};
+export declare function measureSource(source: string): Promise<Measured>;
+export declare function measureMedia(raw: any, baseDir: string, fps?: any): Promise<Record<string, MediaInfo>>;
+export declare function attachCaptions(composition: Composition, baseDir: string): Promise<Composition>;
+export declare function captionTrack(composition: Composition): CaptionCue[];
+export declare function prepareComposition(raw: unknown, values?: Record<string, unknown>, baseDir?: string): Promise<Composition>;
+export {};

package/dist/types/packages/core/src/review.d.ts

@@ -0,0 +1,29 @@
+import type { Composition } from '../../schema/src/index.js';
+export type ReviewIssue = {
+    severity: 'error' | 'warning' | 'info';
+    code: string;
+    message: string;
+    frame?: number;
+    layer?: string;
+};
+export type ReviewResult = {
+    issues: ReviewIssue[];
+    sheet: Buffer;
+    sheetFrames: number[];
+    sampledFrames: number;
+    loudness?: {
+        integrated: number;
+        truePeak: number;
+    };
+};
+export type ReviewOptions = {
+    allowCode?: boolean;
+    baseDir?: string;
+    every?: number;
+    sheetFrames?: number;
+    columns?: number;
+    concurrency?: number;
+    audio?: boolean;
+    onProgress?: (done: number, total: number) => void;
+};
+export declare function reviewComposition(composition: Composition, options?: ReviewOptions): Promise<ReviewResult>;

package/dist/types/packages/ffmpeg/src/index.d.ts

@@ -0,0 +1,68 @@
+export declare const x264Presets: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"];
+export type X264Preset = typeof x264Presets[number];
+export type EncodeOptions = {
+    preset?: X264Preset;
+};
+export declare const defaultPreset: X264Preset;
+export type Mp4Encoder = {
+    write(frame: Buffer): Promise<void>;
+    finish(): Promise<void>;
+    abort(): void;
+};
+export type Encoder = Mp4Encoder;
+export declare const ffmpegPath: () => string;
+export declare const ffprobePath: () => string;
+export type AudioClip = {
+    source: string;
+    start: number;
+    duration: number;
+    trim?: number;
+    rate?: number;
+    loop?: boolean;
+    volume?: number;
+    fadeIn?: number;
+    fadeOut?: number;
+    envelope?: [number, number][];
+};
+export declare function envelopeExpression(points: [number, number][]): string;
+export type AudioMix = {
+    clips: AudioClip[];
+    durationSeconds: number;
+    offsetSeconds?: number;
+    gainDb?: number;
+};
+export declare function audioMixArgs(mix: AudioMix | undefined, audioCodec?: string[]): string[];
+export declare const sfxRecipes: Record<string, string[]>;
+export declare const sfxArgs: (name: string, output: string) => string[];
+export type VideoFormat = 'mp4' | 'webm' | 'mov' | 'gif';
+export type QualityOptions = {
+    crf?: number;
+    bitrate?: string;
+    audioBitrate?: string;
+};
+export type VideoEncodeOptions = EncodeOptions & QualityOptions & {
+    format?: VideoFormat;
+    codec?: 'h264' | 'h265';
+    transparent?: boolean;
+};
+export declare function encodeMp4(framesPattern: string, fps: number, output: string, audio?: AudioMix, options?: VideoEncodeOptions): Promise<void>;
+export declare function createEncoder(fps: number, output: string, audio?: AudioMix, options?: VideoEncodeOptions): Encoder;
+export declare const createMp4Encoder: (fps: number, output: string, audio?: AudioMix, options?: EncodeOptions & {
+    codec?: "h264" | "h265";
+}) => Mp4Encoder;
+export declare function concatSegments(segments: string[], listFile: string, output: string, audio?: AudioMix, options?: Pick<VideoEncodeOptions, 'format' | 'audioBitrate'>): Promise<void>;
+export type ExtractOptions = {
+    fps: number;
+    maxWidth: number;
+    maxHeight: number;
+    durationSeconds?: number;
+    startSeconds?: number;
+};
+export declare function extractFrames(source: string, outDir: string, options: ExtractOptions): Promise<void>;
+export declare const requiredEncoders: Record<string, string[]>;
+export declare function checkFfmpeg(): Promise<{
+    version: string;
+    missing: Record<string, string[]>;
+}>;
+export declare function hasAudioStream(path: string): Promise<boolean>;
+export declare function probe(path: string): Promise<string>;

package/dist/types/packages/graphics/src/fonts.d.ts

@@ -0,0 +1,3 @@
+import { type FontSpec } from './index.js';
+export declare function builtinFontDir(): string;
+export declare const builtinFonts: () => Promise<FontSpec[]>;

package/dist/types/packages/graphics/src/index.d.ts

@@ -0,0 +1,121 @@
+import type { EvaluatedLayer } from '../../timeline/src/index.js';
+import { type CaptionCue } from '../../schema/src/index.js';
+export type CaptionWordState = {
+    text: string;
+    state: 0 | 1 | 2;
+    emphasis?: boolean;
+};
+export type DrawOperation = {
+    kind: 'text' | 'image' | 'video' | 'captions' | 'rect' | 'circle' | 'path' | 'group' | 'html' | 'lottie' | 'shader' | 'code' | 'react';
+    layer: EvaluatedLayer;
+    children?: DrawOperation[];
+    frameKey?: string;
+    fontPrefix?: string;
+    fontStack?: string;
+    spanStacks?: string[];
+    caption?: {
+        words: CaptionWordState[];
+    } | null;
+    vars?: Record<string, string | number>;
+    mediaTime?: number;
+};
+export declare const toDrawOperations: (layers: EvaluatedLayer[]) => DrawOperation[];
+export declare const flattenLayers: (layers: readonly any[]) => any[];
+export declare const flattenOperations: (operations: readonly DrawOperation[]) => DrawOperation[];
+export declare const htmlReferences: (layer: {
+    html?: string;
+    css?: string;
+}) => string[];
+export declare const collectCodeSources: (layers: readonly any[]) => string[];
+/** True when any layer runs the composition's own JavaScript. */
+export declare const hasCodeLayers: (layers: readonly any[]) => boolean;
+/** True when any layer is a React component (its markup can name any image asset the composition declares). */
+export declare const hasReactLayers: (layers: readonly any[]) => boolean;
+export declare const collectLottieSources: (layers: readonly any[]) => string[];
+export declare const collectImageSources: (layers: readonly any[]) => string[];
+export type TextLayoutOptions = {
+    fontSize: number;
+    maxWidth?: number;
+    maxLines?: number;
+    minFontSize?: number;
+};
+export type TextLayout = {
+    lines: string[];
+    fontSize: number;
+    truncated: boolean;
+};
+export type TextSpan = {
+    text: string;
+    fontSize?: number;
+    [style: string]: unknown;
+};
+export type RichLayout = {
+    lines: {
+        runs: {
+            text: string;
+            span: number;
+            kind: 'word' | 'space';
+            size: number;
+            width: number;
+        }[];
+        width: number;
+    }[];
+    scale: number;
+    truncated: boolean;
+};
+export type TextNote = {
+    id: string;
+    kind: 'text' | 'captions';
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    size: number;
+    baseSize: number;
+    alpha: number;
+    color: string;
+    truncated: boolean;
+    shrunk: boolean;
+    text: string;
+    words: number;
+};
+export type FrameReport = {
+    texts: TextNote[];
+    thumb: {
+        width: number;
+        height: number;
+        pixels: number[];
+    };
+};
+export type FontSpec = {
+    family: string;
+    src: string;
+    url: string;
+    weight: number | string;
+    style: string;
+    unicodeRange?: string;
+};
+export declare const builtinFontFaces: {
+    family: string;
+    file: string;
+    weight: string;
+    style: 'normal' | 'italic';
+    unicodeRange: string;
+}[];
+export declare const fontStack: (family: string) => string;
+export declare const cssFont: (layer: {
+    fontStyle?: string;
+    fontWeight?: number | string;
+    fontFamily: string;
+}, fontSize: number) => string;
+export declare function captionAt(layer: {
+    cues?: CaptionCue[];
+    maxWords: number;
+    mode: string;
+    offset?: number;
+    dropFillers?: boolean;
+    emphasis?: string[];
+}, seconds: number): {
+    words: CaptionWordState[];
+} | null;
+export declare const prepareOperations: (operations: DrawOperation[], fps?: number) => DrawOperation[];

package/dist/types/packages/graphics/src/runtime.d.ts

@@ -0,0 +1,10 @@
+import type { TextLayoutOptions, TextLayout, TextSpan, RichLayout } from './index.js';
+/** layoutText and layoutRich, as source. */
+export declare const textLayoutSource: string;
+/** The Lottie player as source; it defines a global `lottie` when run as a script. */
+export declare const lottieSource: string;
+export declare const lottiePlayerPath: () => string;
+/** The whole page runtime: text layout followed by createCanvasRuntime(canvas, measurePath). */
+export declare const canvasRuntimeSource: string;
+export declare const layoutText: (text: string, options: TextLayoutOptions, measure: (text: string, fontSize: number) => number) => TextLayout;
+export declare const layoutRich: (spans: TextSpan[], options: TextLayoutOptions, measure: (text: string, span: TextSpan, fontSize: number) => number) => RichLayout;

package/dist/types/packages/jobs/src/env.d.ts

@@ -0,0 +1,78 @@
+import { type AiProvider, type ComposeOptions, type ComposeResult, type NarrateOptions, type NarrateResult, type RevisionMeta } from '../../ai/src/index.js';
+import { type Composition } from '../../core/src/index.js';
+import type { FsProjectStore, Principal, StoredAsset } from '../../storage/src/index.js';
+/** How a job names, finds and describes files. The local implementation maps names to folders on disk; a worker maps them to a scratch folder. */
+export interface JobPaths {
+    /** A path inside the requester's space (relative values resolve from `base`). */
+    resolve(value: string, label: string, base?: string): string;
+    /** `project/path` style name of a file, as shown to people. */
+    relative(file: string): string;
+    urlFor(file: string): string;
+    /** The project a file belongs to. */
+    idOf(file: string): string;
+    projectDir(value: unknown, brief: string): string;
+    fileInside(value: unknown, label: string): string;
+    /** What a job reports about a file it made. */
+    resultFile(file: string): {
+        file: string;
+        relative: string;
+        url: string;
+    };
+    readJson(file: string): Promise<any>;
+    loadForRender(file: string): Promise<{
+        raw: any;
+        composition: Composition;
+        baseDir: string;
+    }>;
+    writeComposition(file: string, composition: Composition, meta?: RevisionMeta): Promise<void>;
+}
+/** Work the job code does not own: picking a template and drawing a thumbnail depend on files that ship with the command line. */
+export type JobCapabilities = {
+    composeSmart(provider: AiProvider, options: ComposeOptions, mode: {
+        full?: boolean;
+    }): Promise<ComposeResult & {
+        template?: string;
+        source?: Record<string, unknown>;
+    }>;
+    narrateSmart(provider: AiProvider, composed: {
+        template?: string;
+    }, options: NarrateOptions & {
+        brief: string;
+        composition: NonNullable<NarrateOptions['composition']>;
+    }): Promise<NarrateResult>;
+    makeThumbnail(raw: any, values: Record<string, unknown>, baseDir: string, options: {
+        frame?: number;
+        title?: string;
+        width?: number;
+    }): Promise<{
+        png: Buffer;
+        frame: number;
+        width: number;
+        height: number;
+    }>;
+};
+export type JobEnv = {
+    who: Principal;
+    paths: JobPaths;
+    /** The AI provider, or the reason there is none. */
+    provider(): AiProvider;
+    /** Who made a revision, for the history. */
+    providerInfo(): {
+        provider?: string;
+        model?: string;
+    };
+    capabilities: JobCapabilities;
+    /** The pictures, video and audio a project holds. */
+    assets(projectId: string): Promise<StoredAsset[]>;
+    /** Only where people may name files anywhere on their own machine (the local studio). Hosted use leaves it out, and jobs that need it refuse. */
+    local?: {
+        inputFile(value: unknown, label: string, extensions: string[]): string;
+    };
+};
+/** Paths for the folder store: every name is resolved inside the principal's space. */
+export declare function createFsPaths(store: FsProjectStore, who: Principal, info?: () => {
+    provider?: string;
+    model?: string;
+}): JobPaths;
+/** Files you already have may be anywhere on disk, but only the kinds the job uses: audio is sent to the provider, rows are read as data. */
+export declare function localInputFile(value: unknown, label: string, extensions: string[]): string;

package/dist/types/packages/jobs/src/handlers.d.ts

@@ -0,0 +1,17 @@
+import type { JobEnv } from './env.js';
+import type { JobSpec } from './queue.js';
+type Input = Record<string, unknown>;
+export declare function createHandlers(env: JobEnv): {
+    compose: (input: Input) => JobSpec;
+    refine: (input: Input) => JobSpec;
+    import: (input: Input) => JobSpec;
+    render: (input: Input) => JobSpec;
+    thumbnail: (input: Input) => JobSpec;
+    review: (input: Input) => JobSpec;
+    narrate: (input: Input) => JobSpec;
+    transcribe: (input: Input) => JobSpec;
+    image: (input: Input) => JobSpec;
+    batch: (input: Input) => JobSpec;
+};
+export type Handlers = ReturnType<typeof createHandlers>;
+export {};

package/dist/types/packages/jobs/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './input.js';
+export * from './queue.js';
+export * from './env.js';
+export * from './handlers.js';
+export * from './redis.js';

package/dist/types/packages/jobs/src/input.d.ts

@@ -0,0 +1,18 @@
+import type { BatchSettings } from '../../ai/src/index.js';
+export declare const textOf: (value: unknown, label: string) => string;
+export declare const optionalText: (value: unknown) => string | undefined;
+export declare const boolOf: (value: unknown) => value is true | "true" | "on";
+export declare function numberIn(value: unknown, fallback: number, label: string, min: number, max: number): number;
+export declare function optionalNumber(value: unknown, label: string, min: number, max: number): number | undefined;
+export declare function integerIn(value: unknown, fallback: number, label: string, min: number, max: number): number;
+/** The canvas from the same presets the CLI uses, so a page and a command produce the same shape. */
+export declare function canvasFor(input?: Record<string, unknown>): {
+    kind: string;
+    width: number;
+    height: number;
+    durationSeconds: number;
+    fps: number;
+};
+/** A folder name that is safe on Windows and POSIX, used when the page leaves the folder blank. */
+export declare function folderName(value: string): string;
+export declare function renderSettings(input: Record<string, unknown>): BatchSettings;

package/dist/types/packages/jobs/src/queue.d.ts

@@ -0,0 +1,70 @@
+import type { Job, JobKind } from '../../contracts/src/index.js';
+import type { Principal } from '../../storage/src/index.js';
+import type { JobEnv } from './env.js';
+/** What a handler gives back: the kind of job and the work to do, reporting progress as it goes. */
+export type JobSpec = {
+    kind: JobKind;
+    run: (progress: (message: string) => void) => Promise<unknown>;
+};
+/** A job as a description, so it can wait in a queue, cross to another process, and be run there: what to do, with what, for whom. */
+export type JobRequest = {
+    kind: JobKind;
+    input: Record<string, unknown>;
+    who: Principal;
+};
+/** Does the work for a request, reporting progress as it goes, and gives the result. */
+export type JobRunner = (request: JobRequest, progress: (message: string) => void) => Promise<unknown>;
+/** Jobs that draw frames (and so need Chromium and run user compositions) are kept apart from jobs that only talk to the AI. */
+export type JobClass = 'render' | 'ai';
+export declare const jobClass: (kind: JobKind) => JobClass;
+export interface JobQueue {
+    enqueue(request: JobRequest): Promise<Job>;
+    /** A job, only for the person who asked for it. */
+    get(id: string, who: Principal): Promise<Job | undefined>;
+    recent(who: Principal): Promise<Job[]>;
+    /** Called with a copy of each of this person's jobs when it is added, starts, reports, or ends. Returns a function that stops listening. */
+    subscribe(who: Principal, listener: (job: Job) => void): () => void;
+    close?(): Promise<void>;
+}
+/** Builds the handlers for one person and checks a request with them, which refuses a bad request straight away (before it is queued). */
+export declare function createJobRunner(makeEnv: (who: Principal) => JobEnv): {
+    /** Throws the same Error the handler would, without running anything. */
+    validate(request: JobRequest): void;
+    run: JobRunner;
+};
+/** One job at a time, in this process, forgotten on restart. A hosted setup puts a durable queue behind the same interface. */
+export declare class InProcessQueue implements JobQueue {
+    private runner;
+    private redact;
+    private entries;
+    private waiting;
+    private listeners;
+    private running;
+    private nextId;
+    /** `redact` cleans a failure message before anyone sees it (a hosted setup removes server paths). */
+    constructor(runner: JobRunner, redact?: (message: string) => string);
+    enqueue(request: JobRequest): Promise<Job>;
+    get(id: string, who: Principal): Promise<{
+        messages: string[];
+        id: string;
+        kind: "image" | "compose" | "refine" | "import" | "thumbnail" | "render" | "review" | "narrate" | "transcribe" | "batch";
+        status: "error" | "done" | "queued" | "running";
+        result?: unknown;
+        error?: string | undefined;
+        startedAt?: number | undefined;
+        endedAt?: number | undefined;
+    } | undefined>;
+    recent(who: Principal): Promise<{
+        messages: string[];
+        id: string;
+        kind: "image" | "compose" | "refine" | "import" | "thumbnail" | "render" | "review" | "narrate" | "transcribe" | "batch";
+        status: "error" | "done" | "queued" | "running";
+        result?: unknown;
+        error?: string | undefined;
+        startedAt?: number | undefined;
+        endedAt?: number | undefined;
+    }[]>;
+    subscribe(who: Principal, listener: (job: Job) => void): () => void;
+    private emit;
+    private pump;
+}

package/dist/types/packages/jobs/src/redis.d.ts

@@ -0,0 +1,42 @@
+import { type ConnectionOptions } from 'bullmq';
+import type { Job } from '../../contracts/src/index.js';
+import type { Principal } from '../../storage/src/index.js';
+import { type JobClass, type JobQueue, type JobRequest } from './queue.js';
+export declare const queueName: (cls: JobClass) => string;
+export declare class RedisQueue implements JobQueue {
+    private connection;
+    private redact;
+    private queues;
+    private events;
+    private listeners;
+    constructor(connection: ConnectionOptions, redact?: (message: string) => string);
+    enqueue(request: JobRequest): Promise<Job>;
+    get(id: string, who: Principal): Promise<{
+        id: string;
+        kind: "image" | "compose" | "refine" | "import" | "thumbnail" | "render" | "review" | "narrate" | "transcribe" | "batch";
+        status: "error" | "done" | "queued" | "running";
+        messages: string[];
+        result?: unknown;
+        error?: string | undefined;
+        startedAt?: number | undefined;
+        endedAt?: number | undefined;
+    } | undefined>;
+    recent(who: Principal): Promise<{
+        id: string;
+        kind: "image" | "compose" | "refine" | "import" | "thumbnail" | "render" | "review" | "narrate" | "transcribe" | "batch";
+        status: "error" | "done" | "queued" | "running";
+        messages: string[];
+        result?: unknown;
+        error?: string | undefined;
+        startedAt?: number | undefined;
+        endedAt?: number | undefined;
+    }[]>;
+    subscribe(who: Principal, listener: (job: Job) => void): () => void;
+    private listening;
+    /** One event stream per lane, started when the first person subscribes; each event is turned into the job as it now is and sent to its owner. */
+    private listen;
+    private toJob;
+    close(): Promise<void>;
+}
+/** BullMQ's connection settings from a redis:// address (redis://:password@host:6379/0). */
+export declare function redisConnection(url: string): ConnectionOptions;

package/dist/types/packages/player/src/bundle.d.ts

@@ -0,0 +1,4 @@
+export declare function bundlePlayer(options?: {
+    outfile?: string;
+    minify?: boolean;
+}): Promise<string>;

package/dist/types/packages/player/src/canvas-runtime.d.ts

@@ -0,0 +1,11 @@
+// The canvas drawing runtime, generated at build time from packages/graphics/runtime/*.js (see bundle.ts), so the Player draws
+// with exactly the code the renderer uses.
+declare module 'ove:canvas-runtime' {
+  export type CanvasRuntime = {
+    canvas: HTMLCanvasElement;
+    images: Map<string, HTMLImageElement>;
+    load(sources: Record<string, string>, fonts: { family: string; src: string; url: string; weight: number | string; style: string; unicodeRange?: string }[], lotties?: Record<string, unknown>, codes?: Record<string, { url?: string; text?: string }>): Promise<void>;
+    draw(payload: { width: number; height: number; background?: unknown; transparent?: boolean; grain?: number; frame?: number; operations: unknown[]; videoFrames?: Record<string, string> }, drawables?: Map<string, CanvasImageSource>): Promise<void>;
+  };
+  export function createCanvasRuntime(canvas: HTMLCanvasElement, measurePath: SVGPathElement): CanvasRuntime;
+}

package/dist/types/packages/player/src/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference path="./canvas-runtime.d.ts" />
+import { type Composition, type MediaInfo } from '../../schema/src/index.js';
+export type PlayerEvent = 'frame' | 'play' | 'pause' | 'ended' | 'error';
+export type PlayerOptions = {
+    /** A composition as JSON (variables are resolved with `values`) or an already loaded one. */ composition: unknown;
+    values?: Record<string, unknown>;
+    /** Measured audio and video for compositions that time scenes from their media ({{media[...]}}), from measureMedia in open-video-engine. */ media?: Record<string, MediaInfo>;
+    /** Where relative media paths in the composition are resolved from, usually the composition file's URL. Defaults to the page URL. */ assetBase?: string | URL;
+    /** Where the built-in Inter font files are served from. Defaults to the `fonts` folder next to the Player script (the package ships it in `dist/fonts`). */ fontBase?: string | URL;
+    /** Where the built-in sound effects (sfx:…) are served from. Defaults to the `sfx` folder next to the Player script. */ sfxBase?: string | URL;
+    /** Lets the composition's code layers run in this page. They execute the composition's JavaScript with the page's full powers, so pass true only for compositions you wrote or trust. */ allowCode?: boolean;
+    controls?: boolean;
+    loop?: boolean;
+    autoplay?: boolean; /** 0–1, multiplies every sound. */
+    volume?: number;
+};
+export type Player = {
+    readonly element: HTMLElement;
+    readonly composition: Composition;
+    readonly frame: number;
+    readonly playing: boolean;
+    play(): Promise<void>;
+    pause(): void;
+    seek(frame: number): Promise<void>;
+    setValues(values: Record<string, unknown>): Promise<void>;
+    on(event: PlayerEvent, listener: (detail: any) => void): () => void;
+    destroy(): void;
+};
+export declare function createPlayer(container: HTMLElement, options: PlayerOptions): Promise<Player>;