diff --git a/crates/misaligned-assets/src/bin/misaligned-effects.rs b/crates/misaligned-assets/src/bin/misaligned-effects.rs
new file mode 100644
index 0000000..708496a
--- /dev/null
+++ b/crates/misaligned-assets/src/bin/misaligned-effects.rs
@@ -0,0 +1,435 @@
+//! Focused liquid/dust laboratory using the same effects plugin as the game.
+//!
+//! Controls: 1 liquid, 2 dust, 3 both, 4 stress; Q/W/E force close/medium/far;
+//! A automatic LOD; Space pause; arrows change amounts; drag orbit; scroll zoom.
+
+use bevy::core_pipeline::tonemapping::Tonemapping;
+use bevy::input::mouse::{AccumulatedMouseMotion, AccumulatedMouseScroll};
+use bevy::prelude::*;
+use bevy::render::view::screenshot::{Screenshot, save_to_disk};
+use bevy::window::{CursorGrabMode, CursorOptions, WindowResolution};
+use misaligned_assets::effects::{
+    EffectLod, EffectsControl, MaterialEffects, MaterialEffectsPlugin, spawn_material_effects,
+};
+use misaligned_assets::palette::{BONE, GUNMETAL, NEAR_BLACK, PORCELAIN, scaled};
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Resource)]
+enum LabPreset {
+    Liquid,
+    Dust,
+    #[default]
+    Both,
+    Stress,
+}
+
+impl LabPreset {
+    fn label(self) -> &'static str {
+        match self {
+            Self::Liquid => "liquid",
+            Self::Dust => "dust",
+            Self::Both => "both",
+            Self::Stress => "stress",
+        }
+    }
+}
+
+#[derive(Resource)]
+struct Orbit {
+    yaw: f32,
+    pitch: f32,
+    distance: f32,
+    target: Vec3,
+}
+
+impl Default for Orbit {
+    fn default() -> Self {
+        Self {
+            yaw: 0.42,
+            pitch: 0.27,
+            distance: 5.8,
+            target: Vec3::new(0.0, 0.65, 0.25),
+        }
+    }
+}
+
+#[derive(Component)]
+struct LabEffectRoot;
+
+#[derive(Component)]
+struct Hud;
+
+#[derive(Resource)]
+struct ShotHarness {
+    path: String,
+    frames: u32,
+    taken: bool,
+}
+
+fn main() {
+    let shot = shot_settings();
+    let (preset, forced_lod) = shot
+        .as_ref()
+        .map(|(preset, lod, _)| (*preset, Some(*lod)))
+        .unwrap_or((LabPreset::Both, None));
+    let control = EffectsControl {
+        forced_lod,
+        fixed_step: shot.as_ref().map(|_| 1.0 / 60.0),
+        ..default()
+    };
+    let hidden = shot.is_some();
+
+    let mut app = App::new();
+    app.add_plugins(DefaultPlugins.set(WindowPlugin {
+        primary_window: Some(Window {
+            title: "Misaligned — liquid / dust effects lab".into(),
+            resolution: WindowResolution::new(1280, 800),
+            visible: !hidden,
+            ..default()
+        }),
+        ..default()
+    }))
+    .add_plugins(MaterialEffectsPlugin)
+    .insert_resource(ClearColor(NEAR_BLACK))
+    .insert_resource(GlobalAmbientLight {
+        color: Color::srgb(0.60, 0.66, 0.76),
+        brightness: 20.0,
+        ..default()
+    })
+    .insert_resource(control)
+    .insert_resource(preset)
+    .insert_resource(Orbit::default())
+    .add_systems(Startup, setup)
+    .add_systems(
+        Update,
+        (
+            handle_quit,
+            handle_controls,
+            rebuild_lab_effects,
+            orbit_camera,
+            update_hud,
+            shot_harness_system,
+        )
+            .chain(),
+    );
+    if let Some((_, _, path)) = shot {
+        app.insert_resource(ShotHarness {
+            path,
+            frames: 90,
+            taken: false,
+        });
+    }
+    app.run();
+}
+
+fn shot_settings() -> Option<(LabPreset, EffectLod, String)> {
+    let kind = std::env::var("MISALIGNED_SHOT").ok()?;
+    let mut parts = kind.rsplitn(2, '_');
+    let suffix = parts.next().unwrap_or_default();
+    let (base, lod) = match suffix {
+        "close" => (parts.next().unwrap_or("both"), EffectLod::Close),
+        "medium" => (parts.next().unwrap_or("both"), EffectLod::Medium),
+        "far" => (parts.next().unwrap_or("both"), EffectLod::Far),
+        _ => (kind.as_str(), EffectLod::Close),
+    };
+    let preset = match base {
+        "liquid" => LabPreset::Liquid,
+        "dust" => LabPreset::Dust,
+        "both" => LabPreset::Both,
+        "stress" => LabPreset::Stress,
+        _ => return None,
+    };
+    let path = std::env::var("MISALIGNED_SHOT_PATH")
+        .unwrap_or_else(|_| format!("misaligned_shot_{kind}.png"));
+    Some((preset, lod, path))
+}
+
+fn setup(
+    mut commands: Commands,
+    orbit: Res<Orbit>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    harness: Option<Res<ShotHarness>>,
+) {
+    let eye = orbit_eye(&orbit);
+    commands.spawn((
+        Camera3d::default(),
+        Tonemapping::AcesFitted,
+        Transform::from_translation(eye).looking_at(orbit.target, Vec3::Y),
+    ));
+
+    commands.spawn((
+        DirectionalLight {
+            color: Color::srgb(0.95, 0.97, 1.0),
+            illuminance: 8_500.0,
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(-4.0, 6.0, 4.0).looking_at(Vec3::new(0.0, 0.6, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        PointLight {
+            color: Color::srgb(0.50, 0.62, 0.86),
+            intensity: 460_000.0,
+            range: 16.0,
+            shadows_enabled: false,
+            ..default()
+        },
+        Transform::from_xyz(3.0, 3.2, 2.8),
+    ));
+    commands.spawn((
+        PointLight {
+            color: Color::srgb(0.90, 0.91, 0.94),
+            intensity: 650_000.0,
+            range: 18.0,
+            shadows_enabled: false,
+            ..default()
+        },
+        Transform::from_xyz(-1.0, 4.6, -4.0),
+    ));
+
+    let floor = materials.add(StandardMaterial {
+        base_color: scaled(GUNMETAL, 0.35),
+        metallic: 0.10,
+        perceptual_roughness: 0.88,
+        ..default()
+    });
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::new(7.5, 0.08, 5.0))),
+        MeshMaterial3d(floor),
+        Transform::from_xyz(0.0, -0.06, 0.0),
+        Name::new("clinical_floor"),
+    ));
+
+    // Two matte chalk forms provide reflections and make wet/dry contrast
+    // judgeable without borrowing a game machine.
+    let chalk = materials.add(StandardMaterial {
+        base_color: PORCELAIN,
+        metallic: 0.0,
+        perceptual_roughness: 0.92,
+        ..default()
+    });
+    for x in [-1.65, 1.55] {
+        commands.spawn((
+            Mesh3d(meshes.add(Cuboid::new(0.42, 1.20, 0.62))),
+            MeshMaterial3d(chalk.clone()),
+            Transform::from_xyz(x, 0.58, 0.0),
+            Name::new("chalk_effect_anchor"),
+        ));
+    }
+
+    if harness.is_none() {
+        commands.spawn((
+            Text::new(String::new()),
+            TextFont {
+                font_size: 17.0,
+                ..default()
+            },
+            TextColor(BONE),
+            Node {
+                position_type: PositionType::Absolute,
+                top: Val::Px(16.0),
+                left: Val::Px(18.0),
+                ..default()
+            },
+            Hud,
+        ));
+    }
+}
+
+fn apply_preset(preset: LabPreset, effects: &mut MaterialEffects) {
+    effects.show_thought = matches!(
+        preset,
+        LabPreset::Liquid | LabPreset::Both | LabPreset::Stress
+    );
+    effects.show_exposure = matches!(
+        preset,
+        LabPreset::Dust | LabPreset::Both | LabPreset::Stress
+    );
+}
+
+fn handle_quit(keys: Res<ButtonInput<KeyCode>>, mut exit: MessageWriter<AppExit>) {
+    if keys.just_pressed(KeyCode::Escape) {
+        exit.write(AppExit::Success);
+    }
+}
+
+fn handle_controls(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut preset: ResMut<LabPreset>,
+    mut control: ResMut<EffectsControl>,
+    mut effects: Query<&mut MaterialEffects, With<LabEffectRoot>>,
+) {
+    let next_preset = if keys.just_pressed(KeyCode::Digit1) {
+        Some(LabPreset::Liquid)
+    } else if keys.just_pressed(KeyCode::Digit2) {
+        Some(LabPreset::Dust)
+    } else if keys.just_pressed(KeyCode::Digit3) {
+        Some(LabPreset::Both)
+    } else if keys.just_pressed(KeyCode::Digit4) {
+        Some(LabPreset::Stress)
+    } else {
+        None
+    };
+    if let Some(next) = next_preset {
+        *preset = next;
+    }
+
+    if keys.just_pressed(KeyCode::KeyQ) {
+        control.forced_lod = Some(EffectLod::Close);
+    }
+    if keys.just_pressed(KeyCode::KeyW) {
+        control.forced_lod = Some(EffectLod::Medium);
+    }
+    if keys.just_pressed(KeyCode::KeyE) {
+        control.forced_lod = Some(EffectLod::Far);
+    }
+    if keys.just_pressed(KeyCode::KeyA) {
+        control.forced_lod = None;
+    }
+    if keys.just_pressed(KeyCode::Space) {
+        control.paused = !control.paused;
+    }
+
+    for mut effect in &mut effects {
+        if keys.just_pressed(KeyCode::ArrowUp) {
+            effect.thought_amount = (effect.thought_amount + 1.0).min(16.0);
+            effect.exposure_amount = (effect.exposure_amount + 1.0).min(16.0);
+        }
+        if keys.just_pressed(KeyCode::ArrowDown) {
+            effect.thought_amount = (effect.thought_amount - 1.0).max(1.0);
+            effect.exposure_amount = (effect.exposure_amount - 1.0).max(1.0);
+        }
+        if keys.just_pressed(KeyCode::ArrowRight) {
+            effect.thought_rate = (effect.thought_rate + 0.25).min(3.0);
+            effect.exposure_rate = (effect.exposure_rate + 0.25).min(3.0);
+        }
+        if keys.just_pressed(KeyCode::ArrowLeft) {
+            effect.thought_rate = (effect.thought_rate - 0.25).max(0.25);
+            effect.exposure_rate = (effect.exposure_rate - 0.25).max(0.25);
+        }
+    }
+}
+
+fn rebuild_lab_effects(
+    mut commands: Commands,
+    preset: Res<LabPreset>,
+    roots: Query<Entity, With<LabEffectRoot>>,
+) {
+    if !preset.is_changed() {
+        return;
+    }
+    for root in &roots {
+        commands.entity(root).despawn();
+    }
+
+    if *preset == LabPreset::Stress {
+        for z in 0..3 {
+            for x in 0..4 {
+                let mut effects = MaterialEffects::default();
+                apply_preset(*preset, &mut effects);
+                effects.thought_amount = 10.0;
+                effects.exposure_amount = 10.0;
+                let root = spawn_material_effects(
+                    &mut commands,
+                    effects,
+                    Transform::from_xyz((x as f32 - 1.5) * 3.8, 0.0, (z as f32 - 1.0) * 2.0),
+                );
+                commands.entity(root).insert(LabEffectRoot);
+            }
+        }
+    } else {
+        let mut effects = MaterialEffects::default();
+        apply_preset(*preset, &mut effects);
+        let root = spawn_material_effects(&mut commands, effects, Transform::IDENTITY);
+        commands.entity(root).insert(LabEffectRoot);
+    }
+}
+
+fn orbit_camera(
+    buttons: Res<ButtonInput<MouseButton>>,
+    motion: Res<AccumulatedMouseMotion>,
+    scroll: Res<AccumulatedMouseScroll>,
+    mut orbit: ResMut<Orbit>,
+    mut cameras: Query<&mut Transform, With<Camera3d>>,
+    mut windows: Query<&mut CursorOptions>,
+) {
+    if buttons.pressed(MouseButton::Left) || buttons.pressed(MouseButton::Right) {
+        orbit.yaw -= motion.delta.x * 0.005;
+        orbit.pitch = (orbit.pitch + motion.delta.y * 0.005).clamp(-1.15, 1.25);
+        if let Ok(mut options) = windows.single_mut() {
+            options.grab_mode = CursorGrabMode::Confined;
+        }
+    } else if let Ok(mut options) = windows.single_mut() {
+        options.grab_mode = CursorGrabMode::None;
+    }
+    if scroll.delta.y.abs() > 0.0 {
+        orbit.distance = (orbit.distance * (1.0 - scroll.delta.y * 0.08)).clamp(2.2, 24.0);
+    }
+    if let Ok(mut transform) = cameras.single_mut() {
+        *transform =
+            Transform::from_translation(orbit_eye(&orbit)).looking_at(orbit.target, Vec3::Y);
+    }
+}
+
+fn orbit_eye(orbit: &Orbit) -> Vec3 {
+    orbit.target
+        + Vec3::new(
+            orbit.yaw.sin() * orbit.pitch.cos(),
+            orbit.pitch.sin(),
+            orbit.yaw.cos() * orbit.pitch.cos(),
+        ) * orbit.distance
+}
+
+fn update_hud(
+    preset: Res<LabPreset>,
+    control: Res<EffectsControl>,
+    effects: Query<&MaterialEffects, With<LabEffectRoot>>,
+    mut hud: Query<&mut Text, With<Hud>>,
+) {
+    let Some(effect) = effects.iter().next() else {
+        return;
+    };
+    let Ok(mut text) = hud.single_mut() else {
+        return;
+    };
+    let lod = control
+        .forced_lod
+        .map(EffectLod::label)
+        .unwrap_or("auto (zoom)");
+    *text = Text::new(format!(
+        "MISALIGNED EFFECTS LAB  ·  {}  ·  LOD {}{}\n\
+         thought {:.0} @ {:.2}   exposure {:.0} @ {:.2}\n\
+         1 liquid  2 dust  3 both  4 stress   Q/W/E close/medium/far  A auto   Space pause\n\
+         arrows amount/rate   drag orbit   scroll zoom",
+        preset.label(),
+        lod,
+        if control.paused { "  ·  PAUSED" } else { "" },
+        effect.thought_amount,
+        effect.thought_rate,
+        effect.exposure_amount,
+        effect.exposure_rate,
+    ));
+}
+
+fn shot_harness_system(
+    mut commands: Commands,
+    harness: Option<ResMut<ShotHarness>>,
+    mut exit: MessageWriter<AppExit>,
+) {
+    let Some(mut harness) = harness else {
+        return;
+    };
+    if harness.frames > 0 {
+        harness.frames -= 1;
+        return;
+    }
+    if !harness.taken {
+        harness.taken = true;
+        harness.frames = 45;
+        commands
+            .spawn(Screenshot::primary_window())
+            .observe(save_to_disk(std::path::PathBuf::from(&harness.path)));
+    } else {
+        exit.write(AppExit::Success);
+    }
+}
diff --git a/crates/misaligned-assets/src/effects.rs b/crates/misaligned-assets/src/effects.rs
new file mode 100644
index 0000000..b9a2895
--- /dev/null
+++ b/crates/misaligned-assets/src/effects.rs
@@ -0,0 +1,566 @@
+//! Shared Thought-liquid and Exposure-dust presentation.
+//!
+//! The effects lab supplies authored values; the game supplies sim readouts.
+//! This module owns only disposable presentation state (art/effects-lab.md).
+
+use bevy::prelude::*;
+
+use crate::palette::{BONE, CRIMSON};
+
+/// Camera-distance representation for both material effects.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub enum EffectLod {
+    #[default]
+    Close,
+    Medium,
+    Far,
+}
+
+impl EffectLod {
+    pub const ALL: [Self; 3] = [Self::Close, Self::Medium, Self::Far];
+
+    pub const fn label(self) -> &'static str {
+        match self {
+            Self::Close => "close",
+            Self::Medium => "medium",
+            Self::Far => "far",
+        }
+    }
+}
+
+/// Presentation controls shared by the lab and game frontend.
+#[derive(Resource, Clone, Debug)]
+pub struct EffectsControl {
+    /// `None` selects from camera distance; the lab can force a tier.
+    pub forced_lod: Option<EffectLod>,
+    pub paused: bool,
+    pub speed: f32,
+    /// Fixed-step presentation time for deterministic screenshot evidence.
+    pub fixed_step: Option<f32>,
+}
+
+impl Default for EffectsControl {
+    fn default() -> Self {
+        Self {
+            forced_lod: None,
+            paused: false,
+            speed: 1.0,
+            fixed_step: None,
+        }
+    }
+}
+
+/// Readout-shaped inputs. These are amounts and rates, never game rules.
+#[derive(Component, Clone, Debug)]
+pub struct MaterialEffects {
+    pub show_thought: bool,
+    pub show_exposure: bool,
+    pub thought_amount: f32,
+    pub thought_rate: f32,
+    pub exposure_amount: f32,
+    pub exposure_rate: f32,
+    /// Local-space route endpoints. The presentation bends between them.
+    pub route_start: Vec3,
+    pub route_end: Vec3,
+    /// Downwind direction for airborne and settled Exposure.
+    pub wind: Vec3,
+}
+
+impl Default for MaterialEffects {
+    fn default() -> Self {
+        Self {
+            show_thought: true,
+            show_exposure: true,
+            thought_amount: 6.0,
+            thought_rate: 1.0,
+            exposure_amount: 6.0,
+            exposure_rate: 1.0,
+            route_start: Vec3::new(-1.65, 0.85, 0.0),
+            route_end: Vec3::new(1.55, 0.72, 0.0),
+            wind: Vec3::new(0.8, 0.0, 0.35),
+        }
+    }
+}
+
+/// Add this plugin in both the effects lab and the material game frontend.
+pub struct MaterialEffectsPlugin;
+
+impl Plugin for MaterialEffectsPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<EffectsControl>()
+            .init_resource::<EffectsClock>()
+            .add_systems(Startup, setup_effect_assets)
+            .add_systems(
+                Update,
+                (
+                    advance_clock,
+                    select_lod,
+                    rebuild_effect_population,
+                    animate_thought,
+                    animate_dust,
+                    animate_pools,
+                )
+                    .chain(),
+            );
+    }
+}
+
+/// Spawn an effect root. The plugin owns every child under this entity.
+pub fn spawn_material_effects(
+    commands: &mut Commands,
+    effects: MaterialEffects,
+    transform: Transform,
+) -> Entity {
+    commands
+        .spawn((
+            effects,
+            EffectLodState::default(),
+            transform,
+            Visibility::default(),
+            Name::new("material_effects"),
+        ))
+        .id()
+}
+
+#[derive(Resource, Default)]
+struct EffectsClock {
+    elapsed: f32,
+}
+
+#[derive(Resource)]
+struct EffectAssets {
+    sphere: Handle<Mesh>,
+    cube: Handle<Mesh>,
+    mercury: Handle<StandardMaterial>,
+    mercury_dim: Handle<StandardMaterial>,
+    dust: Handle<StandardMaterial>,
+    dust_haze: Handle<StandardMaterial>,
+}
+
+#[derive(Component, Clone, Copy, Debug, Default)]
+struct EffectLodState(EffectLod);
+
+#[derive(Component)]
+struct EffectVisual;
+
+#[derive(Component)]
+struct ThoughtSlug {
+    start: Vec3,
+    end: Vec3,
+    phase: f32,
+    speed: f32,
+    scale: f32,
+    length: f32,
+}
+
+#[derive(Component)]
+struct DustMote {
+    base: Vec3,
+    phase: f32,
+    lofted: bool,
+    size: Vec3,
+}
+
+#[derive(Component)]
+struct LiquidPool {
+    base_scale: Vec3,
+    phase: f32,
+}
+
+fn setup_effect_assets(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let mercury = materials.add(StandardMaterial {
+        base_color: Color::srgb(0.92, 0.90, 0.84),
+        emissive: BONE.to_linear() * 0.14,
+        metallic: 0.72,
+        perceptual_roughness: 0.12,
+        reflectance: 0.82,
+        ..default()
+    });
+    let mercury_dim = materials.add(StandardMaterial {
+        base_color: Color::srgb(0.72, 0.71, 0.68),
+        emissive: BONE.to_linear() * 0.08,
+        metallic: 0.58,
+        perceptual_roughness: 0.20,
+        reflectance: 0.65,
+        ..default()
+    });
+    let dust = materials.add(StandardMaterial {
+        base_color: Color::srgb(0.28, 0.012, 0.018),
+        emissive: CRIMSON.to_linear() * 0.012,
+        metallic: 0.02,
+        perceptual_roughness: 0.92,
+        reflectance: 0.08,
+        ..default()
+    });
+    let dust_haze = materials.add(StandardMaterial {
+        base_color: Color::srgba(0.24, 0.008, 0.014, 0.34),
+        emissive: CRIMSON.to_linear() * 0.008,
+        metallic: 0.0,
+        perceptual_roughness: 1.0,
+        alpha_mode: AlphaMode::Blend,
+        ..default()
+    });
+    commands.insert_resource(EffectAssets {
+        sphere: meshes.add(Sphere::new(1.0)),
+        cube: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
+        mercury,
+        mercury_dim,
+        dust,
+        dust_haze,
+    });
+}
+
+fn advance_clock(time: Res<Time>, control: Res<EffectsControl>, mut clock: ResMut<EffectsClock>) {
+    if control.paused {
+        return;
+    }
+    let dt = control.fixed_step.unwrap_or(time.delta_secs());
+    clock.elapsed += dt * control.speed.max(0.0);
+}
+
+fn lod_for_distance(distance: f32) -> EffectLod {
+    if distance < 7.0 {
+        EffectLod::Close
+    } else if distance < 15.0 {
+        EffectLod::Medium
+    } else {
+        EffectLod::Far
+    }
+}
+
+fn select_lod(
+    control: Res<EffectsControl>,
+    camera: Query<&GlobalTransform, With<Camera3d>>,
+    mut roots: Query<(&GlobalTransform, &mut EffectLodState), With<MaterialEffects>>,
+) {
+    let camera_pos = camera.iter().next().map(GlobalTransform::translation);
+    for (root, mut state) in &mut roots {
+        let lod = control.forced_lod.unwrap_or_else(|| {
+            camera_pos
+                .map(|eye| lod_for_distance(eye.distance(root.translation())))
+                .unwrap_or(EffectLod::Close)
+        });
+        if state.0 != lod {
+            state.0 = lod;
+        }
+    }
+}
+
+fn population(lod: EffectLod) -> (usize, usize) {
+    match lod {
+        EffectLod::Close => (420, 22),
+        EffectLod::Medium => (110, 9),
+        EffectLod::Far => (14, 3),
+    }
+}
+
+#[allow(clippy::type_complexity)]
+fn rebuild_effect_population(
+    mut commands: Commands,
+    assets: Option<Res<EffectAssets>>,
+    roots: Query<
+        (
+            Entity,
+            Ref<MaterialEffects>,
+            Ref<EffectLodState>,
+            Option<&Children>,
+        ),
+        Or<(Changed<MaterialEffects>, Changed<EffectLodState>)>,
+    >,
+) {
+    let Some(assets) = assets else {
+        return;
+    };
+    for (root, effects, lod, children) in &roots {
+        if let Some(children) = children {
+            for child in children.iter() {
+                commands.entity(child).despawn();
+            }
+        }
+        let (dust_count, slug_count) = population(lod.0);
+        if effects.show_exposure && effects.exposure_amount > 0.01 {
+            spawn_dust(&mut commands, &assets, root, &effects, lod.0, dust_count);
+        }
+        if effects.show_thought && effects.thought_amount > 0.01 {
+            spawn_thought(&mut commands, &assets, root, &effects, lod.0, slug_count);
+        }
+    }
+}
+
+fn spawn_dust(
+    commands: &mut Commands,
+    assets: &EffectAssets,
+    root: Entity,
+    effects: &MaterialEffects,
+    lod: EffectLod,
+    base_count: usize,
+) {
+    let amount_scale = (effects.exposure_amount / 6.0).sqrt().clamp(0.35, 1.8);
+    let count = ((base_count as f32 * amount_scale).round() as usize).max(1);
+    let wind = effects.wind.normalize_or_zero();
+    let cross = Vec3::new(-wind.z, 0.0, wind.x);
+    for i in 0..count {
+        let along = hash01(i, 1).powf(0.72) * (1.2 + amount_scale * 1.7);
+        let side = (hash01(i, 2) - 0.5) * (0.55 + along * 0.45);
+        let lofted = lod != EffectLod::Far
+            && hash01(i, 3) < (0.20 * effects.exposure_rate).clamp(0.06, 0.48);
+        let base = effects.route_start
+            + wind * along
+            + cross * side
+            + Vec3::new(
+                0.0,
+                if lofted {
+                    0.10 + hash01(i, 4) * 0.5
+                } else {
+                    0.018
+                },
+                0.0,
+            );
+        let scale = match lod {
+            EffectLod::Close => 0.012 + hash01(i, 5) * 0.020,
+            EffectLod::Medium => 0.026 + hash01(i, 5) * 0.032,
+            EffectLod::Far => 0.045 + hash01(i, 5) * 0.045,
+        };
+        let size = if lod == EffectLod::Far {
+            Vec3::new(scale * 2.2, scale * 0.06, scale * 1.35)
+        } else {
+            Vec3::new(scale, scale * (0.35 + hash01(i, 6)), scale * 0.7)
+        };
+        commands.spawn((
+            EffectVisual,
+            DustMote {
+                base,
+                phase: hash01(i, 7) * 19.0,
+                lofted,
+                size,
+            },
+            Mesh3d(assets.cube.clone()),
+            MeshMaterial3d(if lod == EffectLod::Far {
+                assets.dust_haze.clone()
+            } else {
+                assets.dust.clone()
+            }),
+            Transform::from_translation(base)
+                .with_scale(size)
+                .with_rotation(Quat::from_rotation_y(hash01(i, 8) * std::f32::consts::TAU)),
+            ChildOf(root),
+            Name::new("exposure_dust"),
+        ));
+    }
+}
+
+fn spawn_thought(
+    commands: &mut Commands,
+    assets: &EffectAssets,
+    root: Entity,
+    effects: &MaterialEffects,
+    lod: EffectLod,
+    base_count: usize,
+) {
+    let rivulet = lod != EffectLod::Far && effects.thought_rate >= 0.75;
+    let base_count = if rivulet {
+        match lod {
+            EffectLod::Close => 42,
+            EffectLod::Medium => 18,
+            EffectLod::Far => base_count,
+        }
+    } else {
+        base_count
+    };
+    let count = ((base_count as f32 * effects.thought_rate.sqrt().clamp(0.55, 1.35)).round()
+        as usize)
+        .max(1);
+    let slug_scale = (0.040 + effects.thought_amount.sqrt() * 0.010)
+        * match lod {
+            EffectLod::Close => 1.0,
+            EffectLod::Medium => 1.55,
+            EffectLod::Far => 1.25,
+        };
+    for i in 0..count {
+        commands.spawn((
+            EffectVisual,
+            ThoughtSlug {
+                start: effects.route_start,
+                end: effects.route_end,
+                phase: i as f32 / count as f32,
+                speed: (0.13 + effects.thought_rate * 0.12).clamp(0.08, 0.9),
+                scale: slug_scale,
+                length: if rivulet { 4.6 } else { 1.8 },
+            },
+            Mesh3d(assets.sphere.clone()),
+            MeshMaterial3d(if lod == EffectLod::Far {
+                assets.mercury_dim.clone()
+            } else {
+                assets.mercury.clone()
+            }),
+            Transform::default(),
+            ChildOf(root),
+            Name::new("thought_slug"),
+        ));
+    }
+
+    let volume = effects.thought_amount.max(0.1).cbrt();
+    let detail = match lod {
+        EffectLod::Close => 3,
+        EffectLod::Medium => 2,
+        EffectLod::Far => 1,
+    };
+    for side in [effects.route_start, effects.route_end] {
+        for i in 0..detail {
+            let offset = Vec3::new(
+                (i as f32 - (detail - 1) as f32 * 0.5) * 0.075,
+                -0.03 * i as f32,
+                (i as f32 * 1.7).sin() * 0.04,
+            );
+            let base_scale = Vec3::new(0.18, 0.065, 0.13)
+                * volume
+                * if lod == EffectLod::Far { 1.05 } else { 1.0 };
+            commands.spawn((
+                EffectVisual,
+                LiquidPool {
+                    base_scale,
+                    phase: i as f32 * 1.9 + if side == effects.route_end { 0.7 } else { 0.0 },
+                },
+                Mesh3d(assets.sphere.clone()),
+                MeshMaterial3d(assets.mercury.clone()),
+                Transform::from_translation(side + offset).with_scale(base_scale),
+                ChildOf(root),
+                Name::new("thought_pool"),
+            ));
+        }
+    }
+
+    // The far read is an aggregate route, not a tiny population of close slugs.
+    if lod == EffectLod::Far {
+        for i in 0..10 {
+            let t0 = i as f32 / 10.0;
+            let t1 = (i + 1) as f32 / 10.0;
+            let a = route_point(effects.route_start, effects.route_end, t0);
+            let b = route_point(effects.route_start, effects.route_end, t1);
+            let d = b - a;
+            commands.spawn((
+                EffectVisual,
+                Mesh3d(assets.cube.clone()),
+                MeshMaterial3d(assets.mercury_dim.clone()),
+                Transform::from_translation((a + b) * 0.5)
+                    .with_rotation(Quat::from_rotation_arc(Vec3::Y, d.normalize_or_zero()))
+                    .with_scale(Vec3::new(0.025, d.length(), 0.025)),
+                ChildOf(root),
+                Name::new("thought_far_route"),
+            ));
+        }
+    }
+}
+
+fn animate_thought(clock: Res<EffectsClock>, mut slugs: Query<(&ThoughtSlug, &mut Transform)>) {
+    for (slug, mut transform) in &mut slugs {
+        let t = (slug.phase + clock.elapsed * slug.speed).fract();
+        let pos = route_point(slug.start, slug.end, t);
+        let tangent = route_tangent(slug.start, slug.end, t);
+        let pulse = 1.0 + 0.09 * (t * std::f32::consts::TAU).sin();
+        transform.translation = pos;
+        transform.rotation = Quat::from_rotation_arc(Vec3::Y, tangent);
+        transform.scale = Vec3::new(
+            slug.scale * 0.72,
+            slug.scale * slug.length * pulse,
+            slug.scale * 0.72,
+        );
+    }
+}
+
+fn animate_dust(clock: Res<EffectsClock>, mut motes: Query<(&DustMote, &mut Transform)>) {
+    for (mote, mut transform) in &mut motes {
+        let t = clock.elapsed + mote.phase;
+        if mote.lofted {
+            let cycle = (t * 0.18).fract();
+            let lift = (cycle * std::f32::consts::PI).sin().max(0.0);
+            transform.translation = mote.base
+                + Vec3::new(
+                    (t * 1.7).sin() * 0.10 + (t * 0.43).cos() * 0.05,
+                    lift * (0.35 + 0.22 * (t * 0.31).sin().abs()),
+                    (t * 1.13).cos() * 0.12,
+                );
+            transform.rotation = Quat::from_euler(EulerRot::YXZ, t * 0.9, t * 0.37, t * 0.23);
+        } else {
+            transform.translation = mote.base + Vec3::Y * ((t * 1.1).sin().max(0.0) * 0.003);
+        }
+        transform.scale = mote.size;
+    }
+}
+
+fn animate_pools(clock: Res<EffectsClock>, mut pools: Query<(&LiquidPool, &mut Transform)>) {
+    for (pool, mut transform) in &mut pools {
+        let ring = (clock.elapsed * 1.35 + pool.phase).sin();
+        transform.scale = pool.base_scale
+            * Vec3::new(
+                1.0 + ring * 0.035,
+                1.0 - ring.abs() * 0.025,
+                1.0 - ring * 0.025,
+            );
+    }
+}
+
+fn route_point(start: Vec3, end: Vec3, t: f32) -> Vec3 {
+    let span = end - start;
+    let c1 = start + span * 0.30 + Vec3::new(0.0, 0.55, 0.22);
+    let c2 = start + span * 0.70 + Vec3::new(0.0, 0.28, -0.18);
+    let u = 1.0 - t;
+    start * u * u * u + c1 * 3.0 * u * u * t + c2 * 3.0 * u * t * t + end * t * t * t
+}
+
+fn route_tangent(start: Vec3, end: Vec3, t: f32) -> Vec3 {
+    let before = route_point(start, end, (t - 0.005).max(0.0));
+    let after = route_point(start, end, (t + 0.005).min(1.0));
+    (after - before).normalize_or_zero()
+}
+
+fn hash01(index: usize, salt: u32) -> f32 {
+    let mut x = (index as u32).wrapping_mul(0x9E37_79B9) ^ salt.wrapping_mul(0x85EB_CA6B);
+    x ^= x >> 16;
+    x = x.wrapping_mul(0x7FEB_352D);
+    x ^= x >> 15;
+    x = x.wrapping_mul(0x846C_A68B);
+    x ^= x >> 16;
+    x as f32 / u32::MAX as f32
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn distance_levels_are_ordered() {
+        assert_eq!(lod_for_distance(2.0), EffectLod::Close);
+        assert_eq!(lod_for_distance(9.0), EffectLod::Medium);
+        assert_eq!(lod_for_distance(30.0), EffectLod::Far);
+    }
+
+    #[test]
+    fn populations_reduce_aggressively() {
+        let close = population(EffectLod::Close);
+        let medium = population(EffectLod::Medium);
+        let far = population(EffectLod::Far);
+        assert!(close.0 > medium.0 && medium.0 > far.0);
+        assert!(close.1 > medium.1 && medium.1 > far.1);
+    }
+
+    #[test]
+    fn route_keeps_authored_endpoints() {
+        let start = Vec3::new(-2.0, 1.0, 0.0);
+        let end = Vec3::new(3.0, 0.5, 1.0);
+        assert_eq!(route_point(start, end, 0.0), start);
+        assert_eq!(route_point(start, end, 1.0), end);
+    }
+
+    #[test]
+    fn deterministic_scatter_is_bounded() {
+        for i in 0..10_000 {
+            let value = hash01(i, 17);
+            assert!((0.0..=1.0).contains(&value));
+        }
+    }
+}
diff --git a/crates/misaligned-assets/src/lib.rs b/crates/misaligned-assets/src/lib.rs
index f4409f5..fce8710 100644
--- a/crates/misaligned-assets/src/lib.rs
+++ b/crates/misaligned-assets/src/lib.rs
@@ -1,3 +1,4 @@
 //! Shared flat-material procedural meshes for the asset tester and Bevy frontend.
