/**
 * Mograph execute — the first-class live render path for a motion pack, on the
 * operator's Omni transport (`veo-useapi` omni-flash).
 *
 * Shape mirrors the repo's other resumable drivers (`execute-render-scenes.ts`,
 * `studio/execute.ts`): a PURE scheduler (`runMographExecute`) plus an injectable
 * per-block runner (`MographBlockRunner`), so the whole scheduler is
 * offline-testable with a simulated runner. The REAL runner (in
 * `src/cli/handlers/mograph.ts`) does NOT re-implement submit/poll/download — it
 * shells to the existing `vclaw video` produce chain per block (synthesize a
 * one-scene storyboard from the assembled prompt, no image asset → prose-only on
 * Omni, produce, map `outputs/scene-0.mp4` to the block's output), reusing the
 * proven transport. One produce per block keeps the driver dead-simple and
 * resumable at block granularity.
 *
 * Credit safety: the CLI handler is spend-gated (`requireSpendConfirmation`);
 * this scheduler is pure control flow and spends nothing itself.
 */
import type { MographPriority, MographSubmission } from './types.js';
/** Outcome of rendering one block through the injected runner. */
export interface MographBlockRunResult {
    status: 'done' | 'failed';
    /** Absolute path to the rendered clip (set on 'done'). */
    outputPath?: string;
    /** Absolute path to the written sidecar contract (prompt+refs+route). */
    sidecarPath?: string;
    /** Failure reason when status is 'failed'. */
    error?: string;
}
/**
 * Injectable per-block runner: render ONE mograph submission and resolve its
 * outcome. The real runner shells to the produce chain; tests inject a stub.
 * A throw is treated as a per-block failure (never a run abort).
 */
export type MographBlockRunner = (submission: MographSubmission) => Promise<MographBlockRunResult>;
export interface MographExecuteBlockResult {
    blockId: string;
    priority: MographPriority;
    status: 'done' | 'failed' | 'skipped';
    outputPath?: string;
    sidecarPath?: string;
    error?: string;
}
export interface MographExecuteReport {
    schemaVersion: 1;
    /** Blocks that rendered this run. */
    ranCount: number;
    /** Blocks skipped because an output already existed (resume). */
    skippedCount: number;
    /** The first block that failed, if any (fail-fast stops the run there). */
    stoppedAt?: string;
    results: MographExecuteBlockResult[];
}
export interface MographExecuteOptions {
    /** Planned submissions in narrative order (already ref-free for Omni). */
    submissions: MographSubmission[];
    /** Injectable per-block runner (submit + poll + map + sidecar for one block). */
    runner: MographBlockRunner;
    /**
     * Resume hook: when it returns true for a block id, that block is recorded
     * 'skipped' and never handed to the runner (its clip already exists).
     */
    isAlreadyRendered?: (blockId: string) => boolean;
    /** Optional progress sink (one message per block). */
    onProgress?: (msg: string) => void;
}
/**
 * Render the planned submissions in order, one block at a time.
 *
 * - A block for which `isAlreadyRendered(id)` is true is recorded 'skipped'
 *   (resume) and never handed to the runner.
 * - Otherwise the runner renders it; a 'done' result records the output +
 *   sidecar paths; a 'failed' result (or a throw) is FAIL-FAST: it is recorded,
 *   `stoppedAt` is set, and the run stops — no further blocks are rendered (so a
 *   provider outage or a bad prompt doesn't burn the whole scope before you see
 *   it). Re-running resumes from the failed block once fixed.
 *
 * PURE: no fs / provider / timer access beyond awaiting the injected runner.
 */
export declare function runMographExecute(opts: MographExecuteOptions): Promise<MographExecuteReport>;
//# sourceMappingURL=execute.d.ts.map