@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/camera-grid/grid-snapshot.d.ts

@@ -1,62 +1,62 @@
-import { GridStreamLogger } from './grid-stream-session.js';
+import type { GridStreamLogger } from "./grid-stream-session.js";
 /** Where a grid's last composed frame is kept between compositions. */
 export interface GridLastFrameStore {
-    /** The last frame kept for this grid, or `null` — which is a real answer. */
-    get(deviceId: number): Promise<Buffer | null>;
-    put(deviceId: number, jpeg: Buffer): Promise<void>;
+	/** The last frame kept for this grid, or `null` — which is a real answer. */
+	get(deviceId: number): Promise<Buffer | null>;
+	put(deviceId: number, jpeg: Buffer): Promise<void>;
 }
 /** Just enough of a session for the snapshot to choose one and read its state. */
 export interface GridSnapshotSession {
-    isRunning(): boolean;
+	isRunning(): boolean;
 }
 export interface GridSnapshotAnswerInput {
-    readonly running: boolean;
-    readonly hasStoredFrame: boolean;
+	readonly running: boolean;
+	readonly hasStoredFrame: boolean;
 }
 export type GridSnapshotAnswer = {
-    readonly kind: 'live';
+	readonly kind: "live";
 } | {
-    readonly kind: 'stored';
+	readonly kind: "stored";
 } | {
-    readonly kind: 'none';
-    readonly reason: 'never-composed';
+	readonly kind: "none";
+	readonly reason: "never-composed";
 };
 /**
- * Which of the three answers applies. Pure, so the rule can be read — and
- * sabotaged — without a socket, a file or an ffmpeg.
- */
+* Which of the three answers applies. Pure, so the rule can be read — and
+* sabotaged — without a socket, a file or an ffmpeg.
+*/
 export declare function gridSnapshotAnswerFor(input: GridSnapshotAnswerInput): GridSnapshotAnswer;
 export interface GridSnapshotImage {
-    readonly base64: string;
-    readonly contentType: string;
+	readonly base64: string;
+	readonly contentType: string;
 }
 /**
- * Generic in the session type so the addon can hand over its OWN session
- * record — the one that also knows the instance and the stream — and get it
- * back in `sampleFrame` without a cast or a second lookup.
- */
+* Generic in the session type so the addon can hand over its OWN session
+* record — the one that also knows the instance and the stream — and get it
+* back in `sampleFrame` without a cast or a second lookup.
+*/
 export interface GridSnapshotDeps<S extends GridSnapshotSession = GridSnapshotSession> {
-    readonly logger: GridStreamLogger;
-    /**
-     * This grid's compositions — one, since the collapse to a single output.
-     * Kept as a LIST because the choosing logic below is the same either way and
-     * a list of one costs nothing. EMPTY means this addon does not own the
-     * device — never "no picture".
-     */
-    readonly sessionsFor: (deviceId: number) => readonly S[];
-    /**
-     * One JPEG out of a composition that is ALREADY running. `null` when the
-     * bytes could not be turned into a frame — which is a miss, not a reason to
-     * start anything.
-     */
-    readonly sampleFrame: (session: S) => Promise<Buffer | null>;
-    readonly store: GridLastFrameStore;
+	readonly logger: GridStreamLogger;
+	/**
+	* This grid's compositions — one, since the collapse to a single output.
+	* Kept as a LIST because the choosing logic below is the same either way and
+	* a list of one costs nothing. EMPTY means this addon does not own the
+	* device — never "no picture".
+	*/
+	readonly sessionsFor: (deviceId: number) => readonly S[];
+	/**
+	* One JPEG out of a composition that is ALREADY running. `null` when the
+	* bytes could not be turned into a frame — which is a miss, not a reason to
+	* start anything.
+	*/
+	readonly sampleFrame: (session: S) => Promise<Buffer | null>;
+	readonly store: GridLastFrameStore;
 }
 export declare class GridSnapshotSource<S extends GridSnapshotSession = GridSnapshotSession> {
-    private readonly deps;
-    constructor(deps: GridSnapshotDeps<S>);
-    getSnapshot(deviceId: number): Promise<GridSnapshotImage | null>;
-    private sample;
-    private readStored;
-    private keep;
+	private readonly deps;
+	constructor(deps: GridSnapshotDeps<S>);
+	getSnapshot(deviceId: number): Promise<GridSnapshotImage | null>;
+	private sample;
+	private readStored;
+	private keep;
 }

