allyhub 0.6.0 → 0.7.0

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

@@ -1,149 +0,0 @@
-import { type Combo, type FootageLayer, type GraphicLayer, type LayerSpec, type Part, type PartPlane, type PartSpec, type StageContext, type TextBox, type TimeShape, type Word } from "@allyhub-next/video-core";
-import type { CaptionTrack } from "./captions.js";
-import type { FilmClock } from "./clock.js";
-import type { Embedder } from "./embed.js";
-import type { Env } from "./env.js";
-import type { DrawState } from "./frame.js";
-import type { FootagePlanner } from "./footage.js";
-import type { ResolvedPiece } from "./piece.js";
-import type { PlacedClip } from "./player/clips.js";
-import type { SoundPlanner } from "./sound.js";
-import type { StageHost } from "./stage.js";
-import type { Takes } from "./takes.js";
-/** A graphic layer of a part, mounted in its element. */
-export interface MountedLayer {
-    spec: GraphicLayer;
-    /** Its place in the part's `layers`. */
-    index: number;
-    /** Drawn behind the person, in front, or over the finished picture. */
-    z: "front" | "behind-person" | "overlay";
-    /** The part's graphics plane it is drawn in (Part.planes). */
-    plane: number;
-    props: object;
-    el: HTMLElement;
-    ctx: StageContext;
-    /** Its window, seconds from the part's start. */
-    start: number;
-    end: number;
-    /** The questions it answers (StageContext.answer), by name. */
-    answers: Map<string, (args: unknown) => unknown>;
-}
-/**
- * What a part's layers told the runtime while it ran: what they read
- * while mounting and drawing (a message, a medium or data file → its
- * value; an embedded video's identity; its place in the film), whether
- * one read its captions, and its title once ready() found it.
- */
-export interface PartRecord {
-    reads: Map<string, string>;
-    captioned: boolean;
-    title?: string;
-    /** The texts it shows at its still (its scenery's screens left out). */
-    onScreen?: string[];
-}
-export interface Mounted {
-    part: Part;
-    spec: PartSpec;
-    /** Its index in the timing. */
-    n: number;
-    el: HTMLElement;
-    /**
-     * What a transition moves: the part's picture (its element itself, or
-     * with overlays the box under them), and the box of its overlays, which
-     * a transition moves the same way over both parts' pictures.
-     */
-    picture: HTMLElement;
-    overlays?: HTMLElement;
-    layers: MountedLayer[];
-    record: PartRecord;
-}
-/** The text of the layers listed before one, at part time t (ctx.texts). */
-export type TextsAt = (m: {
-    part: Part;
-    el: HTMLElement;
-}, layers: readonly MountedLayer[], t: number) => TextBox[];
-export declare const isFootage: (l: LayerSpec) => l is FootageLayer;
-/** A graphic layer's plane: behind the person, in front, or over the finished picture. */
-export declare const zOf: (l: GraphicLayer) => "front" | "behind-person" | "overlay";
-/** The layers' names, for the timeline: component names and "footage". */
-export declare const layerNames: (layers: readonly LayerSpec[]) => string[];
-/** Replaces word references in props with seconds, where the shape says they are times. */
-export declare function resolveTimes(v: unknown, shape: true | TimeShape, at: (ref: unknown) => number): unknown;
-/** A layer's window in its part, seconds from the part's start. */
-export declare function windowOf(l: LayerSpec, dur: number, at: (ref: unknown) => number): [number, number];
-/** A part's stack, planned from its layers alone. */
-export interface StackPlan {
-    /** The part's own footage (the first footage layer without a file) when layers are behind its person; else -1. */
-    takeAt: number;
-    /** Some graphic layer is behind the person. */
-    hasBehind: boolean;
-    /** The layers' indices in the order they are drawn, back to front. */
-    order: number[];
-    /** Its graphics planes, back to front (their layers filled in by compose). */
-    planes: PartPlane[];
-    /** Each graphic layer's plane. */
-    planeOf: Map<number, number>;
-    /** Each footage layer's count of planes under it. */
-    overOf: Map<number, number>;
-    /** Whether layer i is over the finished picture. */
-    overlaid(i: number): boolean;
-}
-/**
- * The stack: the layers in the order they are listed, back to front,
- * footage and graphics alike. A layer behind the person belongs to the
- * part's own footage (the first footage layer without a file): drawn
- * right over it, under its speaker. Graphic layers with no footage
- * between them are one plane; a footage layer is over the planes before
- * it; layers over the finished picture come last.
- */
-export declare function planStack(layers: readonly LayerSpec[]): StackPlan;
-/** What a layer's context reads of its part; a cover's reads nothing. */
-export interface PartReads {
-    captions: StageContext["captions"];
-    face: StageContext["face"];
-    faces: StageContext["faces"];
-    texts: StageContext["texts"];
-}
-export interface LayerContextInput {
-    dur: number;
-    words: () => readonly Word[];
-    at: (ref: unknown) => number;
-    start: number;
-    end: number;
-    /** The combo as the layer sees it (another slot's pick is AK-X005). */
-    combo?: Combo;
-    reads?: PartReads;
-    /** Records a read for the part's identity. */
-    record?: (what: string, value: string) => void;
-    /** The part's place in the film. */
-    place?: {
-        start: number;
-        part: string;
-    };
-    /** Where the layer's answers to the host's questions go. */
-    answers?: Map<string, (args: unknown) => unknown>;
-}
-/** Makes layers' contexts: what mount and render receive besides the element and props. */
-export type LayerContexts = (input: LayerContextInput) => StageContext;
-export declare function layerContexts(env: Env, piece: ResolvedPiece, embedder: Embedder, draw: DrawState, film: FilmClock | undefined): LayerContexts;
-export interface Composed {
-    parts: Part[];
-    mounted: Mounted[];
-    /** The player's footage, each in its place in its part's stack (play only). */
-    clips: PlacedClip[];
-}
-export interface ComposeInput {
-    env: Env;
-    piece: ResolvedPiece;
-    stage: StageHost;
-    takes: Takes;
-    film: FilmClock;
-    captions: CaptionTrack;
-    footage: FootagePlanner;
-    sound: SoundPlanner;
-    contexts: LayerContexts;
-    texts: TextsAt;
-}
-/** Every part, in film order: its plan, its record and its DOM. */
-export declare function compose(input: ComposeInput): Composed;
-//# sourceMappingURL=compose.d.ts.map

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