+pub mod effects;
 pub mod palette;
 pub mod rack;
diff --git a/wiki/SUMMARY.md b/wiki/SUMMARY.md
index 41282fc..f6b9e9d 100644
--- a/wiki/SUMMARY.md
+++ b/wiki/SUMMARY.md
@@ -88,6 +88,7 @@
 - [Overview](art/README.md)
   - [Visual identity: clinical gore](art/visual-identity.md)
   - [Procedural asset tester](art/asset-tester.md)
+  - [Effects lab: dust and liquid](art/effects-lab.md)
 
 # Engineering
 
diff --git a/wiki/art/README.md b/wiki/art/README.md
index 43a5f13..49c7543 100644
--- a/wiki/art/README.md
+++ b/wiki/art/README.md
@@ -12,7 +12,10 @@ under light** — solid palette colors, emissive for machine presence, no
 image textures ([interface/flat-materials.md](../interface/flat-materials.md)).
 Iterate new procedural meshes in the
 [asset tester](asset-tester.md) (`misaligned-assets`) before wiring them
-into Bevy. The Pixel Lab generation pipeline was removed 2026-07-08; git
+into Bevy. Iterate dynamic Thought-liquid and Exposure-dust treatments in the
+separate [effects lab](effects-lab.md) (`misaligned-effects`); its renderer is
+shared package code, not a disposable prototype. The Pixel Lab generation
+pipeline was removed 2026-07-08; git
 history has it. Direction notes live under
 `assets/reference/art-direction/` (not runtime art). Placeholders, if
 any return, are tracked in this directory — not silently reused