package/dist/builtins/camera-grid/grid-stream-descriptor.d.ts

@@ -1,25 +1,53 @@
-import { CamProfile, CamStreamDescriptor } from '@camstack/types';
+/**
+* What a grid camera tells the broker it offers: one stream per profile.
+*
+* ## Why a `stream-catalog` descriptor and not `publishCameraStream`
+*
+* The broker PULLS this catalog per camera and reconciles its registry against
+* it. Anything the broker holds that the catalog does not name is swept — which
+* is the sweep `brokerOwned: true` exists to opt OUT of, for streams no
+* provider can ever declare (a `derived:*`, an `egress:*`). A grid is not one
+* of those: this addon owns the device, answers `getCatalog` for it, and names
+* its streams on every pull. Being PRESENT in the catalog is what keeps them,
+* and `brokerOwned` is not on the cap wire at all — deliberately, so a cap
+* caller cannot make its own publication un-sweepable.
+*
+* The corollary is the rule this addon has to keep: `getCatalog` must name
+* every OFFERED stream on EVERY pull, including while the composition is idle.
+* It describes what the grid offers, not what is running.
+*
+* ## One descriptor per OFFERED profile
+*
+* A grid's `low` is composed of its sources' `low`, onto the canvas their `low`
+* implies — so the three are each 1:1 with what they are made of, and a
+* viewer's adaptive picks a rung without knowing a grid is a grid.
+*
+* A profile one source cannot serve is not named here at all: composing a hole
+* is worse than not offering, because the operator files the hole as a broken
+* camera.
+*/
+import type { CamProfile, CamStreamDescriptor } from "@camstack/types";
 export interface GridStreamDescriptorInput {
-    /** Which composition this is. Also the `profileHint` — see below. */
-    readonly profile: CamProfile;
-    /** The DERIVED canvas of that profile, never an authored number. */
-    readonly width: number;
-    readonly height: number;
-    readonly fps: number;
-    /** The on-demand endpoint the broker dials. Dialling it IS the demand. */
-    readonly url: string;
+	/** Which composition this is. Also the `profileHint` — see below. */
+	readonly profile: CamProfile;
+	/** The DERIVED canvas of that profile, never an authored number. */
+	readonly width: number;
+	readonly height: number;
+	readonly fps: number;
+	/** The on-demand endpoint the broker dials. Dialling it IS the demand. */
+	readonly url: string;
 }
 /**
- * `profileHint` is load-bearing, not decoration.
- *
- * A device publishing a SINGLE stream with no hint is ranked by pixel count,
- * and a single stream ranks into `mid` — the slot `recordings` does not select
- * on its own (`high|mid` picks high), that `recordingsLow` ignores, and that
- * scrub never reads. The Dreame robot's one 720p relay landed exactly there and
- * its footage was written nowhere anything looked.
- *
- * With several compositions published the hint does a second job: it says which
- * slot each one is FOR. Ranked by pixels a grid's `mid` would take the `high`
- * slot on any grid whose `high` was not offered.
- */
+* `profileHint` is load-bearing, not decoration.
+*
+* A device publishing a SINGLE stream with no hint is ranked by pixel count,
+* and a single stream ranks into `mid` — the slot `recordings` does not select
+* on its own (`high|mid` picks high), that `recordingsLow` ignores, and that
+* scrub never reads. The Dreame robot's one 720p relay landed exactly there and
+* its footage was written nowhere anything looked.
+*
+* With several compositions published the hint does a second job: it says which
+* slot each one is FOR. Ranked by pixels a grid's `mid` would take the `high`
+* slot on any grid whose `high` was not offered.
+*/
 export declare function gridStreamDescriptor(input: GridStreamDescriptorInput): CamStreamDescriptor;

package/dist/builtins/camera-grid/grid-stream-invocation.d.ts

