tighten(hpc/blocked_grid): apply P2 savant pre-merge findings + persist verdict

P2 savant (Phase 13) verdict: SHIP-WITH-FOLLOWUPS. 4 P2 findings; 3 applied
in this commit, 1 deferred to PR-X3.1.

P2-1 (applied) — downscope `pub` helpers on GridBlock/GridBlockMut to
`pub(crate)`. The four helpers (data_slice, padded_cols_stride on
GridBlock; data_mut, padded_cols on GridBlockMut) are intra-crate
implementation seams. Leaving them `pub` meant downstream consumers
could bypass the `# Footgun` guard on `as_padded_slice`. Also drops the
`#[doc(hidden)]` attribute — no longer needed once visibility is tight.

P2-3 (applied) — drop stray `T: Copy` bound from `GridBlock::from_grid`,
`GridBlockMut::from_grid`, `Iterator for BaseBlockIter`, `Iterator for
BaseBlockIterMut`, both `ExactSizeIterator` impls, and the impl block
holding `blocks_base` / `blocks_base_mut`. None of these positions
actually copy a `T` value — they only compute index arithmetic and
slice the storage. The bound was over-constraining; iterator surface
now works for any `T` (not just `T: Copy`). `BlockedGrid::get` / `set`
still correctly require `T: Copy` because they do copy values.

P2-4 (applied) — strengthen macro L1-only deferral wording with explicit
PR-X3.1 ticket reference + `TODO(PR-X3.1)` marker + dedicated per-field
workaround warning. Reduces the risk that callers cement per-field
loops outside the macro-generated struct.

P2-2 (DEFERRED → PR-X3.1) — typed `field_grid::<I, FieldT>()` accessor
alongside the existing erased `field_n::<I>()`. Additive but requires
either a downcast trait or extra macro emit arm; no current consumer
needs it.

Verdict file persisted at .claude/knowledge/pr-x3-p2-savant-review.md.
PR-X3.1 follow-up backlog documented at the bottom of the verdict file.

All 5 gates green after tightenings:
- cargo check: PASS
- cargo test --lib hpc::blocked_grid: 111/111 PASS
- cargo test --doc hpc::blocked_grid: 79/79 PASS
- cargo fmt --check: clean
- cargo clippy -D warnings: clean

Author: claude

.claude/knowledge/pr-x3-p2-savant-review.md