diff --git a/wiki/art/asset-tester.md b/wiki/art/asset-tester.md
index 9240b1d..4797a8a 100644
--- a/wiki/art/asset-tester.md
+++ b/wiki/art/asset-tester.md
@@ -10,6 +10,10 @@ light ([flat-materials.md](../interface/flat-materials.md)); this binary
 is the sandbox where new meshes earn their look before they land in
 `misaligned-bevy`.
 
+Dynamic liquid/dust work has its own focused sibling,
+[effects-lab.md](effects-lab.md): `misaligned-effects`. Both binaries consume
+shared code from the `misaligned-assets` library; neither is a private renderer.
+
 ## Run
 
 ```bash
diff --git a/wiki/art/effects-lab.md b/wiki/art/effects-lab.md
new file mode 100644
index 0000000..57ac824
--- /dev/null
+++ b/wiki/art/effects-lab.md
@@ -0,0 +1,169 @@
+# Spec: effects lab — shared dust and liquid at every zoom
+
+```
+Type: spec
+Status: IN PROGRESS
+Status note: decided 2026-07-10. The first implementation establishes the
+  separate lab binary, shared renderer boundary, deterministic presets, and
+  close / medium / far visual levels. Main-game binding follows the live
+  machine-work and thought-fluid readouts; the lab does not invent game state.
+Stage: B1 — The Basement
+Work order: effects-lab
+Work priority: 26
+Work class: frontend
+Blocked by: none
+Exclusive keys:
+  - crates/misaligned-assets/
+  - wiki/art/effects-lab.md
+Design:
+  - wiki/art/visual-identity.md#visual-identity-clinical-gore
+  - wiki/interface/thought-fluid.md#spec-the-thought-fluid-slugs-meniscus-and-the-filament-snap
+  - wiki/mechanics/machine-work.md#spec-machine-work-delegation-visible-tokens-and-the-byproduct-network
+Depends on:
+  - wiki/interface/flat-materials.md#spec-flat-materials-the-world-without-textures
+  - wiki/engineering/crate-workspace.md#spec-crate-workspace-core-terminal-bevy-assets
+  - wiki/art/asset-tester.md#procedural-asset-tester
+```
+
+## Dependency notes
+
+The visual-identity law owns the material split: Thought is wet ivory mercury;
+Exposure is dry crimson contamination and never borrows blood's smooth pool.
+thought-fluid.md owns the exact slug, pool, vessel, and filament grammar.
+machine-work.md owns the quantities and carrier rules. This page owns only the
+shared effects implementation, its standalone laboratory, and how that
+implementation becomes cheaper with distance.
+
+## Why a separate lab
+
+Dust and liquid are camera-sensitive effects. Their quality comes from motion,
+lighting, scale, and the transition between representations; iterating them by
+booting a full run makes every visual correction slow and encourages a pretty
+prototype that never becomes the game renderer.
+
+`misaligned-effects` is a second binary in the `misaligned-assets` package. It
+boots a small clinical stage containing only Exposure dust and Thought liquid.
+The effect systems themselves live in the package library and are consumed by
+both the lab and `misaligned-bevy`. **Separate binary, shared implementation:**
+the lab may synthesize inputs for inspection, but it may not grow a private
+renderer that must later be rewritten.
+
+## One effect, three visual levels
+
+The renderer chooses a visual level from camera distance. The lab can force a
+level so transitions can be judged directly. Thresholds and population counts
+are `[TUNE]`; the semantic compression is fixed.
+
+| Level | Thought | Exposure |
+| --- | --- | --- |
+| **Close** | Specular slugs, pool surface, meniscus and filament gestures; motion may use rich local easing. | Fine angular motes, turbulent drift, settling and local trails. |
+| **Medium** | Fewer merged slugs/rivulet segments and a simplified pool silhouette. | Reduced motes over a stable drift footprint. |
+| **Far** | A sparse ivory route pulse plus aggregate source/sink mass. | A dark crimson stain/haze whose area and density carry amount. |
+
+Crossing a threshold must not pop an amount in or out. Representations
+cross-fade or exchange equivalent silhouettes over a short presentation-only
+window `[TUNE]`. Far zoom is deliberately not a tiny close simulation: it
+spends detail on the decision the player can make at that scale.
+
+## Truth boundary
+
+The lab uses authored demo values. The game supplies real readouts:
+
+- Thought route, direction, amount, and rate come from `work_in_flight`, queue,
+  and sink readouts named by thought-fluid.md.
+- Exposure amount, emission, deposited residue, and carrier trails come from
+  machine-work / people-token state as those readouts land.
+- Local particle positions, turbulence phase, surface wobble, and cross-fade
+  state are presentation. They may be discarded and reconstructed.
+
+No visual level accumulates gameplay Thought or Exposure. Zooming cannot
+change a route, consume a quantity, settle gameplay residue, or alter
+detection. A paused frame still communicates amount through pool/stain
+geometry even when rate animation stops.
+
+## The effects laboratory
+
+The binary provides one orbitable, close-lit stage and deterministic presets:
+
+- **liquid** — source pool, traveling slugs/rivulet, receiving mass;
+- **dust** — active plume above a settled downwind drift;
+- **both** — proves wet ivory and dry crimson remain distinct in one frame;
+- **stress** — repeats the shared effect across twelve roots at high amount;
+- forced **close / medium / far** levels for transition and cost inspection.
+
+Interactive controls select the preset and level, pause time, change effect
+amount/rate, orbit, and zoom. A shot harness fixes the seed and timestep,
+writes a PNG, and exits. This is evidence infrastructure, not a second game.
+
+### Run and controls
+
+```bash
+cargo run -p misaligned-assets --bin misaligned-effects
+
+MISALIGNED_SHOT=both_close \
+MISALIGNED_SHOT_PATH=/tmp/effects.png \
+  cargo run -p misaligned-assets --bin misaligned-effects
+```
+
+| Input | Action |
+| --- | --- |
+| `1` / `2` / `3` / `4` | Liquid / dust / both / stress |
+| `Q` / `W` / `E` | Force close / medium / far level |
+| `A` | Return to automatic camera-distance level |
+| `Space` | Pause/unpause presentation time |
+| Up/down | Raise/lower both visible amounts |
+| Left/right | Lower/raise both visible rates |
+| Drag / scroll | Orbit / zoom |
+
+## Quality and performance posture
+
+Close quality is allowed to be ambitious because only nearby effects receive
+it. Medium and far levels carry a hard population reduction. The lab includes
+a stress preset so frame cost is measured before the implementation is wired
+through a whole building. Exact particle counts, distance thresholds, shader
+technique, and frame budgets remain `[TUNE]` against representative hardware;
+the required result is stable cost as the visible machine count grows.
+
+## Acceptance criteria
+
+1. `cargo run -p misaligned-assets --bin misaligned-effects` opens the effects
+   lab without booting `Sim` or loading a save.
+2. The liquid/dust systems are exported by `misaligned-assets`; the lab does
+   not own a private copy of their rendering code.
+3. Liquid and dust can be viewed separately and together, with fixed-seed
+   close, medium, and far captures.
+4. Camera distance selects all three levels automatically; a lab override can
+   force each level, and transitions preserve the aggregate amount read.
+5. Close Thought reads wet and specular against matte chalk. Close Exposure
+   reads dry, angular, settling, and substantially darker than signal light.
+6. Pausing stops rate animation without erasing the pool or drift amount.
+7. The shot harness uses a fixed timestep and leaves a deterministic PNG at
+   the requested path before exiting.
+8. The main Bevy frontend consumes the same exported effect systems and feeds
+   them only named sim readouts. Until this criterion lands, status remains
+   `IN PROGRESS`.
+
+## Implementation slice — 2026-07-10
+
+Criteria 1–7 are held by the first lab slice: the exported
+`MaterialEffectsPlugin`, four interactive presets (including twelve-root
+stress), automatic and forced LOD, deterministic scatter/time, and the PNG
+harness. Screenshot review rejected the first pearl-train close prototype and
+replaced high-rate Thought with an overlapping rivulet. Criterion 8 remains:
+`misaligned-bevy` has a concurrent Thought-flow renderer, so binding the shared
+plugin to its named sim readouts must be a deliberate reconciliation rather
+than an overwrite.
+
+## Decided, open, and deferred
+
+**DECIDED:** separate `misaligned-effects` binary; shared package-library
+implementation; close / medium / far representations; materially simpler
+medium/far rendering; deterministic presets and capture.
+
+**OPEN AS TUNING:** exact thresholds, counts, shader/mesh technique, turbulence,
+viscosity, and cross-fade duration. These are judged in the lab rather than
+turned into design questions.
+
+**DEFERRED TO OWNING SPECS:** gameplay dust deposition/carrier mechanics and
+the final game readout wiring. The lab may visualize those behaviors but does
+not create their rules.
diff --git a/wiki/engineering/architecture.md b/wiki/engineering/architecture.md
index 136d36c..7b0e7d8 100644
--- a/wiki/engineering/architecture.md
+++ b/wiki/engineering/architecture.md
@@ -22,8 +22,8 @@ crates/
     tests/act_one.rs            — Act One integration test
   misaligned-terminal/          — binary `misaligned` (crossterm + agent protocol)
   misaligned-bevy/              — binary `misaligned-bevy` (Bevy 0.18 frontend)
-  misaligned-assets/            — lib `misaligned_assets` + binary `misaligned-assets`
-                                  (procedural meshes; shared with Bevy for rack spawn)
+  misaligned-assets/            — shared art lib + `misaligned-assets` mesh tester
+                                  + `misaligned-effects` liquid/dust lab
 ```
 
 ### Package contracts
