mkdir -p raylib/tests/fixtures
cp raylib-test/resources/billboard.png raylib/tests/fixtures/billboard.png
cp raylib-test/resources/alagard.png raylib/tests/fixtures/alagard.png
cp raylib-test/resources/pixeloid.ttf raylib/tests/fixtures/pixeloid.ttf

git add raylib/tests/fixtures/billboard.png raylib/tests/fixtures/alagard.png raylib/tests/fixtures/pixeloid.ttf
git commit -m "$(cat <<'EOF'
feat(test-fixtures): copy assets from raylib-test/resources to raylib/tests/fixtures

Three binary assets copied verbatim:
- billboard.png — used by image_load + texture_load tests.
- alagard.png — used by font_load (PNG bitmap font).
- pixeloid.ttf — used by font_load_ex (TTF font).

These are the only fixtures needed for the salvaged tests; OBJ +
animation assets stay sourced from vendored
raylib-sys/raylib/examples/models/resources/.

Per spec §7. Originals remain at raylib-test/resources/ until Task 10
deletes the crate.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ffi::Color;

    /// Salvaged from raylib-test/src/texture.rs `test_image_loading`.
    /// Image is CPU-side; no window context needed.
    #[test]
    fn image_load_from_file_happy_and_error() {
        // Happy: load the bundled fixture.
        let path = "tests/fixtures/billboard.png";
        if std::path::Path::new(path).exists() {
            let img = Image::load_image(path).expect("billboard.png loads");
            assert!(img.width() > 0, "loaded image has non-zero width");
            assert!(img.height() > 0, "loaded image has non-zero height");
        } else {
            eprintln!("SKIP: {path} not found (cargo invoked from a non-workspace-root cwd?)");
        }

        // Error: nonexistent path returns Err.
        Image::load_image("tests/fixtures/does_not_exist.png")
            .expect_err("nonexistent file should error");
    }

    /// Salvaged from raylib-test/src/texture.rs `test_image_manipulations`.
    /// Exercises the Image CPU-side API without a window context.
    #[test]
    fn image_manipulations_no_segfault() {
        let mut i = Image::gen_image_color(32, 32, Color::new(230, 41, 55, 255));
        let mut canvas = Image::gen_image_color(32, 32, Color::new(0, 0, 0, 0));
        let mask = Image::gen_image_checked(
            32, 32, 8, 8,
            Color::new(255, 255, 255, 255),
            Color::new(0, 0, 0, 0),
        );

        let mut c = i.clone();
        c.alpha_mask(&mask);
        c.alpha_clear(Color::new(0, 0, 255, 255), 0.5);
        c.alpha_crop(0.5);
        c.alpha_premultiply();

        let mut blurry = c.clone();
        blurry.resize(64, 64);
        c.resize_nn(64, 64);
        i.resize_canvas(64, 64, 10, 10, Color::new(0, 0, 255, 255));

        c.mipmaps();
        blurry.dither(128, 128, 128, 128);

        let colors = c.extract_palette(100);
        assert_eq!(
            colors.len(),
            2,
            "checker-masked single-color image has 2-color palette"
        );

        canvas.draw(
            &i,
            Rectangle::new(0.0, 0.0, 20.0, 20.0),
            Rectangle::new(0.0, 0.0, 20.0, 20.0),
            Color::new(255, 255, 255, 255),
        );
        canvas.draw_rectangle_lines(
            Rectangle::new(20.0, 0.0, 20.0, 20.0),
            4,
            Color::new(0, 228, 48, 255),
        );
        canvas.draw_rectangle(40, 0, 20, 20, Color::new(255, 161, 0, 255));

        canvas.flip_vertical();
        canvas.flip_horizontal();
        canvas.rotate_cw();
        canvas.rotate_ccw();

        canvas.color_tint(Color::new(255, 109, 194, 255));
        canvas.color_invert();
        canvas.color_contrast(0.5);
        canvas.color_brightness(128);
        canvas.color_replace(
            Color::new(0, 228, 48, 255),
            Color::new(230, 41, 55, 255),
        );

        // Test reaches here = no segfault during the manipulation pipeline.
    }
}