@@ -0,0 +1,53 @@
+# PR-X3 P2 Savant Pre-Merge Review — Verdict
+
+Reviewer: Sonnet P2 savant (Phase 13 of PR-X3 sprint)
+PR: AdaWorldAPI/ndarray#158
+Branch reviewed: `claude/pr-x3-cognitive-grid-design` @ `01a70edb`
+
+Verdict: **SHIP-WITH-FOLLOWUPS**
+
+P2 count: 4 (3 applied pre-merge, 1 deferred to PR-X3.1)
+
+## Highest-leverage tightenings (rank-ordered)
+
+1. **P2-3 — drop stray `T: Copy` from `from_grid` + iterator impls** (APPLIED) — `src/hpc/blocked_grid/base.rs:334, 482` and `iter.rs:55, 87, 144, 187, 193`
+2. **P2-1 — downscope four helpers to `pub(crate)`** (APPLIED) — `src/hpc/blocked_grid/base.rs:413, 421, 557, 563`
+3. **P2-4 — macro deferral wording strengthened with PR-X3.1 marker** (APPLIED) — `src/hpc/blocked_grid/grid_struct_macro.rs:12-18`
+4. **P2-2 — typed `field_grid::<I, FieldT>()` accessor** (DEFERRED → PR-X3.1)
+
+## Detailed findings + rulings
+
+### P2-1: `pub` helpers on `GridBlock` / `GridBlockMut` → `pub(crate)` (APPLIED)
+
+Worker A4 added `data_slice()` / `padded_cols_stride()` on `GridBlock` and `data_mut()` / `padded_cols()` on `GridBlockMut` as `#[doc(hidden)] pub` to enable sibling-module access. Leaving them `pub` means downstream consumers can call `blk.data_slice()` and bypass the `# Footgun` guard on `as_padded_slice`. Downscoped all four to `pub(crate)` and dropped the `#[doc(hidden)]` attribute (no longer needed once visibility is tightened).
+
+### P2-2: `field_n::<I>()` type erasure (DEFERRED → PR-X3.1)
+
+Returns `&dyn FieldGridRef` (erased type), matching the W3-W6 `soa_struct!` pattern. Adding a typed `field_grid::<I, FieldT>()` accessor is additive but requires either a `FromFieldGridRef` downcast trait or a macro-generated per-field method — neither is trivially additive without a new trait or extra macro emit arm. The erased form is sufficient for the PR-X3 use case (dimension parity checks); the typed accessor would unlock `let edge: &BlockedGrid<u64, 64, 64> = g.field_grid::<0, u64>()` but no current consumer needs it. Queue for PR-X3.1 alongside macro L2/L3/L4 deferral.
+
+### P2-3: Stray `T: Copy` bound on iterator surface (APPLIED)
+
+`GridBlock::from_grid` / `GridBlockMut::from_grid` carried `where T: Copy` even though their bodies only compute index arithmetic and slice `&grid.data[start..end]` — no `T` value is ever copied. This bound propagated into `Iterator for BaseBlockIter` / `BaseBlockIterMut` / `ExactSizeIterator` / the `impl<T: Copy> BlockedGrid<T, BR, BC>` block holding `blocks_base` / `blocks_base_mut`. A consumer with `BlockedGrid<MyNonCopyType, 8, 8>` could only `get` / `set` cells, not iterate. Removed the bound from all six sites. `BlockedGrid::get` / `set` still correctly require `T: Copy` (they actually copy values).
+
+### P2-4: Macro L1-only deferral wording (APPLIED)
+
+The v1 macro emits `map_l1` / `bulk_apply_l1` / `blocks_l1` on the generated struct; L2/L3/L4 are deferred. The deferral itself is the right call (emitting lockstep `{Name}L2Block` for a four-field struct requires `paste!`-generated types with `N=4` const generics — non-trivial without regression risk). But the v1 deferral note was low-visibility, risking callers cementing per-field workarounds. Strengthened the wording: explicit PR-X3.1 ticket reference + `TODO(PR-X3.1)` marker + dedicated "per-field workaround warning" subsection alerting readers that per-field call sites won't auto-migrate when PR-X3.1 lands.
+
+## CI signal
+
+No fragile tests in the new modules: no timing-dependent, no env-dependent, no `#[ignore]`-gated tests. The `BaseBlockIterMut` raw-pointer lending-iterator carries three `// SAFETY:` annotations accounting for the aliasing invariant — appropriate level of annotation for this pattern. No CI concern.
+
+The `paste = "1"` dep (P1-2 from codex audit) is already in the workspace lock and has zero binary impact.
+
+## Net call
+
+Three P2 tightenings applied as a same-day follow-up commit on this branch. P2-2 (typed `field_grid` accessor) correctly post-merge — queued for PR-X3.1 alongside the macro L2/L3/L4 emission.
+
+After this commit lands, PR #158 flips draft → ready-for-review and advances to the merge ladder.
+
+## PR-X3.1 follow-up backlog
+
+Queued for a small same-week follow-up PR:
+1. Emit lockstep `{Name}L{2,3,4}Block` block view types + `map_l{2,3,4}` + `bulk_apply_l{2,3,4}` methods on the macro-generated SoA-of-grids struct
+2. Add `field_grid::<I, FieldT>()` typed accessor alongside the existing `field_n::<I>()` erased accessor
+3. Naming consistency: rename `GridBlockMut::padded_cols` → `padded_cols_stride` to match `GridBlock::padded_cols_stride`

src/hpc/blocked_grid/base.rs

