- name: Unit + doc tests
        run: cargo test -p raylib --features ${{ matrix.features }} && cargo test -p raylib --doc --features ${{ matrix.features }}

      - name: Install cargo-nextest
        uses: taiki-e/install-action@nextest
      - name: Unit tests (nextest)
        run: cargo nextest run -p raylib --features ${{ matrix.features }}
      - name: Doc tests
        run: cargo test -p raylib --doc --features ${{ matrix.features }}

      - name: Tier-2 render tests (shapes/text)
        run: cargo test -p raylib --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 render_shapes --test render_text -- --test-threads=1

      - name: Install cargo-nextest
        uses: taiki-e/install-action@nextest
      - name: Tier-2 render tests (shapes/text)
        run: cargo nextest run -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION -E 'test(render_shapes) | test(render_text)'
      - name: Tier-2 render tests (raygui)
        run: cargo nextest run -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,raygui -E 'test(render_gui)'
      - name: Tier-2 render tests (rlgl)
        run: cargo nextest run -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION -E 'test(render_rlgl)'
      - name: Tier-2 integration tests (raylib-test salvage)
        run: cargo nextest run -p raylib --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 -E 'test(integration_window_api) | test(integration_image_io) | test(integration_random_seed) | test(integration_fonts) | test(integration_models) | test(integration_model_animations)'

  software-render:
    strategy:
      ...
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v5
        with:
          submodules: recursive
      - name: Install Linux build deps
        ...
      - name: Install macOS build deps
        ...
      - name: Install cargo-nextest
        uses: taiki-e/install-action@nextest
      - name: Build (software_renderer)
        ...
      - name: Headless smoke test
        ...
      - name: Tier-2 render tests (shapes/text)
        run: cargo nextest run -p raylib ... -E 'test(render_shapes) | test(render_text)'
      ... [rest of Tier-2 steps]

      - name: Doctests (software_renderer)
        run: cargo test -p raylib --doc --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

#[cfg(test)]
mod nextest_smoke {
    //! Smoke test for the cargo-nextest switch (rustdoc-rewrite Task 1).
    //!
    //! With cargo test, both #[test]s below run in the same process and the
    //! second hits raylib's "context already initialized" panic. With cargo
    //! nextest run, each #[test] runs in its own subprocess so both pass.
    //!
    //! Reverted at end of Task 1 once the property is confirmed on fork CI.
    use super::*;

    #[test]
    fn nextest_smoke_a() {
        with_headless(32, 32, |rl, thread| {
            let img = render_frame(rl, thread, |d| {
                d.clear_background(crate::prelude::Color::WHITE);
            });
            assert_pixel(&img, 0, 0, crate::prelude::Color::WHITE, 0);
        });
    }

    #[test]
    fn nextest_smoke_b() {
        with_headless(32, 32, |rl, thread| {
            let img = render_frame(rl, thread, |d| {
                d.clear_background(crate::prelude::Color::BLACK);
            });
            assert_pixel(&img, 0, 0, crate::prelude::Color::BLACK, 0);
        });
    }
}

- Tests: `cargo test` and `cargo test --doc` from inside `raylib/`.
- Headless integration tests (Tier-2): `cargo test -p raylib --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-threads=1` (uses `software_renderer` + the rlsw Memory platform; no window opens).

