@camstack/addon-provider-reolink 1.2.158 → 1.2.160

package/dist/addon.mjs

@@ -9,6 +9,7 @@ import path, { dirname, join } from "path";
 import * as crypto$7 from "crypto";
 import crypto$1, { createHash as createHash$1, randomUUID } from "crypto";
 import { execFile, spawn } from "child_process";
+import { createServer } from "node:http";
 import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { join as join$1 } from "node:path";
 import { PassThrough } from "stream";
@@ -5385,7 +5386,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-BVhJDJka.mjs
+//#region ../types/dist/sleep-De1BvmWo.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7854,10 +7855,20 @@ var CameraSwitchAuthoritySchema = discriminatedUnion("kind", [
 var CameraSwitchUnavailableReasonSchema = _enum([
 	"no-provider",
 	"source-unreachable",
-	"not-configured",
 	"device-disabled"
 ]);
 /**
+* Something true about a switch that is nonetheless OFFERED.
+*
+* The distinction from {@link CameraSwitchUnavailableReasonSchema} is the
+* whole point: a reason replaces the control, a warning travels WITH it. The
+* privacy mask taught us the difference — greying the one button that starts
+* the feature teaches the operator the feature is broken, while a live toggle
+* that flips nothing teaches them the switch is broken. Neither is true; the
+* honest surface is a working toggle that says what is missing.
+*/
+var CameraSwitchWarningSchema = _enum(["no-privacy-zones"]);
+/**
 * One switch, resolved for one camera.
 *
 * `label` and `costWhenOff` travel ON THE WIRE rather than being looked up
@@ -7876,6 +7887,11 @@ var CameraSwitchSchema = object({
 	/** False = do not render a control. `unavailableReason` says why. */
 	available: boolean(),
 	unavailableReason: CameraSwitchUnavailableReasonSchema.optional(),
+	/**
+	* Present on an AVAILABLE switch only. Rendered beside the live control;
+	* never a substitute for one.
+	*/
+	warning: CameraSwitchWarningSchema.optional(),
 	/** Current state. Meaningless when `available` is false — read it as `true`. */
 	enabled: boolean(),
 	authority: CameraSwitchAuthoritySchema
@@ -25139,6 +25155,15 @@ var CLIP_STILL_REASON_HEADER = "x-camstack-reason";
 var CLIP_STILL_REASON_CODE_HEADER = "x-camstack-reason-code";
 /** One {@link ClipStillDispositionSchema} token, alone. */
 var CLIP_STILL_DISPOSITION_HEADER = "x-camstack-disposition";