cargo fmt --check 2>&1 | tail -3
cargo clippy -p raylib --features full --tests -- -D warnings 2>&1 | tail -5

git add raylib/src/core/texture.rs
git commit -m "$(cat <<'EOF'
test(image): salvage Tier-1 Image tests from raylib-test

Two #[test] fns added to raylib/src/core/texture.rs:
- image_load_from_file_happy_and_error: Image::load_image happy +
  error paths. Uses raylib/tests/fixtures/billboard.png (added in
  Task 1). Guards missing-asset with SKIP log.
- image_manipulations_no_segfault: exercises ~15 Image CPU-side fns
  (alpha_*, resize*, mipmaps, dither, palette extraction, draw_*,
  flip_*, rotate_*, color_*). Asserts extract_palette returns 2
  colors for a 2-color checker pattern; rest is "doesn't segfault"
  smoke coverage.

Tier-1 because Image is CPU-side — no window or RaylibHandle needed.
Salvaged from raylib-test/src/texture.rs.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

//! Tier-2: validate ModelAnimations::Drop frees the raylib heap array
//! exactly once. The sanitizers workflow (ASAN/UBSAN) runs this test
//! to catch double-free / use-after-free regressions in the WS3 RAII
//! redesign.
//!
//! Salvaged from raylib-test/tests/model_animation_raii.rs.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;
use raylib::test_harness::with_headless;

#[test]
fn model_animations_load_and_drop() {
    with_headless(64, 64, |rl, thread| {
        // Vendored raylib example asset — bundled with the raylib C source.
        let path = "raylib-sys/raylib/examples/models/resources/guy/guyanim.iqm";
        if std::path::Path::new(path).exists() {
            let anims = rl
                .load_model_animations(thread, path)
                .expect("animations load");
            assert!(!anims.is_empty(), "expected >= 1 animation");
            drop(anims); // exercises UnloadModelAnimations exactly once.
        } else {
            eprintln!("SKIP: animation asset not found at {path}");
        }
    });
}

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION --test integration_model_animations -- --test-threads=1 2>&1 | tail -10

git add raylib/tests/integration_model_animations.rs
git commit -m "$(cat <<'EOF'
test(integration): salvage model_animation_raii — ModelAnimations Drop RAII

New raylib/tests/integration_model_animations.rs (Tier-2,
software_renderer-gated). Explicit ModelAnimations::Drop assertion
matching what the sanitizers workflow wants to run for ASAN/UBSAN
coverage of the WS3 redesign.

Uses vendored raylib-sys/raylib/examples/models/resources/guy/guyanim.iqm
(no fixture copy needed). File-existence guarded with SKIP log.

Salvaged verbatim from raylib-test/tests/model_animation_raii.rs;
switched from raylib::init().build() to with_headless(64, 64, ...)
matching the existing Tier-2 convention.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

//! Tier-2: raylib's set_random_seed contract is deterministic.
//! Salvaged from raylib-test/src/random.rs.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;
use raylib::test_harness::with_headless;

#[test]
fn random_seed_is_deterministic() {
    with_headless(64, 64, |rl, _thread| {
        // Single value with seed 1: documented to return 2 for range 0..4.
        rl.set_random_seed(1);
        let r: i32 = rl.get_random_value(0..4);
        assert_eq!(r, 2, "set_random_seed(1) + get_random_value(0..4) is deterministic");

        // Sequence with seed 1: documented values from raylib-test/src/random.rs.
        rl.set_random_seed(1);
        let seq = rl.load_random_sequence(1..10, 10);
        let expected = [8, 7, 6, 4, 10, 3, 5, 1, 2, 9];
        assert_eq!(seq.len(), expected.len(), "sequence length matches");
        for (i, (got, want)) in seq.iter().zip(expected.iter()).enumerate() {
            assert_eq!(*got, *want, "sequence element {i} matches");
        }
    });
}

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION --test integration_random_seed -- --test-threads=1 2>&1 | tail -10

git add raylib/tests/integration_random_seed.rs
git commit -m "$(cat <<'EOF'
test(integration): salvage random-seed determinism assertions

