@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/snapshot/snapshot-link-url.d.ts

@@ -1,66 +1,66 @@
 /**
- * How long a minted link stays valid.
- *
- * A snapshot is a live view of the operator's home, so this is short on purpose
- * — the exposure of a leaked link is bounded by it. Two minutes is long enough
- * that a page renders, re-renders and survives a brief backgrounding on the URL
- * it was given, and short enough that a link pasted somewhere is dead before it
- * is useful. The client re-mints on every overview poll (5 s), so it never
- * depends on the tail of this window.
- */
-export declare const SNAPSHOT_LINK_TTL_MS = 120000;
+* How long a minted link stays valid.
+*
+* A snapshot is a live view of the operator's home, so this is short on purpose
+* — the exposure of a leaked link is bounded by it. Two minutes is long enough
+* that a page renders, re-renders and survives a brief backgrounding on the URL
+* it was given, and short enough that a link pasted somewhere is dead before it
+* is useful. The client re-mints on every overview poll (5 s), so it never
+* depends on the tail of this window.
+*/
+export declare const SNAPSHOT_LINK_TTL_MS = 12e4;
 /**
- * Quantum the expiry is rounded UP to, so a link is stable between mints.
- *
- * Without it every mint produces a different `exp`, hence a different URL, hence
- * a full re-download of an unchanged frame on every poll. With it the URL is a
- * pure function of (device, width, frame, bucket) — so a tile fetches when its
- * frame moves, and at most once more per bucket.
- */
-export declare const SNAPSHOT_LINK_EXP_BUCKET_MS = 30000;
+* Quantum the expiry is rounded UP to, so a link is stable between mints.
+*
+* Without it every mint produces a different `exp`, hence a different URL, hence
+* a full re-download of an unchanged frame on every poll. With it the URL is a
+* pure function of (device, width, frame, bucket) — so a tile fetches when its
+* frame moves, and at most once more per bucket.
+*/
+export declare const SNAPSHOT_LINK_EXP_BUCKET_MS = 3e4;
 /** The token the signature is computed over. Width is part of the identity so a
- *  tile link cannot be escalated into a full-frame request. */
+*  tile link cannot be escalated into a full-frame request. */
 export declare function snapshotLinkId(deviceId: number, width: number | undefined): string;
 /** The bucketed expiry for a link minted at `nowMs`. Always ≥ `nowMs + TTL`. */
 export declare function snapshotLinkExpiry(nowMs: number, ttlMs?: number, bucketMs?: number): number;
 export interface BuildSnapshotLinkInput {
-    /** Root-relative plane prefix, e.g. `/addon/snapshot/link`. */
-    readonly routePrefix: string;
-    readonly deviceId: number;
-    /** Snapped ladder rung the bytes will be at, or undefined for the full frame. */
-    readonly width: number | undefined;
-    /** Capture identity of the frame this link names — the client's cache key. */
-    readonly capturedAt: number | null;
-    readonly secret: string;
-    readonly expMs: number;
+	/** Root-relative plane prefix, e.g. `/addon/snapshot/link`. */
+	readonly routePrefix: string;
+	readonly deviceId: number;
+	/** Snapped ladder rung the bytes will be at, or undefined for the full frame. */
+	readonly width: number | undefined;
+	/** Capture identity of the frame this link names — the client's cache key. */
+	readonly capturedAt: number | null;
+	readonly secret: string;
+	readonly expMs: number;
 }
 /**
- * The link, as a ROOT-RELATIVE path.
- *
- * Deliberately not absolute. The artifact and HA planes must mint absolute URLs
- * because the fetcher is a phone or a notifier backend that has no idea where
- * the hub is — and picking that base is the `hubUrl: localhost` trap the Alexa
- * work paid for. Here the fetcher is a client that is already connected to the
- * hub and holds its own `serverUrl`, so the correct base is the one it used to
- * make the call. Returning a path makes it impossible to hand a client a link
- * pointing somewhere it cannot reach.
- */
+* The link, as a ROOT-RELATIVE path.
+*
+* Deliberately not absolute. The artifact and HA planes must mint absolute URLs
+* because the fetcher is a phone or a notifier backend that has no idea where
+* the hub is — and picking that base is the `hubUrl: localhost` trap the Alexa
+* work paid for. Here the fetcher is a client that is already connected to the
+* hub and holds its own `serverUrl`, so the correct base is the one it used to
+* make the call. Returning a path makes it impossible to hand a client a link
+* pointing somewhere it cannot reach.
+*/
 export declare function buildSnapshotLinkUrl(input: BuildSnapshotLinkInput): string;
 /** A verified link request. `width` is the SIGNED width, never the raw query. */
 export interface ParsedSnapshotLink {
-    readonly deviceId: number;
-    readonly width: number | undefined;
+	readonly deviceId: number;
+	readonly width: number | undefined;
 }
 export interface ParseSnapshotLinkInput {
-    /** Handler-relative url, e.g. `/615.jpg?w=240&exp=…&sig=…`. */
-    readonly url: string;
-    readonly secret: string;
-    readonly nowMs: number;
+	/** Handler-relative url, e.g. `/615.jpg?w=240&exp=…&sig=…`. */
+	readonly url: string;
+	readonly secret: string;
+	readonly nowMs: number;
 }
 /**
- * Parse and VERIFY a link request in one step, so a caller cannot accidentally
- * use the device id before checking the signature. Null = refuse (404/403);
- * there is deliberately no way to distinguish "bad signature" from "expired"
- * from "malformed" at this boundary, so a public route cannot be probed.
- */
+* Parse and VERIFY a link request in one step, so a caller cannot accidentally
+* use the device id before checking the signature. Null = refuse (404/403);
+* there is deliberately no way to distinguish "bad signature" from "expired"
+* from "malformed" at this boundary, so a public route cannot be probed.
+*/
 export declare function parseVerifiedSnapshotLink(input: ParseSnapshotLinkInput): ParsedSnapshotLink | null;