+/**
+* The clip STREAM route's own statement of what it is (D597): the value is
+* `forward-only`. A producer writes it on the 200; a consumer that dials a
+* URL and does not read it back refuses to play, because a progressive file
+* through a forward-only feeder looks like it worked until the first seek.
+* Named here because BOTH the provider and the broker spell it, and two
+* copies of a header name is how one of them stops being checked.
+*/
+var CLIP_STREAM_TRANSPORT_HEADER = "x-camstack-clip-transport";
 var ClipSchema = object({
 	/** Opaque, provider-namespaced id. The default provider encodes the time
 	*  window so `getClipPlayback` is self-contained (no event re-query). */
@@ -25424,6 +25449,82 @@ var ClipBytesSchema = object({
 	*/
 	durationMs: number().positive().optional()
 });
+/**
+* Where a clip's STREAM can be dialled (D597) — the answer to
+* {@link videoclipsCapability.methods.dialClipStream}.
+*
+* `url` is plain `http://` on the provider's own token-gated listener, one
+* shot, short-lived. It is NOT the hub-proxied `/addon/<id>/clip-stream/…`
+* path: that plane takes only a user credential, which an addon does not
+* hold, and the framework offers no addon→addon byte transport — the one
+* precedent is the broker's own restream URLs (`getStreamWithCodec`), which
+* a consumer dials directly, and this is that precedent one addon over.
+*/
+/**
+* The audio a clip stream can be asked for, and the audio it carries.
+*
+* The camera stores AAC and no WebRTC session speaks it, so a stream that
+* carries sound carries it TRANSCODED, muxed as a second track beside the
+* video by the one ffmpeg the provider already runs (D600). `opus` is
+* 48 kHz mono, `pcmu` is 8 kHz µ-law — the two codecs a broker session
+* negotiates — and `none` is a stream asked for, or served, without sound.
+*/
+var ClipStreamAudioSchema = _enum([
+	"opus",
+	"pcmu",
+	"none"
+]);
+/**
+* Why a stream that was ASKED for sound is not carrying it (D600).
+*
+* Only ever set beside `servedAudio: 'none'` after a non-`none` ask. Absent
+* means the ask was honoured, or there was no ask.
+*
+* - `not-requested` — the caller asked for `none`.
+* - `unsupported-ask` — the provider cannot produce that codec.
+*
+* Whether the RECORDING has sound at all is not knowable here: the camera
+* declares no audio track before its first frame arrives. That answer is in
+* the stream itself — an fMP4 with no audio track — and the broker reads it
+* there. A dial that says `opus` promises the codec, never the content.
+*/
+var ClipStreamAudioReasonSchema = _enum(["not-requested", "unsupported-ask"]);
+var ClipStreamDialSchema = object({
+	url: string().min(1),
+	/** After this the token is gone and the URL answers 404 `dial-expired`. */
+	expiresAtMs: number(),
+	/** What the stream IS — a consumer that cannot honour it must not dial. */
+	transport: literal("forward-only"),
+	/**
+	* Which twin the stream ACTUALLY carries — not what was asked for.
+	*
+	* The stream serves every profile (D599), and a recording whose main twin
+	* does not exist is streamed as its sub copy, which this field reports as
+	* `low`. That is the whole reason the dial no longer refuses `high`:
+	* stating what was served is what makes accepting honest, where a silent
+	* substitution would be the 33x lie D576 forbids. Stated rather than
+	* assumed, the way {@link ClipPlaybackSchema.served} is (D549 15).
+	*/
+	served: CamProfileSchema,
+	/**
+	* Which audio the stream will ACTUALLY carry — `served`'s companion for
+	* sound, and the same reasoning (D599, D600).
+	*
+	* The broker asks for the codec its WebRTC session negotiated, and the
+	* provider either muxes that codec or carries none. Stating it is what
+	* lets the broker wire the matching sink before the first byte, and what
+	* keeps a session from being handed a codec it cannot send — the audio
+	* shape of the substitution `served` exists to prevent.
+	*
+	* It is a promise about the CODEC, not about the content: a recording with
+	* no microphone track answers `opus` here and then arrives with no audio
+	* track at all. That second answer is in the stream, and the broker reads
+	* it from the `moov`.
+	*/
+	servedAudio: ClipStreamAudioSchema,
+	/** Why `servedAudio` is `none` although sound was asked for. */
+	audioReason: ClipStreamAudioReasonSchema.optional()
+});
 var ClipSourceAvailabilitySchema = object({
 	state: _enum([
 		"ok",
@@ -25674,6 +25775,44 @@ var videoclipsCapability = {
 		}), ClipBytesSchema, {
 			kind: "query",
 			auth: "protected"
+		}),
+		/**
+		* Where this clip's STREAM can be dialled (D597) — the forward-only
+		* fMP4 the provider writes from the first muxed byte, for the broker to
+		* play through the same WebRTC session as recorded footage, with the
+		* first frame at the first fragment instead of after the last byte.
+		*
+		* Nothing is fetched here: the answer is a one-shot URL on the
+		* provider's own listener, and the camera is touched when it is dialled.
+		* The gates the file path runs (`readClipBytes`) run on the dial too —
+		* the id, the row, a clip still being written — and refuse in the same
+		* vocabulary, THROWN with `clipExportFailure(<token>, <prose>)`. Every
+		* profile is served (D599) and the answer states which twin it carries;
+		* `high` is not refused. Optional on the provider for the same reason
+		* `readClipBytes` is: a source with no camera socket behind it (the
+		* recorder's analytics window, a HomeKit tee) has no stream.
+		*/
+		dialClipStream: optionalMethod(object({
+			deviceId: number(),
+			clipId: string().min(1),
+			/** WHICH provider holds the camera — see `readClipBytes.provider`. */
+			provider: string().min(1),
+			/** Which twin — `high` → the main file, everything else the sub (D599). */
+			profile: CamProfileSchema.optional(),
+			/**
+			* Which audio codec the caller's session negotiated, so the provider
+			* can mux it (D600). The ask travels on the DIAL because the mux is
+			* spawned once, before the first byte, and cannot gain a track later.
+			*
+			* ABSENT IS `none`, never a guess: a caller that does not state an
+			* ask is served the video-only stream that shipped first, so a broker
+			* older than this field keeps working unchanged (D382 — an unstated
+			* ask is zero).
+			*/
+			audio: ClipStreamAudioSchema.optional()
+		}), ClipStreamDialSchema, {
+			kind: "query",
+			auth: "protected"
 		})
 	}
 };
@@ -38012,6 +38151,1329 @@ var BATTERY_UNREACHABLE_AFTER_MS = 360 * 6e4;
 DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
 new Set(Object.values(DeviceType));
 DeviceFeature.BatteryOperated;
+/**
+* The vocabulary, in the order a picker offers it.
+*
+* Adding a key here is not enough to make it pickable: both glyph tables must
+* gain it too, and their tests fail until they do. That is the intended
+* friction — it is the only thing that keeps the two surfaces honest.
+*/
+var DISPLAY_ICON_VOCABULARY = [
+	{
+		key: "camera",
+		group: "device",
+		synonyms: [
+			"telecamera",
+			"videocamera",
+			"camera",
+			"cam"
+		]
+	},
+	{
+		key: "network",
+		group: "device",
+		synonyms: [
+			"rete",
+			"network",
+			"lan"
+		]
+	},
+	{
+		key: "toggle-left",
+		group: "device",
+		synonyms: [
+			"interruttore",
+			"switch",
+			"toggle"
+		]
+	},
+	{
+		key: "toggle-right",
+		group: "device",
+		synonyms: [
+			"interruttore",
+			"switch",
+			"toggle",
+			"acceso"
+		]
+	},
+	{
+		key: "circle-dot",
+		group: "device",
+		synonyms: [
+			"pulsante",
+			"bottone",
+			"button",
+			"dot"
+		]
+	},
+	{
+		key: "refresh-cw",
+		group: "device",
+		synonyms: [
+			"aggiorna",
+			"ricarica",
+			"refresh",
+			"reload",
+			"ciclo"
+		]
+	},
+	{
+		key: "box",
+		group: "device",
+		synonyms: [
+			"scatola",
+			"box",
+			"contenitore"
+		]
+	},
+	{
+		key: "scroll-text",
+		group: "device",
+		synonyms: [
+			"registro",
+			"log",
+			"testo"
+		]
+	},
+	{
+		key: "workflow",
+		group: "device",
+		synonyms: [
+			"automazione",
+			"flusso",
+			"workflow",
+			"scenario"
+		]
+	},
+	{
+		key: "lock",
+		group: "device",
+		synonyms: [
+			"serratura",
+			"chiave",
+			"lucchetto",
+			"chiuso",
+			"locked"
+		]
+	},
+	{
+		key: "lock-open",
+		group: "device",
+		synonyms: [
+			"serratura",
+			"aperta",
+			"sbloccato",
+			"unlocked"
+		]
+	},
+	{
+		key: "blinds",
+		group: "device",
+		synonyms: [
+			"tapparella",
+			"persiana",
+			"serranda",
+			"avvolgibile",
+			"shutter",
+			"blind",
+			"veneziana"
+		]
+	},
+	{
+		key: "air-vent",
+		group: "device",
+		synonyms: [
+			"bocchetta",
+			"aria",
+			"ventilazione",
+			"condizionatore",
+			"vent"
+		]
+	},
+	{
+		key: "monitor-play",
+		group: "device",
+		synonyms: [
+			"schermo",
+			"riproduzione",
+			"player",
+			"display"
+		]
+	},
+	{
+		key: "sliders-horizontal",
+		group: "device",
+		synonyms: [
+			"regolazione",
+			"cursori",
+			"impostazioni",
+			"slider"
+		]
+	},
+	{
+		key: "map-pin",
+		group: "device",
+		synonyms: [
+			"posizione",
+			"luogo",
+			"mappa",
+			"pin"
+		]
+	},
+	{
+		key: "bot",
+		group: "device",
+		synonyms: [
+			"robot",
+			"aspirapolvere",
+			"bot"
+		]
+	},
+	{
+		key: "tractor",
+		group: "device",
+		synonyms: [
+			"trattore",
+			"tosaerba",
+			"giardino"
+		]
+	},
+	{
+		key: "image",
+		group: "device",
+		synonyms: [
+			"immagine",
+			"foto",
+			"snapshot"
+		]
+	},
+	{
+		key: "bone",
+		group: "device",
+		synonyms: ["osso", "cane"]
+	},
+	{
+		key: "door-closed",
+		group: "device",
+		synonyms: [
+			"porta",
+			"chiusa",
+			"contatto"
+		]
+	},
+	{
+		key: "door-open",
+		group: "device",
+		synonyms: [
+			"porta",
+			"aperta",
+			"contatto",
+			"ingresso",
+			"uscita"
+		]
+	},
+	{
+		key: "crosshair",
+		group: "device",
+		synonyms: [
+			"mirino",
+			"puntamento",
+			"centro"
+		]
+	},
+	{
+		key: "eye",
+		group: "device",
+		synonyms: [
+			"occhio",
+			"visibile",
+			"visto"
+		]
+	},
+	{
+		key: "eye-off",
+		group: "device",
+		synonyms: [
+			"privacy",
+			"nascosto",
+			"oscurato",
+			"mascherato",
+			"invisibile"
+		]
+	},
+	{
+		key: "smartphone",
+		group: "device",
+		synonyms: [
+			"telefono",
+			"cellulare",
+			"smartphone"
+		]
+	},
+	{
+		key: "phone",
+		group: "device",
+		synonyms: ["telefono", "chiamata"]
+	},
+	{
+		key: "tablet",
+		group: "device",
+		synonyms: ["tablet", "ipad"]
+	},
+	{
+		key: "laptop",
+		group: "device",
+		synonyms: [
+			"portatile",
+			"laptop",
+			"notebook"
+		]
+	},
+	{
+		key: "monitor",
+		group: "device",
+		synonyms: ["monitor", "schermo"]
+	},
+	{
+		key: "tv",
+		group: "device",
+		synonyms: ["televisore", "tv"]
+	},
+	{
+		key: "speaker",
+		group: "device",
+		synonyms: [
+			"altoparlante",
+			"cassa",
+			"speaker"
+		]
+	},
+	{
+		key: "printer",
+		group: "device",
+		synonyms: ["stampante"]
+	},
+	{
+		key: "projector",
+		group: "device",
+		synonyms: ["proiettore"]
+	},
+	{
+		key: "gamepad-2",
+		group: "device",
+		synonyms: [
+			"console",
+			"gioco",
+			"joystick"
+		]
+	},
+	{
+		key: "radio",
+		group: "device",
+		synonyms: ["radio"]
+	},
+	{
+		key: "router",
+		group: "device",
+		synonyms: ["router", "modem"]
+	},
+	{
+		key: "bluetooth",
+		group: "device",
+		synonyms: ["bluetooth"]
+	},
+	{
+		key: "cpu",
+		group: "device",
+		synonyms: [
+			"processore",
+			"cpu",
+			"chip",
+			"dispositivo"
+		]
+	},
+	{
+		key: "hard-drive",
+		group: "device",
+		synonyms: [
+			"disco",
+			"hdd",
+			"archiviazione",
+			"storage"
+		]
+	},
+	{
+		key: "server",
+		group: "device",
+		synonyms: ["server", "nas"]
+	},
+	{
+		key: "mic",
+		group: "device",
+		synonyms: ["microfono", "audio"]
+	},
+	{
+		key: "mic-off",
+		group: "device",
+		synonyms: [
+			"microfono",
+			"spento",
+			"muto"
+		]
+	},
+	{
+		key: "video",
+		group: "device",
+		synonyms: ["video"]
+	},
+	{
+		key: "video-off",
+		group: "device",
+		synonyms: ["video", "spento"]
+	},
+	{
+		key: "music",
+		group: "device",
+		synonyms: ["musica"]
+	},
+	{
+		key: "plug",
+		group: "device",
+		synonyms: [
+			"presa",
+			"spina",
+			"plug"
+		]
+	},
+	{
+		key: "plug-zap",
+		group: "device",
+		synonyms: ["presa", "alimentata"]
+	},
+	{
+		key: "power",
+		group: "device",
+		synonyms: [
+			"accensione",
+			"alimentazione",
+			"power"
+		]
+	},
+	{
+		key: "power-off",
+		group: "device",
+		synonyms: ["spegnimento", "spento"]
+	},
+	{
+		key: "cable",
+		group: "device",
+		synonyms: ["cavo"]
+	},
+	{
+		key: "battery",
+		group: "device",
+		synonyms: ["batteria"]
+	},
+	{
+		key: "battery-charging",
+		group: "device",
+		synonyms: [
+			"batteria",
+			"carica",
+			"ricarica"
+		]
+	},
+	{
+		key: "battery-full",
+		group: "device",
+		synonyms: [
+			"batteria",
+			"carica",
+			"piena"
+		]
+	},
+	{
+		key: "battery-low",
+		group: "device",
+		synonyms: ["batteria", "scarica"]
+	},
+	{
+		key: "key",
+		group: "device",
+		synonyms: ["chiave"]
+	},
+	{
+		key: "key-round",
+		group: "device",
+		synonyms: ["chiave", "tonda"]
+	},
+	{
+		key: "mailbox",
+		group: "device",
+		synonyms: [
+			"cassetta",
+			"postale",
+			"posta"
+		]
+	},
+	{
+		key: "package",
+		group: "device",
+		synonyms: ["pacco", "consegna"]
+	},
+	{
+		key: "shield",
+		group: "device",
+		synonyms: [
+			"scudo",
+			"protezione",
+			"sicurezza",
+			"allarme"
+		]
+	},
+	{
+		key: "shield-check",
+		group: "device",
+		synonyms: [
+			"protetto",
+			"sicuro",
+			"armato"
+		]
+	},
+	{
+		key: "shield-off",
+		group: "device",
+		synonyms: [
+			"protezione",
+			"disattivata",
+			"disarmato"
+		]
+	},
+	{
+		key: "briefcase",
+		group: "device",
+		synonyms: [
+			"ufficio",
+			"lavoro",
+			"valigetta",
+			"studio"
+		]
+	},
+	{
+		key: "lightbulb",
+		group: "lighting",
+		synonyms: [
+			"luce",
+			"lampadina",
+			"lampada",
+			"light"
+		]
+	},
+	{
+		key: "lamp",
+		group: "lighting",
+		synonyms: ["lampada", "abatjour"]
+	},
+	{
+		key: "lamp-ceiling",
+		group: "lighting",
+		synonyms: [
+			"plafoniera",
+			"lampadario",
+			"luce",
+			"soffitto"
+		]
+	},
+	{
+		key: "lamp-desk",
+		group: "lighting",
+		synonyms: [
+			"lampada",
+			"scrivania",
+			"abatjour"
+		]
+	},
+	{
+		key: "lamp-floor",
+		group: "lighting",
+		synonyms: [
+			"piantana",
+			"lampada",
+			"terra"
+		]
+	},
+	{
+		key: "flashlight",
+		group: "lighting",
+		synonyms: [
+			"faretto",
+			"torcia",
+			"spot",
+			"faro"
+		]
+	},
+	{
+		key: "heater",
+		group: "lighting",
+		synonyms: [
+			"riscaldamento",
+			"termosifone",
+			"stufa",
+			"calore"
+		]
+	},
+	{
+		key: "snowflake",
+		group: "lighting",
+		synonyms: [
+			"freddo",
+			"raffrescamento",
+			"aria",
+			"condizionata",
+			"neve"
+		]
+	},
+	{
+		key: "thermometer-sun",
+		group: "lighting",
+		synonyms: [
+			"caldo",
+			"temperatura",
+			"alta"
+		]
+	},
+	{
+		key: "thermometer-snowflake",
+		group: "lighting",
+		synonyms: [
+			"freddo",
+			"temperatura",
+			"bassa"
+		]
+	},
+	{
+		key: "refrigerator",
+		group: "lighting",
+		synonyms: ["frigorifero", "frigo"]
+	},
+	{
+		key: "microwave",
+		group: "lighting",
+		synonyms: ["microonde", "forno"]
+	},
+	{
+		key: "washing-machine",
+		group: "lighting",
+		synonyms: [
+			"lavatrice",
+			"lavastoviglie",
+			"asciugatrice"
+		]
+	},
+	{
+		key: "cooking-pot",
+		group: "lighting",
+		synonyms: [
+			"pentola",
+			"cucina",
+			"fornello"
+		]
+	},
+	{
+		key: "utensils",
+		group: "lighting",
+		synonyms: [
+			"cucina",
+			"posate",
+			"sala",
+			"pranzo"
+		]
+	},
+	{
+		key: "thermometer",
+		group: "sensing",
+		synonyms: [
+			"temperatura",
+			"termometro",
+			"termostato"
+		]
+	},
+	{
+		key: "droplets",
+		group: "sensing",
+		synonyms: [
+			"umidita",
+			"acqua",
+			"allagamento",
+			"perdita"
+		]
+	},
+	{
+		key: "droplet",
+		group: "sensing",
+		synonyms: [
+			"goccia",
+			"acqua",
+			"perdita",
+			"allagamento"
+		]
+	},
+	{
+		key: "gauge",
+		group: "sensing",
+		synonyms: [
+			"misura",
+			"livello",
+			"pressione",
+			"indicatore"
+		]
+	},
+	{
+		key: "gauge2",
+		group: "sensing",
+		synonyms: [
+			"misura",
+			"livello",
+			"pressione",
+			"indicatore"
+		],
+		aliasOf: "gauge"
+	},
+	{
+		key: "sun",
+		group: "sensing",
+		synonyms: [
+			"sole",
+			"luminosita",
+			"giorno",
+			"esterno"
+		]
+	},
+	{
+		key: "sun-medium",
+		group: "sensing",
+		synonyms: ["sole", "luminosita"]
+	},
+	{
+		key: "sunrise",
+		group: "sensing",
+		synonyms: ["alba"]
+	},
+	{
+		key: "moon",
+		group: "sensing",
+		synonyms: [
+			"notte",
+			"luna",
+			"notturna",
+			"nightvision"
+		]
+	},
+	{
+		key: "wind",
+		group: "sensing",
+		synonyms: [
+			"vento",
+			"aria",
+			"gas",
+			"monossido",
+			"co"
+		]
+	},
+	{
+		key: "cloud",
+		group: "sensing",
+		synonyms: ["nuvola", "nuvoloso"]
+	},
+	{
+		key: "cloud-rain",
+		group: "sensing",
+		synonyms: ["pioggia"]
+	},
+	{
+		key: "cloud-sun",
+		group: "sensing",
+		synonyms: [
+			"variabile",
+			"sole",
+			"nuvole"
+		]
+	},
+	{
+		key: "waves",
+		group: "sensing",
+		synonyms: [
+			"onde",
+			"acqua",
+			"vibrazione"
+		]
+	},
+	{
+		key: "sprout",
+		group: "sensing",
+		synonyms: [
+			"irrigazione",
+			"pianta",
+			"germoglio",
+			"orto"
+		]
+	},
+	{
+		key: "leaf",
+		group: "sensing",
+		synonyms: [
+			"foglia",
+			"pianta",
+			"verde"
+		]
+	},
+	{
+		key: "flower",
+		group: "sensing",
+		synonyms: ["fiore", "pianta"]
+	},
+	{
+		key: "zap",
+		group: "sensing",
+		synonyms: [
+			"energia",
+			"corrente",
+			"consumo",
+			"watt",
+			"elettricita"
+		]
+	},
+	{
+		key: "flame",
+		group: "sensing",
+		synonyms: [
+			"fiamma",
+			"gas",
+			"fuoco",
+			"incendio"
+		]
+	},
+	{
+		key: "bell",
+		group: "sensing",
+		synonyms: [
+			"campanello",
+			"suoneria",
+			"notifica",
+			"bell",
+			"chime"
+		]
+	},
+	{
+		key: "bell-ring",
+		group: "sensing",
+		synonyms: [
+			"campanello",
+			"suona",
+			"doorbell",
+			"notifica"
+		]
+	},
+	{
+		key: "bell-off",
+		group: "sensing",
+		synonyms: [
+			"silenzioso",
+			"notifiche",
+			"disattivate",
+			"muto"
+		]
+	},
+	{
+		key: "siren",
+		group: "sensing",
+		synonyms: ["sirena", "allarme"]
+	},
+	{
+		key: "radar",
+		group: "sensing",
+		synonyms: [
+			"movimento",
+			"presenza",
+			"pir",
+			"rilevamento",
+			"radar"
+		]
+	},
+	{
+		key: "activity",
+		group: "sensing",
+		synonyms: [
+			"attivita",
+			"sensore",
+			"generico"
+		]
+	},
+	{
+		key: "hash",
+		group: "sensing",
+		synonyms: [
+			"numero",
+			"contatore",
+			"valore"
+		]
+	},
+	{
+		key: "clock",
+		group: "sensing",
+		synonyms: [
+			"orologio",
+			"ora",
+			"tempo"
+		]
+	},
+	{
+		key: "timer",
+		group: "sensing",
+		synonyms: [
+			"timer",
+			"conto",
+			"rovescia"
+		]
+	},
+	{
+		key: "calendar",
+		group: "sensing",
+		synonyms: [
+			"calendario",
+			"data",
+			"pianificazione"
+		]
+	},
+	{
+		key: "pipette",
+		group: "sensing",
+		synonyms: [
+			"qualita",
+			"aria",
+			"misura",
+			"campione"
+		]
+	},
+	{
+		key: "fan",
+		group: "sensing",
+		synonyms: [
+			"ventilatore",
+			"ventola",
+			"aria"
+		]
+	},
+	{
+		key: "bath",
+		group: "sensing",
+		synonyms: [
+			"bagno",
+			"vasca",
+			"doccia"
+		]
+	},
+	{
+		key: "footprints",
+		group: "sensing",
+		synonyms: [
+			"movimento",
+			"passi",
+			"presenza",
+			"motion"
+		]
+	},
+	{
+		key: "alarm-smoke",
+		group: "sensing",
+		synonyms: [
+			"fumo",
+			"antincendio",
+			"rilevatore"
+		]
+	},
+	{
+		key: "shield-alert",
+		group: "sensing",
+		synonyms: [
+			"manomissione",
+			"allarme",
+			"tamper",
+			"avviso"
+		]
+	},
+	{
+		key: "vibrate",
+		group: "sensing",
+		synonyms: [
+			"vibrazione",
+			"urto",
+			"tamper"
+		]
+	},
+	{
+		key: "wifi",
+		group: "sensing",
+		synonyms: [
+			"wifi",
+			"rete",
+			"segnale"
+		]
+	},
+	{
+		key: "wifi-off",
+		group: "sensing",
+		synonyms: [
+			"wifi",
+			"assente",
+			"offline",
+			"disconnesso"
+		]
+	},
+	{
+		key: "volume-2",
+		group: "sensing",
+		synonyms: [
+			"volume",
+			"audio",
+			"altoparlante",
+			"suono"
+		]
+	},
+	{
+		key: "volume-x",
+		group: "sensing",
+		synonyms: [
+			"muto",
+			"silenziato",
+			"volume",
+			"spento"
+		]
+	},
+	{
+		key: "heart",
+		group: "sensing",
+		synonyms: [
+			"cuore",
+			"preferito",
+			"salute"
+		]
+	},
+	{
+		key: "heart-pulse",
+		group: "sensing",
+		synonyms: [
+			"battito",
+			"salute",
+			"monitoraggio"
+		]
+	},
+	{
+		key: "star",
+		group: "sensing",
+		synonyms: [
+			"preferito",
+			"stella",
+			"importante"
+		]
+	},
+	{
+		key: "sparkles",
+		group: "sensing",
+		synonyms: [
+			"automatico",
+			"intelligente",
+			"ai",
+			"scena"
+		]
+	},
+	{
+		key: "house",
+		group: "place",
+		synonyms: [
+			"casa",
+			"abitazione",
+			"home"
+		]
+	},
+	{
+		key: "sofa",
+		group: "place",
+		synonyms: [
+			"salone",
+			"soggiorno",
+			"divano",
+			"living"
+		]
+	},
+	{
+		key: "bed-double",
+		group: "place",
+		synonyms: [
+			"camera",
+			"letto",
+			"matrimoniale"
+		]
+	},
+	{
+		key: "bed",
+		group: "place",
+		synonyms: [
+			"cameretta",
+			"letto",
+			"singolo"
+		]
+	},
+	{
+		key: "warehouse",
+		group: "place",
+		synonyms: [
+			"magazzino",
+			"capanno",
+			"deposito",
+			"cantina"
+		]
+	},
+	{
+		key: "trees",
+		group: "place",
+		synonyms: [
+			"giardino",
+			"alberi",
+			"esterno",
+			"parco"
+		]
+	},
+	{
+		key: "tree-pine",
+		group: "place",
+		synonyms: [
+			"albero",
+			"pino",
+			"giardino"
+		]
+	},
+	{
+		key: "fence",
+		group: "place",
+		synonyms: [
+			"recinto",
+			"cancello",
+			"staccionata",
+			"perimetro"
+		]
+	},
+	{
+		key: "store",
+		group: "place",
+		synonyms: [
+			"negozio",
+			"ingresso",
+			"vetrina"
+		]
+	},
+	{
+		key: "building",
+		group: "place",
+		synonyms: ["edificio", "palazzo"]
+	},
+	{
+		key: "building-2",
+		group: "place",
+		synonyms: [
+			"edificio",
+			"uffici",
+			"condominio"
+		]
+	},
+	{
+		key: "mountain",
+		group: "place",
+		synonyms: [
+			"montagna",
+			"esterno",
+			"panorama"
+		]
+	},
+	{
+		key: "umbrella",
+		group: "place",
+		synonyms: [
+			"tenda",
+			"markise",
+			"ombrellone",
+			"pergola",
+			"veranda"
+		]
+	},
+	{
+		key: "dumbbell",
+		group: "place",
+		synonyms: ["palestra", "attrezzi"]
+	},
+	{
+		key: "wrench",
+		group: "place",
+		synonyms: [
+			"officina",
+			"manutenzione",
+			"attrezzi",
+			"utenze"
+		]
+	},
+	{
+		key: "hammer",
+		group: "place",
+		synonyms: [
+			"officina",
+			"martello",
+			"lavori"
+		]
+	},
+	{
+		key: "drill",
+		group: "place",
+		synonyms: [
+			"officina",
+			"trapano",
+			"lavori"
+		]
+	},
+	{
+		key: "waves-ladder",
+		group: "place",
+		synonyms: ["piscina", "vasca"]
+	},
+	{
+		key: "circle-parking",
+		group: "place",
+		synonyms: [
+			"parcheggio",
+			"posto",
+			"auto",
+			"garage"
+		]
+	},
+	{
+		key: "route",
+		group: "place",
+		synonyms: [
+			"percorso",
+			"strada",
+			"vialetto",
+			"tragitto"
+		]
+	},
+	{
+		key: "car",
+		group: "life",
+		synonyms: [
+			"auto",
+			"macchina",
+			"veicolo",
+			"parcheggio"
+		]
+	},
+	{
+		key: "bike",
+		group: "life",
+		synonyms: [
+			"bicicletta",
+			"bici",
+			"moto"
+		]
+	},
+	{
+		key: "bus",
+		group: "life",
+		synonyms: ["autobus", "pullman"]
+	},
+	{
+		key: "truck",
+		group: "life",
+		synonyms: [
+			"camion",
+			"furgone",
+			"consegna"
+		]
+	},
+	{
+		key: "plane",
+		group: "life",
+		synonyms: ["aereo"]
+	},
+	{
+		key: "train-front",
+		group: "life",
+		synonyms: ["treno"]
+	},
+	{
+		key: "sailboat",
+		group: "life",
+		synonyms: ["barca", "imbarcazione"]
+	},
+	{
+		key: "dog",
+		group: "life",
+		synonyms: ["cane", "animale"]
+	},
+	{
+		key: "cat",
+		group: "life",
+		synonyms: ["gatto", "animale"]
+	},
+	{
+		key: "bird",
+		group: "life",
+		synonyms: ["uccello", "animale"]
+	},
+	{
+		key: "paw-print",
+		group: "life",
+		synonyms: [
+			"animale",
+			"zampa",
+			"pet"
+		]
+	},
+	{
+		key: "baby",
+		group: "life",
+		synonyms: [
+			"neonato",
+			"bimbo",
+			"cameretta",
+			"babymonitor"
+		]
+	},
+	{
+		key: "user",
+		group: "life",
+		synonyms: ["persona", "utente"]
+	},
+	{
+		key: "users",
+		group: "life",
+		synonyms: [
+			"persone",
+			"gruppo",
+			"famiglia"
+		]
+	},
+	{
+		key: "person-standing",
+		group: "life",
+		synonyms: [
+			"persona",
+			"piedi",
+			"presenza"
+		]
+	}
+];
+DISPLAY_ICON_VOCABULARY.map((e) => e.key);
+DISPLAY_ICON_VOCABULARY.filter((e) => e.aliasOf === void 0).map((e) => e.key);
+new Map(DISPLAY_ICON_VOCABULARY.map((e) => [e.key, e]));
 var LAST_FETCHED_FIELD = "lastFetchedAt";
 /**
 * How long a bridge stops re-attempting a refresh that did not land.
@@ -44957,6 +46419,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"videoclips.dialClipStream": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"videoclips.getClipPlayback": {
 		capName: "videoclips",
 		capScope: "device",
@@ -46996,6 +48464,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"videoclips.dialClipStream": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"videoclips.getClipPlayback": [{
 		name: "deviceId",
 		form: "single",
@@ -76810,7 +78283,7 @@ var require_lz4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 }));
 //#endregion
-//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-5PJ6XPBF.js
+//#region node_modules/@apocaliss92/nodelink-js/dist/chunk-GNC5U3YA.js
 var import_fxp = require_fxp();
 var import_lz4 = /* @__PURE__ */ __toESM(require_lz4(), 1);
 function encodeHeader(h) {
@@ -80975,6 +82448,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter {
 						lockedChannelId = frame.header.channelId;
 						lockedStreamType = frame.header.streamType;
 					}
+					params.onChunk?.(decrypted);
 					chunks.push(decrypted);
 					armIdleFinish();
 					if (frame.header.responseCode === 201) finish(Buffer.concat(chunks));
@@ -92981,7 +94455,8 @@ ${stderr}`));
 				payloadXml,
 				streamType: 0,
 				timeoutMs,
-				...params.idleTimeoutMs != null ? { idleTimeoutMs: params.idleTimeoutMs } : {}
+				...params.idleTimeoutMs != null ? { idleTimeoutMs: params.idleTimeoutMs } : {},
+				...params.onChunk ? { onChunk: params.onChunk } : {}
 			});
 		} catch (e) {
 			trace(`download failed: ${e instanceof Error ? e.message : String(e)}`);
@@ -149045,6 +150520,161 @@ function createClipPlaybackHandler(deps) {
 		}).pipe(res);
 	};
 }
+/**
+* `/addon/provider-reolink/clip-stream/<deviceId>/<clipKey>.mp4` — the same
+* recording as `clip/…`, served as it ARRIVES from the camera.
+*
+* **Not `Range`-able, and it says so.** The response has no length: it is a
+* fragmented MP4 written by an ffmpeg that is still reading the camera when
+* the first byte leaves. So there is no `content-length`, `accept-ranges` is
+* `none`, a `Range` header is IGNORED (a 206 over something with no length
+* would be a lie), and the peer may not cache it (`no-store`) — a stream is
+* not an immutable artifact, the file route is. The status line is written
+* on the first muxed byte, never before: until then every refusal still owns
+* it, and a camera that serves nothing answers a status with a reason, not an
+* empty 200 (D391).
+*
+* `HEAD` answers the headers and touches no camera.
+*/
+var CLIP_STREAM_PREFIX = "clip-stream";
+/** The data plane's own form: the clip is named on the path. */
+var resolveClipStreamPathTarget = (req) => {
+	const match = MEDIA_PATH.exec(pathnameOf(req));
+	if (match === null) return {
+		kind: "refused",
+		status: 400,
+		code: "bad-path",
+		detail: "not /<deviceId>/<clipKey>.mp4"
+	};
+	return {
+		kind: "target",
+		target: {
+			deviceId: Number(match[1]),
+			clipKey: match[2] ?? "",
+			twin: "sub",
+			audio: "none"
+		}
+	};
+};
+/**
+* Everything but the content type, which the MUX decides: a stream carrying
+* µ-law is a QuickTime container (measured — ffmpeg's MP4 muxer refuses
+* `pcm_mulaw`), and a header that said `video/mp4` for it would be a small
+* lie on a plane whose whole point is saying what it really serves.
+*/
+var STREAM_HEADERS = {
+	"accept-ranges": "none",
+	"cache-control": "no-store",
+	[CLIP_STREAM_TRANSPORT_HEADER]: "forward-only"
+};
+/** The status a refusal answers. `404` = nothing here to serve; `409` = a
+*  clip that exists and cannot be served right now; `502` = the camera. */
+function streamRefusalStatus(code) {
+	switch (code) {
+		case "unknown-device":
+		case "no-catalog-row": return 404;
+		case "sleeping":
+		case "uid-missing":
+		case "clip-in-progress": return 409;
+		case "camera-refused":
+		case "fetch-failed": return 502;
+	}
+}
+function createClipStreamHandler(deps) {
+	const resolveTarget = deps.target ?? resolveClipStreamPathTarget;
+	return async (req, res) => {
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			res.writeHead(405, { allow: "GET, HEAD" });
+			res.end();
+			return;
+		}
+		const resolved = resolveTarget(req);
+		if (resolved.kind === "refused") {
+			deps.logger.warn("videoclips: clip stream request names no clip", { meta: {
+				code: resolved.code,
+				reason: resolved.detail,
+				status: resolved.status
+			} });
+			res.writeHead(resolved.status, {
+				[CLIP_STILL_REASON_HEADER]: resolved.detail.slice(0, 500),
+				[CLIP_STILL_REASON_CODE_HEADER]: resolved.code
+			});
+			res.end();
+			return;
+		}
+		const { deviceId, clipKey } = resolved.target;
+		if (req.method === "HEAD") {
+			res.writeHead(200, {
+				"content-type": "video/mp4",
+				...STREAM_HEADERS
+			});
+			res.end();
+			return;
+		}
+		if (req.headers.range !== void 0) deps.logger.debug("videoclips: a Range header on the clip stream route is ignored", {
+			tags: { deviceId },
+			meta: {
+				clipKey,
+				range: req.headers.range
+			}
+		});
+		const sink = {
+			begin: (contentType) => {
+				res.writeHead(200, {
+					"content-type": contentType,
+					...STREAM_HEADERS
+				});
+			},
+			write: (chunk) => res.write(chunk),
+			onceDrain: (listener) => {
+				res.once("drain", listener);
+			},
+			onceClose: (listener) => {
+				res.once("close", listener);
+			},
+			end: () => {
+				res.end();
+			},
+			destroy: () => {
+				res.destroy();
+			}
+		};
+		let outcome;
+		try {
+			outcome = await deps.stream(resolved.target, sink);
+		} catch (err) {
+			deps.logger.warn("videoclips: the clip stream route threw", {
+				tags: { deviceId },
+				meta: {
+					clipKey,
+					branch: "stream-threw",
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+			if (res.headersSent) res.destroy();
+			else {
+				res.writeHead(500);
+				res.end();
+			}
+			return;
+		}
+		if (outcome.kind !== "refused") return;
+		deps.logger.info("videoclips: clip stream not served", {
+			tags: { deviceId },
+			meta: {
+				clipKey,
+				code: outcome.code,
+				reason: outcome.detail,
+				status: streamRefusalStatus(outcome.code)
+			}
+		});
+		res.writeHead(streamRefusalStatus(outcome.code), {
+			[CLIP_STILL_REASON_HEADER]: outcome.detail.slice(0, 500),
+			[CLIP_STILL_REASON_CODE_HEADER]: outcome.code
+		});
+		res.end();
+	};
+}
 //#endregion
 //#region src/clips/clip-mux.ts
 /** A clip that has not transferred by here is not going to. */
@@ -149202,6 +150832,147 @@ function describeMuxFailure(run) {
 	if (run.code !== 0) return `mux-failed (exit ${String(run.code)}): ${run.stderr.slice(0, 300)}`;
 	return null;
 }
+/** The fragmented container a stream is muxed into — see the file header. */
+var CLIP_STREAM_MOVFLAGS = "frag_keyframe+empty_moov+default_base_moof";
+/**
+* The rate the probe measured, through the library's one derivation.
+*
+* `estimateVideoTiming` falls back to the info header when the timestamps
+* cannot say; that fallback is REFUSED here (`fpsSource: 'unmeasured'`), as
+* D567 says, so a guess is never handed to `-r` under a measurement's name.
+*/
+function probeClipStreamRate(timestampsUs) {
+	const timing = estimateVideoTiming({ timestampsUs });
+	if (timing.fpsSource !== "timestamps" || timing.fps === null) return {
+		fps: null,
+		fpsSource: "unmeasured",
+		accessUnits: timestampsUs.length
+	};
+	return {
+		fps: timing.fps,
+		fpsSource: "timestamps",
+		accessUnits: timestampsUs.length
+	};
+}
+/** Opus at 48 kHz — the only rate the codec has, and the session's RTP clock. */
+var CLIP_STREAM_OPUS_RATE_HZ = 48e3;
+/** µ-law at 8 kHz — the PCMU RTP clock. */
+var CLIP_STREAM_PCMU_RATE_HZ = 8e3;
+/**
+* The container a stream is muxed into, for a given audio ask.
+*
+* MEASURED, not chosen: ffmpeg's MP4 muxer refuses `pcm_mulaw`
+* (`Could not find tag for codec pcm_mulaw in stream #1`), and its MOV muxer
+* takes it as a `ulaw` sample entry. The boxes a consumer walks are the same
+* either way — `ftyp`, an empty `moov`, then `moof`+`mdat` — so this changes
+* the content type and nothing else.
+*/
+function clipStreamContainerFor(audio) {
+	return audio === "pcmu" ? "mov" : "mp4";
+}
+/** What the route puts on `content-type` for {@link clipStreamContainerFor}. */
+function clipStreamContentTypeFor(audio) {
+	return clipStreamContainerFor(audio) === "mov" ? "video/quicktime" : "video/mp4";
+}
+/**
+* One ffmpeg, stdin to stdout, fragmented, with an optional second input.
+*
+* Mirrors `buildClipMuxArgs` where a stream can: the demuxer is named from
+* the DETECTED codec (the BcMedia header lies on a hub child), `-r` is an
+* input option before its own `-i`, and the video is copied. Where it
+* cannot — `+faststart` — the file header says why; where it now can — the
+* audio input — it is an ENCODE rather than the file path's copy, because
+* this output is consumed by a WebRTC sender and not by a player.
+*/
+function buildClipStreamMuxArgs(input) {
+	const demuxer = input.videoType === "H265" ? "hevc" : "h264";
+	const audio = input.audio;
+	return [
+		"-hide_banner",
+		"-loglevel",
+		"error",
+		"-nostdin",
+		...input.fps !== null && Number.isFinite(input.fps) && input.fps > 0 ? ["-r", String(input.fps)] : [],
+		"-f",
+		demuxer,
+		"-i",
+		"pipe:0",
+		...audio !== null ? [
+			"-f",
+			"aac",
+			"-i",
+			`pipe:${String(3)}`
+		] : [],
+		...audio !== null ? [
+			"-map",
+			"0:v",
+			"-map",
+			"1:a"
+		] : [],
+		"-c:v",
+		"copy",
+		...audio === "opus" ? [
+			"-c:a",
+			"libopus",
+			"-ar",
+			String(CLIP_STREAM_OPUS_RATE_HZ),
+			"-ac",
+			String(1),
+			"-b:a",
+			"24k"
+		] : [],
+		...audio === "pcmu" ? [
+			"-c:a",
+			"pcm_mulaw",
+			"-ar",
+			String(CLIP_STREAM_PCMU_RATE_HZ),
+			"-ac",
+			String(1)
+		] : [],
+		"-movflags",
+		CLIP_STREAM_MOVFLAGS,
+		"-f",
+		clipStreamContainerFor(audio),
+		"pipe:1"
+	];
+}
+/**
+* The D447 rule as a state machine, so it can be proved without a socket.
+*
+* A `false` write ARMS the timer; further `false` writes while it is armed do
+* not push the deadline out. `drain` — the hop's own word that it took what
+* it held — disarms it. Stall fires at most once, and a disposed gate is
+* silent for ever.
+*/
+function createDrainGate(deps) {
+	let handle = null;
+	let stalled = false;
+	const disarm = () => {
+		if (handle !== null) clearTimeout(handle);
+		handle = null;
+	};
+	return {
+		wrote(accepted) {
+			if (accepted || handle !== null || stalled) return;
+			handle = setTimeout(() => {
+				handle = null;
+				if (stalled) return;
+				stalled = true;
+				deps.onStall();
+			}, deps.timeoutMs);
+		},
+		drained() {
+			disarm();
+		},
+		waiting() {
+			return handle !== null;
+		},
+		dispose() {
+			disarm();
+			stalled = true;
+		}
+	};
+}
 //#endregion
 //#region src/clips/clip-truncation.ts
 /**
@@ -149248,6 +151019,885 @@ function judgeClipDuration(input) {
 	};
 }
 //#endregion
+//#region src/clips/clip-stream.ts
+function isWritable(stream) {
+	return "write" in stream && typeof stream.write === "function";
+}
+/** The stream at `index`, if it is one this process can be WRITTEN to. */
+function writableAt(stdio, index) {
+	const candidate = stdio[index];
+	if (candidate === null || candidate === void 0) return null;
+	return isWritable(candidate) ? candidate : null;
+}
+var defaultDecoder = (handlers) => new BcMediaAnnexBDecoder({
+	strict: false,
+	onVideoAccessUnit: handlers.onVideoAccessUnit,
+	onAudioFrame: (frame) => handlers.onAudioFrame({
+		audioType: frame.audioType,
+		data: frame.data
+	})
+});
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createClipStreamProducer(deps) {
+	const sleep = deps.sleep ?? defaultSleep;
+	const createDecoder = deps.createDecoder ?? defaultDecoder;
+	const drainTimeoutMs = deps.drainTimeoutMs ?? 1e4;
+	const flushTimeoutMs = deps.flushTimeoutMs ?? 15e3;
+	const lanes = /* @__PURE__ */ new Map();
+	const activeByHost = /* @__PURE__ */ new Map();
+	const runAttempt = (input, attempt) => new ClipStreamRun({
+		logger: deps.logger,
+		spawnMux: deps.spawnMux,
+		createDecoder,
+		drainTimeoutMs,
+		flushTimeoutMs
+	}, input, attempt).run();
+	const runAttempts = async (input) => {
+		const { deviceId } = input.device;
+		let lastDetail = "no reason given";
+		for (let attempt = 1; attempt <= 3; attempt += 1) {
+			if (attempt > 1) await sleep(500 * 2 ** (attempt - 2));
+			const result = await runAttempt(input, attempt);
+			if (result.kind !== "no-media") return result;
+			lastDetail = result.detail;
+			deps.logger.warn("videoclips: a clip stream produced no media — retrying", {
+				tags: { deviceId },
+				meta: {
+					clipKey: input.row.clipKey,
+					twin: input.twin,
+					branch: "stream-no-media",
+					attempt,
+					error: lastDetail
+				}
+			});
+		}
+		deps.logger.warn("videoclips: the camera never delivered this clip stream", {
+			tags: { deviceId },
+			meta: {
+				clipKey: input.row.clipKey,
+				twin: input.twin,
+				branch: "camera-refused",
+				attempts: 3,
+				error: lastDetail
+			}
+		});
+		return {
+			kind: "refused",
+			code: "camera-refused",
+			detail: `clip stream never landed after 3 attempts — ${lastDetail}`,
+			attempts: 3
+		};
+	};
+	return {
+		active: (hostKey) => activeByHost.get(hostKey) ?? 0,
+		stream: (input) => {
+			const { hostKey, deviceId } = input.device;
+			const ahead = activeByHost.get(hostKey) ?? 0;
+			if (ahead > 0) deps.logger.info("videoclips: a clip stream is queued behind another on this host", {
+				tags: { deviceId },
+				meta: {
+					clipKey: input.row.clipKey,
+					twin: input.twin,
+					branch: "stream-queued",
+					ahead
+				}
+			});
+			activeByHost.set(hostKey, ahead + 1);
+			const run = (lanes.get(hostKey) ?? Promise.resolve()).then(() => runAttempts(input)).finally(() => {
+				const left = (activeByHost.get(hostKey) ?? 1) - 1;
+				if (left <= 0) activeByHost.delete(hostKey);
+				else activeByHost.set(hostKey, left);
+			});
+			lanes.set(hostKey, run.then(() => void 0, () => void 0));
+			return run;
+		}
+	};
+}
+/**
+* One transfer: camera → decoder → ffmpeg → peer, with a cut on every hop.
+*
+* A class because the run is a state machine with a dozen fields the chunk
+* callback and the download promise both touch; passing them around as
+* closures over `let`s was less readable, not more immutable.
+*/
+var ClipStreamRun = class {
+	deps;
+	input;
+	attempt;
+	accessUnits = 0;
+	/** Every audio frame the decoder handed over, of any codec. */
+	audioFrames = 0;
+	audioFramesDropped = 0;
+	audioFramesAfterMux = 0;
+	/** ADTS frames held until the mux exists — the audio half of the probe. */
+	audioProbe = [];
+	audioProbeBytes = 0;
+	audioMuxed = null;
+	audioSilentReason = null;
+	audioIn = null;
+	timestampsUs = [];
+	/** Access units held until the rate is probed — the frames in flight. */
+	probe = [];
+	mux = null;
+	muxStderr = "";
+	muxClosed = null;
+	rate = {
+		fps: null,
+		fpsSource: "unmeasured",
+		accessUnits: 0
+	};
+	videoType = null;
+	begun = false;
+	ended = false;
+	bytesOut = 0;
+	cut = null;
+	stdinGate;
+	audioStdinGate;
+	peerGate;
+	tags;
+	constructor(deps, input, attempt) {
+		this.deps = deps;
+		this.input = input;
+		this.attempt = attempt;
+		this.tags = { deviceId: input.device.deviceId };
+		this.stdinGate = createDrainGate({
+			timeoutMs: deps.drainTimeoutMs,
+			onStall: () => this.sever("mux-stalled", "ffmpeg stopped taking access units")
+		});
+		this.audioStdinGate = createDrainGate({
+			timeoutMs: deps.drainTimeoutMs,
+			onStall: () => this.sever("mux-audio-stalled", "ffmpeg stopped taking audio frames")
+		});
+		this.peerGate = createDrainGate({
+			timeoutMs: deps.drainTimeoutMs,
+			onStall: () => this.sever("peer-stalled", "the peer stopped taking bytes")
+		});
+	}
+	async run() {
+		const { device, row, fileName, twin, sink } = this.input;
+		sink.onceClose(() => {
+			if (!this.ended) this.sever("peer-closed", "the peer closed the connection");
+		});
+		const decoder = this.deps.createDecoder({
+			onVideoAccessUnit: (unit) => this.onAccessUnit(unit),
+			onAudioFrame: (frame) => this.onAudioFrame(frame)
+		});
+		this.deps.logger.info("videoclips: streaming a clip file from the camera", {
+			tags: this.tags,
+			meta: {
+				clipKey: row.clipKey,
+				twin,
+				fileName,
+				startMs: row.startMs,
+				endMs: row.endMs,
+				attempt: this.attempt,
+				audioAsked: this.input.audio,
+				idleTimeoutMs: 300
+			}
+		});
+		let api;
+		try {
+			api = await device.getApi();
+		} catch (err) {
+			return {
+				kind: "no-media",
+				detail: describe(err)
+			};
+		}
+		try {
+			await api.fileInfoListReplayBinaryDownload({
+				channel: device.channel,
+				...device.uid !== void 0 ? { uid: device.uid } : {},
+				fileName,
+				idleTimeoutMs: 300,
+				onChunk: (chunk) => this.onChunk(decoder, chunk)
+			});
+		} catch (err) {
+			return this.onTransferFailed(err);
+		}
+		return this.onTransferEnded();
+	}
+	/** The camera's bytes, as they arrive. A cut run THROWS here: the only stop. */
+	onChunk(decoder, chunk) {
+		if (this.cut !== null) throw new Error(`clip stream cut: ${this.cut.reason}`);
+		try {
+			decoder.push(chunk);
+		} catch (err) {
+			this.sever("decode-failed", describe(err));
+			throw err;
+		}
+	}
+	onAccessUnit(unit) {
+		if (this.cut !== null) return;
+		this.accessUnits += 1;
+		this.timestampsUs.push(unit.microseconds);
+		if (this.mux === null) {
+			this.probe = [...this.probe, unit];
+			if (this.probe.length >= 16) this.startMux();
+			return;
+		}
+		this.feed(unit.annexB);
+	}
+	/**
+	* One audio frame from the decoder.
+	*
+	* Before the mux exists the ADTS frames are HELD, exactly as the video
+	* probe holds access units, because the spawn cannot gain an input later
+	* and ffmpeg will not write a byte until every input it was given has been
+	* probed. After it exists they are either fed or counted as dropped — and
+	* a frame that arrives after a SILENT spawn is counted apart, because that
+	* one is a recording whose sound was there and was decided away.
+	*/
+	onAudioFrame(frame) {
+		if (this.cut !== null) return;
+		this.audioFrames += 1;
+		if (this.input.audio === "none" || frame.audioType !== "Aac" || frame.data.byteLength === 0) {
+			this.audioFramesDropped += 1;
+			return;
+		}
+		if (this.mux === null) {
+			if (this.audioProbe.length >= 4096 || this.audioProbeBytes + frame.data.byteLength > 4194304) {
+				this.audioFramesDropped += 1;
+				return;
+			}
+			this.audioProbe = [...this.audioProbe, frame.data];
+			this.audioProbeBytes += frame.data.byteLength;
+			return;
+		}
+		if (this.audioMuxed === null) {
+			this.audioFramesDropped += 1;
+			this.audioFramesAfterMux += 1;
+			return;
+		}
+		this.feedAudio(frame.data);
+	}
+	/**
+	* What the mux will carry as sound, decided ONCE, before the spawn.
+	*
+	* The gate is `an ADTS frame is already in hand`, not `the ask was not
+	* none`: ffmpeg probes `pipe:3` before it writes output, so declaring an
+	* input that never delivers would hold the VIDEO hostage for a recording
+	* that simply has no microphone. An ADPCM-only camera is named separately
+	* from a silent one — the file path draws the same distinction
+	* (`decideClipAudio`) and for the same reason.
+	*/
+	decideAudio() {
+		const asked = this.input.audio;
+		if (asked === "none") {
+			this.audioSilentReason = "not-requested";
+			return;
+		}
+		if (this.audioProbe.length > 0) {
+			this.audioMuxed = asked;
+			return;
+		}
+		this.audioSilentReason = this.audioFrames > 0 ? "audio-not-copyable" : "no-audio-track";
+	}
+	/** Spawn ffmpeg with the probed rate and hand it what was held. */
+	startMux() {
+		const first = this.probe[0];
+		if (first === void 0 || this.mux !== null) return;
+		this.videoType = first.videoType;
+		this.rate = probeClipStreamRate(this.timestampsUs);
+		this.decideAudio();
+		const { row, twin } = this.input;
+		if (this.rate.fpsSource !== "timestamps") this.deps.logger.warn("videoclips: no measured frame rate for this clip stream", {
+			tags: this.tags,
+			meta: {
+				clipKey: row.clipKey,
+				twin,
+				branch: "fps-unmeasured",
+				probeAccessUnits: this.rate.accessUnits
+			}
+		});
+		let mux;
+		try {
+			mux = this.deps.spawnMux(buildClipStreamMuxArgs({
+				videoType: this.videoType,
+				fps: this.rate.fps,
+				audio: this.audioMuxed
+			}));
+		} catch (err) {
+			this.sever("mux-failed", `ffmpeg could not be spawned: ${describe(err)}`);
+			return;
+		}
+		this.mux = mux;
+		if (this.audioMuxed !== null) {
+			this.audioIn = writableAt(mux.stdio, 3);
+			if (this.audioIn === null) {
+				this.audioMuxed = null;
+				this.audioSilentReason = "no-audio-track";
+				this.deps.logger.warn("videoclips: a clip stream mux exposed no audio pipe", {
+					tags: this.tags,
+					meta: {
+						clipKey: row.clipKey,
+						twin,
+						branch: "audio-pipe-missing"
+					}
+				});
+				this.sever("mux-failed", "the mux was spawned with an audio input it does not expose");
+				return;
+			}
+			this.audioIn.on("error", (err) => this.sever("mux-failed", `ffmpeg audio stdin: ${err.message}`));
+			this.audioIn.on("drain", () => this.audioStdinGate.drained());
+		}
+		this.muxClosed = new Promise((resolve) => {
+			mux.on("close", (code) => resolve(code));
+			mux.on("error", (err) => {
+				this.sever("mux-failed", `ffmpeg failed: ${err.message}`);
+				resolve(null);
+			});
+		});
+		mux.stderr?.on("data", (chunk) => {
+			if (this.muxStderr.length < 2e3) this.muxStderr += chunk.toString("utf8");
+		});
+		mux.stdin?.on("error", (err) => this.sever("mux-failed", `ffmpeg stdin: ${err.message}`));
+		mux.stdin?.on("drain", () => this.stdinGate.drained());
+		mux.stdout?.on("data", (chunk) => this.onMuxOut(chunk));
+		mux.stdout?.on("end", () => this.finishSink());
+		this.deps.logger.info("videoclips: a clip stream is muxing", {
+			tags: this.tags,
+			meta: {
+				clipKey: row.clipKey,
+				twin,
+				videoType: this.videoType,
+				fps: this.rate.fps,
+				fpsSource: this.rate.fpsSource,
+				probeAccessUnits: this.rate.accessUnits,
+				audioAsked: this.input.audio,
+				audioMuxed: this.audioMuxed,
+				audioSilentReason: this.audioSilentReason,
+				probeAudioFrames: this.audioProbe.length
+			}
+		});
+		const held = this.probe;
+		this.probe = [];
+		const heldAudio = this.audioProbe;
+		this.audioProbe = [];
+		this.audioProbeBytes = 0;
+		for (const unit of held) this.feed(unit.annexB);
+		if (this.audioMuxed === null) this.audioFramesDropped += heldAudio.length;
+		else for (const frame of heldAudio) this.feedAudio(frame);
+	}
+	feed(annexB) {
+		if (this.cut !== null || this.mux?.stdin === null || this.mux?.stdin === void 0) return;
+		this.stdinGate.wrote(this.mux.stdin.write(annexB));
+	}
+	feedAudio(adts) {
+		const audioIn = this.audioIn;
+		if (this.cut !== null || audioIn === null) return;
+		this.audioStdinGate.wrote(audioIn.write(adts));
+	}
+	/** ffmpeg's output, to the peer, honouring `write()`'s return (D447). */
+	onMuxOut(chunk) {
+		if (this.cut !== null) return;
+		const { sink } = this.input;
+		if (!this.begun) {
+			this.begun = true;
+			sink.begin(clipStreamContentTypeFor(this.audioMuxed));
+		}
+		const accepted = sink.write(chunk);
+		this.bytesOut += chunk.byteLength;
+		this.peerGate.wrote(accepted);
+		if (accepted) return;
+		const stdout = this.mux?.stdout;
+		stdout?.pause();
+		sink.onceDrain(() => {
+			this.peerGate.drained();
+			stdout?.resume();
+		});
+	}
+	finishSink() {
+		if (this.cut !== null || this.ended) return;
+		this.ended = true;
+		this.input.sink.end();
+	}
+	/** Sever every hop, once, and say why. */
+	sever(reason, detail) {
+		if (this.cut !== null) return;
+		this.cut = {
+			reason,
+			detail
+		};
+		this.stdinGate.dispose();
+		this.audioStdinGate.dispose();
+		this.peerGate.dispose();
+		this.mux?.kill("SIGKILL");
+		this.deps.logger.warn("videoclips: a clip stream was cut", {
+			tags: this.tags,
+			meta: {
+				clipKey: this.input.row.clipKey,
+				twin: this.input.twin,
+				branch: reason,
+				detail,
+				accessUnits: this.accessUnits,
+				bytesOut: this.bytesOut,
+				begun: this.begun,
+				audioMuxed: this.audioMuxed,
+				audioFramesIn: this.audioFrames,
+				audioFramesDropped: this.audioFramesDropped
+			}
+		});
+		if (this.begun) this.input.sink.destroy();
+	}
+	cutOutcome(cut) {
+		if (this.begun) return {
+			kind: "cut",
+			reason: cut.reason,
+			detail: cut.detail,
+			bytesOut: this.bytesOut
+		};
+		return {
+			kind: "refused",
+			code: "fetch-failed",
+			detail: `${cut.reason}: ${cut.detail}`,
+			attempts: this.attempt
+		};
+	}
+	onTransferFailed(err) {
+		if (this.cut !== null) return this.cutOutcome(this.cut);
+		if (this.accessUnits === 0) return {
+			kind: "no-media",
+			detail: describe(err)
+		};
+		this.sever("camera-failed", describe(err));
+		return this.cutOutcome({
+			reason: "camera-failed",
+			detail: describe(err)
+		});
+	}
+	async onTransferEnded() {
+		if (this.cut !== null) return this.cutOutcome(this.cut);
+		if (this.accessUnits === 0) return {
+			kind: "no-media",
+			detail: "the camera answered the transfer with no access unit"
+		};
+		if (this.mux === null) this.startMux();
+		const cutAtStart = this.cut;
+		if (cutAtStart !== null) return this.cutOutcome(cutAtStart);
+		const mux = this.mux;
+		if (mux === null || this.muxClosed === null) return this.cutOutcome({
+			reason: "mux-failed",
+			detail: "no mux after the transfer ended"
+		});
+		mux.stdin?.end();
+		this.audioIn?.end();
+		const flush = setTimeout(() => this.sever("mux-hung", `ffmpeg did not exit ${this.deps.flushTimeoutMs} ms after its input ended`), this.deps.flushTimeoutMs);
+		const code = await this.muxClosed;
+		clearTimeout(flush);
+		const cutAfter = this.cut;
+		if (cutAfter !== null) return this.cutOutcome(cutAfter);
+		if (code !== 0) {
+			this.sever("mux-failed", `ffmpeg exited ${String(code)}: ${this.muxStderr.slice(0, 300)}`);
+			return this.cutOutcome({
+				reason: "mux-failed",
+				detail: this.muxStderr.slice(0, 300)
+			});
+		}
+		this.finishSink();
+		return this.served();
+	}
+	/** The stream landed: judge it against the row, out loud, and answer. */
+	served() {
+		const { row, twin } = this.input;
+		const timing = estimateVideoTiming({ timestampsUs: this.timestampsUs });
+		const durationSeconds = timing.fpsSource === "timestamps" ? timing.durationSeconds : null;
+		const verdict = judgeClipDuration({
+			expectedMs: row.endMs - row.startMs,
+			decodedSeconds: durationSeconds,
+			...row.inProgress === true ? { inProgress: true } : {}
+		});
+		const audio = this.audioReport();
+		const meta = {
+			clipKey: row.clipKey,
+			twin,
+			attempt: this.attempt,
+			accessUnits: this.accessUnits,
+			audioMuxed: audio.muxed,
+			bytesOut: this.bytesOut,
+			durationSeconds,
+			expectedMs: row.endMs - row.startMs,
+			fps: this.rate.fps,
+			fpsSource: this.rate.fpsSource,
+			videoType: this.videoType
+		};
+		if (verdict.kind === "short") this.deps.logger.warn("videoclips: a clip stream came up short against its row", {
+			tags: this.tags,
+			meta: {
+				...meta,
+				branch: "stream-short",
+				shortfallSeconds: verdict.shortfallSeconds,
+				retried: false
+			}
+		});
+		else if (verdict.kind === "unknown") this.deps.logger.warn("videoclips: a clip stream could not be checked for truncation", {
+			tags: this.tags,
+			meta: {
+				...meta,
+				branch: "completeness-unverified",
+				reason: verdict.reason
+			}
+		});
+		else this.deps.logger.info("videoclips: a clip stream landed whole", {
+			tags: this.tags,
+			meta: {
+				...meta,
+				branch: "stream-served"
+			}
+		});
+		this.reportAudio(audio);
+		return {
+			kind: "served",
+			accessUnits: this.accessUnits,
+			audio,
+			bytesOut: this.bytesOut,
+			durationSeconds,
+			verdict,
+			rate: this.rate,
+			attempts: this.attempt
+		};
+	}
+	audioReport() {
+		return {
+			asked: this.input.audio,
+			muxed: this.audioMuxed,
+			reason: this.audioSilentReason,
+			framesIn: this.audioFrames,
+			framesDropped: this.audioFramesDropped,
+			framesAfterMux: this.audioFramesAfterMux
+		};
+	}
+	/**
+	* Say what became of the sound, on EVERY served stream — including the one
+	* that carried it.
+	*
+	* A branch that accepts work and produces nothing is the branch that has to
+	* speak (D391), and silence is exactly what that looks like here. But a
+	* stream that DID carry audio says so too, with the frame count, because
+	* "the clip was silent" and "the clip had sound and you did not hear it"
+	* are answered from this line and nowhere else.
+	*/
+	reportAudio(audio) {
+		const { row, twin } = this.input;
+		const meta = {
+			clipKey: row.clipKey,
+			twin,
+			audioAsked: audio.asked,
+			audioMuxed: audio.muxed,
+			audioFramesIn: audio.framesIn,
+			audioFramesDropped: audio.framesDropped,
+			audioFramesAfterMux: audio.framesAfterMux
+		};
+		if (audio.muxed !== null) {
+			this.deps.logger.info("videoclips: a clip stream carried sound", {
+				tags: this.tags,
+				meta: {
+					...meta,
+					branch: "stream-with-audio"
+				}
+			});
+			return;
+		}
+		if (audio.framesAfterMux > 0) {
+			this.deps.logger.warn("videoclips: a clip stream dropped sound that arrived too late", {
+				tags: this.tags,
+				meta: {
+					...meta,
+					branch: "stream-audio-after-mux"
+				}
+			});
+			return;
+		}
+		if (audio.asked === "none") {
+			this.deps.logger.info("videoclips: a clip stream was served without sound", {
+				tags: this.tags,
+				meta: {
+					...meta,
+					branch: "stream-video-only"
+				}
+			});
+			return;
+		}
+		this.deps.logger.warn("videoclips: a clip stream was asked for sound and had none", {
+			tags: this.tags,
+			meta: {
+				...meta,
+				branch: `stream-silent:${audio.reason ?? "unknown"}`
+			}
+		});
+	}
+};
+function describe(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function pathToken(req) {
+	const raw = req.url ?? "/";
+	const query = raw.indexOf("?");
+	return (query === -1 ? raw : raw.slice(0, query)).replace(/^\/+/, "");
+}
+function createClipStreamDial(deps) {
+	const now = deps.now ?? (() => Date.now());
+	const ttlMs = deps.ttlMs ?? 3e4;
+	const maxOutstanding = deps.maxOutstanding ?? 64;
+	const host = deps.host ?? "127.0.0.1";
+	const tokens = /* @__PURE__ */ new Map();
+	/** Tokens already dialled, kept for their TTL so a replay is named `dial-used`, not `dial-unknown`. */
+	const used = /* @__PURE__ */ new Map();
+	let server = null;
+	let baseUrl = null;
+	let listening = null;
+	const sweep = () => {
+		const at = now();
+		for (const [token, minted] of tokens) if (minted.expiresAtMs <= at) tokens.delete(token);
+		for (const [token, expiresAtMs] of used) if (expiresAtMs <= at) used.delete(token);
+	};
+	const resolveTarget = (req) => {
+		const token = pathToken(req);
+		const minted = tokens.get(token);
+		if (minted === void 0) {
+			if (used.get(token) !== void 0) return {
+				kind: "refused",
+				status: 410,
+				code: "dial-used",
+				detail: "this dial was already taken"
+			};
+			return {
+				kind: "refused",
+				status: 404,
+				code: "dial-unknown",
+				detail: "no such dial"
+			};
+		}
+		if (minted.expiresAtMs <= now()) {
+			tokens.delete(token);
+			return {
+				kind: "refused",
+				status: 410,
+				code: "dial-expired",
+				detail: "this dial has expired"
+			};
+		}
+		if (req.method === "GET") {
+			tokens.delete(token);
+			used.set(token, minted.expiresAtMs);
+			deps.logger.info("videoclips: a clip stream dial was taken", {
+				tags: { deviceId: minted.target.deviceId },
+				meta: {
+					clipKey: minted.target.clipKey,
+					twin: minted.target.twin,
+					audio: minted.target.audio,
+					outstanding: tokens.size
+				}
+			});
+		}
+		return {
+			kind: "target",
+			target: minted.target
+		};
+	};
+	const handler = createClipStreamHandler({
+		stream: deps.stream,
+		logger: deps.logger,
+		target: resolveTarget
+	});
+	const listen = () => {
+		if (listening !== null) return listening;
+		listening = new Promise((resolve, reject) => {
+			const created = createServer((req, res) => {
+				handler(req, res).catch((err) => {
+					deps.logger.warn("videoclips: the clip stream dial handler threw", { meta: { error: err instanceof Error ? err.message : String(err) } });
+					if (!res.headersSent) res.writeHead(500);
+					res.end();
+				});
+			});
+			created.on("error", (err) => {
+				listening = null;
+				reject(err);
+			});
+			created.listen(0, host, () => {
+				const address = created.address();
+				if (address === null || typeof address === "string") {
+					created.close();
+					listening = null;
+					reject(/* @__PURE__ */ new Error("the dial listener bound no TCP port"));
+					return;
+				}
+				server = created;
+				baseUrl = `http://${host}:${address.port}`;
+				deps.logger.info("videoclips: clip stream dial listener bound", { meta: {
+					host,
+					port: address.port,
+					ttlMs,
+					maxOutstanding
+				} });
+				resolve(baseUrl);
+			});
+		});
+		return listening;
+	};
+	return {
+		get outstanding() {
+			sweep();
+			return tokens.size;
+		},
+		mint: async (input) => {
+			sweep();
+			if (tokens.size >= maxOutstanding) {
+				deps.logger.warn("videoclips: clip stream dial refused — too many outstanding", {
+					tags: { deviceId: input.deviceId },
+					meta: {
+						clipKey: input.clipKey,
+						twin: input.twin,
+						outstanding: tokens.size,
+						maxOutstanding
+					}
+				});
+				return {
+					kind: "refused",
+					code: "dial-exhausted",
+					detail: `${tokens.size} dials outstanding against a bound of ${maxOutstanding}`
+				};
+			}
+			let base;
+			try {
+				base = baseUrl ?? await listen();
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : String(err);
+				deps.logger.warn("videoclips: clip stream dial refused — no listener", {
+					tags: { deviceId: input.deviceId },
+					meta: {
+						clipKey: input.clipKey,
+						twin: input.twin,
+						error: detail
+					}
+				});
+				return {
+					kind: "refused",
+					code: "listener-failed",
+					detail
+				};
+			}
+			const token = randomBytes(24).toString("base64url");
+			const expiresAtMs = now() + ttlMs;
+			tokens.set(token, {
+				target: input,
+				expiresAtMs
+			});
+			deps.logger.info("videoclips: clip stream dial minted", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					clipKey: input.clipKey,
+					twin: input.twin,
+					audio: input.audio,
+					expiresInMs: ttlMs,
+					outstanding: tokens.size
+				}
+			});
+			return {
+				kind: "ticket",
+				url: `${base}/${token}`,
+				expiresAtMs
+			};
+		},
+		dispose: async () => {
+			tokens.clear();
+			used.clear();
+			const open = server;
+			server = null;
+			baseUrl = null;
+			listening = null;
+			if (open === null) return;
+			await new Promise((resolve) => {
+				open.close(() => resolve());
+				open.closeAllConnections();
+			});
+			deps.logger.info("videoclips: clip stream dial listener closed", {});
+		}
+	};
+}
+//#endregion
+//#region src/clips/clip-stream-route.ts
+function createClipStreamRoute(deps) {
+	return async (target, sink) => {
+		const { deviceId, clipKey, twin, audio } = target;
+		const gate = await deps.gate({
+			deviceId,
+			clipKey,
+			twin,
+			path: "stream"
+		});
+		if (gate.kind === "refused") return {
+			kind: "refused",
+			code: gate.branch,
+			detail: gate.detail
+		};
+		const row = deps.rowFor(deviceId, clipKey);
+		if (row === null) {
+			deps.logger.warn("videoclips: no catalog row for this clip stream", {
+				tags: { deviceId },
+				meta: {
+					clipKey,
+					twin,
+					branch: "no-catalog-row"
+				}
+			});
+			return {
+				kind: "refused",
+				code: "no-catalog-row",
+				detail: "no-catalog-row: list this day before asking for its stream"
+			};
+		}
+		if (row.inProgress === true) {
+			deps.logger.warn("videoclips: refusing to stream a clip the camera is still writing", {
+				tags: { deviceId },
+				meta: {
+					clipKey,
+					twin,
+					branch: "clip-in-progress"
+				}
+			});
+			return {
+				kind: "refused",
+				code: "clip-in-progress",
+				detail: "clip-in-progress: the camera is still writing this file; it has no end to stream to"
+			};
+		}
+		const fileName = twin === "main" ? row.mainFileName ?? "" : row.subFileName;
+		if (fileName === "") {
+			deps.logger.warn("videoclips: no byte handle for the twin this clip stream names", {
+				tags: { deviceId },
+				meta: {
+					clipKey,
+					twin,
+					branch: "no-catalog-row"
+				}
+			});
+			return {
+				kind: "refused",
+				code: "no-catalog-row",
+				detail: `no-catalog-row: this clip is listed with no ${twin} file behind it`
+			};
+		}
+		const outcome = await deps.producer.stream({
+			device: gate.device,
+			row,
+			fileName,
+			twin,
+			audio,
+			sink
+		});
+		switch (outcome.kind) {
+			case "served": return { kind: "served" };
+			case "cut": return { kind: "cut" };
+			case "refused": return {
+				kind: "refused",
+				code: outcome.code,
+				detail: outcome.detail
+			};
+		}
+	};
+}
+//#endregion
 //#region src/clips/clip-thumb-queue.ts
 /**
 * The provider's OWN CoverPreview lane — two queues, one in flight per host.
@@ -149427,210 +152077,58 @@ function decideClipPrefetch(input) {
 	return { kind: "run" };
 }
 //#endregion
-//#region src/clips/clip-identity.ts
+//#region src/clips/clip-window.ts
 /**
-* A Reolink clip's IDENTITY — the id the operator's surface carries around and
-* the key its cached bytes are filed under.
+* Does this row overlap the window?
 *
-* `native:reolink:<source>:<channel>:<base64url(fileName)>` (D549 3). It is
-* self-contained on purpose: the thumbnail route, the playback route and the
-* collection dispatcher each resolve a clip from the id alone, so none of them
-* re-lists the camera to answer a click. The source is INSIDE the id because
-* D554 5 routes a scalar cap call by the longest source that prefixes it, and
-* because an id naming a source this provider no longer serves must be
-* REFUSED rather than routed by prefix luck.
+* Half-open on both ends (`start < until`, `end > since`), so a clip that ends
+* exactly when the window begins is OUT and a clip that begins exactly when it
+* ends is OUT — otherwise two adjacent windows both claim the same boundary
+* clip and a surface paging through them renders it twice.
 *
-* base64url, not base64: a hub's `<Id>` is a real path
-* (`/mnt/sda/U10<uid>-<name>/RecS02_…mp4`), and `/` and `+` in a URL path
-* segment are a different path or a space.
+* A row whose `endMs` is not after its `startMs` is treated as an INSTANT at
+* `startMs`. That is not defensive padding: a clip still being written carries
+* a frozen `endMs` from the camera's index (D563), and on this fleet that has
+* been observed equal to — and once behind — its own start. Judging such a row
+* by a bad end would drop a recording that is happening right now.
 */
+function clipOverlapsWindow(row, window) {
+	const end = row.endMs > row.startMs ? row.endMs : row.startMs;
+	return row.startMs < window.until && end > window.since;
+}
 /**
-* The camera's OWN recordings — the ONE Reolink source.
+* What the provider ANSWERS with — the one gate, so there is a single place
+* that decides what leaves this listing and a single line that reports it.
 *
-* It was two (`onboard` for the files view, `hub` for the parent's event
-* view, D549 11) for a few hours, on the premise that the two might hold
-* DIFFERENT sets. Our own measurement disproved that premise: the hub's uid
-* addresses no catalog at all (empty month over 24 months, zero files, zero
-* rows) while the child's uid addresses all of it, cmd 5 serves identical
-* bytes under either, and on 3628 the two views cover each other almost
-* exactly — 29 events, 28 inside the 20 listed files, and all 20 files
-* carrying an event. They are two VIEWS of one store.
+* ## Why a clip still being written is not listed
 *
-* So the operator collapsed them (2026-09-20): one source, which picked the
-* best API for what the camera IS, and REPORTED the pick on `ClipSource.via`.
-* Later the same day the pick went too (D565): `FileInfoList` is the catalog
-* on every topology, so `via` had one value and is gone. What is left is one
-* source reading one API — and `clipKeyFor` below is still keyed off
-* `(channel, fileName)` rather than the source, which is now simply true
-* rather than a concession.
-*/
-var CLIP_SOURCE_ONBOARD = "native:reolink:onboard";
-/** Every source this provider can name. Order is the picker's order. */
-var REOLINK_CLIP_SOURCES = [CLIP_SOURCE_ONBOARD];
-function encodeFileName(fileName) {
-	return Buffer.from(fileName, "utf8").toString("base64url");
-}
-function mintClipId(parts) {
-	const base = `${parts.source}:${parts.channel}:${encodeFileName(parts.fileName)}`;
-	return parts.window === void 0 ? base : `${base}:${parts.window.startMs}-${parts.window.endMs}`;
-}
-/**
-* Parse an id this provider minted. `null` for anything else — including an id
-* from the analytics or HKSV source, which is how the collection dispatcher's
-* "nobody claimed this id" branch stays honest.
-*/
-function parseClipId(clipId) {
-	const source = REOLINK_CLIP_SOURCES.find((candidate) => clipId.startsWith(`${candidate}:`));
-	if (source === void 0) return null;
-	const rest = clipId.slice(source.length + 1);
-	const sep = rest.indexOf(":");
-	if (sep <= 0) return null;
-	const channel = Number(rest.slice(0, sep));
-	if (!Number.isInteger(channel) || channel < 0) return null;
-	const payload = rest.slice(sep + 1);
-	if (payload === "") return null;
-	const windowSep = payload.indexOf(":");
-	const encoded = windowSep === -1 ? payload : payload.slice(0, windowSep);
-	if (encoded === "") return null;
-	const fileName = Buffer.from(encoded, "base64url").toString("utf8");
-	if (fileName === "") return null;
-	if (windowSep === -1) return {
-		source,
-		channel,
-		fileName
-	};
-	const match = /^(\d+)-(\d+)$/.exec(payload.slice(windowSep + 1));
-	if (match === null) return null;
-	return {
-		source,
-		channel,
-		fileName,
-		window: {
-			startMs: Number(match[1]),
-			endMs: Number(match[2])
-		}
-	};
-}
-/**
-* The on-disk key for a clip's derived artifacts (its thumbnail, its muxed
-* MP4). Derived from `(channel, fileName)` and NOT from the source: a
-* thumbnail belongs to the FILE, so any surface that names the same file
-* finds the same picture and the camera is never asked for a second
-* CoverPreview of it.
+* The operator, 2026-09-22: *"Niente clips in preparazione, non ha senso
+* visualizzarle."* He is right, and the reasons had been accumulating:
 *
-* A hash rather than the encoded name because a hub `<Id>` is a full path and
-* the encoded form is long enough to hit a file-name limit.
-*/
-function clipKeyFor(channel, fileName) {
-	return createHash("sha1").update(`${channel}${fileName}`, "utf8").digest("hex");
-}
-//#endregion
-//#region src/clips/clip-native-types.ts
-/** Cap on `ClipSchema.labels`, mirrored from `@camstack/types` MAX_CLIP_LABELS. */
-var MAX_LABELS = 3;
-/** Native → object class. The same rule `native-detection-mapping.ts` applies
-*  to live boxes, so a clip and a live box never disagree about a dog. */
-var CLASS_BY_NATIVE = {
-	people: "person",
-	face: "person",
-	visitor: "person",
-	vehicle: "vehicle",
-	nonmotorveh: "vehicle",
-	dog_cat: "animal",
-	package: "package"
-};
-/** Natives that state a KIND rather than a class. */
-var KIND_BY_NATIVE = {
-	md: "motion",
-	pir: "motion",
-	cry: "audio",
-	other: "motion"
-};
-/** What the subject DID — carried beside a class, never as one. */
-var BEHAVIOUR_BY_NATIVE = {
-	crossline: "crossline",
-	intrude: "intrude",
-	intrusion: "intrude",
-	loitering: "loitering",
-	visitor: "doorbell"
-};
-/**
-* Recording REASONS — why the file exists, not what is in it. They get no
-* label and no behaviour; the row still lists, showing the reason raw.
-* `none` is the camera declining to classify, which is not the same as the
-* camera saying "nothing". `other` used to live here and is now a motion KIND
-* — see {@link KIND_BY_NATIVE}.
-*/
-var RECORDING_REASONS = new Set([
-	"sched",
-	"manual",
-	"io",
-	"IPCInputOutput",
-	"legacy",
-	"loss",
-	"answer",
-	"tamper",
-	"lmsg",
-	"none"
-]);
-/**
-* Ordering for `labels` — "dominant first". A person outranks a vehicle
-* outranks an animal outranks a package; anything unknown sorts last so a
-* newer firmware's invention never displaces a class the operator filters on.
+* - its `endMs` is a frozen guess — the camera's index keeps whatever it held
+*   when the file was opened, measured on 592 as the same `endTime` for eight
+*   minutes (D563) — so the row's duration, its position on the axis and its
+*   height are all wrong and all move;
+* - `readClipBytes` already refuses it by name (`clip-in-progress`): it has no
+*   end to export against, so the completion rule has nothing to prove the
+*   fetch finished (D568);
+* - it cannot be looped, and the surface has to explain why (`resolveClipLoop`);
+* - the player route would file a TRUNCATED copy under an immutable key, so
+*   the first seconds become permanently what that clip is.
+*
+* Four different places bending around a row that cannot be played properly.
+* Not listing it deletes all four questions instead of answering them: the
+* clip appears, whole, on the next listing after the camera closes the file.
 */
-var CLASS_RANK = [
-	"person",
-	"vehicle",
-	"animal",
-	"package"
-];
-/** Split the `recordType` CSV a file carries into raw types, de-duplicated,
-*  in wire order. Case is NOT normalised: `IPCInputOutput` is what the camera
-*  said and what `nativeTypes` must carry back. */
-function parseNativeTypes(recordType) {
-	if (recordType === void 0) return [];
-	const out = [];
-	for (const part of recordType.split(",")) {
-		const trimmed = part.trim();
-		if (trimmed === "" || out.includes(trimmed)) continue;
-		out.push(trimmed);
-	}
-	return out;
-}
-function classifyNativeTypes(nativeTypes) {
-	const labels = [];
-	const behaviours = [];
-	let kind = "native";
-	for (const raw of nativeTypes) {
-		const behaviour = BEHAVIOUR_BY_NATIVE[raw];
-		if (behaviour !== void 0 && !behaviours.includes(behaviour)) behaviours.push(behaviour);
-		const cls = CLASS_BY_NATIVE[raw];
-		if (cls !== void 0) {
-			if (!labels.includes(cls)) labels.push(cls);
-			continue;
-		}
-		const kindOf = KIND_BY_NATIVE[raw];
-		if (kindOf !== void 0) {
-			if (kind === "native") kind = kindOf;
-			continue;
-		}
-		if (RECORDING_REASONS.has(raw)) continue;
-		if (behaviour !== void 0) continue;
-		const unknown = `unknown:${raw}`;
-		if (!labels.includes(unknown)) labels.push(unknown);
-	}
-	if (labels.some((label) => !label.startsWith("unknown:"))) kind = "native";
+function listableClips(rows, window) {
+	const inWindow = rows.filter((row) => clipOverlapsWindow(row, window));
+	const kept = inWindow.filter((row) => row.inProgress !== true);
 	return {
-		labels: labels.toSorted((a, b) => rankOf(a) - rankOf(b)).slice(0, MAX_LABELS),
-		behaviours,
-		nativeTypes: [...nativeTypes],
-		kind
+		kept,
+		outOfWindow: rows.length - inWindow.length,
+		inProgress: inWindow.length - kept.length
 	};
 }
-function rankOf(label) {
-	const at = CLASS_RANK.indexOf(label);
-	return at === -1 ? CLASS_RANK.length : at;
-}
 function pairTwins(subs, mains) {
 	const datedSubs = subs.filter((f) => f.startTime instanceof Date);
 	const datedMains = mains.filter((f) => f.startTime instanceof Date).toSorted((a, b) => startOf(a) - startOf(b));
@@ -149665,6 +152163,247 @@ function pairTwins(subs, mains) {
 function startOf(file) {
 	return file.startTime?.getTime() ?? 0;
 }
+/**
+* The ONE place that turns a requested profile into a twin.
+*
+* Three call sites used to decide this independently — `getClipPlayback`,
+* `readClipBytes` and the stream dial — and they did not agree: the dial
+* REFUSED `high` outright while the other two served the sub copy with a
+* warning. Same question, three answers, and the one that refused made `high`
+* look unsupported rather than unavailable for that recording.
+*
+* The mapping is the profile ladder the rest of the system already uses:
+* `high` reaches for the main twin, everything else is the sub. A `high` with
+* no main twin degrades to the sub and SAYS SO through `served` and
+* `downgraded` — "there is no high-quality copy" is an answer (`pairTwins`
+* models it as `main: undefined`), and a silent substitution is what D576
+* forbids. Refusing was the other way of getting it wrong.
+*
+* An ABSENT profile is not `high`: a caller that stated no preference gets the
+* cheap copy, which is what all three call sites did before this function
+* existed (`profile === 'high'` on `undefined` is false).
+*/
+function chooseClipTwin(profile, row) {
+	const wantsMain = profile === "high";
+	const mainFileName = wantsMain ? row.mainFileName : void 0;
+	if (mainFileName !== void 0) return {
+		twin: "main",
+		fileName: mainFileName,
+		served: "high",
+		downgraded: false
+	};
+	return {
+		twin: "sub",
+		fileName: row.subFileName,
+		served: "low",
+		downgraded: wantsMain
+	};
+}
+//#endregion
+//#region src/clips/clip-identity.ts
+/**
+* A Reolink clip's IDENTITY — the id the operator's surface carries around and
+* the key its cached bytes are filed under.
+*
+* `native:reolink:<source>:<channel>:<base64url(fileName)>` (D549 3). It is
+* self-contained on purpose: the thumbnail route, the playback route and the
+* collection dispatcher each resolve a clip from the id alone, so none of them
+* re-lists the camera to answer a click. The source is INSIDE the id because
+* D554 5 routes a scalar cap call by the longest source that prefixes it, and
+* because an id naming a source this provider no longer serves must be
+* REFUSED rather than routed by prefix luck.
+*
+* base64url, not base64: a hub's `<Id>` is a real path
+* (`/mnt/sda/U10<uid>-<name>/RecS02_…mp4`), and `/` and `+` in a URL path
+* segment are a different path or a space.
+*/
+/**
+* The camera's OWN recordings — the ONE Reolink source.
+*
+* It was two (`onboard` for the files view, `hub` for the parent's event
+* view, D549 11) for a few hours, on the premise that the two might hold
+* DIFFERENT sets. Our own measurement disproved that premise: the hub's uid
+* addresses no catalog at all (empty month over 24 months, zero files, zero
+* rows) while the child's uid addresses all of it, cmd 5 serves identical
+* bytes under either, and on 3628 the two views cover each other almost
+* exactly — 29 events, 28 inside the 20 listed files, and all 20 files
+* carrying an event. They are two VIEWS of one store.
+*
+* So the operator collapsed them (2026-09-20): one source, which picked the
+* best API for what the camera IS, and REPORTED the pick on `ClipSource.via`.
+* Later the same day the pick went too (D565): `FileInfoList` is the catalog
+* on every topology, so `via` had one value and is gone. What is left is one
+* source reading one API — and `clipKeyFor` below is still keyed off
+* `(channel, fileName)` rather than the source, which is now simply true
+* rather than a concession.
+*/
+var CLIP_SOURCE_ONBOARD = "native:reolink:onboard";
+/** Every source this provider can name. Order is the picker's order. */
+var REOLINK_CLIP_SOURCES = [CLIP_SOURCE_ONBOARD];
+function encodeFileName(fileName) {
+	return Buffer.from(fileName, "utf8").toString("base64url");
+}
+function mintClipId(parts) {
+	const base = `${parts.source}:${parts.channel}:${encodeFileName(parts.fileName)}`;
+	return parts.window === void 0 ? base : `${base}:${parts.window.startMs}-${parts.window.endMs}`;
+}
+/**
+* Parse an id this provider minted. `null` for anything else — including an id
+* from the analytics or HKSV source, which is how the collection dispatcher's
+* "nobody claimed this id" branch stays honest.
+*/
+function parseClipId(clipId) {
+	const source = REOLINK_CLIP_SOURCES.find((candidate) => clipId.startsWith(`${candidate}:`));
+	if (source === void 0) return null;
+	const rest = clipId.slice(source.length + 1);
+	const sep = rest.indexOf(":");
+	if (sep <= 0) return null;
+	const channel = Number(rest.slice(0, sep));
+	if (!Number.isInteger(channel) || channel < 0) return null;
+	const payload = rest.slice(sep + 1);
+	if (payload === "") return null;
+	const windowSep = payload.indexOf(":");
+	const encoded = windowSep === -1 ? payload : payload.slice(0, windowSep);
+	if (encoded === "") return null;
+	const fileName = Buffer.from(encoded, "base64url").toString("utf8");
+	if (fileName === "") return null;
+	if (windowSep === -1) return {
+		source,
+		channel,
+		fileName
+	};
+	const match = /^(\d+)-(\d+)$/.exec(payload.slice(windowSep + 1));
+	if (match === null) return null;
+	return {
+		source,
+		channel,
+		fileName,
+		window: {
+			startMs: Number(match[1]),
+			endMs: Number(match[2])
+		}
+	};
+}
+/**
+* The on-disk key for a clip's derived artifacts (its thumbnail, its muxed
+* MP4). Derived from `(channel, fileName)` and NOT from the source: a
+* thumbnail belongs to the FILE, so any surface that names the same file
+* finds the same picture and the camera is never asked for a second
+* CoverPreview of it.
+*
+* A hash rather than the encoded name because a hub `<Id>` is a full path and
+* the encoded form is long enough to hit a file-name limit.
+*/
+function clipKeyFor(channel, fileName) {
+	return createHash("sha1").update(`${channel}${fileName}`, "utf8").digest("hex");
+}
+//#endregion
+//#region src/clips/clip-native-types.ts
+/** Cap on `ClipSchema.labels`, mirrored from `@camstack/types` MAX_CLIP_LABELS. */
+var MAX_LABELS = 3;
+/** Native → object class. The same rule `native-detection-mapping.ts` applies
+*  to live boxes, so a clip and a live box never disagree about a dog. */
+var CLASS_BY_NATIVE = {
+	people: "person",
+	face: "person",
+	visitor: "person",
+	vehicle: "vehicle",
+	nonmotorveh: "vehicle",
+	dog_cat: "animal",
+	package: "package"
+};
+/** Natives that state a KIND rather than a class. */
+var KIND_BY_NATIVE = {
+	md: "motion",
+	pir: "motion",
+	cry: "audio",
+	other: "motion"
+};
+/** What the subject DID — carried beside a class, never as one. */
+var BEHAVIOUR_BY_NATIVE = {
+	crossline: "crossline",
+	intrude: "intrude",
+	intrusion: "intrude",
+	loitering: "loitering",
+	visitor: "doorbell"
+};
+/**
+* Recording REASONS — why the file exists, not what is in it. They get no
+* label and no behaviour; the row still lists, showing the reason raw.
+* `none` is the camera declining to classify, which is not the same as the
+* camera saying "nothing". `other` used to live here and is now a motion KIND
+* — see {@link KIND_BY_NATIVE}.
+*/
+var RECORDING_REASONS = new Set([
+	"sched",
+	"manual",
+	"io",
+	"IPCInputOutput",
+	"legacy",
+	"loss",
+	"answer",
+	"tamper",
+	"lmsg",
+	"none"
+]);
+/**
+* Ordering for `labels` — "dominant first". A person outranks a vehicle
+* outranks an animal outranks a package; anything unknown sorts last so a
+* newer firmware's invention never displaces a class the operator filters on.
+*/
+var CLASS_RANK = [
+	"person",
+	"vehicle",
+	"animal",
+	"package"
+];
+/** Split the `recordType` CSV a file carries into raw types, de-duplicated,
+*  in wire order. Case is NOT normalised: `IPCInputOutput` is what the camera
+*  said and what `nativeTypes` must carry back. */
+function parseNativeTypes(recordType) {
+	if (recordType === void 0) return [];
+	const out = [];
+	for (const part of recordType.split(",")) {
+		const trimmed = part.trim();
+		if (trimmed === "" || out.includes(trimmed)) continue;
+		out.push(trimmed);
+	}
+	return out;
+}
+function classifyNativeTypes(nativeTypes) {
+	const labels = [];
+	const behaviours = [];
+	let kind = "native";
+	for (const raw of nativeTypes) {
+		const behaviour = BEHAVIOUR_BY_NATIVE[raw];
+		if (behaviour !== void 0 && !behaviours.includes(behaviour)) behaviours.push(behaviour);
+		const cls = CLASS_BY_NATIVE[raw];
+		if (cls !== void 0) {
+			if (!labels.includes(cls)) labels.push(cls);
+			continue;
+		}
+		const kindOf = KIND_BY_NATIVE[raw];
+		if (kindOf !== void 0) {
+			if (kind === "native") kind = kindOf;
+			continue;
+		}
+		if (RECORDING_REASONS.has(raw)) continue;
+		if (behaviour !== void 0) continue;
+		const unknown = `unknown:${raw}`;
+		if (!labels.includes(unknown)) labels.push(unknown);
+	}
+	if (labels.some((label) => !label.startsWith("unknown:"))) kind = "native";
+	return {
+		labels: labels.toSorted((a, b) => rankOf(a) - rankOf(b)).slice(0, MAX_LABELS),
+		behaviours,
+		nativeTypes: [...nativeTypes],
+		kind
+	};
+}
+function rankOf(label) {
+	const at = CLASS_RANK.indexOf(label);
+	return at === -1 ? CLASS_RANK.length : at;
+}
 var partsCache = /* @__PURE__ */ new Map();
 function formatterFor$1(timeZone) {
 	const cached = partsCache.get(timeZone);
@@ -150199,7 +152938,24 @@ function createReolinkVideoclipsProvider(deps) {
 			state: "ok",
 			catalogAsOf: deps.now()
 		});
-		return rows;
+		for (const row of rows) rowsByKey.set(`${device.deviceId}|${row.clipKey}`, row);
+		const narrowed = listableClips(rows, {
+			since,
+			until
+		});
+		if (narrowed.outOfWindow > 0 || narrowed.inProgress > 0) deps.logger.info("videoclips: narrowed a day listing to what it can answer", {
+			tags,
+			meta: {
+				branch: "listing-narrowed",
+				listed: rows.length,
+				kept: narrowed.kept.length,
+				outOfWindow: narrowed.outOfWindow,
+				inProgress: narrowed.inProgress,
+				since,
+				until
+			}
+		});
+		return narrowed.kept;
 	};
 	/**
 	* Give a day's rows a class when the FILES carried none.
@@ -150349,14 +153105,17 @@ function createReolinkVideoclipsProvider(deps) {
 			if (device === null) throw new Error(`videoclips: device ${deviceId} is not a Reolink camera`);
 			if (device.isBattery && device.sleeping && !device.isHubChild) throw new Error(`videoclips: device ${deviceId} is a standalone battery camera and is sleeping — fetching a clip would wake it. Use "Wake and refresh" first.`);
 			const row = rowsByKey.get(`${deviceId}|${clipKeyFor(parsed.channel, parsed.fileName)}`) ?? null;
-			const wantsMain = profile === "high" && row?.mainFileName !== void 0;
-			const fileName = wantsMain ? row?.mainFileName ?? parsed.fileName : parsed.fileName;
+			const chosen = row === null ? null : chooseClipTwin(profile, {
+				subFileName: row.subFileName,
+				...row.mainFileName !== void 0 ? { mainFileName: row.mainFileName } : {}
+			});
+			const fileName = chosen === null || chosen.fileName === "" ? parsed.fileName : chosen.fileName;
 			const prepared = await deps.preparePlayback({
 				device,
 				row,
 				fileName,
 				clipKey: clipKeyFor(parsed.channel, parsed.fileName),
-				profile: wantsMain ? "high" : "low"
+				profile: chosen?.served ?? "low"
 			});
 			return {
 				playbackUrl: prepared.playbackUrl,
@@ -150417,8 +153176,8 @@ function createReolinkVideoclipsProvider(deps) {
 			const row = rowsByKey.get(`${deviceId}|${clipKey}`);
 			if (row === void 0) return refuse("catalog-miss", `clip "${clipId}" is not in this node's catalog for device ${deviceId} — list the day that holds it first`, { clipKey });
 			if (row.inProgress === true) return refuse("clip-in-progress", `clip "${clipId}" is still being written, so it has no end to export`, { clipKey });
-			const mainFileName = profile === "high" ? row.mainFileName : void 0;
-			if (profile === "high" && mainFileName === void 0) deps.logger.warn("videoclips: no main twin for this clip — serving the sub copy", {
+			const chosen = chooseClipTwin(profile, row);
+			if (chosen.downgraded) deps.logger.warn("videoclips: no main twin for this clip — serving the sub copy", {
 				tags,
 				meta: {
 					clipId,
@@ -150427,13 +153186,13 @@ function createReolinkVideoclipsProvider(deps) {
 					asked: profile
 				}
 			});
-			const twin = mainFileName === void 0 ? "sub" : "main";
-			const fileName = mainFileName ?? row.subFileName;
+			const twin = chosen.twin;
+			const fileName = chosen.fileName;
 			if (fileName === "") return refuse("no-file-for-window", `clip "${clipId}" is listed with no byte handle behind it`, {
 				clipKey,
 				twin
 			});
-			const served = twin === "main" ? "high" : "low";
+			const served = chosen.served;
 			const bound = Math.min(maxBytes ?? 52428800, VIDEOCLIPS_MAX_READ_BYTES);
 			const declaredBytes = twin === "main" ? row.mainBytes : row.subBytes;
 			if (declaredBytes !== void 0 && declaredBytes > bound) return refuse("too-large-to-transfer", `the camera lists the ${twin} file of clip "${clipId}" as ${declaredBytes} bytes, over the ${bound}-byte bound for an inline read — play it from its playback URL instead`, {
@@ -150477,6 +153236,75 @@ function createReolinkVideoclipsProvider(deps) {
 				served,
 				...outcome.durationMs !== null ? { durationMs: outcome.durationMs } : {}
 			};
+		},
+		/**
+		* Where this clip's STREAM is dialled (D597) — the same questions
+		* `readClipBytes` asks before the camera is touched (the id, the row, a
+		* file still being written), the same vocabulary, and NO fetch: the URL
+		* is one shot on the provider's own listener and the camera is opened
+		* when the broker dials it.
+		*
+		* It serves EVERY profile, through the same {@link chooseClipTwin} the
+		* byte read asks (D599). It used to refuse `high` by name, on the grounds
+		* that handing a sub copy to a `high` ask is the silent 33× substitution
+		* D576 forbids — true, but the refusal was not the cure. The cure is
+		* `served`, which is on this answer and states which twin the stream
+		* actually carries. Refusing left the operator with `high` looking
+		* unsupported, and left two transports behind one pointer.
+		*/
+		dialClipStream: async ({ deviceId, clipId, profile, audio }) => {
+			const tags = { deviceId };
+			const refuse = (code, detail, meta) => {
+				deps.logger.warn("videoclips: refusing a clip stream dial", {
+					tags,
+					meta: {
+						clipId,
+						branch: code,
+						...meta
+					}
+				});
+				throw new Error(clipExportFailure(code, detail));
+			};
+			const parsed = parseClipId(clipId);
+			if (parsed === null) return refuse("catalog-miss", `clip id "${clipId}" was not minted by the Reolink provider`, {});
+			const clipKey = clipKeyFor(parsed.channel, parsed.fileName);
+			const row = rowsByKey.get(`${deviceId}|${clipKey}`);
+			if (row === void 0) return refuse("catalog-miss", `clip "${clipId}" is not in this node's catalog for device ${deviceId} — list the day that holds it first`, { clipKey });
+			if (row.inProgress === true) return refuse("clip-in-progress", `clip "${clipId}" is still being written; it has no end to stream to`, { clipKey });
+			const chosen = chooseClipTwin(profile, row);
+			if (chosen.downgraded) deps.logger.warn("videoclips: no main twin for this clip — streaming the sub copy", {
+				tags,
+				meta: {
+					clipId,
+					clipKey,
+					branch: "no-main-twin",
+					asked: profile
+				}
+			});
+			if (chosen.fileName === "") return refuse("no-file-for-window", `clip "${clipId}" is listed with no byte handle behind it`, {
+				clipKey,
+				twin: chosen.twin
+			});
+			const askedAudio = audio ?? "none";
+			const audioReason = askedAudio === "none" ? "not-requested" : null;
+			const outcome = await deps.prepareStreamDial({
+				deviceId,
+				row,
+				twin: chosen.twin,
+				audio: askedAudio
+			});
+			if (outcome.kind === "refused") return refuse(outcome.code, outcome.detail, {
+				clipKey,
+				twin: chosen.twin
+			});
+			return {
+				url: outcome.url,
+				expiresAtMs: outcome.expiresAtMs,
+				transport: "forward-only",
+				served: chosen.served,
+				servedAudio: askedAudio,
+				...audioReason !== null ? { audioReason } : {}
+			};
 		}
 	};
 	/**
@@ -151107,9 +153935,15 @@ function createClipService(deps) {
 	* clip-export vocabulary, so the provider can hand the engine a token it
 	* believes rather than prose it has to guess at (D572).
 	*/
-	const produceTwin = async (input) => {
-		const { deviceId, row, fileName, twin } = input;
-		const clipKey = row.clipKey;
+	/**
+	* The gates every clip byte path runs, in ONE place: the device, the
+	* sleeping standalone, the uid. The file producer and the stream producer
+	* both call this and neither decides any of it again — a second copy of
+	* the sleeping gate is a second chance to wake a camera nobody authorised.
+	* Every refusal is logged HERE, with its branch, so a caller cannot forget.
+	*/
+	const gateClipDevice = async (input) => {
+		const { deviceId, clipKey, twin, path } = input;
 		const tags = { deviceId };
 		const device = await deps.resolveDevice(deviceId);
 		if (device === null) {
@@ -151118,11 +153952,13 @@ function createClipService(deps) {
 				meta: {
 					clipKey,
 					twin,
+					path,
 					branch: "unknown-device"
 				}
 			});
 			return {
 				kind: "refused",
+				branch: "unknown-device",
 				code: "catalog-unreachable",
 				detail: `device ${deviceId} is not a Reolink camera on this node`
 			};
@@ -151134,11 +153970,13 @@ function createClipService(deps) {
 					meta: {
 						clipKey,
 						twin,
+						path,
 						branch: "sleeping"
 					}
 				});
 				return {
 					kind: "refused",
+					branch: "sleeping",
 					code: "sleeping",
 					detail: `device ${deviceId} is a standalone battery camera and is sleeping — fetching a clip would wake it, and no operator authorisation was carried`
 				};
@@ -151148,6 +153986,7 @@ function createClipService(deps) {
 				meta: {
 					clipKey,
 					twin,
+					path,
 					branch: "wake-authorised"
 				}
 			});
@@ -151158,15 +153997,39 @@ function createClipService(deps) {
 				meta: {
 					clipKey,
 					twin,
+					path,
 					branch: "uid-missing"
 				}
 			});
 			return {
 				kind: "refused",
+				branch: "uid-missing",
 				code: "catalog-unreachable",
 				detail: UID_MISSING_REASON
 			};
 		}
+		return {
+			kind: "ok",
+			device
+		};
+	};
+	const produceTwin = async (input) => {
+		const { deviceId, row, fileName, twin } = input;
+		const clipKey = row.clipKey;
+		const tags = { deviceId };
+		const gate = await gateClipDevice({
+			deviceId,
+			clipKey,
+			twin,
+			path: "file",
+			...input.wake !== void 0 ? { wake: input.wake } : {}
+		});
+		if (gate.kind === "refused") return {
+			kind: "refused",
+			code: gate.code,
+			detail: gate.detail
+		};
+		const { device } = gate;
 		let downloaded;
 		deps.logger.info("videoclips: fetching a clip file from the camera", {
 			tags,
@@ -151344,6 +154207,34 @@ function createClipService(deps) {
 		if (outcome.kind === "ok" && twin === "sub") await media.put(deviceId, row.clipKey, outcome.bytes);
 		return outcome;
 	};
+	/**
+	* The STREAM's path (`clip-stream-route.ts`): the same gates, the same row,
+	* nothing written. Beside the file path, not in its place.
+	*/
+	const streamClip = createClipStreamRoute({
+		logger: deps.logger,
+		gate: gateClipDevice,
+		rowFor,
+		producer: createClipStreamProducer({
+			logger: deps.logger,
+			spawnMux: (args) => spawn$1(deps.ffmpegBinaryPath ?? "ffmpeg", [...args], { stdio: [
+				"pipe",
+				"pipe",
+				"pipe",
+				"pipe"
+			] })
+		})
+	});
+	/**
+	* The stream's DIAL (D597): the same route behind a one-shot token on a
+	* loopback listener, because the broker holds no credential the data
+	* plane or the hub proxy would take. See `clip-stream-dial.ts`.
+	*/
+	const streamDial = createClipStreamDial({
+		logger: deps.logger,
+		stream: streamClip,
+		now
+	});
 	const provider = createReolinkVideoclipsProvider({
 		now,
 		cache,
@@ -151356,11 +154247,41 @@ function createClipService(deps) {
 			served: profile === "high" ? "high" : "low"
 		}),
 		prepareBytes,
+		prepareStreamDial: async ({ deviceId, row, twin, audio }) => {
+			const gate = await gateClipDevice({
+				deviceId,
+				clipKey: row.clipKey,
+				twin,
+				path: "stream"
+			});
+			if (gate.kind === "refused") return {
+				kind: "refused",
+				code: gate.code,
+				detail: gate.detail
+			};
+			const minted = await streamDial.mint({
+				deviceId,
+				clipKey: row.clipKey,
+				twin,
+				audio
+			});
+			if (minted.kind === "refused") return {
+				kind: "refused",
+				code: "fetch-failed",
+				detail: `${minted.code}: ${minted.detail}`
+			};
+			return {
+				kind: "ok",
+				url: minted.url,
+				expiresAtMs: minted.expiresAtMs
+			};
+		},
 		logger: deps.logger
 	});
 	return {
 		provider,
 		cache,
+		disposeClipStreamDial: () => streamDial.dispose(),
 		refreshCatalog: async (deviceId) => {
 			const until = now();
 			await provider.listClips({
@@ -151373,6 +154294,11 @@ function createClipService(deps) {
 		hostBusy: (hostKey) => queue.busy(hostKey),
 		thumbPrefix: CLIP_THUMB_PREFIX,
 		mediaPrefix: CLIP_MEDIA_PREFIX,
+		streamPrefix: CLIP_STREAM_PREFIX,
+		streamHandler: createClipStreamHandler({
+			stream: streamClip,
+			logger: deps.logger
+		}),
 		thumbHandler: createClipThumbHandler({
 			readCached: (deviceId, clipKey) => thumbs.read(deviceId, clipKey),
 			mint: (deviceId, clipKey) => mintThumbnail(deviceId, clipKey, "interactive"),
@@ -165391,6 +168317,7 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 			this.clipRefreshTimer = null;
 		}
 		this.logChannels?.stop();
+		await this.clipService?.disposeClipStreamDial().catch(() => {});
 		await this.emailPushServer?.stop().catch(() => {});
 		await this.autodetectCache.dispose();
 	}
@@ -165612,11 +168539,18 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 				access: "authenticated",
 				handler: service.playbackHandler
 			});
+			const stream = await this.ctx.dataPlane?.serve({
+				prefix: service.streamPrefix,
+				access: "authenticated",
+				handler: service.streamHandler
+			});
 			this.ctx.logger.info("Reolink clip data planes served", { meta: {
 				thumbPath: `/addon/${REOLINK_ADDON_ID}/${service.thumbPrefix}`,
 				mediaPath: `/addon/${REOLINK_ADDON_ID}/${service.mediaPrefix}`,
+				streamPath: `/addon/${REOLINK_ADDON_ID}/${service.streamPrefix}`,
 				thumbServed: thumb !== void 0,
-				mediaServed: media !== void 0
+				mediaServed: media !== void 0,
+				streamServed: stream !== void 0
 			} });
 		} catch (err) {
 			this.ctx.logger.warn("Reolink clip data planes failed to serve — clips will not render", { meta: { error: err instanceof Error ? err.message : String(err) } });