Deduplicate runtime verification artifacts

Author: CryZe

TODO.md

@@ -671,14 +671,6 @@ concepts rather than maintaining a parallel inventory.
 
 ### Engine and emulator providers
 
-- [ ] Propose a typed SNES provider from the Super Metroid evidence before
-  implementing it. Compare ASR's higan, bsnes, Snes9x, BizHawk, RetroArch, and
-  lsnes-bsnes discovery, moving mappings, address normalization, byte order,
-  region/timing differences, and core-unload behavior. The public shape should
-  match the existing `state GCN` / `state Genesis` provider model unless a
-  concrete SNES constraint justifies a change; bring that proposal to the user
-  first. A manual RetroArch memory root is an interim port, not the canonical
-  endpoint.
 - [ ] Decide the source-defined provider refresh lifecycle before claiming
   parity for emulator cores that unload without their host process exiting.
   `state PS2` validates RetroArch's core mapping on every read and fails safely
@@ -1011,11 +1003,13 @@ remaining work is product hardening and distribution.
   emitters with narrow inputs; separate call candidate collection, generic
   solving/selection, and diagnostic construction. Move one family at a time
   and do not replace one all-purpose context with nested bags of everything.
-- [ ] Compile each unique runtime `(source, output, profile)` artifact once in
+- [x] Compile each unique runtime `(source, output, profile)` artifact once in
   `cargo xtask check`, validate it once, and run all argument/scenario variants
-  against that artifact. Model compilation separately from runtime scenarios
-  and reject conflicting output definitions or duplicate scenarios without
-  reducing the maintained host coverage.
+  against that artifact. Compilation is modeled separately from runtime
+  scenarios; fixture planning rejects conflicting output definitions and exact
+  duplicate scenarios without reducing maintained host coverage. The current
+  matrix compiles and validates 65 artifacts for 93 runtime scenarios instead
+  of rebuilding 28 duplicate artifacts.
 - [ ] Add a small shared `instantiateRuntimeFixture` host for common Wasm
   loading, text/memory helpers, default imports, `_start`, and `update`, while
   keeping unusual host behavior and assertions local. Migrate harnesses only
@@ -1042,6 +1036,13 @@ remaining work is product hardening and distribution.
 
 ## P2 / deliberately deferred
 
+- [ ] After ASR has a tested SNES provider, align SplitScript with its higan,
+  bsnes, Snes9x, BizHawk, RetroArch, and lsnes-bsnes discovery and memory
+  semantics rather than independently inventing them from the Super Metroid
+  port. The eventual source design should normally match the existing
+  `state GCN` / `state Genesis` provider model, but must still be brought to the
+  user before implementation. A manual RetroArch memory root remains an interim
+  port, not the canonical endpoint.
 - [ ] Revisit native-state suggestions for typed emulator providers only if
   future porting evidence shows this remains a recurring source of incorrect
   scripts after the current provider documentation and search work. This is

docs/ROADMAP_ARCHIVE.md

@@ -1,5 +1,17 @@
 # SplitScript roadmap
 
+## 2026-08-30: deduplicated runtime verification artifacts
+
+- Separated `cargo xtask check` artifact definitions from runtime scenarios.
+  The verifier now compiles and validates each unique output once, then runs
+  every scenario against that artifact; the current 93-scenario matrix needs
+  65 builds instead of 93.
+- Added deterministic fixture-plan validation. Reusing an output for a
+  different source or profile and repeating an exact runtime scenario now fail
+  before compilation begins.
+- Moved the proposed SNES provider to the ASR-dependent deferred roadmap after
+  confirming the current ASR tree has no SNES implementation to align with.
+
 ## 2026-08-30: record literals gain identity-safe field shorthand
 
 - Added record field initializer shorthand: `Point { x }` lowers through the

src/bin/xtask.rs

@@ -4,11 +4,13 @@
 mod documentation_site;
 
 use std::{
+    collections::{BTreeMap, BTreeSet},
     env, fs,
     path::{Path, PathBuf},
     process::{Command, ExitCode},
 };
 
+#[derive(Clone, Copy)]
 struct RuntimeFixture {
     source: &'static str,
     output: &'static str,
@@ -17,13 +19,30 @@ struct RuntimeFixture {
     extra_arguments: &'static [&'static str],
 }
 
+#[derive(Clone, Copy)]
 struct CompileFixture {
     source: &'static str,
     output: &'static str,
     profile: &'static str,
 }
 
