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

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

@@ -0,0 +1,24 @@
+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/node_modules/@allyhub-next/runtime/dist/clock.d.ts

@@ -0,0 +1,32 @@
+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

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

@@ -0,0 +1,149 @@
+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/node_modules/@allyhub-next/runtime/dist/console.d.ts

@@ -0,0 +1,21 @@
+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/node_modules/@allyhub-next/runtime/dist/contrast.d.ts

@@ -0,0 +1,13 @@
+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/node_modules/@allyhub-next/runtime/dist/embed.d.ts

@@ -0,0 +1,50 @@
+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/node_modules/@allyhub-next/runtime/dist/env.d.ts

@@ -0,0 +1,101 @@
+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/node_modules/@allyhub-next/runtime/dist/errors.d.ts

@@ -0,0 +1,21 @@
+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/node_modules/@allyhub-next/runtime/dist/facade.d.ts

@@ -0,0 +1,42 @@
+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/node_modules/@allyhub-next/runtime/dist/fonts.d.ts

@@ -0,0 +1,110 @@
+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/node_modules/@allyhub-next/runtime/dist/footage.d.ts

@@ -0,0 +1,54 @@
+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 part draws graphics: over its own take they need the face. */
+    graphics: boolean;
+    /** 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