@@ -1,29 +1,44 @@
-import { FfmpegInvocation, FfmpegVideoEncoderId } from '@camstack/types';
-import { GridLayout } from './grid-filter-graph.js';
+/**
+* The composite's ffmpeg plan: N decodes, ONE composition, ONE encode, in ONE
+* child.
+*
+* This file composes the SHARED builder in `@camstack/types`
+* (`ffmpeg/invocation.ts`) — it deliberately builds no argv of its own. The
+* repo has already shipped two argv builders that disagreed about hardware,
+* and `scripts/check-ffmpeg-primitive.ts` exists to refuse a third.
+*
+* Why one child rather than one per source: frames never cross a process
+* boundary at frame-rate (D9/D18). A composition needs every source's DECODED
+* pixels at the same instant, so the composition has to happen where the
+* decodes already are. What leaves this child is a compressed elementary
+* stream in an MPEG-TS wrapper, and nothing else.
+*/
+import type { FfmpegInvocation, FfmpegVideoEncoderId } from "@camstack/types";
+import { type GridLayout } from "./grid-filter-graph.js";
 /** One ffmpeg input: the camera it is, and the URL this child will dial. */
 export interface GridStreamSource {
-    /** The SOURCE camera. Carried so every log line about it can be tagged. */
-    readonly deviceId: number;
-    /**
-     * A broker restream URL, acquired through `streamBroker.getStreamWithCodec`.
-     * That is the single demand-counted entry point: it rides the broker's ONE
-     * source dial instead of opening a second connection to the camera.
-     */
-    readonly url: string;
+	/** The SOURCE camera. Carried so every log line about it can be tagged. */
+	readonly deviceId: number;
+	/**
+	* A broker restream URL, acquired through `streamBroker.getStreamWithCodec`.
+	* That is the single demand-counted entry point: it rides the broker's ONE
+	* source dial instead of opening a second connection to the camera.
+	*/
+	readonly url: string;
 }
 export interface GridStreamInvocationInput {
-    readonly layout: GridLayout;
-    /** In ffmpeg INPUT ORDINAL order — `sources[n]` is the graph's `[n:v]`. */
-    readonly sources: readonly GridStreamSource[];
-    readonly decodeHwAccel: string | null;
-    readonly encoder: FfmpegVideoEncoderId;
-    readonly fps: number;
-    readonly bitrateKbps: number;
+	readonly layout: GridLayout;
+	/** In ffmpeg INPUT ORDINAL order — `sources[n]` is the graph's `[n:v]`. */
+	readonly sources: readonly GridStreamSource[];
+	readonly decodeHwAccel: string | null;
+	readonly encoder: FfmpegVideoEncoderId;
+	readonly fps: number;
+	readonly bitrateKbps: number;
 }
 /**
- * @throws when the layout addresses an input the sources do not contain, or
- * when there is nothing to compose. Both are plan errors: ffmpeg would refuse
- * them at start-up with a message about a filter pad, which names the graph
- * rather than the configuration that produced it.
- */
+* @throws when the layout addresses an input the sources do not contain, or
+* when there is nothing to compose. Both are plan errors: ffmpeg would refuse
+* them at start-up with a message about a filter pad, which names the graph
+* rather than the configuration that produced it.
+*/
 export declare function gridStreamInvocation(input: GridStreamInvocationInput): FfmpegInvocation;

package/dist/builtins/camera-grid/grid-stream-relay.d.ts

