allyhub 0.5.0 → 0.7.0

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

@@ -1,151 +0,0 @@
-import type { Mastered } from "@allyhub-next/audio/node";
-import { type EncodeOptions, type VideoType } from "./encode.js";
-import type { GraphicsPage, ProjectMedia, RenderTarget, VideoLook } from "./page.js";
-import { PartCache, type PieceCode } from "./parts.js";
-import { type SoundInput } from "./sound.js";
-import { type Tools } from "./tools.js";
-export interface RenderOptions extends Tools {
-    /** The output rendered. */
-    target: RenderTarget;
-    /** Its options that change the picture: transparency, motion blur, the camera's marks, post. */
-    look: VideoLook;
-    /** The project's media: its footage, mattes and LUT. */
-    media: ProjectMedia;
-    /**
-     * Pages holding the output, drawing its graphics plane (at least one);
-     * the first one's timeline is the one rendered. The caller opens and
-     * closes them.
-     */
-    pages: readonly GraphicsPage[];
-    /**
-     * Opens another page of the same output, when more would draw the
-     * frames faster (up to `workers`); the render closes the pages it
-     * opened. Absent: it draws with `pages` alone.
-     */
-    openPage?: () => Promise<GraphicsPage>;
-    /** The sound muxed in; absent: a file without sound. A gif has none. */
-    sound?: SoundInput;
-    out: string;
-    /** The file type; default mp4. */
-    type?: VideoType;
-    encode?: EncodeOptions;
-    /** 0–1 */
-    onProgress?: (progress: number) => void;
-    /**
-     * Pages drawing the graphics plane, shared by the parts rendered at
-     * once; default from the CPUs and length (autoWorkers). How many parts
-     * render at once is partsAtOnce's.
-     */
-    workers?: number;
-    /** What the build knows of the piece's code: without it, nothing is kept in the part cache. */
-    code?: PieceCode;
-    /**
-     * The part cache (default: the project's, .allyhub/cache/parts/); false
-     * renders every part again and keeps nothing.
-     */
-    partCache?: PartCache | false;
-    /** Aborting it stops the render: its pages and ffmpeg runs, and no part of its file stays. */
-    signal?: AbortSignal;
-}
-/** Where one part's time went (RenderTimings.part), in seconds. */
-export interface PartTimings {
-    /** The part's key; a junction's is `<outgoing>><incoming>`. */
-    key: string;
-    /** A transition's window between two parts. */
-    junction?: true;
-    frames: number;
-    /** The part cache had its segment. */
-    cached: boolean;
-    /** Graphics images sent to ffmpeg (frames × motion blur samples × planes); 0 without graphics. */
-    images: number;
-    /** Images a page captured. */
-    captured: number;
-    /** Images whose DOM was the same as one captured already. */
-    reused: number;
-    /** Images where no graphic layer shows: the cached transparent PNG. */
-    clear: number;
-    /** Seconds pages spent seeking and capturing its images, summed over pages. */
-    capture: number;
-    /** Seconds from its ffmpeg's start to its exit. */
-    ffmpeg: number;
-    /** Seconds ffmpeg's input waited for the next image from the pages. */
-    waitFrames: number;
-    /** Seconds the pages' images waited for ffmpeg to take them (the pipe full). */
-    waitPipe: number;
-    /**
-     * Its video overran the bitrate cap: the file kept is the one the
-     * encoder that held the cap made of the same frames (on one thread,
-     * beside the encoder without the cap, in the same run).
-     */
-    held?: true;
-    /**
-     * A part drawn by code the part cache cannot see into: keyed by what its
-     * frames draw ("frames"), or, where a frame shows what its signature
-     * cannot say, by the piece's whole bundle, with why ("bundle: …").
-     */
-    keyed?: string;
-    /** When it started and ended, in seconds from the render's start. */
-    start: number;
-    end: number;
-}
-/**
- * Where a render's time went, in seconds (RenderResult.timings;
- * allyhub render --json prints it with ALLYHUB_RENDER_TIMINGS=1).
- */
-export interface RenderTimings {
-    /** Opening the pages the render opened (RenderOptions.openPage). */
-    pages: number;
-    /** Pages drawing the graphics plane, and parts rendered at once. */
-    workers: number;
-    concurrency: number;
-    /** Probing the footage, the part digests and the cache lookups. */
-    plan: number;
-    /** From the first part's start to the last part's end. */
-    parts: number;
-    /** Mixing and mastering the sound (it may run alongside the parts). */
-    mix: number;
-    /** Joining the segments and adding the sound (gif: the palette pass; png: copying). */
-    mux: number;
-    /** Segments encoded again so the cap holds across the joins (mp4 with a cap). */
-    capped?: number;
-    /**
-     * Signing the frames of the parts drawn by code the part cache cannot
-     * see into (a custom() layer, a scenery), which it keys them by.
-     */
-    signs?: number;
-    total: number;
-    part: PartTimings[];
-}
-export interface RenderResult {
-    out: string;
-    frames: number;
-    duration: number;
-    bytes: number;
-    /**
-     * The sound as written, measured: integrated loudness (LUFS), its range
-     * (LU) and true peak (dBTP). Absent for a silent film or a gif.
-     */
-    loudness?: {
-        integrated: number;
-        range?: number;
-        truePeak?: number;
-    };
-    /** What the master did: its gain and what its limiter took, dB, and its targets. */
-    master?: Omit<Mastered, "loudness">;
-    /** Every file written, when there are several (a PNG sequence). */
-    files?: string[];
-    /** Its parts: how many, and how many came from the part cache. */
-    parts: {
-        total: number;
-        cached: number;
-    };
-    /** Its transitions' windows, when it has any: how many, and how many came from the cache. */
-    junctions?: {
-        total: number;
-        cached: number;
-    };
-    timings: RenderTimings;
-}
-/** allyhub render's video file types: mp4, mov, webm, gif and PNG frames. */
-export declare function renderVideo(opts: RenderOptions): Promise<RenderResult>;
-//# sourceMappingURL=render.d.ts.map

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

