allyhub 0.6.0 → 0.7.0

package/dist/node_modules/@allyhub-next/render/dist/composite.d.ts

@@ -1,106 +0,0 @@
-import { type CaptureOptions, type Part, type Timeline } from "@allyhub-next/video-core";
-import { type PlaneSource } from "./footage.js";
-import type { ProjectMedia } from "./page.js";
-/** A fully transparent PNG of w × h: the graphics plane where no graphic layer shows. */
-export declare function transparentPng(width: number, height: number): Buffer;
-/** The part showing at film time t. */
-export declare function partAt(timeline: Timeline, t: number): Part | undefined;
-/** The local files of a timeline's footage, probed (alpha, decoder, matrix). */
-export declare function planSources(project: ProjectMedia, timeline: Timeline, ffprobe?: string): Promise<Map<string, PlaneSource>>;
-export interface CompositeOptions {
-    timeline: Timeline;
-    /** The window: film frames [first, first + frames). */
-    first: number;
-    frames: number;
-    sources: ReadonlyMap<string, PlaneSource>;
-    /** Keep the alpha of a transparent video. */
-    alpha: boolean;
-    /**
-     * The graphics planes of the window's part that show in it, back to
-     * front (their numbers in Part.planes), piped in on stdin as PNG: each
-     * output frame's `samples` images of the first, then of the next. They
-     * are stacked with the footage (footage.ts). Empty: nothing shows in
-     * this window.
-     */
-    planes: readonly number[];
-    /**
-     * Of `planes`, those laid over the finished picture (z "overlay"): one
-     * image a frame each, no motion blur, after the camera's marks, post and
-     * the LUT.
-     */
-    overlays?: readonly number[];
-    /** Motion blur's samples per frame (1: none) and their shutter. */
-    samples: number;
-    /** What the camera filming it does to the picture, before post. */
-    capture?: CaptureOptions;
-    /** The output's post filter and LUT file, if any. */
-    post?: string;
-    lut?: string;
-    /** The part this window is of: its own post (part({ post })) runs on its picture first. */
-    part?: Part;
-    /** Filters after everything (the encoder's colour chain). */
-    tail: string[];
-}
-/** A part's own post chain, if it has one. */
-export declare const partPost: (part: Part | undefined) => string | undefined;
-/** A LUT path inside a filtergraph's single quotes (which nothing escapes). */
-export declare function filterPath(path: string): string | undefined;
-/**
- * The end of a composite's graph, from the picture's label `base` to [v]:
- * the camera's marks, then post (postGraph's contract), the LUT, the
- * planes laid over the finished picture (`over`, back to front) and the
- * tail. `first` is the film frame of the stream's first frame.
- */
-export declare function finishGraph(filters: string[], base: string, o: {
-    timeline: Timeline;
-    first: number;
-    frames: number;
-    alpha: boolean;
-    capture?: CaptureOptions;
-    post?: string;
-    lut?: string;
-    tail: readonly string[];
-}, over?: readonly string[]): void;
-/** How many images of a plane each output frame pipes: one for an overlay, else the blur's samples. */
-export declare const imagesOf: (plane: number, samples: number, overlays: readonly number[] | undefined) => number;
-/**
- * The inputs and the filter graph of one composite: ffmpeg arguments up
- * to the output options, with the result mapped as [v].
- */
-export declare function compositeArgs(o: CompositeOptions): string[];
-/** The film frame a moment falls in, inside the timeline. */
-export declare function frameAt(timeline: Timeline, t: number): number;
-/** How a still is encoded: a PNG (every pixel), a JPEG, or a WebP to look at. */
-export type StillFormat = "png" | "jpeg" | "webp";
-/**
- * ffmpeg's output for one still in `format`, written to a pipe: PNG by
- * default, JPEG at quality 2, or a WebP at quality 90 (a picture to look
- * at, encoded where it is composited).
- */
-export declare const stillOutput: (format?: StillFormat) => string[];
-/**
- * One frame composited to a PNG (or JPEG): the footage at film frame
- * `frame` (or only the background, without one) stacked with the graphics
- * given (none: nothing drawn), then post and LUT.
- */
-export declare function compositeStill(o: {
-    timeline: Timeline;
-    sources: ReadonlyMap<string, PlaneSource>;
-    frame?: number;
-    /** The planes' images: every sample of the first of `planes`, then of the next. */
-    graphics: Buffer[];
-    /**
-     * The part's graphics planes the images are of, back to front (their
-     * numbers in Part.planes); absent: one plane, over all the footage.
-     */
-    planes?: readonly number[];
-    /** Of `planes`, those laid over the finished picture: one image each. */
-    overlays?: readonly number[];
-    alpha: boolean;
-    capture?: CaptureOptions;
-    post?: string;
-    lut?: string;
-    format?: StillFormat;
-    ffmpeg: string;
-}): Promise<Buffer>;
-//# sourceMappingURL=composite.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/delivery.d.ts