@@ -1,21 +0,0 @@
-import { type ConsoleLog, type ConsoleWhere } from "@allyhub-next/video-core";
-/** Wraps the console's methods, once per page, before piece code loads. */
-export declare function installConsole(): void;
-/**
- * Starts recording for one output: earlier messages go. `limit` messages
- * are kept at most; `passThrough` also prints to the browser's own console
- * (the preview page, where a person may open the developer tools).
- */
-export declare function resetConsole(opts: {
-    limit?: number;
-    passThrough: boolean;
-}): void;
-/** The parts in order, for sorting the messages. */
-export declare function consoleParts(keys: readonly string[]): void;
-/** Runs piece code with its place: what it prints is recorded there. */
-export declare function consoleAt<T>(at: ConsoleWhere, fn: () => T): T;
-/** consoleAt for piece code that is awaited (a module, an output's function). */
-export declare function consoleAtAsync<T>(at: ConsoleWhere, fn: () => Promise<T>): Promise<T>;
-/** What was printed since the output started loading. */
-export declare function consoleLog(): ConsoleLog;
-//# sourceMappingURL=console.d.ts.map

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

@@ -1,13 +0,0 @@
-import type { InkLine, Rgba } from "@allyhub-next/video-core";
-import type { TextBlock } from "./inspect.js";
-/** A CSS colour as sRGB (any syntax the browser reads: rgb, hex, oklch, color()). */
-export declare function rgbaOf(css: string): Rgba | undefined;
-/** A block's lines with their fills, and its type. `k` is frame pixels per CSS pixel. */
-export declare function inkOfBlock(block: TextBlock, k: number): {
-    lines: InkLine[];
-    size: number;
-    weight: number;
-    shadow?: true;
-    stroke?: true;
-};
-//# sourceMappingURL=contrast.d.ts.map

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

