allyhub 0.7.1 → 0.8.0

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

@@ -0,0 +1,37 @@
+import { type GenFile } from "@allyhub/formats";
+/** Where a file fetched from a library came from: the library, its page, its authors and its licence (SPDX). */
+export type GenSource = NonNullable<GenFile["source"]>;
+/** What a media value says of its record (`MediaInfo.gen`). */
+export interface MediaGen {
+    /** The record's path in the project. */
+    record: string;
+    ai: boolean;
+    tool?: string;
+    model?: string;
+    /** When it was made (ISO 8601). */
+    at?: string;
+    credits?: number;
+    /** The input as recorded (the prompt, the settings). */
+    input?: Record<string, unknown>;
+    /** What the tool returned about the file, as recorded. */
+    output?: Record<string, unknown>;
+    /** The file's sha256 as the record has it. */
+    sha256?: string;
+    /** A file fetched from a library: where from, who made it, its licence. */
+    source?: GenSource;
+    /**
+     * Whether that is this file's sha256: false when the record was moved
+     * beside another file or the file was changed since.
+     */
+    matches?: boolean;
+}
+/**
+ * A `.gen.json`'s content as a media value's `gen`, or why it cannot be
+ * read. `sha256` is the media file's own.
+ */
+export declare function mediaGen(record: string, value: unknown, sha256: string): {
+    gen: MediaGen;
+} | {
+    error: string;
+};
+//# sourceMappingURL=gen.d.ts.map

package/dist/node_modules/@allyhub/video-core/dist/gen.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{GenFileSchema as u}from"@allyhub/formats";import{z as d}from"zod";export function mediaGen(r,o,n){const t=u.safeParse(o);if(!t.success)return{error:d.prettifyError(t.error)};const e=t.data;return{gen:{record:r,ai:e.ai,...e.tool===void 0?{}:{tool:e.tool},...e.model===void 0?{}:{model:e.model},at:e.at,...e.credits===void 0?{}:{credits:e.credits},...e.input===void 0?{}:{input:e.input},...e.output===void 0?{}:{output:e.output},...e.source===void 0?{}:{source:e.source},sha256:e.sha256,matches:e.sha256===n}}}

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

@@ -0,0 +1,41 @@
+export * from "./piece.js";
+export * from "./component.js";
+export * from "./timeline.js";
+export * from "./source.js";
+export * from "./look.js";
+export * from "./formats.js";
+export * from "./placement.js";
+export * from "./media.js";
+export * from "./gen.js";
+export * from "./messages.js";
+export * from "./script.js";
+export * from "./anchors.js";
+export * from "./marks.js";
+export * from "./script-edit.js";
+export * from "./edit.js";
+export * from "./timing.js";
+export * from "./music.js";
+export * from "./words.js";
+export * from "./speech.js";
+export * from "./edits.js";
+export * from "./voice.js";
+export * from "./transcript.js";
+export * from "./cut-report.js";
+export * from "./captions.js";
+export * from "./transition.js";
+export * from "./motion.js";
+export * from "./footage-motion.js";
+export * from "./backdrop.js";
+export * from "./measure.js";
+export * from "./seams.js";
+export * from "./contrast.js";
+export * from "./matrix.js";
+export * from "./problem.js";
+export * from "./fact.js";
+export * from "./console.js";
+export * from "./export.js";
+export * from "./schema.js";
+export * from "./audio-types.js";
+export * from "./render-types.js";
+export * from "./sound-under.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/node_modules/@allyhub/video-core/dist/index.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export*from"./piece.js";export*from"./component.js";export*from"./timeline.js";export*from"./source.js";export*from"./look.js";export*from"./formats.js";export*from"./placement.js";export*from"./media.js";export*from"./gen.js";export*from"./messages.js";export*from"./script.js";export*from"./anchors.js";export*from"./marks.js";export*from"./script-edit.js";export*from"./edit.js";export*from"./timing.js";export*from"./music.js";export*from"./words.js";export*from"./speech.js";export*from"./edits.js";export*from"./voice.js";export*from"./transcript.js";export*from"./cut-report.js";export*from"./captions.js";export*from"./transition.js";export*from"./motion.js";export*from"./footage-motion.js";export*from"./backdrop.js";export*from"./measure.js";export*from"./seams.js";export*from"./contrast.js";export*from"./matrix.js";export*from"./problem.js";export*from"./fact.js";export*from"./console.js";export*from"./export.js";export*from"./schema.js";export*from"./audio-types.js";export*from"./render-types.js";export*from"./sound-under.js";

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