@@ -1,40 +0,0 @@
-import { type Timeline, type TimelineTransition } from "@allyhub-next/video-core";
-export type TimelinePart = Timeline["parts"][number];
-/**
- * A stretch of the film encoded in one run: a part, less the frames its
- * transitions cover, or a transition's window (a junction).
- */
-export interface Segment {
-    /** The film frames it encodes: [first, first + frames). */
-    first: number;
-    frames: number;
-    /** The part; a junction's incoming part. */
-    part: TimelinePart;
-    /** A junction: the transition, and the part it comes from. */
-    junction?: {
-        transition: TimelineTransition;
-        from: TimelinePart;
-    };
-    /**
-     * How many of its frames the film shows, from its first: fewer than
-     * `frames` when the next part's transition takes its last ones, which
-     * are dropped at the join.
-     */
-    keep: number;
-    /**
-     * A part: the frames a transition took from its start, and the ones
-     * left out of the encode at its end (the part cache's key has both).
-     */
-    trim: {
-        head: number;
-        tail: number;
-    };
-}
-/**
- * The film cut at its parts' frame boundaries and at its transitions'
- * windows, in film order. `dropTail`: the segments are joined by copying,
- * and a segment's last frames can be dropped there; else a part is encoded
- * without the frames the next transition takes.
- */
-export declare function segmentsOf(timeline: Timeline, dropTail: boolean): Segment[];
-//# sourceMappingURL=segments.d.ts.map

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

@@ -1,24 +0,0 @@
-import { type MasterTargets, type MixPlan } from "@allyhub-next/audio";
-import { type Mastered, type MixSources } from "@allyhub-next/audio/node";
-import type { Timeline } from "@allyhub-next/video-core";
-import { type Tools } from "./tools.js";
-/** The sound a render muxes: the plan, where its files are, and what it is mastered to. */
-export interface SoundInput {
-    plan: MixPlan;
-    sources: MixSources;
-    /** Default: the timeline's own targets, else the platform profile's loudness over the defaults. */
-    master?: MasterTargets;
-}
-/** The targets a timeline's sound is mastered to when none are given. */
-export declare const masterOf: (timeline: Timeline) => MasterTargets;
-/**
- * The sound of a timeline mastered and padded to exactly its frames,
- * written as a 48 kHz WAV at `out`. Needs no frames, so a command can hear
- * an output without rendering it.
- */
-export declare function mixSound(o: Tools & {
-    timeline: Timeline;
-    sound: SoundInput;
-    out: string;
-}): Promise<Mastered>;
-//# sourceMappingURL=sound.d.ts.map

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

