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

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

@@ -0,0 +1,169 @@
+import { type PixelRect, type Timeline, type TimelineFootage } from "@allyhub-next/video-core";
+/** What the footage plane needs to know about a source file. */
+export interface SourceInfo {
+    /** The picture has an alpha channel. */
+    alpha: boolean;
+    /** The decoder that keeps it. */
+    decoder?: string;
+}
+/** A source of the plane: the local file, its probe and its length. */
+export interface PlaneSource {
+    path: string;
+    info: SourceInfo;
+    /** Seconds, when known. */
+    duration?: number;
+    /** Its displayed pixels, when known (a matte is scaled to them). */
+    width?: number;
+    height?: number;
+    /** Its person matte (the media index's matte.mp4), when there is one. */
+    matte?: string;
+    /** The matte's pixels (matte.json), when known. */
+    matteSize?: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * An overlay that shows only while `when` holds (an expression of `t`).
+ *
+ * Not the filter's `enable`: ffmpeg 6 evaluates a timeline on a filter
+ * with two inputs a frame later than ffmpeg 7 and 8 do, so a layer came
+ * and went a frame early there (and a still, one frame long, lost its
+ * footage). The overlay's own position expression reads the frame's own
+ * time in every version; while `when` is false the picture sits past the
+ * right edge.
+ */
+export declare function shownOverlay(x: number | string, y: number | string, when: string): string;
+/** Whether a video has alpha, and the decoder that keeps it. Cached per file version. */
+export declare function probeSource(file: string, ffprobe?: string): Promise<SourceInfo>;
+/** A seconds value for an ffmpeg argument or expression. */
+export declare const sec: (x: number) => string;
+/** A CSS-like "#rrggbb" or "#rrggbbaa" (or "transparent") as an ffmpeg color. */
+export declare function ffmpegColor(css: string, alpha: boolean): string;
+export interface PlaneOptions {
+    timeline: Timeline;
+    /** The window: film frames [first, first + frames). */
+    first: number;
+    frames: number;
+    /**
+     * Repo path → the local file and its probe, for every footage file (and
+     * the image of a layer's `background`).
+     */
+    sources: ReadonlyMap<string, PlaneSource>;
+    /** Keep the alpha: a transparent background stays transparent. */
+    alpha: boolean;
+    /** The index the plane's first input gets on the command line. */
+    firstInput: number;
+    /**
+     * The graphics planes of the window's part, back to front
+     * (Part.planes): each one's stream in this graph (its label, a picture
+     * of the frame's size with alpha at the output rate), or undefined
+     * where nothing of it shows in the window. They are stacked with the
+     * footage, each footage layer over the planes its `over` counts; a
+     * speaker cut out with the matte goes over the plane behind them.
+     * Without it the plane is the footage alone.
+     */
+    graphics?: readonly (string | undefined)[];
+}
+export interface FootagePlane {
+    /** Input arguments: per source file, its decoder, -ss, -t and -i. */
+    inputs: string[];
+    /** filter_complex chains, the last one ending in `[${out}]`. */
+    filters: string[];
+    /**
+     * The picture's label: the footage, and the graphics planes given,
+     * stacked back to front; the frame's pixels at the output rate, gbrp
+     * (gbrap with alpha).
+     */
+    out: string;
+    /** How many inputs it adds. */
+    count: number;
+    /** The footage layers it draws. */
+    layers: TimelineFootage[];
+    /**
+     * Speakers cut out with their matte and drawn over the plane behind
+     * them: the plane each one is over.
+     */
+    cutouts: {
+        label: string;
+        over: number;
+    }[];
+}
+/**
+ * Linear keys as an ffmpeg expression of `tv` (whose value is t - offset),
+ * held before the first and after the last: a balanced tree of if()s, so
+ * a key on every frame of a long move stays far inside the expression
+ * parser's depth (a hundred levels).
+ */
+export declare function linearExpr(keys: readonly {
+    t: number;
+    v: number;
+}[], tv: string, offset?: number): string;
+/**
+ * A layer with a moving box, drawn by its placement at every frame: the
+ * whole of what it shows (its crop) scaled once to `size`, then on each
+ * frame the part of it that shows in the box (`cut`, perspective's source
+ * corners in its pixels) is drawn where it shows (`to`, the destination
+ * corners of a `canvas` of the frame's size or larger, with what was cut
+ * at (1, 1)). Both are uniform: the picture keeps its shape. The corners
+ * are ffmpeg expressions of the window's clock `tv`, made from
+ * placementAt's own numbers (the player's) at every frame.
+ */
+export interface KeyedGeometry {
+    size: [number, number];
+    canvas: [number, number];
+    cut: {
+        x0: string;
+        y0: string;
+        x1: string;
+        y1: string;
+    };
+    to: {
+        x0: string;
+        y0: string;
+        x1: string;
+        y1: string;
+    };
+    /** The box in the cut picture's pixels at the window's first frame, for a shape's mask. */
+    box: PixelRect;
+}
+export declare function keyedGeometry(f: TimelineFootage, o: {
+    first: number;
+    frames: number;
+    fps: number;
+    width: number;
+    height: number;
+    tv: string;
+}): KeyedGeometry;
+/** The footage layers that show in a window of film frames. */
+export declare function layersIn(timeline: Timeline, first: number, frames: number): TimelineFootage[];
+/**
+ * The footage plane of a window of the film: the background canvas with
+ * every footage layer showing in it, at the output rate, starting at time
+ * 0 for the window's first frame.
+ */
+export declare function footagePlane(o: PlaneOptions): FootagePlane;
+/**
+ * The ellipse inscribed in a layer's box (its first box when keyframed),
+ * relative to what shows of it (`vis`, the branch's picture): centre and
+ * radii in its pixels.
+ */
+export declare function insetEllipse(f: Pick<TimelineFootage, "box" | "boxes">, vis: PixelRect): {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+};
+/**
+ * A layer's rounded box (its first box when keyframed), relative to what
+ * shows of it (`vis`): centre, half sides and the corners' radius in its
+ * pixels, the radius at most half the shorter side.
+ */
+export declare function roundedBox(f: Pick<TimelineFootage, "box" | "boxes" | "radius">, vis: PixelRect): {
+    cx: number;
+    cy: number;
+    hw: number;
+    hh: number;
+    r: number;
+};
+//# sourceMappingURL=footage.d.ts.map

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

@@ -0,0 +1,16 @@
+/** An image as 8-bit RGBA. */
+export interface Img {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export declare const readPng: (buf: Buffer) => Img;
+export declare const writePng: (img: Img) => Buffer;
+export declare const blankImage: (width: number, height: number, rgba?: readonly [number, number, number, number]) => Img;
+/** A box of an image (x, y, width, height), cut to the image; undefined when nothing of it is inside. */
+export declare function cropImage(img: Img, box: readonly [number, number, number, number]): Img | undefined;
+/** Another image drawn into `dst` at x, y (copied, not blended). */
+export declare function pasteImage(dst: Img, src: Img, x: number, y: number): void;
+/** An image resampled to width × height (premultiplied, so transparent edges keep their colour), or by its nearest pixels. */
+export declare function resizeImage(img: Img, width: number, height: number, filter?: "smooth" | "nearest"): Img;
+//# sourceMappingURL=image.d.ts.map

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

@@ -0,0 +1,27 @@
+export type { ExportPage, FrameOptions, GraphicsPage, OutputReads, PartSignature, PartText, PrintPage, ProjectMedia, RenderTarget, VideoLook, } from "./page.js";
+export { RenderError } from "./errors.js";
+export { ffmpegOf, ffprobeOf, runFfmpegWith, toolsOf, write, type Tools, } from "./tools.js";
+export { ENCODERS, FFMPEG_MINIMUM, FFMPEG_PINNED, compareReleases, ffmpegEncoders, ffmpegHint, ffmpegRelease, ffmpegVersion, findFfmpeg, judgeFfmpeg, requireEncoder, requireFfmpeg, versionIn, type FfmpegFound, type FfmpegRelease, } from "./ffmpeg.js";
+export { renderVideo, type PartTimings, type RenderOptions, type RenderResult, type RenderTimings, } from "./render.js";
+export { MAX_WORKERS, SHARE_ENCODE, VIDEO_TYPES, autoWorkers, encodeFor, shareKbps, type EncodeOptions, type Picture, type VideoType, } from "./encode.js";
+export { segmentsOf, type Segment } from "./segments.js";
+export { masterOf, mixSound, type SoundInput } from "./sound.js";
+export { backgroundStill, finalStill, footageStill, videoFrame, type StillOptions, } from "./stills.js";
+export { hasFinalLook, lutFile } from "./look.js";
+export { compositeArgs, compositeStill, finishGraph, frameAt, partAt, planSources, stillOutput, transparentPng, type CompositeOptions, type StillFormat, } from "./composite.js";
+export { ffmpegColor, footagePlane, insetEllipse, keyedGeometry, layersIn, linearExpr, probeSource, roundedBox, type FootagePlane, type KeyedGeometry, type PlaneOptions, type PlaneSource, type SourceInfo, } from "./footage.js";
+export { junctionArgs, junctionGroups, junctionStill, type JunctionGroup, type JunctionOptions, type JunctionPicture, } from "./junction.js";
+export { PipeFormat, pngColorType, rgbaPng } from "./png.js";
+export { CAPTURE_DEFAULTS, GRAIN_MOST, blurredNoise, captureGraph, captureProblem, capturesAnything, exposureStops, grainAt, grainSize, grainWeight, type CaptureOptions, type Grain as CaptureGrain, } from "./capture.js";
+export { postFilterProblem, postGraph, postReadsTime } from "./post.js";
+export { ffmpegRuns, postPlaces, postProblems, tryPost, type PostPlace, type PostTrial, } from "./post-probe.js";
+export { CAP_START, breaksCap, capOf, capRun, overCap, packetSizes, type Cap, } from "./cap.js";
+export { PartCache, closedPart, drawnKey, junctionDigest, partCacheLimit, partDigest, type JunctionInputs, type PartInputs, type PieceCode, } from "./parts.js";
+export { MAX_PARTS, PagePool, Slots, drawInOrder, encoderSlots, partsAtOnce, renderSerial, type Rank, type Waits, } from "./pool.js";
+export { renderCaptions, renderCover, renderPdf, renderPng, renderPptx, type ExportOptions, type ExportResult, } from "./exports.js";
+export { lookFormat, webp, webpPath, type WebpQuality } from "./webp.js";
+export { blankImage, cropImage, pasteImage, readPng, resizeImage, writePng, type Img, } from "./image.js";
+export { CLIP_TYPES, clipTypeOf, writeClip, type ClipOptions, type ClipType, } from "./clip.js";
+export { DELIVERY_LEAD, parseEncode, throughEncode, type DeliveryEncode, } from "./delivery.js";
+export { encodeServed, servedEncodeOf, servedPlatforms, type ServedAudio, } from "./served.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,70 @@
+import { type CaptureOptions, type Timeline, type TimelineTransition } from "@allyhub-next/video-core";
+import { type StillFormat } from "./composite.js";
+import { type PlaneSource } from "./footage.js";
+/** How one part's graphics come to a junction. */
+export interface JunctionPicture {
+    /**
+     * Its graphics planes that show in the window, back to front (their
+     * numbers in Part.planes): they are piped in. Empty: none shows.
+     */
+    planes: readonly number[];
+    /** Of `planes`, those laid over the finished picture (z "overlay"): one image a frame. */
+    overlays?: readonly number[];
+}
+/** One group of images per output frame: whose graphics, and which plane. */
+export interface JunctionGroup {
+    picture: "out" | "in";
+    /** The plane's number in its part (Part.planes). */
+    plane: number;
+    /** Laid over the finished picture: one image a frame, no blur. */
+    overlay?: true;
+}
+/** The groups a junction's graphics are piped in, in order. */
+export declare function junctionGroups(out: JunctionPicture, into: JunctionPicture): JunctionGroup[];
+export interface JunctionOptions {
+    timeline: Timeline;
+    transition: TimelineTransition;
+    /** Film frames [first, first + frames), inside the transition's window. */
+    first: number;
+    frames: number;
+    sources: ReadonlyMap<string, PlaneSource>;
+    /** Keep the alpha of a transparent video. */
+    alpha: boolean;
+    /** The outgoing part's graphics, and the incoming part's. */
+    out: JunctionPicture;
+    in: JunctionPicture;
+    /** Motion blur's samples per frame (1: none). */
+    samples: number;
+    capture?: CaptureOptions;
+    post?: string;
+    lut?: string;
+    /** Filters after everything (the encoder's colour chain). */
+    tail: string[];
+}
+/**
+ * The inputs and the filter graph of a junction: ffmpeg arguments up to
+ * the output options, with the result mapped as [v].
+ */
+export declare function junctionArgs(o: JunctionOptions): string[];
+/**
+ * One frame of a transition's window composited to a PNG (or JPEG): the
+ * graphics given are the groups of that frame in junctionGroups' order,
+ * `samples` images each.
+ */
+export declare function junctionStill(o: {
+    timeline: Timeline;
+    transition: TimelineTransition;
+    sources: ReadonlyMap<string, PlaneSource>;
+    frame: number;
+    out: JunctionPicture;
+    in: JunctionPicture;
+    graphics: Buffer[];
+    samples: number;
+    alpha: boolean;
+    capture?: CaptureOptions;
+    post?: string;
+    lut?: string;
+    format?: StillFormat;
+    ffmpeg: string;
+}): Promise<Buffer>;
+//# sourceMappingURL=junction.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { Part, Timeline } from "@allyhub-next/video-core";
+import type { GraphicsPage, RenderTarget, VideoLook } from "./page.js";
+/** Whether an output looks different once rendered: blur, the camera, post (its own or a part's) or alpha. */
+export declare function hasFinalLook(look: VideoLook, timeline?: Timeline): boolean;
+/** The LUT file of post.lut, a project path, checked to be inside the project and there. */
+export declare function lutFile(root: string, lut: string | undefined): Promise<string | undefined>;
+/**
+ * What a capture of one of a part's planes asks the page for: that plane
+ * alone, or nothing when the part has one plane (every layer is its).
+ */
+export declare const pagePlane: (part: Part, plane: number) => {
+    plane?: number;
+};
+/**
+ * Tries the post chains of a page's output once (post-probe.ts, as the
+ * check does) and reports what is wrong with them on the page: a chain
+ * that does not run (AK-M001), one whose frames depend on where a segment
+ * starts (AK-D002, so a still is not the render's frame).
+ */
+export declare function reportPost(page: GraphicsPage, target: RenderTarget, video: string | undefined, ffmpeg: string): Promise<void>;
+//# sourceMappingURL=look.d.ts.map

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

@@ -0,0 +1,176 @@
+import type { CaptionLine, CaptionOptions, CaptureOptions, Combo, MediaInfo, Problem, Timeline } from "@allyhub-next/video-core";
+/** Which output a render is of: a piece's output in one combo and format. */
+export interface RenderTarget {
+    piece: string;
+    output: string;
+    combo: Combo;
+    format: string;
+}
+/** What a page is asked to capture at a moment (GraphicsPage.frame). */
+export interface FrameOptions {
+    format: "jpeg" | "png";
+    quality?: number;
+    /** Draw this much after the frame's moment, seconds (motion blur's sub-frame samples). */
+    offset?: number;
+    /** Keep the stage's transparency (PNG only). */
+    alpha?: boolean;
+    /**
+     * Only the graphic layers of this plane of the part (its number in
+     * Part.planes): a part whose graphics are in several planes is drawn a
+     * plane at a time.
+     */
+    plane?: number;
+    /**
+     * This part alone (its key), as a cut would show it, held at its first
+     * or last frame outside its own time: the two pictures of a transition
+     * are captured one by one and composited by ffmpeg. Without it, a moment
+     * in a transition's window has both parts, placed with CSS.
+     */
+    part?: string;
+    /**
+     * Frames captured (or being captured), by the stage's signature: a
+     * moment whose DOM is the same as one in here is not captured again.
+     */
+    reuse?: Map<string, Promise<Buffer>>;
+    /** Counts what the call did: a capture, or a frame from `reuse`. */
+    stats?: {
+        captured: number;
+        reused: number;
+    };
+}
+/**
+ * What a part draws at each of a list of moments, as one hash, for a part
+ * drawn by code the part cache cannot see into (a custom() layer, a
+ * scenery, a component of the piece's own file): `sign` and the
+ * components (`owners`) that drew a canvas in it; or why it cannot be
+ * said (`unknown`: a canvas the piece's own code paints, a video, an
+ * iframe, a GIF).
+ */
+export type PartSignature = {
+    sign: string;
+    owners: string[];
+    unknown?: undefined;
+} | {
+    unknown: string;
+};
+/** What the output read while it was drawn: message keys and project paths. */
+export interface OutputReads {
+    messages: readonly string[];
+    media: readonly string[];
+    data: readonly string[];
+}
+/**
+ * A page holding a loaded output, drawing its graphics plane: transparent,
+ * without footage (the render's ffmpeg draws the footage). A render may be
+ * given several, which draw different frames at once.
+ */
+export interface GraphicsPage {
+    /** The output's timeline as the page loaded it. */
+    readonly timeline: Timeline;
+    /**
+     * Each part's identity as JSON, by part key (the runtime's signs): its
+     * layers and their props and windows, its words, what its layers read,
+     * the look, the format, its length in frames. The part cache's key.
+     */
+    readonly signs: Readonly<Record<string, string>>;
+    /** What the output read while it loaded and drew its stills. */
+    readonly reads: OutputReads;
+    /** Drawn on this computer's GPU, not on the CPU: other pixels, another cache key. */
+    readonly gpu?: boolean;
+    /**
+     * One picture of the graphics at film time t, drawn as the render draws
+     * it: a PNG with alpha (`alpha`), or opaque, of the timeline's size.
+     */
+    frame(t: number, options: FrameOptions): Promise<Buffer>;
+    /** What part `key` draws at each of `times` (seconds), as one hash. */
+    partSign(key: string, times: readonly number[]): Promise<PartSignature>;
+    /**
+     * Every problem the page has seen so far: loading's, and what went
+     * wrong at any moment drawn since. A render fails a part whose drawing
+     * raised an error.
+     */
+    problems(): Promise<Problem[]>;
+    /**
+     * Problems found outside the page about what it drew (a post chain of a
+     * still), kept with the page's own; absent: they are dropped.
+     */
+    report?(problems: readonly Problem[]): void;
+    /** Closes the page. A render closes only the pages it opened (`RenderOptions.openPage`). */
+    close?(): Promise<void>;
+}
+/** A part's text, for a slide's speaker notes. */
+export interface PartText {
+    key: string;
+    /** A page's notes (`<prefix>.<page>.notes`). */
+    notes?: string;
+    /** What the part says. */
+    spoken?: string;
+    /** The text it shows. */
+    onScreen: readonly string[];
+}
+/** A page of a printed handout (ExportPage.print). */
+export interface PrintPage {
+    /** The moment the page shows: the part's still. */
+    still: number;
+    /** The page's title, its heading in the PDF's outline. */
+    title: string;
+    /** CSS for what is under the graphics: the footage plane as an image, or the background colour. */
+    background: string;
+}
+/** What the other export files need of the page beyond its frames. */
+export interface ExportPage extends GraphicsPage {
+    /**
+     * Each voiced part's line as shown and as said, with its words on the
+     * film clock, whatever says them (a take, a `say` line, a stretch of
+     * another video): the subtitles.
+     */
+    lines(): Promise<CaptionLine[]>;
+    /** The options the first layer that read its captions asked (ctx.captions): the subtitles follow them. */
+    captionOptions(): Promise<CaptionOptions | undefined>;
+    /** Each part's notes and text, for a deck's speaker notes. */
+    text(): Promise<readonly PartText[]>;
+    /** How many covers the output has (video(…, { covers })). */
+    covers(): Promise<number>;
+    /**
+     * Cover `i`'s graphic layers as a PNG with alpha, the timeline's size,
+     * drawn outside the film's clock.
+     */
+    cover(i: number): Promise<Buffer>;
+    /**
+     * The output printed to a PDF, a sheet per page: at each page's still,
+     * the stage's DOM cloned onto a sheet of `paper` (CSS `@page` size: "W H"
+     * in pixels, or A4 and Letter at their size, the frame scaled onto it),
+     * over its `background`, so the text stays text; canvases frozen to
+     * pictures; a sheet without headings of its own given an invisible
+     * one, its title, so the outline lists every page; printed tagged, with
+     * the outline, backgrounds drawn.
+     */
+    print(pages: readonly PrintPage[], paper: string): Promise<Buffer>;
+}
+/** Where the project's media are, and what the build measured of them. */
+export interface ProjectMedia {
+    /** The project's folder: the media index (mattes, LUTs) is under it. */
+    root: string;
+    /** What the build measured of each media file, by project path. */
+    media: Readonly<Record<string, MediaInfo>>;
+    /** A media file's path on this computer, by its project path; undefined when it is not there. */
+    path(file: string): string | undefined;
+}
+/** What of an output's options (video({ … })) changes its picture once rendered. */
+export interface VideoLook {
+    /** A transparent video: its alpha kept where the file type has one. */
+    transparent?: boolean;
+    /** Motion blur: samples a frame (2–16) over `shutter` of a frame (default 0.5). */
+    motionBlur?: {
+        samples: number;
+        shutter?: number;
+    };
+    /** What a camera filming the picture does to it, before post. */
+    capture?: CaptureOptions;
+    /** A post filter chain and a .cube LUT, a project path. */
+    post?: {
+        filter?: string;
+        lut?: string;
+    };
+}
+//# sourceMappingURL=page.d.ts.map

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

@@ -0,0 +1,140 @@
+import { type Combo, type MediaInfo, type Part, type Timeline, type TimelineTransition } from "@allyhub-next/video-core";
+import type { PartSignature } from "./page.js";
+/** The cache's size limit: ALLYHUB_PART_CACHE_MB, default 4096 MB. */
+export declare function partCacheLimit(): number;
+/**
+ * What the build knows of a piece's code, for the part cache: which
+ * project files draw it, and what every stage loads.
+ */
+export interface PieceCode {
+    /** The piece's own file, a project path. */
+    file: string;
+    /** The project modules its bundle holds, project paths (its own file among them). */
+    files?: readonly string[];
+    /** The digest of its whole bundle: a part drawn by code nothing else describes is keyed by it. */
+    bundle?: string;
+    /** The digest of the packages' code the bundle holds; absent: unknown. */
+    vendor?: string;
+    /** The project's components: each one's name and the file that defines it. */
+    components: readonly {
+        name: string;
+        file: string;
+    }[];
+    /**
+     * What every stage loads and draws with, each a version or a digest:
+     * the runtime's bundle, the SDK's and the runtime's versions, the
+     * project's fonts.
+     */
+    stage: readonly string[];
+    /** The project's messages: its languages, the first the default, and each one's values by key. */
+    messages: {
+        locales: readonly string[];
+        messages: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    };
+    /** The project's data files' digests, by project path. */
+    data: Readonly<Record<string, {
+        sha256: string;
+    }>>;
+}
+/** What one part's digest is made of, besides the page's identity. */
+export interface PartInputs {
+    /** The project's folder: the media index (mattes) is under it. */
+    root: string;
+    code: PieceCode;
+    combo: Combo;
+    timeline: Timeline;
+    part: Part;
+    /** The page's identity of the part (GraphicsPage.signs[part.key]). */
+    sign: string;
+    /**
+     * What the part draws at every image of it, for a part drawn by code
+     * the digest cannot see into (GraphicsPage.partSign); absent, or unknown,
+     * and such a part is keyed by the piece's whole bundle.
+     */
+    drawn?: PartSignature;
+    /** The project's media by path. */
+    media: Readonly<Record<string, MediaInfo>>;
+    /** The output read these (message keys, media and data paths): for custom parts. */
+    reads: {
+        messages: readonly string[];
+        media: readonly string[];
+        data: readonly string[];
+    };
+    /** The frames it covers, and the ffmpeg arguments that encode them. */
+    frames: number;
+    encode: readonly string[];
+    /** Post filter, LUT bytes' sha256, motion blur. */
+    look: unknown;
+    ffmpeg: string;
+    /** Drawn on this computer's GPU, not on the CPU: other pixels. */
+    gpu?: boolean;
+    /**
+     * Frames of the part the segment leaves out: at its start (its own
+     * transition's window) and at its end (the next part's, when they are
+     * not dropped at the join instead).
+     */
+    trim?: {
+        head: number;
+        tail: number;
+    };
+}
+/**
+ * Whether a part is drawn by code the digest sees in full (components
+ * from their own files): what it is is in its signs, and no frame need be
+ * drawn to key it.
+ */
+export declare function closedPart(code: PieceCode, sign: string): boolean;
+/**
+ * A part's frames' signature as its key, when it can be one: every frame
+ * signed, every canvas drawn by a component whose file the key hashes,
+ * and the packages' code known. Else undefined, and why.
+ */
+export declare function drawnKey(code: PieceCode, drawn: PartSignature | undefined): {
+    sign: string;
+    owners: string[];
+} | undefined;
+/** The digest of one part's segment: the cache's key. */
+export declare function partDigest(i: PartInputs): Promise<string>;
+/** What a junction's digest is made of. */
+export interface JunctionInputs {
+    /** The outgoing and the incoming part as wholes: partDigest of each with all its frames and no encoder. */
+    out: string;
+    in: string;
+    transition: TimelineTransition;
+    fps: number;
+    /** The frames it covers, and the ffmpeg arguments that encode them. */
+    frames: number;
+    encode: readonly string[];
+    ffmpeg: string;
+}
+/** The digest of a junction's segment: the frames of a transition's window. */
+export declare function junctionDigest(i: JunctionInputs): Promise<string>;
+/** A segment file's place: .allyhub/cache/parts/<digest>.<ext>. */
+export declare class PartCache {
+    readonly dir: string;
+    private readonly limit;
+    private readonly making;
+    /** Segments found in the cache and rendered, since it was opened. */
+    hits: number;
+    misses: number;
+    private constructor();
+    private static open1;
+    /** The project's part cache (one per project in this process). */
+    static of(root: string, limit?: number): PartCache;
+    private path;
+    /** The cached segment, marked as used now; undefined when there is none. */
+    get(digest: string, ext: string): Promise<string | undefined>;
+    /**
+     * The segment for a digest: the cached file, or `make(tmp)` writes one,
+     * which is kept. Calls for the same digest at the same time make it once.
+     */
+    segment(digest: string, ext: string, make: (out: string) => Promise<void>): Promise<{
+        file: string;
+        cached: boolean;
+    }>;
+    /** Removes the least recently used segments while the cache is over its limit. */
+    evict(keep?: string): Promise<void>;
+}
+/** A cached segment in a render's own folder: a hard link, or a copy across devices. */
+export declare function place(from: string, to: string): Promise<void>;
+//# sourceMappingURL=parts.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * A PNG as 8-bit RGBA: itself when it is one already, an 8-bit RGB one
+ * (what Chrome writes for an opaque capture) decoded and written again by
+ * pngjs with an alpha channel (255, or a transparent colour's 0). Any
+ * other kind is returned as it is. The same buffer converts once: a frame
+ * captured once and sent many times is the same object.
+ */
+export declare function rgbaPng(png: Buffer): Buffer;
+/** A PNG's colour type (2 RGB, 6 RGBA…), or undefined when it is not a PNG. */
+export declare function pngColorType(png: Buffer): number | undefined;
+/**
+ * Keeps the images written to one ffmpeg run in one pixel format. With
+ * `rgba` every RGB image is converted. Without it the first image sets the
+ * format: after RGBA ones an RGB image is converted, and after RGB ones an
+ * image with alpha cannot be made to fit, so `next` throws
+ * PipeFormat.Mixed and the caller starts the run again with `rgba`.
+ */
+export declare class PipeFormat {
+    /** An image with alpha came after opaque ones were sent as RGB. */
+    static Mixed: {
+        new (): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    private readonly rgba;
+    private first;
+    constructor(rgba: boolean);
+    /** The image to write for `png`, in the run's format. */
+    next(png: Buffer): Buffer;
+}
+//# sourceMappingURL=png.d.ts.map