@@ -1,35 +1,35 @@
-import { CamProfile } from '@camstack/types';
-import { GridStreamLogger, GridStreamSession } from './grid-stream-session.js';
+import { type CamProfile } from "@camstack/types";
+import type { GridStreamLogger, GridStreamSession } from "./grid-stream-session.js";
 /**
- * Which grid, and WHICH COMPOSITION of it.
- *
- * The profile is a path segment and not a query string for the reason the
- * restream suffixes are (`restream-intent.ts`): the choice belongs to the URL
- * the consumer was handed, so a broker configured once keeps asking for the
- * same thing. It is REQUIRED — a dial naming none would be the broker asking
- * for "whichever", which is how a `low` slot ends up holding a `high`
- * composition.
- */
+* Which grid, and WHICH COMPOSITION of it.
+*
+* The profile is a path segment and not a query string for the reason the
+* restream suffixes are (`restream-intent.ts`): the choice belongs to the URL
+* the consumer was handed, so a broker configured once keeps asking for the
+* same thing. It is REQUIRED — a dial naming none would be the broker asking
+* for "whichever", which is how a `low` slot ends up holding a `high`
+* composition.
+*/
 export interface GridStreamRequest {
-    readonly instanceId: string;
-    readonly profile: CamProfile;
+	readonly instanceId: string;
+	readonly profile: CamProfile;
 }
 /** `/grid/<instanceId>/<profile>.flv`, or `null` when it is anything else. */
 export declare function parseGridStreamPath(url: string | undefined): GridStreamRequest | null;
 export interface GridStreamRelayDeps {
-    readonly logger: GridStreamLogger;
-    /** `null` when no grid serves that instance/profile pair right now. */
-    readonly sessionFor: (request: GridStreamRequest) => GridStreamSession | null;
+	readonly logger: GridStreamLogger;
+	/** `null` when no grid serves that instance/profile pair right now. */
+	readonly sessionFor: (request: GridStreamRequest) => GridStreamSession | null;
 }
 export declare class GridStreamRelay {
-    private readonly deps;
-    private server;
-    private baseUrl;
-    private readonly open;
-    constructor(deps: GridStreamRelayDeps);
-    start(): Promise<void>;
-    /** The URL a grid's catalog descriptor advertises. Empty before {@link start}. */
-    streamUrl(request: GridStreamRequest): string;
-    private serve;
-    dispose(): Promise<void>;
+	private readonly deps;
+	private server;
+	private baseUrl;
+	private readonly open;
+	constructor(deps: GridStreamRelayDeps);
+	start(): Promise<void>;
+	/** The URL a grid's catalog descriptor advertises. Empty before {@link start}. */
+	streamUrl(request: GridStreamRequest): string;
+	private serve;
+	dispose(): Promise<void>;
 }

package/dist/builtins/camera-grid/grid-stream-session.d.ts

@@ -1,113 +1,143 @@
-import { FfmpegVideoEncoderId, IScopedLogger } from '@camstack/types';
-import { Readable } from 'node:stream';
-import { GridLayout } from './grid-filter-graph.js';
+/**
+* One composite camera's stream, on demand.
+*
+* ## The lifecycle, stated once
+*
+* There is **no prebuffer and no idle stream**. The child exists while, and
+* only while, somebody is reading its bytes:
+*
+* - **A consumer** is an open read of this grid's HTTP endpoint. The broker is
+*   the only thing that dials it, and it dials on demand for whatever is
+*   consuming the grid's profile slot — a viewer, a snapshot, or the recorder.
+*   That is why "the recorder counts as a client" needs no special case here:
+*   with recording enabled the broker keeps a dial open, so the grid stays up
+*   exactly like an ordinary camera that records.
+* - **The first** consumer acquires one broker handle per cell and starts ONE
+*   ffmpeg child.
+* - **The last** consumer to leave stops the child and releases every handle.
+*   {@link GridStreamSessionDeps.lingerMs} debounces that teardown; it holds no
+*   media and answers nobody, it only stops a reconnect costing a respawn plus
+*   N re-acquisitions.
+*
+* ## Why the sources come from the broker
+*
+* `streamBroker.getStreamWithCodec` is the single demand-counted stream entry
+* point: it rides the broker's ONE dial to each source camera rather than
+* opening a second connection, and it is refcounted, so a source that also
+* feeds a viewer is not dialled twice. A grid that dialled cameras itself would
+* double every source's connection count and wake battery cameras nobody asked
+* for.
+*/
+import type { FfmpegVideoEncoderId, IScopedLogger } from "@camstack/types";
+import type { Readable } from "node:stream";
+import type { GridLayout } from "./grid-filter-graph.js";
 /** The logging surface this session needs — a structural subset of the injected logger. */
