@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/snapshot/snapshot-coalescing.d.ts

@@ -1,135 +1,135 @@
 /**
- * Pure, side-effect-free coalescing / stale-while-revalidate / bounded-pool
- * primitives for the snapshot wrapper.
- *
- * These are extracted from `SnapshotAddon` so the decision logic is unit-testable
- * without instantiating the addon (no camera, no ffmpeg, no tRPC). The addon wires
- * them to its cache + ladder; this module owns only the mechanics:
- *
- *   - {@link decideSnapshotServe} — the pure serve/refresh decision (fresh cache vs
- *     stale-while-revalidate vs cold blocking capture) keyed off the cached frame
- *     age, the per-device max-age, and whether the caller forced a refresh.
- *   - {@link Semaphore} — a counting semaphore bounding concurrent grabs.
- *   - {@link SingleFlight} — de-dupes concurrent captures for the same key and
- *     retains a SETTLED success for a short hold window so a mount burst collapses
- *     into one capture.
- *   - {@link raceForResult} — races a promise against a wait bound without
- *     cancelling the promise (the loser keeps running in the background).
- */
+* Pure, side-effect-free coalescing / stale-while-revalidate / bounded-pool
+* primitives for the snapshot wrapper.
+*
+* These are extracted from `SnapshotAddon` so the decision logic is unit-testable
+* without instantiating the addon (no camera, no ffmpeg, no tRPC). The addon wires
+* them to its cache + ladder; this module owns only the mechanics:
+*
+*   - {@link decideSnapshotServe} — the pure serve/refresh decision (fresh cache vs
+*     stale-while-revalidate vs cold blocking capture) keyed off the cached frame
+*     age, the per-device max-age, and whether the caller forced a refresh.
+*   - {@link Semaphore} — a counting semaphore bounding concurrent grabs.
+*   - {@link SingleFlight} — de-dupes concurrent captures for the same key and
+*     retains a SETTLED success for a short hold window so a mount burst collapses
+*     into one capture.
+*   - {@link raceForResult} — races a promise against a wait bound without
+*     cancelling the promise (the loser keeps running in the background).
+*/
 /**
- * Retain a SETTLED single-flight capture this long so a grid-mount burst of
- * `getSnapshot` calls (and a row of refresh buttons) collapses into ONE capture
- * instead of one dial per tile. Only success outcomes are held — a null/failed
- * capture expires immediately so a transiently-unreachable camera is retried on
- * the next call rather than pinned blank for the window.
- */
-export declare const COALESCE_MS = 4000;
+* Retain a SETTLED single-flight capture this long so a grid-mount burst of
+* `getSnapshot` calls (and a row of refresh buttons) collapses into ONE capture
+* instead of one dial per tile. Only success outcomes are held — a null/failed
+* capture expires immediately so a transiently-unreachable camera is retried on
+* the next call rather than pinned blank for the window.
+*/
+export declare const COALESCE_MS = 4e3;
 /**
- * Stale-while-revalidate: when a cached frame exists but is past its max-age,
- * start the refresh and wait at most this long for it to land before returning
- * the STALE frame (the refresh keeps running and populates the cache for the
- * next poll). Keeps a grid mount painting instantly from cache.
- */
+* Stale-while-revalidate: when a cached frame exists but is past its max-age,
+* start the refresh and wait at most this long for it to land before returning
+* the STALE frame (the refresh keeps running and populates the cache for the
+* next poll). Keeps a grid mount painting instantly from cache.
+*/
 export declare const SWR_STALE_WAIT_MS = 2500;
 /**
- * Cold path (no cached frame) or a forced refresh: wait up to this long for a
- * fresh capture. On a cold miss there is nothing to fall back to, so we block
- * (bounded) on the capture; on a forced refresh with a stale frame available we
- * still prefer a fresh one but cap the wait, falling back to stale on timeout.
- */
-export declare const SWR_COLD_WAIT_MS = 10000;
+* Cold path (no cached frame) or a forced refresh: wait up to this long for a
+* fresh capture. On a cold miss there is nothing to fall back to, so we block
+* (bounded) on the capture; on a forced refresh with a stale frame available we
+* still prefer a fresh one but cap the wait, falling back to stale on timeout.
+*/
+export declare const SWR_COLD_WAIT_MS = 1e4;
 /**
- * Max simultaneous ffmpeg keyframe grabs — the WRAPPER path, the common case for
- * cameras with no vendor snapshot URL. A 20-cam grid mount spawns at most this
- * many ffmpeg processes; the rest serve cached frames (SWR) or queue.
- *
- * Raised 3 → 6 on 2026-08-12 (operator): a 17-camera cold start serialised
- * into 6 waves and the client-side "image displayed" clustering matched the
- * pool exactly (p90 10.8 s). Measured client-side after the raise — if the
- * hub shows decode pressure, this is the first knob to lower.
- */
+* Max simultaneous ffmpeg keyframe grabs — the WRAPPER path, the common case for
+* cameras with no vendor snapshot URL. A 20-cam grid mount spawns at most this
+* many ffmpeg processes; the rest serve cached frames (SWR) or queue.
+*
+* Raised 3 → 6 on 2026-08-12 (operator): a 17-camera cold start serialised
+* into 6 waves and the client-side "image displayed" clustering matched the
+* pool exactly (p90 10.8 s). Measured client-side after the raise — if the
+* hub shows decode pressure, this is the first knob to lower.
+*/
 export declare const MAX_CONCURRENT_GRABS = 6;
 /**
- * Max simultaneous cheap native snapshot fetches (vendor HTTP/ONVIF). Higher than
- * the ffmpeg bound because a native fetch is a lightweight HTTP round-trip, not a
- * decode pipeline.
- */
+* Max simultaneous cheap native snapshot fetches (vendor HTTP/ONVIF). Higher than
+* the ffmpeg bound because a native fetch is a lightweight HTTP round-trip, not a
+* decode pipeline.
+*/
 export declare const MAX_CONCURRENT_NATIVE = 6;
 /**
- * Serve either the fresh cache directly, or start/join a refresh and wait a
- * bounded time. `await-refresh` always runs (or joins) the single flight;
- * `waitMs` bounds how long the caller waits before, when `staleFallback` is set
- * and a cached frame exists, returning the stale frame while the refresh
- * continues in the background.
- */
+* Serve either the fresh cache directly, or start/join a refresh and wait a
+* bounded time. `await-refresh` always runs (or joins) the single flight;
+* `waitMs` bounds how long the caller waits before, when `staleFallback` is set
+* and a cached frame exists, returning the stale frame while the refresh
+* continues in the background.
+*/
 export type SnapshotServeDecision = {
-    readonly kind: 'serve-cache';
+	readonly kind: "serve-cache";
 } | {
-    readonly kind: 'await-refresh';
-    readonly waitMs: number;
-    readonly staleFallback: boolean;
+	readonly kind: "await-refresh";
+	readonly waitMs: number;
+	readonly staleFallback: boolean;
 };
 export interface SnapshotServeInputs {
-    readonly now: number;
-    /** Epoch ms of the cached frame, or null when nothing is cached. */
-    readonly cachedAt: number | null;
-    /** Effective per-device max cache age in ms (battery-aware default or override). */
-    readonly effectiveMaxAgeMs: number;
-    /** Caller forced a refresh (UI refresh button) — bypass the freshness gate. */
-    readonly force: boolean;
+	readonly now: number;
+	/** Epoch ms of the cached frame, or null when nothing is cached. */
+	readonly cachedAt: number | null;
+	/** Effective per-device max cache age in ms (battery-aware default or override). */
+	readonly effectiveMaxAgeMs: number;
+	/** Caller forced a refresh (UI refresh button) — bypass the freshness gate. */
+	readonly force: boolean;
 }
 /**
- * Pure serve/refresh decision.
- *
- *   - fresh cache + !force            -> serve-cache
- *   - stale cache + !force            -> SWR: wait SWR_STALE_WAIT_MS, then stale
- *   - no cache   + !force             -> cold: wait SWR_COLD_WAIT_MS, no fallback
- *   - force (cache present or not)    -> prefer fresh: wait SWR_COLD_WAIT_MS,
- *                                       fall back to stale only if a frame exists
- */
+* Pure serve/refresh decision.
+*
+*   - fresh cache + !force            -> serve-cache
+*   - stale cache + !force            -> SWR: wait SWR_STALE_WAIT_MS, then stale
+*   - no cache   + !force             -> cold: wait SWR_COLD_WAIT_MS, no fallback
+*   - force (cache present or not)    -> prefer fresh: wait SWR_COLD_WAIT_MS,
+*                                       fall back to stale only if a frame exists
+*/
 export declare function decideSnapshotServe(input: SnapshotServeInputs): SnapshotServeDecision;
 /**
- * A counting semaphore. `run` acquires a permit, awaits `fn`, and releases the
- * permit (even if `fn` throws), so at most `max` `fn`s run concurrently. Waiters
- * are served FIFO.
- */
+* A counting semaphore. `run` acquires a permit, awaits `fn`, and releases the
+* permit (even if `fn` throws), so at most `max` `fn`s run concurrently. Waiters
+* are served FIFO.
+*/
 export declare class Semaphore {
-    private available;
-    private readonly waiters;
-    constructor(max: number);
-    run<T>(fn: () => Promise<T>): Promise<T>;
-    private acquire;
-    private makeReleaser;
+	private available;
+	private readonly waiters;
+	constructor(max: number);
+	run<T>(fn: () => Promise<T>): Promise<T>;
+	private acquire;
+	private makeReleaser;
 }
 export declare class SingleFlight<T> {
-    private readonly holdMs;
-    private readonly holdWorthy;
-    private readonly now;
-    private readonly flights;
-    /**
-     * @param holdMs      how long a settled hold-worthy result is reused
-     * @param holdWorthy  predicate deciding whether a settled value is worth holding
-     *                    (e.g. a successful capture with a real frame)
-     * @param now         clock injection for tests
-     */
-    constructor(holdMs: number, holdWorthy: (value: T) => boolean, now?: () => number);
-    run(key: string, factory: () => Promise<T>): Promise<T>;
-    /** Drop every held flight whose key starts with `prefix` (e.g. `"<deviceId>:"`). */
-    invalidatePrefix(prefix: string): void;
-    clear(): void;
-    private isReusable;
+	private readonly holdMs;
+	private readonly holdWorthy;
+	private readonly now;
+	private readonly flights;
+	/**
+	* @param holdMs      how long a settled hold-worthy result is reused
+	* @param holdWorthy  predicate deciding whether a settled value is worth holding
+	*                    (e.g. a successful capture with a real frame)
+	* @param now         clock injection for tests
+	*/
+	constructor(holdMs: number, holdWorthy: (value: T) => boolean, now?: () => number);
+	run(key: string, factory: () => Promise<T>): Promise<T>;
+	/** Drop every held flight whose key starts with `prefix` (e.g. `"<deviceId>:"`). */
+	invalidatePrefix(prefix: string): void;
+	clear(): void;
+	private isReusable;
 }
 export type RaceOutcome<T> = {
-    readonly settled: true;
-    readonly value: T;
+	readonly settled: true;
+	readonly value: T;
 } | {
-    readonly settled: false;
+	readonly settled: false;
 };
 /**
- * Race `promise` against a `timeoutMs` bound WITHOUT cancelling it — on timeout
- * the promise keeps running (its result lands in the cache for the next poll).
- * Rejections propagate: if `promise` rejects before the timeout, this rejects.
- * The caller passes a promise that never rejects (a settled outcome union) when
- * background continuation must stay unhandled-safe.
- */
+* Race `promise` against a `timeoutMs` bound WITHOUT cancelling it — on timeout
+* the promise keeps running (its result lands in the cache for the next poll).
+* Rejections propagate: if `promise` rejects before the timeout, this rejects.
+* The caller passes a promise that never rejects (a settled outcome union) when
+* background continuation must stay unhandled-safe.
+*/
 export declare function raceForResult<T>(promise: Promise<T>, timeoutMs: number): Promise<RaceOutcome<T>>;