@@ -1,18 +0,0 @@
-import { type Tools } from "./tools.js";
-/** How long the stretch encoded before a moment is, seconds (an encoder's references reach back about this far). */
-export declare const DELIVERY_LEAD = 1;
-/** An encode a platform serves a video with. */
-export interface DeliveryEncode {
-    codec: "h264" | "hevc";
-    /** The picture's bitrate, kilobits a second. */
-    kbps: number;
-}
-/** What `--encode` takes: a codec and a bitrate in kbps, "hevc:618". */
-export declare function parseEncode(text: string): DeliveryEncode | undefined;
-/**
- * The last of `frames` (PNGs of one size, in order, at `fps`) as it comes
- * out of `encode`: all of them encoded as one stretch, then the last one
- * decoded, as a PNG.
- */
-export declare function throughEncode(frames: readonly Buffer[], fps: number, encode: DeliveryEncode, o?: Tools): Promise<Buffer>;
-//# sourceMappingURL=delivery.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/doc/fonts.d.ts

@@ -1,3 +0,0 @@
-/** The @font-face rules of a doc's faces, each file inside its rule. */
-export declare function docFontsCss(): Promise<string>;
-//# sourceMappingURL=fonts.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/doc/index.d.ts

@@ -1,3 +0,0 @@
-export { docPage, printPage, renderDoc, renderWord, type DocFile, type DocFileType, type PrintOptions, type RenderDocOptions, type RenderWordOptions, } from "./print.js";
-export { docFontsCss } from "./fonts.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/doc/print.d.ts

@@ -1,51 +0,0 @@
-import { type DocxModule, type DocxZip } from "@allyhub-next/doc/docx";
-export type DocFileType = "pdf" | "png";
-/** Which doc: its file and folder (project paths), and its title. */
-export interface DocFile {
-    /** The doc's file, `<place>/doc.mdx`. */
-    file: string;
-    /** Its folder, which its pictures are named from. */
-    dir: string;
-    /** Its place, the page's title when it has none. */
-    path: string;
-    title?: string | undefined;
-}
-/** A doc's page as HTML, with the project's pictures it shows inside it. */
-export declare function docPage(root: string, doc: DocFile): Promise<string>;
-export interface RenderWordOptions {
-    root: string;
-    doc: DocFile;
-    /** The file written. */
-    out: string;
-    docx: DocxModule;
-    zip: DocxZip;
-}
-/** Writes a doc as a Word document, its text editable. */
-export declare function renderWord(opts: RenderWordOptions): Promise<void>;
-export interface RenderDocOptions {
-    root: string;
-    doc: DocFile;
-    /** The folder the files go in. */
-    out: string;
-    /** The files' base name; default "doc". */
-    name?: string;
-    types?: readonly DocFileType[];
-}
-export interface PrintOptions {
-    /** The page, whole: its fonts and pictures inside it. */
-    html: string;
-    /** The folder the files go in. */
-    out: string;
-    /** The files' base name. */
-    name: string;
-    types: readonly DocFileType[];
-    /** Added to the page before a picture of it is taken. */
-    pictureCss?: string;
-    /** The width of the window the page is laid out in, px. */
-    width?: number;
-}
-/** Writes a page of HTML as a PDF, a picture of all of it, or both: the files' names. */
-export declare function printPage(opts: PrintOptions): Promise<string[]>;
-/** Writes a doc as a PDF (and a picture of the whole page, when asked): the files' names. */
-export declare function renderDoc(opts: RenderDocOptions): Promise<string[]>;
-//# sourceMappingURL=print.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/encode.d.ts

