@dcl-regenesislabs/opendcl 0.2.1-26165320302.commit-e6effe4 → 0.2.1-26238928766.commit-28648d7

package/skills/animations-tweens/SKILL.md

@@ -5,6 +5,10 @@ description: Animate objects in Decentraland scenes. Play GLTF model animations
 
 # Animations and Tweens in Decentraland
 
+## Authoring split
+
+`Animator`, `Tween`, and `TweenSequence` are all supported in `main-entities.ts` — declare the entity, its visual components, and its initial animation state in the literal. Switch clips or replace tweens at runtime in `src/index.ts` via `getMutable`.
+
 ## When to Use Which Animation Approach
 
 | Need | Approach | When |
@@ -21,142 +25,214 @@ description: Animate objects in Decentraland scenes. Play GLTF model animations
 
 ## GLTF Animations (Animator)
 
-Play animations embedded in .glb models:
+Declare the character and its animation states in `main-entities.ts`. The `states` array is part of the `Animator` shape and is JSON-compatible.
 
 ```typescript
-import { engine, Transform, GltfContainer, Animator } from '@dcl/sdk/ecs'
-import { Vector3 } from '@dcl/sdk/math'
-
-const character = engine.addEntity()
-Transform.create(character, { position: Vector3.create(8, 0, 8) })
-GltfContainer.create(character, { src: 'models/character.glb' })
-
-// Set up animation states
-Animator.create(character, {
-  states: [
-    { clip: 'idle', playing: true, loop: true, speed: 1 },
-    { clip: 'walk', playing: false, loop: true, speed: 1 },
-    { clip: 'attack', playing: false, loop: false, speed: 1.5 }
-  ]
-})
+// main-entities.ts
+import type { Scene } from '@dcl/sdk/scene-types'
+
+export const scene = {
+  character: {
+    components: {
+      Transform: { position: { x: 8, y: 0, z: 8 } },
+      GltfContainer: { src: 'models/character.glb' },
+      Animator: {
+        states: [
+          { clip: 'idle', playing: true, loop: true, speed: 1 },
+          { clip: 'walk', playing: false, loop: true, speed: 1 },
+          { clip: 'attack', playing: false, loop: false, speed: 1.5 }
+        ]
+      }
+    }
+  }
+} satisfies Scene
+```
 
-// Play a specific animation
-Animator.playSingleAnimation(character, 'walk')
+Trigger and switch animations at runtime in `src/index.ts`:
 
-// Stop all animations
-Animator.stopAllAnimations(character)
+```typescript
+import { engine, Animator } from '@dcl/sdk/ecs'
+
+export function main() {
+  const character = engine.getEntityOrNullByName('character')
+  if (!character) return
+
+  // Play a specific animation
+  Animator.playSingleAnimation(character, 'walk')
+
+  // Stop all animations
+  // Animator.stopAllAnimations(character)
+}
 ```
 
 ### Switching Animations
 ```typescript
+import { Entity, Animator } from '@dcl/sdk/ecs'
+
 function playAnimation(entity: Entity, clipName: string) {
   const animator = Animator.getMutable(entity)
-  // Stop all
-  for (const state of animator.states) {
-    state.playing = false
-  }
-  // Play the desired one
+  for (const state of animator.states) state.playing = false
   const state = animator.states.find(s => s.clip === clipName)
-  if (state) {
-    state.playing = true
-  }
+  if (state) state.playing = true
 }
 ```
 
-## Tweens (Code-Based Animation)
+## Tweens
 
-Animate entity properties smoothly over time:
+`Tween` and `TweenSequence` are JSON-compatible. The `mode` is a `$case`-tagged union; positions/quaternions are plain object literals; easing is a numeric enum.
 
 ### Move
 ```typescript
-import { engine, Transform, Tween, EasingFunction } from '@dcl/sdk/ecs'
-import { Vector3 } from '@dcl/sdk/math'
-
-const box = engine.addEntity()
-Transform.create(box, { position: Vector3.create(2, 1, 8) })
-
-Tween.create(box, {
-  mode: Tween.Mode.Move({
-    start: Vector3.create(2, 1, 8),
-    end: Vector3.create(14, 1, 8)
-  }),
-  duration: 2000,  // milliseconds
-  easingFunction: EasingFunction.EF_EASESINE
-})
+// main-entities.ts
+sliding_box: {
+  components: {
+    Transform: { position: { x: 2, y: 1, z: 8 } },
+    MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } },
+    Tween: {
+      duration: 2000,  // milliseconds
+      easingFunction: 6,  // EasingFunction.EF_EASESINE
+      mode: {
+        $case: 'move',
+        move: { start: { x: 2, y: 1, z: 8 }, end: { x: 14, y: 1, z: 8 } }
+      }
+    }
+  }
+}
 ```
 