@@ -33,16 +33,16 @@ crates/
 | `misaligned-core` | `Sim`, map, systems, save format, rule tests | Bevy, crossterm, wall-clock-driven game rules |
 | `misaligned-terminal` | UI, input, agent line protocol, wall-clock tick mapping | Game-rule forks of `Sim` |
 | `misaligned-bevy` | 3D/2.5D view, shot harness, wall-clock tick mapping | Game-rule forks of `Sim` |
-| `misaligned-assets` | Mesh/material boards, art harness | Save/load of full runs; sim progression |
+| `misaligned-assets` | Shared mesh/effect render code and focused art harnesses | Save/load of full runs; sim progression |
 
 Frontends import the lib as `misaligned::…` (crate name `misaligned-core`,
 lib name `misaligned`). That split is deliberate: package name states the
 **job** (core); lib name states the **product** so imports stay stable — see
 crate-workspace naming.
 
-`misaligned-bevy` depends on `misaligned-assets` for shared rack/mesh spawn
-so the game binary and the asset tester do not fork mesh code; assets still
-does not depend on core (no sim progression in the tester).
+`misaligned-bevy` depends on `misaligned-assets` for shared rack/mesh/effect
+rendering so the game binary and focused art harnesses do not fork visual code;
+assets still does not depend on core (no sim progression in either tester).
 
 ## The sim/frontend contract
 