-const COMPILE_FIXTURES: &[CompileFixture] = &[];
+const COMPILE_FIXTURES: &[CompileFixture] = &[
+    CompileFixture {
+        source: "examples/lunistice.split",
+        output: "lunistice.release.wasm",
+        profile: "release",
+    },
+    CompileFixture {
+        source: "tests/debug_profile.split",
+        output: "debug_profile.debug.wasm",
+        profile: "debug",
+    },
+    CompileFixture {
+        source: "tests/debug_profile.split",
+        output: "debug_profile.release.wasm",
+        profile: "release",
+    },
+];
 
 const RUNTIME_FIXTURES: &[RuntimeFixture] = &[
     RuntimeFixture {
@@ -847,16 +866,13 @@ fn check() -> Result<(), String> {
     } else {
         "target/debug/splitc"
     });
-    for fixture in RUNTIME_FIXTURES {
-        compile_once(
-            &root,
-            &compiler,
-            fixture.source,
-            &outputs.join(fixture.output),
-            fixture.profile,
-        )?;
-    }
-    for fixture in COMPILE_FIXTURES {
+    let artifacts = verification_artifacts(RUNTIME_FIXTURES, COMPILE_FIXTURES)?;
+    println!(
+        "compiling {} unique verification artifacts for {} runtime scenarios",
+        artifacts.len(),
+        RUNTIME_FIXTURES.len()
+    );
+    for fixture in &artifacts {
         compile_once(
             &root,
             &compiler,
@@ -865,48 +881,14 @@ fn check() -> Result<(), String> {
             fixture.profile,
         )?;
     }
-    let lunistice_release = outputs.join("lunistice.release.wasm");
-    compile_once(
-        &root,
-        &compiler,
-        "examples/lunistice.split",
-        &lunistice_release,
-        "release",
-    )?;
     let debug = outputs.join("debug_profile.debug.wasm");
     let release = outputs.join("debug_profile.release.wasm");
-    compile_once(
-        &root,
-        &compiler,
-        "tests/debug_profile.split",
-        &debug,
-        "debug",
-    )?;
-    compile_once(
-        &root,
-        &compiler,
-        "tests/debug_profile.split",
-        &release,
-        "release",
-    )?;
 
-    let mut validated = RUNTIME_FIXTURES
-        .iter()
-        .map(|fixture| outputs.join(fixture.output))
-        .collect::<Vec<_>>();
-    validated.extend(
-        COMPILE_FIXTURES
-            .iter()
-            .map(|fixture| outputs.join(fixture.output)),
-    );
-    validated.extend([lunistice_release, debug.clone(), release.clone()]);
-    validated.sort();
-    validated.dedup();
-    for module in &validated {
+    for module in artifacts.iter().map(|fixture| outputs.join(fixture.output)) {
         run(
             &root,
             "wasm-tools",
-            &["validate", "--features", "all", path_text(module)?],
+            &["validate", "--features", "all", path_text(&module)?],
         )?;
     }
 
@@ -929,6 +911,57 @@ fn check() -> Result<(), String> {
     Ok(())
 }
 
+fn verification_artifacts(
+    runtime_fixtures: &[RuntimeFixture],
+    compile_fixtures: &[CompileFixture],
+) -> Result<Vec<CompileFixture>, String> {
+    let mut scenarios = BTreeSet::new();
+    for fixture in runtime_fixtures {
+        if !scenarios.insert((
+            fixture.source,
+            fixture.output,
+            fixture.profile,
+            fixture.harness,
+            fixture.extra_arguments,
+        )) {
+            return Err(format!(
+                "duplicate runtime scenario for `{}` with harness `{}` and arguments {:?}",
+                fixture.output, fixture.harness, fixture.extra_arguments
+            ));
+        }
+    }
+
+    let mut artifacts = BTreeMap::new();
+    for fixture in runtime_fixtures.iter().map(|fixture| CompileFixture {
+        source: fixture.source,
+        output: fixture.output,
+        profile: fixture.profile,
+    }) {
+        insert_artifact(&mut artifacts, fixture)?;
+    }
+    for &fixture in compile_fixtures {
+        insert_artifact(&mut artifacts, fixture)?;
+    }
+    Ok(artifacts.into_values().collect())
+}
+
+fn insert_artifact(
+    artifacts: &mut BTreeMap<&'static str, CompileFixture>,
+    fixture: CompileFixture,
+) -> Result<(), String> {
+    if let Some(previous) = artifacts.get(fixture.output) {
+        if previous.source != fixture.source || previous.profile != fixture.profile {
+            return Err(format!(
+                "conflicting artifact `{}`: `{}` ({}) and `{}` ({})",
+                fixture.output, previous.source, previous.profile, fixture.source, fixture.profile
+            ));
+        }
+    } else {
+        artifacts.insert(fixture.output, fixture);
+    }
+    Ok(())
+}
+
 fn compile_once(
     root: &Path,
     compiler: &Path,