-export type GridStreamLogger = Pick<IScopedLogger, 'debug' | 'info' | 'warn' | 'error'>;
+export type GridStreamLogger = Pick<IScopedLogger, "debug" | "info" | "warn" | "error">;
 /** One acquired broker handle: what to dial, and what to release it by. */
 export interface GridSourceHandle {
-    readonly url: string;
-    readonly pipelineKey: string;
+	readonly url: string;
+	readonly pipelineKey: string;
 }
 /** The spawned ffmpeg, as this session uses it. */
 export interface GridStreamChild {
-    readonly stdout: Readable;
-    stop(): Promise<void>;
+	readonly stdout: Readable;
+	stop(): Promise<void>;
 }
 /** Everything the composition needs that is not a per-run acquisition. */
 export interface GridStreamPlan {
-    readonly layout: GridLayout;
-    /** In ffmpeg INPUT ORDINAL order — `sourceDeviceIds[n]` is the graph's `[n:v]`. */
-    readonly sourceDeviceIds: readonly number[];
-    readonly encoder: FfmpegVideoEncoderId;
-    readonly decodeHwAccel: string | null;
-    readonly fps: number;
-    readonly bitrateKbps: number;
+	readonly layout: GridLayout;
+	/** In ffmpeg INPUT ORDINAL order — `sourceDeviceIds[n]` is the graph's `[n:v]`. */
+	readonly sourceDeviceIds: readonly number[];
+	readonly encoder: FfmpegVideoEncoderId;
+	readonly decodeHwAccel: string | null;
+	readonly fps: number;
+	readonly bitrateKbps: number;
 }
 export interface GridStreamSessionDeps {
-    readonly logger: GridStreamLogger;
-    readonly acquireSource: (deviceId: number) => Promise<GridSourceHandle>;
-    readonly releaseSource: (pipelineKey: string) => Promise<void>;
-    readonly startChild: (plan: GridStreamPlan, sources: readonly GridSourceHandle[]) => Promise<GridStreamChild>;
-    /** Teardown debounce. `0` ⇒ tear down the moment the last consumer leaves. */
-    readonly lingerMs?: number;
+	readonly logger: GridStreamLogger;
+	readonly acquireSource: (deviceId: number) => Promise<GridSourceHandle>;
+	readonly releaseSource: (pipelineKey: string) => Promise<void>;
+	readonly startChild: (plan: GridStreamPlan, sources: readonly GridSourceHandle[]) => Promise<GridStreamChild>;
+	/** Teardown debounce. `0` ⇒ tear down the moment the last consumer leaves. */
+	readonly lingerMs?: number;
 }
 export interface GridStreamConsumer {
-    readonly onData: (chunk: Buffer) => void;
-    /** Called once, with WHY, when this consumer's stream ends from our side. */
-    readonly onClose: (reason: string) => void;
+	readonly onData: (chunk: Buffer) => void;
+	/** Called once, with WHY, when this consumer's stream ends from our side. */
+	readonly onClose: (reason: string) => void;
 }
 export interface GridStreamHold {
-    close(): void;
+	close(): void;
 }
 export interface GridStreamSessionOptions {
-    /** The COMPOSITE camera's device id — every log line here is tagged with it. */
-    readonly deviceId: number;
-    readonly deps: GridStreamSessionDeps;
-    /**
-     * The current composition, re-read on every cold start. `null` ⇒ the grid has
-     * no cells yet, which is the normal state of a freshly created grid.
-     */
-    readonly resolvePlan: () => GridStreamPlan | null;
+	/** The COMPOSITE camera's device id — every log line here is tagged with it. */
+	readonly deviceId: number;
+	readonly deps: GridStreamSessionDeps;
+	/**
+	* The current composition, re-read on every cold start. `null` ⇒ the grid has
+	* no cells yet, which is the normal state of a freshly created grid.
+	*/
+	readonly resolvePlan: () => GridStreamPlan | null;
 }
 export declare class GridStreamSession {
-    private readonly options;
-    private readonly consumers;
-    /**
-     * The FLV stream's describing bytes, and where each reader may start.
-     *
-     * Rebuilt with every cold start: a new child means a new header and a new
-     * sequence header, and handing a reader the previous child's would decode
-     * noise. See `flv-join.ts` for why FLV needs this and MPEG-TS did not.
-     */
-    private join;
-    private running;
-    private starting;
-    private lingerTimer;
-    private teardown;
-    private disposed;
-    constructor(options: GridStreamSessionOptions);
-    private get logTags();
-    /** The COMPOSITE camera's device id — what every log line about this grid is tagged with. */
-    get deviceId(): number;
-    isRunning(): boolean;
-    consumerCount(): number;
-    /** Resolves once any in-flight start or teardown has finished. For tests and shutdown. */
-    settled(): Promise<void>;
-    /**
-     * Attach a consumer, starting the composition if this is the first one.
-     *
-     * @throws when the grid has nothing to compose, or a source could not be
-     * acquired. Both are LOGGED before they are thrown: a branch that accepts a
-     * consumer and then produces no media is exactly the branch that reads as
-     * "nothing ever happened".
-     */
-    open(consumer: GridStreamConsumer): Promise<GridStreamHold>;
-    /**
-     * Attach to a composition that is ALREADY running, or refuse.
-     *
-     * The whole difference from {@link open} is the refusal, and the refusal is
-     * the feature. A snapshot of a grid is a frame of the composition — which
-     * only exists while something is watching it — and the operator's rule is
-     * that producing a thumbnail must never be the reason N cameras get dialled.
-     * `open()` would start the composition, acquire every source, and on a
-     * battery camera that is a wake nobody asked for.
-     *
-     * `null` is a real answer: "there is no composition to take a frame from",
-     * which the caller turns into the stored last frame, or into nothing.
-     */
-    openIfRunning(consumer: GridStreamConsumer): GridStreamHold | null;
-    /** Forget a consumer AND the reader holding bytes on its behalf. */
-    private dropConsumer;
-    /**
-     * The child ended on its own. Every consumer is told WHY — a stream that
-     * simply stops is indistinguishable from a stalled one at the far end.
-     */
-    onChildEnded(reason: string): void;
-    dispose(): Promise<void>;
-    private ensureRunning;
-    private startCold;
-    private scheduleTeardownIfIdle;
-    private cancelLinger;
-    private stopNow;
-    private releaseAll;
+	private readonly options;
+	private readonly consumers;
+	/**
+	* The FLV stream's describing bytes, and where each reader may start.
+	*
+	* Rebuilt with every cold start: a new child means a new header and a new
+	* sequence header, and handing a reader the previous child's would decode
+	* noise. See `flv-join.ts` for why FLV needs this and MPEG-TS did not.
+	*/
+	private join;
+	private running;
+	private starting;
+	private lingerTimer;
+	private teardown;
+	private disposed;
+	constructor(options: GridStreamSessionOptions);
+	private get logTags();
+	/** The COMPOSITE camera's device id — what every log line about this grid is tagged with. */
+	get deviceId(): number;
+	isRunning(): boolean;
+	consumerCount(): number;
+	/** Resolves once any in-flight start or teardown has finished. For tests and shutdown. */
+	settled(): Promise<void>;
+	/**
+	* Attach a consumer, starting the composition if this is the first one.
+	*
+	* @throws when the grid has nothing to compose, or a source could not be
+	* acquired. Both are LOGGED before they are thrown: a branch that accepts a
+	* consumer and then produces no media is exactly the branch that reads as
+	* "nothing ever happened".
+	*/
+	open(consumer: GridStreamConsumer): Promise<GridStreamHold>;
+	/**
+	* Attach to a composition that is ALREADY running, or refuse.
+	*
+	* The whole difference from {@link open} is the refusal, and the refusal is
+	* the feature. A snapshot of a grid is a frame of the composition — which
+	* only exists while something is watching it — and the operator's rule is
+	* that producing a thumbnail must never be the reason N cameras get dialled.
+	* `open()` would start the composition, acquire every source, and on a
+	* battery camera that is a wake nobody asked for.
+	*
+	* `null` is a real answer: "there is no composition to take a frame from",
+	* which the caller turns into the stored last frame, or into nothing.
+	*/
+	openIfRunning(consumer: GridStreamConsumer): GridStreamHold | null;
+	/** Forget a consumer AND the reader holding bytes on its behalf. */
+	private dropConsumer;
+	/**
+	* The child ended on its own. Every consumer is told WHY — a stream that
+	* simply stops is indistinguishable from a stalled one at the far end.
+	*/
+	onChildEnded(reason: string): void;
+	dispose(): Promise<void>;
+	private ensureRunning;
+	private startCold;
+	private scheduleTeardownIfIdle;
+	private cancelLinger;
+	private stopNow;
+	private releaseAll;
 }