@@ -1,50 +0,0 @@
-import { type BuildSource, type BoxKey, type EmbeddedVideo, type FootageBox, type FootageLayer, type GraphicLayer, type LoadOptions, type ShownIn, type SizeInfo, type StageContext } from "@allyhub-next/video-core";
-import type { LoadedOutput } from "./bridge.js";
-import type { Embed, Env } from "./env.js";
-import type { StageHost } from "./stage.js";
-/** The loader, as the embedder calls it. */
-export type Loader = (source: BuildSource, options: LoadOptions, el: HTMLElement, embed: Embed) => Promise<LoadedOutput>;
-/** A video item loaded inside this output, ready. */
-export interface Inner {
-    id: string;
-    /** Its output's name: video or slides. */
-    output: string;
-    format: string;
-    inner: LoadedOutput;
-}
-export interface EmbedOptions {
-    /** Drawn in the part's frame (a part's video take): this output's format. */
-    frame?: boolean;
-    cameras?: Readonly<Record<string, unknown>>;
-    shown?: ShownIn;
-    sceneryScale?: number;
-}
-export interface Embedder {
-    /**
-     * Loads a video item the piece imported into `el`, unseen while it
-     * loads, then puts the element back where it was. A chain that reaches
-     * itself is refused (AK-M010).
-     */
-    load(piece: unknown, el: HTMLElement, o?: EmbedOptions): Promise<Inner>;
-    /** ctx.video(piece, el): its identity recorded with `record`. */
-    video(piece: unknown, el: HTMLElement, record: (what: string, value: string) => void): Promise<EmbeddedVideo>;
-    /** Every video loaded inside this output: their reads, problems and identities count as its own. */
-    readonly loaded: readonly Inner[];
-}
-/** A video item's moment: seconds of its clock, or a reference of its own. */
-export declare const momentIn: (inner: LoadedOutput, v: number | string) => number;
-/** The cameras footage() asks a video item's scenery layers to be drawn from. */
-export declare const camerasOf: (l: FootageLayer | undefined) => Readonly<Record<string, unknown>> | undefined;
-export declare function createEmbedder(env: Env, stage: StageHost, load: Loader): Embedder;
-/** Box keyframes rather than one rectangle. */
-export declare const isBoxKeys: (b: FootageBox | undefined) => b is BoxKey[];
-/**
- * A video item drawn in a layer: its stage at its own pixels, fitted to
- * the layer's box, sought to its time at each frame (after the layer's
- * part is drawn, so the clock and the seed stay the outer part's).
- */
-export declare function videoLayer(dims: SizeInfo, base: FootageLayer, v: {
-    inner: LoadedOutput;
-    host: HTMLElement;
-}, timeAt: (t: number, ctx: StageContext) => number, sign: Record<string, unknown>): GraphicLayer;
-//# sourceMappingURL=embed.d.ts.map

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