@@ -1,41 +0,0 @@
-import { type Timeline } from "@allyhub-next/video-core";
-import { type StillFormat } from "./composite.js";
-import type { GraphicsPage, ProjectMedia, RenderTarget, VideoLook } from "./page.js";
-import { type Tools } from "./tools.js";
-export interface StillOptions extends Tools {
-    /** The output the page holds. */
-    target: RenderTarget;
-    /** Its options that change the picture. */
-    look: VideoLook;
-    /** The project's media: its footage, mattes and LUT. */
-    media: ProjectMedia;
-    /** Without motion blur, the camera's marks, the post filter and the LUT. */
-    raw?: boolean;
-    /** PNG (default), JPEG, or a WebP to look at (`lookFormat`). */
-    format?: StillFormat;
-}
-/**
- * One moment as the render shows it: the footage plane and the graphics
- * plane composited by ffmpeg, as in a render, with motion blur's samples
- * averaged, then the post filter and the LUT, keeping the alpha of a
- * transparent output (PNG). `raw` leaves out blur, post and LUT. The page
- * draws the graphics plane alone, as a render's does.
- */
-export declare function finalStill(page: GraphicsPage, t: number, opts: StillOptions): Promise<Buffer>;
-/**
- * The footage plane alone at a moment (the background and any footage),
- * or undefined when only the background shows there.
- */
-export declare function footageStill(media: ProjectMedia, timeline: Timeline, t: number, format?: "png" | "jpeg", o?: Tools): Promise<Buffer | undefined>;
-/**
- * Graphics drawn over the background only (no footage): a cover, whose
- * graphic layers the page drew outside the film's clock.
- */
-export declare function backgroundStill(timeline: Timeline, graphics: Buffer, format?: "png" | "jpeg", o?: Tools): Promise<Buffer>;
-/**
- * Frame n of a video file (the one showing n / fps) as a PNG (or in
- * `format`: a WebP to look at, encoded as it is decoded). The seek lands
- * half a frame early, so frame n is the first one decoded past it.
- */
-export declare function videoFrame(file: string, n: number, fps: number, format?: StillFormat, o?: Tools): Promise<Buffer>;
-//# sourceMappingURL=stills.d.ts.map

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

@@ -1,25 +0,0 @@
-import { ffmpegOf } from "@allyhub-next/audio/node";
-/** Which programs to run; each absent is the pinned one, fetched when first needed. */
-export interface Tools {
-    ffmpeg?: string | undefined;
-    ffprobe?: string | undefined;
-}
-export { ffmpegOf };
-/** The ffprobe to run: the one named, else the pinned build's. */
-export declare function ffprobeOf(o?: Tools): Promise<string>;
-/** Both programs, resolved. */
-export declare function toolsOf(o?: Tools): Promise<{
-    ffmpeg: string;
-    ffprobe: string;
-}>;
-/**
- * Runs ffmpeg, feeding stdin when asked; resolves with stdout (when kept)
- * and stderr. Aborting the signal stops it outright.
- */
-export declare function runFfmpegWith(ffmpeg: string, args: string[], input?: (stdin: NodeJS.WritableStream) => Promise<void>, keepOut?: boolean, signal?: AbortSignal): Promise<{
-    out: Buffer;
-    err: string;
-}>;
-/** Writes a chunk, waiting while the pipe is full. */
-export declare const write: (stream: NodeJS.WritableStream, chunk: Buffer) => Promise<void>;
-//# sourceMappingURL=tools.d.ts.map

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

@@ -1,17 +0,0 @@
-import { type Tools } from "./tools.js";
-/** How a picture to look at is encoded where it is made: WebP, or a PNG in the tests' exact pictures. */
-export declare const lookFormat: () => "webp" | "png";
-/** A WebP's quality: lossy at 0–100, or every pixel kept. */
-export type WebpQuality = number | "lossless";
-/**
- * Pixels worked out in Node, as a PNG, made a WebP to look at: lossy at
- * `quality` (0–100), or every pixel kept with "lossless". The PNG itself
- * in the tests' exact pictures.
- */
-export declare function webp(png: Buffer, quality?: WebpQuality, o?: Tools): Promise<Buffer>;
-/**
- * Where a picture to look at goes: `path` ending in `.webp`, in place of
- * the extension it had (`path` itself in the tests' exact pictures).
- */
-export declare const webpPath: (path: string) => string;
-//# sourceMappingURL=webp.d.ts.map

