motionrender 0.0.0-stage → 0.2.1

package/dist/types/packages/cli/src/init.d.ts

@@ -0,0 +1,10 @@
+export declare const starterTemplate: string;
+export declare const skillDir: string;
+/** Every skill folder: the main `ove` guide and the task guides (reels, voiceover, batches, AI). */
+export declare const skillsRoot: string;
+export type InitOptions = {
+    force?: boolean;
+    skill?: boolean;
+    template?: string;
+};
+export declare function initProject(dir: string, options?: InitOptions): Promise<string[]>;

package/dist/types/packages/cli/src/serve.d.ts

@@ -0,0 +1,2 @@
+export declare function runServe(env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function runJobWorker(env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/types/packages/cli/src/studio.d.ts

@@ -0,0 +1,36 @@
+import type { Composition } from '../../schema/src/index.js';
+export type TimelineLayer = {
+    id: string;
+    type: string;
+    scene: string;
+    depth: number;
+    start: number;
+    end: number;
+    editable: boolean;
+};
+export declare function findRawLayers(raw: unknown, id: string): Record<string, any>[];
+export declare function layerTimeline(composition: Composition, raw: unknown): TimelineLayer[];
+export type LayerEdit = {
+    id: string;
+    set?: Record<string, unknown>;
+    unset?: string[];
+};
+export declare function applyLayerEdit(raw: unknown, edit: LayerEdit): unknown;
+export type SceneEdit = {
+    id: string;
+    set: {
+        startFrame?: number;
+        durationFrames?: number;
+    };
+};
+/** Moves or resizes a scene written directly in the file's scenes list (not one made by repeat or a variable). */
+export declare function applySceneEdit(raw: unknown, edit: SceneEdit): unknown;
+export type KeyframeEdit = {
+    id: string;
+    animation: number;
+    keyframe: number;
+    frame: number;
+};
+/** Retimes one keyframe of a layer's animation (its frame counts from the layer's own start), keeping the keyframes in order. */
+export declare function applyKeyframeEdit(raw: unknown, edit: KeyframeEdit): unknown;
+export declare function formatLike(previous: string, value: unknown): string;

package/dist/types/packages/cli/src/templates.d.ts

@@ -0,0 +1,63 @@
+import { type NarrateOptions, type NarrateResult, type AiProvider, type ComposeOptions, type ComposeResult, type TemplateChoice } from '../../ai/src/index.js';
+export declare const templatesDir: string;
+export type TemplateVariable = {
+    name: string;
+    type: string;
+    default?: unknown;
+    description?: string;
+    /** list variables: the fields each item has, so a form can show one input per field */
+    items?: Record<string, {
+        type: string;
+        default?: unknown;
+        description?: string;
+    }>;
+};
+export type TemplateInfo = {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    brief?: string;
+    width: number;
+    height: number;
+    fps: number;
+    durationFrames: number;
+    durationSeconds: number;
+    previewFrame: number;
+    variables: TemplateVariable[];
+    order: number;
+};
+export type TemplateFile = {
+    dir: string;
+    info: TemplateInfo;
+    composition: Record<string, unknown>;
+};
+/** Template ids name a folder, so anything with a separator or a dot is refused before it can reach the filesystem. */
+export declare function assertTemplateId(id: string): string;
+/** Reads one template. `template.json` is required, so the starter project (which has none) is not listed as a template. */
+export declare function readTemplate(id: string, root?: string): Promise<TemplateFile>;
+/** Every template folder that has a template.json, in catalogue order. */
+export declare function listTemplates(root?: string): Promise<TemplateInfo[]>;
+/** Every template with its composition, in the shape `composeFromTemplate` reads. */
+export declare function templateChoices(root?: string): Promise<TemplateChoice[]>;
+/**
+ * Compose by filling a ready-made template (a few hundred tokens), and write the whole composition only when that cannot
+ * work: `full` was asked for, assets or batch fields were supplied (templates use neither), no template has the wanted shape,
+ * or the model finds none that suits the brief.
+ */
+export declare function composeSmart(provider: AiProvider, options: ComposeOptions, mode?: {
+    full?: boolean;
+}): Promise<ComposeResult & {
+    template?: string;
+    source?: Record<string, unknown>;
+}>;
+/**
+ * Narrate a composed video. A template video is cut to the voiceover (one spoken line per scene, scenes as long as their line);
+ * a free-form composition gets one script over the whole video, as before.
+ */
+export declare function narrateSmart(provider: AiProvider, composed: {
+    template?: string;
+}, options: NarrateOptions & {
+    brief: string;
+    composition: NonNullable<NarrateOptions['composition']>;
+}): Promise<NarrateResult>;

package/dist/types/packages/cli/src/thumbnail.d.ts

@@ -0,0 +1,20 @@
+export type ThumbnailOptions = {
+    frame?: number;
+    title?: string;
+    width?: number;
+    allowCode?: boolean;
+};
+export type ThumbnailResult = {
+    png: Buffer;
+    frame: number;
+    width: number;
+    height: number;
+};
+/** The frame used when none is given: well into the first scene, once its entrance has played. */
+export declare function defaultThumbnailFrame(scenes: {
+    startFrame: number;
+    durationFrames: number;
+    id: string;
+}[], durationFrames: number): number;
+export declare function makeThumbnail(raw: any, values: Record<string, unknown>, baseDir: string, options?: ThumbnailOptions): Promise<ThumbnailResult>;
+export declare function runThumbnail(argv: string[], raw: any, values: Record<string, unknown>, baseDir: string): Promise<void>;

package/dist/types/packages/cli/src/track.d.ts

@@ -0,0 +1,35 @@
+export type TrackPoint = {
+    frame: number;
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    cx: number;
+    cy: number;
+};
+/** The box around the white of each frame of a matte (video or picture), at `fps` frames a second. Frames with no speaker repeat the last box. */
+export declare function trackMatte(file: string, options?: {
+    fps?: number;
+    threshold?: number;
+}): Promise<TrackPoint[]>;
+/** Keyframes for a box of `labelWidth` x `labelHeight` pixels that stays beside the speaker: on the right when there is room, else on the left. Smoothed. */
+export declare function labelKeyframes(points: TrackPoint[], canvas: {
+    width: number;
+    height: number;
+}, label: {
+    width: number;
+    height: number;
+}, options?: {
+    step?: number;
+    gap?: number;
+}): {
+    xKeys: {
+        frame: number;
+        value: number;
+    }[];
+    yKeys: {
+        frame: number;
+        value: number;
+    }[];
+};
+export declare function runTrack(argv: string[]): Promise<void>;

package/dist/types/packages/cli/src/worker.d.ts

@@ -0,0 +1,13 @@
+export type WorkerOptions = {
+    port?: number;
+    host?: string;
+    token?: string;
+    concurrency?: number;
+    log?: (line: string) => void;
+};
+export type WorkerServer = {
+    url: string;
+    token: string;
+    close(): Promise<void>;
+};
+export declare function startWorker(options?: WorkerOptions): Promise<WorkerServer>;

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

@@ -0,0 +1,377 @@
+import { z } from 'zod';
+export declare const errorSchema: z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>;
+export type ApiError = z.infer<typeof errorSchema>;
+export declare const projectModeSchema: z.ZodEnum<{
+    template: "template";
+    finished: "finished";
+}>;
+export declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    fps: z.ZodNumber;
+    durationFrames: z.ZodNumber;
+    seconds: z.ZodNumber;
+    scenes: z.ZodNumber;
+    modified: z.ZodNumber;
+    revisions: z.ZodNumber;
+    mode: z.ZodEnum<{
+        template: "template";
+        finished: "finished";
+    }>;
+}, z.core.$strip>;
+export type Project = z.infer<typeof projectSchema>;
+export declare const projectListSchema: z.ZodObject<{
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        fps: z.ZodNumber;
+        durationFrames: z.ZodNumber;
+        seconds: z.ZodNumber;
+        scenes: z.ZodNumber;
+        modified: z.ZodNumber;
+        revisions: z.ZodNumber;
+        mode: z.ZodEnum<{
+            template: "template";
+            finished: "finished";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const variableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        color: "color";
+        list: "list";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    items: z.ZodOptional<z.ZodUnknown>;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+export type Variable = z.infer<typeof variableSchema>;
+export declare const textLayerSchema: z.ZodObject<{
+    path: z.ZodString;
+    scene: z.ZodString;
+    id: z.ZodString;
+    content: z.ZodString;
+    fontSize: z.ZodNumber;
+}, z.core.$strip>;
+export type TextLayer = z.infer<typeof textLayerSchema>;
+export declare const assetSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    kind: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type Asset = z.infer<typeof assetSchema>;
+export declare const sceneSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    startFrame: z.ZodNumber;
+    durationFrames: z.ZodNumber;
+}, z.core.$strip>;
+export type Scene = z.infer<typeof sceneSummarySchema>;
+export declare const detailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    fps: z.ZodNumber;
+    durationFrames: z.ZodNumber;
+    mode: z.ZodEnum<{
+        template: "template";
+        finished: "finished";
+    }>;
+    scenes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        startFrame: z.ZodNumber;
+        durationFrames: z.ZodNumber;
+    }, z.core.$strip>>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            color: "color";
+            list: "list";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodUnknown>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    theme: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    texts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        scene: z.ZodString;
+        id: z.ZodString;
+        content: z.ZodString;
+        fontSize: z.ZodNumber;
+    }, z.core.$strip>>;
+    assets: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        kind: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    revisions: z.ZodNumber;
+    source: z.ZodObject<{
+        raw: z.ZodUnknown;
+        media: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        base: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Detail = z.infer<typeof detailSchema>;
+export declare const revisionSchema: z.ZodObject<{
+    n: z.ZodNumber;
+    file: z.ZodString;
+    at: z.ZodString;
+    kind: z.ZodEnum<{
+        baseline: "baseline";
+        compose: "compose";
+        refine: "refine";
+        edit: "edit";
+        import: "import";
+        restore: "restore";
+    }>;
+    label: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    attempts: z.ZodOptional<z.ZodNumber>;
+    frames: z.ZodNumber;
+    scenes: z.ZodNumber;
+    changes: z.ZodArray<z.ZodString>;
+    restoredFrom: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Revision = z.infer<typeof revisionSchema>;
+export declare const historySchema: z.ZodObject<{
+    revisions: z.ZodArray<z.ZodObject<{
+        n: z.ZodNumber;
+        file: z.ZodString;
+        at: z.ZodString;
+        kind: z.ZodEnum<{
+            baseline: "baseline";
+            compose: "compose";
+            refine: "refine";
+            edit: "edit";
+            import: "import";
+            restore: "restore";
+        }>;
+        label: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        attempts: z.ZodOptional<z.ZodNumber>;
+        frames: z.ZodNumber;
+        scenes: z.ZodNumber;
+        changes: z.ZodArray<z.ZodString>;
+        restoredFrom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const blockSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodString;
+    kind: z.ZodEnum<{
+        overlay: "overlay";
+        scene: "scene";
+    }>;
+    durationFrames: z.ZodNumber;
+}, z.core.$loose>;
+export type Block = z.infer<typeof blockSchema>;
+export declare const themeSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    variables: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export type Theme = z.infer<typeof themeSchema>;
+export declare const librarySchema: z.ZodObject<{
+    blocks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodString;
+        kind: z.ZodEnum<{
+            overlay: "overlay";
+            scene: "scene";
+        }>;
+        durationFrames: z.ZodNumber;
+    }, z.core.$loose>>;
+    themes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        variables: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>;
+    templates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Library = z.infer<typeof librarySchema>;
+export declare const jobKindSchema: z.ZodEnum<{
+    image: "image";
+    compose: "compose";
+    refine: "refine";
+    import: "import";
+    thumbnail: "thumbnail";
+    render: "render";
+    review: "review";
+    narrate: "narrate";
+    transcribe: "transcribe";
+    batch: "batch";
+}>;
+export type JobKind = z.infer<typeof jobKindSchema>;
+export declare const jobSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        image: "image";
+        compose: "compose";
+        refine: "refine";
+        import: "import";
+        thumbnail: "thumbnail";
+        render: "render";
+        review: "review";
+        narrate: "narrate";
+        transcribe: "transcribe";
+        batch: "batch";
+    }>;
+    status: z.ZodEnum<{
+        error: "error";
+        done: "done";
+        queued: "queued";
+        running: "running";
+    }>;
+    messages: z.ZodArray<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Job = z.infer<typeof jobSchema>;
+export declare const jobEnvelopeSchema: z.ZodObject<{
+    job: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            image: "image";
+            compose: "compose";
+            refine: "refine";
+            import: "import";
+            thumbnail: "thumbnail";
+            render: "render";
+            review: "review";
+            narrate: "narrate";
+            transcribe: "transcribe";
+            batch: "batch";
+        }>;
+        status: z.ZodEnum<{
+            error: "error";
+            done: "done";
+            queued: "queued";
+            running: "running";
+        }>;
+        messages: z.ZodArray<z.ZodString>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        endedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const statusSchema: z.ZodObject<{
+    outDir: z.ZodString;
+    jobs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            image: "image";
+            compose: "compose";
+            refine: "refine";
+            import: "import";
+            thumbnail: "thumbnail";
+            render: "render";
+            review: "review";
+            narrate: "narrate";
+            transcribe: "transcribe";
+            batch: "batch";
+        }>;
+        status: z.ZodEnum<{
+            error: "error";
+            done: "done";
+            queued: "queued";
+            running: "running";
+        }>;
+        messages: z.ZodArray<z.ZodString>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        endedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    error: z.ZodNullable<z.ZodString>;
+    provider: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        model: z.ZodString;
+        baseUrl: z.ZodString;
+        capabilities: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Status = z.infer<typeof statusSchema>;
+/** What a finished job that wrote a file reports. */
+export declare const resultFileSchema: z.ZodObject<{
+    file: z.ZodString;
+    relative: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type ResultFile = z.infer<typeof resultFileSchema>;
+export declare const newProjectRequest: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodOptional<z.ZodString>;
+    aspect: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    fps: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export declare const renameRequest: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const idRequest: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const variablesRequest: z.ZodObject<{
+    id: z.ZodString;
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const themeRequest: z.ZodObject<{
+    id: z.ZodString;
+    theme: z.ZodString;
+}, z.core.$strip>;
+export declare const textRequest: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const addBlockRequest: z.ZodObject<{
+    id: z.ZodString;
+    block: z.ZodString;
+    at: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    frames: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    scene: z.ZodOptional<z.ZodString>;
+    set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const restoreRequest: z.ZodObject<{
+    file: z.ZodString;
+    n: z.ZodNumber;
+}, z.core.$strip>;
+export type NewProjectRequest = z.infer<typeof newProjectRequest>;
+/** The first problem in a request, in the words the studio shows. */
+export declare function parseRequest<T extends z.ZodType>(schema: T, body: unknown): z.infer<T>;

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

@@ -0,0 +1,14 @@
+import { type Composition } from '../../schema/src/index.js';
+import { type AudioMix } from '../../ffmpeg/src/index.js';
+export declare function sfxFile(name: string): Promise<string>;
+export declare const sourceOf: (composition: Composition, src: string, baseDir: string) => Promise<string>;
+export declare function planAudio(composition: Composition, baseDir: string, probe?: (source: string) => Promise<boolean>): Promise<AudioMix | undefined>;
+export declare function measureMix(mix: AudioMix): Promise<{
+    integrated: number;
+    truePeak: number;
+} | undefined>;
+export declare function masterAudio(composition: Composition, baseDir: string): Promise<AudioMix | undefined>;
+export declare function measureLoudness(composition: Composition, baseDir: string): Promise<{
+    integrated: number;
+    truePeak: number;
+} | undefined>;

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

@@ -0,0 +1,50 @@
+import { type Composition } from '../../schema/src/index.js';
+import { type X264Preset } from '../../ffmpeg/src/index.js';
+import type { RenderMediaResult, RenderProgress } from './index.js';
+export type ChunkFormat = 'mp4' | 'webm' | 'mov';
+export type ChunkSettings = {
+    format: ChunkFormat;
+    codec: 'h264' | 'h265';
+    transparent: boolean;
+    preset: X264Preset;
+    crf?: number;
+    bitrate?: string;
+    scale?: number;
+};
+export type ChunkJob = {
+    index: number;
+    frameRange: [number, number];
+};
+export type RenderWorker = {
+    name: string;
+    renderChunk(composition: Composition, job: ChunkJob, settings: ChunkSettings, signal: AbortSignal): Promise<Buffer>;
+};
+export declare function planChunks(first: number, last: number, chunkSize: number): ChunkJob[];
+export declare function absolutizeSources(composition: Composition, baseDir: string): Composition;
+export type RenderDistributedOptions = {
+    output: string;
+    baseDir?: string;
+    workers: RenderWorker[];
+    chunkSize?: number;
+    frameRange?: [number, number];
+    format?: ChunkFormat;
+    codec?: 'h264' | 'h265';
+    transparent?: boolean;
+    preset?: X264Preset;
+    crf?: number;
+    bitrate?: string;
+    audioBitrate?: string;
+    scale?: number;
+    loudness?: number;
+    motionBlur?: boolean;
+    /** Attempts per chunk beyond the first, each on the next free worker. */ retries?: number;
+    onProgress?: (progress: RenderProgress & {
+        chunk: number;
+        worker: string;
+    }) => void;
+    onWorkerError?: (worker: string, error: Error) => void;
+    signal?: AbortSignal;
+};
+export declare function renderDistributed(composition: Composition, options: RenderDistributedOptions): Promise<RenderMediaResult>;
+export declare function httpWorker(url: string, token: string): RenderWorker;
+export declare const tokensMatch: (given: string, expected: string) => boolean;