allyhub 0.2.0-next.0 → 0.2.0-next.2

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

@@ -0,0 +1,288 @@
+import type { EditedSpeech } from "./edits.js";
+import type { Word } from "./media.js";
+import { type UnheardSound, type VoiceFrames } from "./voice.js";
+/** A take's noise floor and speech level, dBFS (FilmCraft's percentiles). */
+export interface TakeLevels {
+    /** The 10th percentile of frame levels above −100 dBFS. */
+    floor: number;
+    /** The 95th percentile. */
+    speech: number;
+    /** Speech or silence: 30 % of the way from floor to speech, at least 6 dB above the floor. */
+    threshold: number;
+}
+export declare function takeLevels(frames: Pick<VoiceFrames, "db">): TakeLevels;
+/** A word's level: its loudest and its mean frame, dBFS. */
+export interface WordLevel {
+    peak: number;
+    mean: number;
+}
+export declare function wordLevels(words: readonly Word[], frames: Pick<VoiceFrames, "db" | "hop">): WordLevel[];
+/**
+ * Word bounds moved inward past frames quieter than the take's speech
+ * threshold (takeLevels), so the silence a recognizer puts inside a word
+ * goes back between words; a word keeps at least 60 ms, and a word with no
+ * frame above the threshold is left alone (FilmCraft's tighten_words).
+ * Returns new words and how many moved.
+ */
+export declare function tightenWords(words: readonly Word[], frames: Pick<VoiceFrames, "db" | "hop">): {
+    words: Word[];
+    moved: number;
+};
+/** What a word's length is compared with: a line through the take's own words. */
+export interface SpeakingRate {
+    /** Seconds a word takes whatever its length. */
+    base: number;
+    /** Seconds more for each letter. */
+    perLetter: number;
+    /** Words the line was fitted through. */
+    words: number;
+}
+/** What the measurement inside words uses. */
+export interface WordShapeOptions {
+    /** A frame counts as voiced from this voicing, 0 to 1. */
+    voiced: number;
+    /** A dip is a stretch of frames at least this many dB under the loudest frame on each side of it, inside the word. */
+    dip: number;
+}
+export declare const WORD_SHAPE_DEFAULTS: Readonly<WordShapeOptions>;
+/** A word's length against the take's rate, and the sound inside it. */
+export interface WordShape {
+    /** The word's index in the take's words. */
+    i: number;
+    /** Seconds it lasts. */
+    dur: number;
+    /** The letters its text has (0 for a word written in digits: no length follows from them). */
+    letters: number;
+    /** Seconds a word of this many letters takes by the take's rate; null without a rate or without letters. */
+    expected: number | null;
+    /** `dur` over `expected`. */
+    ratio: number | null;
+    /** `dur` minus `expected`, seconds. */
+    excess: number | null;
+    /** The stretches of voiced frames inside it, seconds of the file. */
+    voicedRuns: {
+        start: number;
+        end: number;
+    }[];
+    /** The dips in level inside it, seconds of the file, and how deep each goes, dB. */
+    dips: {
+        start: number;
+        end: number;
+        depth: number;
+    }[];
+}
+export interface WordShapes {
+    /** The take's rate; null when it has too few words to tell (`rateWhy`). */
+    rate: SpeakingRate | null;
+    rateWhy?: string;
+    options: WordShapeOptions;
+    /** One per word, in order. */
+    words: WordShape[];
+}
+/**
+ * The take's speaking rate: a line through the median length of its words
+ * of each letter count (the medians keep drawn-out words from bending it),
+ * weighted by how many words have that count. Undefined with fewer than
+ * eight words with letters, or when longer words do not last longer.
+ */
+export declare function speakingRate(words: readonly Word[]): SpeakingRate | undefined;
+/**
+ * Every word measured from inside: how long it lasts against what its
+ * letters take at the take's own rate, the stretches of voiced frames in
+ * it and the dips in level between louder frames. Nothing is judged: a
+ * word far over its expected length with two voiced stretches may hold a
+ * filler run into it, or be a word said slowly.
+ */
+export declare function wordShapes(words: readonly Word[], frames: VoiceFrames, opts?: Partial<WordShapeOptions>): WordShapes;
+/** Which words the transcript marks as long. */
+export interface LongWordOptions {
+    /** A word is listed when it lasts at least this many times its expected length… */
+    ratio: number;
+    /** …and at least this many seconds more than it. */
+    excess: number;
+}
+export declare const LONG_WORD_DEFAULTS: Readonly<LongWordOptions>;
+/** The words at least `ratio` times and `excess` seconds over their expected length. Candidates, never cuts. */
+export declare function longWords(shapes: readonly WordShape[], opts?: Partial<LongWordOptions>): WordShape[];
+/** A long word as the transcript marks it: `(long 0.62s ×2.4)`. */
+export declare function longLabel(s: WordShape): string;
+/** Words [from, to] said without a pause as long as the paragraph gap. */
+export interface Paragraph {
+    from: number;
+    to: number;
+    start: number;
+    end: number;
+    text: string;
+}
+/** A paragraph of a take ends at a pause this long, seconds. */
+export declare const PARAGRAPH_GAP = 0.5;
+/** The take's words in paragraphs: a new one after a gap of `gap` seconds or more. */
+export declare function paragraphs(words: readonly Word[], gap?: number, first?: number, last?: number): Paragraph[];
+/** Where a phrase is said: words [from, to] and their times. */
+export interface WordMatch {
+    from: number;
+    to: number;
+    start: number;
+    end: number;
+    text: string;
+}
+/**
+ * Every place the take says `phrase`: case and punctuation ignored, word
+ * by word, the last word of the phrase may be the start of a word
+ * ("manag" finds "manager").
+ */
+export declare function searchWords(words: readonly Word[], phrase: string): WordMatch[];
+/**
+ * Where the take says any of `phrases` (the agent's list: "um", "you
+ * know"), whole words, longer phrases first, never overlapping. A
+ * candidate list: nothing is removed.
+ */
+export declare function phraseMatches(words: readonly Word[], phrases: readonly string[]): (WordMatch & {
+    phrase: string;
+})[];
+/** A pause between two words, and the stretch `keep` seconds of air would remove. */
+export interface PauseCandidate {
+    /** The word before it. */
+    after: number;
+    start: number;
+    end: number;
+    gap: number;
+    /** What `maxPause: keep` cuts: the middle of the pause. */
+    remove: {
+        from: number;
+        to: number;
+        seconds: number;
+    };
+}
+/** Pauses of `min` seconds or more between words [first, last]. A candidate list. */
+export declare function pauseCandidates(words: readonly Word[], min: number, keep: number, first?: number, last?: number): PauseCandidate[];
+/** One side of a join: the kept word nearest the cut, and the sound between them. */
+export interface JoinSide {
+    /** The kept word's index in the take's words. */
+    i: number;
+    text: string;
+    /**
+     * The word's end (before the cut) or start (after it), seconds of the
+     * file; the cut itself when it is inside the word.
+     */
+    edge: number;
+    /** Seconds of the take kept between the word and the cut, by the word times (0 for a cut inside the word). */
+    gap: number;
+    /**
+     * Seconds of 10 ms frames under the quiet level reaching the cut on this
+     * side, inside the kept stretch: the silence the level shows, which may
+     * differ from `gap` when a word's bound is loose. null without levels.
+     */
+    quiet: number | null;
+    /** The loudest frame between the word and the cut, dBFS; null without levels or with no frame between. */
+    peakBetween: number | null;
+    /** The word's loudest and mean frame, dBFS; null without levels. */
+    peak: number | null;
+    mean: number | null;
+    /** The mean level of the word's `near` seconds next to the cut (its end before it, its start after it), dBFS; null without levels. */
+    near: number | null;
+}
+/** Seconds of a word next to a cut whose level `Join.step` compares, when not given. */
+export declare const JOIN_NEAR = 0.2;
+/** Where a cut take jumps from one kept stretch to the next, measured on both sides. */
+export interface Join {
+    /** Seconds of the edited take: where the join plays. */
+    at: number;
+    /** Seconds of the file where the stretch before ends, and where the next one starts. */
+    out: number;
+    in: number;
+    /** The words removed between the two kept words, if any (else a pause shortened or a sound cut). */
+    removed: {
+        from: number;
+        to: number;
+    } | null;
+    /** The cut is inside a kept word on a side (an edits file's `inWord`): no silence there by the word times. */
+    inWord: boolean;
+    before: JoinSide;
+    after: JoinSide;
+    /** `after.near` minus `before.near`, dB: the level step across the join; null without levels. */
+    step: number | null;
+}
+/**
+ * Every join of a cut take, measured: on each side, how much of the take
+ * lies between the kept word and the cut (by word times, and as frames
+ * quieter than `quietDb` by the level), the two words' levels, and the
+ * step between the `near` seconds of each word next to the cut.
+ * Numbers only: whether a join sounds natural is the agent's call.
+ */
+export declare function joinsOf(words: readonly Word[], edited: Pick<EditedSpeech, "ranges" | "kept">, frames: Pick<VoiceFrames, "db" | "hop"> | undefined, quietDb: number, near?: number): Join[];
+/** What counts as scripted, and as a line said. */
+export interface ScriptDiffOptions {
+    /** A word counts as scripted when this share of its letters matched the script exactly (0–1). */
+    match: number;
+    /** A script line counts as said at a place when this share of its letters matched there (0–1). */
+    lineMatch: number;
+}
+export declare const SCRIPT_DIFF_DEFAULTS: Readonly<ScriptDiffOptions>;
+/** A script line, measured against the take. */
+export interface ScriptLine {
+    /** Its index among the script's non-empty lines. */
+    line: number;
+    text: string;
+    /** The share of its letters the take matched exactly, aligned with the whole script (0–1). */
+    share: number;
+    /** Each place the take says it (at least `lineMatch` of its letters there). */
+    matches: WordMatch[];
+}
+/** How a take differs from the script it was read from. Data, not decisions. */
+export interface ScriptDiff {
+    /** The thresholds used. */
+    options: ScriptDiffOptions;
+    /** Stretches of words with less than `match` of their letters matched (ad-libs, fillers, false starts). */
+    unscripted: WordMatch[];
+    /** Script lines the take says more than once, each place it says them. */
+    repeated: {
+        line: number;
+        text: string;
+        matches: WordMatch[];
+    }[];
+    /** Every script line with its match share and the places it is said. */
+    lines: ScriptLine[];
+}
+export declare function scriptDiff(words: readonly Word[], lines: readonly string[], opts?: Partial<ScriptDiffOptions>): ScriptDiff;
+/** What the packed transcript marks. */
+export interface PackOptions {
+    /** A new line after a pause this long, seconds (default PARAGRAPH_GAP). */
+    gap?: number;
+    /** A paragraph goes on to a new line at the first sentence end after this many words (default 12). */
+    lineWords?: number;
+    /** Only words [from, to]. */
+    from?: number;
+    to?: number;
+    /** Sounds heard between words, shown where they are. */
+    sounds?: readonly UnheardSound[];
+    /** Word indices an edits file removes: shown struck, [-like this-]. */
+    removed?: ReadonlySet<number>;
+    /** Sound stretches an edits file removes. */
+    removedSounds?: readonly {
+        from: number;
+        to: number;
+    }[];
+    /** Stretches an edits file cuts inside kept words: shown after the word, `(cut 61.31–61.62 in word)`. */
+    inWord?: readonly {
+        from: number;
+        to: number;
+    }[];
+    /** Words to mark as long, by index: shown after the word, `(long 0.62s ×2.4)`. */
+    long?: ReadonlyMap<number, WordShape>;
+    /** Words no script matched: shown {like this}. */
+    unscripted?: ReadonlySet<number>;
+}
+/** A line of the packed transcript ends at the first sentence end after this many words. */
+export declare const LINE_WORDS = 12;
+/** A sound as the transcript shows it: `(sound 61.17–61.40 0.23s −9dB v0.87)`. */
+export declare function soundLabel(s: UnheardSound, removed?: boolean): string;
+/**
+ * The take as lines an agent plans cuts from: one per paragraph,
+ * `[012.40-015.10] #57-#71 text…`, word indices where they matter, the
+ * sounds between words inline with their stretch, level against speech
+ * and voicing; after a word, that it is long for the take's rate, and a
+ * stretch an edits file cuts inside it.
+ */
+export declare function packTranscript(words: readonly Word[], opts?: PackOptions): string[];
+//# sourceMappingURL=transcript.d.ts.map

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

