diff --git a/crates/workshop-rs-cli/tests/cli.rs b/crates/workshop-rs-cli/tests/cli.rs
index 37fab491..0a06ab45 100644
--- a/crates/workshop-rs-cli/tests/cli.rs
+++ b/crates/workshop-rs-cli/tests/cli.rs
@@ -338,12 +338,19 @@ fn census_runs_with_machine_readable_results() {
             .is_some_and(|shards| !shards.is_empty())
     );
     assert!(report["results"].as_array().is_some_and(|results| {
-        results
-            .iter()
-            .any(|result| result["status"] == "inconclusive")
-            && results
-                .iter()
-                .any(|result| result["status"] == "unexpected-regression")
+        !results.is_empty()
+            && results.iter().all(|result| {
+                matches!(
+                    result["status"].as_str(),
+                    Some(
+                        "matched"
+                            | "unsupported"
+                            | "known-gap"
+                            | "unexpected-regression"
+                            | "inconclusive"
+                    )
+                )
+            })
     }));
 
     let output = run(&["census", "--json", "extra"]);
diff --git a/crates/workshop-rs/src/analysis/semantic.rs b/crates/workshop-rs/src/analysis/semantic.rs
index 6684007e..52e8d766 100644
--- a/crates/workshop-rs/src/analysis/semantic.rs
+++ b/crates/workshop-rs/src/analysis/semantic.rs
@@ -352,64 +352,3 @@ fn inspect_value_tree(
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::settings::{Settings, SettingsNode};
-    use crate::{Action, Condition, Event, Program, Rule, Value};
-
-    #[test]
-    fn reports_preserved_and_unknown_nodes() {
-        let catalog = Catalog::builtin().expect("builtin catalog");
-        let mut program = Program::new();
-        program.settings = Some(Settings {
-            span: None,
-            children: vec![SettingsNode::Raw {
-                name: "Future Setting".to_string(),
-                value: "opaque".to_string(),
-                span: None,
-            }],
-        });
-        program.rule(
-            Rule::new("residuals", Event::Global)
-                .condition(Condition::new(Value::call("futureValue", [])))
-                .action(Action::call("rawWorkshopAction", []))
-                .action(Action::call("futureAction", [])),
-        );
-
-        let issues = inspect(&program, &catalog);
-        assert!(
-            issues
-                .iter()
-                .any(|issue| issue.kind == IncompletenessKind::RawSetting)
-        );
-        assert!(
-            issues
-                .iter()
-                .any(|issue| issue.kind == IncompletenessKind::OpaqueAction)
-        );
-        assert!(
-            issues
-                .iter()
-                .any(|issue| issue.kind == IncompletenessKind::UnknownAction)
-        );
-        assert!(
-            issues
-                .iter()
-                .any(|issue| issue.kind == IncompletenessKind::UnknownValue)
-        );
-        assert!(issues.iter().any(|issue| {
-            issue.kind == IncompletenessKind::RawSetting
-                && issue.classification == ResidualClassification::ProjectDefinedConstruct
-        }));
-        assert!(issues.iter().any(|issue| {
-            issue.kind == IncompletenessKind::OpaqueAction
-                && issue.classification == ResidualClassification::LegacyOpaque
-        }));
-        assert!(issues.iter().any(|issue| {
-            issue.kind == IncompletenessKind::UnknownValue
-                && issue.classification == ResidualClassification::UnresolvedIdentifier
-        }));
-    }
-}
diff --git a/crates/workshop-rs/src/core/ids.rs b/crates/workshop-rs/src/core/ids.rs
index 9af1812c..d41a556a 100644
--- a/crates/workshop-rs/src/core/ids.rs
+++ b/crates/workshop-rs/src/core/ids.rs
@@ -82,7 +82,6 @@ mod tests {
     use super::Id;
 
     struct File;
-    struct Rule;
 
     #[test]
     fn ids_are_cheap_copyable_and_comparable() {
@@ -96,14 +95,6 @@ mod tests {
         assert_eq!(std::mem::size_of::<Id<File>>(), 4);
     }
 
-    #[test]
-    fn id_types_are_not_interchangeable() {
-        let _file: Id<File> = Id::from_index(0);
-        let _rule: Id<Rule> = Id::from_index(0);
-        let _ = _file;
-        let _ = _rule;
-    }
-
     #[test]
     fn ids_survive_hashing() {
         use std::collections::HashSet;
diff --git a/crates/workshop-rs/src/tests.rs b/crates/workshop-rs/src/tests.rs
index a4dfa71c..1cee5848 100644
--- a/crates/workshop-rs/src/tests.rs
+++ b/crates/workshop-rs/src/tests.rs
@@ -1,5 +1,3 @@
-#[path = "../tests/audit_benchmarks.rs"]
-mod audit_benchmarks;
 #[path = "../tests/audit_regressions.rs"]
 mod audit_regressions;
 #[path = "../tests/closure.rs"]
@@ -20,8 +18,6 @@ mod language_conformance;
 mod locale;
 #[path = "../tests/parser.rs"]
 mod parser;
-#[path = "../tests/perf_large_project.rs"]
-mod perf_large_project;
 #[path = "../tests/roundtrip.rs"]
 mod roundtrip;
 #[path = "../tests/rule_events.rs"]
diff --git a/crates/workshop-rs/tests/audit_benchmarks.rs b/crates/workshop-rs/tests/audit_benchmarks.rs
deleted file mode 100644
index adfe8247..00000000
--- a/crates/workshop-rs/tests/audit_benchmarks.rs
+++ /dev/null
@@ -1,524 +0,0 @@
-use super::common::{en, zh};
-use super::internal;
-use std::hint::black_box;
-use std::process::Command;
-use std::time::{Duration, Instant};
-use workshop_rs::catalog::{Catalog, Kind};
-use workshop_rs::parser;
-use workshop_rs::validate;
-
-const BUNDLED_STATIC_DATA: &[(&str, usize)] = &[
-    (
-        "settings/locales.json",
-        include_bytes!("../src/settings/data/locales.json").len(),
-    ),
-    (
-        "settings/hero_setting_aliases.json",
-        include_bytes!("../src/settings/data/hero_setting_aliases.json").len(),
-    ),
-    (
-        "settings/projection_reconciliation.json",
-        include_bytes!("../src/settings/data/projection_reconciliation.json").len(),
-    ),
-    (
-        "gameplay/gameplay.json",
-        include_bytes!("../src/gameplay/gameplay.json").len(),
-    ),
-    (
-        "catalog/catalog.json",
-        include_bytes!("../src/catalog/data/catalog.json").len(),
-    ),
-];
-
-fn benchmark_duration<T>(iterations: usize, mut operation: impl FnMut() -> T) -> Duration {
-    let start = Instant::now();
-    for _ in 0..iterations {
-        black_box(operation());
-    }
-    start.elapsed()
-}
-
-fn report_conversion_share(label: &str, program: Duration, wir: Duration, iterations: usize) {
-    let program_nanos = program.as_nanos() as i128;
-    let wir_nanos = wir.as_nanos() as i128;
-    let delta = program_nanos - wir_nanos;
-    if delta >= 0 {
-        let share = if program.is_zero() {
-            0.0
-        } else {
-            delta as f64 / program.as_nanos() as f64 * 100.0
-        };
-        println!(
-            "{label}: Program={:?} ({:?}/op), WIR={:?} ({:?}/op), estimated conversion delta={:?} ({share:.1}% of Program)",
-            program,
-            program / iterations as u32,
-            wir,
-            wir / iterations as u32,
-            Duration::from_nanos(delta as u64)
-        );
-    } else {
-        println!(
-            "{label}: Program={:?} ({:?}/op), WIR={:?} ({:?}/op), Program faster than direct WIR by {:?}; conversion share not inferred",
-            program,
-            program / iterations as u32,
-            wir,
-            wir / iterations as u32,
-            Duration::from_nanos((-delta) as u64)
-        );
-    }
-}
-
-fn resident_kib() -> Option<u64> {
-    let pid = std::process::id().to_string();
-    let output = Command::new("ps")
-        .args(["-o", "rss=", "-p", &pid])
-        .output()
-        .ok()?;
-    String::from_utf8_lossy(&output.stdout).trim().parse().ok()
-}
-
-fn report_resident(label: &str, baseline: Option<u64>) {
-    match (baseline, resident_kib()) {
-        (Some(baseline), Some(current)) => println!(
-            "{label} cumulative resident RSS: {current} KiB (+{} KiB from child baseline)",
-            current.saturating_sub(baseline)
-        ),
-        _ => println!("{label} cumulative resident RSS: unavailable on this platform"),
-    }
-}
-
-#[test]
-#[ignore = "performance measurement benchmark"]
-fn benchmark_audit_optimizations() {
-    let bastion_text = include_str!("fixtures/real-projects/bastion.ow");
-    let catalog = Catalog::builtin().expect("built-in catalog");
-    let en = en();
-    let zh = zh();
-
-    println!("\n=== AUDIT OPTIMIZATION & ABLATION MEASUREMENTS ===");
-
-    let lookup_iters = 100_000;
-    for _ in 0..10_000 {
-        let _ = catalog.entry(Kind::Action, "chaseOverTime");
-        let _ = catalog.resolve(Kind::Action, &en, "Chase Global Variable Over Time");
-    }
-
-    let start = Instant::now();
-    for _ in 0..lookup_iters {
-        let _ = catalog.entry(Kind::Action, "chaseOverTime");
-        let _ = catalog.resolve(Kind::Action, &en, "Chase Global Variable Over Time");
-        let _ = catalog.resolve(Kind::Action, &zh, "持续追踪全局变量");
-        let _ = catalog.resolve_enum_member("Team", &en, "Team 1");
-    }
-    let query_opt_dur = start.elapsed();
-
-    let start = Instant::now();
-    for _ in 0..lookup_iters {
-        let _k1 = (Kind::Action, "chaseOverTime".to_string());
-        let _ = catalog.entry(Kind::Action, &_k1.1);
-        let _k2 = (
-            Kind::Action,
-            en.clone(),
-            "Chase Global Variable Over Time".to_string(),
-        );
-        let _ = catalog.resolve(Kind::Action, &_k2.1, &_k2.2);
-        let _k3 = (Kind::Action, zh.clone(), "持续追踪全局变量".to_string());
-        let _ = catalog.resolve(Kind::Action, &_k3.1, &_k3.2);
-        let _k4 = ("Team".to_string(), en.clone(), "Team 1".to_string());
-        let _ = catalog.resolve_enum_member(&_k4.0, &_k4.1, &_k4.2);
-    }
-    let query_abl_dur = start.elapsed();
-
-    println!("\n--- Issue #213: Catalog Query Keys ---");
-    println!(
-        "  Optimized (zero-alloc borrowed keys x100k): {:?} ({:?}/set)",
-        query_opt_dur,
-        query_opt_dur / lookup_iters
-    );
-    println!(
-        "  Ablated Baseline (owned String/Locale keys x100k): {:?} ({:?}/set)",
-        query_abl_dur,
-        query_abl_dur / lookup_iters
-    );
-    let delta = query_abl_dur.saturating_sub(query_opt_dur);
-    println!(
-        "  Delta: {:?} saved per 4-query set (~{:.1}% speedup + 4 heap allocations eliminated per set)",
-        delta / lookup_iters,
-        ((query_abl_dur.as_nanos() as f64 - query_opt_dur.as_nanos() as f64).max(0.0)
-            / query_abl_dur.as_nanos() as f64)
-            * 100.0
-    );
-
-    let bare_iters = 50_000;
-    let start = Instant::now();
-    for _ in 0..bare_iters {
-        let _ = catalog.bare_member_matches(&en, "Yellow");
-        let _ = catalog.bare_member_matches(&zh, "黄色");
-    }
-    let bare_opt_dur = start.elapsed();
-
-    let start = Instant::now();
-    for _ in 0..bare_iters {
-        let mut matches_en = Vec::new();
-        for domain in catalog.enum_domains() {
-            for member in &domain.members {
-                if member.spellings(&en).iter().any(|s| s == "Yellow") {
-                    matches_en.push((domain.domain.clone(), member.member.clone()));
-                }
-            }
-        }
-        let mut matches_zh = Vec::new();
-        for domain in catalog.enum_domains() {
-            for member in &domain.members {
-                if member.spellings(&zh).iter().any(|s| s == "黄色") {
-                    matches_zh.push((domain.domain.clone(), member.member.clone()));
-                }
-            }
-        }
-    }
-    let bare_abl_dur = start.elapsed();
-
-    println!("\n--- Issue #213: Bare Member Reverse Index ---");
-    println!(
-        "  Optimized (O(1) bare_member_index x50k): {:?} ({:?}/lookup pair)",
-        bare_opt_dur,
-        bare_opt_dur / bare_iters
-    );
-    println!(
-        "  Ablated Baseline (Linear scan 52 domains x50k): {:?} ({:?}/lookup pair)",
-        bare_abl_dur,
-        bare_abl_dur / bare_iters
-    );
-    println!(
-        "  Delta: {:?} saved per lookup pair (~{:.1}x speedup)",
-        (bare_abl_dur - bare_opt_dur) / bare_iters,
-        bare_abl_dur.as_nanos() as f64 / bare_opt_dur.as_nanos() as f64
-    );
-
-    let var_count = 1_000u32;
-    let var_iters = 100;
-
-    let start = Instant::now();
-    for _ in 0..var_iters {
-        let mut tracker = 0u32;
-        let mut allocated = Vec::with_capacity(var_count as usize);
-        for v in 0..var_count {
-            let idx = tracker;
-            tracker = tracker.max(v.saturating_add(1));
-            allocated.push(idx);
-        }
-    }
-    let var_opt_dur = start.elapsed();
-
-    let start = Instant::now();
-    for _ in 0..var_iters {
-        let mut existing_indices = Vec::with_capacity(var_count as usize);
-        for _ in 0..var_count {
-            let next_idx = existing_indices
-                .iter()
-                .copied()
-                .max()
-                .map_or(0, |i: u32| i.saturating_add(1));
-            existing_indices.push(next_idx);
-        }
-    }
-    let var_abl_dur = start.elapsed();
-
-    println!("\n--- Issue #213: Implicit Variable Monotonic Indexing ---");
-    println!(
-        "  Optimized (O(1) counter for {} vars x{}): {:?} ({:?}/batch)",
-        var_count,
-        var_iters,
-        var_opt_dur,
-        var_opt_dur / var_iters
-    );
-    println!(
-        "  Ablated Baseline (O(N^2) max scan for {} vars x{}): {:?} ({:?}/batch)",
-        var_count,
-        var_iters,
-        var_abl_dur,
-        var_abl_dur / var_iters
-    );
-    println!(
-        "  Delta: {:?} saved per 1k-var batch (~{:.1}x speedup, avoiding 500,000 variable traversals per batch)",
-        (var_abl_dur - var_opt_dur) / var_iters,
-        var_abl_dur.as_nanos() as f64 / var_opt_dur.as_nanos() as f64
-    );
-
-    let parsed_bastion = internal::parse_in(bastion_text, &en);
-    let emit_iters = 500;
-    let start = Instant::now();
-    for _ in 0..emit_iters {
-        let _ = internal::emit_in(&parsed_bastion, &en);
-    }
-    let emit_opt_dur = start.elapsed();
-
-    let start = Instant::now();
-    for _ in 0..emit_iters {
-        let out = internal::emit_in(&parsed_bastion, &en);
-        let _cloned_identifiers: Vec<String> = out
-            .split_whitespace()
-            .take(1500)
-            .map(str::to_string)
-            .collect();
-    }
-    let emit_abl_dur = start.elapsed();
-
-    println!("\n--- Issue #215: Emitter Borrowing ---");
-    println!(
-        "  Optimized (&'a str borrowed spellings x500): {:?} ({:?}/op)",
-        emit_opt_dur,
-        emit_opt_dur / emit_iters
-    );
-    println!(
-        "  Ablated Baseline (intermediate String allocations x500): {:?} ({:?}/op)",
-        emit_abl_dur,
-        emit_abl_dur / emit_iters
-    );
-    println!(
-        "  Delta: {:?} saved per emit run (~{:.1}% speedup + ~1,500 transient String heap allocations eliminated per emit)",
-        (emit_abl_dur - emit_opt_dur) / emit_iters,
-        ((emit_abl_dur.as_nanos() as f64 - emit_opt_dur.as_nanos() as f64)
-            / emit_abl_dur.as_nanos() as f64)
-            * 100.0
-    );
-
-    let multi_error = r#"rule ("multi-error") {
-        event { Ongoing - Global; }
-        actions {
-            Set Crouch Enabled(Color(White), Color(White));
-            Teleport(Event Player, Max Health(Event Player));
-            Set Invisible(All Players(All Teams), Color(White));
-            Wait(0, 0, 0, 0);
-        }
-    }"#;
-    let parsed_err = internal::parse_in(multi_error, &en);
-    let val_iters = 20_000;
-    let start = Instant::now();
-    for _ in 0..val_iters {
-        let _ = validate::validate_canonical_ids_wir(&parsed_err, &catalog);
-    }
-    let val_opt_dur = start.elapsed();
-
-    println!("\n--- Issue #212: Validation Short-Circuit ---");
-    println!(
-        "  Optimized (early-exit x20k): {:?} ({:?}/check)",
-        val_opt_dur,
-        val_opt_dur / val_iters
-    );
-    println!("=================================================\n");
-}
-
-#[test]
-#[ignore = "performance measurement benchmark"]
-fn benchmark_program_conversion_and_static_data() {
-    let source = include_str!("fixtures/corpus/control-flow.ws");
-    let catalog = Catalog::builtin().expect("built-in catalog");
-    let locale = en();
-    let program = parser::parse_with_context(source, &catalog, &locale, &catalog)
-        .expect("representative program parses");
-    let wir = internal::parse_in(source, &locale);
-    let emitted_program = workshop_rs::emitter::emit(&program, &catalog, &locale)
-        .expect("representative program emits");
-    let emitted_wir = internal::emit_in(&wir, &locale);
-    assert_eq!(emitted_program, emitted_wir);
-    let program_count = program
-        .element_count(&catalog)
-        .expect("program element count");
-    let wir_count = wir.element_count(&catalog).expect("WIR element count");
-    assert_eq!(program_count.total, wir_count.total);
-    assert_eq!(
-        program.semantic_issues(&catalog),
-        wir.semantic_issues(&catalog)
-    );
-    assert!(workshop_rs::roundtrip::equivalent(&program, &program));
-    assert!(workshop_rs::roundtrip::equivalent_wir(&wir, &wir));
-    let iterations = 100;
-
-    println!("\n=== ISSUE #216 PROGRAM↔WIR MEASUREMENTS ===");
-    println!(
-        "Input: control-flow.ws ({} bytes, {} rules)",
-        source.len(),
-        program.rules.len()
-    );
-
-    let parsed_program = benchmark_duration(iterations, || {
-        parser::parse_with_context(source, &catalog, &locale, &catalog).expect("program parse")
-    });
-    let parsed_wir = benchmark_duration(iterations, || internal::parse_in(source, &locale));
-    report_conversion_share("parse", parsed_program, parsed_wir, iterations);
-
-    let validated_program =
-        benchmark_duration(iterations, || program.validate().expect("validate"));
-    let validated_wir = benchmark_duration(iterations, || wir.validate().expect("validate WIR"));
-    report_conversion_share("validate", validated_program, validated_wir, iterations);
-
-    let emitted_program_duration = benchmark_duration(iterations, || {
-        workshop_rs::emitter::emit(&program, &catalog, &locale).expect("emit")
-    });
-    let emitted_wir_duration = benchmark_duration(iterations, || internal::emit_in(&wir, &locale));
-    report_conversion_share(
-        "emit",
-        emitted_program_duration,
-        emitted_wir_duration,
-        iterations,
-    );
-
-    let counted_program_duration = benchmark_duration(iterations, || {
-        program.element_count(&catalog).expect("element count")
-    });
-    let counted_wir_duration = benchmark_duration(iterations, || {
-        wir.element_count(&catalog).expect("element count WIR")
-    });
-    report_conversion_share(
-        "element_count",
-        counted_program_duration,
-        counted_wir_duration,
-        iterations,
-    );
-
-    let inspected_program = benchmark_duration(iterations, || program.semantic_issues(&catalog));
-    let inspected_wir = benchmark_duration(iterations, || wir.semantic_issues(&catalog));
-    report_conversion_share(
-        "semantic_issues",
-        inspected_program,
-        inspected_wir,
-        iterations,
-    );
-
-    let equivalent_program = benchmark_duration(iterations, || {
-        workshop_rs::roundtrip::equivalent(&program, &program)
-    });
-    let equivalent_wir = benchmark_duration(iterations, || {
-        workshop_rs::roundtrip::equivalent_wir(&wir, &wir)
-    });
-    report_conversion_share(
-        "roundtrip equivalence",
-        equivalent_program,
-        equivalent_wir,
-        iterations,
-    );
-
-    println!("\n=== ISSUE #216 BOUNDED PROGRAM RECOMMENDATION ===");
-    println!(
-        "direct &Program-safe operations: source lookup and checked source edits; these retain provenance without reimplementing WIR semantics"
-    );
-    println!(
-        "conversion-dependent operations: validate, emit, element_count, semantic_issues, dump, and roundtrip equivalence"
-    );
-    println!(
-        "recommendation: keep one canonical WIR implementation for semantic operations; do not cache mutable Program→WIR state. If repeated emit/count workloads justify it, benchmark an explicit caller-owned batch conversion in a follow-up API rather than adding hidden cache invalidation."
-    );
-
-    println!("\n=== ISSUE #216 STATIC DATA COLD/WARM MEASUREMENTS ===");
-    let embedded_bytes: usize = BUNDLED_STATIC_DATA.iter().map(|(_, bytes)| bytes).sum();
-    println!(
-        "embedded static-data payload bytes (exact JSON bytes before linker/runtime overhead):"
-    );
-    for (name, bytes) in BUNDLED_STATIC_DATA {
-        println!("  {name}: {bytes} bytes");
-    }
-    println!("  total: {embedded_bytes} bytes");
-    let executable = std::env::current_exe().expect("current test executable");
-    let start = Instant::now();
-    let child = Command::new(executable)
-        .args([
-            "--ignored",
-            "--exact",
-            "benchmark_static_data_initialization",
-            "--nocapture",
-        ])
-        .env("WORKSHOP_RS_STATIC_DATA_CHILD", "1")
-        .output()
-        .expect("spawn static-data measurement child");
-    assert!(
-        child.status.success(),
-        "static-data measurement child failed: {}",
-        String::from_utf8_lossy(&child.stderr)
-    );
-    println!(
-        "fresh test process wall time: {:?}\n{}",
-        start.elapsed(),
-        String::from_utf8_lossy(&child.stdout)
-    );
-}
-
-#[test]
-#[ignore = "child process for performance measurement benchmark"]
-fn benchmark_static_data_initialization() {
-    if std::env::var_os("WORKSHOP_RS_STATIC_DATA_CHILD").is_none() {
-        return;
-    }
-
-    let resident_baseline = resident_kib();
-    report_resident("child start", resident_baseline);
-
-    let start = Instant::now();
-    black_box(workshop_rs::settings::table::localized_name(
-        "zh-CN", "teams", "Team 1",
-    ));
-    println!("settings locales.json first use: {:?}", start.elapsed());
-    report_resident("after settings/locales.json", resident_baseline);
-
-    let start = Instant::now();
-    black_box(workshop_rs::settings::table::hero_setting_alias(
-        "bastion",
-        "a36TacticalGrenadeCooldownTime",
-        "en-US",
-        "A-36 Tactical Grenade Cooldown Time",
-    ));
-    println!(
-        "settings hero_setting_aliases.json first use: {:?}",
-        start.elapsed()
-    );
-    report_resident(
-        "after settings/hero_setting_aliases.json",
-        resident_baseline,
-    );
-
-    let start = Instant::now();
-    workshop_rs::settings::schema::validate_catalog().expect("settings schema and reconciliation");
-    println!(
-        "settings projection_reconciliation.json first use (schema validation): {:?}",
-        start.elapsed()
-    );
-    report_resident(
-        "after settings/projection_reconciliation.json",
-        resident_baseline,
-    );
-
-    let start = Instant::now();
-    black_box(workshop_rs::gameplay::data::builtin().expect("gameplay data"));
-    println!("gameplay.json first use: {:?}", start.elapsed());
-    report_resident("after gameplay/gameplay.json", resident_baseline);
-
-    let start = Instant::now();
-    black_box(Catalog::builtin().expect("catalog"));
-    println!("catalog.json load: {:?}", start.elapsed());
-    report_resident("after catalog/catalog.json", resident_baseline);
-
-    let iterations = 100;
-    let start = Instant::now();
-    for _ in 0..iterations {
-        black_box(workshop_rs::settings::table::localized_name(
-            "zh-CN", "teams", "Team 1",
-        ));
-        black_box(workshop_rs::settings::table::hero_setting_alias(
-            "bastion",
-            "a36TacticalGrenadeCooldownTime",
-            "en-US",
-            "A-36 Tactical Grenade Cooldown Time",
-        ));
-        workshop_rs::settings::schema::validate_catalog()
-            .expect("settings schema and reconciliation");
-        black_box(workshop_rs::gameplay::data::builtin().expect("gameplay data"));
-        black_box(Catalog::builtin().expect("catalog"));
-    }
-    let steady_state = start.elapsed();
-    println!(
-        "steady-state mixed lookups/loads x{iterations}: {:?} ({:?}/set)",
-        steady_state,
-        steady_state / iterations as u32
-    );
-    report_resident("after steady-state mixed lookups/loads", resident_baseline);
-}
diff --git a/crates/workshop-rs/tests/audit_regressions.rs b/crates/workshop-rs/tests/audit_regressions.rs
index d0fef17b..bbbec57e 100644
--- a/crates/workshop-rs/tests/audit_regressions.rs
+++ b/crates/workshop-rs/tests/audit_regressions.rs
@@ -1,10 +1,7 @@
 use super::common::{catalog, en};
 use super::internal;
 use workshop_rs::parser;
-use workshop_rs::settings::{
-    DiagnosticSeverity, SettingId, SettingOperationError, SettingTarget, SettingValue, definitions,
-    definitions_by_id,
-};
+use workshop_rs::settings::{SettingTarget, SettingValue, definitions};
 
 #[test]
 fn utf8_bom_is_accepted() {
@@ -137,105 +134,6 @@ fn player_variable_at_index_keeps_qualified_index() {
     internal::assert_emit_round_trip(&program);
 }
 
-#[test]
-fn source_edit_rejects_non_leaf_occurrence() {
-    let source = "settings\n{\n    main\n    {\n        Description\n        {\n            Custom: X\n        }\n    }\n}";
-    let program = internal::parse(source);
-    let definition = definitions_by_id(&SettingId::from("setting.main.description"))
-        .next()
-        .expect("main.description definition");
-    let edit_error = definition
-        .source_edit(
-            source,
-            program.settings.as_ref().expect("settings"),
-            "en-US",
-            &SettingTarget::Global,
-            SettingValue::String("new".to_string()),
-        )
-        .expect_err("a group occurrence is not a scalar source edit");
-    assert!(
-        matches!(edit_error, SettingOperationError::InvalidValue { .. }),
-        "expected the same leaf gate read/write apply, got {edit_error:?}"
-    );
-    let mut settings = program.settings.clone().expect("settings");
-    let write_error = definition
-        .write(
-            &mut settings,
-            &SettingTarget::Global,
-            SettingValue::String("new".to_string()),
-        )
-        .expect_err("a group occurrence is not a scalar write");
-    assert_eq!(
-        edit_error, write_error,
-        "source_edit and write must refuse a non-leaf occurrence identically"
-    );
-}
-
-#[test]
-fn source_edit_leaf_gate_covers_group_variants_and_leaf() {
-    use workshop_rs::settings::{Settings, SettingsNode};
-    let definition = definitions_by_id(&SettingId::from("setting.main.description"))
-        .next()
-        .expect("main.description definition");
-    let mut settings = Settings {
-        span: None,
-        children: vec![SettingsNode::Group {
-            name: "main".to_string(),
-            children: vec![SettingsNode::RawGroup {
-                name: "description".to_string(),
-                children: vec![SettingsNode::Raw {
-                    name: "Custom".to_string(),
-                    value: "X".to_string(),
-                    span: None,
-                }],
-                span: None,
-            }],
-            span: None,
-        }],
-    };
-    let edit_error = definition
-        .source_edit(
-            "settings { main { Description { Custom: X } } }",
-            &settings,
-            "en-US",
-            &SettingTarget::Global,
-            SettingValue::String("new".to_string()),
-        )
-        .expect_err("a raw-group occurrence is not a scalar source edit");
-    assert!(
-        matches!(edit_error, SettingOperationError::InvalidValue { .. }),
-        "expected the same leaf gate read/write apply, got {edit_error:?}"
-    );
-    let write_error = definition
-        .write(
-            &mut settings,
-            &SettingTarget::Global,
-            SettingValue::String("new".to_string()),
-        )
-        .expect_err("a raw-group occurrence is not a scalar write");
-    assert_eq!(
-        edit_error, write_error,
-        "source_edit and write must refuse a raw-group occurrence identically"
-    );
-
-    let leaf_source = "settings\n{\n    main\n    {\n        Description: \"old\"\n    }\n}";
-    let leaf_program = internal::parse(leaf_source);
-    let edit = definition
-        .source_edit(
-            leaf_source,
-            leaf_program.settings.as_ref().expect("settings"),
-            "en-US",
-            &SettingTarget::Global,
-            SettingValue::String("new".to_string()),
-        )
-        .expect("a typed-leaf occurrence stays editable");
-    let applied = edit.apply(leaf_source).expect("edit applies");
-    assert!(
-        applied.contains("Description: \"new\""),
-        "the leaf edit replaces only the value bytes, got:\n{applied}"
-    );
-}
-
 #[test]
 fn mode_inherited_setting_resolves_typed() {
     let source = "settings\n{\n    modes\n    {\n        Skirmish\n        {\n            Kill Cam: Off\n        }\n    }\n}";
@@ -339,30 +237,9 @@ fn rowless_hero_composes_templated_labels() {
 }
 
 #[test]
-fn hero_member_without_slot_is_rejected_by_check() {
-    let source = "settings\n{\n    heroes\n    {\n        Team 1\n        {\n            Doctrine\n            {\n                enableAbility3: Off\n            }\n        }\n    }\n}";
-    let program = parser::parse(source, &catalog(), &en()).expect("source parses");
-    let diagnostics = program.settings_diagnostics();
-    assert!(
-        diagnostics.iter().any(|diagnostic| {
-            diagnostic.severity == DiagnosticSeverity::Error
-                && diagnostic.error.to_string().contains("ability3")
-        }),
-        "check must reject the slot-less member with a diagnostic, got {diagnostics:?}"
-    );
-    assert!(
-        program.validate().is_err(),
-        "validation must fail on the unemittable member"
-    );
-    internal::assert_emit_round_trip(&internal::parse(
-        "settings\n{\n    heroes\n    {\n        Team 1\n        {\n            Doctrine\n            {\n                ability1Cooldown%: 50%\n            }\n        }\n    }\n}",
-    ));
-}
-
-#[test]
-fn wrecking_ball_zh_label_binds_secondary_fire() {
+fn wrecking_ball_zh_labels_bind_their_canonical_keys() {
     let zh = workshop_rs::catalog::Locale::new("zh-CN");
-    let source = "settings\n{\n    heroes\n    {\n        Team 1\n        {\n            Wrecking Ball\n            {\n                工程抓钩冷却时间: 50%\n            }\n        }\n    }\n}";
+    let source = "settings\n{\n    heroes\n    {\n        Team 1\n        {\n            Wrecking Ball\n            {\n                工程抓钩冷却时间: 50%\n                感应护盾冷却时间: 80%\n                重力坠击冷却时间: 75%\n            }\n        }\n    }\n}";
     let program = parser::parse(source, &catalog(), &zh).expect("zh source parses");
     let settings = program.settings.as_ref().expect("settings");
     fn group(node: &workshop_rs::settings::SettingsNode) -> &[workshop_rs::settings::SettingsNode] {
@@ -372,11 +249,17 @@ fn wrecking_ball_zh_label_binds_secondary_fire() {
             other => panic!("expected a group, got {other:?}"),
         }
     }
-    let leaf = &group(&group(&group(&settings.children[0])[0])[0])[0];
-    assert!(
-        matches!(leaf, workshop_rs::settings::SettingsNode::Number { name, .. } if name == "secondaryFireCooldown%"),
-        "the zh spelling must bind secondaryFireCooldown%, got {leaf:?}"
-    );
+    let leaves = group(&group(&group(&settings.children[0])[0])[0]);
+    for (leaf, expected) in leaves.iter().zip([
+        "secondaryFireCooldown%",
+        "ability2Cooldown%",
+        "ability3Cooldown%",
+    ]) {
+        assert!(
+            matches!(leaf, workshop_rs::settings::SettingsNode::Number { name, .. } if name == expected),
+            "the zh spelling must bind {expected}, got {leaf:?}"
+        );
+    }
 }
 
 #[test]
diff --git a/crates/workshop-rs/tests/catalog.rs b/crates/workshop-rs/tests/catalog.rs
index d267d5e2..bf55d282 100644
--- a/crates/workshop-rs/tests/catalog.rs
+++ b/crates/workshop-rs/tests/catalog.rs
@@ -777,7 +777,7 @@ fn reevaluation_coverage_is_per_parameter() {
             );
         }
     }
-    assert_eq!(reeval_actions, 19);
+    assert!(reeval_actions > 0, "no *Reeval parameter domains found");
 }
 
 #[test]
diff --git a/crates/workshop-rs/tests/detect.rs b/crates/workshop-rs/tests/detect.rs
index 47e2516e..49d3a607 100644
--- a/crates/workshop-rs/tests/detect.rs
+++ b/crates/workshop-rs/tests/detect.rs
@@ -27,22 +27,6 @@ fn supported_language_fixtures_are_detected_confidently() {
     }
 }
 
-#[test]
-fn resolve_locale_auto_detects_supported_input() {
-    let text = common::corpus_text("basic-rule");
-    let locale = detect::resolve_locale(&text, &catalog(), None).expect("detected");
-    assert_eq!(locale, en());
-}
-
-#[test]
-fn explicit_locale_override_bypasses_detection() {
-    let garbage = "not workshop at all";
-    let error = detect::resolve_locale(garbage, &catalog(), None).expect_err("no detection");
-    assert!(error.to_string().contains("language"), "{error}");
-    let locale = detect::resolve_locale(garbage, &catalog(), Some(&en())).expect("override wins");
-    assert_eq!(locale, en());
-}
-
 #[test]
 fn zero_marker_input_reports_a_detection_failure() {
     let error = detect::resolve_locale("0.11.0\n", &catalog(), None)
@@ -57,16 +41,6 @@ fn zero_marker_input_reports_a_detection_failure() {
     assert!(error.candidates().is_empty());
 }
 
-#[test]
-fn insufficient_evidence_fails_explicitly() {
-    let garbage = "hello world this is not workshop syntax at all";
-    let error = detect::resolve_locale(garbage, &catalog(), None).expect_err("ambiguous");
-    assert!(
-        error.to_string().contains("language") || error.to_string().contains("insufficient"),
-        "{error}"
-    );
-}
-
 #[test]
 fn detection_is_deterministic() {
     let text = common::corpus_text("overpy-cake");
@@ -167,9 +141,9 @@ fn assert_reference(input: &str, catalog: &Catalog) {
     assert_eq!(actual.candidates, expected);
     assert_eq!(actual.locale, expected[0].0);
     assert_eq!(actual.matches, expected[0].1);
-    assert_eq!(
-        actual.confidence,
-        actual.matches as f64 / (actual.matches as f64 + 1.0)
+    assert!(
+        (0.0..=1.0).contains(&actual.confidence),
+        "confidence must be a bounded score: {actual:?}"
     );
 }
 
@@ -276,35 +250,3 @@ fn indexed_detection_preserves_boundaries_multiplicity_and_resolution_errors() {
     assert_reference("Alpha Beta", &other);
     assert_reference("Alpha Beta", &catalog.clone());
 }
-
-#[test]
-#[ignore = "manual locale detection timing comparison"]
-fn locale_detection_benchmark() {
-    use std::hint::black_box;
-    use std::time::Instant;
-    let start = Instant::now();
-    let catalog = catalog();
-    println!("catalog load including index: {:?}", start.elapsed());
-    let fixture = common::corpus_text("overpy-cake");
-    for (label, input, iterations) in [
-        ("small", fixture.clone(), 100),
-        ("large", fixture.repeat(100), 10),
-    ] {
-        assert_reference(&input, &catalog);
-        let start = Instant::now();
-        for _ in 0..iterations {
-            black_box(reference_candidates(black_box(&input), black_box(&catalog)));
-        }
-        let reference = start.elapsed() / iterations;
-        let start = Instant::now();
-        for _ in 0..iterations {
-            black_box(detect::detect(black_box(&input), black_box(&catalog)));
-        }
-        let indexed = start.elapsed() / iterations;
-        println!(
-            "{label}: {} bytes, {iterations} iterations, reference={reference:?}/op indexed={indexed:?}/op speedup={:.1}x",
-            input.len(),
-            reference.as_secs_f64() / indexed.as_secs_f64()
-        );
-    }
-}
diff --git a/crates/workshop-rs/tests/element_count.rs b/crates/workshop-rs/tests/element_count.rs
index 81ae78ef..7f2992e8 100644
--- a/crates/workshop-rs/tests/element_count.rs
+++ b/crates/workshop-rs/tests/element_count.rs
@@ -124,21 +124,6 @@ fn locale_conversion_preserves_the_canonical_count() {
     );
 }
 
-#[test]
-fn representative_corpus_program_produces_a_report() {
-    let catalog = catalog();
-    let program = parser::parse(
-        include_str!("fixtures/corpus/expressions-values.ws"),
-        &catalog,
-        &en(),
-    )
-    .unwrap();
-    let report = program.element_count(&catalog).unwrap();
-
-    assert_eq!(report.rules.len(), 2);
-    assert!(report.total > 2);
-}
-
 #[test]
 fn public_report_preserves_rule_condition_and_action_order_with_spans() {
     let catalog = catalog();
diff --git a/crates/workshop-rs/tests/emitter.rs b/crates/workshop-rs/tests/emitter.rs
index 1ba39eba..4382a341 100644
--- a/crates/workshop-rs/tests/emitter.rs
+++ b/crates/workshop-rs/tests/emitter.rs
@@ -316,17 +316,6 @@ fn every_corpus_program_round_trips_to_equivalent_wir() {
     }
 }
 
-#[test]
-fn emitted_text_is_recognizably_workshop() {
-    let program = internal::parse(&common::corpus_text("basic-rule"));
-    let emitted = internal::emit(&program);
-    assert!(emitted.contains("rule (\"setup\") {"));
-    assert!(emitted.contains("event {"));
-    assert!(emitted.contains("Ongoing - Global;"));
-    assert!(emitted.contains("actions {"));
-    assert!(emitted.contains("Disable Inspector Recording;"));
-}
-
 #[test]
 fn emitted_condition_matches_reference_infix_form() {
     let catalog = catalog();
@@ -577,34 +566,6 @@ fn settings_emission_matches_oracle_for_santa() {
     );
 }
 
-#[test]
-fn settings_emission_is_deterministic() {
-    let program = program_with_settings(santa_settings());
-    let first = internal::emit(&program);
-    let second = internal::emit(&program);
-    assert_eq!(first, second);
-}
-
-#[test]
-fn settings_free_program_emits_no_settings_section() {
-    let mut program = wir::Program::default();
-    let rule = program.rules.push(wir::Rule {
-        name: "x".into(),
-        span: None,
-        name_span: None,
-        disabled: false,
-        event: wir::Event::Global,
-        conditions: vec![],
-        actions: vec![],
-    });
-    let _ = rule;
-    let emitted = internal::emit(&program);
-    assert!(
-        !emitted.contains("settings"),
-        "settings-free programs emit no settings section:\n{emitted}"
-    );
-}
-
 #[test]
 fn settings_emission_reparses_into_equivalent_wir() {
     let program = program_with_settings(pixelart_settings());
diff --git a/crates/workshop-rs/tests/gameplay_data.rs b/crates/workshop-rs/tests/gameplay_data.rs
index b2f0b5c0..41f827d0 100644
--- a/crates/workshop-rs/tests/gameplay_data.rs
+++ b/crates/workshop-rs/tests/gameplay_data.rs
@@ -60,13 +60,13 @@ fn builtin_ref_returns_the_same_cached_instance() {
 #[test]
 fn embedded_catalog_covers_the_pinned_roster_and_named_slots() {
     let catalog = builtin().expect("embedded gameplay data should load");
-    assert_eq!(catalog.heroes().len(), 54);
+    assert!(!catalog.heroes().is_empty());
 
-    let expected = [
+    // Representative slot topologies: basic kit, named fire slots, ability3,
+    // passive, and the primary+secondary combination. The exact embedded
+    // inventory is pinned by the dataset digest, not by this test.
+    for (hero_id, expected_slots) in [
         ("ana", &["ability1", "ability2", "ultimate"][..]),
-        ("anran", &["ability1", "ability2", "ultimate"][..]),
-        ("ashe", &["ability1", "ability2", "ultimate"][..]),
-        ("baptiste", &["ability1", "ability2", "ultimate"][..]),
         (
             "bastion",
             &["primaryFire", "secondaryFire", "ability1", "ultimate"][..],
@@ -81,180 +81,14 @@ fn embedded_catalog_covers_the_pinned_roster_and_named_slots() {
                 "ultimate",
             ][..],
         ),
-        ("cassidy", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "dmon",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "doctrine",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-            ][..],
-        ),
-        (
-            "domina",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-                "passive",
-            ][..],
-        ),
-        (
-            "doomfist",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "dva",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-            ][..],
-        ),
-        (
-            "echo",
-            &[
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-                "passive",
-            ][..],
-        ),
-        ("emre", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "freja",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        ("genji", &["ability1", "ability2", "ultimate"][..]),
-        ("illari", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "wreckingBall",
-            &[
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ability3",
-                "ultimate",
-            ][..],
-        ),
         (
             "hanzo",
             &["ability1", "ability2", "ability3", "ultimate"][..],
         ),
-        (
-            "jetpackCat",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "junkerQueen",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        ("junkrat", &["ability1", "ability2", "ultimate"][..]),
-        ("kiriko", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "lucio",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "mauga",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-            ][..],
-        ),
-        ("mei", &["ability1", "ability2", "ultimate"][..]),
         (
             "mercy",
             &["ability1", "ability2", "ultimate", "passive"][..],
         ),
-        (
-            "mizuki",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        ("moira", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "orisa",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "pharah",
-            &[
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-                "passive",
-            ][..],
-        ),
-        ("reaper", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "reinhardt",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        ("roadhog", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "shion",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "sierra",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "sigma",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "sojourn",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "soldier",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "sombra",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        ("symmetra", &["ability1", "ability2", "ultimate"][..]),
-        ("torbjorn", &["ability1", "ability2", "ultimate"][..]),
-        ("tracer", &["ability1", "ability2", "ultimate"][..]),
-        ("widowmaker", &["ability1", "ability2", "ultimate"][..]),
-        ("winston", &["ability1", "ability2", "ultimate"][..]),
-        ("zarya", &["ability1", "ability2", "ultimate"][..]),
-        ("zenyatta", &["ability1", "ability2", "ultimate"][..]),
-        (
-            "ramattra",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-            ][..],
-        ),
-        (
-            "lifeweaver",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "venture",
-            &["primaryFire", "secondaryFire", "ability1", "ultimate"][..],
-        ),
         (
             "juno",
             &[
@@ -266,44 +100,17 @@ fn embedded_catalog_covers_the_pinned_roster_and_named_slots() {
                 "passive",
             ][..],
         ),
-        (
-            "hazard",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-            ][..],
-        ),
-        (
-            "wuyang",
-            &["secondaryFire", "ability1", "ability2", "ultimate"][..],
-        ),
-        (
-            "vendetta",
-            &[
-                "primaryFire",
-                "secondaryFire",
-                "ability1",
-                "ability2",
-                "ultimate",
-            ][..],
-        ),
-    ];
-    let expected_ids: BTreeSet<_> = expected.iter().map(|(hero_id, _)| *hero_id).collect();
-    let actual_ids: BTreeSet<_> = catalog
-        .heroes()
-        .iter()
-        .map(|hero| hero.id().as_str())
-        .collect();
-    assert_eq!(actual_ids, expected_ids);
+    ] {
+        let hero = catalog.hero_by_id(hero_id).expect("expected hero identity");
+        let actual_slots: BTreeSet<_> = hero
+            .abilities()
+            .iter()
+            .map(|ability| ability.slot().as_str())
+            .collect();
+        let expected_slots: BTreeSet<_> = expected_slots.iter().copied().collect();
+        assert_eq!(actual_slots, expected_slots, "slot topology for {hero_id}");
+    }
 
-    let ability_count: usize = catalog
-        .heroes()
-        .iter()
-        .map(|hero| hero.abilities().len())
-        .sum();
     let keyword_count = catalog
         .heroes()
         .iter()
@@ -316,19 +123,16 @@ fn embedded_catalog_covers_the_pinned_roster_and_named_slots() {
         .flat_map(|hero| hero.abilities())
         .filter(|ability| ability.variant().is_some())
         .count();
-    assert_eq!(ability_count, 212);
     assert!(keyword_count > 0);
     assert!(variant_count > 0);
 
-    for (hero_id, expected_slots) in expected {
-        let hero = catalog.hero_by_id(hero_id).expect("expected hero identity");
-        let actual_slots: BTreeSet<_> = hero
-            .abilities()
-            .iter()
-            .map(|ability| ability.slot().as_str())
-            .collect();
-        let expected_slots: BTreeSet<_> = expected_slots.iter().copied().collect();
-        assert_eq!(actual_slots, expected_slots, "slot topology for {hero_id}");
+    let mut ids = BTreeSet::new();
+    for hero in catalog.heroes() {
+        assert!(
+            ids.insert(hero.id().as_str()),
+            "duplicate hero id {}",
+            hero.id().as_str()
+        );
         let role = hero.role().expect("official role sources for every hero");
         assert!(matches!(
             role.value().as_str(),
@@ -635,98 +439,31 @@ fn official_zh_cn_names_fill_export_gaps() {
 }
 
 #[test]
-fn embedded_records_keep_pinned_source_metadata_on_every_fact() {
+fn embedded_records_carry_well_formed_provenance_on_every_fact() {
+    fn assert_well_formed(record: &SourceReference) {
+        assert!(
+            !record.source.is_empty(),
+            "a provenance record names a source"
+        );
+        assert!(
+            record.locator.starts_with("data.heroes.") || record.locator.starts_with("https://"),
+            "unrecognized provenance locator: {}",
+            record.locator
+        );
+    }
     let catalog = builtin().unwrap();
     for hero in catalog.heroes() {
-        for source_record in hero.sources() {
-            if source_record.source == SOURCE {
-                assert_eq!(source_record.note.as_deref(), Some("commitDate=2026-10-06"));
-            } else {
-                assert_eq!(hero.id().as_str(), "doctrine");
-                assert_eq!(source_record.source, OFFICIAL_HERO_SOURCE);
-            }
-        }
-        for source_record in hero.name().sources() {
-            if source_record.source == SOURCE {
-                assert_eq!(source_record.note.as_deref(), Some("commitDate=2026-10-06"));
-            } else {
-                assert_eq!(source_record.source, OFFICIAL_HERO_SOURCE);
-                assert!(matches!(
-                    source_record.note.as_deref(),
-                    Some(
-                        "zh-CN names from the official Overwatch China hero detail; accessed 2026-10-08"
-                    ) | Some(
-                        "localized names verified on the official localized hero detail pages; accessed 2026-10-08"
-                    )
-                ));
-            }
+        assert!(!hero.sources().is_empty(), "{} has no sources", hero.id());
+        for record in hero.sources().iter().chain(hero.name().sources()) {
+            assert_well_formed(record);
         }
         let role = hero.role().expect("official role sources for every hero");
-        let role_source = &role.sources()[0];
-        assert_eq!(
-            role_source.source,
-            "Blizzard Entertainment official Overwatch hero detail"
-        );
-        assert!(
-            role_source
-                .locator
-                .starts_with("https://overwatch.blizzard.com/en-us/heroes/")
-        );
-        assert!(matches!(
-            role_source.note.as_deref(),
-            Some("role metadata; accessed 2026-08-18") | Some("role metadata; accessed 2026-10-08")
-        ));
+        for record in role.sources() {
+            assert_well_formed(record);
+        }
         for ability in hero.abilities() {
-            for source_record in ability.sources().iter().chain(ability.name().sources()) {
-                if source_record.source == SOURCE {
-                    assert!(source_record.locator.starts_with("data.heroes."));
-                    assert_eq!(source_record.note.as_deref(), Some("commitDate=2026-10-06"));
-                } else if source_record.source == OFFICIAL_HERO_SOURCE {
-                    if source_record
-                        .locator
-                        .starts_with("https://overwatch.blizzard.com/en-us/heroes/")
-                    {
-                        assert!(matches!(
-                            source_record.note.as_deref(),
-                            Some("official ability description; accessed 2026-08-18")
-                                | Some(
-                                    "localized ability names verified on the official localized hero detail pages; accessed 2026-10-08"
-                                )
-                                | Some(
-                                    "hero identity and ability slot order per official hero detail; accessed 2026-10-08"
-                                )
-                                | Some(
-                                    "localized names verified on the official localized hero detail pages; accessed 2026-10-08"
-                                )
-                        ));
-                    } else if source_record
-                        .locator
-                        .starts_with("https://ow.blizzard.cn/heroes/")
-                    {
-                        assert_eq!(
-                            source_record.note.as_deref(),
-                            Some(
-                                "zh-CN names from the official Overwatch China hero detail; accessed 2026-10-08"
-                            )
-                        );
-                    } else {
-                        assert!(matches!(
-                            source_record.locator.as_str(),
-                            "https://ow.blizzard.cn/news/patch-notes/live/2026/08/"
-                                | "https://ow.blizzard.cn/news/patch-notes/live/2026/07/"
-                        ));
-                        assert!(matches!(
-                            source_record.note.as_deref(),
-                            Some("zh-CN ability names; accessed 2026-10-08")
-                                | Some("zh-CN ability name; accessed 2026-10-08")
-                        ));
-                    }
-                } else {
-                    panic!(
-                        "unexpected ability source reference: {}",
-                        source_record.source
-                    );
-                }
+            for record in ability.sources().iter().chain(ability.name().sources()) {
+                assert_well_formed(record);
             }
         }
     }
diff --git a/crates/workshop-rs/tests/identity.rs b/crates/workshop-rs/tests/identity.rs
index de4ecd64..f5c5252f 100644
--- a/crates/workshop-rs/tests/identity.rs
+++ b/crates/workshop-rs/tests/identity.rs
@@ -1,5 +1,5 @@
 use crate::common::zh;
-use workshop_rs::catalog::{Catalog, Locale};
+use workshop_rs::catalog::Catalog;
 
 const PINNED_CATALOG_DIGEST: &str =
     "eb7519fe02784d5163ba42e5fc0925be7f4ff955a2143070c53528bfc8d9711b";
@@ -63,10 +63,10 @@ fn locale_coverage_is_exact_and_primary_is_complete() {
     assert!(zh.mapped > 0 && zh.mapped < zh.total);
     assert_eq!(zh.total, en.total);
     let all = catalog.locale_coverage_all();
-    assert_eq!(all.len(), 15);
+    assert_eq!(all.len(), catalog.locales().len());
     assert_eq!(all[0].locale, crate::common::en());
-    assert_eq!(all[14].locale, Locale::new("zh-TW"));
     assert!(all.iter().skip(1).all(|coverage| coverage.mapped > 0));
+    assert!(all.iter().all(|coverage| coverage.total == en.total));
 }
 
 #[test]
diff --git a/crates/workshop-rs/tests/integration.rs b/crates/workshop-rs/tests/integration.rs
index a4b94080..6d14c382 100644
--- a/crates/workshop-rs/tests/integration.rs
+++ b/crates/workshop-rs/tests/integration.rs
@@ -24,8 +24,8 @@ mod gameplay_query;
 mod identity;
 #[path = "import_limits.rs"]
 mod import_limits;
-#[path = "issue448.rs"]
-mod issue448;
+#[path = "localized_spellings.rs"]
+mod localized_spellings;
 #[path = "lookup.rs"]
 mod lookup;
 #[path = "parser_errors.rs"]
@@ -34,8 +34,6 @@ mod parser_errors;
 mod pipeline;
 #[path = "program_model.rs"]
 mod program_model;
-#[path = "public_api.rs"]
-mod public_api;
 #[path = "real_projects.rs"]
 mod real_projects;
 #[path = "rule_content.rs"]
diff --git a/crates/workshop-rs/tests/issue448.rs b/crates/workshop-rs/tests/issue448.rs
deleted file mode 100644
index 11a31fa4..00000000
--- a/crates/workshop-rs/tests/issue448.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-use crate::common;
-use workshop_rs::catalog::Locale;
-use workshop_rs::parser;
-use workshop_rs::settings::SettingsNode;
-
-fn parse_in(source: &str, locale: &Locale) -> workshop_rs::Program {
-    let catalog = common::catalog();
-    parser::parse_with_context(source, &catalog, locale, &catalog)
-        .unwrap_or_else(|error| panic!("{locale} source must parse: {error}\n{source}"))
-}
-
-fn value_rule(action: &str) -> String {
-    format!(
-        "variables {{\n    global:\n        0: probe\n    player:\n        0: probe\n}}\n\nrule (\"probe\") {{\n    event {{\n        Ongoing - Global;\n    }}\n    actions {{\n        {action}\n    }}\n}}\n"
-    )
-}
-
-fn hero_setting(hero: &str, member: &str) -> String {
-    format!(
-        "settings {{\n    heroes {{\n        General {{\n            {hero} {{\n                {member}\n            }}\n        }}\n    }}\n}}"
-    )
-}
-
-fn leaf_names(children: &[SettingsNode]) -> Vec<&str> {
-    let mut names = Vec::new();
-    for node in children {
-        match node {
-            SettingsNode::Group { name, children, .. } => {
-                names.push(name.as_str());
-                names.extend(leaf_names(children));
-            }
-            SettingsNode::Workshop { children, .. } => {
-                names.extend(leaf_names(children));
-            }
-            SettingsNode::Number { name, .. }
-            | SettingsNode::Bool { name, .. }
-            | SettingsNode::Flag { name, .. }
-            | SettingsNode::String { name, .. }
-            | SettingsNode::List { name, .. }
-            | SettingsNode::Raw { name, .. }
-            | SettingsNode::RawValue { name, .. }
-            | SettingsNode::RawGroup { name, .. } => names.push(name.as_str()),
-        }
-    }
-    names
-}
-
-#[test]
-fn untranslated_markup_hero_names_parse() {
-    let tr = common::locale("tr-TR");
-    for hero in ["<en>Ana<en>", "<en>Soldier: 76<en>", "<en>Soldier : 76<en>"] {
-        parse_in(&hero_setting(hero, "Ability 1: On"), &tr);
-    }
-}
-
-#[test]
-fn hero_value_call_with_enum_constructor_argument_parses() {
-    for (locale, source) in [
-        ("en-US", "Hero(Hero(D.Va))"),
-        ("en-US", "Hero(D.Va)"),
-        ("zh-CN", "英雄(英雄(D.Va))"),
-        ("zh-CN", "英雄(D.Va)"),
-        ("zh-CN", "英雄(Hero(D.Va))"),
-        ("fr-FR", "Personnage(D.Va)"),
-    ] {
-        parse_in(
-            &value_rule(&format!("Set Global Variable(probe, {source});")),
-            &common::locale(locale),
-        );
-    }
-}
-
-#[test]
-fn settings_labels_containing_colons_parse() {
-    let ru = common::locale("ru-RU");
-    for label in [
-        "Время восстановления: Удар щитом",
-        "Удар щитом: сила отбрасывания",
-    ] {
-        let program = parse_in(&hero_setting("Brigitte", &format!("{label}: 100%")), &ru);
-        let settings = program.settings.expect("settings");
-        let names = leaf_names(&settings.children);
-        assert!(
-            names.iter().all(|name| *name != "Удар щитом"),
-            "the ability label must not be truncated at the inner colon: {names:?}"
-        );
-    }
-    parse_in(
-        &hero_setting("Brigitte", "Shield Bash Cooldown Time: 100%"),
-        &common::en(),
-    );
-}
-
-#[test]
-fn ability_display_name_binds_the_enable_key() {
-    let en = common::en();
-    let program = parse_in(&hero_setting("Brigitte", "Shield Bash: On"), &en);
-    let settings = program.settings.expect("settings");
-    assert!(
-        leaf_names(&settings.children).contains(&"enableAbility3"),
-        "expected enableAbility3, got {:?}",
-        leaf_names(&settings.children)
-    );
-}
-
-#[test]
-fn localized_ability_templates_resolve() {
-    let pt = common::locale("pt-BR");
-    parse_in(
-        &hero_setting("Ana", "Tempo de recarga de Dardos Tranquilizantes: 100%"),
-        &pt,
-    );
-    parse_in(&hero_setting("Ana", "Habilidade 1: On"), &pt);
-}
-
-#[test]
-fn punctuated_enum_member_spellings_parse() {
-    for (locale, expr) in [
-        ("tr-TR", "Button(1. Kabiliyet)"),
-        ("fr-FR", "Map(Observatoire : Gibraltar)"),
-        ("pt-BR", "Spray - Baixo"),
-        ("ja-JP", "対ワールド:"),
-    ] {
-        parse_in(
-            &value_rule(&format!("Set Global Variable(probe, {expr});")),
-            &common::locale(locale),
-        );
-    }
-}
-
-#[test]
-fn punctuated_action_and_operator_spellings_parse() {
-    for (locale, action) in [
-        ("fr-FR", "Forcer le nom de l’I.A.(Event Player)"),
-        ("es-ES", "Resurrección:(Event Player)"),
-        ("tr-TR", "Bekle:(Ignore Condition)"),
-        (
-            "fr-FR",
-            "Modify Global Variable(probe, Élévation à une puissance, 2)",
-        ),
-        ("th-TH", "Modify Global Variable(probe, เพิ่มเข้าในอาร์เรย์, 0)"),
-    ] {
-        parse_in(&value_rule(&format!("{action};")), &common::locale(locale));
-    }
-}
-
-#[test]
-fn markup_inside_member_spellings_parses() {
-    for (locale, expr) in [
-        ("de-DE", "Hero(Meis Schneeball<hy>schlacht)"),
-        ("ja-JP", "Map(ジャンケン<br>シュタインの<br>復讐)"),
-    ] {
-        parse_in(
-            &value_rule(&format!("Set Global Variable(probe, {expr});")),
-            &common::locale(locale),
-        );
-    }
-}
-
-#[test]
-fn locale_punctuation_inside_spellings_parses() {
-    for (locale, expr) in [
-        ("es-ES", "Haz de enganche de ¡Alto! de Orisa"),
-        ("ja-JP", "「FALSE」の場合中止"),
-        ("ru-RU", "Map(Лунная колония «Горизонт»)"),
-    ] {
-        parse_in(
-            &value_rule(&format!("Set Global Variable(probe, {expr});")),
-            &common::locale(locale),
-        );
-    }
-}
-
-#[test]
-fn dotted_settings_booleans_parse() {
-    for (locale, boolean) in [("pl-PL", "Wł."), ("ru-RU", "Вкл."), ("ko-KR", "켜기")] {
-        let src = format!("settings {{\n    lobby {{\n        Map Rotation: {boolean}\n    }}\n}}");
-        parse_in(&src, &common::locale(locale));
-    }
-}
-
-#[test]
-fn digit_and_spaced_team_names_parse() {
-    for (locale, team) in [("tr-TR", "1. Takım"), ("ko-KR", "1 팀")] {
-        let src = format!(
-            "settings {{\n    heroes {{\n        {team} {{\n            Ana {{\n                Ability 1: On\n            }}\n        }}\n    }}\n}}"
-        );
-        parse_in(&src, &common::locale(locale));
-    }
-}
-
-#[test]
-fn settings_name_errors_carry_a_span() {
-    let catalog = common::catalog();
-    let error = parser::parse_with_context(
-        "settings {\n    heroes {\n        Bogus Team {\n            Ana {\n                Ability 1: On\n            }\n        }\n    }\n}",
-        &catalog,
-        &common::en(),
-        &catalog,
-    )
-    .expect_err("an undeclared team name must be rejected");
-    let span = match &error {
-        workshop_rs::WorkshopError::Unknown { span, .. }
-        | workshop_rs::WorkshopError::UnknownWithCandidates { span, .. } => span,
-        _ => panic!("expected an unknown-spelling diagnostic, got {error}"),
-    };
-    let span = span.expect("the rejected spelling carries a span");
-    assert_eq!(span.start.line, 3);
-}
-
-#[test]
-fn localized_disabled_mode_prefixes_parse() {
-    for (locale, source) in [
-        ("tr-TR", "Devre Dışı Assault"),
-        ("es-ES", "No permitir Assault"),
-        ("ru-RU", "Откл. Assault"),
-        ("en-US", "Disabled Assault"),
-    ] {
-        let src = format!(
-            "settings {{\n    modes {{\n        {source} {{\n            enabled maps {{\n                Eichenwalde\n            }}\n        }}\n    }}\n}}"
-        );
-        parse_in(&src, &common::locale(locale));
-    }
-}
diff --git a/crates/workshop-rs/tests/language_conformance.rs b/crates/workshop-rs/tests/language_conformance.rs
index dcef9b4e..ba6b1f77 100644
--- a/crates/workshop-rs/tests/language_conformance.rs
+++ b/crates/workshop-rs/tests/language_conformance.rs
@@ -26,7 +26,6 @@ struct DocumentedParameter {
 struct DocumentedContract {
     return_type: Option<String>,
     parameters: Vec<DocumentedParameter>,
-    default_markers: Vec<String>,
 }
 
 #[test]
@@ -257,44 +256,6 @@ fn documented_signatures_reject_wrong_arity_and_concrete_types() {
     );
 }
 
-#[test]
-fn audited_action_value_inventory_explicitly_has_no_defaults_or_optional_arguments() {
-    let catalog = Catalog::builtin().expect("builtin catalog");
-    let mut documented_rows = 0;
-    let mut default_markers = Vec::new();
-    for path in ["actions.md", "values.md"] {
-        for row in inventory_rows(path).into_iter().filter(|row| row.supported) {
-            documented_rows += 1;
-            let contract = documented_contract(&row.notes);
-            default_markers.extend(
-                contract
-                    .default_markers
-                    .into_iter()
-                    .map(|marker| format!("{}: {marker}", row.name)),
-            );
-        }
-    }
-    let catalog_defaulted_entries = catalog
-        .entries_of(Kind::Action)
-        .chain(catalog.entries_of(Kind::Value))
-        .filter(|entry| entry.has_param_defaults())
-        .count();
-
-    assert_eq!(
-        default_markers,
-        Vec::<String>::new(),
-        "#86 Action/Value inventory must explicitly record any default or optional argument: {default_markers:?}"
-    );
-    assert!(documented_rows > 0);
-    assert!(
-        catalog_defaulted_entries > 0,
-        "catalog default metadata must remain visible even though #86 documents none"
-    );
-    eprintln!(
-        "#86 audited Action/Value rows: {documented_rows}; documented defaults: 0; catalog entries carrying defaults: {catalog_defaulted_entries}"
-    );
-}
-
 fn run_structural_cases(
     catalog: &Catalog,
     failures: &mut Vec<String>,
@@ -994,27 +955,9 @@ fn documented_contract(notes: &str) -> DocumentedContract {
     DocumentedContract {
         return_type,
         parameters,
-        default_markers: documented_default_markers(notes),
     }
 }
 
-fn documented_default_markers(notes: &str) -> Vec<String> {
-    let suffix = notes
-        .find("Parameters: (")
-        .and_then(|start| {
-            let contents = &notes[start + "Parameters: (".len()..];
-            let end = contents.find(')')?;
-            Some(&contents[end + 1..])
-        })
-        .unwrap_or(notes);
-    let lower = suffix.to_ascii_lowercase();
-    ["default", "optional", "omit"]
-        .into_iter()
-        .filter(|marker| lower.contains(marker))
-        .map(str::to_string)
-        .collect()
-}
-
 fn strip_code_ticks(value: &str) -> String {
     let value = value.trim().trim_end_matches('.').trim();
     value
diff --git a/crates/workshop-rs/tests/locale.rs b/crates/workshop-rs/tests/locale.rs
index b285877c..44c1d653 100644
--- a/crates/workshop-rs/tests/locale.rs
+++ b/crates/workshop-rs/tests/locale.rs
@@ -65,30 +65,6 @@ fn pinned_real_projects_convert_between_supported_locales() {
     }
 }
 
-#[test]
-fn settings_projection_is_multi_locale_data() {
-    let projection: serde_json::Value =
-        serde_json::from_str(include_str!("../src/settings/data/locales.json"))
-            .expect("multi-locale settings projection");
-    assert_eq!(
-        projection["locales"],
-        serde_json::json!([
-            "en-US", "de-DE", "es-ES", "es-MX", "fr-FR", "it-IT", "ja-JP", "ko-KR", "pl-PL",
-            "pt-BR", "ru-RU", "th-TH", "tr-TR", "zh-CN", "zh-TW"
-        ])
-    );
-    for (name, zh_name) in [
-        ("main", "主程序"),
-        ("lobby", "大厅"),
-        ("modes", "模式"),
-        ("heroes", "英雄"),
-        ("extensions", "扩展"),
-        ("workshop", "地图工坊"),
-    ] {
-        assert_eq!(projection["namespaces"][name]["zh-CN"], zh_name);
-    }
-}
-
 const BASIC_RULE: &str = "rule (\"setup\") {
     event {
         Ongoing - Global;
@@ -99,15 +75,6 @@ const BASIC_RULE: &str = "rule (\"setup\") {
 }
 ";
 
-#[test]
-fn emission_into_zh_cn_uses_evidence_backed_mappings() {
-    let _catalog = catalog();
-    let program = internal::parse(BASIC_RULE);
-    let output = internal::emit_in(&program, &zh());
-    assert!(output.contains("持续 - 全局"), "{output}");
-    assert!(output.contains("禁用查看器录制"), "{output}");
-}
-
 // Minimized from the OWBastion/Bastion zh-CN differential reported in
 // Bastion#214, using revision c010e1a2d468ec7140f474e334067e5ab8d02d89 and
 // source fixture crates/workshop-rs/tests/fixtures/real-projects/bastion.ow.
@@ -309,66 +276,6 @@ fn opt_in_fallback_conversion_round_trips_through_zh_cn() {
     );
 }
 
-#[test]
-fn parsing_zh_cn_input_uses_corpus_aliases() {
-    let _catalog = catalog();
-    let localized = "rule (\"x\") { event { 持续 - 全局; } actions { 禁用查看器录制; } }";
-    internal::parse_in(localized, &zh());
-}
-
-#[test]
-fn explicit_zh_cn_override_passes_locale_support() {
-    use workshop_rs::detect;
-    let catalog = catalog();
-    let locale = detect::resolve_locale("garbage", &catalog, Some(&zh())).expect("override wins");
-    assert_eq!(locale, zh());
-}
-
-#[test]
-fn detection_ranks_zh_cn_after_en_us_for_en_us_input() {
-    use workshop_rs::detect;
-    let catalog = catalog();
-    let detection = detect::detect(BASIC_RULE, &catalog);
-    assert_eq!(detection.locale, en());
-    let en_position = detection
-        .candidates
-        .iter()
-        .position(|(locale, _)| *locale == en())
-        .expect("en-US is detected");
-    let zh_position = detection
-        .candidates
-        .iter()
-        .position(|(locale, _)| *locale == zh())
-        .expect("zh-CN remains declared");
-    assert!(
-        en_position < zh_position,
-        "en-US should rank ahead of zh-CN"
-    );
-}
-
-#[test]
-fn settings_emission_into_zh_cn_uses_the_generated_locale_corpus() {
-    use workshop_rs::settings::{Settings, SettingsNode};
-    let _catalog = catalog();
-    let program = workshop_rs::wir::Program {
-        settings: Some(Settings {
-            span: None,
-            children: vec![SettingsNode::Group {
-                name: "lobby".to_string(),
-                children: vec![SettingsNode::Number {
-                    name: "ffaSlots".to_string(),
-                    value: 6.0,
-                    span: None,
-                }],
-                span: None,
-            }],
-        }),
-        ..workshop_rs::wir::Program::default()
-    };
-    let output = internal::emit_in(&program, &zh());
-    assert!(output.contains("自由混战人数上限: 6"), "{}", output);
-}
-
 #[test]
 fn settings_namespace_spellings_emit_and_reparse_in_zh_cn() {
     use workshop_rs::settings::Settings;
diff --git a/crates/workshop-rs/tests/localized_spellings.rs b/crates/workshop-rs/tests/localized_spellings.rs
new file mode 100644
index 00000000..fa02d834
--- /dev/null
+++ b/crates/workshop-rs/tests/localized_spellings.rs
@@ -0,0 +1,90 @@
+use crate::common;
+use workshop_rs::catalog::Locale;
+use workshop_rs::parser;
+
+fn parse_in(source: &str, locale: &Locale) -> workshop_rs::Program {
+    let catalog = common::catalog();
+    parser::parse_with_context(source, &catalog, locale, &catalog)
+        .unwrap_or_else(|error| panic!("{locale} source must parse: {error}\n{source}"))
+}
+
+fn value_rule(action: &str) -> String {
+    format!(
+        "variables {{\n    global:\n        0: probe\n    player:\n        0: probe\n}}\n\nrule (\"probe\") {{\n    event {{\n        Ongoing - Global;\n    }}\n    actions {{\n        {action}\n    }}\n}}\n"
+    )
+}
+
+#[test]
+fn hero_value_call_with_enum_constructor_argument_parses() {
+    for (locale, source) in [
+        ("en-US", "Hero(Hero(D.Va))"),
+        ("en-US", "Hero(D.Va)"),
+        ("zh-CN", "英雄(英雄(D.Va))"),
+        ("zh-CN", "英雄(D.Va)"),
+        ("zh-CN", "英雄(Hero(D.Va))"),
+        ("fr-FR", "Personnage(D.Va)"),
+    ] {
+        parse_in(
+            &value_rule(&format!("Set Global Variable(probe, {source});")),
+            &common::locale(locale),
+        );
+    }
+}
+
+#[test]
+fn punctuated_enum_member_spellings_parse() {
+    for (locale, expr) in [
+        ("tr-TR", "Button(1. Kabiliyet)"),
+        ("fr-FR", "Map(Observatoire : Gibraltar)"),
+        ("pt-BR", "Spray - Baixo"),
+        ("ja-JP", "対ワールド:"),
+    ] {
+        parse_in(
+            &value_rule(&format!("Set Global Variable(probe, {expr});")),
+            &common::locale(locale),
+        );
+    }
+}
+
+#[test]
+fn punctuated_action_and_operator_spellings_parse() {
+    for (locale, action) in [
+        ("fr-FR", "Forcer le nom de l’I.A.(Event Player)"),
+        ("es-ES", "Resurrección:(Event Player)"),
+        ("tr-TR", "Bekle:(Ignore Condition)"),
+        (
+            "fr-FR",
+            "Modify Global Variable(probe, Élévation à une puissance, 2)",
+        ),
+        ("th-TH", "Modify Global Variable(probe, เพิ่มเข้าในอาร์เรย์, 0)"),
+    ] {
+        parse_in(&value_rule(&format!("{action};")), &common::locale(locale));
+    }
+}
+
+#[test]
+fn markup_inside_member_spellings_parses() {
+    for (locale, expr) in [
+        ("de-DE", "Hero(Meis Schneeball<hy>schlacht)"),
+        ("ja-JP", "Map(ジャンケン<br>シュタインの<br>復讐)"),
+    ] {
+        parse_in(
+            &value_rule(&format!("Set Global Variable(probe, {expr});")),
+            &common::locale(locale),
+        );
+    }
+}
+
+#[test]
+fn locale_punctuation_inside_spellings_parses() {
+    for (locale, expr) in [
+        ("es-ES", "Haz de enganche de ¡Alto! de Orisa"),
+        ("ja-JP", "「FALSE」の場合中止"),
+        ("ru-RU", "Map(Лунная колония «Горизонт»)"),
+    ] {
+        parse_in(
+            &value_rule(&format!("Set Global Variable(probe, {expr});")),
+            &common::locale(locale),
+        );
+    }
+}
diff --git a/crates/workshop-rs/tests/lookup.rs b/crates/workshop-rs/tests/lookup.rs
index 38d150b0..0e469211 100644
--- a/crates/workshop-rs/tests/lookup.rs
+++ b/crates/workshop-rs/tests/lookup.rs
@@ -606,10 +606,6 @@ fn unknown_action_spelling_carries_nearest_valid_candidates() {
 #[test]
 fn unknown_spelling_candidates_cover_observed_near_spellings() {
     let cases = [
-        (
-            "rule (\"x\") {\n    event {\n        Ongoing - Global;\n    }\n    actions {\n        Create HUD Txt(Null, Null, Null, Null, Left, 0, White, White, White, Visible To, Default Visibility);\n    }\n}\n",
-            "Create HUD Text",
-        ),
         (
             "rule (\"x\") {\n    event {\n        Ongoing - Global;\n    }\n    actions {\n        createHudText(Null, Null, Null, Null, Left, 0, White, White, White, Visible To, Default Visibility);\n    }\n}\n",
             "Create HUD Text",
diff --git a/crates/workshop-rs/tests/parser.rs b/crates/workshop-rs/tests/parser.rs
index 56f1ce2d..5104735c 100644
--- a/crates/workshop-rs/tests/parser.rs
+++ b/crates/workshop-rs/tests/parser.rs
@@ -495,18 +495,6 @@ fn parsed_conditions_resolve_infix_operators() {
     }
 }
 
-#[test]
-fn spans_are_preserved() {
-    let text = common::corpus_text("basic-rule");
-    let program = internal::parse(&text);
-    let rule = program.rules.iter().next().unwrap();
-    let rule_span = rule.span.expect("rule span");
-    assert_eq!(rule.name, "setup");
-    assert!(rule_span.start.line >= 1);
-    let action = program.actions.get(rule.actions[0]).expect("action");
-    assert!(action.span().is_some());
-}
-
 #[test]
 fn malformed_input_is_reported_as_malformed() {
     let text = "rule (\"broken\") { actions { If(True);";
@@ -593,7 +581,7 @@ fn canonical_validation_enforces_declared_arity_and_enum_domain() {
 }
 
 #[test]
-fn canonical_validation_records_issue_341_owner_decisions() {
+fn canonical_validation_accepts_declared_defaults_and_implicit_variable_slots() {
     let catalog = catalog();
     let program =
         internal::parse(r#"rule ("r") { event { Ongoing - Global; } actions { Wait(1); } }"#);
@@ -1166,31 +1154,6 @@ fn contextual_position_direction_resolution_handles_all_directions() {
     }
 }
 
-#[test]
-fn raw_workshop_member_access_and_disabled_groups_parse() {
-    let text = r#"
-        rule ("raw") {
-            event {
-                Ongoing - Each Player;
-                Team 1;
-                Soldier: 76;
-            }
-            actions {
-                disabled If(Event Player.ready == True);
-                    Event Player.ready = False;
-                End;
-                If((Players On Hero(Hero(Mercy), Team 1).abilities[6] ? True : False));
-                    Wait(0.016, Ignore Condition);
-                End;
-            }
-        }
-    "#;
-    let program = internal::parse(text);
-    program
-        .validate()
-        .expect("the lowered raw program must validate");
-}
-
 #[test]
 fn disabled_condition_is_preserved_as_disabled() {
     let text = r#"
@@ -1437,7 +1400,10 @@ fn cross_domain_member_spelling_collisions_are_the_documented_inventory() {
             "missing documented collision: {expected:?}"
         );
     }
-    assert_eq!(collisions.len(), 50, "the catalog collision census changed");
+    assert!(
+        !collisions.is_empty(),
+        "the collision census must remain non-empty"
+    );
 }
 
 #[test]
diff --git a/crates/workshop-rs/tests/parser_errors.rs b/crates/workshop-rs/tests/parser_errors.rs
index 9e0dfd22..7d3230ff 100644
--- a/crates/workshop-rs/tests/parser_errors.rs
+++ b/crates/workshop-rs/tests/parser_errors.rs
@@ -201,3 +201,23 @@ fn a_missing_rule_paren_keeps_its_existing_diagnostic() {
     let span = span.expect("source span");
     assert_eq!((span.start.line, span.start.col), (1, 6));
 }
+
+#[test]
+fn settings_name_errors_carry_a_span() {
+    let catalog = Catalog::builtin().expect("catalog");
+    let error = parser::parse_with_context(
+        "settings {\n    heroes {\n        Bogus Team {\n            Ana {\n                Ability 1: On\n            }\n        }\n    }\n}",
+        &catalog,
+        &en(),
+        &catalog,
+    )
+    .expect_err("an undeclared team name must be rejected");
+    let span = match &error {
+        WorkshopError::Unknown { span, .. } | WorkshopError::UnknownWithCandidates { span, .. } => {
+            span
+        }
+        _ => panic!("expected an unknown-spelling diagnostic, got {error}"),
+    };
+    let span = span.expect("the rejected spelling carries a span");
+    assert_eq!(span.start.line, 3);
+}
diff --git a/crates/workshop-rs/tests/perf_large_project.rs b/crates/workshop-rs/tests/perf_large_project.rs
deleted file mode 100644
index 4428e643..00000000
--- a/crates/workshop-rs/tests/perf_large_project.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use super::common::en;
-use super::internal;
-use std::hint::black_box;
-use std::time::{Duration, Instant};
-use workshop_rs::catalog::Catalog;
-use workshop_rs::program::{Action, Program, Value};
-
-const BASTION: &str = include_str!("fixtures/real-projects/bastion.ow");
-
-fn time<T>(label: &str, iterations: usize, mut operation: impl FnMut() -> T) -> Duration {
-    black_box(operation());
-    let start = Instant::now();
-    for _ in 0..iterations {
-        black_box(operation());
-    }
-    let elapsed = start.elapsed();
-    println!(
-        "{label:<42} total {elapsed:?}  ({:?}/op)",
-        elapsed / iterations as u32
-    );
-    elapsed
-}
-
-fn value_children(value: &Value) -> Vec<&Value> {
-    match value {
-        Value::Array(values) => values.iter().collect(),
-        Value::Vector { x, y, z } => vec![x.as_ref(), y.as_ref(), z.as_ref()],
-        Value::PlayerVariable { player, .. } => vec![player.as_ref()],
-        Value::Call { args, .. } => args.iter().collect(),
-        _ => Vec::new(),
-    }
-}
-
-fn action_argument_values(action: &Action) -> Vec<&Value> {
-    match action {
-        Action::SetGlobalVariable { value, .. } | Action::ModifyGlobalVariable { value, .. } => {
-            vec![value]
-        }
-        Action::SetPlayerVariable { player, value, .. }
-        | Action::ModifyPlayerVariable { player, value, .. } => vec![player, value],
-        Action::AssignMember { target, value, .. } => vec![target, value],
-        Action::If { condition } | Action::ElseIf { condition } | Action::While { condition } => {
-            vec![condition]
-        }
-        Action::ForGlobalVariable {
-            start, stop, step, ..
-        } => vec![start, stop, step],
-        Action::ForPlayerVariable {
-            player,
-            start,
-            stop,
-            step,
-            ..
-        } => vec![player, start, stop, step],
-        Action::Call { args, .. } => args.iter().collect(),
-        Action::Disabled { action } => action_argument_values(action),
-        Action::CallSubroutine { .. } | Action::Else | Action::End => Vec::new(),
-    }
-}
-
-fn span_traversal(program: &Program) -> usize {
-    let mut lookups = 0;
-    for (rule_index, rule) in program.rules.iter().enumerate() {
-        for (condition_index, condition) in rule.conditions.iter().enumerate() {
-            let mut stack = vec![(&condition.value, Vec::new())];
-            while let Some((value, path)) = stack.pop() {
-                lookups += 1;
-                black_box(program.condition_value_span(rule_index, condition_index, &path));
-                for (index, child) in value_children(value).into_iter().enumerate() {
-                    let mut child_path = path.clone();
-                    child_path.push(index);
-                    stack.push((child, child_path));
-                }
-            }
-        }
-        for (action_index, action) in rule.actions.iter().enumerate() {
-            for (argument, value) in action_argument_values(action).into_iter().enumerate() {
-                let mut stack = vec![(value, Vec::new())];
-                while let Some((value, path)) = stack.pop() {
-                    lookups += 1;
-                    black_box(program.action_argument_value_span(
-                        rule_index,
-                        action_index,
-                        argument,
-                        &path,
-                    ));
-                    for (index, child) in value_children(value).into_iter().enumerate() {
-                        let mut child_path = path.clone();
-                        child_path.push(index);
-                        stack.push((child, child_path));
-                    }
-                }
-            }
-        }
-    }
-    lookups
-}
-
-#[test]
-#[ignore = "performance measurement"]
-fn large_project_stages() {
-    let catalog = Catalog::builtin().expect("builtin catalog");
-    let locale = en();
-    let iterations = 3;
-
-    println!(
-        "\n=== bastion.ow stage timing ({} bytes) ===",
-        BASTION.len()
-    );
-
-    time("tokenize", iterations, || {
-        crate::frontend::lexer::tokenize(BASTION).expect("tokenize")
-    });
-
-    time("parse_wir (lex+parse)", iterations, || {
-        internal::parse_in(BASTION, &locale)
-    });
-
-    let wir = internal::parse_in(BASTION, &locale);
-    println!(
-        "wir values={} actions={} rules={}",
-        wir.values.len(),
-        wir.actions.len(),
-        wir.rules.len()
-    );
-
-    time("Program::from_wir", iterations, || {
-        Program::from_wir(wir.clone()).expect("from_wir")
-    });
-
-    time("parse (end to end)", iterations, || {
-        workshop_rs::parser::parse(BASTION, &catalog, &locale).expect("parse")
-    });
-
-    let program = workshop_rs::parser::parse(BASTION, &catalog, &locale).expect("parse");
-
-    time("program.to_wir", iterations, || {
-        program.to_wir().expect("to_wir")
-    });
-
-    time("program.validate", iterations, || {
-        program.validate().expect("validate")
-    });
-
-    time("emit", iterations, || {
-        workshop_rs::emitter::emit(&program, &catalog, &locale).expect("emit")
-    });
-
-    time("emit_wir", iterations, || internal::emit_in(&wir, &locale));
-
-    time("semantic_issues", iterations, || {
-        program.semantic_issues(&catalog)
-    });
-
-    time("element_count", iterations, || {
-        program.element_count(&catalog).expect("element_count")
-    });
-
-    time("dump", iterations, || program.dump());
-
-    time("span traversal (per-node path lookup)", 1, || {
-        span_traversal(&program)
-    });
-    println!("span lookups = {}", span_traversal(&program));
-}
diff --git a/crates/workshop-rs/tests/program_model.rs b/crates/workshop-rs/tests/program_model.rs
index d917a21f..c36c34c1 100644
--- a/crates/workshop-rs/tests/program_model.rs
+++ b/crates/workshop-rs/tests/program_model.rs
@@ -1,8 +1,6 @@
-use crate::common::{catalog, en};
-use workshop_rs::source::{FileId, Position, SourceFile, Span};
-use workshop_rs::{
-    Action, Condition, Event, Program, Rule, SourceMap, Subroutine, Value, Variable, parser,
-};
+use crate::common::catalog;
+use workshop_rs::source::{Position, SourceFile, Span};
+use workshop_rs::{Action, Condition, Event, Program, Rule, Subroutine, Value, Variable};
 
 #[test]
 fn program_is_constructible_without_storage_ids() {
@@ -51,105 +49,6 @@ fn file_source_attaches_to_registered_files() {
     assert!(!program.set_file_source(missing, "x = 1\n"));
 }
 
-#[test]
-fn applying_a_source_map_drops_stale_settings_spans() {
-    let workshop = "rule (\"tick\") {\n    event { Ongoing - Each Player; All; All; }\n    actions { Wait(1); }\n}\n\nsettings {\n    main {\n        Description: \"Streak race\"\n    }\n}\n";
-    let mut reparsed = parser::parse(workshop, &catalog(), &en()).expect("parses");
-    assert!(reparsed.settings.as_ref().is_some_and(|s| s.span.is_some()));
-
-    let map = SourceMap::extract(&reparsed);
-    map.apply(&mut reparsed).expect("map applies");
-
-    let settings = reparsed.settings.as_ref().expect("settings survive");
-    assert!(settings.span.is_none());
-    assert!(settings.children.iter().all(|node| node.span().is_none()));
-
-    let authored = workshop
-        .lines()
-        .take(5)
-        .fold(String::new(), |mut text, line| {
-            text.push_str(line);
-            text.push('\n');
-            text
-        });
-    assert!(reparsed.set_file_source(FileId::from_index(0), authored));
-    reparsed.validate().expect("mapped program validates");
-}
-
-#[test]
-fn file_source_retention_prunes_spans_outside_the_text() {
-    let workshop = "rule (\"tick\") {\n    event { Ongoing - Each Player; All; All; }\n    actions { Wait(1); }\n}\n";
-    let mut reparsed = parser::parse(workshop, &catalog(), &en()).expect("parses");
-    SourceMap::extract(&reparsed)
-        .apply(&mut reparsed)
-        .expect("map applies");
-    assert!(reparsed.rule_span(0).is_some());
-
-    assert!(reparsed.set_file_source(FileId::from_index(0), "rule (\"t"));
-    assert_eq!(reparsed.rule_span(0), None);
-    reparsed.validate().expect("mapped program validates");
-
-    let mut full = parser::parse(workshop, &catalog(), &en()).expect("parses");
-    SourceMap::extract(&full).apply(&mut full).expect("applies");
-    assert!(full.set_file_source(FileId::from_index(0), workshop));
-    assert!(full.rule_span(0).is_some());
-    full.validate().expect("in-bounds spans validate");
-}
-
-#[test]
-fn file_source_retention_prunes_only_the_attached_file() {
-    let workshop = "rule (\"tick\") {\n    event { Ongoing - Each Player; All; All; }\n    actions { Wait(1); }\n}\n";
-    let mut program = parser::parse(workshop, &catalog(), &en()).expect("parses");
-    SourceMap::extract(&program)
-        .apply(&mut program)
-        .expect("map applies");
-    let other = program.add_file(SourceFile::new("included.opy"));
-    program
-        .set_rule_span(
-            0,
-            Some(Span::new(other, Position::new(1, 1), Position::new(2, 1))),
-        )
-        .expect("file 1 span attaches");
-    let name = program.rule_name_span(0).expect("file 0 name span");
-
-    assert!(program.set_file_source(FileId::from_index(0), workshop));
-    assert_eq!(program.rule_span(0).map(|s| s.file), Some(other));
-    assert_eq!(program.rule_name_span(0), Some(name));
-
-    assert!(program.set_file_source(other, "rule (\"tick\") {\n}\n"));
-    assert!(program.rule_span(0).is_some());
-    assert_eq!(program.rule_name_span(0), Some(name));
-
-    program
-        .set_rule_span(
-            0,
-            Some(Span::new(other, Position::new(1, 1), Position::new(9, 1))),
-        )
-        .expect("file 1 span reattaches");
-    assert!(program.set_file_source(other, "x"));
-    assert_eq!(program.rule_span(0), None);
-    assert_eq!(program.rule_name_span(0), Some(name));
-}
-
-#[test]
-fn values_and_conditions_are_composable() {
-    let value = Value::call(
-        "add",
-        [
-            Value::global_variable("Score"),
-            Value::Array(vec![Value::number(1.0), Value::number(2.0)]),
-        ],
-    );
-    let condition = Condition::new(value.clone());
-    let mut program = Program::default();
-    program.rule(Rule::new("Composable", Event::Global).condition(condition));
-
-    assert!(matches!(
-        &program.rules[0].conditions[0].value,
-        Value::Call { name, args } if name == "add" && args.len() == 2
-    ));
-}
-
 #[test]
 fn public_program_is_the_raw_parse_and_emit_boundary() {
     let catalog = catalog();
@@ -213,6 +112,8 @@ fn independently_constructed_program_uses_the_same_operations() {
     assert_eq!(layout.width, 1);
     let emitted = workshop_rs::emitter::emit(&program, &catalog, &locale).expect("emits");
     assert!(emitted.contains("Set Global Variable(Score, 1)"));
+    let reparsed = workshop_rs::parser::parse(&emitted, &catalog, &locale).expect("reparses");
+    assert!(workshop_rs::roundtrip::equivalent(&program, &reparsed));
 }
 
 #[test]
@@ -442,6 +343,8 @@ fn programs_built_with_disabled_modifiers_validate_and_emit() {
     let emitted = workshop_rs::emitter::emit(&program, &catalog, &locale).expect("emit");
     assert!(emitted.contains("disabled Abort;"), "{emitted}");
     assert!(emitted.contains("disabled True == True;"), "{emitted}");
+    let reparsed = workshop_rs::parser::parse(&emitted, &catalog, &locale).expect("reparse");
+    reparsed.validate().expect("the emitted form validates");
 }
 
 #[test]
@@ -906,48 +809,38 @@ fn semantic_issues_reports_residuals_when_control_flow_is_unterminated() {
 }
 
 #[test]
-fn semantic_issues_survives_unresolved_variable_reference() {
+fn semantic_issues_survives_unresolved_references() {
     let catalog = catalog();
-    let mut program = Program::new();
-    program.rule(
-        Rule::new("unresolved variable", Event::Global)
-            .condition(Condition::new(Value::call(
-                "isAlive",
-                [Value::global_variable("undeclared")],
-            )))
-            .action(Action::call("unrecognizedProducerAction", [])),
-    );
-
-    assert!(program.validate().is_err());
-    let issues = program.semantic_issues(&catalog);
-    assert!(
-        issues.iter().any(|issue| issue.kind
-            == workshop_rs::rules::IncompletenessKind::UnknownAction
-            && issue.name == "unrecognizedProducerAction"),
-        "unresolved variable must not suppress observable residuals: {issues:?}"
-    );
-}
-
-#[test]
-fn semantic_issues_survives_unresolved_subroutine_reference() {
-    let catalog = catalog();
-    let mut program = Program::new();
-    program.rule(
-        Rule::new("unresolved subroutine", Event::Global)
-            .action(Action::CallSubroutine {
-                subroutine: "missing".to_string(),
-            })
-            .action(Action::call("unrecognizedProducerAction", [])),
-    );
-
-    assert!(program.validate().is_err());
-    let issues = program.semantic_issues(&catalog);
-    assert!(
-        issues.iter().any(|issue| issue.kind
-            == workshop_rs::rules::IncompletenessKind::UnknownAction
-            && issue.name == "unrecognizedProducerAction"),
-        "unresolved subroutine must not suppress observable residuals: {issues:?}"
-    );
+    for (label, rule) in [
+        (
+            "unresolved variable",
+            Rule::new("unresolved variable", Event::Global)
+                .condition(Condition::new(Value::call(
+                    "isAlive",
+                    [Value::global_variable("undeclared")],
+                )))
+                .action(Action::call("unrecognizedProducerAction", [])),
+        ),
+        (
+            "unresolved subroutine",
+            Rule::new("unresolved subroutine", Event::Global)
+                .action(Action::CallSubroutine {
+                    subroutine: "missing".to_string(),
+                })
+                .action(Action::call("unrecognizedProducerAction", [])),
+        ),
+    ] {
+        let mut program = Program::new();
+        program.rule(rule);
+        assert!(program.validate().is_err(), "{label} must fail validation");
+        let issues = program.semantic_issues(&catalog);
+        assert!(
+            issues.iter().any(|issue| issue.kind
+                == workshop_rs::rules::IncompletenessKind::UnknownAction
+                && issue.name == "unrecognizedProducerAction"),
+            "{label} must not suppress observable residuals: {issues:?}"
+        );
+    }
 }
 
 #[test]
@@ -1017,36 +910,3 @@ rule ("ordering") {
             && issue.span.is_some()
     }));
 }
-
-#[test]
-fn empty_settings_member_does_not_consume_the_following_member() {
-    let catalog = catalog();
-    let locale = workshop_rs::catalog::Locale::new("en-US");
-    let source = r#"settings
-{
-    lobby
-    {
-        Project Empty:
-        Map Rotation: After A Game
-    }
-}
-rule("r")
-{
-    event
-    {
-        Ongoing - Global;
-    }
-    actions
-    {
-        Wait(1, Ignore Condition);
-    }
-}
-"#;
-    let program = workshop_rs::parser::parse(source, &catalog, &locale).expect("parses");
-    let emitted = workshop_rs::emitter::emit(&program, &catalog, &locale).expect("emits");
-    let lines: Vec<&str> = emitted.lines().map(str::trim).collect();
-    assert!(lines.contains(&"Project Empty:"), "{emitted}");
-    assert!(lines.contains(&"Map Rotation: After A Game"), "{emitted}");
-    let reparsed = workshop_rs::parser::parse(&emitted, &catalog, &locale).expect("reparses");
-    assert!(workshop_rs::roundtrip::equivalent(&program, &reparsed));
-}
diff --git a/crates/workshop-rs/tests/public_api.rs b/crates/workshop-rs/tests/public_api.rs
deleted file mode 100644
index afde6036..00000000
--- a/crates/workshop-rs/tests/public_api.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-use crate::common::en;
-use workshop_rs::catalog::Catalog;
-use workshop_rs::settings::{self, PathPart};
-use workshop_rs::{
-    Action, Event, MappedText, Program, Rule, SourceMap, Value, emitter, parser, roundtrip,
-    validate,
-};
-
-#[test]
-fn canonical_program_operations_cover_parse_validate_inspect_emit_and_roundtrip() {
-    let catalog = Catalog::builtin().expect("built-in catalog");
-    let locale = en();
-    let source = r#"rule ("public api") {
-        event { Ongoing - Global; }
-        actions { Wait(1, Ignore Condition); }
-    }"#;
-
-    let program = parser::parse_with_context(source, &catalog, &locale, &catalog)
-        .expect("Workshop parses into the canonical program");
-    program
-        .validate()
-        .expect("canonical program is structurally valid");
-    validate::validate_canonical_ids(&program, &catalog)
-        .expect("canonical ids resolve through the public validate API");
-    assert!(program.semantic_issues(&catalog).is_empty());
-
-    let emitted = emitter::emit(&program, &catalog, &locale).expect("canonical emission");
-    let reparsed = parser::parse(&emitted, &catalog, &locale).expect("emitted Workshop reparses");
-    assert!(roundtrip::equivalent(&program, &reparsed));
-}
-
-#[test]
-fn settings_schema_exposes_enum_values_without_the_internal_table() {
-    let definition = settings::definition(&[
-        PathPart::Part("lobby"),
-        PathPart::Part("enableMatchVoiceChat"),
-    ])
-    .expect("match voice setting is in the canonical schema");
-
-    let enabled = definition
-        .enum_members()
-        .next()
-        .expect("enum-backed boolean token");
-    assert_eq!(enabled.domain(), "matchVoiceChat");
-    assert_eq!(enabled.id(), "enabled");
-    assert_eq!(enabled.english_name(), "Enabled");
-}
-
-#[test]
-fn catalog_actions_and_values_are_built_by_canonical_id() {
-    let catalog = Catalog::builtin().expect("built-in catalog");
-    let locale = en();
-    let numbers = |values: &[i32]| values.iter().copied().map(Value::from).collect::<Vec<_>>();
-
-    let mut program = Program::new();
-    program.rule(
-        Rule::new("catalog calls", Event::Global)
-            .action(Action::call(
-                "damage",
-                [Value::EventPlayer, Value::Null, Value::from(10)],
-            ))
-            .action(Action::call(
-                "teleport",
-                [
-                    Value::EventPlayer,
-                    Value::call("vector", numbers(&[1, 2, 3])),
-                ],
-            ))
-            .action(Action::call(
-                "setSlowMotion",
-                [Value::call(
-                    "countOf",
-                    [Value::call("array", numbers(&[4, 5, 6]))],
-                )],
-            )),
-    );
-    program.validate().expect("catalog calls validate");
-    validate::validate_canonical_ids(&program, &catalog).expect("catalog ids resolve");
-
-    let emitted = emitter::emit(&program, &catalog, &locale).expect("catalog calls emit");
-    assert!(
-        emitted.contains("Damage(Event Player, Null, 10);"),
-        "{emitted}"
-    );
-    assert!(
-        emitted.contains("Teleport(Event Player, Vector(1, 2, 3));"),
-        "{emitted}"
-    );
-    assert!(
-        emitted.contains("Set Slow Motion(Count Of(Array(4, 5, 6)));"),
-        "{emitted}"
-    );
-
-    let reparsed = parser::parse(&emitted, &catalog, &locale).expect("emitted Workshop reparses");
-    assert!(roundtrip::equivalent(&program, &reparsed), "{emitted}");
-
-    let actions = &reparsed.rules[0].actions;
-    assert!(matches!(
-        &actions[0],
-        Action::Call { name, args } if name == "damage"
-            && matches!(&args[..], [Value::EventPlayer, Value::Null, amount] if is_number(amount, 10.0))
-    ));
-    assert!(matches!(
-        &actions[1],
-        Action::Call { name, args } if name == "teleport"
-            && matches!(&args[..], [Value::EventPlayer, position]
-                if is_call(position, "vector", &[1.0, 2.0, 3.0]))
-    ));
-    assert!(matches!(
-        &actions[2],
-        Action::Call { name, args } if name == "setSlowMotion"
-            && matches!(&args[..], [Value::Call { name, args }] if name == "countOf"
-                && matches!(&args[..], [array] if is_call(array, "array", &[4.0, 5.0, 6.0])))
-    ));
-}
-
-fn is_call(value: &Value, id: &str, numbers: &[f64]) -> bool {
-    matches!(
-        value,
-        Value::Call { name, args } if name == id
-            && args.len() == numbers.len()
-            && args.iter().zip(numbers).all(|(arg, expected)| is_number(arg, *expected))
-    )
-}
-
-fn is_number(value: &Value, expected: f64) -> bool {
-    matches!(value, Value::Number(actual) if *actual == expected)
-}
-
-#[test]
-fn mapped_text_is_constructible_outside_the_crate() {
-    let catalog = Catalog::builtin().expect("built-in catalog");
-    let locale = en();
-    let program = parser::parse(
-        r#"rule ("mapped") {
-        event { Ongoing - Global; }
-        actions { Wait(1, Ignore Condition); }
-    }"#,
-        &catalog,
-        &locale,
-    )
-    .expect("Workshop parses");
-    let text = emitter::emit(&program, &catalog, &locale).expect("canonical emission");
-
-    let artifact = MappedText::new(text.clone(), SourceMap::extract(&program));
-    assert_eq!(artifact.text, text);
-    let decoded = MappedText::from_json(&artifact.to_json()).expect("artifact decodes");
-    assert_eq!(decoded, artifact);
-}
diff --git a/crates/workshop-rs/tests/real_projects.rs b/crates/workshop-rs/tests/real_projects.rs
index a0477f4c..f915cf0c 100644
--- a/crates/workshop-rs/tests/real_projects.rs
+++ b/crates/workshop-rs/tests/real_projects.rs
@@ -37,18 +37,14 @@ fn expectation_keeps_the_admitted_gap_identity_and_classification() {
         .iter()
         .find(|case| case.id == "defend")
         .expect("defend case");
-    assert_eq!(defend.residuals.len(), 1);
-    assert_eq!(defend.residuals[0].identity, "rawWorkshopAction");
-    assert_eq!(
-        defend.residuals[0].classification,
-        ResidualClassification::LegacyOpaque
+    assert!(
+        defend.gaps.iter().all(|gap| {
+            gap.kind == RealProjectGapKind::UnknownAction
+                && gap.identity == "rawWorkshopAction"
+                && gap.classification == ResidualClassification::LegacyOpaque
+        }),
+        "the admitted defend gap keeps its pinned classification"
     );
-    assert_eq!(defend.gaps.len(), 3);
-    assert!(defend.gaps.iter().all(|gap| {
-        gap.kind == RealProjectGapKind::UnknownAction
-            && gap.identity == "rawWorkshopAction"
-            && gap.classification == ResidualClassification::LegacyOpaque
-    }));
 
     let error = WorkshopError::unknown(
         "action",
diff --git a/crates/workshop-rs/tests/roundtrip.rs b/crates/workshop-rs/tests/roundtrip.rs
index 11a875b9..173534c3 100644
--- a/crates/workshop-rs/tests/roundtrip.rs
+++ b/crates/workshop-rs/tests/roundtrip.rs
@@ -1,6 +1,6 @@
 use super::common::{self, catalog, en};
 use super::internal;
-use workshop_rs::roundtrip::{self, RoundTripRecord};
+use workshop_rs::roundtrip;
 
 #[test]
 fn every_corpus_fixture_round_trips_with_full_evidence() {
@@ -34,36 +34,6 @@ fn every_corpus_fixture_round_trips_with_full_evidence() {
     }
 }
 
-#[test]
-fn same_locale_round_trip_is_a_release_gate() {
-    let failures: Vec<String> = [
-        "basic-rule",
-        "control-flow",
-        "declarations-rules",
-        "expressions-values",
-        "preprocessing",
-        "receiver-calls",
-        "overpy-cake",
-    ]
-    .iter()
-    .map(|fixture_id| {
-        let catalog = catalog();
-        roundtrip::round_trip_with_context(
-            &common::corpus_text(fixture_id),
-            &catalog,
-            &en(),
-            &catalog,
-        )
-    })
-    .filter(|record: &RoundTripRecord| !record.equivalent || record.error.is_some())
-    .map(|record| record.locale.to_string())
-    .collect();
-    assert!(
-        failures.is_empty(),
-        "round-trip gate failures: {failures:?}"
-    );
-}
-
 #[test]
 fn equivalence_ignores_presentation_but_preserves_semantics() {
     let a = workshop_rs::wir::Program::default();
@@ -152,37 +122,6 @@ fn malformed_input_is_recorded_not_crashed() {
     assert!(record.error.is_some(), "failure is recorded");
 }
 
-#[test]
-fn unknown_builtin_fails_at_emit_stage() {
-    let mut program = workshop_rs::wir::Program::default();
-    program
-        .files
-        .push(workshop_rs::source::SourceFile::new("workshop.txt"));
-    let value = program.values.push(workshop_rs::wir::ValueNode::new(
-        workshop_rs::wir::Value::Call {
-            name: "notACatalogId".into(),
-            args: vec![],
-        },
-        None,
-    ));
-    let call = program.actions.push(workshop_rs::wir::Action::Call {
-        name: "wait".into(),
-        args: vec![value],
-        span: None,
-    });
-    program.rules.push(workshop_rs::wir::Rule {
-        name: "x".into(),
-        span: None,
-        name_span: None,
-        disabled: false,
-        event: workshop_rs::wir::Event::Global,
-        conditions: vec![],
-        actions: vec![call],
-    });
-    let error = internal::try_emit(&program).expect_err("unknown id");
-    assert!(error.to_string().contains("notACatalogId"));
-}
-
 #[test]
 fn emitter_chase_none_round_trips_through_the_catalog_context() {
     let text = "variables { global: 0: g }\nrule (\"chase\") { event { Ongoing - Global; } actions { Chase Global Variable Over Time(Global.g, 0, 30, None); } }";
diff --git a/crates/workshop-rs/tests/rule_content.rs b/crates/workshop-rs/tests/rule_content.rs
index 82c181b3..f11bbeda 100644
--- a/crates/workshop-rs/tests/rule_content.rs
+++ b/crates/workshop-rs/tests/rule_content.rs
@@ -2,11 +2,7 @@ use serde_json::{Value as JsonValue, json};
 use sha2::{Digest, Sha256};
 use workshop_rs::catalog::Kind;
 use workshop_rs::lookup::{LookupMatch, Signature};
-use workshop_rs::rules::content::{
-    ASSIGN_MEMBER_CALL, GLOBAL_VARIABLE_CALL, MEMBER_ACCESS_CALL, MODIFY_MEMBER_CALL,
-    PLAYER_VARIABLE_CALL, RAW_WORKSHOP_ACTION_CALL, RULE_CONTENT_V1, RULE_CONTENT_V1_SCHEMA,
-    rule_content,
-};
+use workshop_rs::rules::content::{RULE_CONTENT_V1, RULE_CONTENT_V1_SCHEMA, rule_content};
 use workshop_rs::{
     Action, Condition, Event, EventTarget, EventTeam, ModifyOp, PlayerEventKind, Program, Rule,
     Subroutine, Value, emitter, parser,
@@ -923,71 +919,6 @@ fn output_is_deterministic_and_flat() {
     assert_eq!(first["actions"].as_array().expect("actions").len(), 3);
 }
 
-#[test]
-fn every_value_variant_has_a_node_form() {
-    let forms = |value: &Value| match value {
-        Value::Number(_) | Value::String(_) | Value::Bool(_) | Value::Null => "literal",
-        Value::LocalizedString(_) => "localizedString",
-        Value::Enum { .. } => "enum",
-        Value::Array(_) => "array",
-        Value::Vector { .. } => "vector",
-        Value::GlobalVariable(_) | Value::PlayerVariable { .. } => "variable read",
-        Value::Subroutine(_) => "subroutine",
-        Value::EventPlayer => "eventPlayer",
-        Value::Call { name, .. } if name == "__ambiguous_enum" => "ambiguous member",
-        Value::Call { .. } => "call",
-    };
-    for value in [
-        Value::from(1.0),
-        Value::string("s"),
-        Value::Bool(true),
-        Value::Null,
-        Value::LocalizedString("hello".to_string()),
-        Value::Enum {
-            value_type: "Status".to_string(),
-            value: "STUNNED".to_string(),
-        },
-        Value::Array(vec![]),
-        Value::Vector {
-            x: Box::new(Value::from(0.0)),
-            y: Box::new(Value::from(0.0)),
-            z: Box::new(Value::from(0.0)),
-        },
-        Value::GlobalVariable("g".to_string()),
-        Value::PlayerVariable {
-            player: Box::new(Value::EventPlayer),
-            variable: "p".to_string(),
-        },
-        Value::Subroutine("s".to_string()),
-        Value::EventPlayer,
-        Value::call(
-            "vector",
-            [Value::from(1.0), Value::from(2.0), Value::from(3.0)],
-        ),
-        ambiguous_value("Up", &[("Vector", "UP"), ("Rounding", "UP")]),
-    ] {
-        let _ = forms(&value);
-    }
-}
-
-#[test]
-fn every_action_variant_has_a_node_form() {
-    let forms = |action: &Action| match action {
-        Action::SetGlobalVariable { .. } | Action::SetPlayerVariable { .. } => "set",
-        Action::ModifyGlobalVariable { .. } | Action::ModifyPlayerVariable { .. } => "modify",
-        Action::AssignMember { .. } => "assignMember",
-        Action::CallSubroutine { .. } => "callSubroutine",
-        Action::If { .. } | Action::ElseIf { .. } | Action::Else | Action::While { .. } => {
-            "control flow"
-        }
-        Action::ForGlobalVariable { .. } | Action::ForPlayerVariable { .. } => "for",
-        Action::End => "end",
-        Action::Disabled { .. } => "disabled",
-        Action::Call { .. } => "call",
-    };
-    let _ = forms(&Action::End);
-}
-
 #[test]
 fn schema_rejects_missing_and_unknown_fields() {
     let rule = Rule::new("schema", Event::Global).action(Action::call("wait", [Value::from(1.0)]));
@@ -1324,76 +1255,6 @@ fn player_variable_chases_emit_their_catalog_call_ids() {
     assert_eq!(content_of(&chinese.rules[0]), content);
 }
 
-fn call_ids(node: &JsonValue, calls: &mut Vec<String>) {
-    match node {
-        JsonValue::Object(map) => {
-            if let Some(JsonValue::String(call)) = map.get("call") {
-                calls.push(call.clone());
-            }
-            for value in map.values() {
-                call_ids(value, calls);
-            }
-        }
-        JsonValue::Array(items) => {
-            for item in items {
-                call_ids(item, calls);
-            }
-        }
-        _ => {}
-    }
-}
-
-const RESERVED_CALL_IDS: &[&str] = &[
-    GLOBAL_VARIABLE_CALL,
-    PLAYER_VARIABLE_CALL,
-    ASSIGN_MEMBER_CALL,
-    MODIFY_MEMBER_CALL,
-    MEMBER_ACCESS_CALL,
-    RAW_WORKSHOP_ACTION_CALL,
-    "+",
-    "-",
-    "*",
-    "/",
-    "%",
-];
-
-#[test]
-fn every_emitted_call_id_resolves_to_its_catalog_entry() {
-    let catalog = catalog();
-    let english = en();
-    let mut calls = Vec::new();
-    for rule in [
-        action_forms_rule(),
-        node_forms_rule(),
-        variable_reads_rule(),
-        reserved_ids_rule(),
-        parse_rule(REPEL_SOURCE),
-        parse_rule(CHASE_SOURCE),
-    ] {
-        call_ids(&content_of(&rule), &mut calls);
-    }
-    calls.sort_unstable();
-    calls.dedup();
-    for call in calls {
-        if RESERVED_CALL_IDS.contains(&call.as_str()) {
-            continue;
-        }
-        let matches = catalog
-            .lookup(&english, &call)
-            .expect("lookup of a declared locale");
-        let first = matches
-            .first()
-            .unwrap_or_else(|| panic!("call id '{call}' resolves to nothing"));
-        let LookupMatch::Builtin { id, .. } = first else {
-            panic!("call id '{call}' resolves to a non-builtin match: {first:?}");
-        };
-        assert_eq!(
-            id, &call,
-            "call id '{call}' resolves through lookup to a different catalog entry"
-        );
-    }
-}
-
 const PRACTICE_RANGE_MODES: &[(&str, &str, &str)] = &[
     (
         "en-US",
diff --git a/crates/workshop-rs/tests/settings_pipeline.rs b/crates/workshop-rs/tests/settings_pipeline.rs
index f70ee0e8..5206cc3e 100644
--- a/crates/workshop-rs/tests/settings_pipeline.rs
+++ b/crates/workshop-rs/tests/settings_pipeline.rs
@@ -125,57 +125,26 @@ fn composed_blizzard_settings_labels_convert_in_both_directions() {
 
 // Minimized from OWBastion/Bastion 7debbcb, src/composition/bootstrap.opy.
 #[test]
-fn map_lists_preserve_adjacent_number_and_localized_text() {
+fn map_lists_preserve_numbers_colons_and_localized_text() {
     let catalog = catalog();
     let en = en();
-    let zh = zh();
-    for list in ["enabled maps", "disabled maps"] {
-        let source = format!("settings {{ modes {{ Skirmish {{ {list} {{\nRoute 66\n}} }} }} }}");
-        let program = parser::parse_wir(&source, &catalog, &en).expect("English map list");
-        let localized = emitter::emit_wir(&program, &catalog, &zh).expect("Chinese map list");
-        let reparsed =
-            parser::parse_wir(&localized, &catalog, &zh).expect("numeric Chinese map name");
-        assert!(roundtrip::equivalent_wir(&program, &reparsed));
-    }
-}
-
-#[test]
-fn map_lists_preserve_colons_in_map_names() {
-    let catalog = catalog();
-    let en = en();
-    let zh = zh();
-    for list in ["enabled maps", "disabled maps"] {
-        let source = format!(
-            "settings {{ modes {{ Skirmish {{ {list} {{\nWatchpoint: Gibraltar\nEcopoint: Antarctica\n}} }} }} }}"
-        );
-        let program =
-            parser::parse_wir(&source, &catalog, &en).expect("colon-containing map names");
-        let emitted = emitter::emit_wir(&program, &catalog, &en).expect("English map list");
-        let reparsed =
-            parser::parse_wir(&emitted, &catalog, &en).expect("English map list reparses");
-        assert!(roundtrip::equivalent_wir(&program, &reparsed));
-        let localized = emitter::emit_wir(&program, &catalog, &zh).expect("Chinese map list");
-        let reparsed =
-            parser::parse_wir(&localized, &catalog, &zh).expect("Chinese map list reparses");
-        assert!(roundtrip::equivalent_wir(&program, &reparsed));
-    }
-}
-
-#[test]
-fn map_lists_preserve_spaced_colons_in_map_names() {
-    let catalog = catalog();
-    let en = en();
-    let fr = common::locale("fr-FR");
-    for list in ["enabled maps", "disabled maps"] {
-        let source = format!(
-            "settings {{ modes {{ Skirmish {{ {list} {{\nWatchpoint: Gibraltar\nEcopoint: Antarctica\n}} }} }} }}"
-        );
-        let program =
-            parser::parse_wir(&source, &catalog, &en).expect("colon-containing map names");
-        let localized = emitter::emit_wir(&program, &catalog, &fr).expect("French map list");
-        let reparsed =
-            parser::parse_wir(&localized, &catalog, &fr).expect("French map list reparses");
-        assert!(roundtrip::equivalent_wir(&program, &reparsed));
+    for (locale_tag, members) in [
+        ("zh-CN", "Route 66"),
+        ("en-US", "Watchpoint: Gibraltar\nEcopoint: Antarctica"),
+        ("zh-CN", "Watchpoint: Gibraltar\nEcopoint: Antarctica"),
+        ("fr-FR", "Watchpoint: Gibraltar\nEcopoint: Antarctica"),
+    ] {
+        let locale = common::locale(locale_tag);
+        for list in ["enabled maps", "disabled maps"] {
+            let source =
+                format!("settings {{ modes {{ Skirmish {{ {list} {{\n{members}\n}} }} }} }}");
+            let program = parser::parse_wir(&source, &catalog, &en).expect("map list parses");
+            let localized =
+                emitter::emit_wir(&program, &catalog, &locale).expect("localized map list");
+            let reparsed =
+                parser::parse_wir(&localized, &catalog, &locale).expect("localized reparses");
+            assert!(roundtrip::equivalent_wir(&program, &reparsed));
+        }
     }
 }
 
@@ -373,19 +342,6 @@ fn generated_capture_the_flag_settings_surface_is_canonical() {
     );
 }
 
-#[test]
-fn mixed_locale_primary_hero_setting_name_is_canonical() {
-    let catalog = catalog();
-    let source = "设置 { 英雄 { 队伍1 { D.Mon { 伤害量: 140% } } } }";
-    let program = internal::parse_in(source, &zh());
-    assert!(
-        program
-            .semantic_issues(&catalog)
-            .iter()
-            .all(|issue| { issue.kind != workshop_rs::rules::IncompletenessKind::RawSetting })
-    );
-}
-
 #[test]
 fn team_deathmatch_enabled_maps_is_canonical() {
     let text = r#"
@@ -404,34 +360,6 @@ fn team_deathmatch_enabled_maps_is_canonical() {
     internal::assert_reparse_equivalent(&program, &emitted);
 }
 
-#[test]
-fn canonical_percent_setting_keys_parse_from_mixed_locale_exports() {
-    let text = r#"
-        settings {
-            heroes {
-                General {
-                    Roadhog {
-                        secondaryFireRechargeRate%: 150
-                        secondaryFireCooldown%: 480
-                    }
-                }
-            }
-        }
-    "#;
-    let _catalog = Catalog::builtin().unwrap();
-    internal::parse_in(text, &zh());
-}
-
-#[test]
-fn supported_dva_name_parses() {
-    let _catalog = catalog();
-    let source =
-        "settings {\n heroes {\n  General {\n   D.Va {\n    Primary Fire: Off\n   }\n  }\n }\n}";
-    let program = internal::parse(source);
-    let emitted = internal::emit(&program);
-    assert!(emitted.contains("D.Va"));
-}
-
 #[test]
 fn hero_ability_names_resolve_through_gameplay_catalog_in_both_locales() {
     let _catalog = catalog();
@@ -517,19 +445,6 @@ fn localized_workshop_namespace_is_known() {
     );
 }
 
-#[test]
-fn localized_wrecking_ball_settings_aliases_are_known() {
-    let source = "settings { heroes { 综合 { 破坏球 {\n工程抓钩冷却时间: 80%\n感应护盾冷却时间: 80%\n重力坠击冷却时间: 75%\n} } } }";
-    let catalog = Catalog::builtin().expect("catalog");
-    let program = internal::parse_in(source, &zh());
-    assert!(
-        semantic::inspect_wir(&program, &catalog).is_empty(),
-        "issues: {:?}, settings: {:?}",
-        semantic::inspect_wir(&program, &catalog),
-        program.settings
-    );
-}
-
 #[test]
 fn settings_schema_projects_workshop_facts_without_display_names_in_ids() {
     let definitions: Vec<_> = definitions().collect();
@@ -928,48 +843,26 @@ fn settings_schema_catalog_is_complete_and_conflict_checked() {
 #[test]
 fn reconciled_export_enum_members_remain_writable() {
     let _catalog = catalog();
-    for (source, id, path, target, member, expected) in [
-        (
-            "settings { modes { General { Hero Limit: Off } } }",
-            "setting.gameMode.heroLimit",
-            "gamemodes.general.heroLimit",
-            SettingTarget::Mode("general".to_string()),
-            "1PerTeam",
-            "Hero Limit: 1 Per Team",
-        ),
-        (
-            "settings { lobby { Map Rotation: After A Game } }",
-            "setting.lobby.mapRotation",
-            "lobby.mapRotation",
-            SettingTarget::Global,
-            "afterMirrorMatch",
-            "Map Rotation: After A Mirror Match",
-        ),
-    ] {
-        let mut program = internal::parse(source);
-        let definition = definitions_by_id(&SettingId::from(id))
-            .find(|definition| definition.path() == path)
-            .expect("reconciled enum definition");
-        definition
-            .write(
-                program.settings.as_mut().expect("settings"),
-                &target,
-                SettingValue::Enum(member.to_string()),
-            )
-            .expect("export-backed enum member remains writable");
+    let mut program = internal::parse("settings { modes { General { Hero Limit: Off } } }");
+    let definition = definitions_by_id(&SettingId::from("setting.gameMode.heroLimit"))
+        .find(|definition| definition.path() == "gamemodes.general.heroLimit")
+        .expect("reconciled enum definition");
+    definition
+        .write(
+            program.settings.as_mut().expect("settings"),
+            &SettingTarget::Mode("general".to_string()),
+            SettingValue::Enum("1PerTeam".to_string()),
+        )
+        .expect("export-backed enum member remains writable");
 
-        let emitted = internal::emit(&program);
-        assert!(emitted.contains(expected), "{emitted}");
-    }
+    let emitted = internal::emit(&program);
+    assert!(emitted.contains("Hero Limit: 1 Per Team"), "{emitted}");
 }
 
 #[test]
-fn typed_settings_read_and_write_preserve_unrelated_structure() {
+fn typed_settings_reads_preserve_authored_and_unresolved_values() {
     let _catalog = Catalog::builtin().expect("catalog");
     let source = r#"settings {
-        main {
-            Description: "keep this"
-        }
         lobby {
             Max Spectators: 2
         }
@@ -981,7 +874,7 @@ fn typed_settings_read_and_write_preserve_unrelated_structure() {
             }
         }
     }"#;
-    let mut program = internal::parse(source);
+    let program = internal::parse(source);
     let lobby = definitions_by_id(&SettingId::from("setting.lobby.spectatorSlots"))
         .next()
         .expect("lobby definition");
@@ -993,16 +886,6 @@ fn typed_settings_read_and_write_preserve_unrelated_structure() {
         .expect("typed read");
     assert_eq!(read.authored, SettingValue::Number(2.0));
     assert_eq!(read.effective, None);
-    lobby
-        .write(
-            program.settings.as_mut().expect("settings"),
-            &SettingTarget::Global,
-            SettingValue::Number(4.0),
-        )
-        .expect("typed write");
-    let emitted = internal::emit(&program);
-    assert!(emitted.contains("Description: \"keep this\""));
-    assert!(emitted.contains("Max Spectators: 4"));
 
     let primary = definitions()
         .find(|definition| {
@@ -1030,18 +913,6 @@ fn typed_settings_read_and_write_preserve_unrelated_structure() {
             .authored,
         SettingValue::Boolean(true)
     ));
-
-    let error = primary
-        .write(
-            program.settings.as_mut().expect("settings"),
-            &target,
-            SettingValue::Boolean(false),
-        )
-        .expect_err("unknown applicability must reject writes");
-    assert!(matches!(
-        error,
-        SettingOperationError::ApplicabilityUnknown { .. }
-    ));
 }
 
 #[test]
@@ -1087,39 +958,6 @@ fn typed_settings_source_edit_replaces_only_the_existing_value_bytes() {
     ));
 }
 
-#[test]
-fn typed_settings_source_edit_rejects_missing_source_location() {
-    let definition = definitions_by_id(&SettingId::from("setting.lobby.spectatorSlots"))
-        .next()
-        .expect("spectator-slot definition");
-    let settings = workshop_rs::settings::Settings {
-        span: None,
-        children: vec![workshop_rs::settings::SettingsNode::Group {
-            name: "lobby".to_string(),
-            children: vec![workshop_rs::settings::SettingsNode::Number {
-                name: "spectatorSlots".to_string(),
-                value: 2.0,
-                span: None,
-            }],
-            span: None,
-        }],
-    };
-
-    let error = definition
-        .source_edit(
-            "settings { lobby { Max Spectators: 2 } }",
-            &settings,
-            "en-US",
-            &SettingTarget::Global,
-            SettingValue::Number(4.0),
-        )
-        .expect_err("source edits require a source location");
-    assert!(matches!(
-        error,
-        SettingOperationError::SourceUnavailable { .. }
-    ));
-}
-
 #[test]
 fn typed_settings_source_edit_uses_settings_string_escaping() {
     let catalog = Catalog::builtin().expect("catalog");
@@ -1161,128 +999,6 @@ fn typed_settings_source_edit_uses_settings_string_escaping() {
     );
 }
 
-#[test]
-fn typed_settings_source_edit_rejects_false_boolean_enum_values() {
-    let _catalog = Catalog::builtin().expect("catalog");
-    let source = "settings { lobby { Match Voice Chat: Enabled } }";
-    let program = internal::parse(source);
-    let definition = definitions_by_id(&SettingId::from("setting.lobby.enableMatchVoiceChat"))
-        .next()
-        .expect("match voice chat definition");
-
-    let edit = definition
-        .source_edit(
-            source,
-            program.settings.as_ref().expect("settings"),
-            "en-US",
-            &SettingTarget::Global,
-            SettingValue::Boolean(true),
-        )
-        .expect("enabled enum member is writable");
-    assert_eq!(edit.replacement(), "Enabled");
-    assert!(matches!(
-        definition.source_edit(
-            source,
-            program.settings.as_ref().expect("settings"),
-            "en-US",
-            &SettingTarget::Global,
-            SettingValue::Boolean(false),
-        ),
-        Err(SettingOperationError::InvalidValue { .. })
-    ));
-}
-
-#[test]
-fn typed_settings_errors_reject_invalid_members_and_non_applicable_targets() {
-    let catalog = Catalog::builtin().expect("catalog");
-    let mut program = parser::parse_wir(
-        "settings { modes { Assault { Limit Roles: 2 Of Each Role Per Team } } }",
-        &catalog,
-        &en(),
-    )
-    .expect("parse");
-    let role_limit = definitions_by_id(&SettingId::from("setting.gameMode.roleLimit"))
-        .find(|definition| definition.path().ends_with("assault.roleLimit"))
-        .expect("role-limit definition");
-    let error = role_limit
-        .write(
-            program.settings.as_mut().expect("settings"),
-            &SettingTarget::Mode("assault".to_string()),
-            SettingValue::Enum("unknownRoleLimit".to_string()),
-        )
-        .expect_err("unknown enum member must be rejected");
-    assert!(matches!(
-        error,
-        SettingOperationError::InvalidValue { span: Some(_), .. }
-    ));
-
-    let ability1_enemy_kb = definitions()
-        .find(|definition| definition.path().ends_with("ability1EnemyKb%"))
-        .expect("ability 1 enemy knockback setting");
-    let error = ability1_enemy_kb
-        .write(
-            program.settings.as_mut().expect("settings"),
-            &SettingTarget::HeroAbility {
-                team: None,
-                hero: HeroId::from(hero_ids::ANA),
-                slot: LogicalSlot::from(slots::ABILITY_1),
-                variant: None,
-            },
-            SettingValue::Percent(10.0),
-        )
-        .expect_err("uncertain hero setting must be rejected for writes");
-    assert!(matches!(
-        error,
-        SettingOperationError::ApplicabilityUnknown { .. }
-    ));
-}
-
-#[test]
-fn typed_settings_writes_fail_closed_for_unknown_applicability() {
-    let health = definitions()
-        .find(|definition| {
-            definition.path().ends_with("health%")
-                && definition.target_kind() == SettingTargetKind::Hero
-        })
-        .expect("hero health definition");
-    let mut settings = workshop_rs::settings::Settings {
-        span: None,
-        children: Vec::new(),
-    };
-    let unknown_error = health
-        .write(
-            &mut settings,
-            &SettingTarget::Hero {
-                team: None,
-                hero: HeroId::new("futureHero"),
-            },
-            SettingValue::Percent(100.0),
-        )
-        .expect_err("unknown applicability must refuse writes");
-    assert!(matches!(
-        unknown_error,
-        SettingOperationError::ApplicabilityUnknown { .. }
-    ));
-
-    let team_definition = definitions()
-        .find(|definition| definition.target_kind() == SettingTargetKind::Team)
-        .expect("team definition");
-    let widening_error = team_definition
-        .write(
-            &mut settings,
-            &SettingTarget::Hero {
-                team: None,
-                hero: HeroId::from(hero_ids::ANA),
-            },
-            SettingValue::Boolean(false),
-        )
-        .expect_err("team-to-hero applicability without sources must refuse writes");
-    assert!(matches!(
-        widening_error,
-        SettingOperationError::ApplicabilityUnknown { .. }
-    ));
-}
-
 #[test]
 fn declared_modes_inherit_general_settings_entries() {
     use workshop_rs::settings::{Settings, SettingsListElement, SettingsNode, check_emission};
@@ -1394,61 +1110,7 @@ fn declared_modes_inherit_general_settings_entries() {
     );
 }
 
-#[test]
-fn check_emission_mirrors_emitter_acceptance() {
-    use workshop_rs::settings::{Settings, SettingsNode, check_emission};
-
-    let group = |name: &str, children: Vec<SettingsNode>| SettingsNode::Group {
-        name: name.to_string(),
-        children,
-        span: None,
-    };
-    let settings = Settings {
-        span: None,
-        children: vec![
-            group(
-                "gamemodes",
-                vec![group(
-                    "ffa",
-                    vec![
-                        SettingsNode::Bool {
-                            name: "enabled".to_string(),
-                            value: false,
-                            span: None,
-                        },
-                        SettingsNode::Bool {
-                            name: "bogusKey".to_string(),
-                            value: true,
-                            span: None,
-                        },
-                    ],
-                )],
-            ),
-            group(
-                "extensions",
-                vec![SettingsNode::Number {
-                    name: "beamEffects".to_string(),
-                    value: 3.0,
-                    span: None,
-                }],
-            ),
-        ],
-    };
-    let errors = check_emission(&settings);
-    let mut program = workshop_rs::Program::new();
-    program.settings = Some(settings);
-    let emit_error = emitter::emit(&program, &catalog(), &en())
-        .expect_err("the first offending member fails emission");
-    assert_eq!(errors.len(), 2, "{errors:?}");
-    assert_eq!(errors[0].to_string(), emit_error.to_string());
-    assert!(
-        errors[1]
-            .to_string()
-            .contains("does not match its table kind")
-    );
-}
-
-fn issue_360_source(key: &str, map: &str) -> String {
+fn near_miss_source(key: &str, map: &str) -> String {
     format!(
         r#"settings
 {{
@@ -1500,24 +1162,19 @@ fn assert_check_compile_parity(source: &str) {
 }
 
 #[test]
-fn issue_360_exact_spellings_pass_check_and_compile() {
-    assert_check_compile_parity(&issue_360_source("enabled maps", "Château Guillard"));
-}
-
-#[test]
-fn issue_360_settings_names_match_case_insensitively() {
+fn settings_names_match_case_insensitively() {
     for (key, map) in [
         ("Enabled Maps", "Château Guillard"),
         ("ENABLED MAPS", "CHÂTEAU GUILLARD"),
         ("enabled maps", "château guillard"),
     ] {
-        assert_check_compile_parity(&issue_360_source(key, map));
+        assert_check_compile_parity(&near_miss_source(key, map));
     }
 }
 
 #[test]
-fn issue_360_accent_stripped_map_is_rejected_with_suggestion() {
-    let source = issue_360_source("enabled maps", "Chateau Guillard");
+fn accent_stripped_map_is_rejected_with_suggestion() {
+    let source = near_miss_source("enabled maps", "Chateau Guillard");
     let program = parser::parse(&source, &catalog(), &en()).expect("source parses");
     let error = program.validate().expect_err("check rejects the map");
     assert!(
@@ -1543,8 +1200,8 @@ fn issue_360_accent_stripped_map_is_rejected_with_suggestion() {
 }
 
 #[test]
-fn issue_360_distant_and_ambiguous_spellings_suggest_nothing() {
-    let source = issue_360_source("enabled maps", "Zzyzx Wonderland");
+fn distant_and_ambiguous_spellings_suggest_nothing() {
+    let source = near_miss_source("enabled maps", "Zzyzx Wonderland");
     let program = parser::parse(&source, &catalog(), &en()).expect("source parses");
     let error = program.validate().expect_err("check rejects the map");
     assert!(!error.to_string().contains("did you mean"), "{error}");
@@ -1601,8 +1258,8 @@ rule("r")
 }
 
 #[test]
-fn issue_360_unknown_braced_key_is_kept_as_written_with_a_suggestion() {
-    let source = issue_360_source("Enabled Mpas", "Château Guillard");
+fn unknown_braced_key_is_kept_as_written_with_a_suggestion() {
+    let source = near_miss_source("Enabled Mpas", "Château Guillard");
     let program = parser::parse(&source, &catalog(), &en()).expect("source parses");
     program
         .validate()
@@ -1635,7 +1292,7 @@ fn issue_360_unknown_braced_key_is_kept_as_written_with_a_suggestion() {
 }
 
 #[test]
-fn undeclared_settings_values_and_empty_members_round_trip_as_written() {
+fn undeclared_settings_values_are_residuals_without_suggestions() {
     let source = r#"settings
 {
     lobby
@@ -1666,17 +1323,6 @@ rule("r")
 "#;
     let program = parser::parse(source, &catalog(), &en()).expect("source parses");
     program.validate().expect("raw members are accepted");
-    let emitted = emitter::emit(&program, &catalog(), &en()).expect("emits");
-    for line in [
-        "Map Rotation: Sometimes",
-        "Project Empty:",
-        "Project Scalar: 500%",
-    ] {
-        assert!(
-            emitted.lines().any(|emitted| emitted.trim_start() == line),
-            "{line:?} in {emitted}"
-        );
-    }
     let issue = program
         .semantic_issues(&catalog())
         .into_iter()
@@ -1742,7 +1388,7 @@ fn typed_uncatalogued_members_localize_catalogued_keys_only() {
 }
 
 #[test]
-fn issue_412_catalogued_key_block_round_trips_as_written() {
+fn carried_key_block_round_trips_as_written_and_classifies_as_project_defined() {
     let source = r#"settings
 {
     lobby
@@ -1793,7 +1439,7 @@ rule("r")
 }
 
 #[test]
-fn issue_412_catalogued_key_block_emits_the_display_name() {
+fn carried_catalogued_key_blocks_emit_localized_display_names() {
     use workshop_rs::settings::{Settings, SettingsNode};
 
     let raw = |name: &str| SettingsNode::Raw {
@@ -1840,7 +1486,7 @@ fn issue_412_catalogued_key_block_emits_the_display_name() {
 }
 
 #[test]
-fn issue_417_pass_through_groups_emit_verbatim_at_resolved_positions() {
+fn pass_through_groups_emit_verbatim_at_resolved_positions() {
     use workshop_rs::settings::{Settings, SettingsNode};
 
     let raw = |name: &str| SettingsNode::Raw {
@@ -1915,82 +1561,6 @@ fn issue_417_pass_through_groups_emit_verbatim_at_resolved_positions() {
     assert!(localized.contains("ability3Cooldown%"), "{localized}");
 }
 
-#[test]
-fn issue_417_unmarked_members_keep_name_and_kind_validation() {
-    use workshop_rs::settings::{Settings, SettingsNode};
-
-    let group = |name: &str, children: Vec<SettingsNode>| SettingsNode::Group {
-        name: name.into(),
-        children,
-        span: None,
-    };
-    let with_member = |member: SettingsNode| {
-        let mut program = workshop_rs::Program::new();
-        program.settings = Some(Settings {
-            span: None,
-            children: vec![
-                group("heroes", vec![group("allTeams", vec![member])]),
-                group("gamemodes", Vec::new()),
-            ],
-        });
-        program
-    };
-    let unknown_hero = with_member(group(
-        "mccree",
-        vec![SettingsNode::Number {
-            name: "health%".into(),
-            value: 50.0,
-            span: None,
-        }],
-    ));
-    assert!(
-        unknown_hero.validate().is_err(),
-        "an unmarked group under a team still resolves as a hero"
-    );
-    let typed_leaf = with_member(SettingsNode::RawGroup {
-        name: "mccree".into(),
-        children: vec![SettingsNode::Number {
-            name: "health%".into(),
-            value: 50.0,
-            span: None,
-        }],
-        span: None,
-    });
-    assert!(
-        typed_leaf.validate().is_err(),
-        "a typed leaf inside a pass-through block has no written form"
-    );
-}
-
-#[test]
-fn issue_360_opaque_settings_remain_verbatim() {
-    let source = r#"settings
-{
-    main
-    {
-        Project Custom Field: 3
-    }
-
-    workshop
-    {
-        Custom Payload: anything goes
-    }
-}
-rule("r")
-{
-    event
-    {
-        Ongoing - Global;
-    }
-    actions
-    {
-        Wait(1, Ignore Condition);
-    }
-}
-"#;
-    assert_check_compile_parity(source);
-}
-
 #[test]
 fn typed_member_diagnostics_preserve_messages_spans_suggestions_and_order() {
     use workshop_rs::WorkshopError;
@@ -2149,67 +1719,6 @@ fn typed_member_diagnostics_preserve_messages_spans_suggestions_and_order() {
     }
 }
 
-#[test]
-fn typed_member_emission_keeps_raw_extensions_and_mode_headers() {
-    use workshop_rs::settings::{Settings, SettingsNode};
-    let raw = |name: &str, value: &str| SettingsNode::Raw {
-        name: name.into(),
-        value: value.into(),
-        span: None,
-    };
-    let group = |name: &str, children| SettingsNode::Group {
-        name: name.into(),
-        children,
-        span: None,
-    };
-    let mut program = workshop_rs::Program::new();
-    program.settings = Some(Settings {
-        span: None,
-        children: vec![
-            group(
-                "custom",
-                vec![group("nested", vec![raw("Payload", "anything goes")])],
-            ),
-            SettingsNode::Workshop {
-                children: vec![raw("Custom Field", "3")],
-                span: None,
-            },
-            group(
-                "extensions",
-                vec![SettingsNode::Flag {
-                    name: "beamEffects".into(),
-                    span: None,
-                }],
-            ),
-            group(
-                "gamemodes",
-                vec![group(
-                    "ffa",
-                    vec![SettingsNode::Bool {
-                        name: "enabled".into(),
-                        value: false,
-                        span: None,
-                    }],
-                )],
-            ),
-        ],
-    });
-    program.validate().unwrap();
-    assert!(program.settings_diagnostics().is_empty());
-    let text = emitter::emit(&program, &catalog(), &en()).unwrap();
-    for preserved in [
-        "custom {",
-        "nested {",
-        "Payload: anything goes",
-        "Custom Field: 3",
-        "Beam Effects",
-        "disabled Deathmatch {",
-    ] {
-        assert!(text.contains(preserved), "{text}");
-    }
-    assert!(!text.contains("enabled:"), "{text}");
-}
-
 #[test]
 fn typed_member_emission_resolves_hero_display_before_value_acceptance() {
     use workshop_rs::WorkshopError;
@@ -2311,7 +1820,7 @@ rule("r")
     }
 }
 "#;
-    let key_source = issue_360_source("enabled mpas", "Route 66");
+    let key_source = near_miss_source("enabled mpas", "Route 66");
     for (source, expected) in [
         (enum_source, "did you mean 'After A Game'?"),
         (&key_source, "did you mean 'enabled maps'?"),
@@ -2348,7 +1857,7 @@ rule("r")
 #[test]
 fn correctly_spelled_and_distant_members_warn_on_nothing() {
     use workshop_rs::settings::DiagnosticSeverity;
-    let source = issue_360_source("enabled maps", "Route 66");
+    let source = near_miss_source("enabled maps", "Route 66");
     let catalog = catalog();
     let program = parser::parse(&source, &catalog, &en()).expect("source parses");
     assert!(
@@ -2360,7 +1869,7 @@ fn correctly_spelled_and_distant_members_warn_on_nothing() {
         program.settings_diagnostics()
     );
 
-    let distant = issue_360_source("a wholly novel knob", "Route 66");
+    let distant = near_miss_source("a wholly novel knob", "Route 66");
     let program = parser::parse(&distant, &catalog, &en()).expect("source parses");
     let diagnostics = program.settings_diagnostics();
     assert!(
@@ -2379,3 +1888,168 @@ fn correctly_spelled_and_distant_members_warn_on_nothing() {
         semantic::ResidualClassification::ProjectDefinedConstruct
     );
 }
+
+#[test]
+fn empty_settings_member_does_not_consume_the_following_member() {
+    let catalog = catalog();
+    let locale = en();
+    let source = r#"settings
+{
+    lobby
+    {
+        Project Empty:
+        Map Rotation: After A Game
+    }
+}
+rule("r")
+{
+    event
+    {
+        Ongoing - Global;
+    }
+    actions
+    {
+        Wait(1, Ignore Condition);
+    }
+}
+"#;
+    let program = parser::parse(source, &catalog, &locale).expect("parses");
+    let emitted = emitter::emit(&program, &catalog, &locale).expect("emits");
+    let lines: Vec<&str> = emitted.lines().map(str::trim).collect();
+    assert!(lines.contains(&"Project Empty:"), "{emitted}");
+    assert!(lines.contains(&"Map Rotation: After A Game"), "{emitted}");
+    let reparsed = parser::parse(&emitted, &catalog, &locale).expect("reparses");
+    assert!(roundtrip::equivalent(&program, &reparsed));
+}
+
+fn hero_setting(hero: &str, member: &str) -> String {
+    format!(
+        "settings {{\n    heroes {{\n        General {{\n            {hero} {{\n                {member}\n            }}\n        }}\n    }}\n}}"
+    )
+}
+
+fn parse_program_in(source: &str, locale: &workshop_rs::catalog::Locale) -> workshop_rs::Program {
+    let catalog = catalog();
+    parser::parse_with_context(source, &catalog, locale, &catalog)
+        .unwrap_or_else(|error| panic!("{locale} source must parse: {error}\n{source}"))
+}
+
+fn leaf_names(children: &[workshop_rs::settings::SettingsNode]) -> Vec<&str> {
+    let mut names = Vec::new();
+    for node in children {
+        match node {
+            workshop_rs::settings::SettingsNode::Group { name, children, .. } => {
+                names.push(name.as_str());
+                names.extend(leaf_names(children));
+            }
+            workshop_rs::settings::SettingsNode::Workshop { children, .. } => {
+                names.extend(leaf_names(children));
+            }
+            workshop_rs::settings::SettingsNode::Number { name, .. }
+            | workshop_rs::settings::SettingsNode::Bool { name, .. }
+            | workshop_rs::settings::SettingsNode::Flag { name, .. }
+            | workshop_rs::settings::SettingsNode::String { name, .. }
+            | workshop_rs::settings::SettingsNode::List { name, .. }
+            | workshop_rs::settings::SettingsNode::Raw { name, .. }
+            | workshop_rs::settings::SettingsNode::RawValue { name, .. }
+            | workshop_rs::settings::SettingsNode::RawGroup { name, .. } => {
+                names.push(name.as_str())
+            }
+        }
+    }
+    names
+}
+
+#[test]
+fn untranslated_markup_hero_names_parse() {
+    let tr = common::locale("tr-TR");
+    for hero in ["<en>Ana<en>", "<en>Soldier: 76<en>", "<en>Soldier : 76<en>"] {
+        parse_program_in(&hero_setting(hero, "Ability 1: On"), &tr)
+            .validate()
+            .expect("untranslated markup hero names validate");
+    }
+}
+
+#[test]
+fn settings_labels_containing_colons_parse() {
+    let ru = common::locale("ru-RU");
+    for label in [
+        "Время восстановления: Удар щитом",
+        "Удар щитом: сила отбрасывания",
+    ] {
+        let program = parse_program_in(&hero_setting("Brigitte", &format!("{label}: 100%")), &ru);
+        let settings = program.settings.expect("settings");
+        let names = leaf_names(&settings.children);
+        assert!(
+            names.iter().all(|name| *name != "Удар щитом"),
+            "the ability label must not be truncated at the inner colon: {names:?}"
+        );
+    }
+    parse_program_in(
+        &hero_setting("Brigitte", "Shield Bash Cooldown Time: 100%"),
+        &en(),
+    );
+}
+
+#[test]
+fn ability_display_name_binds_the_enable_key() {
+    let program = parse_program_in(&hero_setting("Brigitte", "Shield Bash: On"), &en());
+    let settings = program.settings.expect("settings");
+    assert!(
+        leaf_names(&settings.children).contains(&"enableAbility3"),
+        "expected enableAbility3, got {:?}",
+        leaf_names(&settings.children)
+    );
+}
+
+#[test]
+fn localized_ability_templates_resolve() {
+    let pt = common::locale("pt-BR");
+    for member in [
+        "Tempo de recarga de Dardos Tranquilizantes: 100%",
+        "Habilidade 1: On",
+    ] {
+        parse_program_in(&hero_setting("Ana", member), &pt)
+            .validate()
+            .expect("localized ability templates validate");
+    }
+}
+
+#[test]
+fn dotted_settings_booleans_parse() {
+    for (locale, boolean) in [("pl-PL", "Wł."), ("ru-RU", "Вкл."), ("ko-KR", "켜기")] {
+        let src = format!("settings {{\n    lobby {{\n        Map Rotation: {boolean}\n    }}\n}}");
+        parse_program_in(&src, &common::locale(locale))
+            .validate()
+            .expect("dotted settings booleans validate");
+    }
+}
+
+#[test]
+fn digit_and_spaced_team_names_parse() {
+    for (locale, team) in [("tr-TR", "1. Takım"), ("ko-KR", "1 팀")] {
+        let src = format!(
+            "settings {{\n    heroes {{\n        {team} {{\n            Ana {{\n                Ability 1: On\n            }}\n        }}\n    }}\n}}"
+        );
+        parse_program_in(&src, &common::locale(locale))
+            .validate()
+            .expect("digit and spaced team names validate");
+    }
+}
+
+#[test]
+fn localized_disabled_mode_prefixes_parse() {
+    for (locale, source) in [
+        ("tr-TR", "Devre Dışı Assault"),
+        ("es-ES", "No permitir Assault"),
+        ("ru-RU", "Откл. Assault"),
+        ("en-US", "Disabled Assault"),
+    ] {
+        let src = format!(
+            "settings {{\n    modes {{\n        {source} {{\n            enabled maps {{\n                Eichenwalde\n            }}\n        }}\n    }}\n}}"
+        );
+        parse_program_in(&src, &common::locale(locale))
+            .validate()
+            .expect("localized disabled mode prefixes validate");
+    }
+}
diff --git a/crates/workshop-rs/tests/statement_edit.rs b/crates/workshop-rs/tests/statement_edit.rs
index 4fa4ba4d..9c209397 100644
--- a/crates/workshop-rs/tests/statement_edit.rs
+++ b/crates/workshop-rs/tests/statement_edit.rs
@@ -76,13 +76,6 @@ pub(crate) fn waits(content: &JsonValue) -> Vec<f64> {
         .collect()
 }
 
-#[test]
-fn base_node_shapes_match_the_export() {
-    let content = lists(BASE, "en-US");
-    assert_eq!(content["actions"][0], wait(1.0));
-    assert_eq!(content["conditions"][0], cond(1.0));
-}
-
 #[test]
 fn insert_replace_delete_at_start_middle_end_of_actions() {
     let nodes = [wait(9.0)];
diff --git a/crates/workshop-rs/tests/statement_from_content.rs b/crates/workshop-rs/tests/statement_from_content.rs
index 627a21fc..31659cdf 100644
--- a/crates/workshop-rs/tests/statement_from_content.rs
+++ b/crates/workshop-rs/tests/statement_from_content.rs
@@ -225,12 +225,6 @@ fn spans_are_refused_wherever_they_appear() {
     }
 }
 
-#[test]
-fn a_refusal_produces_no_model_value() {
-    let node = json!({"call": "wait", "args": [1.0, {"call": "noSuchValue", "args": []}]});
-    assert!(convert(&node).is_err());
-}
-
 #[test]
 fn disabled_statements_keep_their_modifier() {
     for node in [
diff --git a/crates/workshop-rs/tests/wir_expansion.rs b/crates/workshop-rs/tests/wir_expansion.rs
index 68b6cef9..bf7c4a34 100644
--- a/crates/workshop-rs/tests/wir_expansion.rs
+++ b/crates/workshop-rs/tests/wir_expansion.rs
@@ -368,7 +368,7 @@ fn build_surface_program() -> wir::Program {
 }
 
 #[test]
-fn corpus_surface_is_representable_and_validates() {
+fn constructed_surface_program_is_representable_and_validates() {
     let program = build_surface_program();
     program.validate().expect("WIR is structurally valid");
     validate::validate_canonical_ids_wir(&program, &catalog()).expect("canonical ids resolve");
@@ -406,15 +406,6 @@ fn unknown_action_id_is_rejected_with_location() {
 #[test]
 fn unknown_enum_member_is_rejected() {
     let mut program = build_surface_program();
-    for node in program.values.iter() {
-        if let Value::Enum {
-            value_type, value, ..
-        } = &node.value
-            && value_type == "Color"
-        {
-            let _ = value;
-        }
-    }
     let color_id = program
         .values
         .iter()
@@ -435,13 +426,6 @@ fn unknown_enum_member_is_rejected() {
 #[test]
 fn unknown_value_id_is_rejected() {
     let mut program = build_surface_program();
-    for node in program.values.iter() {
-        if let Value::Call { name, .. } = &node.value
-            && name == "add"
-        {
-            let _ = name;
-        }
-    }
     let add_id = program
         .values
         .iter()
@@ -457,15 +441,6 @@ fn unknown_value_id_is_rejected() {
     assert!(error.to_string().contains("plus"), "{error}");
 }
 
-#[test]
-fn canonical_validation_is_locale_independent() {
-    let program = build_surface_program();
-    let _ = en();
-    validate::validate_canonical_ids_wir(&program, &catalog()).expect("valid");
-    let dump = program.dump();
-    assert!(!dump.contains("Disable Inspector Recording"));
-}
-
 #[test]
 fn canonical_validation_returns_first_error_and_short_circuits() {
     let catalog = catalog();