@@ -1,101 +0,0 @@
-import { type BuildSource, type Combo, type Fact, type LoadOptions, type MatrixSpace, type MediaInfo, type MediaRef, type PieceDefinition, type Problem, type ShownIn } from "@allyhub-next/video-core";
-import { type Guards } from "./guards.js";
-import { ReadLog } from "./reads.js";
-/** The most different run-time problems one page keeps. */
-export declare const RUN_PROBLEMS = 200;
-/**
- * A video loaded inside another output (a part's video take, a footage of
- * a video item, a scenery's screen): the piece the outer one imported. It
- * shares the page with the outer output: the clock's guards, the console
- * and the read log's media are the outer's, nothing outside its own
- * element is touched, and it draws its graphic layers over its background
- * (no footage yet).
- */
-export interface Embed {
-    def: PieceDefinition;
-    /** The cameras its scenery layers are drawn from, by layer name ("*": every one); absent: their own. */
-    cameras?: Readonly<Record<string, unknown>>;
-    /** The pieces it is inside, outermost first: a piece that reaches itself is refused. */
-    chain: readonly string[];
-    /** Where the outer video shows it, filled in once the outer one is timed. */
-    shown?: ShownIn;
-    /** The drawing scale its scenery layers take, in place of their own. */
-    sceneryScale?: number;
-}
-/** Where piece code runs now: the layer mounting or drawing, its part and moment (film seconds). */
-export interface Running {
-    part?: string;
-    layer?: string;
-    index?: number;
-    t?: number;
-    /** In words, for a message: "chart (layer 2) in part intro at 1.20 s". */
-    what: string;
-}
-/**
- * What every module reports into: the problems found while loading, the
- * facts, what goes wrong at run time (for the page's whole life: a layer
- * that throws, work that fails or never settles, what a layer reports),
- * who is running, the work layers wait for, and what loading took.
- */
-export declare class Ledger {
-    readonly problems: Problem[];
-    readonly facts: Fact[];
-    readonly run: Problem[];
-    /** What loading spent its time on, for AK-P002. */
-    readonly times: {
-        what: string;
-        ms: number;
-    }[];
-    running: Running | undefined;
-    /** Loading: the work a layer waits for counts in its time. */
-    loading: boolean;
-    /** What loading is doing now, in words. */
-    doing: string | undefined;
-    private readonly waiting;
-    /** A run-time problem, once: the same one at every frame is one. */
-    ran(p: Problem): void;
-    /** Runs `run`, adding what it took to the load's times. */
-    timed<T>(what: string, run: () => Promise<T>): Promise<T>;
-    /** Work a layer asks to finish before a frame is drawn (StageContext.wait). */
-    wait(work: Promise<unknown>): void;
-    /**
-     * Waits for the work layers asked to wait for, at most `limit` ms in
-     * all, and reports what failed under its rule with the layer, part and
-     * moment that asked. What is still pending at the limit is not waited
-     * for again: it is returned, for AK-P003.
-     */
-    settle(limit: number): Promise<string[]>;
-}
-export interface Env {
-    readonly source: BuildSource;
-    readonly options: LoadOptions;
-    readonly embed: Embed | undefined;
-    readonly combo: Combo;
-    readonly lang: string | undefined;
-    readonly defaultLang: string | undefined;
-    /** The piece's one output, named by its item's kind: "video" or "slides". */
-    readonly output: string;
-    /** Seeds the whole output: piece id, output, the combo key with the format. */
-    readonly seedBase: string;
-    /**
-     * A part's seed: piece id, output, the dimensions with the format, the
-     * part's key and the frame in the part. The same part draws the same
-     * frames in every combo that has it.
-     */
-    readonly partSeed: (key: string, frame: number) => string;
-    /** The combo's slot picks (and structure): a part may read its own only. */
-    readonly picked: ReadonlySet<string>;
-    readonly space: MatrixSpace | undefined;
-    readonly guards: Guards;
-    readonly log: ReadLog;
-    readonly ledger: Ledger;
-    /** When loading began, on the real clock. */
-    readonly start: number;
-    /**
-     * Media named by a path (relative to `base`, the file the code that
-     * named it was written in, else the piece's) or an imported value.
-     */
-    readonly mediaOf: (ref: MediaRef, base?: string) => MediaInfo;
-}
-export declare function createEnv(source: BuildSource, options: LoadOptions, embed?: Embed): Env;
-//# sourceMappingURL=env.d.ts.map

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

@@ -1,21 +0,0 @@
-import { type RuleCode } from "@allyhub-next/video-core";
-/**
- * Why a piece cannot load at all (no default export, no parts, a combo it
- * does not have): `load()` rejects with it. Its message starts with its
- * code, `bad_combo: …`, so a host that reads only the text the page threw
- * still has it.
- */
-export declare class LoadFailure extends Error {
-    readonly code: string;
-    readonly text: string;
-    constructor(code: string, text: string);
-}
-/**
- * The rule an error carries: its `code` when that is a rule's, else a
- * rule named in its message (a scenery's AK-W003 inside another's), else
- * an embedded video reaching itself (AK-M010), else AK-R001.
- */
-export declare function codeOf(e: unknown): RuleCode;
-/** An error's message, whatever was thrown. */
-export declare const messageOf: (e: unknown) => string;
-//# sourceMappingURL=errors.d.ts.map

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

@@ -1,42 +0,0 @@
-import { type Cue, type Part, type Problem, type TimelineTransition, type AudioPlan } from "@allyhub-next/video-core";
-import type { LoadedOutput } from "./bridge.js";
-import type { CaptionTrack } from "./captions.js";
-import type { Mounted } from "./compose.js";
-import type { Embedder } from "./embed.js";
-import type { Env } from "./env.js";
-import type { Drawer } from "./frame.js";
-import { type FootagePlanner } from "./footage.js";
-import type { Measurer } from "./measure.js";
-import type { ResolvedPiece } from "./piece.js";
-import type { StageHost } from "./stage.js";
-import type { Takes } from "./takes.js";
-export interface FacadeInput {
-    env: Env;
-    piece: ResolvedPiece;
-    stage: StageHost;
-    mounted: readonly Mounted[];
-    parts: readonly Part[];
-    takes: Takes;
-    captions: CaptionTrack;
-    footage: FootagePlanner;
-    cues: readonly Cue[];
-    audio: AudioPlan;
-    transitions: readonly TimelineTransition[];
-    duration: number;
-    /** Part n's words on its own clock, as the timing has them. */
-    words(n: number): readonly {
-        text: string;
-        start: number;
-        end: number;
-    }[];
-    /** What the timing found wrong. */
-    timingProblems: readonly Problem[];
-    background: string;
-    embedder: Embedder;
-    drawer: Drawer;
-    measurer: Measurer;
-    /** A deck's speaker notes, by page. */
-    notes: ReadonlyMap<string, string>;
-}
-export declare function facade(input: FacadeInput): LoadedOutput;
-//# sourceMappingURL=facade.d.ts.map

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