@@ -1,111 +0,0 @@
-import { type FileType } from "@allyhub-next/video-core";
-/** The file types renderVideo makes. */
-export type VideoType = Extract<FileType, "mp4" | "mov" | "webm" | "gif" | "png">;
-export declare const VIDEO_TYPES: readonly VideoType[];
-/** How the frames are encoded (allyhub render --codec, --crf, --chroma, --bits). */
-export interface EncodeOptions {
-    /** mp4 only: h264 (default, plays everywhere) or h265 (smaller files). */
-    codec?: "h264" | "h265";
-    /** Constant rate factor, lower is better: an mp4's is a profile's or SHARE_ENCODE's (20) unless given, else 18 (h264) or 20 (h265); 30 for webm. */
-    crf?: number;
-    /** Chroma: 420 (default) or 444 (sharp colored edges; fewer players). mp4 and webm. */
-    chroma?: "420" | "444";
-    /** Bit depth: 8 (default) or 10. mp4 and webm; ProRes is always 10-bit. */
-    bits?: 8 | 10;
-    /** The sound's bitrate in kbit/s: AAC in mp4 (default 192), Opus in webm (default 160); mov keeps PCM. */
-    audioBitrate?: number;
-    /**
-     * mp4 only: the most video bitrate, kbit/s (the buffer it is measured
-     * by holds two seconds of it); 0 for none. Unless given, a platform
-     * profile's format has its own (PlatformProfile.file.encode) and any
-     * other the share-ready cap for its size and rate (SHARE_ENCODE). A segment's frames go to two encoders, one without the cap
-     * and one holding it; the second's file is kept only when the first's
-     * overruns it (cap.ts).
-     */
-    maxBitrate?: number;
-}
-/**
- * How an mp4 is encoded when nothing chooses otherwise and its format is
- * no platform profile: ready to share on social media, where most videos
- * go. Every platform encodes what it is given again, so bits over what
- * its own encode keeps make a bigger file, not a better video; and an
- * uncapped crf 18 gave a phone camera's film grain 61 Mbit/s (110 MB for
- * 14 s at 1080 × 1920), a file too big to send. crf 20 is what the
- * platform profiles upload at, and 8000 kbit/s at 1080p 30 fps is
- * YouTube's upload recommendation for 1080p and the shorts profile's cap:
- * about 1 MB a second at most, while a plain picture stays well under it.
- * The cap is for `width` × `height` at `fps` and scales with the pixels a second of
- * another size and rate (shareKbps): 16000 at 1080p 60, 32000 at 4K 30.
- * `--param crf` and `--param max-bitrate` (0 for none) change them.
- */
-export declare const SHARE_ENCODE: {
-    /** H.264's constant rate factor. */
-    readonly crf: 20;
-    /** The most video bitrate, kbit/s, for `width` × `height` (or the same turned) at `fps`. */
-    readonly maxKbps: 8000;
-    readonly width: 1920;
-    readonly height: 1080;
-    readonly fps: 30;
-};
-/** The share-ready cap (SHARE_ENCODE) for a picture of this size and rate, kbit/s. */
-export declare function shareKbps(width: number, height: number, fps: number): number;
-/** The picture an encode is for: its pixels and frames a second. */
-export interface Picture {
-    width: number;
-    height: number;
-    fps: number;
-}
-/**
- * The encode options a render uses: the ones given, over, for an mp4,
- * its platform profile's upload defaults when the format is one (crf
- * for H.264, the most bitrate), else the share-ready defaults for the
- * picture's size and rate (SHARE_ENCODE). Other types take the given
- * alone.
- */
-export declare function encodeFor(type: VideoType, format: string, given: EncodeOptions, picture: Picture): EncodeOptions;
-/**
- * The encoder settings a file type and the encode options choose, checked.
- * `held`: the encoder holds the bitrate cap itself (a segment that
- * overran it when encoded without), with its rate control on one thread:
- * x264's and x265's is not the same from run to run on several (x264's
- * frame and slice threads, x265's frame threads and its rows in parallel
- * all read each other's progress). Measured with ffmpeg 8.1 on the same
- * frames again and again: x264 with -maxrate gave other bytes each run
- * with threads, sliced-threads, sync-lookahead=0, lookahead-threads=1,
- * rc-lookahead=0, no mbtree, deterministic=1 or a wide ratetol, and the
- * same bytes only with threads=1; x265 only with frame-threads=1 and
- * wpp=0. Without a cap both are the same on every thread.
- */
-export declare function encoderOf(type: VideoType, e: EncodeOptions, alpha: boolean, gop?: number, held?: boolean, 
-/** Held: how full the cap's buffer is at the first frame, 0–1 (the encoders' vbv-init; theirs is 0.9). */
-init?: number): {
-    args: string[];
-    rgb: boolean;
-    pixFmt: string;
-};
-/**
- * A closed GOP the length of the segment: one keyframe at its start and
- * none after, so segments join with -c copy. (x265 takes it in its own
- * parameters, see encoderOf; ProRes, gif and PNG have only keyframes.)
- */
-export declare function gopArgs(type: VideoType, codec: EncodeOptions["codec"], frames: number): string[];
-/** The label of a composite's second output: the picture for the encoder that holds the cap. */
-export declare const HELD_OUT = "vheld";
-/**
- * A composite's arguments (compositeArgs, junctionArgs: a graph whose
- * result is [v], mapped once) with the result split in two when `two`:
- * the first output maps it as before, and a second output can map
- * [vheld], the same frames.
- */
-export declare function twoOutputs(args: string[], two: boolean): string[];
-/** Most pages one export draws with when allyhub render --workers asks. */
-export declare const MAX_WORKERS = 32;
-/**
- * How many pages to draw with: HyperFrames' sizing (engine/src/services/
- * parallelCoordinator.ts) — leave two CPUs, at least 60 frames each — capped
- * at 4 for one export, since a worker may run several exports at once.
- * ALLYHUB_RENDER_WORKERS overrides; allyhub render --workers sets it per
- * export, up to MAX_WORKERS.
- */
-export declare function autoWorkers(frames: number): number;
-//# sourceMappingURL=encode.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/errors.d.ts