- Tests: `cargo nextest run` (unit + integration; per-test process isolation respects raylib's single-init constraint) and `cargo test --doc` (doctests; nextest does not run them). Both from inside `raylib/`. Contributors without cargo-nextest can fall back to `cargo test ... -- --test-threads=1` locally; CI uses nextest.
- Headless integration tests (Tier-2): `cargo nextest run -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION` (uses `software_renderer` + the rlsw Memory platform; no window opens). Software-renderer doctests run via `cargo test -p raylib --doc --no-default-features --features software_renderer,...` (same feature set).

cargo fmt --all --check

cargo clippy -p raylib --features full -- -D warnings

git add .github/workflows/test.yml raylib/src/test_harness.rs CLAUDE.md CONTRIBUTE.md
git commit -m "$(cat <<'EOF'
test(nextest): switch test.yml unit+software-render to cargo nextest run

Per-test process isolation respects raylib's single-init constraint
without --test-threads=1, unblocking multiple harness #[test]s per
file. Doctests stay on cargo test --doc (nextest does not run them);
adds a new software-renderer doctest leg so Flavor-2 harness-runnable
examples actually execute. Includes a temporary nextest_smoke #[test]
pair proving per-test isolation; reverted once fork CI confirms green.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

git add raylib/src/test_harness.rs
git commit -m "$(cat <<'EOF'
revert(nextest-smoke): drop the temporary nextest_smoke test pair

The smoke confirmed cargo nextest run's per-test process isolation
respects raylib's single-init constraint on fork CI. Smoke's job is
done; no signal remains.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

cargo clippy -p raylib --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 --tests -- -D warnings 2>&1 | tee /tmp/clippy-out.txt

cargo clippy -p raylib --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 --tests -- -D warnings

cargo clippy -p raylib --features full --tests -- -D warnings

cargo nextest run -p raylib --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 -E 'test(integration_models) | test(integration_fonts)'

git add raylib/tests/integration_models.rs raylib/tests/integration_fonts.rs
git commit -m "$(cat <<'EOF'
fix(tests): clippy unused warnings in integration_{models,fonts}.rs

Salvaged from the deleted raylib-test crate in the raylib-test-
salvage workstream; left unused_imports/unused_variables behind that
made the check workflow's clippy -D warnings red. Removing dead
imports and prefixing intentionally-unused bindings with _ restores
green. Fold-in per rustdoc-rewrite spec §3 D8 (same raylib/tests/
surface as the workstream's other adjacent work).

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

git log --oneline --all | grep -iE 'ws6a|missing.docs|batch 3' | head -20

find raylib/src -name '*.rs' -not -path '*/test_harness.rs' | xargs -I{} sh -c 'echo "=== {} ==="; grep -c "^pub\|    pub" {}' | head -40

grep -n '^///' raylib/src/core/error.rs | awk -F: '{print $1}' > /tmp/stub-lines.txt
# Then for each line N in /tmp/stub-lines.txt, check if line N+1 starts with /// (multi-line doc) or with pub/fn/enum (single-line stub).

files:
  - path: raylib/src/core/error.rs
    stubs:
      - line: 8
        item: "AudioInitError::DoubleInit"
        flavor: template-a
      - line: 11
        item: "AudioInitError::InitFailed"
        flavor: template-a
      # ... etc
    ws7_enriched: []   # WS7 didn't touch error.rs
  - path: raylib/src/ease.rs
    stubs:
      - line: <N>
        item: "linear_in"
        flavor: flavor-1
      # ...
    ws7_enriched: []
  # ... etc

# Rustdoc rewrite — per-file stub inventory

Snapshot of single-line `///` stubs (added by WS6a, not enriched by
WS7) that the Wave 1 implementers will enrich. Each Wave-1 dispatch
brief includes its file's section verbatim.

## raylib/src/core/error.rs (Wave-1 dispatch B1)

WS6a-added stubs: <N> (target: enrich all to Template A).
WS7-enriched items in this file: <list or "none">.

| Line | Item | Flavor | Notes |
|------|------|--------|-------|
| 8 | `AudioInitError::DoubleInit` | Template A | parent enum line 7 |
| ... | ... | ... | ... |

Parent enums (require Flavor-3 `# Examples` block on the enum itself):
- `AudioInitError` (line 7)
- `ExportWaveError` (line 18)
- ... etc

## raylib/src/ease.rs (Wave-1 dispatch B2)

[...]

**Total stubs across all files: <N>** (spec quotes ~183; verify and update spec §5's `~183` if the count differs by more than 10%).

git add docs/superpowers/notes/rustdoc-rewrite-stub-inventory.md
git commit -m "$(cat <<'EOF'
docs(rustdoc-rewrite): per-file stub inventory for Wave 1 dispatches

Enumerates the remaining WS6a one-line stubs per file (WS7-enriched
items excluded) so Wave-1 implementers have a precise worklist.
Temporary; superseded by the done-note at workstream close.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// <Summary in active voice — expansion of the #[error] message.>
///
/// **Cause:** <Concrete situation that triggers this variant.>
///
/// **Recovery:** <What the caller can reasonably do.>
#[error("...")]
VariantName { ... }

/// Errors returned when initializing the raylib audio device.
#[derive(Error, Debug)]
pub enum AudioInitError {
    /// Audio was already initialized; only one audio device may be active at a time.
    #[error("RaylibAudio cannot be instantiated more then once at a time")]
    DoubleInit,
    /// The underlying audio device failed to initialize.
    #[error("failed to initialize audio device")]
    InitFailed,
}

/// Errors returned when initializing the raylib audio device.
///
/// # Examples
///
/// ```no_run
/// use raylib::prelude::*;
/// use raylib::core::audio::RaylibAudio;
///
/// match RaylibAudio::init_audio_device() {
///     Ok(audio) => { /* use audio */ }
///     Err(e) => match e {
///         raylib::core::error::AudioInitError::DoubleInit => {
///             eprintln!("audio device already open");
///         }
///         raylib::core::error::AudioInitError::InitFailed => {
///             eprintln!("audio device init failed");
///         }
///     },
/// }
/// ```
#[derive(Error, Debug)]
pub enum AudioInitError {
    /// Audio was already initialized; only one audio device may be active at a time.
    ///
    /// **Cause:** raylib's `InitAudioDevice` was called while a `RaylibAudio` is
    /// already live in this process. raylib enforces a single global audio device.
    ///
    /// **Recovery:** drop the existing `RaylibAudio` (releasing it via `Drop` closes
    /// the device) before constructing a new one, or reuse the existing handle.
    #[error("RaylibAudio cannot be instantiated more then once at a time")]
    DoubleInit,
    /// The underlying audio device failed to initialize.
    ///
    /// **Cause:** the platform's audio backend (CoreAudio on macOS, WASAPI on
    /// Windows, ALSA/PulseAudio on Linux) could not open a default playback
    /// device. Common causes: no audio hardware, a held exclusive lock, or
    /// a missing driver.
    ///
    /// **Recovery:** report to the user and fall back to silent mode. Audio cannot
    /// be enabled in this process until the underlying issue is resolved.
    #[error("failed to initialize audio device")]
    InitFailed,
}

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings

RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps

cargo test -p raylib --doc --features full

git add raylib/src/core/error.rs
git commit -m "$(cat <<'EOF'
docs(error): enrich error enum variants with cause + recovery prose

Applies rustdoc-rewrite Template A across all variants in
core/error.rs. Each parent enum receives one Flavor-3 # Examples
block showing a match against its variants. Per-variant docs gain
**Cause:** and **Recovery:** lines so callers handling the error
know what triggers it and what they can do.

Doc-only; no behavior change.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Ease-out quadratic.
pub fn quad_out(t: f32, b: f32, c: f32, d: f32) -> f32 {
    -c * (t / d) * ((t / d) - 2.0) + b
}

/// Ease-out quadratic — fast start, slow end.
///
/// Returns the interpolated value at time `t` (in `[0, d]`), starting at base
/// `b` and ending at `b + c`. Quadratic easing has a single curved acceleration
/// profile (vs. cubic's steeper one); use it when the motion should noticeably
/// decelerate but not abruptly stop.
///
/// # Examples
///
/// ```rust
/// use raylib::ease::quad_out;
///
/// assert_eq!(quad_out(0.0, 0.0, 1.0, 1.0), 0.0);
/// assert_eq!(quad_out(1.0, 0.0, 1.0, 1.0), 1.0);
/// assert!((quad_out(0.5, 0.0, 1.0, 1.0) - 0.75).abs() < 1e-6);
/// ```
pub fn quad_out(t: f32, b: f32, c: f32, d: f32) -> f32 {
    -c * (t / d) * ((t / d) - 2.0) + b
}

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/ease.rs
git commit -m "$(cat <<'EOF'
docs(ease): runtime-checked Flavor-1 examples for easing fns

Applies rustdoc-rewrite Template B with Flavor 1 (pure compile+run)
across all 28 easing functions in ease.rs. Each fn gains a one-line
descriptor, a sentence on its motion profile, and a doctest that
asserts endpoint behaviour + midpoint signature (in/out/inout).

Doc-only; no behavior change.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Draws a rectangle outline at the given position with the given dimensions.
fn draw_rectangle_lines(&mut self, ...) { ... }

/// Draws a rectangle outline (1-pixel-thick stroke) at `(x, y)` with the given
/// `width` and `height`, using `color` for the stroke.
///
/// The outline is inclusive of the bounding box — `(x, y)` is the top-left pixel,
/// `(x + width - 1, y + height - 1)` is the bottom-right.
///
/// # Examples
///
/// ```rust
/// # #[cfg(feature = "software_renderer")] {
/// use raylib::prelude::*;
/// use raylib::test_harness::*;
///
/// with_headless(64, 64, |rl, thread| {
///     let img = render_frame(rl, thread, |d| {
///         d.clear_background(Color::WHITE);
///         d.draw_rectangle_lines(10, 10, 20, 20, Color::RED);
///     });
///     // Stroke pixel:
///     assert_pixel(&img, 10, 10, Color::RED, 0);
///     // Interior pixel (still white):
///     assert_pixel(&img, 15, 15, Color::WHITE, 0);
/// });
/// # }
/// ```
///
/// # See also
///
/// - [`RaylibDraw::draw_rectangle`] — filled variant
fn draw_rectangle_lines(&mut self, ...) { ... }

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full
cargo test -p raylib --doc --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

git add raylib/src/core/drawing.rs
git commit -m "$(cat <<'EOF'
docs(drawing): harness-runnable Flavor-2 examples for drawing primitives

Adds Flavor-2 doctests (cfg-gated body under software_renderer)
across the 17 WS6a stubs in core/drawing.rs. Each draw primitive
gets a pixel-probe example that verifies its rasterizer output:
inside-the-shape and outside-the-shape both checked. Under
--features full the doctests compile to fn main() {} and pass
instantly; under software_renderer they execute via the rlsw
Memory platform and assert actual pixel values.

WS7-enriched items in this file (RaylibDraw trait itself) left
untouched.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Returns the camera's view matrix.
///
/// The view matrix transforms world coordinates into camera/eye space. Use it
/// when manually rendering geometry that camera should observe.
///
/// # Examples
///
/// ```rust
/// use raylib::prelude::*;
///
/// let cam = Camera3D::perspective(
///     Vector3::new(0.0, 10.0, 10.0),  // position
///     Vector3::new(0.0, 0.0, 0.0),    // target
///     Vector3::new(0.0, 1.0, 0.0),    // up
///     45.0,
/// );
/// let view = cam.get_matrix();
/// // View matrix translates +Z = camera direction; verify a known invariant:
/// assert!((view.m15 - 1.0).abs() < 1e-5);
/// ```
pub fn get_matrix(&self) -> Matrix { ... }

/// Updates the camera based on the current input state and `mode`.
///
/// Call once per frame; raylib reads keyboard/mouse and adjusts the camera
/// position + target accordingly. Each `CameraMode` has its own interpretation —
/// see [`CameraMode`] for details.
///
/// # Examples
///
/// ```no_run
/// use raylib::prelude::*;
///
/// let (mut rl, thread) = raylib::init().size(800, 600).title("demo").build();
/// let mut cam = Camera3D::perspective(
///     Vector3::new(0.0, 10.0, 10.0),
///     Vector3::zero(),
///     Vector3::up(),
///     60.0,
/// );
/// while !rl.window_should_close() {
///     rl.update_camera(&mut cam, CameraMode::Free);
///     // render with cam ...
/// }
/// ```
pub fn update_camera(&mut self, cam: &mut Camera3D, mode: CameraMode) { ... }

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/core/camera.rs
git commit -m "$(cat <<'EOF'
docs(camera): Flavor-1 + Flavor-3 examples for camera helpers

Flavor 1 for pure camera-math fns (get_matrix, screen-to-world etc.) —
doctests run and assert mathematical invariants. Flavor 3 for window-
required fns (update_camera, camera-mode handlers) — no_run with
standard init+loop scaffolding.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Loads a `Mesh` from a vertex+index array.
///
/// The mesh is uploaded to GPU memory on creation; drop the returned `Mesh` to
/// release the upload. For meshes you build procedurally (terrain, particles),
/// prefer this over loading from a file.
///
/// # Examples
///
/// ```no_run
/// use raylib::prelude::*;
///
/// let (mut rl, thread) = raylib::init().size(800, 600).title("demo").build();
/// // Build a procedural cube mesh ...
/// let mesh = Mesh::gen_mesh_cube(&thread, 1.0, 1.0, 1.0);
/// let model = rl.load_model_from_mesh(&thread, mesh).unwrap();
/// ```
pub fn ...

/// Returns the number of vertices in this mesh.
pub fn vertex_count(&self) -> usize { ... }

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/core/models.rs
git commit -m "$(cat <<'EOF'
docs(models): Flavor-3 demos for model + mesh helpers

Enriches the 11 WS6a stubs in core/models.rs. Window-required fns
get Flavor-3 no_run examples with standard init+load scaffolding;
trivial getters whose name fully describes behavior stay at single-
line prose per spec §4.3 skip-examples policy.

WS7-enriched Mesh/Model/Material/ModelAnimations types untouched.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Returns whether the window's contents have been resized since last call.
///
/// Use this to recompute layout when the user drags the window edge. Note
/// that on fullscreen toggles, raylib also reports the dimensions changed.
///
/// # Examples
///
/// ```no_run
/// use raylib::prelude::*;
///
/// let (mut rl, thread) = raylib::init().size(800, 600).title("demo").build();
/// while !rl.window_should_close() {
///     if rl.is_window_resized() {
///         // recompute layout for new (rl.get_screen_width(), rl.get_screen_height())
///     }
/// }
/// ```
pub fn is_window_resized(&self) -> bool { ... }

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/core/window.rs
git commit -m "$(cat <<'EOF'
docs(window): Flavor-3 demos for window inspection helpers

Enriches the 7 WS6a stubs in core/window.rs. WS7-enriched
RaylibHandle/RaylibThread/RaylibBuilder untouched; these are the
smaller window-query helpers (monitor info, resize detection).

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Returns the color as a packed RGBA `u32` (R in highest byte, A in lowest).
///
/// # Examples
///
/// ```rust
/// use raylib::prelude::*;
///
/// assert_eq!(Color::RED.color_to_int(), 0xFF0000FF);
/// ```
pub fn color_to_int(&self) -> u32 { ... }

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/core/mod.rs
git commit -m "$(cat <<'EOF'
docs(core): Flavor-1 examples for Color/Rectangle helpers

Enriches the 5 WS6a stubs in core/mod.rs. WS7-enriched Color and
Rectangle types themselves left untouched; these are the smaller
helper methods (conversions, packed-int representations) that gain
runnable doctests asserting numeric correctness.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

/// Generates a thin wrapper type around an FFI pointer, with `Drop` calling
/// the supplied `Unload*` raylib fn.
///
/// The wrapper transparently exposes `Deref<Target = ffi::T>` so callers can
/// pass `&wrapper` everywhere a `&ffi::T` is expected. The wrapper is `!Send`
/// + `!Sync` because raylib resources are single-threaded.
///
/// Expansion shape (conceptual):
///
/// ```text
/// pub struct Wrapper(*mut ffi::T);
/// impl Drop for Wrapper { fn drop(&mut self) { ffi::UnloadT(self.0); } }
/// impl Deref for Wrapper { type Target = ffi::T; fn deref(&self) -> &ffi::T { ... } }
/// ```
///
/// Used internally to wrap `Image`, `Texture2D`, `RenderTexture2D`, etc.
#[macro_export]
macro_rules! make_thin_wrapper { ... }

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/core/macros.rs
git commit -m "$(cat <<'EOF'
docs(macros): expand prose for internal wrapper macros

Enriches the 4 WS6a stubs in core/macros.rs. Macros get expanded
prose describing purpose, expansion shape, and use sites — no
# Examples blocks per spec §4.3 (a macro's "example" is its
inline use, not a separable code block).

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full

git add raylib/src/core/automation.rs raylib/src/core/callbacks.rs raylib/src/core/file.rs raylib/src/core/input.rs raylib/src/core/logging.rs raylib/src/core/text.rs raylib/src/core/vr.rs
# (use the actual file list from Task 3's inventory)
git commit -m "$(cat <<'EOF'
docs(batch3-a): enrich first cluster of small-file stubs

Enriches the WS6a stubs across the audio/file/input-adjacent small
files in core/ (see Task 3 inventory for the precise file list).
Per-file flavor decisions: pure helpers get Flavor 1, window-required
fns get Flavor 3, callback registration fns get prose + intra-doc
links to the callback-type docs.

WS7-enriched items in any of these files left untouched.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full
cargo test -p raylib --doc --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

git add <files>
git commit -m "$(cat <<'EOF'
docs(batch3-b): enrich second cluster of small-file stubs

Enriches the WS6a stubs across the graphics/math-adjacent small
files in core/ (see Task 3 inventory for the precise file list).
Flavor-2 harness verification applied where the item exercises
pixel-level behaviour (e.g. Image-manipulation helpers in
texture.rs); other items get Flavor 1 / Flavor 3 per the standard
rubric.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

Review the rustdoc-rewrite workstream commits against the spec at
docs/superpowers/specs/2026-05-30-rustdoc-rewrite-design.md.

Tasks 4–13 enriched ~183 WS6a one-line stubs across 21 files. Each
file's flavor is assigned per spec §5. Templates and three doctest
flavors are defined in spec §4.2 and §4.3.

For each commit from Tasks 4–13 (git log 6.0-rc --oneline since Task
3's inventory commit), verify:
1. Every WS6a stub the spec said to enrich is now enriched per its
   assigned flavor (Template A / Template B / module-level Template C).
2. Items that are still one-liners have a clear rationale (typically
   "method name fully describes behavior" per §4.3 skip-examples
   policy). Flag any that don't.
3. # Examples blocks: Flavor 1 uses ```rust (runs); Flavor 2 uses
   ```rust with hidden `# #[cfg(feature = "software_renderer")] {`
   wrapper; Flavor 3 uses ```no_run.
4. Per-variant error.rs docs follow Template A (Cause/Recovery
   lines); parent enums get one Flavor-3 # Examples each.
5. Intra-doc links resolve under RUSTDOCFLAGS=-Dwarnings (already
   gated, but flag any links that look suspicious in prose).

Output a structured report: per-file findings, severity tags
(critical/major/minor), and a recommendation per finding (fix in
fixup commit / accept with rationale / out-of-scope-defer). Report
in markdown; under 1500 words.

Code-quality review the rustdoc-rewrite workstream (commits from
Tasks 4–13) at code-review depth = high.

This is a doc-only pass: zero behavior change, ~183 enriched items.
Focus areas (in priority order):

1. Flavor-2 doctest correctness — the hidden `#
   #[cfg(feature = "software_renderer")] {` / `# }` wrapper must
   bracket the harness body exactly. Under --features full the body
   must be empty (cfg false → empty block compiles as fn main()
   {}); under --features software_renderer the body must execute.
   Verify both states compile.

2. Intra-doc link health — `[ItemName]` references should resolve
   under RUSTDOCFLAGS=-Dwarnings (already gated, but check for
   anything subtle: bare URLs vs. links, [Vector2] vs.
   [ffi::Vector2], paths that depend on `use` statements at doc-
   resolve time).

3. Prose quality — flag hedging ("might", "may", "if applicable"),
   fluff ("Note that"), and passive voice ("This function is
   used..."). Spec §4.4 quality bar is cheatsheet-style.

4. Template adherence — Template A (error variants) should have
   **Cause:** and **Recovery:** lines; Template B (non-error) should
   have a one-sentence summary + optional elaboration + # Examples;
   Template C (module-level) should have a # See also pointing at
   the book chapter as plain prose.

5. Cross-file consistency — if two files reference the same item
   (e.g. RaylibDraw across multiple draw fns), the wording style
   should match.

Output the findings as a markdown report with per-file groupings.
Tag severity (critical/major/minor). Limit to ~2000 words.

cargo fmt --all --check
cargo clippy -p raylib --features full -- -D warnings
RUSTDOCFLAGS=-Dwarnings cargo doc -p raylib --features full --no-deps
cargo test -p raylib --doc --features full
cargo test -p raylib --doc --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

git add <fixup files>
git commit -m "$(cat <<'EOF'
docs(review): R1/R2 fixups

Applies findings from the spec-review (R1) + code-quality (R2)
review subagents. Notable fixes: <summarize>. Findings deferred
to tracked-deferred: <list, if any>.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc

# Rustdoc rewrite complete — ~183 WS6a one-line stubs enriched + nextest switch

**Status:** DONE on branch `6.0-rc` (pushed to `fork`). Sixth pre-WS9
workstream in the owner-locked queue (after pixel-pointers, hashes,
mixed-audio, raylib-test salvage, UBSAN-through-FFI). Spec:
`docs/superpowers/specs/2026-05-30-rustdoc-rewrite-design.md`. Plan:
`docs/superpowers/plans/2026-05-30-rustdoc-rewrite.md`.

## What shipped

Each WS6a one-line stub across <N> files is now enriched per its
assigned flavor (Template A for error variants, Template B for non-
error items, Template C module-level). The `cargo test` runner for
unit + software-render legs is now `cargo nextest run`; per-test
process isolation makes raylib's single-init-per-process constraint
per-test, unblocking multiple harness `#[test]`s per file.

[...summarize each Task's output...]

## Doctest count

| Leg | Before | After |
|-----|--------|-------|
| `cargo test --doc --features full` | 32 pass + 2 ignored | <N> pass + <M> ignored |
| `cargo test --doc --features software_renderer,...` (new) | 0 | <K> pass |

## Items left as one-liners (with rationale)

[...list any, or "none — all stubs enriched"]

## Tracked-deferred follow-ups

[...carry forward from spec §8 plus anything R1/R2 surfaced...]

## CI inventory (5 of 5 green on the fork, branch `6.0-rc`)

| Workflow | Jobs | Status |
|----------|------|--------|
| `check` | fmt, clippy, docs, cargo-deny, msrv | ✅ (pre-existing red fixed by Task 2) |
| `test` | unit ×6 (nextest), no-default ×3, software-render ×3 (nextest + new SR doctest leg) | ✅ |
| `web` | wasm-build (sys + safe) | ✅ |
| `sanitizers` | asan-ubsan (informational) | ✅ |
| `book` | mdbook build + test | ✅ |

**Rustdoc rewrite ✅. Next: safe-abstractions for GuiGetIcons/GuiLoadIcons + PR #296 → WS9 showcase → final-release.**

...UBSAN ✅ → rustdoc rewrite ✅ → safe-abstractions for GuiGetIcons/GuiLoadIcons + PR #296 ← NEXT → WS9 showcase → GitHub Pages (finale) → final-release.

git rm docs/superpowers/notes/rustdoc-rewrite-stub-inventory.md

git add docs/superpowers/notes/ws-rustdoc-rewrite-complete.md CLAUDE.md
# Plus the git rm if applicable
git commit -m "$(cat <<'EOF'
docs(ws-rustdoc): done-note + CLAUDE.md status flip

Rustdoc rewrite ✅. ~183 WS6a one-line stubs enriched per the spec's
three templates and three doctest flavors. Switch to cargo-nextest
for unit + software-render legs unlocks multiple harness #[test]s
per file. New software-renderer doctest leg actually executes
Flavor-2 harness doctests. All 5 CI workflows green on fork.

Next: safe-abstractions for GuiGetIcons/GuiLoadIcons + PR #296.

Co-Authored-By: Claude Opus 4.7 <[email protected]>
EOF
)"
git push fork 6.0-rc