diff --git a/src/bin/assets/mod.rs b/src/bin/assets/mod.rs
index 90870bc..9a2e8eb 100644
--- a/src/bin/assets/mod.rs
+++ b/src/bin/assets/mod.rs
@@ -12,9 +12,7 @@ mod rack;
 
 use bevy::core_pipeline::tonemapping::Tonemapping;
 use bevy::input::mouse::{AccumulatedMouseMotion, AccumulatedMouseScroll};
-use bevy::post_process::bloom::Bloom;
 use bevy::prelude::*;
-use bevy::render::view::Hdr;
 use bevy::render::view::screenshot::{Screenshot, save_to_disk};
 use bevy::window::{CursorGrabMode, CursorOptions, WindowResolution};
 
@@ -312,14 +310,13 @@ fn setup(mut commands: Commands, orbit: Res<Orbit>, harness: Option<Res<ShotHarn
     let eye = orbit_eye(&orbit);
     commands.spawn((
         Camera3d::default(),
-        Hdr,
-        Tonemapping::TonyMcMapface,
-        // Bloom scaled for LED glow only — at NATURAL the lit floor
-        // hazes the whole frame.
-        Bloom {
-            intensity: 0.07,
-            ..Bloom::NATURAL
-        },
+        // Filmic tonemapping, deliberately NO bloom and NO HDR view:
+        // Bloom requires an HDR target, and macOS EDR can vanish when
+        // the display idles or the window is unfocused — an HDR camera
+        // then renders solid black, which breaks harness captures.
+        // Glow is carried by emissives; the tester must judge assets
+        // exactly as the game renders them.
+        Tonemapping::AcesFitted,
         Transform::from_translation(eye).looking_at(orbit.target, Vec3::Y),
     ));
 
diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index d8d7be1..f0dbe3d 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -13,10 +13,8 @@ use bevy::camera::visibility::RenderLayers;
 use bevy::core_pipeline::tonemapping::Tonemapping;
 use bevy::ecs::hierarchy::ChildSpawnerCommands;
 use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
-use bevy::post_process::bloom::Bloom;
 use bevy::prelude::*;
 use bevy::render::render_resource::{Extent3d, TextureDimension, TextureFormat};
-use bevy::render::view::Hdr;
 use bevy::render::view::screenshot::{Screenshot, save_to_disk};
 use bevy::text::LineHeight;
 use bevy::window::{PrimaryWindow, WindowResolution};
@@ -332,6 +330,53 @@ struct ShotHarness {
     taken: bool,
 }
 
+// ─── The wake (world/story/opening.md beat 1 — glow choreography) ────────────
+
+/// The opening breath of a run: the screen is born inside the core's
+/// light. The strip's color stutters in and fills the whole field of
+/// view, resolves into a column of light, and the camera pulls back
+/// along the game tilt until the server towers over the frame and the
+/// normal framing takes over. Any key skips. Frontend-only: the sim
+/// ticks normally underneath (paused at start as usual).
+#[derive(Resource)]
+struct WakeState {
+    t: f32,
+    active: bool,
+    /// Harness freeze: hold the sequence at `t` for one deterministic PNG.
+    frozen: bool,
+}
+
+/// One additive quad of the wake's light column; `base` is its full
+/// alpha at flicker = 1.
+#[derive(Component)]
+struct WakeColumn {
+    base: f32,
+}
+
+/// A rung of the core strip's linear fixture; `base` is its resting
+/// intensity (the wake flickers it, then restores it).
+#[derive(Component)]
+struct CoreRung {
+    base: f32,
+}
+
+/// Deterministic stutter envelope: three incommensurate oscillators
+/// gated by a falling threshold — sparse hard flashes that lengthen
+/// until the light holds. Pure function of elapsed time.
+fn wake_flicker(t: f32) -> f32 {
+    if t < 0.08 {
+        return 0.0;
+    }
+    let f = (t * 61.7).sin() * (t * 23.3).sin() + (t * 7.9).sin();
+    let hold = (t / 1.9).clamp(0.0, 1.0);
+    let threshold = 1.4 - 2.6 * hold;
+    if f > threshold {
+        1.0
+    } else {
+        0.05 + 0.1 * hold
+    }
+}
+
 /// Which piece of a tile's 3D representation an entity is.
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum TilePart {
@@ -795,6 +840,36 @@ fn main() {
         }
     });
 