+Common easing values: `0 = EF_LINEAR`, `1 = EF_EASEINQUAD`, `2 = EF_EASEOUTQUAD`, `3 = EF_EASEQUAD`, `6 = EF_EASESINE`. To replace or stop a tween at runtime, use `Tween.createOrReplace` / `Tween.deleteFrom` on the named entity in `src/index.ts`.
+
 ### Rotate
+
 ```typescript
-Tween.create(box, {
-  mode: Tween.Mode.Rotate({
-    start: Quaternion.fromEulerDegrees(0, 0, 0),
-    end: Quaternion.fromEulerDegrees(0, 360, 0)
-  }),
-  duration: 3000,
-  easingFunction: EasingFunction.EF_LINEAR
-})
+// main-entities.ts — quaternions are { x, y, z, w } literals.
+// 360° around Y end-state is { x: 0, y: 1, z: 0, w: 0 }
+spinning_obj: {
+  components: {
+    Transform: { position: { x: 8, y: 1, z: 8 } },
+    MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } },
+    Tween: {
+      duration: 3000,
+      easingFunction: 0,  // EF_LINEAR
+      mode: {
+        $case: 'rotate',
+        rotate: {
+          start: { x: 0, y: 0, z: 0, w: 1 },
+          end: { x: 0, y: 1, z: 0, w: 0 }
+        }
+      }
+    }
+  }
+}
+```
+
+For exact-degree rotations without hand-computing quaternions, leave the tween out of `main-entities.ts` and create it at runtime in `src/index.ts` where `Quaternion.fromEulerDegrees()` is available:
+
+```typescript
+// src/index.ts — runtime tween authoring (helpers allowed)
+import { engine, Tween, EasingFunction } from '@dcl/sdk/ecs'
+import { Quaternion } from '@dcl/sdk/math'
+
+export function main() {
+  const box = engine.getEntityOrNullByName('spinning_obj')
+  if (!box) return
+  Tween.createOrReplace(box, {
+    mode: Tween.Mode.Rotate({
+      start: Quaternion.fromEulerDegrees(0, 0, 0),
+      end: Quaternion.fromEulerDegrees(0, 360, 0)
+    }),
+    duration: 3000,
+    easingFunction: EasingFunction.EF_LINEAR
+  })
+}
 ```
 
 ### Scale
+
 ```typescript
-Tween.create(box, {
-  mode: Tween.Mode.Scale({
-    start: Vector3.create(1, 1, 1),
-    end: Vector3.create(2, 2, 2)
-  }),
-  duration: 1000,
-  easingFunction: EasingFunction.EF_EASEOUTBOUNCE
-})
+// main-entities.ts
+grow_box: {
+  components: {
+    Transform: { position: { x: 8, y: 1, z: 8 } },
+    MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } },
+    Tween: {
+      duration: 1000,
+      easingFunction: 14,  // EF_EASEOUTBOUNCE
+      mode: {
+        $case: 'scale',
+        scale: { start: { x: 1, y: 1, z: 1 }, end: { x: 2, y: 2, z: 2 } }
+      }
+    }
+  }
+}
 ```
 
 ## Tween Sequences (Chained Animations)
 