@@ -1,110 +0,0 @@
-export declare const isGeneric: (family: string) => boolean;
-/** The families of a computed font-family, unquoted, in order. */
-export declare function families(fontFamily: string): string[];
-/** A FontFace's unicode-range as code point intervals ("U+4??" included). */
-export declare function unicodeRanges(range: string): [number, number][];
-/** A FontFace weight ("400", "100 900", "bold") as a range. */
-export declare function weightRange(weight: string): [number, number];
-/**
- * The weight CSS font matching picks among faces for a wanted weight
- * (CSS Fonts 4, 5.2): within a face's range it is exact; otherwise below
- * 400 it looks lighter first, above 500 heavier first, and between them up
- * to 500, then lighter, then heavier.
- */
-export declare function matchWeight(want: number, faces: readonly [number, number][]): number | undefined;
-/** Bold is faked when 600 or more is asked of faces that stop below 600. */
-export declare const BOLD = 600;
-export interface FaceInfo {
-    family: string;
-    weight: [number, number];
-    /** Whether the face is italic or oblique. */
-    slanted: boolean;
-    status: FontFaceLoadStatus;
-    ranges: [number, number][];
-}
-export interface FontWant {
-    families: string[];
-    weight: number;
-    italic: boolean;
-    /** Chrome may fake bold / italic (font-synthesis). */
-    synthBold: boolean;
-    synthItalic: boolean;
-}
-/** What went wrong with the font of some text, if anything. */
-export type FontIssue = {
-    kind: "fallback";
-    family: string;
-    failed: boolean;
-    usedFamily: string;
-} | {
-    kind: "bold";
-    family: string;
-    weight: number;
-    drawn: number;
-    faked: boolean;
-} | {
-    kind: "italic";
-    family: string;
-    faked: boolean;
-};
-/**
- * Decides, from the declared faces, how text asks for its font:
- * `local(family)` says whether a family without faces is on this computer.
- */
-export declare function fontIssue(want: FontWant, cps: readonly number[], faces: readonly FaceInfo[], local: (family: string) => boolean): FontIssue | undefined;
-/**
- * The families a text is drawn in, in the order they first draw one of its
- * characters: for each, as the browser picks it, the first family of its
- * font stack with a loaded face whose range covers it, a family on this
- * computer (`local`; whether it has the character is not known), or a
- * generic one; what none of them draws, the browser's default font.
- */
-export declare function drawnFamilies(want: FontWant, cps: readonly number[], faces: readonly FaceInfo[], local: (family: string) => boolean): string[];
-/** One sentence about an issue, with the fix. */
-export declare function fontIssueText(issue: FontIssue): string;
-/** Every string in a value (props: nested objects and arrays), at most `max`. */
-export declare function stringsOf(v: unknown, max?: number): string[];
-/**
- * The emoji characters of some texts, each once, with the joiners and
- * selectors that build sequences: what to load of the emoji font. Digits,
- * `#` and `*` (also keycap bases) are left to the text fonts.
- */
-export declare function emojiOf(texts: readonly string[]): string;
-/** The faces of the page (read once per checked frame). */
-export declare function pageFaces(): FaceInfo[];
-/**
- * Whether a family without @font-face is installed on this computer: text
- * in it measures differently from the generic fonts it would fall back to.
- */
-export declare function localFamily(family: string): boolean;
-/** What text in el asks of its font. */
-export declare function fontWant(cs: CSSStyleDeclaration): FontWant;
-/** The code points of some texts, each once. */
-export declare function codePoints(texts: readonly string[]): Set<number>;
-/** Whether a face's unicode-range has one of these code points. */
-export declare function coversAny(ranges: readonly [number, number][], cps: ReadonlySet<number>): boolean;
-/**
- * The families a font-family value names, generic ones and variables
- * left out, in lower case: what a declaration can draw with.
- */
-export declare function namedFamilies(fontFamily: string): string[];
-/** The families the page's stylesheets name in font-family (lower case). */
-export declare function styleSheetFamilies(): Set<string>;
-/**
- * The declared families (lower case) a layer's props name: a component
- * given a font as a prop sets it on its own elements when it mounts, and
- * measures in it, so its faces load before mount as the look's do.
- */
-export declare function propFamilies(props: readonly string[]): Set<string>;
-/**
- * Loads every face of these families (lower case) that has one of the
- * code points, whatever its weight and style. A face that fails is the
- * check's to report (AK-L006).
- */
-export declare function loadFaces(wanted: ReadonlySet<string>, cps: ReadonlySet<number>): Promise<void>;
-/**
- * Loads the faces the text under `root` asks for, as Chrome would to draw
- * it: per font (style, weight and families), the characters set in it.
- */
-export declare function loadTextFonts(root: Element): Promise<void>;
-//# sourceMappingURL=fonts.d.ts.map

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