package/dist/builtins/snapshot/snapshot-courtesy.d.ts

@@ -1,68 +1,68 @@
 /**
- * Why a camera cannot produce a frame right now.
- *
- * `sleeping` and `unreachable` are deliberately two reasons and not one. A
- * battery camera in low-power mode is WORKING — that tile must not read as a
- * fault, which is D62's rule in the third state — while a battery camera
- * nothing has been heard from for hours is a genuine fault the operator has to
- * see (a flat battery, or a camera off the LAN). Painting the second as the
- * first is how a dead camera stayed green for 30 hours. The two are separated
- * by `deriveBatteryPresence`, never by a caller's own guess.
- */
-export type CourtesyReason = 'disabled' | 'offline' | 'sleeping' | 'unreachable' | 'waking';
+* Why a camera cannot produce a frame right now.
+*
+* `sleeping` and `unreachable` are deliberately two reasons and not one. A
+* battery camera in low-power mode is WORKING — that tile must not read as a
+* fault, which is D62's rule in the third state — while a battery camera
+* nothing has been heard from for hours is a genuine fault the operator has to
+* see (a flat battery, or a camera off the LAN). Painting the second as the
+* first is how a dead camera stayed green for 30 hours. The two are separated
+* by `deriveBatteryPresence`, never by a caller's own guess.
+*/
+export type CourtesyReason = "disabled" | "offline" | "sleeping" | "unreachable" | "waking";
 /** Default tile size when the caller asks for no particular width. */
 export declare const COURTESY_DEFAULT_WIDTH = 640;
 /** The word the frame carries. Deliberately the operator's vocabulary. */
 export declare function courtesyLabel(reason: CourtesyReason): string;
 /**
- * Background per reason. A disabled camera is a DELIBERATE state and must not
- * read as an alarm, so it is neutral grey; offline is a fault and is warmer.
- */
+* Background per reason. A disabled camera is a DELIBERATE state and must not
+* read as an alarm, so it is neutral grey; offline is a fault and is warmer.
+*/
 export declare function courtesyBackground(reason: CourtesyReason): string;
 /** XML escaping for text placed inside an SVG `<text>` node. */
 export declare function escapeCourtesyText(value: string): string;
 export interface CourtesyFrameSpec {
-    readonly deviceName: string;
-    readonly reason: CourtesyReason;
-    readonly width: number;
-    readonly height: number;
+	readonly deviceName: string;
+	readonly reason: CourtesyReason;
+	readonly width: number;
+	readonly height: number;
 }
 /**
- * The SVG the frame is rasterized from: the state large and centred, the
- * camera's name under it, smaller and dimmer.
- *
- * Sizes derive from the width so a 240 px grid tile and a 1920 px full-bleed
- * frame read the same, with a floor so a thumbnail stays legible.
- */
+* The SVG the frame is rasterized from: the state large and centred, the
+* camera's name under it, smaller and dimmer.
+*
+* Sizes derive from the width so a 240 px grid tile and a 1920 px full-bleed
+* frame read the same, with a floor so a thumbnail stays legible.
+*/
 export declare function buildCourtesySvg(spec: CourtesyFrameSpec): string;
 /**
- * The state treatment for a frame that HAS a picture under it: a band along the
- * bottom, and nothing else touched.
- *
- * It was a full-frame wash at 0.62 opacity, under a docblock claiming the frame
- * "remains visible underneath". A 38 % view of a dark room is not a view of it,
- * and the operator read the result as a placeholder rather than as their own
- * camera: *"ma perché Waking? Dovremmo mostrare l'ultimo snapshot
- * disponibile"* [but why Waking? We should show the last available snapshot] (Baby monitor, 2026-09-16).
- *
- * The marker still has to earn its place — a stale frame shown clean gets
- * mistaken for live, which is the reason the treatment exists at all. A band
- * says the same thing a wash said. Covering the picture was never the message.
- */
+* The state treatment for a frame that HAS a picture under it: a band along the
+* bottom, and nothing else touched.
+*
+* It was a full-frame wash at 0.62 opacity, under a docblock claiming the frame
+* "remains visible underneath". A 38 % view of a dark room is not a view of it,
+* and the operator read the result as a placeholder rather than as their own
+* camera: *"ma perché Waking? Dovremmo mostrare l'ultimo snapshot
+* disponibile"* [but why Waking? We should show the last available snapshot] (Baby monitor, 2026-09-16).
+*
+* The marker still has to earn its place — a stale frame shown clean gets
+* mistaken for live, which is the reason the treatment exists at all. A band
+* says the same thing a wash said. Covering the picture was never the message.
+*/
 export declare function buildCourtesyOverlaySvg(spec: CourtesyFrameSpec): string;
 /** Cache key — a courtesy frame is a pure function of these four. */
 export declare function courtesyCacheKey(spec: CourtesyFrameSpec): string;
 /**
- * Render the frame.
- *
- * Rejects on failure — the caller decides what to do, exactly as `resizeJpeg`
- * does, so a broken courtesy path is never mistaken for a broken camera.
- */
+* Render the frame.
+*
+* Rejects on failure — the caller decides what to do, exactly as `resizeJpeg`
+* does, so a broken courtesy path is never mistaken for a broken camera.
+*/
 export declare function renderCourtesyJpeg(spec: CourtesyFrameSpec): Promise<Buffer>;
 /**
- * Paint the state treatment over a real cached frame.
- *
- * The source dimensions are authoritative: overlays preserve the original
- * frame rather than resizing it to the generated courtesy-frame default.
- */
-export declare function renderCourtesyOverlayJpeg(background: Buffer, spec: Pick<CourtesyFrameSpec, 'deviceName' | 'reason'>): Promise<Buffer>;
+* Paint the state treatment over a real cached frame.
+*
+* The source dimensions are authoritative: overlays preserve the original
+* frame rather than resizing it to the generated courtesy-frame default.
+*/
+export declare function renderCourtesyOverlayJpeg(background: Buffer, spec: Pick<CourtesyFrameSpec, "deviceName" | "reason">): Promise<Buffer>;