diff --git a/wiki/engineering/crate-workspace.md b/wiki/engineering/crate-workspace.md
index 5d6e0b2..aab5cee 100644
--- a/wiki/engineering/crate-workspace.md
+++ b/wiki/engineering/crate-workspace.md
@@ -61,7 +61,7 @@ crates/
   misaligned-core/         — sim library (package name); lib name `misaligned`
   misaligned-terminal/     — binary `misaligned` (crossterm + agent protocol)
   misaligned-bevy/         — binary `misaligned-bevy` (Bevy 0.18 frontend)
-  misaligned-assets/       — lib `misaligned_assets` + binary `misaligned-assets`
+  misaligned-assets/       — shared art lib + `misaligned-assets` / `misaligned-effects`
 ```
 
 There is **no** root `src/` product tree and **no** feature-flag substitute for
@@ -74,7 +74,7 @@ these packages. Optional features must not re-merge package jobs.
 | **core** | All game rules, save format, sim tests | Must stay free of render/input toolchains so sim work stays cheap and deterministic. |
 | **terminal** | Player/agent text surface + wall clock | First-class frontend; must not pull Bevy; must not own rules. |
 | **bevy** | Material/digital 3D/2.5D view + shot harness | Heavy compile graph; isolated so frontend thrash does not block sim agents. |
-| **assets** | Procedural meshes / art tester boards | Shared mesh code without loading the full game loop; no sim progression. |
+| **assets** | Shared meshes/effects plus focused art harnesses | Reusable render code without loading the full game loop; no sim progression. |
 
 **Not** one umbrella `misaligned-frontends` package: that would keep terminal
 and Bevy compile-coupled and erase the frontend-tier win.
@@ -87,7 +87,7 @@ win until a real module boundary demands it (see out of scope).
 | Choice | Why |
 |---|---|
 | Package `misaligned-core`, **lib name `misaligned`** | Frontends keep `use misaligned::…` so imports and mental model stay “the sim,” not a rename churn. Package name states the *job* (core); lib name states the *product*. |
-| Binary names `misaligned`, `misaligned-bevy`, `misaligned-assets` | CLI, docs, shot harnesses, and muscle memory stay stable after the split. |
+| Binary names `misaligned`, `misaligned-bevy`, `misaligned-assets`, `misaligned-effects` | Product names and each focused art harness stay explicit. |
 | Directory prefix `crates/misaligned-*` | Workspace-local, greppable, matches package names. |
 
 ### Dependency edges (and why)
@@ -118,7 +118,7 @@ misaligned-core     ──► serde, serde_json, dirs
 | `misaligned-core` | `Sim`, map, systems, save format, rule tests | Bevy, crossterm, wall-clock-driven rules, `Instant::now` as game time, env reads that change rules |
 | `misaligned-terminal` | UI, input, agent line protocol, wall-clock → tick | Game-rule `if`s that belong on `Sim` |
 | `misaligned-bevy` | View, shot harness, wall-clock → tick | Game-rule forks of `Sim` behavior |
-| `misaligned-assets` | Mesh/material boards, art harness | Full-run save/load; sim progression |
+| `misaligned-assets` | Mesh/effect render code, asset tester, effects lab | Full-run save/load; sim progression |
 
 Frontends talk to core through **command/query methods** and read state for
 render — same contract as [architecture.md](architecture.md) “The
@@ -163,8 +163,8 @@ These remain true for the life of the layout (not a one-time land checklist):
 2. `misaligned-core` has **no** dependency on `bevy` or `crossterm`.
    `cargo test -p misaligned-core` does not build Bevy.
 3. Game rules live only in core; frontends do not re-implement sim rules.
-4. Binary names remain `misaligned`, `misaligned-bevy`, `misaligned-assets`
-   unless a deliberate product rename is specced.
+4. Binary names remain `misaligned`, `misaligned-bevy`, `misaligned-assets`,
+   `misaligned-effects` unless a deliberate product rename is specced.
 5. `./tools/check.sh` auto-classification and documented tiers key off
    packages; CI enforces a conservative full workspace gate.
 6. [architecture.md](architecture.md) stays an accurate as-built mirror;
diff --git a/wiki/engineering/env.md b/wiki/engineering/env.md
index 888fa6e..2bf04ab 100644
--- a/wiki/engineering/env.md
+++ b/wiki/engineering/env.md
@@ -40,7 +40,8 @@ is sim or frontend state, never an environment variable.
 |---|---|---|---|
 | `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `intel`, `tokens`, `signal`, `ears`, `eyes-white`, `eyes-form`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, save one PNG, run the fog audit, exit. `intel` stages tick-zero intel tiers (no splice); `tokens` enqueues D5/K4 on the host; `signal` focuses the known environmental monitor before any feed tap to capture its cold-signal presence cue; `ears` stages hearing-feed coverage (material dark mass; flat may still diagram coverage); `eyes-white` / `eyes-form` freeze the first-Eyes source held white and then contracted around the resolving chassis; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
 | `MISALIGNED_SHOT` | `misaligned-assets` | `dead`, `foreign`, `idle`, `busy`, `core`, `dayjob`, `research`, `conceal`, `operations` (each optionally suffixed `_ladder`/`_ring`/`_wash`), `lineup[_<style>]`, `modes[_<style>]`, `tokens`, `tokens_max`, `exposure`, `splash` | Tester screenshot harness: stage the named board, capture, exit (art/asset-tester.md documents each board). |
