refactor(pr-x1): split simd_soa (carriers) / simd_ops (slicing)

Per layering rule: slicing/ops helpers belong in simd_ops.rs, not
simd_soa.rs. Moved `array_chunks` + `array_chunks_checked` + their
tests from `src/simd_soa.rs` → `src/simd_ops.rs`.

  src/simd_soa.rs  — MultiLaneColumn (Arc<[u8]> carrier) only
  src/simd_ops.rs  — array_chunks + array_chunks_checked
                      (alongside the existing add_f32 / sub_f32 / …
                      slice elementwise ops)

`src/simd.rs` re-exports now point at both source modules:
  pub use crate::simd_soa::MultiLaneColumn;
  pub use crate::simd_ops::{array_chunks, array_chunks_checked};

Also drops the stale `pub mod column; pub mod array_chunks;` from
`src/hpc/mod.rs` (the two files were removed in 8483ae3; this
commit fixes the dangling references that earlier Edits missed
because the linter raced the writes).

Author: claude

src/hpc/mod.rs

@@ -39,10 +39,11 @@ pub mod packed;
 #[allow(missing_docs)]
 pub mod fingerprint;
 
-// PR-X1 — multi-lane typed column substrate + const-size array windows.
-// Re-exported from crate::simd::* per the W1a consumer contract.
-pub mod column;
-pub mod array_chunks;
+// PR-X1 primitives (MultiLaneColumn, array_chunks) live at the crate root
+// in `crate::simd_soa` + `crate::simd_ops` and are re-exported via
+// `crate::simd::*`. They are intentionally NOT under `hpc::*` — SIMD
+// substrate goes through the `simd_{type}.rs` family per the W1a layering
+// rule (carriers in simd_soa, slicing/ops in simd_ops).
 #[allow(missing_docs)]
 pub mod plane;
 #[allow(missing_docs)]

src/simd.rs

@@ -1718,12 +1718,11 @@ pub use crate::hpc::fingerprint::{
     vector_config, Fingerprint, Fingerprint1K, Fingerprint2K, Fingerprint64K, VectorConfig, VectorWidth,
 };
 
-// PR-X1 — multi-lane typed column carrier + const-size slice window helpers.
-// The W1a consumer contract requires all SIMD-staged primitives to surface
-// through `crate::simd::*`; without these re-exports the cognitive-shader
-// stack reaches for `crate::hpc::column::*` directly, breaking the contract.
-pub use crate::hpc::column::MultiLaneColumn;
-pub use crate::hpc::array_chunks::{array_chunks, array_chunks_checked};
+// PR-X1 — SoA carrier + const-size slice helpers, dispatched from their
+// respective `simd_{type}.rs` modules. The W1a consumer contract forbids
+// reaching past `crate::simd::*` into the implementation modules directly.
+pub use crate::simd_soa::MultiLaneColumn;
+pub use crate::simd_ops::{array_chunks, array_chunks_checked};
 
 pub use crate::hpc::quantized::{
     dequantize_i2_to_f32, dequantize_i4_to_f32, dequantize_i8_to_f32, quantize_f32_to_i2, quantize_f32_to_i4,

src/simd_ops.rs

@@ -286,3 +286,119 @@ mod tests {
         assert_eq!(c.len(), 5);
     }
 }