-Chain multiple tweens to play one after another:
+Chain multiple tweens to play one after another. `TweenSequence` is supported in `main-entities.ts`:
 
 ```typescript
-import { TweenSequence, TweenLoop } from '@dcl/sdk/ecs'
-
-// First tween
-Tween.create(box, {
-  mode: Tween.Mode.Move({
-    start: Vector3.create(2, 1, 8),
-    end: Vector3.create(14, 1, 8)
-  }),
-  duration: 2000,
-  easingFunction: EasingFunction.EF_EASESINE
-})
-
-// Chain sequence
-TweenSequence.create(box, {
-  sequence: [
-    // Second: move back
-    {
-      mode: Tween.Mode.Move({
-        start: Vector3.create(14, 1, 8),
-        end: Vector3.create(2, 1, 8)
-      }),
+// main-entities.ts
+patrol_box: {
+  components: {
+    Transform: { position: { x: 2, y: 1, z: 8 } },
+    MeshRenderer: { mesh: { $case: 'box', box: { uvs: [] } } },
+    Tween: {
       duration: 2000,
-      easingFunction: EasingFunction.EF_EASESINE
+      easingFunction: 6,  // EF_EASESINE
+      mode: { $case: 'move', move: { start: { x: 2, y: 1, z: 8 }, end: { x: 14, y: 1, z: 8 } } }
+    },
+    TweenSequence: {
+      loop: 0,  // TweenLoop.TL_RESTART (1 = TL_YOYO)
+      sequence: [
+        {
+          duration: 2000,
+          easingFunction: 6,
+          mode: { $case: 'move', move: { start: { x: 14, y: 1, z: 8 }, end: { x: 2, y: 1, z: 8 } } }
+        }
+      ]
     }
-  ],
-  loop: TweenLoop.TL_RESTART // Loop the entire sequence
-})
+  }
+}
 ```
 
 ## Easing Functions
 
-Available easing functions from `EasingFunction`:
-- `EF_LINEAR` — Constant speed
-- `EF_EASEINQUAD` / `EF_EASEOUTQUAD` / `EF_EASEQUAD` — Quadratic
-- `EF_EASEINSINE` / `EF_EASEOUTSINE` / `EF_EASESINE` — Sinusoidal (smooth)
-- `EF_EASEINEXPO` / `EF_EASEOUTEXPO` / `EF_EASEEXPO` — Exponential
-- `EF_EASEINELASTIC` / `EF_EASEOUTELASTIC` / `EF_EASEELASTIC` — Elastic bounce
-- `EF_EASEOUTBOUNCE` / `EF_EASEINBOUNCE` / `EF_EASEBOUNCE` — Bounce effect
-- `EF_EASEINBACK` / `EF_EASEOUTBACK` / `EF_EASEBACK` — Overshoot
-- `EF_EASEINCUBIC` / `EF_EASEOUTCUBIC` / `EF_EASECUBIC` — Cubic
-- `EF_EASEINQUART` / `EF_EASEOUTQUART` / `EF_EASEQUART` — Quartic
-- `EF_EASEINQUINT` / `EF_EASEOUTQUINT` / `EF_EASEQUINT` — Quintic
-- `EF_EASEINCIRC` / `EF_EASEOUTCIRC` / `EF_EASECIRC` — Circular
+Inside `main-entities.ts` use the integer values (left). In `src/index.ts` you can reference `EasingFunction.<NAME>` directly.
+
+| value | enum | shape |
+|---|---|---|
+| 0  | EF_LINEAR          | Constant speed |
+| 1  | EF_EASEINQUAD      | Quadratic in |
+| 2  | EF_EASEOUTQUAD     | Quadratic out |
+| 3  | EF_EASEQUAD        | Quadratic in-out |
+| 4  | EF_EASEINSINE      | Sinusoidal in |
+| 5  | EF_EASEOUTSINE     | Sinusoidal out |
+| 6  | EF_EASESINE        | Sinusoidal in-out (smooth) |
+| 7  | EF_EASEINEXPO      | Exponential in |
+| 8  | EF_EASEOUTEXPO     | Exponential out |
+| 9  | EF_EASEEXPO        | Exponential in-out |
+| 10 | EF_EASEINELASTIC   | Elastic in |
+| 11 | EF_EASEOUTELASTIC  | Elastic out |
+| 12 | EF_EASEELASTIC     | Elastic in-out |
+| 13 | EF_EASEINBOUNCE    | Bounce in |
+| 14 | EF_EASEOUTBOUNCE   | Bounce out |
+| 15 | EF_EASEBOUNCE      | Bounce in-out |
+| 16 | EF_EASEINCUBIC     | Cubic in |
+| 17 | EF_EASEOUTCUBIC    | Cubic out |
+| 18 | EF_EASECUBIC       | Cubic in-out |
+| 19 | EF_EASEINQUART     | Quartic in |
+| 20 | EF_EASEOUTQUART    | Quartic out |
+| 21 | EF_EASEQUART       | Quartic in-out |
+| 22 | EF_EASEINQUINT     | Quintic in |
+| 23 | EF_EASEOUTQUINT    | Quintic out |
+| 24 | EF_EASEQUINT       | Quintic in-out |
+| 25 | EF_EASEINCIRC      | Circular in |
+| 26 | EF_EASEOUTCIRC     | Circular out |
+| 27 | EF_EASECIRC        | Circular in-out |
+| 28 | EF_EASEINBACK      | Overshoot in |
+| 29 | EF_EASEOUTBACK     | Overshoot out |
+| 30 | EF_EASEBACK        | Overshoot in-out |
 
 ## Custom Animation Systems
 