@@ -331,10 +331,7 @@ impl<'a, T, const BR: usize, const BC: usize> GridBlock<'a, T, BR, BC> {
     /// assert_eq!(blk.row_origin(), 4);
     /// assert_eq!(blk.col_origin(), 4);
     /// ```
-    pub fn from_grid(grid: &'a BlockedGrid<T, BR, BC>, block_row: usize, block_col: usize) -> Self
-    where
-        T: Copy,
-    {
+    pub fn from_grid(grid: &'a BlockedGrid<T, BR, BC>, block_row: usize, block_col: usize) -> Self {
         let row_origin = block_row * BR;
         let col_origin = block_col * BC;
         let start = row_origin * grid.padded_cols + col_origin;
@@ -405,20 +402,16 @@ impl<'a, T, const BR: usize, const BC: usize> GridBlock<'a, T, BR, BC> {
         self.col_origin
     }
 
-    /// Access internal data slice.
-    ///
-    /// Used by compute.rs (worker A4) to implement `row()` / `rows()` on
-    /// `GridBlock` without re-opening base.rs.
-    #[doc(hidden)]
-    pub fn data_slice(&self) -> &[T] {
+    /// Access internal data slice (intra-crate seam used by `compute.rs` /
+    /// `iter.rs` / `super_block.rs`). `pub(crate)` — not exposed downstream
+    /// since callers should go through `GridBlock::row` / `row_mut`, which
+    /// enforce the BR/BC bounds.
+    pub(crate) fn data_slice(&self) -> &[T] {
         self.data
     }
 
-    /// Access padded_cols stride.
-    ///
-    /// Used by compute.rs (worker A4) to implement `row()` on `GridBlock`.
-    #[doc(hidden)]
-    pub fn padded_cols_stride(&self) -> usize {
+    /// Access padded_cols stride (intra-crate seam — see `data_slice` note).
+    pub(crate) fn padded_cols_stride(&self) -> usize {
         self.padded_cols
     }
 
@@ -479,10 +472,7 @@ impl<'a, T, const BR: usize, const BC: usize> GridBlockMut<'a, T, BR, BC> {
     /// assert_eq!(blk.block_row(), 1);
     /// assert_eq!(blk.row_origin(), 4);
     /// ```
-    pub fn from_grid(grid: &'a mut BlockedGrid<T, BR, BC>, block_row: usize, block_col: usize) -> Self
-    where
-        T: Copy,
-    {
+    pub fn from_grid(grid: &'a mut BlockedGrid<T, BR, BC>, block_row: usize, block_col: usize) -> Self {
         let row_origin = block_row * BR;
         let col_origin = block_col * BC;
         let start = row_origin * grid.padded_cols + col_origin;
@@ -552,15 +542,19 @@ impl<'a, T, const BR: usize, const BC: usize> GridBlockMut<'a, T, BR, BC> {
         self.col_origin
     }
 
-    /// Access internal data slice (for use by future iterator workers).
-    #[doc(hidden)]
-    pub fn data_mut(&mut self) -> &mut [T] {
+    /// Access internal mutable data slice (intra-crate seam used by `iter.rs`
+    /// / `compute.rs`). `pub(crate)` — not exposed downstream since callers
+    /// should go through `GridBlockMut::row_mut`, which enforces the BR
+    /// bound.
+    pub(crate) fn data_mut(&mut self) -> &mut [T] {
         self.data
     }
 
-    /// Access padded_cols stride (for use by future iterator workers).
-    #[doc(hidden)]
-    pub fn padded_cols(&self) -> usize {
+    /// Access padded_cols stride (intra-crate seam — see `data_mut` note).
+    /// NOTE: Named `padded_cols` (not `padded_cols_stride` as on `GridBlock`)
+    /// for back-compat with `iter.rs`'s `row_mut` impl. Naming consistency is
+    /// queued as PR-X3.1 housekeeping.
+    pub(crate) fn padded_cols(&self) -> usize {
         self.padded_cols
     }
 

src/hpc/blocked_grid/grid_struct_macro.rs

@@ -12,11 +12,19 @@
 //! # Tier coverage (v1)
 //!
 //! **v1 emits L1 methods only.** L2/L3/L4 alias methods on the generated
-//! struct are deferred to a follow-up PR. The reserved field names below
-//! include L2-L4 identifiers so future emission won't break callers. Callers
-//! that need L2/L3/L4 can access individual fields and call `.blocks_l2()` /
-//! `.map_l2()` / `.bulk_apply_l2()` directly on each
-//! `BlockedGrid<FieldT, 64, 64>` field.
+//! struct are deferred to **PR-X3.1** (TODO(PR-X3.1): emit lockstep L2/L3/L4
+//! block view types `{Name}L{2,3,4}Block` and the corresponding `map_l*` /
+//! `bulk_apply_l*` methods). The reserved field names below include L2-L4
+//! identifiers so the future emission cannot break callers.
+//!
+//! **Per-field workaround warning.** Callers who need lockstep L2/L3/L4
+//! behavior in the meantime can access individual fields and call
+//! `.blocks_l2()` / `.map_l2()` / `.bulk_apply_l2()` directly on each
+//! `BlockedGrid<FieldT, 64, 64>` field — but be aware that per-field calls
+//! are NOT lockstep across fields. If you write per-field loops outside the
+//! macro-generated struct, those call sites will not auto-migrate when PR-X3.1
+//! lands. Prefer to gate L2-using code on PR-X3.1 if the lockstep guarantee
+//! matters.
 //!
 //! # Reserved field names
 //!

src/hpc/blocked_grid/iter.rs

@@ -52,7 +52,7 @@ pub struct BaseBlockIter<'a, T, const BR: usize, const BC: usize> {
     n_block_cols: usize,
 }
 
-impl<'a, T: Copy, const BR: usize, const BC: usize> Iterator for BaseBlockIter<'a, T, BR, BC> {
+impl<'a, T, const BR: usize, const BC: usize> Iterator for BaseBlockIter<'a, T, BR, BC> {
     type Item = GridBlock<'a, T, BR, BC>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -84,7 +84,7 @@ impl<'a, T: Copy, const BR: usize, const BC: usize> Iterator for BaseBlockIter<'
     }
 }
 
-impl<'a, T: Copy, const BR: usize, const BC: usize> ExactSizeIterator for BaseBlockIter<'a, T, BR, BC> {}
+impl<'a, T, const BR: usize, const BC: usize> ExactSizeIterator for BaseBlockIter<'a, T, BR, BC> {}
 
 // ============================================================
 // BaseBlockIterMut — mutable row-major iterator
@@ -141,7 +141,7 @@ pub struct BaseBlockIterMut<'a, T, const BR: usize, const BC: usize> {
 unsafe impl<'a, T: Send, const BR: usize, const BC: usize> Send for BaseBlockIterMut<'a, T, BR, BC> {}
 unsafe impl<'a, T: Sync, const BR: usize, const BC: usize> Sync for BaseBlockIterMut<'a, T, BR, BC> {}
 
-impl<'a, T: Copy, const BR: usize, const BC: usize> Iterator for BaseBlockIterMut<'a, T, BR, BC> {
+impl<'a, T, const BR: usize, const BC: usize> Iterator for BaseBlockIterMut<'a, T, BR, BC> {
     type Item = GridBlockMut<'a, T, BR, BC>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -184,13 +184,13 @@ impl<'a, T: Copy, const BR: usize, const BC: usize> Iterator for BaseBlockIterMu
     }
 }
 
-impl<'a, T: Copy, const BR: usize, const BC: usize> ExactSizeIterator for BaseBlockIterMut<'a, T, BR, BC> {}
+impl<'a, T, const BR: usize, const BC: usize> ExactSizeIterator for BaseBlockIterMut<'a, T, BR, BC> {}
 
 // ============================================================
 // BlockedGrid methods: blocks_base / blocks_base_mut
 // ============================================================
 
-impl<T: Copy, const BR: usize, const BC: usize> BlockedGrid<T, BR, BC> {
+impl<T, const BR: usize, const BC: usize> BlockedGrid<T, BR, BC> {
     /// Iterator over BR×BC base blocks, yielding one [`GridBlock`] per
     /// `(block_row, block_col)` pair in row-major order.
     ///