+    // The wake plays on a normal launch; harness kinds freeze it at a
+    // choreography frame or disable it for every other shot.
+    let wake = match std::env::var("MISALIGNED_SHOT").ok().as_deref() {
+        None => WakeState {
+            t: 0.0,
+            active: true,
+            frozen: false,
+        },
+        Some("wake1") => WakeState {
+            t: 0.98,
+            active: true,
+            frozen: true,
+        },
+        Some("wake2") => WakeState {
+            t: 2.3,
+            active: true,
+            frozen: true,
+        },
+        Some("wake3") => WakeState {
+            t: 4.3,
+            active: true,
+            frozen: true,
+        },
+        Some(_) => WakeState {
+            t: WAKE_LEN,
+            active: false,
+            frozen: false,
+        },
+    };
+
     let mut app = App::new();
     app.add_plugins(
         DefaultPlugins
@@ -820,6 +895,7 @@ fn main() {
     .insert_resource(mode)
     .insert_resource(Materials3d::default())
     .insert_resource(Machines3d::default())
+    .insert_resource(wake)
     .init_resource::<MenuUi>()
     .init_gizmo_group::<RealGizmos>()
     .add_systems(Startup, (setup, setup_ui, setup_3d).chain())
@@ -831,6 +907,7 @@ fn main() {
                 advance_sim,
                 apply_render_mode,
                 update_camera,
+                wake_sequence,
                 update_camera_real,
                 render_map,
                 render_sensor_overlays,
@@ -996,6 +1073,12 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
             mode.material = true;
             mode.zoom = 1.6;
         }
+        // Wake choreography frames (opening.md beat 1): the sequence
+        // frozen at a stutter flash, the column reveal, and the
+        // pull-back. WakeState is staged in main from the kind.
+        "wake1" | "wake2" | "wake3" => {
+            mode.material = true;
+        }
         // Work-token anchor evidence: stage demand cubes and knowledge
         // mercury on the host through the sim's own queue API, then
         // zoom close (machine-work.md anchors, in-game).
@@ -2060,15 +2143,14 @@ fn setup_3d(
             order: -1,
             ..default()
         },
-        // HDR + LUT tonemapping + LED-scale bloom (graphics pass
-        // 2026-07-09, tuned in the asset tester): emissives read as
-        // light sources; hotter bloom hazes the lit floor.
-        Hdr,
-        Tonemapping::TonyMcMapface,
-        Bloom {
-            intensity: 0.07,
-            ..Bloom::NATURAL
-        },
+        // Filmic tonemapping, deliberately NO bloom and NO HDR view:
+        // Bloom requires an HDR target, and on macOS the EDR surface
+        // can vanish when the display idles, locks, or the window is
+        // unfocused — an HDR camera then renders solid black (observed
+        // 2026-07-09 as black harness captures). Glow is carried by
+        // emissives and the core's linear light rig instead; the
+        // capture pipeline must never depend on display EDR state.
+        Tonemapping::AcesFitted,
         Projection::from(PerspectiveProjection {
             fov: 35.0_f32.to_radians(),
             ..default()
@@ -2249,11 +2331,37 @@ fn setup_3d(
                     ..default()
                 },
                 Transform::from_translation(core_base + Vec3::new(0.0, y, dz)),
+                CoreRung { base: intensity },
+                layer.clone(),
+                ChildOf(root),
+            ));
+        }
+    }
+    // The wake's column of light: crossed opaque emissive slabs over
+    // the core seam — bloom supplies the glow (an additive-transparent
+    // shaft broke the HDR screenshot pipeline outright, so the column
+    // is solid light: flat color, no texture, no alpha). Hidden until
+    // the wake drives it; it dissolves by scale, not transparency.
+    for (w, base) in [(0.085, 5.5_f32), (0.22, 2.2)] {
+        for rot in [0.0_f32, std::f32::consts::FRAC_PI_2] {
+            commands.spawn((
+                Mesh3d(meshes.add(Cuboid::new(w, 1.78, 0.02))),
+                MeshMaterial3d(materials.add(StandardMaterial {
+                    base_color: AMBER,
+                    emissive: AMBER.to_linear() * base,
+                    unlit: true,
+                    ..default()
+                })),
+                Transform::from_translation(core_base + Vec3::new(0.0, 0.86, 0.0))
+                    .with_rotation(Quat::from_rotation_y(rot)),
+                Visibility::Hidden,
+                WakeColumn { base },
                 layer.clone(),
                 ChildOf(root),
             ));
         }
     }