-| `MISALIGNED_SHOT_PATH` | both binaries | file path | Output path for the captured PNG (default `misaligned_shot_<kind>.png`). |
+| `MISALIGNED_SHOT` | `misaligned-effects` | `liquid`, `dust`, `both`, `stress`, optionally suffixed `_close`, `_medium`, or `_far` | Fixed-seed, fixed-timestep effects-lab capture; writes the requested liquid/dust frame and exits. |
+| `MISALIGNED_SHOT_PATH` | game and art binaries | file path | Output path for the captured PNG (default `misaligned_shot_<kind>.png`). |
 | `MISALIGNED_BEVY_SMOKE` | `tools/check.sh` | `0` / `1` | When `1`, frontend/full verification runs the hidden-window `dark` Bevy screenshot harness and requires fog-audit plus PNG evidence. Default `0` keeps ordinary gates display-independent. |
 | `MISALIGNED_WAKE` | `misaligned-bevy` | `off`, `0`, `skip` | Disable the wake (opening.md beat 1) on launch and start in normal framing. At runtime, any key skips the wake; harness kinds other than `wake*` disable it automatically. |
 
diff --git a/wiki/log/2026-07-10-effects-lab.md b/wiki/log/2026-07-10-effects-lab.md
new file mode 100644
index 0000000..cc0f710
--- /dev/null
+++ b/wiki/log/2026-07-10-effects-lab.md
@@ -0,0 +1,44 @@
+# 2026-07-10 — Shared liquid and dust effects lab
+
+```
+Type: log
+```
+
+## Intent
+
+Make ambitious close-up Thought liquid and Exposure dust practical by giving
+them a focused laboratory, cheaper distance representations, and one shared
+implementation that can graduate directly into the material game frontend.
+
+## Changed
+
+- Added the binding effects-lab spec: a separate `misaligned-effects` binary,
+  shared package-library implementation, close / medium / far levels, and a
+  strict readout-versus-presentation boundary.
+- Added `MaterialEffectsPlugin`, deterministic dust drift/settling, routed
+  Thought slugs/rivulets and endpoint pools, automatic camera-distance LOD,
+  pause/fixed-step time, and aggressive population reduction.
+- Added the orbitable lab with liquid, dust, combined, and twelve-root stress
+  presets; forced LOD inspection; amount/rate controls; and hidden-window PNG
+  capture.
+- Replaced the first close prototype's pearl-train read with an overlapping
+  rivulet after screenshot inspection showed it violated the affirmed Thought
+  grammar.
+- Updated the art/package/environment knowledge pages and package architecture
+  to name the new binary and shared-renderer boundary.
+
+## Evidence
+
+- `cargo test -p misaligned-assets --lib` (7 tests)
+- `cargo check -p misaligned-assets --bin misaligned-effects`
+- hidden-window `dust_close`, `both_close`, `both_medium`, `both_far`, and
+  `stress_far` PNG captures at 1280x800
+- two independent `both_close` captures produced the same SHA-256 digest
+  (`3312eb86edc599a242f0d5d941ca8ee2474613ba5aa388252e667e9a0531d922`)
+
+## Defense
+
+Implements `wiki/art/effects-lab.md` under
+`wiki/art/visual-identity.md#visual-identity-clinical-gore`: near-camera detail
+may be rich, but Thought remains wet ivory and Exposure remains dry crimson;
+distance changes only presentation cost, never gameplay quantity.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 48c83e5..ae77fc9 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -126,6 +126,11 @@ add or amend a session log, then re-run the generator.
 - Intent: Cameron settled two of the three remaining thought-flow [OPEN]s: arbitration is nearest-first (control by open/close and placement, no priority menu), and the run starts with the camera's sink already open so the first THINK toggle visibly sends thought to it — the first-think...
 - Log: [wiki/log/2026-07-10-first-tap.md](2026-07-10-first-tap.md)
 