package/dist/builtins/snapshot/snapshot-media-handler.d.ts

@@ -1,121 +1,121 @@
-import { DataPlaneHandler } from '@camstack/types';
+import type { DataPlaneHandler } from "@camstack/types";
 /** A renderable snapshot frame resolved for one device. */
 export interface SnapshotMedia {
-    /** Raw image bytes (already decoded from the wrapper's base64 cache). */
-    readonly bytes: Uint8Array;
-    /** MIME type — practically always `image/jpeg`. */
-    readonly contentType: string;
-    /** Epoch ms of the cached capture — drives the ETag and frame identity. */
-    readonly capturedAt: number;
-    /** Effective per-device max cache age (seconds) → `Cache-Control: max-age`. */
-    readonly maxAgeS: number;
-    /** State treatment painted over the capture (sleeping, waking, …). */
-    readonly variantKey?: string | undefined;
-    /**
-     * The width the returned BYTES are actually at, or undefined when they are the
-     * frame as captured.
-     *
-     * Deliberately not the same thing as the requested width. A failed resize
-     * serves the full frame, and stamping the requested `-w320` on it poisons the
-     * ETag: a later SUCCESSFUL resize of the same capture mints the identical tag
-     * with completely different bytes, so a client holding the megabyte revalidates,
-     * gets a 304, and keeps it. The tag has to describe what went out.
-     */
-    readonly servedWidth?: number | undefined;
+	/** Raw image bytes (already decoded from the wrapper's base64 cache). */
+	readonly bytes: Uint8Array;
+	/** MIME type — practically always `image/jpeg`. */
+	readonly contentType: string;
+	/** Epoch ms of the cached capture — drives the ETag and frame identity. */
+	readonly capturedAt: number;
+	/** Effective per-device max cache age (seconds) → `Cache-Control: max-age`. */
+	readonly maxAgeS: number;
+	/** State treatment painted over the capture (sleeping, waking, …). */
+	readonly variantKey?: string | undefined;
+	/**
+	* The width the returned BYTES are actually at, or undefined when they are the
+	* frame as captured.
+	*
+	* Deliberately not the same thing as the requested width. A failed resize
+	* serves the full frame, and stamping the requested `-w320` on it poisons the
+	* ETag: a later SUCCESSFUL resize of the same capture mints the identical tag
+	* with completely different bytes, so a client holding the megabyte revalidates,
+	* gets a 304, and keeps it. The tag has to describe what went out.
+	*/
+	readonly servedWidth?: number | undefined;
 }
 /** What the cache can answer about a device WITHOUT capturing anything. */
 export interface SnapshotPeek {
-    /** Epoch ms of the cached capture. */
-    readonly capturedAt: number;
-    /** Effective per-device max cache age (seconds). */
-    readonly maxAgeS: number;
-    /** State treatment that would be painted over this capture. */
-    readonly variantKey?: string | undefined;
+	/** Epoch ms of the cached capture. */
+	readonly capturedAt: number;
+	/** Effective per-device max cache age (seconds). */
+	readonly maxAgeS: number;
+	/** State treatment that would be painted over this capture. */
+	readonly variantKey?: string | undefined;
 }
 export interface SnapshotMediaHandlerDeps {
-    /**
-     * Resolve a device (+ optional stream, + force) to a renderable frame. Runs
-     * the wrapper's coalesced capture ladder; returns null when no frame can be
-     * produced (→ 404). Throwing produces an opaque 500 (caller logs).
-     */
-    readonly getMedia: (deviceId: number, streamId: string | undefined, force: boolean, width: number | undefined) => Promise<SnapshotMedia | null>;
-    /**
-     * Cache-only lookup: what frame is cached for this (device, stream) right now,
-     * and is it still FRESH? Returns null when nothing is cached or the entry is
-     * past its max-age.
-     *
-     * This exists so a conditional GET can be answered before `getMedia` runs.
-     * Without it a 304 is only cheap in bytes — the ladder and the resize have
-     * both already happened by the time the ETags are compared, which on a camera
-     * whose live paths are failing is two 15 s ffmpeg timeouts to send zero bytes.
-     *
-     * Width is deliberately absent: the ETag the client presents already names the
-     * width it holds, and it can only hold a tag this server minted, so matching
-     * the frame identity is sufficient. A client holding the FULL frame after a
-     * failed resize presents `"<id>-<ts>"`, which cannot collide with the
-     * `"<id>-<ts>-w320"` a `?w=320` request computes — it falls through and
-     * re-derives, which is exactly right.
-     *
-     * Optional: a host that does not supply it keeps the previous behaviour
-     * exactly (run the ladder, then compare).
-     */
-    readonly peekFresh?: (deviceId: number, streamId: string | undefined) => Promise<SnapshotPeek | null>;
+	/**
+	* Resolve a device (+ optional stream, + force) to a renderable frame. Runs
+	* the wrapper's coalesced capture ladder; returns null when no frame can be
+	* produced (→ 404). Throwing produces an opaque 500 (caller logs).
+	*/
+	readonly getMedia: (deviceId: number, streamId: string | undefined, force: boolean, width: number | undefined) => Promise<SnapshotMedia | null>;
+	/**
+	* Cache-only lookup: what frame is cached for this (device, stream) right now,
+	* and is it still FRESH? Returns null when nothing is cached or the entry is
+	* past its max-age.
+	*
+	* This exists so a conditional GET can be answered before `getMedia` runs.
+	* Without it a 304 is only cheap in bytes — the ladder and the resize have
+	* both already happened by the time the ETags are compared, which on a camera
+	* whose live paths are failing is two 15 s ffmpeg timeouts to send zero bytes.
+	*
+	* Width is deliberately absent: the ETag the client presents already names the
+	* width it holds, and it can only hold a tag this server minted, so matching
+	* the frame identity is sufficient. A client holding the FULL frame after a
+	* failed resize presents `"<id>-<ts>"`, which cannot collide with the
+	* `"<id>-<ts>-w320"` a `?w=320` request computes — it falls through and
+	* re-derives, which is exactly right.
+	*
+	* Optional: a host that does not supply it keeps the previous behaviour
+	* exactly (run the ladder, then compare).
+	*/
+	readonly peekFresh?: (deviceId: number, streamId: string | undefined) => Promise<SnapshotPeek | null>;
 }
 /** Parsed `/<deviceId>[.jpg][?streamId=…&force=1&w=320]` request. */
 export interface SnapshotMediaRequest {
-    readonly deviceId: number;
-    readonly streamId: string | undefined;
-    readonly force: boolean;
-    /** Snapped target width in px, or undefined for the frame as captured. */
-    readonly width: number | undefined;
+	readonly deviceId: number;
+	readonly streamId: string | undefined;
+	readonly force: boolean;
+	/** Snapped target width in px, or undefined for the frame as captured. */
+	readonly width: number | undefined;
 }
 /**
- * The widths a thumbnail may be served at.
- *
- * A ladder, not a free integer: the width is a cache key AND an ffmpeg run, so
- * honouring `?w=` verbatim would let any caller mint unbounded work and
- * unbounded memory. Twelve tiles measured at 181–240 px collapse onto one
- * variant instead of twelve.
- *
- * Rungs are chosen for the card sizes the viewer actually renders (180–390 px)
- * with headroom for a 2× device pixel ratio.
- */
+* The widths a thumbnail may be served at.
+*
+* A ladder, not a free integer: the width is a cache key AND an ffmpeg run, so
+* honouring `?w=` verbatim would let any caller mint unbounded work and
+* unbounded memory. Twelve tiles measured at 181–240 px collapse onto one
+* variant instead of twelve.
+*
+* Rungs are chosen for the card sizes the viewer actually renders (180–390 px)
+* with headroom for a 2× device pixel ratio.
+*/
 export declare const SNAPSHOT_WIDTH_LADDER: readonly number[];
 /** Snap UP to the next rung — never below what was asked, so the client is not
- *  handed an image it has to upscale. Above the ladder, the largest rung: the
- *  point is to stop serving the 4K original. */
+*  handed an image it has to upscale. Above the ladder, the largest rung: the
+*  point is to stop serving the 4K original. */
 export declare function snapSnapshotWidth(requested: number): number;
 /**
- * Parse the handler-relative path (`/<deviceId>.jpg?query`) into a request.
- * Returns null for a malformed / nested / non-numeric id so the handler answers
- * 404 without ever reaching `getMedia`.
- */
+* Parse the handler-relative path (`/<deviceId>.jpg?query`) into a request.
+* Returns null for a malformed / nested / non-numeric id so the handler answers
+* 404 without ever reaching `getMedia`.
+*/
 export declare function parseSnapshotMediaRequest(url: string): SnapshotMediaRequest | null;
 /**
- * The response's entity tag.
- *
- * It has to identify the VARIANT, not just the frame: the same capture can now
- * be served at several widths, from several streams, and with a camera-state
- * treatment, and a plain
- * `"<device>-<capturedAt>"` would let a client that fetched `?w=320` receive a
- * 304 for `?w=960` and render the small image at full size. The base form is
- * unchanged for a plain request, so the identity
- * `snapshot.getSnapshotOverview` advertises still matches the frame nobody
- * asked to resize.
- */
+* The response's entity tag.
+*
+* It has to identify the VARIANT, not just the frame: the same capture can now
+* be served at several widths, from several streams, and with a camera-state
+* treatment, and a plain
+* `"<device>-<capturedAt>"` would let a client that fetched `?w=320` receive a
+* 304 for `?w=960` and render the small image at full size. The base form is
+* unchanged for a plain request, so the identity
+* `snapshot.getSnapshotOverview` advertises still matches the frame nobody
+* asked to resize.
+*/
 export declare function snapshotEtag(variant: SnapshotVariantIdentity, capturedAt: number): string;
 /** The (device, stream, width) triple an ETag names. Structurally a
- *  {@link SnapshotMediaRequest}, but the width is the width SERVED — see
- *  {@link SnapshotMedia.servedWidth}. */
+*  {@link SnapshotMediaRequest}, but the width is the width SERVED — see
+*  {@link SnapshotMedia.servedWidth}. */
 export interface SnapshotVariantIdentity {
-    readonly deviceId: number;
-    readonly streamId: string | undefined;
-    readonly width: number | undefined;
-    readonly variantKey?: string | undefined;
+	readonly deviceId: number;
+	readonly streamId: string | undefined;
+	readonly width: number | undefined;
+	readonly variantKey?: string | undefined;
 }
 /**
- * Create a data-plane handler that serves per-device snapshots as JPEG images.
- * `deps.getMedia` is called once per request; null → 404, throw → 500. A
- * conditional GET with a matching `If-None-Match` produces a 304.
- */
+* Create a data-plane handler that serves per-device snapshots as JPEG images.
+* `deps.getMedia` is called once per request; null → 404, throw → 500. A
+* conditional GET with a matching `If-None-Match` produces a 304.
+*/
 export declare function createSnapshotMediaHandler(deps: SnapshotMediaHandlerDeps): DataPlaneHandler;

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