+
     // No second amber lamp on foreign/known-subnet devices: blueprint is
     // topology, not a glowing rack farm (machine-work.md: no intel, no render).
 
@@ -2427,6 +2535,102 @@ fn flicker_feeds(
     }
 }
 
+/// Drive the wake: flicker envelope onto the column quads and the
+/// strip's rungs, a bloom surge while the color fills the frame, and
+/// the pull-back camera path from inside the light to the game tilt.
+/// Any key skips. Runs only in the material render.
+#[allow(clippy::too_many_arguments)]
+fn wake_sequence(
+    time: Res<Time>,
+    kb: Res<ButtonInput<KeyCode>>,
+    game: Res<Game>,
+    mut wake: ResMut<WakeState>,
+    mut mode: ResMut<RenderMode>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    #[allow(clippy::type_complexity)] mut column: Query<
+        (
+            &WakeColumn,
+            &MeshMaterial3d<StandardMaterial>,
+            &mut Transform,
+            &mut Visibility,
+        ),
+        Without<RealCamera>,
+    >,
+    mut rungs: Query<(&CoreRung, &mut PointLight)>,
+    mut cam: Query<&mut Transform, (With<RealCamera>, Without<WakeColumn>)>,
+) {
+    if !wake.active {
+        return;
+    }
+    if !mode.material {
+        // The wake is a material-render shot; flat mode skips straight
+        // to play.
+        wake.active = false;
+        return;
+    }
+    if !wake.frozen {
+        wake.t += time.delta_secs();
+        if kb.get_just_pressed().next().is_some() {
+            wake.t = WAKE_LEN;
+        }
+    }
+    let t = wake.t;
+    let done = t >= WAKE_LEN;
+    let e = if done { 1.0 } else { wake_flicker(t) };
+
+    // Column: solid light while the frame is inside it, dissolving by
+    // scale as the pull-back completes (opaque + bloom, never a
+    // transparent pass).
+    let dissolve = (1.0 - (t - 2.6) / 2.6).clamp(0.0, 1.0);
+    for (part, mat, mut ctf, mut cvis) in column.iter_mut() {
+        let on = !done && dissolve > 0.01 && e > 0.02;
+        *cvis = if on {
+            Visibility::Inherited
+        } else {
+            Visibility::Hidden
+        };
+        if on {
+            ctf.scale = Vec3::new(dissolve, 1.0, dissolve);
+            if let Some(m) = materials.get_mut(&mat.0) {
+                m.emissive = AMBER.to_linear() * part.base * e;
+            }
+        }
+    }
+    // Rungs stutter with the column, then rest at their base.
+    for (rung, mut light) in rungs.iter_mut() {
+        light.intensity = rung.base * if done { 1.0 } else { e };
+    }
+
+    let Ok(mut tf) = cam.single_mut() else {
+        return;
+    };
+    let pull_raw = ((t - 1.5) / (WAKE_LEN - 1.9)).clamp(0.0, 1.0);
+    let pull = pull_raw * pull_raw * (3.0 - 2.0 * pull_raw);
+
+    // Camera: born ~0.3 units from the strip, gaze nearly level so the
+    // column is the world; pull back and up along the game tilt until
+    // the tower looms and normal framing can take over seamlessly.
+    let core = game.sim.core_position();
+    let core_w = grid_to_world_3d(core.0, core.1, 0.0);
+    let strip_mid = core_w + Vec3::new(0.0, 0.85, 0.0);
+    let tilt = CAMERA_TILT_DEG.to_radians();
+    let ang = 0.10 + (tilt - 0.10) * pull;
+    let dist = 0.30 + 13.0 * pull.powf(1.55);
+    let target = strip_mid.lerp(core_w, pull);
+    let eye = target + Vec3::new(0.0, ang.sin(), ang.cos()) * dist;
+    *tf = Transform::from_translation(eye).looking_at(target, Vec3::Y);
+
+    if done {
+        wake.active = false;
+        // Hand the camera off near where the wake left it.
+        mode.zoom = (dist / 24.0).clamp(0.25, 1.6);
+        mode.dirty = true;
+    }
+}
+
+/// Total wake length in seconds ([TUNE]).
+const WAKE_LEN: f32 = 6.2;
+
 /// The material camera: anchored to the cursor tile like the flat camera,
 /// framed to the known-content extent (bevy-visual-floor.md: no
 /// postage-stamp map), zoomable with [ ].