@@ -205,8 +281,23 @@ Tween.setScale(entity,
   Vector3.One(), Vector3.create(2, 2, 2),
   1000, EasingFunction.EF_LINEAR
 )
+
+// Combined Move + Rotate + Scale in one Tween
+Tween.setMoveRotateScale(entity, {
+  positionStart: Vector3.create(0, 0, 0), positionEnd: Vector3.create(0, 5, 0),
+  rotationStart: Quaternion.fromEulerDegrees(0, 0, 0), rotationEnd: Quaternion.fromEulerDegrees(0, 360, 0),
+  scaleStart: Vector3.One(), scaleEnd: Vector3.create(0.5, 0.5, 0.5)
+}, 2000, EasingFunction.EF_EASEINOUTCUBIC)
+
+// Continuous spin — applies a per-frame Quaternion delta. No end state.
+Tween.setRotateContinuous(entity, Quaternion.fromEulerDegrees(0, -1, 0), 700)
+
+// Continuous move — applies a per-frame Vector3 delta scaled by speed.
+Tween.setMoveContinuous(entity, Vector3.create(0, 0, 1), 0.5)
 ```
 
+`*Continuous` variants don't end — they apply a constant delta until the Tween is removed (`Tween.deleteFrom(entity)`).
+
 ### Yoyo Loop Mode
 
 `TL_YOYO` reverses the tween at each end instead of restarting:
@@ -247,6 +338,20 @@ anim.states[0].weight = 0.5  // blend walk at 50%
 anim.states[1].weight = 0.5  // blend idle at 50%
 ```
 
+### Morph Targets (Blend Shapes)
+
+If a GLTF model exports morph targets (e.g., facial expressions, shape blends), drive them via the `weights` array on each `Animator.state`. Indices match the order morph targets were exported. Values range `0`–`1`.
+
+```typescript
+const anim = Animator.getMutable(entity)
+const state = anim.states.find(s => s.clip === 'Idle')
+if (state) {
+  state.weights = state.weights ?? []
+  state.weights[0] = 0.8   // morph target 0 at 80%
+  state.weights[1] = 0.3   // morph target 1 at 30%
+}
+```
+
 ## Troubleshooting
 
 | Problem | Cause | Solution |