package/dist/node_modules/@allyhub-next/runtime/dist/bridge.d.ts

@@ -1,211 +0,0 @@
-import type { NoteShape } from "@allyhub-next/formats";
-import type { LocatedLayer } from "./locate.js";
-import type { MixPlan } from "@allyhub-next/audio";
-import type { BuildSource, CaptionLine, CaptionOptions, ConsoleLog, CoverInfo, Fact, LayerAnswer, LayerQueries, LayoutReport, LoadOptions, MediaInfo, PageObjects, PartText, Problem, Reads, TextInk, Timeline, Track, Word } from "@allyhub-next/video-core";
-import type { SayNeed } from "./speech.js";
-export type { SayNeed };
-/** How a moment is drawn: for its picture, or for its layout alone (nothing reads its pixels). */
-export type DrawMode = "picture" | "layout";
-export interface DrawOptions {
-    /** Default "picture". `ctx.layoutOnly` is true for a "layout" draw. */
-    mode?: DrawMode;
-    /**
-     * Seconds after the frame's moment, under one frame: the sub-frame
-     * samples of motion blur. The frame's seed is kept.
-     */
-    offset?: number;
-    /** Only the graphic layers of this plane of the part (Part.planes). */
-    plane?: number;
-    /**
-     * This part alone, as a cut would show it, held at its first or last
-     * frame outside its own time: a render composites the two parts of a
-     * transition itself. Without it, inside a transition's window both
-     * parts are drawn, placed as the transition has them.
-     */
-    part?: string;
-}
-/** LoadedOutput.partSignature's answer. */
-export type PartSignature = {
-    sign: string;
-    owners: string[];
-    unknown?: undefined;
-} | {
-    unknown: string;
-};
-/** One output of one piece in one combo, ready to draw frame by frame. */
-export interface LoadedOutput {
-    readonly kind: "video" | "slides";
-    /** The film's plan; after ready() it has the parts' titles. */
-    readonly timeline: Timeline;
-    /** Fonts and media loaded and decoded; every layer mounted; every still drawn. */
-    ready(): Promise<void>;
-    /** Draws moment t (film seconds), on the frame grid; the picture is settled when it returns. */
-    seek(t: number, options?: DrawOptions): Promise<void>;
-    /** The words said in it, on its film clock, as its captions have them. */
-    words(): Word[];
-    /** Its caption lines on its film clock: each part's line as shown and as said, with its words. */
-    lines(): CaptionLine[];
-    /** The options its first layer that read its captions asked (ctx.captions), which its subtitles follow; null when none did. */
-    captionOptions(): CaptionOptions | null;
-    /** The player plays or pauses: footage plays along. */
-    setPlaying(on: boolean): void;
-    text(): PartText[];
-    reads(): Reads;
-    /**
-     * Every problem so far, for the page's whole life: loading's, and what
-     * went wrong at any moment drawn since (a layer that throws, work that
-     * fails or never settles, a picture that does not load).
-     */
-    problems(): Problem[];
-    /** The AK-P003 of the last seek, when that moment did not finish drawing. */
-    stuck(): string | undefined;
-    /** The longest one moment may take to draw, seconds (video({ seekLimit })). */
-    readonly seekLimit: number;
-    /**
-     * What loading found that is a fact, not a problem: layers drawn their
-     * fallback way (a face track, matte or take missing). The layout's facts
-     * come from measure().
-     */
-    facts(): Fact[];
-    /** The parts that say text through `say`, and the file each needs. */
-    says(): SayNeed[];
-    /**
-     * Each part's identity, by key: what its graphics are drawn from (layers,
-     * props, windows, words, what it read while mounting and at its still,
-     * the look, the format, its length in frames), as JSON. The host adds
-     * the footage and the code, and renders a part once per identity.
-     */
-    signs(): Record<string, string>;
-    /** Its sound as a plan, which @allyhub-next/audio renders (the player's and the export's). */
-    mixPlan(): MixPlan;
-    covers(): CoverInfo[];
-    drawCover(n: number): Promise<void>;
-    /**
-     * Measurements for the check's facts and allyhub inspect: at each moment
-     * (film seconds; default every part's still, the middle of every graphic
-     * layer's window and of every caption cue, and every second where the
-     * speaker shows, at most 24 a part) the text blocks on screen and what
-     * they overlap (each other, the face, the covered edges); and how much
-     * each footage layer is enlarged. Facts, no judgement.
-     */
-    measure(times?: readonly number[]): Promise<LayoutReport>;
-    /**
-     * Everything on screen followed frame by frame from `from` to `to` (film
-     * seconds): each part alone, its text blocks, painted boxes and pictures,
-     * with their box and opacity at every frame.
-     */
-    tracks(from: number, to: number): Promise<Track[]>;
-    /**
-     * The text blocks on screen at `t` (film seconds; each part drawn where
-     * it rests), each line's glyph box with the colour its glyphs are
-     * filled with: what the text-contrast fact measures the pixels behind
-     * them against.
-     */
-    inks(t: number): Promise<TextInk[]>;
-    /** A deck as it was drawn (@allyhub-next/slides-core's DrawnDeck): what its PowerPoint file is written from. Absent on a video. */
-    deck?(): unknown;
-    /** A deck's editor's command (@allyhub-next/slides-runtime's DeckEditCommand): a shape drawn at a frame, its text typed in place, what is typed posted back. Absent on a video. */
-    edit?(command: unknown, post: (message: unknown) => void): void;
-    /** What moment t shows that an editor lets a person point at: placed elements and text blocks with their message keys. */
-    objects(t: number): Promise<PageObjects>;
-    /**
-     * What the stage shows after the last seek, as a short string: two
-     * moments with the same signature draw the same pixels, so a render
-     * captures the frame once. Parts hidden at that moment are left out.
-     * Undefined when what shows holds something the DOM does not describe
-     * (a canvas, a video, an iframe, a GIF).
-     */
-    signature(): string | undefined;
-    /**
-     * The signature of moment t (film seconds), drawn for its layout alone:
-     * what signature() would say after seek(t), without painting what no
-     * signature reads. The stage's pixels are then not t's until the next
-     * seek.
-     */
-    signatureAt(t: number): Promise<string | undefined>;
-    /**
-     * What part `key` draws at each of `times` (film seconds), for the part
-     * cache, which keys a part drawn by code it cannot see into (a custom()
-     * layer, a scenery, a component of the piece's own file) by it: each
-     * moment drawn for its layout alone, the part alone, and what shows of
-     * the stage's DOM hashed with SHA-256, a hash of them all. A canvas in
-     * it says what it draws (data-ak-sign: a scenery's), or is said by the
-     * layer that drew it and that layer's own time, its code named in
-     * `owners`: a component's name, or "custom@" and the file that wrote a
-     * custom() layer's part. `unknown` says why there is no signature: a
-     * moment shows a video, an iframe, a GIF or a canvas outside any layer.
-     */
-    partSignature(key: string, times: readonly number[]): Promise<PartSignature>;
-    /**
-     * Asks every layer that answers `name` (StageContext.answer), in film
-     * order: each answer with the part and layer it came from.
-     */
-    ask<K extends keyof LayerQueries>(name: K, args: LayerQueries[K]["args"]): Promise<LayerAnswer<LayerQueries[K]["answer"]>[]>;
-    dispose(): void;
-}
-/** What a host reads once, after a load and its ready(). */
-export interface LoadedSummary {
-    kind: "video" | "slides";
-    timeline: Timeline;
-    problems: Problem[];
-    facts: Fact[];
-    reads: Reads;
-    text: PartText[];
-    says: SayNeed[];
-    signs: Record<string, string>;
-    covers: CoverInfo[];
-    /** Seconds (LoadedOutput.seekLimit). */
-    seekLimit: number;
-}
-/**
- * Why a piece cannot load at all. The page rejects with an Error named
- * "LoadFailure" whose message is `<code>: <text>`.
- */
-export interface LoadFailureInfo {
-    code: string;
-    text: string;
-}
-/** The one global the runtime's bundle installs. */
-export interface StageBridge {
-    /** Loads one piece and readies it. Rejects with a LoadFailure when the piece cannot load at all. */
-    load(source: BuildSource, options: LoadOptions): Promise<LoadedSummary>;
-    /** The output loaded last; every call below is on it. */
-    readonly output: LoadedOutput | undefined;
-    /** What piece code printed since the last load began. */
-    console(): ConsoleLog;
-    /**
-     * Plays the output loaded last in real time, in this page (a preview's
-     * stage): its sound the export's mix, its controls drawn unless asked
-     * not to; the page that embeds it drives it with `command`.
-     */
-    play(options: PlayOptions): Promise<PlayControl>;
-    /** What a person's mark is on, in shares of the stage. */
-    locate(mark: NoteShape): LocatedLayer[];
-}
-/** What `play` takes: the player's options but the output and the stage, which are the page's. */
-export interface PlayOptions {
-    /** The project's media by path, as the stage sees them (with loudness). */
-    media?: Readonly<Record<string, MediaInfo>>;
-    /** Seeds the synthesized sounds like the export: piece:output:seed key. */
-    seed?: string;
-    /** Where to start, seconds. */
-    start?: number;
-    /** Tells the embedding page what happens (the player's events, as JSON). */
-    post?: (event: unknown) => void;
-    /** false: no control bar (the embedding page draws its own). */
-    chrome?: boolean;
-}
-/** A playing output, driven by the page that embeds it. */
-export interface PlayControl {
-    /** play, pause, seek, mode, next, prev, captions (the player's PlayerCommand). */
-    command(command: {
-        type: string;
-        [key: string]: unknown;
-    }): void;
-}
-declare global {
-    interface Window {
-        allyhub: StageBridge;
-    }
-}
-//# sourceMappingURL=bridge.d.ts.map