@@ -1,114 +1,75 @@
-/**
- * Downscaling a captured frame to a card-sized thumbnail.
- *
- * Applied AFTER capture rather than during it, and that is deliberate: the two
- * capture paths (the vendor's native HTTP snapshot and the ffmpeg keyframe
- * grab) produce a JPEG by different routes, and only one of them has an
- * ffmpeg filter chain to hook into. Resizing the finished bytes gives both the
- * same behaviour with one implementation.
- *
- * ── Why sharp and not ffmpeg (2026-08-11) ─────────────────────────────────
- * This used to `spawn('ffmpeg')` per resize. The snapshot wrapper is a system
- * builtin, so it loads in the hub's ROOT process: sampled on the live hub,
- * ~1.6 of those children were running at any instant, every one of them
- * parented by the root PID.
- *
- * Be precise about what that cost the root process, because it is easy to
- * overstate. The transcode itself ran in the CHILD and was charged to ffmpeg
- * (16 % + 13 % of a core in that same sample), not to the parent. What the
- * parent paid was the fork, the exec, the JPEG written into one pipe and read
- * back out of the other, and the base64 — real event-loop work, on the loop
- * that also serves the tRPC API, but NOT the 52 ms below.
- *
- * Benchmarked in that container, 2560×1440 → 640 wide, wall-clock per resize:
- *
- *     ffmpeg   52.0 ms   (fork + exec + pipe round-trip + teardown)
- *     sharp     4.8 ms   (in-process libvips, on its own threadpool)
- *
- * So this removes ~29 % of a core of container CPU and the per-resize process
- * churn from the root process. It was NOT verified to be the cause of that
- * process sitting at 90 % — nobody has profiled it.
- *
- * `sharp` is not a new dependency: it is already a host-external
- * (`HOST_EXTERNAL_SPECIFIERS`), already resolved from the framework closure at
- * runtime, and already used by the terminal frame renderer. The build preset
- * keeps it out of the bundle, so this import costs nothing at pack time.
- *
- * The cost is still one resize per (device, stream, width) per cache window —
- * not one per request. What changed is what a resize COSTS.
- */
 /** Runs the resize. Injected so the caller is testable without a real ffmpeg. */
 export type JpegResizer = (bytes: Buffer, width: number) => Promise<Buffer>;
