allyhub 0.4.0 → 0.5.0

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

@@ -1,1134 +0,0 @@
-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 deck, 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 deck. */
-    seconds?: number;
-}
-/** What each kind of fact measures. */
-export interface FactData extends DeckFactData {
-    /** 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 deck. */
-        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;
-}
-/** An edge of a box and how far past a line it is, in pixels. */
-export interface EdgePast {
-    side: "top" | "bottom" | "left" | "right";
-    px: number;
-}
-/** Facts of a deck: what is measured of each slide as drawn (`deckFacts`, @allyhub-next/slides-core). */
-export interface DeckFactData {
-    /** A shape's text past its box, by its lines' glyphs. */
-    "text-overflow": {
-        shape: string;
-        text: string;
-        box: Box;
-        glyphs: Box;
-        edges: EdgePast[];
-        /** Its lines, and those past the box. */
-        lines: number;
-        past: number;
-        /** The share autofit shrank it to, when it did and it still does not fit. */
-        scale?: number;
-    };
-    /** A shape partly or wholly past the slide's edge. */
-    "shape-off-slide": {
-        shape: string;
-        box: Box;
-        edges: EdgePast[];
-        /** Its area past the edge, as a share of its own (0–1). */
-        share: number;
-    };
-    /**
-     * Two shapes of a slide over each other, not a master's or a layout's own
-     * under another: what shows of each, its box when it is filled or a
-     * picture, else its text's glyphs.
-     */
-    "shape-overlap": {
-        a: string;
-        b: string;
-        /** Pixels both cover, and that as a share of the smaller (0–1). */
-        area: number;
-        share: number;
-    };
-    /** Edges or centres of two shapes, or of a shape and the slide, nearly in line and not. */
-    "near-alignment": {
-        a: string;
-        /** Another shape, or "slide" for the slide's centre. */
-        b: string;
-        line: "left" | "right" | "top" | "bottom" | "centre-x" | "centre-y";
-        /** How far apart, in points. */
-        gap: number;
-        options: {
-            within: number;
-            aligned: number;
-        };
-    };
-    /** A shape of one name at different places on slides of one layout. */
-    "placement-drift": {
-        layout: string;
-        shape: string;
-        /** Each place, in points, with the slides it is at. */
-        places: {
-            frame: Box;
-            slides: string[];
-        }[];
-        options: {
-            drift: number;
-        };
-    };
-    /** The sizes and weights the deck's text uses, and on how many slides. */
-    "type-in-use": {
-        type: {
-            size: number;
-            weight: number;
-            slides: number;
-            shapes: number;
-        }[];
-        /** The smallest size, in points. */
-        smallest: number;
-    };
-    /** A text's size as read: on the slide, on a screen from the farthest seat, on a phone. */
-    "read-size": {
-        shape: string;
-        text: string;
-        /** Its smallest size and lowercase x's height, in points on the slide. */
-        size: number;
-        xHeight?: number;
-        /**
-         * On a room's screen, when one is given: its lowercase x (`by: "x"`), or for text with
-         * no lowercase Latin letter (CJK) its em (`by: "em"`), in millimetres,
-         * and the angle that makes at the farthest seat, in minutes of arc.
-         */
-        screen?: {
-            by: "x" | "em";
-            mm: number;
-            arcmin: number;
-        };
-        /** Its size in points on the phone of `options.phone`, the slide fitted inside it. */
-        phone: number;
-        options: {
-            room?: {
-                screen: number;
-                distance: number;
-            };
-            phone: [number, number];
-        };
-    };
-    /** Words, lines and texts on a slide. */
-    "words-on-slide": {
-        words: number;
-        lines: number;
-        texts: number;
-    };
-    /** A picture drawn larger than its pixels, or stretched. */
-    "picture-resolution": {
-        shape: string;
-        source: [number, number];
-        shown: [number, number];
-        box: Box;
-        /** Slide pixels per source pixel, the larger of the two directions (over 1: enlarged). */
-        scale: number;
-        /** Source pixels per inch of the slide, the smaller of the two directions. */
-        ppi: number;
-        /** How much wider than its pixels it is drawn, against how much taller, less 1 (0: not stretched). */
-        stretch: number;
-    };
-    /** A shape another covers whole. */
-    /** Covered whole at every step that shows it (`by`), or shown by no step. */
-    "shape-hidden": {
-        shape: string;
-        by?: string;
-        never?: true;
-    };
-    /** A table's rows its words made taller than they are set, in points, which moves all that is under them. */
-    "chart-data": {
-        shape: string;
-        type: string;
-        categories: number;
-        series: number;
-        /** The smallest and largest number it shows; absent when it shows none. */
-        low?: number;
-        high?: number;
-        /** The project file its numbers came from; absent: written in slides.yaml or the code. */
-        source?: string;
-    };
-    "table-grown": {
-        shape: string;
-        /** Its height as set and as drawn. */
-        set: number;
-        drawn: number;
-        rows: {
-            row: number;
-            set: number;
-            drawn: number;
-        }[];
-    };
-    /**
-     * The fonts a deck's PowerPoint file names, and whether each is one
-     * every PowerPoint, Keynote and Google Slides has (`options.standard`):
-     * one that is not is replaced where the file is opened without it.
-     */
-    "deck-fonts": {
-        fonts: {
-            name: string;
-            where: "theme" | "text";
-            standard: boolean;
-        }[];
-        options: {
-            standard: string[];
-        };
-    };
-}
-/** 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