+## 2026-07-10 - Shared liquid and dust effects lab
+
+- Intent: Make ambitious close-up Thought liquid and Exposure dust practical by giving them a focused laboratory, cheaper distance representations, and one shared implementation that can graduate directly into the material game frontend.
+- Log: [wiki/log/2026-07-10-effects-lab.md](2026-07-10-effects-lab.md)
+
 ## 2026-07-10 - Diegetic playtest entry
 
 - Intent: (see session log)
diff --git a/wiki/log/decisions/2026-07-10.md b/wiki/log/decisions/2026-07-10.md
index eb84335..3a1fb6c 100644
--- a/wiki/log/decisions/2026-07-10.md
+++ b/wiki/log/decisions/2026-07-10.md
@@ -298,3 +298,17 @@ Type: log
   thinking — kept, it is the designed dark bargain. Spec:
   interface/thought-fluid.md (IN PROGRESS), machine-work.md criterion
   10 partial, reach.md criterion 6 restated, sim-mechanics.md updated.
+- **2026-07-10 — A separate effects lab, one renderer at every zoom.**
+  Cameron adopted a focused liquid/dust binary after discussing how far-zoom
+  simplification makes an ambitious close treatment affordable. DECIDED:
+  `misaligned-effects` boots only a clinical effects stage; its liquid and dust
+  systems live in the shared `misaligned-assets` library so the game consumes
+  the same implementation. Close zoom spends on fine dust, specular liquid,
+  pooling, and route motion; medium reduces populations and merges shapes; far
+  becomes aggregate ivory route/source/sink mass plus a crimson stain/haze.
+  The lab can force each level and capture a fixed-seed, fixed-timestep frame.
+  Lab inputs are authored demonstrations only; game quantities remain owned by
+  machine-work and thought-fluid readouts. Exact algorithms, thresholds,
+  populations, and shader constants remain `[TUNE]` in the lab. Rejected: a
+  beautiful disposable prototype that must be rewritten before game use; a
+  tiny full-detail simulation at far zoom. Spec: wiki/art/effects-lab.md.
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 12344c8..dc9f61c 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -21,6 +21,7 @@ not a second status owner.
 | 10 | `machine-work` | [machine work — delegation, visible tokens, and the byproduct network](../mechanics/machine-work.md) | IN PROGRESS | save | - |
 | 20 | `compute` | [compute](../mechanics/compute.md) | IN PROGRESS | save | - |
 | 25 | `bevy-digital-real-canvas` | [Bevy digital/real canvas](../interface/bevy-digital-real-canvas.md) | IN PROGRESS | frontend | - |
