allyhub 0.5.0 → 0.7.0

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

@@ -1,26 +0,0 @@
-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";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,70 +0,0 @@
-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/dist/node_modules/@allyhub-next/render/dist/look.d.ts

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

@@ -1,186 +0,0 @@
-import type { TextInk, 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[]>;
-    /**
-     * Each text block drawn at film time t, with its lines' glyph boxes and
-     * fills, its size and weight (LoadedOutput.inks): an editable PPTX's
-     * text boxes. Absent where the page cannot measure.
-     */
-    inks?(t: number): Promise<TextInk[]>;
-    /** A deck as it was drawn (slides-core's DrawnDeck): its PowerPoint file's model. Absent on a video. */
-    deck?(): Promise<unknown>;
-    /** Hides every text's fill while on (HIDE_TEXT_CSS): the picture behind an editable PPTX's text boxes. */
-    hideText?(on: boolean): Promise<void>;
-    /** 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/dist/node_modules/@allyhub-next/render/dist/parts.d.ts

@@ -1,140 +0,0 @@
-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/dist/node_modules/@allyhub-next/render/dist/png.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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

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

@@ -1,54 +0,0 @@
-/** A rank: the part's place in the film, then the frame's in the part. Lower goes first. */
-export type Rank = readonly [number, number];
-/** Pages lent one call at a time, to the waiting call of lowest rank. */
-export declare class PagePool<P> {
-    private readonly idle;
-    private readonly waiting;
-    /** Pages in the pool, lent or idle. */
-    size: number;
-    /** A page joins (a page opens while the parts already draw). */
-    add(page: P): void;
-    private give;
-    /** Runs `fn` with a page of its own, waiting for one when all are lent. */
-    use<T>(rank: Rank, fn: (page: P) => Promise<T>): Promise<T>;
-}
-/** How long a part waited, in seconds (PartTimings). */
-export interface Waits {
-    /** For the next frame from the pages. */
-    waitFrames: number;
-}
-/**
- * Frames 0…count−1 drawn by `draw` (several at once, at most `ahead`
- * past the one written last) and given to `emit` in order. Stops with
- * the signal's reason once it is aborted.
- */
-export declare function drawInOrder(o: {
-    count: number;
-    ahead: number;
-    draw: (n: number) => Promise<Buffer>;
-    emit: (frame: Buffer) => Promise<void>;
-    waits: Waits;
-    signal?: AbortSignal;
-}): Promise<void>;
-/** A count of running jobs: `run` waits while `limit` are running, then runs in arrival order. */
-export declare class Slots {
-    private running;
-    private readonly queue;
-    limit: number;
-    constructor(limit: number);
-    run<T>(fn: () => Promise<T>): Promise<T>;
-}
-/** Whether renders run one part at a time, the sound after them: ALLYHUB_RENDER_SERIAL=1 (for debugging). */
-export declare const renderSerial: () => boolean;
-/** Most parts one render works on at once (ALLYHUB_RENDER_PARTS caps it). */
-export declare const MAX_PARTS = 16;
-/**
- * How many parts this process encodes at once, over all its renders: a
- * third of the CPUs, at least 2 (each ffmpeg run decodes footage and
- * encodes on several threads of its own); ALLYHUB_RENDER_PARTS overrides,
- * ALLYHUB_RENDER_SERIAL=1 makes it 1.
- */
-export declare function partsAtOnce(): number;
-/** The encoders this process runs at once (partsAtOnce, read on first use and when it changes). */
-export declare function encoderSlots(): Slots;
-//# sourceMappingURL=pool.d.ts.map

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

@@ -1,27 +0,0 @@
-import { type Problem, type Timeline } from "@allyhub-next/video-core";
-/** What a try found: why it does not run, or whether its frames depend on where a segment starts. */
-export type PostTrial = {
-    runs: false;
-    why: string;
-} | {
-    runs: true;
-    depends: boolean;
-};
-/** Tries a post chain once per ffmpeg (the same chain is not tried again). */
-export declare function tryPost(chain: string, ffmpeg: string): Promise<PostTrial>;
-/** Where a chain is written: the video's post, or a part's. */
-export interface PostPlace {
-    chain: string;
-    /** The part whose post it is; absent: the video's. */
-    part?: string;
-}
-/** An output's post chains: the video's (video({ post })), then each part's of the timelines (part({ post })). */
-export declare function postPlaces(video: string | undefined, timelines: Iterable<Timeline>): PostPlace[];
-/** Whether this ffmpeg runs here: a chain is tried only where it does. */
-export declare function ffmpegRuns(ffmpeg: string): Promise<boolean>;
-/** The problems of an output's post chains, each tried once. */
-export declare function postProblems(places: readonly PostPlace[], where: {
-    piece: string;
-    output: string;
-}, ffmpeg: string): Promise<Problem[]>;
-//# sourceMappingURL=post-probe.d.ts.map

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

@@ -1,27 +0,0 @@
-/**
- * Why a post filter chain cannot be used, or undefined when it can: one
- * linear chain of video filters, without the ones in DENIED and without
- * options that name files.
- */
-export declare function postFilterProblem(chain: string): string | undefined;
-/**
- * Whether a post chain may read the time (t, n, pts and the like, or a
- * per-frame evaluation): its frames then depend on where they are in the
- * film, and a part that moves is drawn again.
- */
-export declare function postReadsTime(chain: string): boolean;
-/**
- * A post chain over a stream, as its contract says: it is given the
- * picture opaque, as 8-bit planar RGB (gbrp), on the film's clock (its `t`
- * is film seconds: `first` / fps at the stream's first frame), and what it
- * gives back is made opaque gbrp again, on the stream's own clock. A
- * transparent picture's alpha is set aside and put back as it was. Its
- * labels start with `prefix`; returns the label of what it gives.
- */
-export declare function postGraph(filters: string[], input: string, chain: string, at: {
-    first: number;
-    fps: number;
-    alpha: boolean;
-    prefix: string;
-}): string;
-//# sourceMappingURL=post.d.ts.map