@jokerized/decksmith 0.1.0

package/dist/types/plan/select.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Which beats survive a budget, and why each one that did not was cut.
+ *
+ * A format profile caps a length (src/types.ts, `DESTINATIONS`). When the
+ * narrated cut runs over, something has to go, and until now the only tool was
+ * `--min-weight`: a flat threshold on the author's salience number. A threshold
+ * is the wrong instrument, for three separate reasons, each of which the demo
+ * exhibits at 9:16.
+ *
+ * 1. IT IGNORES LENGTH. Weight says how much a beat matters; it says nothing
+ *    about what it costs. At `--min-weight 0.85` the demo drops b08 (14.3s,
+ *    weight 0.80) while keeping b02 (39.1s, weight 0.95) whole. Two 14-second
+ *    beats at 0.80 are worth more than one 39-second beat at 0.95 to anybody
+ *    who is trying to fit three minutes, and a threshold cannot express that.
+ * 2. IT IGNORES WHAT KIND OF BEAT IT IS. A deck is an argument. Weight is a
+ *    per-beat number and has no view on the SHAPE of what is left, so a
+ *    threshold will happily cut every chart and keep every claim — the exact
+ *    failure mode of dropping the evidence and keeping the assertions.
+ * 3. IT IGNORES THE ENDS. `--min-weight 0.85` drops b12, the caveat the deck
+ *    closes on, because the author scored the caveat lowest. A cut is a cut of
+ *    the MIDDLE: an explanation that stops in the middle of its evidence has no
+ *    ending, whatever the weights say.
+ *
+ * WHAT "BETTER" MEANS HERE, in priority order. A cut is better than another when
+ * it is coherent (this function never breaks an `inside` pair the author's own
+ * floor left intact), then when it keeps the
+ * ends and one beat of every archetype family the full deck used, then when it
+ * fits, and only then when it carries more author weight. Weight is the last
+ * tiebreak, not the objective — that inversion is the whole change.
+ *
+ * WHY NOT A PURE KNAPSACK ON WEIGHT. Because it is not neutral either: value
+ * per second systematically deletes the LONGEST beats, and a beat is long
+ * because its narration needed the words. Run unprotected on the demo it drops
+ * b02 (the method) and b03 (the comparison figure) — the two most-explained
+ * beats in the deck — for a higher weight total than the cut here. The
+ * protections below exist to say what the knapsack cannot see.
+ *
+ * SHORTENING WOULD BE BETTER THAN DROPPING, and it is not available here. A
+ * beat's length is measured speech (src/narrate), so the only way to shorten one
+ * is to write a shorter sentence, which is a planner decision made before any
+ * audio exists — `plan` would have to take a seconds budget and target
+ * words-per-beat, and the deck would keep all twelve beats at 15s each rather
+ * than nine at 20s. That is the better product and a different workstream; this
+ * function is what you need once the audio is already recorded, and what `verify`
+ * needs to explain an overrun it can only measure after the fact.
+ *
+ * PURE. No I/O, no clock, no randomness; integer arithmetic inside the optimiser
+ * so the same storyboard and budget always produce byte-identical output.
+ */
+import { type Beat, type Ref, type Storyboard } from "../types.js";
+/** What a caller must know about the target to make a cut. `Format` satisfies it. */
+export interface SelectionBudget {
+    /** The author's floor. Beats below it never enter, as `--min-weight` does today. */
+    minWeight: number;
+    /** The hard ceiling in seconds. Absent or `Infinity` means nothing is cut. */
+    maxSeconds?: number;
+    /** Named in explanations, so a cut says which profile asked for it. */
+    id?: string;
+}
+/**
+ * Why a beat is not in the cut. Machine-readable; `reason` is the prose.
+ *
+ * There is deliberately no `orphaned`. A beat whose `inside` container was cut
+ * is KEPT and reported through `Cut.dangling` — see `dangling` for why deleting
+ * it was both unnecessary and destructive.
+ */
+export type DropRule = "below_min_weight" | "over_budget";
+export interface Dropped {
+    beat: Beat;
+    /** The length this beat would have contributed. */
+    seconds: number;
+    rule: DropRule;
+    /** One sentence naming the cause, with the numbers behind it. */
+    reason: string;
+}
+/**
+ * A kept beat that cites something no kept beat shows.
+ *
+ * Not a drop — the beat still stands on its own drawing — but the reference in
+ * it has gone dangling, and that is exactly the "as the comparison figure
+ * showed" failure the caller has to be able to see. The demo has a live one:
+ * b08 bar-compare cites `tbl-bench`, which only b09 data-table displays.
+ *
+ * `{ kind: "beat" }` is the same failure one level up: the beat happens INSIDE a
+ * beat this cut does not keep, so it opens on a hard cut where the author wrote
+ * a dive. See `dangling` for why that is a note and not a removal.
+ */
+export interface Dangling {
+    beat: Beat;
+    ref: Ref | {
+        kind: "beat";
+        id: string;
+    };
+    reason: string;
+}
+export interface Cut {
+    /** In storyboard order. */
+    kept: Beat[];
+    /** In storyboard order. */
+    dropped: Dropped[];
+    /** Sum of the kept beats' seconds, rounded to 3dp like every other time here. */
+    seconds: number;
+    /** References inside `kept` whose subject is not in `kept`. */
+    dangling: Dangling[];
+    /** False when even the protected core does not fit — nothing here can save it. */
+    fits: boolean;
+}
+/**
+ * The cut for one budget.
+ *
+ * `seconds` maps a beat id to its NARRATED length — what `beatSeconds` in
+ * src/emit/composition.ts produces, or what a built composition's scene windows
+ * report. Beats absent from the map fall back to their authored `beat.seconds`,
+ * which is what an un-narrated storyboard has and all it has.
+ */
+export declare function selectBeats(storyboard: Storyboard, budget: SelectionBudget, seconds?: Readonly<Record<string, number>>): Cut;