package/dist/builtins/camera-grid/grid-tile-feed.d.ts

@@ -1,50 +1,50 @@
 /**
- * One source's decoded tiles, of which only the LATEST is ever wanted.
- *
- * ## Why dropping is the point, not a compromise
- *
- * ffmpeg's `overlay` consumes one frame per input per output frame, so an input
- * that got ahead of another stays ahead for the life of the child — that is the
- * tile gap. A canvas asks a different question: "what does this camera look
- * like NOW". Everything behind the newest frame is not a backlog to work
- * through, it is history, and dropping it is what keeps every tile at the same
- * moment however unevenly their frames arrive.
- *
- * It is also the only bound on memory here. A decoder child that outruns the
- * output tick — or a tick that stalls — would otherwise grow an unbounded queue
- * of raw frames, and a raw frame is 345 KB at 640x360.
- *
- * ## The last frame is HELD
- *
- * A tick that finds nothing new redraws what was there. A tile must not blink
- * because a source was 40 ms late, and a source that has genuinely stopped is a
- * still picture — which is legible, and which the snapshot path already treats
- * as the honest answer for a camera that is not sending.
- */
+* One source's decoded tiles, of which only the LATEST is ever wanted.
+*
+* ## Why dropping is the point, not a compromise
+*
+* ffmpeg's `overlay` consumes one frame per input per output frame, so an input
+* that got ahead of another stays ahead for the life of the child — that is the
+* tile gap. A canvas asks a different question: "what does this camera look
+* like NOW". Everything behind the newest frame is not a backlog to work
+* through, it is history, and dropping it is what keeps every tile at the same
+* moment however unevenly their frames arrive.
+*
+* It is also the only bound on memory here. A decoder child that outruns the
+* output tick — or a tick that stalls — would otherwise grow an unbounded queue
+* of raw frames, and a raw frame is 345 KB at 640x360.
+*
+* ## The last frame is HELD
+*
+* A tick that finds nothing new redraws what was there. A tile must not blink
+* because a source was 40 ms late, and a source that has genuinely stopped is a
+* still picture — which is legible, and which the snapshot path already treats
+* as the honest answer for a camera that is not sending.
+*/
 export declare class GridTileFeed {
-    private readonly frameBytes;
-    private partial;
-    private newest;
-    private fresh;
-    constructor(frameBytes: number);
-    /** Feed bytes from the decoder. Any whole frames inside replace the newest. */
-    push(chunk: Buffer): void;
-    /** The newest whole frame, or `null` while none has arrived. */
-    latest(): Buffer | null;
-    /** Has a new frame arrived since the last {@link latest}? */
-    hasFresh(): boolean;
-    /**
-     * Forget the half frame, keep the picture.
-     *
-     * Raw video has no framing: the feed cuts on a fixed length, so bytes from a
-     * NEW decoder concatenated onto a partial frame from the old one would be
-     * misaligned for ever — every frame after it sheared, with nothing to
-     * re-sync on. Called whenever a tile's decoder is replaced.
-     *
-     * The newest frame is kept deliberately: the cell holds its last picture
-     * while its decoder comes back, instead of blinking to black.
-     */
-    resetPartial(): void;
-    /** For the bound in the spec: one frame plus at most a partial one. */
-    bufferedBytes(): number;
+	private readonly frameBytes;
+	private partial;
+	private newest;
+	private fresh;
+	constructor(frameBytes: number);
+	/** Feed bytes from the decoder. Any whole frames inside replace the newest. */
+	push(chunk: Buffer): void;
+	/** The newest whole frame, or `null` while none has arrived. */
+	latest(): Buffer | null;
+	/** Has a new frame arrived since the last {@link latest}? */
+	hasFresh(): boolean;
+	/**
+	* Forget the half frame, keep the picture.
+	*
+	* Raw video has no framing: the feed cuts on a fixed length, so bytes from a
+	* NEW decoder concatenated onto a partial frame from the old one would be
+	* misaligned for ever — every frame after it sheared, with nothing to
+	* re-sync on. Called whenever a tile's decoder is replaced.
+	*
+	* The newest frame is kept deliberately: the cell holds its last picture
+	* while its decoder comes back, instead of blinking to black.
+	*/
+	resetPartial(): void;
+	/** For the bound in the spec: one frame plus at most a partial one. */
+	bufferedBytes(): number;
 }