package/dist/builtins/snapshot/snapshot-durable-store.d.ts

@@ -1,36 +1,36 @@
-import { IScopedLogger } from '@camstack/types';
+import type { IScopedLogger } from "@camstack/types";
 export interface SnapshotDurableStoreOptions {
-    /** `ctx.dataDir` — the addon's exclusive directory. */
-    readonly dataDir: string;
-    readonly minIntervalMs?: number;
-    /** Injectable for tests; `Date.now` otherwise. */
-    readonly now?: () => number;
-    /** Where a refused write is reported. Absent only in unit tests. */
-    readonly logger?: IScopedLogger;
+	/** `ctx.dataDir` — the addon's exclusive directory. */
+	readonly dataDir: string;
+	readonly minIntervalMs?: number;
+	/** Injectable for tests; `Date.now` otherwise. */
+	readonly now?: () => number;
+	/** Where a refused write is reported. Absent only in unit tests. */
+	readonly logger?: IScopedLogger;
 }
 export declare class SnapshotDurableStore {
-    private readonly dir;
-    private readonly minIntervalMs;
-    private readonly now;
-    private readonly logger;
-    /** Last write per device, so the throttle survives without touching disk. */
-    private readonly lastWriteMs;
-    constructor(options: SnapshotDurableStoreOptions);
-    /** @returns whether the frame was written. `false` is throttled or refused. */
-    put(deviceId: number, jpeg: Buffer): Promise<boolean>;
-    /** The frame from a previous process, or `null` — which is a real answer. */
-    get(deviceId: number): Promise<Buffer | null>;
-    /**
-     * The frame WITH the moment it was captured.
-     *
-     * The age travels with it because everything downstream decides on age, and
-     * a frame restored from disk that claims to be new is worse than no frame:
-     * it would satisfy a freshness gate it has no right to pass. The file's own
-     * mtime is the honest answer — it is when this frame was written.
-     */
-    getDated(deviceId: number): Promise<{
-        jpeg: Buffer;
-        capturedAtMs: number;
-    } | null>;
-    private pathFor;
+	private readonly dir;
+	private readonly minIntervalMs;
+	private readonly now;
+	private readonly logger;
+	/** Last write per device, so the throttle survives without touching disk. */
+	private readonly lastWriteMs;
+	constructor(options: SnapshotDurableStoreOptions);
+	/** @returns whether the frame was written. `false` is throttled or refused. */
+	put(deviceId: number, jpeg: Buffer): Promise<boolean>;
+	/** The frame from a previous process, or `null` — which is a real answer. */
+	get(deviceId: number): Promise<Buffer | null>;
+	/**
+	* The frame WITH the moment it was captured.
+	*
+	* The age travels with it because everything downstream decides on age, and
+	* a frame restored from disk that claims to be new is worse than no frame:
+	* it would satisfy a freshness gate it has no right to pass. The file's own
+	* mtime is the honest answer — it is when this frame was written.
+	*/
+	getDated(deviceId: number): Promise<{
+		jpeg: Buffer;
+		capturedAtMs: number;
+	} | null>;
+	private pathFor;
 }