@@ -0,0 +1,563 @@
+import type { SafeZone } from "./formats.js";
+import type { Box } from "./problem.js";
+import type { PixelRect, TimelineFootage } from "./timeline.js";
+/** A block of text on screen at a moment: one layer's line or paragraph. */
+export interface MeasuredText {
+    /** The layer's component name ("custom" for custom()). */
+    layer: string;
+    /** The plane it is drawn in. */
+    z: "front" | "behind-person" | "overlay";
+    text: string;
+    /** Its box in the frame's pixels, rounded. */
+    box: Box;
+    /** Inside a page viewport (a site demo): the page's own text. */
+    viewport?: true;
+    /**
+     * How opaque it is drawn, the lowest of its text nodes' (each the product
+     * of its element's and its ancestors'), when under 1.
+     */
+    opacity?: number;
+    /**
+     * The box of what shows of its glyphs, when not `box`: the rows they
+     * cover (a line's box is the font's whole ascent and descent, taller
+     * than what is drawn), cut where an ancestor clips its content. Blocks of
+     * one layer, and a block and the boxes it is drawn inside, are compared
+     * by it.
+     */
+    ink?: Box;
+    /**
+     * The font families its characters are drawn in, in the order they first
+     * draw one: by the faces the page declares and their ranges, as the
+     * browser picks them (the runtime's drawnFamilies).
+     */
+    fonts?: string[];
+}
+/** What makes an element a box one can see: a background, a border, a shadow. */
+export type BoxPaint = "background" | "border" | "shadow";
+/**
+ * A box a text block is drawn inside: an element between the block and its
+ * layer with a background, a border or a shadow (the block's own element
+ * too), nearest first.
+ */
+export interface TextContainer {
+    /** In the frame's pixels, rounded. */
+    box: Box;
+    paint: BoxPaint[];
+}
+/** A text block reaching outside a box it is drawn inside. */
+export interface TextOutside {
+    text: number;
+    /** The nearest box it reaches out of. */
+    container: TextContainer;
+    /** Per edge of that box it crosses: pixels past the edge. */
+    edges: {
+        side: "top" | "bottom" | "left" | "right";
+        px: number;
+    }[];
+}
+/** Two text blocks drawn over each other. */
+export interface TextOverlap {
+    /** Indices into the moment's texts. */
+    a: number;
+    b: number;
+    /** Pixels both cover. */
+    area: number;
+    /** That area as a share of the smaller block's box (0–1). */
+    share: number;
+}
+/** A text block over the speaker's face. */
+export interface FaceOverlap {
+    text: number;
+    area: number;
+    /** Share of the text block's box. */
+    ofText: number;
+    /** Share of the face's box. */
+    ofFace: number;
+}
+/** A text block reaching into the area a platform's interface covers (not a page viewport's own text). */
+export interface SafeOverlap {
+    text: number;
+    /** Per covered edge it reaches into: pixels in from that edge's line. */
+    edges: {
+        side: "top" | "bottom" | "left" | "right";
+        px: number;
+    }[];
+}
+/**
+ * A text block the frame's edges cut: what shows of its glyphs (the rows
+ * each line's glyphs cover, the columns of its letters, after the boxes it
+ * is drawn inside clip it) that lies outside the frame.
+ */
+export interface TextOffFrame {
+    text: 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;
+    /** Per edge of the frame it crosses: pixels past the edge. */
+    edges: {
+        side: "top" | "bottom" | "left" | "right";
+        px: number;
+    }[];
+    /** The box round its glyphs, whole pixels, the frame not cutting it. */
+    glyphs: Box;
+}
+export interface LayoutMoment {
+    /** Film seconds, on the frame grid. */
+    t: number;
+    part: string;
+    texts: MeasuredText[];
+    /** The speaker's face, when the footage showing has a face track. */
+    face?: Box;
+    /** Blocks of different layers over each other. */
+    overlaps: TextOverlap[];
+    /** Blocks of the same layer over each other. */
+    ownOverlaps: TextOverlap[];
+    /** Blocks reaching outside a box they are drawn inside. */
+    outside: TextOutside[];
+    faceOverlaps: FaceOverlap[];
+    safeOverlaps: SafeOverlap[];
+    /** Blocks the frame's edges cut. */
+    offFrame: TextOffFrame[];
+}
+/** A footage layer's enlargement at one moment. */
+export interface ScaleAt {
+    /** Output pixels per source pixel (1: its own pixels; 2: each source pixel drawn 2 × 2). */
+    scale: number;
+    /** Film seconds. */
+    t: number;
+    /** What makes up the scale then: the fit, and a zoom (punch-in or pullback) or box key. */
+    from: string[];
+}
+/**
+ * How much a footage layer is enlarged over its window: drawn pixels per
+ * source pixel at its largest and at its smallest.
+ */
+export interface FootageScale {
+    part: string;
+    file: string;
+    /** The source's pixels, as displayed. */
+    source: [width: number, height: number];
+    /** The part of the source drawn (crop, reframe window), in its pixels. */
+    shown: [width: number, height: number];
+    /** The largest enlargement, at its first moment. */
+    max: ScaleAt;
+    /** The smallest enlargement, at its first moment. */
+    min: ScaleAt;
+}
+/** How the time a text can be read is measured (the text-time fact). */
+export interface ReadOptions {
+    /** Seconds between the moments each part is looked at. */
+    every: number;
+    /** A block is whole while every text node of it is drawn at this opacity or more… */
+    opacity: number;
+    /** …and at least this share of each node's glyphs' box shows (an ancestor's overflow clips the rest). */
+    shown: number;
+    /**
+     * The phone a text's size is given on: its screen in points, held
+     * upright, the frame fitted inside it whole (a 16:9 frame across its
+     * width, a 9:16 one up its height).
+     */
+    phone: [width: number, height: number];
+}
+export declare const READ_DEFAULTS: ReadOptions;
+/** How many of the phone's points a pixel of a frame is (`ReadOptions.phone`). */
+export declare function phoneScale(frame: readonly [width: number, height: number], phone: readonly [width: number, height: number]): number;
+/** A text block at one of the moments a part is looked at. */
+export interface TextSample {
+    /** Film seconds. */
+    t: number;
+    text: string;
+    box: Box;
+    /** The lowest opacity of its text nodes. */
+    opacity: number;
+    /** The share of its glyphs' box that shows, the lowest of its text nodes' (an ancestor's overflow clips the rest). */
+    shown: number;
+    /** Its font size as drawn, in the frame's pixels (a transform's scale counted), the smallest of its text nodes'. */
+    size?: number;
+    /** Its font's lowercase x as drawn, in the frame's pixels, the smallest of its text nodes' with lowercase Latin letters. */
+    xHeight?: number;
+}
+/** How long one text block can be read. */
+export interface TextTime {
+    part: string;
+    /** The text the block shows longest, where it is first whole (else first on screen). */
+    text: MeasuredText;
+    words: number;
+    chars: number;
+    /** Seconds that text shows whole. */
+    seconds: number;
+    /** When, in film seconds: [from, until]. */
+    spans: [from: number, until: number][];
+    /** Seconds that text is on screen at all. */
+    onScreen: number;
+    /** Film seconds it is first whole, else first on screen. */
+    first: number;
+    /**
+     * Its font size: the smallest it is drawn at while whole (else while on
+     * screen), in the frame's pixels and in points on the phone of
+     * `ReadOptions.phone`. Missing when it was not measured. `lowercase` is
+     * the height of its font's lowercase x the same way, for text with
+     * lowercase Latin letters: two faces at one size can draw their letters
+     * at very different heights (a handwriting face's are much smaller).
+     */
+    size?: TextSize;
+}
+/** A text's size in the frame's pixels and in points on a phone, with its lowercase letters' height. */
+export interface TextSize {
+    px: number;
+    phone: number;
+    lowercase?: {
+        px: number;
+        phone: number;
+    };
+}
+/** A text of a deck's shape as drawn. */
+export interface DeckTextLayout {
+    text: string;
+    words: number;
+    /** Its lines as drawn, a box of each one's glyphs, in the slide's pixels. */
+    lines: Box[];
+    /** All of its glyphs; null when none shows. */
+    glyphs: Box | null;
+    /** The sizes and weights it is drawn at, each once: size and lowercase x's height in points. */
+    type: {
+        size: number;
+        weight: number;
+        xHeight?: number;
+    }[];
+    /** The share autofit shrank it to, when it did. */
+    scale?: number;
+    /** Its first paragraph's alignment: the line it is aligned by. */
+    align?: "l" | "ctr" | "r" | "just";
+}
+/** A deck's shape as drawn on its slide. */
+export interface DeckShapeLayout {
+    name: string;
+    /** placeholder, textbox, picture, movie, autoshape, line, component. */
+    kind: string;
+    /** Where it comes from: its master's or layout's own, or the slide's (placeholders are the slide's). */
+    level: "master" | "layout" | "slide";
+    placeholder?: string;
+    /** Its frame as set, in the slide's pixels. */
+    frame: Box;
+    /** Its box as drawn (a shape that fits its text has grown to it). */
+    box: Box;
+    /** It hides what is under it: filled, a picture, a movie. */
+    opaque: boolean;
+    /** Not drawn at this moment: its entrance is to come, or its exit has been. */
+    hidden?: boolean;
+    text?: DeckTextLayout;
+    /** A table's rows, each as tall as it is set and as it is drawn, in the slide's pixels. */
+    rows?: {
+        set: number;
+        drawn: number;
+    }[];
+    /** A chart's numbers: how many, how far they run, and the project file they came from. */
+    chart?: {
+        type: string;
+        categories: number;
+        series: number;
+        low?: number;
+        high?: number;
+        source?: string;
+    };
+    picture?: {
+        /** The file's own pixels. */
+        source: [width: number, height: number];
+        /** The part of them shown (its crop). */
+        shown: [width: number, height: number];
+    };
+}
+/** A deck's slide as drawn at a still: one of its steps'. */
+export interface DeckSlideLayout {
+    slide: string;
+    /** How many steps the slide has, so that all of them measured can be told. */
+    steps?: number;
+    /** Its still, in the deck's seconds. */
+    t: number;
+    layout: string;
+    hidden: boolean;
+    notes?: string;
+    /** Back to front, as drawn; an empty placeholder is not drawn. */
+    shapes: DeckShapeLayout[];
+}
+/** A deck as drawn, measured for its facts. */
+export interface DeckLayout {
+    /** The slide's pixels per point. */
+    pxPerPt: number;
+    /**
+     * The fonts its PowerPoint file names: its theme's, and those its text
+     * names itself; `drawn`, whether the stage has the font (a face the page
+     * declares, or one on this computer) or draws its text in another.
+     */
+    fonts?: {
+        name: string;
+        where: "theme" | "text";
+        drawn?: boolean;
+    }[];
+    slides: DeckSlideLayout[];
+}
+export interface LayoutReport {
+    width: number;
+    height: number;
+    /** A deck's slides as drawn (a deck's measure() only). */
+    deck?: DeckLayout;
+    /** The format's covered edges, in pixels. */
+    safe: SafeZone;
+    moments: LayoutMoment[];
+    footage: FootageScale[];
+    /** How long each text block can be read (a video measured at its default moments). */
+    reading?: {
+        options: ReadOptions;
+        texts: TextTime[];
+    };
+}
+/** The words and characters of a text: word-like segments as the language breaks them, and characters that are not spaces. */
+export declare function countWords(text: string): {
+    words: number;
+    chars: number;
+};
+/**
+ * How long one text block can be read, from what it showed at each moment
+ * its part was looked at (in order, `every` seconds apart; a moment it was
+ * not on screen has no sample). Its text is the one it shows longest (a
+ * line that comes in word by word, a number that counts up: what they
+ * settle on), the latest of equals. It is whole while it shows that text
+ * with every node at `opacity` or more and `shown` or more of its glyphs
+ * showing; each run of
+ * such moments counts from its first to `every` after its last, no later
+ * than `end`. Its size is the smallest its text is drawn at while whole
+(else while on screen), and on a phone the frame (`o.frame`) fitted in
+`options.phone`.
+ */
+export declare function textTime(samples: readonly TextSample[], o: {
+    part: string;
+    layer: string;
+    z: MeasuredText["z"];
+    end: number;
+    frame: [width: number, height: number];
+}, options?: ReadOptions): TextTime | undefined;
+/** How much of what a part says shows as text in that part (the speech-on-screen fact). */
+export interface SpeechShown {
+    /** Words the part says, and how many of them are in a text it shows. */
+    words: number;
+    shown: number;
+    /** The words said that no text shows, each once, in order. */
+    unshown: string[];
+}
+/** Words said against the texts on screen, by their letters: a caption's words are the words said. */
+export declare function speechShown(heard: string, texts: readonly string[]): SpeechShown;
+/** The words whole on screen at once in a part (the words-on-screen fact). */
+export interface WordsAtOnce {
+    part: string;
+    /** The most words whole at once, with the characters and text blocks they are. */
+    words: number;
+    chars: number;
+    texts: number;
+    /** The first stretch with that many, in film seconds. */
+    from: number;
+    until: number;
+    /** Every change of the count over the part: from `t` on, `words` whole in `texts` blocks. */
+    steps: {
+        t: number;
+        words: number;
+        texts: number;
+    }[];
+}
+/**
+ * How many words are whole on screen at once, per part: the text blocks'
+ * whole spans (textTime) laid over each other. A block counts its words
+ * from the start of a span up to its end. A part none of whose texts is
+ * ever whole has none.
+ */
+export declare function wordsAtOnce(texts: readonly TextTime[]): WordsAtOnce[];
+/** The pixels two boxes both cover. */
+export declare function overlapArea(a: Box | PixelRect, b: Box | PixelRect): number;
+/** How two boxes overlap: the area, and its share of the smaller box. */
+export declare function boxOverlap(a: Box | PixelRect, b: Box | PixelRect): {
+    area: number;
+    share: number;
+} | undefined;
+/**
+ * How far a box reaches into the covered edges of a frame W × H: pixels
+ * in from each covered edge's line, for the edges it crosses.
+ */
+export declare function safeEdges(b: Box | PixelRect, safe: SafeZone, W: number, H: number): SafeOverlap["edges"];
+/**
+ * How far a box reaches past the edges of another: pixels out per edge it
+ * crosses, whole pixels (under one is none).
+ */
+export declare function outsideEdges(b: Box | PixelRect, inside: Box | PixelRect): TextOutside["edges"];
+/**
+ * How much of a text's glyphs lies outside a frame W × H: `glyphs` are the
+ * boxes of what shows of them (a box per line), in the frame's pixels. The
+ * pixels outside, their share of all the glyphs' pixels, and per edge of
+ * the frame they cross, how far past it they reach (whole pixels: under
+ * one is none). Undefined when they cross no edge, or have no pixels.
+ */
+export declare function offFrame(glyphs: readonly (Box | PixelRect)[], W: number, H: number): Omit<TextOffFrame, "text"> | undefined;
+/** A text block the frame's edges cut at every measured moment of its part that shows it. */
+export interface CutThroughout {
+    part: string;
+    /** The block at the moment the frame cuts most of it. */
+    text: MeasuredText;
+    /** The measured moments that show it, film seconds: the frame cuts it at each. */
+    moments: number[];
+    /** The moment the frame cuts most of it. */
+    t: number;
+    /** At that moment: its glyphs outside the frame, as `TextOffFrame`. */
+    worst: Omit<TextOffFrame, "text">;
+}
+/**
+ * The text blocks a report's measured moments never show whole inside the
+ * frame: in a part, a block (a layer's text, the same at each moment) that
+ * the frame's edges cut at every moment it is on screen. A block that
+ * slides in from past an edge and comes to rest inside is whole at some
+ * moment, and is not one; each moment of it stays a text-off-frame fact.
+ * A block wholly past the edges at a moment is not on screen then, so not
+ * cut. A page viewport's text is not measured against the frame.
+ */
+export declare function cutThroughout(report: LayoutReport): CutThroughout[];
+/**
+ * The facts of one moment: overlaps between text blocks (of different
+ * layers, and of the same layer), blocks reaching outside a box they are
+ * drawn inside, text over the face and in the covered edges.
+ */
+export declare function measureMoment(o: {
+    t: number;
+    part: string;
+    texts: MeasuredText[];
+    face?: Box;
+    safe: SafeZone;
+    width: number;
+    height: number;
+    /** Which layer each text belongs to (an index): blocks of one layer and of two are told apart. */
+    owner: number[];
+    /**
+     * Per text, the boxes it is drawn inside, nearest first (absent: none
+     * measured). A block is compared with each in turn, and the nearest it
+     * reaches out of is reported.
+     */
+    containers?: (readonly TextContainer[] | undefined)[];
+    /**
+     * Per text, the box of what shows of its glyphs (MeasuredText.ink; absent:
+     * its box). Blocks of one layer are compared by it, and so is a block
+     * with the boxes it is drawn inside.
+     */
+    seen?: (Box | undefined)[];
+    /**
+     * Per text, the boxes of what shows of its glyphs, one per line, the
+     * frame's own edges not clipping them (absent: its `seen` box, else its
+     * box). The frame's edges are measured against them.
+     */
+    glyphs?: (readonly Box[] | undefined)[];
+}): LayoutMoment;
+/**
+ * How much a footage layer is enlarged over its window, at its largest and
+ * at its smallest: drawn pixels per source pixel, from the part of the
+ * source it shows (its crop, or the reframe window) and the picture it is
+ * drawn as, times its zoom (punch-ins, a pullback) and its box keys (a
+ * key's box against the first box, which places the picture). Measured at
+ * the window's first and last frames and at every key between them: eases
+ * move monotonically from key to key, so the extremes are at those
+ * moments. `outScale` is output pixels per drawn pixel (a small custom
+ * format is drawn larger and scaled down); `fps` puts the last moment on
+ * the window's last frame. Undefined when the source's size is not known.
+ */
+export declare function footageScale(f: Pick<TimelineFootage, "part" | "file" | "start" | "end" | "crop" | "picture" | "zoom" | "boxes" | "fit"> & {
+    source?: {
+        width: number;
+        height: number;
+    };
+}, outScale?: number, fps?: number): FootageScale | undefined;
+/** Rows of the frame, [y0, y1]: from the top edge y0 to the bottom edge y1, in pixels. */
+export type RowSpan = [y0: number, y1: number];
+/** A band across the content box that nothing measured covers. */
+export interface FreeBand {
+    /** Its rows, [top, bottom] edges in pixels. */
+    y: RowSpan;
+    /** Its columns: the content box's, [left, right] edges in pixels. */
+    x: [x0: number, x1: number];
+    /** y1 − y0. */
+    height: number;
+}
+/** The content box of a frame W × H: inside its covered edges, as columns and rows. */
+export declare function contentBox(W: number, H: number, safe: SafeZone): {
+    x: [number, number];
+    y: [number, number];
+};
+/** Spans joined where they overlap or touch, top to bottom; empty spans dropped. */
+export declare function unionSpans(spans: readonly RowSpan[]): RowSpan[];
+/**
+ * The bands of a content box that none of the spans covers, top to
+ * bottom, each the content box's width. No threshold: a band one pixel
+ * high is a band.
+ */
+export declare function freeBands(content: {
+    x: [number, number];
+    y: [number, number];
+}, covered: readonly RowSpan[]): FreeBand[];
+/**
+ * The rows a box covers where it reaches into the columns [x0, x1], rounded
+ * outwards to whole pixels; undefined when it does not reach them.
+ */
+export declare function boxRows(b: Box | PixelRect, x: readonly [number, number]): RowSpan | undefined;
+/** One thing on screen at one frame: a text block, a painted box, a picture. */
+export interface TrackSample {
+    /** Film seconds. */
+    t: number;
+    /** Its box in the frame's pixels; absent while it does not show. */
+    box?: Box;
+    /** 0 while it does not show. */
+    opacity: number;
+}
+/** A thing followed frame by frame through a part. */
+export interface Track {
+    part: string;
+    layer: string;
+    /** What it is: `text "…"`, `box`, or its tag for a picture (`img`, `svg`, `canvas`, `video`). */
+    what: string;
+    /** Where it is in the layer, as a selector. */
+    selector: string;
+    /** Its own `data-ak` name, when it has one (`named(el, name)`). */
+    name?: string;
+    /** One per frame looked at, in order. */
+    samples: TrackSample[];
+}
+/** A thing's largest change between two frames in a row, against the changes beside it. */
+export interface Step {
+    part: string;
+    layer: string;
+    what: string;
+    selector: string;
+    /** `move`: its box's centre and size; `fade`: its opacity. */
+    kind: "move" | "fade";
+    /** Film seconds of the later frame. */
+    t: number;
+    /** Its box before and after (a fade from or to nothing has only one). */
+    from?: Box;
+    to?: Box;
+    /** Pixels its centre moved, and the most a side grew or shrank. */
+    px: number;
+    grew: number;
+    /** Its opacity before and after. */
+    opacity: [before: number, after: number];
+    /**
+     * The same change over the frame before and the frame after, the larger
+     * of the two: a thing gliding has about as much, a thing jumping far
+     * less.
+     */
+    around: number;
+    /** The change less `around`: pixels for a move, opacity for a fade. */
+    over: number;
+}
+/**
+ * Each track's largest step of each kind: where its box moved or changed
+ * size the most over the change beside it, and where its opacity did. A
+ * measurement, not a verdict: a cut inside a layer and a glitch both show
+ * as a large step with little around it. Sorted by `over`, moves and fades
+ * apart (pixels and opacity are not one scale), moves first.
+ */
+export declare function largestSteps(tracks: readonly Track[]): Step[];
+//# sourceMappingURL=measure.d.ts.map