+
+// ════════════════════════════════════════════════════════════════════
+// PR-X1 — Const-size non-overlapping slice chunk helpers
+// ════════════════════════════════════════════════════════════════════
+//
+// Slicing primitive for SIMD-staged inner loops. Naming: `array_chunks`
+// (NOT `array_windows`) because `std::slice::array_windows::<N>()`
+// (nightly) is the **overlapping** iterator already referenced in
+// `src/simd.rs` comments. These helpers are the **non-overlapping**
+// variant, matching `std::slice::ArrayChunks` / stable `slice::as_chunks`.
+
+/// Walk `data` as a sequence of non-overlapping const-size windows.
+///
+/// Returns an iterator over `&[T; N]` references into `data`. The tail
+/// (`data.len() % N` items) is discarded; use [`array_chunks_checked`] to
+/// fail-fast when the length is not a multiple of `N`.
+///
+/// Zero-cost: thin wrapper around [`slice::as_chunks`] that pins the
+/// chunk size at the call site for type inference.
+///
+/// # Examples
+///
+/// ```
+/// use ndarray::simd::array_chunks;
+/// let data: Vec<u8> = (0..16).collect();
+/// let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
+/// assert_eq!(windows.len(), 4);
+/// assert_eq!(windows[0], &[0, 1, 2, 3]);
+/// assert_eq!(windows[3], &[12, 13, 14, 15]);
+/// ```
+///
+/// # Examples — tail discarded
+///
+/// ```
+/// use ndarray::simd::array_chunks;
+/// let data: Vec<u8> = (0..7).collect();
+/// let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
+/// assert_eq!(windows.len(), 1);
+/// ```
+#[inline]
+pub fn array_chunks<T, const N: usize>(data: &[T]) -> impl Iterator<Item = &[T; N]> + '_ {
+    data.as_chunks::<N>().0.iter()
+}
+
+/// Walk `data` as `&[T; N]` windows, returning `Err(())` if `data.len()`
+/// is not a multiple of `N`.
+///
+/// Strict variant of [`array_chunks`]: the consumer asserts up front that
+/// the buffer is lane-aligned and wants the error surfaced rather than
+/// silently truncating.
+///
+/// # Examples
+///
+/// ```
+/// use ndarray::simd::array_chunks_checked;
+/// let data: Vec<u8> = (0..16).collect();
+/// let it = array_chunks_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
+/// assert_eq!(it.count(), 4);
+///
+/// let bad: Vec<u8> = (0..7).collect();
+/// assert!(array_chunks_checked::<u8, 4>(&bad).is_err());
+/// ```
+#[inline]
+pub fn array_chunks_checked<T, const N: usize>(
+    data: &[T],
+) -> Result<impl Iterator<Item = &[T; N]> + '_, ()> {
+    if data.len() % N != 0 {
+        return Err(());
+    }
+    Ok(array_chunks::<T, N>(data))
+}
+
+#[cfg(test)]
+mod array_chunks_tests {
+    use super::*;
+
+    #[test]
+    fn array_chunks_4_over_16() {
+        let data: Vec<u8> = (0u8..16).collect();
+        let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
+        assert_eq!(windows.len(), 4);
+        assert_eq!(windows[0], &[0, 1, 2, 3]);
+        assert_eq!(windows[1], &[4, 5, 6, 7]);
+        assert_eq!(windows[2], &[8, 9, 10, 11]);
+        assert_eq!(windows[3], &[12, 13, 14, 15]);
+    }
+
+    #[test]
+    fn array_chunks_drops_tail() {
+        let data: Vec<u8> = (0u8..7).collect();
+        let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
+        assert_eq!(windows.len(), 1);
+        assert_eq!(windows[0], &[0, 1, 2, 3]);
+    }
+
+    #[test]
+    fn array_chunks_checked_rejects_mismatch() {
+        assert!(array_chunks_checked::<u8, 4>(&[0u8; 7]).is_err());
+        assert!(array_chunks_checked::<u8, 4>(&[0u8; 5]).is_err());
+        assert!(array_chunks_checked::<u8, 4>(&[0u8; 1]).is_err());
+    }
+
+    #[test]
+    fn array_chunks_checked_accepts_aligned() {
+        let data = [0u8; 16];
+        let it = array_chunks_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
+        assert_eq!(it.count(), 4);
+    }
+
+    #[test]
+    fn array_chunks_empty_buffer() {
+        assert_eq!(array_chunks::<u8, 4>(&[]).count(), 0);
+        let it = array_chunks_checked::<u8, 4>(&[]).expect("0 % 4 == 0, should be Ok");
+        assert_eq!(it.count(), 0);
+    }
+}

src/simd_soa.rs

@@ -1,22 +1,22 @@
-//! SoA-shaped SIMD substrate primitives (PR-X1).
+//! SoA-shaped SIMD substrate carriers (PR-X1).
 //!
 //! Lives at the crate root under `crate::simd_soa::*` and is re-exported
 //! through `crate::simd::*` per the W1a consumer contract. This is the
-//! canonical home for SoA-of-bytes / multi-lane column carriers and the
-//! const-size chunk-walking helpers that SIMD-staged inner loops use.
+//! canonical home for SoA-of-bytes / multi-lane column carriers.
+//!
+//! Generic slice / chunk helpers (`array_chunks`, `array_chunks_checked`)
+//! live in `crate::simd_ops` — they're operations, not carriers.
 //!
 //! # What lives here
 //!
 //! - [`MultiLaneColumn`] — `Arc<[u8]>` carrier with typed-width chunk iters
-//! - [`array_chunks`] / [`array_chunks_checked`] — generic const-size
-//!   non-overlapping `&[T] → impl Iterator<Item = &[T; N]>` helpers
 //!
 //! # Layering
 //!
 //! This module is **layout-only**. No `#[target_feature]`, no per-arch
 //! imports, no raw intrinsics. The SIMD register load happens inside the
 //! consumer's loop using `crate::simd::F32x16::from_array` etc. The
-//! `simd.rs` dispatcher re-exports these primitives via `pub use
+//! `simd.rs` dispatcher re-exports these carriers via `pub use
 //! crate::simd_soa::{…};` so consumers always go through
 //! `use ndarray::simd::*;`.
 //!
@@ -25,13 +25,9 @@
 //! These types are layout-only. No distance-aware API. See
 //! `.claude/knowledge/cognitive-distance-typing.md` (no-umbrella rule).
 //!
-//! # Design references
+//! # Design reference
 //!
-//! - `.claude/knowledge/pr-x1-design.md` § "1. `MultiLaneColumn`"
-//! - `.claude/knowledge/pr-x1-design.md` § "3. `array_window`" (the
-//!   singular-window sketch superseded by the iterator form here; the
-//!   name landed as `array_chunks` to avoid collision with std's
-//!   nightly overlapping `slice::array_windows`).
+//! `.claude/knowledge/pr-x1-design.md` § "1. `MultiLaneColumn`".
 
 use std::sync::Arc;
 