package/dist/node_modules/@allyhub-next/runtime/dist/captions.d.ts

@@ -1,24 +0,0 @@
-import { type CaptionLine, type CaptionOptions, type CaptionTrackCue, type Word, type WordCue } from "@allyhub-next/video-core";
-import type { FilmClock } from "./clock.js";
-import type { Takes } from "./takes.js";
-export interface CaptionTrack {
-    /** Every voiced part's line with its words on the film's clock. */
-    readonly lines: readonly CaptionLine[];
-    /** The options the first layer that read its captions asked (ctx.captions), the subtitles' too. */
-    readonly asked: CaptionOptions | undefined;
-    /** The cues of the whole film for these options (cached by them). */
-    cues(o?: CaptionOptions): WordCue[];
-    /**
-     * The cues heard over a part's picture, on its own clock; with `edges`
-     * its first cue from its start and its last to its end.
-     */
-    partCues(start: number, end: number, o?: CaptionOptions): readonly CaptionTrackCue[];
-    /** Part `key`'s words on its own clock (seconds from its start). */
-    partWords(key: string): readonly Word[];
-    /** Where the word starting at part time `a` of part `key` ends (a punch-in held for its word). */
-    wordEnd(key: string, a: number): number;
-}
-/** No words: a deck's pages. */
-export declare function noCaptions(): CaptionTrack;
-export declare function captionTrack(takes: Takes, film: FilmClock, fps: number): CaptionTrack;
-//# sourceMappingURL=captions.d.ts.map