package/dist/builtins/snapshot/snapshot-fatigue.d.ts

@@ -1,41 +1,41 @@
 /**
- * Rest for a camera that could not answer a native snapshot.
- *
- * The wrapper is polled — grids, cards, the media plane — and every miss used
- * to be followed by another ISAPI/CGI dial on the next poll. On a camera that
- * is already struggling ("Videocamera retro casa" answered HTTP 503 to 68
- * native dials in one hour on 2026-09-05) that is the load that keeps it
- * struggling. So a miss earns a rest window during which the native provider
- * is NOT dialled: the request falls through to the stream-broker frame grab
- * and the stale cache, which cost the camera nothing. The window doubles with
- * consecutive misses and is capped; the first frame that lands ends it.
- *
- * Generic on purpose: every vendor's native provider sits behind this one
- * wrapper, so one ledger here covers them all (D62 spirit: one owner).
- * `force` bypasses it — an operator's deliberate wake is never held back.
- */
+* Rest for a camera that could not answer a native snapshot.
+*
+* The wrapper is polled — grids, cards, the media plane — and every miss used
+* to be followed by another ISAPI/CGI dial on the next poll. On a camera that
+* is already struggling ("Videocamera retro casa" answered HTTP 503 to 68
+* native dials in one hour on 2026-09-05) that is the load that keeps it
+* struggling. So a miss earns a rest window during which the native provider
+* is NOT dialled: the request falls through to the stream-broker frame grab
+* and the stale cache, which cost the camera nothing. The window doubles with
+* consecutive misses and is capped; the first frame that lands ends it.
+*
+* Generic on purpose: every vendor's native provider sits behind this one
+* wrapper, so one ledger here covers them all (D62 spirit: one owner).
+* `force` bypasses it — an operator's deliberate wake is never held back.
+*/
 export interface NativeSnapshotFatigueOptions {
-    /** Rest after the first miss. */
-    readonly baseMs?: number;
-    /** Longest rest a streak can earn. */
-    readonly maxMs?: number;
+	/** Rest after the first miss. */
+	readonly baseMs?: number;
+	/** Longest rest a streak can earn. */
+	readonly maxMs?: number;
 }
 export interface FatigueVerdict {
-    readonly streak: number;
-    readonly restMs: number;
+	readonly streak: number;
+	readonly restMs: number;
 }