@@ -1,52 +0,0 @@
-import { type FaceOnFrame, type FootageLayer, type IndexNeed, type Part, type PixelRect, type TimelineFootage } from "@allyhub-next/video-core";
-import type { CaptionTrack } from "./captions.js";
-import type { Env } from "./env.js";
-import type { ResolvedPiece } from "./piece.js";
-import type { ResolvedSpeech } from "./speech.js";
-/** A footage layer as planned: the timeline's entry and what the player needs to draw it. */
-export interface FootagePlan extends TimelineFootage {
-    /** Where the stage loads the video. */
-    url: string;
-    /** The video's length, seconds, if known. */
-    duration?: number;
-    /** The video's pixels, if known. */
-    source?: {
-        width: number;
-        height: number;
-    };
-    /** Where the stage loads the background's image. */
-    imageUrl?: string;
-    /** The file's person matte, when the player draws the person cut out (over graphics behind them, or over a treated background). */
-    matteUrl?: string;
-    /** The person is drawn over the part's graphics behind them, not over the layer's own background. */
-    personOver?: boolean;
-}
-export interface FootageLayerPlace {
-    /** A word reference of the part, in seconds from its start. */
-    at: (ref: unknown) => number;
-    /** The part's own take, whose speaker is drawn again over the behind-person graphics. */
-    cutout: boolean;
-    /** How many of the part's graphics planes are under it. */
-    over: number;
-    /** The player draws the speaker cut out over the behind-person graphics. */
-    person: boolean;
-}
-export interface FootagePlanner {
-    /** Plans a footage layer of a part; undefined, with its problem, when it shows nothing. */
-    plan(l: FootageLayer, part: Part, sp: ResolvedSpeech | undefined, speechAt: number | undefined, start: number, end: number, more: FootageLayerPlace): FootagePlan | undefined;
-    /** Every footage layer planned, in film order. */
-    readonly placed: readonly FootagePlan[];
-    /** What the media index lacks for this output (Timeline.index). */
-    needs(): IndexNeed[];
-    /** Whether a part shows footage whose speaker moves: a face track or a person matte. */
-    speakerIn(partKey: string): boolean;
-    /** A face on the frame at film time t, from the topmost footage showing then: face `id`, by default that layer's speaker. */
-    faceAt(partKey: string, t: number, id?: number): PixelRect | undefined;
-    /** Every face on the frame at film time t, from the topmost footage showing then with any. */
-    facesAt(partKey: string, t: number): FaceOnFrame[];
-}
-/** The footage planner; `cssColor` resolves a colour as the stage draws it. */
-export declare function footagePlanner(env: Env, piece: ResolvedPiece, captions: CaptionTrack, cssColor: (color: string) => string): FootagePlanner;
-/** The footage plan as the timeline holds it: without what only the player reads. */
-export declare function timelineFootage(p: FootagePlan): TimelineFootage;
-//# sourceMappingURL=footage.d.ts.map

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