package/dist/node_modules/@allyhub-next/runtime/dist/clock.d.ts

@@ -1,32 +0,0 @@
-import { type PartAnchor, type SoundMoment, type Timing } from "@allyhub-next/video-core";
-import type { Env } from "./env.js";
-import type { MusicClock } from "./music.js";
-import type { ResolvedPiece } from "./piece.js";
-import type { Takes } from "./takes.js";
-export interface FilmClock {
-    readonly timing: Timing;
-    readonly duration: number;
-    /** Every part's start and anchors on the film's clock, for references anywhere in the output. */
-    readonly parts: readonly {
-        key: string;
-        start: number;
-        anchors: PartAnchor[];
-    }[];
-    /** Film seconds of a reference anywhere in the output: an anchor of any part, or a part's key. */
-    filmAt(ref: string): number;
-    /**
-     * A moment a video-level option names (the music's gain, a band's
-     * keys), in film seconds: seconds, an anchor or a part's key, or a word
-     * reference in a part; one it cannot find is AK-T004, and left out.
-     */
-    momentAt(m: SoundMoment, what: string): number | undefined;
-    /** The windows of the transitions parts ask for, by the incoming part's index: frames before and after the join. */
-    readonly windows: ReadonlyMap<number, {
-        before: number;
-        after: number;
-    }>;
-    /** A platform profile's length limit (AK-F001). */
-    checkLimit(): void;
-}
-export declare function timeFilm(env: Env, piece: ResolvedPiece, takes: Takes, music: MusicClock | undefined): FilmClock;
-//# sourceMappingURL=clock.d.ts.map