@@ -0,0 +1,289 @@
+import { type Ease, type ScalarKey } from "./motion.js";
+import type { Part, TimelineFootage } from "./timeline.js";
+export declare const TRANSITION_TYPES: readonly ["fade", "dip", "slide", "push", "wipe", "zoom", "custom"];
+export type TransitionType = (typeof TRANSITION_TYPES)[number];
+/** The way a slide, a push or a wipe travels. */
+export declare const DIRECTIONS: readonly ["left", "right", "up", "down"];
+export type Direction = (typeof DIRECTIONS)[number];
+/** What a transition gets when it does not say. */
+export declare const TRANSITION_DEFAULTS: {
+    /** Seconds the window lasts. */
+    readonly dur: 0.4;
+    /** The share of the window before the join. */
+    readonly split: 0.5;
+    /** Where a slide, a push or a wipe travels. */
+    readonly direction: "left";
+    /** zoom: how large the outgoing picture grows. */
+    readonly scale: 1.2;
+};
+/** The longest a transition may last, seconds. */
+export declare const TRANSITION_MAX_DUR = 10;
+/** The easing a type gets when it gives none: moves ease in and out, fades run evenly. */
+export declare function transitionEase(type: TransitionType): Ease;
+/**
+ * A channel of a custom transition over the progress (0 at the window's
+ * start, 1 at its end): a number that holds, `[from, to]`, or keys
+ * `[{ p, v }]` in order of p, linear between them.
+ */
+export type TransitionChannel = number | [from: number, to: number] | {
+    p: number;
+    v: number;
+}[];
+/** What a custom transition does to one of the two pictures. */
+export interface TransitionPicture {
+    /** Moved right by this share of the frame's width (−1: a frame to the left); default 0. */
+    x?: TransitionChannel;
+    /** Moved down by this share of the frame's height; default 0. */
+    y?: TransitionChannel;
+    /** Scaled about the frame's centre; default 1. */
+    scale?: TransitionChannel;
+    /** 0 (gone) to 1; default 1. */
+    opacity?: TransitionChannel;
+    /** This share of the picture cut off at each edge, 0 to 1; default 0. */
+    clip?: {
+        left?: TransitionChannel;
+        right?: TransitionChannel;
+        top?: TransitionChannel;
+        bottom?: TransitionChannel;
+    };
+}
+interface TransitionCommon {
+    /** Seconds the window lasts; default 0.4. */
+    dur?: number;
+    /**
+     * How the progress runs; default "linear" for fade, dip and custom,
+     * "in-out" for slide, push, wipe and zoom.
+     */
+    ease?: Ease;
+    /**
+     * The share of the window before the join, 0 to 1; default 0.5. With 1
+     * the whole window is the end of the part before (this part holds its
+     * first frame until its own time starts), with 0 the start of this part.
+     */
+    split?: number;
+}
+/** How a part comes in from the part before it. */
+export type TransitionSpec = 
+/** A crossfade. */
+(TransitionCommon & {
+    type: "fade";
+})
+/**
+ * Through a colour: the part before fades to it, this part fades in
+ * from it. Any CSS colour; default the look's background.
+ */
+ | (TransitionCommon & {
+    type: "dip";
+    color?: string;
+})
+/**
+ * slide: this part's picture travels in over the part before, which
+ * stays. push: it pushes the part before out, both travelling. wipe: an
+ * edge travels across and uncovers it, neither picture moving.
+ * `direction` is the way it travels; default "left".
+ */
+ | (TransitionCommon & {
+    type: "slide" | "push" | "wipe";
+    direction?: Direction;
+})
+/**
+ * The part before grows to `scale` (default 1.2) while this part fades
+ * in over it, settling from `from` to its size: `from` is `scale` by
+ * default (both pictures always fill the frame); under 1 it grows in
+ * instead, the part before showing round it.
+ */
+ | (TransitionCommon & {
+    type: "zoom";
+    scale?: number;
+    from?: number;
+})
+/**
+ * The channels given directly: `out` for the part before, `in` for this
+ * part (over it), and a colour between them with an opacity channel.
+ */
+ | (TransitionCommon & {
+    type: "custom";
+    out?: TransitionPicture;
+    in?: TransitionPicture;
+    color?: {
+        value?: string;
+        opacity: TransitionChannel;
+    };
+});
+/** What `part({ transition })` takes: a type's name, or a type with its options. */
+export type TransitionInput = Exclude<TransitionType, "custom"> | TransitionSpec;
+/** What is wrong with a `transition` value, or undefined when it is one. */
+export declare function transitionProblem(v: unknown): string | undefined;
+/** A transition as an object: a type's name becomes `{ type }`. */
+export declare function transitionSpec(input: TransitionInput): TransitionSpec;
+/** Channels over the progress: `t` is the progress, linear between keys. */
+export type ProgressKeys = ScalarKey[];
+/** The channels of one picture that are not at rest (absent: 0, or 1 for scale and opacity). */
+export interface PictureKeys {
+    x?: ProgressKeys;
+    y?: ProgressKeys;
+    scale?: ProgressKeys;
+    opacity?: ProgressKeys;
+    left?: ProgressKeys;
+    right?: ProgressKeys;
+    top?: ProgressKeys;
+    bottom?: ProgressKeys;
+}
+/** A transition resolved to channels: what the render, stills and the preview draw from. */
+export interface TransitionKeys {
+    /** The outgoing part's picture. */
+    out: PictureKeys;
+    /** The incoming part's picture, drawn over it. */
+    in: PictureKeys;
+    /** A plain colour between the two ("#rrggbb" or "#rrggbbaa"). */
+    color?: {
+        value: string;
+        opacity: ProgressKeys;
+    };
+    /**
+     * A dissolve of pictures that may be see-through (a transparent video):
+     * the two are added, the outgoing one weighted by 1 − the incoming
+     * one's opacity, instead of one drawn over the other.
+     */
+    add?: true;
+}
+/**
+ * A transition's channels. `transparent`: the video has no background, so
+ * a fade is a true dissolve (`add`). `background` is the look's background
+ * as the timeline carries it; `color` the transition's own colour,
+ * resolved the same way, when it gives one.
+ */
+export declare function transitionKeys(spec: TransitionSpec, o: {
+    transparent: boolean;
+    background: string;
+    color?: string;
+}): TransitionKeys;
+/** A transition on the film's clock, as the timeline carries it. */
+export interface TimelineTransition {
+    /** The incoming part's key (the part that asked for it). */
+    part: string;
+    /** The outgoing part's key. */
+    from: string;
+    type: TransitionType;
+    /**
+     * Film seconds of the window, [start, end) on the frame grid, and of the
+     * join inside it (the incoming part's start).
+     */
+    start: number;
+    at: number;
+    end: number;
+    ease: Ease;
+    /** What it does to the two pictures. */
+    keys: TransitionKeys;
+    /** Seconds it asked for (the window is shorter when a part is short). */
+    dur: number;
+    /** As asked, for people: a slide's, push's or wipe's direction, a zoom's scale. */
+    direction?: Direction;
+    scale?: number;
+}
+/**
+ * A window's frames either side of the join: `dur` on the frame grid (at
+ * least one frame), `split` of it before; at most half of either part, so
+ * two windows never meet inside a part.
+ */
+export declare function transitionWindow(spec: Pick<TransitionCommon, "dur" | "split">, fps: number, outFrames: number, inFrames: number): {
+    before: number;
+    after: number;
+};
+/** A window in film frames: its first frame, how many, and the join's frame. */
+export declare function windowFrames(tr: Pick<TimelineTransition, "start" | "end" | "at">, fps: number): {
+    first: number;
+    frames: number;
+    join: number;
+};
+/** The transition whose window holds film time t. */
+export declare function transitionAt<T extends Pick<TimelineTransition, "start" | "end">>(transitions: readonly T[] | undefined, t: number, fps: number): T | undefined;
+/**
+ * The progress before easing at frame `i` of a window of `frames`: the
+ * frames split the way evenly, so the frame before the window is 0, the
+ * one after it 1, and a window of one frame shows the middle.
+ */
+export declare const rawProgress: (i: number, frames: number) => number;
+/** The eased progress of a transition at film frame `frame`. */
+export declare function progressAt(tr: Pick<TimelineTransition, "start" | "end" | "at" | "ease">, frame: number, fps: number): number;
+/** One picture at a moment of a transition. */
+export interface PictureState {
+    /** Moved by these shares of the frame's width and height. */
+    x: number;
+    y: number;
+    /** Scaled about the frame's centre. */
+    scale: number;
+    opacity: number;
+    /** The share cut off at each edge. */
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface TransitionState {
+    out: PictureState;
+    in: PictureState;
+    color?: {
+        value: string;
+        opacity: number;
+    };
+    /** The two are added (TransitionKeys.add); `out.opacity` is then its weight. */
+    add: boolean;
+}
+/** A picture's channels at progress p. */
+export declare function pictureAt(keys: PictureKeys, p: number): PictureState;
+/** Both pictures and the colour at (eased) progress p. */
+export declare function stateAt(keys: TransitionKeys, p: number): TransitionState;
+/** A transition's state at film frame `frame`. */
+export declare function transitionState(tr: TimelineTransition, frame: number, fps: number): TransitionState;
+/** A picture's place in whole pixels, as the render and the preview both round it. */
+export declare function pictureOffset(s: Pick<PictureState, "x" | "y">, width: number, height: number): [x: number, y: number];
+/**
+ * A picture's state as CSS on an element the size of the frame
+ * (transform-origin at its centre): what the preview sets on a part.
+ */
+export declare function pictureCss(s: PictureState, width: number, height: number): {
+    transform: string;
+    opacity: string;
+    clipPath: string;
+};
+/**
+ * The eased progress as an ffmpeg expression of `n`, a frame counter that
+ * is 0 at frame `offset` of a window of `frames` frames (progressAt, for
+ * a filter that counts its own frames).
+ */
+export declare function progressExpr(ease: Ease, frames: number, n: string, offset?: number): string;
+/**
+ * A channel as an ffmpeg expression of the progress expression `p` (the
+ * value pictureAt gives): a number when it never changes.
+ */
+export declare function channelExpr(keys: ProgressKeys | undefined, rest: number, p: string): string;
+/** Whether a channel is there and moves, or rests somewhere other than `rest`. */
+export declare const channelActive: (keys: ProgressKeys | undefined, rest: number) => keys is ProgressKeys;
+/** The lowest value a channel takes (its keys are linear in between). */
+export declare const channelMin: (keys: ProgressKeys | undefined, rest: number) => number;
+/**
+ * The film time a part's graphics are drawn at when the film is at frame
+ * time t: t inside the part's own time, else its first or its last frame,
+ * which holds through a transition's window.
+ */
+export declare function heldTime(part: Pick<Part, "start" | "end">, t: number, fps: number): number;
+/**
+ * A footage layer shown from `start` until `end` instead of its own
+ * window, playing on in its file: before its start it plays what comes
+ * before in the file (a cut take: before its first stretch, as far as the
+ * file goes), after its end what comes after. Where the file has no more,
+ * a frame holds.
+ */
+export declare function extendFootage<F extends TimelineFootage>(f: F, start: number, end: number): F;
+/**
+ * The footage with handles: a layer showing at its part's last frame runs
+ * on through the window of the transition out of the part, and one
+ * showing at its part's first frame starts at the start of the window into
+ * it. Layers no window touches are returned as they are.
+ */
+export declare function withHandles<F extends TimelineFootage>(footage: readonly F[], parts: readonly Pick<Part, "key" | "start" | "end">[], transitions: readonly TimelineTransition[] | undefined, fps: number): F[];
+/** A transition in a few words, for people: "push up 0.5 s". */
+export declare function transitionLabel(tr: TimelineTransition): string;
+export {};
+//# sourceMappingURL=transition.d.ts.map