@camstack/addon-provider-reolink 1.2.159 → 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-CUmLTud7.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",
@@ -149064,11 +150537,35 @@ function createClipPlaybackHandler(deps) {
 * `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 = {
-	"content-type": "video/mp4",
 	"accept-ranges": "none",
 	"cache-control": "no-store",
-	["x-camstack-clip-transport"]: "forward-only"
+	[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. */
@@ -149084,22 +150581,33 @@ function streamRefusalStatus(code) {
 	}
 }
 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 match = MEDIA_PATH.exec(pathnameOf(req));
-		if (match === null) {
-			res.writeHead(400);
+		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 = Number(match[1]);
-		const clipKey = match[2] ?? "";
+		const { deviceId, clipKey } = resolved.target;
 		if (req.method === "HEAD") {
-			res.writeHead(200, STREAM_HEADERS);
+			res.writeHead(200, {
+				"content-type": "video/mp4",
+				...STREAM_HEADERS
+			});
 			res.end();
 			return;
 		}
@@ -149111,8 +150619,11 @@ function createClipStreamHandler(deps) {
 			}
 		});
 		const sink = {
-			begin: () => {
-				res.writeHead(200, STREAM_HEADERS);
+			begin: (contentType) => {
+				res.writeHead(200, {
+					"content-type": contentType,
+					...STREAM_HEADERS
+				});
 			},
 			write: (chunk) => res.write(chunk),
 			onceDrain: (listener) => {
@@ -149130,7 +150641,7 @@ function createClipStreamHandler(deps) {
 		};
 		let outcome;
 		try {
-			outcome = await deps.stream(deviceId, clipKey, sink);
+			outcome = await deps.stream(resolved.target, sink);
 		} catch (err) {
 			deps.logger.warn("videoclips: the clip stream route threw", {
 				tags: { deviceId },
@@ -149343,16 +150854,39 @@ function probeClipStreamRate(timestampsUs) {
 		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;
 /**
-* One ffmpeg, stdin to stdout, video only, fragmented MP4.
+* 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 audio input — the file header says why.
+* 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",
@@ -149363,12 +150897,42 @@ function buildClipStreamMuxArgs(input) {
 		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",
-		"mp4",
+		clipStreamContainerFor(audio),
 		"pipe:1"
 	];
 }
@@ -149456,10 +151020,22 @@ 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: () => handlers.onAudioFrame()
+	onAudioFrame: (frame) => handlers.onAudioFrame({
+		audioType: frame.audioType,
+		data: frame.data
+	})
 });
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function createClipStreamProducer(deps) {
@@ -149549,7 +151125,16 @@ var ClipStreamRun = class {
 	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 = [];
@@ -149567,6 +151152,7 @@ var ClipStreamRun = class {
 	bytesOut = 0;
 	cut = null;
 	stdinGate;
+	audioStdinGate;
 	peerGate;
 	tags;
 	constructor(deps, input, attempt) {
@@ -149578,6 +151164,10 @@ var ClipStreamRun = class {
 			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")
@@ -149590,9 +151180,7 @@ var ClipStreamRun = class {
 		});
 		const decoder = this.deps.createDecoder({
 			onVideoAccessUnit: (unit) => this.onAccessUnit(unit),
-			onAudioFrame: () => {
-				this.audioFrames += 1;
-			}
+			onAudioFrame: (frame) => this.onAudioFrame(frame)
 		});
 		this.deps.logger.info("videoclips: streaming a clip file from the camera", {
 			tags: this.tags,
@@ -149603,6 +151191,7 @@ var ClipStreamRun = class {
 				startMs: row.startMs,
 				endMs: row.endMs,
 				attempt: this.attempt,
+				audioAsked: this.input.audio,
 				idleTimeoutMs: 300
 			}
 		});
@@ -149649,12 +151238,68 @@ var ClipStreamRun = class {
 		}
 		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,
@@ -149669,13 +151314,33 @@ var ClipStreamRun = class {
 		try {
 			mux = this.deps.spawnMux(buildClipStreamMuxArgs({
 				videoType: this.videoType,
-				fps: this.rate.fps
+				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) => {
@@ -149698,24 +151363,38 @@ var ClipStreamRun = class {
 				videoType: this.videoType,
 				fps: this.rate.fps,
 				fpsSource: this.rate.fpsSource,
-				probeAccessUnits: this.rate.accessUnits
+				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();
+			sink.begin(clipStreamContentTypeFor(this.audioMuxed));
 		}
 		const accepted = sink.write(chunk);
 		this.bytesOut += chunk.byteLength;
@@ -149741,6 +151420,7 @@ var ClipStreamRun = class {
 			detail
 		};
 		this.stdinGate.dispose();
+		this.audioStdinGate.dispose();
 		this.peerGate.dispose();
 		this.mux?.kill("SIGKILL");
 		this.deps.logger.warn("videoclips: a clip stream was cut", {
@@ -149752,7 +151432,10 @@ var ClipStreamRun = class {
 				detail,
 				accessUnits: this.accessUnits,
 				bytesOut: this.bytesOut,
-				begun: this.begun
+				begun: this.begun,
+				audioMuxed: this.audioMuxed,
+				audioFramesIn: this.audioFrames,
+				audioFramesDropped: this.audioFramesDropped
 			}
 		});
 		if (this.begun) this.input.sink.destroy();
@@ -149798,6 +151481,7 @@ var ClipStreamRun = class {
 			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);
@@ -149823,11 +151507,13 @@ var ClipStreamRun = class {
 			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,
@@ -149859,19 +151545,11 @@ var ClipStreamRun = class {
 				branch: "stream-served"
 			}
 		});
-		if (this.audioFrames > 0) this.deps.logger.warn("videoclips: a clip stream was served without sound", {
-			tags: this.tags,
-			meta: {
-				clipKey: row.clipKey,
-				twin,
-				branch: "stream-video-only",
-				audioFramesDropped: this.audioFrames
-			}
-		});
+		this.reportAudio(audio);
 		return {
 			kind: "served",
 			accessUnits: this.accessUnits,
-			audioFramesDropped: this.audioFrames,
+			audio,
 			bytesOut: this.bytesOut,
 			durationSeconds,
 			verdict,
@@ -149879,15 +151557,269 @@ var ClipStreamRun = class {
 			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 (deviceId, clipKey, sink) => {
-		const twin = "sub";
+	return async (target, sink) => {
+		const { deviceId, clipKey, twin, audio } = target;
 		const gate = await deps.gate({
 			deviceId,
 			clipKey,
@@ -149930,11 +151862,28 @@ function createClipStreamRoute(deps) {
 				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: row.subFileName,
+			fileName,
 			twin,
+			audio,
 			sink
 		});
 		switch (outcome.kind) {
@@ -150180,6 +152129,76 @@ function listableClips(rows, window) {
 		inProgress: inWindow.length - kept.length
 	};
 }
+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));
+	const claimed = /* @__PURE__ */ new Set();
+	const pairs = [];
+	for (const sub of datedSubs.toSorted((a, b) => startOf(a) - startOf(b))) {
+		const subStart = startOf(sub);
+		let bestIndex = -1;
+		let bestDelta = Number.POSITIVE_INFINITY;
+		for (const [index, candidate] of datedMains.entries()) {
+			if (claimed.has(index)) continue;
+			const delta = Math.abs(startOf(candidate) - subStart);
+			if (delta > 3e3) continue;
+			if (delta < bestDelta) {
+				bestDelta = delta;
+				bestIndex = index;
+			}
+		}
+		if (bestIndex === -1) {
+			pairs.push({ sub });
+			continue;
+		}
+		claimed.add(bestIndex);
+		const main = datedMains[bestIndex];
+		pairs.push(main === void 0 ? { sub } : {
+			sub,
+			main
+		});
+	}
+	return pairs.toSorted((a, b) => startOf(b.sub) - startOf(a.sub));
+}
+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
 /**
@@ -150385,40 +152404,6 @@ 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));
-	const claimed = /* @__PURE__ */ new Set();
-	const pairs = [];
-	for (const sub of datedSubs.toSorted((a, b) => startOf(a) - startOf(b))) {
-		const subStart = startOf(sub);
-		let bestIndex = -1;
-		let bestDelta = Number.POSITIVE_INFINITY;
-		for (const [index, candidate] of datedMains.entries()) {
-			if (claimed.has(index)) continue;
-			const delta = Math.abs(startOf(candidate) - subStart);
-			if (delta > 3e3) continue;
-			if (delta < bestDelta) {
-				bestDelta = delta;
-				bestIndex = index;
-			}
-		}
-		if (bestIndex === -1) {
-			pairs.push({ sub });
-			continue;
-		}
-		claimed.add(bestIndex);
-		const main = datedMains[bestIndex];
-		pairs.push(main === void 0 ? { sub } : {
-			sub,
-			main
-		});
-	}
-	return pairs.toSorted((a, b) => startOf(b.sub) - startOf(a.sub));
-}
-function startOf(file) {
-	return file.startTime?.getTime() ?? 0;
-}
 var partsCache = /* @__PURE__ */ new Map();
 function formatterFor$1(timeZone) {
 	const cached = partsCache.get(timeZone);
@@ -151120,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,
@@ -151188,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,
@@ -151198,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`, {
@@ -151248,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 } : {}
+			};
 		}
 	};
 	/**
@@ -152161,12 +154218,23 @@ function createClipService(deps) {
 		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,
@@ -152179,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({
@@ -166219,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();
 	}