New raylib/tests/integration_random_seed.rs (Tier-2,
software_renderer-gated). Two deterministic-seed assertions:
- set_random_seed(1) + get_random_value(0..4) == 2.
- set_random_seed(1) + load_random_sequence(1..10, 10) ==
  [8, 7, 6, 4, 10, 3, 5, 1, 2, 9].

Real assertions, not just smoke. Verifies raylib's documented
deterministic-seed contract still holds under 6.0.

Salvaged from raylib-test/src/random.rs.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

//! Tier-2: window-coupled API smoke tests batched into one test fn
//! (one InitWindow per process per file). Salvaged from
//! raylib-test/src/{misc,window}.rs.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;
use raylib::test_harness::with_headless;

#[test]
fn window_api_smoke() {
    with_headless(64, 64, |rl, thread| {
        // Clipboard round-trip.
        let s = "Hello, world!";
        rl.set_clipboard_text(s).expect("set_clipboard_text");
        let got = rl.get_clipboard_text().expect("get_clipboard_text");
        assert_eq!(got, s, "clipboard round-trip preserves text");

        // Screen-space conversions (don't panic).
        let cam = Camera::orthographic(
            Vector3::ZERO,
            Vector3::new(0.0, 0.0, 1.0),
            Vector3::Y,
            90.0,
        );
        let _ = rl.get_screen_to_world_ray(Vector2::ZERO, &cam);
        let _ = rl.get_world_to_screen(Vector3::ZERO, &cam);

        // Timing fns (don't panic).
        rl.set_target_fps(24);
        let _ = rl.get_fps();
        let _ = rl.get_frame_time();
        let _ = rl.get_time();

        // Cursor: double-show / double-hide / double-disable / double-enable
        // must be idempotent (raylib's C side guards against double-state).
        rl.hide_cursor();
        rl.hide_cursor();
        rl.show_cursor();
        rl.show_cursor();
        rl.disable_cursor();
        rl.disable_cursor();
        rl.enable_cursor();
        rl.enable_cursor();

        // Window title + dimensions (with_headless opened a 64x64 window).
        rl.set_window_title(thread, "raylib test");
        assert_eq!(rl.get_screen_width(), 64, "screen width matches headless dim");
        assert_eq!(rl.get_screen_height(), 64, "screen height matches headless dim");
    });
}

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION --test integration_window_api -- --test-threads=1 2>&1 | tail -15

if let Ok(()) = rl.set_clipboard_text(s) {
    if let Ok(got) = rl.get_clipboard_text() {
        assert_eq!(got, s);
    }
}

git add raylib/tests/integration_window_api.rs
git commit -m "$(cat <<'EOF'
test(integration): salvage window-coupled API smoke tests

New raylib/tests/integration_window_api.rs (Tier-2,
software_renderer-gated). One #[test] batching 5 smoke tests:
- Clipboard round-trip (set + get + assert equality).
- Screen-space conversions (get_screen_to_world_ray +
  get_world_to_screen) — don't panic.
- Timing fns (set_target_fps + get_fps + get_frame_time +
  get_time) — don't panic.
- Cursor double-show / hide / disable / enable idempotency.
- Window title set + screen-dimension verification (64x64 matches
  the with_headless dim).

Salvaged from raylib-test/src/{misc,window}.rs. Single #[test] fn
per the InitWindow single-init constraint.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

//! Tier-2: image + screen I/O smoke tests. Salvaged from
//! raylib-test/src/{misc,texture}.rs.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;
use raylib::test_harness::with_headless;

#[test]
fn image_io_smoke() {
    with_headless(64, 64, |rl, thread| {
        // take_screenshot writes a file.
        let out_dir = "target/tmp";
        std::fs::create_dir_all(out_dir).expect("mkdir target/tmp");
        let shot = format!("{out_dir}/screenshot.png");
        rl.take_screenshot(thread, &shot);
        assert!(
            std::path::Path::new(&shot).exists(),
            "take_screenshot writes {shot}"
        );

        // load_image_from_screen: make sure it doesn't segfault.
        let _ = rl.load_image_from_screen(thread);

        // texture_load: load PNG from file + from existing Image.
        let path = "tests/fixtures/billboard.png";
        if std::path::Path::new(path).exists() {
            let img = Image::load_image(path).expect("image loads");
            let _tex = rl
                .load_texture(thread, path)
                .expect("texture loads from path");
            let _tex2 = rl
                .load_texture_from_image(thread, &img)
                .expect("texture loads from image");
        } else {
            eprintln!("SKIP: {path} not found");
        }

        // render_texture: wrapped in catch_unwind because software_renderer
        // may not support GL framebuffer objects. If it panics, log a SKIP
        // and continue.
        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
            rl.load_render_texture(thread, 256, 256)
                .expect("render texture creates")
        }));
        match result {
            Ok(_rt) => { /* loaded successfully; dropping at end */ }
            Err(_) => eprintln!("SKIP: load_render_texture not supported under software_renderer"),
        }
    });
}

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION --test integration_image_io -- --test-threads=1 2>&1 | tail -15

