diff --git a/.gitignore b/.gitignore
index 98f7320e..e3d6f2a8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,5 +35,8 @@ dist/
 # omo
 .sisyphus/
 
+# cc
+.claude/
+
 # acta
 data/
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index e1943eff..ec9fba08 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,21 +8,16 @@ version = "0.1.1"
 dependencies = [
  "acta-build",
  "ansi_colours",
- "anstyle",
  "anstyle-lossy",
  "arc-swap",
- "arrayvec",
  "chrono",
  "compact_str",
- "derive_more",
  "flate2",
  "nerd-font-symbols",
  "owo-colors",
  "serde",
  "smallvec",
- "smart-default",
  "supports-color",
- "tap",
  "thiserror",
  "tokio",
  "tracing",
@@ -105,12 +100,6 @@ dependencies = [
  "rustversion",
 ]
 
-[[package]]
-name = "arrayvec"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -186,15 +175,6 @@ dependencies = [
  "static_assertions",
 ]
 
-[[package]]
-name = "convert_case"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -234,29 +214,6 @@ dependencies = [
  "powerfmt",
 ]
 
-[[package]]
-name = "derive_more"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "rustc_version",
- "syn",
- "unicode-xid",
-]
-
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -486,15 +443,6 @@ dependencies = [
  "bytemuck",
 ]
 
-[[package]]
-name = "rustc_version"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
-dependencies = [
- "semver",
-]
-
 [[package]]
 name = "rustversion"
 version = "1.0.22"
@@ -516,12 +464,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "semver"
-version = "1.0.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
-
 [[package]]
 name = "serde"
 version = "1.0.228"
@@ -598,17 +540,6 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
-[[package]]
-name = "smart-default"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eb01866308440fc64d6c44d9e86c5cc17adfe33c4d6eed55da9145044d0ffc1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -641,12 +572,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
 [[package]]
 name = "thiserror"
 version = "2.0.18"
@@ -810,18 +735,6 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
-
 [[package]]
 name = "valuable"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index 6d5f9ec4..aa9c0e3d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,7 +40,6 @@ serde = { version = "1", features = ["derive"], optional = true }
 tracing = "0.1"
 tracing-log = "0.2"
 smallvec = "1"