package/dist/types/prefs.d.ts

@@ -0,0 +1,43 @@
+import type { z } from "zod";
+import { prefsSchema } from "./types.js";
+export type Prefs = z.infer<typeof prefsSchema>;
+/**
+ * A partial Prefs. `narration` is the one nested object, so it is the one place
+ * a patch merges rather than replaces: `--voice` must not wipe a `rate` the
+ * config file set.
+ */
+export type PrefsPatch = Partial<Omit<Prefs, "narration">> & {
+    narration?: Partial<Prefs["narration"]>;
+};
+export declare const CONFIG_FILE = "decksmith.config.json";
+/**
+ * Resolve the preferences that govern one run.
+ *
+ * `cwd` is where the search for a config file starts; the search stops at the
+ * filesystem root. Returns a fully-populated Prefs — every consumer downstream
+ * reads fields, never optionals.
+ */
+export declare function loadPrefs(overrides?: PrefsPatch, cwd?: string): Promise<Prefs>;
+/**
+ * Turn CLI flags into a patch. Values arrive as strings from commander and are
+ * not validated here beyond the numbers: `loadPrefs` runs them through the
+ * schema, so there is exactly one place that decides what a legal tone is.
+ */
+export declare function prefsFromFlags(flags: PrefFlags): PrefsPatch;
+/** The flag surface the CLI exposes. Every one optional: absent means unstated. */
+export interface PrefFlags {
+    slides?: string | number;
+    lang?: string;
+    tone?: string;
+    density?: string;
+    duration?: string | number;
+    theme?: string;
+    speed?: string | number;
+    narrate?: boolean;
+    voice?: string;
+    rate?: string;
+    pitch?: string;
+    subtitles?: boolean;
+    /** `--narration-density`. Spelled apart from `density`, which is a slide's. */
+    narrationDensity?: string;
+}

package/dist/types/render/captions.d.ts