@@ -1,15 +0,0 @@
-import { type ExitCode } from "@allyhub-next/protocol";
-/**
- * A render that cannot be made, as the CLI reports it: a stable code in
- * kebab case, what happened, what to do about it, and the exit code.
- */
-export declare class RenderError extends Error {
-    readonly code: string;
-    readonly hint: string | undefined;
-    readonly exit: ExitCode;
-    constructor(code: string, message: string, { hint, exit }?: {
-        hint?: string;
-        exit?: ExitCode;
-    });
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/exports.d.ts

@@ -1,67 +0,0 @@
-import { type CaptionCueOptions, type Part, type Timeline } from "@allyhub-next/video-core";
-import type { ExportPage, ProjectMedia, RenderTarget, VideoLook } from "./page.js";
-import type { Tools } from "./tools.js";
-export interface ExportOptions extends Tools {
-    /** A page holding the output, drawing its graphics plane; the caller opens and closes it. */
-    page: ExportPage;
-    target: RenderTarget;
-    look: VideoLook;
-    media: ProjectMedia;
-    out: string;
-    /** A deck's pages: a PDF page, a PNG or a slide per step, not only each page's last; default false. */
-    steps?: boolean;
-}
-/** A moment an export draws: a part's (or a step's) still. */
-interface Still {
-    part: Part;
-    at: number;
-    /** Its title: the part's, numbered by step when it has several. */
-    title: string;
-}
-/**
- * The stills a deck's (or a video's handout's) pages are: every part's
- * still in order, a deck's hidden pages left out; with `steps`, each step's.
- */
-export declare function stillsOf(timeline: Timeline, steps?: boolean): Still[];
-export interface ExportResult {
-    out: string;
-    /** Pages for pdf / pptx / png, cues for subtitles, 1 for a cover. */
-    units: number;
-    bytes: number;
-    /** Every file written, when there are several (one PNG per page). */
-    files?: string[];
-}
-/** SRT or WebVTT from what each part says, timed by its words. */
-export declare function renderCaptions(opts: ExportOptions & {
-    type: "srt" | "vtt";
-    /**
-     * How cues are cut and timed, over what the piece asks; without them
-     * the piece's own captions' options (subtitleCues).
-     */
-    captions?: CaptionCueOptions;
-}): Promise<ExportResult>;
-/** The cover as JPEG: the output's first cover, else the first part's still. */
-export declare function renderCover(opts: ExportOptions): Promise<ExportResult>;
-/**
- * One PDF page per part (a video's handout) or slide (a deck), each
- * at its still; the text stays text. The page is the output's paper: the
- * frame's pixels, or A4 and Letter at their real size with the frame
- * scaled onto it. A page without headings of its own starts with an
- * invisible heading, its title, so the PDF's outline lists every page
- * (tagged PDF, outline on).
- */
-export declare function renderPdf(opts: ExportOptions): Promise<ExportResult>;
-/**
- * Each page's still as PNG. One page: the file asked for; more: one file
- * per page next to it, numbered from 1 (`<name>.01.png`, `<name>.02.png`…),
- * so they sort in order.
- */
-export declare function renderPng(opts: ExportOptions): Promise<ExportResult>;
-/**
- * One slide per part or page (per step with `steps`), each the still as a
- * full-bleed picture; the speaker notes are a page's notes, else what a
- * part says, else the text it shows.
- */
-export declare function renderPptx(opts: ExportOptions): Promise<ExportResult>;
-export {};
-//# sourceMappingURL=exports.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/ffmpeg.d.ts

@@ -1,75 +0,0 @@
-import { type Tools } from "./tools.js";
-/** The version in what `ffmpeg -version` prints ("ffmpeg version 8.1 …" → "8.1"). */
-export declare function versionIn(printed: string): string;
-/** The ffmpeg version line ("ffmpeg version 8.1 …" → "8.1"). */
-export declare function ffmpegVersion(ffmpeg: string): Promise<string>;
-/**
- * The ffmpeg release AllyHub is made and tested with: the one the runtime
- * manager pins (its manifest's ffmpeg) and the frame regression's
- * baselines are composited with.
- */
-export declare const FFMPEG_PINNED = "9.0.2";
-/**
- * The oldest ffmpeg release AllyHub runs with: the first with every filter
- * and option it writes. The mix measures its master with ebur128's
- * framelog=quiet, which came in 6.0: 5.1 (Debian 12's) refuses it, once
- * every frame is drawn. The rest is in 6.0: every ffmpeg and ffprobe call
- * of renders of every kind, the check, allyhub audio, frames, still,
- * reference and sync, recorded under 9.0.2 and run again on the same
- * inputs under 6.0.1 (and 6.1, 7.1, 8.0), exited as it did, with the same
- * loudness and frame counts and pictures as close to 9.0.2's as its own
- * Linux build's. Under 5.1 the master's measurement failed, and joining
- * the segments put a few frames at other times.
- */
-export declare const FFMPEG_MINIMUM = "6.0";
-/** A release's numbers: major, minor, patch. */
-export type FfmpegRelease = readonly [number, number, number];
-/**
- * The release of a version as ffmpeg prints it ("7.1.1-1+b1",
- * "9.0.2-https://www.martin-riedl.de", "n6.1" → [7, 1, 1], [9, 0, 2],
- * [6, 1, 0]); undefined for a build of no release, such as a git snapshot
- * ("N-122320-g38e89fe502").
- */
-export declare function ffmpegRelease(version: string): FfmpegRelease | undefined;
-/** Negative when a is older than b, 0 when they are the same release. */
-export declare function compareReleases(a: FfmpegRelease, b: FfmpegRelease): number;
-/** What an ffmpeg is, against what AllyHub needs and is made with. */
-export interface FfmpegFound {
-    /** The program, as it is run. */
-    path: string;
-    /** Its version as it prints it ("7.1.1-1+b1"). */
-    version: string;
-    /** Its release; undefined for a build of no release (a git snapshot). */
-    release?: FfmpegRelease;
-    /** Older than FFMPEG_MINIMUM: AllyHub refuses it. */
-    old: boolean;
-    /** The pinned release, FFMPEG_PINNED. */
-    pinned: boolean;
-}
-/** An ffmpeg's version, judged (allyhub doctor, requireFfmpeg). */
-export declare function judgeFfmpeg(path: string, version: string): FfmpegFound;
-/**
- * How to get an ffmpeg AllyHub runs with (`old`: this one is older than
- * FFMPEG_MINIMUM), or the release it is made with.
- */
-export declare function ffmpegHint(old: boolean): string;
-/** The ffmpeg that runs here and its version; undefined when it does not run. */
-export declare function findFfmpeg(ffmpeg: string): Promise<FfmpegFound | undefined>;
-/**
- * The ffmpeg a render runs (the one named, else the runtime manager's
- * pinned build), checked: fails early, with how to fix it, when it is
- * missing or older than FFMPEG_MINIMUM, better than after the browser drew
- * a thousand frames. Says once, on stderr, when it is not FFMPEG_PINNED:
- * its frames may differ from the baselines and from another computer's.
- */
-export declare function requireFfmpeg(o?: Tools): Promise<string>;
-/** The ffmpeg encoder each video file type needs (allyhub doctor lists them). */
-export declare const ENCODERS: Record<string, string>;
-/** The encoders this ffmpeg has, of the ones ENCODERS names. */
-export declare function ffmpegEncoders(ffmpeg: string): Promise<Set<string>>;
-/**
- * Fails early when this ffmpeg lacks the encoder a file type needs (ProRes,
- * VP9 and H.265 are not in every build), with what to do.
- */
-export declare function requireEncoder(type: string, codec?: string, o?: Tools): Promise<void>;
-//# sourceMappingURL=ffmpeg.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/footage.d.ts

@@ -1,169 +0,0 @@
-import { type PixelRect, type Timeline, type TimelineFootage } from "@allyhub-next/video-core";
-/** What the footage plane needs to know about a source file. */
-export interface SourceInfo {
-    /** The picture has an alpha channel. */
-    alpha: boolean;
-    /** The decoder that keeps it. */
-    decoder?: string;
-}
-/** A source of the plane: the local file, its probe and its length. */
-export interface PlaneSource {
-    path: string;
-    info: SourceInfo;
-    /** Seconds, when known. */
-    duration?: number;
-    /** Its displayed pixels, when known (a matte is scaled to them). */
-    width?: number;
-    height?: number;
-    /** Its person matte (the media index's matte.mp4), when there is one. */
-    matte?: string;
-    /** The matte's pixels (matte.json), when known. */
-    matteSize?: {
-        width: number;
-        height: number;
-    };
-}
-/**
- * An overlay that shows only while `when` holds (an expression of `t`).
- *
- * Not the filter's `enable`: ffmpeg 6 evaluates a timeline on a filter
- * with two inputs a frame later than ffmpeg 7 and 8 do, so a layer came
- * and went a frame early there (and a still, one frame long, lost its
- * footage). The overlay's own position expression reads the frame's own
- * time in every version; while `when` is false the picture sits past the
- * right edge.
- */
-export declare function shownOverlay(x: number | string, y: number | string, when: string): string;
-/** Whether a video has alpha, and the decoder that keeps it. Cached per file version. */
-export declare function probeSource(file: string, ffprobe?: string): Promise<SourceInfo>;
-/** A seconds value for an ffmpeg argument or expression. */
-export declare const sec: (x: number) => string;
-/** A CSS-like "#rrggbb" or "#rrggbbaa" (or "transparent") as an ffmpeg color. */
-export declare function ffmpegColor(css: string, alpha: boolean): string;
-export interface PlaneOptions {
-    timeline: Timeline;
-    /** The window: film frames [first, first + frames). */
-    first: number;
-    frames: number;
-    /**
-     * Repo path → the local file and its probe, for every footage file (and
-     * the image of a layer's `background`).
-     */
-    sources: ReadonlyMap<string, PlaneSource>;
-    /** Keep the alpha: a transparent background stays transparent. */
-    alpha: boolean;
-    /** The index the plane's first input gets on the command line. */
-    firstInput: number;
-    /**
-     * The graphics planes of the window's part, back to front
-     * (Part.planes): each one's stream in this graph (its label, a picture
-     * of the frame's size with alpha at the output rate), or undefined
-     * where nothing of it shows in the window. They are stacked with the
-     * footage, each footage layer over the planes its `over` counts; a
-     * speaker cut out with the matte goes over the plane behind them.
-     * Without it the plane is the footage alone.
-     */
-    graphics?: readonly (string | undefined)[];
-}
-export interface FootagePlane {
-    /** Input arguments: per source file, its decoder, -ss, -t and -i. */
-    inputs: string[];
-    /** filter_complex chains, the last one ending in `[${out}]`. */
-    filters: string[];
-    /**
-     * The picture's label: the footage, and the graphics planes given,
-     * stacked back to front; the frame's pixels at the output rate, gbrp
-     * (gbrap with alpha).
-     */
-    out: string;
-    /** How many inputs it adds. */
-    count: number;
-    /** The footage layers it draws. */
-    layers: TimelineFootage[];
-    /**
-     * Speakers cut out with their matte and drawn over the plane behind
-     * them: the plane each one is over.
-     */
-    cutouts: {
-        label: string;
-        over: number;
-    }[];
-}
-/**
- * Linear keys as an ffmpeg expression of `tv` (whose value is t - offset),
- * held before the first and after the last: a balanced tree of if()s, so
- * a key on every frame of a long move stays far inside the expression
- * parser's depth (a hundred levels).
- */
-export declare function linearExpr(keys: readonly {
-    t: number;
-    v: number;
-}[], tv: string, offset?: number): string;
-/**
- * A layer with a moving box, drawn by its placement at every frame: the
- * whole of what it shows (its crop) scaled once to `size`, then on each
- * frame the part of it that shows in the box (`cut`, perspective's source
- * corners in its pixels) is drawn where it shows (`to`, the destination
- * corners of a `canvas` of the frame's size or larger, with what was cut
- * at (1, 1)). Both are uniform: the picture keeps its shape. The corners
- * are ffmpeg expressions of the window's clock `tv`, made from
- * placementAt's own numbers (the player's) at every frame.
- */
-export interface KeyedGeometry {
-    size: [number, number];
-    canvas: [number, number];
-    cut: {
-        x0: string;
-        y0: string;
-        x1: string;
-        y1: string;
-    };
-    to: {
-        x0: string;
-        y0: string;
-        x1: string;
-        y1: string;
-    };
-    /** The box in the cut picture's pixels at the window's first frame, for a shape's mask. */
-    box: PixelRect;
-}
-export declare function keyedGeometry(f: TimelineFootage, o: {
-    first: number;
-    frames: number;
-    fps: number;
-    width: number;
-    height: number;
-    tv: string;
-}): KeyedGeometry;
-/** The footage layers that show in a window of film frames. */
-export declare function layersIn(timeline: Timeline, first: number, frames: number): TimelineFootage[];
-/**
- * The footage plane of a window of the film: the background canvas with
- * every footage layer showing in it, at the output rate, starting at time
- * 0 for the window's first frame.
- */
-export declare function footagePlane(o: PlaneOptions): FootagePlane;
-/**
- * The ellipse inscribed in a layer's box (its first box when keyframed),
- * relative to what shows of it (`vis`, the branch's picture): centre and
- * radii in its pixels.
- */
-export declare function insetEllipse(f: Pick<TimelineFootage, "box" | "boxes">, vis: PixelRect): {
-    cx: number;
-    cy: number;
-    rx: number;
-    ry: number;
-};
-/**
- * A layer's rounded box (its first box when keyframed), relative to what
- * shows of it (`vis`): centre, half sides and the corners' radius in its
- * pixels, the radius at most half the shorter side.
- */
-export declare function roundedBox(f: Pick<TimelineFootage, "box" | "boxes" | "radius">, vis: PixelRect): {
-    cx: number;
-    cy: number;
-    hw: number;
-    hh: number;
-    r: number;
-};
-//# sourceMappingURL=footage.d.ts.map

package/dist/node_modules/@allyhub-next/render/dist/image.d.ts

@@ -1,16 +0,0 @@
-/** An image as 8-bit RGBA. */
-export interface Img {
-    width: number;
-    height: number;
-    data: Uint8Array;
-}
-export declare const readPng: (buf: Buffer) => Img;
-export declare const writePng: (img: Img) => Buffer;
-export declare const blankImage: (width: number, height: number, rgba?: readonly [number, number, number, number]) => Img;
-/** A box of an image (x, y, width, height), cut to the image; undefined when nothing of it is inside. */
-export declare function cropImage(img: Img, box: readonly [number, number, number, number]): Img | undefined;
-/** Another image drawn into `dst` at x, y (copied, not blended). */
-export declare function pasteImage(dst: Img, src: Img, x: number, y: number): void;
-/** An image resampled to width × height (premultiplied, so transparent edges keep their colour), or by its nearest pixels. */
-export declare function resizeImage(img: Img, width: number, height: number, filter?: "smooth" | "nearest"): Img;
-//# sourceMappingURL=image.d.ts.map