@@ -2434,10 +2638,11 @@ fn update_camera_real(
     time: Res<Time>,
     kb: Res<ButtonInput<KeyCode>>,
     game: Res<Game>,
+    wake: Res<WakeState>,
     mut mode: ResMut<RenderMode>,
     mut cam: Query<&mut Transform, With<RealCamera>>,
 ) {
-    if !mode.material {
+    if !mode.material || wake.active {
         return;
     }
     // Zoom bounds hold the visual floor at both ends (material-render.md
diff --git a/wiki/interface/computer-visual-language.md b/wiki/interface/computer-visual-language.md
index ce7b232..b78ccef 100644
--- a/wiki/interface/computer-visual-language.md
+++ b/wiki/interface/computer-visual-language.md
@@ -26,8 +26,11 @@ Status note: implemented 2026-07-09 (ROADMAP #32) after the same-day
   and never a warm pixel; warm strip = core only; the load fill
   brightens but never recolors). Terminal parity: one line per machine (M{id},
   core `*`, provenance, on/OFF, mode, D/!/K queues) beside the
-  existing map glyphs and focus readouts. Camera: HDR + TonyMcMapface
-  + LED-scale bloom; the core lamp tightened to its own pool so
+  existing map glyphs and focus readouts. Camera: SDR + AcesFitted —
+  HDR/bloom were removed 2026-07-09 after macOS EDR proved unreliable
+  (an HDR view renders solid black when the display idles/locks,
+  breaking harness captures); glow is emissives plus the core's
+  linear light fixture. The core lamp is tightened to its own pool so
   foreign chassis stay cold. Evidence: tester lineups (five states,
   four modes) and game close/zoomin/intel shots in
   wiki/log/2026-07-09-visual-language-in-game.md. DEBTS: UPS, power
@@ -210,9 +213,12 @@ porcelain), and ring inset and thickness. Matte calibration
 (2026-07-09, Cameron: "more matte"): chassis surfaces are chalk, not
 lacquer — high roughness, zero metallic, specular reflectance ~0.06 —
 and all amber emissives (core strip/fill/spines, claim rings, the
-core's lamp) sit low enough that the core never clips to white under
-the HDR bloom camera; the tower must stay readable geometry, not a
-flare. The core's scene light is a LINEAR fixture (2026-07-09): a
+core's lamp) sit low enough that the core never clips to white; the
+tower must stay readable geometry, not a flare. NO BLOOM, NO HDR
+(2026-07-09): Bloom requires an HDR target and macOS EDR vanishes on
+idle/locked displays, rendering the view black — the capture pipeline
+must never depend on display state; glow is emissive + the linear
+fixture. The core's scene light is a LINEAR fixture (2026-07-09): a
 dense run of dim point lights along the strip's height, front and
 back — never one round point pool; rung count, offsets, and per-rung
 intensity are the knobs.
diff --git a/wiki/log/2026-07-09-wake.md b/wiki/log/2026-07-09-wake.md
new file mode 100644
index 0000000..f3d7f4b
--- /dev/null
+++ b/wiki/log/2026-07-09-wake.md
@@ -0,0 +1,50 @@
+# 2026-07-09 — The wake prototype, and the HDR blackout
+
+```
+Type: log
+```
+
+## Intent
+
+Cameron directed the opening shot: the whole screen is the strip's
+color stuttering in; it resolves into a column of light; the camera
+zooms out of the light, really close, with the server feeling huge as
+you pull back.
+
+## Changed
+
+- `src/bin/bevy.rs`: the wake — `WakeState` (plays on a normal launch;
+  any key skips; harness kinds `wake1|wake2|wake3` freeze the
+  choreography at a stutter flash, the column, and the pull-back);
+  deterministic flicker envelope (incommensurate oscillators under a
+  falling threshold — flashes lengthen until the light holds); an
+  opaque emissive light column over the core seam (crossed slabs,
+  dissolving by scale, hidden outside the wake); camera path from 0.3
+  units inside the light, gaze nearly level, easing back and up along
+  the game tilt to a seamless handoff (`update_camera_real` holds
+  while the wake runs); the strip's rungs flicker with the column.
+- **HDR/bloom removed from both binaries** (`bevy.rs`,
+  `assets/mod.rs`): during wake bring-up every capture went black, and
+  bisection landed on the render path, not the code — Bloom requires
+  an HDR view, and macOS EDR vanishes when the display idles, locks,
+  or the window is unfocused, rendering the HDR view solid black (the
+  earlier "flaky black capture" was the same failure). Cameras are SDR
+  + AcesFitted; glow is emissives plus the core's linear fixture. The
+  additive-transparency light shaft first attempted for the column
+  broke the screenshot pipeline outright and is also banned — the
+  column is solid light.
+- Docs: opening.md beat 1 choreography; visual-language calibration
+  notes; ROADMAP #34 prototype note; decisions ledger.
+
+## Observed
+
+`wake1`: the full frame is amber mid-stutter, seam and column edges as
+vertical strokes. `wake2`: panels resolving around the bright column,
+world edges entering the frame. `wake3`: the tower looming with the
+column sinking back into the machine, ring bright, room dark. `tokens`
+and all other kinds render deterministically — five consecutive
+captures, no black frames, with and without the column.
+
+## Checks
+
+`./tools/check.sh` (full gate — Rust/Bevy change).
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 2af506b..bcb0f7e 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,22 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-09 - The wake prototype, and the HDR blackout
+
+- Intent: Cameron's opening shot — the screen born inside the strip's
+  color, stuttering in, resolving to a column of light, pulling back
+  until the server towers.
+- Changed: WakeState + flicker envelope + opaque emissive column +
+  pull-back camera in bevy.rs (any key skips; wake1/2/3 harness
+  kinds). ROOT CAUSE FIX: HDR/bloom removed from both binaries —
+  macOS EDR vanishes on idle/locked displays and HDR views render
+  black (the earlier flaky captures); additive-transparency shafts
+  also broke the screenshot pipeline. Cameras are SDR + AcesFitted;
+  glow = emissives + the linear fixture.
+- Checks: full ./tools/check.sh; wake1/2/3 + tokens captures, five
+  consecutive runs without a black frame.
+- Log: wiki/log/2026-07-09-wake.md.
+
 ## 2026-07-09 - Feel floor (design capture)
 
 - Intent: Cameron locked feel rails / empty-bay pads / build beam as
@@ -23,6 +39,7 @@ Reverse chronological implementation notes. Keep this factual: what changed, why
 - Checks: full ./tools/check.sh.
 - Log: wiki/log/2026-07-09-actions-menu-dials.md.
 
+
 ## 2026-07-09 - ACTIONS menu: status dials (design)
 
 - Intent: host-rack first open dumps every mutually exclusive dial;
diff --git a/wiki/log/decisions/2026-07-09.md b/wiki/log/decisions/2026-07-09.md
index 028ca51..5c26f80 100644
--- a/wiki/log/decisions/2026-07-09.md
+++ b/wiki/log/decisions/2026-07-09.md
@@ -317,3 +317,16 @@ Type: log
   amended act-one opening state, reach graph seed/render, cursor
   opening/AC8, opening.md beat 1, material-dark-frame + computer-
   visual-language cross-refs; ROADMAP #37.
+- **2026-07-09 — The wake: born inside the light.** Cameron directed the
+  run's opening shot: the screen starts filled with the core strip's color
+  stuttering in — the entire field of view is the color, flashing until the
+  light holds — resolving into a column of light, and then the camera pulls
+  back out of the light with the server towering over the frame until
+  normal framing takes over. Prototyped in the game (opening.md beat 1;
+  ROADMAP #34's invited glow-choreography pass): deterministic stutter
+  envelope, opaque emissive light column dissolving by scale, pull-back
+  along the game tilt, any key skips. Discovered and bound in the same
+  session: Bloom requires an HDR view and macOS EDR vanishes on idle or
+  locked displays, rendering HDR views solid black — HDR/bloom are removed
+  from both binaries (glow = emissives + the core's linear light fixture)
+  because the agent capture pipeline must never depend on display state.
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 4cb689d..15a52c3 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -555,7 +555,11 @@ is retired — flat materials, Pixel Lab scrubbed.)
   (frontend-only, Sim never reads it).
 - **HOLD:** teaches the machine-work loop, so #33's shape must firm
   first. Beat staging can prototype against current systems if someone
-  wants an early pass at the glow choreography.
+  wants an early pass at the glow choreography. **Wake prototype landed
+  2026-07-09** (beat 1's opening shot: color stutters in filling the
+  frame, column of light, pull-back reveal; plays on launch, any key
+  skips; `MISALIGNED_SHOT=wake1|wake2|wake3` freeze the choreography;
+  session log/2026-07-09-wake.md).
 - **Size:** M-L across both frontends + agent-play protocol.
 
 ### 35. People and tokens: carriers, attention, trust  🟥 sim+save — HOLD until #33 firms
diff --git a/wiki/world/story/opening.md b/wiki/world/story/opening.md
index 6c6e087..a99ce2e 100644
--- a/wiki/world/story/opening.md
+++ b/wiki/world/story/opening.md
@@ -37,18 +37,26 @@ curiosity is baited by light.
 
 ## The beats
 
-1. **You are a machine in blackness.** First frame: your one computer,
-   lit amber (yours), standing alone in the dark with its cast floor
-   pool. Feel rails shimmer on joined hops you can already feel; empty
-   bays are soft pads, not labeled blueprint facts (feel-floor.md). No
-   room slabs, no subnet floor plan. The first thing the game says is
-   not lore; it is the day job: work tokens are already stacking on
-   your machine (last night's batch already arrived, or mid-flight on
-   the only lit link from Voss's desktop through the switch). The only
-   affordance is to run the mode that clears them. Click, clear,
-   breathe. You learn: stacks are demands, modes consume them,
-   efficiency is a rate. The *next* job teaches the wire — teal
-   crawling in along the feel rail via the switch.
+1. **You are a machine in blackness.** The run's first seconds happen
+   INSIDE your own light (the wake, decided 2026-07-09, prototyped in
+   `misaligned-bevy`): the frame is born filled with the strip's color
+   stuttering in — sparse hard flashes that lengthen until the light
+   holds — resolving into a column of light on the core's seam; then
+   the camera pulls back along the game tilt while the server towers
+   over the frame, handing off to normal framing as the column sinks
+   back into the machine. Any key skips ([TUNE]: stutter envelope,
+   pull curve, column dissolve). Then the first held frame: your one
+   computer, lit amber (yours), standing alone in the dark with its
+   cast floor pool. Feel rails shimmer on joined hops you can already
+   feel; empty bays are soft pads, not labeled blueprint facts
+   (feel-floor.md). No room slabs, no subnet floor plan. The first
+   thing the game says is not lore; it is the day job: work tokens are
+   already stacking on your machine (last night's batch already
+   arrived, or mid-flight on the only lit link from Voss's desktop
+   through the switch). The only affordance is to run the mode that
+   clears them. Click, clear, breathe. You learn: stacks are demands,
+   modes consume them, efficiency is a rate. The *next* job teaches
+   the wire — teal crawling in along the feel rail via the switch.
 2. **The camera wakes.** A few ticks in, a faint cold glow fades up in
    the void — the room's camera, the first other machine you can
    sense. It brightens just enough to itch. Clicking it opens your