git add raylib/tests/integration_image_io.rs
git commit -m "$(cat <<'EOF'
test(integration): salvage image + screen I/O smoke tests

New raylib/tests/integration_image_io.rs (Tier-2,
software_renderer-gated). One #[test] batching 4 smoke tests:
- take_screenshot writes target/tmp/screenshot.png; assert file
  exists.
- load_image_from_screen doesn't segfault.
- load_texture (from path) + load_texture_from_image (from Image)
  both succeed using tests/fixtures/billboard.png.
- load_render_texture (256, 256): wrapped in catch_unwind because
  software_renderer may not support GL framebuffer objects.
  Logs SKIP and continues if it panics.

Salvaged from raylib-test/src/{misc,texture}.rs.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

//! Tier-2: font loading + export smoke tests.
//! Salvaged from raylib-test/src/text.rs.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;
use raylib::test_harness::with_headless;

#[test]
fn fonts_load_and_export_smoke() {
    with_headless(64, 64, |rl, thread| {
        // Bitmap font (PNG).
        let png_path = "tests/fixtures/alagard.png";
        if std::path::Path::new(png_path).exists() {
            let _font = rl
                .load_font(thread, png_path)
                .expect("load_font (png) succeeds");
        } else {
            eprintln!("SKIP: {png_path} not found");
        }

        // TTF font with explicit size + None glyph chars (use defaults).
        let ttf_path = "tests/fixtures/pixeloid.ttf";
        if std::path::Path::new(ttf_path).exists() {
            let _font_ex = rl
                .load_font_ex(thread, ttf_path, 32, None)
                .expect("load_font_ex (ttf) succeeds");
        } else {
            eprintln!("SKIP: {ttf_path} not found");
        }

        // export_font_as_code: write a .h file. Use target/tmp/ for output.
        if std::path::Path::new(png_path).exists() {
            std::fs::create_dir_all("target/tmp").expect("mkdir target/tmp");
            let font = rl.load_font(thread, png_path).expect("load_font for export");
            let _ = font.export_font_as_code("target/tmp/font.h");
            assert!(
                std::path::Path::new("target/tmp/font.h").exists(),
                "export_font_as_code writes target/tmp/font.h"
            );
        }
    });
}

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,SUPPORT_FILEFORMAT_TTF --test integration_fonts -- --test-threads=1 2>&1 | tail -10

git add raylib/tests/integration_fonts.rs
git commit -m "$(cat <<'EOF'
test(integration): salvage font load + export smoke tests

New raylib/tests/integration_fonts.rs (Tier-2,
software_renderer-gated). One #[test] batching 3 smoke tests:
- load_font (PNG bitmap font) using tests/fixtures/alagard.png.
- load_font_ex (TTF font, size 32, default glyphs) using
  tests/fixtures/pixeloid.ttf.
- export_font_as_code writes target/tmp/font.h; assert file exists.

Each test guards the asset path with file-existence + SKIP log.
TTF support requires SUPPORT_FILEFORMAT_TTF in the feature set.

Salvaged from raylib-test/src/text.rs.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

//! Tier-2: model loading + generated-mesh smoke tests.
//! Salvaged from raylib-test/src/models.rs.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;
use raylib::test_harness::with_headless;

