@allyhub/sdk 0.1.0-alpha.7 → 0.2.0-next.0

package/node_modules/@allyhub-next/video-core/dist/fact.d.ts

@@ -0,0 +1,965 @@
+import type { ContrastOptions } from "./contrast.js";
+import type { SafeZone } from "./formats.js";
+import type { Combo } from "./matrix.js";
+import type { MediaKind } from "./media.js";
+import { type FootageScale, type FreeBand, type LayoutReport, type MeasuredText, type ReadOptions, type RowSpan, type TextContainer, type TextSize, type WordsAtOnce } from "./measure.js";
+import type { Box } from "./problem.js";
+import type { FlashOptions, FrameChange, SeamCarrier, SeamChange, SeamOptions, SeamSide } from "./seams.js";
+/** What makes a run of frames a flat run (the flat-frames fact). */
+export interface FlatFrameOptions {
+    /** A frame is flat when its luminance's standard deviation (of 255) is at most this. */
+    maxStd: number;
+    /** Runs this many frames long or longer are reported (the search probes one frame in this many). */
+    minFrames: number;
+    /** A run whose luminance is within this many levels of the picture before or after it is that picture's background, not reported. */
+    sameLuma: number;
+}
+/** How the still-picture fact looks for stretches where the picture holds. */
+export interface StillOptions {
+    /** Seconds between the frames looked at. */
+    every: number;
+    /** The width of the small copy of each frame compared, in pixels. */
+    width: number;
+    /** A pixel has changed when one of its channels differs by more than this many levels (of 255). */
+    noise: number;
+    /** A frame is still while at most this share of its pixels (0–1) has changed from the stretch's first frame. */
+    change: number;
+    /** Stretches this many seconds long or longer are reported (0: every stretch of two frames looked at or more). */
+    minSeconds: number;
+}
+/** One measurement of where the speaker is, over a part (the free-bands fact). */
+export interface FreeBandsFrom {
+    /** The footage files it was read from. */
+    files: string[];
+    /** The face followed (the layer's speaker, else the track's default), for the face track. */
+    speaker?: number;
+    /** Moments at which it was seen in the content box's columns. */
+    seen: number;
+    /** The rows it covered at any of those moments, joined. */
+    rows: RowSpan[];
+    /** The content box's bands free of it. */
+    bands: FreeBand[];
+}
+/** A measurement the free-bands fact could not make: the media index lacks it for the part's footage. */
+export interface FreeBandsMissing<M extends string> {
+    missing: M;
+    /** The part's footage files. */
+    files: string[];
+}
+/** Why a join's loudness could not be measured. */
+export type JoinLoudnessMissing = "ffmpeg" | "file" | "silent" | "failed";
+/** How a version uses a generated file. */
+export interface GeneratedUse {
+    /** The part that uses it; absent for the output's music, or a read outside any part. */
+    part?: string;
+    /**
+     * `footage`: a footage layer shows it; `speech`: the part says it;
+     * `music`: the output's music; `sound`: a sound effect the part places;
+     * `read`: the part's layers read its media value (an image a component
+     * shows), during the part at most.
+     */
+    as: "footage" | "speech" | "music" | "sound" | "read";
+    /** Film seconds it shows or plays from and until; absent on a paged output, or outside any part. */
+    start?: number;
+    end?: number;
+}
+/** A generated file a version shows or plays (it has a `.gen.json` record whose `ai` is not false). */
+export interface GeneratedFile {
+    file: string;
+    kind: MediaKind;
+    /** From its record, when the record says. */
+    tool?: string;
+    model?: string;
+    /** When it was made (ISO 8601). */
+    at?: string;
+    /** Its record's sha256 is not the file's (the gen-mismatch fact). */
+    mismatch?: true;
+    uses: GeneratedUse[];
+    /** Film seconds during which it shows or plays, overlapping uses counted once; absent on a paged output. */
+    seconds?: number;
+}
+/** What each kind of fact measures. */
+export interface FactData {
+    /** Two text blocks of different layers drawn over each other. */
+    "text-overlap": {
+        a: MeasuredText;
+        b: MeasuredText;
+        /** Pixels both cover. */
+        area: number;
+        /** That area as a share of the smaller box (0–1). */
+        share: number;
+    };
+    /**
+     * Two text blocks of the same layer drawn over each other, compared by
+     * what shows of their glyphs (each block's `ink`, else its `box`). A
+     * layer that fades one line into another at the same place has one while
+     * both show: each block's `opacity` says how much.
+     */
+    "text-overlap-own": {
+        a: MeasuredText;
+        b: MeasuredText;
+        /** Pixels both cover. */
+        area: number;
+        /** That area as a share of the smaller box (0–1). */
+        share: number;
+    };
+    /**
+     * A text block reaching outside a box it is drawn inside: an element
+     * between the block and its layer that has a background, a border or a
+     * shadow (the block's own element too). The nearest such box it reaches
+     * out of; a box that clips its content, or covers the whole frame, is
+     * not one.
+     */
+    "text-outside": {
+        text: MeasuredText;
+        container: TextContainer;
+        /** Per edge of the box it crosses: pixels past the edge. */
+        edges: {
+            side: "top" | "bottom" | "left" | "right";
+            px: number;
+        }[];
+    };
+    /**
+     * How long a text block can be read: the seconds its text shows whole
+     * (every node at `options.opacity` or more, `options.shown` or more of
+     * its glyphs showing), against its words and characters. Its text is the one the block shows longest: what
+     * a line that comes in word by word, or a number that counts up, settles
+     * on. One per block of each part of a video, looked at every
+     * `options.every` seconds.
+     */
+    "text-time": {
+        text: MeasuredText;
+        words: number;
+        chars: number;
+        /** Seconds the text shows whole. */
+        seconds: number;
+        /** When, in film seconds: [from, until]. */
+        spans: [from: number, until: number][];
+        /** Seconds the text is on screen at all (over 5 % opacity). */
+        onScreen: number;
+        /** Its font size, the smallest it is drawn at while whole: in the frame's pixels, and in points on the phone of `options.phone`, with its lowercase x's height the same way (`lowercase`, for text with lowercase Latin letters). Missing when it was not measured. */
+        size?: TextSize;
+        options: ReadOptions;
+    };
+    /**
+     * How many words are whole on screen at once in a part: the most (with
+     * the first stretch that has them), and every change of the count over
+     * the part. Counted from the text-time spans, so `options` says what
+     * whole means. One per part of a video with a text that is ever whole.
+     */
+    "words-on-screen": Omit<WordsAtOnce, "part"> & {
+        options: ReadOptions;
+    };
+    /**
+     * A text block over the speaker: the face track's box and/or the person
+     * matte (the share of the text's box where the matte is opaque).
+     */
+    "text-speaker": {
+        text: MeasuredText;
+        face?: {
+            box: Box;
+            /** Pixels the text's box and the face's both cover. */
+            area: number;
+            /** Shares of the text's box and of the face's box (0–1). */
+            ofText: number;
+            ofFace: number;
+        };
+        person?: {
+            /** Share of the text's box over the person matte (0–1). */
+            ofText: number;
+            /** The footage file whose matte it is. */
+            file: string;
+        };
+    };
+    /**
+     * A text block the frame's edges cut: what shows of its glyphs (each
+     * line's glyph rows and its letters' columns, after the boxes it is drawn
+     * inside clip it; the frame's own edges do not) reaching past the frame,
+     * whatever its layout box says: a transform, a line wider than its box
+     * or a glyph taller than its line counts.
+     */
+    "text-off-frame": {
+        text: MeasuredText;
+        /** The frame: the format's pixels. */
+        frame: [width: number, height: number];
+        /** Per edge of the frame it crosses: pixels past the edge. */
+        edges: {
+            side: "top" | "bottom" | "left" | "right";
+            px: number;
+        }[];
+        /** Pixels of its glyphs outside the frame. */
+        outside: number;
+        /** That as a share of its glyphs' pixels (0–1; 1: none of them inside). */
+        share: number;
+        /** The box round its glyphs in the frame's pixels, the frame not cutting it (its ink box stops at a box that clips at the frame). */
+        glyphs: Box;
+    };
+    /**
+     * The contrast between a text block's fill and the pixels drawn behind
+     * its glyphs (every text's fill hidden, the picture captured): WCAG 2.1
+     * ratios over every pixel of each line's glyph box, the fill drawn at
+     * its alpha and opacity over the pixel against the pixel. A shadow or a
+     * stroke round the letters is part of what is behind. On the check's
+     * picture (`graphics`: the graphic layers over the look's background)
+     * footage is not drawn: what shows under the block is listed.
+     */
+    "text-contrast": {
+        text: MeasuredText;
+        /** The colours its glyphs are filled with (#rrggbb, #rrggbbaa when translucent). */
+        fill: string[];
+        /** Its font size in the frame's pixels, and its weight. */
+        size: number;
+        weight: number;
+        shadow?: true;
+        stroke?: true;
+        /** The picture measured: the check's graphics, or the final picture with footage (allyhub inspect contrast --final). */
+        picture: "graphics" | "final";
+        /** Footage whose box is under its glyphs then, which `graphics` does not draw. */
+        footage?: string[];
+        options: ContrastOptions;
+    } & ({
+        /**
+         * WCAG ratios, 1–21, against the picture behind its fill (a
+         * stroke or shadow round its letters counts there): the lowest
+         * pixel, the `options.percentile`th lowest, the median.
+         */
+        ratio: {
+            min: number;
+            low: number;
+            median: number;
+        };
+        /** Pixels measured (of the picture captured, at `options.scale`). */
+        pixels: number;
+        /** The picture behind, #rrggbb: each channel's median, and the pixel at the minimum. */
+        background: {
+            median: string;
+            atMin: string;
+        };
+        /**
+         * With a stroke or shadow round its letters: the same against the
+         * picture under them, the stroke and shadow hidden too.
+         */
+        under?: {
+            ratio: {
+                min: number;
+                low: number;
+                median: number;
+            };
+            background: {
+                median: string;
+                atMin: string;
+            };
+        };
+    } | {
+        /** Not measured: its fill is not a colour (a background clipped to the text), or none of its glyphs is inside the frame. */
+        missing: "fill" | "pixels";
+        why: string;
+    });
+    /** A text block reaching into the area a format's platform interface covers. */
+    "text-covered": {
+        text: MeasuredText;
+        /** The frame, and its covered edges in pixels. */
+        frame: [width: number, height: number];
+        covered: SafeZone;
+        /** The platform profile the format is (its name for people), when it is one. */
+        profile?: string;
+        /** Per covered edge it reaches into: pixels in from that edge's line. */
+        edges: {
+            side: "top" | "bottom" | "left" | "right";
+            px: number;
+        }[];
+    };
+    /**
+     * How much a footage layer is enlarged over its window, at its largest
+     * (the fact's `t`) and its smallest, zoom and box keys counted.
+     */
+    "footage-scale": Omit<FootageScale, "part">;
+    /**
+     * The bands of a part's content box (the frame inside the format's
+     * covered edges) that the speaker covers at none of the part's measured
+     * moments: free of the face box, of the person matte, and of both. A
+     * part with footage that has a face track or a person matte has one;
+     * what was not measured says so.
+     */
+    "free-bands": {
+        frame: [width: number, height: number];
+        /** The format's covered edges in pixels, and the content box inside them. */
+        covered: SafeZone;
+        content: {
+            x: [x0: number, x1: number];
+            y: [y0: number, y1: number];
+        };
+        /** The platform profile the format is (its name for people), when it is one. */
+        profile?: string;
+        /** The part's measured moments, film seconds. */
+        moments: number[];
+        /** The speaker's face box (the face track's), or why it was not measured. */
+        face: FreeBandsFrom | FreeBandsMissing<"face-track">;
+        /** The person matte, or why it was not measured. */
+        person: FreeBandsFrom | FreeBandsMissing<"person-matte">;
+        /** Bands free of everything measured (face and person); the whole content box when neither was. */
+        bands: FreeBand[];
+    };
+    /** A run of nearly flat frames whose colour differs from the picture around it. */
+    "flat-frames": {
+        /** Film seconds: the first frame, and the end of the last. */
+        start: number;
+        end: number;
+        frames: number;
+        /** Mean luminance of the run, 0–255, and a word for it. */
+        luma: number;
+        shade: "black" | "dark" | "grey" | "white";
+        /** The run went on past how far it was followed (two seconds). */
+        longer: boolean;
+        /** The thresholds the search used. */
+        options: FlatFrameOptions;
+        /**
+         * The run lies in a transition's window (a dip through a colour is
+         * flat on purpose): its type and the parts it joins.
+         */
+        transition?: {
+            type: string;
+            from: string;
+            to: string;
+        };
+    };
+    /**
+     * A stretch where the picture holds: from a frame looked at, every frame
+     * looked at after it (`options.every` seconds apart) differs from it in
+     * at most `options.change` of its pixels. Across parts too: a join that
+     * changes nothing on screen does not end one. What is compared is the
+     * graphics the check draws over the look's background; footage is not
+     * drawn there, so the footage that shows meanwhile is listed, not
+     * measured.
+     */
+    "still-picture": {
+        /** Film seconds: the first frame looked at and the last that still held (the picture may hold up to `options.every` longer either side). */
+        start: number;
+        end: number;
+        /** end − start. */
+        seconds: number;
+        /** Frames looked at in it. */
+        frames: number;
+        /** The parts it runs through. */
+        parts: string[];
+        /** The most any frame in it changed from its first: the share of pixels (0–1), and the mean change of a pixel's largest channel (of 255). */
+        change: number;
+        mean: number;
+        /** The picture at its end against its start: share and mean, as `change`. */
+        drift: {
+            change: number;
+            mean: number;
+        };
+        /** Footage showing during it (film seconds), which the comparison did not see. */
+        footage?: {
+            file: string;
+            part: string;
+            start: number;
+            end: number;
+        }[];
+        /** It runs to the video's last frame. */
+        toEnd?: true;
+        /** How it was looked for. */
+        options: StillOptions;
+    };
+    /**
+     * How things move either side of a join between parts (with a
+     * transition, either side of its window): each thing's velocity over
+     * the last `options.frames` frames before and the first after, each part
+     * drawn alone, from the boxes of what shows (text, painted boxes,
+     * pictures); the picture's own shift when measured (allyhub inspect
+     * --seams); the change across; things named alike on both sides.
+     */
+    "cut-seam": {
+        /** The join: the incoming part's start, film seconds. */
+        at: number;
+        before: SeamSide;
+        after: SeamSide;
+        /** The transition into the incoming part: its type and window (film seconds). */
+        transition?: {
+            type: string;
+            start: number;
+            end: number;
+        };
+        /** The change across: of the largest moving thing each side, of the moving things' overall velocity, and of the picture's shift when measured. */
+        change: {
+            lead: SeamChange;
+            overall: SeamChange;
+            picture?: SeamChange;
+        };
+        /** Things on both sides with the same `data-ak` name, or the same text. */
+        carriers: SeamCarrier[];
+        options: SeamOptions;
+    };
+    /**
+     * A frame (or a run of up to `options.frames` frames) unlike both the
+     * frame before and the frame after it: `foreign` is the share of its
+     * pixels with a channel outside what those two span, by more than
+     * `options.noise`. A one-frame flash, a blank or half-drawn frame, a
+     * layer that shows for one frame. Looked for at the frames beside each
+     * join; anywhere with allyhub inspect flash. On the check's picture:
+     * graphics, no footage.
+     */
+    flash: {
+        /** Film seconds: its first frame, and the end of its last. */
+        start: number;
+        end: number;
+        frames: number;
+        parts: string[];
+        /** The least foreign of its frames: share of pixels (0–1) and mean (levels of 255). */
+        foreign: FrameChange;
+        /** Its first frame against the frame before, its last against the frame after, and those two against each other (share past `options.noise`, mean). */
+        before: FrameChange;
+        after: FrameChange;
+        across: FrameChange;
+        /**
+         * When it touches a cut: it against its own shot alone. `step`, its
+         * frame nearest its own side against the next frame of its shot;
+         * `usual`, that frame against the one beyond, the shot's own change a
+         * frame. A step far past the usual is a frame unlike its own shot; a
+         * step near it is a frame in motion beside a cut.
+         */
+        own?: {
+            side: "before" | "after";
+            step: FrameChange;
+            usual: FrameChange;
+        };
+        /** The join it is beside, film seconds. */
+        join?: number;
+        /** It lies in a transition's window. */
+        transition?: {
+            type: string;
+            from: string;
+            to: string;
+        };
+        options: FlashOptions;
+    };
+    /** A video's music against its length. */
+    "music-length": {
+        file: string;
+        /** Seconds of music the video can play: the file from `from` on. */
+        music: number;
+        /** Seconds into the file where it starts (music.from), when not 0. */
+        from?: number;
+        /** It loops (music.loop): never shorter than the video. */
+        loop?: true;
+        video: number;
+        /** Seconds at the end without music (0 when the music is long enough). */
+        without: number;
+        /** The combo was put together from its parts, not loaded. */
+        estimated?: true;
+    };
+    /** What a piece's matrix chose: requested against possible, and each candidate's combos. */
+    "matrix-coverage": {
+        /** How the combos were chosen: named in matrix.combos, or sampled. */
+        choice: "combos" | "sampling";
+        /** Combos sampling was asked for (`pick`; absent: every one). */
+        pick?: number;
+        /**
+         * Slot combinations the rules allow (absent when matrix.combos chose
+         * among more than were counted), and how many were chosen.
+         */
+        possible?: number;
+        chosen: number;
+        /** Every candidate of every slot, with the ids of the chosen combos that use it. */
+        candidates: {
+            slot: string;
+            candidate: string;
+            combos: string[];
+        }[];
+    };
+    /**
+     * The speech's loudness either side of a join (pieces with slots,
+     * measured with ffmpeg), or why it could not be measured. A join where a
+     * side has no speech has no fact.
+     */
+    "join-loudness": {
+        before: string;
+        after: string;
+        estimated?: true;
+    } & ({
+        /** LUFS of each side's speech, levelled as the mix levels it. */
+        beforeLufs: number;
+        afterLufs: number;
+        /** after − before, in LU. */
+        difference: number;
+    } | {
+        /**
+         * Not measured: ffmpeg is not there, a take's file is not in the
+         * media index or not on this computer, a side's speech is silent
+         * (below −70 LUFS), or ffmpeg failed.
+         */
+        missing: JoinLoudnessMissing;
+        /** What happened, in words. */
+        why: string;
+    });
+    /**
+     * The generated media a version shows or plays, from the `.gen.json`
+     * records beside its files, and when: one per output × combo × format
+     * that uses any. Whether a platform's AI label is needed is the
+     * agent's to decide.
+     */
+    "generated-media": {
+        files: GeneratedFile[];
+        /** The video's length, seconds; absent on a paged output. */
+        duration?: number;
+        /** The combo was put together from its parts, not loaded. */
+        estimated?: true;
+    };
+    /**
+     * A `.gen.json` record that does not hold for the file beside it: its
+     * sha256 is another file's (the record was moved or copied without its
+     * media, or the media was changed), or it cannot be read. One per piece
+     * that reads the file.
+     */
+    "gen-mismatch": {
+        file: string;
+        record: string;
+    } & ({
+        why: "sha256";
+        /** The sha256 the record has, and the file's. */
+        recorded: string;
+        actual: string;
+    } | {
+        why: "unreadable";
+        error: string;
+    });
+    /**
+     * Graphic layers drawn under footage. A part's layers are stacked in
+     * the order they are listed, so a graphic layer listed before a footage
+     * layer is under it: a card behind a video, or a layer the footage
+     * hides. One per plane of graphics with footage over it while it shows.
+     */
+    "graphics-under-footage": {
+        /** The graphic layers, back to front: the component and when it shows (film seconds). */
+        layers: {
+            component: string;
+            start: number;
+            end: number;
+        }[];
+        /**
+         * The footage layers over them while they show: when each shows, its
+         * box in the frame's pixels (its largest when keyframed) and the share
+         * of the frame that box covers (1: all of it).
+         */
+        footage: {
+            file: string;
+            start: number;
+            end: number;
+            box: Box;
+            frame: number;
+        }[];
+        /** The largest of those shares: 1 when a footage layer covers the whole frame over them. */
+        covered: number;
+    };
+    /**
+     * A layer drawn its fallback way because what it reads is missing: a
+     * reframe around the face without a face track (centred), a footage
+     * layer's `speaker` that is not a face of its track (its reframe,
+     * punch-ins and face centred), a layer behind the person without a
+     * person matte, or without footage of the part's own take (drawn in
+     * front), a footage layer's `background` without a person matte (the
+     * footage shown as it is). check, render and dev index what is missing
+     * first unless indexing is off.
+     */
+    fallback: {
+        /** The footage or music file, when the missing thing is its analysis. */
+        file?: string;
+        missing: "face-track" | "face" | "person-matte" | "own-footage" | "tempo";
+        /** The face id asked for (missing "face"). */
+        face?: number;
+        /** What reads it. */
+        for: "reframe" | "speaker" | "behind-person" | "background" | "snap" | "music-play" | "music-end";
+        /** What is done instead. */
+        fallback: "centred" | "in-front" | "unprocessed" | "not-snapped" | "played-once" | "film-end";
+    };
+    /**
+     * Two named objects of a 3D scenery that touch or cross, at the moment a
+     * scenery layer starts (docs/design/3d-worlds.md §6): touching with the
+     * area faces in one plane share, or crossing with the curve's length,
+     * how deep at least (a lower bound from surface samples), the lift that
+     * clears them along +Y moving a and moving b, and the volume they share
+     * where both are closed.
+     */
+    "scenery-contact": SceneryFactPlace & {
+        a: string;
+        b: string;
+        crossing: boolean;
+        touching: boolean;
+        gap?: number;
+        area?: number;
+        curve?: number;
+        within?: "a in b" | "b in a";
+        depth?: number;
+        lift?: {
+            a: number;
+            b: number;
+        };
+        volume?: number;
+        volumeMissing?: string;
+        /** The pair could not be measured, and why. */
+        missing?: string;
+    };
+    /**
+     * A named object of a 3D scenery and what is below it, by columns down
+     * through its footprint: the least gap (negative when sunk), what is
+     * below, the share of its footprint in contact, and how far its centre
+     * of mass is inside the contact's hull.
+     */
+    "scenery-support": SceneryFactPlace & {
+        object: string;
+        gap: number | null;
+        sunk: number;
+        on: string[];
+        footprintShare: number;
+        margin?: number;
+        nothingBelow: number;
+    };
+    /**
+     * Whether a scenery layer's scenery was drawn with its bake laid
+     * (`allyhub scenery bake`): a bake is laid only on the scene it was made
+     * for, by the scene's digest, so a scenery that changed since it was baked
+     * is drawn unbaked, lit by its own lights alone. Reported for a scenery
+     * that says how to bake it (defineScenery's `bake`), has a bake laid, or
+     * was baked before.
+     */
+    "scenery-bake": SceneryFactPlace & {
+        laid: boolean;
+        /** Whether the scenery says how to bake it (defineScenery's `bake`). */
+        asked: boolean;
+        /** The scene's digest a bake was looked for by. */
+        digest: string;
+        /** The renderer it was looked for on (this page's; the CPU's is looked for too). */
+        renderer: string;
+        /** Laid: the renderer the bake was made on. */
+        bakedOn?: string;
+        /** The scenery's module, a project path, when known. */
+        file?: string;
+        /** Not laid: the digest the scenery was last baked to on each renderer (the bake index); empty when it never was. */
+        baked?: Record<string, string>;
+        /** Not laid: whether the scenery was baked before, for another scene (it changed since), rather than never. */
+        stale?: boolean;
+        /** Not laid: the renderers (other GPUs) a bake of this very scene was made on, which this one does not lay. */
+        elsewhere?: string[];
+        /** Not laid: the command that makes its bake. */
+        command?: string;
+    };
+    /** A named object of a 3D scenery whose surface is open, non-manifold, degenerate or crosses itself. */
+    "mesh-health": SceneryFactPlace & {
+        object: string;
+        triangles: number;
+        closed: boolean;
+        openEdges: number;
+        nonManifoldEdges: number;
+        degenerate: number;
+        selfIntersections: number | null;
+    };
+    /**
+     * A scenery layer's camera near or in the scenery's surfaces over the layer:
+     * the least distance to a surface and when, the moments it is inside an
+     * object, and those its near plane cuts geometry (sampled ten times a
+     * second).
+     */
+    "camera-clearance": SceneryFactPlace & {
+        nearest?: {
+            object: string;
+            distance: number;
+            t: number;
+        };
+        inside: {
+            object: string;
+            closed: boolean;
+            from: number;
+            to: number;
+        }[];
+        nearCut: {
+            object: string;
+            from: number;
+            to: number;
+        }[];
+    };
+    /**
+     * A scenery layer's camera motion over the layer, in its own frame: the
+     * peaks of each channel (m/s, °/s, stops/s), speed, turn, acceleration,
+     * jerk and when, a dimensionless smoothness, the largest step between
+     * frames.
+     */
+    "camera-motion": SceneryFactPlace & {
+        fps: number;
+        length: number;
+        peaks: Record<"truck" | "pedestal" | "dolly" | "pan" | "tilt" | "roll" | "zoom" | "speed" | "turn" | "acceleration" | "jerk", {
+            peak: number;
+            at: number;
+        }>;
+        smoothness: number | null;
+        step: {
+            distance: number;
+            angle: number;
+            at: number;
+        };
+        /** The camera's cuts (shots()), part times: what is measured stops at each. */
+        cuts?: number[];
+    };
+    /**
+     * A screen in a scenery layer (scenery({ screens })) over the layer, sampled
+     * ten times a second: when it is on the frame facing the camera, its
+     * share of the layer's box, frame px per content px (below 1 its content
+     * is shrunk), the angle between its face's normal and the line to the
+     * camera at the centre of what the frame shows of it (°, 0 square on;
+     * the face's own centre when all of it shows), and the share
+     * of it hidden by what is in front, by which objects at the most.
+     */
+    "scenery-screen": SceneryFactPlace & {
+        screen: string;
+        /** Its content's size, px. */
+        size: [number, number];
+        /** The layer's box on the frame, px. */
+        frame: [number, number];
+        shown: {
+            from: number;
+            to: number;
+        }[];
+        share?: SceneryRange;
+        scale?: SceneryRange;
+        angle?: SceneryRange;
+        hidden?: SceneryRange & {
+            by: {
+                object: string;
+                share: number;
+            }[];
+        };
+        /**
+         * With a camera that has an aperture: the circle of confusion across
+         * the screen (a turned screen's near side is blurred more than its far
+         * side), its diameter in frame px (0 in focus), the least and the most
+         * over the layer.
+         */
+        blur?: SceneryRange;
+        /**
+         * With a sensor (scenery({ sensor })): the moiré its grid makes of the
+         * screen's pixels, the deepest band over a grid of its points at each
+         * sampled moment (how much it darkens at its darkest, 0–1), the least
+         * and the most over the layer, and how far apart that band's stripes
+         * are at the deepest, frame px.
+         */
+        moire?: SceneryRange & {
+            period?: number;
+        };
+        /**
+         * Each sampled moment it was on the frame: part time, its corners in
+         * the frame's px (top left, top right, bottom right, bottom left of its
+         * content), its share, its scale (least, most), its angle, and the share
+         * hidden when it was measured.
+         */
+        samples?: {
+            t: number;
+            corners: [number, number][];
+            share: number;
+            scale: [number, number];
+            angle: number;
+            hidden?: number;
+        }[];
+        /**
+         * A video on the screen (screen(video, { cues })): each stretch between
+         * two cues, in scenery seconds and the video's, and its speed (the
+         * video's seconds per scenery second; 1 is its own pace).
+         */
+        stretches?: {
+            from: number;
+            to: number;
+            video: [number, number];
+            speed: number;
+        }[];
+        /**
+         * Where it is drawn at this check, and at what share of the frame's
+         * pixels each way: in the scenery (Chrome's HTML-in-Canvas), at the scenery
+         * layer's drawing scale (quality.scale, default 0.5: its picture drawn
+         * at that size, then shown at the layer's); over the scenery, at the
+         * frame's own, 1.
+         */
+        drawn?: {
+            in: "scenery" | "over";
+            scale: number;
+        };
+        /**
+         * Its smallest text: font size in content px (of every text the screen
+         * holds, in any of its parts), and on the frame at the least and the
+         * most scale it is seen at (px), as drawn: times the drawing scale
+         * (`drawn`, at most 1).
+         */
+        text?: {
+            size: number;
+            onFrame: [number, number];
+        };
+    };
+    /**
+     * A screen drawn in the scenery (Chrome's HTML-in-Canvas) against its own
+     * element, at one moment of its scenery layer (its part's still, else the
+     * layer's middle): a small level of its texture as uploaded (before the
+     * scenery's light, tone curve and a sensor's moiré) and the element drawn
+     * flat by the browser's compositor, made the same size in linear light,
+     * both over `backdrop`. The colour difference (ΔE*ab, CIE76) over its
+     * pixels, the share over `tolerance`, the regions where they differ
+     * (content px, largest first) with the elements of the content in each
+     * that the texture is known to draw otherwise (canvases, faces with
+     * backface-visibility hidden, preserve-3d contexts, elements in the
+     * browser's top layer), and every such element. Missing, with why, when
+     * it could not be compared (a browser without HTML-in-Canvas draws the
+     * screen over the scenery).
+     */
+    "scenery-screen-fidelity": SceneryFactPlace & {
+        screen: string;
+        /** Part time of the moment compared, s. */
+        at: number;
+        /** Its content's size, px. */
+        size: [number, number];
+        /**
+         * The texture's level compared and its pixels each way, the texture's
+         * own (`of`), and the element's (`element`: its content's size times
+         * its pixels' density). A texture smaller than its element was painted
+         * at fewer pixels than it has: HTML-in-Canvas paints it at the scenery's
+         * canvas's pixels per CSS pixel, its quality.scale.
+         */
+        texture?: {
+            level: number;
+            size: [number, number];
+            of: [number, number];
+            element: [number, number];
+        };
+        /** The element as the browser draws it flat, captured at this size, px. */
+        flat?: [number, number];
+        /** A pixel differs when its ΔE*ab is over this. */
+        tolerance: number;
+        /** What both are seen over where they are transparent, RGB. */
+        backdrop: [number, number, number];
+        deltaE?: {
+            mean: number;
+            p95: number;
+            max: number;
+        };
+        /** Mean absolute difference of each channel, 0–255. */
+        channels?: {
+            r: number;
+            g: number;
+            b: number;
+            alpha: number;
+        };
+        /** The share of its pixels whose ΔE*ab is over the tolerance. */
+        share?: number;
+        regions?: {
+            /** Content px: x, y, width, height. */
+            box: [number, number, number, number];
+            /** Its differing pixels as a share of the screen's. */
+            share: number;
+            meanDeltaE: number;
+            maxDeltaE: number;
+            /** The listed elements whose box meets it: their places in `elements`. */
+            elements: number[];
+        }[];
+        /** Elements of the content the texture is known to draw otherwise, with their boxes, content px. */
+        elements?: {
+            kind: "canvas" | "backface-hidden" | "preserve-3d" | "top-layer";
+            name: string;
+            box: [number, number, number, number];
+        }[];
+        /** The comparison could not be made, and why. */
+        missing?: string;
+    };
+    /**
+     * A part that plays a stretch of a video item (take(piece).range) whose
+     * start or end falls inside a word of it: the word, and how far into it.
+     */
+    "cut-in-word": {
+        /** The video item the stretch is of. */
+        source: string;
+        side: "start" | "end";
+        /** Its seconds where the cut is. */
+        at: number;
+        word: string;
+        /** The word's start and end, its seconds. */
+        wordStart: number;
+        wordEnd: number;
+    };
+}
+/** The least and the most of a value over a scenery layer's samples, and when (part time, s). */
+export interface SceneryRange {
+    least: number;
+    leastAt: number;
+    most: number;
+    mostAt: number;
+}
+/** Where a scenery fact is from: the scenery layer (its name), and its window on its part's clock, s. */
+export interface SceneryFactPlace {
+    layer: string;
+    start: number;
+    end: number;
+}
+export type FactKind = keyof FactData;
+/** Where a fact was measured. Piece-level facts (the matrix) have no output, combo or format. */
+export interface FactPlace {
+    piece: string;
+    output?: string;
+    combo?: Combo;
+    format?: string;
+    part?: string;
+    /** Film seconds. */
+    t?: number;
+}
+export type Fact = {
+    [K in FactKind]: FactPlace & {
+        kind: K;
+        data: FactData[K];
+    };
+}[FactKind];
+/** Every kind, with what it says, in the order `allyhub inspect` prints them. */
+export declare const FACT_KINDS: Record<FactKind, string>;
+export declare function isFactKind(k: string): k is FactKind;
+/** A fact of one kind, typed. */
+export declare function fact<K extends FactKind>(kind: K, place: FactPlace, data: FactData[K]): Fact;
+/** Facts of one kind, typed. */
+export declare function factsOf<K extends FactKind>(facts: readonly Fact[], kind: K): Extract<Fact, {
+    kind: K;
+}>[];
+/** How many facts of each kind. */
+export declare function countFacts(facts: readonly Fact[]): Partial<Record<FactKind, number>>;
+/** Which facts to keep: of these kinds, of this part, between these seconds. */
+export interface FactFilter {
+    kinds?: readonly FactKind[] | undefined;
+    part?: string | undefined;
+    from?: number | undefined;
+    to?: number | undefined;
+}
+/** The facts a filter keeps; a fact without a time goes when a time is asked. */
+export declare function filterFacts(facts: readonly Fact[], o: FactFilter): Fact[];
+/**
+ * The free-bands fact's data for one part: the content box of a frame
+ * W × H inside `safe`, and its bands free of the face boxes (one per
+ * measured moment, undefined where no face was seen), of the person
+ * matte's rows (spans per moment, already limited to the content box's
+ * columns) and of both. A measurement that is missing stays missing: it
+ * covers nothing, and says so.
+ */
+export declare function freeBandsData(o: {
+    width: number;
+    height: number;
+    safe: SafeZone;
+    profile?: string;
+    moments: number[];
+    face: {
+        files: string[];
+        speaker?: number;
+        boxes: (Box | undefined)[];
+    } | FreeBandsMissing<"face-track">;
+    person: {
+        files: string[];
+        rows: RowSpan[][];
+    } | FreeBandsMissing<"person-matte">;
+}): FactData["free-bands"];
+/**
+ * The facts in a layout measurement (LoadedOutput.measure): text over
+ * text, over the face and in covered edges at each moment, and each
+ * footage layer's enlargement. The person matte is the host's to add
+ * (`text-speaker`'s `person`).
+ */
+export declare function layoutFacts(report: LayoutReport, place: Omit<FactPlace, "part" | "t">, profile?: string): Fact[];
+//# sourceMappingURL=fact.d.ts.map