+| 26 | `effects-lab` | [effects lab — shared dust and liquid at every zoom](../art/effects-lab.md) | IN PROGRESS | frontend | - |
 | 35 | `views` | [views — same-frame digital and real representations](../interface/views.md) | READY | frontend | - |
 | 60 | `marcus` | [Marcus Webb — night janitor](../world/characters/marcus.md) | READY | sim | - |
 | 61 | `voss` | [Dr. Eli Voss — your handler](../world/characters/voss.md) | READY | sim | - |
diff --git a/wiki/process/specs.md b/wiki/process/specs.md
index dae7c70..a08f8ef 100644
--- a/wiki/process/specs.md
+++ b/wiki/process/specs.md
@@ -27,6 +27,7 @@ replaced the old `spec/`/`knowledge/` directory split.
 
 | Spec | System | Status |
 |---|---|---|
+| [../art/effects-lab.md](../art/effects-lab.md) | effects lab — shared dust and liquid at every zoom | IN PROGRESS |
 | [../engineering/flow-substrate.md](../engineering/flow-substrate.md) | the flow substrate (signals, messages, money — the shared engine) | IMPLEMENTED |
 | [../interface/computer-visual-language.md](../interface/computer-visual-language.md) | computer visual language — territory at a glance | IMPLEMENTED |
 | [../interface/context-menu.md](../interface/context-menu.md) | context menu — actions live on the thing | IMPLEMENTED |