@@ -1,61 +0,0 @@
-import { type CoverInfo, type PartSpec, type TimelineTransition } from "@allyhub-next/video-core";
-import type { DrawMode, DrawOptions } from "./bridge.js";
-import { type LayerContexts, type Mounted } from "./compose.js";
-import type { Env } from "./env.js";
-import type { ResolvedPiece } from "./piece.js";
-import type { Clips } from "./player/clips.js";
-import type { StageHost } from "./stage.js";
-import type { TransitionStage } from "./transitions.js";
-/** How long a moment waits, ms, once one moment of its page did not finish drawing (AK-P003). */
-export declare const STUCK_WAIT = 1000;
-/** What the draw in progress is: its mode, and the plane it draws (all when undefined). */
-export interface DrawState {
-    mode: DrawMode;
-    plane: number | undefined;
-}
-export declare const newDrawState: () => DrawState;
-/** Runs `f` as part of a draw for its layout alone (ctx.texts measuring). */
-export declare function withLayout<T>(state: DrawState, f: () => T): T;
-/**
- * Each layer element's code and the time it was last drawn at (its own
- * part's), for every output on the page (a video on a scenery's screen
- * too): what partSignature says of a canvas a layer drew. The code is the
- * component's name, or for a custom() layer "custom@" and the file that
- * wrote its part (its closures are that file's, or its imports').
- */
-export declare const drawnAt: WeakMap<Element, {
-    by: string;
-    t: number;
-}>;
-export interface Drawer {
-    readonly state: DrawState;
-    /** The part on show after the last draw. */
-    readonly current: Mounted | undefined;
-    ready(): Promise<void>;
-    draw(t: number, options?: DrawOptions): Promise<void>;
-    /** Runs `f` as a moment drawn for its layout alone. */
-    forLayout<T>(f: () => T): T;
-    /** The AK-P003 of the last draw, when it did not finish. */
-    stuck(): string | undefined;
-    covers(): CoverInfo[];
-    drawCover(n: number): Promise<void>;
-    setPlaying(on: boolean): void;
-    dispose(): void;
-}
-export interface DrawerInput {
-    env: Env;
-    piece: ResolvedPiece;
-    stage: StageHost;
-    mounted: readonly Mounted[];
-    transitions: readonly TimelineTransition[];
-    transitionStage: TransitionStage | undefined;
-    duration: number;
-    clips: Clips;
-    contexts: LayerContexts;
-    covers: readonly PartSpec[];
-    state: DrawState;
-}
-export declare function createDrawer(input: DrawerInput): Drawer;
-/** Cover parts (video({ covers })): parts without speech, drawn at their still. */
-export declare function coverParts(piece: ResolvedPiece, ctx: Parameters<NonNullable<ResolvedPiece["options"]["covers"]>>[0]): Promise<PartSpec[]>;
-//# sourceMappingURL=frame.d.ts.map

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

@@ -1,32 +0,0 @@
-import type { RealTimers } from "@allyhub-next/video-core";
-/** Time 0 of a piece as a wall-clock date: 2026-01-01T00:00:00Z. */
-export declare const EPOCH_MS: number;
-export declare function hashString(s: string): number;
-export declare function mulberry32(seed: number): () => number;
-/** The real clock, captured before the guards replace it (for timing frames). */
-export declare const realNow: () => number;
-/** The real timer, for waits the runtime itself bounds (a clip's seek). */
-export declare const realTimeout: (cb: () => void, ms: number) => unknown;
-/** The real clearTimeout, captured before anything replaces the global one. */
-export declare const realClearTimeout: (id: unknown) => void;
-/**
- * Waits for promises at most `ms` (on the real clock): each one's result,
- * or undefined for one still pending then.
- */
-export declare function within<T>(list: readonly Promise<T>[], ms: number): Promise<(PromiseSettledResult<T> | undefined)[]>;
-/** The real frame callback, for the player's playback loop. */
-export declare const realRaf: (cb: FrameRequestCallback) => number;
-export interface Guards {
-    /** Sets the virtual moment and reseeds randomness for it. */
-    setMoment(t: number, seed: string): void;
-    /** Runs the requestAnimationFrame callbacks queued so far, at the virtual time. */
-    flushFrames(): void;
-}
-/**
- * The page's own clock and timers, captured before the guards replace
- * them: a layer gets them as ctx.realTimers (a scenery's loaders while it
- * builds), never for what a frame shows.
- */
-export declare const realTimers: RealTimers;
-export declare function installGuards(): Guards;
-//# sourceMappingURL=guards.d.ts.map