package/skills/audio-analysis/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: audio-analysis
+description: Read real-time amplitude and 8-band frequency data from any AudioSource, AudioStream, or VideoPlayer entity in a Decentraland SDK7 scene with the AudioAnalysis component. Renderer fills the component each frame; scenes copy values into a plain JS view via readIntoView/tryReadIntoView and drive entity scale, color, lights, materials, particles, or UI from amplitude (overall loudness) and bands[0..7] (low→high frequency bins). Use when the user asks for music visualizers, beat reactivity, audio-reactive scenes, equalizers, dancing lights, scaling cubes that pulse to music, audio-driven materials, or anything that should react to sound. Do NOT use to play sound (see audio-video) or to detect player-emitted audio (this reads only entity-attached AudioSource/AudioStream/VideoPlayer audio).
+---
+
+# AudioAnalysis
+
+Real-time audio signal analysis attached to any entity that already has an `AudioSource`, `AudioStream`, or `VideoPlayer`. The renderer analyzes the audio frame buffer and writes results back into the component each tick. Scenes read those results to drive visualizers, beat-reactive geometry, audio-driven lights, etc.
+
+## Authoring split
+
+The **audio-emitting entity** (a speaker / radio / video screen) is static and belongs in `main-entities.ts` with its `AudioSource` / `AudioStream` / `VideoPlayer` component. `AudioAnalysis` itself is **not** in the supported declarative list — attach it at runtime in `src/index.ts` via `getEntityOrNullByName`. Reactive entities (pulsing cubes, EQ bars) are likewise added in code since their visuals are driven dynamically.
+
+```typescript
+// main-entities.ts — the audio source
+dj_speaker: {
+  components: {
+    Transform: { position: { x: 8, y: 1, z: 8 } },
+    AudioSource: { audioClipUrl: 'sounds/track.mp3', playing: true, loop: true, volume: 0.8 }
+  }
+}
+```
+
+```typescript
+// src/index.ts — attach analysis + reactive systems
+import { engine, AudioAnalysis, PBAudioAnalysisMode, Transform } from '@dcl/sdk/ecs'
+import { Vector3 } from '@dcl/sdk/math'
+
+export function main() {
+  const speaker = engine.getEntityOrNullByName('dj_speaker')
+  if (!speaker) return
+  AudioAnalysis.createAudioAnalysis(speaker, PBAudioAnalysisMode.MODE_LOGARITHMIC)
+  // ... reactive systems below
+}
+```
+
+## RULE: Requires an audio-emitting component on the same entity
+
+`AudioAnalysis` does nothing on its own. The entity MUST also have one of: `AudioSource`, `AudioStream`, or `VideoPlayer`. The renderer taps that component's audio frame buffer to compute amplitude/bands. An entity with only `AudioAnalysis` produces no data.
+
+## RULE: Audio must be playing for non-zero output
+
+Values are derived from live audio frames. If the source is paused, muted, or not yet loaded, `amplitude` and all `bands[]` stay at `0`. There is no "ready" event — start your reactive systems unconditionally, they will simply animate toward `0` while silent.
+
+## RULE: Only the Unity explorer implements this
+
+Bevy and the mobile Godot explorer ignore the component (no analysis written). Treat `AudioAnalysis` as a Unity-explorer-only enhancement and design fallbacks (e.g. a base scale that doesn't depend on `amplitude`) so the scene still looks reasonable elsewhere.
+
+## RULE: Read via `readIntoView` into a pre-allocated view
+
+`readIntoView` / `tryReadIntoView` write into a caller-owned `AudioAnalysisView = { amplitude: number, bands: number[] }`. Allocate the view once at scene init and reuse it every frame — do not `new` it inside the system. The `bands` array MUST be pre-sized to 8.
+
+## RULE: Use `createAudioAnalysis`, not `create`
+
+Use the helper `AudioAnalysis.createAudioAnalysis(entity, mode?, amplitudeGain?, bandsGain?)`. It pre-fills all required protobuf fields (8 bands + amplitude + mode) with safe defaults. Calling the raw `AudioAnalysis.create(entity, {...})` requires you to provide every band/amplitude field manually. Use `createOrReplaceAudioAnalysis` to overwrite an existing one without throwing.
+
+## Import
+
+```typescript
+import {
+  AudioAnalysis,
+  AudioAnalysisView,
+  PBAudioAnalysisMode,
+  AudioSource, // or AudioStream / VideoPlayer
+  engine,
+  Transform
+} from '@dcl/sdk/ecs'
+import { Vector3 } from '@dcl/sdk/math'
+```
+
+`AudioAnalysisView` is a TypeScript type alias (not a component), exported from `@dcl/sdk/ecs`.
+
+## Component fields
+
+Output (filled by the renderer; read in your systems):
+
+| Field | Type | Range | Notes |
+|---|---|---|---|
+| `amplitude` | `number` | `0..~1` (mode-dep.) | Aggregate signal strength of the current audio frame. |
+| `band0` | `number` | `0..~1` (mode-dep.) | Lowest frequency bin (sub-bass). |
+| `band1..6` | `number` | `0..~1` (mode-dep.) | Increasing frequency bins, log-spaced under MODE_LOGARITHMIC. |
+| `band7` | `number` | `0..~1` (mode-dep.) | Highest frequency bin (treble/air). |
+
+Inputs (configure once at create time):
+
+| Field | Type | Default | Notes |
+|---|---|---|---|
+| `mode` | `PBAudioAnalysisMode` | `MODE_LOGARITHMIC` | `MODE_RAW = 0` (raw FFT magnitudes) / `MODE_LOGARITHMIC = 1` (perceptual log mapping, recommended). |
+| `amplitudeGain` | `number?` | `5.0` | Multiplier applied to `amplitude`. Only used in MODE_LOGARITHMIC. |
+| `bandsGain` | `number?` | `0.05` | Multiplier applied to all 8 bands. Only used in MODE_LOGARITHMIC. |
+
+> Values are unbounded floats — gains can push them above `1`. Clamp or scale in your system if the visual you drive needs `0..1`. For typical music at default gains, expect peaks roughly in `0..1` with normal content sitting `0..0.5`.
+
+## AudioAnalysisView
+
+```typescript
+type AudioAnalysisView = {
+  amplitude: number
+  bands: number[]  // length 8 — bands[0] = lowest freq, bands[7] = highest
+}
+```
+
+## Reading the data
+
+```typescript
+const view: AudioAnalysisView = { amplitude: 0, bands: new Array<number>(8) }
+
+engine.addSystem(() => {
+  AudioAnalysis.readIntoView(audioEntity, view)
+  // Or, defensive variant — returns false if the component is missing:
+  // if (!AudioAnalysis.tryReadIntoView(audioEntity, view)) return
+
+  // view.amplitude and view.bands[0..7] are now populated
+})
+```
+
+## Common patterns
+
+```typescript
+// 1. Pulse an entity's scale to overall amplitude
+const view: AudioAnalysisView = { amplitude: 0, bands: new Array<number>(8) }
+engine.addSystem(() => {
+  AudioAnalysis.readIntoView(audioEntity, view)
+  const t = Transform.getMutable(pulseEntity)
+  const s = 1 + view.amplitude * 10
+  t.scale = Vector3.create(s, s, s)
+})
+
+// 2. 8-bar equalizer (one entity per band, scale Y by bands[i])
+for (const [entity, _] of engine.getEntitiesWith(VisualBar, Transform)) {
+  const i = VisualBar.get(entity).index   // 0..7
+  Transform.getMutable(entity).scale = Vector3.create(1, view.bands[i] * BAR_HEIGHT, 1)
+}
+
+// 3. Bass-only kick
+const bass = view.bands[0] + view.bands[1]
+if (bass > 0.7) { /* trigger flash */ }
+
+// 4. Custom gains (less sensitive amplitude, punchier bands)
+AudioAnalysis.createAudioAnalysis(
+  audioEntity,
+  PBAudioAnalysisMode.MODE_LOGARITHMIC,
+  2.0,
+  0.1
+)
+```
+
+## Mode selection
+
+- `MODE_LOGARITHMIC` (default) — bands are log-spaced and gain-scaled to roughly fit `0..1` for typical music. Use for visualizers, scaling, color reactivity. `amplitudeGain` / `bandsGain` apply.
+- `MODE_RAW` — raw FFT-derived magnitudes, linearly spaced. Lower bands dominate visually because most musical energy is there. Gains are ignored. Use only if you intend to do your own normalization.
+
+## Gotchas
+
+- **Output values can exceed `1.0`** with high gains or loud sources. Clamp downstream if you feed UI bars or alpha channels expecting `0..1`.
+- **Throttled updates.** Renderer runs analysis under a frame-time budget — values may skip frames under load. Drive smooth animations with `dt` interpolation.
+- **Multi-source scenes.** Each audio-emitting entity needs its own `AudioAnalysis`. No global mix-down.
+- **Works on `VideoPlayer` audio too.** The same audio frame buffer interface backs `AudioStream` and `VideoPlayer`, so you can react to a video's soundtrack.
+- **No `pitch` interaction.** `AudioSource.pitch` changes playback speed; analysis runs on the actual played frames, so a higher pitch shifts perceived band energy upward.
+- **Don't call `readIntoView` before `createAudioAnalysis`.** Reading without the component throws. Use `tryReadIntoView` if the component may not be attached yet.
+
+## Permissions
+
+No special scene permission beyond what `AudioSource` / `AudioStream` / `VideoPlayer` already requires. Streamed audio still needs `ALLOW_MEDIA_HOSTNAMES` in `scene.json` for its hostname (see `audio-video` skill).