@@ -0,0 +1,108 @@
+import type { Cue } from "../deck/subtitles.js";
+import type { BurnStyle } from "./ffmpeg.js";
+/** Where `build` puts the subset woff2 and its `@font-face` rules. */
+export declare const DECK_FONT_CSS = "assets/fonts/fonts.css";
+/**
+ * One PNG per cue, and the single rectangle all of them occupy.
+ *
+ * ONE rectangle, not one per cue, and that is the point: a one-line cue and a
+ * two-line cue are clipped to the same box, so the filtergraph carries a
+ * constant `x:y` instead of per-cue geometry. Geometry that appears once cannot
+ * disagree with itself, and the transparent rows a short cue leaves behind cost
+ * nothing — PNG runs them out to a few bytes.
+ */
+export interface CaptionBand {
+    /** Basenames inside the work directory, in cue order. */
+    files: string[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The caption page: every cue laid out at the same place, all hidden.
+ *
+ * All of them in one document rather than one document per cue, because a
+ * navigation costs about as much as the screenshot does and there are dozens of
+ * cues. Hidden by default and revealed one at a time, so what is measured is
+ * exactly what is captured.
+ *
+ * The scrim is `box-decoration-break: clone`, which gives each LINE its own box
+ * — the same treatment ASS's `BorderStyle=4` produces, and the only one that
+ * reads as a caption rather than as a letterbox: a single box around a block
+ * whose second line is two words wide is a wide black bar with a short line
+ * floating in it.
+ *
+ * `line-height` is set from a measurement, not from a ratio. The inline box is
+ * as tall as the font's content area plus the padding, and that is a number only
+ * the font knows; guessing it either overlaps the two boxes — and two 70%
+ * scrims stacked composite to a visible dark seam across the middle of the band
+ * — or opens a gap the slide shows through. `--line` is written by `measure()`
+ * below once the font has actually loaded.
+ *
+ * THE BREAK IS OURS TO MAKE, and forgetting that cost a render. `splitCue` caps
+ * a cue at two lines' worth of characters, but `plan.cues` carries the text
+ * UNWRAPPED — `toSrt` calls `wrap` on its way out to the sidecar, so the hard
+ * `\n` exists only in the .srt. Handing the raw text to CSS let it soft-wrap at
+ * the container instead, and the first burned frame came out as a 49-character
+ * line over the orphan "up against": the same one-word-flash failure `splitCue`
+ * was fixed for, reappearing three modules downstream. So `wrap` is called here,
+ * the same function on the same text, and the burned band and the .srt break in
+ * the same places by construction rather than by coincidence.
+ *
+ * `white-space: pre-wrap` then honours those breaks, and still soft-wraps if a
+ * line somehow overruns rather than letting it run off the frame.
+ */
+export declare function captionPage(cues: readonly Cue[], style: BurnStyle, fontHref: string | null): string;
+/**
+ * Why captions cannot be drawn here, or null if they can.
+ *
+ * Asked BEFORE the capture, because discovering it afterwards is discovering it
+ * an hour late — the same reason the libass probe this replaced was asked early.
+ */
+export declare function captionBlocker(): Promise<string | null>;
+/**
+ * Write one transparent PNG per cue and report the box they share.
+ *
+ * `omitBackground` is what makes the PNG transparent outside the scrim;
+ * `deviceScaleFactor: 1` keeps a pixel a pixel on a retina host, without which
+ * every band comes back at twice the size and lands half off the frame.
+ */
+export declare function renderCaptions(cues: readonly Cue[], style: BurnStyle, deck: string, work: string): Promise<CaptionBand>;
+/**
+ * The rectangle every band fits in, snapped outwards to whole pixels.
+ *
+ * Snapped because a fractional clip makes Chrome resample, and a resampled
+ * caption is a soft caption. Every band shares a bottom edge — they are all
+ * bottom-anchored — so the union only ever grows upwards and sideways.
+ */
+export declare function union(rects: readonly {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Chain one `overlay` per cue onto `input`, each gated to its own time range.
+ *
+ * HALF-OPEN, `gte * lt` rather than `between`: `between` closes both ends, and
+ * `splitCue` hands over at an exact shared instant, so every sentence boundary
+ * in the deck would put two captions on screen for one frame. This is the same
+ * `[start, end)` rule `activeCue` applies in the presented deck.
+ *
+ * A disabled `overlay` passes its frame through untouched, so the cost of the
+ * chain is one pointer copy per cue per frame, not one blend.
+ *
+ * `format=yuv444` keeps the alpha at full resolution through the blend. At the
+ * default `yuv420` the scrim's edges are composited from half-resolution alpha,
+ * which frays a 40px glyph's outline by a pixel — free to avoid, since the
+ * encode subsamples afterwards either way.
+ */
+export declare function overlayGraph(cues: readonly Cue[], band: CaptionBand, input?: string, output?: string): string;
+/** `-i` for every band PNG, in the order `overlayGraph` expects them. */
+export declare function overlayInputs(band: CaptionBand): string[];

package/dist/types/render/ffmpeg.d.ts

@@ -0,0 +1,129 @@
+export interface RunOptions {
+    cwd?: string;
+    timeoutMs?: number;
+}
+/**
+ * Run a command, and on failure raise the last of its output rather than the
+ * whole log. ffmpeg says what is wrong in its final lines; the four hundred
+ * before them are the build configuration.
+ */
+export declare function runTool(file: string, args: string[], opts?: RunOptions): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Run a command with its stderr going straight to ours, live.
+ *
+ * `runTool` buffers, which is right for ffprobe and wrong for the capture: a
+ * seven-minute render that prints nothing until it ends is a render you cannot
+ * tell from a hung one, and the failure this verb is meant to survive is
+ * exactly a long job dying two thirds of the way through. Streaming means the
+ * frame counter is on screen when it stops.
+ */
+export declare function runLive(file: string, args: string[]): Promise<void>;
+export interface Probe {
+    width: number;
+    height: number;
+    /** Exact, from `r_frame_rate` — 30000/1001 must not become 29.97. */
+    fps: number;
+    frames: number;
+    seconds: number;
+    hasAudio: boolean;
+}
+/** What a rendered file actually is, as opposed to what we asked for. */
+export declare function probe(path: string): Promise<Probe>;
+/**
+ * Encoder settings, shared by every piece so the concat demuxer can copy.
+ *
+ * `-g 12` because each piece is opened at a keyframe anyway and short GOPs cost
+ * little at this bitrate; `veryfast` because the whole point of the piece
+ * pipeline is that it runs once per stop and there are dozens of them.
+ */
+export declare function encoderArgs(fps: number): string[];
+/**
+ * One piece: `motion` frames from `fromFrame`, then `freeze` clones of the last.
+ *
+ * `-ss` on the INPUT so the decoder seeks rather than decoding and discarding
+ * from zero — on a four-minute source the difference between the two is the
+ * difference between a minute and an hour. It is a keyframe seek refined to the
+ * requested time, so the first frame can land one frame either side of the one
+ * asked for; the piece's LENGTH is exact regardless, because `trim=end_frame`
+ * and `tpad=stop` count frames rather than seconds. A frame of content offset
+ * is invisible. A frame of length error would accumulate across dozens of
+ * pieces and pull every later sentence off its picture, which is the whole
+ * failure this feature exists to prevent.
+ */
+export declare function pieceFilter(motion: number, freeze: number): string;
+export declare function pieceArgs(source: string, fromFrame: number, motion: number, freeze: number, fps: number, out: string): string[];
+export interface AudioInput {
+    /** Path to the mp3, as ffmpeg will be given it. */
+    file: string;
+    delayMs: number;
+}
+/**
+ * Delay every segment onto one track and sum them.
+ *
+ * `amix` with `normalize=0` sums rather than averaging: the default divides by
+ * the input count, which on a 37-segment deck would render the narration 31 dB
+ * down and sound exactly like a bug in the TTS. The segments never overlap — the
+ * timing model gives each one the video's undivided attention — so summing is
+ * safe. `dropout_transition=0` stops amix ramping the gain as inputs end.
+ *
+ * Every input is resampled and laid out identically first, because amix refuses
+ * a mismatch and edge-tts emits 24 kHz mono while the video wants 48 kHz.
+ * `apad` runs the track out to the video's length so the mux does not have to
+ * choose between a short audio stream and `-shortest` truncating the picture.
+ */
+export declare function audioGraph(inputs: readonly AudioInput[], seconds: number, 
+/**
+ * ffmpeg input index of the first mp3. 1 when the video is the only other
+ * input; higher once the burned-in caption bands have taken 1..n, and getting
+ * this wrong points `adelay` at a PNG and mixes silence.
+ */
+first?: number): string;
+/**
+ * Speed a finished mp4 up by `factor`, pitch preserved.
+ *
+ * `setpts` compresses the video's timestamps and `atempo` time-stretches the
+ * audio without transposing it, so the voice stays the voice. This is the cheap
+ * half of duration control: MEASURED at 169.0s → 58.3s in 4.1 seconds of wall
+ * clock on experiments/010-burn-in/short.mp4, with no re-synthesis, no re-render
+ * and no rebuild. The expensive half — how much is said in the first place —
+ * happens back at plan time, because time-stretching cannot make 196 seconds of
+ * sentences into 60 seconds of listenable ones.
+ *
+ * `chain` is `tempoChain`'s, and it is the caller's because `atempo` clamps to
+ * 2.0 per instance and the decomposition is arithmetic that belongs where it can
+ * be tested with no ffmpeg — the rule this file's header states.
+ *
+ * `-fps_mode cfr` at the source's own rate is what turns compressed timestamps
+ * back into a normal file: frames are dropped to hold the frame rate, rather
+ * than the container being handed a 37.5 fps stream nothing expects.
+ */
+export declare function respeedArgs(source: string, factor: number, chain: readonly number[], fps: number, hasAudio: boolean, out: string): string[];
+export interface BurnStyle {
+    width: number;
+    height: number;
+    fontSize: number;
+    marginV: number;
+    marginX: number;
+    font: string;
+}
+/**
+ * How a burned-in caption is styled.
+ *
+ * Vertical and square are watched muted, so the caption is the format rather
+ * than an accessibility extra — it gets generous type and its own scrim.
+ *
+ * The band is drawn HERE and never in the composition. A band inside the slide
+ * collides with content the archetypes already fill their canvas with; that was
+ * measured once and fixed by moving the band out of the slide, and re-importing
+ * it as a composition element would re-import the collision.
+ */
+export declare function burnStyle(width: number, height: number, font?: string): BurnStyle;
+/**
+ * The band is drawn by ./captions.ts and composited with \`overlay\`, so nothing
+ * here converts a cue to a subtitle format. What used to live below was an ASS
+ * writer and a probe for the \`subtitles\` filter; both were deleted when the
+ * libass path turned out to be unavailable on the ffmpeg most customers have.
+ */

package/dist/types/render/render.d.ts

@@ -0,0 +1,123 @@
+export type SubtitleMode = "auto" | "burn" | "sidecar" | "none";
+/** What a mode actually does. Pure, so the default can be tested without ffmpeg. */
+export interface SubtitlePlan {
+    /** Write the .srt beside the mp4. */
+    sidecar: boolean;
+    /** Cook the caption band into the picture too. */
+    burn: boolean;
+}
+/**
+ * SIDECAR BY DEFAULT. A burned-in caption is a decision taken away from the
+ * viewer: every player on earth has a subtitle toggle and none of them can turn
+ * off a band that is part of the picture. The band sits over the bottom ninth of
+ * the frame (`burnStyle` in ./ffmpeg.ts) and the archetypes do not know it is
+ * coming, so on a diagram that fills its canvas it lands on the content — which
+ * is the frame the owner opened and the reason this default flipped.
+ *
+ * `auto` used to mean "burn if the canvas is vertical or square". It is kept as
+ * a spelling of the default rather than removed, so an existing `--subtitles
+ * auto` in someone's script keeps working — but it no longer decides anything,
+ * because the thing it was deciding was not the renderer's to decide.
+ *
+ * Burning is still right for one case and it is a real one: a Reel or a Short
+ * posted to a feed, watched muted, where the platform's own caption track is
+ * either unavailable or off by default. That is `--subtitles burn`, typed on
+ * purpose, and it costs a full libx264 re-encode — the sidecar path copies the
+ * video bitstream through untouched.
+ */
+export declare function subtitlePlan(mode: SubtitleMode): SubtitlePlan;
+/**
+ * WHAT A REAL FIX NEEDS. Making the band optional did not stop it covering the
+ * slide; it only means you can now choose not to be covered. Anyone who wants
+ * `--subtitles burn` to be safe rather than merely available has to do this, and
+ * the shape of it is not obvious, so it is written down once here.
+ *
+ * THE MEASUREMENT. At 1080x1920 the band is 862x120px and `burnStyle`'s
+ * `marginV` puts its baseline 173px off the bottom, so it occupies the bottom
+ * 293px — 15.3% of the frame. Nothing in `src/emit` knows that. Extracted from
+ * two frames of the same deck rendered both ways, the difference is confined to
+ * exactly that strip (mean |Δ|Y of 8.2 there against 0.10 over the rest, which is
+ * re-encode noise), and in the strip it lands on the title rule and the sub-line.
+ *
+ * THE CAUSE, precisely: the burn decision is taken HERE, at render time, and the
+ * layout was fixed at build time. A render-time flag cannot move content that was
+ * positioned an hour earlier. So every step below exists to move the decision
+ * earlier, not to draw the band differently.
+ *
+ *  1. ONE SOURCE FOR THE BAND'S BOX. Today its height is implied by `burnStyle`
+ *     (./ffmpeg.ts) plus the CSS in `captionPage` (./captions.ts) and is only
+ *     known after a browser has laid the text out. Export a pure
+ *     `bandReserve(width, height): number` — the bottom strip the band may
+ *     occupy, `marginV` included, for the two-line worst case `wrap` and
+ *     `splitCue` already bound. Both the renderer and the emitter must read that
+ *     one function; a second copy of 0.09 and 0.037 is how this drifts back.
+ *
+ *  2. THE FORMAT HAS TO CARRY IT. `Format` in src/types.ts gains a
+ *     `captionReserve: number`, defaulting to 0 and set by `build` when the
+ *     caller says the render will burn — `build --subtitles burn`, or a
+ *     `--reserve-captions` flag. It belongs on `Format` and not on `DeckOptions`
+ *     because it changes the drawable box, which is what a format IS.
+ *
+ *  3. THE DRAWABLE BOX SHRINKS, IN ONE PLACE. `contentH` in src/emit/kit.ts
+ *     becomes `height - 2·padY - captionReserve`. That is the whole geometric
+ *     change: every archetype was audited for this and none of the twelve reads
+ *     `format.height` directly — only `title.ts`, and only to ask which way up
+ *     the canvas is. They all lay out into `contentH`, so subtracting there moves
+ *     all of them at once. Note it must NOT go into `padY`: the padding is
+ *     symmetric and the reserve is not, and a symmetric version would throw away
+ *     as much off the top for nothing.
+ *
+ *  4. A GATE, OR THIS REGRESSES. `src/verify/check.ts` must fail a deck whose
+ *     audience text falls inside the reserve — invariant 5 with a new floor. A
+ *     purely geometric fix with no gate is one refactor away from being undone,
+ *     and this failure is invisible to every gate that exists: the deck passes,
+ *     the video renders, and only a person opening a frame ever finds out.
+ *
+ *  5. THE RENDERER REFUSES WHAT IT CANNOT HONOUR. `Timing` (./timing.ts) records
+ *     the `captionReserve` the deck was built with, and `render --subtitles burn`
+ *     errors when it is 0 — the same way `assertCapture` refuses a video that
+ *     does not match its manifest. Otherwise the flag silently reintroduces the
+ *     collision on any deck built before the reserve existed.
+ *
+ * NOT WORTH DOING: drawing the band inside the composition instead. That was
+ * tried and reverted (see `burnStyle`), and it makes the collision unconditional
+ * rather than opt-in, which is the wrong direction from where this now stands.
+ */
+export interface RenderOptions {
+    /** A built deck directory — the one `build -o` wrote. */
+    deck: string;
+    /** Where the mp4 goes. */
+    out: string;
+    /** Skip capture and retime this file instead. */
+    video?: string;
+    workers?: string;
+    quality?: string;
+    fps?: number;
+    /** CDP protocol timeout in ms, handed to hyperframes. */
+    protocolTimeoutMs?: number;
+    subtitles?: SubtitleMode;
+    /**
+     * Speed the finished video up to land near this many seconds.
+     *
+     * Only ever a SPEED-UP, and only ever the last thing that happens: the deck's
+     * length is decided at plan time by how much it says, and this closes whatever
+     * gap survived that. A video already inside the target is left alone rather
+     * than padded — dead air is worse than eight seconds short.
+     */
+    targetSeconds?: number;
+    /** Leave the per-piece intermediates on disk. */
+    keep?: boolean;
+    /** Progress, one line at a time. */
+    log?: (message: string) => void;
+}
+export interface RenderResult {
+    out: string;
+    srt?: string;
+    seconds: number;
+    frames: number;
+    segments: number;
+    burned: boolean;
+    /** What `targetSeconds` cost, if anything. 1 means the file was not respeeded. */
+    playback: number;
+}
+export declare function render(opts: RenderOptions): Promise<RenderResult>;