-export declare const RESIZE_TIMEOUT_MS = 10000;
+export declare const RESIZE_TIMEOUT_MS = 1e4;
 /**
- * Scale to `width`, preserving aspect ratio.
- *
- * Rejects on failure or timeout. It NEVER falls back to the original silently —
- * a caller that quietly served the 4K frame when the resize failed would
- * reproduce exactly the bug this whole module exists to fix, and nobody would
- * see it. The caller decides, and logs.
- *
- * It DOES upscale a source narrower than `width`, and that is deliberate. A
- * `withoutEnlargement: true` was tried first — it is the obvious saving, since
- * upscaling pays encode cost for a blurrier, larger image. But the caller
- * stamps the response ETag from the width it asked for, and its resize-FAILURE
- * path already returns `width: undefined` specifically so a response can never
- * "claim a width the bytes do not have". Silently returning 320 px bytes for a
- * `w=640` request breaks that invariant on the SUCCESS path, where nobody is
- * looking. Honest output width beats a few saved pixels; revisit only together
- * with the ETag.
- */
+* Scale to `width`, preserving aspect ratio.
+*
+* Rejects on failure or timeout. It NEVER falls back to the original silently —
+* a caller that quietly served the 4K frame when the resize failed would
+* reproduce exactly the bug this whole module exists to fix, and nobody would
+* see it. The caller decides, and logs.
+*
+* It DOES upscale a source narrower than `width`, and that is deliberate. A
+* `withoutEnlargement: true` was tried first — it is the obvious saving, since
+* upscaling pays encode cost for a blurrier, larger image. But the caller
+* stamps the response ETag from the width it asked for, and its resize-FAILURE
+* path already returns `width: undefined` specifically so a response can never
+* "claim a width the bytes do not have". Silently returning 320 px bytes for a
+* `w=640` request breaks that invariant on the SUCCESS path, where nobody is
+* looking. Honest output width beats a few saved pixels; revisit only together
+* with the ETag.
+*/
 export declare function resizeJpeg(bytes: Buffer, width: number, timeoutMs?: number): Promise<Buffer>;
 /**
- * Resized frames, keyed by (device, stream, width, state treatment) AND
- * validated against the source frame's timestamp.
- *
- * The timestamp is the whole correctness argument: a variant outlives nothing.
- * When the underlying frame is recaptured its `capturedAt` moves, every variant
- * derived from the old one stops matching, and the next request re-derives.
- * Without that check a card would keep showing a thumbnail of a frame the
- * full-size view had already replaced.
- */
+* Resized frames, keyed by (device, stream, width, state treatment) AND
+* validated against the source frame's timestamp.
+*
+* The timestamp is the whole correctness argument: a variant outlives nothing.
+* When the underlying frame is recaptured its `capturedAt` moves, every variant
+* derived from the old one stops matching, and the next request re-derives.
+* Without that check a card would keep showing a thumbnail of a frame the
+* full-size view had already replaced.
+*/
 /**
- * Byte budget across every retained variant.
- *
- * Variants are small individually (a card-sized JPEG is tens of KB) but the key
- * space is a product — device × stream × width × state treatment — and the map
- * had no cap at all. 16 MiB is hundreds of thumbnails, far beyond any real
- * roster's working set, and turns an unbounded product into a ceiling.
- */
+* Byte budget across every retained variant.
+*
+* Variants are small individually (a card-sized JPEG is tens of KB) but the key
+* space is a product — device × stream × width × state treatment — and the map
+* had no cap at all. 16 MiB is hundreds of thumbnails, far beyond any real
+* roster's working set, and turns an unbounded product into a ceiling.
+*/
 export declare const SNAPSHOT_VARIANT_CACHE_MAX_BYTES: number;
 export interface SnapshotVariantCacheOptions {
-    /** Total variant bytes retained. Default {@link SNAPSHOT_VARIANT_CACHE_MAX_BYTES}. */
-    readonly maxBytes?: number;
-    /** Injected clock, so LRU order is testable without real time passing. */
-    readonly now?: () => number;
+	/** Total variant bytes retained. Default {@link SNAPSHOT_VARIANT_CACHE_MAX_BYTES}. */
+	readonly maxBytes?: number;
+	/** Injected clock, so LRU order is testable without real time passing. */
+	readonly now?: () => number;
 }
 export declare class SnapshotVariantCache {
-    private readonly byKey;
-    private readonly keysByDevice;
-    private readonly maxBytes;
-    private readonly now;
-    private totalBytes;
-    constructor(options?: SnapshotVariantCacheOptions);
-    private static key;
-    /** The variant for this exact frame, or undefined when it is missing or was
-     *  derived from an older capture.
-     *
-     *  A superseded variant is DELETED here, not merely reported missing. It used
-     *  to be left in the map: unreachable by every future read (its `sourceTs` can
-     *  never match again) and removed by nothing, so every recapture added a dead
-     *  key. Returning `undefined` while retaining the bytes is the leak. */
-    get(deviceId: number, streamId: string | undefined, width: number, sourceTs: number, variantKey?: string): Buffer | undefined;
-    set(deviceId: number, streamId: string | undefined, width: number, sourceTs: number, bytes: Buffer, variantKey?: string): void;
-    /** Variant bytes currently retained. */
-    sizeBytes(): number;
-    /** Variants currently retained — including any that are no longer readable.
-     *  The number that used to only ever go up. */
-    entryCount(): number;
-    /** Evict least-recently-accessed first until the budget holds. */
-    private enforceBudget;
-    private forget;
-    deleteDevice(deviceId: number): void;
-    clear(): void;
+	private readonly byKey;
+	private readonly keysByDevice;
+	private readonly maxBytes;
+	private readonly now;
+	private totalBytes;
+	constructor(options?: SnapshotVariantCacheOptions);
+	private static key;
+	/** The variant for this exact frame, or undefined when it is missing or was
+	*  derived from an older capture.
+	*
+	*  A superseded variant is DELETED here, not merely reported missing. It used
+	*  to be left in the map: unreachable by every future read (its `sourceTs` can
+	*  never match again) and removed by nothing, so every recapture added a dead
+	*  key. Returning `undefined` while retaining the bytes is the leak. */
+	get(deviceId: number, streamId: string | undefined, width: number, sourceTs: number, variantKey?: string): Buffer | undefined;
+	set(deviceId: number, streamId: string | undefined, width: number, sourceTs: number, bytes: Buffer, variantKey?: string): void;
+	/** Variant bytes currently retained. */
+	sizeBytes(): number;
+	/** Variants currently retained — including any that are no longer readable.
+	*  The number that used to only ever go up. */
+	entryCount(): number;
+	/** Evict least-recently-accessed first until the budget holds. */
+	private enforceBudget;
+	private forget;
+	deleteDevice(deviceId: number): void;
+	clear(): void;
 }