-export declare const NATIVE_SNAPSHOT_REST_BASE_MS = 10000;
-export declare const NATIVE_SNAPSHOT_REST_MAX_MS = 300000;
+export declare const NATIVE_SNAPSHOT_REST_BASE_MS = 1e4;
+export declare const NATIVE_SNAPSHOT_REST_MAX_MS = 3e5;
 export declare class NativeSnapshotFatigue {
-    private readonly baseMs;
-    private readonly maxMs;
-    private readonly entries;
-    constructor(options?: NativeSnapshotFatigueOptions);
-    /** The instant the rest ends, or `null` when the camera may be dialled now. */
-    restingUntil(deviceId: number, now: number): number | null;
-    /** A dial that did not produce a frame — thrown or answered `null`. */
-    recordFailure(deviceId: number, now: number): FatigueVerdict;
-    /** A frame landed: the camera is answering again. */
-    recordSuccess(deviceId: number): void;
-    forget(deviceId: number): void;
+	private readonly baseMs;
+	private readonly maxMs;
+	private readonly entries;
+	constructor(options?: NativeSnapshotFatigueOptions);
+	/** The instant the rest ends, or `null` when the camera may be dialled now. */
+	restingUntil(deviceId: number, now: number): number | null;
+	/** A dial that did not produce a frame — thrown or answered `null`. */
+	recordFailure(deviceId: number, now: number): FatigueVerdict;
+	/** A frame landed: the camera is answering again. */
+	recordSuccess(deviceId: number): void;
+	forget(deviceId: number): void;
 }