-arrayvec = "0.7"
 tracing-appender = { version = "0.2", optional = true }
 nerd-font-symbols = { version = "0.3.0", optional = true }
 tokio = { version = "1", default-features = false, features = [
@@ -57,14 +56,10 @@ tracing-subscriber = { version = "0.3", features = [
     "ansi",
     "std",
 ] }
-smart-default = "0.7.1"
 supports-color = "3"
 ansi_colours = "1.2"
 anstyle-lossy = "1.1"
-anstyle = "1"
 arc-swap = "1.7.1"
-derive_more = { version = "2.0.0", features = ["full"] }
-tap = "1.0.1"
 compact_str = { version = "0.9", features = ["serde"] }
 
 [build-dependencies]
diff --git a/README.md b/README.md
index 2f1ccf83..4e1ad364 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ Keep the returned guard alive for as long as logging is needed. Dropping it stop
 | Feature        | Enabled by default | Description                                                                                              |
 | -------------- | ------------------ | -------------------------------------------------------------------------------------------------------- |
 | `unicode`      | Yes                | Uses the Unicode icon set unless `nerd` selects Nerd Font icons.                                         |
-| `file`         | Yes                | Enables `init`, `TracingGuard`, `build_file_layer`, and file logging through `tracing-appender`. |
+| `file`         | Yes                | Enables `init`, `TracingGuard`, and file logging through `tracing-appender`. |
 | `compress`     | No                 | Enables `Rotation::Compress` for gzip-compressing old log files.                                         |
 | `serde`        | No                 | Adds `Serialize` / `Deserialize` support for config types.                                               |
 | `nerd`         | No                 | Enables Nerd Font icons through `Icons::NERD` and uses them by default.                         |
@@ -82,14 +82,14 @@ If you disable default features, `init` is unavailable unless the `file` feature
 
 ```rust
 use acta::{
-    init, Format, Level, Config, Result, Writer,
+    init, Format, LayerConfig, Level, Config, Result, Writer,
 };
 
 fn main() -> Result<()> {
     let config = Config {
-        level: Level::Debug,
+        filter: Level::Debug.into(),
         writers: vec![Writer {
-            format: Format::Compact,
+            format: Format::Compact(LayerConfig::compact()),
             ansi: true,
             show_path: true,
             show_spans: true,
@@ -109,9 +109,9 @@ fn main() -> Result<()> {
 
 | Format            | Description                                                        |
 | ----------------- | ------------------------------------------------------------------ |
-| `Format::Compact` | Default themed formatter with optional path and span display.      |
-| `Format::Pretty`  | `tracing-subscriber` pretty formatter with file and line metadata. |
-| `Format::Json`    | Flattened JSON events without ANSI colors.                         |
+| `Format::Compact(LayerConfig)` | Default themed formatter with optional path and span display.      |
+| `Format::Pretty(LayerConfig)`  | `tracing-subscriber` pretty formatter with file and line metadata. |
+| `Format::Json(LayerConfig)`    | Flattened JSON events without ANSI colors.                         |
 ## File logging
 
 File logging is available with the `file` feature, which is enabled by default. File logs are written as flattened JSON
@@ -119,15 +119,15 @@ events.
 
 ```rust
 use acta::{
-    init, Level, Config, Result, Rotation, Writer, WriterTarget,
+    init, Format, LayerConfig, Level, Config, Result, Rotation, Writer, WriterTarget,
 };
 use std::path::PathBuf;
 
 fn main() -> Result<()> {
     let config = Config {
-        level: Level::Info,
+        filter: Level::Info.into(),
         writers: vec![Writer {
-            format: Format::Compact,
+            format: Format::Compact(LayerConfig::compact()),
             target: WriterTarget::File {
                 path: PathBuf::from("logs/app.log"),
                 rotation: Rotation::Rename,
@@ -156,10 +156,10 @@ Supported rotation modes:
 acta uses `tracing-subscriber` `EnvFilter` directive syntax for startup filters and runtime reloads.
 
 ```rust
-use acta::{Level, Config};
+use acta::{Config, Filter};
 
 let config = Config {
-    level: Level::Custom("info,my_crate=debug,my_crate::db=trace".to_owned()),
+    filter: Filter::from_directive("info,my_crate=debug,my_crate::db=trace"),
     ..Default::default()
 };
 ```
@@ -175,23 +175,22 @@ fn main() -> Result<()> {
     guard.set_level(Level::Debug)?;
     guard.set_target_level("my_crate", Level::Trace)?;
     guard.remove_target_level("my_crate")?;
-    guard.reload("info,my_crate=trace")?;
     guard.set_filter(
-        Filter::new(Level::Warn).with_target("my_crate", Level::Debug),
+        Filter::from_directive("warn,my_crate=debug"),
     )?;
 
     Ok(())
 }
 ```
 
-`RUST_LOG` is not read automatically. If you want to use it, pass its value into `Level::Custom`.
+`RUST_LOG` is not read automatically. If you want to use it, pass its value into `Filter::from_directive`.
 
 ```rust
-use acta::{Level, Config};
+use acta::{Config, Filter};
 
 let directive = std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string());
 let config = Config {
-    level: Level::Custom(directive),
+    filter: Filter::from_directive(directive),
     ..Default::default()
 };
 ```
@@ -206,13 +205,35 @@ use acta::{Formatter, Icons, LevelLabels, Theme};
 let formatter = Formatter::new()
     .with_theme(Theme::tokyo_night())
     .with_icons(Icons::UNICODE)
-    .with_labels(LevelLabels::long())
+    .with_labels(LevelLabels::DEFAULT)
     .with_time_format("%H:%M:%S")
     .with_show_path(true)
     .with_show_spans(true);
 ```
 
-The default path width is generated at build time.
+The default path width is computed at acta's build time from its own source
+tree — fine for a quick start, but if you want the column to fit **your**
+project's source paths, add the `acta-build` helper to your build script:
+
+```toml
+[build-dependencies]
+acta-build = "0.1"
+```
+
+```rust
+// build.rs
+fn main() {
+    let width = acta_build::walk_src_max_width("src", "src/");
+    println!("cargo:rustc-env=ACTA_PATH_WIDTH={width}");
+    println!("cargo:rerun-if-changed=src");
+}
+```
+
+```rust
+// in your code
+let width: usize = env!("ACTA_PATH_WIDTH").parse().unwrap_or(40);
+let formatter = Formatter::new().with_path_width(width);
+```
 
 ## Themes
 
@@ -232,16 +253,16 @@ Create custom themes from RGB values:
 ```rust
 use acta::Theme;
 
-let custom = Theme::new(
-    (91, 206, 250),   // accent
-    (245, 169, 184),  // secondary
-    (255, 255, 255),  // text
-    (255, 85, 85),    // error
-    (255, 200, 60),   // warn
-    (91, 206, 250),   // info
-    (245, 169, 184),  // debug
-    (240, 240, 240),  // trace
-);
+let custom = Theme {
+    accent:    (91, 206, 250),
+    secondary: (245, 169, 184),
+    text:      (255, 255, 255),
+    error:     (255, 85, 85),
+    warn:      (255, 200, 60),
+    info:      (91, 206, 250),
+    debug:     (245, 169, 184),
+    trace:     (240, 240, 240),
+};
 ```
 
 ## Icons and labels
@@ -250,8 +271,8 @@ let custom = Theme::new(
 use acta::{Icons, LevelLabels};
 
 let unicode_icons = Icons::UNICODE;
-let short_labels = LevelLabels::short();
-let long_labels = LevelLabels::long();
+let short_labels = LevelLabels::SHORT;
+let long_labels = LevelLabels::DEFAULT;
 ```
 
 With the `nerd` feature enabled:
@@ -287,35 +308,6 @@ fn main() -> Result<()> {
     Ok(())
 }
 ```
-If you build the subscriber manually, `build_reload_filter` returns a `TracingGuard` that also supports style reloading:
-
-```rust
-use acta::{
-    build_reload_filter, Formatter, Level, Result,
-    Theme, Style, Writer,
-};
-use tracing_subscriber::prelude::*;
-
-fn main() -> Result<()> {
-    let formatter = Formatter::new().with_theme(Theme::monokai());
-    let style = *formatter.style_config();
-    let console_layer = tracing_subscriber::fmt::Layer::default()
-        .with_writer(std::io::stdout)
-        .event_format(formatter)
-        .boxed();
-    let (filter_layer, mut guard) = build_reload_filter(Level::Info, style);
-
-    let subscriber = tracing_subscriber::registry()
-        .with(console_layer)
-        .with(filter_layer);
-    tracing::subscriber::set_global_default(subscriber)?;
-
-    guard.with_style(|s| s.theme = Theme::dracula());
-
-    Ok(())
-}
-```
-This low-level setup requires adding `tracing-subscriber` as a direct dependency.
 
 ## Async console writers
 
diff --git a/build.rs b/build.rs
index be2555f7..e0a5889f 100644
--- a/build.rs
+++ b/build.rs
@@ -1,19 +1,11 @@
 #![allow(clippy::expect_used)]
 
 fn main() {
-    let max = match acta_build::walk_src_max_width("src", "src/") {
-        Ok(m) => m,
-        Err(e) => {
-            println!("cargo::warning=walk_src_max_width failed: {e}");
-            20
-        }
-    };
-    std::fs::write(
-        std::path::Path::new(&std::env::var("OUT_DIR").expect("Cargo should set OUT_DIR"))
-            .join("path_width"),
-        max.to_string(),
-    )
-    .expect("failed to write path_width to OUT_DIR");
-
+    let width = acta_build::walk_src_max_width("src", "src/");
+    let out_dir = std::env::var_os("OUT_DIR").expect("Cargo should set OUT_DIR");
+    let path = std::path::Path::new(&out_dir).join("path_width");
+    if let Err(e) = std::fs::write(&path, width.to_string()) {
+        println!("cargo::warning=failed to write {}: {e}", path.display());
+    }
     println!("cargo::rerun-if-changed=src");
 }
diff --git a/crates/acta-build/Cargo.toml b/crates/acta-build/Cargo.toml
index ea089b9b..6aaffc57 100644
--- a/crates/acta-build/Cargo.toml
+++ b/crates/acta-build/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acta-build"
 version.workspace = true
 edition = "2024"
-description = "Build-time helper for acta path width calculation"
+description = "Build-time helper for acta: compute path-column width from a project's source tree"
 repository = "https://github.com/Sn0wo2/acta"
 publish = true
 license = "Apache-2.0"
diff --git a/crates/acta-build/src/lib.rs b/crates/acta-build/src/lib.rs
index f7bb521e..254506da 100644
--- a/crates/acta-build/src/lib.rs
+++ b/crates/acta-build/src/lib.rs
@@ -1,14 +1,55 @@
+//! Build-time helper for [acta](https://crates.io/crates/acta).
+//!
+//! Call from your `build.rs` to compute a sensible default `path_width` for
+//! [`acta::Formatter`] based on the longest source-file path in your project.
+//!
+//! # Example
+//!
+//! Add to your `Cargo.toml`:
+//!
+//! ```toml
+//! [build-dependencies]
+//! acta-build = "0.1"
+//! ```
+//!
+//! In `build.rs`:
+//!
+//! ```no_run
+//! # fn example() {
+//! let width = acta_build::walk_src_max_width("src", "src/");
+//! println!("cargo:rustc-env=ACTA_PATH_WIDTH={width}");
+//! println!("cargo:rerun-if-changed=src");
+//! # }
+//! ```
+//!
+//! Then in your code:
+//!
+//! ```ignore
+//! let width: usize = env!("ACTA_PATH_WIDTH").parse().unwrap_or(40);
+//! let formatter = acta::Formatter::new().with_path_width(width);
+//! ```
+
+use std::path::Path;
 use walkdir::WalkDir;
 
-pub fn walk_src_max_width(dir: &str, strip_prefix: &str) -> Result<usize, String> {
-    let entries: Vec<_> = WalkDir::new(dir)
+const FALLBACK_WIDTH: usize = 40;
+const PADDING: usize = 4;
+
+/// Walk `dir` recursively, find every `.rs` file, and return
+/// `max(path_len_after_stripping(strip_prefix)) + 4`.
+///
+/// Returns [`FALLBACK_WIDTH`] (40) if `dir` does not exist or contains no
+/// `.rs` files — safe to call unconditionally from a `build.rs`.
+#[must_use]
+pub fn walk_src_max_width(dir: impl AsRef<Path>, strip_prefix: &str) -> usize {
+    let entries: Vec<_> = WalkDir::new(dir.as_ref())
         .into_iter()
-        .filter_map(|e| e.ok())
+        .filter_map(Result::ok)
         .filter(|e| e.path().extension().is_some_and(|ext| ext == "rs"))
         .collect();
 
     if entries.is_empty() {
-        return Err(format!("no .rs files found in {dir}"));
+        return FALLBACK_WIDTH;
     }
 
     let max = entries
@@ -17,12 +58,10 @@ pub fn walk_src_max_width(dir: &str, strip_prefix: &str) -> Result<usize, String
             let display = e.path().to_string_lossy().replace('\\', "/");
             display
                 .find(strip_prefix)
-                .map(|i| &display[i + strip_prefix.len()..])
-                .unwrap_or(&display)
-                .len()
+                .map_or(display.len(), |i| display[i + strip_prefix.len()..].len())
         })
         .max()
-        .unwrap(); // safe
+        .unwrap_or(FALLBACK_WIDTH);
 
-    Ok(max + 4)
+    max + PADDING
 }
diff --git a/crates/acta-debug/src/main.rs b/crates/acta-debug/src/main.rs
index 40d7a339..88a8fd9b 100644
--- a/crates/acta-debug/src/main.rs
+++ b/crates/acta-debug/src/main.rs
@@ -1,9 +1,9 @@
-#![allow(clippy::print_stdout, clippy::print_stderr)]
+#![allow(clippy::print_stdout, clippy::print_stderr, clippy::unwrap_used)]
 use std::sync::LazyLock;
 
 use acta::{
-    Config, Format, Icons, LayerConfig, Level, LevelLabels, Rotation, Style, Theme, Writer,
-    WriterTarget, build_layer, build_reload_filter, init, rotate_log_file,
+    Config, Filter, Format, Icons, LayerConfig, Level, LevelLabels, Rotation, Style, Theme, Writer,
+    WriterTarget, build_layer, init, rotate_log_file,
 };
 use smallvec::{SmallVec, smallvec};
 use tracing_subscriber::prelude::*;
@@ -40,34 +40,11 @@ macro_rules! log {
 }
 
 fn run_with(w: &Writer, f: impl FnOnce()) {
-    let layer = build_layer::<tracing_subscriber::Registry>(w);
+    let layer = build_layer(w);
     let subscriber = tracing_subscriber::registry().with(layer);
     tracing::subscriber::with_default(subscriber, f);
 }
 
-fn none_layer<S>() -> Option<acta::builder::FmtLayer<S>>
-where
-    S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
-{
-    None
-}
-
-fn run_with_reload(
-    style: Style,
-    w: &Writer,
-    level: Level,
-    f: impl FnOnce(&mut acta::TracingGuard),
-) {
-    let (filter_layer, mut guard) = build_reload_filter(level, style);
-    let subscriber = tracing_subscriber::Registry::default()
-        .with(Some(build_layer::<tracing_subscriber::Registry>(w)))
-        .with(none_layer())
-        .with(none_layer())
-        .with(none_layer())
-        .with(none_layer())
-        .with(filter_layer);
-    tracing::subscriber::with_default(subscriber, || f(&mut guard));
-}
 fn emit_demo(label: &str) {
     tracing::info!("{label}: info");
     tracing::warn!(user = "alice", count = 42, "{label}: warn");
@@ -277,68 +254,6 @@ fn main() {
         emit_spans,
     );
 
-    section("RELOAD");
-
-    log!(sub, "Level reload");
-    run_with_reload(
-        Style::default(),
-        &Writer {
-            show_path: false,
-            show_spans: false,
-            ..Default::default()
-        },
-        Level::Info,
-        |h| {
-            tracing::info!("level=Info: info passes");
-            h.set_level(Level::Debug).unwrap();
-            log!(info, "→ set_level(Debug)");
-            tracing::debug!("level=Debug: debug passes");
-        },
-    );
-
-    log!(sub, "Target-level reload");
-    run_with_reload(
-        Style::default(),
-        &Writer {
-            show_path: false,
-            show_spans: false,
-            ..Default::default()
-        },
-        Level::Debug,
-        |h| {
-            tracing::info!(target: "demo", "before: info@demo passes (level=Debug)");
-            h.set_target_level("demo", Level::Warn).unwrap();
-            log!(info, "→ set_target_level(demo, Warn)");
-            tracing::info!(target: "demo", "after: info@demo suppressed");
-            tracing::warn!(target: "demo", "after: warn@demo passes");
-        },
-    );
-
-    log!(sub, "Style switch");
-    let style = Style {
-        icons: Icons::UNICODE,
-        ..Default::default()
-    };
-    run_with_reload(
-        style,
-        &Writer {
-            style,
-            show_path: false,
-            show_spans: false,
-            ..Default::default()
-        },
-        Level::Info,
-        |h| {
-            tracing::info!("unicode + acta theme");
-            h.with_style(|s| s.theme = Theme::monokai());
-            log!(info, "→ monokai theme");
-            tracing::info!("monokai theme");
-            h.with_style(|s| s.icons = Icons::NERD);
-            log!(info, "→ nerd icons");
-            tracing::error!("nerd icons");
-        },
-    );
-
     section("INFRA");
 
     log!(sub, "Level → directive");
@@ -349,10 +264,16 @@ fn main() {
         Level::Debug,
         Level::Trace,
         Level::Off,
-        Level::Custom("info,my_crate=debug".into()),
     ] {
         log!(info, &format!("{l:?} → \"{}\"", l.as_directive()));
     }
+    log!(
+        info,
+        &format!(
+            "Filter::from_directive(\"info,my_crate=debug\") → \"{}\"",
+            Filter::from_directive("info,my_crate=debug").as_directive()
+        )
+    );
 
     log!(sub, "build_layer");
     for (desc, w) in [
@@ -367,7 +288,7 @@ fn main() {
             },
         ),
     ] {
-        drop(build_layer::<tracing_subscriber::Registry>(&w));
+        drop(build_layer(&w));
         log!(success, &format!("build_layer({desc})"));
     }
 
@@ -396,7 +317,8 @@ fn main() {
         }
     }
 
-    log!(sub, "init — end-to-end");
+    section("RELOAD via init");
+    log!(sub, "init + runtime reload");
     let dir = std::path::Path::new("data/logs/full");
     drop(std::fs::create_dir_all(dir));
     let config = Config::builder()
@@ -418,12 +340,26 @@ fn main() {
         })
         .build();
     match init(config) {
-        Ok(g) => {
+        Ok(mut g) => {
             log!(success, "init");
             if let Some(p) = g.log_path() {
                 log!(info, &format!("file → {}", p.display()));
             }
             tracing::info!(init = true, "console + file");
+
+            g.set_level(Level::Warn).unwrap();
+            log!(info, "→ set_level(Warn)");
+            tracing::info!("info suppressed");
+            tracing::warn!("warn passes");
+
+            g.set_target_level("demo", Level::Trace).unwrap();
+            log!(info, "→ set_target_level(demo, Trace)");
+            tracing::trace!(target: "demo", "demo trace passes");
+
+            g.with_style(|s| s.theme = Theme::monokai());
+            log!(info, "→ style switch (monokai)");
+            tracing::warn!("monokai");
+
             drop(g);
         }
         Err(e) => log!(fail, &format!("init: {e}")),
diff --git a/src/builder.rs b/src/builder.rs
index f148abbf..8c67de4d 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -6,53 +6,116 @@ use std::io;
 #[cfg(feature = "file")]
 use std::path::PathBuf;
 use std::sync::Arc;
+use tracing_subscriber::Registry;
 use tracing_subscriber::fmt::format::FmtSpan;
+use tracing_subscriber::layer::Layered;
 use tracing_subscriber::prelude::*;
 
-pub type FmtLayer<S = tracing_subscriber::Registry> =
-    Box<dyn tracing_subscriber::Layer<S> + Send + Sync>;
-
-// tracing_subscriber::reload::Handle<EnvFilter, S> needs the concrete S.
-// Six optional layers stacked → this pyramid.  Users never name it.
-type Layer1 = tracing_subscriber::layer::Layered<
-    Option<FmtLayer<tracing_subscriber::Registry>>,
-    tracing_subscriber::Registry,
->;
-type Layer2 = tracing_subscriber::layer::Layered<Option<FmtLayer<Layer1>>, Layer1>;
-type Layer3 = tracing_subscriber::layer::Layered<Option<FmtLayer<Layer2>>, Layer2>;
-type Layer4 = tracing_subscriber::layer::Layered<Option<FmtLayer<Layer3>>, Layer3>;
-pub(crate) type InnerSubscriber =
-    tracing_subscriber::layer::Layered<Option<FmtLayer<Layer4>>, Layer4>;
-
-pub(crate) struct ReloadHandle(
-    pub(crate) tracing_subscriber::reload::Handle<tracing_subscriber::EnvFilter, InnerSubscriber>,
-);
-
-impl ReloadHandle {
-    fn new(
-        filter: tracing_subscriber::EnvFilter,
-    ) -> (
-        tracing_subscriber::reload::Layer<tracing_subscriber::EnvFilter, InnerSubscriber>,
-        Self,
-    ) {
-        let (layer, handle) = tracing_subscriber::reload::Layer::new(filter);
-        (layer, Self(handle))
+#[cfg(any(feature = "file", feature = "custom-async", feature = "native-async"))]
+use crate::writer;
+
+pub(crate) type BoxedLayer = Box<dyn tracing_subscriber::Layer<Registry> + Send + Sync>;
+
+/// Newtype wrapping Vec<BoxedLayer> to avoid orphan-rule reliance on
+/// tracing-subscriber's blanket `impl Layer<S> for Vec<L>`.
+pub(crate) struct Layers(pub(crate) Vec<BoxedLayer>);
+
+impl tracing_subscriber::Layer<Registry> for Layers {
+    fn on_layer(&mut self, subscriber: &mut Registry) {
+        for layer in &mut self.0 {
+            layer.on_layer(subscriber);
+        }
     }
 
-    fn modify(&self, f: impl FnOnce(&mut tracing_subscriber::EnvFilter)) -> crate::Result<()> {
-        self.0.modify(f)?;
-        Ok(())
+    fn on_new_span(&self, attrs: &tracing::span::Attributes<'_>, id: &tracing::span::Id, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_new_span(attrs, id, ctx.clone());
+        }
+    }
+
+    fn on_event(&self, event: &tracing::Event<'_>, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_event(event, ctx.clone());
+        }
     }
-}
 
-impl From<Style> for Arc<arc_swap::ArcSwap<Style>> {
-    fn from(s: Style) -> Self {
-        Self::new(arc_swap::ArcSwap::new(Arc::new(s)))
+    fn on_enter(&self, id: &tracing::span::Id, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_enter(id, ctx.clone());
+        }
+    }
+
+    fn on_exit(&self, id: &tracing::span::Id, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_exit(id, ctx.clone());
+        }
+    }
+
+    fn on_close(&self, id: tracing::span::Id, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_close(id.clone(), ctx.clone());
+        }
+    }
+
+    fn on_record(&self, id: &tracing::span::Id, values: &tracing::span::Record<'_>, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_record(id, values, ctx.clone());
+        }
+    }
+
+    fn on_follows_from(&self, id: &tracing::span::Id, follows: &tracing::span::Id, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_follows_from(id, follows, ctx.clone());
+        }
+    }
+
+    fn on_id_change(&self, old: &tracing::span::Id, new: &tracing::span::Id, ctx: tracing_subscriber::layer::Context<'_, Registry>) {
+        for layer in &self.0 {
+            layer.on_id_change(old, new, ctx.clone());
+        }
+    }
+
+    fn enabled(&self, metadata: &tracing::Metadata<'_>, ctx: tracing_subscriber::layer::Context<'_, Registry>) -> bool {
+        self.0.iter().any(|layer| layer.enabled(metadata, ctx.clone()))
+    }
+
+    fn event_enabled(&self, event: &tracing::Event<'_>, ctx: tracing_subscriber::layer::Context<'_, Registry>) -> bool {
+        self.0.iter().any(|layer| layer.event_enabled(event, ctx.clone()))
     }
 }
 
-#[cfg(any(feature = "file", feature = "custom-async", feature = "native-async"))]
-use crate::writer;
+pub(crate) type InnerSubscriber = Layered<Layers, Registry>;
+pub(crate) type ReloadHandle =
+    tracing_subscriber::reload::Handle<tracing_subscriber::EnvFilter, InnerSubscriber>;
+
+#[allow(clippy::single_call_fn)]
+fn detect_color_depth(target: &WriterTarget) -> ColorDepth {
+    use supports_color::Stream;
+    let stream = match *target {
+        WriterTarget::Stdout => Stream::Stdout,
+        WriterTarget::Stderr => Stream::Stderr,
+        #[cfg(feature = "file")]
+        WriterTarget::File { .. } => return ColorDepth::NoColor,
+        #[cfg(any(feature = "custom-async", feature = "native-async"))]
+        WriterTarget::AsyncStdout(_) => Stream::Stdout,
+        #[cfg(any(feature = "custom-async", feature = "native-async"))]
+        WriterTarget::AsyncStderr(_) => Stream::Stderr,
+    };
+
+    if let Some(level) = supports_color::on_cached(stream) {
+        if level.has_16m {
+            return ColorDepth::TrueColor;
+        }
+        if level.has_256 {
+            return ColorDepth::Ansi256;
+        }
+        if level.has_basic {
+            return ColorDepth::Ansi16;
+        }
+    }
+
+    ColorDepth::NoColor
+}
 
 fn build_formatter(
     writer: &Writer,
@@ -75,24 +138,22 @@ fn build_formatter(
     f
 }
 
-fn build_layer_inner<S>(
+pub fn build_layer(writer: &Writer) -> BoxedLayer {
+    build_layer_with(writer, None)
+}
+
+fn build_layer_with(
     writer: &Writer,
     shared_handle: Option<Arc<arc_swap::ArcSwap<Style>>>,
-) -> FmtLayer<S>
-where
-    S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
-{
-    let formatter = build_formatter(
-        writer,
-        writer.color_depth.unwrap_or_else(|| {
-            if writer.ansi {
-                crate::config::depth::detect(&writer.target)
-            } else {
-                ColorDepth::NoColor
-            }
-        }),
-        shared_handle,
-    );
+) -> BoxedLayer {
+    let color_depth = writer.color_depth.unwrap_or_else(|| {
+        if writer.ansi {
+            detect_color_depth(&writer.target)
+        } else {
+            ColorDepth::NoColor
+        }
+    });
+    let formatter = build_formatter(writer, color_depth, shared_handle);
 
     let base = || {
         tracing_subscriber::fmt::Layer::default()
@@ -163,20 +224,9 @@ where
     }
 }
 
-pub fn build_layer<S>(writer: &Writer) -> FmtLayer<S>
-where
-    S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
-{
-    build_layer_inner(writer, None)
-}
-
 #[cfg(feature = "file")]
 #[allow(clippy::single_call_fn)]
-fn build_file_fmt_layer<S>(writer: &Writer, file_writer: writer::FileWriter) -> FmtLayer<S>
-where
-    S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
-{
-    let formatter = build_formatter(writer, ColorDepth::NoColor, None);
+fn build_file_layer(writer: &Writer, file_writer: writer::FileWriter) -> BoxedLayer {
     let base = || {
         tracing_subscriber::fmt::Layer::default()
             .with_thread_ids(false)
@@ -198,7 +248,7 @@ where
             .with_file(cfg.file)
             .with_line_number(cfg.line_number)
             .with_ansi(false)
-            .event_format(formatter)
+            .event_format(build_formatter(writer, ColorDepth::NoColor, None))
             .with_writer(file_writer)
             .boxed(),
         Format::Json(cfg) => base()
@@ -215,170 +265,59 @@ where
     }
 }
 
-/// Build a reload layer + TracingGuard.
-///
-/// `style_handle` can be:
-/// - A `Style` (creates an independent handle — `with_style()` works on the
-///   guard but won't affect `Formatter`s that already exist).
-/// - An `Arc<ArcSwap<Style>>` from `Formatter::style_handle()` — the guard
-///   and formatter share the same style state so `with_style()` updates the
-///   formatter at runtime.
-pub fn build_reload_filter(
-    level: crate::config::Level,
-    style_handle: impl Into<Arc<arc_swap::ArcSwap<Style>>>,
-) -> (
-    tracing_subscriber::reload::Layer<tracing_subscriber::EnvFilter, InnerSubscriber>,
-    TracingGuard,
-) {
-    let filter = Filter::new(level);
-    let env_filter =
-        tracing_subscriber::EnvFilter::try_new(filter.as_directive()).unwrap_or_default();
-    let (layer, raw) = ReloadHandle::new(env_filter);
-    let guard = TracingGuard {
-        raw,
-        filter,
-        style: style_handle.into(),
-        #[cfg(feature = "file")]
-        worker_guard: None,
-        #[cfg(feature = "file")]
-        log_path: None,
-    };
-    (layer, guard)
-}
-
-#[non_exhaustive]
-pub struct SubscriberParts {
-    pub(crate) raw: ReloadHandle,
-    pub(crate) filter: Filter,
-    pub(crate) style: Arc<arc_swap::ArcSwap<Style>>,
-    #[cfg(feature = "file")]
-    pub(crate) file_guard: Option<writer::LogHandle>,
-    #[cfg(feature = "file")]
-    pub(crate) log_path: Option<PathBuf>,
-}
-
-impl std::fmt::Debug for SubscriberParts {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SubscriberParts").finish_non_exhaustive()
-    }
-}
-
-impl SubscriberParts {
-    pub fn into_guard(self) -> TracingGuard {
-        TracingGuard {
-            raw: self.raw,
-            filter: self.filter,
-            style: self.style,
-            #[cfg(feature = "file")]
-            worker_guard: self.file_guard,
-            #[cfg(feature = "file")]
-            log_path: self.log_path,
-        }
-    }
-    #[cfg(feature = "file")]
-    pub fn file_guard(self) -> Option<writer::LogHandle> {
-        self.file_guard
-    }
-    #[cfg(feature = "file")]
-    pub fn log_path(self) -> Option<PathBuf> {
-        self.log_path
-    }
-}
+pub fn init(config: impl Into<Config>) -> crate::Result<TracingGuard> {
+    let Config { filter, writers } = config.into();
+    let shared_style = Arc::new(arc_swap::ArcSwap::new(Arc::new(
+        writers.first().map_or_else(Style::default, |w| w.style),
+    )));
 
-#[allow(clippy::type_complexity)]
-pub fn build_subscriber(config: Config) -> crate::Result<SubscriberParts> {
-    let Config { level, writers } = config;
-    let initial_style = writers.first().map_or_else(Style::default, |w| w.style);
-    let shared_style = Arc::new(arc_swap::ArcSwap::new(Arc::new(initial_style)));
-
-    let mut stdout_layer = None;
-    let mut stderr_layer = None;
-    #[cfg(any(feature = "custom-async", feature = "native-async"))]
-    let mut async_stdout_layer = None;
-    #[cfg(not(any(feature = "custom-async", feature = "native-async")))]
-    let async_stdout_layer = None;
-    #[cfg(any(feature = "custom-async", feature = "native-async"))]
-    let mut async_stderr_layer = None;
-    #[cfg(not(any(feature = "custom-async", feature = "native-async")))]
-    let async_stderr_layer = None;
+    let mut layers: Vec<BoxedLayer> = Vec::with_capacity(writers.len());
     #[cfg(feature = "file")]
-    let mut file_layer = None;
-    #[cfg(not(feature = "file"))]
-    let file_layer = None;
-
     #[cfg(feature = "file")]
     let mut file_guard = None;
     #[cfg(feature = "file")]
     let mut log_path = None;
 
-    let mut shared_style_used = false;
-
     for writer in writers {
         #[cfg(feature = "file")]
         let eligible = !matches!(writer.target, WriterTarget::File { .. });
         #[cfg(not(feature = "file"))]
         let eligible = true;
 
-        let handle = (eligible && !shared_style_used).then(|| {
-            shared_style_used = true;
-            shared_style.clone()
-        });
+        let handle = eligible.then(|| shared_style.clone());
 
-        match writer.target {
-            WriterTarget::Stdout => stdout_layer = Some(build_layer_inner(&writer, handle)),
-            WriterTarget::Stderr => stderr_layer = Some(build_layer_inner(&writer, handle)),
-            #[cfg(feature = "file")]
-            WriterTarget::File { ref path, rotation } => {
-                let (file_w, guard, resolved_path) =
-                    writer::file::build_file_layer(path, rotation)?;
-                file_guard = Some(guard);
-                log_path = Some(resolved_path);
-                file_layer = Some(build_file_fmt_layer(&writer, file_w));
-            }
-            #[cfg(any(feature = "custom-async", feature = "native-async"))]
-            WriterTarget::AsyncStdout(_) => {
-                async_stdout_layer = Some(build_layer_inner(&writer, handle))
-            }
-            #[cfg(any(feature = "custom-async", feature = "native-async"))]
-            WriterTarget::AsyncStderr(_) => {
-                async_stderr_layer = Some(build_layer_inner(&writer, handle))
-            }
+        #[cfg(feature = "file")]
+        if let WriterTarget::File { ref path, rotation } = writer.target {
+            let (file_w, guard, resolved_path) = writer::file::build_file_layer(path, rotation)?;
+            file_guard = Some(guard);
+            log_path = Some(resolved_path);
+            layers.push(build_file_layer(&writer, file_w));
+            continue;
         }
+
+        layers.push(build_layer_with(&writer, handle));
     }
 
-    let filter = Filter::new(level);
-    let env_filter =
-        tracing_subscriber::EnvFilter::try_new(filter.as_directive()).unwrap_or_default();
-    let (env_filter_layer, raw) = ReloadHandle::new(env_filter);
+    let env_filter = tracing_subscriber::EnvFilter::try_new(filter.as_directive())?;
+    let (env_filter_layer, raw) = tracing_subscriber::reload::Layer::new(env_filter);
 
-    let subscriber = tracing_subscriber::Registry::default()
-        .with(stdout_layer)
-        .with(stderr_layer)
-        .with(async_stdout_layer)
-        .with(async_stderr_layer)
-        .with(file_layer)
-        .with(env_filter_layer);
+    let subscriber = Registry::default().with(Layers(layers)).with(env_filter_layer);
 
     let _ = tracing_log::LogTracer::init();
     tracing::subscriber::set_global_default(subscriber)?;
-    Ok(SubscriberParts {
+
+    Ok(TracingGuard {
         raw,
         filter,
         style: shared_style,
         #[cfg(feature = "file")]
-        file_guard,
+        worker_guard: file_guard,
         #[cfg(feature = "file")]
         log_path,
     })
 }
 
-pub fn init(config: impl Into<Config>) -> crate::Result<TracingGuard> {
-    build_subscriber(config.into()).map(SubscriberParts::into_guard)
-}
-
 #[must_use = "dropping TracingGuard will release associated resources"]
-#[allow(clippy::module_name_repetitions)]
-#[non_exhaustive]
 pub struct TracingGuard {
     pub(crate) raw: ReloadHandle,
     pub(crate) filter: Filter,
@@ -392,11 +331,11 @@ pub struct TracingGuard {
 impl std::fmt::Debug for TracingGuard {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut d = f.debug_struct("TracingGuard");
-        d.field("filter", &self.filter);
+        let _ = d.field("filter", &self.filter);
         #[cfg(feature = "file")]
-        d.field("log_path", &self.log_path);
+        let _ = d.field("log_path", &self.log_path);
         #[cfg(feature = "file")]
-        d.field("has_file_guard", &self.worker_guard.is_some());
+        let _ = d.field("has_file_guard", &self.worker_guard.is_some());
         d.finish_non_exhaustive()
     }
 }
@@ -408,20 +347,14 @@ impl TracingGuard {
         self.style.store(Arc::new(style));
     }
 
-    pub fn reload(&mut self, directive: &str) -> crate::Result<()> {
-        self.apply_directive(directive)?;
-        self.filter = Filter::new(crate::config::Level::Custom(directive.to_owned()));
-        Ok(())
-    }
-
     pub fn set_filter(&mut self, filter: Filter) -> crate::Result<()> {
-        let directive = filter.as_directive();
-        self.apply_directive(&directive)?;
+        let env_filter = tracing_subscriber::EnvFilter::try_new(filter.as_directive())?;
+        self.raw.modify(|f| *f = env_filter)?;
         self.filter = filter;
         Ok(())
     }
 
-    pub fn set_level(&mut self, level: impl Into<crate::config::Level>) -> crate::Result<()> {
+    pub fn set_level(&mut self, level: crate::config::Level) -> crate::Result<()> {
         self.filter = Filter::new(level);
         self.apply_current_filter()
     }
@@ -429,7 +362,7 @@ impl TracingGuard {
     pub fn set_target_level(
         &mut self,
         target: impl Into<compact_str::CompactString>,
-        level: impl Into<crate::config::Level>,
+        level: crate::config::Level,
     ) -> crate::Result<()> {
         self.filter.with_target(target, level);
         self.apply_current_filter()
@@ -442,21 +375,12 @@ impl TracingGuard {
 
     fn apply_current_filter(&self) -> crate::Result<()> {
         let env_filter = tracing_subscriber::EnvFilter::try_new(self.filter.as_directive())?;
-        self.raw.modify(|f| *f = env_filter)
-    }
-
-    fn apply_directive(&self, directive: &str) -> crate::Result<()> {
-        let filter = tracing_subscriber::EnvFilter::try_new(directive)?;
-        self.raw.modify(|f| *f = filter)
+        self.raw.modify(|f| *f = env_filter)?;
+        Ok(())
     }
 
     #[cfg(feature = "file")]
     pub fn log_path(&self) -> Option<&std::path::Path> {
         self.log_path.as_deref()
     }
-
-    pub fn shutdown(&self) -> crate::Result<()> {
-        let filter = tracing_subscriber::EnvFilter::try_new("off")?;
-        self.raw.modify(|f| *f = filter)
-    }
 }
diff --git a/src/color/mapping.rs b/src/color/mapping.rs
deleted file mode 100644
index 3aa969b7..00000000
--- a/src/color/mapping.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use owo_colors::AnsiColors;
-
-use anstyle::RgbColor;
-use anstyle_lossy::{palette::Palette, rgb_to_ansi};
-
-/// Delegates to the `anstyle_lossy` crate which uses a weighted
-/// Euclidean distance metric against a platform-aware default palette
-/// (VGA on Unix, Windows 10 Console on Windows).
-pub fn rgb_to_ansi16(r: u8, g: u8, b: u8) -> AnsiColors {
-    let ansi = rgb_to_ansi(RgbColor(r, g, b), Palette::default());
-    const PALETTE: [AnsiColors; 16] = [
-        AnsiColors::Black,
-        AnsiColors::Red,
-        AnsiColors::Green,
-        AnsiColors::Yellow,
-        AnsiColors::Blue,
-        AnsiColors::Magenta,
-        AnsiColors::Cyan,
-        AnsiColors::White,
-        AnsiColors::BrightBlack,
-        AnsiColors::BrightRed,
-        AnsiColors::BrightGreen,
-        AnsiColors::BrightYellow,
-        AnsiColors::BrightBlue,
-        AnsiColors::BrightMagenta,
-        AnsiColors::BrightCyan,
-        AnsiColors::BrightWhite,
-    ];
-    *PALETTE.get(ansi as usize).unwrap_or(&AnsiColors::White)
-}
diff --git a/src/color/mod.rs b/src/color/mod.rs
index a5e6d87a..69f46614 100644
--- a/src/color/mod.rs
+++ b/src/color/mod.rs
@@ -1,8 +1,6 @@
-pub mod mapping;
 pub mod style;
 
 #[cfg(test)]
 mod tests;
 
-pub use mapping::rgb_to_ansi16;
-pub use style::{rgb_to_owo, rgb_to_owo_on, theme_fg_dimmed};
+pub(crate) use style::Styled;
diff --git a/src/color/style.rs b/src/color/style.rs
index 39be94ff..760ddda2 100644
--- a/src/color/style.rs
+++ b/src/color/style.rs
@@ -1,51 +1,87 @@
-use ansi_colours::ansi256_from_rgb;
-use owo_colors::{DynColors, Style as OwoStyle, XtermColors};
+use anstyle_lossy::palette::Palette;
+use anstyle_lossy::rgb_to_ansi;
+use owo_colors::AnsiColors;
+use owo_colors::Rgb;
+use owo_colors::Style as OwoStyle;
+use owo_colors::XtermColors;
+use crate::ColorDepth;
 
-use crate::color::mapping::rgb_to_ansi16;
-use crate::config::ColorDepth;
+const ANSI16_TABLE: [AnsiColors; 16] = [
+    AnsiColors::Black,
+    AnsiColors::Red,
+    AnsiColors::Green,
+    AnsiColors::Yellow,
+    AnsiColors::Blue,
+    AnsiColors::Magenta,
+    AnsiColors::Cyan,
+    AnsiColors::White,
+    AnsiColors::BrightBlack,
+    AnsiColors::BrightRed,
+    AnsiColors::BrightGreen,
+    AnsiColors::BrightYellow,
+    AnsiColors::BrightBlue,
+    AnsiColors::BrightMagenta,
+    AnsiColors::BrightCyan,
+    AnsiColors::BrightWhite,
+];
 
-pub fn rgb_to_owo(rgb: (u8, u8, u8), depth: ColorDepth) -> OwoStyle {
-    let r = rgb.0;
-    let g = rgb.1;
-    let b = rgb.2;
+#[derive(Clone, Copy, Debug)]
+pub struct Styled {
+    rgb: Rgb,
+    depth: ColorDepth,
+    on: bool,
+}
 
-    match depth {
-        ColorDepth::TrueColor => OwoStyle::new().color(DynColors::Rgb(r, g, b)),
-        ColorDepth::Ansi256 => {
-            let idx = ansi256_from_rgb((r, g, b));
-            OwoStyle::new().color(DynColors::Xterm(XtermColors::from(idx)))
-        }
-        ColorDepth::Ansi16 => {
-            let c = rgb_to_ansi16(r, g, b);
-            OwoStyle::new().color(DynColors::Ansi(c))
+impl Styled {
+    pub(crate) const fn new(rgb: Rgb, depth: ColorDepth) -> Self {
+        Self {
+            rgb,
+            depth,
+            on: false,
         }
-        ColorDepth::NoColor => OwoStyle::new(),
     }
-}
 
-/// Dims the foreground by dividing brightness by 4 to ensure high text legibility against the background.
-pub fn rgb_to_owo_on(r: u8, g: u8, b: u8, depth: ColorDepth) -> OwoStyle {
-    let dr = r >> 2;
-    let dg = g >> 2;
-    let db = b >> 2;
-    match depth {
-        ColorDepth::TrueColor => OwoStyle::new()
-            .color(DynColors::Rgb(dr, dg, db))
-            .on_color(DynColors::Rgb(r, g, b)),
-        ColorDepth::Ansi256 => OwoStyle::new()
-            .color(DynColors::Xterm(XtermColors::from(ansi256_from_rgb((
-                dr, dg, db,
-            )))))
-            .on_color(DynColors::Xterm(XtermColors::from(ansi256_from_rgb((
-                r, g, b,
-            ))))),
-        ColorDepth::Ansi16 => OwoStyle::new()
-            .color(DynColors::Ansi(rgb_to_ansi16(dr, dg, db)))
-            .on_color(DynColors::Ansi(rgb_to_ansi16(r, g, b))),
-        ColorDepth::NoColor => OwoStyle::new(),
+    pub(crate) const fn dimmed(mut self) -> Self {
+        self.rgb = Rgb(self.rgb.0 >> 2, self.rgb.1 >> 2, self.rgb.2 >> 2);
+        self
+    }
+
+    pub(crate) const fn on(mut self) -> Self {
+        self.on = true;
+        self
+    }
+
+    pub(crate) const fn as_tuple(&self) -> (u8, u8, u8) {
+        (self.rgb.0, self.rgb.1, self.rgb.2)
     }
 }
 
-pub fn theme_fg_dimmed(rgb: (u8, u8, u8), depth: ColorDepth) -> OwoStyle {
-    rgb_to_owo((rgb.0 >> 2, rgb.1 >> 2, rgb.2 >> 2), depth)
+impl From<Styled> for OwoStyle {
+    fn from(s: Styled) -> Self {
+        let style = Self::new();
+        match s.depth {
+            ColorDepth::TrueColor => {
+                if s.on {
+                    return style.on_truecolor(s.rgb.0, s.rgb.1, s.rgb.2);
+                }
+                style.truecolor(s.rgb.0, s.rgb.1, s.rgb.2)
+            }
+            ColorDepth::Ansi256 => {
+                let ansi = XtermColors::from(ansi_colours::ansi256_from_rgb(s.as_tuple()));
+                if s.on {
+                    return style.on_color(ansi);
+                }
+                style.color(ansi)
+            }
+            ColorDepth::Ansi16 => {
+                let idx = rgb_to_ansi(s.as_tuple().into(), Palette::default()) as usize;
+                let ansi = ANSI16_TABLE.get(idx).copied().unwrap_or(AnsiColors::White);
+                if s.on {
+                    return style.on_color(ansi);
+                }
+                style.color(ansi)
+            }
+            ColorDepth::NoColor => style,
+        }
+    }
 }
diff --git a/src/color/tests.rs b/src/color/tests.rs
index b63429ac..cc6db641 100644
--- a/src/color/tests.rs
+++ b/src/color/tests.rs
@@ -1,43 +1,26 @@
-#[cfg(test)]
-mod tests {
-    use ansi_colours::ansi256_from_rgb;
-    use owo_colors::AnsiColors;
+use ansi_colours::ansi256_from_rgb;
 
-    use crate::color::mapping::rgb_to_ansi16;
-
-    #[test]
-    fn rgb256_primary_red() {
-        assert_eq!(ansi256_from_rgb((255, 0, 0)), 196);
-    }
-    #[test]
-    fn rgb256_primary_green() {
-        assert_eq!(ansi256_from_rgb((0, 255, 0)), 46);
-    }
-    #[test]
-    fn rgb256_primary_blue() {
-        assert_eq!(ansi256_from_rgb((0, 0, 255)), 21);
-    }
-    #[test]
-    fn rgb256_gray() {
-        assert_eq!(ansi256_from_rgb((128, 128, 128)), 244);
-    }
-    #[test]
-    fn rgb256_black() {
-        assert_eq!(ansi256_from_rgb((0, 0, 0)), 16);
-    }
-    #[test]
-    fn rgb256_white() {
-        assert_eq!(ansi256_from_rgb((255, 255, 255)), 231);
-    }
-
-    #[test]
-    fn rgb16_primary_red() {
-        // anstyle-lossy maps (255,0,0) → Red (not BrightRed)
-        // on both VGA and WIN10_CONSOLE palettes
-        assert_eq!(rgb_to_ansi16(255, 0, 0), AnsiColors::Red);
-    }
-    #[test]
-    fn rgb16_green() {
-        assert_eq!(rgb_to_ansi16(0, 128, 0), AnsiColors::Green);
-    }
+#[test]
+fn rgb256_primary_red() {
+    assert_eq!(ansi256_from_rgb((255, 0, 0)), 196);
+}
+#[test]
+fn rgb256_primary_green() {
+    assert_eq!(ansi256_from_rgb((0, 255, 0)), 46);
+}
+#[test]
+fn rgb256_primary_blue() {
+    assert_eq!(ansi256_from_rgb((0, 0, 255)), 21);
+}
+#[test]
+fn rgb256_gray() {
+    assert_eq!(ansi256_from_rgb((128, 128, 128)), 244);
+}
+#[test]
+fn rgb256_black() {
+    assert_eq!(ansi256_from_rgb((0, 0, 0)), 16);
+}
+#[test]
+fn rgb256_white() {
+    assert_eq!(ansi256_from_rgb((255, 255, 255)), 231);
 }
diff --git a/src/config/depth.rs b/src/config/depth.rs
deleted file mode 100644
index 68078319..00000000
--- a/src/config/depth.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use supports_color::Stream;
-
-use super::{ColorDepth, WriterTarget};
-
-pub fn detect(target: &WriterTarget) -> ColorDepth {
-    let stream = match target {
-        WriterTarget::Stdout => Stream::Stdout,
-        WriterTarget::Stderr => Stream::Stderr,
-        #[cfg(feature = "file")]
-        WriterTarget::File { .. } => return ColorDepth::NoColor,
-        #[cfg(any(feature = "custom-async", feature = "native-async"))]
-        WriterTarget::AsyncStdout(_) => Stream::Stdout,
-        #[cfg(any(feature = "custom-async", feature = "native-async"))]
-        WriterTarget::AsyncStderr(_) => Stream::Stderr,
-    };
-
-    if let Some(level) = supports_color::on_cached(stream) {
-        if level.has_16m {
-            return ColorDepth::TrueColor;
-        }
-        if level.has_256 {
-            return ColorDepth::Ansi256;
-        }
-        if level.has_basic {
-            return ColorDepth::Ansi16;
-        }
-    }
-
-    ColorDepth::NoColor
-}
-
-pub fn detect_nerd() -> bool {
-    std::env::var("NERD_FONT").is_ok_and(|v| !v.is_empty() && v != "0" && v != "false")
-}
diff --git a/src/config/mod.rs b/src/config/mod.rs
index 1b9aaeeb..5b4df8ab 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -4,10 +4,6 @@ use std::collections::HashMap;
 #[cfg(feature = "file")]
 use std::path::PathBuf;
 
-pub mod depth;
-
-pub use depth::detect;
-
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[non_exhaustive]
@@ -144,7 +140,7 @@ impl Default for Icons {
 type Rgb = (u8, u8, u8);
 
 #[derive(Clone, Copy, Debug)]
-#[non_exhaustive]
+#[allow(clippy::exhaustive_structs)]
 pub struct Theme {
     pub accent: Rgb,
     pub secondary: Rgb,
@@ -158,7 +154,7 @@ pub struct Theme {
 
 impl Theme {
     #[allow(clippy::too_many_arguments)]
-    pub const fn new(
+    const fn from_palette(
         accent: Rgb,
         secondary: Rgb,
         text: Rgb,
@@ -179,10 +175,7 @@ impl Theme {
             trace,
         }
     }
-    ///
-    /// light blue, pink, white, bright red, gold, off white
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // 让下面的颜色对齐
+    #[rustfmt::skip]
     pub const fn acta() -> Self {
         const LIGHT_BLUE:  Rgb = (91, 206, 250);  // #5BCEFA
         const PINK:        Rgb = (245, 169, 184); // #F5A9B8
@@ -190,115 +183,84 @@ impl Theme {
         const BRIGHT_RED:  Rgb = (255, 85, 85);   // #FF5555
         const GOLD:        Rgb = (255, 200, 60);  // #FFC83C
         const OFF_WHITE:   Rgb = (240, 240, 240); // #F0F0F0
-
-        Self::new(
-            LIGHT_BLUE, PINK, WHITE, BRIGHT_RED, GOLD, LIGHT_BLUE, PINK, OFF_WHITE,
-        )
+        Self::from_palette(LIGHT_BLUE, PINK, WHITE, BRIGHT_RED, GOLD, LIGHT_BLUE, PINK, OFF_WHITE)
     }
 
-    ///
-    /// cyan, pink, white, bright red, gold, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn monokai() -> Self {
-        const CYAN:       Rgb = (102, 217, 239);  // #66D9EF
-        const PINK:       Rgb = (249, 38, 114);   // #F92672
-        const WHITE:      Rgb = (248, 248, 242);  // #F8F8F2
-        const BRIGHT_RED: Rgb = (255, 85, 85);    // #FF5555
-        const GOLD:       Rgb = (255, 200, 60);   // #FFC83C
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(CYAN, PINK, WHITE, BRIGHT_RED, GOLD, CYAN, PINK, GRAY)
+        const CYAN:       Rgb = (102, 217, 239); // #66D9EF
+        const PINK:       Rgb = (249, 38, 114);  // #F92672
+        const WHITE:      Rgb = (248, 248, 242); // #F8F8F2
+        const BRIGHT_RED: Rgb = (255, 85, 85);   // #FF5555
+        const GOLD:       Rgb = (255, 200, 60);  // #FFC83C
+        const GRAY:       Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(CYAN, PINK, WHITE, BRIGHT_RED, GOLD, CYAN, PINK, GRAY)
     }
 
-    ///
-    /// cyan, pink, white, bright red, gold, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn dracula() -> Self {
-        const CYAN:       Rgb = (139, 233, 253);  // #8BE9FD
-        const PINK:       Rgb = (255, 121, 198);  // #FF79C6
-        const WHITE:      Rgb = (248, 248, 242);  // #F8F8F2
-        const BRIGHT_RED: Rgb = (255, 85, 85);    // #FF5555
-        const GOLD:       Rgb = (255, 200, 60);   // #FFC83C
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(CYAN, PINK, WHITE, BRIGHT_RED, GOLD, CYAN, PINK, GRAY)
+        const CYAN:       Rgb = (139, 233, 253); // #8BE9FD
+        const PINK:       Rgb = (255, 121, 198); // #FF79C6
+        const WHITE:      Rgb = (248, 248, 242); // #F8F8F2
+        const BRIGHT_RED: Rgb = (255, 85, 85);   // #FF5555
+        const GOLD:       Rgb = (255, 200, 60);  // #FFC83C
+        const GRAY:       Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(CYAN, PINK, WHITE, BRIGHT_RED, GOLD, CYAN, PINK, GRAY)
     }
 
-    ///
-    /// blue, green, white, red, yellow, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn nord() -> Self {
-        const BLUE:       Rgb = (136, 192, 208);  // #88C0D0
-        const GREEN:      Rgb = (163, 190, 140);  // #A3BE8C
-        const WHITE:      Rgb = (216, 222, 233);  // #D8DEE9
-        const RED:        Rgb = (191, 97, 106);   // #BF616A
-        const YELLOW:     Rgb = (235, 203, 139);  // #EBCB8B
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(BLUE, GREEN, WHITE, RED, YELLOW, BLUE, GREEN, GRAY)
+        const BLUE:   Rgb = (136, 192, 208); // #88C0D0
+        const GREEN:  Rgb = (163, 190, 140); // #A3BE8C
+        const WHITE:  Rgb = (216, 222, 233); // #D8DEE9
+        const RED:    Rgb = (191, 97, 106);  // #BF616A
+        const YELLOW: Rgb = (235, 203, 139); // #EBCB8B
+        const GRAY:   Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(BLUE, GREEN, WHITE, RED, YELLOW, BLUE, GREEN, GRAY)
     }
 
-    ///
-    /// blue, mauve, text, red, yellow, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn catppuccin_mocha() -> Self {
-        const BLUE:       Rgb = (137, 180, 250);  // #89B4FA
-        const MAUVE:      Rgb = (203, 166, 247);  // #CBA6F7
-        const TEXT:       Rgb = (205, 214, 244);  // #CDD6F4
-        const RED:        Rgb = (243, 139, 168);  // #F38BA8
-        const YELLOW:     Rgb = (249, 226, 175);  // #F9E2AF
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(BLUE, MAUVE, TEXT, RED, YELLOW, BLUE, MAUVE, GRAY)
+        const BLUE:   Rgb = (137, 180, 250); // #89B4FA
+        const MAUVE:  Rgb = (203, 166, 247); // #CBA6F7
+        const TEXT:   Rgb = (205, 214, 244); // #CDD6F4
+        const RED:    Rgb = (243, 139, 168); // #F38BA8
+        const YELLOW: Rgb = (249, 226, 175); // #F9E2AF
+        const GRAY:   Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(BLUE, MAUVE, TEXT, RED, YELLOW, BLUE, MAUVE, GRAY)
     }
 
-    ///
-    /// aqua, orange, light, red, yellow, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn gruvbox() -> Self {
-        const AQUA:       Rgb = (131, 165, 152);  // #83A598
-        const ORANGE:     Rgb = (254, 128, 25);   // #FE8019
-        const LIGHT:      Rgb = (235, 219, 178);  // #EBDBB2
-        const RED:        Rgb = (251, 73, 52);    // #FB4934
-        const YELLOW:     Rgb = (250, 189, 47);   // #FABD2F
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(AQUA, ORANGE, LIGHT, RED, YELLOW, AQUA, ORANGE, GRAY)
+        const AQUA:   Rgb = (131, 165, 152); // #83A598
+        const ORANGE: Rgb = (254, 128, 25);  // #FE8019
+        const LIGHT:  Rgb = (235, 219, 178); // #EBDBB2
+        const RED:    Rgb = (251, 73, 52);   // #FB4934
+        const YELLOW: Rgb = (250, 189, 47);  // #FABD2F
+        const GRAY:   Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(AQUA, ORANGE, LIGHT, RED, YELLOW, AQUA, ORANGE, GRAY)
     }
 
-    ///
-    /// blue, purple, white, red, yellow, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn one_dark() -> Self {
-        const BLUE:       Rgb = (97, 175, 239);   // #61AFEF
-        const PURPLE:     Rgb = (198, 120, 221);  // #C678DD
-        const WHITE:      Rgb = (171, 178, 191);  // #ABB2BF
-        const RED:        Rgb = (224, 108, 117);  // #E06C75
-        const YELLOW:     Rgb = (229, 192, 123);  // #E5C07B
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(BLUE, PURPLE, WHITE, RED, YELLOW, BLUE, PURPLE, GRAY)
+        const BLUE:   Rgb = (97, 175, 239);  // #61AFEF
+        const PURPLE: Rgb = (198, 120, 221); // #C678DD
+        const WHITE:  Rgb = (171, 178, 191); // #ABB2BF
+        const RED:    Rgb = (224, 108, 117); // #E06C75
+        const YELLOW: Rgb = (229, 192, 123); // #E5C07B
+        const GRAY:   Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(BLUE, PURPLE, WHITE, RED, YELLOW, BLUE, PURPLE, GRAY)
     }
 
-    ///
-    /// blue, purple, white, red, yellow, gray
-    /// with some dimmed for terminal readability.
-    #[rustfmt::skip] // ↑
+    #[rustfmt::skip]
     pub const fn tokyo_night() -> Self {
-        const BLUE:       Rgb = (122, 162, 247);  // #7AA2F7
-        const PURPLE:     Rgb = (187, 154, 247);  // #BB9AF7
-        const WHITE:      Rgb = (192, 202, 245);  // #C0CAF5
-        const RED:        Rgb = (247, 118, 142);  // #F7768E
-        const YELLOW:     Rgb = (224, 175, 104);  // #E0AF68
-        const GRAY:       Rgb = (180, 180, 180);  // #B4B4B4
-
-        Self::new(BLUE, PURPLE, WHITE, RED, YELLOW, BLUE, PURPLE, GRAY)
+        const BLUE:   Rgb = (122, 162, 247); // #7AA2F7
+        const PURPLE: Rgb = (187, 154, 247); // #BB9AF7
+        const WHITE:  Rgb = (192, 202, 245); // #C0CAF5
+        const RED:    Rgb = (247, 118, 142); // #F7768E
+        const YELLOW: Rgb = (224, 175, 104); // #E0AF68
+        const GRAY:   Rgb = (180, 180, 180); // #B4B4B4
+        Self::from_palette(BLUE, PURPLE, WHITE, RED, YELLOW, BLUE, PURPLE, GRAY)
     }
 }
 
@@ -418,7 +380,12 @@ pub enum Rotation {
     Compress,
 }
 
-#[derive(Clone, Debug)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(rename_all = "lowercase")
+)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Level {
     Error,
@@ -427,11 +394,10 @@ pub enum Level {
     Debug,
     Trace,
     Off,
-    Custom(String),
 }
 
 impl Level {
-    pub const fn as_directive(&self) -> &str {
+    pub const fn as_directive(self) -> &'static str {
         match self {
             Self::Error => "error",
             Self::Warn => "warn",
@@ -439,50 +405,51 @@ impl Level {
             Self::Debug => "debug",
             Self::Trace => "trace",
             Self::Off => "off",
-            Self::Custom(s) => s.as_str(),
-        }
-    }
-
-    pub fn parse_str(s: &str) -> Self {
-        match s {
-            "error" => Self::Error,
-            "warn" => Self::Warn,
-            "info" => Self::Info,
-            "debug" => Self::Debug,
-            "trace" => Self::Trace,
-            "off" => Self::Off,
-            other => Self::Custom(other.to_owned()),
         }
     }
 }
 
+/// Tracing filter directive.
+///
+/// Built either from a `Level` (structured) or a raw `EnvFilter`-compatible
+/// directive string. Per-target overrides added via [`with_target`] are
+/// appended after the base; [`remove_target`] only removes entries that were
+/// added structurally — entries embedded in a raw base string cannot be
+/// removed without rebuilding the filter.
+///
+/// [`with_target`]: Filter::with_target
+/// [`remove_target`]: Filter::remove_target
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Debug)]
 #[non_exhaustive]
 pub struct Filter {
-    level: Level,
-
+    base: compact_str::CompactString,
     targets: HashMap<compact_str::CompactString, Level>,
 }
 
 impl Filter {
-    pub fn new(level: impl Into<Level>) -> Self {
+    pub fn new(level: Level) -> Self {
         Self {
-            level: level.into(),
+            base: level.as_directive().into(),
             targets: HashMap::new(),
         }
     }
 
-    pub const fn level(&self) -> &Level {
-        &self.level
+    /// Build a `Filter` from a raw `EnvFilter`-style directive string,
+    /// e.g. `"info,my_crate=debug,my_crate::db=trace"`.
+    pub fn from_directive(directive: impl Into<compact_str::CompactString>) -> Self {
+        Self {
+            base: directive.into(),
+            targets: HashMap::new(),
+        }
     }
 
     pub fn with_target(
         &mut self,
         target: impl Into<compact_str::CompactString>,
-        level: impl Into<Level>,
+        level: Level,
     ) -> &mut Self {
-        self.targets.insert(target.into(), level.into());
+        self.targets.insert(target.into(), level);
         self
     }
 
@@ -491,7 +458,7 @@ impl Filter {
     }
 
     pub fn as_directive(&self) -> String {
-        let mut directive = String::from(self.level.as_directive());
+        let mut directive = String::from(self.base.as_str());
         for (target, level) in &self.targets {
             directive.push(',');
             directive.push_str(target);
@@ -502,24 +469,15 @@ impl Filter {
     }
 }
 
-impl From<Level> for Filter {
-    fn from(level: Level) -> Self {
-        Self::new(level)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for Level {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(self.as_directive())
+impl Default for Filter {
+    fn default() -> Self {
+        Self::new(Level::Info)
     }
 }
 
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for Level {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let s = String::deserialize(deserializer)?;
-        Ok(Self::parse_str(&s))
+impl From<Level> for Filter {
+    fn from(level: Level) -> Self {
+        Self::new(level)
     }
 }
 
@@ -610,7 +568,8 @@ impl Default for Writer {
 #[derive(Clone, Debug)]
 #[non_exhaustive]
 pub struct Config {
-    pub level: Level,
+    #[cfg_attr(feature = "serde", serde(default))]
+    pub filter: Filter,
     #[cfg_attr(feature = "serde", serde(default))]
     pub writers: Vec<Writer>,
 }
@@ -624,7 +583,7 @@ impl Config {
 impl Default for Config {
     fn default() -> Self {
         Self {
-            level: Level::Info,
+            filter: Filter::default(),
             writers: vec![Writer::default()],
         }
     }
@@ -634,13 +593,20 @@ impl Default for Config {
 #[must_use]
 #[allow(clippy::module_name_repetitions)]
 pub struct ConfigBuilder {
-    level: Option<Level>,
+    filter: Option<Filter>,
     writers: Vec<Writer>,
 }
 
 impl ConfigBuilder {
-    pub fn level(mut self, level: impl Into<Level>) -> Self {
-        self.level = Some(level.into());
+    /// Convenience: set the filter to a single level.
+    pub fn level(mut self, level: Level) -> Self {
+        self.filter = Some(Filter::new(level));
+        self
+    }
+
+    /// Set the full filter (for raw directives or pre-built filters).
+    pub fn filter(mut self, filter: Filter) -> Self {
+        self.filter = Some(filter);
         self
     }
 
@@ -652,7 +618,7 @@ impl ConfigBuilder {
     pub fn build(self) -> Config {
         let defaults = Config::default();
         Config {
-            level: self.level.unwrap_or(defaults.level),
+            filter: self.filter.unwrap_or(defaults.filter),
             writers: if self.writers.is_empty() {
                 defaults.writers
             } else {
diff --git a/src/config/test.rs b/src/config/test.rs
index 169475d0..870f1b2f 100644
--- a/src/config/test.rs
+++ b/src/config/test.rs
@@ -1,9 +1,11 @@
+#![allow(clippy::indexing_slicing)]
+
 use super::*;
 
 #[test]
 fn config_default() {
     let config = Config::default();
-    assert!(matches!(config.level, Level::Info));
+    assert_eq!(config.filter.as_directive(), "info");
     assert_eq!(config.writers.len(), 1);
     let w = &config.writers[0];
     assert!(matches!(w.format, Format::Compact(_)));
@@ -29,10 +31,18 @@ fn config_builder() {
         .level(Level::Debug)
         .with_writer(Writer::default())
         .build();
-    assert_eq!(cfg.level.as_directive(), "debug");
+    assert_eq!(cfg.filter.as_directive(), "debug");
     assert_eq!(cfg.writers.len(), 1);
 }
 
+#[test]
+fn config_builder_filter() {
+    let cfg = Config::builder()
+        .filter(Filter::from_directive("info,my_crate=debug"))
+        .build();
+    assert_eq!(cfg.filter.as_directive(), "info,my_crate=debug");
+}
+
 #[test]
 fn config_builder_multiple_writers() {
     let cfg = Config::builder()
@@ -60,9 +70,18 @@ fn level_directives() {
 }
 
 #[test]
-fn level_custom_directive() {
-    let level = Level::Custom("info,my_crate=debug".into());
-    assert_eq!(level.as_directive(), "info,my_crate=debug");
+fn filter_from_directive() {
+    let f = Filter::from_directive("info,my_crate=debug");
+    assert_eq!(f.as_directive(), "info,my_crate=debug");
+}
+
+#[test]
+fn filter_from_directive_with_extra_target() {
+    let mut f = Filter::from_directive("info,bar=warn");
+    f.with_target("foo", Level::Trace);
+    let directive = f.as_directive();
+    assert!(directive.starts_with("info,bar=warn"));
+    assert!(directive.contains("foo=trace"));
 }
 
 #[test]
@@ -122,6 +141,12 @@ fn filter_from_level_debug() {
     assert_eq!(filter.as_directive(), "debug");
 }
 
+#[test]
+fn filter_default_is_info() {
+    let filter = Filter::default();
+    assert_eq!(filter.as_directive(), "info");
+}
+
 #[test]
 #[cfg(feature = "file")]
 fn writer_file_target() {
diff --git a/src/fmt/mod.rs b/src/fmt/mod.rs
index e365b05d..f2eb86e7 100644
--- a/src/fmt/mod.rs
+++ b/src/fmt/mod.rs
@@ -1,13 +1,12 @@
-use crate::color::style::{rgb_to_owo, rgb_to_owo_on, theme_fg_dimmed};
+use crate::color::Styled;
 use crate::config::ColorDepth;
 use crate::config::{Icons, LevelLabels, Style, Theme};
-use arrayvec::ArrayString;
 use chrono::Utc;
+use owo_colors::Rgb;
 use owo_colors::Style as OwoStyle;
 use smallvec::SmallVec;
 
 use std::fmt;
-use std::fmt::Write;
 use std::sync::Arc;
 
 use tracing::{Event, Level, Subscriber};
@@ -19,16 +18,7 @@ use tracing_subscriber::registry::LookupSpan;
 mod visitor;
 use visitor::EventVisitor;
 
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct LevelStyles {
-    bracket_fg: OwoStyle,
-    bracket_bg: OwoStyle,
-    label: OwoStyle,
-}
-
-const BUILD_PATH_WIDTH: usize = include!(concat!(env!("OUT_DIR"), "/path_width"));
-
-const PATH_BUF_SIZE: usize = 256;
+const DEFAULT_PATH_WIDTH: usize = include!(concat!(env!("OUT_DIR"), "/path_width"));
 
 #[derive(Debug, Clone)]
 #[non_exhaustive]
@@ -52,7 +42,7 @@ impl Formatter {
     pub fn new() -> Self {
         Self {
             time_format: String::from("%H:%M:%S"),
-            path_width: BUILD_PATH_WIDTH,
+            path_width: DEFAULT_PATH_WIDTH,
             show_path: true,
             show_spans: true,
             style: Arc::new(arc_swap::ArcSwap::new(Arc::new(Style::default()))),
@@ -68,7 +58,7 @@ impl Formatter {
     pub fn new_with_handle(style: Arc<arc_swap::ArcSwap<Style>>) -> Self {
         Self {
             time_format: String::from("%H:%M:%S"),
-            path_width: BUILD_PATH_WIDTH,
+            path_width: DEFAULT_PATH_WIDTH,
             show_path: true,
             show_spans: true,
             style,
@@ -82,14 +72,6 @@ impl Formatter {
         **self.style.load()
     }
 
-    /// Returns a clone of the internal style handle for sharing with TracingGuard.
-    /// When TracingGuard modifies the handle (via `with_style`), all Formatters
-    /// sharing this handle will see the update on the next format_event call.
-    #[must_use]
-    pub fn style_handle(&self) -> Arc<arc_swap::ArcSwap<Style>> {
-        self.style.clone()
-    }
-
     #[must_use]
     pub fn with_style_config(self, new_style: Style) -> Self {
         self.style.store(Arc::new(new_style));
@@ -150,57 +132,51 @@ impl Formatter {
         self
     }
 
-    pub(crate) fn format_path(&self, file: &str, line: u32) -> ArrayString<PATH_BUF_SIZE> {
-        let path_start = file.find("src/").or_else(|| file.find("src\\"));
-        let path = path_start.map_or(file, |i| file.get(i.saturating_add(4)..).unwrap_or(file));
+    pub(crate) fn format_path(&self, file: &str, line: u32) -> String {
+        let max_width = self.path_width;
 
-        let mut norm_path = ArrayString::<PATH_BUF_SIZE>::new();
-        for c in path.chars() {
-            if norm_path.len() < norm_path.capacity() {
-                let replaced = if c == '\\' { '/' } else { c };
-                norm_path.push(replaced);
-            }
-        }
-        let path_str = norm_path.as_str();
+        let relative = file
+            .split_once("src/")
+            .map(|(_, tail)| tail)
+            .or_else(|| file.split_once("src\\").map(|(_, tail)| tail))
+            .unwrap_or(file);
 
-        let max_width = self.path_width;
-        let mut full = ArrayString::<PATH_BUF_SIZE>::new();
-        let _ = write!(full, "{path_str}:{line}");
+        let path_str = relative.replace('\\', "/");
 
+        let full = format!("{path_str}:{line}");
         if full.len() <= max_width {
-            let mut result = ArrayString::<PATH_BUF_SIZE>::new();
-            write!(result, "{full:>max_width$}").ok();
-            return result;
+            return format!("{full:>max_width$}");
         }
 
         if let Some(last_slash) = path_str.rfind('/') {
-            let tail = path_str
-                .get(last_slash.saturating_add(1)..)
-                .unwrap_or(path_str);
-            let mut file_part = ArrayString::<PATH_BUF_SIZE>::new();
-            let _ = write!(file_part, "{tail}:{line}");
-
-            if file_part.len().saturating_add(2) <= max_width {
-                let dir_part = path_str.get(..last_slash).unwrap_or("");
-                let dir_start = dir_part
-                    .len()
-                    .saturating_sub(max_width.saturating_sub(file_part.len()).saturating_sub(1));
-                let dir_tail = dir_part.get(dir_start..).unwrap_or("");
-                let clean_dir = dir_tail.find('/').map_or(dir_tail, |i| {
-                    dir_tail.get(i.saturating_add(1)..).unwrap_or(dir_tail)
-                });
-
-                let mut result = ArrayString::<PATH_BUF_SIZE>::new();
-                let _ = write!(result, "{clean_dir}/{file_part}");
-                return result;
+            let filename = &path_str[last_slash + 1..];
+            let file_with_line = format!("{filename}:{line}");
+
+            if file_with_line.len() + 2 <= max_width {
+                let dir_part = &path_str[..last_slash];
+                let remaining = max_width.saturating_sub(file_with_line.len() + 1);
+                let start = dir_part.len().saturating_sub(remaining);
+                let mut adj = start;
+                while adj < dir_part.len() && !dir_part.is_char_boundary(adj) {
+                    adj += 1;
+                }
+                let dir_tail = &dir_part[adj..];
+                let clean_dir = dir_tail
+                    .rfind('/')
+                    .map_or(dir_tail, |i| &dir_tail[i + 1..]);
+
+                let formatted = format!("{clean_dir}/{file_with_line}");
+                return format!("{formatted:>max_width$}");
             }
         }
 
+        // Truncate from left with ellipsis, guarding char boundaries
         let start = full.len().saturating_sub(max_width.saturating_sub(1));
-        let mut result = ArrayString::<PATH_BUF_SIZE>::new();
-        result.push('\u{2026}');
-        result.push_str(full.get(start..).unwrap_or(""));
-        result
+        let mut adj = start;
+        while adj < full.len() && !full.is_char_boundary(adj) {
+            adj += 1;
+        }
+        format!("\u{2026}{}", &full[adj..])
     }
 
     fn write_time(&self, writer: &mut Writer<'_>, theme: &Theme) -> fmt::Result {
@@ -208,7 +184,11 @@ impl Formatter {
         write!(
             writer,
             "{}",
-            rgb_to_owo(theme.text, self.color_depth).style(now.format(&self.time_format))
+            OwoStyle::from(Styled::new(
+                Rgb(theme.text.0, theme.text.1, theme.text.2),
+                self.color_depth
+            ))
+            .style(now.format(&self.time_format))
         )
     }
 
@@ -222,7 +202,14 @@ impl Formatter {
         write!(
             writer,
             "{}",
-            theme_fg_dimmed(theme.text, self.color_depth).style(self.format_path(
+            OwoStyle::from(
+                Styled::new(
+                    Rgb(theme.text.0, theme.text.1, theme.text.2),
+                    self.color_depth
+                )
+                .dimmed()
+            )
+            .style(self.format_path(
                 event.metadata().file().unwrap_or("?"),
                 event.metadata().line().unwrap_or(0),
             ))
@@ -230,7 +217,11 @@ impl Formatter {
         write!(
             writer,
             " {} ",
-            rgb_to_owo(theme.accent, self.color_depth).style(icons.arrow)
+            OwoStyle::from(Styled::new(
+                Rgb(theme.accent.0, theme.accent.1, theme.accent.2),
+                self.color_depth
+            ))
+            .style(icons.arrow)
         )?;
         Ok(())
     }
@@ -248,7 +239,11 @@ impl Formatter {
             write!(
                 writer,
                 "{}",
-                rgb_to_owo(theme.text, self.color_depth).style(msg)
+                OwoStyle::from(Styled::new(
+                    Rgb(theme.text.0, theme.text.1, theme.text.2),
+                    self.color_depth
+                ))
+                .style(msg)
             )?;
             " "
         } else {
@@ -260,9 +255,21 @@ impl Formatter {
                 writer,
                 "{}{}{}{}",
                 sep,
-                rgb_to_owo(theme.secondary, self.color_depth).style(k),
-                rgb_to_owo(theme.accent, self.color_depth).style("="),
-                rgb_to_owo(theme.text, self.color_depth).style(v)
+                OwoStyle::from(Styled::new(
+                    Rgb(theme.secondary.0, theme.secondary.1, theme.secondary.2),
+                    self.color_depth
+                ))
+                .style(k),
+                OwoStyle::from(Styled::new(
+                    Rgb(theme.accent.0, theme.accent.1, theme.accent.2),
+                    self.color_depth
+                ))
+                .style("="),
+                OwoStyle::from(Styled::new(
+                    Rgb(theme.text.0, theme.text.1, theme.text.2),
+                    self.color_depth
+                ))
+                .style(v)
             )?;
             sep = " ";
         }
@@ -294,10 +301,28 @@ impl Formatter {
         }
 
         let total = spans.len();
-        let accent = rgb_to_owo(theme.accent, self.color_depth);
-        let accent_dimmed = theme_fg_dimmed(theme.accent, self.color_depth);
-        let text = rgb_to_owo(theme.text, self.color_depth);
-        let text_dimmed = theme_fg_dimmed(theme.text, self.color_depth);
+        let accent = OwoStyle::from(Styled::new(
+            Rgb(theme.accent.0, theme.accent.1, theme.accent.2),
+            self.color_depth,
+        ));
+        let accent_dimmed = OwoStyle::from(
+            Styled::new(
+                Rgb(theme.accent.0, theme.accent.1, theme.accent.2),
+                self.color_depth,
+            )
+            .dimmed(),
+        );
+        let text = OwoStyle::from(Styled::new(
+            Rgb(theme.text.0, theme.text.1, theme.text.2),
+            self.color_depth,
+        ));
+        let text_dimmed = OwoStyle::from(
+            Styled::new(
+                Rgb(theme.text.0, theme.text.1, theme.text.2),
+                self.color_depth,
+            )
+            .dimmed(),
+        );
 
         write!(writer, " {}", accent.style("["))?;
 
@@ -346,44 +371,67 @@ where
             Level::TRACE => (config.theme.trace, config.labels.trace),
         };
 
-        let ls = {
-            let r = color.0;
-            let g = color.1;
-            let b = color.2;
-            let depth = self.color_depth;
-            LevelStyles {
-                bracket_fg: rgb_to_owo((r, g, b), depth),
-                bracket_bg: rgb_to_owo_on(r, g, b, depth),
-                label: rgb_to_owo_on(r, g, b, depth),
-            }
-        };
+        let level_rgb = Rgb(color.0, color.1, color.2);
+        let fg_only = OwoStyle::from(Styled::new(level_rgb, self.color_depth));
+        let on_bg = OwoStyle::from(Styled::new(level_rgb, self.color_depth).on());
 
-        let fg_style = match config.icons.name {
-            "nerd" => ls.bracket_fg,
-            _ => ls.bracket_bg,
+        let bracket_style = if config.icons.name == "nerd" {
+            fg_only
+        } else {
+            on_bg
         };
 
         write!(
             writer,
             "{}",
-            rgb_to_owo(config.theme.accent, self.color_depth).style(config.icons.time_bracket_open)
+            OwoStyle::from(Styled::new(
+                Rgb(
+                    config.theme.accent.0,
+                    config.theme.accent.1,
+                    config.theme.accent.2
+                ),
+                self.color_depth
+            ))
+            .style(config.icons.time_bracket_open)
         )?;
         self.write_time(&mut writer, &config.theme)?;
         write!(
             writer,
             " {} ",
-            theme_fg_dimmed(config.theme.accent, self.color_depth).style(config.icons.separator)
+            OwoStyle::from(
+                Styled::new(
+                    Rgb(
+                        config.theme.accent.0,
+                        config.theme.accent.1,
+                        config.theme.accent.2
+                    ),
+                    self.color_depth
+                )
+                .dimmed()
+            )
+            .style(config.icons.separator)
         )?;
 
-        write!(writer, "{}", fg_style.style(config.icons.bracket_open))?;
-        write!(writer, "{}", ls.label.style(level_label))?;
-        write!(writer, "{} ", fg_style.style(config.icons.bracket_close))?;
+        write!(writer, "{}", bracket_style.style(config.icons.bracket_open))?;
+        write!(writer, "{}", on_bg.style(level_label))?;
+        write!(
+            writer,
+            "{} ",
+            bracket_style.style(config.icons.bracket_close)
+        )?;
 
         write!(
             writer,
             "{} ",
-            rgb_to_owo(config.theme.accent, self.color_depth)
-                .style(config.icons.time_bracket_close)
+            OwoStyle::from(Styled::new(
+                Rgb(
+                    config.theme.accent.0,
+                    config.theme.accent.1,
+                    config.theme.accent.2
+                ),
+                self.color_depth
+            ))
+            .style(config.icons.time_bracket_close)
         )?;
 
         if self.show_path {
diff --git a/src/fmt/test.rs b/src/fmt/test.rs
index b2d83846..39b06175 100644
--- a/src/fmt/test.rs
+++ b/src/fmt/test.rs
@@ -6,7 +6,7 @@ use smallvec::SmallVec;
 fn formatter_defaults() {
     let fmt = Formatter::new();
     assert_eq!(fmt.time_format, "%H:%M:%S");
-    assert_eq!(fmt.path_width, BUILD_PATH_WIDTH);
+    assert_eq!(fmt.path_width, DEFAULT_PATH_WIDTH);
     assert!(fmt.show_path);
     assert!(fmt.show_spans);
 }
@@ -112,6 +112,71 @@ fn format_path_strips_src() {
     assert!(!result.contains("src/"));
 }
 
+#[test]
+fn format_path_right_aligned_no_truncation() {
+    let mut fmt = Formatter::new();
+    fmt.path_width = 40;
+    let result = fmt.format_path("src/lib.rs", 10);
+    assert!(!result.contains('\u{2026}'), "expected no ellipsis: {result}");
+    assert_eq!(result.len(), 40);
+    assert!(result.ends_with("lib.rs:10"), "expected to end with stripped path: {result}");
+}
+
+#[test]
+fn format_path_dir_truncation_preserves_filename() {
+    let mut fmt = Formatter::new();
+    fmt.path_width = 28;
+    let result = fmt.format_path("very/long/deeply/nested/dir/file.rs", 42);
+    assert!(result.contains("file.rs:42"), "expected filename preserved: {result}");
+    assert!(!result.contains('\u{2026}'), "expected no leading ellipsis in dir truncation: {result}");
+    assert!(result.len() <= 28);
+}
+
+#[test]
+fn format_path_windows_normalization() {
+    let mut fmt = Formatter::new();
+    fmt.path_width = 40;
+    let result = fmt.format_path(r"C:\project\src\module\file.rs", 7);
+    assert!(!result.contains('\\'), "expected backslashes normalized: {result}");
+    assert!(result.contains("module/file.rs:7"), "expected normalized src path: {result}");
+}
+
+#[test]
+fn format_path_leading_ellipsis_for_very_long_path() {
+    let mut fmt = Formatter::new();
+    // Narrow enough that file_with_line alone exceeds width,
+    // forcing the leading-ellipsis fallback branch.
+    fmt.path_width = 11;
+    let result = fmt.format_path("/very/long/prefix/deep/nested/dirs/file.rs", 99);
+    assert!(result.starts_with('\u{2026}'), "expected leading ellipsis: {result}");
+    assert!(result.contains("file.rs:99"), "expected filename preserved: {result}");
+}
+
+#[test]
+fn format_path_file_with_line_branch_no_ellipsis() {
+    let mut fmt = Formatter::new();
+    fmt.path_width = 16;
+    let result = fmt.format_path("src/main.rs", 1);
+    assert!(result.contains("main.rs:1"), "expected stripped path: {result}");
+    assert!(!result.contains('\u{2026}'));
+    assert_eq!(result.len(), 16);
+}
+
+#[test]
+fn format_path_unicode_char_boundary_safe() {
+    let mut fmt = Formatter::new();
+    // Multi-byte Chinese characters: 模块 (6 bytes) + 文件 (6 bytes)
+    // Narrow width forces truncation exercising char-boundary adjustment
+    fmt.path_width = 12;
+    let result = fmt.format_path("src/模块/文件.rs", 10);
+    // Must be valid UTF-8 (no split multi-byte characters)
+    assert!(std::str::from_utf8(result.as_bytes()).is_ok());
+    // Char-boundary adjustment may skip leading bytes of a multi-byte char,
+    // but preserves the suffix after the boundary.
+    assert!(result.contains("件.rs:10") || result.contains("文件.rs:10"),
+        "expected filename suffix preserved: {result}");
+}
+
 #[test]
 fn formatter_style_config_returns_reference() {
     let fmt = Formatter::new();
diff --git a/src/lib.rs b/src/lib.rs
index 32ad7d37..cff70b45 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -11,17 +11,19 @@ pub mod prelude;
 #[cfg(any(feature = "file", feature = "custom-async", feature = "native-async"))]
 pub mod writer;
 
-pub use builder::TracingGuard;
-pub use config::{ColorDepth, Icons, LevelLabels, Style, Theme};
+pub use builder::{TracingGuard, build_layer, init};
+pub use config::{
+    ColorDepth, Config, Filter, Format, Icons, LayerConfig, Level, LevelLabels, Rotation, Style,
+    Theme, Writer, WriterTarget,
+};
 pub use fmt::Formatter;
 
-pub use color::rgb_to_ansi16;
 pub use tracing::{
     debug, debug_span, error, error_span, info, info_span, trace, trace_span, warn, warn_span,
 };
 
 #[cfg(feature = "custom-async")]
-pub use writer::{AsyncWriter, async_writer, async_writer_for};
+pub use writer::{AsyncWriter, async_writer_for};
 
 #[cfg(any(feature = "custom-async", feature = "native-async"))]
 pub use config::AsyncMode;
@@ -29,8 +31,6 @@ pub use config::AsyncMode;
 #[cfg(any(feature = "custom-async", feature = "native-async"))]
 pub use writer::AsyncWriterTarget;
 
-pub use config::{Config, Filter, Format, LayerConfig, Level, Rotation, Writer, WriterTarget};
-
 #[cfg(feature = "file")]
 pub use crate::writer::{LogHandle, resolve_log_path, rotate_log_file};
 
@@ -51,9 +51,5 @@ pub enum ActaError {
 
 pub type Result<T> = std::result::Result<T, ActaError>;
 
-pub use crate::builder::{SubscriberParts, build_layer, build_reload_filter, build_subscriber};
-
-pub use crate::builder::init;
-
 #[cfg(test)]
 mod test;
diff --git a/src/prelude.rs b/src/prelude.rs
index d0621479..808d9dd8 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -1,15 +1,15 @@
-pub use crate::TracingGuard;
-pub use crate::builder::init;
-pub use crate::builder::{build_layer, build_reload_filter, build_subscriber};
+pub use crate::builder::{TracingGuard, init};
 #[cfg(any(feature = "custom-async", feature = "native-async"))]
 pub use crate::config::AsyncMode;
-pub use crate::config::{Config, Icons, LevelLabels, Style, Theme, Writer, WriterTarget};
-pub use crate::config::{Filter, Format, LayerConfig, Level, Rotation};
+pub use crate::config::{
+    Config, Filter, Format, Icons, LayerConfig, Level, LevelLabels, Rotation, Style, Theme, Writer,
+    WriterTarget,
+};
 pub use crate::fmt::Formatter;
 #[cfg(any(feature = "custom-async", feature = "native-async"))]
 pub use crate::writer::AsyncWriterTarget;
 #[cfg(feature = "custom-async")]
-pub use crate::writer::{AsyncWriter, async_writer, async_writer_for};
+pub use crate::writer::{AsyncWriter, async_writer_for};
 pub use crate::{ActaError, Result};
 pub use tracing::{
     debug, debug_span, error, error_span, info, info_span, trace, trace_span, warn, warn_span,
diff --git a/src/test.rs b/src/test.rs
index aad50dd3..d36ea06c 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -1,62 +1,45 @@
+#![allow(clippy::unwrap_used)]
+
 use std::io;
+use std::sync::Arc;
 
 use super::*;
+use crate::builder::{BoxedLayer, Layers, ReloadHandle, build_layer};
 use crate::config::LayerConfig;
+use tracing_subscriber::Registry;
 use tracing_subscriber::layer::Layered;
 use tracing_subscriber::prelude::*;
 
-pub(crate) type SubscriberWithBoth = Layered<
+type TestSubscriber = Layered<
     tracing_subscriber::reload::Layer<tracing_subscriber::EnvFilter, builder::InnerSubscriber>,
     builder::InnerSubscriber,
 >;
 
-pub(crate) fn build_reload_filter(
-    level: Level,
-    style: Style,
-) -> (
-    tracing_subscriber::reload::Layer<builder::FmtLayer, tracing_subscriber::Registry>,
-    TracingGuard,
-    SubscriberWithBoth,
-) {
-    let stdout_layer = Some(
+fn build_test_guard(level: Level, style: Style) -> (TracingGuard, TestSubscriber) {
+    let filter = Filter::new(level);
+    let env_filter =
+        tracing_subscriber::EnvFilter::try_new(filter.as_directive()).unwrap_or_default();
+    let (env_layer, raw): (_, ReloadHandle) = tracing_subscriber::reload::Layer::new(env_filter);
+
+    let layers: Vec<BoxedLayer> = vec![
         tracing_subscriber::fmt::Layer::default()
             .with_writer(io::sink)
             .boxed(),
-    );
-    let stderr_layer = None;
-    let async_stdout_layer = None;
-    let async_stderr_layer = None;
-    let file_layer = None;
-
-    let inner_subscriber = tracing_subscriber::Registry::default()
-        .with(stdout_layer)
-        .with(stderr_layer)
-        .with(async_stdout_layer)
-        .with(async_stderr_layer)
-        .with(file_layer);
+    ];
 
-    let filter = Filter::new(level);
-    let env_filter =
-        tracing_subscriber::EnvFilter::try_new(filter.as_directive()).unwrap_or_default();
-    let (env_layer, env_handle) = tracing_subscriber::reload::Layer::new(env_filter);
-    let subscriber = inner_subscriber.with(env_layer);
+    let subscriber = Registry::default().with(Layers(layers)).with(env_layer);
 
-    let shared_state = std::sync::Arc::new(arc_swap::ArcSwap::new(std::sync::Arc::new(style)));
-    let reload_handle = TracingGuard {
-        raw: builder::ReloadHandle(env_handle),
+    let guard = TracingGuard {
+        raw,
         filter,
-        style: shared_state,
+        style: Arc::new(arc_swap::ArcSwap::new(Arc::new(style))),
         #[cfg(feature = "file")]
         worker_guard: None,
         #[cfg(feature = "file")]
         log_path: None,
     };
 
-    let console_layer = tracing_subscriber::fmt::Layer::default()
-        .with_writer(io::sink)
-        .boxed();
-    let (layer, _) = tracing_subscriber::reload::Layer::new(console_layer);
-    (layer, reload_handle, subscriber)
+    (guard, subscriber)
 }
 
 #[test]
@@ -80,7 +63,7 @@ fn build_layer_all_variants() {
                 style: Style::default(),
                 target: target.clone(),
             };
-            let _layer = build_layer::<tracing_subscriber::Registry>(&w);
+            let _layer = build_layer(&w);
         }
     }
 }
@@ -91,7 +74,7 @@ fn build_layer_no_ansi() {
         ansi: false,
         ..Default::default()
     };
-    let _layer = build_layer::<tracing_subscriber::Registry>(&w);
+    let _layer = build_layer(&w);
 }
 
 #[test]
@@ -100,20 +83,19 @@ fn build_layer_custom_time() {
         time_format: Some(String::from("%Y/%m/%d")),
         ..Default::default()
     };
-    let _layer = build_layer::<tracing_subscriber::Registry>(&w);
+    let _layer = build_layer(&w);
 }
 
 #[cfg(feature = "nerd")]
 #[test]
 fn build_layer_with_nerd_icons() {
     let w = Writer::default();
-    let _layer = build_layer::<tracing_subscriber::Registry>(&w);
+    let _layer = build_layer(&w);
 }
 
 #[test]
 fn reload_handle_with_style_config() {
-    let style = Style::default();
-    let (_layer, mut handle, _subscriber) = build_reload_filter(Level::Info, style);
+    let (mut handle, _sub) = build_test_guard(Level::Info, Style::default());
     handle.with_style(|s| s.theme = Theme::dracula());
     handle.with_style(|s| s.icons = Icons::UNICODE);
     handle.with_style(|s| s.labels = LevelLabels::SHORT);
@@ -121,14 +103,14 @@ fn reload_handle_with_style_config() {
 
 #[test]
 fn reload_handle_set_target_level_accepts_string() {
-    let (_layer, mut handle, _subscriber) = build_reload_filter(Level::Info, Style::default());
+    let (mut handle, _sub) = build_test_guard(Level::Info, Style::default());
     let target = String::from("my_crate");
     assert!(handle.set_target_level(target, Level::Trace).is_ok());
 }
 
 #[test]
 fn reload_handle_remove_nonexistent_target_level() {
-    let (_layer, mut handle, _subscriber) = build_reload_filter(Level::Info, Style::default());
+    let (mut handle, _sub) = build_test_guard(Level::Info, Style::default());
     assert!(handle.remove_target_level("nonexistent_crate").is_ok());
 }
 
@@ -151,3 +133,57 @@ fn acta_error_from_io_error() {
     let error: ActaError = io_err.into();
     assert!(matches!(error, ActaError::Io(_)));
 }
+
+#[test]
+fn set_filter_with_raw_directive_updates_guard() {
+    let (mut guard, _subscriber) = build_test_guard(Level::Info, Style::default());
+    let filter = Filter::from_directive("info,my_crate=debug");
+    guard
+        .set_filter(filter)
+        .expect("set_filter with raw directive should succeed");
+    assert_eq!(
+        guard.filter.as_directive(),
+        "info,my_crate=debug",
+        "guard.filter should reflect the raw directive applied via set_filter"
+    );
+}
+
+#[test]
+fn set_level_after_filter_replaces_with_simple_level_directive() {
+    let (mut guard, _subscriber) = build_test_guard(Level::Info, Style::default());
+    guard
+        .set_filter(Filter::from_directive("info,my_crate=debug"))
+        .expect("set_filter should succeed");
+    guard
+        .set_level(Level::Warn)
+        .expect("set_level(Level::Warn) should succeed");
+    assert_eq!(
+        guard.filter.as_directive(),
+        "warn",
+        "set_level should replace the filter with a simple level directive"
+    );
+}
+
+#[test]
+fn set_target_level_after_raw_directive_adds_per_target_override() {
+    let (mut guard, _subscriber) = build_test_guard(Level::Info, Style::default());
+    guard
+        .set_filter(Filter::from_directive("info,my_crate=debug"))
+        .expect("initial set_filter should succeed");
+    guard
+        .set_target_level("demo", Level::Trace)
+        .expect("set_target_level should succeed after set_filter");
+    let directive = guard.filter.as_directive();
+    assert!(
+        directive.contains("info"),
+        "directive should still include base level after set_target_level: {directive}"
+    );
+    assert!(
+        directive.contains("my_crate=debug"),
+        "directive should retain existing per-target override after set_target_level: {directive}"
+    );
+    assert!(
+        directive.contains("demo=trace"),
+        "directive should include the new per-target override: {directive}"
+    );
+}
diff --git a/src/writer/custom.rs b/src/writer/custom.rs
index 44be7bf1..c49df4f3 100644
--- a/src/writer/custom.rs
+++ b/src/writer/custom.rs
@@ -1,6 +1,4 @@
 use std::io::Write;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use tokio::io::{AsyncWrite, AsyncWriteExt, stderr, stdout};
 use tokio::sync::mpsc;
 use tracing_subscriber::fmt::MakeWriter;
@@ -10,35 +8,23 @@ use super::AsyncWriterTarget;
 #[derive(Clone, Debug)]
 pub struct AsyncWriter {
     sender: mpsc::Sender<Vec<u8>>,
-    count: Arc<AtomicUsize>,
-}
-
-impl AsyncWriter {
-    pub fn pending_writes(&self) -> usize {
-        self.count.load(Ordering::Relaxed)
-    }
 }
 
 impl Write for AsyncWriter {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        self.count.fetch_add(1, Ordering::Relaxed);
         match self.sender.try_send(buf.to_vec()) {
             Ok(_) => Ok(buf.len()),
             Err(mpsc::error::TrySendError::Full(_)) => {
-                self.count.fetch_sub(1, Ordering::Relaxed);
                 let _unused = writeln!(
                     std::io::stderr(),
                     "acta: async writer buffer full (4096), dropping log message"
                 );
                 Ok(buf.len())
             }
-            Err(mpsc::error::TrySendError::Closed(_)) => {
-                self.count.fetch_sub(1, Ordering::Relaxed);
-                Err(std::io::Error::new(
-                    std::io::ErrorKind::BrokenPipe,
-                    "async writer closed",
-                ))
-            }
+            Err(mpsc::error::TrySendError::Closed(_)) => Err(std::io::Error::new(
+                std::io::ErrorKind::BrokenPipe,
+                "async writer closed",
+            )),
         }
     }
 
@@ -55,14 +41,8 @@ impl MakeWriter<'_> for AsyncWriter {
     }
 }
 
-pub fn async_writer() -> AsyncWriter {
-    async_writer_for(AsyncWriterTarget::Stdout)
-}
-
 pub fn async_writer_for(target: AsyncWriterTarget) -> AsyncWriter {
     let (sender, mut receiver) = mpsc::channel::<Vec<u8>>(4096);
-    let count = Arc::new(AtomicUsize::new(0));
-    let count_clone = count.clone();
 
     tokio::spawn(async move {
         let writer: &mut (dyn AsyncWrite + Unpin + Send) = match target {
@@ -74,9 +54,8 @@ pub fn async_writer_for(target: AsyncWriterTarget) -> AsyncWriter {
             if let Err(e) = writer.write_all(&data).await {
                 let _unused = writeln!(std::io::stderr(), "async writer error: {e}");
             }
-            count_clone.fetch_sub(1, Ordering::Relaxed);
         }
     });
 
-    AsyncWriter { sender, count }
+    AsyncWriter { sender }
 }
diff --git a/src/writer/mod.rs b/src/writer/mod.rs
index 9766f531..2e1bbb15 100644
--- a/src/writer/mod.rs
+++ b/src/writer/mod.rs
@@ -10,7 +10,7 @@ pub mod custom;
 
 #[cfg(feature = "custom-async")]
 #[allow(clippy::module_name_repetitions)]
-pub use custom::{AsyncWriter, async_writer, async_writer_for};
+pub use custom::{AsyncWriter, async_writer_for};
 
 #[cfg(feature = "native-async")]
 pub mod native;
diff --git a/src/writer/test.rs b/src/writer/test.rs
index b4bcae23..a1f4ff9c 100644
--- a/src/writer/test.rs
+++ b/src/writer/test.rs
@@ -1,3 +1,9 @@
+#![allow(
+    clippy::unwrap_used,
+    clippy::indexing_slicing,
+    clippy::unnecessary_map_or
+)]
+
 use crate::Rotation;
 use crate::writer::file::{build_file_layer, resolve_log_path, rotate_log_file};