@@ -174,77 +170,6 @@ impl MultiLaneColumn {
     }
 }
 
-// ════════════════════════════════════════════════════════════════════
-// array_chunks — generic non-overlapping const-size chunk helpers
-// ════════════════════════════════════════════════════════════════════
-//
-// Naming: `array_chunks` (NOT `array_windows`) because:
-// - `std::slice::array_windows::<N>()` (nightly) is the **overlapping**
-//   variant, already referenced in src/simd.rs comments.
-// - These helpers are the **non-overlapping** variant, matching
-//   `std::slice::ArrayChunks` / stable `slice::as_chunks`.
-
-/// Walk `data` as a sequence of non-overlapping const-size windows.
-///
-/// Returns an iterator over `&[T; N]` references into `data`. The tail
-/// (`data.len() % N` items) is discarded; use [`array_chunks_checked`] to
-/// fail-fast when the length is not a multiple of `N`.
-///
-/// Zero-cost: this is a thin wrapper around [`slice::as_chunks`] that pins
-/// the chunk size at the call site for type inference.
-///
-/// # Examples
-///
-/// ```
-/// use ndarray::simd::array_chunks;
-/// let data: Vec<u8> = (0..16).collect();
-/// let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
-/// assert_eq!(windows.len(), 4);
-/// assert_eq!(windows[0], &[0, 1, 2, 3]);
-/// assert_eq!(windows[3], &[12, 13, 14, 15]);
-/// ```
-///
-/// # Examples — tail discarded
-///
-/// ```
-/// use ndarray::simd::array_chunks;
-/// let data: Vec<u8> = (0..7).collect();
-/// let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
-/// assert_eq!(windows.len(), 1);
-/// ```
-#[inline]
-pub fn array_chunks<T, const N: usize>(data: &[T]) -> impl Iterator<Item = &[T; N]> + '_ {
-    data.as_chunks::<N>().0.iter()
-}
-
-/// Walk `data` as `&[T; N]` windows, returning `Err(())` if `data.len()`
-/// is not a multiple of `N`.
-///
-/// Strict variant of [`array_chunks`]: the consumer asserts up front that
-/// the buffer is lane-aligned and wants the error surfaced rather than
-/// silently truncating.
-///
-/// # Examples
-///
-/// ```
-/// use ndarray::simd::array_chunks_checked;
-/// let data: Vec<u8> = (0..16).collect();
-/// let it = array_chunks_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
-/// assert_eq!(it.count(), 4);
-///
-/// let bad: Vec<u8> = (0..7).collect();
-/// assert!(array_chunks_checked::<u8, 4>(&bad).is_err());
-/// ```
-#[inline]
-pub fn array_chunks_checked<T, const N: usize>(
-    data: &[T],
-) -> Result<impl Iterator<Item = &[T; N]> + '_, ()> {
-    if data.len() % N != 0 {
-        return Err(());
-    }
-    Ok(array_chunks::<T, N>(data))
-}
-
 // ════════════════════════════════════════════════════════════════════
 // Tests
 // ════════════════════════════════════════════════════════════════════
@@ -352,46 +277,4 @@ mod tests {
         fn assert_send_sync<T: Send + Sync>() {}
         assert_send_sync::<MultiLaneColumn>();
     }
-
-    // ---- array_chunks ----
-
-    #[test]
-    fn array_chunks_4_over_16() {
-        let data: Vec<u8> = (0u8..16).collect();
-        let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
-        assert_eq!(windows.len(), 4);
-        assert_eq!(windows[0], &[0, 1, 2, 3]);
-        assert_eq!(windows[1], &[4, 5, 6, 7]);
-        assert_eq!(windows[2], &[8, 9, 10, 11]);
-        assert_eq!(windows[3], &[12, 13, 14, 15]);
-    }
-
-    #[test]
-    fn array_chunks_drops_tail() {
-        let data: Vec<u8> = (0u8..7).collect();
-        let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
-        assert_eq!(windows.len(), 1);
-        assert_eq!(windows[0], &[0, 1, 2, 3]);
-    }
-
-    #[test]
-    fn array_chunks_checked_rejects_mismatch() {
-        assert!(array_chunks_checked::<u8, 4>(&[0u8; 7]).is_err());
-        assert!(array_chunks_checked::<u8, 4>(&[0u8; 5]).is_err());
-        assert!(array_chunks_checked::<u8, 4>(&[0u8; 1]).is_err());
-    }
-
-    #[test]
-    fn array_chunks_checked_accepts_aligned() {
-        let data = [0u8; 16];
-        let it = array_chunks_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
-        assert_eq!(it.count(), 4);
-    }
-
-    #[test]
-    fn array_chunks_empty_buffer() {
-        assert_eq!(array_chunks::<u8, 4>(&[]).count(), 0);
-        let it = array_chunks_checked::<u8, 4>(&[]).expect("0 % 4 == 0, should be Ok");
-        assert_eq!(it.count(), 0);
-    }
 }