package/dist/builtins/snapshot/snapshot-grab-pick.d.ts

@@ -1,20 +1,20 @@
 /**
- * Which restream ffmpeg should grab a snapshot JPEG from.
- *
- * `status: 'streaming'` is not enough. A derived whose source profile is
- * unassigned sits in that state with zero packets (618, 2026-08-16: `derived:Mid
- * to low` had four subscribers and never a frame). Preferring it as "warm"
- * parked every grab on a 15 s ffmpeg timeout, so the connecting poster never
- * moved.
- *
- * Derived brokers are never the warm shortcut. A native that is actually
- * streaming still wins; otherwise the caller walks the ranked list and will
- * wake an idle source.
- */
+* Which restream ffmpeg should grab a snapshot JPEG from.
+*
+* `status: 'streaming'` is not enough. A derived whose source profile is
+* unassigned sits in that state with zero packets (618, 2026-08-16: `derived:Mid
+* to low` had four subscribers and never a frame). Preferring it as "warm"
+* parked every grab on a 15 s ffmpeg timeout, so the connecting poster never
+* moved.
+*
+* Derived brokers are never the warm shortcut. A native that is actually
+* streaming still wins; otherwise the caller walks the ranked list and will
+* wake an idle source.
+*/
 export declare function isDerivedBrokerId(brokerId: string, devicePrefix: string): boolean;
 export interface SnapshotGrabCandidate {
-    readonly brokerId: string;
-    readonly status: string;
+	readonly brokerId: string;
+	readonly status: string;
 }
 /** Highest-quality currently-streaming NON-derived broker, or undefined. */
 export declare function pickWarmSnapshotBroker(ranked: readonly SnapshotGrabCandidate[], devicePrefix: string): SnapshotGrabCandidate | undefined;