#[test]
fn models_load_and_generated_smoke() {
    with_headless(64, 64, |rl, thread| {
        // OBJ model loading: use vendored cube.obj from raylib examples.
        let obj_path = "raylib-sys/raylib/examples/models/resources/models/obj/cube.obj";
        if std::path::Path::new(obj_path).exists() {
            let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                let _ = rl.load_model(thread, obj_path);
            }));
            if result.is_err() {
                eprintln!("SKIP: load_model not supported under software_renderer");
            }
        } else {
            eprintln!("SKIP: {obj_path} not found");
        }

        // Model from generated mesh: gen_mesh_cube + load_model_from_mesh.
        // May fail under software_renderer if GL VBO upload is required.
        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
            let mesh = unsafe {
                Mesh::gen_mesh_cube(thread, 1.0, 1.0, 1.0).make_weak()
            };
            let _model = rl.load_model_from_mesh(thread, mesh)
                .expect("load_model_from_mesh");
        }));
        if result.is_err() {
            eprintln!("SKIP: gen_mesh_cube + load_model_from_mesh not supported under software_renderer");
        }
    });
}

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,SUPPORT_FILEFORMAT_OBJ,SUPPORT_MESH_GENERATION --test integration_models -- --test-threads=1 2>&1 | tail -10

git add raylib/tests/integration_models.rs
git commit -m "$(cat <<'EOF'
test(integration): salvage model loading + generated-mesh smoke tests

New raylib/tests/integration_models.rs (Tier-2,
software_renderer-gated). One #[test] batching 2 smoke tests:
- load_model (OBJ) using vendored
  raylib-sys/raylib/examples/models/resources/models/obj/cube.obj.
- gen_mesh_cube + load_model_from_mesh: generated 1x1x1 cube mesh,
  loaded as model.

Both calls wrapped in catch_unwind because software_renderer may not
support GL VBO upload required by model loading. Logs SKIP and
continues if either panics.

Salvaged from raylib-test/src/models.rs. Feature set requires
SUPPORT_FILEFORMAT_OBJ + SUPPORT_MESH_GENERATION.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,SUPPORT_FILEFORMAT_TTF,SUPPORT_FILEFORMAT_OBJ,SUPPORT_MESH_GENERATION -- --test-threads=1 2>&1 | tail -20

cargo fmt --check 2>&1 | tail -3
cargo clippy -p raylib --features full --tests -- -D warnings 2>&1 | tail -5

git rm -r raylib-test/ 2>&1 | tail -5

rm -rf raylib-test/

git add -u  # picks up the workspace Cargo.toml + the deletions
git commit -m "$(cat <<'EOF'
feat(workspace)!: delete raylib-test crate, salvage moved in-tree

Removes the entire raylib-test/ directory (~1591 LOC of stale tests
+ Cargo.toml + README + resources/). Also removes raylib-test from
the workspace Cargo.toml exclude list (no longer needed since the
directory is gone).

All 17 still-relevant tests have been salvaged to in-tree Tier-1 +
Tier-2 targets in prior tasks of this workstream:
- raylib/src/core/texture.rs gets 2 Tier-1 Image tests.
- raylib/tests/integration_*.rs gets 6 integration files (one #[test]
  per file per the InitWindow single-init constraint).
- raylib/tests/fixtures/ holds 3 copied assets.

CI cleanup (integration-xvfb job removal + sanitizers.yml comment
update + CLAUDE.md workspace-layout cleanup) lands in subsequent
tasks of this workstream.

BREAKING for raylib-test consumers: the crate is gone. It was never
published, so no downstream impact expected. See
docs/superpowers/notes/spike-raylib-test-delete-or-fix.md for the
decision history.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

NODE_PATH=/tmp/yaml-check/node_modules node -e "const yaml=require('js-yaml');const fs=require('fs');yaml.load(fs.readFileSync('.github/workflows/test.yml','utf8'));console.log('OK')" 2>&1 | tail -3

# NOTE: the originally-specified model_animation_raii target lives in raylib-test,
# which is stale vs the 6.0 API (see notes/spike-raylib-test-delete-or-fix.md);

# Runs the ModelAnimations RAII test (raylib/tests/integration_model_animations.rs)
# under ASAN/UBSAN to validate ModelAnimations::Drop doesn't double-free the heap
# array allocated by LoadModelAnimations.

software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION

