@camstack/system 1.2.390 → 1.2.392

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;

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;