NODE_PATH=/tmp/yaml-check/node_modules node -e "const yaml=require('js-yaml');const fs=require('fs');yaml.load(fs.readFileSync('.github/workflows/sanitizers.yml','utf8'));console.log('OK')" 2>&1 | tail -3

git add .github/workflows/test.yml .github/workflows/sanitizers.yml
git commit -m "$(cat <<'EOF'
ci(test,sanitizers): remove integration-xvfb job; update sanitizers comment

- test.yml: remove the entire `integration-xvfb` Linux job + its
  preamble comments. The job was non-required (continue-on-error)
  and has been a no-op since WS6a when raylib-test went stale.
  With raylib-test deleted (Task 10 of this workstream), the job
  is dead.
- sanitizers.yml: update the stale "model_animation_raii target
  lives in raylib-test, which is stale vs the 6.0 API" comment to
  point at the new test location:
  raylib/tests/integration_model_animations.rs (Task 3 of this
  workstream). Verify the workflow's feature set includes
  software_renderer + the SUPPORT_MODULE_* flags needed for the
  new test.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

- `raylib-test/` — integration tests that open a window. Excluded from workspace; requires nightly. Run from inside the directory.

raylib-test ✅ → UBSAN ← NEXT

## Decision (2026-05-29)

**Outcome:** Option A + salvage. The raylib-test crate is deleted;
the still-relevant tests are migrated to the in-tree Tier-1 / Tier-2
surface (2 Image-API unit tests in `raylib/src/core/texture.rs`;
15 window-coupled tests grouped into 6 integration files under
`raylib/tests/integration_*.rs`).

**Sanitizers coverage preserved** via the new
`raylib/tests/integration_model_animations.rs` target — the
ModelAnimations RAII Drop test that the sanitizers workflow's
WS6a comment explicitly wanted to run.

**Window-real-GLFW coverage retired.** The `integration-xvfb` CI
job is removed. The `software_renderer` Tier-2 tests (rlsw +
Memory platform) remain the gating headless coverage. WS9's
showcase port will provide broad real-API exercise once the
showcase is feature-complete.

**Workstream:** `docs/superpowers/specs/2026-05-29-raylib-test-delete-and-salvage-design.md`
+ `docs/superpowers/plans/2026-05-29-raylib-test-delete-and-salvage.md`.

- raylib-test crate removed in favor of in-tree integration tests at
  `raylib/tests/integration_*.rs`. 17 salvaged tests (2 Tier-1 image
  + 15 Tier-2 window-coupled, grouped into 6 files by topic) replace
  the stale nightly-harness crate. Window-real-GLFW coverage via
  xvfb retired; `software_renderer` is the gating headless coverage.
  Sanitizers workflow now targets the new
  `integration_model_animations.rs` directly. See
  `docs/superpowers/notes/spike-raylib-test-delete-or-fix.md` for
  the decision history.

git add CLAUDE.md docs/superpowers/notes/spike-raylib-test-delete-or-fix.md CHANGELOG.md
git commit -m "$(cat <<'EOF'
docs(raylib-test): close out the delete-or-fix decision

- CLAUDE.md: drop the raylib-test/ workspace-layout bullet (the
  crate is gone). Status line: raylib-test ← NEXT → raylib-test ✅
  → UBSAN ← NEXT.
- docs/superpowers/notes/spike-raylib-test-delete-or-fix.md:
  append "## Decision (2026-05-29)" section recording Option A +
  salvage as the outcome. Preserves the rest of the spike as
  historical record.
- CHANGELOG.md ## 6.0.0-rc.1 (unreleased) ### Internal: new entry
  summarizing the raylib-test retirement, the salvage shape (2
  Tier-1 + 15 Tier-2 across 6 files), and the sanitizers-coverage
  preservation.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"

cargo test -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,SUPPORT_FILEFORMAT_TTF,SUPPORT_FILEFORMAT_OBJ,SUPPORT_MESH_GENERATION -- --test-threads=1 2>&1 | tail -20

cargo clippy -p raylib --tests --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,SUPPORT_FILEFORMAT_TTF,SUPPORT_FILEFORMAT_OBJ,SUPPORT_MESH_GENERATION -- -D warnings 2>&1 | tail -5