diff --git a/Project.toml b/Project.toml
index 19d280c..22126bd 100644
--- a/Project.toml
+++ b/Project.toml
@@ -9,18 +9,21 @@ SIMD = "fdea26ae-647d-5447-a871-4b548cad5224"
 StridedViews = "4db3bf67-4bd7-4b4e-b153-31dc3fb37143"
 TensorOperations = "6aa20fa7-93e2-5fca-9bc0-fbd0db3c71a2"
 TupleTools = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6"
+VectorInterface = "409d34a3-91d5-4945-b6ec-7529ddf182d8"
 
 [compat]
 Aqua = "0.8"
 Bumper = "0.7"
 InteractiveUtils = "1"
 LinearAlgebra = "1"
+ParallelTestRunner = "2.9"
 Random = "1"
 SIMD = "3"
 Strided = "2.6"
 StridedViews = "0.5"
 TensorOperations = "5.8"
 TupleTools = "1.6"
+VectorInterface = "0.4.1, 0.5, 0.6, 0.7"
 Test = "1"
 julia = "1.10"
 
@@ -28,9 +31,10 @@ julia = "1.10"
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 Bumper = "8ce10254-0962-460f-a3d8-1f77fea1446e"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+ParallelTestRunner = "d3525ed8-44d0-4b2c-a655-542cee43accc"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Strided = "5e0ebb24-38b0-5f93-81fe-25c709ecae67"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "Random", "Strided", "Aqua", "Bumper", "InteractiveUtils"]
+test = ["Test", "Random", "Strided", "Aqua", "Bumper", "InteractiveUtils", "ParallelTestRunner"]
diff --git a/README.md b/README.md
index 82c85a4..e2d4e49 100644
--- a/README.md
+++ b/README.md
@@ -64,8 +64,8 @@ plan = plan_contract(StridedView(C), StridedView(A), (1, 2, 3),
 execute!(plan, 1.0, 0.0)
 ```
 
-`plan_contract` also takes `workspace=`/`allocator=` keywords (e.g. for
-Bumper-backed buffers); see its docstring.
+`plan_contract` also takes an `allocator=` keyword (e.g. for Bumper-backed
+buffers); see its docstring.
 
 ## API
 
@@ -95,7 +95,7 @@ and `B` into panels and drives a microkernel over register tiles of `C`.
 | `src/packing/` | packed-panel formats and the `pack_a!`/`pack_b!` packers with contiguous fast paths |
 | `src/microkernels/` | the kernel interface and the scalar, SIMD, planar, 1m and fmaddsub kernels |
 | `src/planning/` | label classification, conjugation, kernel selection, cache blocking, `plan_contract` |
-| `src/execution/` | the workspace, the five-loop nest, the specialised paths and the tile-by-tile oracle |
+| `src/execution/` | the workspace, the barriers, the five-loop nest and the specialised paths |
 | `src/integrations/` | `QuasiStridedBackend` for TensorOperations.jl |
 
 `test/` mirrors this layout.
@@ -127,8 +127,8 @@ Implemented:
   `eltype(C)` once. `conjA`/`conjB` and each operand's `StridedView.op` are
   applied during packing.
 - Zero steady-state allocation on Julia >= 1.11 for `execute!` on a reused
-  plan and for `tensorcontract!` through the backend (which pools workspaces
-  per task). On Julia 1.10 `SIMDKernel`'s accumulator is not kept in
+  plan; `tensorcontract!` through the backend plans each call, so it allocates
+  the plan's workspace through the given allocator. On Julia 1.10 `SIMDKernel`'s accumulator is not kept in
   registers, so calls allocate; results are unaffected.
 
 Not implemented:
diff --git a/benchmark/README.md b/benchmark/README.md
new file mode 100644
index 0000000..4081a02
--- /dev/null
+++ b/benchmark/README.md
@@ -0,0 +1,29 @@
+# Benchmarks
+
+Single-core scripts; each script's header has its options and outputs. All run
+from the repo root with `julia --project=benchmark benchmark/<script> [args]`,
+and every `bench_*.jl` takes `--smoke` (one rep on a few cases) to check that it runs.
+
+| Script | Use it to |
+|:-|:-|
+| `bench_to_suite.jl` | compare QuasiStridedBackend with StridedBLAS on the upstream TensorOperations suite (`:contract`, `:network`); the overall picture after any change |
+| `plot_bench_to_suite.jl` | plot a `bench_to_suite.csv`: per dtype, both backends' GFLOP/s and their time ratio against arithmetic intensity, with `--dtypes`/`--categories`/`--tags` filters |
+| `bench_kernels.jl` | measure every register tile of the kernel menu against the default choice and OpenBLAS, after kernel or kernel-selection changes |
+| `bench_blocking_model.jl` | check the cache-blocking model against a sweep of `(m_block, k_block, n_block)`, after blocking changes |
+| `bench_mixed.jl` | compare the mixed real/complex kernels with promotion and the real GEMM of equal FMA count |
+| `bench_degenerate.jl` | compare the dot, outer-product and unpacked-B paths with the five-loop nest and BLAS |
+| `probes/probe_ttfx.jl` | time to first call (load, first plans, `@tensor`, `contract!`); one fresh process per run |
+| `probes/probe_call_floor.jl` | per-call time and bytes on tiny problems (`tensorcontract!`, `contract!`, reused-plan `execute!`) |
+| `probes/probe_specialisations.jl` | count compiled specialisations of the hot functions after a fixed workload |
+
+On the cluster, one script per job, one job per microarchitecture:
+
+    sbatch --reservation=rocky8 --constraint=<icelake|genoa|rome> benchmark/submit.sh <script> [args]
+
+A same-node A/B of two revisions, alternating them over `$QS_AB_ROUNDS` rounds:
+
+    sbatch --reservation=rocky8 --constraint=<icelake|genoa|rome> benchmark/submit_ab.sh <rev_a> <rev_b> <script> [args]
+
+`benchmark/submit_bench_to_suite.sh` runs the full suite sweep plus its plots.
+Results land in `benchmark/results/` (gitignored). Timings on a shared
+workstation are indicative only.
diff --git a/benchmark/bench_blocking_model.jl b/benchmark/bench_blocking_model.jl
index 2f3dd3b..265a34b 100644
--- a/benchmark/bench_blocking_model.jl
+++ b/benchmark/bench_blocking_model.jl
@@ -1,24 +1,25 @@
-# (mc, kc, nc) plateau sweep: the analytical blocking model and the fallback
-# row against a log-spaced grid, at the engine's default kernel.
+# (m_block, k_block, n_block) plateau sweep: the analytical blocking model and
+# the fallback row against a log-spaced grid, at the engine's default kernel.
 #
 #   julia --project=benchmark benchmark/bench_blocking_model.jl [--reps 21] [--smoke] [--outdir DIR]
 #
-# Per real dtype: the named rows (`model` = `_modelled_blocking`, `fallback` =
-# `_fallback_blocking`) and the `wide` grid on every harness shape, plus 1-D
-# `nc` and `mc` slices through the model row on a 2048x256x2048 shape (the only
-# one large enough for `nc` to bind). Per complex dtype: the named rows scaled
-# by `_scale_blocking`. Every configuration of a shape is timed back to back.
+# Per real dtype: the named rows (`model` = `default_blocking` on this host,
+# `fallback` = on an undetected one) and the `wide` grid on every harness
+# shape, plus 1-D `n_block` and `m_block` slices through the model row on a
+# 2048x256x2048 shape (the only one large enough for `n_block` to bind). Per
+# complex dtype: the named rows. Every configuration of a shape is timed back to back.
 # The score of a configuration is the geomean over shapes of its time over the
 # best time at that shape. `--smoke` runs 1 rep on a few points.
 
 include(joinpath(@__DIR__, "harness.jl"))
 
-using QuasiStrided: Blocking, target_profile, _default_kernel, _modelled_blocking,
-    _fallback_blocking, _scale_blocking, complex_method
+using QuasiStrided: Blocking, target_profile, unknown_target, default_blocking,
+    kernel_from_shape, derived_shape
 
-const SMOKE = hasflag("smoke")
-const REPS = SMOKE ? 1 : argopt("reps", 21)
-thin(v) = SMOKE ? v[1:min(end, 3)] : v
+const REPS = reps_arg(21)
+const DTYPES = (Float64, Float32)
+const CDTYPES = (ComplexF64, ComplexF32)
+full_grid(m_blocks, k_blocks, n_blocks) = [(m_block, k_block, n_block) for k_block in k_blocks for m_block in m_blocks for n_block in n_blocks]
 
 const GRID_SHAPES = vcat(MAIN_SHAPES, EXTRA_SHAPES, SMALL_SHAPES)
 const BIG_SHAPE = ShapeSpec(2048, 256, 2048)
@@ -34,27 +35,29 @@ const OUTDIR = outdir()
 const CSV_PATH = joinpath(OUTDIR, "blocking_model.csv")
 const SUMMARY_PATH = joinpath(OUTDIR, "summary_blocking_model.txt")
 
-tup(b::Blocking) = (b.mc, b.kc, b.nc)
+tup(b::Blocking) = (b.m_block, b.k_block, b.n_block)
 named_points(rows) = [(string(k), tup(v)) for (k, v) in pairs(rows) if v !== nothing]
-named_rows(::Type{T}) where {T <: Real} = (model = _modelled_blocking(PROFILE, T), fallback = _fallback_blocking(T))
+detected = PROFILE.l1d.bytes > 0 && PROFILE.l2.bytes > 0
+named_rows(kernel) = (model = detected ? default_blocking(kernel, PROFILE) : nothing, fallback = default_blocking(kernel, unknown_target()))
+host_kernel(::Type{T}) where {T} = kernel_from_shape(derived_shape(PROFILE, T), T)
 
 csv = open(CSV_PATH, "w")
-println(csv, "set,dtype,shape,Ma,Ka,Na,mc,kc,nc,mc_eff,kc_eff,nc_eff,reps,median_seconds,gflops")
+println(csv, "set,dtype,shape,Ma,Ka,Na,m_block_requested,k_block_requested,n_block_requested,m_block,k_block,n_block,reps,median_seconds,gflops")
 
 function sweep_shape!(raw, kernel, ::Type{T}, spec, points) where {T}
     fx = build_plain(T, spec, MersenneTwister(0xB10C))
-    for (set, (mc, kc, nc)) in points
+    for (set, (m_block, k_block, n_block)) in points
         plan = plan_contract(
-            fx.Cv, fx.Av, fx.indA, fx.Bv, fx.indB, fx.indC; kernel = kernel, mc = mc, kc = kc, nc = nc
+            fx.Cv, fx.Av, fx.indA, fx.Bv, fx.indB, fx.indC; kernel = kernel, m_block = m_block, k_block = k_block, n_block = n_block
         )
         t = median_time_s(() -> execute!(plan, one(T), zero(T)); reps = REPS)
         b = plan.blocking
         println(
-            csv, "$set,$T,$(spec.name),$(spec.Ma),$(spec.Ka),$(spec.Na),$mc,$kc,$nc,$(b.mc),$(b.kc),$(b.nc),$REPS,",
+            csv, "$set,$T,$(spec.name),$(spec.Ma),$(spec.Ka),$(spec.Na),$m_block,$k_block,$n_block,$(b.m_block),$(b.k_block),$(b.n_block),$REPS,",
             @sprintf("%.9f,%.4f", t, gflops(T, spec.Ma, spec.Ka, spec.Na, t))
         )
         flush(csv)
-        push!(raw, (; set, dtype = T, shape = spec.name, mc, kc, nc, t))
+        push!(raw, (; set, dtype = T, shape = spec.name, m_block, k_block, n_block, t))
     end
     return nothing
 end
@@ -80,8 +83,8 @@ function summarize(io, raw, canaries)
     @printf(io, "canary spread = %.1f%%  %s\n", 100 * relative_spread(canaries), canaries)
     grid_names = [s.name for s in GRID_SHAPES]
     for T in DTYPES
-        println(io, "\n## $T   ", named_rows(T))
-        w = score(raw, T, grid_names, r -> (r.mc, r.kc, r.nc); sets = ("wide",))
+        println(io, "\n## $T   ", named_rows(host_kernel(T)))
+        w = score(raw, T, grid_names, r -> (r.m_block, r.k_block, r.n_block); sets = ("wide",))
         @printf(
             io, "wide grid: best %.4f %s  worst %.4f %s  spread %.1f%%\n",
             w[1][2], w[1][1], w[end][2], w[end][1], 100 * (w[end][2] / w[1][2] - 1)
@@ -92,7 +95,7 @@ function summarize(io, raw, canaries)
         for (set, g) in score(raw, T, grid_names, r -> r.set; sets = ("model", "fallback"))
             @printf(io, "  %-10s %.4f\n", set, g)
         end
-        for (s, f) in (("nslice", r -> r.nc), ("mslice", r -> r.mc))
+        for (s, f) in (("nslice", r -> r.n_block), ("mslice", r -> r.m_block))
             pts = sort([r for r in raw if r.dtype == T && r.set == s]; by = f)
             isempty(pts) && continue
             tb = minimum(r.t for r in pts)
@@ -114,9 +117,9 @@ raw = NamedTuple[]
 crng = MersenneTwister(0x0CA9A121)
 canaries = [run_canary(crng, "start")]
 for T in DTYPES
-    kernel = _default_kernel(T)
-    rows = named_rows(T)
-    println("\n$T kernel $(mr(kernel))x$(nr(kernel))/W$(lanewidth(kernel))  ", rows)
+    kernel = host_kernel(T)
+    rows = named_rows(kernel)
+    println("\n$T kernel $(tile_size(kernel, 1))x$(tile_size(kernel, 2))/W$(lanewidth(kernel))  ", rows)
     rows.model === nothing && @warn "no cache geometry detected: model undefined"
     grid = [("wide", c) for c in thin(WIDE[T])]
     for spec in thin(GRID_SHAPES)
@@ -124,16 +127,16 @@ for T in DTYPES
     end
     m = something(rows.model, rows.fallback)
     slices = vcat(
-        named_points(rows), [("nslice", (m.mc, m.kc, n)) for n in thin(NSLICE)],
-        [("mslice", (x, m.kc, m.nc)) for x in thin(MSLICE)],
+        named_points(rows), [("nslice", (m.m_block, m.k_block, n)) for n in thin(NSLICE)],
+        [("mslice", (x, m.k_block, m.n_block)) for x in thin(MSLICE)],
     )
     sweep_shape!(raw, kernel, T, BIG_SHAPE, slices)
     push!(canaries, run_canary(crng, "after-$T"))
 end
 for T in CDTYPES
-    kernel = _default_kernel(T)
-    rows = map(v -> v === nothing ? nothing : _scale_blocking(v, complex_method(kernel)), named_rows(real(T)))
-    println("\n$T kernel $(mr(kernel))x$(nr(kernel))/W$(lanewidth(kernel))  ", rows)
+    kernel = host_kernel(T)
+    rows = named_rows(kernel)
+    println("\n$T kernel $(tile_size(kernel, 1))x$(tile_size(kernel, 2))/W$(lanewidth(kernel))  ", rows)
     for spec in thin(MAIN_SHAPES)
         sweep_shape!(raw, kernel, T, spec, named_points(rows))
     end
diff --git a/benchmark/bench_degenerate.jl b/benchmark/bench_degenerate.jl
index 7ae088f..9ddd389 100644
--- a/benchmark/bench_degenerate.jl
+++ b/benchmark/bench_degenerate.jl
@@ -1,20 +1,20 @@
 # A/B of the three automatically selected small/degenerate-shape paths against
-# the five-loop nest, via their mode overrides:
+# the five-loop nest, via the internal `path_modes` keyword of `plan_contract`:
 #
-#   outer      K = 1 outer product      C[a,b] = A[a] B[b]           _OUTER_MODE
-#   dot        M = 1 gemv               C[cde] = A[ab] B[abcde]      _DOT_MODE
-#   unpackedb  small square matmul      C[a,c] = A[a,b] B[b,c]       _UNPACKED_B_MODE
+#   outer      K = 1 outer product      C[a,b] = A[a] B[b]           outer
+#   dot        M = 1 gemv               C[cde] = A[ab] B[abcde]      dot
+#   unpackedb  small square matmul      C[a,c] = A[a,b] B[b,c]       unpacked_b
 #
 # `execute!` only (planning excluded), plus OpenBLAS `mul!` on the equivalent
 # dense matrices for scale. Modes are interleaved rep by rep; each rep times a
 # batch of calls sized to ~200 us. Prints median ns per call and [q25, q75].
 #
-#   julia --project=benchmark benchmark/bench_degenerate.jl [--reps 31]
+#   julia --project=benchmark benchmark/bench_degenerate.jl [--reps 31] [--smoke]
 
 include(joinpath(@__DIR__, "harness.jl"))
 using Statistics: quantile
 
-const REPS = argopt("reps", 31)
+const REPS = reps_arg(31)
 
 function batchsize(f!)
     f!()
@@ -39,17 +39,11 @@ end
 
 fmt((m, lo, hi)) = @sprintf("%9.0f [%6.0f,%6.0f]", m, lo, hi)
 
-function withmode(f, ref::Ref{Symbol}, mode::Symbol)
-    return () -> begin
-        old = ref[]; ref[] = mode
-        f()
-        ref[] = old
-    end
-end
-
-function row(name, ref, plan, blasf)
-    ex = () -> execute!(plan, 1.0, 0.0)
-    r = interleaved(Any[withmode(ex, ref, :never), withmode(ex, ref, :auto), blasf])
+# One plan with the path ruled out (`mode = :never`), one with it automatic.
+function row(name, mode::Symbol, args, blasf)
+    nest = plan_contract(args...; path_modes = QuasiStrided.PathModes(; mode => :never))
+    path = plan_contract(args...)
+    r = interleaved(Any[() -> execute!(nest, 1.0, 0.0), () -> execute!(path, 1.0, 0.0), blasf])
     @printf(
         "%-28s nest %s  path %s  blas %s  path/nest %.2f  path/blas %.2f\n",
         name, fmt(r[1]), fmt(r[2]), fmt(r[3]), r[2][1] / r[1][1], r[2][1] / r[3][1]
@@ -62,19 +56,19 @@ for T in (Float64, ComplexF64)
     println("## $T")
     for d in (16, 63, 128)
         a = randn(T, d); b = randn(T, d); C = zeros(T, d, d)
-        plan = plan_contract(StridedView(C), StridedView(a), (1,), StridedView(b), (2,), (1, 2))
+        args = (StridedView(C), StridedView(a), (1,), StridedView(b), (2,), (1, 2))
         am = reshape(a, d, 1); bm = reshape(b, 1, d)
-        row("outer $(d)x$(d)", QuasiStrided._OUTER_MODE, plan, () -> mul!(C, am, bm))
+        row("outer $(d)x$(d)", :outer, args, () -> mul!(C, am, bm))
     end
-    for d in (6, 8, 12, 16)
+    for d in thin((6, 8, 12, 16))
         A = randn(T, d, d); B = randn(T, d, d, d, d, d); C = zeros(T, d, d, d)
-        plan = plan_contract(StridedView(C), StridedView(A), (1, 2), StridedView(B), (1, 2, 3, 4, 5), (3, 4, 5))
+        args = (StridedView(C), StridedView(A), (1, 2), StridedView(B), (1, 2, 3, 4, 5), (3, 4, 5))
         Bm = reshape(B, d^2, d^3); av = vec(A); cv = vec(C)
-        row("dot 1x$(d^2)x$(d^3)", QuasiStrided._DOT_MODE, plan, () -> mul!(cv, transpose(Bm), av))
+        row("dot 1x$(d^2)x$(d^3)", :dot, args, () -> mul!(cv, transpose(Bm), av))
     end
-    for d in (16, 32, 64, 128)
+    for d in thin((16, 32, 64, 128))
         A = randn(T, d, d); B = randn(T, d, d); C = zeros(T, d, d)
-        plan = plan_contract(StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3))
-        row("unpackedB $(d)^3", QuasiStrided._UNPACKED_B_MODE, plan, () -> mul!(C, A, B))
+        args = (StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3))
+        row("unpackedB $(d)^3", :unpacked_b, args, () -> mul!(C, A, B))
     end
 end
diff --git a/benchmark/bench_kernels.jl b/benchmark/bench_kernels.jl
index 2a8b1b9..eb53f93 100644
--- a/benchmark/bench_kernels.jl
+++ b/benchmark/bench_kernels.jl
@@ -2,11 +2,11 @@
 # default choice and OpenBLAS `gemm!`, single core.
 #
 #   julia --project=benchmark benchmark/bench_kernels.jl [--dtypes Float64,ComplexF64]
-#       [--shapes 64x64x64,2048x2048x2048] [--reps 11] [--outdir DIR]
+#       [--shapes 64x64x64,2048x2048x2048] [--reps 11] [--smoke] [--outdir DIR]
 #
 # Arms:
-#   kernel  (real dtypes) the ceiling of each menu tile: `unsafe_execute_tile!`
-#           on one L1-resident packed A and B sliver at the tile's default `kc`.
+#   kernel  (real dtypes) the ceiling of each menu tile: `@inbounds execute_tile!`
+#           on one L1-resident packed A and B sliver at the tile's default `k_block`.
 #   engine  per dtype and shape: OpenBLAS, the default plan, and every menu
 #           kernel (of every complex method, for complex dtypes) at its own
 #           default blocking; all configurations of a shape back to back.
@@ -21,31 +21,33 @@
 
 include(joinpath(@__DIR__, "harness.jl"))
 
-using QuasiStrided: RealMethod, PlanarMethod, OneMMethod, FMAddSubMethod, kernel_shapes,
-    _kernel_from_shape, default_blocking, packed_panel, unsafe_execute_tile!,
-    DestinationTile, AffineAxis, target_profile
+using QuasiStrided: SIMDKernel, PlanarKernel, OneMKernel, FMAddSubKernel, kernel_shapes,
+    kernel_from_shape, default_blocking, packed_panel, execute_tile!,
+    Tile, AffineAxis, target_profile
 
 const RUN_DTYPES = parse_dtypes(argopt("dtypes", "Float64,Float32,ComplexF64,ComplexF32"))
 const SHAPES = let s = argval("shapes")
-    s === nothing ? vcat(MAIN_SHAPES, EXTRA_SHAPES, SMALL_SHAPES, [ShapeSpec(2048, 2048, 2048)]) :
-        [ShapeSpec(parse_ints(replace(x, 'x' => ','))...) for x in split(s, ',')]
+    thin(
+        s === nothing ? vcat(MAIN_SHAPES, EXTRA_SHAPES, SMALL_SHAPES, [ShapeSpec(2048, 2048, 2048)]) :
+            [ShapeSpec(parse_ints(replace(x, 'x' => ','))...) for x in split(s, ',')]
+    )
 end
-const REPS = argopt("reps", 11)
+const REPS = reps_arg(11)
 const OUTDIR = outdir()
 const CSV_PATH = joinpath(OUTDIR, "bench_kernels.csv")
 const SUMMARY_PATH = joinpath(OUTDIR, "summary_kernels.txt")
 
-tag(k) = "$(mr(k))x$(nr(k))/W$(lanewidth(k))"
-menu_methods(::Type{T}) where {T} = T <: Complex ? (PlanarMethod(), OneMMethod(), FMAddSubMethod()) : (RealMethod(),)
+tag(k) = "$(tile_size(k, 1))x$(tile_size(k, 2))/W$(lanewidth(k))"
+menu_kernels(::Type{T}) where {T} = T <: Complex ? (PlanarKernel, OneMKernel, FMAddSubKernel) : (SIMDKernel,)
 
 csv = open(CSV_PATH, "w")
-println(csv, "arm,dtype,shape,M,K,N,config,kernel,mc,kc,nc,seconds,gflops,frac_openblas")
+println(csv, "arm,dtype,shape,M,K,N,config,kernel,m_block,k_block,n_block,seconds,gflops,frac_openblas")
 rows = NamedTuple[]
 function record!(arm, T, spec, config, kernel, blk, t, t_blas)
     gf = gflops(T, spec.Ma, spec.Ka, spec.Na, t)
     println(
         csv, "$arm,$T,$(spec.name),$(spec.Ma),$(spec.Ka),$(spec.Na),$config,$kernel,",
-        blk === nothing ? ",," : "$(blk.mc),$(blk.kc),$(blk.nc)", ",",
+        blk === nothing ? ",," : "$(blk.m_block),$(blk.k_block),$(blk.n_block)", ",",
         @sprintf("%.9f,%.3f,%.4f", t, gf, t_blas / t)
     )
     flush(csv)
@@ -56,27 +58,27 @@ print_env_header(stdout, "bench_kernels.jl")
 println("target = ", target_profile())
 canaries = [run_canary(MersenneTwister(0xCA), "start")]
 
-function kernel_hot!(kernel, C, apack, bpack, kc, reps)
+function kernel_hot!(kernel, C, apack, bpack, k_block, reps)
     GC.@preserve apack bpack begin
         ap = packed_panel(apack, 1, length(apack))
         bp = packed_panel(bpack, 1, length(bpack))
-        dest = DestinationTile(C, 0, AffineAxis(0, 1, mr(kernel)), AffineAxis(0, mr(kernel), nr(kernel)))
+        dest = Tile(C, 0, AffineAxis(0, 1, tile_size(kernel, 1)), AffineAxis(0, tile_size(kernel)...))
         for _ in 1:reps
-            unsafe_execute_tile!(kernel, dest, ap, bp, kc, one(eltype(C)), one(eltype(C)))
+            @inbounds execute_tile!(kernel, dest, ap, bp, k_block, one(eltype(C)), one(eltype(C)))
         end
     end
     return nothing
 end
 
-for T in filter(t -> t <: Real, RUN_DTYPES), sh in kernel_shapes(T)
-    kernel = _kernel_from_shape(sh, T)
+for T in filter(t -> t <: Real, RUN_DTYPES), sh in thin(kernel_shapes(T))
+    kernel = kernel_from_shape(sh, T)
     MR, NR = sh
-    kc = default_blocking(kernel).kc
-    apack = rand(T, MR * kc); bpack = rand(T, NR * kc); C = zeros(T, MR * NR)
-    kernel_hot!(kernel, C, apack, bpack, kc, 10)
-    reps = max(100, round(Int, 0.05 / @elapsed(kernel_hot!(kernel, C, apack, bpack, kc, 100)) * 100))
-    t = median_time_s(() -> kernel_hot!(kernel, C, apack, bpack, kc, reps); reps = REPS) / reps
-    record!("kernel", T, ShapeSpec("l1_tile", MR, kc, NR), "menu", tag(kernel), nothing, t, NaN)
+    k_block = default_blocking(kernel).k_block
+    apack = rand(T, MR * k_block); bpack = rand(T, NR * k_block); C = zeros(T, MR * NR)
+    kernel_hot!(kernel, C, apack, bpack, k_block, 10)
+    reps = max(100, round(Int, 0.05 / @elapsed(kernel_hot!(kernel, C, apack, bpack, k_block, 100)) * 100))
+    t = median_time_s(() -> kernel_hot!(kernel, C, apack, bpack, k_block, reps); reps = REPS) / reps
+    record!("kernel", T, ShapeSpec("l1_tile", MR, k_block, NR), "menu", tag(kernel), nothing, t, NaN)
 end
 
 function time_plan(fx, ::Type{T}; kw...) where {T}
@@ -91,11 +93,11 @@ for spec in SHAPES, T in RUN_DTYPES
     td, pd = time_plan(fx, T)
     @assert isapprox(fx.Cmat, fx.Amat * fx.Bmat; rtol = sqrt(eps(real(T))))
     record!("engine", T, spec, "default", tag(pd.kernel), pd.blocking, td, tb)
-    for m in menu_methods(T), sh in kernel_shapes(T, m)
-        k = _kernel_from_shape(sh, T, m)
+    for K in menu_kernels(T), sh in thin(kernel_shapes(T, K))
+        k = kernel_from_shape(sh, T, K)
         b = default_blocking(k)
-        t, _ = time_plan(fx, T; kernel = k, mc = b.mc, kc = b.kc, nc = b.nc)
-        record!("engine", T, spec, lowercase(replace(string(nameof(typeof(m))), "Method" => "")), tag(k), b, t, tb)
+        t, _ = time_plan(fx, T; kernel = k, m_block = b.m_block, k_block = b.k_block, n_block = b.n_block)
+        record!("engine", T, spec, lowercase(replace(string(nameof(K)), "Kernel" => "")), tag(k), b, t, tb)
     end
     println("  ", rpad(string(T), 11), rpad(spec.name, 22), @sprintf("default %7.2f GF/s  %.2fx OpenBLAS", gflops(T, spec.Ma, spec.Ka, spec.Na, td), tb / td))
 end
diff --git a/benchmark/bench_mixed.jl b/benchmark/bench_mixed.jl
index 355aafa..8815562 100644
--- a/benchmark/bench_mixed.jl
+++ b/benchmark/bench_mixed.jl
@@ -5,16 +5,18 @@
 # fraction of real efficiency reached.
 #
 #   julia --project=benchmark benchmark/bench_mixed.jl [--dtypes ComplexF64,ComplexF32]
-#       [--sizes 512,2048] [--reps 5] [--outdir DIR]
+#       [--sizes 512,2048] [--reps 5] [--smoke] [--outdir DIR]
+#
+# `--smoke` defaults the sizes to 64.
 
 include(joinpath(@__DIR__, "harness.jl"))
 
-using QuasiStrided: ComplexRealKernel, RealComplexKernel, PlanarMethod, target_profile,
-    _derived_shape, _kernel_from_shape
+using QuasiStrided: ComplexRealKernel, RealComplexKernel, PlanarKernel, target_profile,
+    derived_shape, kernel_from_shape
 
 const RUN_DTYPES = parse_dtypes(argopt("dtypes", "ComplexF64,ComplexF32"))
-const SIZES = parse_ints(argopt("sizes", "512,2048"))
-const REPS = argopt("reps", 5)
+const SIZES = parse_ints(argopt("sizes", SMOKE ? "64" : "512,2048"))
+const REPS = reps_arg(5)
 const OUTDIR = outdir()
 const CSV_PATH = joinpath(OUTDIR, "bench_mixed.csv")
 
@@ -29,8 +31,8 @@ function run(io)
     rng = MersenneTwister(1)
     for T in RUN_DTYPES, n in SIZES
         R = real(T)
-        MRr, NRr, W = _derived_shape(target_profile(), R)
-        planar = _kernel_from_shape(_derived_shape(target_profile(), T), T, PlanarMethod())
+        MRr, NRr, W = derived_shape(target_profile(), R)
+        planar = kernel_from_shape(derived_shape(target_profile(), T), T, PlanarKernel)
         cases = (
             (
                 "CR", ComplexRealKernel(Val(MRr ÷ 2), Val(NRr), T, Val(W)),
@@ -46,7 +48,7 @@ function run(io)
             tm = time_plan(C, A, B; kernel)
             tp = time_plan(C, A, B; kernel = planar)
             tr = time_plan(zeros(R, Mr, Nr), randn(rng, R, Mr, n), randn(rng, R, n, Nr))
-            tag = "$(mr(kernel))x$(nr(kernel))/W$(lanewidth(kernel))"
+            tag = "$(tile_size(kernel, 1))x$(tile_size(kernel, 2))/W$(lanewidth(kernel))"
             @printf(
                 "%-10s %s %5d  %-10s mixed %8.4f s  promoted %8.4f s  real %8.4f s  promoted/mixed %.2f  real/mixed %.2f\n",
                 T, case, n, tag, tm, tp, tr, tp / tm, tr / tm
diff --git a/benchmark/bench_to_suite.jl b/benchmark/bench_to_suite.jl
index d36157d..882b7d4 100644
--- a/benchmark/bench_to_suite.jl
+++ b/benchmark/bench_to_suite.jl
@@ -23,6 +23,8 @@
 #   --max-bytes 2147483648             # per-case skip ceiling
 #   --max-flops 200000000000           # per-case skip ceiling
 #   --outdir <path>                    # default benchmark/results/<host>-<date>
+#   --smoke                            # 1 rep, smallest size, first 3 cases
+#                                      #   per source/topic
 #
 # Each source/topic generator gets its own size sweep (upstream shares one per
 # category), since a leg dim sensible for a rank-4 synthetic shape is far too
@@ -32,8 +34,8 @@
 # `batch` separate tensorcontract! calls (per-call overhead is the point).
 #
 # Writes bench_to_suite.csv (per-rep GF/s min/std next to the median-based
-# rate, for the plot's violins), canary_to_suite.csv, summary_to_suite.txt,
-# mismatches_to_suite.txt and PROVENANCE_to_suite.txt.
+# rate; plotted by plot_bench_to_suite.jl), canary_to_suite.csv,
+# summary_to_suite.txt, mismatches_to_suite.txt and PROVENANCE_to_suite.txt.
 
 using TensorOperations
 using TensorOperations: StridedBLAS
@@ -49,8 +51,8 @@ include(joinpath(@__DIR__, "harness.jl"))
 
 const TOB = TensorOperationsBenchmarks
 
-const REPS = argopt("reps", 21)
-const MIN_REPS = 5
+const REPS = reps_arg(21)
+const MIN_REPS = SMOKE ? 1 : 5
 const TIME_BUDGET = parse(Float64, argopt("time-budget", "10"))
 const RUN_DTYPES = parse_dtypes(argopt("dtypes", "Float64,Float32"))
 const CATEGORIES = Symbol.(split(argopt("categories", "contract"), ','))
@@ -97,7 +99,7 @@ function _generate(generators, selected, category)
     cases = BenchmarkCase[]
     for (name, (gen, sizes)) in pairs(generators)
         name in selected || continue
-        for case in gen(sizes)
+        for case in thin(gen(SMOKE ? sizes[1:1] : sizes))
             @assert case.category === category
             push!(cases, case)
         end
diff --git a/benchmark/harness.jl b/benchmark/harness.jl
index bbd4e81..a5f1a2f 100644
--- a/benchmark/harness.jl
+++ b/benchmark/harness.jl
@@ -1,9 +1,9 @@
 # Shared helpers for the benchmark scripts (`include`d, not a module):
 # single-threaded warm-up-then-median timing, fixtures, a drift canary, CLI
-# parsing and output paths.
+# parsing, the `--smoke` mode and output paths.
 
 using QuasiStrided
-using QuasiStrided: SIMDKernel, mr, nr, lanewidth, plan_contract, execute!
+using QuasiStrided: SIMDKernel, tile_size, lanewidth, plan_contract, execute!
 using StridedViews: StridedView
 using LinearAlgebra
 using Statistics: median
@@ -61,11 +61,6 @@ function build_plain(::Type{T}, spec::ShapeSpec, rng) where {T}
     )
 end
 
-full_grid(mcs, kcs, ncs) = [(mc, kc, nc) for kc in kcs for mc in mcs for nc in ncs]
-
-const DTYPES = (Float64, Float32)
-const CDTYPES = (ComplexF64, ComplexF32)
-
 # Complex is charged the textbook 8 flops per multiply-accumulate, never an
 # induced method's lower count, so methods compare on equal terms.
 gflops(::Type{T}, Ma::Int, Ka::Int, Na::Int, seconds::Float64) where {T} =
@@ -105,7 +100,7 @@ function run_canary(rng, label::String)
     fx = build_plain(Float64, ShapeSpec("canary_64^3", 64, 64, 64), rng)
     plan = plan_contract(
         fx.Cv, fx.Av, fx.indA, fx.Bv, fx.indB, fx.indC;
-        kernel = SIMDKernel(Val(8), Val(6), Float64), mc = 128, kc = 256, nc = 1536
+        kernel = SIMDKernel(Val(8), Val(6), Float64), m_block = 128, k_block = 256, n_block = 1536
     )
     t = median_time_s(() -> execute!(plan, 1.0, 0.0); reps = 15)
     println("canary[$label] median = $(t) s")
@@ -126,6 +121,11 @@ hasflag(name::String) = "--$name" in ARGS
 argopt(name::String, default::AbstractString) = something(argval(name), default)
 argopt(name::String, default::Integer) = something(tryparse(Int, something(argval(name), "")), default)
 
+# `--smoke`: one rep on the first few cases, to check that a script runs.
+const SMOKE = hasflag("smoke")
+thin(v) = SMOKE ? v[1:min(end, 3)] : v
+reps_arg(default::Int) = SMOKE ? 1 : argopt("reps", default)
+
 const DTYPE_BY_NAME = Dict(
     "Float64" => Float64, "Float32" => Float32, "ComplexF64" => ComplexF64, "ComplexF32" => ComplexF32,
 )
diff --git a/benchmark/plot_bench_to_suite.jl b/benchmark/plot_bench_to_suite.jl
index 0bf7524..8ff534d 100644
--- a/benchmark/plot_bench_to_suite.jl
+++ b/benchmark/plot_bench_to_suite.jl
@@ -1,203 +1,189 @@
-# Plots bench_to_suite.jl's CSV, per (dtype, category, group) -- group =
-# upstream's source/topic tag, split by sweep dim above MAX_PER_FIG cases: a
-# GFLOP/s panel, a log-scaled QuasiStrided/StridedBLAS time ratio (< 1 =
-# QuasiStrided faster), and a per-case throughput violin plot. Float64 and
-# ComplexF64 only.
+# Overview plot of bench_to_suite.jl's CSV: one row per dtype, columns
+# sharing the arithmetic-intensity axis: QuasiStrided GFLOP/s, StridedBLAS
+# GFLOP/s (same scale) and the QuasiStrided/StridedBLAS time ratio (< 1 =
+# QuasiStrided faster, with the geomean and faster count). Colour = total
+# work, marker = category.
 #
 #   julia --project=benchmark benchmark/plot_bench_to_suite.jl [csv_path]
+#       [--dtypes ComplexF64] [--categories network] [--tags source=tccg,topic=mps]
 #
 # Without `csv_path`, uses the newest benchmark/results/*/bench_to_suite.csv.
-# Writes PNGs next to the CSV.
-#
-# The CSV keeps only median/min/std per case, so the violins are drawn from a
-# normal(median, std) reflected at the observed min: their location and spread
-# are real, their tail shape is illustrative.
+# Without `--dtypes`, plots whichever of Float64 and ComplexF64 the CSV has,
+# or every dtype it has if neither.
+# `--tags` selects on the case params: a case is kept when it carries at least
+# one of the named keys and matches one of the values given for each key it
+# carries, so `source=tccg,topic=mps` keeps the TCCG and the MPS cases. Writes
+# bench_to_suite_overview[_<filters>].png next to the CSV.
 
 using CairoMakie
 using Printf
-using Random
 
-const PLOTTED_DTYPES = ("Float64", "ComplexF64")
-const MAX_PER_FIG = 60
+include(joinpath(@__DIR__, "harness.jl"))
 
 function latest_csv()
     root = joinpath(@__DIR__, "results")
-    candidates = String[]
-    for d in readdir(root; join = true)
-        p = joinpath(d, "bench_to_suite.csv")
-        isfile(p) && push!(candidates, p)
-    end
+    candidates = filter(isfile, [joinpath(d, "bench_to_suite.csv") for d in readdir(root; join = true)])
     isempty(candidates) && error("no benchmark/results/*/bench_to_suite.csv found")
     return candidates[argmax(mtime.(candidates))]
 end
 
-const CSV_PATH = isempty(ARGS) ? latest_csv() : ARGS[1]
-const OUTDIR = dirname(CSV_PATH)
-
-struct Row
-    backend::String
-    dtype::String
-    category::String
-    case_id::String
-    dim::Int
-    params::Dict{String, String}
-    reps::Int
-    t::Float64
-    gflops::Float64
-    gbytes::Float64
-    min_gflops::Float64
-    std_gflops::Float64
-    group::String
-    blas::Bool
-    intensity::Float64
-    expr::String
+# The positional CSV path is the first argument that is neither an option nor an option's value.
+const CSV_PATH = let i = findfirst(i -> !startswith(ARGS[i], "--") && (i == 1 || !startswith(ARGS[i - 1], "--")), eachindex(ARGS))
+    i === nothing ? latest_csv() : ARGS[i]
 end
-
-# "k1=v1;k2=v2;..." as written by bench_to_suite.jl; values stay strings.
-function parse_params(s::AbstractString)
-    d = Dict{String, String}()
-    isempty(s) && return d
-    for kv in split(s, ';')
-        k, v = split(kv, '=')
-        d[k] = v
-    end
-    return d
+splitlist(s) = s === nothing ? nothing : String.(strip.(split(s, ',')))
+const DTYPES_FILTER = splitlist(argval("dtypes"))
+const CATEGORIES_FILTER = splitlist(argval("categories"))
+const TAGS_FILTER = let t = splitlist(argval("tags"))
+    t === nothing ? nothing : [Pair(String.(split(kv, '='; limit = 2))...) for kv in t]
 end
 
+# "k1=v1;k2=v2;..." as written by bench_to_suite.jl.
+parse_params(s) = isempty(s) ? Dict{String, String}() : Dict(Pair(String.(split(kv, '='; limit = 2))...) for kv in split(s, ';'))
+
 function read_rows(path)
     lines = readlines(path)
-    occursin(",expr", lines[1]) || error("$path is not a bench_to_suite.jl CSV (no expr column)")
-    rows = Row[]
-    for line in lines[2:end]
+    header = split(lines[1], ',')
+    "expr" in header || error("$path is not a bench_to_suite.jl CSV (no expr column)")
+    col = Dict(h => i for (i, h) in enumerate(header))
+    return map(lines[2:end]) do line
         f = split(line, ',')
-        push!(
-            rows, Row(
-                f[1], f[2], f[3], f[4], parse(Int, f[5]), parse_params(f[6]), parse(Int, f[7]),
-                parse(Float64, f[8]), parse(Float64, f[9]), parse(Float64, f[10]),
-                parse(Float64, f[11]), parse(Float64, f[12]),
-                f[13], f[15] == "true", parse(Float64, f[16]), f[17]
-            )
+        t = parse(Float64, f[col["median_seconds"]])
+        gf = parse(Float64, f[col["gflops"]])
+        (
+            backend = f[col["backend"]], dtype = f[col["dtype"]], category = f[col["category"]],
+            id = f[col["case_id"]], params = parse_params(f[col["params"]]), t = t, gflops = gf,
+            flops = gf * t * 1.0e9, intensity = parse(Float64, f[col["intensity"]]),
         )
     end
-    return rows
 end
 
-const ROWS = read_rows(CSV_PATH)
-
-# Plotted on a log axis: ratios span orders of magnitude across cases.
-function ratio_for(rows, case_id, num, den)
-    t_num = only(r.t for r in rows if r.case_id == case_id && r.backend == num)
-    t_den = only(r.t for r in rows if r.case_id == case_id && r.backend == den)
-    return t_num / t_den
+function tags_match(params)
+    TAGS_FILTER === nothing && return true
+    keys_present = filter(k -> haskey(params, k), unique(first.(TAGS_FILTER)))
+    return !isempty(keys_present) &&
+        all(k -> any(kv -> kv == (k => params[k]), TAGS_FILTER), keys_present)
 end
 
-# A leading "*" marks upstream's `isblasequivalent` cases.
-case_label(r::Row) = @sprintf("%s%s  %s  dim=%d  %.3g FLOP/B", r.blas ? "*" : "", r.expr, r.case_id, r.dim, r.intensity)
-
-# Modeled samples (see the header), reflected rather than clipped at `min_v` so
-# no mass piles up at the boundary; seeded from the inputs, so replots match.
-function synth_samples(median_v::Float64, min_v::Float64, std_v::Float64; n::Int = 300)
-    std_v <= 0 && return fill(median_v, n)
-    rng = Random.Xoshiro(hash((median_v, min_v, std_v)))
-    raw = median_v .+ std_v .* randn(rng, n)
-    return map(x -> x < min_v ? 2 * min_v - x : x, raw)
+const ALL_ROWS = read_rows(CSV_PATH)
+const PLOT_DTYPES = something(
+    DTYPES_FILTER, let present = unique(r.dtype for r in ALL_ROWS)
+        default = filter(in(present), ["Float64", "ComplexF64"])
+        isempty(default) ? present : default
+    end
+)
+
+keep(r) = r.dtype in PLOT_DTYPES && (CATEGORIES_FILTER === nothing || r.category in CATEGORIES_FILTER) &&
+    tags_match(r.params)
+
+const ROWS = filter(keep, ALL_ROWS)
+isempty(ROWS) && error("no rows left after filtering $CSV_PATH")
+
+const SUFFIX = join(
+    vcat(
+        something(DTYPES_FILTER, String[]), something(CATEGORIES_FILTER, String[]),
+        TAGS_FILTER === nothing ? String[] : ["$(k)-$(v)" for (k, v) in TAGS_FILTER],
+    ), "_"
+)
+outpath(name) = joinpath(dirname(CSV_PATH), "bench_to_suite_$(name)$(isempty(SUFFIX) ? "" : "_" * SUFFIX).png")
+
+# One entry per (dtype, category, case) timed by both backends.
+const PAIRS = let byid = Dict{Tuple{String, String, String}, Dict{String, Any}}()
+    for r in ROWS
+        get!(byid, (r.dtype, r.category, r.id), Dict{String, Any}())[r.backend] = r
+    end
+    [
+        (dtype = k[1], category = k[2], id = k[3], qs = v["QuasiStrided"], blas = v["StridedBLAS"])
+            for (k, v) in byid if haskey(v, "QuasiStrided") && haskey(v, "StridedBLAS")
+    ]
 end
-
-# (dtype, category, group) panels; a group larger than MAX_PER_FIG is split
-# into consecutive chunks of its sweep dims.
-function panels(rows)
-    out = Tuple{String, Vector{Row}}[]
-    for dtype in PLOTTED_DTYPES, category in unique(r.category for r in rows),
-            group in unique(r.group for r in rows if r.category == category)
-        sub = filter(r -> r.dtype == dtype && r.category == category && r.group == group, rows)
-        isempty(sub) && continue
-        ncase = length(unique(r.case_id for r in sub))
-        if ncase <= MAX_PER_FIG
-            push!(out, ("$(dtype)_$(category)_$(group)", sub))
-            continue
-        end
-        chunk, dims = Int[], sort(unique(r.dim for r in sub))
-        flush_chunk() = (
-            push!(
-                out, (
-                    "$(dtype)_$(category)_$(group)_dim$(first(chunk))-$(last(chunk))",
-                    filter(r -> r.dim in chunk, sub),
-                )
-            ); empty!(chunk)
+const DTYPE_ORDER = ["Float32", "Float64", "ComplexF32", "ComplexF64"]
+const PANEL_DTYPES = sort(unique(r.dtype for r in ROWS); by = d -> something(findfirst(==(d), DTYPE_ORDER), 99))
+
+# batlow without its darkest and palest ends, so both ends stay visible on white.
+const CMAP = cgrad(:batlow)[0.08:0.01:0.85]
+const GREY = RGBf(0.45, 0.45, 0.45)
+decade_ticks(ms) = [m * 10.0^e for e in -3:4 for m in ms]
+const LOG_TICKS = decade_ticks((1, 2, 5))
+# Log-axis ticks with plain labels, as many per decade as the span allows.
+log_ticks(lo, hi) = hi / lo > 1000 ? decade_ticks((1,)) : hi / lo > 10 ? LOG_TICKS : decade_ticks((1, 1.5, 2, 3, 5, 7))
+# Ratios within a decade of each other get the steps in between.
+ratio_ticks(lo, hi) = hi / lo < 10 ? sort(vcat(LOG_TICKS, [0.6, 0.7, 0.8, 0.9, 1.1, 1.25, 1.5, 3])) : LOG_TICKS
+plainticks(vs) = [@sprintf("%g", v) for v in vs]
+const TITLE = "$(basename(dirname(CSV_PATH)))$(isempty(SUFFIX) ? "" : "  [" * replace(SUFFIX, "_" => ", ") * "]")"
+const MARKERS = (contract = (marker = :circle, markersize = 10), network = (marker = :utriangle, markersize = 13))
+const CATEGORIES = filter(c -> any(r -> r.category == c, ROWS), ["contract", "network"])
+
+function points!(ax, items, x, y, crange)
+    for cat in CATEGORIES
+        cs = filter(it -> it.category == cat, items)
+        isempty(cs) && continue
+        scatter!(
+            ax, [Point2f(x(it), y(it)) for it in cs]; MARKERS[Symbol(cat)]...,
+            color = [log10(work(it)) for it in cs], colormap = CMAP, colorrange = crange,
+            alpha = 0.65, strokewidth = 0.4, strokecolor = (:black, 0.5)
         )
-        for d in dims
-            nd = length(unique(r.case_id for r in sub if r.dim == d))
-            n = length(unique(r.case_id for r in sub if r.dim in chunk))
-            !isempty(chunk) && n + nd > MAX_PER_FIG && flush_chunk()
-            push!(chunk, d)
-        end
-        isempty(chunk) || flush_chunk()
     end
-    return out
+    return
 end
-
-for (name, subset) in panels(ROWS)
-    ids = unique(r.case_id for r in subset)
-    length(ids) < 2 && continue
-    dtype = first(subset).dtype
-
-    ratios = [ratio_for(subset, id, "QuasiStrided", "StridedBLAS") for id in ids]
-    order = sortperm(ratios)
-    ids, ratios = ids[order], ratios[order]
-    labels = [case_label(first(r for r in subset if r.case_id == id)) for id in ids]
-    title = replace(name, "_" => " / ")
-
-    fig = Figure(size = (1250, max(400, 26 * length(ids) + 174)))
-    Label(fig[0, 1:2], "* = BLAS-equivalent (upstream isblasequivalent: one gemm after reshapes alone)"; fontsize = 12)
-
-    ax1 = Axis(
-        fig[1, 1]; xscale = log10, yticks = (1:length(ids), labels),
-        xlabel = "GFLOP/s (log scale)", title = "$title -- throughput"
-    )
-    for backend in ("StridedBLAS", "QuasiStrided")
-        ys = [only(r.gflops for r in subset if r.case_id == id && r.backend == backend) for id in ids]
-        scatter!(ax1, ys, 1:length(ids); label = backend, markersize = 10)
-    end
-    axislegend(ax1; position = :rb)
-
-    ax2 = Axis(
-        fig[1, 2]; xscale = log10,
-        xlabel = "QuasiStrided / StridedBLAS time (log scale)",
-        title = "ratio (< 1 = QuasiStrided faster)"
-    )
-    hideydecorations!(ax2)
-    colors = [r <= 1 ? :seagreen : :firebrick for r in ratios]
-    barplot!(ax2, 1:length(ids), ratios; direction = :x, color = colors)
-    vlines!(ax2, [1.0]; color = :black, linestyle = :dash)
-
-    path = joinpath(OUTDIR, "bench_to_suite_$(name).png")
-    save(path, fig)
-    println("wrote ", path)
-
-    vfig = Figure(size = (1250, max(400, 26 * length(ids) + 174)))
-    Label(vfig[0, 1], "* = BLAS-equivalent (upstream isblasequivalent: one gemm after reshapes alone)"; fontsize = 12)
-    vax = Axis(
-        vfig[1, 1]; yticks = (1:length(ids), labels),
-        xlabel = "GFLOP/s -- modeled from median/min/std (see file header)",
-        title = "$title -- throughput spread"
-    )
-    offset = 0.18
-    for (boff, backend, color) in ((-offset, "StridedBLAS", :dodgerblue), (offset, "QuasiStrided", :orange))
-        ys = Float64[]
-        positions = Float64[]
-        for (i, id) in enumerate(ids)
-            row = only(r for r in subset if r.case_id == id && r.backend == backend)
-            samples = synth_samples(row.gflops, row.min_gflops, row.std_gflops)
-            append!(ys, samples)
-            append!(positions, fill(Float64(i) + boff, length(samples)))
+work(r) = hasproperty(r, :flops) ? r.flops : r.blas.flops
+
+function overview_figure()
+    nrow = length(PANEL_DTYPES)
+    fig = Figure(size = (1700, 430 * nrow + 170))
+    Label(fig[0, 1:3], TITLE; fontsize = 13, color = GREY)
+    crange = extrema(log10(r.flops) for r in ROWS)
+    xticks = log_ticks(extrema(r.intensity for r in ROWS)...)
+    axes = Axis[]
+    for (i, dtype) in enumerate(PANEL_DTYPES)
+        last = i == nrow
+        xlabel = last ? "arithmetic intensity (flop/byte)" : ""
+        rate_axes = map(enumerate(("QuasiStrided", "StridedBLAS"))) do (j, backend)
+            ax = Axis(
+                fig[i, j]; xscale = log10, yscale = log10, xticks, xtickformat = plainticks, xlabel,
+                yticks = log_ticks(extrema(r.gflops for r in ROWS if r.dtype == dtype)...), ytickformat = plainticks,
+                title = i == 1 ? backend : "", titlesize = 16, ylabel = j == 1 ? "throughput (GFLOP/s)" : ""
+            )
+            points!(ax, filter(r -> r.dtype == dtype && r.backend == backend, ROWS), r -> r.intensity, r -> r.gflops, crange)
+            ax
         end
-        violin!(
-            vax, positions, ys; orientation = :horizontal, side = boff < 0 ? :left : :right,
-            width = 2 * abs(offset) * 1.8, color = color, label = backend
+        linkyaxes!(rate_axes...)
+        ps = filter(p -> p.dtype == dtype, PAIRS)
+        rv = [p.qs.t / p.blas.t for p in ps]
+        ylim = isempty(ps) ? (0.5, 2.0) : extrema(rv) .* (0.8, 1.25)
+        # An empty band below the data for the summary box, so it hides no point.
+        ylim = (ylim[1] / (ylim[2] / ylim[1])^0.3, ylim[2])
+        ax = Axis(
+            fig[i, 3]; xscale = log10, yscale = log10, xticks, xtickformat = plainticks, xlabel,
+            yticks = ratio_ticks(ylim...), ytickformat = plainticks,
+            title = i == 1 ? "QuasiStrided / StridedBLAS time" : "", titlesize = 16,
+            ylabel = "time ratio (< 1: QuasiStrided faster)"
         )
+        hlines!(ax, [1.0]; color = :black, linewidth = 1, linestyle = :dash)
+        points!(ax, ps, p -> p.blas.intensity, p -> p.qs.t / p.blas.t, crange)
+        ylims!(ax, ylim)
+        if !isempty(ps)
+            textlabel!(
+                ax, Point2f(0.98, 0.03); space = :relative, text_align = (:right, :bottom), fontsize = 13,
+                text = @sprintf("geomean %.2f\nQuasiStrided faster in %d of %d", geomean(rv), count(<(1), rv), length(rv)),
+                background_color = (:white, 0.85), strokecolor = (:black, 0.3), cornerradius = 3, justification = :left
+            )
+        end
+        last || foreach(a -> hidexdecorations!(a; grid = false, minorgrid = false), (rate_axes..., ax))
+        Label(fig[i, 0], dtype; rotation = pi / 2, fontsize = 16, font = :bold, tellheight = false)
+        append!(axes, rate_axes)
+        push!(axes, ax)
     end
-    axislegend(vax; position = :rb)
-    vpath = joinpath(OUTDIR, "bench_to_suite_$(name)_violin.png")
-    save(vpath, vfig)
-    println("wrote ", vpath)
+    linkxaxes!(axes...)
+    Colorbar(fig[1:nrow, 4]; colormap = CMAP, limits = crange, label = "total work (log10 flop)")
+    Legend(
+        fig[nrow + 1, 1:3],
+        [MarkerElement(; MARKERS[Symbol(c)]..., color = GREY, strokewidth = 0.4, strokecolor = :black) for c in CATEGORIES],
+        CATEGORIES; orientation = :horizontal, framevisible = false
+    )
+    return fig
 end
+
+path = outpath("overview")
+save(path, overview_figure())
+println("wrote ", path)
diff --git a/benchmark/probes/probe_call_floor.jl b/benchmark/probes/probe_call_floor.jl
index b67628c..4a1e69b 100644
--- a/benchmark/probes/probe_call_floor.jl
+++ b/benchmark/probes/probe_call_floor.jl
@@ -1,17 +1,19 @@
-# Per-call floor of `tensorcontract!` on tiny problems: QuasiStridedBackend vs
-# StridedBLAS, through TensorOperations' public entry point with the default
-# allocator (so QuasiStrided uses its pooled task workspace).
+# Per-call floor on small problems:
 #
 #   JULIA_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 taskset -c 4-7 \
-#       julia --project=benchmark benchmark/probes/probe_call_floor.jl [label]
+#       julia --project=benchmark benchmark/probes/probe_call_floor.jl [--label X]
 #
-# Prints one line per (case, backend): median ns/call over SAMPLES samples of
-# CALLS calls each, the [min, max] of those samples, and bytes/call. Whatever
-# QuasiStrided the `--project` environment resolves is what is measured, so an
-# A/B is two runs of this script from two checkouts, interleaved.
+# `tensorcontract!` through TensorOperations' public entry point with the
+# default allocator, QuasiStridedBackend (QS) against StridedBLAS (BLAS); then
+# QuasiStrided's own `contract!` (planning included) and `execute!` of a reused
+# plan. Prints one line per (case, entry point): median ns/call over SAMPLES
+# samples of CALLS calls each, the [min, max] of those samples, and bytes/call.
+# Whatever QuasiStrided the `--project` environment resolves is what is
+# measured, so an A/B is two runs of this script from two checkouts, interleaved.
 
-using TensorOperations, Statistics, Printf, LinearAlgebra
+using TensorOperations, StridedViews, Statistics, Printf, LinearAlgebra
 using QuasiStrided
+using QuasiStrided: plan_contract, execute!, contract!
 const TO = TensorOperations
 
 BLAS.set_num_threads(1)
@@ -19,6 +21,10 @@ BLAS.set_num_threads(1)
 const SAMPLES = 15
 const CALLS = 2000
 
+label = let i = findfirst(==("--label"), ARGS)
+    i === nothing ? "" : ARGS[i + 1]
+end
+
 # (name, sizes of A, B, C, pA, pB, pAB)
 const CASES = (
     ("8x8x8 gemm", (8, 8), (8, 8), (8, 8), ((1,), (2,)), ((1,), (2,)), ((1, 2), ())),
@@ -27,32 +33,45 @@ const CASES = (
     ("d4 outer", (4, 4), (4, 4), (4, 4, 4, 4), ((1, 2), ()), ((), (1, 2)), ((1, 2, 3, 4), ())),
 )
 
-function ncalls(C, A, pA, B, pB, pAB, backend, n)
+function ncalls(f::F, n) where {F}
     for _ in 1:n
-        TO.tensorcontract!(C, A, pA, false, B, pB, false, pAB, true, false, backend)
+        f()
     end
-    return C
+    return
 end
 
-function measure(C, A, pA, B, pB, pAB, backend)
-    ncalls(C, A, pA, B, pB, pAB, backend, 10)
-    bytes = @allocated ncalls(C, A, pA, B, pB, pAB, backend, 100)
+function measure(f)
+    ncalls(f, 10)
+    bytes = @allocated ncalls(f, 100)
     ts = map(1:SAMPLES) do _
         t = time_ns()
-        ncalls(C, A, pA, B, pB, pAB, backend, CALLS)
+        ncalls(f, CALLS)
         (time_ns() - t) / CALLS
     end
     return median(ts), minimum(ts), maximum(ts), bytes / 100
 end
 
-label = isempty(ARGS) ? "" : ARGS[1]
-for T in (Float64, ComplexF64), (name, sa, sb, sc, pA, pB, pAB) in CASES
-    A, B, C = rand(T, sa), rand(T, sb), zeros(T, sc)
-    for (bname, backend) in (("QS", QuasiStridedBackend()), ("BLAS", TO.StridedBLAS()))
-        med, lo, hi, b = measure(C, A, pA, B, pB, pAB, backend)
-        @printf(
-            "%s\t%-10s\t%-10s\t%-4s\t%8.1f ns\t[%7.1f, %7.1f]\t%6.0f B\n",
-            label, T, name, bname, med, lo, hi, b
-        )
+function report(T, name, entry, f)
+    med, lo, hi, b = measure(f)
+    @printf(
+        "%s\t%-10s\t%-10s\t%-9s\t%9.1f ns\t[%8.1f, %8.1f]\t%6.0f B\n",
+        label, T, name, entry, med, lo, hi, b
+    )
+    return flush(stdout)
+end
+
+for T in (Float64, ComplexF64)
+    for (name, sa, sb, sc, pA, pB, pAB) in CASES
+        A, B, C = rand(T, sa), rand(T, sb), zeros(T, sc)
+        for (bname, backend) in (("QS", QuasiStridedBackend()), ("BLAS", TO.StridedBLAS()))
+            report(T, name, bname, () -> TO.tensorcontract!(C, A, pA, false, B, pB, false, pAB, true, false, backend))
+        end
+    end
+    for n in (2, 64)
+        A, B, C = StridedView(rand(T, n, n)), StridedView(rand(T, n, n)), StridedView(zeros(T, n, n))
+        name = n == 2 ? "2x2 gemm" : "64^3 gemm"
+        report(T, name, "contract!", () -> contract!(C, one(T), A, (1, 2), B, (2, 3), zero(T), (1, 3)))
+        plan = plan_contract(C, A, (1, 2), B, (2, 3), (1, 3))
+        report(T, name, "execute!", () -> execute!(plan, one(T), zero(T)))
     end
 end
diff --git a/benchmark/probes/probe_specialisations.jl b/benchmark/probes/probe_specialisations.jl
new file mode 100644
index 0000000..add457f
--- /dev/null
+++ b/benchmark/probes/probe_specialisations.jl
@@ -0,0 +1,56 @@
+# Number of compiled specialisations of the engine's hot generic functions
+# after a fixed workload: one plan per path (real, complex and mixed nests with
+# packed and unpacked B, line-by-line packing, a C panel, dot, outer) plus an
+# `@tensor` call, each executed once. A growing count means a change splits
+# methods on more type parameters, which costs compile time.
+#
+#   julia --project=benchmark benchmark/probes/probe_specialisations.jl [--label X]
+#
+# Prints one line per function: its specialisations summed over its methods.
+# `planned` is counted through its keyword body. Names the checked-out
+# revision lacks print 0, so two revisions compare line by line.
+
+using QuasiStrided, StridedViews, TensorOperations
+using QuasiStrided: plan_contract, execute!, PathModes
+
+label = let i = findfirst(==("--label"), ARGS)
+    i === nothing ? "" : ARGS[i + 1]
+end
+
+views(T, ext, (iA, iB, iC); TA = T, TB = T, TC = T) =
+    (StridedView(zeros(TC, map(l -> ext[l], iC))), StridedView(randn(TA, map(l -> ext[l], iA))), iA, StridedView(randn(TB, map(l -> ext[l], iB))), iB, iC)
+gemm(T, M, K, N; kw...) = views(T, (M, K, N), ((1, 2), (2, 3), (1, 3)); kw...)
+
+# The line-by-line case follows the test suite's `SP_I7`; whether it splits
+# depends on the host's L2, so it is a representative call rather than a forced split.
+const CASES = (
+    (gemm(Float64, 64, 64, 64), (;)),
+    (gemm(ComplexF64, 64, 64, 64), (;)),
+    (gemm(ComplexF64, 64, 64, 64; TB = Float64), (;)),
+    (gemm(ComplexF64, 64, 64, 64; TA = Float64), (;)),
+    (gemm(Float64, 16, 16, 16), (; path_modes = PathModes(unpacked_b = :always))),
+    (gemm(Float64, 16, 16, 16), (; path_modes = PathModes(unpacked_b = :never))),
+    (gemm(ComplexF64, 16, 16, 16), (; path_modes = PathModes(unpacked_b = :never))),
+    (views(Float64, (24, 24, 24, 24, 24, 24), ((1, 2, 3, 4, 5), (4, 6), (5, 3, 2, 6, 1))), (;)),
+    (gemm(Float64, 13, 20, 40; TC = Float32), (; k_block = 4)),
+    (gemm(Float64, 1, 256, 64), (;)),
+    (gemm(ComplexF64, 1, 256, 64), (;)),
+    (gemm(Float64, 64, 1, 64), (;)),
+    (gemm(ComplexF64, 64, 1, 64), (;)),
+)
+
+for ((Cv, Av, iA, Bv, iB, iC), kw) in CASES
+    execute!(plan_contract(Cv, Av, iA, Bv, iB, iC; kw...), 1, 0)
+end
+let A = randn(20, 30, 10), B = randn(30, 15), C = zeros(20, 10, 15)
+    @tensor backend = QuasiStridedBackend() C[a, b, n] = A[a, k, b] * B[k, n]
+end
+
+nspec(m::Method) = count(_ -> true, Base.specializations(m))
+nspec(f) = sum(nspec, methods(f); init = 0)
+for name in (:nest!, :micro_tiles!, :execute_tile!, :store_tile!, :pack!, :execute_path!, :build_plan, :planned)
+    n = !isdefined(QuasiStrided, name) ? 0 :
+        name === :planned ? sum(m -> nspec(Base.bodyfunction(m)), methods(QuasiStrided.planned); init = 0) :
+        nspec(getfield(QuasiStrided, name))
+    println(label, isempty(label) ? "" : "\t", rpad(name, 15), n)
+end
diff --git a/benchmark/probes/probe_ttfx.jl b/benchmark/probes/probe_ttfx.jl
index 8bd4099..58ff419 100644
--- a/benchmark/probes/probe_ttfx.jl
+++ b/benchmark/probes/probe_ttfx.jl
@@ -1,9 +1,33 @@
-t0 = time(); using TensorOperations, QuasiStrided; tload = time() - t0
-function first(T)
-    A = randn(T, 20, 30, 10); B = randn(T, 30, 15); C = zeros(T, 20, 10, 15)
-    t = @elapsed @tensor backend = QuasiStridedBackend() C[a, b, n] = A[a, k, b] * B[k, n]
-    return t
+# Time to first call, in one fresh process:
+#
+#   julia --project=benchmark benchmark/probes/probe_ttfx.jl [--label X]
+#
+# Prints one line per step, in order: `using QuasiStrided`; the first Float64
+# `plan_contract` + `execute!` (64^3); the first ComplexF64 one; the first
+# `@tensor` with `QuasiStridedBackend`; the first `contract!`. Each step's time
+# is what it adds on top of the steps before it, so run the script once per
+# process, never twice in one session; repeat processes for a spread (the A/B
+# script does, once per round).
+
+label = let i = findfirst(==("--label"), ARGS)
+    i === nothing ? "" : ARGS[i + 1]
 end
-ts = [(T, first(T)) for T in (Float64, ComplexF64)]
-t2 = @elapsed @tensor backend = QuasiStridedBackend() D[a, b] := randn(8, 1)[a, k] * randn(1, 9)[k, b]
-println("load ", round(tload, digits = 1), " s; first call ", join(["$T $(round(t, digits = 1)) s" for (T, t) in ts], ", "), "; first K=1 outer ", round(t2, digits = 1), " s")
+report(step, t) = println(label, isempty(label) ? "" : "\t", rpad(step, 26), round(t; digits = 2), " s")
+
+report("using QuasiStrided", @elapsed using QuasiStrided)
+using StridedViews, TensorOperations
+using QuasiStrided: plan_contract, execute!, contract!
+
+gemm(T) = (StridedView(zeros(T, 64, 64)), StridedView(randn(T, 64, 64)), (1, 2), StridedView(randn(T, 64, 64)), (2, 3), (1, 3))
+plan_execute(args) = execute!(plan_contract(args...), 1, 0)
+function tensor_call(A, B, C)
+    @tensor backend = QuasiStridedBackend() C[a, b, n] = A[a, k, b] * B[k, n]
+    return C
+end
+contract_call((C, A, iA, B, iB, iC)) = contract!(C, 1, A, iA, B, iB, 0, iC)
+
+f64, c64 = gemm(Float64), gemm(ComplexF64)
+report("Float64 plan+execute!", @elapsed plan_execute(f64))
+report("ComplexF64 plan+execute!", @elapsed plan_execute(c64))
+report("@tensor", @elapsed tensor_call(randn(20, 30, 10), randn(30, 15), zeros(20, 10, 15)))
+report("contract!", @elapsed contract_call(gemm(Float64)))
diff --git a/benchmark/submit_ab.sh b/benchmark/submit_ab.sh
new file mode 100644
index 0000000..5e19bb7
--- /dev/null
+++ b/benchmark/submit_ab.sh
@@ -0,0 +1,79 @@
+#!/bin/bash
+# Same-node A/B of two git revisions on one benchmark script, from the repo root:
+#
+#   sbatch [--reservation=rocky8] [--constraint=icelake|genoa|rome] [--time=..] \
+#       benchmark/submit_ab.sh <rev_a> <rev_b> <script.jl> [script args...]
+#
+# e.g. `sbatch --constraint=genoa benchmark/submit_ab.sh main HEAD probes/probe_call_floor.jl`.
+# Each revision runs from its own temporary worktree with its own copy of the
+# script (the submitting checkout's when the revision lacks it), alternately a, b, a, b, ... for $QS_AB_ROUNDS rounds (default 2), so
+# slow drift on the node hits both alike. Outputs go to
+# benchmark/results/<script>-ab-<jobid>-<host>/<a|b>-r<round>/. See
+# https://wiki.flatironinstitute.org/SCC/Software/Slurm.
+#SBATCH --job-name=qs-bench-ab
+#SBATCH --partition=ccq
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=32G
+#SBATCH --time=06:00:00
+#SBATCH --output=benchmark/results/slurm-%j.out
+
+set -euo pipefail
+# Slurm runs a spooled copy of this script; SLURM_SUBMIT_DIR is the repo root.
+cd "${SLURM_SUBMIT_DIR:?SLURM_SUBMIT_DIR not set -- run this script via sbatch, not directly}"
+USAGE="usage: sbatch benchmark/submit_ab.sh <rev_a> <rev_b> <script.jl> [args...]"
+REV_A=${1:?$USAGE}
+REV_B=${2:?$USAGE}
+SCRIPT=${3:?$USAGE}
+shift 3
+ROUNDS=${QS_AB_ROUNDS:-2}
+SHA_A=$(git rev-parse --verify "$REV_A^{commit}")
+SHA_B=$(git rev-parse --verify "$REV_B^{commit}")
+
+# Same julia lookup as submit.sh.
+module load modules/2.5-beta1 2>/dev/null || true
+module load julia/1.12.6 2>/dev/null || true
+MODJULIA=$(command -v julia 2>/dev/null || true)
+case "$MODJULIA" in /mnt/sw/*) ;; *) MODJULIA="" ;; esac # only a module-provided one
+JULIA=${QS_JULIA:-${MODJULIA:-$(ls -d "$HOME"/.julia/juliaup/julia-1.12*/bin/julia 2>/dev/null | tail -1)}}
+[ -x "${JULIA:-}" ] || { echo "no julia found; set QS_JULIA" >&2; exit 127; }
+export JULIA_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1
+
+echo "julia = $JULIA  node = ${SLURM_JOB_NODELIST:-?}  nproc = $(nproc)"
+taskset -cp $$ || true
+lscpu | grep -i "model name\|cache" || true
+
+WORK=$(mktemp -d "${TMPDIR:-/tmp}/qs-ab-${SLURM_JOB_ID}-XXXX")
+cleanup() {
+    git worktree remove --force "$WORK/a" 2>/dev/null || true
+    git worktree remove --force "$WORK/b" 2>/dev/null || true
+    rm -rf "$WORK"
+}
+trap cleanup EXIT
+
+OUTDIR="benchmark/results/$(basename "$SCRIPT" .jl)-ab-${SLURM_JOB_ID}-$(hostname -s)"
+mkdir -p "$OUTDIR"
+OUTDIR=$(cd "$OUTDIR" && pwd)
+printf 'a %s %s\nb %s %s\n' "$REV_A" "$SHA_A" "$REV_B" "$SHA_B" | tee "$OUTDIR/revisions.txt"
+
+for side in a b; do
+    sha=$SHA_A
+    [ "$side" = b ] && sha=$SHA_B
+    git worktree add --detach "$WORK/$side" "$sha"
+    # The submitting checkout's resolved versions, when it has them, so both
+    # sides differ only in QuasiStrided.
+    [ -f benchmark/Manifest.toml ] && cp benchmark/Manifest.toml "$WORK/$side/benchmark/"
+    [ -f "$WORK/$side/benchmark/$SCRIPT" ] || install -D "benchmark/$SCRIPT" "$WORK/$side/benchmark/$SCRIPT"
+    "$JULIA" --project="$WORK/$side/benchmark" -e 'using Pkg; Pkg.instantiate(); Pkg.precompile()'
+done
+
+for round in $(seq 1 "$ROUNDS"); do
+    for side in a b; do
+        dir="$OUTDIR/$side-r$round"
+        mkdir -p "$dir"
+        echo "=== round $round: $(grep "^$side " "$OUTDIR/revisions.txt")"
+        "$JULIA" --project="$WORK/$side/benchmark" "$WORK/$side/benchmark/$SCRIPT" --outdir "$dir" "$@" |
+            tee "$dir/stdout.txt"
+    done
+done
diff --git a/src/QuasiStrided.jl b/src/QuasiStrided.jl
index 5ff6419..6372cfd 100644
--- a/src/QuasiStrided.jl
+++ b/src/QuasiStrided.jl
@@ -1,7 +1,9 @@
 module QuasiStrided
 
-using LinearAlgebra
 using StridedViews: StridedView, offset
+import TupleTools
+using Base.Checked: checked_abs, checked_add, checked_mul
+using VectorInterface: Zero, One
 
 # TensorOperations names are always qualified: a bare `using` collides on `scalartype`.
 import TensorOperations as TO
@@ -16,7 +18,6 @@ include("hardware/target.jl")
 
 # --- Layout: zero-based strided/scattered addressing ---
 include("layout/axis_group.jl")
-include("layout/pair_group.jl")
 include("layout/tiles.jl")
 
 # --- Packing: packed-panel formats and the packers that fill them ---
@@ -24,34 +25,29 @@ include("packing/format.jl")
 include("packing/panel.jl")
 include("packing/pack.jl")
 include("packing/pack_contiguous.jl")
-include("packing/transposed.jl")
+include("packing/line_packing.jl")
 
-# --- Microkernels: accumulate over one packed K panel, store into C ---
+# --- Microkernels: add one packed K block to a register tile, store into C ---
 include("microkernels/interface.jl")
-include("microkernels/scalar.jl")
-include("microkernels/simd.jl")
-include("microkernels/planar.jl")
-include("microkernels/onem.jl")
-include("microkernels/fmaddsub.jl")
-include("microkernels/mixed.jl")
+include("microkernels/kernels.jl")
+include("microkernels/vecops.jl")
+# B read in place: a B source beside `PackedPanel`, ahead of the K steps' generators.
+include("packing/unpacked_b.jl")
+include("microkernels/steps.jl")
+include("microkernels/stores.jl")
 
-# --- Planning: labels, conjugation, kernel and blocking choice, the plan ---
+# --- Planning: labels, kernel and blocking choice, the plan ---
 include("planning/labels.jl")
-include("planning/conjugation.jl")
 include("planning/kernel_selection.jl")
 include("planning/blocking.jl")
-include("planning/defaults.jl")
-include("planning/pack_split.jl")
+include("execution/paths.jl")
 include("execution/workspace.jl")
-include("execution/barrier.jl")
 include("planning/plan.jl")
 
-# --- Execution: the five-loop nest, the tile-by-tile oracle and the
-# specialised paths ---
-include("execution/macrokernel.jl")
+# --- Execution: the five-loop nest and the specialised paths ---
+include("execution/nest.jl")
 include("execution/execute.jl")
-include("execution/oracle.jl")
-include("execution/unpackedb.jl")
+include("execution/c_panel.jl")
 include("execution/dot.jl")
 include("execution/outer.jl")
 
@@ -63,7 +59,7 @@ export QuasiStridedBackend
 # Detect the hardware per process, not at precompile time: a cached .ji may be
 # loaded on a different CPU.
 function __init__()
-    _init_target!()
+    init_target!()
     return nothing
 end
 
@@ -71,7 +67,7 @@ end
     eval(
         Expr(
             :public, :contract!, :plan_contract, :execute!, :ContractPlan,
-            :ContractWorkspace, :Blocking, :default_blocking,
+            :ContractWorkspace, :Blocking, :default_blocking, :tile_size, :sliver_width,
             :ScalarKernel, :SIMDKernel, :PlanarKernel, :OneMKernel, :FMAddSubKernel,
             :ComplexRealKernel, :RealComplexKernel,
             :target_profile, :cache_topology,
diff --git a/src/execution/barrier.jl b/src/execution/barrier.jl
deleted file mode 100644
index c51460e..0000000
--- a/src/execution/barrier.jl
+++ /dev/null
@@ -1,102 +0,0 @@
-# Dispatch barriers. The kernel and the execution path are runtime choices
-# that everything below them is specialised on. A static branch over every
-# choice would make Julia infer and compile every arm (the whole kernel menu x
-# every path x, for complex, four transform pairs) on the first call. A
-# dynamic call instead compiles only the callee actually reached.
-#
-# `jl_apply_generic` boxes every argument that is not already a heap object
-# or a singleton, so each barrier passes:
-#   * static choices (kernel shape, method, transforms, path) as singletons;
-#   * operand storages (already heap objects) as themselves;
-#   * everything else through a typed slot, a `Base.RefValue{P}` owned by the
-#     workspace's `_SlotCache`: written just before the call, read back first
-#     thing in the callee.
-# The payload never holds an operand array, so a pooled workspace retains no
-# user data between calls. A workspace belongs to one task at a time, and
-# the callee copies the payload out before it could run another contraction.
-
-# The typed slot for payload type `P`; the common case (same payload type as
-# the previous crossing) is one type-tag test.
-@inline function _barrier_slot!(ws::ContractWorkspace, ::Type{P}) where {P}
-    cache = ws.slots
-    slot = cache.last
-    slot isa Base.RefValue{P} && return slot
-    return _barrier_slot_slow!(cache, P)
-end
-
-# No workspace yet: a one-off slot, on a path that allocates a workspace anyway.
-@inline _barrier_slot!(::Nothing, ::Type{P}) where {P} = Base.RefValue{P}()
-
-@noinline function _barrier_slot_slow!(cache::_SlotCache, ::Type{P}) where {P}
-    slot = get!(() -> Base.RefValue{P}(), cache.slots, P)::Base.RefValue{P}
-    cache.last = slot
-    return slot
-end
-
-# ----------------------------------------------------------------------------
-# Execution paths: singletons that select one `_execute_path!` method.
-# ----------------------------------------------------------------------------
-
-# The five-loop nest. `UNPACKED_B`: B read in place instead of packed. `AFF`:
-# per map, in the order M-in-A, M-in-C, N-in-B, N-in-C, K-in-A, K-in-B,
-# whether it is an affine ramp, so that its sliver axes are statically
-# `AffineAxis` and the `PtrScatterAxis` arm is never compiled. `SPLIT`: whether
-# A and B are packed line by line (`plan.mpack`/`plan.npack`).
-struct _NestPath{UNPACKED_B, AFF, SPLIT} end
-
-@inline _is_ramp_map(g::AxisGroup, p::Int) = _map_ramp_step(g, p) !== nothing
-
-# N's B flag stays `false` when B is read in place: that path builds no B
-# sliver axis, so the flag would only split specialisations. A split group is
-# enumerated in another order, so its ramp flags are `false`. `panel`: C is
-# `_PanelPath`'s dense panel, whose M and N maps are ramps.
-@inline function _nest_path(
-        unpacked_b::Bool, mgroup::AxisGroup, ngroup::AxisGroup, kgroup::AxisGroup,
-        split_a::Bool, split_b::Bool, panel::Bool = false
-    )
-    split_b &= !unpacked_b
-    return _nest_path_from_flags(
-        panel ? _PANEL_PATHS : _NEST_PATHS, unpacked_b,
-        !split_a && _is_ramp_map(mgroup, 1), !split_a && (panel || _is_ramp_map(mgroup, 2)),
-        !unpacked_b && !split_b && _is_ramp_map(ngroup, 1), !split_b && (panel || _is_ramp_map(ngroup, 2)),
-        _is_ramp_map(kgroup, 1), _is_ramp_map(kgroup, 2), split_a, split_b
-    )
-end
-
-# The nest run against a dense panel of C in the compute type.
-struct _PanelPath{P <: _NestPath} end
-
-# Table lookup rather than `_NestPath{u, aff, split}()` built at runtime (a
-# dynamic type application) or a 512-leaf branch tree (slow to infer).
-@inline function _nest_path_from_flags(table::Vector{Any}, flags::Vararg{Bool, 9})
-    index = 1
-    for i in 1:9
-        index += flags[i] << (i - 1)
-    end
-    return @inbounds table[index]
-end
-
-const _NEST_PATHS = let
-    table = Vector{Any}(undef, 512)
-    for index in 1:512
-        bits = ntuple(i -> ((index - 1) >> (i - 1)) & 1 == 1, 9)
-        table[index] = _NestPath{bits[1], bits[2:7], bits[8:9]}()
-    end
-    table
-end
-
-const _PANEL_PATHS = Any[_PanelPath{typeof(p)}() for p in _NEST_PATHS]
-
-# The dot path at lane width `W`; `MATB`: the matrix operand is B (`Qm == 1`).
-struct _DotPath{MATB, W} end
-
-# The outer-product path at lane width `W`.
-struct _OuterPath{W} end
-
-# A runtime lane width to its path singleton, one literal per arm.
-@inline function _lane_path(::Type{P}, W::Int) where {P}
-    W == 16 && return P{16}()
-    W == 8 && return P{8}()
-    W == 4 && return P{4}()
-    return P{2}()
-end
diff --git a/src/execution/c_panel.jl b/src/execution/c_panel.jl
new file mode 100644
index 0000000..aba926f
--- /dev/null
+++ b/src/execution/c_panel.jl
@@ -0,0 +1,66 @@
+# The panel of C: for an eltype of C narrower than the compute type, partial
+# sums across K blocks live in a compute-type panel in the workspace, one N
+# block at a time.
+
+# Per N block: load the block of C into the panel (unless `beta == 0`), run the
+# nest on a plan whose C is the panel holding just that block, with dense M/N
+# maps, and round the block back into C.
+function execute_path!(
+        plan::ContractPlan{T}, alphaT::T, betaT::T, ::PanelPath{P}
+    ) where {T, P}
+    ws = plan.workspace
+    m_length = axis_length(plan.mgroup)
+    n_length = axis_length(plan.ngroup)
+    n_block = plan.blocking.n_block
+    panel_plan = ContractPlan(
+        plan; mgroup = dense_second_map(plan.mgroup, 1), ngroup = dense_second_map(plan.ngroup, m_length),
+        Cstorage = ws.c_panel
+    )
+    n_block_start = 0
+    while n_block_start < n_length
+        n_block_length = min(n_block, n_length - n_block_start)
+        n_range = n_block_start:(n_block_start + n_block_length - 1)
+        iszero(betaT) || panel_copy!(plan, n_range, true)
+        block_plan = ContractPlan(panel_plan; Cbase = -n_block_start * m_length)
+        GC.@preserve ws nest!(block_plan, alphaT, betaT, P(), n_range)
+        panel_copy!(plan, n_range, false)
+        n_block_start += n_block_length
+    end
+    return nothing
+end
+
+# `g` with its second map replaced by the column-major one scaled by `step`.
+@inline function dense_second_map(g::AxisGroup{D, 2}, step::Int) where {D}
+    dense = ntuple(d -> step * prod(ntuple(i -> i < d ? g.lengths[i] : 1, Val(D))), Val(D))
+    return AxisGroup(g.lengths, (g.strides[1], dense))
+end
+
+# Columns `n_range` of `plan`'s C into (`load`) or out of the panel, converting
+# to the destination's eltype. Borrows the M/N offset buffers, which the nest
+# refills before reading them again.
+function panel_copy!(plan::ContractPlan, n_range::UnitRange{Int}, load::Bool)
+    ws = plan.workspace
+    panel = ws.c_panel
+    C = plan.Cstorage
+    m_length = axis_length(plan.mgroup)
+    m_block = plan.blocking.m_block
+    n_bufC = ws.n.offsets[2]
+    fill_offsets!(ws.n.offsets, plan.ngroup, first(n_range), length(n_range))
+    m_block_start = 0
+    while m_block_start < m_length
+        m_block_length = min(m_block, m_length - m_block_start)
+        m_bufC = ws.m.offsets[2]
+        fill_offsets!(ws.m.offsets, plan.mgroup, m_block_start, m_block_length)
+        for j in 1:length(n_range), i in 1:m_block_length
+            c = plan.Cbase + m_bufC[i] + n_bufC[j] + 1
+            q = m_block_start + i + (j - 1) * m_length
+            if load
+                panel[q] = C[c]
+            else
+                C[c] = panel[q]
+            end
+        end
+        m_block_start += m_block_length
+    end
+    return nothing
+end
diff --git a/src/execution/dot.jl b/src/execution/dot.jl
index 3e9dd0b..7e676a1 100644
--- a/src/execution/dot.jl
+++ b/src/execution/dot.jl
@@ -1,183 +1,103 @@
 # The dot-product ("gemv") path for `M == 1` or `N == 1` when the matrix
 # operand (`Qfree x K`) is stored with K unit-stride. The register microkernel
-# vectorizes along M, which is 1/mr full here, and gathering the K-major
+# vectorizes along M, which is 1/m_tile full here, and gathering the K-major
 # matrix into packed panels would dominate the call. This path vectorizes
 # along K instead: one W-wide FMA per W matrix elements, the matrix read once
 # and unpacked, one horizontal reduction per output. Only the K-vector is
 # gathered, once per K block, with its conjugation folded in.
 
-# Forces the path off (`:never`) for benchmarks and tests; `:auto` otherwise.
-const _DOT_MODE = Ref{Symbol}(:auto)
-
-# One full hardware vector register of `real(T)`.
-@inline function _dot_lanewidth(::Type{T}) where {T}
-    R = real(T)
-    vb = target_profile().vector_bytes
-    return (vb > 0 && vb % sizeof(R) == 0) ? vb ÷ sizeof(R) : _default_lanewidth(R)
-end
-
 # Outputs computed together: 8 independent FMA chains cover the FMA latency
 # (a complex output has two accumulator planes).
-_dot_group_width(::Type{T}) where {T} = T <: Complex ? 4 : 8
-
-# The affine step of map `p` of `g` alone, or `nothing` if it is not a single
-# ramp; `affine_ramp` asks the same of all maps at once.
-function _map_ramp_step(g::AxisGroup{D, P}, p::Int) where {D, P}
-    step = 0
-    run = 1
-    started = false
-    for d in 1:D
-        L = g.lengths[d]
-        L == 0 && return 0
-        L == 1 && continue
-        S = g.strides[p][d]
-        if !started
-            step = S
-            run = L
-            started = true
-        else
-            Int128(run) * Int128(step) == Int128(S) || return nothing
-            run *= L
-        end
-    end
-    return step
-end
-
-# Whether the dot path applies (all but the workspace capacity): a degenerate
-# free extent, a matrix operand with unit-ramp K in dense storage (raw-pointer
-# loads), and at least one vector of K.
-function _dot_applicable(::Type{T}, Astorage, Bstorage, kgroup::AxisGroup, Qm::Int, Qn::Int, Qk::Int) where {T}
-    _DOT_MODE[] === :never && return false
-    (Qm == 1 || Qn == 1) || return false
-    Qk >= _dot_lanewidth(T) || return false
-    if Qm == 1
-        Bstorage isa DenseVector{T} || return false
-        _map_ramp_step(kgroup, 2) == 1 || return false
-    else
-        Astorage isa DenseVector{T} || return false
-        _map_ramp_step(kgroup, 1) == 1 || return false
-    end
-    return true
-end
-
-# The gathered vector (and, complex, its pair-swapped copy) lives in the
-# packed-A buffer. Always true for an automatically chosen kernel; `nothing`
-# is the prediction's "assume so".
-function _dot_capacity_ok(plan::ContractPlan{T}) where {T}
-    need = (T <: Complex ? 2 : 1) * plan.blocking.kc
-    return (length(plan.workspace.packed_a) * sizeof(real(T))) ÷ sizeof(T) >= need
-end
-_dot_capacity_ok(::Nothing) = true
+dot_group_width(::Type{T}) where {T} = T <: Complex ? 4 : 8
 
-function _execute_dot!(plan::ContractPlan{T}, alphaT::T, betaT::T, matB::Bool, ::Val{W}) where {T, W}
+function execute_path!(plan::ContractPlan{T}, alphaT::T, betaT::T, ::DotPath{MATB, W}) where {T, MATB, W}
     ws = plan.workspace
-    if matB
-        _dot_nest!(
-            plan, ws, plan.Bstorage, plan.Bbase, plan.btransform,
-            plan.Astorage, plan.Abase, plan.atransform,
-            plan.ngroup, ws.n_buf_B, ws.n_buf_C, plan.blocking.nc, ws.k_buf_A,
-            alphaT, betaT, Val(W)
-        )
-    else
-        _dot_nest!(
-            plan, ws, plan.Astorage, plan.Abase, plan.atransform,
-            plan.Bstorage, plan.Bbase, plan.btransform,
-            plan.mgroup, ws.m_buf_A, ws.m_buf_C, plan.blocking.mc, ws.k_buf_B,
-            alphaT, betaT, Val(W)
-        )
-    end
-    return plan.Cstorage
-end
-
-# Conjugation is folded out of the kernel: `sum conj(m)*v == conj(sum m*conj(v))`,
-# so a conjugated matrix becomes a flipped vector plus a `conj` per output.
-@inline _is_conj(::typeof(conj)) = true
-@inline _is_conj(::typeof(identity)) = false
-
-# `(lo, hi)` of `buf[1:count]`, `count >= 1`.
-@inline function _buffer_range(buf::Vector{Int}, count::Int)
-    @inbounds lo = hi = buf[1]
-    @inbounds for t in 2:count
-        v = buf[t]
-        lo = min(lo, v)
-        hi = max(hi, v)
-    end
-    return (lo, hi)
-end
-
-function _dot_nest!(
-        plan::ContractPlan{T}, ws, mstorage::SM, mbase::Int, mtrans::FM,
-        vstorage::SV, vbase::Int, vtrans::FV, g::G, bufM::Vector{Int}, bufC::Vector{Int},
-        blocklen::Int, vkbuf::Vector{Int}, alphaT::T, betaT::T, ::Val{W}
-    ) where {T, SM, FM, SV, FV, G <: AxisGroup, W}
+    matrix, vector = dot_operands(plan, Val(MATB))
+    mstorage, mbase, mtrans, g, (bufM, bufC), blocklen = matrix
+    vstorage, vbase, vtrans, vkbuf = vector
     Qf = axis_length(g)
-    Qk = axis_length(plan.kgroup)
-    kc_eff = plan.blocking.kc
+    k_length = axis_length(plan.kgroup)
+    k_block = plan.blocking.k_block
     Cstorage = plan.Cstorage
     cbase = plan.Cbase
     lenm = length(mstorage)
     lenv = length(vstorage)
     lenc = length(Cstorage)
-    mconj = _is_conj(mtrans)
-    vflip = _is_conj(vtrans) ⊻ mconj
-    NB = _dot_group_width(T)
+    # Conjugation is folded out of the kernel: `sum conj(m)*v == conj(sum m*conj(v))`,
+    # so a conjugated matrix becomes a flipped vector plus a `conj` per output.
+    mconj = op_conjugates(mtrans)
+    vflip = op_conjugates(vtrans) ⊻ mconj
+    NB = dot_group_width(T)
 
     GC.@preserve ws mstorage begin
-        gptr = reinterpret(Ptr{T}, pointer(ws.packed_a))
+        gptr = pointer(ws.dot_vector)
         mptr = pointer(mstorage)
-        pc = 0
-        firstblock = true
-        while pc < Qk
-            kblock = min(kc_eff, Qk - pc)
-            beta_eff = firstblock ? betaT : one(T)
-
-            fill_offsets!((ws.k_buf_A, ws.k_buf_B), plan.kgroup, pc, kblock)
-            checked_span_bounds(vbase, _buffer_range(vkbuf, kblock), (0, 0), lenv)
+        k_block_start = 0
+        first_k_block = true
+        while k_block_start < k_length
+            k_block_length = min(k_block, k_length - k_block_start)
+            beta_eff = first_k_block ? betaT : one(T)
+
+            fill_offsets!(ws.k, plan.kgroup, k_block_start, k_block_length)
+            checked_span_bounds(vbase, extrema(view(vkbuf, 1:k_block_length)), (0, 0), lenv)
             if vflip
-                _dot_gather!(gptr, vstorage, vbase, vkbuf, kblock, conj)
+                dot_gather!(gptr, vstorage, vbase, vkbuf, k_block_length, conj)
             else
-                _dot_gather!(gptr, vstorage, vbase, vkbuf, kblock, identity)
+                dot_gather!(gptr, vstorage, vbase, vkbuf, k_block_length, identity)
             end
 
             q0 = 0
             while q0 < Qf
                 qcount = min(blocklen, Qf - q0)
                 fill_offsets!((bufM, bufC), g, q0, qcount)
-                # The matrix's K offsets are `pc .. pc+kblock-1` (unit ramp).
-                checked_span_bounds(mbase, _buffer_range(bufM, qcount), (pc, pc + kblock - 1), lenm)
-                checked_span_bounds(cbase, _buffer_range(bufC, qcount), (0, 0), lenc)
+                # The matrix's K offsets are
+                # `k_block_start .. k_block_start+k_block_length-1` (unit ramp).
+                checked_span_bounds(mbase, extrema(view(bufM, 1:qcount)), (k_block_start, k_block_start + k_block_length - 1), lenm)
+                checked_span_bounds(cbase, extrema(view(bufC, 1:qcount)), (0, 0), lenc)
                 if mconj
-                    _dot_block!(
-                        Cstorage, cbase, bufC, mptr, mbase + pc, bufM, qcount, gptr, kblock,
+                    dot_block!(
+                        Cstorage, cbase, bufC, mptr, mbase + k_block_start, bufM, qcount, gptr, k_block_length,
                         alphaT, beta_eff, Val(W), Val(NB), Val(true)
                     )
                 else
-                    _dot_block!(
-                        Cstorage, cbase, bufC, mptr, mbase + pc, bufM, qcount, gptr, kblock,
+                    dot_block!(
+                        Cstorage, cbase, bufC, mptr, mbase + k_block_start, bufM, qcount, gptr, k_block_length,
                         alphaT, beta_eff, Val(W), Val(NB), Val(false)
                     )
                 end
                 q0 += qcount
             end
 
-            firstblock = false
-            pc += kblock
+            first_k_block = false
+            k_block_start += k_block_length
         end
     end
     return nothing
 end
 
+# The matrix side (B for `MATB`): storage, base, transform, free group, the
+# group's offset buffers and block length. The vector side: storage, base,
+# transform and K offsets.
+@inline dot_operands(plan::ContractPlan, ::Val{true}) = (
+    (plan.Bstorage, plan.Bbase, plan.btransform, plan.ngroup, plan.workspace.n.offsets, plan.blocking.n_block),
+    (plan.Astorage, plan.Abase, plan.atransform, plan.workspace.k[1]),
+)
+@inline dot_operands(plan::ContractPlan, ::Val{false}) = (
+    (plan.Astorage, plan.Abase, plan.atransform, plan.mgroup, plan.workspace.m.offsets, plan.blocking.m_block),
+    (plan.Bstorage, plan.Bbase, plan.btransform, plan.workspace.k[2]),
+)
+
 # Gather the transformed vector into `gptr`; for a complex `T` also its
-# pair-swapped copy at `gptr + kblock`, which gives the imaginary part without
-# a per-step shuffle.
-@inline function _dot_gather!(
-        gptr::Ptr{T}, vstorage::SV, vbase::Int, vkbuf::Vector{Int}, kblock::Int, transform::F
+# pair-swapped copy at `gptr + k_block_length`, which gives the imaginary part
+# without a per-step shuffle.
+@inline function dot_gather!(
+        gptr::Ptr{T}, vstorage::SV, vbase::Int, vkbuf::Vector{Int}, k_block_length::Int, transform::F
     ) where {T, SV, F}
-    @inbounds for t in 0:(kblock - 1)
+    @inbounds for t in 0:(k_block_length - 1)
         z = convert(T, transform(vstorage[vbase + vkbuf[t + 1] + 1]))
         unsafe_store!(gptr + sizeof(T) * t, z)
         if T <: Complex
-            unsafe_store!(gptr + sizeof(T) * (kblock + t), Complex(imag(z), real(z)))
+            unsafe_store!(gptr + sizeof(T) * (k_block_length + t), Complex(imag(z), real(z)))
         end
     end
     return nothing
@@ -185,19 +105,19 @@ end
 
 # One block of outputs, `NB` at a time. The last group's padding outputs alias
 # the last valid one (computed, never stored).
-@inline function _dot_block!(
+@inline function dot_block!(
         Cstorage::SC, cbase::Int, bufC::Vector{Int}, mptr::Ptr{T}, mbase_k::Int,
-        bufM::Vector{Int}, qcount::Int, gptr::Ptr{T}, kblock::Int,
+        bufM::Vector{Int}, qcount::Int, gptr::Ptr{T}, k_block_length::Int,
         alpha::T, beta::T, ::Val{W}, ::Val{NB}, ::Val{MCONJ}
     ) where {SC, T, W, NB, MCONJ}
     q = 0
     while q < qcount
         nvalid = min(NB, qcount - q)
-        mbases = _dot_bases(bufM, q, nvalid, mbase_k, Val(NB))
-        sums = _dot_group(mptr, gptr, mbases, kblock, Val(W), Val(NB))
+        mbases = dot_bases(bufM, q, nvalid, mbase_k, Val(NB))
+        sums = dot_group(mptr, gptr, mbases, k_block_length, Val(W), Val(NB))
         @inbounds for j in 1:nvalid
             s = MCONJ ? conj(sums[j]) : sums[j]
-            _axpby_at!(Cstorage, cbase + bufC[q + j] + 1, alpha, s, beta)
+            axpby_at!(Cstorage, cbase + bufC[q + j] + 1, alpha, s, static_beta(beta))
         end
         q += nvalid
     end
@@ -205,7 +125,7 @@ end
 end
 
 # A literal tuple: an `ntuple` closure over the loop-carried `q` would box it.
-@generated function _dot_bases(bufM::Vector{Int}, q::Int, nvalid::Int, mbase_k::Int, ::Val{NB}) where {NB}
+@generated function dot_bases(bufM::Vector{Int}, q::Int, nvalid::Int, mbase_k::Int, ::Val{NB}) where {NB}
     ex = [:(mbase_k + @inbounds(bufM[q + min($j, nvalid)])) for j in 1:NB]
     return quote
         Base.@_inline_meta
@@ -217,30 +137,30 @@ end
 # W-wide main loop, one masked tail step, a horizontal reduction. The step
 # bodies are `@generated` so every tuple index is a literal.
 
-@inline function _dot_group(
-        mptr::Ptr{T}, gptr::Ptr{T}, mbases::NTuple{NB, Int}, kblock::Int, ::Val{W}, ::Val{NB}
+@inline function dot_group(
+        mptr::Ptr{T}, gptr::Ptr{T}, mbases::NTuple{NB, Int}, k_block_length::Int, ::Val{W}, ::Val{NB}
     ) where {T <: Real, NB, W}
     accs = ntuple(_ -> zero(Vec{W, T}), Val(NB))
-    kmain = (kblock ÷ W) * W
+    kmain = (k_block_length ÷ W) * W
     t = 0
     while t < kmain
-        accs = _dot_step_real(accs, mptr, gptr, mbases, t, nothing)
+        accs = dot_step_real(accs, mptr, gptr, mbases, t, nothing)
         t += W
     end
     # Masked-off lanes are never read, so nothing past a row's end is touched.
-    if t < kblock
-        accs = _dot_step_real(accs, mptr, gptr, mbases, t, _dot_tailmask(Val(W), kblock - t))
+    if t < k_block_length
+        accs = dot_step_real(accs, mptr, gptr, mbases, t, dot_tailmask(Val(W), k_block_length - t))
     end
-    return _dot_reduce_real(accs)
+    return dot_reduce_real(accs)
 end
 
 # Lanes `0 .. rem-1` of a `W`-lane mask, `0 < rem < W`.
-@inline _dot_tailmask(::Val{W}, rem::Int) where {W} =
+@inline dot_tailmask(::Val{W}, rem::Int) where {W} =
     Vec{W, Int}(ntuple(i -> i - 1, Val(W))) < rem
 
 # `mask === nothing` for the main loop. Passed explicitly: a default argument
 # adds a non-inlined wrapper method.
-@generated function _dot_step_real(
+@generated function dot_step_real(
         accs::NTuple{NB, Vec{W, T}}, mptr::Ptr{T}, gptr::Ptr{T}, mbases::NTuple{NB, Int}, t::Int,
         mask::M
     ) where {NB, W, T, M}
@@ -256,7 +176,7 @@ end
     end
 end
 
-@generated function _dot_reduce_real(accs::NTuple{NB, Vec{W, T}}) where {NB, W, T}
+@generated function dot_reduce_real(accs::NTuple{NB, Vec{W, T}}) where {NB, W, T}
     ex = [:(sum(accs[$j])) for j in 1:NB]
     return quote
         Base.@_inline_meta
@@ -269,28 +189,28 @@ end
 #     P2 += m .* swap(v)  ->  im = sum(P2)
 # so two FMAs per matrix vector and no shuffle. `accs[NB+j]` is `P2_j`.
 
-@inline function _dot_group(
-        mptr::Ptr{T}, gptr::Ptr{T}, mbases::NTuple{NB, Int}, kblock::Int, ::Val{W}, ::Val{NB}
+@inline function dot_group(
+        mptr::Ptr{T}, gptr::Ptr{T}, mbases::NTuple{NB, Int}, k_block_length::Int, ::Val{W}, ::Val{NB}
     ) where {T <: Complex, NB, W}
     R = real(T)
     WC = W ÷ 2
     accs = ntuple(_ -> zero(Vec{W, R}), Val(2 * NB))
-    kmain = (kblock ÷ WC) * WC
+    kmain = (k_block_length ÷ WC) * WC
     t = 0
     while t < kmain
-        accs = _dot_step_cplx(accs, mptr, gptr, gptr + sizeof(T) * kblock, mbases, t, nothing)
+        accs = dot_step_cplx(accs, mptr, gptr, gptr + sizeof(T) * k_block_length, mbases, t, nothing)
         t += WC
     end
-    if t < kblock
-        accs = _dot_step_cplx(
-            accs, mptr, gptr, gptr + sizeof(T) * kblock, mbases, t,
-            _dot_tailmask(Val(W), 2 * (kblock - t))
+    if t < k_block_length
+        accs = dot_step_cplx(
+            accs, mptr, gptr, gptr + sizeof(T) * k_block_length, mbases, t,
+            dot_tailmask(Val(W), 2 * (k_block_length - t))
         )
     end
-    return _dot_reduce_cplx(accs, T)
+    return dot_reduce_cplx(accs, T)
 end
 
-@generated function _dot_step_cplx(
+@generated function dot_step_cplx(
         accs::NTuple{NA, Vec{W, R}}, mptr::Ptr{T}, gptr::Ptr{T}, gsptr::Ptr{T},
         mbases::NTuple{NB, Int}, t::Int, mask::M
     ) where {NA, W, R, T, NB, M}
@@ -311,7 +231,7 @@ end
     end
 end
 
-@generated function _dot_reduce_cplx(accs::NTuple{NA, Vec{W, R}}, ::Type{T}) where {NA, W, R, T}
+@generated function dot_reduce_cplx(accs::NTuple{NA, Vec{W, R}}, ::Type{T}) where {NA, W, R, T}
     NB = NA ÷ 2
     sgn = ntuple(i -> isodd(i) ? one(R) : -one(R), W)
     ex = [:(Complex(sum(accs[$j] * SGN), sum(accs[$(NB + j)]))) for j in 1:NB]
diff --git a/src/execution/execute.jl b/src/execution/execute.jl
index 51ad95a..691f0cc 100644
--- a/src/execution/execute.jl
+++ b/src/execution/execute.jl
@@ -1,28 +1,3 @@
-# `C *= beta` tile by tile, never reading A or B: the `Qk == 0 || alpha == 0`
-# pass of `execute!` and `execute_tilewise!`. Uses the MR/NR-sized `tile_*`
-# buffers, which is why those exist even under `oracle = false`.
-function _scale_all_of_C!(plan, betaT::T, MRk::Int, NRk::Int, Qm::Int, Qn::Int) where {T}
-    ws = plan.workspace
-    m_bufs = (ws.tile_m_buf_A, ws.tile_m_buf_C)
-    n_bufs = (ws.tile_n_buf_B, ws.tile_n_buf_C)
-    mfirst = 0
-    while mfirst < Qm
-        mcount = min(MRk, Qm - mfirst)
-        (_, dM_C) = block_descriptors!(m_bufs, plan.mgroup, mfirst, mcount)
-        rowsC = _axis_of(dM_C, ws.tile_m_buf_C, 0)
-        nfirst = 0
-        while nfirst < Qn
-            ncount = min(NRk, Qn - nfirst)
-            (_, dN_C) = block_descriptors!(n_bufs, plan.ngroup, nfirst, ncount)
-            colsC = _axis_of(dN_C, ws.tile_n_buf_C, 0)
-            _scale_micro_tile!(plan.Cstorage, plan.Cbase, rowsC, colsC, betaT)
-            nfirst += ncount
-        end
-        mfirst += mcount
-    end
-    return nothing
-end
-
 """
     execute!(plan::ContractPlan, alpha::Number, beta::Number)
 
@@ -36,442 +11,56 @@ block. Allocation-free.
 function execute!(plan::ContractPlan{T}, alpha::Number, beta::Number) where {T}
     alphaT = convert(T, alpha)
     betaT = convert(T, beta)
-    _execute_short_circuit!(plan, alphaT, betaT) && return plan.Cstorage
-    _execute_across_barrier!(plan, alphaT, betaT, _select_path(plan))
-    return plan.Cstorage
-end
-
-# The short-circuits every path shares; `true` when the call is finished.
-@inline function _execute_short_circuit!(plan::ContractPlan{T}, alphaT::T, betaT::T) where {T}
-    Qm = axis_length(plan.mgroup)
-    Qn = axis_length(plan.ngroup)
-    (Qm == 0 || Qn == 0) && return true
-    if axis_length(plan.kgroup) == 0 || iszero(alphaT)
-        _scale_all_of_C!(plan, betaT, mr(plan.kernel), nr(plan.kernel), Qm, Qn)
-        return true
-    end
-    return false
-end
-
-# The path `execute!` runs past its short-circuits: the dot path, else the
-# outer-product path, else the nest (B packed or read in place).
-@inline _select_path(plan::ContractPlan{T}) where {T} = _select_path(
-    T, _unpacked_b_kernel_eligible(plan.kernel),
-    plan.Astorage, plan.Bstorage, plan.Cstorage, plan.mgroup, plan.ngroup, plan.kgroup, plan,
-    plan.blocking.kc, _is_split(plan.mpack), _is_split(plan.npack)
-)
-
-# On the plan's parts, so `plan_contract` can predict the path before the
-# plan exists (`_path_hint`). `unpack_ok`: the kernel admits unpacked B.
-# `capacity`: the plan whose workspace must hold the dot path's vector, or
-# `nothing` to assume it does. `kc`: the requested K block, `nothing` for
-# the default. `split_a`/`split_b`: the plan packs A/B line by line.
-@inline function _select_path(
-        ::Type{T}, unpack_ok::Bool, Astorage, Bstorage, Cstorage,
-        mgroup::AxisGroup, ngroup::AxisGroup, kgroup::AxisGroup, capacity, kc,
-        split_a::Bool = false, split_b::Bool = false
-    ) where {T}
-    Qm = axis_length(mgroup)
-    Qn = axis_length(ngroup)
-    Qk = axis_length(kgroup)
-    panel = _c_panel_needed(T, Cstorage, Qk, kc)
-    if (Qm == 1 || Qn == 1) && !panel && _dot_applicable(T, Astorage, Bstorage, kgroup, Qm, Qn, Qk) &&
-            _dot_capacity_ok(capacity)
-        W = _dot_lanewidth(T)
-        return Qm == 1 ? _lane_path(_DotPath{true}, W) : _lane_path(_DotPath{false}, W)
-    end
-    Qk == 1 && _outer_applicable(T, Astorage, Cstorage, mgroup, Qm) &&
-        return _lane_path(_OuterPath, _dot_lanewidth(T))
-    return _nest_path(
-        unpack_ok && _unpacked_b_rule(mgroup, kgroup), mgroup, ngroup, kgroup, split_a, split_b, panel
-    )
-end
-
-# Whether the partial sums between K blocks must live in a compute-type panel
-# rather than in a C of narrower eltype. Static `false` unless C is narrower,
-# so the default blocking is looked up only then.
-@inline function _c_panel_needed(::Type{T}, Cstorage, Qk::Int, kc) where {T}
-    sizeof(real(eltype(Cstorage))) < sizeof(real(T)) || return false
-    return Qk > (kc === nothing ? _resolved_defaults(T).real_row.kc : kc)
-end
-
-# Run `path` behind a dynamic call. The plan crosses in the workspace slot
-# with its storages stripped; they cross as arguments.
-@inline function _execute_across_barrier!(plan::ContractPlan{T}, alphaT::T, betaT::T, path) where {T}
-    core = _strip_storage(plan)
-    slot = _barrier_slot!(plan.workspace, Tuple{typeof(core), T, T})
-    slot[] = (core, alphaT, betaT)
-    Base.inferencebarrier(_execute_resolved!)(
-        path, slot, plan.Astorage, plan.Bstorage, plan.Cstorage
-    )
-    return nothing
-end
-
-function _execute_resolved!(
-        path::P, slot::Base.RefValue{Tuple{R, T, T}}, Astorage::SA, Bstorage::SB, Cstorage::SC
-    ) where {P, R <: ContractPlan, T, SA, SB, SC}
-    core, alphaT, betaT = slot[]
-    _execute_path!(_with_storage(core, Astorage, Bstorage, Cstorage), alphaT, betaT, path)
-    return nothing
-end
-
-@inline _strip_storage(p::ContractPlan) = ContractPlan(
-    p.kernel, p.mgroup, p.ngroup, p.kgroup, p.blocking,
-    nothing, p.Abase, nothing, p.Bbase, nothing, p.Cbase,
-    p.atransform, p.btransform, p.workspace, p.mpack, p.npack
-)
-@inline _with_storage(p::ContractPlan, Astorage, Bstorage, Cstorage) = ContractPlan(
-    p.kernel, p.mgroup, p.ngroup, p.kgroup, p.blocking,
-    Astorage, p.Abase, Bstorage, p.Bbase, Cstorage, p.Cbase,
-    p.atransform, p.btransform, p.workspace, p.mpack, p.npack
-)
-
-# The continuation the TensorOperations adapter hands `_planned`: `execute!`
-# inside the planning barrier. A struct, not a closure, so the scalars are
-# concretely typed.
-struct _Execute{T}
-    alpha::T
-    beta::T
-end
-(e::_Execute)(plan::ContractPlan) = (execute!(plan, e.alpha, e.beta); nothing)
-
-# The path predicted before the kernel barrier, so its callee is specialised
-# on the path as well as the kernel.
-@inline _path_hint(::_Execute, req::_PlanRequest{T}, unpack_ok::Bool) where {T} = _select_path(
-    T, unpack_ok,
-    req.Astorage, req.Bstorage, req.Cstorage, req.mgroup, req.ngroup, req.kgroup, nothing,
-    req.kc
-)
-
-@inline _continue(e::_Execute{T}, plan::ContractPlan{T}, hint) where {T} =
-    (_execute_hinted!(plan, e.alpha, e.beta, hint); nothing)
-@inline _continue(e::_Execute{T}, plan::ContractPlan{T}, ::Nothing) where {T} =
-    (execute!(plan, e.alpha, e.beta); nothing)
-
-# Runs the predicted path statically when it provably equals the plan's own
-# `_select_path` (always, for an automatically chosen kernel); otherwise
-# falls back to `execute!`'s barrier. The prediction assumes no split, so a
-# split plan crosses the barrier to its own nest path.
-@inline function _execute_hinted!(plan::ContractPlan{T}, alphaT::T, betaT::T, hint) where {T}
-    _execute_short_circuit!(plan, alphaT, betaT) && return nothing
-    if !_hint_holds(plan, hint)
-        _execute_across_barrier!(plan, alphaT, betaT, _select_path(plan))
-    elseif _splits(plan, hint)
-        _execute_across_barrier!(plan, alphaT, betaT, _split_path(plan, hint))
+    if iszero(alphaT)
+        scale_all_of_C!(plan, betaT)
     else
-        _execute_path!(plan, alphaT, betaT, hint)
+        execute_path!(plan, alphaT, betaT, plan.path)
     end
-    return nothing
+    return plan.Cstorage
 end
 
-@inline _splits(plan::ContractPlan, hint) = false
-@inline _splits(plan::ContractPlan, ::Union{_NestPath, _PanelPath}) = _is_split(plan.mpack) || _is_split(plan.npack)
-@inline _split_path(plan::ContractPlan, ::_NestPath{U}) where {U} = _nest_path(
-    U, plan.mgroup, plan.ngroup, plan.kgroup, _is_split(plan.mpack), _is_split(plan.npack)
-)
-@inline _split_path(plan::ContractPlan, ::_PanelPath{<:_NestPath{U}}) where {U} = _nest_path(
-    U, plan.mgroup, plan.ngroup, plan.kgroup, _is_split(plan.mpack), _is_split(plan.npack), true
-)
+execute_path!(plan::ContractPlan, alphaT, betaT, ::EmptyPath) = nothing
 
-# The prediction differs from `_select_path(plan)` in three inputs only: the
-# kernel's unpacked-B eligibility (predicted from its method; folds), the
-# dot path's workspace capacity (assumed) and the panel decision (made at the
-# default `kc`; folds to `false` unless C is narrower than `T`).
-@inline _hint_holds(plan::ContractPlan{T}, path::Union{_NestPath, _PanelPath}) where {T} =
-    _c_panel_needed(T, plan.Cstorage, axis_length(plan.kgroup), plan.blocking.kc) === (path isa _PanelPath) &&
-    _unpacked_b_method_eligible(complex_method(plan.kernel)) === _unpacked_b_kernel_eligible(plan.kernel)
-@inline _hint_holds(plan::ContractPlan, ::_DotPath) = _dot_capacity_ok(plan)
-@inline _hint_holds(plan::ContractPlan, ::_OuterPath) = true
+execute_path!(plan::ContractPlan, alphaT, betaT, ::ScalePath) = scale_all_of_C!(plan, betaT)
 
-_execute_path!(plan::ContractPlan, alphaT, betaT, ::_DotPath{MATB, W}) where {MATB, W} =
-    (_execute_dot!(plan, alphaT, betaT, MATB, Val(W)); nothing)
-
-_execute_path!(plan::ContractPlan, alphaT, betaT, ::_OuterPath{W}) where {W} = (
-    _execute_outer!(
-        plan, alphaT, betaT, axis_length(plan.mgroup), axis_length(plan.ngroup), Val(W)
-    ); nothing
-)
-
-function _execute_path!(
-        plan::ContractPlan{T}, alphaT::T, betaT::T, path::_NestPath
-    ) where {T}
-    kernel = plan.kernel
+function execute_path!(plan::ContractPlan{T}, alphaT::T, betaT::T, path::NestPath) where {T}
     ws = plan.workspace
-    # Panels and `PtrScatterAxis`es borrow pointers into `ws`.
-    GC.@preserve ws begin
-        _execute_nest!(
-            plan, ws, kernel, mr(kernel), nr(kernel),
-            axis_length(plan.mgroup), axis_length(plan.ngroup), axis_length(plan.kgroup),
-            plan.blocking.mc, plan.blocking.kc, plan.blocking.nc, alphaT, betaT, path, nothing
-        )
-    end
+    GC.@preserve ws nest!(plan, alphaT, betaT, path, 0:(axis_length(plan.ngroup) - 1))
     return nothing
 end
 
-# The nest over `pplan`, a copy of `plan` whose C is the workspace panel with
-# dense M/N maps, one `jc` block at a time: `_panel_enter!` loads the block of
-# C into the panel and `_panel_exit!` rounds it back.
-function _execute_path!(
-        plan::ContractPlan{T}, alphaT::T, betaT::T, ::_PanelPath{P}
-    ) where {T, P}
-    kernel = plan.kernel
+# `C *= beta` tile by tile, never reading A or B. Borrows the first tile of the
+# M/N offset buffers.
+function scale_all_of_C!(plan::ContractPlan{T}, betaT::T) where {T}
     ws = plan.workspace
-    Qm = axis_length(plan.mgroup)
-    pplan = ContractPlan(
-        kernel, _dense_second_map(plan.mgroup, 1), _dense_second_map(plan.ngroup, Qm),
-        plan.kgroup, plan.blocking, plan.Astorage, plan.Abase, plan.Bstorage, plan.Bbase,
-        ws.c_panel, 0, plan.atransform, plan.btransform, ws, plan.mpack, plan.npack
-    )
-    GC.@preserve ws begin
-        _execute_nest!(
-            pplan, ws, kernel, mr(kernel), nr(kernel),
-            Qm, axis_length(plan.ngroup), axis_length(plan.kgroup),
-            plan.blocking.mc, plan.blocking.kc, plan.blocking.nc, alphaT, betaT, P(), plan
-        )
-    end
-    return nothing
-end
-
-# `g` with its second map replaced by the column-major one scaled by `step`.
-@inline function _dense_second_map(g::AxisGroup{D, 2}, step::Int) where {D}
-    dense = ntuple(d -> step * _unchecked_axis_length(ntuple(i -> i < d ? g.lengths[i] : 1, Val(D))), Val(D))
-    return AxisGroup(g.lengths, (g.strides[1], dense))
-end
-
-# `target`: `nothing`, or the plan whose C the panel stands in for.
-@inline _panel_enter!(::Nothing, plan, jc, nblock, betaT) = plan
-@inline _panel_exit!(::Nothing, jc, nblock) = nothing
-
-function _panel_enter!(target::ContractPlan, plan::ContractPlan, jc::Int, nblock::Int, betaT)
-    iszero(betaT) || _panel_copy!(target, jc, nblock, true)
-    return ContractPlan(
-        plan.kernel, plan.mgroup, plan.ngroup, plan.kgroup, plan.blocking,
-        plan.Astorage, plan.Abase, plan.Bstorage, plan.Bbase, plan.Cstorage,
-        -jc * axis_length(plan.mgroup), plan.atransform, plan.btransform, plan.workspace,
-        plan.mpack, plan.npack
-    )
-end
-
-_panel_exit!(target::ContractPlan, jc::Int, nblock::Int) = _panel_copy!(target, jc, nblock, false)
-
-# Columns `jc .+ (0:nblock-1)` of `target`'s C into (`load`) or out of the
-# panel, converting to the destination's eltype. Borrows the M/N offset
-# buffers, which the nest refills before reading them again.
-function _panel_copy!(target::ContractPlan, jc::Int, nblock::Int, load::Bool)
-    ws = target.workspace
-    panel = ws.c_panel
-    C = target.Cstorage
-    Qm = axis_length(target.mgroup)
-    mc = target.blocking.mc
-    fill_offsets!((ws.n_buf_B, ws.n_buf_C), target.ngroup, jc, nblock)
-    ic = 0
-    while ic < Qm
-        mblock = min(mc, Qm - ic)
-        fill_offsets!((ws.m_buf_A, ws.m_buf_C), target.mgroup, ic, mblock)
-        for j in 1:nblock, i in 1:mblock
-            c = target.Cbase + ws.m_buf_C[i] + ws.n_buf_C[j] + 1
-            q = ic + i + (j - 1) * Qm
-            if load
-                panel[q] = C[c]
-            else
-                C[c] = panel[q]
-            end
+    m_tile, n_tile = tile_size(plan.kernel)
+    m_length = axis_length(plan.mgroup)
+    n_length = axis_length(plan.ngroup)
+    m_bufs = ws.m.offsets
+    n_bufs = ws.n.offsets
+    m_tile_start = 0
+    while m_tile_start < m_length
+        m_tile_length = min(m_tile, m_length - m_tile_start)
+        (_, dM_C) = block_descriptors!(m_bufs, plan.mgroup, m_tile_start, m_tile_length)
+        n_tile_start = 0
+        while n_tile_start < n_length
+            n_tile_length = min(n_tile, n_length - n_tile_start)
+            (_, dN_C) = block_descriptors!(n_bufs, plan.ngroup, n_tile_start, n_tile_length)
+            rowsC = axis_of(dM_C, m_bufs[2], 0)
+            colsC = axis_of(dN_C, n_bufs[2], 0)
+            GC.@preserve ws scale_micro_tile!(plan.Cstorage, plan.Cbase, rowsC, colsC, betaT)
+            n_tile_start += n_tile_length
         end
-        ic += mblock
+        m_tile_start += m_tile_length
     end
     return nothing
 end
 
-function _execute_nest!(
-        plan::ContractPlan{T}, ws, kernel::K, MRk::Int, NRk::Int,
-        Qm::Int, Qn::Int, Qk::Int, mc_eff::Int, kc_eff::Int, nc_eff::Int,
-        alphaT::T, betaT::T, ::_NestPath{UNPACKED_B, AFF, SPLIT}, target
-    ) where {T, K, UNPACKED_B, AFF, SPLIT}
-    # GUARDRAIL: reals per sliver per K step address the packed panels;
-    # `MRk`/`NRk` count register-tile rows. They differ for complex kernels.
-    MRp = packed_a_per_k(kernel)
-    NRp = packed_b_per_k(kernel)
-
-    atransform = plan.atransform
-    btransform = plan.btransform
-
-    split_a, split_b = SPLIT
-    mgroup = split_a ? _split_group(plan.mgroup, plan.mpack) : plan.mgroup
-    ngroup = split_b ? _split_group(plan.ngroup, plan.npack) : plan.ngroup
-
-    # Ramp composites get closed-form block descriptors, no offset buffers; the
-    # block pack reads the offsets.
-    (m_ramp, m_step) = affine_ramp(mgroup)
-    (n_ramp, n_step) = affine_ramp(ngroup)
-    m_ramp &= !split_a
-    n_ramp &= !split_b
-    (k_ramp, k_step) = affine_ramp(plan.kgroup)
-
-    lenA = length(plan.Astorage)
-    lenB = length(plan.Bstorage)
-    lenC = length(plan.Cstorage)
-
-    aff_mA, aff_mC, aff_nB, aff_nC, aff_kA, aff_kB = map(Val, AFF)
-
-    # --- loop 5: jc over N in steps of nc_eff ---
-    jc = 0
-    while jc < Qn
-        nblock = min(nc_eff, Qn - jc)
-        cplan = _panel_enter!(target, plan, jc, nblock, betaT)
-        n_slivers = cld(nblock, NRk)
-        (rng_nB, rng_nC) = if n_ramp
-            _ramp_slivers!(
-                ws.n_desc_B, ws.n_desc_C, n_step[1], n_step[2], jc,
-                nblock, NRk, n_slivers
-            )
-        else
-            fill_offsets!((ws.n_buf_B, ws.n_buf_C), ngroup, jc, nblock)
-            _classify_slivers!(
-                ws.n_desc_B, ws.n_desc_C, ws.n_buf_B, ws.n_buf_C,
-                nblock, NRk, n_slivers
-            )
-        end
-
-        # --- loop 4: pc over K in steps of kc_eff ---
-        pc = 0
-        firstpanel = true
-        while pc < Qk
-            kblock = min(kc_eff, Qk - pc)
-            dK_A, dK_B, rng_kA, rng_kB = if k_ramp
-                (
-                    _ramp_descriptor(k_step[1], pc, kblock),
-                    _ramp_descriptor(k_step[2], pc, kblock),
-                    _ramp_offset_range(k_step[1], pc, kblock),
-                    _ramp_offset_range(k_step[2], pc, kblock),
-                )
-            else
-                fill_offsets!((ws.k_buf_A, ws.k_buf_B), plan.kgroup, pc, kblock)
-                dA = describe_block(ws.k_buf_A, 0, kblock)
-                dB = describe_block(ws.k_buf_B, 0, kblock)
-                (
-                    dA, dB,
-                    descriptor_offset_range(dA, ws.k_buf_A, 0),
-                    descriptor_offset_range(dB, ws.k_buf_B, 0),
-                )
-            end
-            colsA_k = _axis_of(dK_A, ws.k_buf_A, 0, aff_kA)
-            rowsB_k = _axis_of(dK_B, ws.k_buf_B, 0, aff_kB)
-
-            # Hoisted bounds checks (B here, A and C per ic block): each
-            # rectangle is exactly the union of the per-sliver/per-tile
-            # regions, so the `unsafe_*` calls below read nothing unchecked.
-            checked_span_bounds(plan.Bbase, rng_kB, rng_nB, lenB)
-
-            beta_eff = firstpanel ? betaT : one(T)
-
-            if split_b
-                _pack_block_transposed!(
-                    packed_b_plane_offset, b_format(kernel),
-                    packed_panel(ws.packed_b, 1, NRp * kblock * n_slivers), kernel, Val(nr(kernel)), NRp,
-                    plan.Bstorage, plan.Bbase, ws.n_buf_B, rowsB_k, btransform, nblock, kblock,
-                    plan.npack
-                )
-            elseif !UNPACKED_B
-                for s in 0:(n_slivers - 1)
-                    sfirst = s * NRk
-                    colsB = _axis_of(ws.n_desc_B[s + 1], ws.n_buf_B, sfirst, aff_nB)
-                    bpanel = _sliver_panel(ws.packed_b, NRp, kblock, s)
-                    _pack_sliver!(
-                        unsafe_pack_b!, bpanel, plan.Bstorage, plan.Bbase, rowsB_k, colsB,
-                        kernel, btransform
-                    )
-                end
-            end
-
-            # --- loop 3: ic over M in steps of mc_eff ---
-            ic = 0
-            while ic < Qm
-                mblock = min(mc_eff, Qm - ic)
-                m_slivers = cld(mblock, MRk)
-                (rng_mA, rng_mC) = if m_ramp
-                    _ramp_slivers!(
-                        ws.m_desc_A, ws.m_desc_C, m_step[1], m_step[2], ic,
-                        mblock, MRk, m_slivers
-                    )
-                else
-                    fill_offsets!((ws.m_buf_A, ws.m_buf_C), mgroup, ic, mblock)
-                    _classify_slivers!(
-                        ws.m_desc_A, ws.m_desc_C, ws.m_buf_A, ws.m_buf_C,
-                        mblock, MRk, m_slivers
-                    )
-                end
-
-                checked_span_bounds(plan.Abase, rng_mA, rng_kA, lenA)
-                checked_span_bounds(cplan.Cbase, rng_mC, rng_nC, lenC)
-
-                if split_a
-                    _pack_block_transposed!(
-                        packed_a_plane_offset, a_format(kernel),
-                        packed_panel(ws.packed_a, 1, MRp * kblock * m_slivers), kernel, Val(mr(kernel)), MRp,
-                        plan.Astorage, plan.Abase, ws.m_buf_A, colsA_k, atransform, mblock, kblock,
-                        plan.mpack
-                    )
-                else
-                    for r in 0:(m_slivers - 1)
-                        rfirst = r * MRk
-                        rowsA = _axis_of(ws.m_desc_A[r + 1], ws.m_buf_A, rfirst, aff_mA)
-                        apanel = _sliver_panel(ws.packed_a, MRp, kblock, r)
-                        _pack_sliver!(
-                            unsafe_pack_a!, apanel, plan.Astorage, plan.Abase, rowsA, colsA_k,
-                            kernel, atransform
-                        )
-                    end
-                end
-
-                # --- loop 2: jr over N-slivers; loop 1: ir over M-slivers ---
-                if UNPACKED_B
-                    _micro_tiles_unpacked_b!(
-                        kernel, cplan, ws, rowsB_k, m_slivers, n_slivers,
-                        MRk, NRk, MRp, kblock, alphaT, beta_eff, aff_mC, aff_nC
-                    )
-                else
-                    _micro_tiles_packed_b!(
-                        kernel, cplan, ws, m_slivers, n_slivers,
-                        MRk, NRk, MRp, NRp, kblock, alphaT, beta_eff, aff_mC, aff_nC
-                    )
-                end
-
-                ic += mblock
-            end
-
-            firstpanel = false
-            pc += kblock
-        end
-
-        _panel_exit!(target, jc, nblock)
-        jc += nblock
-    end
-
-    return plan.Cstorage
-end
-
-# Loops 2/1 over one (jc, pc, ic) block. `@noinline`: one call per block, and
-# the inlined microkernel is most of a nest's size; compile cost grows faster
-# than linearly with function size.
-@noinline function _micro_tiles_packed_b!(
-        kernel::K, plan::ContractPlan, ws, m_slivers::Int, n_slivers::Int,
-        MRk::Int, NRk::Int, MRp::Int, NRp::Int, kblock::Int, alphaT, beta_eff,
-        aff_mC::Val{MC}, aff_nC::Val{NC}
-    ) where {K, MC, NC}
-    for s in 0:(n_slivers - 1)
-        sfirst = s * NRk
-        colsC = _axis_of(ws.n_desc_C[s + 1], ws.n_buf_C, sfirst, aff_nC)
-        bpanel = _sliver_panel(ws.packed_b, NRp, kblock, s)
-        for r in 0:(m_slivers - 1)
-            rfirst = r * MRk
-            rowsC = _axis_of(ws.m_desc_C[r + 1], ws.m_buf_C, rfirst, aff_mC)
-            apanel = _sliver_panel(ws.packed_a, MRp, kblock, r)
-            unsafe_execute_micro_tile!(
-                kernel, plan.Cstorage, plan.Cbase, rowsC, colsC,
-                apanel, bpanel, kblock, alphaT, beta_eff
-            )
-        end
-    end
+@inline function scale_micro_tile!(
+        storage::S, base::Int, rows::R, cols::C, beta
+    ) where {S, R <: AbstractVector{Int}, C <: AbstractVector{Int}}
+    destination = Tile(storage, base, rows, cols)
+    scale_tile!(destination, beta)
     return nothing
 end
 
@@ -500,7 +89,7 @@ function contract!(
         indC::NTuple{NC, Int};
         accumulator::Union{Nothing, Type{Float32}, Type{Float64}} = nothing
     ) where {NA, NB, NC}
-    plan = plan_contract(C, A, indA, B, indB, indC; accumulator)
-    execute!(plan, alpha, beta)
+    T = compute_type(eltype(A), eltype(B), eltype(C), accumulator)
+    planned(C, A, indA, B, indB, indC, convert(T, alpha), convert(T, beta); accumulator)
     return C
 end
diff --git a/src/execution/macrokernel.jl b/src/execution/macrokernel.jl
deleted file mode 100644
index 8fc0f87..0000000
--- a/src/execution/macrokernel.jl
+++ /dev/null
@@ -1,132 +0,0 @@
-# Macro-kernel helpers for the five-loop nest: function barriers over the
-# tile axis types, packed-sliver addressing, and sliver classification.
-
-# GUARDRAIL: `_axis_of` returns a `Union{AffineAxis,PtrScatterAxis}` (both
-# isbits, so unboxed), and each consumer below is a barrier specialised per
-# concrete axis type, so no partially-typed, heap-boxed `QSTile` is ever
-# built. Do not inline these helpers into their callers.
-@inline function _axis_of(d::BlockDescriptor, buffer::Vector{Int}, first::Int)
-    return d.regular ? AffineAxis(d.base, d.stride, d.count) :
-        PtrScatterAxis(pointer(buffer, first + 1), d.count)
-end
-
-# The same with the axis type fixed by the path: `Val(true)` for a ramp map,
-# whose descriptors are always regular (checked).
-@inline _axis_of(d::BlockDescriptor, buffer::Vector{Int}, first::Int, ::Val{false}) =
-    _axis_of(d, buffer, first)
-@inline function _axis_of(d::BlockDescriptor, ::Vector{Int}, ::Int, ::Val{true})
-    d.regular || _throw_irregular_ramp_descriptor()
-    return AffineAxis(d.base, d.stride, d.count)
-end
-@noinline _throw_irregular_ramp_descriptor() =
-    throw(AssertionError("an affine-ramp map produced an irregular block descriptor"))
-
-# `pack!` is one of pack_a!/pack_b!/unsafe_pack_a!/unsafe_pack_b!; call sites
-# spell the unsafe name out. GUARDRAIL: `transform` needs its own bound type
-# parameter, or it costs a dynamic dispatch per call (see `pack_a!`).
-@inline function _pack_sliver!(
-        pack!::PF, packed::PK, storage::S, base::Int,
-        rows::R, cols::C, kernel, transform::TF
-    ) where {PF, PK, S, R <: Axis, C <: Axis, TF}
-    pack!(packed, SourceTile(storage, base, rows, cols), kernel, transform)
-    return nothing
-end
-
-@inline function _execute_micro_tile!(
-        kernel, storage::S, base::Int, rows::R, cols::C,
-        packed_a::PA, packed_b::PB, kc_len::Int, alpha, beta
-    ) where {PA, PB, S, R <: Axis, C <: Axis}
-    destination = DestinationTile(storage, base, rows, cols)
-    execute_tile!(kernel, destination, packed_a, packed_b, kc_len, alpha, beta)
-    return nothing
-end
-
-# The caller has bounds-checked the whole macro block this tile belongs to.
-@inline function unsafe_execute_micro_tile!(
-        kernel, storage::S, base::Int, rows::R, cols::C,
-        packed_a::PA, packed_b::PB, kc_len::Int, alpha, beta
-    ) where {PA, PB, S, R <: Axis, C <: Axis}
-    destination = DestinationTile(storage, base, rows, cols)
-    unsafe_execute_tile!(kernel, destination, packed_a, packed_b, kc_len, alpha, beta)
-    return nothing
-end
-
-@inline function _scale_micro_tile!(
-        storage::S, base::Int, rows::R, cols::C, beta
-    ) where {S, R <: Axis, C <: Axis}
-    destination = DestinationTile(storage, base, rows, cols)
-    scale_tile!(destination, beta)
-    return nothing
-end
-
-# Sliver `s` of a packed panel at the current block's depth `kc_len`, shared by
-# the packing and the consuming step so the two cannot disagree. GUARDRAIL:
-# `reg_tile` counts reals per K step (`packed_a_per_k`), not `mr`; they differ
-# for complex kernels.
-@inline function _sliver_panel(buffer, reg_tile::Int, kc_len::Int, s::Int)
-    stride = reg_tile * kc_len
-    return packed_panel(buffer, s * stride + 1, stride)
-end
-
-# Classify each register sliver of a just-filled macro block, and return the
-# two maps' offset ranges over the whole block (the slivers partition it) for
-# the hoisted bounds checks.
-@inline function _classify_slivers!(
-        desc1::Vector{BlockDescriptor}, desc2::Vector{BlockDescriptor},
-        buf1::Vector{Int}, buf2::Vector{Int},
-        blocklen::Int, reg_tile::Int, nslivers::Int
-    )
-    lo1 = typemax(Int); hi1 = typemin(Int)
-    lo2 = typemax(Int); hi2 = typemin(Int)
-    for s in 0:(nslivers - 1)
-        sfirst = s * reg_tile
-        scount = min(reg_tile, blocklen - sfirst)
-        d1 = describe_block(buf1, sfirst, scount)
-        d2 = describe_block(buf2, sfirst, scount)
-        desc1[s + 1] = d1
-        desc2[s + 1] = d2
-        (l1, h1) = descriptor_offset_range(d1, buf1, sfirst)
-        if h1 >= l1
-            lo1 = min(lo1, l1); hi1 = max(hi1, h1)
-        end
-        (l2, h2) = descriptor_offset_range(d2, buf2, sfirst)
-        if h2 >= l2
-            lo2 = min(lo2, l2); hi2 = max(hi2, h2)
-        end
-    end
-    # `hi < lo` means empty to `checked_span_bounds`.
-    return ((lo1, hi1), (lo2, hi2))
-end
-
-# Closed-form block descriptors for an affine-ramp composite (offset of `q`
-# is `q * step`), with no offset buffer or scan. `==` to what `describe_block`
-# gives for the materialized interval, including its `stride == 0` for a
-# count-1 block.
-@inline _ramp_descriptor(step::Int, first::Int, count::Int) =
-    count == 0 ? BlockDescriptor(0, 0, 0, true) :
-    count == 1 ? BlockDescriptor(first * step, 0, 1, true) :
-    BlockDescriptor(first * step, step, count, true)
-
-# Offset range of `[first, first+count)`; `(0, -1)` if empty. Cannot overflow:
-# `AxisGroup` validated every in-domain offset at construction.
-@inline _ramp_offset_range(step::Int, first::Int, count::Int) =
-    count == 0 ? (0, -1) : minmax(first * step, (first + count - 1) * step)
-
-# `_classify_slivers!`'s closed-form twin.
-@inline function _ramp_slivers!(
-        desc1::Vector{BlockDescriptor}, desc2::Vector{BlockDescriptor},
-        step1::Int, step2::Int, first::Int,
-        blocklen::Int, reg_tile::Int, nslivers::Int
-    )
-    for s in 0:(nslivers - 1)
-        sfirst = s * reg_tile
-        scount = min(reg_tile, blocklen - sfirst)
-        q0 = first + sfirst
-        desc1[s + 1] = _ramp_descriptor(step1, q0, scount)
-        desc2[s + 1] = _ramp_descriptor(step2, q0, scount)
-    end
-    return (
-        _ramp_offset_range(step1, first, blocklen),
-        _ramp_offset_range(step2, first, blocklen),
-    )
-end
diff --git a/src/execution/nest.jl b/src/execution/nest.jl
new file mode 100644
index 0000000..928e9d8
--- /dev/null
+++ b/src/execution/nest.jl
@@ -0,0 +1,310 @@
+# The five-loop nest and its helpers: function barriers over the tile axis
+# types, block packing, packed-sliver addressing and sliver classification.
+
+# The nest over the N coordinates `n_range`, in N blocks from its start. The
+# caller preserves `plan.workspace`: packed panels and scatter axes borrow
+# pointers into it.
+function nest!(
+        plan::ContractPlan{T}, alphaT::T, betaT::T, path::NestPath{UNPACKED_B, AFF, SPLIT},
+        n_range::UnitRange{Int}
+    ) where {T, UNPACKED_B, AFF, SPLIT}
+    kernel = plan.kernel
+    ws = plan.workspace
+    m_tile, n_tile = tile_size(kernel)
+    (; m_block, k_block, n_block) = plan.blocking
+    m_length = axis_length(plan.mgroup)
+    k_length = axis_length(plan.kgroup)
+
+    split_a, split_b = SPLIT
+    mgroup = split_a ? split_group(plan.mgroup, plan.mpack) : plan.mgroup
+    ngroup = split_b ? split_group(plan.ngroup, plan.npack) : plan.ngroup
+
+    # Ramp composites get closed-form block descriptors, no offset buffers; the
+    # block pack reads the offsets. A group is a ramp when both its maps are,
+    # which the path's flags record, except N's B map under unpacked B.
+    aff_mA, aff_mC, aff_nB, aff_nC, aff_kA, aff_kB = AFF
+    m_ramp = aff_mA && aff_mC
+    n_ramp = (UNPACKED_B ? is_ramp_map(ngroup, 1) : aff_nB) && aff_nC
+    k_ramp = aff_kA && aff_kB
+    m_step = m_ramp ? affine_ramp(mgroup)[2] : (0, 0)
+    n_step = n_ramp ? affine_ramp(ngroup)[2] : (0, 0)
+    k_step = k_ramp ? affine_ramp(plan.kgroup)[2] : (0, 0)
+
+    lenA = length(plan.Astorage)
+    lenB = length(plan.Bstorage)
+    lenC = length(plan.Cstorage)
+
+    # --- loop over N blocks ---
+    n_block_start = first(n_range)
+    while n_block_start <= last(n_range)
+        n_block_length = min(n_block, last(n_range) + 1 - n_block_start)
+        n_tiles = cld(n_block_length, n_tile)
+        (rng_nB, rng_nC) = if n_ramp
+            ramp_slivers!(
+                ws.n, n_step[1], n_step[2], n_block_start, n_block_length, n_tile, n_tiles
+            )
+        else
+            fill_offsets!(ws.n.offsets, ngroup, n_block_start, n_block_length)
+            classify_slivers!(ws.n, n_block_length, n_tile, n_tiles)
+        end
+
+        # --- loop over K blocks ---
+        k_block_start = 0
+        first_k_block = true
+        while k_block_start < k_length
+            k_block_length = min(k_block, k_length - k_block_start)
+            dK_A, dK_B, rng_kA, rng_kB = if k_ramp
+                (
+                    ramp_descriptor(k_step[1], k_block_start, k_block_length),
+                    ramp_descriptor(k_step[2], k_block_start, k_block_length),
+                    ramp_offset_range(k_step[1], k_block_start, k_block_length),
+                    ramp_offset_range(k_step[2], k_block_start, k_block_length),
+                )
+            else
+                fill_offsets!(ws.k, plan.kgroup, k_block_start, k_block_length)
+                dA = describe_block(ws.k[1], 0, k_block_length)
+                dB = describe_block(ws.k[2], 0, k_block_length)
+                (
+                    dA, dB,
+                    descriptor_offset_range(dA, ws.k[1], 0),
+                    descriptor_offset_range(dB, ws.k[2], 0),
+                )
+            end
+
+            colsA_k = axis_of(dK_A, ws.k[1], 0, Val(aff_kA))
+            rowsB_k = axis_of(dK_B, ws.k[2], 0, Val(aff_kB))
+
+            # Hoisted bounds checks (B here, A and C per M block): each
+            # rectangle is exactly the union of the per-sliver/per-tile
+            # regions, and the storage check compares only range extremes, so
+            # the `@inbounds` pack and tile calls below touch nothing unchecked.
+            checked_span_bounds(plan.Bbase, rng_kB, rng_nB, lenB)
+
+            beta_eff = first_k_block ? betaT : one(T)
+
+            UNPACKED_B || pack_block!(plan, path, Val(2), rowsB_k, n_block_length, k_block_length, n_tiles)
+
+            # --- loop over M blocks ---
+            m_block_start = 0
+            while m_block_start < m_length
+                m_block_length = min(m_block, m_length - m_block_start)
+                m_tiles = cld(m_block_length, m_tile)
+                (rng_mA, rng_mC) = if m_ramp
+                    ramp_slivers!(
+                        ws.m, m_step[1], m_step[2], m_block_start, m_block_length, m_tile, m_tiles
+                    )
+                else
+                    fill_offsets!(ws.m.offsets, mgroup, m_block_start, m_block_length)
+                    classify_slivers!(ws.m, m_block_length, m_tile, m_tiles)
+                end
+
+                checked_span_bounds(plan.Abase, rng_mA, rng_kA, lenA)
+                checked_span_bounds(plan.Cbase, rng_mC, rng_nC, lenC)
+
+                pack_block!(plan, path, Val(1), colsA_k, m_block_length, k_block_length, m_tiles)
+
+                # --- loops over N tiles and M tiles ---
+                micro_tiles!(
+                    plan, path, UNPACKED_B ? rowsB_k : nothing, m_tiles, n_tiles, k_block_length,
+                    alphaT, beta_eff, Val(aff_mC), Val(aff_nC)
+                )
+
+                m_block_start += m_block_length
+            end
+
+            first_k_block = false
+            k_block_start += k_block_length
+        end
+
+        n_block_start += n_block_length
+    end
+    return nothing
+end
+
+# Pack one macro block of operand `I` (1: A over M, 2: B over N): line by line
+# when the path splits it, else sliver by sliver. Inside the caller's bounds
+# checks.
+@inline function pack_block!(
+        plan::ContractPlan, ::NestPath{UNPACKED_B, AFF, SPLIT}, side::Val{I}, kaxis::KA,
+        block_length::Int, k_block_length::Int, tiles::Int
+    ) where {UNPACKED_B, AFF, SPLIT, I, KA <: AbstractVector{Int}}
+    kernel = plan.kernel
+    spec = sliver_spec(kernel, I)
+    width = sliver_width(kernel, I)
+    tile = tile_size(kernel, I)
+    storage, base, transform, buffer, g, split = packed_operand(plan, side)
+    if SPLIT[I]
+        pack_block_by_lines!(
+            packed_panel(buffer, 1, width * k_block_length * tiles), spec,
+            storage, base, g.offsets[1], kaxis, transform, block_length, k_block_length, split
+        )
+    else
+        for tile_index in 0:(tiles - 1)
+            tile_start = tile_index * tile
+            panel = sliver_panel(buffer, width, k_block_length, tile_index)
+            lanes = axis_of(g.descriptors[1][tile_index + 1], g.offsets[1], tile_start, Val(AFF[2I - 1]))
+            @inbounds pack_sliver!(panel, storage, base, lanes, kaxis, spec, transform)
+        end
+    end
+    return nothing
+end
+
+# Operand `I`'s storage, base and transform, packed buffer, free-group buffers
+# and split.
+@inline packed_operand(plan::ContractPlan, ::Val{1}) =
+    (plan.Astorage, plan.Abase, plan.atransform, plan.workspace.packed_a, plan.workspace.m, plan.mpack)
+@inline packed_operand(plan::ContractPlan, ::Val{2}) =
+    (plan.Bstorage, plan.Bbase, plan.btransform, plan.workspace.packed_b, plan.workspace.n, plan.npack)
+
+# The tile loops over one (N, K, M) block. `@noinline`: one call per block, and
+# the inlined microkernel is most of a nest's size; compile cost grows faster
+# than linearly with function size. `rowsB_k`: B's K axis when B is read in
+# place (a barrier over its type, so each view is concretely typed), else
+# `nothing`, so that the packed-B loop does not specialise on it.
+@noinline function micro_tiles!(
+        plan::ContractPlan, path::NestPath, rowsB_k::KB, m_tiles::Int, n_tiles::Int, k_block_length::Int,
+        alphaT, beta_eff, aff_mC::Val{MC}, aff_nC::Val{NC}
+    ) where {KB, MC, NC}
+    kernel = plan.kernel
+    ws = plan.workspace
+    m_tile, n_tile = tile_size(kernel)
+    # GUARDRAIL: reals per sliver per K step address the packed panels;
+    # `m_tile`/`n_tile` count register-tile rows. They differ for complex
+    # kernels.
+    a_sliver_width = sliver_width(kernel, 1)
+    for n_tile_index in 0:(n_tiles - 1)
+        n_tile_start = n_tile_index * n_tile
+        bsliver = b_sliver(plan, path, rowsB_k, k_block_length, n_tile_index, n_tile_start)
+        colsC = axis_of(ws.n.descriptors[2][n_tile_index + 1], ws.n.offsets[2], n_tile_start, aff_nC)
+        for m_tile_index in 0:(m_tiles - 1)
+            m_tile_start = m_tile_index * m_tile
+            apanel = sliver_panel(ws.packed_a, a_sliver_width, k_block_length, m_tile_index)
+            rowsC = axis_of(ws.m.descriptors[2][m_tile_index + 1], ws.m.offsets[2], m_tile_start, aff_mC)
+            # Inside the caller's C check.
+            @inbounds execute_micro_tile!(
+                kernel, plan.Cstorage, plan.Cbase, rowsC, colsC,
+                apanel, bsliver, k_block_length, alphaT, beta_eff
+            )
+        end
+    end
+    return nothing
+end
+
+# The B sliver of N tile `n_tile_index`: its packed panel, or B in place.
+@inline b_sliver(plan::ContractPlan, ::NestPath{false}, ::Nothing, k_block_length::Int, n_tile_index::Int, ::Int) =
+    sliver_panel(plan.workspace.packed_b, sliver_width(plan.kernel, 2), k_block_length, n_tile_index)
+@inline function b_sliver(
+        plan::ContractPlan, ::NestPath{true}, rowsB_k::KB, ::Int, n_tile_index::Int, n_tile_start::Int
+    ) where {KB <: AbstractVector{Int}}
+    n = plan.workspace.n
+    return unpacked_b_view(
+        plan.kernel, plan.Bstorage, plan.Bbase, n.descriptors[1][n_tile_index + 1], n.offsets[1],
+        n_tile_start, rowsB_k, plan.btransform
+    )
+end
+
+# The axis `d` describes. GUARDRAIL: a `Union{AffineAxis, ScatterAxis}` of
+# `isbits` types, never boxed; each consumer below binds each axis type as its
+# own parameter, so it builds a concretely typed `Tile`.
+@inline axis_of(d::BlockDescriptor, buffer::Vector{Int}, first::Int) =
+    d.regular ? AffineAxis(d.base, d.stride, d.count) : ScatterAxis(pointer(buffer, first + 1), d.count)
+
+# The same with the axis type fixed by the path: `Val(true)` for a ramp map,
+# whose descriptors are always regular (checked).
+@inline axis_of(d::BlockDescriptor, buffer::Vector{Int}, first::Int, ::Val{false}) =
+    axis_of(d, buffer, first)
+@inline function axis_of(d::BlockDescriptor, ::Vector{Int}, ::Int, ::Val{true})
+    d.regular || throw_irregular_ramp_descriptor()
+    return AffineAxis(d.base, d.stride, d.count)
+end
+@noinline throw_irregular_ramp_descriptor() =
+    throw(AssertionError("an affine-ramp map produced an irregular block descriptor"))
+
+# B passes its axes swapped (its `transpose`). GUARDRAIL: `transform` needs its
+# own bound type parameter, or it costs a dynamic dispatch per call.
+Base.@propagate_inbounds function pack_sliver!(
+        packed::PK, storage::S, base::Int,
+        lanes::R, steps::C, spec, transform::TF
+    ) where {PK, S, R <: AbstractVector{Int}, C <: AbstractVector{Int}, TF}
+    pack!(packed, Tile(storage, base, lanes, steps), spec, transform)
+    return nothing
+end
+
+Base.@propagate_inbounds function execute_micro_tile!(
+        kernel, storage::S, base::Int, rows::R, cols::C,
+        packed_a::PA, packed_b::PB, k_block_length::Int, alpha, beta
+    ) where {PA, PB, S, R <: AbstractVector{Int}, C <: AbstractVector{Int}}
+    destination = Tile(storage, base, rows, cols)
+    execute_tile!(kernel, destination, packed_a, packed_b, k_block_length, alpha, beta)
+    return nothing
+end
+
+# Sliver `tile_index` of a packed panel at the current block's depth
+# `k_block_length`, shared by the packing and the consuming step so the two
+# cannot disagree. GUARDRAIL: `width` counts reals per K step
+# (`sliver_width`), not the tile size; they differ for complex kernels.
+@inline function sliver_panel(buffer, width::Int, k_block_length::Int, tile_index::Int)
+    stride = width * k_block_length
+    return packed_panel(buffer, tile_index * stride + 1, stride)
+end
+
+# Classify each register sliver of a just-filled macro block, and return the
+# two maps' offset ranges over the whole block (the slivers partition it) for
+# the hoisted bounds checks.
+@inline function classify_slivers!(g::GroupBuffers, block_length::Int, tile::Int, tile_count::Int)
+    desc1, desc2 = g.descriptors
+    buf1, buf2 = g.offsets
+    lo1 = typemax(Int); hi1 = typemin(Int)
+    lo2 = typemax(Int); hi2 = typemin(Int)
+    for tile_index in 0:(tile_count - 1)
+        tile_start = tile_index * tile
+        tile_length = min(tile, block_length - tile_start)
+        d1 = describe_block(buf1, tile_start, tile_length)
+        d2 = describe_block(buf2, tile_start, tile_length)
+        desc1[tile_index + 1] = d1
+        desc2[tile_index + 1] = d2
+        (l1, h1) = descriptor_offset_range(d1, buf1, tile_start)
+        if h1 >= l1
+            lo1 = min(lo1, l1); hi1 = max(hi1, h1)
+        end
+        (l2, h2) = descriptor_offset_range(d2, buf2, tile_start)
+        if h2 >= l2
+            lo2 = min(lo2, l2); hi2 = max(hi2, h2)
+        end
+    end
+    # `hi < lo` means empty to `checked_span_bounds`.
+    return ((lo1, hi1), (lo2, hi2))
+end
+
+# Closed-form block descriptors for an affine-ramp composite (offset of `q`
+# is `q * step`), with no offset buffer or scan. `==` to what `describe_block`
+# gives for the materialized interval, including its `stride == 0` for a
+# count-1 block.
+@inline ramp_descriptor(step::Int, first::Int, count::Int) =
+    count == 0 ? BlockDescriptor(0, 0, 0, true) :
+    count == 1 ? BlockDescriptor(first * step, 0, 1, true) :
+    BlockDescriptor(first * step, step, count, true)
+
+# Offset range of `[first, first+count)`; `(0, -1)` if empty. Cannot overflow:
+# `AxisGroup` validated every in-domain offset at construction.
+@inline ramp_offset_range(step::Int, first::Int, count::Int) =
+    count == 0 ? (0, -1) : minmax(first * step, (first + count - 1) * step)
+
+# `classify_slivers!`'s closed-form twin.
+@inline function ramp_slivers!(
+        g::GroupBuffers, step1::Int, step2::Int, first::Int,
+        block_length::Int, tile::Int, tile_count::Int
+    )
+    desc1, desc2 = g.descriptors
+    for tile_index in 0:(tile_count - 1)
+        tile_start = tile_index * tile
+        tile_length = min(tile, block_length - tile_start)
+        q0 = first + tile_start
+        desc1[tile_index + 1] = ramp_descriptor(step1, q0, tile_length)
+        desc2[tile_index + 1] = ramp_descriptor(step2, q0, tile_length)
+    end
+    return (
+        ramp_offset_range(step1, first, block_length),
+        ramp_offset_range(step2, first, block_length),
+    )
+end
diff --git a/src/execution/oracle.jl b/src/execution/oracle.jl
deleted file mode 100644
index 2ddf32f..0000000
--- a/src/execution/oracle.jl
+++ /dev/null
@@ -1,87 +0,0 @@
-# The tile-by-tile correctness oracle for `execute!`: per register tile, K in
-# `kc` panels, pack one sliver each and call the checked `execute_tile!`. Uses
-# only its own `tw_*` buffers, so it shares no mutable state with `execute!`.
-# Needs a plan built with `oracle = true`. Unlike `execute!`, rounds a C narrower
-# than the compute type once per `kc` block.
-function execute_tilewise!(plan::ContractPlan{T}, alpha::Number, beta::Number) where {T}
-    ws = plan.workspace
-    # `tw_packed_a` is never empty for a legal blocking unless `oracle = false`.
-    isempty(ws.tw_packed_a) && throw(
-        ArgumentError(
-            "execute_tilewise! needs the oracle buffers, which this plan was built " *
-                "without; re-plan with `oracle = true`"
-        )
-    )
-
-    alphaT = convert(T, alpha)
-    betaT = convert(T, beta)
-
-    kernel = plan.kernel
-    MRk = mr(kernel)
-    NRk = nr(kernel)
-
-    Qm = axis_length(plan.mgroup)
-    Qn = axis_length(plan.ngroup)
-    Qk = axis_length(plan.kgroup)
-
-    (Qm == 0 || Qn == 0) && return plan.Cstorage
-
-    if Qk == 0 || iszero(alphaT)
-        _scale_all_of_C!(plan, betaT, MRk, NRk, Qm, Qn)
-        return plan.Cstorage
-    end
-
-    m_bufs = (ws.tile_m_buf_A, ws.tile_m_buf_C)
-    n_bufs = (ws.tile_n_buf_B, ws.tile_n_buf_C)
-    k_bufs = (ws.tw_k_buf_A, ws.tw_k_buf_B)
-    kc_panel = plan.blocking.kc
-
-    mfirst = 0
-    while mfirst < Qm
-        mcount = min(MRk, Qm - mfirst)
-        (dM_A, dM_C) = block_descriptors!(m_bufs, plan.mgroup, mfirst, mcount)
-        rowsA = _axis_of(dM_A, ws.tile_m_buf_A, 0)
-        rowsC = _axis_of(dM_C, ws.tile_m_buf_C, 0)
-
-        nfirst = 0
-        while nfirst < Qn
-            ncount = min(NRk, Qn - nfirst)
-            (dN_B, dN_C) = block_descriptors!(n_bufs, plan.ngroup, nfirst, ncount)
-            colsB = _axis_of(dN_B, ws.tile_n_buf_B, 0)
-            colsC = _axis_of(dN_C, ws.tile_n_buf_C, 0)
-
-            kfirst = 0
-            firstpanel = true
-            while kfirst < Qk
-                kcount = min(kc_panel, Qk - kfirst)
-                (dK_A, dK_B) = block_descriptors!(k_bufs, plan.kgroup, kfirst, kcount)
-                colsK_A = _axis_of(dK_A, ws.tw_k_buf_A, 0)
-                rowsK_B = _axis_of(dK_B, ws.tw_k_buf_B, 0)
-
-                # Whole single-sliver buffers, so no `_sliver_panel`.
-                _pack_sliver!(
-                    pack_a!, ws.tw_packed_a, plan.Astorage, plan.Abase, rowsA, colsK_A,
-                    kernel, plan.atransform
-                )
-                _pack_sliver!(
-                    pack_b!, ws.tw_packed_b, plan.Bstorage, plan.Bbase, rowsK_B, colsB,
-                    kernel, plan.btransform
-                )
-
-                beta_eff = firstpanel ? betaT : one(T)
-                _execute_micro_tile!(
-                    kernel, plan.Cstorage, plan.Cbase, rowsC, colsC,
-                    ws.tw_packed_a, ws.tw_packed_b, kcount, alphaT, beta_eff
-                )
-
-                firstpanel = false
-                kfirst += kcount
-            end
-
-            nfirst += ncount
-        end
-        mfirst += mcount
-    end
-
-    return plan.Cstorage
-end
diff --git a/src/execution/outer.jl b/src/execution/outer.jl
index 7df91f4..b30eb62 100644
--- a/src/execution/outer.jl
+++ b/src/execution/outer.jl
@@ -1,106 +1,68 @@
 # The outer-product path for `K == 1`, real `T`, M unit-stride in A and C:
 # `C[:, n] = alpha * A * B[n] + beta * C[:, n]` as a streaming write. Through
 # the nest a K = 1 contraction is all per-tile fixed cost. The arithmetic is
-# the nest's term for term (`r = a * b`, then `_store_tile_vector!`'s
+# the nest's term for term (`r = a * b`, then `vector_store!`'s
 # expressions), so the two agree bitwise except on a signed zero. Real only:
 # complex K = 1 tiles are not the bottleneck, and the path would need its own
 # interleaved arithmetic.
 
-# `:never` forces the path off, for benchmarks and tests.
-const _OUTER_MODE = Ref{Symbol}(:auto)
-
-# N and B may have any layout: B is read one scalar per column.
-function _outer_applicable(::Type{T}, Astorage, Cstorage, mgroup::AxisGroup, Qm::Int) where {T}
-    _OUTER_MODE[] === :never && return false
-    T <: Real || return false
-    (Astorage isa DenseVector{T} && Cstorage isa DenseVector{T}) || return false
-    Qm >= _dot_lanewidth(T) || return false
-    _map_ramp_step(mgroup, 1) == 1 || return false
-    return _map_ramp_step(mgroup, 2) == 1
-end
-
-function _execute_outer!(
-        plan::ContractPlan{T}, alphaT::T, betaT::T, Qm::Int, Qn::Int, ::Val{W}
-    ) where {T, W}
+# B is read one scalar per column.
+function execute_path!(plan::ContractPlan{T}, alphaT::T, betaT::T, ::OuterPath{W}) where {T, W}
     ws = plan.workspace
     Astorage = plan.Astorage
     Bstorage = plan.Bstorage
     Cstorage = plan.Cstorage
     Bbase = plan.Bbase
-    bufB = ws.n_buf_B
-    bufC = ws.n_buf_C
-    nc_eff = plan.blocking.nc
+    bufB = ws.n.offsets[1]
+    bufC = ws.n.offsets[2]
+    m_length = axis_length(plan.mgroup)
+    n_length = axis_length(plan.ngroup)
+    n_block = plan.blocking.n_block
     lenB = length(Bstorage)
     lenC = length(Cstorage)
 
-    checked_span_bounds(plan.Abase, (0, Qm - 1), (0, 0), length(Astorage))
+    checked_span_bounds(plan.Abase, (0, m_length - 1), (0, 0), length(Astorage))
 
     GC.@preserve ws Astorage Cstorage begin
         ap = pointer(Astorage) + sizeof(T) * plan.Abase
         cp = pointer(Cstorage) + sizeof(T) * plan.Cbase
-        jc = 0
-        while jc < Qn
-            nblock = min(nc_eff, Qn - jc)
-            fill_offsets!((bufB, bufC), plan.ngroup, jc, nblock)
-            checked_span_bounds(Bbase, _buffer_range(bufB, nblock), (0, 0), lenB)
-            checked_span_bounds(plan.Cbase, (0, Qm - 1), _buffer_range(bufC, nblock), lenC)
-            _outer_block!(
-                cp, bufC, ap, Bstorage, Bbase, bufB, nblock, Qm,
-                alphaT, betaT, plan.btransform, Val(W)
+        n_block_start = 0
+        while n_block_start < n_length
+            n_block_length = min(n_block, n_length - n_block_start)
+            fill_offsets!((bufB, bufC), plan.ngroup, n_block_start, n_block_length)
+            checked_span_bounds(Bbase, extrema(view(bufB, 1:n_block_length)), (0, 0), lenB)
+            checked_span_bounds(plan.Cbase, (0, m_length - 1), extrema(view(bufC, 1:n_block_length)), lenC)
+            outer_block!(
+                cp, bufC, ap, Bstorage, Bbase, bufB, n_block_length, m_length,
+                alphaT, static_beta(betaT), plan.btransform, Val(W)
             )
-            jc += nblock
+            n_block_start += n_block_length
         end
     end
-    return plan.Cstorage
+    return nothing
 end
 
-# One N block, W rows at a time with a scalar tail; the `beta` regime is
-# chosen once per block.
-@inline function _outer_block!(
+# One N block, W rows at a time with a scalar tail, for a `beta` case.
+@inline function outer_block!(
         cp::Ptr{T}, bufC::Vector{Int}, ap::Ptr{T}, Bstorage::SB, Bbase::Int,
-        bufB::Vector{Int}, nblock::Int, Qm::Int, alpha::T, beta::T, btransform::F, ::Val{W}
+        bufB::Vector{Int}, n_block_length::Int, m_length::Int, alpha::T, beta, btransform::F, ::Val{W}
     ) where {T, SB, F, W}
     sz = sizeof(T)
-    mmain = (Qm ÷ W) * W
-    @inbounds for n in 1:nblock
+    mmain = (m_length ÷ W) * W
+    @inbounds for n in 1:n_block_length
         b = convert(T, btransform(Bstorage[Bbase + bufB[n] + 1]))
         bv = Vec{W, T}(b)
         cpn = cp + sz * bufC[n]
         m = 0
-        if iszero(beta)
-            while m < mmain
-                r = vload(Vec{W, T}, ap + sz * m) * bv
-                vstore(alpha * r, cpn + sz * m)
-                m += W
-            end
-            while m < Qm
-                r = unsafe_load(ap + sz * m) * b
-                unsafe_store!(cpn + sz * m, alpha * r)
-                m += 1
-            end
-        elseif isone(beta)
-            while m < mmain
-                r = vload(Vec{W, T}, ap + sz * m) * bv
-                vstore(muladd(alpha, r, vload(Vec{W, T}, cpn + sz * m)), cpn + sz * m)
-                m += W
-            end
-            while m < Qm
-                r = unsafe_load(ap + sz * m) * b
-                unsafe_store!(cpn + sz * m, muladd(alpha, r, unsafe_load(cpn + sz * m)))
-                m += 1
-            end
-        else
-            betav = Vec{W, T}(beta)
-            while m < mmain
-                r = vload(Vec{W, T}, ap + sz * m) * bv
-                vstore(muladd(alpha, r, betav * vload(Vec{W, T}, cpn + sz * m)), cpn + sz * m)
-                m += W
-            end
-            while m < Qm
-                r = unsafe_load(ap + sz * m) * b
-                unsafe_store!(cpn + sz * m, muladd(alpha, r, beta * unsafe_load(cpn + sz * m)))
-                m += 1
-            end
+        while m < mmain
+            r = vload(Vec{W, T}, ap + sz * m) * bv
+            vstore(axpby(alpha, r, old_c(Vec{W, T}, cpn + sz * m, beta), beta), cpn + sz * m)
+            m += W
+        end
+        while m < m_length
+            r = unsafe_load(ap + sz * m) * b
+            unsafe_store!(cpn + sz * m, axpby(alpha, r, old_c(T, cpn + sz * m, beta), beta))
+            m += 1
         end
     end
     return nothing
diff --git a/src/execution/paths.jl b/src/execution/paths.jl
new file mode 100644
index 0000000..262ddee
--- /dev/null
+++ b/src/execution/paths.jl
@@ -0,0 +1,74 @@
+# Execution paths: singletons that select one `execute_path!` method.
+# `plan_contract` decides the path (`select_path`) and stores it in the plan,
+# so `execute!` reaches the path's code statically.
+
+# Nothing to compute: M or N is empty.
+struct EmptyPath end
+
+# `C *= beta`: K is empty.
+struct ScalePath end
+
+# The five-loop nest. `UNPACKED_B`: B read in place instead of packed. `AFF`:
+# per map, in the order M-in-A, M-in-C, N-in-B, N-in-C, K-in-A, K-in-B,
+# whether it is an affine ramp, so that its sliver axes are statically
+# `AffineAxis` and the offset-buffer `view` arm is never compiled. `SPLIT`: whether
+# A and B are packed line by line (`plan.mpack`/`plan.npack`).
+struct NestPath{UNPACKED_B, AFF, SPLIT} end
+
+@inline is_ramp_map(g::AxisGroup, p::Int) = map_ramp_step(g, p) !== nothing
+
+# N's B flag stays `false` when B is read in place: that path builds no B
+# sliver axis, so the flag would only split specialisations. A split group is
+# enumerated in another order, so its ramp flags are `false`. `panel`: C is
+# `PanelPath`'s dense panel, whose M and N maps are ramps.
+@inline function nest_path(
+        unpacked_b::Bool, mgroup::AxisGroup, ngroup::AxisGroup, kgroup::AxisGroup,
+        split_a::Bool, split_b::Bool, panel::Bool = false
+    )
+    split_b &= !unpacked_b
+    return nest_path_from_flags(
+        panel ? PANEL_PATHS : NEST_PATHS, unpacked_b,
+        !split_a && is_ramp_map(mgroup, 1), !split_a && (panel || is_ramp_map(mgroup, 2)),
+        !unpacked_b && !split_b && is_ramp_map(ngroup, 1), !split_b && (panel || is_ramp_map(ngroup, 2)),
+        is_ramp_map(kgroup, 1), is_ramp_map(kgroup, 2), split_a, split_b
+    )
+end
+
+# The nest run against a dense panel of C in the compute type.
+struct PanelPath{P <: NestPath} end
+
+# Table lookup rather than `NestPath{u, aff, split}()` built at runtime (a
+# dynamic type application) or a 512-leaf branch tree (slow to infer).
+@inline function nest_path_from_flags(table::Vector{Any}, flags::Vararg{Bool, 9})
+    index = 1
+    for i in 1:9
+        index += flags[i] << (i - 1)
+    end
+    return @inbounds table[index]
+end
+
+const NEST_PATHS = let
+    table = Vector{Any}(undef, 512)
+    for index in 1:512
+        bits = ntuple(i -> ((index - 1) >> (i - 1)) & 1 == 1, 9)
+        table[index] = NestPath{bits[1], bits[2:7], bits[8:9]}()
+    end
+    table
+end
+
+const PANEL_PATHS = Any[PanelPath{typeof(p)}() for p in NEST_PATHS]
+
+# The dot path at lane width `W`; `MATB`: the matrix operand is B
+# (`m_length == 1`).
+struct DotPath{MATB, W} end
+
+# The outer-product path at lane width `W`.
+struct OuterPath{W} end
+
+# A runtime lane width to its path singleton, one literal per arm.
+@inline function lane_path(::Type{P}, W::Int) where {P}
+    W == 16 && return P{16}()
+    W == 8 && return P{8}()
+    W == 4 && return P{4}()
+    return P{2}()
+end
diff --git a/src/execution/unpackedb.jl b/src/execution/unpackedb.jl
deleted file mode 100644
index 952a84b..0000000
--- a/src/execution/unpackedb.jl
+++ /dev/null
@@ -1,114 +0,0 @@
-# "Unpacked B": the microkernel reads B in place instead of from a packed
-# panel. The kernels consume B one (complex) scalar at a time and broadcast
-# it, so any K axis, column offsets and `AbstractVector` storage work.
-# Packing B buys locality and padding columns at an O(N*K) gather per
-# (jc, pc) block, which at small M costs as much as the kernel itself.
-
-# Stands in for a packed B micro-panel of `NR` columns: column `j`, K step
-# `p` is storage address `colbase[j+1] + axis_offset(ksteps, p)` (base
-# included). Padding columns of a tail sliver alias the last valid column, so
-# every address read is inside the hoisted B check; their results are never
-# stored. `length` is the packed-equivalent count that
-# `_execute_tile_prologue!` checks, not the storage length.
-struct UnpackedBView{S, K <: Axis, NR, F}
-    storage::S
-    colbase::NTuple{NR, Int}
-    ksteps::K
-    per_k::Int
-    transform::F
-end
-
-Base.length(u::UnpackedBView) = u.per_k * axis_length(u.ksteps)
-
-# `@inbounds`: the caller has checked the whole B panel region.
-@inline function _unpacked_b_element(u::UnpackedBView{S, K, NR, F}, j::Int, p::Int) where {S, K, NR, F}
-    @inbounds z = u.storage[u.colbase[j + 1] + axis_offset(u.ksteps, p) + 1]
-    return u.transform(z)
-end
-
-@inline _b_step_load(u::UnpackedBView, kernel, j::Int, p::Int) =
-    convert(scalartype(kernel), _unpacked_b_element(u, j, p))
-
-# Complex kernels: the planar `(re, im)` pair.
-@inline function _b_step_load2(u::UnpackedBView, kernel, j::Int, p::Int)
-    z = convert(scalartype(kernel), _unpacked_b_element(u, j, p))
-    return (real(z), imag(z))
-end
-
-# The kernels whose K step reads B through `_b_step_load`/`_b_step_load2`
-# (not 1m, whose inner kernel walks the planar panel, nor the scalar one).
-@inline _unpacked_b_kernel_eligible(::SIMDKernel) = true
-@inline _unpacked_b_kernel_eligible(::PlanarKernel) = true
-@inline _unpacked_b_kernel_eligible(::FMAddSubKernel) = true
-@inline _unpacked_b_kernel_eligible(::ComplexRealKernel) = true
-@inline _unpacked_b_kernel_eligible(::Any) = false
-
-# The same by method, to predict the path before the kernel exists.
-@inline _unpacked_b_method_eligible(::Union{RealMethod, PlanarMethod, FMAddSubMethod, ComplexRealMethod}) = true
-@inline _unpacked_b_method_eligible(::Any) = false
-
-# `:always`/`:never` override the rule below, for benchmarks and tests.
-const _UNPACKED_B_MODE = Ref{Symbol}(:auto)
-
-# Whether B is read in place (given an eligible kernel): small M, and every B
-# column contiguous along K. Packing pays off only through reuse across M
-# slivers, while `nr` contiguous columns read in place cost the kernel
-# nothing. A large K stride in B (each step its own cache line, and for a
-# power of two only a few L1 sets) is what packing exists for.
-@inline function _unpacked_b_rule(mgroup::AxisGroup, kgroup::AxisGroup)
-    mode = _UNPACKED_B_MODE[]
-    mode === :always && return true
-    mode === :never && return false
-    axis_length(mgroup) <= _UNPACKED_B_MMAX || return false
-    (k_ramp, k_step) = affine_ramp(kgroup)
-    return k_ramp && abs(k_step[2]) == 1
-end
-
-# Beyond this M the packed B's reuse wins.
-const _UNPACKED_B_MMAX = 256
-
-# The view for one N sliver; `buf`/`sfirst` locate an irregular sliver's
-# offsets in `ws.n_buf_B`.
-@inline function _unpacked_b_view(
-        kernel::DescriptorKernel{MR, NR, T}, storage::S, base::Int,
-        d::BlockDescriptor, buf::Vector{Int}, sfirst::Int, ksteps::K, transform::F
-    ) where {MR, NR, T, S, K <: Axis, F}
-    last = d.count - 1
-    colbase = ntuple(Val(NR)) do j1
-        jj = min(j1 - 1, last)
-        off = d.regular ? d.base + jj * d.stride : (@inbounds buf[sfirst + jj + 1])
-        base + off
-    end
-    return UnpackedBView(storage, colbase, ksteps, packed_b_per_k(kernel), transform)
-end
-
-# Loops 2/1 of `_execute_nest!` with B read in place. A barrier over the K
-# axis type, so each view is concretely typed. `@noinline` so that the
-# packed-B nest does not grow by this body. The view's addresses are within
-# the caller's B check.
-@noinline function _micro_tiles_unpacked_b!(
-        kernel::K, plan::ContractPlan, ws, rowsB_k::KA, m_slivers::Int, n_slivers::Int,
-        MRk::Int, NRk::Int, MRp::Int, kblock::Int, alphaT, beta_eff,
-        aff_mC::Val{MC}, aff_nC::Val{NC}
-    ) where {K, KA <: Axis, MC, NC}
-    Bstorage = plan.Bstorage
-    Bbase = plan.Bbase
-    btransform = plan.btransform
-    for s in 0:(n_slivers - 1)
-        sfirst = s * NRk
-        colsC = _axis_of(ws.n_desc_C[s + 1], ws.n_buf_C, sfirst, aff_nC)
-        bview = _unpacked_b_view(
-            kernel, Bstorage, Bbase, ws.n_desc_B[s + 1], ws.n_buf_B, sfirst, rowsB_k, btransform
-        )
-        for r in 0:(m_slivers - 1)
-            rfirst = r * MRk
-            rowsC = _axis_of(ws.m_desc_C[r + 1], ws.m_buf_C, rfirst, aff_mC)
-            apanel = _sliver_panel(ws.packed_a, MRp, kblock, r)
-            unsafe_execute_micro_tile!(
-                kernel, plan.Cstorage, plan.Cbase, rowsC, colsC,
-                apanel, bview, kblock, alphaT, beta_eff
-            )
-        end
-    end
-    return nothing
-end
diff --git a/src/execution/workspace.jl b/src/execution/workspace.jl
index 9080ab6..7e0f9a3 100644
--- a/src/execution/workspace.jl
+++ b/src/execution/workspace.jl
@@ -1,72 +1,45 @@
-# Typed payload slots for the dispatch barriers (src/execution/barrier.jl):
-# one `Base.RefValue{P}` per payload type, plus the last one used. They live
-# as long as the workspace, which is what lets a barrier call allocate nothing.
-mutable struct _SlotCache
-    last::Any
-    const slots::IdDict{Any, Any}
+# One M or N macro block's offsets in the group's two operands, and the
+# per-sliver descriptors of each.
+struct GroupBuffers
+    offsets::NTuple{2, Vector{Int}}
+    descriptors::NTuple{2, Vector{BlockDescriptor}}
 end
-_SlotCache() = _SlotCache(nothing, IdDict{Any, Any}())
+
+GroupBuffers(block::Int, tiles::Int) = GroupBuffers(
+    (Vector{Int}(undef, block), Vector{Int}(undef, block)),
+    (Vector{BlockDescriptor}(undef, tiles), Vector{BlockDescriptor}(undef, tiles))
+)
 
 """
     ContractWorkspace{T,VT<:AbstractVector,PT<:AbstractVector}
 
-The buffers [`execute!`](@ref) needs. Pass one back as
-`plan_contract(...; workspace = ws)` to reuse (and grow) it across
-contractions; one from a non-default allocator is single-use and must be
-[`release!`](@ref)d. `T` is the plan's compute type; the packed panels (`VT`)
-hold `real(T)`, the panel of C (`PT`) holds `T`. Field layout is an
+The buffers [`execute!`](@ref) needs, built by [`plan_contract`](@ref) and
+reused by every `execute!` on that plan. One from a non-default allocator must
+be [`release!`](@ref)d. `T` is the plan's compute type; the packed panels
+(`VT`) hold `real(T)`, the panel of C (`PT`) holds `T`. Field layout is an
 implementation detail.
 """
-# A `mutable struct` with `const` fields so a plan and a barrier slot hold one
-# pointer to it instead of copying twenty-two GC-tracked fields.
+# A `mutable struct` with `const` fields so a plan holds one pointer to it
+# instead of copying every GC-tracked field.
 mutable struct ContractWorkspace{T, VT <: AbstractVector, PT <: AbstractVector}
-    # Macro-block offset buffers and their per-sliver descriptors.
-    const m_buf_A::Vector{Int}
-    const m_buf_C::Vector{Int}
-    const n_buf_B::Vector{Int}
-    const n_buf_C::Vector{Int}
-    const k_buf_A::Vector{Int}
-    const k_buf_B::Vector{Int}
-    const m_desc_A::Vector{BlockDescriptor}
-    const m_desc_C::Vector{BlockDescriptor}
-    const n_desc_B::Vector{BlockDescriptor}
-    const n_desc_C::Vector{BlockDescriptor}
+    const m::GroupBuffers
+    const n::GroupBuffers
+    # K blocks are described whole, so K has offsets only.
+    const k::NTuple{2, Vector{Int}}
 
-    # Packed macro panels and the panel of C: the only allocator-routed buffers.
+    # The only allocator-routed buffers.
     const packed_a::VT
     const packed_b::VT
-
-    # One register tile's offsets: the beta-only pass and the oracle.
-    const tile_m_buf_A::Vector{Int}
-    const tile_m_buf_C::Vector{Int}
-    const tile_n_buf_B::Vector{Int}
-    const tile_n_buf_C::Vector{Int}
-
-    # `execute_tilewise!`'s own buffers, empty under `oracle = false`; not
-    # shared, so the oracle has no state in common with what it checks.
-    const tw_k_buf_A::Vector{Int}
-    const tw_k_buf_B::Vector{Int}
-    const tw_packed_a::VT
-    const tw_packed_b::VT
-
-    const slots::_SlotCache
-
     # The compute-type panel of C for an eltype of C narrower than `T` (see
-    # `_PanelPath`); empty otherwise.
+    # `PanelPath`); empty otherwise.
     const c_panel::PT
+    # The dot path's gathered vector (complex: and its pair-swapped copy).
+    const dot_vector::Vector{T}
 
     # GUARDRAIL: the packed panels hold `real(T)`, never `T`.
-    function ContractWorkspace{T, VT, PT}(
-            m_buf_A::Vector{Int}, m_buf_C::Vector{Int},
-            n_buf_B::Vector{Int}, n_buf_C::Vector{Int},
-            k_buf_A::Vector{Int}, k_buf_B::Vector{Int},
-            m_desc_A::Vector{BlockDescriptor}, m_desc_C::Vector{BlockDescriptor},
-            n_desc_B::Vector{BlockDescriptor}, n_desc_C::Vector{BlockDescriptor},
-            packed_a::VT, packed_b::VT,
-            tile_m_buf_A::Vector{Int}, tile_m_buf_C::Vector{Int},
-            tile_n_buf_B::Vector{Int}, tile_n_buf_C::Vector{Int},
-            tw_k_buf_A::Vector{Int}, tw_k_buf_B::Vector{Int},
-            tw_packed_a::VT, tw_packed_b::VT, c_panel::PT
+    function ContractWorkspace{T}(
+            m::GroupBuffers, n::GroupBuffers, k::NTuple{2, Vector{Int}},
+            packed_a::VT, packed_b::VT, c_panel::PT, dot_vector::Vector{T}
         ) where {T, VT <: AbstractVector, PT <: AbstractVector}
         eltype(VT) === real(T) || throw(
             ArgumentError(
@@ -74,234 +47,77 @@ mutable struct ContractWorkspace{T, VT <: AbstractVector, PT <: AbstractVector}
                     "(the real type of the compute type $T), got $(eltype(VT))"
             )
         )
-        return new{T, VT, PT}(
-            m_buf_A, m_buf_C, n_buf_B, n_buf_C, k_buf_A, k_buf_B,
-            m_desc_A, m_desc_C, n_desc_B, n_desc_C,
-            packed_a, packed_b,
-            tile_m_buf_A, tile_m_buf_C, tile_n_buf_B, tile_n_buf_C,
-            tw_k_buf_A, tw_k_buf_B, tw_packed_a, tw_packed_b, _SlotCache(), c_panel,
-        )
+        return new{T, VT, PT}(m, n, k, packed_a, packed_b, c_panel, dot_vector)
     end
 end
 
-# Buffer lengths for `kernel` at the effective `blocking`, shared by the
-# constructors and `reserve!`. GUARDRAIL: `packed_a_length` already counts
-# reals, the sliver counts are in logical `mr`/`nr`; do not rescale either.
-@inline function _workspace_sizes(kernel, blocking::Blocking)
-    MRk = mr(kernel)
-    NRk = nr(kernel)
-    kc = blocking.kc
-    pa = packed_a_length(kernel, kc)
-    pb = packed_b_length(kernel, kc)
-    m_slivers = cld(blocking.mc, MRk)
-    n_slivers = cld(blocking.nc, NRk)
+# Buffer lengths for `kernel` on `path`: M and N offsets (`m`, `n`) and
+# sliver counts (`m_tiles`, `n_tiles`), packed reals and the dot vector. Every
+# path keeps at least one tile of M and N offsets for `scale_all_of_C!`.
+# GUARDRAIL: the packed lengths count reals, the sliver counts logical
+# `m_tile`/`n_tile`; do not rescale either.
+function workspace_sizes(::Type{T}, kernel, blocking::Blocking, path) where {T}
+    m_tile, n_tile = tile_size(kernel)
+    a_reals, b_reals = map(reals_per_element, pack_formats(typeof(kernel)))
+    m_tiles = cld(blocking.m_block, m_tile)
+    n_tiles = cld(blocking.n_block, n_tile)
     return (
-        mc = blocking.mc, nc = blocking.nc, kc = kc,
-        mr = MRk, nr = NRk,
-        m_slivers = m_slivers, n_slivers = n_slivers,
-        packed_a = m_slivers * pa, packed_b = n_slivers * pb,
-        tw_packed_a = pa, tw_packed_b = pb,
-    )
-end
-
-# A temporary, never `resize!`d.
-@inline function _alloc_temp(::Type{T}, n::Int, allocator) where {T}
-    return TO.tensoralloc(Vector{T}, (n,), Val(true), allocator)
-end
-
-# A non-temporary, which every allocator serves as a plain `Vector{Int}`.
-@inline function _alloc_offsets(n::Int, allocator)
-    return TO.tensoralloc(Vector{Int}, (n,), Val(false), allocator)::Vector{Int}
-end
-
-# Not tensor buffers, so never through `tensoralloc`.
-@inline _alloc_descriptors(n::Int) = Vector{BlockDescriptor}(undef, n)
-
-@inline function _build_workspace(
-        ::Type{T}, s, ntw::Int, ints::F,
-        packed_a::VT, packed_b::VT, tw_packed_a::VT, tw_packed_b::VT, c_panel::PT
-    ) where {T, F, VT <: AbstractVector, PT <: AbstractVector}
-    return ContractWorkspace{T, VT, PT}(
-        ints(s.mc), ints(s.mc),
-        ints(s.nc), ints(s.nc),
-        ints(s.kc), ints(s.kc),
-        _alloc_descriptors(s.m_slivers), _alloc_descriptors(s.m_slivers),
-        _alloc_descriptors(s.n_slivers), _alloc_descriptors(s.n_slivers),
-        packed_a, packed_b,
-        ints(s.mr), ints(s.mr),
-        ints(s.nr), ints(s.nr),
-        ints(ntw), ints(ntw),
-        tw_packed_a, tw_packed_b, c_panel,
+        m = blocking.m_block, n = blocking.n_block, m_tiles, n_tiles,
+        packed_a = m_tiles * m_tile * a_reals * blocking.k_block,
+        packed_b = n_tiles * n_tile * b_reals * blocking.k_block, dot_vector = 0,
     )
 end
+# The dot path reads the matrix in place; its vector side's block is one tile.
+workspace_sizes(::Type{T}, kernel, blocking::Blocking, ::DotPath) where {T} = (
+    m = blocking.m_block, n = blocking.n_block, m_tiles = 0, n_tiles = 0, packed_a = 0, packed_b = 0,
+    dot_vector = (T <: Complex ? 2 : 1) * blocking.k_block,
+)
+# M offsets only for `scale_all_of_C!`.
+workspace_sizes(::Type{T}, kernel, blocking::Blocking, ::OuterPath) where {T} = (
+    m = tile_size(kernel, 1), n = blocking.n_block, m_tiles = 0, n_tiles = 0, packed_a = 0, packed_b = 0,
+    dot_vector = 0,
+)
 
 """
     ContractWorkspace(T, kernel, blocking::Blocking;
-                      oracle = true, allocator = TensorOperations.DefaultAllocator(),
-                      panel = 0)
+                      allocator = TensorOperations.DefaultAllocator(), panel = 0,
+                      path = nothing)
 
 A workspace for compute type `T`, `kernel` and an effective `blocking`.
-`oracle = false` leaves the `execute_tilewise!` buffers empty. `panel` is the
-length of the compute-type panel of C (see [`plan_contract`](@ref)). Under a
-non-default `allocator` the packed panels and the panel of C come from
-`tensoralloc`, are never resized, and must be handed back with
-[`release!`](@ref).
+`panel` is the length of the compute-type panel of C (see
+[`plan_contract`](@ref)); `path` is the plan's execution path, and the
+dot and outer-product paths get no packed panels. The packed panels and the
+panel of C come from `allocator` (`tensoralloc`) and must be handed back with
+[`release!`](@ref) unless it is the default one.
 """
 function ContractWorkspace(
-        ::Type{T}, kernel, blocking::Blocking, oracle::Bool, ::TO.DefaultAllocator,
-        panel::Int = 0
-    ) where {T}
-    s = _workspace_sizes(kernel, blocking)
-    R = realtype(kernel)
-    return _build_workspace(
-        T, s, oracle ? s.kc : 0, n -> Vector{Int}(undef, n),
-        Vector{R}(undef, s.packed_a), Vector{R}(undef, s.packed_b),
-        Vector{R}(undef, oracle ? s.tw_packed_a : 0),
-        Vector{R}(undef, oracle ? s.tw_packed_b : 0), Vector{T}(undef, panel),
-    )
-end
-
-function ContractWorkspace(
-        ::Type{T}, kernel, blocking::Blocking, oracle::Bool, allocator, panel::Int = 0
+        ::Type{T}, kernel, blocking::Blocking;
+        allocator = TO.DefaultAllocator(), panel::Int = 0, path = nothing
     ) where {T}
-    s = _workspace_sizes(kernel, blocking)
+    s = workspace_sizes(T, kernel, blocking, path)
     R = realtype(kernel)
-
     # `release!` frees in exactly the reverse order, for arena allocators.
-    packed_a = _alloc_temp(R, s.packed_a, allocator)
-    packed_b = _alloc_temp(R, s.packed_b, allocator)
-    tw_packed_a = _alloc_temp(R, oracle ? s.tw_packed_a : 0, allocator)
-    tw_packed_b = _alloc_temp(R, oracle ? s.tw_packed_b : 0, allocator)
-    c_panel = _alloc_temp(T, panel, allocator)
-
-    return _build_workspace(
-        T, s, oracle ? s.kc : 0, n -> _alloc_offsets(n, allocator),
-        packed_a, packed_b, tw_packed_a, tw_packed_b, c_panel
+    packed_a = TO.tensoralloc(Vector{R}, (s.packed_a,), Val(true), allocator)
+    packed_b = TO.tensoralloc(Vector{R}, (s.packed_b,), Val(true), allocator)
+    c_panel = TO.tensoralloc(Vector{T}, (panel,), Val(true), allocator)
+    k = (Vector{Int}(undef, blocking.k_block), Vector{Int}(undef, blocking.k_block))
+    return ContractWorkspace{T}(
+        GroupBuffers(s.m, s.m_tiles), GroupBuffers(s.n, s.n_tiles), k,
+        packed_a, packed_b, c_panel, Vector{T}(undef, s.dot_vector)
     )
 end
 
-function ContractWorkspace(
-        ::Type{T}, kernel, blocking::Blocking;
-        oracle::Bool = true, allocator = TO.DefaultAllocator(), panel::Int = 0
-    ) where {T}
-    return ContractWorkspace(T, kernel, blocking, oracle, allocator, panel)
-end
-
-# Grow `ws` in place (never shrink, never reallocate what is large enough)
-# for `kernel` at `blocking`. Only for the GC-owned path: an allocator's
-# temporaries must never be resized.
-function reserve!(
-        ws::ContractWorkspace{T, Vector{R}, Vector{T}}, kernel, blocking::Blocking,
-        oracle::Bool, panel::Int = 0
-    ) where {T, R}
-    s = _workspace_sizes(kernel, blocking)
-
-    _grow!(ws.m_buf_A, s.mc)
-    _grow!(ws.m_buf_C, s.mc)
-    _grow!(ws.n_buf_B, s.nc)
-    _grow!(ws.n_buf_C, s.nc)
-    _grow!(ws.k_buf_A, s.kc)
-    _grow!(ws.k_buf_B, s.kc)
-
-    _grow!(ws.m_desc_A, s.m_slivers)
-    _grow!(ws.m_desc_C, s.m_slivers)
-    _grow!(ws.n_desc_B, s.n_slivers)
-    _grow!(ws.n_desc_C, s.n_slivers)
-
-    _grow!(ws.packed_a, s.packed_a)
-    _grow!(ws.packed_b, s.packed_b)
-
-    _grow!(ws.tile_m_buf_A, s.mr)
-    _grow!(ws.tile_m_buf_C, s.mr)
-    _grow!(ws.tile_n_buf_B, s.nr)
-    _grow!(ws.tile_n_buf_C, s.nr)
-    _grow!(ws.c_panel, panel)
-
-    if oracle
-        _grow!(ws.tw_k_buf_A, s.kc)
-        _grow!(ws.tw_k_buf_B, s.kc)
-        _grow!(ws.tw_packed_a, s.tw_packed_a)
-        _grow!(ws.tw_packed_b, s.tw_packed_b)
-    end
-
-    return ws
-end
-
-@inline function _grow!(v::Vector, n::Int)
-    length(v) < n && resize!(v, n)
-    return v
-end
-
 """
     release!(ws::ContractWorkspace, allocator)
+    release!(plan::ContractPlan, allocator)
 
-Hand `ws`'s packed panels and panel of C back to `allocator`
-(`TensorOperations.tensorfree!`) in reverse acquisition order; `ws` must not be
-used afterwards. Correct for every allocator.
+Hand the packed panels and panel of C back to `allocator`
+(`TensorOperations.tensorfree!`) in reverse acquisition order; the workspace
+must not be used afterwards. A no-op for the default allocator.
 """
 function release!(ws::ContractWorkspace, allocator)
     TO.tensorfree!(ws.c_panel, allocator)
-    TO.tensorfree!(ws.tw_packed_b, allocator)
-    TO.tensorfree!(ws.tw_packed_a, allocator)
     TO.tensorfree!(ws.packed_b, allocator)
     TO.tensorfree!(ws.packed_a, allocator)
     return nothing
 end
-
-# Build or reuse the plan's workspace, dispatching on the allocator type.
-function _resolve_workspace(
-        ::Type{T}, workspace, kernel, blocking::Blocking, oracle::Bool,
-        allocator::TO.DefaultAllocator, panel::Int
-    ) where {T}
-    workspace === nothing &&
-        return ContractWorkspace(T, kernel, blocking, oracle, allocator, panel)
-    return _reuse_workspace(T, workspace, kernel, blocking, oracle, panel)
-end
-
-# Explicit allocator: sized once, never reused; the caller owns `release!`.
-function _resolve_workspace(
-        ::Type{T}, workspace, kernel, blocking::Blocking, oracle::Bool, allocator,
-        panel::Int
-    ) where {T}
-    workspace === nothing || throw(
-        ArgumentError(
-            "plan_contract: `workspace` cannot be combined with a non-default " *
-                "`allocator` ($(typeof(allocator))); an allocator-provided workspace is " *
-                "sized once at construction and must not be resized or reused"
-        )
-    )
-    return ContractWorkspace(T, kernel, blocking, oracle, allocator, panel)
-end
-
-# The pool is keyed by the compute type alone, so also check the packed type
-# (folds at compile time).
-@inline function _reuse_workspace(
-        ::Type{T}, ws::ContractWorkspace{T, Vector{R}, Vector{T}}, kernel, blocking::Blocking,
-        oracle::Bool, panel::Int
-    ) where {T, R}
-    R === realtype(kernel) || _throw_packed_eltype_mismatch(T, ws, kernel)
-    return reserve!(ws, kernel, blocking, oracle, panel)
-end
-
-@noinline function _throw_packed_eltype_mismatch(::Type{T}, ws, kernel) where {T}
-    throw(
-        ArgumentError(
-            "plan_contract: cannot reuse a $(typeof(ws)) whose packed panels hold " *
-                "$(eltype(ws.packed_a)) for a kernel packing $(realtype(kernel))"
-        )
-    )
-end
-
-@noinline function _reuse_workspace(
-        ::Type{T}, ws::ContractWorkspace, kernel, blocking::Blocking, oracle::Bool,
-        panel::Int
-    ) where {T}
-    throw(
-        ArgumentError(
-            "plan_contract: cannot reuse a $(typeof(ws)) for a contraction of compute " *
-                "type $T on the default allocator; only a " *
-                "ContractWorkspace{$T,Vector{$(realtype(kernel))},Vector{$T}} -- compute " *
-                "type $T, packed panels of $(realtype(kernel)) -- is `reserve!`-able"
-        )
-    )
-end
diff --git a/src/hardware/target.jl b/src/hardware/target.jl
index 7f59555..32746e0 100644
--- a/src/hardware/target.jl
+++ b/src/hardware/target.jl
@@ -3,59 +3,64 @@
 # the fixed fallback shapes.
 
 """
-    CacheLevel(bytes, ways, line, sharing)
+    CacheLevel(bytes, line, sharing)
 
 One detected cache level; any field may be `0` for "not detected". `sharing` is
 the number of logical CPUs sharing this level.
 """
 struct CacheLevel
     bytes::Int
-    ways::Int
     line::Int
     sharing::Int
 end
-CacheLevel() = CacheLevel(0, 0, 0, 0)
+CacheLevel() = CacheLevel(0, 0, 0)
 
 """
-    TargetProfile
+    TargetProfile(isa, cpu_name, l1d, l2, l3)
 
 What was detected about the host CPU. `isa` is one of `:avx512`, `:avx2`,
-`:neon` or `:unknown`.
+`:neon` or `:unknown`, and fixes `vector_bytes` and `nregisters`. The core's
+share of L2 and L3 (`l2_share`, `l3_share`, in bytes) and whether 512-bit FMAs
+are double-pumped (`double_pumped`) are derived as well.
 """
 struct TargetProfile
     isa::Symbol
-    arch::Symbol
     cpu_name::String
     vector_bytes::Int
     nregisters::Int
     l1d::CacheLevel
     l2::CacheLevel
     l3::CacheLevel
-end
-
-unknown_target() = TargetProfile(
-    :unknown, Sys.ARCH, "", 0, 0, CacheLevel(), CacheLevel(), CacheLevel()
-)
-
-# LLVM CPU name -> vector ISA. Unlisted names fall through to the CPUID probe.
-const _UARCH_ISA = Dict{String, Symbol}(
-    n => :avx512 for n in (
-            "skylake-avx512", "cascadelake", "cooperlake", "cannonlake",
-            "icelake-client", "icelake-server", "tigerlake", "rocketlake",
-            "sapphirerapids", "emeraldrapids", "graniterapids", "knl", "knm",
-            "znver4", "znver5",
+    # Derived here: planning reads them on every call.
+    l2_share::Int
+    l3_share::Int
+    double_pumped::Bool
+
+    function TargetProfile(isa::Symbol, cpu_name::AbstractString, l1d::CacheLevel, l2::CacheLevel, l3::CacheLevel)
+        isa in (:avx512, :avx2, :neon, :unknown) ||
+            throw(ArgumentError("TargetProfile: unknown ISA $(repr(isa))"))
+        return new(
+            isa, cpu_name, isa_vector_bytes(isa), isa_nregisters(isa), l1d, l2, l3,
+            core_bytes(l1d, l2), core_bytes(l1d, l3), cpu_name in DOUBLE_PUMPED_CPUS
         )
-)
-for n in (
-        "haswell", "broadwell", "skylake", "alderlake", "raptorlake",
-        "meteorlake", "sierraforest", "grandridge", "tremont", "goldmont",
-        "goldmont-plus", "znver1", "znver2", "znver3", "bdver4",
-    )
-    _UARCH_ISA[n] = :avx2
+    end
 end
 
+# This core's share of `level`: the CPUs sharing it over the SMT threads per
+# core, which are the CPUs sharing L1d.
+core_bytes(l1d::CacheLevel, level::CacheLevel) = level.bytes ÷ max(1, level.sharing ÷ max(1, l1d.sharing))
+
+# AMD's AVX-512 cores, which double-pump 512-bit FMAs.
+const DOUBLE_PUMPED_CPUS = ("znver4", "znver5")
+
+unknown_target() = TargetProfile(:unknown, "", CacheLevel(), CacheLevel(), CacheLevel())
+
+# The register count is the ISA's, not the lane width's: AVX512VL gives 32 ymm registers.
+isa_vector_bytes(isa::Symbol) = isa === :avx512 ? 64 : isa === :avx2 ? 32 : isa === :neon ? 16 : 0
+isa_nregisters(isa::Symbol) = isa === :avx512 ? 32 : isa === :avx2 ? 16 : isa === :neon ? 32 : 0
+
 # `Base.BinaryPlatforms.CPUID` is undocumented, so a failure degrades to `:unknown`.
-function _isa_from_cpuid()
+function isa_from_cpuid()
     return try
         C = Base.BinaryPlatforms.CPUID
         C.test_cpu_feature(C.JL_X86_avx512f) ? :avx512 :
@@ -65,39 +70,25 @@ function _isa_from_cpuid()
     end
 end
 
-_isa_rank(k::Symbol) = k === :avx512 ? 2 : k === :avx2 ? 1 : 0
-
-function _detect_isa()
-    if Sys.ARCH === :x86_64 || Sys.ARCH === :i686
-        key = get(_UARCH_ISA, Sys.CPU_NAME, :miss)
-        key === :miss && return _isa_from_cpuid()
-        # A hypervisor can mask CPUID features without changing the CPU name;
-        # AVX-512 code would then SIGILL, so a narrower live probe wins.
-        probe = _isa_from_cpuid()
-        probe === :unknown && return key
-        return _isa_rank(probe) < _isa_rank(key) ? probe : key
-    elseif Sys.ARCH === :aarch64
-        # SVE is not detected: its runtime vector length cannot be a fixed kernel shape.
-        return :neon
-    end
+function detect_isa()
+    (Sys.ARCH === :x86_64 || Sys.ARCH === :i686) && return isa_from_cpuid()
+    # SVE is not detected: its runtime vector length cannot be a fixed kernel shape.
+    Sys.ARCH === :aarch64 && return :neon
     return :unknown
 end
 
-# The register count is the ISA's, not the lane width's: AVX512VL gives 32 ymm registers.
-_isa_vector_bytes(::Val{K}) where {K} = K === :avx512 ? 64 : K === :avx2 ? 32 : K === :neon ? 16 : 0
-_isa_nregisters(::Val{K}) where {K} = K === :avx512 ? 32 : K === :avx2 ? 16 : K === :neon ? 32 : 0
-
 # "32K" / "1024K" / "2M" as Linux sysfs writes them.
-function _parse_size(s::AbstractString)
+function parse_size(s::AbstractString)
     s = strip(s)
     isempty(s) && return 0
-    mult = get(Dict('K' => 1024, 'M' => 1024^2, 'G' => 1024^3), uppercase(s[end]), 1)
+    unit = uppercase(s[end])
+    mult = unit == 'K' ? 1024 : unit == 'M' ? 1024^2 : unit == 'G' ? 1024^3 : 1
     mult == 1 || (s = s[1:(end - 1)])
     return something(tryparse(Int, strip(s)), 0) * mult
 end
 
 # "0,16" -> 2; "0-7,16-23" -> 16; "" -> 0.
-function _count_cpu_list(s::AbstractString)
+function count_cpu_list(s::AbstractString)
     n = 0
     for part in split(strip(s), ',')
         isempty(part) && continue
@@ -110,31 +101,30 @@ function _count_cpu_list(s::AbstractString)
     return n
 end
 
-_read_or(path, default = "") = try
+read_or(path, default = "") = try
     isfile(path) ? chomp(read(path, String)) : default
 catch
     default
 end
-_int_or(path) = something(tryparse(Int, _read_or(path)), 0)
+int_or(path) = something(tryparse(Int, read_or(path)), 0)
 
-function _cache_topology_linux()
+function cache_topology_linux()
     base = "/sys/devices/system/cpu/cpu0/cache"
     isdir(base) || return nothing
     levels = Dict{Symbol, CacheLevel}()
     for entry in readdir(base)
         startswith(entry, "index") || continue
         d = joinpath(base, entry)
-        level = tryparse(Int, _read_or(joinpath(d, "level")))
+        level = tryparse(Int, read_or(joinpath(d, "level")))
         level === nothing && continue
-        kind = _read_or(joinpath(d, "type"))
+        kind = read_or(joinpath(d, "type"))
         key = level == 1 ? (kind == "Data" ? :l1d : :skip) :
             level == 2 ? :l2 : level == 3 ? :l3 : :skip
         key === :skip && continue
         levels[key] = CacheLevel(
-            _parse_size(_read_or(joinpath(d, "size"))),
-            _int_or(joinpath(d, "ways_of_associativity")),
-            _int_or(joinpath(d, "coherency_line_size")),
-            _count_cpu_list(_read_or(joinpath(d, "shared_cpu_list"))),
+            parse_size(read_or(joinpath(d, "size"))),
+            int_or(joinpath(d, "coherency_line_size")),
+            count_cpu_list(read_or(joinpath(d, "shared_cpu_list"))),
         )
     end
     return (
@@ -143,25 +133,25 @@ function _cache_topology_linux()
     )
 end
 
-_sysctl_int(name) = try
+sysctl_int(name) = try
     something(tryparse(Int, chomp(read(`sysctl -n $name`, String))), 0)
 catch
     0
 end
 
 # macOS exposes no associativity; `cpusperl2` gives the L2 sharing.
-function _cache_topology_darwin()
-    line = _sysctl_int("hw.cachelinesize")
-    pick(a, b) = (v = _sysctl_int(a); v == 0 ? _sysctl_int(b) : v)
+function cache_topology_darwin()
+    line = sysctl_int("hw.cachelinesize")
+    pick(a, b) = (v = sysctl_int(a); v == 0 ? sysctl_int(b) : v)
     return (
-        l1d = CacheLevel(pick("hw.perflevel0.l1dcachesize", "hw.l1dcachesize"), 0, line, 1),
+        l1d = CacheLevel(pick("hw.perflevel0.l1dcachesize", "hw.l1dcachesize"), line, 1),
         l2 = CacheLevel(
-            pick("hw.perflevel0.l2cachesize", "hw.l2cachesize"), 0, line,
-            _sysctl_int("hw.perflevel0.cpusperl2")
+            pick("hw.perflevel0.l2cachesize", "hw.l2cachesize"), line,
+            sysctl_int("hw.perflevel0.cpusperl2")
         ),
         l3 = CacheLevel(
-            _sysctl_int("hw.l3cachesize"), 0, line,
-            _sysctl_int("hw.perflevel0.logicalcpu")
+            sysctl_int("hw.l3cachesize"), line,
+            sysctl_int("hw.perflevel0.logicalcpu")
         ),
     )
 end
@@ -174,25 +164,21 @@ Linux sysfs or macOS `sysctl`, or `nothing` if unavailable.
 """
 function cache_topology()
     return try
-        Sys.islinux() ? _cache_topology_linux() :
-            Sys.isapple() ? _cache_topology_darwin() : nothing
+        Sys.islinux() ? cache_topology_linux() :
+            Sys.isapple() ? cache_topology_darwin() : nothing
     catch
         nothing
     end
 end
 
-function _detect_target()
-    key = _detect_isa()
+function detect_target()
     topo = cache_topology()
     l1d, l2, l3 = topo === nothing ?
         (CacheLevel(), CacheLevel(), CacheLevel()) : (topo.l1d, topo.l2, topo.l3)
-    return TargetProfile(
-        key, Sys.ARCH, Sys.CPU_NAME,
-        _isa_vector_bytes(Val(key)), _isa_nregisters(Val(key)), l1d, l2, l3
-    )
+    return TargetProfile(detect_isa(), Sys.CPU_NAME, l1d, l2, l3)
 end
 
-const _TARGET = Ref{TargetProfile}(unknown_target())
+const TARGET = Ref{TargetProfile}(unknown_target())
 
 """
     target_profile() -> TargetProfile
@@ -200,19 +186,24 @@ const _TARGET = Ref{TargetProfile}(unknown_target())
 The [`TargetProfile`](@ref) detected for this process (all `:unknown` if
 detection failed).
 """
-target_profile() = _TARGET[]
+target_profile() = TARGET[]
 
-function _init_target!()
-    _TARGET[] = try
-        _detect_target()
-    catch
-        unknown_target()
-    end
-    return nothing
-end
+init_target!() = (TARGET[] = detect_target(); nothing)
+
+# The core's private L2 share, or 1 MB when undetected.
+l2_core_bytes(profile::TargetProfile) = profile.l2_share > 0 ? profile.l2_share : 1 << 20
+
+# Default `SIMD.Vec` lane count: one 256-bit register.
+default_lanewidth(::Type{Float64}) = 4
+default_lanewidth(::Type{Float32}) = 8
+
+# Lanes of `R` in one hardware vector register.
+vector_lanes(profile::TargetProfile, ::Type{R}) where {R} =
+    profile.vector_bytes > 0 ? profile.vector_bytes ÷ sizeof(R) : default_lanewidth(R)
+
+line_bytes(profile::TargetProfile) = profile.l1d.line > 0 ? profile.l1d.line : 64
 
-# Shared by the deinterleaving complex packer and the planar store: both pay
-# off only with 512-bit vector registers.
-@inline _complex_fastpath_isa_eligible(profile::TargetProfile) =
-    profile.vector_bytes == _isa_vector_bytes(Val(:avx512))
-@inline _complex_fastpath_isa_eligible() = _complex_fastpath_isa_eligible(target_profile())
+# A K step at least a page apart: a chain of demand misses no prefetcher
+# follows, which the K-order model charges this factor.
+const K_WALK_FAR_BYTES = 4096
+const K_WALK_FAR_PENALTY = 3
diff --git a/src/integrations/tensoroperations.jl b/src/integrations/tensoroperations.jl
index a10e588..fc5939c 100644
--- a/src/integrations/tensoroperations.jl
+++ b/src/integrations/tensoroperations.jl
@@ -1,7 +1,6 @@
 # TensorOperations backend. The engine itself knows nothing about TO.
 import TensorOperations as TO
 using TensorOperations: Index2Tuple, linearize
-import TupleTools
 using StridedViews: StridedView, isstrided
 
 """
@@ -32,40 +31,13 @@ end
 
 QuasiStridedBackend(; accumulator = nothing) = QuasiStridedBackend{accumulator}()
 
-# Task-local pool of workspaces, keyed by the compute type only: all complex
-# methods pack into `Vector{real(T)}` and `reserve!` is grow-only, so they can
-# share one.
-const _QS_WORKSPACE_KEY = :quasistrided_contract_workspaces
-
-@inline function _qs_workspace_pool()
-    return get!(task_local_storage(), _QS_WORKSPACE_KEY) do
-        return Dict{DataType, ContractWorkspace}()
-    end::Dict{DataType, ContractWorkspace}
-end
-
-@inline function _qs_task_workspace(::Type{T}) where {T}
-    pool = _qs_workspace_pool()
-    ws = get(pool, T, nothing)
-    # Both assertions are needed: without them the branches join to the abstract
-    # `ContractWorkspace`, and the call into `_planned` boxes its arguments.
-    ws === nothing || return ws::ContractWorkspace{T, Vector{real(T)}, Vector{T}}
-    return _qs_build_task_workspace!(pool, T)::ContractWorkspace{T, Vector{real(T)}, Vector{T}}
-end
-
-@noinline function _qs_build_task_workspace!(pool::Dict{DataType, ContractWorkspace}, ::Type{T}) where {T}
-    kernel = _default_kernel(T)
-    new_ws = ContractWorkspace(T, kernel, default_blocking(kernel), false, TO.DefaultAllocator())
-    pool[T] = new_ws
-    return new_ws
-end
-
 # TO's `pA`/`pB`/`pAB` -> one `Int` label per axis: `1:NoA` for A's open axes
 # (in `pA[1]` order), `NoA+1:NoA+NoB` for B's open axes, `-1:-1:-Nk` for the
 # contracted pairs; `indC` is then `linearize(pAB)`. For example
 #     pA = ((3,1,4),(2,5)), pB = ((3,1),(2,4)), pAB = ((4,2),(5,1,3))
 #     -> indA = (2,-1,1,3,-2), indB = (-2,4,-1,5), indC = (4,2,5,1,3).
 # No validation: `TO.argcheck_tensorcontract` runs first.
-function _qs_labels(pA::Index2Tuple, pB::Index2Tuple, pAB::Index2Tuple)
+function contraction_labels(pA::Index2Tuple, pB::Index2Tuple, pAB::Index2Tuple)
     NoA, Nk = TO.numout(pA), TO.numin(pA)
     qA = TupleTools.invperm(linearize(pA))
     qB = TupleTools.invperm(linearize(pB))
@@ -74,88 +46,44 @@ function _qs_labels(pA::Index2Tuple, pB::Index2Tuple, pAB::Index2Tuple)
     return indA, indB, linearize(pAB)
 end
 
-@noinline _qs_throw(msg::AbstractString) = throw(ArgumentError(msg))
-
-@noinline function _qs_check_eligible(C, A, B)
-    f = TO.tensorcontract!
-    all(isstrided, (A, B, C)) || _qs_throw(
-        "QuasiStridedBackend requires strided arrays for $f, got " *
-            join(map(typeof, (C, A, B)), ", ")
+@noinline function check_strided(C, A, B)
+    all(isstrided, (A, B, C)) || throw(
+        ArgumentError(
+            "QuasiStridedBackend requires strided arrays for $(TO.tensorcontract!), got " *
+                join(map(typeof, (C, A, B)), ", ")
+        )
     )
     return nothing
 end
 
-# Checks shared by both `tensorcontract!` methods. The eltype and conjugated-C
-# checks precede `plan_contract`'s so that a rejected call never acquires or
-# grows a pooled workspace (the workspace is an argument to `plan_contract`).
-@inline function _qs_prepare(C, A, pA, B, pB, pAB, α, β, accumulator)
-    T = _compute_type(eltype(A), eltype(B), eltype(C), accumulator)
-    _qs_check_eligible(C, A, B)
+# The aliasing check runs on the views in `planned`: Base has no `dataids` for
+# a `PermutedDimsArray`, but a `StridedView` forwards to its parent.
+@inline function prepare_contraction(C, A, pA, B, pB, pAB, α, β, accumulator)
+    T = compute_type(eltype(A), eltype(B), eltype(C), accumulator)
+    check_strided(C, A, B)
     TO.argcheck_tensorcontract(C, A, pA, B, pB, pAB)
     TO.dimcheck_tensorcontract(C, A, pA, B, pB, pAB)
-
-    Cv, Av, Bv = StridedView(C), StridedView(A), StridedView(B)
-    # On the wrapped views: Base has no `dataids` for `PermutedDimsArray`, but a
-    # `StridedView` forwards to its parent.
-    (Base.mightalias(Cv, Av) || Base.mightalias(Cv, Bv)) && _qs_throw(
-        "output tensor must not be aliased with an input tensor in $(TO.tensorcontract!)"
-    )
-    _qs_isconj(Cv, false) && _qs_throw(
-        "output tensor of $(TO.tensorcontract!) must not be a conjugated view: " *
-            "QuasiStrided writes through to the parent array and does not apply " *
-            "`StridedView.op` on store, so a conjugated `C` would be silently wrong"
-    )
-
-    # Dropping `Zero()`/`One()` is safe: the kernels branch on `iszero(alpha/beta)`.
-    indA, indB, indC = _qs_labels(pA, pB, pAB)
-    return Cv, Av, Bv, indA, indB, indC, convert(T, α), convert(T, β)
+    # `Zero()`/`One()` become numbers: `static_beta` recovers the β cases
+    # at the branch points.
+    indA, indB, indC = contraction_labels(pA, pB, pAB)
+    return StridedView(C), StridedView(A), StridedView(B), indA, indB, indC, convert(T, α), convert(T, β)
 end
 
-# Default allocator: pooled task-local workspace. `_planned` builds and runs the
-# plan behind the kernel dispatch barrier, so the plan is never boxed (as
-# `execute!(plan_contract(...), ...)` would be).
+# `planned` builds, runs and releases the plan behind the kernel dispatch
+# barrier, so the plan is never boxed (as `execute!(plan_contract(...), ...)`
+# would be). Bracketed with checkpoint/reset like TO's own `blas_contract!`.
 function TO.tensorcontract!(
         C::AbstractArray,
         A::AbstractArray, pA::Index2Tuple, conjA::Bool,
         B::AbstractArray, pB::Index2Tuple, conjB::Bool,
         pAB::Index2Tuple,
         α::Number, β::Number,
-        backend::QuasiStridedBackend{AC},
-        allocator::TO.DefaultAllocator = TO.DefaultAllocator()
+        backend::QuasiStridedBackend{AC}, allocator = TO.DefaultAllocator()
     ) where {AC}
-    Cv, Av, Bv, indA, indB, indC, α′, β′ = _qs_prepare(C, A, pA, B, pB, pAB, α, β, AC)
-    _planned(
-        _Execute(α′, β′), Cv, Av, indA, Bv, indB, indC,
-        nothing, conjA, conjB, nothing, nothing, nothing,
-        _qs_task_workspace(typeof(α′)), allocator, false, AC  # α′ has the compute type
-    )
-    return C
-end
-
-# Explicit allocator: a workspace scoped to this call, bracketed with
-# checkpoint/reset like TO's own `blas_contract!`. This method needs the plan
-# back to release it, hence `plan_contract` rather than `_planned`.
-function TO.tensorcontract!(
-        C::AbstractArray,
-        A::AbstractArray, pA::Index2Tuple, conjA::Bool,
-        B::AbstractArray, pB::Index2Tuple, conjB::Bool,
-        pAB::Index2Tuple,
-        α::Number, β::Number,
-        backend::QuasiStridedBackend{AC}, allocator
-    ) where {AC}
-    Cv, Av, Bv, indA, indB, indC, α′, β′ = _qs_prepare(C, A, pA, B, pB, pAB, α, β, AC)
+    Cv, Av, Bv, indA, indB, indC, α′, β′ = prepare_contraction(C, A, pA, B, pB, pAB, α, β, AC)
     checkpoint = TO.allocator_checkpoint!(allocator)
-    plan = plan_contract(
-        Cv, Av, indA, Bv, indB, indC;
-        conjA = conjA, conjB = conjB,
-        workspace = nothing, allocator = allocator, oracle = false, accumulator = AC
-    )
-    try
-        execute!(plan, α′, β′)
-    finally
-        release!(plan.workspace, allocator)
-        TO.allocator_reset!(allocator, checkpoint)
-    end
+    planned(Cv, Av, indA, Bv, indB, indC, α′, β′; conjA, conjB, allocator, accumulator = AC)
+    TO.allocator_reset!(allocator, checkpoint)
     return C
 end
 
diff --git a/src/layout/axis_group.jl b/src/layout/axis_group.jl
index 59ef8fd..4e107cc 100644
--- a/src/layout/axis_group.jl
+++ b/src/layout/axis_group.jl
@@ -14,7 +14,7 @@ struct AxisGroup{D, P}
         for (d, L) in enumerate(lengths)
             L >= 0 || throw(ArgumentError("AxisGroup lengths must be nonnegative, got lengths[$d] = $L"))
         end
-        _validate_axis_group_bounds(lengths, strides)
+        validate_axis_group_bounds(lengths, strides)
         return new{D, P}(lengths, strides)
     end
 end
@@ -22,80 +22,68 @@ end
 AxisGroup(lengths::NTuple{D, Int}, strides::NTuple{P, NTuple{D, Int}}) where {D, P} =
     AxisGroup{D, P}(lengths, strides)
 
-# Validation-time only; Int128 so nothing (incl. abs(typemin(Int))) can wrap.
-function _checked_axis_length(lengths::NTuple{D, Int}) where {D}
-    any(==(0), lengths) && return 0
-    q = one(Int128)
-    for L in lengths
-        q *= Int128(L)
-        q > Int128(typemax(Int)) &&
-            throw(OverflowError("AxisGroup cardinality (product of lengths) exceeds typemax(Int)"))
-    end
-    return Int(q)
-end
-
-function _validate_axis_group_bounds(
+# The checks that make all later offset arithmetic safe in plain `Int`: the
+# cardinality, and every map's offset range `sum((L[d]-1)*abs(S[d]))`.
+function validate_axis_group_bounds(
         lengths::NTuple{D, Int},
         strides::NTuple{P, NTuple{D, Int}}
     ) where {D, P}
-    Q = _checked_axis_length(lengths)
-    Q == 0 && return nothing
-    for (p, S) in enumerate(strides)
-        acc = zero(Int128)
+    any(iszero, lengths) && return nothing
+    foldl(checked_mul, lengths; init = 1)
+    for S in strides
+        acc = 0
         for d in 1:D
-            acc += Int128(lengths[d] - 1) * abs(Int128(S[d]))
-            acc > Int128(typemax(Int)) &&
-                throw(
-                OverflowError(
-                    "AxisGroup map $p: sum((L[d]-1)*abs(S[d])) exceeds typemax(Int); " *
-                        "this layout is not representable under the conservative offset-range bound"
-                )
-            )
+            lengths[d] > 1 || continue
+            acc = checked_add(acc, checked_mul(lengths[d] - 1, checked_abs(S[d])))
         end
     end
     return nothing
 end
 
-axis_length(g::AxisGroup) = _unchecked_axis_length(g.lengths)
-
-@inline function _unchecked_axis_length(lengths::NTuple{D, Int}) where {D}
-    q = 1
-    for L in lengths
-        q *= L
+"""
+    AxisGroup(labels, (ind1, v1), (ind2, v2))
+
+The two-map group of `labels` in operands `v1` and `v2`, whose axes carry the
+labels `ind1` and `ind2`. Throws a `DimensionMismatch` if a label's axis
+lengths differ.
+"""
+@inline function AxisGroup(
+        labels::NTuple{D, Int},
+        (ind1, v1)::Tuple{NTuple{N1, Int}, StridedView},
+        (ind2, v2)::Tuple{NTuple{N2, Int}, StridedView}
+    ) where {D, N1, N2}
+    # `Base.strides` on a `StridedView` rebuilds a tuple: call it once.
+    st1 = Base.strides(v1)
+    st2 = Base.strides(v2)
+    pos1 = ntuple(d -> findfirst(==(@inbounds labels[d]), ind1)::Int, Val(D))
+    pos2 = ntuple(d -> findfirst(==(@inbounds labels[d]), ind2)::Int, Val(D))
+    lens = ntuple(Val(D)) do d
+        l1 = size(v1, pos1[d])
+        l2 = size(v2, pos2[d])
+        l1 == l2 || throw_label_length((@inbounds labels[d]), l1, l2)
+        l1
     end
-    return q
+    s1 = ntuple(d -> st1[pos1[d]], Val(D))
+    s2 = ntuple(d -> st2[pos2[d]], Val(D))
+    return AxisGroup(lens, (s1, s2))
 end
 
-# Type-stable, stack-allocated "replace element i of an NTuple{N,Int}".
-@inline _tupleset(t::NTuple{N, Int}, i::Int, v::Int) where {N} =
-    ntuple(j -> ifelse(j == i, v, t[j]), Val(N))
+@noinline throw_label_length(label::Int, l1::Int, l2::Int) = throw(
+    DimensionMismatch("label $label has mismatched axis length: $l1 vs $l2")
+)
+
+axis_length(g::AxisGroup) = prod(g.lengths)
 
 # Not inline lambdas: a closure over loop-reassigned variables is boxed and
 # allocates every call.
-@inline function _add_offsets(offs::NTuple{P, Int}, g::AxisGroup{D, P}, d::Int, x::Int) where {D, P}
+@inline function add_offsets(offs::NTuple{P, Int}, g::AxisGroup{D, P}, d::Int, x::Int) where {D, P}
     return ntuple(p -> offs[p] + x * g.strides[p][d], Val(P))
 end
 
-@inline function _sub_reset_offsets(offs::NTuple{P, Int}, g::AxisGroup{D, P}, d::Int, Ld::Int) where {D, P}
+@inline function sub_reset_offsets(offs::NTuple{P, Int}, g::AxisGroup{D, P}, d::Int, Ld::Int) where {D, P}
     return ntuple(p -> offs[p] - (Ld - 1) * g.strides[p][d], Val(P))
 end
 
-function offsets(g::AxisGroup{D, P}, q::Int) where {D, P}
-    Q = axis_length(g)
-    (0 <= q < Q) || throw(BoundsError(g, q))
-    r = q
-    offs = ntuple(_ -> 0, Val(P))
-    for d in 1:D
-        L = g.lengths[d]
-        x = r % L
-        r = r ÷ L
-        if x != 0
-            offs = _add_offsets(offs, g, d, x)
-        end
-    end
-    return offs
-end
-
 function fill_offsets!(
         buffers::NTuple{P, Vector{Int}}, g::AxisGroup{D, P},
         first::Int, count::Int
@@ -112,10 +100,6 @@ function fill_offsets!(
         length(buffers[p]) >= count ||
             throw(DimensionMismatch("buffer $p has length $(length(buffers[p])), need at least $count"))
     end
-    for i in 1:P, j in (i + 1):P
-        buffers[i] === buffers[j] &&
-            throw(ArgumentError("buffers must be distinct Vector{Int} objects (buffers $i and $j alias)"))
-    end
 
     count == 0 && return buffers
 
@@ -127,9 +111,9 @@ function fill_offsets!(
         L = g.lengths[d]
         xd = r % L
         r = r ÷ L
-        x = _tupleset(x, d, xd)
+        x = Base.setindex(x, xd, d)
         if xd != 0
-            offs = _add_offsets(offs, g, d, xd)
+            offs = add_offsets(offs, g, d, xd)
         end
     end
 
@@ -146,12 +130,12 @@ function fill_offsets!(
             L = g.lengths[d]
             xd = x[d]
             if xd < L - 1
-                x = _tupleset(x, d, xd + 1)
-                offs = _add_offsets(offs, g, d, 1)
+                x = Base.setindex(x, xd + 1, d)
+                offs = add_offsets(offs, g, d, 1)
                 break
             else
-                x = _tupleset(x, d, 0)
-                offs = _sub_reset_offsets(offs, g, d, L)
+                x = Base.setindex(x, 0, d)
+                offs = sub_reset_offsets(offs, g, d, L)
                 d += 1
             end
         end
@@ -160,121 +144,37 @@ function fill_offsets!(
     return buffers
 end
 
-# Whether every map is a single ramp `offsets(g, q)[p] == q * steps[p]` (so the
-# offset buffer can be replaced by arithmetic). `steps` is meaningless when not.
-function affine_ramp(g::AxisGroup{D, P}) where {D, P}
-    zerosteps = ntuple(_ -> 0, Val(P))
-    steps = zerosteps
+# The step of map `p` if it is a single ramp, `offsets(g, q)[p] == q * step`
+# (0 for an empty group), else `nothing`.
+function map_ramp_step(g::AxisGroup{D}, p::Int) where {D}
+    step = 0
     run = 1
     started = false
     for d in 1:D
         L = g.lengths[d]
-        L == 0 && return (true, zerosteps)  # empty domain: vacuously a ramp.
-        L == 1 && continue                  # singleton: coordinate never advances.
-        Sd = ntuple(p -> g.strides[p][d], Val(P))
+        L == 0 && return 0
+        L == 1 && continue
+        S = g.strides[p][d]
         if !started
-            steps = Sd
+            step = S
             run = L
             started = true
         else
-            for p in 1:P
-                Int128(run) * Int128(steps[p]) == Int128(Sd[p]) ||
-                    return (false, zerosteps)
-            end
-            run *= L  # a sub-product of the validated cardinality
+            Int128(run) * Int128(step) == Int128(S) || return nothing
+            run *= L
         end
     end
-    return (true, steps)
-end
-
-# An offset interval of one map: `regular` iff `buffer[t+1] == base + t*stride`
-# for all `t < count`; otherwise read the buffer (valid until it is refilled).
-struct BlockDescriptor
-    base::Int
-    stride::Int
-    count::Int
-    regular::Bool
-end
-
-# Classifies `buffer[first+1 : first+count]`; an overflowing difference is irregular.
-function describe_block(buffer::Vector{Int}, first::Int, count::Int)
-    first >= 0 || throw(ArgumentError("first must be nonnegative, got $first"))
-    count >= 0 || throw(ArgumentError("count must be nonnegative, got $count"))
-    first + count <= length(buffer) ||
-        throw(
-        DimensionMismatch(
-            "buffer length $(length(buffer)) is less than first+count = $(first + count)"
-        )
-    )
-
-    count == 0 && return BlockDescriptor(0, 0, 0, true)
-
-    @inbounds base = buffer[first + 1]
-    count == 1 && return BlockDescriptor(base, 0, 1, true)
-
-    @inbounds stride, overflowed = Base.Checked.sub_with_overflow(buffer[first + 2], buffer[first + 1])
-    overflowed && return BlockDescriptor(base, 0, count, false)
-
-    @inbounds for t in 2:(count - 1)
-        diff, ovf = Base.Checked.sub_with_overflow(buffer[first + t + 1], buffer[first + t])
-        (ovf || diff != stride) && return BlockDescriptor(base, 0, count, false)
-    end
-
-    return BlockDescriptor(base, stride, count, true)
-end
-
-describe_block(buffer::Vector{Int}, count::Int) = describe_block(buffer, 0, count)
-
-function block_descriptors!(
-        buffers::NTuple{P, Vector{Int}}, g::AxisGroup{D, P},
-        first::Int, count::Int
-    ) where {D, P}
-    fill_offsets!(buffers, g, first, count)
-    return ntuple(p -> describe_block(buffers[p], count), Val(P))
+    return step
 end
 
-# Same offset sequence with singleton dims dropped and adjacent dims folded
-# where `next_stride[p] == length * stride[p]` for every map. Never reorders.
-function normalize_group(g::AxisGroup{D, P}) where {D, P}
-    axis_length(g) == 0 && return g
-
-    dims = Tuple{Int, NTuple{P, Int}}[]
-    for d in 1:D
-        L = g.lengths[d]
-        if L != 1
-            push!(dims, (L, ntuple(p -> g.strides[p][d], P)))
-        end
-    end
-
-    if isempty(dims)
-        emptylengths = NTuple{0, Int}()
-        emptystrides = ntuple(_ -> NTuple{0, Int}(), P)
-        return AxisGroup(emptylengths, emptystrides)
-    end
-
-    folded = Tuple{Int, NTuple{P, Int}}[]
-    curL, curS = dims[1]
-    for i in 2:length(dims)
-        nextL, nextS = dims[i]
-        foldable = true
-        for p in 1:P
-            if Int128(curL) * Int128(curS[p]) != Int128(nextS[p])
-                foldable = false
-                break
-            end
-        end
-        if foldable
-            curL = curL * nextL
-        else
-            push!(folded, (curL, curS))
-            curL, curS = nextL, nextS
-        end
+# Whether every map is a single ramp, so that the offset buffer can be replaced
+# by arithmetic, and the steps (meaningless when not).
+function affine_ramp(g::AxisGroup{D, P}) where {D, P}
+    steps = ntuple(_ -> 0, Val(P))
+    for p in 1:P
+        step = map_ramp_step(g, p)
+        step === nothing && return (false, ntuple(_ -> 0, Val(P)))
+        steps = Base.setindex(steps, step, p)
     end
-    push!(folded, (curL, curS))
-
-    newD = length(folded)
-    newlengths = ntuple(i -> folded[i][1], newD)
-    newstrides = ntuple(p -> ntuple(i -> folded[i][2][p], newD), P)
-
-    return AxisGroup(newlengths, newstrides)
+    return (true, steps)
 end
diff --git a/src/layout/pair_group.jl b/src/layout/pair_group.jl
deleted file mode 100644
index ab5b878..0000000
--- a/src/layout/pair_group.jl
+++ /dev/null
@@ -1,24 +0,0 @@
-# The two-map AxisGroup for one of M/N/K from label positions in a pair of
-# operands: (v1, v2) is (A, C), (B, C) or (A, B). `labels` is an `NTuple{D,Int}`
-# so the group is a concrete `AxisGroup{D,2}`; a runtime-length list would be
-# heap-boxed and allocate per group.
-@inline function _build_pair_group(
-        labels::NTuple{D, Int},
-        ind1::NTuple{N1, Int}, v1::StridedView,
-        ind2::NTuple{N2, Int}, v2::StridedView
-    ) where {D, N1, N2}
-    # `Base.strides` on a `StridedView` rebuilds a tuple: call it once.
-    st1 = Base.strides(v1)
-    st2 = Base.strides(v2)
-    pos1 = ntuple(d -> findfirst(==(@inbounds labels[d]), ind1)::Int, Val(D))
-    pos2 = ntuple(d -> findfirst(==(@inbounds labels[d]), ind2)::Int, Val(D))
-    lens = ntuple(Val(D)) do d
-        l1 = size(v1, pos1[d])
-        l2 = size(v2, pos2[d])
-        l1 == l2 || _throw_label_length((@inbounds labels[d]), l1, l2)
-        l1
-    end
-    s1 = ntuple(d -> st1[pos1[d]], Val(D))
-    s2 = ntuple(d -> st2[pos2[d]], Val(D))
-    return AxisGroup(lens, (s1, s2))
-end
diff --git a/src/layout/tiles.jl b/src/layout/tiles.jl
index bca8045..5a50401 100644
--- a/src/layout/tiles.jl
+++ b/src/layout/tiles.jl
@@ -1,8 +1,10 @@
-# Tile axes and tiles. Coordinates and addresses are zero-based (storage index
-# = address + 1); a tile's `base` is the address of its logical origin.
+# Tile axes and tiles. Addresses are zero-based (storage index = address + 1),
+# coordinates one-based; a tile's `base` is the address its offsets are
+# relative to. A tile axis is the vector of offsets of its rows or columns: an
+# `AffineAxis`, a `ScatterAxis`, or any `AbstractVector{Int}`.
 
-# `t -> base + t*stride`.
-struct AffineAxis
+# Offsets `base + (t - 1) * stride`. Not a `StepRange`: the stride may be zero.
+struct AffineAxis <: AbstractVector{Int}
     base::Int
     stride::Int
     count::Int
@@ -13,126 +15,106 @@ struct AffineAxis
     end
 end
 
-# `t -> offsets[t+1]`, borrowing `offsets`.
-struct ScatterAxis{V <: AbstractVector{Int}}
-    offsets::V
-    count::Int
+Base.size(ax::AffineAxis) = (ax.count,)
+Base.IndexStyle(::Type{AffineAxis}) = IndexLinear()
 
-    function ScatterAxis(offsets::V, count::Int) where {V <: AbstractVector{Int}}
-        count >= 0 || throw(ArgumentError("ScatterAxis count must be nonnegative, got $count"))
-        count <= length(offsets) ||
-            throw(
-            DimensionMismatch(
-                "ScatterAxis: offsets has length $(length(offsets)), " *
-                    "need at least count = $count"
-            )
-        )
-        return new{V}(offsets, count)
-    end
+@inline function Base.getindex(ax::AffineAxis, t::Int)
+    @boundscheck checkbounds(ax, t)
+    return ax.base + (t - 1) * ax.stride
+end
+
+function Base.extrema(ax::AffineAxis)
+    isempty(ax) && throw(ArgumentError("extrema of an empty AffineAxis"))
+    last = Base.Checked.checked_add(ax.base, Base.Checked.checked_mul(ax.count - 1, ax.stride))
+    return minmax(ax.base, last)
 end
 
-# `ScatterAxis` over a borrowed raw pointer, so that it is `isbits` and
-# `Union{AffineAxis, PtrScatterAxis}` needs no heap box in the driver.
-struct PtrScatterAxis
+# Offsets read from a borrowed buffer, valid while its owner is
+# `GC.@preserve`d. A pointer rather than a `view`, so that it is `isbits` and a
+# `Union{AffineAxis, ScatterAxis}` is never heap-boxed.
+struct ScatterAxis <: AbstractVector{Int}
     offsets::Ptr{Int}
     count::Int
+end
 
-    function PtrScatterAxis(offsets::Ptr{Int}, count::Int)
-        count >= 0 ||
-            throw(ArgumentError("PtrScatterAxis count must be nonnegative, got $count"))
-        return new(offsets, count)
-    end
+Base.size(ax::ScatterAxis) = (ax.count,)
+Base.IndexStyle(::Type{ScatterAxis}) = IndexLinear()
+
+@inline function Base.getindex(ax::ScatterAxis, t::Int)
+    @boundscheck checkbounds(ax, t)
+    return unsafe_load(ax.offsets, t)
 end
 
-const Axis = Union{AffineAxis, ScatterAxis, PtrScatterAxis}
+# An offset interval of one map: `regular` iff `buffer[t+1] == base + t*stride`
+# for all `t < count`; otherwise read the buffer (valid until it is refilled).
+struct BlockDescriptor
+    base::Int
+    stride::Int
+    count::Int
+    regular::Bool
+end
+
+# Classifies `buffer[first+1 : first+count]`. A difference that overflows is
+# irregular: a regular block's offset range is computed as `base + t*stride`.
+function describe_block(buffer::Vector{Int}, first::Int, count::Int)
+    first >= 0 || throw(ArgumentError("first must be nonnegative, got $first"))
+    count >= 0 || throw(ArgumentError("count must be nonnegative, got $count"))
+    count <= length(buffer) - first ||
+        throw(DimensionMismatch("buffer length $(length(buffer)) is less than first + count = $first + $count"))
 
-axis_length(ax::AffineAxis) = ax.count
-axis_length(ax::ScatterAxis) = ax.count
-axis_length(ax::PtrScatterAxis) = ax.count
+    count == 0 && return BlockDescriptor(0, 0, 0, true)
 
-@inline axis_offset(ax::AffineAxis, t::Int) = ax.base + t * ax.stride
-@inline axis_offset(ax::ScatterAxis, t::Int) = @inbounds ax.offsets[t + 1]
-@inline axis_offset(ax::PtrScatterAxis, t::Int) =
-    unsafe_load(ax.offsets + sizeof(Int) * t)
+    @inbounds base = buffer[first + 1]
+    count == 1 && return BlockDescriptor(base, 0, 1, true)
 
-function axis_from_descriptor(descriptor::BlockDescriptor, buffer::Vector{Int}, first::Int)
-    if descriptor.regular
-        return AffineAxis(descriptor.base, descriptor.stride, descriptor.count)
-    else
-        return ScatterAxis(view(buffer, (first + 1):(first + descriptor.count)), descriptor.count)
+    @inbounds stride, overflowed = Base.Checked.sub_with_overflow(buffer[first + 2], buffer[first + 1])
+    overflowed && return BlockDescriptor(base, 0, count, false)
+
+    @inbounds for t in 2:(count - 1)
+        diff, ovf = Base.Checked.sub_with_overflow(buffer[first + t + 1], buffer[first + t])
+        (ovf || diff != stride) && return BlockDescriptor(base, 0, count, false)
     end
+
+    return BlockDescriptor(base, stride, count, true)
 end
 
-axis_from_descriptor(descriptor::BlockDescriptor, buffer::Vector{Int}) =
-    axis_from_descriptor(descriptor, buffer, 0)
+describe_block(buffer::Vector{Int}, count::Int) = describe_block(buffer, 0, count)
 
-# Logical `(i, j)` addresses `base + row_offset(i) + col_offset(j)`.
-struct QSTile{S, R <: Axis, C <: Axis}
+function block_descriptors!(
+        buffers::NTuple{P, Vector{Int}}, g::AxisGroup{D, P},
+        first::Int, count::Int
+    ) where {D, P}
+    fill_offsets!(buffers, g, first, count)
+    return ntuple(p -> describe_block(buffers[p], count), Val(P))
+end
+
+# Logical `(i, j)` addresses `base + rows[i] + cols[j]`.
+struct Tile{S, R <: AbstractVector{Int}, C <: AbstractVector{Int}}
     storage::S
     base::Int
     rows::R
     cols::C
 end
 
-const SourceTile = QSTile
-const DestinationTile = QSTile
-
-nrows(tile::QSTile) = axis_length(tile.rows)
-ncols(tile::QSTile) = axis_length(tile.cols)
+Base.size(tile::Tile) = (length(tile.rows), length(tile.cols))
+Base.transpose(tile::Tile) = Tile(tile.storage, tile.base, tile.cols, tile.rows)
 
-@inline function tile_offset(tile::QSTile, i::Int, j::Int)
-    return tile.base + axis_offset(tile.rows, i) + axis_offset(tile.cols, j)
-end
+Base.@propagate_inbounds Base.getindex(tile::Tile, i::Int, j::Int) =
+    tile.storage[tile.base + tile.rows[i] + tile.cols[j] + 1]
 
-@inline function tile_load(tile::QSTile, i::Int, j::Int)
-    return @inbounds tile.storage[tile_offset(tile, i, j) + 1]
-end
-
-@inline function tile_store!(tile::QSTile, i::Int, j::Int, v)
-    @inbounds tile.storage[tile_offset(tile, i, j) + 1] = v
+Base.@propagate_inbounds function Base.setindex!(tile::Tile, v, i::Int, j::Int)
+    tile.storage[tile.base + tile.rows[i] + tile.cols[j] + 1] = v
     return tile
 end
 
 # Bounds checks run once per tile (or per macro block) before the unchecked
 # hot paths. Offset ranges are `(lo, hi)`, `(0, -1)` when empty.
 
-function axis_offset_range(ax::AffineAxis)
-    ax.count == 0 && return (0, -1)
-    lo128 = Int128(ax.base)
-    hi128 = Int128(ax.base) + Int128(ax.count - 1) * Int128(ax.stride)
-    lo128, hi128 = minmax(lo128, hi128)
-    (typemin(Int) <= lo128 && hi128 <= typemax(Int)) ||
-        throw(OverflowError("axis_offset_range: affine axis range not representable as Int"))
-    return (Int(lo128), Int(hi128))
-end
-
-function axis_offset_range(ax::ScatterAxis)
-    ax.count == 0 && return (0, -1)
-    prefix = view(ax.offsets, 1:ax.count)
-    return (Int(minimum(prefix)), Int(maximum(prefix)))
-end
-
-function axis_offset_range(ax::PtrScatterAxis)
-    ax.count == 0 && return (0, -1)
-    lo = hi = unsafe_load(ax.offsets)
-    for t in 1:(ax.count - 1)
-        v = axis_offset(ax, t)
-        lo, hi = min(lo, v), max(hi, v)
-    end
-    return (lo, hi)
-end
-
-# `axis_offset_range` of the axis `d` describes, without materializing it.
+# `extrema` of the axis `d` describes, without materializing it.
 function descriptor_offset_range(d::BlockDescriptor, buffer::Vector{Int}, first::Int)
     d.count == 0 && return (0, -1)
-    d.regular && return axis_offset_range(AffineAxis(d.base, d.stride, d.count))
-    lo = hi = buffer[first + 1]
-    for t in 1:(d.count - 1)
-        v = buffer[first + t + 1]
-        lo = min(lo, v)
-        hi = max(hi, v)
-    end
-    return (lo, hi)
+    d.regular && return extrema(AffineAxis(d.base, d.stride, d.count))
+    return extrema(@view buffer[(first + 1):(first + d.count)])
 end
 
 # Exact, not conservative, for any rectangular (row-set x column-set) region:
@@ -151,18 +133,12 @@ function checked_span_bounds(
     return nothing
 end
 
-function checked_tile_storage_bounds(base::Int, rows::Axis, cols::Axis, storage_length::Int)
-    (axis_length(rows) == 0 || axis_length(cols) == 0) && return nothing
-    return checked_span_bounds(
-        base, axis_offset_range(rows), axis_offset_range(cols), storage_length
+function checked_tile_storage_bounds(
+        base::Int, rows::AbstractVector{Int}, cols::AbstractVector{Int}, storage_length::Int
     )
+    (isempty(rows) || isempty(cols)) && return nothing
+    return checked_span_bounds(base, extrema(rows), extrema(cols), storage_length)
 end
 
-checked_tile_storage_bounds(tile::QSTile) =
+checked_tile_storage_bounds(tile::Tile) =
     checked_tile_storage_bounds(tile.base, tile.rows, tile.cols, length(tile.storage))
-
-# Whether an axis steps through storage one element at a time. Deliberately no
-# fallback method: an unknown axis type must be a MethodError, not `false`.
-_unit_stride_rows(ax::AffineAxis) = ax.stride == 1
-_unit_stride_rows(::ScatterAxis) = false
-_unit_stride_rows(::PtrScatterAxis) = false
diff --git a/src/microkernels/fmaddsub.jl b/src/microkernels/fmaddsub.jl
deleted file mode 100644
index 48ec904..0000000
--- a/src/microkernels/fmaddsub.jl
+++ /dev/null
@@ -1,281 +0,0 @@
-# FMAddSub (interleaved-accumulator) complex microkernel. One accumulator plane
-# in 1m's layout (lanes `(2u, 2u+1)` are `(re, im)` of one complex row), updated
-# per (A-vector, B-column) pair by two chained x86 `vfmaddsub` ops:
-#
-#     acc = fmaddsub(a, br, fmaddsub(swap(a), bi, acc))
-#
-# where `fmaddsub(x, y, c)` is `x*y - c` in even (0-based) lanes and `x*y + c`
-# in odd lanes, `a = [ar0, ai0, ...]`, `swap(a) = [ai0, ar0, ...]`. The two
-# sign flips compose back to an accumulation:
-#
-#     even:  ar*br - (ai*bi - c_re)  =  c_re + ar*br - ai*bi
-#     odd:   ai*br + (ar*bi + c_im)  =  c_im + ai*br + ar*bi
-#
-# The lane-parity sign needs re/im of one element in adjacent lanes, hence
-# `InterleavedFormat` A; B is read as broadcast scalars, so it stays planar.
-# Same FMA count as planar and 1m, plus one pair-swap per A vector per K step.
-
-using SIMD: Vec, shufflevector
-
-"""
-    FMAddSubKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
-
-Interleaved-accumulator complex microkernel using x86 `vfmaddsub`, over
-`SIMD.Vec{W,real(T)}` lanes with `InterleavedFormat` A and `PlanarFormat` B.
-`2MR` must be a multiple of `W`, and `W` must be even. The default for small-M
-complex contractions on AVX-512.
-"""
-struct FMAddSubKernel{MR, NR, T, W} <: DescriptorKernel{MR, NR, T}
-    descriptor::ComplexKernelDescriptor{MR, NR, T, InterleavedFormat, PlanarFormat}
-
-    function FMAddSubKernel{MR, NR, T, W}(
-            descriptor::ComplexKernelDescriptor{MR, NR, T, InterleavedFormat, PlanarFormat}
-        ) where {MR, NR, T, W}
-        _check_vector_shape("FMAddSubKernel", 2 * MR, W, true)
-        return new{MR, NR, T, W}(descriptor)
-    end
-end
-
-function FMAddSubKernel(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {MR, NR, T, W}
-    T <: Complex ||
-        throw(ArgumentError("FMAddSubKernel requires a complex element type, got $T"))
-    return FMAddSubKernel{MR, NR, T, W}(
-        ComplexKernelDescriptor(Val(MR), Val(NR), T, InterleavedFormat(), PlanarFormat())
-    )
-end
-function FMAddSubKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T}
-    T <: Complex ||
-        throw(ArgumentError("FMAddSubKernel requires a complex element type, got $T"))
-    return FMAddSubKernel(Val(MR), Val(NR), T, Val(_default_lanewidth(real(T))))
-end
-
-complex_method(::FMAddSubKernel) = FMAddSubMethod()
-lanewidth(::FMAddSubKernel{MR, NR, T, W}) where {MR, NR, T, W} = W
-
-# `x*y - c` in even lanes, `x*y + c` in odd lanes, each one fused rounding.
-# Generic IR (`fneg` + two `llvm.fma` + a blend), which the X86 backend folds
-# into one `vfmaddsub` wherever FMA3 exists (and elsewhere stays correct).
-# GUARDRAIL: the SIMD.jl spelling `shufflevector(muladd(x, y, -c), muladd(x, y,
-# c), ...)` also selects `vfmaddsub` but leaves a dead stack store of the
-# accumulator in the K loop, every step.
-@generated function _fmaddsub(x::Vec{N, R}, y::Vec{N, R}, c::Vec{N, R}) where {N, R}
-    R === Float64 || R === Float32 ||
-        return :(throw(ArgumentError("_fmaddsub: unsupported lane type $R")))
-    ty = "<$N x $(R === Float64 ? "double" : "float")>"
-    fn = "llvm.fma.v$(N)$(R === Float64 ? "f64" : "f32")"
-    # lane k: even -> `s` (x*y - c); odd -> `d` (x*y + c), index N + k.
-    mask = join(("i32 $(iseven(k) ? k : N + k)" for k in 0:(N - 1)), ", ")
-    ir = """
-    declare $ty @$fn($ty, $ty, $ty)
-    define $ty @entry($ty %x, $ty %y, $ty %c) #0 {
-    top:
-      %nc = fneg $ty %c
-      %s = call $ty @$fn($ty %x, $ty %y, $ty %nc)
-      %d = call $ty @$fn($ty %x, $ty %y, $ty %c)
-      %r = shufflevector $ty %s, $ty %d, <$N x i32> <$mask>
-      ret $ty %r
-    }
-    attributes #0 = { alwaysinline }
-    """
-    VT = NTuple{N, VecElement{R}}
-    return quote
-        Base.@_inline_meta
-        Vec{$N, $R}(
-            Base.llvmcall(($ir, "entry"), $VT, Tuple{$VT, $VT, $VT}, x.data, y.data, c.data)
-        )
-    end
-end
-
-# `[x1, x0, x3, x2, ...]`: one in-lane `vshufpd`/`vpermilps`.
-@generated function _swap_pairs(x::Vec{N, R}) where {N, R}
-    iseven(N) || return :(throw(ArgumentError("_swap_pairs: expected even N, got $N")))
-    idx = ntuple(k -> isodd(k) ? k : k - 2, N)
-    return :(Base.@_inline_meta; shufflevector(x, Val($idx)))
-end
-
-function zero_accumulator(kernel::FMAddSubKernel{MR, NR, T, W}) where {MR, NR, T, W}
-    z = zero(Vec{W, real(T)})
-    return ntuple(_ -> z, Val(((2 * MR) ÷ W) * NR))
-end
-
-# The INNER op must be the `swap(a) * bi` one: only the inner product is
-# subtracted in the real lanes. Reversed, the real part is `ai*bi - ar*br`.
-@generated function _accumulate_step_fmaddsub(
-        kernel::FMAddSubKernel{MR, NR, T, W}, acc::NTuple{NA, Vec{W, R}},
-        packed_a::PA, packed_b::PB, p::Int
-    ) where {MR, NR, T, W, R, NA, PA, PB}
-    MV = (2 * MR) ÷ W
-    _check_acc(:_accumulate_step_fmaddsub, R, T, NA, MV * NR)
-
-    av = [Symbol(:a, v) for v in 0:(MV - 1)]
-    sv = [Symbol(:s, v) for v in 0:(MV - 1)]
-    brv = [Symbol(:br, j) for j in 0:(NR - 1)]
-    biv = [Symbol(:bi, j) for j in 0:(NR - 1)]
-
-    load_a = Any[]
-    for v in 0:(MV - 1)
-        push!(
-            load_a,
-            :(
-                $(av[v + 1]) = panel_vload(
-                    Vec{$W, $R}, packed_a, packed_a_plane_offset(kernel, 0, $(v * W), p)
-                )
-            )
-        )
-        push!(load_a, :($(sv[v + 1]) = _swap_pairs($(av[v + 1]))))
-    end
-
-    load_b = Any[]
-    for j in 0:(NR - 1)
-        push!(load_b, :((br_s, bi_s) = _b_step_load2(packed_b, kernel, $j, p)))
-        push!(load_b, :($(brv[j + 1]) = Vec{$W, $R}(br_s)))
-        push!(load_b, :($(biv[j + 1]) = Vec{$W, $R}(bi_s)))
-    end
-
-    acc_exprs = Vector{Any}(undef, NA)
-    for j in 0:(NR - 1), v in 0:(MV - 1)
-        idx = v + MV * j + 1
-        acc_exprs[idx] = :(
-            _fmaddsub(
-                $(av[v + 1]), $(brv[j + 1]),
-                _fmaddsub($(sv[v + 1]), $(biv[j + 1]), acc[$idx])
-            )
-        )
-    end
-
-    return quote
-        Base.@_inline_meta
-        @inbounds begin
-            $(load_a...)
-            $(load_b...)
-            return $(Expr(:tuple, acc_exprs...))
-        end
-    end
-end
-
-function Base.accumulate(
-        kernel::FMAddSubKernel{MR, NR, T, W}, acc::NTuple{NA, Vec{W, R}},
-        packed_a::PA, packed_b::PB, kc::Int
-    ) where {MR, NR, T, W, R, NA, PA, PB}
-    kc == 0 && return acc
-    kc > 0 || _throw_negative_kc(:accumulate, kc)
-    @inbounds for p in 0:(kc - 1)
-        acc = _accumulate_step_fmaddsub(kernel, acc, packed_a, packed_b, p)
-    end
-    return acc
-end
-
-# `p - q` in even lanes, `p + q` in odd lanes: Base's unfused complex `*` on
-# interleaved data.
-@generated function _addsub(p::Vec{N, R}, q::Vec{N, R}) where {N, R}
-    iseven(N) || return :(throw(ArgumentError("_addsub: expected even N, got $N")))
-    idx = ntuple(k -> iseven(k - 1) ? k - 1 : N + k - 1, N)
-    return :(Base.@_inline_meta; shufflevector(p - q, p + q, Val($idx)))
-end
-
-# One full `W÷2`-row block, already in `Complex`'s memory order, so no
-# interleave shuffle. Base's `Complex` expression trees in lanes, as planar's
-# `_planar_store_block!`:
-#     beta == 0:  addsub(ar*r, ai*swap(r))
-#     beta == 1:  fmaddsub(ar, r, fmaddsub(ai, swap(r), C))
-#     otherwise:  as beta == 1 with C := addsub(br*C, bi*swap(C))
-@inline function _fmaddsub_store_block!(
-        sp::Ptr{RC}, at::Int, r::Vec{W, R},
-        ar::Vec{W, R}, ai::Vec{W, R}, br::Vec{W, R}, bi::Vec{W, R},
-        beta::Complex{R}
-    ) where {RC, R, W}
-    s = _swap_pairs(r)
-    if iszero(beta)
-        new = _addsub(ar * r, ai * s)
-    else
-        old = convert(Vec{W, R}, vload(Vec{W, RC}, sp + sizeof(RC) * at))
-        x = isone(beta) ? old : _addsub(br * old, bi * _swap_pairs(old))
-        new = _fmaddsub(ar, r, _fmaddsub(ai, s, x))
-    end
-    vstore(convert(Vec{W, RC}, new), sp + sizeof(RC) * at)
-    return nothing
-end
-
-# Same unroll and full-block / row-tail split as `_store_tile_planar_vector!`.
-@generated function _store_tile_fmaddsub_vector!(
-        destination::QSTile{S, <:AffineAxis}, acc::NTuple{NV, Vec{W, R}},
-        alpha::T, beta::T, kernel::DescriptorKernel{MR, NR, T},
-        m::Int, n::Int
-    ) where {S, MR, NR, T, W, R, NV}
-    # The pointer reinterpretation is only sound on dense rank-1 complex storage.
-    S <: DenseVector && _lane_convertible(eltype(S), T) ||
-        throw(ArgumentError("_store_tile_fmaddsub_vector!: storage $S is not a dense vector convertible to $T"))
-    RC = real(eltype(S))
-    iseven(W) || throw(ArgumentError("_store_tile_fmaddsub_vector!: requires an even W, got $W"))
-    MV = (2 * MR) ÷ W
-    _check_acc(:_store_tile_fmaddsub_vector!, R, T, NV, MV * NR)
-    HW = W ÷ 2
-
-    blocks = Any[]
-    for j in 0:(NR - 1)
-        vblocks = Any[]
-        for v in 0:(MV - 1)
-            idx = v + MV * j + 1
-            push!(
-                vblocks, quote
-                    vec = acc[$idx]
-                    if $((v + 1) * HW) <= m
-                        _fmaddsub_store_block!(
-                            sp, 2 * (colbase + $(v * HW)), vec, ar, ai, br, bi, beta
-                        )
-                    elseif $(v * HW) < m
-                        for u in 0:$(HW - 1)
-                            i = $(v * HW) + u
-                            i < m || break
-                            _axpby_at!(
-                                storage, colbase + i + 1, alpha,
-                                Complex(vec[2 * u + 1], vec[2 * u + 2]), beta
-                            )
-                        end
-                    end
-                end
-            )
-        end
-        push!(
-            blocks, quote
-                if $j < n
-                    colbase = rowbase0 + axis_offset(cols, $j)  # zero-based (0, j)
-                    $(vblocks...)
-                end
-            end
-        )
-    end
-
-    return quote
-        storage = destination.storage
-        cols = destination.cols
-        rowbase0 = destination.base + destination.rows.base
-        ar = Vec{$W, $R}(real(alpha))
-        ai = Vec{$W, $R}(imag(alpha))
-        br = Vec{$W, $R}(real(beta))
-        bi = Vec{$W, $R}(imag(beta))
-        GC.@preserve storage begin
-            sp = reinterpret(Ptr{$RC}, pointer(storage))
-            @inbounds begin
-                $(blocks...)
-            end
-        end
-        return destination
-    end
-end
-
-# Not `@inline`, unlike the real and planar stores: inlining it cost time
-# (code growth).
-function store_tile!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, R}},
-        alpha::T, beta::T, kernel::FMAddSubKernel{MR, NR, T, W}
-    ) where {MR, NR, T, W, R, NV}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-
-    if _complex_vector_eligible(destination, T)
-        return _store_tile_fmaddsub_vector!(destination, acc, alpha, beta, kernel, m, n)
-    end
-
-    return _store_tile_lanepair!(destination, acc, alpha, beta, kernel, m, n)
-end
diff --git a/src/microkernels/interface.jl b/src/microkernels/interface.jl
index f7ce9a7..3cdd3b5 100644
--- a/src/microkernels/interface.jl
+++ b/src/microkernels/interface.jl
@@ -1,97 +1,64 @@
-# What every microkernel shares. Each kernel file implements only
-# `zero_accumulator`, `accumulate` and `store_tile!`, with one contract:
-#   * `accumulate(kernel, acc, packed_a, packed_b, kc)` adds `kc` K steps to
-#     `acc`; `kc == 0` returns `acc` without reading the panels.
-#   * `store_tile!(dest, acc, alpha, beta, kernel)` writes `alpha*acc + beta*C`
-#     over the valid rectangle only: `alpha == 0` never reads `acc`, `beta == 0`
-#     never reads old `C`, padding lanes are never read.
-# The vector kernels match `ScalarKernel` only to within rounding (FMA grouping
-# differs), never bitwise.
-
-# Kernels wrapping a descriptor as `.descriptor`; the accessors forward once here.
-abstract type DescriptorKernel{MR, NR, T} end
-
-# Which complex-arithmetic method a kernel implements, as singletons so blocking
-# and the shape menus dispatch on it. No method ranking is hardcoded: planar is
-# the default, 1m and fmaddsub are used only when named (plus fmaddsub for the
-# AVX-512 small-M demotion, `_small_m_shape` in src/planning/kernel_selection.jl).
-abstract type ComplexMethod end
-struct RealMethod <: ComplexMethod end      # what a real kernel reports
-struct PlanarMethod <: ComplexMethod end    # split re/im planes, 4 real FMAs per MAC
-struct OneMMethod <: ComplexMethod end      # Van Zee's 1m: a real 2mr x nr kernel
-struct FMAddSubMethod <: ComplexMethod end  # interleaved A, x86 `vfmaddsub`
-struct ComplexRealMethod <: ComplexMethod end  # complex A, real B: the real kernel on 2MR rows
-struct RealComplexMethod <: ComplexMethod end  # real A, complex B: the real kernel on 2NR columns
-
-# Reals per packed A / B element. Blocking divides the real `mc`/`nc` by these,
-# so every method gets the same packed byte budget.
-a_reals(::RealMethod) = 1
-b_reals(::RealMethod) = 1
-a_reals(::PlanarMethod) = 2
-b_reals(::PlanarMethod) = 2
-a_reals(::OneMMethod) = 4
-b_reals(::OneMMethod) = 2
-a_reals(::FMAddSubMethod) = 2
-b_reals(::FMAddSubMethod) = 2
-a_reals(::ComplexRealMethod) = 2
-b_reals(::ComplexRealMethod) = 1
-a_reals(::RealComplexMethod) = 1
-b_reals(::RealComplexMethod) = 2
-
-# Accumulator planes held live: planar keeps separate re/im planes.
-accumulator_planes(::RealMethod) = 1
-accumulator_planes(::PlanarMethod) = 2
-accumulator_planes(::OneMMethod) = 1
-accumulator_planes(::FMAddSubMethod) = 1
-accumulator_planes(::ComplexRealMethod) = 1
-accumulator_planes(::RealComplexMethod) = 1
-
-complex_method(::Any) = RealMethod()
-
-realtype(k::DescriptorKernel) = realtype(k.descriptor)
-packed_a_per_k(k::DescriptorKernel) = packed_a_per_k(k.descriptor)
-packed_b_per_k(k::DescriptorKernel) = packed_b_per_k(k.descriptor)
-a_format(k::DescriptorKernel) = a_format(k.descriptor)
-b_format(k::DescriptorKernel) = b_format(k.descriptor)
-mr(k::DescriptorKernel) = mr(k.descriptor)
-nr(k::DescriptorKernel) = nr(k.descriptor)
-scalartype(k::DescriptorKernel) = scalartype(k.descriptor)
-packed_a_offset(k::DescriptorKernel, i::Int, p::Int) = packed_a_offset(k.descriptor, i, p)
-packed_b_offset(k::DescriptorKernel, j::Int, p::Int) = packed_b_offset(k.descriptor, j, p)
-packed_a_length(k::DescriptorKernel, kc::Int) = packed_a_length(k.descriptor, kc)
-packed_b_length(k::DescriptorKernel, kc::Int) = packed_b_length(k.descriptor, kc)
-# Only these resolve for a complex descriptor; the single-plane offsets above
-# are a MethodError there, by design.
-@inline packed_a_plane_offset(k::DescriptorKernel, plane::Int, i::Int, p::Int) =
-    packed_a_plane_offset(k.descriptor, plane, i, p)
-@inline packed_b_plane_offset(k::DescriptorKernel, plane::Int, j::Int, p::Int) =
-    packed_b_plane_offset(k.descriptor, plane, j, p)
-
-# GUARDRAIL: every forwarded argument needs its OWN bound type parameter; an
-# unbound one makes the call dynamically dispatched and allocating on every
-# pack. `V` is unconstrained so a `PackedPanel` forwards too.
-pack_a!(
-    packed::V, source::QSTile, kernel::K, transform::F
-) where {V, MR, NR, T, K <: DescriptorKernel{MR, NR, T}, F} =
-    pack_a!(packed, source, kernel.descriptor, transform)
-pack_b!(
-    packed::V, source::QSTile, kernel::K, transform::F
-) where {V, MR, NR, T, K <: DescriptorKernel{MR, NR, T}, F} =
-    pack_b!(packed, source, kernel.descriptor, transform)
-@inline unsafe_pack_a!(
-    packed::V, source::QSTile, kernel::K, transform::F
-) where {V, MR, NR, T, K <: DescriptorKernel{MR, NR, T}, F} =
-    unsafe_pack_a!(packed, source, kernel.descriptor, transform)
-@inline unsafe_pack_b!(
-    packed::V, source::QSTile, kernel::K, transform::F
-) where {V, MR, NR, T, K <: DescriptorKernel{MR, NR, T}, F} =
-    unsafe_pack_b!(packed, source, kernel.descriptor, transform)
+# The microkernel contract, and the validation and store helpers every kernel
+# shares.
+
+"""
+    Microkernel{MR, NR, T}
+
+A register-tile microkernel: computes an `MR x NR` tile of `C`, element type
+`T`, from one packed A sliver and one packed B sliver of a K block. A kernel
+wraps a `Descriptor` (tile size, element type, packing formats) as
+`.descriptor` and implements [`zero_accumulator`](@ref), [`add_tile`](@ref) and
+[`store_tile!`](@ref); [`execute_tile!`](@ref) composes them. The vector
+kernels match `ScalarKernel` only to within rounding (FMA grouping differs),
+never bitwise.
+"""
+abstract type Microkernel{MR, NR, T} end
+
+realtype(k::Microkernel) = realtype(k.descriptor)
+sliver_width(k::Microkernel) = sliver_width(k.descriptor)
+a_format(k::Microkernel) = a_format(k.descriptor)
+b_format(k::Microkernel) = b_format(k.descriptor)
+tile_size(k::Microkernel) = tile_size(k.descriptor)
+scalartype(k::Microkernel) = scalartype(k.descriptor)
+@inline sliver_spec(k::Microkernel, i::Int) = sliver_spec(k.descriptor, i)
+@inline packed_a_offset(k::Microkernel, i::Int, p::Int, plane::Int = 0) =
+    packed_a_offset(k.descriptor, i, p, plane)
+@inline packed_b_offset(k::Microkernel, j::Int, p::Int, plane::Int = 0) =
+    packed_b_offset(k.descriptor, j, p, plane)
+packed_a_length(k::Microkernel, k_block_length::Int) = packed_a_length(k.descriptor, k_block_length)
+packed_b_length(k::Microkernel, k_block_length::Int) = packed_b_length(k.descriptor, k_block_length)
+
+"""
+    zero_accumulator(kernel::Microkernel) -> acc
+
+The kernel's zero register tile, an immutable value.
+"""
+function zero_accumulator end
+
+"""
+    add_tile(kernel::Microkernel, acc, packed_a, packed_b, k_block_length) -> acc
+
+Add the products of `k_block_length` K steps of the packed A and B slivers to
+`acc` and return the result. `k_block_length == 0` returns `acc` without
+reading the panels; a negative one throws an `ArgumentError`.
+"""
+function add_tile end
+
+"""
+    store_tile!(destination::Tile, acc, alpha, beta, kernel::Microkernel) -> destination
+
+Write `alpha * acc + beta * C` over the valid rectangle `size(destination)`
+only: `alpha == 0` never reads `acc`, `beta == 0` never reads old `C`, and
+padding lanes of `acc` are never read. `alpha` and `beta` are of the kernel's
+element type.
+"""
+function store_tile! end
 
 # Constructor check: `rows` reals per sliver must split into whole `W`-vectors.
 # `even`: the lane-pair kernels keep one element's re/im in adjacent lanes, and
 # an odd `W` can divide `2MR` while splitting an element across two vectors --
 # a wrong answer, not an error, hence rejected here.
-@inline function _check_vector_shape(name, rows::Int, W, even::Bool = false)
+@inline function check_vector_shape(name, rows::Int, W, even::Bool = false)
     W isa Int && W > 0 ||
         throw(ArgumentError("$name requires an Int vector width W > 0, got W = $W"))
     even && isodd(W) &&
@@ -103,53 +70,61 @@ pack_b!(
 end
 
 # Generator-time check of an accumulator tuple against the kernel's shape.
-function _check_acc(f::Symbol, R, T, NA::Int, want::Int)
+function check_acc(f::Symbol, R, T, NA::Int, want::Int)
     R === real(T) || throw(ArgumentError("$f: accumulator lane type $R is not real($T)"))
     NA == want || throw(ArgumentError("$f: accumulator length $NA, expected $want"))
     return nothing
 end
 
-# Default `SIMD.Vec` lane count: one 256-bit register.
-_default_lanewidth(::Type{Float64}) = 4
-_default_lanewidth(::Type{Float32}) = 8
-
 # `beta == 0` writes zeros without reading `C`; `beta == 1` is a no-op.
-function scale_tile!(destination::QSTile, beta::T) where {T}
-    m = nrows(destination)
-    n = ncols(destination)
+function scale_tile!(destination::Tile, beta::T) where {T}
+    m, n = size(destination)
     (m == 0 || n == 0) && return destination
     if isone(beta)
         return destination
     elseif iszero(beta)
-        @inbounds for j in 0:(n - 1), i in 0:(m - 1)
-            tile_store!(destination, i, j, zero(T))
+        @inbounds for j in 1:n, i in 1:m
+            destination[i, j] = zero(T)
         end
     else
-        @inbounds for j in 0:(n - 1), i in 0:(m - 1)
-            tile_store!(destination, i, j, convert(T, tile_load(destination, i, j)) * beta)
+        @inbounds for j in 1:n, i in 1:m
+            destination[i, j] = convert(T, destination[i, j]) * beta
         end
     end
     return destination
 end
 
-# `C = alpha*r + beta*C` at one element. Ternaries, so `beta == 0` never reads C.
-@inline _axpby_tile!(dest, i::Int, j::Int, alpha, r, beta::T) where {T} = tile_store!(
-    dest, i, j,
-    iszero(beta) ? alpha * r :
-        isone(beta) ? muladd(alpha, r, convert(T, tile_load(dest, i, j))) :
-        muladd(alpha, r, beta * convert(T, tile_load(dest, i, j)))
-)
-
-@inline _axpby_at!(storage, idx::Int, alpha, r, beta::T) where {T} = @inbounds storage[idx] =
-    iszero(beta) ? alpha * r :
-    isone(beta) ? muladd(alpha, r, convert(T, storage[idx])) :
-    muladd(alpha, r, beta * convert(T, storage[idx]))
+# `beta`'s case for a store: `Zero()`, `One()` or `beta` itself. Called only
+# where a store branches on it, so the nest does not specialise on the case.
+@inline static_beta(beta) = iszero(beta) ? Zero() : isone(beta) ? One() : beta
+
+# `alpha * r + beta * old` for a case from `static_beta`; `Zero()` ignores `old`.
+@inline axpby(alpha, r, old, ::Zero) = alpha * r
+@inline axpby(alpha, r, old, ::One) = muladd(alpha, r, old)
+@inline axpby(alpha, r, old, beta) = muladd(alpha, r, beta * old)
+
+# C's old value for `axpby`, as a `T` (a scalar or a `Vec` through a pointer);
+# `Zero()` never reads it.
+@inline old_c(::Type, storage, idx::Int, ::Zero) = nothing
+@inline old_c(::Type{T}, storage, idx::Int, beta) where {T} = @inbounds convert(T, storage[idx])
+@inline old_c(::Type, dest::Tile, i::Int, j::Int, ::Zero) = nothing
+@inline old_c(::Type{T}, dest::Tile, i::Int, j::Int, beta) where {T} = @inbounds convert(T, dest[i, j])
+@inline old_c(::Type, p::Ptr, ::Zero) = nothing
+@inline old_c(::Type{T}, p::Ptr, beta) where {T} = load_c(T, p)
+
+@inline load_c(::Type{Vec{W, T}}, p::Ptr{T}) where {W, T} = vload(Vec{W, T}, p)
+@inline load_c(::Type{T}, p::Ptr{T}) where {T} = unsafe_load(p)
+
+# `C = alpha*r + beta*C` at one element, for a `beta` case.
+@inline axpby_tile!(dest, i::Int, j::Int, alpha::T, r, beta) where {T} =
+    @inbounds dest[i, j] = axpby(alpha, r, old_c(T, dest, i, j, beta), beta)
+@inline axpby_at!(storage, idx::Int, alpha::T, r, beta) where {T} =
+    @inbounds storage[idx] = axpby(alpha, r, old_c(T, storage, idx, beta), beta)
 
 # The `(m, n)` to store over, or `(0, 0)` when already done (empty destination,
 # or `alpha == 0` handled by `scale_tile!`).
-@inline function _store_prologue!(destination::QSTile, alpha, beta)
-    m = nrows(destination)
-    n = ncols(destination)
+@inline function store_prologue!(destination::Tile, alpha, beta)
+    m, n = size(destination)
     if m == 0 || n == 0
         return (0, 0)
     elseif iszero(alpha)
@@ -159,83 +134,73 @@ end
     return (m, n)
 end
 
-# GUARDRAIL: every throw reachable from the per-tile prologue sits behind a
+# GUARDRAIL: every throw reachable from `execute_tile!` sits behind a
 # `@noinline` helper. An inline interpolated message pulls `print_to_string`, a
 # GC frame and ~1 KB of stack into the hot tile function.
-@noinline _throw_packed_short(which::Symbol, got::Int, need::Int, kc::Int) = throw(
+@noinline throw_packed_short(which::Symbol, got::Int, need::Int, k_block_length::Int) = throw(
     DimensionMismatch(
         "execute_tile!: packed_$which has length $got, " *
-            "need at least packed_$(which)_length(kernel, kc=$kc) = $need"
+            "need at least packed_$(which)_length(kernel, k_block_length=$k_block_length) = $need"
     )
 )
-@noinline _throw_tile_extent(which::Symbol, got::Int, limit::Int) = throw(
+@noinline throw_tile_extent(which::Symbol, got::Int, limit::Int) = throw(
     ArgumentError(
-        "destination valid $which extent $got exceeds $(which === :row ? "mr" : "nr")(kernel) = $limit"
+        "destination valid $which extent $got exceeds tile_size(kernel, $(which === :row ? 1 : 2)) = $limit"
     )
 )
-@noinline _throw_negative_kc(where::Symbol, kc::Int) =
-    throw(ArgumentError("$where requires kc >= 0, got kc = $kc"))
-
-# `execute_tile!`'s validation, in order. Returns `(run, alphaT, betaT)`;
-# `run == false` means the call is finished. `Val(false)` drops the storage
-# bounds check at compile time (`unsafe_execute_tile!` only).
-# GUARDRAIL: `@inline` and one bound type parameter per argument (hot path).
-@inline function _execute_tile_prologue!(
-        kernel::K, destination::QSTile, packed_a::PA, packed_b::PB,
-        kc::Int, alpha, beta, ::Val{BOUNDS}
-    ) where {MR, NR, T, K <: DescriptorKernel{MR, NR, T}, PA, PB, BOUNDS}
-    m = nrows(destination)
-    n = ncols(destination)
-    m <= MR || _throw_tile_extent(:row, m, MR)
-    n <= NR || _throw_tile_extent(:column, n, NR)
-    kc >= 0 || _throw_negative_kc(:execute_tile!, kc)
+@noinline throw_negative_k_block_length(where::Symbol, k_block_length::Int) =
+    throw(ArgumentError("$where requires k_block_length >= 0, got k_block_length = $k_block_length"))
+
+# The kernels read only `PackedPanel`s; a `DenseVector` is borrowed as one.
+function add_tile(
+        kernel::K, acc::A, packed_a::PA, packed_b::PB, k_block_length::Int
+    ) where {K <: Microkernel, A, PA <: DenseVector, PB <: DenseVector}
+    return GC.@preserve packed_a packed_b add_tile(
+        kernel, acc, packed_panel(packed_a, 1, length(packed_a)),
+        packed_panel(packed_b, 1, length(packed_b)), k_block_length
+    )
+end
 
+"""
+    execute_tile!(kernel::Microkernel, destination::Tile, packed_a, packed_b,
+                  k_block_length, alpha, beta) -> destination
+
+One K block of one register tile: `zero_accumulator`, `add_tile`,
+`store_tile!`, i.e. `C = alpha * A * B + beta * C` over `destination`'s valid
+rectangle. Validates, in order: the destination extents against
+`tile_size(kernel)` (`ArgumentError`), `k_block_length >= 0`
+(`ArgumentError`), `alpha` and `beta` converting to the kernel's element type;
+then returns at once for an empty destination; checks the
+destination's storage bounds (`BoundsError`); applies only `beta` when
+`k_block_length == 0` or `alpha == 0`, without reading the panels; and checks
+the panel lengths (`DimensionMismatch`).
+
+Under `@inbounds` (the call inlined) the storage bounds check is skipped, so an
+out-of-range destination is a silent out-of-bounds write; every other check
+stays.
+"""
+@inline function execute_tile!(
+        kernel::K, destination::Tile, packed_a::PA, packed_b::PB,
+        k_block_length::Int, alpha, beta
+    ) where {MR, NR, T, K <: Microkernel{MR, NR, T}, PA, PB}
+    m, n = size(destination)
+    m <= MR || throw_tile_extent(:row, m, MR)
+    n <= NR || throw_tile_extent(:column, n, NR)
+    k_block_length >= 0 || throw_negative_k_block_length(:execute_tile!, k_block_length)
     alphaT = convert(T, alpha)
     betaT = convert(T, beta)
-
-    (m == 0 || n == 0) && return (false, alphaT, betaT)
-
-    BOUNDS && checked_tile_storage_bounds(destination)
-
-    if kc == 0 || iszero(alphaT)
+    (m == 0 || n == 0) && return destination
+    @boundscheck checked_tile_storage_bounds(destination)
+    if k_block_length == 0 || iszero(alphaT)
         scale_tile!(destination, betaT)
-        return (false, alphaT, betaT)
+        return destination
     end
 
-    need_a = packed_a_length(kernel, kc)
-    length(packed_a) >= need_a || _throw_packed_short(:a, length(packed_a), need_a, kc)
-    need_b = packed_b_length(kernel, kc)
-    length(packed_b) >= need_b || _throw_packed_short(:b, length(packed_b), need_b, kc)
-
-    return (true, alphaT, betaT)
-end
-
-# One checked K panel: `zero_accumulator`, `accumulate`, `store_tile!`.
-function execute_tile!(
-        kernel::K, destination::QSTile, packed_a::PA, packed_b::PB,
-        kc::Int, alpha, beta
-    ) where {MR, NR, T, K <: DescriptorKernel{MR, NR, T}, PA, PB}
-    run, alphaT, betaT = _execute_tile_prologue!(
-        kernel, destination, packed_a, packed_b, kc, alpha, beta, Val(true)
-    )
-    run || return destination
-    acc = accumulate(kernel, zero_accumulator(kernel), packed_a, packed_b, kc)
-    return store_tile!(destination, acc, alphaT, betaT, kernel)
-end
+    need_a = packed_a_length(kernel, k_block_length)
+    length(packed_a) >= need_a || throw_packed_short(:a, length(packed_a), need_a, k_block_length)
+    need_b = packed_b_length(kernel, k_block_length)
+    length(packed_b) >= need_b || throw_packed_short(:b, length(packed_b), need_b, k_block_length)
 
-# `execute_tile!` without `checked_tile_storage_bounds(destination)`: an
-# out-of-range destination is a silent out-of-bounds WRITE. `_execute_nest!`
-# checks the union of a whole macro block's tiles once with
-# `checked_span_bounds`, which is equivalent because the check only compares
-# range extremes.
-@inline function unsafe_execute_tile!(
-        kernel::K, destination::QSTile, packed_a::PA, packed_b::PB,
-        kc::Int, alpha, beta
-    ) where {K, PA, PB}
-    run, alphaT, betaT = _execute_tile_prologue!(
-        kernel, destination, packed_a, packed_b, kc, alpha, beta, Val(false)
-    )
-    run || return destination
-    acc = accumulate(kernel, zero_accumulator(kernel), packed_a, packed_b, kc)
+    acc = add_tile(kernel, zero_accumulator(kernel), packed_a, packed_b, k_block_length)
     return store_tile!(destination, acc, alphaT, betaT, kernel)
 end
diff --git a/src/microkernels/kernels.jl b/src/microkernels/kernels.jl
new file mode 100644
index 0000000..61086c8
--- /dev/null
+++ b/src/microkernels/kernels.jl
@@ -0,0 +1,230 @@
+# The kernel types and their type-level facts, ahead of every implementation: a
+# `@generated` function's generator only sees methods defined before it.
+
+"""
+    ScalarKernel(::Val{MR}, ::Val{NR}, ::Type{T})
+
+Scalar reference microkernel for register tile `(MR, NR)` and element type `T`.
+Its accumulator is an `NTuple{MR * NR, T}` holding the tile column-major.
+"""
+struct ScalarKernel{MR, NR, T} <: Microkernel{MR, NR, T}
+    descriptor::RealDescriptor{MR, NR, T}
+end
+
+ScalarKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T} =
+    ScalarKernel(Descriptor(Val(MR), Val(NR), T))
+
+"""
+    VectorKernel{MR, NR, T, W}
+
+An explicit-SIMD microkernel over `SIMD.Vec{W, real(T)}` lanes. Its
+accumulator is an immutable tuple of vectors in one of three layouts
+([`AccumulatorLayout`](@ref)), which fixes the stores; each kernel supplies
+its K step, `accumulate_step`, and the generic `add_tile` loops it
+`k_steps(kernel, k_block_length)` times.
+"""
+abstract type VectorKernel{MR, NR, T, W} <: Microkernel{MR, NR, T} end
+
+"""
+    AccumulatorLayout(kernel::VectorKernel)
+
+How the accumulator holds the tile, as `(MR ÷ rows) * NR` vectors of `rows`
+consecutive tile rows each, column-major (`rows_per_vector`):
+
+  - `RealLayout()`: one real per lane (`SIMDKernel`).
+  - `SplitLayout()`: separate re and im vectors (`PlanarKernel`: a real and an
+    imaginary plane in one flat tuple; `RealComplexKernel`: the real kernel's
+    columns `2j-1` and `2j`).
+  - `LanePairLayout()`: lanes `2u-1` and `2u` are re and im of one row
+    (1m, fmaddsub, `ComplexRealKernel`).
+"""
+abstract type AccumulatorLayout end
+struct RealLayout <: AccumulatorLayout end
+struct SplitLayout <: AccumulatorLayout end
+struct LanePairLayout <: AccumulatorLayout end
+
+# The checks of every vector kernel's constructor; the descriptor has checked
+# the tile size and the element type.
+function check_vector_kernel(::Type{K}, MR, W) where {K <: VectorKernel}
+    pairs = AccumulatorLayout(K) isa LanePairLayout
+    return check_vector_shape(nameof(K), pairs ? 2 * MR : MR, W, pairs)
+end
+
+"""
+    SIMDKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
+
+Explicit-SIMD real microkernel over `SIMD.Vec{W,T}` lanes. `MR` must be a
+multiple of `W` (default: one 256-bit register, 4 for `Float64`, 8 for `Float32`).
+"""
+struct SIMDKernel{MR, NR, T, W} <: VectorKernel{MR, NR, T, W}
+    descriptor::RealDescriptor{MR, NR, T}
+    function SIMDKernel{MR, NR, T, W}(descriptor::RealDescriptor{MR, NR, T}) where {MR, NR, T, W}
+        check_vector_kernel(SIMDKernel, MR, W)
+        return new{MR, NR, T, W}(descriptor)
+    end
+end
+
+"""
+    PlanarKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
+
+Split-complex microkernel for `T = ComplexF32/ComplexF64` over
+`SIMD.Vec{W,real(T)}` lanes. `MR`/`NR` are complex extents; `MR` must be a
+multiple of `W`, which counts reals.
+"""
+struct PlanarKernel{MR, NR, T, W} <: VectorKernel{MR, NR, T, W}
+    descriptor::Descriptor{MR, NR, T, PlanarFormat, PlanarFormat}
+    function PlanarKernel{MR, NR, T, W}(
+            descriptor::Descriptor{MR, NR, T, PlanarFormat, PlanarFormat}
+        ) where {MR, NR, T, W}
+        check_vector_kernel(PlanarKernel, MR, W)
+        return new{MR, NR, T, W}(descriptor)
+    end
+end
+
+"""
+    OneMKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
+
+Van Zee's induced 1m complex microkernel: the real `SIMDKernel` of `2MR x NR`
+over `SIMD.Vec{W,real(T)}` lanes, run verbatim over `2 * k_block_length` real
+K steps against 1e-packed A and planar B. At logical K step `p`, `OneEFormat`
+A holds `(re_0, im_0, re_1, im_1, ...)` then `(-im_0, re_0, -im_1, re_1, ...)`,
+and planar B `re_0..` then `im_0..`, so accumulator real row `2i-1` is the
+real and `2i` the imaginary part of complex row `i`. `2MR` must be a multiple
+of `W`, and `W` must be even. Used only when named in
+`plan_contract(...; kernel = ...)`.
+"""
+struct OneMKernel{MR, NR, T, W} <: VectorKernel{MR, NR, T, W}
+    descriptor::Descriptor{MR, NR, T, OneEFormat, PlanarFormat}
+    function OneMKernel{MR, NR, T, W}(
+            descriptor::Descriptor{MR, NR, T, OneEFormat, PlanarFormat}
+        ) where {MR, NR, T, W}
+        check_vector_kernel(OneMKernel, MR, W)
+        return new{MR, NR, T, W}(descriptor)
+    end
+end
+
+"""
+    FMAddSubKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
+
+Interleaved-accumulator complex microkernel using x86 `vfmaddsub`, over
+`SIMD.Vec{W,real(T)}` lanes with `InterleavedFormat` A and `PlanarFormat` B.
+`2MR` must be a multiple of `W`, and `W` must be even. The default for small-M
+complex contractions on AVX-512.
+"""
+struct FMAddSubKernel{MR, NR, T, W} <: VectorKernel{MR, NR, T, W}
+    descriptor::Descriptor{MR, NR, T, InterleavedFormat, PlanarFormat}
+    function FMAddSubKernel{MR, NR, T, W}(
+            descriptor::Descriptor{MR, NR, T, InterleavedFormat, PlanarFormat}
+        ) where {MR, NR, T, W}
+        check_vector_kernel(FMAddSubKernel, MR, W)
+        return new{MR, NR, T, W}(descriptor)
+    end
+end
+
+"""
+    ComplexRealKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
+
+Mixed-domain microkernel for complex `A` times real `B`, computing in complex
+`T`. Interleaved A is a real `2MR x k_block_length` panel, so this is the real
+`SIMDKernel` of `2MR x NR` over `SIMD.Vec{W,real(T)}` lanes, run verbatim at 2
+real FMAs per complex MAC; the accumulator is 1m's lane-pair layout. `2MR`
+must be a multiple of `W`, and `W` must be even.
+"""
+struct ComplexRealKernel{MR, NR, T, W} <: VectorKernel{MR, NR, T, W}
+    descriptor::Descriptor{MR, NR, T, InterleavedFormat, RealFormat}
+    function ComplexRealKernel{MR, NR, T, W}(
+            descriptor::Descriptor{MR, NR, T, InterleavedFormat, RealFormat}
+        ) where {MR, NR, T, W}
+        check_vector_kernel(ComplexRealKernel, MR, W)
+        return new{MR, NR, T, W}(descriptor)
+    end
+end
+
+"""
+    RealComplexKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
+
+Mixed-domain microkernel for real `A` times complex `B`, computing in complex
+`T`. Interleaved B is a real `k_block_length x 2NR` panel, so this is the real
+`SIMDKernel` of `MR x 2NR` over `SIMD.Vec{W,real(T)}` lanes, run verbatim at 2
+real FMAs per complex MAC; accumulator column `2j-1` holds the real and `2j`
+the imaginary part of column `j`. `MR` must be a multiple of `W`.
+"""
+struct RealComplexKernel{MR, NR, T, W} <: VectorKernel{MR, NR, T, W}
+    descriptor::Descriptor{MR, NR, T, RealFormat, InterleavedFormat}
+    function RealComplexKernel{MR, NR, T, W}(
+            descriptor::Descriptor{MR, NR, T, RealFormat, InterleavedFormat}
+        ) where {MR, NR, T, W}
+        check_vector_kernel(RealComplexKernel, MR, W)
+        return new{MR, NR, T, W}(descriptor)
+    end
+end
+
+"""
+    pack_formats(K::Type{<:Microkernel}) -> (a_format, b_format)
+
+The packing formats of every kernel of type `K`. A kernel type is also the
+shape-free name of its complex-arithmetic scheme, on which blocking and the
+shape menus dispatch:
+
+  - `SIMDKernel` (and `ScalarKernel`): real.
+  - `PlanarKernel`: split re/im planes, 4 real FMAs per complex MAC.
+  - `OneMKernel`: Van Zee's 1m, a real `2MR x NR` kernel.
+  - `FMAddSubKernel`: interleaved A, x86 `vfmaddsub`.
+  - `ComplexRealKernel`: complex A, real B; the real kernel on `2MR` rows.
+  - `RealComplexKernel`: real A, complex B; the real kernel on `2NR` columns.
+
+No ranking is hardcoded: planar is the complex default, 1m and fmaddsub are
+used only when named (plus fmaddsub for the AVX-512 small-M demotion,
+`small_m_shape` in src/planning/kernel_selection.jl).
+"""
+pack_formats(::Type{<:Union{ScalarKernel, SIMDKernel}}) = (RealFormat(), RealFormat())
+pack_formats(::Type{<:PlanarKernel}) = (PlanarFormat(), PlanarFormat())
+pack_formats(::Type{<:OneMKernel}) = (OneEFormat(), PlanarFormat())
+pack_formats(::Type{<:FMAddSubKernel}) = (InterleavedFormat(), PlanarFormat())
+pack_formats(::Type{<:ComplexRealKernel}) = (InterleavedFormat(), RealFormat())
+pack_formats(::Type{<:RealComplexKernel}) = (RealFormat(), InterleavedFormat())
+
+"""
+    reads_b_by_element(K::Type{<:Microkernel}) -> Bool
+
+Whether the K step of every kernel of type `K` reads B only through
+`b_scalar`/`b_complex`, so that any B source implementing those (such as
+`UnpackedBView`, B read in place) can stand in for its packed B panel.
+False otherwise: `ScalarKernel` loads from the panel directly, and 1m and
+`RealComplexKernel` run a real kernel over the packed panel's reals.
+"""
+reads_b_by_element(::Type{<:Microkernel}) = false
+reads_b_by_element(::Type{<:Union{SIMDKernel, PlanarKernel, FMAddSubKernel, ComplexRealKernel}}) = true
+
+# Accumulator planes held live: planar keeps separate re/im planes.
+accumulator_planes(::Type{<:Microkernel}) = 1
+accumulator_planes(::Type{<:PlanarKernel}) = 2
+
+AccumulatorLayout(::Type{<:SIMDKernel}) = RealLayout()
+AccumulatorLayout(::Type{<:Union{PlanarKernel, RealComplexKernel}}) = SplitLayout()
+AccumulatorLayout(::Type{<:Union{OneMKernel, FMAddSubKernel, ComplexRealKernel}}) = LanePairLayout()
+AccumulatorLayout(kernel::VectorKernel) = AccumulatorLayout(typeof(kernel))
+
+rows_per_vector(::AccumulatorLayout, W::Int) = W
+rows_per_vector(::LanePairLayout, W::Int) = W ÷ 2
+accumulator_length(::AccumulatorLayout, MV::Int, NR::Int) = MV * NR
+accumulator_length(::SplitLayout, MV::Int, NR::Int) = 2 * MV * NR
+# The accumulator vector of row block `v` (zero-based) of column `j`.
+acc_index(MV::Int, v::Int, j::Int) = v + MV * (j - 1) + 1
+
+(::Type{K})(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {K <: VectorKernel, MR, NR, T, W} =
+    K{MR, NR, T, W}(Descriptor(Val(MR), Val(NR), T, pack_formats(K)...))
+(::Type{K})() where {MR, NR, T, W, K <: VectorKernel{MR, NR, T, W}} =
+    K(Descriptor(Val(MR), Val(NR), T, pack_formats(K)...))
+(::Type{K})(::Val{MR}, ::Val{NR}, ::Type{T}) where {K <: VectorKernel, MR, NR, T} =
+    K(Val(MR), Val(NR), T, Val(default_lanewidth(real(T))))
+
+lanewidth(::VectorKernel{MR, NR, T, W}) where {MR, NR, T, W} = W
+
+k_steps(::VectorKernel, k_block_length::Int) = k_block_length
+k_steps(::OneMKernel, k_block_length::Int) = 2 * k_block_length
+
+# The real kernel whose K step a kernel without one of its own runs.
+inner(::OneMKernel{MR, NR, T, W}) where {MR, NR, T, W} = SIMDKernel(Val(2 * MR), Val(NR), real(T), Val(W))
+inner(::ComplexRealKernel{MR, NR, T, W}) where {MR, NR, T, W} = SIMDKernel(Val(2 * MR), Val(NR), real(T), Val(W))
+inner(::RealComplexKernel{MR, NR, T, W}) where {MR, NR, T, W} = SIMDKernel(Val(MR), Val(2 * NR), real(T), Val(W))
diff --git a/src/microkernels/mixed.jl b/src/microkernels/mixed.jl
deleted file mode 100644
index 0add24d..0000000
--- a/src/microkernels/mixed.jl
+++ /dev/null
@@ -1,111 +0,0 @@
-# Mixed-domain kernels (BLIS's mixed-domain method): a complex operand times a
-# real one is a real product once the complex operand is viewed as real, so
-# both run the real `SIMDKernel` verbatim, at 2 real FMAs per complex MAC.
-#   * complex A x real B: interleaved A is a real `2MR x kc` panel; the
-#     accumulator is 1m/fmaddsub's interleaved layout.
-#   * real A x complex B: interleaved B is a real `kc x 2NR` panel; accumulator
-#     column `2j` holds the real and `2j+1` the imaginary part of column `j`.
-
-using SIMD: Vec
-
-"""
-    ComplexRealKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
-
-Mixed-domain microkernel for complex `A` times real `B`, computing in complex
-`T`: a real `SIMDKernel` of `2MR x NR` over `SIMD.Vec{W,real(T)}` lanes. `2MR`
-must be a multiple of `W`, and `W` must be even.
-"""
-struct ComplexRealKernel{MR, NR, T, W, KI <: SIMDKernel} <: DescriptorKernel{MR, NR, T}
-    descriptor::ComplexKernelDescriptor{MR, NR, T, InterleavedFormat, RealFormat}
-    inner::KI
-
-    function ComplexRealKernel{MR, NR, T, W, KI}(
-            descriptor::ComplexKernelDescriptor{MR, NR, T, InterleavedFormat, RealFormat},
-            inner::KI
-        ) where {MR, NR, T, W, KI <: SIMDKernel}
-        _check_vector_shape("ComplexRealKernel", 2 * MR, W, true)
-        KI === SIMDKernel{2 * MR, NR, real(T), W} || throw(
-            ArgumentError("ComplexRealKernel's inner kernel must be SIMDKernel{$(2 * MR),$NR,$(real(T)),$W}, got $KI")
-        )
-        return new{MR, NR, T, W, KI}(descriptor, inner)
-    end
-end
-
-"""
-    RealComplexKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
-
-Mixed-domain microkernel for real `A` times complex `B`, computing in complex
-`T`: a real `SIMDKernel` of `MR x 2NR` over `SIMD.Vec{W,real(T)}` lanes. `MR`
-must be a multiple of `W`.
-"""
-struct RealComplexKernel{MR, NR, T, W, KI <: SIMDKernel} <: DescriptorKernel{MR, NR, T}
-    descriptor::ComplexKernelDescriptor{MR, NR, T, RealFormat, InterleavedFormat}
-    inner::KI
-
-    function RealComplexKernel{MR, NR, T, W, KI}(
-            descriptor::ComplexKernelDescriptor{MR, NR, T, RealFormat, InterleavedFormat},
-            inner::KI
-        ) where {MR, NR, T, W, KI <: SIMDKernel}
-        KI === SIMDKernel{MR, 2 * NR, real(T), W} || throw(
-            ArgumentError("RealComplexKernel's inner kernel must be SIMDKernel{$MR,$(2 * NR),$(real(T)),$W}, got $KI")
-        )
-        return new{MR, NR, T, W, KI}(descriptor, inner)
-    end
-end
-
-const _MixedKernel = Union{ComplexRealKernel, RealComplexKernel}
-
-function ComplexRealKernel(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {MR, NR, T, W}
-    descriptor = ComplexKernelDescriptor(Val(MR), Val(NR), T, InterleavedFormat(), RealFormat())
-    inner = SIMDKernel(Val(2 * MR), Val(NR), real(T), Val(W))
-    return ComplexRealKernel{MR, NR, T, W, typeof(inner)}(descriptor, inner)
-end
-
-function RealComplexKernel(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {MR, NR, T, W}
-    descriptor = ComplexKernelDescriptor(Val(MR), Val(NR), T, RealFormat(), InterleavedFormat())
-    inner = SIMDKernel(Val(MR), Val(2 * NR), real(T), Val(W))
-    return RealComplexKernel{MR, NR, T, W, typeof(inner)}(descriptor, inner)
-end
-
-ComplexRealKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T} =
-    ComplexRealKernel(Val(MR), Val(NR), T, Val(_default_lanewidth(real(T))))
-RealComplexKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T} =
-    RealComplexKernel(Val(MR), Val(NR), T, Val(_default_lanewidth(real(T))))
-
-complex_method(::ComplexRealKernel) = ComplexRealMethod()
-complex_method(::RealComplexKernel) = RealComplexMethod()
-lanewidth(kernel::_MixedKernel) = lanewidth(kernel.inner)
-
-zero_accumulator(kernel::_MixedKernel) = zero_accumulator(kernel.inner)
-
-@inline Base.accumulate(kernel::_MixedKernel, acc::NTuple, packed_a, packed_b, kc::Int) =
-    accumulate(kernel.inner, acc, packed_a, packed_b, kc)
-
-# Inlined or not as the fmaddsub and planar stores each reuses.
-function store_tile!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, R}},
-        alpha::T, beta::T, kernel::ComplexRealKernel{MR, NR, T, W}
-    ) where {MR, NR, T, W, R, NV}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-
-    if _complex_vector_eligible(destination, T)
-        return _store_tile_fmaddsub_vector!(destination, acc, alpha, beta, kernel, m, n)
-    end
-
-    return _store_tile_lanepair!(destination, acc, alpha, beta, kernel, m, n)
-end
-
-@inline function store_tile!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, R}},
-        alpha::T, beta::T, kernel::RealComplexKernel{MR, NR, T, W}
-    ) where {MR, NR, T, W, R, NV}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-
-    if _complex_vector_eligible(destination, T)
-        return _store_tile_planar_vector!(destination, acc, alpha, beta, kernel, m, n)
-    end
-
-    return _store_tile_planar!(destination, acc, alpha, beta, kernel, m, n)
-end
diff --git a/src/microkernels/onem.jl b/src/microkernels/onem.jl
deleted file mode 100644
index a1c8029..0000000
--- a/src/microkernels/onem.jl
+++ /dev/null
@@ -1,111 +0,0 @@
-# 1m (Van Zee's induced method): the real `SIMDKernel` of `2MR x NR`, run over
-# `2*kc` real K steps against 1e-packed A and planar B. At logical K step `p`,
-# `OneEFormat` A holds `(re_0, im_0, re_1, im_1, ...)` then
-# `(-im_0, re_0, -im_1, re_1, ...)`, and planar B `re_0..` then `im_0..`, so
-# accumulator real row `2i` is the real and `2i+1` the imaginary part of
-# complex row `i`. There is deliberately no FMA loop here: 1m reuses the real
-# kernel body verbatim.
-
-using SIMD: Vec
-
-"""
-    OneMKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
-
-Van Zee's induced 1m complex microkernel: a real `SIMDKernel` of `2MR x NR`
-over `SIMD.Vec{W,real(T)}` lanes. `2MR` must be a multiple of `W`, and `W`
-must be even. Used only when named in `plan_contract(...; kernel = ...)`.
-"""
-struct OneMKernel{MR, NR, T, W, KI <: SIMDKernel} <: DescriptorKernel{MR, NR, T}
-    descriptor::ComplexKernelDescriptor{MR, NR, T, OneEFormat, PlanarFormat}
-    # `KI` stands in for `SIMDKernel{2MR,NR,real(T),W}`, which is not a legal
-    # field type; the constructor pins it to exactly that.
-    inner::KI
-
-    function OneMKernel{MR, NR, T, W, KI}(
-            descriptor::ComplexKernelDescriptor{MR, NR, T, OneEFormat, PlanarFormat},
-            inner::KI
-        ) where {MR, NR, T, W, KI <: SIMDKernel}
-        _check_vector_shape("OneMKernel", 2 * MR, W, true)
-        KI === SIMDKernel{2 * MR, NR, real(T), W} || throw(
-            ArgumentError("OneMKernel's inner kernel must be SIMDKernel{$(2 * MR),$NR,$(real(T)),$W}, got $KI")
-        )
-        return new{MR, NR, T, W, KI}(descriptor, inner)
-    end
-end
-
-function OneMKernel(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {MR, NR, T, W}
-    T <: Complex ||
-        throw(ArgumentError("OneMKernel requires a complex element type, got $T"))
-    descriptor = ComplexKernelDescriptor(Val(MR), Val(NR), T, OneEFormat(), PlanarFormat())
-    inner = SIMDKernel(Val(2 * MR), Val(NR), real(T), Val(W))
-    return OneMKernel{MR, NR, T, W, typeof(inner)}(descriptor, inner)
-end
-function OneMKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T}
-    T <: Complex ||
-        throw(ArgumentError("OneMKernel requires a complex element type, got $T"))
-    return OneMKernel(Val(MR), Val(NR), T, Val(_default_lanewidth(real(T))))
-end
-
-complex_method(::OneMKernel) = OneMMethod()
-lanewidth(::OneMKernel{MR, NR, T, W}) where {MR, NR, T, W} = W
-
-zero_accumulator(kernel::OneMKernel) = zero_accumulator(kernel.inner)
-
-function Base.accumulate(
-        kernel::OneMKernel{MR, NR, T, W}, acc::NTuple{NV, Vec{W, R}},
-        packed_a::PA, packed_b::PB, kc::Int
-    ) where {MR, NR, T, W, R, NV, PA, PB}
-    # Checked here so the message reports the logical kc, not the doubled one.
-    kc >= 0 || throw(ArgumentError("accumulate requires kc >= 0, got kc = $kc"))
-    return accumulate(kernel.inner, acc, packed_a, packed_b, 2 * kc)
-end
-
-# Scalar store for an interleaved accumulator (1m and fmaddsub): with `W` even
-# and `2MR` a multiple of `W`, complex row `i = v*(W÷2) + u` is lanes `2u+1`
-# (re) and `2u+2` (im) of vector `v` -- never split across two vectors.
-@generated function _store_tile_lanepair!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, R}},
-        alpha::T, beta::T, kernel::DescriptorKernel{MR, NR, T},
-        m::Int, n::Int
-    ) where {MR, NR, T, W, R, NV}
-    iseven(W) || throw(ArgumentError("_store_tile_lanepair!: requires an even W, got $W"))
-    MV = (2 * MR) ÷ W
-    _check_acc(:_store_tile_lanepair!, R, T, NV, MV * NR)
-    HW = W ÷ 2
-
-    blocks = Any[]
-    for j in 0:(NR - 1), v in 0:(MV - 1)
-        idx = v + MV * j + 1
-        push!(
-            blocks, quote
-                if $j < n
-                    vec = acc[$idx]
-                    for u in 0:$(HW - 1)
-                        i = $(v * HW) + u
-                        i < m || break
-                        _axpby_tile!(
-                            destination, i, $j, alpha,
-                            Complex(vec[2 * u + 1], vec[2 * u + 2]), beta
-                        )
-                    end
-                end
-            end
-        )
-    end
-    return quote
-        @inbounds begin
-            $(blocks...)
-        end
-        return destination
-    end
-end
-
-# Scalar only: 1m has no vector store. Not `@inline`, as for fmaddsub.
-function store_tile!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, R}},
-        alpha::T, beta::T, kernel::OneMKernel{MR, NR, T, W}
-    ) where {MR, NR, T, W, R, NV}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-    return _store_tile_lanepair!(destination, acc, alpha, beta, kernel, m, n)
-end
diff --git a/src/microkernels/planar.jl b/src/microkernels/planar.jl
deleted file mode 100644
index 401a4bb..0000000
--- a/src/microkernels/planar.jl
+++ /dev/null
@@ -1,326 +0,0 @@
-# Planar (split-complex, BLIS "1r") microkernel, the default complex method.
-# Both panels are `PlanarFormat` (`[re_0..re_{n-1} | im_0..im_{n-1}]` per K
-# step), so the data is already in the right lanes: four real FMAs per
-# (A-vector, B-scalar) pair, no shuffles. Everything works in `real(T)`.
-
-using SIMD: Vec, vload, vstore, shufflevector
-
-"""
-    PlanarKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
-
-Split-complex microkernel for `T = ComplexF32/ComplexF64` over
-`SIMD.Vec{W,real(T)}` lanes. `MR`/`NR` are complex extents; `MR` must be a
-multiple of `W`, which counts reals.
-"""
-struct PlanarKernel{MR, NR, T, W} <: DescriptorKernel{MR, NR, T}
-    descriptor::ComplexKernelDescriptor{MR, NR, T, PlanarFormat, PlanarFormat}
-
-    function PlanarKernel{MR, NR, T, W}(
-            descriptor::ComplexKernelDescriptor{MR, NR, T, PlanarFormat, PlanarFormat}
-        ) where {MR, NR, T, W}
-        _check_vector_shape("PlanarKernel", MR, W)
-        return new{MR, NR, T, W}(descriptor)
-    end
-end
-
-function PlanarKernel(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {MR, NR, T, W}
-    return PlanarKernel{MR, NR, T, W}(
-        ComplexKernelDescriptor(Val(MR), Val(NR), T, PlanarFormat(), PlanarFormat())
-    )
-end
-function PlanarKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T}
-    T <: Complex ||
-        throw(ArgumentError("PlanarKernel requires a complex element type, got $T"))
-    return PlanarKernel(Val(MR), Val(NR), T, Val(_default_lanewidth(real(T))))
-end
-
-complex_method(::PlanarKernel) = PlanarMethod()
-lanewidth(::PlanarKernel{MR, NR, T, W}) where {MR, NR, T, W} = W
-
-# One flat tuple: the real plane at `1:NV`, the imaginary plane at `NV+1:2NV`,
-# each laid out as the real kernel's. Flat keeps the accumulator in registers.
-function zero_accumulator(kernel::PlanarKernel{MR, NR, T, W}) where {MR, NR, T, W}
-    z = zero(Vec{W, real(T)})
-    return ntuple(_ -> z, Val(2 * (MR ÷ W) * NR))
-end
-
-# B column `j` at K step `p` as `(re, im)`; `UnpackedBView` overrides it.
-# Shared with the fmaddsub kernel.
-@inline _b_step_load2(packed_b::PB, kernel, j::Int, p::Int) where {PB} = (
-    panel_load(packed_b, packed_b_plane_offset(kernel, 0, j, p)),
-    panel_load(packed_b, packed_b_plane_offset(kernel, 1, j, p)),
-)
-
-# GUARDRAIL: the real part is `muladd(-ai, bi, muladd(ar, br, c))`. `c - ai*bi`
-# does NOT fuse (Julia sets no LLVM `contract` flag): two instructions, and
-# different rounding. `-ai` is hoisted out of the `j` loop and folds into
-# `vfnmadd`, so the negation is free.
-@generated function _accumulate_step_planar(
-        kernel::PlanarKernel{MR, NR, T, W}, acc::NTuple{NA, Vec{W, R}},
-        packed_a::PA, packed_b::PB, p::Int
-    ) where {MR, NR, T, W, R, NA, PA, PB}
-    MV = MR ÷ W
-    NV = MV * NR
-    _check_acc(:_accumulate_step_planar, R, T, NA, 2NV)
-
-    arv = [Symbol(:ar, v) for v in 0:(MV - 1)]
-    aiv = [Symbol(:ai, v) for v in 0:(MV - 1)]
-    naiv = [Symbol(:nai, v) for v in 0:(MV - 1)]
-    brv = [Symbol(:br, j) for j in 0:(NR - 1)]
-    biv = [Symbol(:bi, j) for j in 0:(NR - 1)]
-
-    load_a = Any[]
-    for v in 0:(MV - 1)
-        push!(
-            load_a,
-            :(
-                $(arv[v + 1]) = panel_vload(
-                    Vec{$W, $R}, packed_a, packed_a_plane_offset(kernel, 0, $(v * W), p)
-                )
-            )
-        )
-        push!(
-            load_a,
-            :(
-                $(aiv[v + 1]) = panel_vload(
-                    Vec{$W, $R}, packed_a, packed_a_plane_offset(kernel, 1, $(v * W), p)
-                )
-            )
-        )
-        push!(load_a, :($(naiv[v + 1]) = -$(aiv[v + 1])))
-    end
-
-    load_b = Any[]
-    for j in 0:(NR - 1)
-        push!(load_b, :(($(brv[j + 1]), $(biv[j + 1])) = _b_step_load2(packed_b, kernel, $j, p)))
-    end
-
-    acc_exprs = Vector{Any}(undef, NA)
-    for j in 0:(NR - 1), v in 0:(MV - 1)
-        idx = v + MV * j + 1
-        acc_exprs[idx] = :(  # re: ar*br - ai*bi
-            muladd(
-                $(naiv[v + 1]), $(biv[j + 1]),
-                muladd($(arv[v + 1]), $(brv[j + 1]), acc[$idx])
-            )
-        )
-        acc_exprs[NV + idx] = :(  # im: ar*bi + ai*br
-            muladd(
-                $(aiv[v + 1]), $(brv[j + 1]),
-                muladd($(arv[v + 1]), $(biv[j + 1]), acc[$(NV + idx)])
-            )
-        )
-    end
-
-    return quote
-        Base.@_inline_meta
-        @inbounds begin
-            $(load_a...)
-            $(load_b...)
-            return $(Expr(:tuple, acc_exprs...))
-        end
-    end
-end
-
-function Base.accumulate(
-        kernel::PlanarKernel{MR, NR, T, W}, acc::NTuple{NA, Vec{W, R}},
-        packed_a::PA, packed_b::PB, kc::Int
-    ) where {MR, NR, T, W, R, NA, PA, PB}
-    kc == 0 && return acc
-    kc > 0 || _throw_negative_kc(:accumulate, kc)
-    @inbounds for p in 0:(kc - 1)
-        acc = _accumulate_step_planar(kernel, acc, packed_a, packed_b, p)
-    end
-    return acc
-end
-
-# Generator-time accumulator indices of the re/im vectors of block `v`, column
-# `j`: planar's two planes, or `RealComplexKernel`'s column pairs. A `<:` test
-# rather than dispatch, as `RealComplexKernel` is defined after this file.
-function _planar_acc_index(kernel::Type, MV::Int, NR::Int, v::Int, j::Int)
-    kernel <: PlanarKernel && return (v + MV * j + 1, MV * NR + v + MV * j + 1)
-    kernel <: RealComplexKernel && return (v + MV * 2j + 1, v + MV * (2j + 1) + 1)
-    throw(ArgumentError("_planar_acc_index: no planar accumulator layout for $kernel"))
-end
-
-# Scalar fallback store, for every destination the vector store cannot take.
-@generated function _store_tile_planar!(
-        destination::QSTile, acc::NTuple{NA, Vec{W, R}},
-        alpha::T, beta::T, kernel::DescriptorKernel{MR, NR, T},
-        m::Int, n::Int
-    ) where {MR, NR, T, W, R, NA}
-    MV = MR ÷ W
-    NV = MV * NR
-    _check_acc(:_store_tile_planar!, R, T, NA, 2NV)
-
-    blocks = Any[]
-    for j in 0:(NR - 1), v in 0:(MV - 1)
-        ire, iim = _planar_acc_index(kernel, MV, NR, v, j)
-        push!(
-            blocks, quote
-                if $j < n
-                    revec = acc[$ire]
-                    imvec = acc[$iim]
-                    for lane in 1:$W
-                        i = $(v * W) + lane - 1
-                        i < m || break
-                        _axpby_tile!(
-                            destination, i, $j, alpha,
-                            Complex(revec[lane], imvec[lane]), beta
-                        )
-                    end
-                end
-            end
-        )
-    end
-    return quote
-        @inbounds begin
-            $(blocks...)
-        end
-        return destination
-    end
-end
-
-# Vector store: unit-stride rows into rank-1 dense `Complex` storage (so the
-# storage can be reinterpreted as `2W` consecutive reals per `W` rows), on an
-# ISA the complex fast paths ship for (shared with the complex pack fast path).
-@inline _complex_vector_eligible(tile::QSTile, ::Type{T}) where {T} =
-    _unit_stride_rows(tile.rows) && _dense_lanes(tile.storage, T) &&
-    _complex_fastpath_isa_eligible()
-
-# Shuffle patterns built from `W` at specialization time, never hardcoded to
-# one ISA. `v` holds `W` complex values `[re_0, im_0, ..., re_{W-1}, im_{W-1}]`.
-@generated function _deinterleave_re(v::Vec{N, R}, ::Val{W}) where {N, R, W}
-    N == 2 * W || return :(throw(ArgumentError("_deinterleave_re: expected N == 2W")))
-    idx = ntuple(k -> 2 * (k - 1), W)
-    return :(shufflevector(v, Val($idx)))
-end
-
-@generated function _deinterleave_im(v::Vec{N, R}, ::Val{W}) where {N, R, W}
-    N == 2 * W || return :(throw(ArgumentError("_deinterleave_im: expected N == 2W")))
-    idx = ntuple(k -> 2 * (k - 1) + 1, W)
-    return :(shufflevector(v, Val($idx)))
-end
-
-@generated function _interleave_planes(re::Vec{W, R}, im::Vec{W, R}, ::Val{W}) where {W, R}
-    idx = ntuple(k -> isodd(k) ? (k - 1) ÷ 2 : W + (k - 1) ÷ 2, 2 * W)
-    return :(shufflevector(re, im, Val($idx)))
-end
-
-# One full `W`-row block; `at` is the zero-based index of its first real.
-# The arithmetic transcribes Base's `Complex` expression trees (the ones
-# `_axpby_tile!` reaches), so full blocks match them bitwise: `*` is unfused,
-# `muladd(z, w, x) = (muladd(zr, wr, -muladd(zi, wi, -xr)), muladd(zr, wi,
-# muladd(zi, wr, xi)))`. Against the scalar fallback it is exact at
-# `beta == 0/1` and ~1 ULP otherwise, because LLVM contracts Base's scalar
-# complex `muladd` depending on inlining context.
-@inline function _planar_store_block!(
-        sp::Ptr{RC}, at::Int, rev::Vec{W, R}, imv::Vec{W, R},
-        ar::Vec{W, R}, ai::Vec{W, R}, br::Vec{W, R}, bi::Vec{W, R},
-        beta::Complex{R}, ::Val{W}
-    ) where {RC, R, W}
-    if iszero(beta)
-        newre = ar * rev - ai * imv
-        newim = ar * imv + ai * rev
-    else
-        old = convert(Vec{2 * W, R}, vload(Vec{2 * W, RC}, sp + sizeof(RC) * at))
-        orv = _deinterleave_re(old, Val(W))
-        oiv = _deinterleave_im(old, Val(W))
-        if isone(beta)
-            xr, xi = orv, oiv
-        else
-            xr = br * orv - bi * oiv
-            xi = br * oiv + bi * orv
-        end
-        newre = muladd(ar, rev, -muladd(ai, imv, -xr))
-        newim = muladd(ar, imv, muladd(ai, rev, xi))
-    end
-    vstore(convert(Vec{2 * W, RC}, _interleave_planes(newre, newim, Val(W))), sp + sizeof(RC) * at)
-    return nothing
-end
-
-# Same unroll and full-block / row-tail split as `_store_tile_vector!`, with a
-# block of `2W` reals. The raw pointer is only dereferenced inside `GC.@preserve`.
-@generated function _store_tile_planar_vector!(
-        destination::QSTile{S, <:AffineAxis}, acc::NTuple{NA, Vec{W, R}},
-        alpha::T, beta::T, kernel::DescriptorKernel{MR, NR, T},
-        m::Int, n::Int
-    ) where {S, MR, NR, T, W, R, NA}
-    # The pointer reinterpretation is only sound on dense rank-1 complex storage.
-    S <: DenseVector && _lane_convertible(eltype(S), T) ||
-        throw(ArgumentError("_store_tile_planar_vector!: storage $S is not a dense vector convertible to $T"))
-    RC = real(eltype(S))
-    MV = MR ÷ W
-    NV = MV * NR
-    _check_acc(:_store_tile_planar_vector!, R, T, NA, 2NV)
-
-    blocks = Any[]
-    for j in 0:(NR - 1)
-        vblocks = Any[]
-        for v in 0:(MV - 1)
-            ire, iim = _planar_acc_index(kernel, MV, NR, v, j)
-            push!(
-                vblocks, quote
-                    revec = acc[$ire]
-                    imvec = acc[$iim]
-                    if $((v + 1) * W) <= m
-                        _planar_store_block!(
-                            sp, 2 * (colbase + $(v * W)), revec, imvec,
-                            ar, ai, br, bi, beta, Val($W)
-                        )
-                    elseif $(v * W) < m
-                        for lane in 1:$W
-                            i = $(v * W) + lane - 1
-                            i < m || break
-                            _axpby_at!(
-                                storage, colbase + i + 1, alpha,
-                                Complex(revec[lane], imvec[lane]), beta
-                            )
-                        end
-                    end
-                end
-            )
-        end
-        push!(
-            blocks, quote
-                if $j < n
-                    colbase = rowbase0 + axis_offset(cols, $j)  # zero-based (0, j)
-                    $(vblocks...)
-                end
-            end
-        )
-    end
-
-    return quote
-        Base.@_inline_meta
-        storage = destination.storage
-        cols = destination.cols
-        rowbase0 = destination.base + destination.rows.base
-        ar = Vec{$W, $R}(real(alpha))
-        ai = Vec{$W, $R}(imag(alpha))
-        br = Vec{$W, $R}(real(beta))
-        bi = Vec{$W, $R}(imag(beta))
-        GC.@preserve storage begin
-            sp = reinterpret(Ptr{$RC}, pointer(storage))
-            @inbounds begin
-                $(blocks...)
-            end
-        end
-        return destination
-    end
-end
-
-# `@inline` with the vector store, for the reason at the real `store_tile!`.
-@inline function store_tile!(
-        destination::QSTile, acc::NTuple{NA, Vec{W, R}},
-        alpha::T, beta::T, kernel::PlanarKernel{MR, NR, T, W}
-    ) where {MR, NR, T, W, R, NA}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-
-    if _complex_vector_eligible(destination, T)
-        return _store_tile_planar_vector!(destination, acc, alpha, beta, kernel, m, n)
-    end
-
-    return _store_tile_planar!(destination, acc, alpha, beta, kernel, m, n)
-end
diff --git a/src/microkernels/scalar.jl b/src/microkernels/scalar.jl
deleted file mode 100644
index f5b4bc2..0000000
--- a/src/microkernels/scalar.jl
+++ /dev/null
@@ -1,45 +0,0 @@
-"""
-    ScalarKernel(::Val{MR}, ::Val{NR}, ::Type{T})
-
-Scalar reference microkernel for register tile `(MR, NR)` and element type `T`.
-"""
-struct ScalarKernel{MR, NR, T} <: DescriptorKernel{MR, NR, T}
-    descriptor::KernelDescriptor{MR, NR, T}
-end
-
-ScalarKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T} =
-    ScalarKernel(KernelDescriptor(Val(MR), Val(NR), T))
-
-# `acc[i+1, j+1]` for zero-based `(i, j)`.
-zero_accumulator(kernel::ScalarKernel{MR, NR, T}) where {MR, NR, T} = zeros(T, MR, NR)
-
-# Extends `Base.accumulate` so `using QuasiStrided` does not clash with it.
-function Base.accumulate(
-        kernel::ScalarKernel{MR, NR, T}, acc::AbstractMatrix{T},
-        packed_a::PA, packed_b::PB, kc::Int
-    ) where {MR, NR, T, PA, PB}
-    kc == 0 && return acc
-    kc > 0 || throw(ArgumentError("accumulate requires kc >= 0, got kc = $kc"))
-    @inbounds for p in 0:(kc - 1)
-        for j in 0:(NR - 1)
-            bj = panel_load(packed_b, packed_b_offset(kernel, j, p))
-            for i in 0:(MR - 1)
-                ai = panel_load(packed_a, packed_a_offset(kernel, i, p))
-                acc[i + 1, j + 1] = muladd(ai, bj, acc[i + 1, j + 1])
-            end
-        end
-    end
-    return acc
-end
-
-function store_tile!(
-        destination::QSTile, acc::AbstractMatrix{T},
-        alpha::T, beta::T, kernel::ScalarKernel
-    ) where {T}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-    @inbounds for j in 0:(n - 1), i in 0:(m - 1)
-        _axpby_tile!(destination, i, j, alpha, acc[i + 1, j + 1], beta)
-    end
-    return destination
-end
diff --git a/src/microkernels/simd.jl b/src/microkernels/simd.jl
deleted file mode 100644
index 982bb08..0000000
--- a/src/microkernels/simd.jl
+++ /dev/null
@@ -1,204 +0,0 @@
-# Explicit-SIMD real microkernel. The accumulator is an immutable tuple of
-# `Vec{W,T}` so it stays in registers, and every K step and store is
-# `@generated` straight-line code.
-#
-# GUARDRAIL (all kernels): every `acc[...]` must be a *literal* tuple index.
-# Indexing an `NTuple` dynamically forces it to memory, and above 16 vectors
-# the compiler heap-allocates it on every call. Only the lane index inside one
-# `Vec` may be a runtime value.
-
-using SIMD: Vec, vload, vstore
-
-"""
-    SIMDKernel(::Val{MR}, ::Val{NR}, ::Type{T}[, ::Val{W}])
-
-Explicit-SIMD real microkernel over `SIMD.Vec{W,T}` lanes. `MR` must be a
-multiple of `W` (default: one 256-bit register, 4 for `Float64`, 8 for `Float32`).
-"""
-struct SIMDKernel{MR, NR, T, W} <: DescriptorKernel{MR, NR, T}
-    descriptor::KernelDescriptor{MR, NR, T}
-
-    function SIMDKernel{MR, NR, T, W}(descriptor::KernelDescriptor{MR, NR, T}) where {MR, NR, T, W}
-        _check_vector_shape("SIMDKernel", MR, W)
-        return new{MR, NR, T, W}(descriptor)
-    end
-end
-
-SIMDKernel(::Val{MR}, ::Val{NR}, ::Type{T}, ::Val{W}) where {MR, NR, T, W} =
-    SIMDKernel{MR, NR, T, W}(KernelDescriptor(Val(MR), Val(NR), T))
-SIMDKernel(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T} =
-    SIMDKernel(Val(MR), Val(NR), T, Val(_default_lanewidth(T)))
-
-lanewidth(::SIMDKernel{MR, NR, T, W}) where {MR, NR, T, W} = W
-
-# `(MR÷W)*NR` vectors; vector `v` of column `j` is at `v + (MR÷W)*j + 1`.
-function zero_accumulator(kernel::SIMDKernel{MR, NR, T, W}) where {MR, NR, T, W}
-    z = zero(Vec{W, T})
-    return ntuple(_ -> z, Val((MR ÷ W) * NR))
-end
-
-# B column `j` at K step `p`; `UnpackedBView` (src/execution/unpackedb.jl)
-# overrides it to read B in place, resolved at compile time.
-@inline _b_step_load(packed_b::PB, kernel, j::Int, p::Int) where {PB} =
-    panel_load(packed_b, packed_b_offset(kernel, j, p))
-
-@generated function _accumulate_step(
-        kernel::SIMDKernel{MR, NR, T, W}, acc::NTuple{NV, Vec{W, T}},
-        packed_a::PA, packed_b::PB, p::Int
-    ) where {MR, NR, T, W, NV, PA, PB}
-    NVECA = MR ÷ W
-    _check_acc(:_accumulate_step, T, T, NV, NVECA * NR)
-
-    avars = [Symbol(:a, v) for v in 0:(NVECA - 1)]
-    bvars = [Symbol(:b, j) for j in 0:(NR - 1)]
-
-    load_a = [
-        :($(avars[v + 1]) = panel_vload(Vec{$W, $T}, packed_a, packed_a_offset(kernel, $(v * W), p)))
-            for v in 0:(NVECA - 1)
-    ]
-    load_b = [
-        :($(bvars[j + 1]) = _b_step_load(packed_b, kernel, $j, p))
-            for j in 0:(NR - 1)
-    ]
-
-    acc_exprs = Vector{Any}(undef, NV)
-    for j in 0:(NR - 1), v in 0:(NVECA - 1)
-        idx = v + NVECA * j + 1
-        acc_exprs[idx] = :(muladd($(avars[v + 1]), $(bvars[j + 1]), acc[$idx]))
-    end
-
-    return quote
-        Base.@_inline_meta
-        @inbounds begin
-            $(load_a...)
-            $(load_b...)
-            return $(Expr(:tuple, acc_exprs...))
-        end
-    end
-end
-
-@inline function Base.accumulate(
-        kernel::SIMDKernel{MR, NR, T, W}, acc::NTuple{NV, Vec{W, T}},
-        packed_a::PA, packed_b::PB, kc::Int
-    ) where {MR, NR, T, W, NV, PA, PB}
-    kc == 0 && return acc
-    kc > 0 || _throw_negative_kc(:accumulate, kc)
-    @inbounds for p in 0:(kc - 1)
-        acc = _accumulate_step(kernel, acc, packed_a, packed_b, p)
-    end
-    return acc
-end
-
-# Vector store eligibility: unit-stride rows into rank-1 dense real storage,
-# exactly what SIMD.jl's array `vload`/`vstore` accept. Must admit `Memory{T}`:
-# that is the `parent` of an Array-backed `StridedView` on Julia >= 1.11.
-@inline _vector_store_eligible(tile::QSTile, ::Type{T}) where {T} =
-    _unit_stride_rows(tile.rows) && _dense_lanes(tile.storage, T)
-
-@generated function _store_tile_scattered!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, T}},
-        alpha::T, beta::T, kernel::SIMDKernel{MR, NR, T, W},
-        m::Int, n::Int
-    ) where {MR, NR, T, W, NV}
-    NVECA = MR ÷ W
-    blocks = Any[]
-    for j in 0:(NR - 1), v in 0:(NVECA - 1)
-        idx = v + NVECA * j + 1
-        push!(
-            blocks, quote
-                if $j < n
-                    vec = acc[$idx]
-                    for lane in 1:$W
-                        i = $(v * W) + lane - 1
-                        i < m || break
-                        _axpby_tile!(destination, i, $j, alpha, vec[lane], beta)
-                    end
-                end
-            end
-        )
-    end
-    return quote
-        @inbounds begin
-            $(blocks...)
-        end
-        return destination
-    end
-end
-
-# Whole `W`-row blocks are one vector load/store; a block straddling `m` is
-# stored lane by lane, so nothing outside the valid rectangle is touched.
-# `rows::AffineAxis` in the signature: an ineligible tile is a MethodError.
-@generated function _store_tile_vector!(
-        destination::QSTile{S, <:AffineAxis}, acc::NTuple{NV, Vec{W, T}},
-        alpha::T, beta::T, kernel::SIMDKernel{MR, NR, T, W},
-        m::Int, n::Int
-    ) where {S, MR, NR, T, W, NV}
-    NVECA = MR ÷ W
-    RC = eltype(S)
-    old = :(convert(Vec{$W, $T}, vload(Vec{$W, $RC}, storage, at)))
-    blocks = Any[]
-    for j in 0:(NR - 1)
-        vblocks = Any[]
-        for v in 0:(NVECA - 1)
-            idx = v + NVECA * j + 1
-            push!(
-                vblocks, quote
-                    vec = acc[$idx]
-                    if $((v + 1) * W) <= m
-                        at = colbase + $(v * W) + 1
-                        vstore(
-                            convert(
-                                Vec{$W, $RC},
-                                iszero(beta) ? alpha * vec :
-                                    isone(beta) ? muladd(alpha, vec, $old) :
-                                    muladd(alpha, vec, beta * $old)
-                            ),
-                            storage, at
-                        )
-                    elseif $(v * W) < m
-                        for lane in 1:$W
-                            i = $(v * W) + lane - 1
-                            i < m || break
-                            _axpby_at!(storage, colbase + i + 1, alpha, vec[lane], beta)
-                        end
-                    end
-                end
-            )
-        end
-        push!(
-            blocks, quote
-                if $j < n
-                    colbase = rowbase0 + axis_offset(cols, $j)  # zero-based (0, j)
-                    $(vblocks...)
-                end
-            end
-        )
-    end
-    return quote
-        Base.@_inline_meta
-        storage = destination.storage
-        cols = destination.cols
-        rowbase0 = destination.base + destination.rows.base
-        @inbounds begin
-            $(blocks...)
-        end
-        return destination
-    end
-end
-
-# `@inline` with the vector store: out of line, the whole accumulator is spilled
-# to the stack and reloaded on every micro-tile. The scattered store stays out
-# of line: it is scalar anyway, and inlining it bloats the tile function.
-@inline function store_tile!(
-        destination::QSTile, acc::NTuple{NV, Vec{W, T}},
-        alpha::T, beta::T, kernel::SIMDKernel{MR, NR, T, W}
-    ) where {MR, NR, T, W, NV}
-    m, n = _store_prologue!(destination, alpha, beta)
-    (m == 0 || n == 0) && return destination
-
-    if _vector_store_eligible(destination, T)
-        return _store_tile_vector!(destination, acc, alpha, beta, kernel, m, n)
-    end
-
-    return _store_tile_scattered!(destination, acc, alpha, beta, kernel, m, n)
-end
diff --git a/src/microkernels/steps.jl b/src/microkernels/steps.jl
new file mode 100644
index 0000000..d17d4fa
--- /dev/null
+++ b/src/microkernels/steps.jl
@@ -0,0 +1,258 @@
+# The K steps and the generic `add_tile`. A vector kernel's accumulator is an
+# immutable tuple of `Vec`s so it stays in registers, and every K step and store
+# is `@generated` straight-line code.
+#
+# GUARDRAIL (all kernels): every `acc[...]` must be a *literal* tuple index.
+# Indexing an `NTuple` dynamically forces it to memory, and above 16 vectors
+# the compiler heap-allocates it on every call. Only the lane index inside one
+# `Vec` may be a runtime value.
+
+using SIMD: Vec
+
+zero_accumulator(::ScalarKernel{MR, NR, T}) where {MR, NR, T} = ntuple(_ -> zero(T), Val(MR * NR))
+
+function add_tile(
+        kernel::ScalarKernel{MR, NR, T}, acc::NTuple{N, T},
+        packed_a::PA, packed_b::PB, k_block_length::Int
+    ) where {MR, NR, T, N, PA <: PackedPanel, PB}
+    k_block_length == 0 && return acc
+    k_block_length > 0 || throw_negative_k_block_length(:add_tile, k_block_length)
+    for p in 1:k_block_length
+        acc = add_step(kernel, acc, packed_a, packed_b, p)
+    end
+    return acc
+end
+
+# One K step: element `(i, j)` of the tile is `acc[i + MR * (j - 1)]`.
+@inline function add_step(
+        kernel::ScalarKernel{MR, NR, T}, acc::NTuple{N, T}, packed_a, packed_b, p::Int
+    ) where {MR, NR, T, N}
+    return ntuple(Val(N)) do q
+        i, j = mod1(q, MR), cld(q, MR)
+        a = panel_load(packed_a, packed_a_offset(kernel, i, p))
+        b = panel_load(packed_b, packed_b_offset(kernel, j, p))
+        muladd(a, b, acc[q])
+    end
+end
+
+function zero_accumulator(kernel::VectorKernel{MR, NR, T, W}) where {MR, NR, T, W}
+    layout = AccumulatorLayout(kernel)
+    z = zero(Vec{W, real(T)})
+    return ntuple(_ -> z, Val(accumulator_length(layout, MR ÷ rows_per_vector(layout, W), NR)))
+end
+
+# Not unrolled over an `UnpackedBView`: B's K stride is a runtime value, so
+# every unrolled step needs its own column addresses, which spill.
+@generated function add_tile(
+        kernel::VectorKernel, acc::NTuple{NA, Vec{W, R}},
+        packed_a::PA, packed_b::PB, k_block_length::Int
+    ) where {NA, W, R, PA <: PackedPanel, PB}
+    no_unroll = PB <: UnpackedBView ? Expr(:loopinfo, (Symbol("llvm.loop.unroll.disable"),)) : nothing
+    return quote
+        Base.@_inline_meta
+        k_block_length == 0 && return acc
+        k_block_length > 0 || throw_negative_k_block_length(:add_tile, k_block_length)
+        @inbounds for p in 1:k_steps(kernel, k_block_length)
+            acc = accumulate_step(kernel, acc, packed_a, packed_b, p)
+            $no_unroll
+        end
+        return acc
+    end
+end
+
+# B column `j` at K step `p`, as a real or as `(re, im)`; `UnpackedBView`
+# (src/packing/unpacked_b.jl) overrides both to read B in place, resolved at
+# compile time.
+@inline b_scalar(packed_b::PB, kernel, j::Int, p::Int) where {PB} =
+    panel_load(packed_b, packed_b_offset(kernel, j, p))
+@inline b_complex(packed_b::PB, kernel, j::Int, p::Int) where {PB} = (
+    panel_load(packed_b, packed_b_offset(kernel, j, p)),
+    panel_load(packed_b, packed_b_offset(kernel, j, p, 1)),
+)
+
+@generated function accumulate_step(
+        kernel::SIMDKernel{MR, NR, T, W}, acc::NTuple{NV, Vec{W, T}},
+        packed_a::PA, packed_b::PB, p::Int
+    ) where {MR, NR, T, W, NV, PA, PB}
+    NVECA = MR ÷ W
+    check_acc(:accumulate_step, T, T, NV, NVECA * NR)
+
+    avars = [Symbol(:a, v) for v in 0:(NVECA - 1)]
+    bvars = [Symbol(:b, j) for j in 1:NR]
+
+    load_a = [
+        :($(avars[v + 1]) = panel_vload(Vec{$W, $T}, packed_a, packed_a_offset(kernel, $(v * W + 1), p)))
+            for v in 0:(NVECA - 1)
+    ]
+    load_b = [
+        :($(bvars[j]) = b_scalar(packed_b, kernel, $j, p))
+            for j in 1:NR
+    ]
+
+    acc_exprs = Vector{Any}(undef, NV)
+    for j in 1:NR, v in 0:(NVECA - 1)
+        idx = acc_index(NVECA, v, j)
+        acc_exprs[idx] = :(muladd($(avars[v + 1]), $(bvars[j]), acc[$idx]))
+    end
+
+    return quote
+        Base.@_inline_meta
+        @inbounds begin
+            $(load_a...)
+            $(load_b...)
+            return $(Expr(:tuple, acc_exprs...))
+        end
+    end
+end
+
+# A kernel without a K step of its own runs its `inner(kernel)`'s.
+@inline accumulate_step(kernel::VectorKernel, acc::NTuple, packed_a::PA, packed_b::PB, p::Int) where {PA, PB} =
+    accumulate_step(inner(kernel), acc, packed_a, packed_b, p)
+
+# Planar (split-complex, BLIS "1r"), the default complex method. Both panels
+# are `PlanarFormat` (`[re_0..re_{n-1} | im_0..im_{n-1}]` per K step), so the
+# data is already in the right lanes: four real FMAs per (A-vector, B-scalar)
+# pair, no shuffles. Everything works in `real(T)`.
+#
+# GUARDRAIL: the real part is `muladd(-ai, bi, muladd(ar, br, c))`. `c - ai*bi`
+# does NOT fuse (Julia sets no LLVM `contract` flag): two instructions, and
+# different rounding. `-ai` is hoisted out of the `j` loop and folds into
+# `vfnmadd`, so the negation is free.
+@generated function accumulate_step(
+        kernel::PlanarKernel{MR, NR, T, W}, acc::NTuple{NA, Vec{W, R}},
+        packed_a::PA, packed_b::PB, p::Int
+    ) where {MR, NR, T, W, R, NA, PA, PB}
+    MV = MR ÷ W
+    NV = MV * NR
+    check_acc(:accumulate_step, R, T, NA, 2NV)
+
+    arv = [Symbol(:ar, v) for v in 0:(MV - 1)]
+    aiv = [Symbol(:ai, v) for v in 0:(MV - 1)]
+    naiv = [Symbol(:nai, v) for v in 0:(MV - 1)]
+    brv = [Symbol(:br, j) for j in 1:NR]
+    biv = [Symbol(:bi, j) for j in 1:NR]
+
+    load_a = Any[]
+    for v in 0:(MV - 1)
+        push!(
+            load_a,
+            :(
+                $(arv[v + 1]) = panel_vload(
+                    Vec{$W, $R}, packed_a, packed_a_offset(kernel, $(v * W + 1), p)
+                )
+            )
+        )
+        push!(
+            load_a,
+            :(
+                $(aiv[v + 1]) = panel_vload(
+                    Vec{$W, $R}, packed_a, packed_a_offset(kernel, $(v * W + 1), p, 1)
+                )
+            )
+        )
+        push!(load_a, :($(naiv[v + 1]) = -$(aiv[v + 1])))
+    end
+
+    load_b = Any[]
+    for j in 1:NR
+        push!(load_b, :(($(brv[j]), $(biv[j])) = b_complex(packed_b, kernel, $j, p)))
+    end
+
+    acc_exprs = Vector{Any}(undef, NA)
+    for j in 1:NR, v in 0:(MV - 1)
+        idx = acc_index(MV, v, j)
+        acc_exprs[idx] = :(  # re: ar*br - ai*bi
+            muladd(
+                $(naiv[v + 1]), $(biv[j]),
+                muladd($(arv[v + 1]), $(brv[j]), acc[$idx])
+            )
+        )
+        acc_exprs[NV + idx] = :(  # im: ar*bi + ai*br
+            muladd(
+                $(aiv[v + 1]), $(brv[j]),
+                muladd($(arv[v + 1]), $(biv[j]), acc[$(NV + idx)])
+            )
+        )
+    end
+
+    return quote
+        Base.@_inline_meta
+        @inbounds begin
+            $(load_a...)
+            $(load_b...)
+            return $(Expr(:tuple, acc_exprs...))
+        end
+    end
+end
+
+# FMAddSub (interleaved accumulator): one accumulator plane in 1m's layout
+# (lanes `(2u-1, 2u)` are `(re, im)` of one complex row), updated per
+# (A-vector, B-column) pair by two chained x86 `vfmaddsub` ops:
+#
+#     acc = fmaddsub(a, br, fmaddsub(swap(a), bi, acc))
+#
+# where `fmaddsub(x, y, c)` is `x*y - c` in even (0-based) lanes and `x*y + c`
+# in odd lanes, `a = [ar0, ai0, ...]`, `swap(a) = [ai0, ar0, ...]`. The two
+# sign flips compose back to an accumulation:
+#
+#     even:  ar*br - (ai*bi - c_re)  =  c_re + ar*br - ai*bi
+#     odd:   ai*br + (ar*bi + c_im)  =  c_im + ai*br + ar*bi
+#
+# The lane-parity sign needs re/im of one element in adjacent lanes, hence
+# `InterleavedFormat` A; B is read as broadcast scalars, so it stays planar.
+# Same FMA count as planar and 1m, plus one pair-swap per A vector per K step.
+#
+# The INNER op must be the `swap(a) * bi` one: only the inner product is
+# subtracted in the real lanes. Reversed, the real part is `ai*bi - ar*br`.
+@generated function accumulate_step(
+        kernel::FMAddSubKernel{MR, NR, T, W}, acc::NTuple{NA, Vec{W, R}},
+        packed_a::PA, packed_b::PB, p::Int
+    ) where {MR, NR, T, W, R, NA, PA, PB}
+    MV = (2 * MR) ÷ W
+    check_acc(:accumulate_step, R, T, NA, MV * NR)
+
+    av = [Symbol(:a, v) for v in 0:(MV - 1)]
+    sv = [Symbol(:s, v) for v in 0:(MV - 1)]
+    brv = [Symbol(:br, j) for j in 1:NR]
+    biv = [Symbol(:bi, j) for j in 1:NR]
+
+    load_a = Any[]
+    for v in 0:(MV - 1)
+        push!(
+            load_a,
+            :(
+                $(av[v + 1]) = panel_vload(
+                    Vec{$W, $R}, packed_a, packed_a_offset(kernel, $(v * W + 1), p)
+                )
+            )
+        )
+        push!(load_a, :($(sv[v + 1]) = swap_pairs($(av[v + 1]))))
+    end
+
+    load_b = Any[]
+    for j in 1:NR
+        push!(load_b, :((br_s, bi_s) = b_complex(packed_b, kernel, $j, p)))
+        push!(load_b, :($(brv[j]) = Vec{$W, $R}(br_s)))
+        push!(load_b, :($(biv[j]) = Vec{$W, $R}(bi_s)))
+    end
+
+    acc_exprs = Vector{Any}(undef, NA)
+    for j in 1:NR, v in 0:(MV - 1)
+        idx = acc_index(MV, v, j)
+        acc_exprs[idx] = :(
+            fmaddsub(
+                $(av[v + 1]), $(brv[j]),
+                fmaddsub($(sv[v + 1]), $(biv[j]), acc[$idx])
+            )
+        )
+    end
+
+    return quote
+        Base.@_inline_meta
+        @inbounds begin
+            $(load_a...)
+            $(load_b...)
+            return $(Expr(:tuple, acc_exprs...))
+        end
+    end
+end
diff --git a/src/microkernels/stores.jl b/src/microkernels/stores.jl
new file mode 100644
index 0000000..0ca58e5
--- /dev/null
+++ b/src/microkernels/stores.jl
@@ -0,0 +1,278 @@
+# The stores: one generic `store_tile!` per kernel, picking the vector or the
+# scalar store; each accumulator layout supplies its full-block store and lane
+# value.
+
+using SIMD: Vec, vload, vstore
+
+# Real and split stores are `@inline`: out of line, the whole accumulator is
+# spilled to the stack and reloaded on every micro-tile. The lane-pair store is
+# not: inlining it cost time (code growth). The scalar stores never are: they
+# are scalar anyway, and inlining them bloats the tile function.
+inline_store(::AccumulatorLayout) = true
+inline_store(::LanePairLayout) = false
+
+# Generator-time pieces of the stores. `acc_bindings` names the accumulator
+# vector(s) of row block `v` (zero-based) of column `j`, `lane_value` is the
+# element at row `lane` of the block, `block_store` stores a full block whose
+# first row is at zero-based storage index `first`, for the type `B` of the
+# `beta` case (`Zero`, `One` or the element type) bound to `beta_case`.
+split_index(::Type{<:PlanarKernel}, MV::Int, NR::Int, v::Int, j::Int) =
+    (acc_index(MV, v, j), MV * NR + acc_index(MV, v, j))
+split_index(::Type{<:RealComplexKernel}, MV::Int, NR::Int, v::Int, j::Int) =
+    (v + MV * (2j - 2) + 1, v + MV * (2j - 1) + 1)
+
+acc_bindings(::AccumulatorLayout, kernel::Type, MV::Int, NR::Int, v::Int, j::Int) =
+    :(vec = acc[$(acc_index(MV, v, j))])
+function acc_bindings(::SplitLayout, kernel::Type, MV::Int, NR::Int, v::Int, j::Int)
+    ire, iim = split_index(kernel, MV, NR, v, j)
+    return quote
+        revec = acc[$ire]
+        imvec = acc[$iim]
+    end
+end
+
+lane_value(::RealLayout) = :(vec[lane])
+lane_value(::SplitLayout) = :(Complex(revec[lane], imvec[lane]))
+lane_value(::LanePairLayout) = :(Complex(vec[2 * lane - 1], vec[2 * lane]))
+
+function block_store(::RealLayout, first, W::Int, R::Type, RC::Type, B::Type)
+    old = c_operand(B, :(convert(Vec{$W, $R}, vload(Vec{$W, $RC}, storage, at))))
+    return quote
+        at = $first + 1
+        vstore(convert(Vec{$W, $RC}, axpby(alpha, vec, $old, beta_case)), storage, at)
+    end
+end
+block_store(::SplitLayout, first, W::Int, R::Type, RC::Type, B::Type) =
+    :(split_store_block!(sp, 2 * $first, revec, imvec, ar, ai, br, bi, Val($W), beta_case))
+block_store(::LanePairLayout, first, W::Int, R::Type, RC::Type, B::Type) =
+    :(lanepair_store_block!(sp, 2 * $first, vec, ar, ai, br, bi, beta_case))
+
+# The old C operand of `axpby`, never loaded for `beta == 0`.
+c_operand(::Type{Zero}, old) = nothing
+c_operand(::Type, old) = old
+
+# The real lane type of the vector store's storage `S`. The complex layouts
+# reinterpret the storage as reals, only sound on dense rank-1 complex storage.
+store_lanetype(::RealLayout, S::Type, T::Type) = eltype(S)
+function store_lanetype(::AccumulatorLayout, S::Type, T::Type)
+    S <: DenseVector && lane_convertible(eltype(S), T) ||
+        throw(ArgumentError("vector_store!: storage $S is not a dense vector convertible to $T"))
+    return real(eltype(S))
+end
+
+# The vector store's body around its blocks: the complex layouts broadcast
+# `alpha`/`beta` once and store through a raw pointer, only dereferenced
+# inside `GC.@preserve`.
+store_body(::RealLayout, W::Int, R::Type, RC::Type, body) = :(@inbounds $body)
+store_body(::AccumulatorLayout, W::Int, R::Type, RC::Type, body) = quote
+    ar = Vec{$W, $R}(real(alpha))
+    ai = Vec{$W, $R}(imag(alpha))
+    br = Vec{$W, $R}(real(beta))
+    bi = Vec{$W, $R}(imag(beta))
+    GC.@preserve storage begin
+        sp = reinterpret(Ptr{$RC}, pointer(storage))
+        @inbounds $body
+    end
+end
+
+# Vector store eligibility: unit-stride rows into rank-1 dense storage, exactly
+# what SIMD.jl's array `vload`/`vstore` accept. Must admit `Memory{T}`: that is
+# the `parent` of an Array-backed `StridedView` on Julia >= 1.11. The complex
+# layouts reinterpret `W` rows as `2W` consecutive reals, on an ISA the complex
+# fast paths ship for (shared with the complex pack fast path).
+@inline vector_store_eligible(::RealLayout, tile::Tile, ::Type{T}) where {T} =
+    is_unit_stride(tile.rows) && dense_lanes(tile.storage, T)
+@inline vector_store_eligible(::AccumulatorLayout, tile::Tile, ::Type{T}) where {T} =
+    is_unit_stride(tile.rows) && dense_lanes(tile.storage, T) &&
+    complex_fastpath_isa_eligible()
+
+# One full `W`-row block for a `beta` case; `at` is the zero-based index of
+# its first real.
+# The arithmetic transcribes Base's `Complex` expression trees (the ones
+# `axpby_tile!` reaches), so full blocks match them bitwise: `*` is unfused,
+# `muladd(z, w, x) = (muladd(zr, wr, -muladd(zi, wi, -xr)), muladd(zr, wi,
+# muladd(zi, wr, xi)))`. Against the scalar fallback it is exact at
+# `beta == 0/1` and ~1 ULP otherwise, because LLVM contracts Base's scalar
+# complex `muladd` depending on inlining context.
+@inline function split_store_block!(
+        sp::Ptr{RC}, at::Int, rev::Vec{W, R}, imv::Vec{W, R},
+        ar::Vec{W, R}, ai::Vec{W, R}, br::Vec{W, R}, bi::Vec{W, R},
+        ::Val{W}, ::Zero
+    ) where {RC, R, W}
+    newre = ar * rev - ai * imv
+    newim = ar * imv + ai * rev
+    vstore(convert(Vec{2 * W, RC}, interleave_planes(newre, newim, Val(W))), sp + sizeof(RC) * at)
+    return nothing
+end
+@inline function split_store_block!(
+        sp::Ptr{RC}, at::Int, rev::Vec{W, R}, imv::Vec{W, R},
+        ar::Vec{W, R}, ai::Vec{W, R}, br::Vec{W, R}, bi::Vec{W, R},
+        ::Val{W}, beta
+    ) where {RC, R, W}
+    old = convert(Vec{2 * W, R}, vload(Vec{2 * W, RC}, sp + sizeof(RC) * at))
+    xr, xi = split_scaled(deinterleave_re(old, Val(W)), deinterleave_im(old, Val(W)), br, bi, beta)
+    newre = muladd(ar, rev, -muladd(ai, imv, -xr))
+    newim = muladd(ar, imv, muladd(ai, rev, xi))
+    vstore(convert(Vec{2 * W, RC}, interleave_planes(newre, newim, Val(W))), sp + sizeof(RC) * at)
+    return nothing
+end
+
+# `beta * C` in planes.
+@inline split_scaled(orv, oiv, br, bi, ::One) = (orv, oiv)
+@inline split_scaled(orv, oiv, br, bi, beta) = (br * orv - bi * oiv, br * oiv + bi * orv)
+
+# One full `W÷2`-row block, already in `Complex`'s memory order, so no
+# interleave shuffle. Base's `Complex` expression trees in lanes, as planar's
+# `split_store_block!`:
+#     beta == 0:  addsub(ar*r, ai*swap(r))
+#     beta == 1:  fmaddsub(ar, r, fmaddsub(ai, swap(r), C))
+#     otherwise:  as beta == 1 with C := addsub(br*C, bi*swap(C))
+@inline function lanepair_store_block!(
+        sp::Ptr{RC}, at::Int, r::Vec{W, R},
+        ar::Vec{W, R}, ai::Vec{W, R}, br::Vec{W, R}, bi::Vec{W, R}, ::Zero
+    ) where {RC, R, W}
+    vstore(convert(Vec{W, RC}, addsub(ar * r, ai * swap_pairs(r))), sp + sizeof(RC) * at)
+    return nothing
+end
+@inline function lanepair_store_block!(
+        sp::Ptr{RC}, at::Int, r::Vec{W, R},
+        ar::Vec{W, R}, ai::Vec{W, R}, br::Vec{W, R}, bi::Vec{W, R}, beta
+    ) where {RC, R, W}
+    old = convert(Vec{W, R}, vload(Vec{W, RC}, sp + sizeof(RC) * at))
+    new = fmaddsub(ar, r, fmaddsub(ai, swap_pairs(r), lanepair_scaled(old, br, bi, beta)))
+    vstore(convert(Vec{W, RC}, new), sp + sizeof(RC) * at)
+    return nothing
+end
+
+@inline lanepair_scaled(old, br, bi, ::One) = old
+@inline lanepair_scaled(old, br, bi, beta) = addsub(br * old, bi * swap_pairs(old))
+
+@generated function store_tile!(
+        destination::Tile, acc::NTuple{NA, Vec{W, R}},
+        alpha::T, beta::T, kernel::VectorKernel{MR, NR, T, W}
+    ) where {MR, NR, T, W, R, NA}
+    layout = AccumulatorLayout(kernel)
+    return quote
+        $(inline_store(layout) ? :(Base.@_inline_meta) : nothing)
+        m, n = store_prologue!(destination, alpha, beta)
+        (m == 0 || n == 0) && return destination
+
+        if vector_store_eligible($layout, destination, T)
+            return vector_store!(destination, acc, alpha, beta, kernel, m, n)
+        end
+
+        return scalar_store!(destination, acc, alpha, beta, kernel, m, n)
+    end
+end
+
+# Element by element, for every destination the vector store cannot take.
+@generated function scalar_store!(
+        destination::Tile, acc::NTuple{NA, Vec{W, R}},
+        alpha::T, beta::T, kernel::VectorKernel{MR, NR, T, W},
+        m::Int, n::Int
+    ) where {MR, NR, T, W, R, NA}
+    layout = AccumulatorLayout(kernel)
+    rows = rows_per_vector(layout, W)
+    MV = MR ÷ rows
+    check_acc(:scalar_store!, R, T, NA, accumulator_length(layout, MV, NR))
+
+    blocks = Any[]
+    for j in 1:NR, v in 0:(MV - 1)
+        push!(
+            blocks, quote
+                if $j <= n
+                    $(acc_bindings(layout, kernel, MV, NR, v, j))
+                    for lane in 1:$rows
+                        i = $(v * rows) + lane
+                        i <= m || break
+                        axpby_tile!(destination, i, $j, alpha, $(lane_value(layout)), static_beta(beta))
+                    end
+                end
+            end
+        )
+    end
+    return quote
+        @inbounds begin
+            $(blocks...)
+        end
+        return destination
+    end
+end
+
+# Whole row blocks are one vector load/store; a block straddling `m` is stored
+# lane by lane, so nothing outside the valid rectangle is touched. The blocks
+# are generated once per `beta` case, so `beta` is tested once per tile.
+# `rows::AffineAxis` in the signature: an ineligible tile is a MethodError.
+@generated function vector_store!(
+        destination::Tile{S, <:AffineAxis}, acc::NTuple{NA, Vec{W, R}},
+        alpha::T, beta::T, kernel::VectorKernel{MR, NR, T, W},
+        m::Int, n::Int
+    ) where {S, MR, NR, T, W, R, NA}
+    layout = AccumulatorLayout(kernel)
+    rows = rows_per_vector(layout, W)
+    MV = MR ÷ rows
+    check_acc(:vector_store!, R, T, NA, accumulator_length(layout, MV, NR))
+    RC = store_lanetype(layout, S, T)
+
+    function blocks(B)
+        out = Any[]
+        for j in 1:NR
+            vblocks = Any[]
+            for v in 0:(MV - 1)
+                push!(
+                    vblocks, quote
+                        $(acc_bindings(layout, kernel, MV, NR, v, j))
+                        if $((v + 1) * rows) <= m
+                            $(block_store(layout, :(colbase + $(v * rows)), W, R, RC, B))
+                        elseif $(v * rows) < m
+                            for lane in 1:$rows
+                                i = $(v * rows) + lane
+                                i <= m || break
+                                axpby_at!(storage, colbase + i, alpha, $(lane_value(layout)), beta_case)
+                            end
+                        end
+                    end
+                )
+            end
+            push!(
+                out, quote
+                    if $j <= n
+                        colbase = rowbase0 + cols[$j]  # the address of (1, j)
+                        $(vblocks...)
+                    end
+                end
+            )
+        end
+        return out
+    end
+    by_beta = quote
+        beta_case = static_beta(beta)
+        if beta_case isa Zero
+            $(blocks(Zero)...)
+        elseif beta_case isa One
+            $(blocks(One)...)
+        else
+            $(blocks(T)...)
+        end
+    end
+    return quote
+        $(inline_store(layout) ? :(Base.@_inline_meta) : nothing)
+        storage = destination.storage
+        cols = destination.cols
+        rowbase0 = @inbounds destination.base + destination.rows[1]
+        $(store_body(layout, W, R, RC, by_beta))
+        return destination
+    end
+end
+
+function store_tile!(
+        destination::Tile, acc::NTuple{N, T},
+        alpha::T, beta::T, kernel::ScalarKernel{MR}
+    ) where {MR, N, T}
+    m, n = store_prologue!(destination, alpha, beta)
+    (m == 0 || n == 0) && return destination
+    @inbounds for j in 1:n, i in 1:m
+        axpby_tile!(destination, i, j, alpha, acc[i + MR * (j - 1)], static_beta(beta))
+    end
+    return destination
+end
diff --git a/src/microkernels/vecops.jl b/src/microkernels/vecops.jl
new file mode 100644
index 0000000..f60175a
--- /dev/null
+++ b/src/microkernels/vecops.jl
@@ -0,0 +1,71 @@
+# SIMD building blocks shared by the K steps and the stores. Shuffle patterns are
+# built from the vector width at specialization time, never hardcoded to one ISA.
+
+using SIMD: Vec, shufflevector
+
+# `x*y - c` in even lanes, `x*y + c` in odd lanes, each one fused rounding.
+# Generic IR (`fneg` + two `llvm.fma` + a blend), which the X86 backend folds
+# into one `vfmaddsub` wherever FMA3 exists (and elsewhere stays correct).
+# GUARDRAIL: the SIMD.jl spelling `shufflevector(muladd(x, y, -c), muladd(x, y,
+# c), ...)` also selects `vfmaddsub` but leaves a dead stack store of the
+# accumulator in the K loop, every step.
+@generated function fmaddsub(x::Vec{N, R}, y::Vec{N, R}, c::Vec{N, R}) where {N, R}
+    R === Float64 || R === Float32 ||
+        return :(throw(ArgumentError("fmaddsub: unsupported lane type $R")))
+    ty = "<$N x $(R === Float64 ? "double" : "float")>"
+    fn = "llvm.fma.v$(N)$(R === Float64 ? "f64" : "f32")"
+    # lane k: even -> `s` (x*y - c); odd -> `d` (x*y + c), index N + k.
+    mask = join(("i32 $(iseven(k) ? k : N + k)" for k in 0:(N - 1)), ", ")
+    ir = """
+    declare $ty @$fn($ty, $ty, $ty)
+    define $ty @entry($ty %x, $ty %y, $ty %c) #0 {
+    top:
+      %nc = fneg $ty %c
+      %s = call $ty @$fn($ty %x, $ty %y, $ty %nc)
+      %d = call $ty @$fn($ty %x, $ty %y, $ty %c)
+      %r = shufflevector $ty %s, $ty %d, <$N x i32> <$mask>
+      ret $ty %r
+    }
+    attributes #0 = { alwaysinline }
+    """
+    VT = NTuple{N, VecElement{R}}
+    return quote
+        Base.@_inline_meta
+        Vec{$N, $R}(
+            Base.llvmcall(($ir, "entry"), $VT, Tuple{$VT, $VT, $VT}, x.data, y.data, c.data)
+        )
+    end
+end
+
+# `[x1, x0, x3, x2, ...]`: one in-lane `vshufpd`/`vpermilps`.
+@generated function swap_pairs(x::Vec{N, R}) where {N, R}
+    iseven(N) || return :(throw(ArgumentError("swap_pairs: expected even N, got $N")))
+    idx = ntuple(k -> isodd(k) ? k : k - 2, N)
+    return :(Base.@_inline_meta; shufflevector(x, Val($idx)))
+end
+
+# `p - q` in even lanes, `p + q` in odd lanes: Base's unfused complex `*` on
+# interleaved data.
+@generated function addsub(p::Vec{N, R}, q::Vec{N, R}) where {N, R}
+    iseven(N) || return :(throw(ArgumentError("addsub: expected even N, got $N")))
+    idx = ntuple(k -> iseven(k - 1) ? k - 1 : N + k - 1, N)
+    return :(Base.@_inline_meta; shufflevector(p - q, p + q, Val($idx)))
+end
+
+# `v` holds `W` complex values `[re_0, im_0, ..., re_{W-1}, im_{W-1}]`.
+@generated function deinterleave_re(v::Vec{N, R}, ::Val{W}) where {N, R, W}
+    N == 2 * W || return :(throw(ArgumentError("deinterleave_re: expected N == 2W")))
+    idx = ntuple(k -> 2 * (k - 1), W)
+    return :(shufflevector(v, Val($idx)))
+end
+
+@generated function deinterleave_im(v::Vec{N, R}, ::Val{W}) where {N, R, W}
+    N == 2 * W || return :(throw(ArgumentError("deinterleave_im: expected N == 2W")))
+    idx = ntuple(k -> 2 * (k - 1) + 1, W)
+    return :(shufflevector(v, Val($idx)))
+end
+
+@generated function interleave_planes(re::Vec{W, R}, im::Vec{W, R}, ::Val{W}) where {W, R}
+    idx = ntuple(k -> isodd(k) ? (k - 1) ÷ 2 : W + (k - 1) ÷ 2, 2 * W)
+    return :(shufflevector(re, im, Val($idx)))
+end
diff --git a/src/packing/format.jl b/src/packing/format.jl
index 07d1a9f..cf1c977 100644
--- a/src/packing/format.jl
+++ b/src/packing/format.jl
@@ -1,10 +1,10 @@
 # The contract between packing and the microkernels: the packed-panel formats
 # and the descriptor fixing a kernel's register tile, element type and panel
-# formats. Complex panels are "N planes of real(T)"; every format is addressed by
+# formats. Complex panels are "N planes of real(T)". A sliver of register
+# extent `R` (`MR` for A, `NR` for B) puts lane `i` of plane `plane` at K step
+# `p` (one-based `i`, `p`) at zero-based offset, in reals,
 #
-#     p * reg_tile * reals_per_element  +  plane * reg_tile  +  i
-#
-# which at RealFormat (one real per element, plane 0) reduces to `i + MR*p`.
+#     (p - 1) * R * reals_per_element  +  plane * R  +  (i - 1)
 
 abstract type PackFormat end
 
@@ -25,54 +25,48 @@ reals_per_element(::InterleavedFormat) = 2
 reals_per_element(::OneEFormat) = 4
 
 # `MR`/`NR` are logical extents (complex elements for a complex `T`); every
-# length and offset below takes the logical `kc` and counts reals.
+# length and offset below takes the logical `k_block_length` and counts reals.
 struct Descriptor{MR, NR, T, FA <: PackFormat, FB <: PackFormat}
     function Descriptor{MR, NR, T, FA, FB}() where {MR, NR, T, FA, FB}
-        _check_descriptor(MR, NR, T, FA, FB)
+        check_descriptor(MR, NR, T, FA, FB)
         return new{MR, NR, T, FA, FB}()
     end
 end
 
-const KernelDescriptor{MR, NR, T} = Descriptor{MR, NR, T, RealFormat, RealFormat}
-const ComplexKernelDescriptor{MR, NR, T <: Complex, FA, FB} = Descriptor{MR, NR, T, FA, FB}
-
-KernelDescriptor(::Val{MR}, ::Val{NR}, ::Type{T}) where {MR, NR, T} = KernelDescriptor{MR, NR, T}()
+const RealDescriptor{MR, NR, T} = Descriptor{MR, NR, T, RealFormat, RealFormat}
 
-function ComplexKernelDescriptor(
-        ::Val{MR}, ::Val{NR}, ::Type{T}, ::FA, ::FB
-    ) where {MR, NR, T, FA <: PackFormat, FB <: PackFormat}
-    return Descriptor{MR, NR, T, FA, FB}()
-end
+Descriptor(
+    ::Val{MR}, ::Val{NR}, ::Type{T}, a_format::PackFormat = RealFormat(), b_format::PackFormat = RealFormat()
+) where {MR, NR, T} = Descriptor{MR, NR, T, typeof(a_format), typeof(b_format)}()
 
-function _check_descriptor(MR, NR, T, FA, FB)
+function check_descriptor(MR, NR, T, FA, FB)
     real_formats = FA === RealFormat && FB === RealFormat
-    name = real_formats ? "KernelDescriptor" : "ComplexKernelDescriptor"
     MR isa Int && NR isa Int ||
-        throw(ArgumentError("$name requires Int type parameters MR, NR"))
-    MR > 0 || throw(ArgumentError("$name requires MR > 0, got MR = $MR"))
-    NR > 0 || throw(ArgumentError("$name requires NR > 0, got NR = $NR"))
+        throw(ArgumentError("Descriptor requires Int type parameters MR, NR"))
+    MR > 0 || throw(ArgumentError("Descriptor requires MR > 0, got MR = $MR"))
+    NR > 0 || throw(ArgumentError("Descriptor requires NR > 0, got NR = $NR"))
     if real_formats
         T === Float32 || T === Float64 ||
-            throw(ArgumentError("KernelDescriptor requires T ∈ (Float32, Float64), got $T"))
+            throw(ArgumentError("Descriptor with real formats requires T ∈ (Float32, Float64), got $T"))
     else
         # A real operand of a complex `T` only in the mixed-domain pairings.
         mixed = (FA, FB) === (InterleavedFormat, RealFormat) ||
             (FA, FB) === (RealFormat, InterleavedFormat)
         !mixed && (FA === RealFormat || FB === RealFormat) && throw(
             ArgumentError(
-                "ComplexKernelDescriptor requires complex formats on both operands, " *
+                "Descriptor requires complex formats on both operands, " *
                     "or (InterleavedFormat, RealFormat) / (RealFormat, InterleavedFormat), got ($FA, $FB)"
             )
         )
         T === ComplexF32 || T === ComplexF64 || throw(
-            ArgumentError("ComplexKernelDescriptor requires T in (ComplexF32, ComplexF64), got $T")
+            ArgumentError("Descriptor with complex formats requires T in (ComplexF32, ComplexF64), got $T")
         )
     end
     return nothing
 end
 
-mr(::Descriptor{MR}) where {MR} = MR
-nr(::Descriptor{MR, NR}) where {MR, NR} = NR
+tile_size(::Descriptor{MR, NR}) where {MR, NR} = (MR, NR)
+tile_size(k, i::Int) = tile_size(k)[i]
 scalartype(::Descriptor{MR, NR, T}) where {MR, NR, T} = T
 a_format(::Descriptor{MR, NR, T, FA, FB}) where {MR, NR, T, FA, FB} = FA()
 b_format(::Descriptor{MR, NR, T, FA, FB}) where {MR, NR, T, FA, FB} = FB()
@@ -80,19 +74,28 @@ b_format(::Descriptor{MR, NR, T, FA, FB}) where {MR, NR, T, FA, FB} = FB()
 realtype(::Descriptor{MR, NR, T}) where {MR, NR, T} = real(T)
 
 # Reals per A / B sliver per logical K step.
-packed_a_per_k(d::Descriptor{MR}) where {MR} = MR * reals_per_element(a_format(d))
-packed_b_per_k(d::Descriptor{MR, NR}) where {MR, NR} = NR * reals_per_element(b_format(d))
+sliver_width(d::Descriptor{MR, NR}) where {MR, NR} =
+    (MR * reals_per_element(a_format(d)), NR * reals_per_element(b_format(d)))
+sliver_width(k, i::Int) = sliver_width(k)[i]
+
+# How one operand's slivers are packed: side `I` (1 for A, 2 for B), `L` lanes
+# (`MR` or `NR`) in format `F`, for a kernel of scalar type `T`.
+struct SliverSpec{I, L, F <: PackFormat, T} end
+
+@inline sliver_spec(::Descriptor{MR, NR, T, FA, FB}, i::Int) where {MR, NR, T, FA, FB} =
+    i == 1 ? SliverSpec{1, MR, FA, T}() : SliverSpec{2, NR, FB, T}()
 
-packed_a_length(d::Descriptor, kc::Int) = packed_a_per_k(d) * kc
-packed_b_length(d::Descriptor, kc::Int) = packed_b_per_k(d) * kc
+realtype(::SliverSpec{I, L, F, T}) where {I, L, F, T} = real(T)
+sliver_width(::SliverSpec{I, L, F}) where {I, L, F} = L * reals_per_element(F())
+packed_length(spec::SliverSpec, k_block_length::Int) = sliver_width(spec) * k_block_length
 
-# Zero-based offsets, in reals. For 1e and interleaved, `i`/`j` runs over reals
-# (0:2MR-1) and 1e's second region is `plane == 2`.
-@inline packed_a_plane_offset(d::Descriptor{MR}, plane::Int, i::Int, p::Int) where {MR} =
-    p * packed_a_per_k(d) + plane * MR + i
-@inline packed_b_plane_offset(d::Descriptor{MR, NR}, plane::Int, j::Int, p::Int) where {MR, NR} =
-    p * packed_b_per_k(d) + plane * NR + j
+# Zero-based offset, in reals, of lane `t` of plane `plane` at K step `p`. For
+# 1e and interleaved, `t` runs over reals (1:2L) and 1e's second region is
+# `plane == 2`.
+@inline panel_offset(spec::SliverSpec{I, L}, t::Int, p::Int, plane::Int = 0) where {I, L} =
+    (p - 1) * sliver_width(spec) + plane * L + (t - 1)
 
-# Real descriptors only: a complex element has no single offset.
-packed_a_offset(kernel::KernelDescriptor{MR}, i::Int, p::Int) where {MR} = i + MR * p
-packed_b_offset(kernel::KernelDescriptor{MR, NR}, j::Int, p::Int) where {MR, NR} = j + NR * p
+packed_a_length(d::Descriptor, k_block_length::Int) = packed_length(sliver_spec(d, 1), k_block_length)
+packed_b_length(d::Descriptor, k_block_length::Int) = packed_length(sliver_spec(d, 2), k_block_length)
+@inline packed_a_offset(d::Descriptor, i::Int, p::Int, plane::Int = 0) = panel_offset(sliver_spec(d, 1), i, p, plane)
+@inline packed_b_offset(d::Descriptor, j::Int, p::Int, plane::Int = 0) = panel_offset(sliver_spec(d, 2), j, p, plane)
diff --git a/src/packing/line_packing.jl b/src/packing/line_packing.jl
new file mode 100644
index 0000000..a5ce3d4
--- /dev/null
+++ b/src/packing/line_packing.jl
@@ -0,0 +1,215 @@
+# Packing by cache lines. When a register sliver reads one element per line and
+# the line's other elements belong to coordinates a whole sweep of the free
+# composite later, lines rarely survive until reused; at power-of-two extents
+# they alias in a few cache sets and the pack costs a memory latency per
+# element. A split plan enumerates the free composite so that a macro block
+# holds whole lines, and packs each block line by line
+# (`pack_block_by_lines!`); the packed format and the K order are unchanged.
+
+"""
+    PackSplit(q, dj, L, kinner, Eq, E)
+
+How one operand's free group is enumerated and packed under a split: axis `q`
+in chunks of `Eq`, the unit-stride axis `dj > q` in chunks of `L` (a line's
+worth) placed right after the `Eq` chunk. A group is then `E x L`
+coordinates, `E` = (lengths before `q`) * `Eq`, and the block walk reads its
+lines K step by K step, or with K innermost when `kinner`. `L == 0`: no split.
+"""
+struct PackSplit
+    # Narrow fields: the plan carries two of these through every call.
+    q::UInt8
+    dj::UInt8
+    L::UInt8
+    kinner::Bool
+    Eq::Int32
+    E::Int32
+end
+
+const NO_SPLIT = PackSplit(0, 0, 0, false, 0, 0)
+
+is_split(s::PackSplit) = s.L != 0
+
+# The split for the free group `g` of operand `side` (1: A for M, 2: B for N),
+# packed in slivers of `lanes` elements of `format`, whose storage eltype takes
+# `S` bytes, and the block extent it needs, or `(eff, NO_SPLIT)`. `eff` is the
+# plan's extent, `rounded` the requested one rounded to the tile; a split block
+# may take the budget the blocking reserved for `k_block_requested` when the K
+# extent clamps `k_block`. `l2bytes = nothing`: `split_capacity`, doubled for
+# complex, whose block walk costs more per element.
+@inline function pack_split(
+        g::AxisGroup{D}, kg::AxisGroup, side::Int, lanes::Int, format::PackFormat, S::Int, k_block::Int,
+        eff::Int, rounded::Int, k_block_requested::Int; l2bytes::Union{Int, Nothing} = nothing
+    ) where {D}
+    D < 256 || return (eff, NO_SPLIT)
+    line = line_bytes(target_profile())
+    d1 = 0
+    for d in 1:D
+        g.lengths[d] > 1 && (d1 = d; break)
+    end
+    (d1 > 0 && abs(g.strides[1][d1]) * S >= line) || return (eff, NO_SPLIT)
+    dj = 0
+    for d in (d1 + 1):D
+        g.lengths[d] > 1 && abs(g.strides[1][d]) == 1 && (dj = d; break)
+    end
+    dj == 0 && return (eff, NO_SPLIT)
+    return pack_split_window(g, kg, side, d1, dj, lanes, S, !(format isa RealFormat), line, k_block, eff, rounded, k_block_requested, l2bytes)
+end
+
+# Out of line: shared by every eltype, and most plans never get here.
+@noinline function pack_split_window(
+        g::AxisGroup, kg::AxisGroup{DK}, kmap::Int, d1::Int, dj::Int, R::Int, S::Int, complex::Bool,
+        line::Int, k_block::Int, eff::Int, rounded::Int, k_block_requested::Int, l2bytes::Union{Int, Nothing}
+    ) where {DK}
+    L = largest_divisor_upto(g.lengths[dj], max(1, line ÷ S))
+    L >= 2 || return (eff, NO_SPLIT)
+
+    ks = 0
+    for d in 1:DK
+        kg.lengths[d] > 1 && (ks = abs(kg.strides[kmap][d]); break)
+    end
+    # K steps within a page make each sliver element's lines a stream the
+    # prefetchers follow; a split then only saves refetching those lines, which
+    # does not pay for the block walk's costlier complex scatter.
+    kinner = ks * S < K_WALK_FAR_BYTES
+    kinner && complex && return (eff, NO_SPLIT)
+
+    # A line of `dj` is reused `psi` coordinates later; while the lines touched
+    # meanwhile fit the cache, the per-sliver walk is already cache-friendly.
+    psi = 1
+    for d in d1:(dj - 1)
+        psi *= g.lengths[d]
+    end
+    klines = ks * S >= line ? k_block : cld(k_block * ks * S, line)
+    aliased = abs(g.strides[1][d1]) * S % K_WALK_FAR_BYTES == 0
+    cap = something(l2bytes, split_capacity(target_profile(), aliased) << complex)
+    widemul(psi, max(1, klines) * line) > cap || return (eff, NO_SPLIT)
+    return pack_split_dynamic(g.lengths, d1, dj, L, psi, R, eff, rounded, k_block, k_block_requested, kinner)
+end
+
+# The cache that can hold the per-sliver walk's reuse window: the core's L2
+# share, plus its L3 share unless the sliver steps a whole number of pages,
+# which folds the lines it gathers into a few sets of every level.
+function split_capacity(profile::TargetProfile, aliased::Bool)
+    l2 = l2_core_bytes(profile)
+    (aliased || profile.l3.bytes <= 0) && return l2
+    return l2 + profile.l3_share
+end
+
+# Past the tests above the plan is for a large contraction; a dynamic call keeps
+# the search from being compiled for every other plan.
+@noinline pack_split_dynamic(args...) = Base.inferencebarrier(pack_split_blocks)(args...)::Tuple{Int, PackSplit}
+
+function pack_split_blocks(
+        lengths::NTuple{D, Int}, d1::Int, dj::Int, L::Int, psi::Int, R::Int,
+        eff::Int, rounded::Int, k_block::Int, k_block_requested::Int, kinner::Bool
+    ) where {D}
+    budget = max(rounded, Int(min(widemul(rounded, k_block_requested) ÷ k_block, typemax(Int32))) ÷ R * R)
+    # Prefixes of `d1:dj-1`: whole axes, then a divisor chunk of the next one.
+    # `E` is also the run of consecutive C coordinates a block stores, so take
+    # the largest whose whole groups fit the budget, preferring `R | E`. A
+    # prefix shorter than a sliver would make slivers straddle chunks.
+    best = anyc = (0, 0, 0)
+    pre = 1
+    for q in d1:(dj - 1)
+        len = lengths[q]
+        limit = budget ÷ (pre * L)
+        limit >= 1 || break
+        for Eq in min(len, limit):-1:1
+            len % Eq == 0 || continue
+            E = pre * Eq
+            ((E >= R || E == psi) && lcm(R, E * L) <= budget) || continue
+            E > anyc[3] && (anyc = (q, Eq, E))
+            E % R == 0 && E > best[3] && (best = (q, Eq, E))
+        end
+        len <= limit || break
+        pre *= len
+    end
+    (q, Eq, E) = best[3] > 0 ? best : anyc
+    E == 0 && return (eff, NO_SPLIT)
+    blk = lcm(R, E * L)
+    neweff = min(budget ÷ blk * blk, roundup(prod(lengths), R))
+    return (neweff, PackSplit(q, dj, L, kinner, Eq, E))
+end
+
+@inline function largest_divisor_upto(n::Int, cap::Int)
+    for L in min(n, cap):-1:1
+        n % L == 0 && return L
+    end
+    return 1
+end
+
+# `g` in the enumeration `s` describes: `q` and `dj` each replaced by an (inner,
+# outer) pair of axes, the inner chunk of `dj` moved right after that of `q`.
+function split_group(g::AxisGroup{D, P}, s::PackSplit) where {D, P}
+    ax(k, p) = split_axis(g, s, k, p)
+    return AxisGroup(
+        ntuple(k -> ax(k, 0), Val(D + 2)), ntuple(p -> ntuple(k -> ax(k, p), Val(D + 2)), Val(P))
+    )
+end
+
+# Length (`p == 0`) or map-`p` stride of axis `k` of `split_group(g, s)`.
+@inline function split_axis(g::AxisGroup, s::PackSplit, k::Int, p::Int)
+    len(d) = g.lengths[d]
+    str(d) = g.strides[p][d]
+    q, dj, Eq, L = Int(s.q), Int(s.dj), Int(s.Eq), Int(s.L)
+    k < q && return p == 0 ? len(k) : str(k)
+    k == q && return p == 0 ? Eq : str(q)
+    k == q + 1 && return p == 0 ? L : str(dj)
+    k == q + 2 && return p == 0 ? len(q) ÷ Eq : Eq * str(q)
+    k <= dj + 1 && return p == 0 ? len(k - 2) : str(k - 2)
+    k == dj + 2 && return p == 0 ? len(dj) ÷ L : L * str(dj)
+    return p == 0 ? len(k - 2) : str(k - 2)
+end
+
+# Pack a macro block of `fcount` free coordinates (offsets `fbuf`, enumerated by
+# a split group, whole `E x L` groups) by `k_block_length` K steps into the
+# panels the per-sliver packer would write, reading each group line by line:
+# coordinate `i0 + E * y2` is element `y2` of the line at `i0`. `@noinline`: one
+# call per block, and inlined into the nest it slows the nest's micro-kernel
+# loop.
+@noinline function pack_block_by_lines!(
+        buffer::PK, spec::SliverSpec{I, R}, storage::ST, base::Int, fbuf::Vector{Int},
+        kaxis::KA, transform::F, fcount::Int, k_block_length::Int, split::PackSplit
+    ) where {PK, I, R, ST, KA <: AbstractVector{Int}, F}
+    E, L = Int(split.E), Int(split.L)
+    G = E * L
+    # The sliver and lane come from a per-element divrem by the constant `R`;
+    # hoisting them per line lets LLVM rewrite the loop so the line misses no
+    # longer overlap.
+    emit(kbase, i, p) = @inbounds pack_line_element!(
+        buffer, spec, sliver_width(spec) * k_block_length, transform(storage[kbase + fbuf[i + 1]]), i, p
+    )
+    if split.kinner
+        for g0 in 0:G:(fcount - 1), y1 in 0:(E - 1), p in 1:k_block_length
+            kbase = @inbounds base + kaxis[p] + 1
+            for y2 in 0:(L - 1)
+                emit(kbase, g0 + y1 + E * y2, p)
+            end
+        end
+    else
+        for g0 in 0:G:(fcount - 1), p in 1:k_block_length
+            kbase = @inbounds base + kaxis[p] + 1
+            for y1 in 0:(E - 1), y2 in 0:(L - 1)
+                emit(kbase, g0 + y1 + E * y2, p)
+            end
+        end
+    end
+    valid = fcount % R
+    if valid != 0
+        rb = (fcount ÷ R) * sliver_width(spec) * k_block_length
+        for p in 1:k_block_length, t in (valid + 1):R
+            emit_padding!(buffer, spec, rb, t, p)
+        end
+    end
+    return nothing
+end
+
+# Element `x` of zero-based block coordinate `i` (sliver `i ÷ R`, lane
+# `i % R + 1`) at K step `p`.
+@inline function pack_line_element!(
+        buffer::PK, spec::SliverSpec{I, R}, panel::Int, x, i::Int, p::Int
+    ) where {PK, I, R}
+    r, t = divrem(i, R)
+    emit_value!(buffer, spec, r * panel, t + 1, p, convert(element_type(spec), x))
+    return nothing
+end
diff --git a/src/packing/pack.jl b/src/packing/pack.jl
index dcfde8e..c3c2ff2 100644
--- a/src/packing/pack.jl
+++ b/src/packing/pack.jl
@@ -1,241 +1,135 @@
-# Packers: copy one sliver of A (up to MR logical rows) or B (up to NR logical
-# columns) over a K range into a contiguous panel in the descriptor's format.
+# The packer: copies one sliver, up to `L` lanes along `tile.rows` by the K
+# steps along `tile.cols`, into a contiguous panel in the spec's format. A is
+# packed as its tile, B as `transpose` of its tile.
+
+operand_name(i::Int) = i == 1 ? "A" : "B"
 
 # A runtime check rather than dispatch, so a mismatch is an ArgumentError.
-@inline function _check_packed_eltype(packed, kernel::Descriptor{MR, NR, T2}) where {MR, NR, T2}
-    R = realtype(kernel)
-    eltype(packed) === R && return nothing
-    msg = R === T2 ?
-        "packed buffer eltype $(eltype(packed)) does not match kernel scalar type $T2" :
-        "packed buffer eltype $(eltype(packed)) does not match kernel real type $R " *
-        "(scalar type $T2)"
-    throw(ArgumentError(msg))
+@inline function check_packed_eltype(panel, spec::SliverSpec{I, L, F, T}) where {I, L, F, T}
+    eltype(panel) === real(T) || throw_packed_eltype(eltype(panel), T)
+    return nothing
 end
 
-# Out of line so the packers carry no string formatting (and no GC frame).
-@noinline _throw_pack_extent(which::Symbol, name::Symbol, got::Int, limit::Int) = throw(
+# Out of line so the packer carries no string formatting (and no GC frame).
+@noinline throw_packed_eltype(got::Type, ::Type{T}) where {T} = throw(
+    ArgumentError(
+        real(T) === T ?
+            "packed buffer eltype $got does not match kernel scalar type $T" :
+            "packed buffer eltype $got does not match kernel real type $(real(T)) (scalar type $T)"
+    )
+)
+@noinline throw_pack_extent(i::Int, got::Int, limit::Int) = throw(
     ArgumentError(
-        "$(which)!: source $(name) count $got must satisfy 0 <= $got <= $(which === :pack_a ? "mr" : "nr")(kernel)=$limit"
+        "pack!: $(operand_name(i)) sliver has $got lanes, need 0 <= $got <= tile_size(kernel, $i) = $limit"
     )
 )
-@noinline _throw_pack_short(which::Symbol, got::Int, need::Int, kc::Int) = throw(
+@noinline throw_pack_short(i::Int, got::Int, need::Int, k_block_length::Int) = throw(
     DimensionMismatch(
-        "$(which)!: packed buffer has length $got, " *
-            "need at least packed_$(which === :pack_a ? "a" : "b")_length(kernel, kc=$kc) = $need"
+        "pack!: packed $(operand_name(i)) buffer has length $got, need at least " *
+            "packed_$(i == 1 ? "a" : "b")_length(kernel, k_block_length=$k_block_length) = $need"
     )
 )
 
-# `transform` is applied to each loaded (complex) element before it is split
-# into the packed format; padding lanes are literal zeros and never read the
-# source or call `transform`. All validation happens before any write.
-function pack_a!(
-        packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2, FA, FB},
-        transform::F
-    ) where {V, MR, NR, T2, FA, FB, F}
-    return _pack_a!(packed, source, kernel, transform, Val(true))
-end
-
-function pack_b!(
-        packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2, FA, FB},
-        transform::F
-    ) where {V, MR, NR, T2, FA, FB, F}
-    return _pack_b!(packed, source, kernel, transform, Val(true))
-end
-
-# Skips only `checked_tile_storage_bounds(source)`: the caller (`_execute_nest!`)
-# has already validated the whole macro block the sliver belongs to. `@inline`
-# because out of line each call marshals the `QSTile` through the stack.
-@inline function unsafe_pack_a!(
-        packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2, FA, FB},
-        transform::F
-    ) where {V, MR, NR, T2, FA, FB, F}
-    return _pack_a!(packed, source, kernel, transform, Val(false))
-end
-
-@inline function unsafe_pack_b!(
-        packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2, FA, FB},
-        transform::F
-    ) where {V, MR, NR, T2, FA, FB, F}
-    return _pack_b!(packed, source, kernel, transform, Val(false))
-end
-
-@inline function _pack_a!(
-        packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2, FA, FB},
-        transform::F, ::Val{BOUNDS}
-    ) where {V, MR, NR, T2, FA, FB, F, BOUNDS}
-    _check_packed_eltype(packed, kernel)
-    m = nrows(source)
-    kc = ncols(source)
-    (0 <= m <= MR) || _throw_pack_extent(:pack_a, :row, m, MR)
-    needed = packed_a_length(kernel, kc)
-    length(packed) >= needed || _throw_pack_short(:pack_a, length(packed), needed, kc)
+"""
+    pack!(panel, tile::Tile, spec::SliverSpec, transform) -> panel
+
+Pack one sliver of `tile` (lanes along its rows, K steps along its columns)
+into `panel` in `spec`'s format. `transform` is applied to each loaded
+element before it is split into the format; padding lanes are literal zeros
+and never read the source or call `transform`. All validation happens before
+any write. Under `@inbounds` (the call inlined) the storage bounds check of
+`tile` is skipped; the eltype, lane count and panel length checks stay.
+"""
+@inline function pack!(panel::V, tile::Tile, spec::SliverSpec{I, L}, transform::F) where {V, I, L, F}
+    check_packed_eltype(panel, spec)
+    lanes, k_block_length = size(tile)
+    (0 <= lanes <= L) || throw_pack_extent(I, lanes, L)
+    needed = packed_length(spec, k_block_length)
+    length(panel) >= needed || throw_pack_short(I, length(panel), needed, k_block_length)
     # `<= 0`, not `== 0` (counts are never negative): LLVM may then assume
-    # `kc >= 1` in the loops below.
-    kc <= 0 && return packed
-    BOUNDS && checked_tile_storage_bounds(source)
-    return _pack_a_sliver!(FA(), packed, source, kernel, transform, m, kc)
-end
-
-@inline function _pack_b!(
-        packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2, FA, FB},
-        transform::F, ::Val{BOUNDS}
-    ) where {V, MR, NR, T2, FA, FB, F, BOUNDS}
-    _check_packed_eltype(packed, kernel)
-    kc = nrows(source)
-    n = ncols(source)
-    (0 <= n <= NR) || _throw_pack_extent(:pack_b, :column, n, NR)
-    needed = packed_b_length(kernel, kc)
-    length(packed) >= needed || _throw_pack_short(:pack_b, length(packed), needed, kc)
-    kc <= 0 && return packed
-    BOUNDS && checked_tile_storage_bounds(source)
-    return _pack_b_sliver!(FB(), packed, source, kernel, transform, n, kc)
-end
-
-# A's packed index runs along `source.rows`, B's along `source.cols`; each
-# contiguous fast path needs that lane axis to be unit-stride.
-@inline function _pack_a_sliver!(
-        format::FMT, packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2},
-        transform::F, m::Int, kc::Int
-    ) where {FMT, V, MR, NR, T2, F}
-    if format isa RealFormat
-        if _pack_a_contiguous_eligible(packed, source, transform, m, Val(MR), real(T2))
-            rowbase = source.base + source.rows.base
-            return _pack_a_contiguous!(packed, source.storage, rowbase, source.cols, Val(MR), kc)
-        end
-    elseif _pack_complex_contiguous_eligible(
-            packed, source.storage, source.rows, transform, format, m, Val(MR), T2
-        )
-        elembase = source.base + source.rows.base
-        return _pack_complex_contiguous!(
-            format, packed, source.storage, elembase, source.cols, Val(MR), kc, transform
-        )
+    # `k_block_length >= 1` in the loops below.
+    k_block_length <= 0 && return panel
+    @boundscheck checked_tile_storage_bounds(tile)
+    if real_contiguous_eligible(tile, spec, transform, lanes)
+        return pack_real_contiguous!(panel, tile, spec, k_block_length)
+    elseif complex_contiguous_eligible(tile, spec, transform, lanes)
+        return pack_complex_contiguous!(panel, tile, spec, k_block_length, transform)
     end
-    load = (i, p) -> tile_load(source, i, p)
-    plane_offset = (plane, i, p) -> packed_a_plane_offset(kernel, plane, i, p)
-    return _pack_panel!(packed, _element_type(format, T2), format, Val(MR), kc, m, transform, load, plane_offset)
+    return pack_scalar!(panel, tile, spec, transform, lanes, k_block_length)
 end
 
-@inline function _pack_b_sliver!(
-        format::FMT, packed::V, source::QSTile, kernel::Descriptor{MR, NR, T2},
-        transform::F, n::Int, kc::Int
-    ) where {FMT, V, MR, NR, T2, F}
-    if _pack_complex_contiguous_eligible(
-            packed, source.storage, source.cols, transform, format, n, Val(NR), T2
-        )
-        elembase = source.base + source.cols.base
-        return _pack_complex_contiguous!(
-            format, packed, source.storage, elembase, source.rows, Val(NR), kc, transform
-        )
-    end
-    load = (j, p) -> tile_load(source, p, j)
-    plane_offset = (plane, j, p) -> packed_b_plane_offset(kernel, plane, j, p)
-    return _pack_panel!(packed, _element_type(format, T2), format, Val(NR), kc, n, transform, load, plane_offset)
+# The packer writes only `PackedPanel`s; a `DenseVector` is borrowed as one.
+Base.@propagate_inbounds function pack!(
+        panel::V, tile::Tile, spec::SliverSpec, transform::F
+    ) where {V <: DenseVector, F}
+    GC.@preserve panel pack!(packed_panel(panel, 1, length(panel)), tile, spec, transform)
+    return panel
 end
 
 # What a packed element converts to: the real operand of a mixed-domain kernel
 # packs `real(T)`.
-@inline _element_type(::RealFormat, ::Type{T}) where {T} = real(T)
-@inline _element_type(::PackFormat, ::Type{T}) where {T} = T
+element_type(::SliverSpec{I, L, RealFormat, T}) where {I, L, T} = real(T)
+element_type(::SliverSpec{I, L, F, T}) where {I, L, F, T} = T
 
-# One sliver over `kc` K steps; `PD` (MR or NR) is a compile-time constant. A
-# full sliver gets a constant-trip inner loop that LLVM fully unrolls; a tail
+# A full sliver gets a constant-trip inner loop that LLVM fully unrolls; a tail
 # writes its valid lanes and its padding as two loops. A per-lane
-# `t < valid ? load : zero` would compile to a branch around the load and keep
+# `t < lanes ? load : zero` would compile to a branch around the load and keep
 # the loop scalar.
-@inline function _pack_panel!(
-        packed::V, ::Type{T}, format::FMT, ::Val{PD}, kc::Int, valid::Int,
-        transform::F, load::L, plane_offset::P
-    ) where {V, T, FMT <: PackFormat, PD, F, L, P}
-    if valid == PD
-        @inbounds for p in 0:(kc - 1)
-            for t in 0:(PD - 1)
-                z = convert(T, transform(load(t, p)))::T
-                _pack_emit!(packed, format, plane_offset, t, p, z)
+@inline function pack_scalar!(
+        panel::V, tile::Tile, spec::SliverSpec{I, L}, transform::F, lanes::Int, k_block_length::Int
+    ) where {V, I, L, F}
+    T = element_type(spec)
+    if lanes == L
+        @inbounds for p in 1:k_block_length
+            for t in 1:L
+                emit_value!(panel, spec, 0, t, p, convert(T, transform(tile[t, p]))::T)
             end
         end
     else
-        @inbounds for p in 0:(kc - 1)
-            for t in 0:(valid - 1)
-                z = convert(T, transform(load(t, p)))::T
-                _pack_emit!(packed, format, plane_offset, t, p, z)
+        @inbounds for p in 1:k_block_length
+            for t in 1:lanes
+                emit_value!(panel, spec, 0, t, p, convert(T, transform(tile[t, p]))::T)
             end
-            for t in valid:(PD - 1)
-                _pack_emit_zero!(packed, format, plane_offset, t, p, real(T))
+            for t in (lanes + 1):L
+                emit_padding!(panel, spec, 0, t, p)
             end
         end
     end
-    return packed
-end
-
-# Per-lane stores of one element. `real`/`imag` on the loaded element are the
-# only accessors: a `QSTile` may address scattered storage, so the source is
-# never `reinterpret`ed.
-@inline function _pack_emit!(
-        packed::V, ::RealFormat, plane_offset::P, t::Int, p::Int, z::T
-    ) where {V, P, T}
-    panel_store!(packed, plane_offset(0, t, p), z)
-    return nothing
+    return panel
 end
 
-@inline function _pack_emit!(
-        packed::V, ::PlanarFormat, plane_offset::P, t::Int, p::Int, z::T
-    ) where {V, P, T}
-    panel_store!(packed, plane_offset(0, t, p), real(z))
-    panel_store!(packed, plane_offset(1, t, p), imag(z))
-    return nothing
-end
-
-@inline function _pack_emit!(
-        packed::V, ::InterleavedFormat, plane_offset::P, t::Int, p::Int, z::T
-    ) where {V, P, T}
-    panel_store!(packed, plane_offset(0, 2 * t, p), real(z))
-    panel_store!(packed, plane_offset(0, 2 * t + 1, p), imag(z))
-    return nothing
-end
-
-@inline function _pack_emit!(
-        packed::V, ::OneEFormat, plane_offset::P, t::Int, p::Int, z::T
-    ) where {V, P, T}
-    re = real(z)
-    im = imag(z)
-    panel_store!(packed, plane_offset(0, 2 * t, p), re)
-    panel_store!(packed, plane_offset(0, 2 * t + 1, p), im)
-    panel_store!(packed, plane_offset(2, 2 * t, p), -im)
-    panel_store!(packed, plane_offset(2, 2 * t + 1, p), re)
-    return nothing
+# Stores of lane `t` at K step `p`, `base` reals into `panel`. `real`/`imag`
+# on the loaded element are the only accessors: a `Tile` may address scattered
+# storage, so the source is never `reinterpret`ed.
+@inline emit_value!(panel, spec::SliverSpec, base::Int, t::Int, p::Int, z) =
+    emit!(panel, spec, base, t, p, real(z), imag(z), -imag(z))
+# Literal zeros: the value path would write 1e's `-im` as `-0.0`.
+@inline function emit_padding!(panel, spec::SliverSpec, base::Int, t::Int, p::Int)
+    z = zero(realtype(spec))
+    return emit!(panel, spec, base, t, p, z, z, z)
 end
 
-# Padding stores literal zeros; `_pack_emit!(.., zero(T))` would write 1e's
-# `-im` as `-0.0`.
-@inline function _pack_emit_zero!(
-        packed::V, ::RealFormat, plane_offset::P, t::Int, p::Int, ::Type{R}
-    ) where {V, P, R}
-    panel_store!(packed, plane_offset(0, t, p), zero(R))
+@inline function emit!(panel, spec::SliverSpec{I, L, RealFormat}, base, t, p, re, im, neg_im) where {I, L}
+    panel_store!(panel, base + panel_offset(spec, t, p), re)
     return nothing
 end
 
-@inline function _pack_emit_zero!(
-        packed::V, ::PlanarFormat, plane_offset::P, t::Int, p::Int, ::Type{R}
-    ) where {V, P, R}
-    panel_store!(packed, plane_offset(0, t, p), zero(R))
-    panel_store!(packed, plane_offset(1, t, p), zero(R))
+@inline function emit!(panel, spec::SliverSpec{I, L, PlanarFormat}, base, t, p, re, im, neg_im) where {I, L}
+    panel_store!(panel, base + panel_offset(spec, t, p), re)
+    panel_store!(panel, base + panel_offset(spec, t, p, 1), im)
     return nothing
 end
 
-@inline function _pack_emit_zero!(
-        packed::V, ::InterleavedFormat, plane_offset::P, t::Int, p::Int, ::Type{R}
-    ) where {V, P, R}
-    panel_store!(packed, plane_offset(0, 2 * t, p), zero(R))
-    panel_store!(packed, plane_offset(0, 2 * t + 1, p), zero(R))
+@inline function emit!(panel, spec::SliverSpec{I, L, InterleavedFormat}, base, t, p, re, im, neg_im) where {I, L}
+    panel_store!(panel, base + panel_offset(spec, 2t - 1, p), re)
+    panel_store!(panel, base + panel_offset(spec, 2t, p), im)
     return nothing
 end
 
-@inline function _pack_emit_zero!(
-        packed::V, ::OneEFormat, plane_offset::P, t::Int, p::Int, ::Type{R}
-    ) where {V, P, R}
-    panel_store!(packed, plane_offset(0, 2 * t, p), zero(R))
-    panel_store!(packed, plane_offset(0, 2 * t + 1, p), zero(R))
-    panel_store!(packed, plane_offset(2, 2 * t, p), zero(R))
-    panel_store!(packed, plane_offset(2, 2 * t + 1, p), zero(R))
+@inline function emit!(panel, spec::SliverSpec{I, L, OneEFormat}, base, t, p, re, im, neg_im) where {I, L}
+    panel_store!(panel, base + panel_offset(spec, 2t - 1, p), re)
+    panel_store!(panel, base + panel_offset(spec, 2t, p), im)
+    panel_store!(panel, base + panel_offset(spec, 2t - 1, p, 2), neg_im)
+    panel_store!(panel, base + panel_offset(spec, 2t, p, 2), re)
     return nothing
 end
diff --git a/src/packing/pack_contiguous.jl b/src/packing/pack_contiguous.jl
index bbe739f..d2410ff 100644
--- a/src/packing/pack_contiguous.jl
+++ b/src/packing/pack_contiguous.jl
@@ -1,163 +1,153 @@
 # Contiguous packing fast paths, each for the one sliver shape it can serve: a
-# full sliver whose lane axis is unit-stride, dense storage, a `PackedPanel`
-# destination and the driver's `identity`/`conj` transform. They read exactly
-# the addresses the scalar loop would, so they skip no validation.
+# full sliver whose lane axis is unit-stride, dense storage and the driver's
+# `identity`/`conj` transform. They read exactly the addresses the scalar loop
+# would, so they skip no validation.
 
 using SIMD: shufflevector
 
-# `conj` is the identity on a real element type.
-@inline _copies_unchanged(::typeof(identity), ::Type) = true
-@inline _copies_unchanged(::typeof(conj), ::Type{T}) where {T <: Real} = true
-@inline _copies_unchanged(::Any, ::Type) = false
+# --- Vector-path predicates (the microkernels' vector stores use them too) ---
+
+# Whether an axis steps through storage one element at a time.
+is_unit_stride(ax::AffineAxis) = ax.stride == 1
+is_unit_stride(::AbstractVector{Int}) = false
 
 # Dense rank-1 storage whose elements load as SIMD lanes and convert lane-wise
 # to `T`: `T` itself, or another supported type of the same domain.
-const _LaneFloat = Union{Float32, Float64}
-@inline _dense_lanes(storage::S, ::Type{T}) where {S, T} =
-    storage isa DenseVector && _lane_convertible(eltype(S), T)
-_lane_convertible(::Type, ::Type) = false
-_lane_convertible(::Type{<:_LaneFloat}, ::Type{<:_LaneFloat}) = true
-_lane_convertible(::Type{Complex{S}}, ::Type{Complex{T}}) where {S <: _LaneFloat, T <: _LaneFloat} = true
-
-# Everything but `m == MR` and the stride test folds at compile time.
-# `_unit_stride_rows` deliberately has no fallback method: an unknown axis type
-# must be a MethodError.
-@inline function _pack_a_contiguous_eligible(
-        packed::V, source::QSTile, transform::F, m::Int, ::Val{MR}, ::Type{T}
-    ) where {V, F, MR, T}
-    return packed isa PackedPanel{T} && _dense_lanes(source.storage, T) &&
-        _copies_unchanged(transform, T) && m == MR && _unit_stride_rows(source.rows)
+const LaneFloat = Union{Float32, Float64}
+@inline dense_lanes(storage::S, ::Type{T}) where {S, T} =
+    storage isa DenseVector && lane_convertible(eltype(S), T)
+lane_convertible(::Type, ::Type) = false
+lane_convertible(::Type{<:LaneFloat}, ::Type{<:LaneFloat}) = true
+lane_convertible(::Type{Complex{S}}, ::Type{Complex{T}}) where {S <: LaneFloat, T <: LaneFloat} = true
+
+# The deinterleaving complex packer and the planar store pay off only with
+# 512-bit vector registers.
+@inline complex_fastpath_isa_eligible(profile::TargetProfile) = profile.isa === :avx512
+@inline complex_fastpath_isa_eligible() = complex_fastpath_isa_eligible(target_profile())
+
+# --- Real ---
+
+# `conj` is the identity on a real element type.
+@inline copies_unchanged(::typeof(identity), ::Type) = true
+@inline copies_unchanged(::typeof(conj), ::Type{T}) where {T <: Real} = true
+@inline copies_unchanged(::Any, ::Type) = false
+
+# Everything but `lanes == L` and the stride test folds at compile time.
+@inline function real_contiguous_eligible(
+        tile::Tile, spec::SliverSpec{I, L, F}, transform, lanes::Int
+    ) where {I, L, F}
+    T = realtype(spec)
+    return F === RealFormat && dense_lanes(tile.storage, T) &&
+        copies_unchanged(transform, T) && lanes == L && is_unit_stride(tile.rows)
 end
 
-# Real A: one `Vec{MR}` load/convert/store per K step.
-@inline function _pack_a_contiguous!(
-        packed::PackedPanel{T}, storage::DenseVector{S}, rowbase::Int, cols::C,
-        ::Val{MR}, kc::Int
-    ) where {T, S, C, MR}
+# One `Vec{L}` load/convert/store per K step.
+@inline function pack_real_contiguous!(
+        panel::PackedPanel{T}, tile::Tile{<:DenseVector{S}}, ::SliverSpec{I, L}, k_block_length::Int
+    ) where {T, S, I, L}
+    storage = tile.storage
+    lanebase = @inbounds tile.base + tile.rows[1]
     GC.@preserve storage begin
         sp = pointer(storage)
-        dp = packed.ptr
-        for p in 0:(kc - 1)
-            v = vload(Vec{MR, S}, sp + sizeof(S) * (rowbase + axis_offset(cols, p)))
-            vstore(convert(Vec{MR, T}, v), dp + sizeof(T) * (MR * p))
+        dp = panel.ptr
+        for p in 1:k_block_length
+            v = vload(Vec{L, S}, sp + sizeof(S) * (lanebase + (@inbounds tile.cols[p])))
+            vstore(convert(Vec{L, T}, v), dp + sizeof(T) * (L * (p - 1)))
         end
     end
-    return packed
+    return panel
 end
 
-# The transforms `_pack_alt` covers; anything else must take the scalar path.
-@inline _complex_pack_transform_eligible(::typeof(identity)) = true
-@inline _complex_pack_transform_eligible(::typeof(conj)) = true
-@inline _complex_pack_transform_eligible(::Any) = false
-
-# Complex: a deinterleave of the source's native `[re, im, ...]` layout plus,
-# for `conj`, a sign flip. `lane_axis` is the axis the packed index runs along
-# (`source.rows` for A, `source.cols` for B); unit stride over dense rank-1
-# storage is what makes reading `PD` elements as `2PD` reals a sound bitcast.
-# `valid == PD` keeps padding (and its no-`-0.0` rule) on the scalar path.
-@inline function _pack_complex_contiguous_eligible(
-        packed::V, storage::S, lane_axis::AX, transform::F, format::FMT,
-        valid::Int, ::Val{PD}, ::Type{T}
-    ) where {V, S, AX, F, FMT, PD, T}
-    return !(format isa RealFormat) &&
-        packed isa PackedPanel{real(T)} && _dense_lanes(storage, T) &&
-        _complex_pack_transform_eligible(transform) &&
-        valid == PD && _unit_stride_rows(lane_axis) &&
-        _complex_fastpath_isa_eligible()
+# --- Complex ---
+
+# The transforms `pack_alt` covers; anything else must take the scalar path.
+@inline complex_pack_transform_eligible(::typeof(identity)) = true
+@inline complex_pack_transform_eligible(::typeof(conj)) = true
+@inline complex_pack_transform_eligible(::Any) = false
+
+# A deinterleave of the source's native `[re, im, ...]` layout plus, for
+# `conj`, a sign flip. Unit stride over dense rank-1 storage is what makes
+# reading `L` elements as `2L` reals a sound bitcast. `lanes == L` keeps
+# padding (and its no-`-0.0` rule) on the scalar path.
+@inline function complex_contiguous_eligible(
+        tile::Tile, spec::SliverSpec{I, L, F, T}, transform, lanes::Int
+    ) where {I, L, F, T}
+    return F !== RealFormat && dense_lanes(tile.storage, T) &&
+        complex_pack_transform_eligible(transform) &&
+        lanes == L && is_unit_stride(tile.rows) &&
+        complex_fastpath_isa_eligible()
 end
 
 # The shuffles read `re` lanes from `src` and `im` lanes from `alt`, so the
 # transform is entirely the choice of `alt`. `-src` is a sign-bit flip,
 # bit-identical to the scalar `imag(conj(z))` (a multiply by -1 would not be,
 # on NaN payloads).
-@inline _pack_alt(src::Vec, ::typeof(identity)) = src
-@inline _pack_alt(src::Vec, ::typeof(conj)) = -src
+@inline pack_alt(src::Vec, ::typeof(identity)) = src
+@inline pack_alt(src::Vec, ::typeof(conj)) = -src
 # 1e's second region stores `-im`, so it wants the opposite choice.
-@inline _pack_alt_flipped(src::Vec, ::typeof(identity)) = -src
-@inline _pack_alt_flipped(src::Vec, ::typeof(conj)) = src
+@inline pack_alt_flipped(src::Vec, ::typeof(identity)) = -src
+@inline pack_alt_flipped(src::Vec, ::typeof(conj)) = src
 
 # `@generated` because `shufflevector` needs a literal `Val` index tuple, which
-# `Val(ntuple(...))` is not reliably. `src` holds `PD` elements of one K step.
-
-# Planar, one whole K step: `[re_0 .. re_{PD-1} | im_0 .. im_{PD-1}]`.
-@generated function _planar_pack_shuffle(
-        src::Vec{N, R}, alt::Vec{N, R}, ::Val{PD}
-    ) where {N, R, PD}
-    N == 2 * PD || return :(throw(ArgumentError("_planar_pack_shuffle: expected N == 2PD")))
-    idx = ntuple(k -> (k - 1) < PD ? 2 * (k - 1) : N + 2 * ((k - 1) - PD) + 1, 2 * PD)
+# `Val(ntuple(...))` is not reliably. `src` holds `L` elements of one K step.
+
+# Planar, one whole K step: `[re_0 .. re_{L-1} | im_0 .. im_{L-1}]`.
+@generated function planar_pack_shuffle(
+        src::Vec{N, R}, alt::Vec{N, R}, ::Val{L}
+    ) where {N, R, L}
+    N == 2 * L || return :(throw(ArgumentError("planar_pack_shuffle: expected N == 2L")))
+    idx = ntuple(k -> (k - 1) < L ? 2 * (k - 1) : N + 2 * ((k - 1) - L) + 1, 2 * L)
     return :(shufflevector(src, alt, Val($idx)))
 end
 
 # 1e's first region (and interleaved): `[re_0, ±im_0, re_1, ±im_1, ...]`.
-@generated function _onee_pack_shuffle_a(
-        src::Vec{N, R}, alt::Vec{N, R}, ::Val{PD}
-    ) where {N, R, PD}
-    N == 2 * PD || return :(throw(ArgumentError("_onee_pack_shuffle_a: expected N == 2PD")))
-    idx = ntuple(k -> iseven(k) ? N + (k - 1) : (k - 1), 2 * PD)
+@generated function onee_pack_shuffle_a(
+        src::Vec{N, R}, alt::Vec{N, R}, ::Val{L}
+    ) where {N, R, L}
+    N == 2 * L || return :(throw(ArgumentError("onee_pack_shuffle_a: expected N == 2L")))
+    idx = ntuple(k -> iseven(k) ? N + (k - 1) : (k - 1), 2 * L)
     return :(shufflevector(src, alt, Val($idx)))
 end
 
 # 1e's second region: `[∓im_0, re_0, ∓im_1, re_1, ...]`.
-@generated function _onee_pack_shuffle_b(
-        src::Vec{N, R}, alt::Vec{N, R}, ::Val{PD}
-    ) where {N, R, PD}
-    N == 2 * PD || return :(throw(ArgumentError("_onee_pack_shuffle_b: expected N == 2PD")))
-    idx = ntuple(k -> isodd(k) ? N + k : k - 2, 2 * PD)
+@generated function onee_pack_shuffle_b(
+        src::Vec{N, R}, alt::Vec{N, R}, ::Val{L}
+    ) where {N, R, L}
+    N == 2 * L || return :(throw(ArgumentError("onee_pack_shuffle_b: expected N == 2L")))
+    idx = ntuple(k -> isodd(k) ? N + k : k - 2, 2 * L)
     return :(shufflevector(src, alt, Val($idx)))
 end
 
-_single_region_shuffle(::PlanarFormat) = _planar_pack_shuffle
-_single_region_shuffle(::InterleavedFormat) = _onee_pack_shuffle_a
-
-# Lane `t` of K step `p` is element `elembase + axis_offset(steps, p) + t`;
-# only the lane axis must be unit-stride, `steps` may be scattered. Pinning
-# `Complex{RS}` in the signature keeps the bitcast to `RS` lanes sound; the
-# lanes convert to `R` before the shuffle.
-@inline function _pack_complex_contiguous!(
-        format::Union{PlanarFormat, InterleavedFormat}, packed::PackedPanel{R},
-        storage::DenseVector{Complex{RS}}, elembase::Int, steps::C, ::Val{PD}, kc::Int,
-        transform::F
-    ) where {R, RS, C, PD, F}
-    shuffle = _single_region_shuffle(format)
-    GC.@preserve storage begin
-        sp = reinterpret(Ptr{RS}, pointer(storage))
-        dp = packed.ptr
-        for p in 0:(kc - 1)
-            src = convert(
-                Vec{2 * PD, R},
-                vload(Vec{2 * PD, RS}, sp + sizeof(RS) * (2 * (elembase + axis_offset(steps, p))))
-            )
-            vstore(
-                shuffle(src, _pack_alt(src, transform), Val(PD)),
-                dp + sizeof(R) * (2 * PD * p)
-            )
-        end
-    end
-    return packed
+# One K step's `2L` reals `src`, stored at `dp`.
+@inline store_step!(dp::Ptr, src::Vec, ::SliverSpec{I, L, PlanarFormat}, transform) where {I, L} =
+    vstore(planar_pack_shuffle(src, pack_alt(src, transform), Val(L)), dp)
+@inline store_step!(dp::Ptr, src::Vec, ::SliverSpec{I, L, InterleavedFormat}, transform) where {I, L} =
+    vstore(onee_pack_shuffle_a(src, pack_alt(src, transform), Val(L)), dp)
+@inline function store_step!(dp::Ptr{R}, src::Vec, ::SliverSpec{I, L, OneEFormat}, transform) where {R, I, L}
+    vstore(onee_pack_shuffle_a(src, pack_alt(src, transform), Val(L)), dp)
+    vstore(onee_pack_shuffle_b(src, pack_alt_flipped(src, transform), Val(L)), dp + sizeof(R) * 2L)
+    return nothing
 end
 
-@inline function _pack_complex_contiguous!(
-        ::OneEFormat, packed::PackedPanel{R}, storage::DenseVector{Complex{RS}},
-        elembase::Int, steps::C, ::Val{PD}, kc::Int, transform::F
-    ) where {R, RS, C, PD, F}
+# Lane `t` of K step `p` is element `tile.base + tile.rows[1] + tile.cols[p] +
+# (t - 1)`; only the lane axis must be unit-stride, the K steps may be
+# scattered. Pinning `Complex{RS}` in the signature keeps the bitcast to `RS`
+# lanes sound; the lanes convert to `R` before the shuffle.
+@inline function pack_complex_contiguous!(
+        panel::PackedPanel{R}, tile::Tile{<:DenseVector{Complex{RS}}}, spec::SliverSpec{I, L},
+        k_block_length::Int, transform::F
+    ) where {R, RS, I, L, F}
+    storage = tile.storage
+    elembase = @inbounds tile.base + tile.rows[1]
     GC.@preserve storage begin
         sp = reinterpret(Ptr{RS}, pointer(storage))
-        dp = packed.ptr
-        for p in 0:(kc - 1)
+        for p in 1:k_block_length
             src = convert(
-                Vec{2 * PD, R},
-                vload(Vec{2 * PD, RS}, sp + sizeof(RS) * (2 * (elembase + axis_offset(steps, p))))
-            )
-            at = 4 * PD * p
-            vstore(
-                _onee_pack_shuffle_a(src, _pack_alt(src, transform), Val(PD)),
-                dp + sizeof(R) * at
-            )
-            vstore(
-                _onee_pack_shuffle_b(src, _pack_alt_flipped(src, transform), Val(PD)),
-                dp + sizeof(R) * (at + 2 * PD)
+                Vec{2 * L, R},
+                vload(Vec{2 * L, RS}, sp + sizeof(RS) * (2 * (elembase + (@inbounds tile.cols[p]))))
             )
+            store_step!(panel.ptr + sizeof(R) * panel_offset(spec, 1, p), src, spec, transform)
         end
     end
-    return packed
+    return panel
 end
diff --git a/src/packing/panel.jl b/src/packing/panel.jl
index 59146f5..f3b2a3f 100644
--- a/src/packing/panel.jl
+++ b/src/packing/panel.jl
@@ -1,6 +1,7 @@
-# GUARDRAIL: packed micro-panels reach the kernel as borrowed pointers, never
-# `view`s: a `SubArray`'s address arithmetic evicts the accumulator at large
-# register tiles and heap-allocates per `execute!`.
+# GUARDRAIL: packers and kernels read and write packed micro-panels only as
+# `PackedPanel`s, borrowed pointers, never `view`s: a `SubArray`'s address
+# arithmetic evicts the accumulator at large register tiles and heap-allocates
+# per `execute!`. Only the checked entry points also take a `DenseVector`.
 
 using SIMD: Vec, vload, vstore
 
@@ -17,16 +18,9 @@ Base.eltype(::Type{PackedPanel{T}}) where {T} = T
 @inline packed_panel(buffer::AbstractVector{T}, first1::Int, len::Int) where {T} =
     PackedPanel{T}(pointer(buffer, first1), len)
 
-# Zero-based panel element access; the `AbstractVector` methods serve `Vector`
-# and `view` destinations.
+# Zero-based panel element access.
 @inline panel_vload(::Type{Vec{W, T}}, p::PackedPanel{T}, o::Int) where {W, T} =
     vload(Vec{W, T}, p.ptr + sizeof(T) * o)
-@inline panel_vload(::Type{Vec{W, T}}, v::AbstractVector{T}, o::Int) where {W, T} =
-    vload(Vec{W, T}, v, o + 1)
-
 @inline panel_load(p::PackedPanel{T}, o::Int) where {T} = unsafe_load(p.ptr + sizeof(T) * o)
-@inline panel_load(v::AbstractVector, o::Int) = @inbounds v[o + 1]
-
 @inline panel_store!(p::PackedPanel{T}, o::Int, x::T) where {T} =
     unsafe_store!(p.ptr + sizeof(T) * o, x)
-@inline panel_store!(v::AbstractVector{T}, o::Int, x::T) where {T} = @inbounds v[o + 1] = x
diff --git a/src/packing/transposed.jl b/src/packing/transposed.jl
deleted file mode 100644
index a5f84e1..0000000
--- a/src/packing/transposed.jl
+++ /dev/null
@@ -1,53 +0,0 @@
-# Pack a macro block of `fcount` free coordinates (offsets `fbuf`, enumerated
-# by a split group, whole `E x L` groups) by `kc` K steps into the panels the
-# per-sliver packer would write, reading each group line by line: coordinate
-# `i0 + E * y2` is element `y2` of the line at `i0`. `@noinline`: one call per
-# block, and inlined into the nest it slows the nest's micro-kernel loop.
-@noinline function _pack_block_transposed!(
-        plane_offset::PO, format::FMT, buffer::PK, descriptor::DS, ::Val{R}, Rp::Int,
-        storage::ST, base::Int, fbuf::Vector{Int}, kaxis::KA, transform::F,
-        fcount::Int, kc::Int, split
-    ) where {PO, FMT <: PackFormat, PK, DS, R, ST, KA <: Axis, F}
-    E, L = Int(split.E), Int(split.L)
-    G = E * L
-    # The sliver and lane come from a per-element divrem by the constant `R`;
-    # hoisting them per line lets LLVM rewrite the loop so the line misses no
-    # longer overlap.
-    emit(kbase, i, p) = @inbounds _pack_line_element!(
-        plane_offset, format, buffer, descriptor, Val(R), Rp * kc, transform(storage[kbase + fbuf[i + 1]]), i, p
-    )
-    if split.kinner
-        for g0 in 0:G:(fcount - 1), y1 in 0:(E - 1), p in 0:(kc - 1)
-            kbase = base + axis_offset(kaxis, p) + 1
-            for y2 in 0:(L - 1)
-                emit(kbase, g0 + y1 + E * y2, p)
-            end
-        end
-    else
-        for g0 in 0:G:(fcount - 1), p in 0:(kc - 1)
-            kbase = base + axis_offset(kaxis, p) + 1
-            for y1 in 0:(E - 1), y2 in 0:(L - 1)
-                emit(kbase, g0 + y1 + E * y2, p)
-            end
-        end
-    end
-    valid = fcount % R
-    if valid != 0
-        rb = (fcount ÷ R) * Rp * kc
-        pad = (plane, idx, pp) -> rb + plane_offset(descriptor, plane, idx, pp)
-        for p in 0:(kc - 1), t in valid:(R - 1)
-            _pack_emit_zero!(buffer, format, pad, t, p, realtype(descriptor))
-        end
-    end
-    return nothing
-end
-
-# Element `x` of block coordinate `i` (sliver `i ÷ R`, lane `i % R`) at K step `p`.
-@inline function _pack_line_element!(
-        plane_offset::PO, format::FMT, buffer::PK, descriptor::DS, ::Val{R}, panel::Int, x, i::Int, p::Int
-    ) where {PO, FMT, PK, DS, R}
-    r, t = divrem(i, R)
-    po = (plane, idx, pp) -> r * panel + plane_offset(descriptor, plane, idx, pp)
-    _pack_emit!(buffer, format, po, t, p, convert(_element_type(format, scalartype(descriptor)), x))
-    return nothing
-end
diff --git a/src/packing/unpacked_b.jl b/src/packing/unpacked_b.jl
new file mode 100644
index 0000000..c59b4c2
--- /dev/null
+++ b/src/packing/unpacked_b.jl
@@ -0,0 +1,60 @@
+# "Unpacked B": the microkernel reads B in place instead of from a packed
+# panel. The kernels that read B by element (`reads_b_by_element`) broadcast
+# one (complex) scalar at a time, so any K axis, column offsets and
+# `AbstractVector` storage work. Packing B buys locality and padding columns
+# at an O(N*K) gather per (N, K) block, which at small M costs as much as the
+# kernel itself.
+
+# Stands in for a packed B micro-panel of `NR` columns: column `j`, K step
+# `p` is storage address `colbase[j] + ksteps[p]` (base included). Padding
+# columns of a tail sliver alias the last valid column, so every address read
+# is inside the hoisted B check; their results are never stored. `length` is
+# the packed-equivalent count that `execute_tile!` checks, not the
+# storage length.
+struct UnpackedBView{S, K <: AbstractVector{Int}, NR, F}
+    storage::S
+    colbase::NTuple{NR, Int}
+    ksteps::K
+    per_k::Int
+    transform::F
+end
+
+Base.length(u::UnpackedBView) = u.per_k * length(u.ksteps)
+
+# `@inbounds`: the caller has checked the whole B panel region.
+@inline function unpacked_b_element(u::UnpackedBView{S, K, NR, F}, j::Int, p::Int) where {S, K, NR, F}
+    @inbounds z = u.storage[u.colbase[j] + u.ksteps[p] + 1]
+    return u.transform(z)
+end
+# Column pointer plus one K index shared by all columns: indexed, LLVM's SLP
+# vectoriser can turn the `NR` per-column indices into vector arithmetic inside
+# the K loop, which costs a vector register and spills accumulators.
+@inline function unpacked_b_element(u::UnpackedBView{S, K, NR, F}, j::Int, p::Int) where {S <: DenseVector, K, NR, F}
+    s = u.storage
+    z = GC.@preserve s unsafe_load(pointer(s) + u.colbase[j] * sizeof(eltype(s)), @inbounds(u.ksteps[p]) + 1)
+    return u.transform(z)
+end
+
+@inline b_scalar(u::UnpackedBView, kernel, j::Int, p::Int) =
+    convert(scalartype(kernel), unpacked_b_element(u, j, p))
+
+# Complex kernels: the planar `(re, im)` pair.
+@inline function b_complex(u::UnpackedBView, kernel, j::Int, p::Int)
+    z = convert(scalartype(kernel), unpacked_b_element(u, j, p))
+    return (real(z), imag(z))
+end
+
+# The view for one N sliver; `buf`/`n_tile_start` locate an irregular sliver's
+# offsets in `ws.n.offsets[1]`.
+@inline function unpacked_b_view(
+        kernel::Microkernel{MR, NR, T}, storage::S, base::Int,
+        d::BlockDescriptor, buf::Vector{Int}, n_tile_start::Int, ksteps::K, transform::F
+    ) where {MR, NR, T, S, K <: AbstractVector{Int}, F}
+    last = d.count - 1
+    colbase = ntuple(Val(NR)) do j1
+        jj = min(j1 - 1, last)
+        off = d.regular ? d.base + jj * d.stride : (@inbounds buf[n_tile_start + jj + 1])
+        base + off
+    end
+    return UnpackedBView(storage, colbase, ksteps, sliver_width(kernel, 2), transform)
+end
diff --git a/src/planning/blocking.jl b/src/planning/blocking.jl
index dcfe971..b2835f0 100644
--- a/src/planning/blocking.jl
+++ b/src/planning/blocking.jl
@@ -1,71 +1,80 @@
 """
-    Blocking(mc::Int, kc::Int, nc::Int)
+    Blocking(m_block::Int, k_block::Int, n_block::Int)
 
-Cache-blocking factors for the macro-blocking driver: `mc` (M block extent,
-loop 3), `kc` (K block/panel depth, loop 4), `nc` (N block extent, loop 5).
+Cache-blocking factors for the macro-blocking driver: `m_block` (M block
+extent), `k_block` (K block/panel depth) and `n_block` (N block extent).
 All three fields must be `>= 1`; the constructor throws `ArgumentError`
 otherwise.
 """
 struct Blocking
-    mc::Int
-    kc::Int
-    nc::Int
+    m_block::Int
+    k_block::Int
+    n_block::Int
 
-    function Blocking(mc::Int, kc::Int, nc::Int)
-        mc >= 1 || throw(ArgumentError("Blocking requires mc >= 1, got mc = $mc"))
-        kc >= 1 || throw(ArgumentError("Blocking requires kc >= 1, got kc = $kc"))
-        nc >= 1 || throw(ArgumentError("Blocking requires nc >= 1, got nc = $nc"))
-        return new(mc, kc, nc)
+    function Blocking(m_block::Int, k_block::Int, n_block::Int)
+        m_block >= 1 || throw(ArgumentError("Blocking requires m_block >= 1, got m_block = $m_block"))
+        k_block >= 1 || throw(ArgumentError("Blocking requires k_block >= 1, got k_block = $k_block"))
+        n_block >= 1 || throw(ArgumentError("Blocking requires n_block >= 1, got n_block = $n_block"))
+        return new(m_block, k_block, n_block)
     end
 end
 
-# Complex blocking is the real row divided by the packed reals per element of
-# each operand, so every method gets the same packed BYTE budget (1m's `mc` is
-# half planar's).
-@inline _scale_blocking(base::Blocking, m::ComplexMethod) =
-    Blocking(max(1, base.mc ÷ a_reals(m)), base.kc, max(1, base.nc ÷ b_reals(m)))
+"""
+    default_blocking(kernel, profile = target_profile()) -> Blocking
 
-# For a host whose L1d or L2 size is undetected.
-_fallback_blocking(::Type{Float64}) = Blocking(128, 256, 768)
-_fallback_blocking(::Type{Float32}) = Blocking(96, 768, 1152)
+Cache-blocking factors for `kernel` on `profile`: an analytical model of the
+cache geometry, or fixed constants where L1d or L2 is undetected.
+`plan_contract` rounds `m_block`/`n_block` to multiples of the tile size and
+clamps all three to the contraction's extents.
+"""
+default_blocking(kernel, profile::TargetProfile = target_profile()) =
+    kernel_blocking(profile, scalartype(kernel), typeof(kernel), tile_size(kernel)...)
+
+# The default blocking of a kernel of type `K` for `T` with an `MR x NR` tile.
+# `k_block` is the real default kernel's for `real(T)`: derived from a complex
+# B sliver it halves or worse, which is slower, most at small M. The fallback rows are divided by the packed reals per element of
+# each operand, so every kernel type gets the same packed byte budget.
+@inline function kernel_blocking(profile::TargetProfile, ::Type{T}, ::Type{K}, MR::Int, NR::Int) where {T, K}
+    R = real(T)
+    a_reals, b_reals = map(reals_per_element, pack_formats(K))
+    k_block = l1_k_block(profile, derived_shape(profile, R)[2], sizeof(R))
+    modelled = modelled_blocking(profile, MR, NR, a_reals * sizeof(R), b_reals * sizeof(R), k_block)
+    modelled === nothing || return modelled
+    base = fallback_blocking(R)
+    return Blocking(max(1, base.m_block ÷ a_reals), base.k_block, max(1, base.n_block ÷ b_reals))
+end
 
-_real_blocking_row(profile::TargetProfile, ::Type{T}) where {T <: Union{Float32, Float64}} =
-    something(_modelled_blocking(profile, T), _fallback_blocking(T))
+# For a host whose L1d or L2 size is undetected.
+fallback_blocking(::Type{Float64}) = Blocking(128, 256, 768)
+fallback_blocking(::Type{Float32}) = Blocking(96, 768, 1152)
 
-# Analytical real row from the cache geometry. Per (jc, pc) the packed B panel
-# is `nc*kc` elements, per (jc, pc, ic) the A block `mc*kc`, and one `NR x kc`
-# B sliver is reused by every A sliver of the block:
+# Analytical blocking from the cache geometry, with `SA`/`SB` the packed bytes
+# per element of A and B. Per (N, K) block the packed B panel is
+# `n_block*k_block` elements, per (N, K, M) block the A block
+# `m_block*k_block`, and one `NR x k_block` B sliver is reused by every A
+# sliver of the block:
 #
-#     NR*kc*S  <= L1/2              the reused B sliver
-#     mc*kc*S  <= L2core/2          the A block
-#     nc*kc*S  <= L2core + L3core   the B panel
+#     NR*k_block*SB       <= L1/2              the reused B sliver (real kernels)
+#     m_block*k_block*SA  <= L2core/2          the A block
+#     n_block*k_block*SB  <= L2core + L3core   the B panel
 #
 # rounded down to MR/NR multiples, shared levels divided by the cores sharing
-# them. `nc` takes the whole per-core capacity, not half the L3: an oversized B
-# panel only re-streams B, an undersized one repacks A once per `jc` block.
+# them. `n_block` takes the whole per-core capacity, not half the L3: an
+# oversized B panel only re-streams B, an undersized one repacks A once per N
+# block.
 # `nothing` when L1d or L2 is undetected.
-function _modelled_blocking(profile::TargetProfile, ::Type{T}, MR::Int, NR::Int) where {T}
-    l1, l2, l3 = profile.l1d, profile.l2, profile.l3
-    (l1.bytes > 0 && l2.bytes > 0) || return nothing
-    smt = max(1, l1.sharing)
-    core_share(c) = c.bytes ÷ max(1, c.sharing ÷ smt)
-    l2core = core_share(l2)
-    l3core = l3.bytes > 0 ? core_share(l3) : 0
-    S = sizeof(T)
-    kc = max(1, (l1.bytes ÷ 2) ÷ (NR * S))
-    mc = max(MR, ((l2core ÷ 2) ÷ (kc * S)) ÷ MR * MR)
-    nc = max(NR, ((l2core + l3core) ÷ (kc * S)) ÷ NR * NR)
-    return Blocking(mc, kc, nc)
-end
-
-function _modelled_blocking(profile::TargetProfile, ::Type{T}) where {T <: Real}
-    MR, NR, _ = _derived_shape(profile, T)
-    return _modelled_blocking(profile, T, MR, NR)
+@inline function modelled_blocking(
+        profile::TargetProfile, MR::Int, NR::Int, SA::Int, SB::Int, k_block::Int = l1_k_block(profile, NR, SB)
+    )
+    (profile.l1d.bytes > 0 && profile.l2.bytes > 0) || return nothing
+    l2core, l3core = profile.l2_share, profile.l3_share
+    m_block = max(MR, ((l2core ÷ 2) ÷ (k_block * SA)) ÷ MR * MR)
+    n_block = max(NR, ((l2core + l3core) ÷ (k_block * SB)) ÷ NR * NR)
+    return Blocking(m_block, k_block, n_block)
 end
 
-# For a bare scalar type: the fallback row, independent of the host.
-default_blocking(::Type{Float64}) = _fallback_blocking(Float64)
-default_blocking(::Type{Float32}) = _fallback_blocking(Float32)
+# The K depth at which an `NR`-wide B sliver of `SB`-byte elements fills half of L1d.
+@inline l1_k_block(profile::TargetProfile, NR::Int, SB::Int) = max(1, (profile.l1d.bytes ÷ 2) ÷ (NR * SB))
 
 # Smallest multiple of `n` that is >= `x` (`x >= 0`, `n >= 1`).
-@inline _roundup(x::Int, n::Int) = cld(x, n) * n
+@inline roundup(x::Int, n::Int) = cld(x, n) * n
diff --git a/src/planning/conjugation.jl b/src/planning/conjugation.jl
deleted file mode 100644
index ef0bd46..0000000
--- a/src/planning/conjugation.jl
+++ /dev/null
@@ -1,22 +0,0 @@
-# Conjugation: folding `conjA`/`conjB` with each view's `.op`. The engine never
-# indexes through a `StridedView`, so an unfolded `.op` would be silently dropped.
-
-# GUARDRAIL: a TOTAL table with a throwing fallback, not an `op === conj` test,
-# which classifies a directly constructed `adjoint` view as unconjugated.
-_op_conjugates(::typeof(identity)) = false
-_op_conjugates(::typeof(conj)) = true
-# Elementwise on a `Number`, these are identity/conj; the axes are already resolved.
-_op_conjugates(::typeof(transpose)) = false
-_op_conjugates(::typeof(adjoint)) = true
-@noinline _op_conjugates(f) = throw(
-    ArgumentError(
-        "unsupported StridedView.op $f: QuasiStrided folds a view's `op` into the " *
-            "packing transform and recognizes only identity/conj/transpose/adjoint"
-    )
-)
-
-# GUARDRAIL: `⊻`, not `||`: the flag and the view's `op` are independent
-# conjugations and `conj` is involutive. Always `false` for real `T`, so the
-# real path never gets a `conj` specialization.
-_qs_isconj(v::StridedView{T}, flag::Bool) where {T} =
-    (T <: Complex) && (flag ⊻ _op_conjugates(v.op))
diff --git a/src/planning/defaults.jl b/src/planning/defaults.jl
deleted file mode 100644
index 8ac74f0..0000000
--- a/src/planning/defaults.jl
+++ /dev/null
@@ -1,108 +0,0 @@
-# The engine's per-host defaults for an element type, resolved once per
-# (detected profile, eltype) and cached: every lookup in kernel_selection.jl and
-# blocking.jl is keyed on `Val(profile.isa)`, a dynamic dispatch far too slow to
-# repeat on every `plan_contract`.
-
-# The default `shape`, the `fitted` small-M demotion shape, the AVX-512 complex
-# small-M FMAddSub candidates, the unscaled real blocking row and the core's L2
-# share, all derived from `profile`, which is the cache key.
-struct ResolvedDefaults
-    profile::TargetProfile
-    shape::NTuple{3, Int}
-    fitted::NTuple{3, Int}
-    small_m::Vector{NTuple{3, Int}}
-    real_row::Blocking
-    l2_core::Int
-end
-
-function _resolve_defaults(profile::TargetProfile, ::Type{T}) where {T}
-    method = _default_method(T)
-    # First, so an element type with no menu throws from here.
-    shape = _derived_shape(profile, T, method)
-    fitted = _fitted_shape(profile, T, method)
-    small_m = _small_m_candidates(Val(profile.isa), profile, T)
-    real_row = _real_blocking_row(profile, real(T))
-    l2_core = _l2_core_bytes(profile)
-    return ResolvedDefaults(profile, shape, fitted, small_m, real_row, l2_core)
-end
-
-# One slot per supported element type (a method dispatch, not a `Dict` probe);
-# other types take the uncached path and fail there.
-const _DEFAULTS_F64 = Ref{Union{Nothing, ResolvedDefaults}}(nothing)
-const _DEFAULTS_F32 = Ref{Union{Nothing, ResolvedDefaults}}(nothing)
-const _DEFAULTS_C64 = Ref{Union{Nothing, ResolvedDefaults}}(nothing)
-const _DEFAULTS_C32 = Ref{Union{Nothing, ResolvedDefaults}}(nothing)
-_defaults_slot(::Type{Float64}) = _DEFAULTS_F64
-_defaults_slot(::Type{Float32}) = _DEFAULTS_F32
-_defaults_slot(::Type{ComplexF64}) = _DEFAULTS_C64
-_defaults_slot(::Type{ComplexF32}) = _DEFAULTS_C32
-_defaults_slot(::Type) = nothing
-
-# Refilled whenever the slot's profile is not `===` the current one, so a
-# profile installed after load (as test/forced_isa_runner.jl does) takes effect
-# without an invalidation hook. Unlocked: a racing refill stores the same value.
-@inline function _resolved_defaults(::Type{T}) where {T}
-    slot = _defaults_slot(T)
-    profile = target_profile()
-    slot === nothing && return _resolve_defaults(profile, T)
-    cached = slot[]
-    (cached !== nothing && cached.profile === profile) && return cached
-    return _refill_defaults!(slot, profile, T)
-end
-
-@noinline function _refill_defaults!(slot, profile::TargetProfile, ::Type{T}) where {T}
-    fresh = _resolve_defaults(profile, T)
-    slot[] = fresh
-    return fresh
-end
-
-_default_kernel(::Type{T}) where {T} =
-    _kernel_from_shape(_resolved_defaults(T).shape, T, _default_method(T))
-
-# The automatic `(shape, method)` for extents `Qm`/`Qn` and C's unit-stride run
-# along M (`run = Qm`: no layout known). Returned as plain values so
-# `plan_contract` never holds a menu-wide kernel Union. The extent and store
-# step-downs apply first; then an `Qm` that cannot fill one tile demotes to the
-# fitted shape, or on AVX-512 complex to FMAddSub.
-@inline function _default_shape(::Type{T}, Qm::Int, Qn::Int, run::Int = Qm) where {T}
-    d = _resolved_defaults(T)
-    method = _default_method(T)
-    shape = _store_shape(_extent_shape(d.shape, T, method, Qm), T, method, Qm, run)
-    (Qm > 0 && Qm < shape[1]) || return (shape, method)
-    # Static, so a real `T`'s method stays a concrete `RealMethod`.
-    T <: Complex || return (d.fitted, method)
-    small = _small_m_shape(d.small_m, Qm)
-    small === nothing || return (small, FMAddSubMethod())
-    return (d.fitted, method)
-end
-
-# The automatic `(shape, method)` under `method`, `_default_method(T, TA, TB)`.
-@inline _default_shape(::Type{T}, ::ComplexMethod, Qm::Int, Qn::Int, run::Int) where {T} =
-    _default_shape(T, Qm, Qn, run)
-
-# The real default shape of the real problem, mapped: the real extent, store and
-# small-M demotions carry over, on the real type's cached defaults.
-@inline function _default_shape(::Type{T}, method::_MixedMethod, Qm::Int, Qn::Int, run::Int) where {T}
-    shape, _ = _default_shape(real(T), _real_problem(method, Qm, Qn, run)...)
-    return (_mixed_shape(method, shape), method)
-end
-
-# `@noinline`: the return type is the Union of `T`'s menu kernels.
-@noinline function _default_kernel(::Type{T}, Qm::Int, Qn::Int) where {T}
-    shape, method = _default_shape(T, Qm, Qn)
-    return _kernel_from_shape(shape, T, method)
-end
-
-"""
-    default_blocking(kernel) -> Blocking
-
-Cache-blocking factors for `kernel` on this host: an analytical model of the
-detected cache geometry ([`target_profile`](@ref)), or fixed constants where
-L1d or L2 is undetected, scaled for complex methods by packed reals per
-element. `plan_contract` rounds `mc`/`nc` to `mr`/`nr` multiples and clamps
-all three to the contraction's extents.
-"""
-function default_blocking(kernel)
-    T = scalartype(kernel)
-    return _scale_blocking(_resolved_defaults(T).real_row, complex_method(kernel))
-end
diff --git a/src/planning/kernel_selection.jl b/src/planning/kernel_selection.jl
index b1bfd9f..5cb222e 100644
--- a/src/planning/kernel_selection.jl
+++ b/src/planning/kernel_selection.jl
@@ -1,33 +1,32 @@
 # Kernel selection: the microkernel `plan_contract` builds when the caller does
-# not name one. Everything here is a pure function of a `TargetProfile` and `T`;
-# src/planning/defaults.jl caches the host-dependent results per eltype, since
-# the `Val(profile.isa)` dispatch below is dynamic.
-
-# `OneMMethod`/`FMAddSubMethod` are chosen only by naming the kernel (FMAddSub
-# also by the AVX-512 small-M demotion, `_small_m_shape`).
-_default_method(::Type{<:Real}) = RealMethod()
-_default_method(::Type{<:Complex}) = PlanarMethod()
-
-const _MixedMethod = Union{ComplexRealMethod, RealComplexMethod}
-
-# The method for compute type `T` and (oriented) operand eltypes: a mixed-domain
-# method when exactly one operand is real.
-_default_method(::Type{T}, ::Type{TA}, ::Type{TB}) where {T, TA, TB} =
-    _default_method(T)
-_default_method(::Type{T}, ::Type{<:Complex}, ::Type{<:Real}) where {T <: Complex} =
-    ComplexRealMethod()
-_default_method(::Type{T}, ::Type{<:Real}, ::Type{<:Complex}) where {T <: Complex} =
-    RealComplexMethod()
+# not name one, a pure function of a `TargetProfile` and `T`.
+
+# Kernel types, unparameterised, name the complex-arithmetic schemes here.
+# `OneMKernel`/`FMAddSubKernel` are chosen only by naming the kernel (FMAddSub
+# also by the AVX-512 small-M demotion, `small_m_shape`).
+default_kernel_type(::Type{<:Real}) = SIMDKernel
+default_kernel_type(::Type{<:Complex}) = PlanarKernel
+
+const MixedKernel = Union{Type{<:ComplexRealKernel}, Type{<:RealComplexKernel}}
+
+# The kernel type for compute type `T` and (oriented) operand eltypes: a
+# mixed-domain kernel when exactly one operand is real.
+default_kernel_type(::Type{T}, ::Type{TA}, ::Type{TB}) where {T, TA, TB} =
+    default_kernel_type(T)
+default_kernel_type(::Type{T}, ::Type{<:Complex}, ::Type{<:Real}) where {T <: Complex} =
+    ComplexRealKernel
+default_kernel_type(::Type{T}, ::Type{<:Real}, ::Type{<:Complex}) where {T <: Complex} =
+    RealComplexKernel
 
 const NR_DEFAULT = 6
 
 # An (8, 6) tile at one 256-bit register's lane width: the shape wherever no rule applies.
-_fallback_shape(::Type{T}) where {T} = (8, NR_DEFAULT, _default_lanewidth(real(T)))
+fallback_shape(::Type{T}) where {T} = (8, NR_DEFAULT, default_lanewidth(real(T)))
 
 # Closed menus of `(MR, NR, W)` shapes, so the compiled specializations stay
 # bounded. Complex `MR` counts complex rows and `W` real lanes; 1m runs a real
 # kernel of `2MR` rows, so only `2MR` must be a multiple of `W`. The trailing
-# `MV = 1` planar entries guarantee `_fitted_shape` a fit on any register file
+# `MV = 1` planar entries guarantee `fitted_shape` a fit on any register file
 # of >= 16 registers.
 const KERNEL_SHAPES_F64 = ((8, 6, 4), (16, 6, 8), (32, 6, 8))
 const KERNEL_SHAPES_F32 = ((8, 6, 8), (32, 6, 16), (16, 6, 8), (64, 6, 16))
@@ -45,82 +44,74 @@ const KERNEL_SHAPES_C64_FMADDSUB = ((12, 8, 8), (8, 8, 8), (4, 6, 4), (4, 5, 4))
 const KERNEL_SHAPES_C32_FMADDSUB = ((24, 8, 16), (16, 8, 16), (8, 6, 8), (8, 5, 8))
 
 """
-    kernel_shapes(T, method::ComplexMethod = _default_method(T)) -> NTuple{<:Any,NTuple{3,Int}}
+    kernel_shapes(T, K = default_kernel_type(T)) -> NTuple{<:Any,NTuple{3,Int}}
 
 The closed menu of `(MR, NR, W)` register shapes the engine may build for
-element type `T` under `method`.
+element type `T` with kernel type `K` (empty where it builds none).
 """
-kernel_shapes(::Type{T}) where {T} = kernel_shapes(T, _default_method(T))
-kernel_shapes(::Type{Float64}, ::RealMethod) = KERNEL_SHAPES_F64
-kernel_shapes(::Type{Float32}, ::RealMethod) = KERNEL_SHAPES_F32
-kernel_shapes(::Type{ComplexF64}, ::PlanarMethod) = KERNEL_SHAPES_C64_PLANAR
-kernel_shapes(::Type{ComplexF64}, ::OneMMethod) = KERNEL_SHAPES_C64_ONEM
-kernel_shapes(::Type{ComplexF32}, ::PlanarMethod) = KERNEL_SHAPES_C32_PLANAR
-kernel_shapes(::Type{ComplexF32}, ::OneMMethod) = KERNEL_SHAPES_C32_ONEM
-kernel_shapes(::Type{ComplexF64}, ::FMAddSubMethod) = KERNEL_SHAPES_C64_FMADDSUB
-kernel_shapes(::Type{ComplexF32}, ::FMAddSubMethod) = KERNEL_SHAPES_C32_FMADDSUB
-# The mixed menus are the real menu of `real(T)`, mapped by `_mixed_shape`.
-kernel_shapes(::Type{T}, method::_MixedMethod) where {T <: Union{ComplexF32, ComplexF64}} =
-    map(s -> _mixed_shape(method, s), kernel_shapes(real(T), RealMethod()))
-
-# A real inner shape to the mixed kernel's `(MR, NR, W)`, and back: complex A
-# rows and complex B columns each span two reals of the inner kernel.
-_mixed_shape(::ComplexRealMethod, (MR, NR, W)::NTuple{3, Int}) = (MR ÷ 2, NR, W)
-_mixed_shape(::RealComplexMethod, (MR, NR, W)::NTuple{3, Int}) = (MR, NR ÷ 2, W)
-_real_shape(::ComplexRealMethod, (MR, NR, W)::NTuple{3, Int}) = (2 * MR, NR, W)
-_real_shape(::RealComplexMethod, (MR, NR, W)::NTuple{3, Int}) = (MR, 2 * NR, W)
-
-# The real problem the inner kernel sees: extents and C's unit-stride M run in reals.
-_real_problem(::ComplexRealMethod, Qm::Int, Qn::Int, run::Int) = (2 * Qm, Qn, 2 * run)
-_real_problem(::RealComplexMethod, Qm::Int, Qn::Int, run::Int) = (Qm, 2 * Qn, run)
-
-# The kernel type implementing `method` for `T`, or `nothing` (exactly the
-# pairs with a menu).
-_kernel_type(::RealMethod, ::Type{<:Union{Float32, Float64}}) = SIMDKernel
-_kernel_type(::PlanarMethod, ::Type{<:Union{ComplexF32, ComplexF64}}) = PlanarKernel
-_kernel_type(::OneMMethod, ::Type{<:Union{ComplexF32, ComplexF64}}) = OneMKernel
-_kernel_type(::FMAddSubMethod, ::Type{<:Union{ComplexF32, ComplexF64}}) = FMAddSubKernel
-_kernel_type(::ComplexRealMethod, ::Type{<:Union{ComplexF32, ComplexF64}}) = ComplexRealKernel
-_kernel_type(::RealComplexMethod, ::Type{<:Union{ComplexF32, ComplexF64}}) = RealComplexKernel
-_kernel_type(::Any, ::Type) = nothing
+kernel_shapes(::Type{T}) where {T} = kernel_shapes(T, default_kernel_type(T))
+kernel_shapes(::Type, ::Type) = ()
+kernel_shapes(::Type{Float64}, ::Type{<:SIMDKernel}) = KERNEL_SHAPES_F64
+kernel_shapes(::Type{Float32}, ::Type{<:SIMDKernel}) = KERNEL_SHAPES_F32
+kernel_shapes(::Type{ComplexF64}, ::Type{<:PlanarKernel}) = KERNEL_SHAPES_C64_PLANAR
+kernel_shapes(::Type{ComplexF64}, ::Type{<:OneMKernel}) = KERNEL_SHAPES_C64_ONEM
+kernel_shapes(::Type{ComplexF32}, ::Type{<:PlanarKernel}) = KERNEL_SHAPES_C32_PLANAR
+kernel_shapes(::Type{ComplexF32}, ::Type{<:OneMKernel}) = KERNEL_SHAPES_C32_ONEM
+kernel_shapes(::Type{ComplexF64}, ::Type{<:FMAddSubKernel}) = KERNEL_SHAPES_C64_FMADDSUB
+kernel_shapes(::Type{ComplexF32}, ::Type{<:FMAddSubKernel}) = KERNEL_SHAPES_C32_FMADDSUB
+# The mixed menus are the real menu of `real(T)`, mapped by `mixed_shape`.
+kernel_shapes(::Type{T}, K::MixedKernel) where {T <: Union{ComplexF32, ComplexF64}} =
+    map(s -> mixed_shape(K, s), kernel_shapes(real(T), SIMDKernel))
+
+# A real inner shape to the mixed kernel's `(MR, NR, W)`: complex A rows and
+# complex B columns each span two reals of the inner kernel.
+mixed_shape(::Type{<:ComplexRealKernel}, (MR, NR, W)::NTuple{3, Int}) = (MR ÷ 2, NR, W)
+mixed_shape(::Type{<:RealComplexKernel}, (MR, NR, W)::NTuple{3, Int}) = (MR, NR ÷ 2, W)
+
+# The real problem the inner kernel sees: `m_length` and C's unit-stride M run in reals.
+real_problem(::Type{<:ComplexRealKernel}, m_length::Int, run::Int) = (2 * m_length, 2 * run)
+real_problem(::Type{<:RealComplexKernel}, m_length::Int, run::Int) = (m_length, run)
 
 # An unrolled `shape === menu[i] ? ... :` ladder over the menu whose branches
 # are built from literals, so each is concrete; a shape outside the menu throws.
-# Each branch builds the kernel, or `Val(shape)` when `valonly`.
-function _menu_ladder(::Type{T}, method, valonly::Bool) where {T}
-    K = _kernel_type(method, T)
-    K === nothing && return :(_throw_no_kernel(shape, T, method))
-    ex = :(_throw_shape_not_in_menu(shape, T, method))
-    for (MR, NR, W) in reverse(kernel_shapes(T, method))
-        arm = valonly ? :(Val(($MR, $NR, $W))) : :($K(Val($MR), Val($NR), T, Val($W)))
+# Each branch builds the kernel, or a `Val` of its concrete type when `valonly`.
+function menu_ladder(::Type{T}, ::Type{K}, valonly::Bool) where {T, K}
+    menu = kernel_shapes(T, K)
+    isempty(menu) && return :(throw_no_kernel(shape, T, K))
+    ex = :(throw_shape_not_in_menu(shape, T, K))
+    for (MR, NR, W) in reverse(menu)
+        arm = valonly ? :(Val{$(K{MR, NR, T, W})}()) : :(K(Val($MR), Val($NR), T, Val($W)))
         ex = :(shape === ($MR, $NR, $W) ? $arm : $ex)
     end
     return ex
 end
 
-# The `method` kernel for `T` at a menu `shape` (one dynamic dispatch per plan).
-_kernel_from_shape(shape::Tuple{Int, Int, Int}, ::Type{T}) where {T} =
-    _kernel_from_shape(shape, T, _default_method(T))
-@generated _kernel_from_shape(shape::Tuple{Int, Int, Int}, ::Type{T}, method::M) where {T, M} =
-    _menu_ladder(T, M.instance, false)
-
-# `Val(shape)` for a menu `shape`: a singleton, so it crosses `plan_contract`'s
-# kernel barrier without boxing.
-@generated _menu_val(shape::Tuple{Int, Int, Int}, ::Type{T}, method::M) where {T, M} =
-    _menu_ladder(T, M.instance, true)
-
-@noinline _throw_no_kernel(shape, ::Type{T}, method) where {T} = throw(
+# The kernel of type `K` for `T` at a menu `shape` (one dynamic dispatch per plan).
+kernel_from_shape(shape::Tuple{Int, Int, Int}, ::Type{T}) where {T} =
+    kernel_from_shape(shape, T, default_kernel_type(T))
+@generated kernel_from_shape(shape::Tuple{Int, Int, Int}, ::Type{T}, ::Type{K}) where {T, K} =
+    menu_ladder(T, K, false)
+kernel_from_shape(shape::Tuple{Int, Int, Int}, ::Type{T}, ::Val{K}) where {T, K} =
+    kernel_from_shape(shape, T, K)
+
+# The concrete kernel type at a menu `shape`, as a `Val`: a singleton crosses
+# `plan_contract`'s kernel barrier without boxing, and dispatch on it hits the
+# fast method cache, which a bare `Type` argument misses.
+@generated menu_val(shape::Tuple{Int, Int, Int}, ::Type{T}, ::Type{K}) where {T, K} =
+    menu_ladder(T, K, true)
+
+@noinline throw_no_kernel(shape, ::Type{T}, K) where {T} = throw(
     ArgumentError(
-        "no microkernel is available for $T at shape $shape under $(method). " *
+        "no microkernel is available for $T at shape $shape with $(K). " *
             "Pass an explicit `kernel = ...` to plan_contract to use a kernel this " *
             "engine does not pick itself."
     )
 )
 
-@noinline _throw_shape_not_in_menu(shape, ::Type{T}, method) where {T} = throw(
+@noinline throw_shape_not_in_menu(shape, ::Type{T}, K) where {T} = throw(
     ArgumentError(
-        "shape $shape is not in the $(method) menu for $T, " *
-            "$(kernel_shapes(T, method)); only menu shapes are compiled"
+        "shape $shape is not in the $(K) menu for $T, " *
+            "$(kernel_shapes(T, K)); only menu shapes are compiled"
     )
 )
 
@@ -129,149 +120,163 @@ _kernel_from_shape(shape::Tuple{Int, Int, Int}, ::Type{T}) where {T} =
 # ----------------------------------------------------------------------------
 
 # Per-ISA shapes, consulted first. None for real types: the rule below is the optimum.
-_shape_override(key::Val, ::Type{T}) where {T} = _shape_override(key, T, _default_method(T))
-_shape_override(::Val, ::Type, ::ComplexMethod) = nothing
-# On AVX-512 the rule's planar `MR = 2W, NR = 6` spills; `NR = 3` tiles do not.
-_shape_override(::Val{:avx512}, ::Type{ComplexF64}, ::PlanarMethod) = (24, 3, 8)
-_shape_override(::Val{:avx512}, ::Type{ComplexF32}, ::PlanarMethod) = (48, 3, 16)
-# What the register fit selects on NEON anyway; pinned against menu edits.
-_shape_override(::Val{:neon}, ::Type{ComplexF64}, ::PlanarMethod) = (4, 6, 2)
-_shape_override(::Val{:neon}, ::Type{ComplexF32}, ::PlanarMethod) = (8, 6, 4)
-# AVX2 has 16 registers: at `MV = 1` planar `NR = 6` needs all 16, `NR = 5` needs 14.
-_shape_override(::Val{:avx2}, ::Type{ComplexF64}, ::PlanarMethod) = (4, 5, 4)
-_shape_override(::Val{:avx2}, ::Type{ComplexF32}, ::PlanarMethod) = (8, 5, 8)
-# The AVX2-sized 1m shape, for a caller naming `OneMMethod()` (the fit would
-# hand it an AVX-512 shape).
-_shape_override(::Val{:avx2}, ::Type{ComplexF64}, ::OneMMethod) = (4, 6, 4)
+shape_override(isa::Symbol, ::Type{T}) where {T} = shape_override(isa, T, default_kernel_type(T))
+function shape_override(isa::Symbol, ::Type{T}, ::Type{K}) where {T, K}
+    if K <: PlanarKernel && T === ComplexF64
+        # On AVX-512 the rule's planar `MR = 2W, NR = 6` spills; `NR = 3` tiles
+        # do not. AVX2 has 16 registers: at `MV = 1` planar `NR = 6` needs all
+        # 16, `NR = 5` needs 14.
+        isa === :avx512 && return (24, 3, 8)
+        isa === :avx2 && return (4, 5, 4)
+    elseif K <: PlanarKernel && T === ComplexF32
+        isa === :avx512 && return (48, 3, 16)
+        isa === :avx2 && return (8, 5, 8)
+    elseif K <: OneMKernel && T === ComplexF64
+        # The AVX2-sized 1m shape, for a caller asking for `OneMKernel`'s shape
+        # (the fit would hand it an AVX-512 shape).
+        isa === :avx2 && return (4, 6, 4)
+    end
+    return nothing
+end
 
 # Where the `MR = MV*W` rule applies. Not on NEON (2W on 128-bit lanes is no
 # better than the fallback), nor complex off AVX-512 (planar's two accumulator
 # planes leave AVX2's 16 registers nothing spare).
-_rule_applies(::Val{:avx512}, ::RealMethod) = true
-_rule_applies(::Val{:avx512}, ::Union{PlanarMethod, OneMMethod}) = true
-_rule_applies(::Val{:avx2}, ::RealMethod) = true
-_rule_applies(::Val, ::ComplexMethod) = false
+rule_applies(isa::Symbol, ::Type{K}) where {K} =
+    isa === :avx512 ? K <: Union{SIMDKernel, PlanarKernel, OneMKernel} : isa === :avx2 && K <: SIMDKernel
 
 # `W` real lanes per register, `MV` A vectors per column.
-_rule_shape(vb::Int, ::Type{T}, mv::Int) where {T} =
+rule_shape(vb::Int, ::Type{T}, mv::Int) where {T} =
     (mv * (vb ÷ sizeof(real(T))), NR_DEFAULT, vb ÷ sizeof(real(T)))
 
 # MV = 4 for the real kernel on AVX-512: the MV = 2 tile is front-end bound on
 # cores with 2 FMA ports, and 4*6 accumulators + 4 A vectors + 2 still fit 32
-# registers. Complex methods keep MV = 2 (planar already spills there).
-_rule_mv(::Val{:avx512}, ::RealMethod) = 4
-_rule_mv(::Val, ::ComplexMethod) = 2
-
-# AMD's AVX-512 cores double-pump 512-bit FMAs, so their MV = 2 tile is not
-# front-end bound and the taller tile only adds edge and store cost.
-const _MV4_UNPROFITABLE_CPUS = ("znver4", "znver5")
-
-_profile_mv(profile::TargetProfile, method) = _rule_mv(Val(profile.isa), method)
-function _profile_mv(profile::TargetProfile, method::RealMethod)
-    mv = _rule_mv(Val(profile.isa), method)
-    return (mv == 4 && profile.cpu_name in _MV4_UNPROFITABLE_CPUS) ? 2 : mv
+# registers. Complex kernels keep MV = 2 (planar already spills there).
+rule_mv(isa::Symbol, ::Type{K}) where {K} = isa === :avx512 && K <: SIMDKernel ? 4 : 2
+
+# Where 512-bit FMAs are double-pumped the MV = 2 tile is not front-end bound,
+# and the taller tile only adds edge and store cost.
+function profile_mv(profile::TargetProfile, ::Type{K}) where {K}
+    mv = rule_mv(profile.isa, K)
+    return (mv == 4 && profile.double_pumped) ? 2 : mv
 end
 
-# The register shape for `T` under `method` on `profile`: an override row, else
-# the rule where it applies (and lands in the menu), else `_fitted_shape`.
-_derived_shape(profile::TargetProfile, ::Type{T}) where {T} =
-    _derived_shape(profile, T, _default_method(T))
+# The register shape for `T` with kernel type `K` on `profile`: an override
+# row, else the rule where it applies (and lands in the menu), else `fitted_shape`.
+derived_shape(profile::TargetProfile, ::Type{T}) where {T} =
+    derived_shape(profile, T, default_kernel_type(T))
 
-function _derived_shape(profile::TargetProfile, ::Type{T}, method) where {T}
-    key = Val(profile.isa)
-    ovr = _shape_override(key, T, method)
+function derived_shape(profile::TargetProfile, ::Type{T}, ::Type{K}) where {T, K}
+    ovr = shape_override(profile.isa, T, K)
     ovr === nothing || return ovr
     vb = profile.vector_bytes
-    if _rule_applies(key, method) && vb > 0 && vb % sizeof(real(T)) == 0
-        shape = _rule_shape(vb, T, _profile_mv(profile, method))
-        shape in kernel_shapes(T, method) && return shape
+    if rule_applies(profile.isa, K) && vb > 0
+        shape = rule_shape(vb, T, profile_mv(profile, K))
+        shape in kernel_shapes(T, K) && return shape
     end
-    return _fitted_shape(profile, T, method)
+    return fitted_shape(profile, T, K)
 end
 
 # Vector registers a planar kernel holds live per K step (two planes of
 # accumulators and A vectors, plus 2 broadcasts). Spilling is not monotone in
 # it, so it only excludes shapes, never ranks them.
-_planar_pressure(MR::Int, NR::Int, W::Int) = 2 * (MR ÷ W) * NR + 2 * (MR ÷ W) + 2
+planar_pressure(MR::Int, NR::Int, W::Int) = 2 * (MR ÷ W) * NR + 2 * (MR ÷ W) + 2
 
 # The shape where no rule applies, and the small-M demotion target. Planar: the
 # largest menu shape with `W <= lanes` whose pressure fits the register file
 # (16 when unknown). 1m/FMAddSub: the menu head.
-_fitted_shape(::TargetProfile, ::Type{T}, ::RealMethod) where {T} = _fallback_shape(T)
-_fitted_shape(::TargetProfile, ::Type{T}, method::Union{OneMMethod, FMAddSubMethod}) where {T} =
-    first(kernel_shapes(T, method))
+fitted_shape(::TargetProfile, ::Type{T}, ::Type{<:SIMDKernel}) where {T} = fallback_shape(T)
+fitted_shape(::TargetProfile, ::Type{T}, ::Type{K}) where {T, K <: Union{OneMKernel, FMAddSubKernel}} =
+    first(kernel_shapes(T, K))
 
-function _fitted_shape(profile::TargetProfile, ::Type{T}, method::PlanarMethod) where {T}
-    R = real(T)
-    vb = profile.vector_bytes
-    lanes = (vb > 0 && vb % sizeof(R) == 0) ? vb ÷ sizeof(R) : _default_lanewidth(R)
+function fitted_shape(profile::TargetProfile, ::Type{T}, ::Type{K}) where {T, K <: PlanarKernel}
+    lanes = vector_lanes(profile, real(T))
     budget = profile.nregisters > 0 ? profile.nregisters : 16
     best = nothing
-    for shape in kernel_shapes(T, method)
+    for shape in kernel_shapes(T, K)
         MR, NR, W = shape
         (W <= lanes && MR % W == 0) || continue
-        _planar_pressure(MR, NR, W) <= budget || continue
+        planar_pressure(MR, NR, W) <= budget || continue
         # Largest logical tile wins; ties by the wider vector.
         if best === nothing || (MR * NR, W) > (best[1] * best[2], best[3])
             best = shape
         end
     end
     # Unreachable for any budget >= 16; a slow kernel beats throwing.
-    return best === nothing ? last(kernel_shapes(T, method)) : best
+    return best === nothing ? last(kernel_shapes(T, K)) : best
 end
 
 # ----------------------------------------------------------------------------
-# The default kernel for a profile, and the plan-time demotions
+# The automatic shape for a contraction
 # ----------------------------------------------------------------------------
 
-# The default kernel for `T` on `profile`, uncached.
-@noinline _kernel_for(profile::TargetProfile, ::Type{T}) where {T} =
-    _kernel_from_shape(_derived_shape(profile, T), T, _default_method(T))
-
-# The real MV = 4 shape steps down to its MV = 2 sibling when `Qm` is below one
-# tall tile, or below two and the half tile pads to fewer rows. Above `2MR` the
-# tall tile's padding excess is under 1.2x, its speed advantage.
-@inline _extent_shape(shape::NTuple{3, Int}, ::Type{T}, method, Qm::Int) where {T} = shape
+"""
+    select_shape(T, K, m_length, k_length, run) -> (shape, Val(kernel_type))
+
+The automatic register shape `(MR, NR, W)`, and the kernel type it is built
+with, for compute type `T` and kernel type `K = default_kernel_type(T, TA, TB)`,
+extents `m_length`/`k_length` and C's unit-stride run along M (`run`;
+`m_length` when no layout is known). The steps, in order:
+
+ 1. The host's shape for `T` (`derived_shape`).
+ 2. Extent (real): the MV = 4 shape steps down to MV = 2 where `m_length`
+    pads less (`extent_shape`).
+ 3. Small M: an `m_length` below one tile takes the fitted shape, or for
+    complex `T` on AVX-512 the FMAddSub shape that pads least (`small_m_shape`).
+ 4. Run (real): the shape shrinks until C's run fills its slivers (`fit_to_run`).
+
+A mixed kernel runs the steps on the real problem of `real(T)` and maps the
+shape. Plain values, so `plan_contract` never holds a menu-wide kernel Union;
+the kernel type as a `Val`, since inference widens a type inside a returned
+tuple to `UnionAll`.
+"""
+@inline function select_shape(::Type{T}, ::Type{K}, m_length::Int, k_length::Int, run::Int) where {T, K}
+    profile = target_profile()
+    shape = extent_shape(derived_shape(profile, T, K), T, K, m_length)
+    if m_length > 0 && m_length < shape[1]
+        # Static, so a real `T`'s kernel type stays concrete.
+        if T <: Complex
+            small = small_m_shape(profile, T, m_length)
+            small === nothing || return (small, Val(FMAddSubKernel))
+        end
+        shape = fitted_shape(profile, T, K)
+    end
+    return (fit_to_run(shape, T, K, m_length, k_length, run), Val(K))
+end
 
-@inline function _extent_shape(shape::NTuple{3, Int}, ::Type{T}, method::RealMethod, Qm::Int) where {T}
-    MR, NR, W = shape
-    (Qm > 0 && MR == 4 * W && Qm < 2 * MR) || return shape
-    half = (2 * W, NR, W)
-    half in kernel_shapes(T, method) || return shape
-    # Below one tall tile, always: the tall shape would fall to the fitted
-    # shape (two steps down) in `_default_shape`.
-    Qm < MR && return half
-    return cld(Qm, half[1]) * half[1] < cld(Qm, MR) * MR ? half : shape
+@inline function select_shape(::Type{T}, K::MixedKernel, m_length::Int, k_length::Int, run::Int) where {T}
+    m, r = real_problem(K, m_length, run)
+    shape, _ = select_shape(real(T), SIMDKernel, m, k_length, r)
+    return (mixed_shape(K, shape), Val(K))
 end
 
-# The real MV = 4 shape steps down to MV = 2 when C's unit-stride run along M
-# (`run`) can't fill the tall tile's slivers but fills a half tile: a sliver
-# that is not unit-stride in C takes the scattered store, which costs more than
-# the tall tile gains. Below one half tile both scatter, and the tall one stays.
-@inline _store_shape(shape::NTuple{3, Int}, ::Type{T}, method, Qm::Int, run::Int) where {T} = shape
+# The real MV = 4 shape steps down to its MV = 2 sibling when `m_length` is
+# below one tall tile, or below two and the half tile pads to fewer rows. Above
+# `2MR` the tall tile's padding excess is under 1.2x, its speed advantage.
+@inline extent_shape(shape::NTuple{3, Int}, ::Type{T}, ::Type, m_length::Int) where {T} = shape
 
-@inline function _store_shape(shape::NTuple{3, Int}, ::Type{T}, method::RealMethod, Qm::Int, run::Int) where {T}
+@inline function extent_shape(shape::NTuple{3, Int}, ::Type{T}, ::Type{K}, m_length::Int) where {T, K <: SIMDKernel}
     MR, NR, W = shape
-    (MR == 4 * W && Qm != run && run % MR != 0 && run >= 2 * W) || return shape
+    (m_length > 0 && MR == 4 * W && m_length < 2 * MR) || return shape
     half = (2 * W, NR, W)
-    return half in kernel_shapes(T, method) ? half : shape
+    half in kernel_shapes(T, K) || return shape
+    # Below one tall tile, always: the tall shape would fall to the fitted
+    # shape (two steps down) at the small-M step.
+    m_length < MR && return half
+    return cld(m_length, half[1]) * half[1] < cld(m_length, MR) * MR ? half : shape
 end
 
 # Small-M demotion for complex `T` on AVX-512, where the planar fitted shape is
-# the spilling `MR = 2W` tile: the native-width FMAddSub shape that pads `Qm`
-# least, ties by the larger tile. `_small_m_candidates` is the cached,
-# host-dependent half (empty where the rule does not apply).
-_small_m_candidates(::Val, ::TargetProfile, ::Type) = NTuple{3, Int}[]
-function _small_m_candidates(::Val{:avx512}, profile::TargetProfile, ::Type{T}) where {T <: Complex}
-    lanes = profile.vector_bytes ÷ sizeof(real(T))
-    return [shape for shape in kernel_shapes(T, FMAddSubMethod()) if shape[3] == lanes]
-end
-
-function _small_m_shape(candidates::Vector{NTuple{3, Int}}, Qm::Int)
+# the spilling `MR = 2W` tile: the native-width FMAddSub shape that pads
+# `m_length` least, ties by the larger tile.
+function small_m_shape(profile::TargetProfile, ::Type{T}, m_length::Int) where {T}
+    profile.isa === :avx512 || return nothing
+    lanes = vector_lanes(profile, real(T))
     best = nothing
-    for shape in candidates
-        MR, NR, _ = shape
-        key = (-(cld(Qm, MR) * MR), MR * NR)
+    for shape in kernel_shapes(T, FMAddSubKernel)
+        MR, NR, W = shape
+        W == lanes || continue
+        key = (-(cld(m_length, MR) * MR), MR * NR)
         if best === nothing || key > best[1]
             best = (key, shape)
         end
@@ -279,41 +284,32 @@ function _small_m_shape(candidates::Vector{NTuple{3, Int}}, Qm::Int)
     return best === nothing ? nothing : best[2]
 end
 
-# Run-length demotion (real `T` only): the vectorized store needs every
-# register sliver unit-stride in C, i.e. `Qm == run || run % mr == 0` (not
-# `mr <= run`). Otherwise demote to the largest menu shape whose `mr` divides
-# `run`, unless `Qk` is deep enough that the smaller kernel's cost dominates.
-@inline function _demote_shape_for_run(
-        ::Type{T}, shape::NTuple{3, Int}, method, run::Int, Qm::Int, Qk::Int
-    ) where {T}
-    target = _run_demotion_target(T, shape[1], method, run, Qm, Qk)
-    return target === nothing ? shape : target
-end
-
-@inline function _demote_shape_for_run(
-        ::Type{T}, shape::NTuple{3, Int}, method::_MixedMethod, run::Int, Qm::Int, Qk::Int
-    ) where {T}
-    m, _, r = _real_problem(method, Qm, 0, run)
-    real_shape = _demote_shape_for_run(real(T), _real_shape(method, shape), RealMethod(), r, m, Qk)
-    return _mixed_shape(method, real_shape)
-end
-
-function _run_demotion_target(::Type{T}, mrk::Int, method, run::Int, Qm::Int, Qk::Int) where {T}
-    T <: Real || return nothing
-    kmax = T === Float64 ? _RUN_DEMOTE_KMAX_F64 : _RUN_DEMOTE_KMAX_F32
-    Qk > kmax && return nothing
-    Qm == run && return nothing
-    run % mrk == 0 && return nothing
+# A register sliver takes the vectorized store only if it is unit-stride in C:
+# `m_length == run || run % MR == 0` (not `MR <= run`); otherwise it takes the
+# scattered one. Real `T` only, two steps in this order:
+#  - the MV = 4 shape steps down to MV = 2 when the run fills a half tile but
+#    not the tall tile's slivers (below one half tile both scatter, and the tall
+#    one stays);
+#  - at a shallow `k_length`, where the smaller kernel's cost does not dominate,
+#    the largest menu shape whose `MR` divides the run.
+@inline fit_to_run(shape::NTuple{3, Int}, ::Type{T}, ::Type, m_length::Int, k_length::Int, run::Int) where {T} = shape
+
+@inline function fit_to_run(shape::NTuple{3, Int}, ::Type{T}, ::Type{K}, m_length::Int, k_length::Int, run::Int) where {T, K <: SIMDKernel}
+    m_length == run && return shape
+    MR, NR, W = shape
+    half = (2 * W, NR, W)
+    if MR == 4 * W && run % MR != 0 && run >= 2 * W && half in kernel_shapes(T, K)
+        shape = half
+    end
+    kmax = T === Float64 ? RUN_DEMOTE_KMAX_F64 : RUN_DEMOTE_KMAX_F32
+    (k_length > kmax || run % shape[1] == 0) && return shape
     best = nothing
-    for shape in kernel_shapes(T, method)
-        m = shape[1]
-        if run % m == 0 && (best === nothing || m > best[1])
-            best = shape
-        end
+    for s in kernel_shapes(T, K)
+        run % s[1] == 0 && (best === nothing || s[1] > best[1]) && (best = s)
     end
-    return best
+    return something(best, shape)
 end
 
-# Deepest `Qk` at which run-length demotion still wins.
-const _RUN_DEMOTE_KMAX_F64 = 32
-const _RUN_DEMOTE_KMAX_F32 = 64
+# Deepest `k_length` at which the divisor step still wins.
+const RUN_DEMOTE_KMAX_F64 = 32
+const RUN_DEMOTE_KMAX_F32 = 64
diff --git a/src/planning/labels.jl b/src/planning/labels.jl
index 6dccc4e..15b3b72 100644
--- a/src/planning/labels.jl
+++ b/src/planning/labels.jl
@@ -3,15 +3,15 @@
 # `NTuple` whose length follows from the label tuples' lengths alone, so
 # planning allocates nothing and every `AxisGroup` is concretely typed.
 
-@inline _label_in(lbl::Int, t::NTuple{N, Int}) where {N} = any(==(lbl), t)
+@inline label_in(lbl::Int, t::NTuple{N, Int}) where {N} = any(==(lbl), t)
 
 # The M/N/K ranks: with A = M ∪ K, B = N ∪ K, C = M ∪ N, solve
 # NA = |M| + |K|, NB = |N| + |K|, NC = |M| + |N|. Meaningful only for input that
-# `_classify_labels` accepts, which asserts them against the counts it finds.
-@inline _group_ranks(NA::Int, NB::Int, NC::Int) =
+# `classify_labels` accepts, which asserts them against the counts it finds.
+@inline group_ranks(NA::Int, NB::Int, NC::Int) =
     ((NA + NC - NB) ÷ 2, (NB + NC - NA) ÷ 2, (NA + NB - NC) ÷ 2)
 
-@noinline _throw_rank_mismatch(which::Symbol, found::Int, derived::Int) = throw(
+@noinline throw_rank_mismatch(which::Symbol, found::Int, derived::Int) = throw(
     ArgumentError(
         "internal error: $which label count $found does not match the rank $derived " *
             "derived from the label tuple lengths"
@@ -19,13 +19,13 @@
 )
 
 # Set element `n` of `out`, ignoring an `n` past the end (input about to be rejected).
-@inline function _push_label(out::NTuple{D, Int}, n::Int, x::Int) where {D}
-    return n <= D ? _tupleset(out, n, x) : out
+@inline function push_label(out::NTuple{D, Int}, n::Int, x::Int) where {D}
+    return n <= D ? Base.setindex(out, x, n) : out
 end
 
 # (mlabels, nlabels, klabels) in indA/indB order. Per (inA, inB, inC):
 # (T,F,T) -> M, (F,T,T) -> N, (T,T,F) -> K, anything else is an ArgumentError.
-function _classify_labels(
+function classify_labels(
         indA::NTuple{NA, Int}, indB::NTuple{NB, Int},
         indC::NTuple{NC, Int}
     ) where {NA, NB, NC}
@@ -36,15 +36,15 @@ function _classify_labels(
     allunique(indC) ||
         throw(ArgumentError("indC has a repeated label (diagonal), not supported: $indC"))
 
-    DM, DN, DK = _group_ranks(NA, NB, NC)
+    DM, DN, DK = group_ranks(NA, NB, NC)
     mlabels = ntuple(_ -> 0, Val(max(DM, 0)))
     nlabels = ntuple(_ -> 0, Val(max(DN, 0)))
     klabels = ntuple(_ -> 0, Val(max(DK, 0)))
     nm = 0
     nk = 0
     for lbl in indA
-        inB = _label_in(lbl, indB)
-        inC = _label_in(lbl, indC)
+        inB = label_in(lbl, indB)
+        inC = label_in(lbl, indC)
         if inB && inC
             throw(
                 ArgumentError(
@@ -54,10 +54,10 @@ function _classify_labels(
             )
         elseif inB && !inC
             nk += 1
-            klabels = _push_label(klabels, nk, lbl)
+            klabels = push_label(klabels, nk, lbl)
         elseif !inB && inC
             nm += 1
-            mlabels = _push_label(mlabels, nm, lbl)
+            mlabels = push_label(mlabels, nm, lbl)
         else
             throw(
                 ArgumentError(
@@ -70,13 +70,13 @@ function _classify_labels(
 
     nn = 0
     for lbl in indB
-        inA = _label_in(lbl, indA)
-        inC = _label_in(lbl, indC)
+        inA = label_in(lbl, indA)
+        inC = label_in(lbl, indC)
         if inA
             continue  # K, or already rejected while scanning indA
         elseif inC
             nn += 1
-            nlabels = _push_label(nlabels, nn, lbl)
+            nlabels = push_label(nlabels, nn, lbl)
         else
             throw(
                 ArgumentError(
@@ -88,49 +88,30 @@ function _classify_labels(
     end
 
     for lbl in indC
-        inA = _label_in(lbl, indA)
-        inB = _label_in(lbl, indB)
+        inA = label_in(lbl, indA)
+        inB = label_in(lbl, indB)
         (inA || inB) ||
             throw(ArgumentError("label $lbl appears in indC but not in indA or indB"))
     end
 
     # Unreachable after the checks above; guards against a silently truncated list.
-    nm == DM || _throw_rank_mismatch(:M, nm, DM)
-    nn == DN || _throw_rank_mismatch(:N, nn, DN)
-    nk == DK || _throw_rank_mismatch(:K, nk, DK)
+    nm == DM || throw_rank_mismatch(:M, nm, DM)
+    nn == DN || throw_rank_mismatch(:N, nn, DN)
+    nk == DK || throw_rank_mismatch(:K, nk, DK)
     return mlabels, nlabels, klabels
 end
 
-@noinline _throw_label_length(lbl::Int, l1::Int, l2::Int) = throw(
-    DimensionMismatch("label $lbl has mismatched axis length: $l1 vs $l2")
-)
-
-# Stable insertion sort of the permutation `perm` by `key[perm[j]]`, ascending
-# (n <= ndims, and unlike `sortperm` it allocates nothing).
-@inline function _sort_perm(perm::NTuple{D, Int}, key::NTuple{D, Int}) where {D}
-    out = perm
-    @inbounds for i in 2:D
-        x = out[i]
-        kx = key[x]
-        j = i - 1
-        while j >= 1 && key[out[j]] > kx
-            out = _tupleset(out, j + 1, out[j])
-            j -= 1
-        end
-        out = _tupleset(out, j + 1, x)
-    end
-    return out
-end
-
 # `labels` stably sorted by `abs(stride)` of their axis in `C` (every label must
 # be in `indC`): a composite enumerates its first label fastest, so this walks
 # C's fastest axis fastest.
-function _order_free_labels(
+# `TupleTools.sortperm` is a merge sort that keeps ties in order (relied on here
+# and in `order_contract_labels`).
+function order_free_labels(
         labels::NTuple{D, Int}, indC::NTuple{NC, Int}, C::StridedView
     ) where {D, NC}
     st = Base.strides(C)
     key = map(l -> abs(st[findfirst(==(l), indC)::Int]), labels)
-    return map(i -> @inbounds(labels[i]), _sort_perm(ntuple(identity, Val(D)), key))
+    return TupleTools.getindices(labels, TupleTools.sortperm(key))
 end
 
 # ----------------------------------------------------------------------------
@@ -143,7 +124,7 @@ end
 #
 #     cost = n * walk * amplification
 #
-#   * `walk` is `_K_WALK_FAR_PENALTY` when the fastest K axis steps more than a
+#   * `walk` is `K_WALK_FAR_PENALTY` when the fastest K axis steps more than a
 #     page (a chain of demand misses no prefetcher follows), else 1.
 #   * `amplification` is how often a cache line is fetched: 1 when the slivers
 #     are whole lines, when the operand's smallest-stride axis `u` is the
@@ -152,28 +133,12 @@ end
 #     `min(L_u, line_bytes / stride_u)`.
 # ----------------------------------------------------------------------------
 
-const _K_WALK_FAR_BYTES = 4096
-const _K_WALK_FAR_PENALTY = 3
-const _K_LINE_BYTES = 64
-
-# The core's private L2 share, or 1 MB when undetected.
-function _l2_core_bytes(profile::TargetProfile)
-    l2 = profile.l2
-    l2.bytes > 0 || return 1 << 20
-    smt = max(1, profile.l1d.sharing)
-    return l2.bytes ÷ max(1, l2.sharing ÷ smt)
-end
-
-# Through the per-eltype cache; an eltype without a slot fails later in planning.
-@inline _l2_core_bytes(::Type{T}) where {T} =
-    _defaults_slot(T) === nothing ? _l2_core_bytes(target_profile()) : _resolved_defaults(T).l2_core
-
 # What the cost model reads of one operand, gathered once per plan in `klabels`
 # order: each K label's extent and |stride|, the element count and size, and
 # whether its register slivers are whole lines (the free composite's first
 # non-singleton axis is unit-stride and at least a line long). A candidate
 # order is then a permutation of `1:DK`.
-struct _KOperand{DK}
+struct KOperand{DK}
     len::NTuple{DK, Int}
     st::NTuple{DK, Int}
     n::Int
@@ -181,9 +146,9 @@ struct _KOperand{DK}
     wholeline::Bool
 end
 
-@inline function _k_operand(
+@inline function k_operand(
         klabels::NTuple{DK, Int}, ind::NTuple{N, Int}, v::StridedView,
-        free::NTuple{DF, Int}
+        free::NTuple{DF, Int}, line::Int
     ) where {DK, N, DF}
     st = Base.strides(v)
     sz = size(v)
@@ -192,7 +157,7 @@ end
     ps = map(pos, klabels)
     len = map(p -> sz[p], ps)
     kst = map(p -> abs(st[p]), ps)
-    line_elems = max(1, _K_LINE_BYTES ÷ S)
+    line_elems = max(1, line ÷ S)
     wholeline = false
     for l in free
         p = pos(l)
@@ -200,12 +165,12 @@ end
         wholeline = st[p] == 1 && sz[p] >= line_elems
         break
     end
-    return _KOperand{DK}(len, kst, length(v), S, wholeline)
+    return KOperand{DK}(len, kst, length(v), S, wholeline)
 end
 
 # Cost of packing one operand under the K order `perm`; `Qfree` is its free extent.
-function _k_order_cost(
-        perm::NTuple{DK, Int}, op::_KOperand{DK}, Qfree::Int, l2bytes::Int
+function k_order_cost(
+        perm::NTuple{DK, Int}, op::KOperand{DK}, Qfree::Int, l2bytes::Int, line::Int
     ) where {DK}
     len, st, S = op.len, op.st, op.S
     kfast = 0
@@ -216,7 +181,7 @@ function _k_order_cost(
         end
     end
     kfast == 0 && return 0  # all-singleton K: nothing walks
-    walk = @inbounds(st[kfast]) * S > _K_WALK_FAR_BYTES ? _K_WALK_FAR_PENALTY : 1
+    walk = @inbounds(st[kfast]) * S > K_WALK_FAR_BYTES ? K_WALK_FAR_PENALTY : 1
     op.wholeline && return op.n * walk
 
     # The smallest-stride K axis `u` (first in this order among equal strides).
@@ -232,46 +197,38 @@ function _k_order_cost(
     # One element of `u` per line exactly when su*S > line/2 (len[u] >= 2);
     # tested first so the division is only paid where its value is used.
     suS = su * S
-    (2 * suS > _K_LINE_BYTES || u == kfast) && return op.n * walk
+    (2 * suS > line || u == kfast) && return op.n * walk
 
     faster = 1
     @inbounds for i in perm
         i == u && break
         faster *= len[i]
     end
-    footprint = Int128(faster) * Int128(Qfree) * Int128(_K_LINE_BYTES)
+    footprint = Int128(faster) * Int128(Qfree) * Int128(line)
     footprint <= l2bytes && return op.n * walk
-    share = min(@inbounds(len[u]), _K_LINE_BYTES ÷ suS)
+    share = min(@inbounds(len[u]), line ÷ suS)
     return op.n * walk * share
 end
 
 # Zero or one K label returns at a compile-time branch, before the model.
-@inline function _order_contract_labels(
-        klabels::NTuple{DK, Int},
-        indA::NTuple{NA, Int}, A::StridedView, morder::NTuple{DM, Int},
-        indB::NTuple{NB, Int}, B::StridedView, norder::NTuple{DN, Int},
-        Qm::Int, Qn::Int
-    ) where {DK, NA, NB, DM, DN}
-    DK <= 1 && return klabels
-    return _choose_k_order(klabels, indA, A, morder, indB, B, norder, Qm, Qn, nothing)
-end
-
 # `l2bytes = nothing`: the core's L2 share, looked up only once a cost is needed.
-function _choose_k_order(
+@inline function order_contract_labels(
         klabels::NTuple{DK, Int},
         indA::NTuple{NA, Int}, A::StridedView, morder::NTuple{DM, Int},
         indB::NTuple{NB, Int}, B::StridedView, norder::NTuple{DN, Int},
-        Qm::Int, Qn::Int, l2bytes::Union{Int, Nothing}
+        m_length::Int, n_length::Int, l2bytes::Union{Int, Nothing} = nothing
     ) where {DK, NA, NB, DM, DN}
     DK <= 1 && return klabels
-    opA = _k_operand(klabels, indA, A, morder)
-    opB = _k_operand(klabels, indB, B, norder)
+    profile = target_profile()
+    line = line_bytes(profile)
+    opA = k_operand(klabels, indA, A, morder, line)
+    opB = k_operand(klabels, indB, B, norder, line)
     id = ntuple(identity, Val(DK))
-    permA = _sort_perm(id, opA.st)
-    permB = _sort_perm(id, opB.st)
+    permA = TupleTools.sortperm(opA.st)
+    permB = TupleTools.sortperm(opB.st)
     permA == id && permB == id && return klabels
-    l2 = l2bytes === nothing ? _l2_core_bytes(eltype(A)) : l2bytes
-    cost(perm) = _k_order_cost(perm, opA, Qm, l2) + _k_order_cost(perm, opB, Qn, l2)
+    l2 = l2bytes === nothing ? l2_core_bytes(profile) : l2bytes
+    cost(perm) = k_order_cost(perm, opA, m_length, l2, line) + k_order_cost(perm, opB, n_length, l2, line)
     best = id
     bestcost = cost(id)
     for cand in (permA, permB)
@@ -282,14 +239,14 @@ function _choose_k_order(
             bestcost = c
         end
     end
-    return map(i -> @inbounds(klabels[i]), best)
+    return TupleTools.getindices(klabels, best)
 end
 
 # Length of the leading unit-stride run in C when `labels` is enumerated
 # first-label-fastest: the first non-singleton label needs C-stride exactly +1,
 # and each following one extends the run only if its stride equals the run so
 # far. 1 when no run starts, 0 if an empty axis is met first.
-function _leading_unit_run(
+function leading_unit_run(
         labels::NTuple{D, Int}, indC::NTuple{NC, Int}, C::StridedView
     ) where {D, NC}
     st = Base.strides(C)
@@ -307,7 +264,7 @@ end
 
 # Swap the operand roles (B feeds M) when the as-is M run cannot fill a register
 # sliver of the kernel it would run and the swapped one can: the vectorized
-# store needs `mr` consecutive M coordinates unit-stride in C, so a shorter run
-# buys nothing.
-_prefer_swap(run_m::Int, run_n::Int, mr_asis::Int, mr_swapped::Int = mr_asis) =
-    run_m < mr_asis && run_n >= mr_swapped
+# store needs `m_tile` consecutive M coordinates unit-stride in C, so a shorter
+# run buys nothing.
+prefer_swap(run_m::Int, run_n::Int, m_tile_asis::Int, m_tile_swapped::Int = m_tile_asis) =
+    run_m < m_tile_asis && run_n >= m_tile_swapped
diff --git a/src/planning/pack_split.jl b/src/planning/pack_split.jl
deleted file mode 100644
index 0aead6e..0000000
--- a/src/planning/pack_split.jl
+++ /dev/null
@@ -1,163 +0,0 @@
-# Packing by cache lines. When a register sliver reads one element per line and
-# the line's other elements belong to coordinates a whole sweep of the free
-# composite later, lines rarely survive until reused; at power-of-two extents
-# they alias in a few cache sets and the pack costs a memory latency per
-# element. A split plan enumerates the free composite so that a macro block
-# holds whole lines, and packs each block line by line
-# (`_pack_block_transposed!`); the packed format and the K order are unchanged.
-
-"""
-    PackSplit(q, dj, L, kinner, Eq, E)
-
-How one operand's free group is enumerated and packed under a split: axis `q`
-in chunks of `Eq`, the unit-stride axis `dj > q` in chunks of `L` (a line's
-worth) placed right after the `Eq` chunk. A group is then `E x L`
-coordinates, `E` = (lengths before `q`) * `Eq`, and the block walk reads its
-lines K step by K step, or with K innermost when `kinner`. `L == 0`: no split.
-"""
-struct PackSplit
-    # Narrow fields: the plan carries two of these through every call.
-    q::UInt8
-    dj::UInt8
-    L::UInt8
-    kinner::Bool
-    Eq::Int32
-    E::Int32
-end
-
-const _NO_SPLIT = PackSplit(0, 0, 0, false, 0, 0)
-
-_is_split(s::PackSplit) = s.L != 0
-
-# The split for the operand behind map 1 of `g` (A for M, B for N) and the block
-# extent it needs, or `(eff, _NO_SPLIT)`. `eff` is the plan's extent, `rounded`
-# the requested one rounded to `R`; a split block may take the budget the
-# blocking reserved for the requested `kc_req` when the K extent clamps `kc`.
-# `l2bytes = nothing`: `_split_capacity`, doubled for complex, whose block
-# walk costs more per element.
-@inline function _pack_split(
-        g::AxisGroup{D}, kg::AxisGroup, kmap::Int, R::Int, S::Int, complex::Bool, kc::Int,
-        eff::Int, rounded::Int, kc_req::Int, l2bytes::Union{Int, Nothing} = nothing
-    ) where {D}
-    D < 256 || return (eff, _NO_SPLIT)
-    line = _K_LINE_BYTES
-    d1 = 0
-    for d in 1:D
-        g.lengths[d] > 1 && (d1 = d; break)
-    end
-    (d1 > 0 && abs(g.strides[1][d1]) * S >= line) || return (eff, _NO_SPLIT)
-    dj = 0
-    for d in (d1 + 1):D
-        g.lengths[d] > 1 && abs(g.strides[1][d]) == 1 && (dj = d; break)
-    end
-    dj == 0 && return (eff, _NO_SPLIT)
-    return _pack_split_window(g, kg, kmap, d1, dj, R, S, complex, kc, eff, rounded, kc_req, l2bytes)
-end
-
-# Out of line: shared by every eltype, and most plans never get here.
-@noinline function _pack_split_window(
-        g::AxisGroup, kg::AxisGroup{DK}, kmap::Int, d1::Int, dj::Int, R::Int, S::Int, complex::Bool,
-        kc::Int, eff::Int, rounded::Int, kc_req::Int, l2bytes::Union{Int, Nothing}
-    ) where {DK}
-    line = _K_LINE_BYTES
-    L = _largest_divisor_upto(g.lengths[dj], max(1, line ÷ S))
-    L >= 2 || return (eff, _NO_SPLIT)
-
-    ks = 0
-    for d in 1:DK
-        kg.lengths[d] > 1 && (ks = abs(kg.strides[kmap][d]); break)
-    end
-    # K steps within a page make each sliver element's lines a stream the
-    # prefetchers follow; a split then only saves refetching those lines, which
-    # does not pay for the block walk's costlier complex scatter.
-    kinner = ks * S < _K_WALK_FAR_BYTES
-    kinner && complex && return (eff, _NO_SPLIT)
-
-    # A line of `dj` is reused `psi` coordinates later; while the lines touched
-    # meanwhile fit the cache, the per-sliver walk is already cache-friendly.
-    psi = 1
-    for d in d1:(dj - 1)
-        psi *= g.lengths[d]
-    end
-    klines = ks * S >= line ? kc : cld(kc * ks * S, line)
-    aliased = abs(g.strides[1][d1]) * S % _K_WALK_FAR_BYTES == 0
-    cap = something(l2bytes, _split_capacity(target_profile(), aliased) << complex)
-    widemul(psi, max(1, klines) * line) > cap || return (eff, _NO_SPLIT)
-    return _pack_split_dynamic(g.lengths, d1, dj, L, psi, R, eff, rounded, kc, kc_req, kinner)
-end
-
-# The cache that can hold the per-sliver walk's reuse window: the core's L2
-# share, plus its L3 share unless the sliver steps a whole number of pages,
-# which folds the lines it gathers into a few sets of every level.
-function _split_capacity(profile::TargetProfile, aliased::Bool)
-    l2 = _l2_core_bytes(profile)
-    l3 = profile.l3
-    (aliased || l3.bytes <= 0) && return l2
-    return l2 + l3.bytes ÷ max(1, l3.sharing ÷ max(1, profile.l1d.sharing))
-end
-
-# Past the tests above the plan is for a large contraction; a dynamic call keeps
-# the search from being compiled for every other plan.
-@noinline _pack_split_dynamic(args...) = Base.inferencebarrier(_pack_split_blocks)(args...)::Tuple{Int, PackSplit}
-
-function _pack_split_blocks(
-        lengths::NTuple{D, Int}, d1::Int, dj::Int, L::Int, psi::Int, R::Int,
-        eff::Int, rounded::Int, kc::Int, kc_req::Int, kinner::Bool
-    ) where {D}
-    budget = max(rounded, Int(min(widemul(rounded, kc_req) ÷ kc, typemax(Int32))) ÷ R * R)
-    # Prefixes of `d1:dj-1`: whole axes, then a divisor chunk of the next one.
-    # `E` is also the run of consecutive C coordinates a block stores, so take
-    # the largest whose whole groups fit the budget, preferring `R | E`. A
-    # prefix shorter than a sliver would make slivers straddle chunks.
-    best = anyc = (0, 0, 0)
-    pre = 1
-    for q in d1:(dj - 1)
-        len = lengths[q]
-        limit = budget ÷ (pre * L)
-        limit >= 1 || break
-        for Eq in min(len, limit):-1:1
-            len % Eq == 0 || continue
-            E = pre * Eq
-            ((E >= R || E == psi) && lcm(R, E * L) <= budget) || continue
-            E > anyc[3] && (anyc = (q, Eq, E))
-            E % R == 0 && E > best[3] && (best = (q, Eq, E))
-        end
-        len <= limit || break
-        pre *= len
-    end
-    (q, Eq, E) = best[3] > 0 ? best : anyc
-    E == 0 && return (eff, _NO_SPLIT)
-    blk = lcm(R, E * L)
-    neweff = min(budget ÷ blk * blk, _roundup(_unchecked_axis_length(lengths), R))
-    return (neweff, PackSplit(q, dj, L, kinner, Eq, E))
-end
-
-@inline function _largest_divisor_upto(n::Int, cap::Int)
-    for L in min(n, cap):-1:1
-        n % L == 0 && return L
-    end
-    return 1
-end
-
-# `g` in the enumeration `s` describes: `q` and `dj` each replaced by an (inner,
-# outer) pair of axes, the inner chunk of `dj` moved right after that of `q`.
-function _split_group(g::AxisGroup{D, P}, s::PackSplit) where {D, P}
-    ax(k, p) = _split_axis(g, s, k, p)
-    return AxisGroup(
-        ntuple(k -> ax(k, 0), Val(D + 2)), ntuple(p -> ntuple(k -> ax(k, p), Val(D + 2)), Val(P))
-    )
-end
-
-# Length (`p == 0`) or map-`p` stride of axis `k` of `_split_group(g, s)`.
-@inline function _split_axis(g::AxisGroup, s::PackSplit, k::Int, p::Int)
-    len(d) = g.lengths[d]
-    str(d) = g.strides[p][d]
-    q, dj, Eq, L = Int(s.q), Int(s.dj), Int(s.Eq), Int(s.L)
-    k < q && return p == 0 ? len(k) : str(k)
-    k == q && return p == 0 ? Eq : str(q)
-    k == q + 1 && return p == 0 ? L : str(dj)
-    k == q + 2 && return p == 0 ? len(q) ÷ Eq : Eq * str(q)
-    k <= dj + 1 && return p == 0 ? len(k - 2) : str(k - 2)
-    k == dj + 2 && return p == 0 ? len(dj) ÷ L : L * str(dj)
-    return p == 0 ? len(k - 2) : str(k - 2)
-end
diff --git a/src/planning/plan.jl b/src/planning/plan.jl
index bff24b5..6aabae2 100644
--- a/src/planning/plan.jl
+++ b/src/planning/plan.jl
@@ -1,21 +1,25 @@
 # The plan: everything `execute!` needs, resolved once so it can be reused.
 # `plan_contract` runs the planning stages (labels, conjugation, kernel
-# selection, blocking) and sizes the `ContractWorkspace`.
+# selection, blocking, execution path) and sizes the `ContractWorkspace`.
 
 """
     ContractPlan
 
 Reusable, concretely typed plan from [`plan_contract`](@ref): the M/N/K
-`AxisGroup`s, kernel, operand storages, effective [`Blocking`](@ref), packing
-transforms and the [`ContractWorkspace`](@ref) holding every buffer
-[`execute!`](@ref) needs. Field layout is not part of the public interface;
-after an M/N orientation swap the `A*` fields describe the original `B`.
+`AxisGroup`s, kernel, execution path, operand storages, effective
+[`Blocking`](@ref), packing transforms and the [`ContractWorkspace`](@ref)
+holding every buffer [`execute!`](@ref) needs. Reusing a plan reuses its
+buffers. A plan, and so its workspace, must be used by one task at a time.
+Field layout is not part of the public interface; after an M/N orientation
+swap the `A*` fields describe the original `B`.
 """
 struct ContractPlan{
-        T, Kern, GM <: AxisGroup, GN <: AxisGroup, GK <: AxisGroup, SA, SB, SC,
+        T, Kern, P, GM <: AxisGroup, GN <: AxisGroup, GK <: AxisGroup, SA, SB, SC,
         TA, TB, VT <: AbstractVector, PT <: AbstractVector,
     }
     kernel::Kern
+    # The singleton selecting the `execute_path!` method (src/execution/paths.jl).
+    path::P
     mgroup::GM
     ngroup::GN
     kgroup::GK
@@ -40,22 +44,40 @@ struct ContractPlan{
     npack::PackSplit
 end
 
+# `p` with some fields replaced.
+@inline ContractPlan(
+    p::ContractPlan; path = p.path, mgroup = p.mgroup, ngroup = p.ngroup,
+    Astorage = p.Astorage, Abase = p.Abase, Bstorage = p.Bstorage, Bbase = p.Bbase,
+    Cstorage = p.Cstorage, Cbase = p.Cbase, atransform = p.atransform, btransform = p.btransform,
+    mpack = p.mpack, npack = p.npack
+) = ContractPlan(
+    p.kernel, path, mgroup, ngroup, p.kgroup, p.blocking, Astorage, Abase, Bstorage, Bbase,
+    Cstorage, Cbase, atransform, btransform, p.workspace, mpack, npack
+)
+
+# Internal, for tests and benchmarks: `:never` rules out the dot, outer-product
+# or unpacked-B path, `:always` forces unpacked B where the kernel admits it.
+Base.@kwdef struct PathModes
+    dot::Symbol = :auto
+    outer::Symbol = :auto
+    unpacked_b::Symbol = :auto
+end
+
 """
     plan_contract(C::StridedView, A::StridedView, indA::NTuple{NA,Int},
                   B::StridedView, indB::NTuple{NB,Int},
                   indC::NTuple{NC,Int};
                   kernel = nothing,
                   conjA = false, conjB = false,
-                  mc = nothing, kc = nothing, nc = nothing,
-                  workspace = nothing,
+                  m_block = nothing, k_block = nothing, n_block = nothing,
                   allocator = TensorOperations.DefaultAllocator(),
-                  oracle = true, accumulator = nothing) -> ContractPlan
+                  accumulator = nothing) -> ContractPlan
 
 Plan `C[indC] = A[indA] * B[indB]` (every label in exactly two operands):
 resolve the labels into M/N/K `AxisGroup`s, validate axis lengths and eltypes,
 choose the kernel and blocking, and preallocate every buffer
 [`execute!`](@ref) needs. Throws `ArgumentError`/`DimensionMismatch` on
-invalid input.
+invalid input; `C` must not share memory with `A` or `B`.
 
   * Each operand's eltype is one of `Float32`, `Float64`, `ComplexF32`,
     `ComplexF64`; a complex `A` or `B` needs a complex `C`. The compute type
@@ -63,8 +85,8 @@ invalid input.
     `Float64`, that precision in the domain (real or complex) of the promoted
     type. Operands are converted to `T` on load and `alpha*AB + beta*C` is
     evaluated in `T`, rounding to `eltype(C)` once. For an `eltype(C)` of
-    lower precision than `T`, a K longer than `kc` accumulates in a panel of
-    `T` in the workspace, of `M * min(N, nc)` elements.
+    lower precision than `T`, a K longer than `k_block` accumulates in a panel
+    of `T` in the workspace, of `M * min(N, n_block)` elements.
   * `kernel = nothing` picks one from the hardware profile and the extents: a
     [`SIMDKernel`](@ref) for a real `T`, a [`PlanarKernel`](@ref) for a
     complex one (an [`FMAddSubKernel`](@ref) for a short M on AVX-512), a
@@ -75,18 +97,17 @@ invalid input.
     operand roles are swapped (B feeds M) when only the N side gives `C` a
     unit-stride run long enough for the kernel's register tile; the result is
     the same either way.
-  * `mc`/`kc`/`nc` override the fields of `default_blocking(kernel)` (each
-    `>= 1`); `mc`/`nc` are rounded up to `mr`/`nr` multiples and all three are
-    clamped to the extents.
+  * `m_block`/`k_block`/`n_block` override the fields of
+    `default_blocking(kernel)` (each `>= 1`); `m_block`/`n_block` are rounded
+    up to multiples of the tile size and all three are clamped to the extents.
   * An operand whose register slivers would read one element per cache line,
     with the lines' other elements needed only after more lines than fit L2,
-    is packed line by line (`PackSplit`); its `mc` (or `nc`) then becomes a
-    whole number of line groups, up to `requested kc / kc` times the request.
-  * `workspace` reuses an existing [`ContractWorkspace`](@ref) for compute
-    type `T`, grown by [`reserve!`](@ref) as needed. A non-default
-    TensorOperations `allocator` sizes the buffers once via `tensoralloc`,
-    forbids `workspace`, and leaves [`release!`](@ref) to the caller.
-  * `oracle = false` skips `execute_tilewise!`'s buffers.
+    is packed line by line (`PackSplit`); its `m_block` (or `n_block`) then
+    becomes a whole number of line groups, up to `requested k_block / k_block`
+    times the request.
+  * The plan's [`ContractWorkspace`](@ref) takes its packed panels from the
+    TensorOperations `allocator`; for a non-default one, [`release!`](@ref)
+    is left to the caller.
   * `conjA`/`conjB` conjugate A's/B's elements (never `alpha`/`beta`) and
     compose by XOR with a view's own `conj`/`adjoint` `op`. A conjugated `C`
     is rejected.
@@ -98,28 +119,27 @@ function plan_contract(
         kernel = nothing,
         conjA::Bool = false,
         conjB::Bool = false,
-        mc::Union{Int, Nothing} = nothing,
-        kc::Union{Int, Nothing} = nothing,
-        nc::Union{Int, Nothing} = nothing,
-        workspace::Union{Nothing, ContractWorkspace} = nothing,
+        m_block::Union{Int, Nothing} = nothing,
+        k_block::Union{Int, Nothing} = nothing,
+        n_block::Union{Int, Nothing} = nothing,
         allocator = TO.DefaultAllocator(),
-        oracle::Bool = true,
-        accumulator::Union{Nothing, Type{Float32}, Type{Float64}} = nothing
+        accumulator::Union{Nothing, Type{Float32}, Type{Float64}} = nothing,
+        path_modes::PathModes = PathModes()
     ) where {NA, NB, NC}
-    return _planned(
-        identity, C, A, indA, B, indB, indC,
-        kernel, conjA, conjB, mc, kc, nc, workspace, allocator, oracle, accumulator
+    return planned(
+        C, A, indA, B, indB, indC, nothing, nothing;
+        kernel, conjA, conjB, m_block, k_block, n_block, allocator, accumulator, path_modes
     )
 end
 
-# Everything `_plan_contract` needs that is concretely typed before the kernel
-# is known (`run` is the chosen M composite's unit-stride run in C), as one
-# value that crosses the kernel barrier. `T` is the phantom compute type.
-struct _PlanRequest{
-        T, F, GM <: AxisGroup, GN <: AxisGroup, GK <: AxisGroup, SA, SB, SC,
-        WS <: Union{Nothing, ContractWorkspace}, AL,
+# Everything planning needs that is concretely typed before the kernel is
+# known (`run` is the chosen M composite's unit-stride run in C). `T` is the
+# phantom compute type; `alpha`/`beta` are `nothing` to build the plan only.
+struct PlanRequest{
+        T, S <: Union{T, Nothing}, GM <: AxisGroup, GN <: AxisGroup, GK <: AxisGroup, SA, SB, SC, AL,
     }
-    f::F
+    alpha::S
+    beta::S
     mgroup::GM
     ngroup::GN
     kgroup::GK
@@ -130,244 +150,337 @@ struct _PlanRequest{
     Cstorage::SC
     Cbase::Int
     run::Int
-    mc::Union{Int, Nothing}
-    kc::Union{Int, Nothing}
-    nc::Union{Int, Nothing}
-    workspace::WS
+    m_block::Union{Int, Nothing}
+    k_block::Union{Int, Nothing}
+    n_block::Union{Int, Nothing}
     allocator::AL
-    oracle::Bool
+    modes::PathModes
 end
 
-@inline function _plan_request(
-        ::Type{T}, f::F, mgroup::GM, ngroup::GN, kgroup::GK,
+@inline function plan_request(
+        ::Type{T}, alpha::S, beta::S, mgroup::GM, ngroup::GN, kgroup::GK,
         Astorage::SA, Abase::Int, Bstorage::SB, Bbase::Int, Cstorage::SC, Cbase::Int,
-        run::Int, mc, kc, nc, workspace::WS, allocator::AL, oracle::Bool
-    ) where {T, F, GM, GN, GK, SA, SB, SC, WS, AL}
-    return _PlanRequest{T, F, GM, GN, GK, SA, SB, SC, WS, AL}(
-        f, mgroup, ngroup, kgroup, Astorage, Abase, Bstorage, Bbase, Cstorage, Cbase,
-        run, mc, kc, nc, workspace, allocator, oracle
+        run::Int, m_block, k_block, n_block, allocator::AL, modes::PathModes
+    ) where {T, S, GM, GN, GK, SA, SB, SC, AL}
+    return PlanRequest{T, S, GM, GN, GK, SA, SB, SC, AL}(
+        alpha, beta, mgroup, ngroup, kgroup, Astorage, Abase, Bstorage, Bbase, Cstorage, Cbase,
+        run, m_block, k_block, n_block, allocator, modes
     )
 end
 
-# `plan_contract`'s body, positional, with a continuation `f` applied to the
-# plan inside the barrier, where its type is concrete (the TensorOperations
-# adapter passes an executor).
-function _planned(
-        f::F, C::StridedView, A::StridedView, indA::NTuple{NA, Int},
+# Conjugation: folding `conjA`/`conjB` with each view's `.op`. The engine never
+# indexes through a `StridedView`, so an unfolded `.op` would be silently dropped.
+
+# GUARDRAIL: a TOTAL table with a throwing fallback, not an `op === conj` test,
+# which classifies a directly constructed `adjoint` view as unconjugated.
+op_conjugates(::typeof(identity)) = false
+op_conjugates(::typeof(conj)) = true
+# Elementwise on a `Number`, these are identity/conj; the axes are already resolved.
+op_conjugates(::typeof(transpose)) = false
+op_conjugates(::typeof(adjoint)) = true
+@noinline op_conjugates(f) = throw(
+    ArgumentError(
+        "unsupported StridedView.op $f: QuasiStrided folds a view's `op` into the " *
+            "packing transform and recognizes only identity/conj/transpose/adjoint"
+    )
+)
+
+# GUARDRAIL: `⊻`, not `||`: the flag and the view's `op` are independent
+# conjugations and `conj` is involutive. Always `false` for real `T`, so the
+# real path never gets a `conj` specialization.
+isconj(v::StridedView{T}, flag::Bool) where {T} =
+    (T <: Complex) && (flag ⊻ op_conjugates(v.op))
+
+# `plan_contract`'s body. With `alpha`/`beta` (of the compute type) the plan
+# is executed and released behind the kernel barrier, where its type is
+# concrete, and `nothing` is returned; with `nothing` the plan is returned.
+function planned(
+        C::StridedView, A::StridedView, indA::NTuple{NA, Int},
         B::StridedView, indB::NTuple{NB, Int}, indC::NTuple{NC, Int},
-        kernel, conjA::Bool, conjB::Bool,
-        mc::Union{Int, Nothing}, kc::Union{Int, Nothing}, nc::Union{Int, Nothing},
-        workspace::Union{Nothing, ContractWorkspace}, allocator, oracle::Bool,
-        accumulator::AC
-    ) where {F, NA, NB, NC, AC}
-    T = _compute_type(eltype(A), eltype(B), eltype(C), accumulator)
-    method = _default_method(T, eltype(A), eltype(B))
-    _check_kernel_domain(kernel, eltype(A), eltype(B))
+        alpha::S, beta::S;
+        kernel = nothing, conjA::Bool = false, conjB::Bool = false,
+        m_block::Union{Int, Nothing} = nothing, k_block::Union{Int, Nothing} = nothing,
+        n_block::Union{Int, Nothing} = nothing, allocator = TO.DefaultAllocator(),
+        accumulator::AC = nothing, path_modes::PathModes = PathModes()
+    ) where {NA, NB, NC, S, AC}
+    T = compute_type(eltype(A), eltype(B), eltype(C), accumulator)
+    K = default_kernel_type(T, eltype(A), eltype(B))
+    check_kernel_domain(kernel, eltype(A), eltype(B))
 
     # GUARDRAIL: a conjugated `C` is rejected; the engine writes through to
     # its parent, so there is nowhere to absorb its `op`.
-    _qs_isconj(C, false) && throw(
+    isconj(C, false) && throw(
         ArgumentError(
             "plan_contract: cannot write into a conjugated view (C has op $(C.op)); " *
                 "writing a conjugated output is not supported"
         )
     )
-    atransform = _qs_isconj(A, conjA) ? conj : identity
-    btransform = _qs_isconj(B, conjB) ? conj : identity
+    (Base.mightalias(C, A) || Base.mightalias(C, B)) &&
+        throw(ArgumentError("plan_contract: C must not share memory with A or B"))
+    atransform = isconj(A, conjA) ? conj : identity
+    btransform = isconj(B, conjB) ? conj : identity
 
-    mlabels, nlabels, klabels = _classify_labels(indA, indB, indC)
+    mlabels, nlabels, klabels = classify_labels(indA, indB, indC)
 
-    morder = _order_free_labels(mlabels, indC, C)
-    norder = _order_free_labels(nlabels, indC, C)
+    morder = order_free_labels(mlabels, indC, C)
+    norder = order_free_labels(nlabels, indC, C)
 
     # Only real `T` swaps and only real kernels run-demote; `0` is a placeholder.
-    run_m = T <: Real || method isa _MixedMethod ? _leading_unit_run(morder, indC, C) : 0
-    run_n = T <: Real ? _leading_unit_run(norder, indC, C) : 0
+    run_m = T <: Real || K isa MixedKernel ? leading_unit_run(morder, indC, C) : 0
+    run_n = T <: Real ? leading_unit_run(norder, indC, C) : 0
 
-    mgroup = _build_pair_group(morder, indA, A, indC, C)  # maps: (A, C)
-    ngroup = _build_pair_group(norder, indB, B, indC, C)  # maps: (B, C)
+    mgroup = AxisGroup(morder, (indA, A), (indC, C))  # maps: (A, C)
+    ngroup = AxisGroup(norder, (indB, B), (indC, C))  # maps: (B, C)
 
-    Qm = axis_length(mgroup)
-    Qn = axis_length(ngroup)
+    m_length = axis_length(mgroup)
+    n_length = axis_length(ngroup)
 
-    korder = _order_contract_labels(klabels, indA, A, morder, indB, B, norder, Qm, Qn)
-    kgroup = _build_pair_group(korder, indA, A, indB, B)  # maps: (A, B)
+    korder = order_contract_labels(klabels, indA, A, morder, indB, B, norder, m_length, n_length)
+    kgroup = AxisGroup(korder, (indA, A), (indB, B))  # maps: (A, B)
 
-    Qk = axis_length(kgroup)
+    k_length = axis_length(kgroup)
 
-    mr_asis, mr_swapped = _candidate_mrs(T, method, kernel, Qm, Qn, run_m, run_n)
+    m_tile_asis, m_tile_swapped = candidate_m_tiles(T, K, kernel, m_length, n_length, run_m, run_n)
 
-    if T <: Real && _prefer_swap(run_m, run_n, mr_asis, mr_swapped)
+    if T <: Real && prefer_swap(run_m, run_n, m_tile_asis, m_tile_swapped)
         # B takes the M role: groups, K maps, storages, run and transforms move
         # together; the sum is unchanged.
-        kgroup_swapped = _build_pair_group(korder, indB, B, indA, A)  # maps: (B, A)
-        req_swapped = _plan_request(
-            T, f, ngroup, mgroup, kgroup_swapped,
+        kgroup_swapped = AxisGroup(korder, (indB, B), (indA, A))  # maps: (B, A)
+        req_swapped = plan_request(
+            T, alpha, beta, ngroup, mgroup, kgroup_swapped,
             parent(B), offset(B), parent(A), offset(A), parent(C), offset(C),
-            run_n, mc, kc, nc, workspace, allocator, oracle
+            run_n, m_block, k_block, n_block, allocator, path_modes
         )
-        return _plan_with_kernel(kernel, method, btransform, atransform, req_swapped)
+        return plan_with_kernel(kernel, K, btransform, atransform, req_swapped)
     end
-    req = _plan_request(
-        T, f, mgroup, ngroup, kgroup,
+    req = plan_request(
+        T, alpha, beta, mgroup, ngroup, kgroup,
         parent(A), offset(A), parent(B), offset(B), parent(C), offset(C),
-        run_m, mc, kc, nc, workspace, allocator, oracle
+        run_m, m_block, k_block, n_block, allocator, path_modes
     )
-    return _plan_with_kernel(kernel, method, atransform, btransform, req)
+    return plan_with_kernel(kernel, K, atransform, btransform, req)
 end
 
-const _QS_ELTYPES = (Float32, Float64, ComplexF32, ComplexF64)
+const SUPPORTED_ELTYPES = (Float32, Float64, ComplexF32, ComplexF64)
 
 # A named mixed-domain kernel's `RealFormat` side packs a real operand only.
-@inline _check_kernel_domain(kernel, ::Type, ::Type) = nothing
-@inline _check_kernel_domain(kernel::ComplexRealKernel, ::Type, ::Type{TB}) where {TB} =
-    TB <: Real || _throw_kernel_domain(kernel, "B", TB)
-@inline _check_kernel_domain(kernel::RealComplexKernel, ::Type{TA}, ::Type) where {TA} =
-    TA <: Real || _throw_kernel_domain(kernel, "A", TA)
+@inline check_kernel_domain(kernel, ::Type, ::Type) = nothing
+@inline check_kernel_domain(kernel::ComplexRealKernel, ::Type, ::Type{TB}) where {TB} =
+    TB <: Real || throw_kernel_domain(kernel, "B", TB)
+@inline check_kernel_domain(kernel::RealComplexKernel, ::Type{TA}, ::Type) where {TA} =
+    TA <: Real || throw_kernel_domain(kernel, "A", TA)
 
-@noinline _throw_kernel_domain(kernel, side, T) = throw(
+@noinline throw_kernel_domain(kernel, side, T) = throw(
     ArgumentError("plan_contract: $(typeof(kernel)) needs a real $side, got eltype $T")
 )
 
 # Fold to the compute type, or a throw, at compile time.
-@inline function _compute_type(::Type{TA}, ::Type{TB}, ::Type{TC}, ::Nothing) where {TA, TB, TC}
-    (TA in _QS_ELTYPES && TB in _QS_ELTYPES && TC in _QS_ELTYPES) ||
-        _throw_eltypes(TA, TB, TC)
-    (TC <: Real && !(TA <: Real && TB <: Real)) && _throw_complex_into_real(TA, TB, TC)
+@inline function compute_type(::Type{TA}, ::Type{TB}, ::Type{TC}, ::Nothing) where {TA, TB, TC}
+    (TA in SUPPORTED_ELTYPES && TB in SUPPORTED_ELTYPES && TC in SUPPORTED_ELTYPES) ||
+        throw_eltypes(TA, TB, TC)
+    (TC <: Real && !(TA <: Real && TB <: Real)) && throw_complex_into_real(TA, TB, TC)
     return promote_type(TA, TB, TC)
 end
-@inline _compute_type(::Type{TA}, ::Type{TB}, ::Type{TC}, ::Type{R}) where {TA, TB, TC, R <: Union{Float32, Float64}} =
-    _compute_type(TA, TB, TC, nothing) <: Complex ? Complex{R} : R
+@inline compute_type(::Type{TA}, ::Type{TB}, ::Type{TC}, ::Type{R}) where {TA, TB, TC, R <: Union{Float32, Float64}} =
+    compute_type(TA, TB, TC, nothing) <: Complex ? Complex{R} : R
 
-@noinline _throw_eltypes(TA, TB, TC) = throw(
+@noinline throw_eltypes(TA, TB, TC) = throw(
     ArgumentError(
         "plan_contract: eltypes (A, B, C) = ($TA, $TB, $TC); each must be one of " *
             "Float32, Float64, ComplexF32, ComplexF64"
     )
 )
-@noinline _throw_complex_into_real(TA, TB, TC) = throw(
+@noinline throw_complex_into_real(TA, TB, TC) = throw(
     ArgumentError("plan_contract: a complex operand (A: $TA, B: $TB) needs a complex C, got $TC")
 )
 
-# `mr` of the kernel each orientation would run, for the swap decision: a named
-# kernel either way, else `_default_shape`'s pick at that orientation's extents
-# and C run.
-@inline _candidate_mrs(::Type{T}, method, kernel, Qm::Int, Qn::Int, run_m::Int, run_n::Int) where {T} =
-    (mr(kernel), mr(kernel))
-@inline function _candidate_mrs(::Type{T}, method, ::Nothing, Qm::Int, Qn::Int, run_m::Int, run_n::Int) where {T}
-    mr_asis = _default_shape(T, method, Qm, Qn, run_m)[1][1]
-    mr_swapped = T <: Real ? _default_shape(T, method, Qn, Qm, run_n)[1][1] : mr_asis
-    return mr_asis, mr_swapped
+# `m_tile` of the kernel each orientation would run, for the swap decision: a
+# named kernel either way, else `select_shape`'s pick at that orientation's
+# extent and C run. The swap is judged before `fit_to_run`'s K-dependent
+# divisor step, which an unbounded `k_length` skips.
+@inline candidate_m_tiles(::Type{T}, ::Type, kernel, m_length::Int, n_length::Int, run_m::Int, run_n::Int) where {T} =
+    (tile_size(kernel, 1), tile_size(kernel, 1))
+@inline function candidate_m_tiles(::Type{T}, ::Type{K}, ::Nothing, m_length::Int, n_length::Int, run_m::Int, run_n::Int) where {T, K}
+    m_tile_asis = select_shape(T, K, m_length, typemax(Int), run_m)[1][1]
+    m_tile_swapped = T <: Real ? select_shape(T, K, n_length, typemax(Int), run_n)[1][1] : m_tile_asis
+    return m_tile_asis, m_tile_swapped
 end
 
 # Kernel resolution. A named kernel goes straight through, never demoted. An
-# automatic one is chosen as a `(shape, method)` value and the plan is built
-# across a dispatch barrier specialised on that one shape, so only the chosen
-# kernel's code is compiled (holding the menu-wide kernel Union would box the
-# request; a static ladder would compile every menu kernel). All barrier
-# arguments are singletons or heap objects: 0 B, one method-cache hit.
-@inline _plan_with_kernel(kernel, method, atransform, btransform, req::_PlanRequest) =
-    _plan_contract(kernel, atransform, btransform, req, nothing)
-@inline function _plan_with_kernel(::Nothing, method, atransform, btransform, req::_PlanRequest{T}) where {T}
-    Qm = axis_length(req.mgroup)
-    shape, method = _default_shape(T, method, Qm, axis_length(req.ngroup), req.run)
-    shape = _demote_shape_for_run(T, shape, method, req.run, Qm, axis_length(req.kgroup))
-    vshape = _menu_val(shape, T, method)
-    # The execution path, predicted so the callee is specialised on it. Only a
-    # `Bool` crosses: a call union-split on `method` is emitted out of line and
-    # boxes `req`.
-    hint = _path_hint(req.f, req, _unpacked_b_method_eligible(method))
-    core = _strip_storage(req)
-    slot = _barrier_slot!(req.workspace, typeof(core))
-    slot[] = core
-    return Base.inferencebarrier(_plan_resolved)(
-        vshape, method, atransform, btransform, hint, slot,
-        req.Astorage, req.Bstorage, req.Cstorage
-    )
+# automatic one is chosen as a `(shape, kernel type)` value. The blocking and
+# execution path follow from the kernel type and tile, so they are resolved
+# here, before the kernel exists; the plan is then built across a dispatch
+# barrier specialised on the one concrete kernel and path, so only their code
+# is compiled (holding the menu-wide kernel Union would box the request; a
+# static ladder would compile every menu kernel). All barrier arguments are
+# singletons or heap objects (the request in a `Ref`): one method-cache hit.
+@inline function plan_with_kernel(kernel, ::Type, atransform, btransform, req::PlanRequest{T}) where {T}
+    scalartype(kernel) === T ||
+        throw(ArgumentError("kernel scalar type $(scalartype(kernel)) does not match the compute type $T"))
+    return plan_across_barrier(kernel, typeof(kernel), tile_size(kernel)..., atransform, btransform, req)
 end
-
-function _plan_resolved(
-        ::Val{S}, method::M, atransform::TA, btransform::TB, hint::H,
-        slot::Base.RefValue{R}, Astorage::SA, Bstorage::SB, Cstorage::SC
-    ) where {S, M, TA, TB, H, T, R <: _PlanRequest{T}, SA, SB, SC}
-    req = _with_storage(slot[], Astorage, Bstorage, Cstorage)
-    return _plan_contract(_kernel_from_shape(S, T, method), atransform, btransform, req, hint)
+@inline function plan_with_kernel(::Nothing, ::Type{K}, atransform, btransform, req::PlanRequest{T}) where {K, T}
+    shape, kernel_type = select_shape(T, K, axis_length(req.mgroup), axis_length(req.kgroup), req.run)
+    return plan_at_shape(shape, kernel_type, atransform, btransform, req)
 end
 
-# The storages cross the barrier as arguments, so no slot retains a user array.
-@inline _strip_storage(req::_PlanRequest{T}) where {T} = _plan_request(
-    T, req.f, req.mgroup, req.ngroup, req.kgroup,
-    nothing, req.Abase, nothing, req.Bbase, nothing, req.Cbase,
-    req.run, req.mc, req.kc, req.nc, req.workspace, req.allocator, req.oracle
-)
-@inline _with_storage(req::_PlanRequest{T}, Astorage, Bstorage, Cstorage) where {T} = _plan_request(
-    T, req.f, req.mgroup, req.ngroup, req.kgroup,
-    Astorage, req.Abase, Bstorage, req.Bbase, Cstorage, req.Cbase,
-    req.run, req.mc, req.kc, req.nc, req.workspace, req.allocator, req.oracle
-)
-
-# `nothing` for a continuation that does not execute (see src/execution/execute.jl).
-@inline _path_hint(f, req::_PlanRequest, unpack_ok::Bool) = nothing
-
-# Plan construction on a concrete kernel and transform pair (a named kernel's
-# transform Unions die here). `req.f` runs in here, on the concrete plan type.
-function _plan_contract(
-        kernel::K, atransform::TA, btransform::TB, req::_PlanRequest{T}, hint::H
-    ) where {K, TA, TB, T, H}
-    scalartype(kernel) === T ||
-        throw(ArgumentError("kernel scalar type $(scalartype(kernel)) does not match the compute type $T"))
+# Nothing here is called on the kernel `Val`: a call union-split on the kernel
+# type is emitted out of line and boxes `req`.
+@inline plan_at_shape(shape, ::Val{K}, atransform, btransform, req::PlanRequest{T}) where {K, T} =
+    plan_across_barrier(menu_val(shape, T, K), K, shape[1], shape[2], atransform, btransform, req)
+
+@inline function plan_across_barrier(
+        kernel, ::Type{K}, m_tile::Int, n_tile::Int, atransform, btransform, req::PlanRequest
+    ) where {K}
+    resolved = resolve_blocking(K, m_tile, n_tile, req)
+    path = select_path(K, req, resolved)
+    return Base.inferencebarrier(build_plan)(
+        kernel, path, atransform, btransform, Base.RefValue((req, resolved))
+    )
+end
 
-    Qm = axis_length(req.mgroup)
-    Qn = axis_length(req.ngroup)
-    Qk = axis_length(req.kgroup)
+# The effective blocking for a kernel of type `K` with an `m_tile x n_tile`
+# tile, its line-by-line packing (`mpack`/`npack`) and whether partial sums
+# live in a panel of C (`panel`).
+function resolve_blocking(::Type{K}, m_tile::Int, n_tile::Int, req::PlanRequest{T}) where {K, T}
+    m_length = axis_length(req.mgroup)
+    n_length = axis_length(req.ngroup)
+    k_length = axis_length(req.kgroup)
 
-    defaults = default_blocking(kernel)
-    mc, kc, nc = req.mc, req.kc, req.nc
+    defaults = kernel_blocking(target_profile(), T, K, m_tile, n_tile)
     requested = Blocking(
-        mc === nothing ? defaults.mc : mc,
-        kc === nothing ? defaults.kc : kc,
-        nc === nothing ? defaults.nc : nc
+        something(req.m_block, defaults.m_block),
+        something(req.k_block, defaults.k_block),
+        something(req.n_block, defaults.n_block)
     )
 
-    MRk = mr(kernel)
-    NRk = nr(kernel)
-
     # Empty extents: the drivers never read these; the floors keep them valid.
-    mc_rounded = _roundup(requested.mc, MRk)
-    nc_rounded = _roundup(requested.nc, NRk)
-    mc_eff = Qm == 0 ? MRk : min(mc_rounded, _roundup(Qm, MRk))
-    nc_eff = Qn == 0 ? NRk : min(nc_rounded, _roundup(Qn, NRk))
-    kc_eff = Qk == 0 ? 1 : min(requested.kc, Qk)
-    panel = _c_panel_needed(T, req.Cstorage, Qk, kc_eff)
-    mpack = npack = _NO_SPLIT
+    m_block_rounded = roundup(requested.m_block, m_tile)
+    n_block_rounded = roundup(requested.n_block, n_tile)
+    m_block = m_length == 0 ? m_tile : min(m_block_rounded, roundup(m_length, m_tile))
+    n_block = n_length == 0 ? n_tile : min(n_block_rounded, roundup(n_length, n_tile))
+    k_block = k_length == 0 ? 1 : min(requested.k_block, k_length)
+    panel = c_panel_needed(T, req.Cstorage, k_length, k_block)
+    mpack = npack = NO_SPLIT
     # Cache lines hold each operand's storage eltype, and the block walk costs
     # what its packed format's scatter does. B is not split under a panel of C:
-    # the panel holds `jc` blocks in C's own N order, which a split N group does
+    # the panel holds N blocks in C's own N order, which a split N group does
     # not enumerate contiguously.
-    if Qm > 0 && Qn > 0 && Qk > 0
-        mc_eff, mpack = _pack_split(
-            req.mgroup, req.kgroup, 1, MRk, sizeof(eltype(req.Astorage)),
-            !(a_format(kernel) isa RealFormat), kc_eff, mc_eff, mc_rounded, requested.kc
+    if m_length > 0 && n_length > 0 && k_length > 0
+        a_format, b_format = pack_formats(K)
+        m_block, mpack = pack_split(
+            req.mgroup, req.kgroup, 1, m_tile, a_format, sizeof(eltype(req.Astorage)),
+            k_block, m_block, m_block_rounded, requested.k_block
         )
         if !panel
-            nc_eff, npack = _pack_split(
-                req.ngroup, req.kgroup, 2, NRk, sizeof(eltype(req.Bstorage)),
-                !(b_format(kernel) isa RealFormat), kc_eff, nc_eff, nc_rounded, requested.kc
+            n_block, npack = pack_split(
+                req.ngroup, req.kgroup, 2, n_tile, b_format, sizeof(eltype(req.Bstorage)),
+                k_block, n_block, n_block_rounded, requested.k_block
             )
         end
     end
-    blocking = Blocking(mc_eff, kc_eff, nc_eff)
-    ws = _resolve_workspace(
-        T, req.workspace, kernel, blocking, req.oracle, req.allocator, panel ? Qm * min(nc_eff, Qn) : 0
-    )
+    return (blocking = Blocking(m_block, k_block, n_block), mpack, npack, panel)
+end
+
+# Whether the partial sums between K blocks must live in a compute-type panel
+# rather than in a C of narrower eltype. Static `false` unless C is narrower.
+@inline function c_panel_needed(::Type{T}, Cstorage, k_length::Int, k_block::Int) where {T}
+    sizeof(real(eltype(Cstorage))) < sizeof(real(T)) || return false
+    return k_length > k_block
+end
+
+# The path `execute!` runs for a nonzero `alpha`: none for an empty C, scaling C
+# for an empty K, else the dot path, the outer-product path or the nest (B
+# packed or read in place).
+function select_path(::Type{K}, req::PlanRequest{T}, resolved) where {K, T}
+    (; mgroup, ngroup, kgroup, modes) = req
+    (; mpack, npack, panel) = resolved
+    m_length = axis_length(mgroup)
+    n_length = axis_length(ngroup)
+    k_length = axis_length(kgroup)
+    (m_length == 0 || n_length == 0) && return EmptyPath()
+    k_length == 0 && return ScalePath()
+    W = vector_lanes(target_profile(), real(T))
+    if !panel && modes.dot !== :never &&
+            dot_applicable(T, req.Astorage, req.Bstorage, kgroup, m_length, n_length, k_length, W)
+        return m_length == 1 ? lane_path(DotPath{true}, W) : lane_path(DotPath{false}, W)
+    end
+    k_length == 1 && modes.outer !== :never && outer_applicable(T, req.Astorage, req.Cstorage, mgroup, m_length, W) &&
+        return lane_path(OuterPath, W)
+    unpacked_b = reads_b_by_element(K) && unpacked_b_rule(modes.unpacked_b, mgroup, kgroup)
+    return nest_path(unpacked_b, mgroup, ngroup, kgroup, is_split(mpack), is_split(npack), panel)
+end
 
+# The dot path (dot.jl): a degenerate free extent, a matrix operand with
+# unit-ramp K in dense storage (raw-pointer loads), and at least one vector
+# (`W` lanes) of K.
+function dot_applicable(::Type{T}, Astorage, Bstorage, kgroup::AxisGroup, m_length::Int, n_length::Int, k_length::Int, W::Int) where {T}
+    (m_length == 1 || n_length == 1) || return false
+    k_length >= W || return false
+    if m_length == 1
+        Bstorage isa DenseVector{T} || return false
+        map_ramp_step(kgroup, 2) == 1 || return false
+    else
+        Astorage isa DenseVector{T} || return false
+        map_ramp_step(kgroup, 1) == 1 || return false
+    end
+    return true
+end
+
+# The outer-product path (outer.jl): real `T`, dense A and C with M a unit
+# ramp in both, at least one vector of M. N and B may have any layout.
+function outer_applicable(::Type{T}, Astorage, Cstorage, mgroup::AxisGroup, m_length::Int, W::Int) where {T}
+    T <: Real || return false
+    (Astorage isa DenseVector{T} && Cstorage isa DenseVector{T}) || return false
+    m_length >= W || return false
+    map_ramp_step(mgroup, 1) == 1 || return false
+    return map_ramp_step(mgroup, 2) == 1
+end
+
+# Whether B is read in place (given a kernel that reads B by element): small
+# M, and every B column contiguous along K. Packing pays off only through
+# reuse across M slivers, while `n_tile` contiguous columns read in place cost
+# the kernel nothing. A large K stride in B (each step its own cache line, and
+# for a power of two only a few L1 sets) is what packing exists for. `mode`:
+# `:always`/`:never` override the rule (`PathModes`).
+@inline function unpacked_b_rule(mode::Symbol, mgroup::AxisGroup, kgroup::AxisGroup)
+    mode === :always && return true
+    mode === :never && return false
+    axis_length(mgroup) <= UNPACKED_B_MMAX || return false
+    (k_ramp, k_step) = affine_ramp(kgroup)
+    return k_ramp && abs(k_step[2]) == 1
+end
+
+# Beyond this M the packed B's reuse wins.
+const UNPACKED_B_MMAX = 256
+
+# Type parameters on the transforms force specialisation on them: the
+# compiler does not specialise on a `Function` argument it only passes on.
+build_plan(::Val{Kern}, path, atransform::TA, btransform::TB, slot::Base.RefValue) where {Kern, TA, TB} =
+    build_plan(Kern(), path, atransform, btransform, slot)
+
+# The plan on a concrete kernel, path and transform pair (a named kernel's
+# transform Unions die here).
+function build_plan(
+        kernel::Microkernel, path::P, atransform::TA, btransform::TB, slot::Base.RefValue{R}
+    ) where {P, TA, TB, R}
+    T = scalartype(kernel)
+    req, (; blocking, mpack, npack, panel) = slot[]
+    panel_length = panel ? axis_length(req.mgroup) * min(blocking.n_block, axis_length(req.ngroup)) : 0
+    ws = ContractWorkspace(T, kernel, blocking; allocator = req.allocator, panel = panel_length, path)
     plan = ContractPlan(
-        kernel, req.mgroup, req.ngroup, req.kgroup, blocking,
+        kernel, path, req.mgroup, req.ngroup, req.kgroup, blocking,
         req.Astorage, req.Abase, req.Bstorage, req.Bbase, req.Cstorage, req.Cbase,
         atransform, btransform, ws, mpack, npack
     )
-    return _continue(req.f, plan, hint)
+    return execute_request(plan, req.alpha, req.beta, req.allocator)
+end
+
+execute_request(plan::ContractPlan, ::Nothing, ::Nothing, allocator) = plan
+function execute_request(plan::ContractPlan{T}, alpha::T, beta::T, allocator) where {T}
+    execute!(plan, alpha, beta)
+    release!(plan, allocator)
+    return nothing
 end
 
-# `hint` is used only by an executing continuation (src/execution/execute.jl).
-@inline _continue(f::F, plan::ContractPlan, hint) where {F} = f(plan)
+release!(plan::ContractPlan, allocator) = release!(plan.workspace, allocator)
diff --git a/test/execution/helpers.jl b/test/execution/helpers.jl
new file mode 100644
index 0000000..c00c4c3
--- /dev/null
+++ b/test/execution/helpers.jl
@@ -0,0 +1,124 @@
+# Fixtures, references and path predicates shared by the execution test files.
+
+include("../helpers.jl")
+
+# Brute-force reference over every label assignment; knows nothing of plans.
+function _brute_ref(A, indA, B, indB, Cstart, indC, alpha, beta; conjA = false, conjB = false)
+    dims = Dict{Int, Int}()
+    for (l, L) in zip(indA, size(A))
+        dims[l] = L
+    end
+    for (l, L) in zip(indB, size(B))
+        dims[l] = L
+    end
+    klabels = Tuple(l for l in indA if l in indB && !(l in indC))
+    ksizes = Tuple(dims[l] for l in klabels)
+    T = eltype(Cstart)
+    out = similar(Cstart, T)
+    for Ic in CartesianIndices(Cstart)
+        at = Dict{Int, Int}(zip(indC, Tuple(Ic)))
+        acc = zero(T)
+        for Ik in CartesianIndices(ksizes)
+            for (l, i) in zip(klabels, Tuple(Ik))
+                at[l] = i
+            end
+            a = A[(at[l] for l in indA)...]
+            b = B[(at[l] for l in indB)...]
+            acc += (conjA ? conj(a) : a) * (conjB ? conj(b) : b)
+        end
+        out[Ic] = iszero(beta) ? alpha * acc : alpha * acc + beta * Cstart[Ic]
+    end
+    return out
+end
+
+# The reference result for the fixture `mk()`.
+function _ref_of(mk, alpha, beta; kw...)
+    Cv, Av, iA, Bv, iB, iC = mk()
+    return _brute_ref(Array(Av), iA, Array(Bv), iB, Array(Cv), iC, alpha, beta; kw...)
+end
+
+# Plan a fresh fixture `mk()` and run `run!` on it. Returns C and the plan.
+function _run_fresh(run!, mk, alpha, beta; plankw...)
+    Cv, Av, iA, Bv, iB, iC = mk()
+    plan = plan_contract(Cv, Av, iA, Bv, iB, iC; plankw...)
+    @test run!(plan, alpha, beta) === plan.Cstorage
+    return Array(Cv), plan
+end
+
+# `_run_fresh` planned onto the nest with B packed, through the path modes the
+# benchmarks use: the baseline for the dedicated paths.
+const NEST_ONLY = QuasiStrided.PathModes(dot = :never, outer = :never, unpacked_b = :never)
+_run_nest(mk, alpha, beta; plankw...) = _run_fresh(execute!, mk, alpha, beta; path_modes = NEST_ONLY, plankw...)
+
+_lanes(T) = QuasiStrided.vector_lanes(QuasiStrided.target_profile(), real(T))
+
+# A DenseMatrix that is not a DenseVector: a plan keeps it as storage, so paths
+# that need raw-pointer loads must decline it.
+struct _WrappedMat{T} <: DenseMatrix{T}
+    data::Matrix{T}
+end
+Base.size(a::_WrappedMat) = size(a.data)
+Base.IndexStyle(::Type{<:_WrappedMat}) = IndexLinear()
+Base.getindex(a::_WrappedMat, i::Int) = a.data[i]
+Base.setindex!(a::_WrappedMat, v, i::Int) = (a.data[i] = v)
+
+# `M` as a StridedView with the same values and a chosen layout of its first
+# axis. Gaps in padded parents are NaN, so reading one poisons C.
+function _view_as(M::Matrix{T}, layout::Symbol) where {T}
+    m, n = size(M)
+    layout === :dense && return StridedView(M)
+    layout === :transposed && return permutedims(StridedView(permutedims(M, (2, 1))), (2, 1))
+    layout === :wrapped && return StridedView(_WrappedMat(copy(M)), (m, n), (1, m), 0)
+    big = fill(convert(T, NaN), 2m + 4, n)
+    rows = layout === :offset ? (3:(m + 2)) : layout === :gap ? (1:2:(2m)) :
+        layout === :reversed ? ((m + 2):-1:3) : error("unknown layout $layout")
+    big[rows, :] .= M
+    return StridedView(view(big, rows, :))
+end
+
+# `C[m,n] = A[m,k] B[k,n]` with chosen layouts for A and B, seeded so every call
+# reproduces the same values. `ABfill` poisons both operands.
+function _mm_maker(::Type{T}, M, K, N, seed; A = :dense, B = :dense, Cfill = nothing, ABfill = nothing) where {T}
+    return function ()
+        rng = MersenneTwister(seed)
+        Amat = ABfill === nothing ? randn(rng, T, M, K) : fill(convert(T, ABfill), M, K)
+        Bmat = ABfill === nothing ? randn(rng, T, K, N) : fill(convert(T, ABfill), K, N)
+        Cmat = Cfill === nothing ? randn(rng, T, M, N) : fill(convert(T, Cfill), M, N)
+        return (StridedView(Cmat), _view_as(Amat, A), (1, 2), _view_as(Bmat, B), (2, 3), (1, 3))
+    end
+end
+
+_dot_takes(plan) = _path_of(plan) isa QuasiStrided.DotPath
+_ub_takes(plan) = _path_of(plan) isa QuasiStrided.NestPath{true}
+_outer_takes(plan) = _path_of(plan) isa QuasiStrided.OuterPath
+
+# `C[a, b] = A[a] * B[b]` at extents `(M, N)`:
+#   :bstrided  B every other element of a longer vector
+#   :cpermC    C stored [b, a] (M not unit-stride in C)
+#   :agap      A every other element (M not unit-stride in A)
+#   :coffset   C a view with an offset, M unit-stride
+#   :multiM    M a composite of two labels that fold to one ramp
+function _outer_maker(::Type{T}, M, N, seed; variant = :plain, Cfill = nothing) where {T}
+    return function ()
+        rng = MersenneTwister(seed)
+        a, b = randn(rng, T, M), randn(rng, T, N)
+        C = Cfill === nothing ? randn(rng, T, M, N) : fill(convert(T, Cfill), M, N)
+        gapped(v, r) = (big = fill(convert(T, NaN), 2 * length(v)); big[r] .= v; StridedView(view(big, r)))
+        Av = variant === :agap ? gapped(a, 1:2:(2M)) : StridedView(a)
+        Bv = variant === :bstrided ? gapped(b, 2:2:(2N)) : StridedView(b)
+        variant === :multiM &&
+            return (StridedView(reshape(C, 4, M ÷ 4, N)), StridedView(reshape(a, 4, M ÷ 4)), (1, 2), Bv, (3,), (1, 2, 3))
+        Cv = if variant === :cpermC
+            permutedims(StridedView(permutedims(C, (2, 1))), (2, 1))
+        elseif variant === :coffset
+            big = fill(convert(T, NaN), M + 3, N + 2)
+            big[2:(M + 1), 2:(N + 1)] .= C
+            StridedView(view(big, 2:(M + 1), 2:(N + 1)))
+        else
+            StridedView(C)
+        end
+        return (Cv, Av, (1,), Bv, (2,), (1, 2))
+    end
+end
+
+const CR, RC = QuasiStrided.ComplexRealKernel, QuasiStrided.RealComplexKernel
diff --git a/test/execution/test_c_panel.jl b/test/execution/test_c_panel.jl
new file mode 100644
index 0000000..f4d1ee9
--- /dev/null
+++ b/test/execution/test_c_panel.jl
@@ -0,0 +1,41 @@
+# The C panel: partial sums of a narrower C stay in the compute type across K blocks.
+
+include("helpers.jl")
+
+# Along K, 1, 2^-30 and -1 fall in different K blocks: the 2^-30 and the small
+# beta*C survive only if the partial sums stay in the compute type between blocks.
+@testset "one rounding to $TC across K blocks: $TA x $TB, M = $M, $case, beta = $beta" for (TA, TB, TC, acc, M, N, K, case, beta) in (
+        (Float64, Float64, Float32, nothing, 13, 40, 20, :manual_n_block_16, 0.5),
+        (Float32, Float32, Float32, Float64, 13, 9, 20, :packed_b, 1),
+        (Float64, ComplexF64, ComplexF32, nothing, 13, 9, 20, :strided_c, 0.5),
+        (Float32, Float32, Float32, Float64, 7, 5, 3000, :backend, 0),
+        (Float64, Float64, Float32, nothing, 1, 9, 20, :strided_c, 1),
+        (Float64, Float64, Float32, nothing, 13, 9, 20, :strided_c, 0),
+    )
+    b = TB <: Complex ? TB(1, 1) : one(TB)
+    A = zeros(TA, M, K)
+    A[:, 1] .= 1
+    A[:, K ÷ 2 + 1] .= 2.0^-30
+    A[:, K] .= -1
+    Av, Bv = StridedView(A), StridedView(fill(b, K, N))
+    case === :packed_b && (Bv = permutedims(StridedView(permutedims(Array(Bv))), (2, 1)))
+    Cv = case === :strided_c ? StridedView(zeros(TC, 2M, 3N))[2:2:2M, 1:3:3N] : StridedView(zeros(TC, M, N))
+    fill!(Cv, iszero(beta) ? NaN : 2.0^-28)
+    if case === :backend
+        @test K ÷ 2 > default_blocking(auto_kernel(Float64, M)).k_block
+        backend = QuasiStrided.QuasiStridedBackend(accumulator = acc)
+        TO.tensorcontract!(Cv, Av, ((1,), (2,)), false, Bv, ((1,), (2,)), false, ((1, 2), ()), 1, beta, backend)
+    else
+        allocator = case === :manual_n_block_16 ? TO.ManualAllocator() : TO.DefaultAllocator()
+        n_block = case === :manual_n_block_16 ? 16 : nothing
+        plan = plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3); accumulator = acc, k_block = 4, n_block, allocator)
+        @test _path_of(plan) isa QuasiStrided.PanelPath
+        @test axis_length(plan.mgroup) == M
+        case === :manual_n_block_16 && @test N > plan.blocking.n_block && !(plan.workspace.c_panel isa Vector)
+        case === :packed_b && @test _path_of(plan) isa QuasiStrided.PanelPath{<:QuasiStrided.NestPath{false}}
+        TB <: Complex && @test plan.kernel isa RC
+        execute!(plan, 1, beta)
+        QuasiStrided.release!(plan.workspace, allocator)
+    end
+    @test all(==(TC(2.0^-30 * b + beta * 2.0^-28)), Array(Cv))
+end
diff --git a/test/execution/test_dot.jl b/test/execution/test_dot.jl
index 0b9d421..f2cbf0d 100644
--- a/test/execution/test_dot.jl
+++ b/test/execution/test_dot.jl
@@ -1,10 +1,10 @@
 # The dot-product path: `execute!` on `M == 1` or `N == 1` with a K-contiguous
-# matrix operand runs a K-vectorized gemv. Results match the nest and the
-# reference to a tolerance (the K summation order differs).
+# matrix operand runs a K-vectorized gemv. Results match the reference to a
+# tolerance (the K summation order differs).
 
-_dot_takes(plan) = _path_of(plan) isa QuasiStrided._DotPath
+include("helpers.jl")
 
-const _DOT_TYPES = (Float64, Float32, ComplexF64, ComplexF32)
+const DOT_TYPES = (Float64, Float32, ComplexF64, ComplexF32)
 
 # `C[cde] = A[ab] * B[abcde]` (M = 1, matrix B K-fastest) at leg dimension `d`:
 #   :permvec  A stored [b,a]: the vector's K map is not a ramp (the matrix's is)
@@ -34,17 +34,15 @@ _dot_n1_maker(::Type{T}, d, K, seed) where {T} = function ()
     return (StridedView(randn(rng, T, d, d)), StridedView(randn(rng, T, K, d, d)), (3, 1, 2), StridedView(randn(rng, T, K)), (3,), (1, 2))
 end
 
-# The dot path against the nest and the reference.
+# The dot path against the reference.
 function _dot_check(mk, alpha, beta; conjA = false, conjB = false, plankw...)
     C_dot, plan = _run_fresh(execute!, mk, alpha, beta; conjA, conjB, plankw...)
-    C_nest, _ = _run_fresh(_run_nest!, mk, alpha, beta; conjA, conjB, plankw...)
     @test _dot_takes(plan)
-    @test C_dot ≈ C_nest
     return @test C_dot ≈ _ref_of(mk, alpha, beta; conjA, conjB)
 end
 
-@testset "dot path: which plans it takes ($T)" for T in _DOT_TYPES
-    W = QuasiStrided._dot_lanewidth(T)
+@testset "dot path: which plans it takes ($T)" for T in DOT_TYPES
+    W = _lanes(T)
     for variant in (:plain, :permvec, :permC, :offsetB)
         @test _dot_takes(plan_contract(_dot_gemv_maker(T, 4, 1; variant)()...))
     end
@@ -60,20 +58,20 @@ end
     end
 end
 
-@testset "dot path: matches the nest and the reference ($T)" for T in _DOT_TYPES
+@testset "dot path: matches the reference ($T)" for T in DOT_TYPES
     ab = ((1.0, 0.0), (2.5, -0.75), (1.0, 1.0))
     for d in (2, 6), variant in (:plain, :permvec, :permC, :offsetB), (alpha, beta) in ab
         mk = _dot_gemv_maker(T, d, 10 * d; variant)
-        if d * d >= QuasiStrided._dot_lanewidth(T)
+        if d * d >= _lanes(T)
             _dot_check(mk, alpha, beta)
         else
             @test !_dot_takes(plan_contract(mk()...))
         end
     end
-    # N = 1: K tails, several K blocks (`kc = 64`) and output blocks (`mc = 7`).
-    W = QuasiStrided._dot_lanewidth(T)
+    # N = 1: K tails, several K blocks (`k_block = 64`) and output blocks (`m_block = 7`).
+    W = _lanes(T)
     for (d, K) in ((3, W), (5, 3W - 1), (2, 1000)), (alpha, beta) in ab
-        _dot_check(_dot_n1_maker(T, d, K, 3K + d), alpha, beta; kc = 64, mc = 7)
+        _dot_check(_dot_n1_maker(T, d, K, 3K + d), alpha, beta; k_block = 64, m_block = 7)
     end
     # A scalar output, C[] = sum_k a[k] b[k].
     K = 5W + 3
@@ -110,14 +108,14 @@ end
     end
 end
 
-@testset "dot path: allocation-free, and through the backend ($T)" for T in _DOT_TYPES
-    for (mk, kw) in ((_dot_gemv_maker(T, 6, 4), (;)), (_dot_n1_maker(T, 5, 300, 4), (kc = 64, mc = 8)))
-        plan = plan_contract(mk()...; oracle = false, kw...)
+@testset "dot path: allocation-free, and through the backend ($T)" for T in DOT_TYPES
+    for (mk, kw) in ((_dot_gemv_maker(T, 6, 4), (;)), (_dot_n1_maker(T, 5, 300, 4), (k_block = 64, m_block = 8)))
+        plan = plan_contract(mk()...; kw...)
         @test _dot_takes(plan)
         execute!(plan, 1.0, 0.0)
         @test (@allocated execute!(plan, 1.0, 0.0)) == 0 skip = (VERSION < v"1.11")
     end
-    # The backend runs the path predicted before planning (`_path_hint`).
+    # The backend plans and runs in one call.
     d = 6
     A, B, C = randn(T, d, d), randn(T, d, d, d, d, d), zeros(T, d, d, d)
     pA, pB, pAB = TO.contract_indices((:a, :b), (:a, :b, :c, :d, :e), (:c, :d, :e))
diff --git a/test/execution/test_execute.jl b/test/execution/test_execute.jl
index 69f7389..57a5ed0 100644
--- a/test/execution/test_execute.jl
+++ b/test/execution/test_execute.jl
@@ -1,118 +1,15 @@
-# Helpers shared by the execution test files included after this one.
-
-# Brute-force reference over every label assignment; knows nothing of plans.
-function _brute_ref(A, indA, B, indB, Cstart, indC, alpha, beta; conjA = false, conjB = false)
-    dims = Dict{Int, Int}()
-    for (l, L) in zip(indA, size(A))
-        dims[l] = L
-    end
-    for (l, L) in zip(indB, size(B))
-        dims[l] = L
-    end
-    klabels = Tuple(l for l in indA if l in indB && !(l in indC))
-    ksizes = Tuple(dims[l] for l in klabels)
-    T = eltype(Cstart)
-    out = similar(Cstart, T)
-    for Ic in CartesianIndices(Cstart)
-        at = Dict{Int, Int}(zip(indC, Tuple(Ic)))
-        acc = zero(T)
-        for Ik in CartesianIndices(ksizes)
-            for (l, i) in zip(klabels, Tuple(Ik))
-                at[l] = i
-            end
-            a = A[(at[l] for l in indA)...]
-            b = B[(at[l] for l in indB)...]
-            acc += (conjA ? conj(a) : a) * (conjB ? conj(b) : b)
-        end
-        out[Ic] = iszero(beta) ? alpha * acc : alpha * acc + beta * Cstart[Ic]
-    end
-    return out
-end
-
-# The reference result for the fixture `mk()`.
-function _ref_of(mk, alpha, beta; kw...)
-    Cv, Av, iA, Bv, iB, iC = mk()
-    return _brute_ref(Array(Av), iA, Array(Bv), iB, Array(Cv), iC, alpha, beta; kw...)
-end
-
-# Plan a fresh fixture `mk()` and run `run!` on it. Returns C and the plan.
-function _run_fresh(run!, mk, alpha, beta; plankw...)
-    Cv, Av, iA, Bv, iB, iC = mk()
-    plan = plan_contract(Cv, Av, iA, Bv, iB, iC; plankw...)
-    @test run!(plan, alpha, beta) === plan.Cstorage
-    return Array(Cv), plan
-end
-
-# `execute!` forced onto the nest with B packed, through the mode switches
-# the benchmarks use: the baseline for the dedicated paths.
-const _PATH_MODES = (QuasiStrided._DOT_MODE, QuasiStrided._OUTER_MODE, QuasiStrided._UNPACKED_B_MODE)
-function _run_nest!(plan, alpha, beta)
-    old = map(getindex, _PATH_MODES)
-    foreach(m -> m[] = :never, _PATH_MODES)
-    try
-        return execute!(plan, alpha, beta)
-    finally
-        foreach(setindex!, _PATH_MODES, old)
-    end
-end
-
-_path_of(plan) = QuasiStrided._select_path(plan)
-
-# A DenseMatrix that is not a DenseVector: a plan keeps it as storage, so paths
-# that need raw-pointer loads must decline it.
-struct _WrappedMat{T} <: DenseMatrix{T}
-    data::Matrix{T}
-end
-Base.size(a::_WrappedMat) = size(a.data)
-Base.IndexStyle(::Type{<:_WrappedMat}) = IndexLinear()
-Base.getindex(a::_WrappedMat, i::Int) = a.data[i]
-Base.setindex!(a::_WrappedMat, v, i::Int) = (a.data[i] = v)
-
-# `M` as a StridedView with the same values and a chosen layout of its first
-# axis. Gaps in padded parents are NaN, so reading one poisons C.
-function _view_as(M::Matrix{T}, layout::Symbol) where {T}
-    m, n = size(M)
-    layout === :dense && return StridedView(M)
-    layout === :transposed && return permutedims(StridedView(permutedims(M, (2, 1))), (2, 1))
-    layout === :wrapped && return StridedView(_WrappedMat(copy(M)), (m, n), (1, m), 0)
-    big = fill(convert(T, NaN), 2m + 4, n)
-    rows = layout === :offset ? (3:(m + 2)) : layout === :gap ? (1:2:(2m)) :
-        layout === :reversed ? ((m + 2):-1:3) : error("unknown layout $layout")
-    big[rows, :] .= M
-    return StridedView(view(big, rows, :))
-end
-
-# `C[m,n] = A[m,k] B[k,n]` with chosen layouts for A and B, seeded so every call
-# reproduces the same values. `ABfill` poisons both operands.
-function _mm_maker(::Type{T}, M, K, N, seed; A = :dense, B = :dense, Cfill = nothing, ABfill = nothing) where {T}
-    return function ()
-        rng = MersenneTwister(seed)
-        Amat = ABfill === nothing ? randn(rng, T, M, K) : fill(convert(T, ABfill), M, K)
-        Bmat = ABfill === nothing ? randn(rng, T, K, N) : fill(convert(T, ABfill), K, N)
-        Cmat = Cfill === nothing ? randn(rng, T, M, N) : fill(convert(T, Cfill), M, N)
-        return (StridedView(Cmat), _view_as(Amat, A), (1, 2), _view_as(Bmat, B), (2, 3), (1, 3))
-    end
-end
-
-# `C[n,m]` stored N-major: for a real eltype the planner swaps the operand roles.
-function _swapped_maker(::Type{T}, M, K, N, seed; B = :dense) where {T}
-    return function ()
-        rng = MersenneTwister(seed)
-        Amat, Bmat, Cmat = randn(rng, T, M, K), randn(rng, T, K, N), randn(rng, T, N, M)
-        return (StridedView(Cmat), StridedView(Amat), (1, 2), _view_as(Bmat, B), (2, 3), (3, 1))
-    end
-end
+include("helpers.jl")
 
 @testset "contract!: worked fixture, permuted and sliced views" begin
     A, B, Cref = _worked_fixture()
     C = zeros(3, 4, 2)
-    contract!(StridedView(C), 1.0, StridedView(A), _INDA, StridedView(B), _INDB, 0.0, _INDC)
+    contract!(StridedView(C), 1.0, StridedView(A), INDA, StridedView(B), INDB, 0.0, INDC)
     @test C ≈ Cref
 
     # Ap[k,b,a] == A[a,k,b], Bp[n,k] == B[k,n].
     C = zeros(3, 4, 2)
     Ap, Bp = permutedims(A, (2, 3, 1)), permutedims(B, (2, 1))
-    contract!(StridedView(C), 1.0, StridedView(Ap), (2, 3, 1), StridedView(Bp), (4, 2), 0.0, _INDC)
+    contract!(StridedView(C), 1.0, StridedView(Ap), (2, 3, 1), StridedView(Bp), (4, 2), 0.0, INDC)
     @test C ≈ Cref
 
     # Nonzero view offsets on A and C.
@@ -120,7 +17,7 @@ end
     Cfull = zeros(4, 4, 2)
     Av, Cv = StridedView(view(A4, 2:4, :, :)), StridedView(view(Cfull, 2:4, :, :))
     @test offset(Av) != 0
-    contract!(Cv, 1.0, Av, _INDA, StridedView(B), _INDB, 0.0, _INDC)
+    contract!(Cv, 1.0, Av, INDA, StridedView(B), INDB, 0.0, INDC)
     @test Array(Cv) ≈ [sum(A4[a, k, b] * B[k, n] for k in 1:5) for a in 2:4, n in 1:4, b in 1:2]
     @test all(iszero, Cfull[1, :, :])
 end
@@ -130,16 +27,18 @@ end
     for (Ka, alpha) in ((0, 1.0), (Ka, 0.0)), beta in (0.5, 0.0)
         # A and B are poisoned: neither may be read.
         mk = _mm_maker(Float64, Ma, Ka, Na, 1; ABfill = NaN)
-        C, _ = _run_fresh(execute!, mk, alpha, beta)
+        C, plan = _run_fresh(execute!, mk, alpha, beta)
         @test C == beta .* Array(mk()[1])
+        Ka == 0 && @test _path_of(plan) isa QuasiStrided.ScalePath
     end
     # beta = 0 never reads a NaN C, across several blocks.
-    C, _ = _run_fresh(execute!, _mm_maker(Float64, 11, 10, 9, 2; Cfill = NaN), 2.5, 0.0; mc = 4, kc = 4, nc = 4)
+    C, _ = _run_fresh(execute!, _mm_maker(Float64, 11, 10, 9, 2; Cfill = NaN), 2.5, 0.0; m_block = 4, k_block = 4, n_block = 4)
     @test C ≈ _ref_of(_mm_maker(Float64, 11, 10, 9, 2), 2.5, 0.0)
     # Empty M or N: a no-op.
     for (M, N) in ((3, 0), (0, 3))
-        C, _ = _run_fresh(execute!, _mm_maker(Float64, M, 4, N, 3; Cfill = NaN), 1.0, 2.0)
+        C, plan = _run_fresh(execute!, _mm_maker(Float64, M, 4, N, 3; Cfill = NaN), 1.0, 2.0)
         @test size(C) == (M, N)
+        @test _path_of(plan) isa QuasiStrided.EmptyPath
     end
     # Singleton extents, and two K labels against a singleton free label.
     mk2K = () -> (
@@ -151,7 +50,7 @@ end
         @test C ≈ _ref_of(mk, 1.5, 0.5)
     end
     # Block sizes beyond the extents are clamped, not an error.
-    C, _ = _run_fresh(execute!, _mm_maker(Float64, 9, 7, 6, 4), 1.0, 0.5; kernel = ScalarKernel(Val(4), Val(3), Float64), mc = 10_000, kc = 10_000, nc = 10_000)
+    C, _ = _run_fresh(execute!, _mm_maker(Float64, 9, 7, 6, 4), 1.0, 0.5; kernel = ScalarKernel(Val(4), Val(3), Float64), m_block = 10_000, k_block = 10_000, n_block = 10_000)
     @test C ≈ _ref_of(_mm_maker(Float64, 9, 7, 6, 4), 1.0, 0.5)
 end
 
@@ -167,7 +66,6 @@ end
         )
         @test_throws BoundsError execute!(plan, 1.0, 0.0)
         @test all(iszero, Cstore)
-        @test_throws BoundsError execute_tilewise!(plan, 1.0, 0.0)
     end
 end
 
@@ -175,20 +73,15 @@ end
     Ma, Ka, Na = 19, 23, 17
     Amat, Bmat = randn(MersenneTwister(1), Ma, Ka), randn(MersenneTwister(2), Ka, Na)
     kernel = SIMDKernel(Val(8), Val(6), Float64, Val(4))
-    # Default everything; a reused workspace without the oracle (the backend's
-    # shape); several blocks with tail tiles in M and N (the vectorized store's
-    # row tail); a conj transform, which the real path never builds but which
-    # must still cross `_pack_sliver!` concretely typed.
+    # Default everything; several blocks with tail tiles in M and N (the
+    # vectorized store's row tail); a conj transform, which the real path never
+    # builds but which must still cross `pack_sliver!` concretely typed.
     Cmat = zeros(Ma, Na)
     p = _mm_plan(Cmat, Amat, Bmat)
     plans = (
-        p, _mm_plan(Cmat, Amat, Bmat; workspace = p.workspace, oracle = false),
-        _mm_plan(Cmat, Amat, Bmat; kernel = kernel, mc = 16, kc = 5, nc = 8),
-        ContractPlan(
-            p.kernel, p.mgroup, p.ngroup, p.kgroup, p.blocking,
-            p.Astorage, p.Abase, p.Bstorage, p.Bbase, p.Cstorage, p.Cbase,
-            conj, conj, p.workspace, p.mpack, p.npack,
-        ),
+        p,
+        _mm_plan(Cmat, Amat, Bmat; kernel = kernel, m_block = 16, k_block = 5, n_block = 8),
+        ContractPlan(p; atransform = conj, btransform = conj),
     )
     @test parent(StridedView(Cmat)) isa DenseVector{Float64}
     for plan in plans
@@ -196,17 +89,13 @@ end
         @test Cmat ≈ Amat * Bmat
         @test allocs == 0 skip = (VERSION < v"1.11")
     end
-    allocs_tw = _steady_allocs!(execute_tilewise!, plans[4], Cmat)
-    @test Cmat ≈ Amat * Bmat
-    @test allocs_tw == 0 skip = (VERSION < v"1.11")
-    # ScalarKernel's accumulator is a Matrix: bounded, one per tile call.
-    ps = _mm_plan(Cmat, Amat, Bmat; kernel = ScalarKernel(Val(4), Val(3), Float64), mc = 8, kc = 6, nc = 7)
-    @test _steady_allocs!(execute!, ps, Cmat) <= 176 * cld(Ma, 4) * cld(Na, 3) * cld(Ka, 6) + 1
+    ps = _mm_plan(Cmat, Amat, Bmat; kernel = ScalarKernel(Val(4), Val(3), Float64), m_block = 8, k_block = 6, n_block = 7)
+    @test _steady_allocs!(execute!, ps, Cmat) == 0 skip = (VERSION < v"1.11")
 end
 
 _ws_union_members(t) = t isa Union ? (_ws_union_members(t.a)..., _ws_union_members(t.b)...) : (t,)
 
-# Every non-concrete QSTile/ContractWorkspace type in `f`'s unoptimized typed
+# Every non-concrete Tile/ContractWorkspace type in `f`'s unoptimized typed
 # IR, directly or as a union member (`Union{}` is a throw, not an instability).
 function _ws_nonconcrete_types(f, argtypes)
     bad = Any[]
@@ -218,7 +107,7 @@ function _ws_nonconcrete_types(f, argtypes)
             t isa Type || continue
             for m in _ws_union_members(t)
                 (m isa Type && m !== Union{}) || continue
-                if (m <: QuasiStrided.QSTile || m <: QuasiStrided.ContractWorkspace) && !isconcretetype(m)
+                if (m <: QuasiStrided.Tile || m <: QuasiStrided.ContractWorkspace) && !isconcretetype(m)
                     push!(bad, t)
                     break
                 end
@@ -231,73 +120,45 @@ end
 @testset "plan_contract/execute!: no union-typed or partially-applied tile/workspace types" begin
     Amat, Bmat, Cmat = randn(19, 23), randn(23, 17), zeros(19, 17)
     Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
-    plan = _mm_plan(Cmat, Amat, Bmat; mc = 8, kc = 6, nc = 7)
+    plan = _mm_plan(Cmat, Amat, Bmat; m_block = 8, k_block = 6, n_block = 7)
     @test isconcretetype(typeof(plan))
     @test all(isconcretetype, fieldtypes(typeof(plan.workspace)))
     @test typeof(plan.workspace) === QuasiStrided.ContractWorkspace{Float64, Vector{Float64}, Vector{Float64}}
     plan_argtypes = (typeof(Cv), typeof(Av), NTuple{2, Int}, typeof(Bv), NTuple{2, Int}, NTuple{2, Int})
     @test isempty(_ws_nonconcrete_types(plan_contract, plan_argtypes))
-    for f in (execute!, execute_tilewise!)
-        @test isempty(_ws_nonconcrete_types(f, (typeof(plan), Float64, Float64)))
-    end
+    @test isempty(_ws_nonconcrete_types(execute!, (typeof(plan), Float64, Float64)))
     @test isconcretetype(only(Base.return_types(execute!, (typeof(plan), Float64, Float64))))
 end
 
-# Line-by-line packing. intensli_7, C[e,c,b,f,a] = A[a,b,c,d,e] * B[d,f], splits A
-# (K steps of a page or more, every eltype); C[a1,au,f1,f2] = A[au,k,a1] * B[f2,k,f1]
-# splits both operands (K steps within a page, real only).
-const _SP_I7 = ((1, 2, 3, 4, 5), (4, 6), (5, 3, 2, 6, 1))
-const _SP_BOTH = ((2, 3, 1), (5, 3, 4), (1, 2, 4, 5))
-
-function _sp_views(T, (iA, iB, iC), ext, TA = T)
-    arr(S, I) = StridedView(randn(S, map(l -> ext[l], I)))
-    return (arr(T, iC), arr(TA, iA), iA, arr(T, iB), iB, iC)
-end
-
-# The plan with every structurally eligible group split, whatever this host's L2:
-# the planner's decision at a zero L2 threshold, replanned at its block extents.
-function _sp_forced_plan(Cv, Av, iA, Bv, iB, iC; kw...)
-    p = plan_contract(Cv, Av, iA, Bv, iB, iC; kw...)
-    k, kc, d, T = p.kernel, p.blocking.kc, default_blocking(p.kernel), eltype(Cv)
-    split(g, map, R, eff, req) = _pack_split(g, p.kgroup, map, R, sizeof(T), T <: Complex, kc, eff, cld(req, R) * R, d.kc, 0)
-    (mc, ms) = split(p.mgroup, 1, mr(k), p.blocking.mc, something(get(kw, :mc, nothing), d.mc))
-    (nc, ns) = split(p.ngroup, 2, nr(k), p.blocking.nc, d.nc)
-    q = plan_contract(Cv, Av, iA, Bv, iB, iC; kw..., kernel = k, mc, nc)
-    @assert q.mgroup == p.mgroup && q.ngroup == p.ngroup
-    return ContractPlan(
-        k, q.mgroup, q.ngroup, q.kgroup, q.blocking, q.Astorage, q.Abase,
-        q.Bstorage, q.Bbase, q.Cstorage, q.Cbase, q.atransform, q.btransform, q.workspace, ms, ns
+@testset "execute! still allocates nothing in steady state" begin
+    Ma, Ka, Na = 40, 21, 30
+    A = randn(Ma, Ka); B = randn(Ka, Na); C = zeros(Ma, Na)
+    p = plan_contract(
+        StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3)
     )
-end
-
-@testset "line-by-line packing: the planner splits A of intensli_7 past the cache" begin
-    plan_of(d) = plan_contract(_sp_views(Float64, _SP_I7, ntuple(_ -> d, 6))...)
-    p = plan_of(16)
-    k, b = p.kernel, p.blocking
-    splits(cap) = QuasiStrided._is_split(_pack_split(p.mgroup, p.kgroup, 1, mr(k), 8, false, b.kc, b.mc, b.mc, default_blocking(k).kc, cap)[2])
-    @test splits(2^20) && !splits(2^24)  # a 4 MB reuse window
-    host = splits(QuasiStrided._split_capacity(target_profile(), true))
-    @test QuasiStrided._is_split(p.mpack) == host
-    host && @test _path_of(p) isa _NestPath{false, <:Any, (true, false)}
-    @test _path_of(plan_of(4)) isa _NestPath{<:Any, <:Any, (false, false)}
-end
-
-@testset "line-by-line packing: contractions ($T)" for T in (Float64, Float32, ComplexF64, ComplexF32)
-    kernels = T === ComplexF64 ? (nothing, OneMKernel(Val(4), Val(4), T), FMAddSubKernel(Val(8), Val(4), T)) : (nothing,)
-    for (ind, ext, mc) in (
-                (_SP_I7, (8, 8, 8, 3, 6, 5), nothing), (_SP_I7, (6, 8, 11, 5, 10, 7), 48),
-                (_SP_BOTH, (20, 16, 9, 20, 8), nothing), (_SP_BOTH, (13, 12, 5, 11, 12), 64),
-            ), kernel in kernels, conjB in (T <: Complex ? (false, true) : (false,)), beta in (0, 0.7)
-        T <: Complex && ind === _SP_BOTH && continue  # K steps within a page: complex never splits
-        Cv, Av, iA, Bv, iB, iC = _sp_views(T, ind, ext)
-        iszero(beta) && fill!(Cv, NaN)
-        Cref = _lo_reference(iszero(beta) ? zero(Array(Cv)) : Array(Cv), Av, iA, Bv, iB, iC; conjB, alpha = 1.3, beta)
-        plan = _sp_forced_plan(Cv, Av, iA, Bv, iB, iC; conjB, mc, kernel)
-        @test _path_of(plan) isa _NestPath{false, <:Any, (true, ind === _SP_BOTH)}
-        execute!(plan, 1.3, beta)
-        @test Array(Cv) ≈ Cref rtol = 100 * eps(real(T))
+    execute!(p, 1.0, 0.0)
+    execute!(p, 1.0, 0.0)
+    allocs = @allocated execute!(p, 1.0, 0.0)
+    @test C ≈ A * B
+    @test allocs == 0 skip = (VERSION < v"1.11")
+
+    # Permuted A with a zero stride, reversed B, sliced C: the non-ramp path,
+    # at both real eltypes' shipped defaults.
+    for T in (Float64, Float32)
+        Cv, Av, iA, Bv, iB, iC = scattered_fixture(T)
+        ps = plan_contract(Cv, Av, iA, Bv, iB, iC)
+        execute!(ps, one(T), zero(T))
+        execute!(ps, one(T), zero(T))
+        @test (@allocated execute!(ps, one(T), zero(T))) == 0 skip = (VERSION < v"1.11")
+        @test Cv ≈ _lo_reference(zeros(T, size(Cv)), Av, iA, Bv, iB, iC)
     end
-    plan = _sp_forced_plan(_sp_views(T, T <: Complex ? _SP_I7 : _SP_BOTH, (20, 16, 9, 20, 8, 5))...)
-    execute!(plan, 1, 0)
-    @test (@allocated execute!(plan, 1, 0)) == 0 skip = (VERSION < v"1.11")
+
+    # M, N and K composites ordered differently per operand: scattered tile axes.
+    A4 = randn(5, 6, 7, 9); B4 = randn(7, 6, 11, 3); C4 = zeros(3, 9, 11, 5)
+    p4 = plan_contract(
+        StridedView(C4), StridedView(A4), (1, 2, 3, 4), StridedView(B4), (3, 2, 5, 6), (6, 4, 5, 1)
+    )
+    execute!(p4, 1.0, 0.5)
+    execute!(p4, 1.0, 0.5)
+    @test (@allocated execute!(p4, 1.0, 0.5)) == 0 skip = (VERSION < v"1.11")
 end
diff --git a/test/execution/test_macro_blocking.jl b/test/execution/test_macro_blocking.jl
deleted file mode 100644
index 391e2bc..0000000
--- a/test/execution/test_macro_blocking.jl
+++ /dev/null
@@ -1,175 +0,0 @@
-# Randomized agreement of the five-loop `execute!` with a dense matmul and with
-# `execute_tilewise!`, at block sizes small enough to split every dimension,
-# over real and complex kernels, alpha/beta and the conjugation flags and ops.
-# helpers.jl binds `plan_contract`/`execute!` unqualified in this scope, so
-# names here are written `QuasiStrided.<name>`.
-
-# Agreement is up to summation-order rounding.
-_macro_rtol(::Type{T}, Ka::Integer) where {T} = 50 * max(Ka, 1) * eps(real(T))
-
-# Plan for C[m,n] = A[m,k] * B[k,n], with operands as `op`-carrying views. The
-# 5-argument constructor keeps `op` on the view instead of materializing.
-_macro_op_view(M::AbstractMatrix, op) = StridedView(M, size(M), strides(M), 0, op)
-function _macro_plan(Cmat, Amat, Bmat, kernel, mc, kc, nc; conjA = false, conjB = false, opA = identity, opB = identity)
-    return QuasiStrided.plan_contract(
-        StridedView(Cmat), _macro_op_view(Amat, opA), (1, 2), _macro_op_view(Bmat, opB), (2, 3), (1, 3);
-        kernel = kernel, conjA = conjA, conjB = conjB, mc = mc, kc = kc, nc = nc
-    )
-end
-
-# The engine's conjugation rule re-derived independently: the flag and the
-# view's `op` compose by XOR; real eltypes never conjugate.
-_macro_op_conjugates(op) = op === conj || op === adjoint
-_macro_conjugated(::Type{T}, flag::Bool, op) where {T} = (T <: Complex) && (flag ⊻ _macro_op_conjugates(op))
-
-const _MACRO_OPS = (identity, conj, adjoint, transpose)
-const _MACRO_SHAPES = ((Val(4), Val(3)), (Val(8), Val(6)))
-
-# Every constructible (kernel type, shape) for `T`; constructors reject shapes
-# their lane width cannot tile.
-function _macro_kernels(::Type{T}) where {T}
-    ctors = T <: Complex ? (QuasiStrided.PlanarKernel, QuasiStrided.OneMKernel) : (ScalarKernel, SIMDKernel)
-    ks = Any[]
-    for ctor in ctors, (m, n) in _MACRO_SHAPES
-        k = try
-            ctor(m, n, T)
-        catch err
-            err isa ArgumentError || rethrow()
-            nothing
-        end
-        k === nothing || push!(ks, k)
-    end
-    return ks
-end
-
-# Scalars that include the 0 and 1 shortcuts and are genuinely complex
-# otherwise, so a dropped imaginary part cannot pass.
-function _macro_scalar(rng, ::Type{T}) where {T}
-    r = rand(rng)
-    r < 0.1 && return zero(T)
-    r < 0.2 && return one(T)
-    return T <: Complex ? T(rand(rng, -3.0:0.5:3.0), rand(rng, -3.0:0.5:3.0)) : T(rand(rng, -3.0:0.5:3.0))
-end
-
-@testset "macro driver: randomized agreement vs dense matmul and the oracle ($T)" for T in (Float64, Float32, ComplexF64, ComplexF32)
-    rng = MersenneTwister(0x5A17_D817)
-    kernels = _macro_kernels(T)
-    @test !isempty(kernels)
-    for kernel in kernels, i in 1:(T <: Complex ? 12 : 5)
-        Ma, Ka, Na = rand(rng, 1:37, 3)
-        mc, kc, nc = rand(rng, 1:13, 3)
-        conjA, conjB = rand(rng, Bool, 2)
-        opA, opB = rand(rng, _MACRO_OPS, 2)
-        alpha, beta = _macro_scalar(rng, T), _macro_scalar(rng, T)
-        Amat, Bmat = randn(rng, T, Ma, Ka), randn(rng, T, Ka, Na)
-        # A NaN-poisoned C whenever beta == 0: it must never be read.
-        Cstart = iszero(beta) ? fill(T(NaN), Ma, Na) : randn(rng, T, Ma, Na)
-        kw = (; conjA, conjB, opA, opB)
-
-        Aeff = _macro_conjugated(T, conjA, opA) ? conj.(Amat) : Amat
-        Beff = _macro_conjugated(T, conjB, opB) ? conj.(Bmat) : Bmat
-        expected = iszero(beta) ? alpha .* (Aeff * Beff) : alpha .* (Aeff * Beff) .+ beta .* Cstart
-
-        C = copy(Cstart)
-        QuasiStrided.execute!(_macro_plan(C, Amat, Bmat, kernel, mc, kc, nc; kw...), alpha, beta)
-        Ctw = copy(Cstart)
-        QuasiStrided.execute_tilewise!(_macro_plan(Ctw, Amat, Bmat, kernel, mc, kc, nc; kw...), alpha, beta)
-        ok = isapprox(C, expected; rtol = _macro_rtol(T, Ka)) && isapprox(C, Ctw; rtol = _macro_rtol(T, Ka))
-        ok || @error "macro driver case $i failed" kernel Ma Ka Na mc kc nc kw alpha beta
-        @test ok
-    end
-end
-
-@testset "macro driver: permuted, zero-stride, negative-stride and sliced views" begin
-    # A[a,k,b] independent of b (zero stride), viewed permuted as (k,b,a);
-    # B[k,n] reversed along k; C a slice with a nonzero offset.
-    a_n, k_n, b_n, n_n = 7, 11, 5, 9
-    Aperm = permutedims(StridedView(vec(randn(a_n, k_n)), (a_n, k_n, b_n), (1, a_n, 0), 0), (2, 3, 1))
-    Bneg = StridedView(randn(k_n * n_n), (k_n, n_n), (-1, k_n), k_n - 1)
-    Cbig = randn(a_n + 2, n_n + 3, b_n + 1)
-    Csub = view(Cbig, 2:(a_n + 1), 2:(n_n + 1), 1:b_n)
-    Cstart = copy(Csub)
-    Cref = _brute_ref(Array(Aperm), (2, 3, 1), Array(Bneg), (2, 4), Cstart, (1, 4, 3), 1.3, 0.6)
-    plan = QuasiStrided.plan_contract(
-        StridedView(Csub), Aperm, (2, 3, 1), Bneg, (2, 4), (1, 4, 3);
-        kernel = ScalarKernel(Val(4), Val(3), Float64), mc = 3, kc = 4, nc = 3
-    )
-    QuasiStrided.execute!(plan, 1.3, 0.6)
-    @test isapprox(Array(Csub), Cref; rtol = _macro_rtol(Float64, k_n))
-end
-
-@testset "macro driver: irregular sliver at a nonzero offset (multi-label M)" begin
-    # M = (a, q): A's map folds across the a/q boundary, C's (padded) does not,
-    # so the second M sliver of the first block is irregular.
-    a_n, q_n, k_n, n_n = 7, 2, 5, 3
-    Amat, Bmat = randn(a_n, q_n, k_n), randn(k_n, n_n)
-    Cstart = randn(a_n, q_n, n_n)
-    Cref = _brute_ref(Amat, (1, 2, 3), Bmat, (3, 4), Cstart, (1, 2, 4), 1.7, -0.4)
-    for run! in (QuasiStrided.execute!, QuasiStrided.execute_tilewise!)
-        Cbig = randn(a_n + 3, q_n, n_n)
-        Csub = view(Cbig, 1:a_n, :, :)
-        Csub .= Cstart
-        plan = QuasiStrided.plan_contract(
-            StridedView(Csub), StridedView(Amat), (1, 2, 3), StridedView(Bmat), (3, 4), (1, 2, 4);
-            kernel = ScalarKernel(Val(4), Val(3), Float64), mc = 8, kc = 5, nc = 3
-        )
-        run!(plan, 1.7, -0.4)
-        @test isapprox(Array(Csub), Cref; rtol = _macro_rtol(Float64, k_n))
-    end
-end
-
-@testset "macro driver: several blocks at the default blocking ($(nameof(typeof(k))){$T})" for T in (ComplexF64, ComplexF32), k in _macro_kernels(T)
-    QuasiStrided.mr(k) == 8 || continue
-    b = QuasiStrided.default_blocking(k)
-    Ma, Ka, Na = b.mc + QuasiStrided.mr(k), b.kc + 1, b.nc + QuasiStrided.nr(k)
-    Amat, Bmat = randn(MersenneTwister(1), T, Ma, Ka), randn(MersenneTwister(2), T, Ka, Na)
-    Cstart = randn(MersenneTwister(3), T, Ma, Na)
-    C = copy(Cstart)
-    alpha, beta = T(1.5, -0.25), T(-0.5, 0.75)
-    # Conjugation from both sources: the flag on A, a conjugating op on B.
-    plan = _macro_plan(C, Amat, Bmat, k, nothing, nothing, nothing; conjA = true, opB = adjoint)
-    @test plan.blocking.mc < Ma && plan.blocking.kc < Ka && plan.blocking.nc < Na
-    QuasiStrided.execute!(plan, alpha, beta)
-    @test isapprox(C, alpha .* (conj.(Amat) * conj.(Bmat)) .+ beta .* Cstart; rtol = _macro_rtol(T, Ka))
-end
-
-@testset "macro driver: conjugation sources compose by XOR ($T)" for T in (ComplexF64, ComplexF32)
-    kernel = first(_macro_kernels(T))
-    Amat, Bmat = randn(MersenneTwister(1), T, 11, 9), randn(MersenneTwister(2), T, 9, 7)
-    rtol = _macro_rtol(T, 9)
-    # (conjA, opA, opB) => (A conjugated, B conjugated). The first two pin the
-    # cases a `||` rule or a `op === conj` test would get wrong.
-    for ((conjA, opA, opB), (ca, cb)) in (
-            (true, conj, identity) => (false, false), (false, adjoint, identity) => (true, false),
-            (false, identity, transpose) => (false, false),
-        )
-        C = zeros(T, 11, 7)
-        QuasiStrided.execute!(_macro_plan(C, Amat, Bmat, kernel, 4, 3, 4; conjA, opA, opB), one(T), zero(T))
-        Aeff, Beff = ca ? conj.(Amat) : Amat, cb ? conj.(Bmat) : Bmat
-        @test isapprox(C, Aeff * Beff; rtol)
-        @test !isapprox(C, (ca ? Amat : conj.(Amat)) * Beff; rtol)
-    end
-end
-
-@testset "macro driver: a conjugating op on C is rejected ($T)" for T in (ComplexF64, Float64)
-    kernel = T <: Complex ? first(_macro_kernels(T)) : ScalarKernel(Val(4), Val(3), T)
-    Amat, Bmat = randn(MersenneTwister(1), T, 9, 7), randn(MersenneTwister(2), T, 7, 6)
-    for op in _MACRO_OPS
-        C = zeros(T, 9, 6)
-        mkplan() = QuasiStrided.plan_contract(
-            _macro_op_view(C, op), _macro_op_view(Amat, op), (1, 2), _macro_op_view(Bmat, op), (2, 3), (1, 3);
-            kernel = kernel, conjA = true, conjB = true, mc = 4, kc = 3, nc = 4
-        )
-        if T <: Complex && _macro_op_conjugates(op)
-            @test_throws ArgumentError mkplan()
-        else
-            plan = mkplan()
-            QuasiStrided.execute!(plan, one(T), zero(T))
-            # For a real eltype nothing conjugates, whatever the flags and ops say.
-            T <: Real && @test plan.atransform === identity === plan.btransform
-            Aeff = _macro_conjugated(T, true, op) ? conj.(Amat) : Amat
-            Beff = _macro_conjugated(T, true, op) ? conj.(Bmat) : Bmat
-            @test isapprox(C, Aeff * Beff; rtol = _macro_rtol(T, 7))
-        end
-    end
-end
diff --git a/test/execution/test_manual_pipeline.jl b/test/execution/test_manual_pipeline.jl
index 93a5ef1..3030641 100644
--- a/test/execution/test_manual_pipeline.jl
+++ b/test/execution/test_manual_pipeline.jl
@@ -1,7 +1,9 @@
 # The stages driven by hand, end to end: AxisGroup -> BlockDescriptor -> tile
-# axes -> pack_a!/pack_b! -> ScalarKernel execute_tile!, with beta applied on
+# axes -> pack! -> ScalarKernel execute_tile!, with beta applied on
 # the first K panel only.
 
+include("../helpers.jl")
+
 @testset "manual pipeline: AxisGroup -> tiles -> packing -> ScalarKernel" begin
     A, B, Cref = _worked_fixture()
     M = AxisGroup((3, 2), ((1, 15), (1, 12)))  # A, C
@@ -14,85 +16,28 @@
     mb, nb, kb = bufs(M), bufs(N), bufs(K)
     (dM_A, dM_C) = block_descriptors!(mb, M, 0, 6)
     (dN_B, dN_C) = block_descriptors!(nb, N, 0, 4)
-    row_A, row_C = axis_from_descriptor(dM_A, mb[1]), axis_from_descriptor(dM_C, mb[2])
-    col_B, col_C = axis_from_descriptor(dN_B, nb[1]), axis_from_descriptor(dN_C, nb[2])
-
-    Cstorage = zeros(length(Cref))
-    destination = DestinationTile(Cstorage, 0, row_C, col_C)
-    @test (nrows(destination), ncols(destination)) == (6, 4)
-    packed_a, packed_b = zeros(mr(kernel) * 5), zeros(nr(kernel) * 5)
-
-    Cstart = rand(MersenneTwister(1234), size(Cref)...)
-    # One panel covering K, then panels of 2, 2, 1 with nontrivial alpha/beta.
-    for (panels, alpha, beta) in ((((0, 5),), 1.0, 0.0), (((0, 2), (2, 2), (4, 1)), 2.5, 0.75))
-        copyto!(Cstorage, vec(Cstart))
-        for (idx, (first, len)) in enumerate(panels)
-            (dK_A, dK_B) = block_descriptors!(kb, K, first, len)
-            pack_a!(packed_a, SourceTile(vec(A), 0, row_A, axis_from_descriptor(dK_A, kb[1])), kernel, identity)
-            pack_b!(packed_b, SourceTile(vec(B), 0, axis_from_descriptor(dK_B, kb[2]), col_B), kernel, identity)
-            execute_tile!(kernel, destination, packed_a, packed_b, len, alpha, idx == 1 ? beta : 1.0)
+    # Scatter axes borrow pointers into the offset buffers.
+    GC.@preserve mb nb kb begin
+        axis(d, buf) = QuasiStrided.axis_of(d, buf, 0)
+        row_A, row_C = axis(dM_A, mb[1]), axis(dM_C, mb[2])
+        col_B, col_C = axis(dN_B, nb[1]), axis(dN_C, nb[2])
+
+        Cstorage = zeros(length(Cref))
+        destination = Tile(Cstorage, 0, row_C, col_C)
+        @test size(destination) == (6, 4)
+        packed_a, packed_b = zeros(tile_size(kernel, 1) * 5), zeros(tile_size(kernel, 2) * 5)
+
+        Cstart = rand(MersenneTwister(1234), size(Cref)...)
+        # One panel covering K, then panels of 2, 2, 1 with nontrivial alpha/beta.
+        for (panels, alpha, beta) in ((((0, 5),), 1.0, 0.0), (((0, 2), (2, 2), (4, 1)), 2.5, 0.75))
+            copyto!(Cstorage, vec(Cstart))
+            for (idx, (first, len)) in enumerate(panels)
+                (dK_A, dK_B) = block_descriptors!(kb, K, first, len)
+                pack!(packed_a, Tile(vec(A), 0, row_A, axis(dK_A, kb[1])), sliver_spec(kernel, 1), identity)
+                pack!(packed_b, Tile(vec(B), 0, col_B, axis(dK_B, kb[2])), sliver_spec(kernel, 2), identity)
+                execute_tile!(kernel, destination, packed_a, packed_b, len, alpha, idx == 1 ? beta : 1.0)
+            end
+            @test reshape(Cstorage, size(Cref)) ≈ alpha .* Cref .+ beta .* Cstart
         end
-        @test reshape(Cstorage, size(Cref)) ≈ alpha .* Cref .+ beta .* Cstart
     end
 end
-
-@testset "tile-level bounds checks and alpha/beta shortcuts" begin
-    k = ScalarKernel(Val(2), Val(2), Float64)
-    # Out-of-bounds source or destination storage is rejected before any access.
-    packed = zeros(4)
-    for base in (10_000, -10_000)
-        src = SourceTile([1.0, 2.0, 3.0, 4.0], base, AffineAxis(0, 1, 2), AffineAxis(0, 2, 2))
-        @test_throws BoundsError pack_a!(packed, src, k, identity)
-        @test_throws BoundsError pack_b!(packed, src, k, identity)
-    end
-    @test all(iszero, packed)
-    canary = fill(999.0, 4)
-    dst = DestinationTile(canary, 3, AffineAxis(0, 1, 2), AffineAxis(0, 0, 1))
-    @test_throws BoundsError execute_tile!(k, dst, zeros(4), zeros(4), 0, 1.0, 2.0)
-    @test all(==(999.0), canary)
-
-    # Undersized packed buffers are rejected, except by the kc = 0 / alpha = 0
-    # short-circuits, which never read them.
-    dst = DestinationTile(zeros(4), 0, AffineAxis(0, 1, 2), AffineAxis(0, 2, 2))
-    @test_throws DimensionMismatch execute_tile!(k, dst, zeros(4), zeros(4), 50, 1.0, 0.0)
-    @test execute_tile!(k, dst, zeros(1), zeros(1), 0, 1.0, 0.0) === dst
-    @test execute_tile!(k, dst, zeros(1), zeros(1), 5, 0.0, 1.0) === dst
-
-    @test axis_offset_range(AffineAxis(5, -2, 3)) == (1, 5)
-    @test axis_offset_range(AffineAxis(7, 3, 0)) == (0, -1)
-    @test axis_offset_range(ScatterAxis([4, 1, 9, 2], 3)) == (1, 9)
-    @test axis_offset_range(ScatterAxis(Int[], 0)) == (0, -1)
-    @test checked_tile_storage_bounds(0, AffineAxis(0, 1, 3), AffineAxis(0, 3, 2), 6) === nothing
-    @test checked_tile_storage_bounds(1_000_000, AffineAxis(0, 1, 0), AffineAxis(0, 1, 5), 1) === nothing
-    @test_throws BoundsError checked_tile_storage_bounds(0, AffineAxis(0, 1, 3), AffineAxis(0, 3, 2), 5)
-    @test_throws BoundsError checked_tile_storage_bounds(-1, AffineAxis(0, 1, 3), AffineAxis(0, 3, 2), 6)
-
-    kernel = ScalarKernel(Val(3), Val(2), Float64)
-    pa, pb = Float64[1, 2, 3, 4, 5, 6], Float64[10, 20, 30, 40]
-    tile(s) = DestinationTile(s, 0, AffineAxis(0, 1, 3), AffineAxis(0, 3, 2))
-    s = fill(NaN, 6)
-    execute_tile!(kernel, tile(s), pa, pb, 2, 0.0, 0.0)   # alpha = beta = 0: zeros
-    @test all(iszero, s)
-    s = [1.0, NaN, 3.0, 4.0, NaN, 6.0]
-    execute_tile!(kernel, tile(s), pa, pb, 2, 0.0, 1.0)   # alpha = 0, beta = 1: no-op
-    @test isequal(s, [1.0, NaN, 3.0, 4.0, NaN, 6.0])
-    s = fill(NaN, 6)
-    execute_tile!(kernel, tile(s), pa, pb, 2, 1.0, 0.0)   # beta = 0 never reads C
-    @test all(isfinite, s)
-    s = [42.0]
-    execute_tile!(kernel, DestinationTile(s, 0, AffineAxis(0, 1, 0), AffineAxis(0, 1, 0)), pa, pb, 2, 1.0, 0.0)
-    @test s == [42.0]
-    @test_throws ArgumentError execute_tile!(
-        kernel, DestinationTile(zeros(20), 0, AffineAxis(0, 1, 4), AffineAxis(0, 4, 2)), pa, pb, 2, 1.0, 0.0
-    )
-    # Canaries outside the tile survive; scattered columns agree with affine ones.
-    s = fill(-1.0, 8)
-    execute_tile!(kernel, tile(s), pa, pb, 2, 1.0, 0.0)
-    @test s[7] == -1.0 && s[8] == -1.0
-    s6 = zeros(6)
-    execute_tile!(kernel, DestinationTile(s6, 0, AffineAxis(0, 1, 3), ScatterAxis([0, 3], 2)), pa, pb, 2, 1.0, 0.0)
-    @test s6 == s[1:6]
-    s32 = zeros(Float32, 6)
-    execute_tile!(ScalarKernel(Val(3), Val(2), Float32), tile(s32), Float32.(pa), Float32.(pb), 2, 1.0f0, 0.0f0)
-    @test s32 ≈ s[1:6]
-end
diff --git a/test/execution/test_mixed.jl b/test/execution/test_mixed.jl
index 1486a60..44d2f51 100644
--- a/test/execution/test_mixed.jl
+++ b/test/execution/test_mixed.jl
@@ -1,12 +1,14 @@
 # Mixed operand eltypes: compute type, conversion on load, one rounding on store.
 
+include("helpers.jl")
+
 using LinearAlgebra: norm
 
 # `(Cv, Av, indA, Bv, indB, indC)` of shape `(M, K, N)`; `:scattered` takes each
 # operand from `scattered_fixture` of its own eltype, `:split` is intensli_7 with
 # M^4 rows.
 function _mixed_fixture(TA, TB, TC, M, K, N, layout, seed)
-    layout === :split && return _sp_views(TC, _SP_I7, (M, M, M, K, M, N), TA)
+    layout === :split && return _sp_views(TC, SP_I7, (M, M, M, K, M, N), TA)
     layout === :scattered &&
         return (scattered_fixture(TC)[1], scattered_fixture(TA)[2:3]..., scattered_fixture(TB)[4:6]...)
     rng = MersenneTwister(seed)
@@ -21,20 +23,19 @@ function _mixed_ref(fx, alpha, beta; kw...)
     return _brute_ref(R.(Array(Av)), iA, R.(Array(Bv)), iB, R.(Array(Cv)), iC, alpha, beta; kw...)
 end
 
-const _CR, _RC = QuasiStrided.ComplexRealKernel, QuasiStrided.RealComplexKernel
-const _PROMOTED = Union{QuasiStrided.PlanarKernel, QuasiStrided.FMAddSubKernel}
+const PROMOTED = Union{QuasiStrided.PlanarKernel, QuasiStrided.FMAddSubKernel}
 
 @testset "mixed eltypes: $TA x $TB -> $TC, accumulator = $acc, $layout" for (TA, TB, TC, acc, layout, MKN, beta, conjA, conjB, path, K) in (
-        (Float32, Float64, Float64, nothing, :dense, (23, 37, 19), 0, false, false, QuasiStrided._NestPath, SIMDKernel),
-        (Float64, Float32, Float32, nothing, :dense, (32, 40, 12), 1, false, false, QuasiStrided._NestPath, SIMDKernel),
-        (Float64, ComplexF64, ComplexF64, nothing, :scattered, (32, 32, 32), 0.3 - 0.7im, false, true, QuasiStrided._NestPath, _RC),
-        (ComplexF32, Float64, ComplexF64, nothing, :scattered, (32, 32, 32), 0.5, true, false, QuasiStrided._NestPath, _CR),
-        (Float64, ComplexF64, ComplexF64, nothing, :split, (8, 3, 5), 0.5, false, true, _NestPath{false, <:Any, (true, false)}, _RC),
-        (ComplexF32, ComplexF64, ComplexF64, nothing, :dense, (19, 29, 23), 1, true, true, QuasiStrided._NestPath, _PROMOTED),
-        (Float64, Float64, ComplexF64, nothing, :dense, (18, 25, 14), 0.25 + 0.5im, false, false, QuasiStrided._NestPath, _PROMOTED),
-        (ComplexF64, Float32, ComplexF64, Float32, :dense, (17, 31, 13), 0, false, false, QuasiStrided._NestPath, _CR),
-        (Float32, Float64, Float64, nothing, :dense, (1, 70, 29), 0.5, false, false, QuasiStrided._DotPath, SIMDKernel),
-        (Float64, Float32, Float64, nothing, :dense, (37, 1, 21), 1, false, false, QuasiStrided._OuterPath, SIMDKernel),
+        (Float32, Float64, Float64, nothing, :dense, (23, 37, 19), 0, false, false, QuasiStrided.NestPath, SIMDKernel),
+        (Float64, Float32, Float32, nothing, :dense, (32, 40, 12), 1, false, false, QuasiStrided.NestPath, SIMDKernel),
+        (Float64, ComplexF64, ComplexF64, nothing, :scattered, (32, 32, 32), 0.3 - 0.7im, false, true, QuasiStrided.NestPath, RC),
+        (ComplexF32, Float64, ComplexF64, nothing, :scattered, (32, 32, 32), 0.5, true, false, QuasiStrided.NestPath, CR),
+        (Float64, ComplexF64, ComplexF64, nothing, :split, (8, 3, 5), 0.5, false, true, NestPath{false, <:Any, (true, false)}, RC),
+        (ComplexF32, ComplexF64, ComplexF64, nothing, :dense, (19, 29, 23), 1, true, true, QuasiStrided.NestPath, PROMOTED),
+        (Float64, Float64, ComplexF64, nothing, :dense, (18, 25, 14), 0.25 + 0.5im, false, false, QuasiStrided.NestPath, PROMOTED),
+        (ComplexF64, Float32, ComplexF64, Float32, :dense, (17, 31, 13), 0, false, false, QuasiStrided.NestPath, CR),
+        (Float32, Float64, Float64, nothing, :dense, (1, 70, 29), 0.5, false, false, QuasiStrided.DotPath, SIMDKernel),
+        (Float64, Float32, Float64, nothing, :dense, (37, 1, 21), 1, false, false, QuasiStrided.OuterPath, SIMDKernel),
     )
     fx = _mixed_fixture(TA, TB, TC, MKN..., layout, 7)
     alpha = 1.5
@@ -45,62 +46,24 @@ const _PROMOTED = Union{QuasiStrided.PlanarKernel, QuasiStrided.FMAddSubKernel}
     @test plan.kernel isa K
     @test _path_of(plan) isa path
     execute!(plan, alpha, beta)
-    Qk = layout === :scattered ? 32 : MKN[2]
-    rtol = 10 * sqrt(Qk) * max(eps(real(T)), eps(real(TC)))
+    k_length = layout === :scattered ? 32 : MKN[2]
+    rtol = 10 * sqrt(k_length) * max(eps(real(T)), eps(real(TC)))
     @test norm(Array(fx[1]) - ref) <= rtol * norm(ref)
 end
 
 @testset "a named mixed-domain kernel with a complex RealFormat side throws at plan time" begin
     Cv, Av, Bv = (StridedView(zeros(ComplexF64, 8, 8)) for _ in 1:3)
-    for kernel in (_CR(Val(4), Val(6), ComplexF64, Val(4)), _RC(Val(8), Val(3), ComplexF64, Val(4)))
+    for kernel in (CR(Val(4), Val(6), ComplexF64, Val(4)), RC(Val(8), Val(3), ComplexF64, Val(4)))
         @test_throws ArgumentError plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3); kernel)
     end
 end
 
-# Along K, 1, 2^-30 and -1 fall in different kc blocks: the 2^-30 and the small
-# beta*C survive only if the partial sums stay in the compute type between blocks.
-@testset "one rounding to $TC across kc blocks: $TA x $TB, M = $M, $case, beta = $beta" for (TA, TB, TC, acc, M, N, K, case, beta) in (
-        (Float64, Float64, Float32, nothing, 13, 40, 20, :manual_nc16, 0.5),
-        (Float32, Float32, Float32, Float64, 13, 9, 20, :packed_b, 1),
-        (Float64, ComplexF64, ComplexF32, nothing, 13, 9, 20, :strided_c, 0.5),
-        (Float32, Float32, Float32, Float64, 7, 5, 3000, :backend, 0),
-        (Float64, Float64, Float32, nothing, 1, 9, 20, :strided_c, 1),
-        (Float64, Float64, Float32, nothing, 13, 9, 20, :strided_c, 0),
-    )
-    b = TB <: Complex ? TB(1, 1) : one(TB)
-    A = zeros(TA, M, K)
-    A[:, 1] .= 1
-    A[:, K ÷ 2 + 1] .= 2.0^-30
-    A[:, K] .= -1
-    Av, Bv = StridedView(A), StridedView(fill(b, K, N))
-    case === :packed_b && (Bv = permutedims(StridedView(permutedims(Array(Bv))), (2, 1)))
-    Cv = case === :strided_c ? StridedView(zeros(TC, 2M, 3N))[2:2:2M, 1:3:3N] : StridedView(zeros(TC, M, N))
-    fill!(Cv, iszero(beta) ? NaN : 2.0^-28)
-    if case === :backend
-        @test K ÷ 2 > QuasiStrided._resolved_defaults(Float64).real_row.kc
-        backend = QuasiStrided.QuasiStridedBackend(accumulator = acc)
-        TO.tensorcontract!(Cv, Av, ((1,), (2,)), false, Bv, ((1,), (2,)), false, ((1, 2), ()), 1, beta, backend)
-    else
-        allocator = case === :manual_nc16 ? TO.ManualAllocator() : TO.DefaultAllocator()
-        nc = case === :manual_nc16 ? 16 : nothing
-        plan = plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3); accumulator = acc, kc = 4, nc, allocator)
-        @test _path_of(plan) isa QuasiStrided._PanelPath
-        @test axis_length(plan.mgroup) == M
-        case === :manual_nc16 && @test N > plan.blocking.nc && !(plan.workspace.c_panel isa Vector)
-        case === :packed_b && @test _path_of(plan) isa QuasiStrided._PanelPath{<:QuasiStrided._NestPath{false}}
-        TB <: Complex && @test plan.kernel isa _RC
-        execute!(plan, 1, beta)
-        QuasiStrided.release!(plan.workspace, allocator)
-    end
-    @test all(==(TC(2.0^-30 * b + beta * 2.0^-28)), Array(Cv))
-end
-
 @testset "steady-state execute! allocates nothing: $TA x $TB -> $TC, accumulator = $acc" for (TA, TB, TC, acc, K) in (
         (Float32, ComplexF64, ComplexF64, nothing, 30), (Float32, Float32, Float32, Float64, 700),
     )
     rng = MersenneTwister(3)
     Amat, Bmat, Cmat = randn(rng, TA, 64, K), randn(rng, TB, K, 40), zeros(TC, 64, 40)
-    plan = _mm_plan(Cmat, Amat, Bmat; accumulator = acc, kc = 256)
-    @test _path_of(plan) isa (TC === Float32 ? QuasiStrided._PanelPath : QuasiStrided._NestPath)
+    plan = _mm_plan(Cmat, Amat, Bmat; accumulator = acc, k_block = 256)
+    @test _path_of(plan) isa (TC === Float32 ? QuasiStrided.PanelPath : QuasiStrided.NestPath)
     @test _steady_allocs!(execute!, plan, Cmat) == 0 skip = (VERSION < v"1.11")
 end
diff --git a/test/execution/test_nest.jl b/test/execution/test_nest.jl
new file mode 100644
index 0000000..44368ae
--- /dev/null
+++ b/test/execution/test_nest.jl
@@ -0,0 +1,409 @@
+# Randomized agreement of the five-loop nest with a dense matmul, at block
+# sizes small enough to split every dimension, over real and complex kernels,
+# alpha/beta and the conjugation flags; the once-per-block storage
+# bounds checks; and the closed-form (`affine_ramp`) block description against
+# the buffer path.
+
+include("helpers.jl")
+
+# Agreement is up to summation-order rounding.
+_macro_rtol(::Type{T}, Ka::Integer) where {T} = 50 * max(Ka, 1) * eps(real(T))
+
+# Plan for C[m,n] = A[m,k] * B[k,n], with operands as `op`-carrying views. The
+# 5-argument constructor keeps `op` on the view instead of materializing.
+_macro_op_view(M::AbstractMatrix, op) = StridedView(M, size(M), strides(M), 0, op)
+function _macro_plan(Cmat, Amat, Bmat, kernel, m_block, k_block, n_block; conjA = false, conjB = false, opA = identity, opB = identity)
+    return QuasiStrided.plan_contract(
+        StridedView(Cmat), _macro_op_view(Amat, opA), (1, 2), _macro_op_view(Bmat, opB), (2, 3), (1, 3);
+        kernel = kernel, conjA = conjA, conjB = conjB, m_block = m_block, k_block = k_block, n_block = n_block
+    )
+end
+
+const MACRO_SHAPES = ((Val(4), Val(3)), (Val(8), Val(6)))
+
+# Every constructible (kernel type, shape) for `T`; constructors reject shapes
+# their lane width cannot tile.
+function _macro_kernels(::Type{T}) where {T}
+    ctors = T <: Complex ? (QuasiStrided.PlanarKernel, QuasiStrided.OneMKernel) : (ScalarKernel, SIMDKernel)
+    ks = Any[]
+    for ctor in ctors, (m, n) in MACRO_SHAPES
+        k = try
+            ctor(m, n, T)
+        catch err
+            err isa ArgumentError || rethrow()
+            nothing
+        end
+        k === nothing || push!(ks, k)
+    end
+    return ks
+end
+
+# Scalars that include the 0 and 1 shortcuts and are genuinely complex
+# otherwise, so a dropped imaginary part cannot pass.
+function _macro_scalar(rng, ::Type{T}) where {T}
+    r = rand(rng)
+    r < 0.1 && return zero(T)
+    r < 0.2 && return one(T)
+    return T <: Complex ? T(rand(rng, -3.0:0.5:3.0), rand(rng, -3.0:0.5:3.0)) : T(rand(rng, -3.0:0.5:3.0))
+end
+
+@testset "macro driver: randomized agreement vs dense matmul ($T)" for T in (Float64, Float32, ComplexF64, ComplexF32)
+    rng = MersenneTwister(0x5A17_D817)
+    kernels = _macro_kernels(T)
+    @test !isempty(kernels)
+    for kernel in kernels, i in 1:(T <: Complex ? 12 : 5)
+        Ma, Ka, Na = rand(rng, 1:37, 3)
+        m_block, k_block, n_block = rand(rng, 1:13, 3)
+        conjA, conjB = rand(rng, Bool, 2)
+        alpha, beta = _macro_scalar(rng, T), _macro_scalar(rng, T)
+        Amat, Bmat = randn(rng, T, Ma, Ka), randn(rng, T, Ka, Na)
+        # A NaN-poisoned C whenever beta == 0: it must never be read.
+        Cstart = iszero(beta) ? fill(T(NaN), Ma, Na) : randn(rng, T, Ma, Na)
+        kw = (; conjA, conjB)
+
+        Aeff = T <: Complex && conjA ? conj.(Amat) : Amat
+        Beff = T <: Complex && conjB ? conj.(Bmat) : Bmat
+        expected = iszero(beta) ? alpha .* (Aeff * Beff) : alpha .* (Aeff * Beff) .+ beta .* Cstart
+
+        C = copy(Cstart)
+        QuasiStrided.execute!(_macro_plan(C, Amat, Bmat, kernel, m_block, k_block, n_block; kw...), alpha, beta)
+        ok = isapprox(C, expected; rtol = _macro_rtol(T, Ka))
+        ok || @error "macro driver case $i failed" kernel Ma Ka Na m_block k_block n_block kw alpha beta
+        @test ok
+    end
+end
+
+@testset "macro driver: permuted, zero-stride, negative-stride and sliced views" begin
+    # A[a,k,b] independent of b (zero stride), viewed permuted as (k,b,a);
+    # B[k,n] reversed along k; C a slice with a nonzero offset.
+    a_n, k_n, b_n, n_n = 7, 11, 5, 9
+    Aperm = permutedims(StridedView(vec(randn(a_n, k_n)), (a_n, k_n, b_n), (1, a_n, 0), 0), (2, 3, 1))
+    Bneg = StridedView(randn(k_n * n_n), (k_n, n_n), (-1, k_n), k_n - 1)
+    Cbig = randn(a_n + 2, n_n + 3, b_n + 1)
+    Csub = view(Cbig, 2:(a_n + 1), 2:(n_n + 1), 1:b_n)
+    Cstart = copy(Csub)
+    Cref = _brute_ref(Array(Aperm), (2, 3, 1), Array(Bneg), (2, 4), Cstart, (1, 4, 3), 1.3, 0.6)
+    plan = QuasiStrided.plan_contract(
+        StridedView(Csub), Aperm, (2, 3, 1), Bneg, (2, 4), (1, 4, 3);
+        kernel = ScalarKernel(Val(4), Val(3), Float64), m_block = 3, k_block = 4, n_block = 3
+    )
+    QuasiStrided.execute!(plan, 1.3, 0.6)
+    @test isapprox(Array(Csub), Cref; rtol = _macro_rtol(Float64, k_n))
+end
+
+@testset "macro driver: irregular sliver at a nonzero offset (multi-label M)" begin
+    # M = (a, q): A's map folds across the a/q boundary, C's (padded) does not,
+    # so the second M sliver of the first block is irregular.
+    a_n, q_n, k_n, n_n = 7, 2, 5, 3
+    Amat, Bmat = randn(a_n, q_n, k_n), randn(k_n, n_n)
+    Cstart = randn(a_n, q_n, n_n)
+    Cref = _brute_ref(Amat, (1, 2, 3), Bmat, (3, 4), Cstart, (1, 2, 4), 1.7, -0.4)
+    Cbig = randn(a_n + 3, q_n, n_n)
+    Csub = view(Cbig, 1:a_n, :, :)
+    Csub .= Cstart
+    plan = QuasiStrided.plan_contract(
+        StridedView(Csub), StridedView(Amat), (1, 2, 3), StridedView(Bmat), (3, 4), (1, 2, 4);
+        kernel = ScalarKernel(Val(4), Val(3), Float64), m_block = 8, k_block = 5, n_block = 3
+    )
+    QuasiStrided.execute!(plan, 1.7, -0.4)
+    @test isapprox(Array(Csub), Cref; rtol = _macro_rtol(Float64, k_n))
+end
+
+@testset "macro driver: several blocks at the default blocking ($(nameof(typeof(k))){$T})" for T in (ComplexF64, ComplexF32), k in _macro_kernels(T)
+    QuasiStrided.tile_size(k, 1) == 8 || continue
+    b = QuasiStrided.default_blocking(k)
+    Ma, Ka, Na = b.m_block + QuasiStrided.tile_size(k, 1), b.k_block + 1, b.n_block + QuasiStrided.tile_size(k, 2)
+    Amat, Bmat = randn(MersenneTwister(1), T, Ma, Ka), randn(MersenneTwister(2), T, Ka, Na)
+    Cstart = randn(MersenneTwister(3), T, Ma, Na)
+    C = copy(Cstart)
+    alpha, beta = T(1.5, -0.25), T(-0.5, 0.75)
+    # Conjugation from both sources: the flag on A, a conjugating op on B.
+    plan = _macro_plan(C, Amat, Bmat, k, nothing, nothing, nothing; conjA = true, opB = adjoint)
+    @test plan.blocking.m_block < Ma && plan.blocking.k_block < Ka && plan.blocking.n_block < Na
+    QuasiStrided.execute!(plan, alpha, beta)
+    @test isapprox(C, alpha .* (conj.(Amat) * conj.(Bmat)) .+ beta .* Cstart; rtol = _macro_rtol(T, Ka))
+end
+
+@testset "macro driver: conjugation sources compose by XOR ($T)" for T in (ComplexF64, ComplexF32)
+    kernel = first(_macro_kernels(T))
+    Amat, Bmat = randn(MersenneTwister(1), T, 11, 9), randn(MersenneTwister(2), T, 9, 7)
+    rtol = _macro_rtol(T, 9)
+    # (conjA, opA, opB) => (A conjugated, B conjugated). The first two pin the
+    # cases a `||` rule or a `op === conj` test would get wrong.
+    for ((conjA, opA, opB), (ca, cb)) in (
+            (true, conj, identity) => (false, false), (false, adjoint, identity) => (true, false),
+            (false, identity, transpose) => (false, false),
+        )
+        C = zeros(T, 11, 7)
+        QuasiStrided.execute!(_macro_plan(C, Amat, Bmat, kernel, 4, 3, 4; conjA, opA, opB), one(T), zero(T))
+        Aeff, Beff = ca ? conj.(Amat) : Amat, cb ? conj.(Bmat) : Bmat
+        @test isapprox(C, Aeff * Beff; rtol)
+        @test !isapprox(C, (ca ? Amat : conj.(Amat)) * Beff; rtol)
+    end
+end
+
+@testset "classify_slivers! accumulates the TRUE block range" begin
+    # The range handed to `checked_span_bounds` is the true min/max over the
+    # whole block; a too-small range would silently under-validate.
+    Random.seed!(20260922)
+    for trial in 1:150
+        blocklen = rand(1:24)
+        reg = rand(1:5)
+        nsliv = cld(blocklen, reg)
+        buf1 = [rand(-40:40) for _ in 1:blocklen]
+        buf2 = [rand(-40:40) for _ in 1:blocklen]
+        d1 = Vector{BlockDescriptor}(undef, nsliv)
+        d2 = Vector{BlockDescriptor}(undef, nsliv)
+        (r1, r2) = QuasiStrided.classify_slivers!(QuasiStrided.GroupBuffers((buf1, buf2), (d1, d2)), blocklen, reg, nsliv)
+        @test r1 == (minimum(buf1), maximum(buf1))
+        @test r2 == (minimum(buf2), maximum(buf2))
+        @test all(s -> d1[s].count == min(reg, blocklen - (s - 1) * reg), 1:nsliv)
+    end
+
+    # Both extremes in an interior sliver.
+    blocklen, reg = 18, 6                      # slivers 1:6, 7:12, 13:18
+    buf1 = fill(1, blocklen); buf1[8] = 500; buf1[9] = -500   # sliver 2, irregular
+    buf2 = fill(2, blocklen)
+    buf2[7:12] .= [0, -7, -14, -21, -28, -35]                 # sliver 2, REGULAR, stride -7
+    d1 = Vector{BlockDescriptor}(undef, 3)
+    d2 = Vector{BlockDescriptor}(undef, 3)
+    (r1, r2) = QuasiStrided.classify_slivers!(QuasiStrided.GroupBuffers((buf1, buf2), (d1, d2)), blocklen, reg, 3)
+    @test !d1[2].regular && d1[2].count == 6        # scan branch
+    @test d2[2].regular && d2[2].stride == -7       # affine branch, negative stride
+    @test r1 == (-500, 500)
+    @test r2 == (-35, 2)
+    @test QuasiStrided.descriptor_offset_range(d1[1], buf1, 0) == (1, 1)
+    @test QuasiStrided.descriptor_offset_range(d1[3], buf1, 12) == (1, 1)
+end
+
+# Counts `length` calls: the hoisted bounds check asks once per operand per
+# block, a per-tile check once per tile. Not a `DenseVector`, so the fast paths
+# stay off.
+mutable struct CountingStorage{T} <: AbstractVector{T}
+    data::Vector{T}
+    n::Int
+end
+CountingStorage(v::Vector{T}) where {T} = CountingStorage{T}(v, 0)
+Base.size(c::CountingStorage) = size(c.data)
+Base.length(c::CountingStorage) = (c.n += 1; length(c.data))
+Base.@propagate_inbounds Base.getindex(c::CountingStorage, i::Int) = c.data[i]
+Base.@propagate_inbounds Base.setindex!(c::CountingStorage, v, i::Int) = (c.data[i] = v)
+Base.IndexStyle(::Type{<:CountingStorage}) = IndexLinear()
+
+@testset "the destination bounds check runs once per macro block" begin
+    Ma, Ka, Na = 40, 7, 30
+    kernel = SIMDKernel(Val(8), Val(6), Float64)
+    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
+    Cmat = zeros(Ma, Na)
+    base = plan_contract(
+        StridedView(Cmat), StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3),
+        (1, 3); kernel = kernel
+    )
+
+    # One (N, K, M) block, so the hoisted checks run once.
+    @test base.blocking.m_block >= Ma && base.blocking.n_block >= Na && base.blocking.k_block >= Ka
+    m_tiles = cld(Ma, tile_size(kernel, 1))
+    n_tiles = cld(Na, tile_size(kernel, 2))
+    ntiles = m_tiles * n_tiles
+    @test ntiles >= 20   # a per-tile check would be at least this many calls
+
+    cstore = CountingStorage(zeros(Ma * Na))
+    astore = CountingStorage(copy(vec(Amat)))
+    bstore = CountingStorage(copy(vec(Bmat)))
+    p = ContractPlan(base; Astorage = astore, Abase = 0, Bstorage = bstore, Bbase = 0, Cstorage = cstore, Cbase = 0)
+    astore.n = 0; bstore.n = 0; cstore.n = 0
+    execute!(p, 1.0, 0.0)
+    @test reshape(cstore.data, Ma, Na) ≈ Amat * Bmat
+
+    # `--check-bounds=yes` (as under `Pkg.test`) also runs the per-tile and
+    # per-sliver checks that `@inbounds` skips.
+    forced = Base.JLOptions().check_bounds == 1
+    @test cstore.n == 1 + forced * ntiles
+    @test astore.n == 1 + forced * m_tiles
+    @test bstore.n == 1
+end
+
+@testset "a block that must be rejected is still rejected" begin
+    Ma, Ka, Na = 40, 7, 30
+    kernel = SIMDKernel(Val(8), Val(6), Float64)
+    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
+    Cmat = zeros(Ma, Na)
+    base = plan_contract(
+        StridedView(Cmat), StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3),
+        (1, 3); kernel = kernel
+    )
+
+    function replan(;
+            Cstorage = vec(Cmat), Astorage = vec(Amat), Bstorage = vec(Bmat),
+            Cbase = 0, Abase = 0, Bbase = 0
+        )
+        return ContractPlan(base; Astorage, Abase, Bstorage, Bbase, Cstorage, Cbase)
+    end
+
+    # One element short: rejected before anything is written.
+    short_C = zeros(Ma * Na - 1)
+    @test_throws BoundsError execute!(replan(Cstorage = short_C), 1.0, 0.0)
+    @test all(iszero, short_C)
+
+    @test_throws BoundsError execute!(replan(Cbase = -1), 1.0, 0.0)
+
+    @test_throws BoundsError execute!(replan(Astorage = zeros(Ma * Ka - 1)), 1.0, 0.0)
+    @test_throws BoundsError execute!(replan(Bstorage = zeros(Ka * Na - 1)), 1.0, 0.0)
+    @test_throws BoundsError execute!(replan(Abase = -1), 1.0, 0.0)
+    @test_throws BoundsError execute!(replan(Bbase = -1), 1.0, 0.0)
+
+    exact = zeros(Ma * Na)
+    execute!(replan(Cstorage = exact), 1.0, 0.0)
+    @test reshape(exact, Ma, Na) ≈ Amat * Bmat
+end
+
+@testset "rejection when the binding address is in an INTERIOR sliver" begin
+    # C[m,n1,n2] = A[m,k] * B[k,n1,n2] with C reversed along n2: the N
+    # offsets climb within each n1 run and fall at its boundary, so the block
+    # maximum sits in an interior, irregular sliver (2 of 7).
+    M, K, N1, N2 = 20, 4, 13, 3
+    kernel = SIMDKernel(Val(8), Val(6), Float64)
+    Amat = randn(M, K)
+    Barr = randn(K, N1, N2)
+    Cfull = zeros(M, N1, N2)
+    Cr = view(Cfull, :, :, N2:-1:1)
+    Av, Bv, Cv = StridedView(Amat), StridedView(Barr), StridedView(Cr)
+
+    base = plan_contract(Cv, Av, (1, 2), Bv, (2, 3, 4), (1, 3, 4); kernel = kernel)
+    @test base.Astorage === parent(Av)                   # no M/N swap: M's run is 20 >= 8
+    @test !first(QuasiStrided.affine_ramp(base.ngroup))            # the buffer path, not the ramp path
+    n_length = axis_length(base.ngroup)
+    @test n_length == N1 * N2
+    @test base.blocking.n_block >= n_length                         # one N block, so 7 slivers
+    nsliv = cld(n_length, tile_size(kernel, 2))
+    @test nsliv == 7
+
+    noffs = [offsets(base.ngroup, q)[2] for q in 0:(n_length - 1)]
+    binding = argmax(noffs) - 1                          # zero-based logical coordinate
+    @test binding == N1 - 1
+    @test 0 < binding ÷ tile_size(kernel, 2) < nsliv - 1           # a strictly interior sliver
+    @test maximum(noffs[1:tile_size(kernel, 2)]) < noffs[binding + 1]                 # not the first
+    @test maximum(noffs[(1 + (nsliv - 1) * tile_size(kernel, 2)):end]) < noffs[binding + 1]  # not the last
+
+    execute!(base, 1.0, 0.0)
+    ref = zeros(M, N1, N2)
+    for m in 1:M, n1 in 1:N1, n2 in 1:N2
+        ref[m, n1, n2] = sum(Amat[m, k] * Barr[k, n1, n2] for k in 1:K)
+    end
+    @test Cr ≈ ref
+
+    # One element short: only the address at `binding` overflows.
+    short_C = zeros(M * N1 * N2 - 1)
+    pshort = ContractPlan(base; Cstorage = short_C)
+    @test_throws BoundsError execute!(pshort, 1.0, 0.0)
+    @test all(iszero, short_C)                            # nothing written before the throw
+
+    # A first- or last-sliver-only range would accept it.
+    moffs = [offsets(base.mgroup, q)[2] for q in 0:(axis_length(base.mgroup) - 1)]
+    mrange = (minimum(moffs), maximum(moffs))
+    NR = tile_size(kernel, 2)
+    truerange = (minimum(noffs), maximum(noffs))
+    firstonly = (minimum(noffs[1:NR]), maximum(noffs[1:NR]))
+    lastonly = let tail = noffs[(1 + (nsliv - 1) * NR):end]
+        (minimum(tail), maximum(tail))
+    end
+    shortlen = length(short_C)
+    @test_throws BoundsError QuasiStrided.checked_span_bounds(base.Cbase, mrange, truerange, shortlen)
+    @test QuasiStrided.checked_span_bounds(base.Cbase, mrange, firstonly, shortlen) === nothing
+    @test QuasiStrided.checked_span_bounds(base.Cbase, mrange, lastonly, shortlen) === nothing
+
+    # An interior-sliver minimum: the base shifted down by one.
+    plow = ContractPlan(base; Cstorage = zeros(M * N1 * N2), Cbase = base.Cbase - 1)
+    @test_throws BoundsError execute!(plow, 1.0, 0.0)
+end
+
+@testset "ramp_slivers! reproduces classify_slivers! exactly" begin
+    Random.seed!(31337)
+    for trial in 1:150
+        D = rand(1:3)
+        lens = ntuple(_ -> rand(1:5), D)
+        # A ramp by construction half the time.
+        strd = if rand() < 0.5
+            s1 = rand(-5:5); s2 = rand(-5:5)
+            acc = 1
+            t1 = Int[]; t2 = Int[]
+            for d in 1:D
+                push!(t1, acc * s1); push!(t2, acc * s2)
+                acc *= lens[d]
+            end
+            (Tuple(t1), Tuple(t2))
+        else
+            ntuple(_ -> ntuple(_ -> rand(-5:5), D), 2)
+        end
+        g = AxisGroup(lens, strd)
+        Q = axis_length(g)
+        Q == 0 && continue
+        (isramp, steps) = QuasiStrided.affine_ramp(g)
+        isramp || continue
+
+        reg = rand(1:4)
+        first = rand(0:(Q - 1))
+        blocklen = rand(1:(Q - first))
+        nsliv = cld(blocklen, reg)
+
+        buf1 = zeros(Int, blocklen); buf2 = zeros(Int, blocklen)
+        d1 = Vector{BlockDescriptor}(undef, nsliv)
+        d2 = Vector{BlockDescriptor}(undef, nsliv)
+        fill_offsets!((buf1, buf2), g, first, blocklen)
+        want = QuasiStrided.classify_slivers!(QuasiStrided.GroupBuffers((buf1, buf2), (d1, d2)), blocklen, reg, nsliv)
+
+        r1 = Vector{BlockDescriptor}(undef, nsliv)
+        r2 = Vector{BlockDescriptor}(undef, nsliv)
+        got = QuasiStrided.ramp_slivers!(QuasiStrided.GroupBuffers((buf1, buf2), (r1, r2)), steps[1], steps[2], first, blocklen, reg, nsliv)
+
+        for s in 1:nsliv
+            @test r1[s].base == d1[s].base && r1[s].stride == d1[s].stride
+            @test r1[s].count == d1[s].count && r1[s].regular == d1[s].regular
+            @test r2[s].base == d2[s].base && r2[s].stride == d2[s].stride
+            @test r2[s].count == d2[s].count && r2[s].regular == d2[s].regular
+        end
+        @test got == want
+    end
+end
+
+@testset "ramp and buffer paths give the same contraction" begin
+    Random.seed!(424242)
+    kernel = SIMDKernel(Val(8), Val(6), Float64)
+
+    function check(Csz, Asz, Bsz, indA, indB, indC; kw...)
+        A = randn(Asz); B = randn(Bsz); C = randn(Csz)
+        C0 = copy(C)
+        p = plan_contract(
+            StridedView(C), StridedView(A), indA, StridedView(B), indB, indC; kw...
+        )
+        execute!(p, 2.0, -0.5)
+        @test C ≈ _lo_reference(C0, A, indA, B, indB, indC; alpha = 2.0, beta = -0.5)
+        return p
+    end
+
+    p = check((40, 30), (40, 7), (7, 30), (1, 2), (2, 3), (1, 3); kernel = kernel)
+    @test first(QuasiStrided.affine_ramp(p.mgroup)) && first(QuasiStrided.affine_ramp(p.ngroup)) &&
+        first(QuasiStrided.affine_ramp(p.kgroup))
+
+    # ao2mo_2: a ramp on M and K but not on N.
+    d = 6
+    p = check(
+        (d, d, d, d), (d, d), (d, d, d, d),
+        (1, 2), (3, 1, 4, 5), (3, 2, 4, 5); kernel = kernel
+    )
+    @test first(QuasiStrided.affine_ramp(p.mgroup))
+    @test first(QuasiStrided.affine_ramp(p.kgroup))
+    @test !first(QuasiStrided.affine_ramp(p.ngroup))   # the mixed path, both branches live
+
+    # Several macro blocks, so ramp descriptors start at a nonzero `first`.
+    check(
+        (40, 30), (40, 21), (21, 30), (1, 2), (2, 3), (1, 3);
+        kernel = kernel, m_block = 8, k_block = 5, n_block = 6
+    )
+    # Non-ramp composites on both sides (rank-4 operands, non-folding order).
+    d = 5
+    check(
+        (d, d, d, d, d, d), (d, d, d, d), (d, d, d, d),
+        (1, 2, 3, 4), (3, 5, 6, 7), (4, 6, 7, 1, 2, 5); kernel = kernel
+    )
+end
diff --git a/test/execution/test_outer.jl b/test/execution/test_outer.jl
index f827987..4c11881 100644
--- a/test/execution/test_outer.jl
+++ b/test/execution/test_outer.jl
@@ -1,40 +1,11 @@
 # The outer-product path: `execute!` on a real `K == 1` plan with unit-stride M
 # in A and C streams `alpha * A * B[n]` column by column. Results match the
-# nest and the reference (`≈`: the two differ on a signed zero).
+# reference.
 
-_outer_takes(plan) = _path_of(plan) isa QuasiStrided._OuterPath
-
-# `C[a, b] = A[a] * B[b]` at extents `(M, N)`:
-#   :bstrided  B every other element of a longer vector
-#   :cpermC    C stored [b, a] (M not unit-stride in C)
-#   :agap      A every other element (M not unit-stride in A)
-#   :coffset   C a view with an offset, M unit-stride
-#   :multiM    M a composite of two labels that fold to one ramp
-function _outer_maker(::Type{T}, M, N, seed; variant = :plain, Cfill = nothing) where {T}
-    return function ()
-        rng = MersenneTwister(seed)
-        a, b = randn(rng, T, M), randn(rng, T, N)
-        C = Cfill === nothing ? randn(rng, T, M, N) : fill(convert(T, Cfill), M, N)
-        gapped(v, r) = (big = fill(convert(T, NaN), 2 * length(v)); big[r] .= v; StridedView(view(big, r)))
-        Av = variant === :agap ? gapped(a, 1:2:(2M)) : StridedView(a)
-        Bv = variant === :bstrided ? gapped(b, 2:2:(2N)) : StridedView(b)
-        variant === :multiM &&
-            return (StridedView(reshape(C, 4, M ÷ 4, N)), StridedView(reshape(a, 4, M ÷ 4)), (1, 2), Bv, (3,), (1, 2, 3))
-        Cv = if variant === :cpermC
-            permutedims(StridedView(permutedims(C, (2, 1))), (2, 1))
-        elseif variant === :coffset
-            big = fill(convert(T, NaN), M + 3, N + 2)
-            big[2:(M + 1), 2:(N + 1)] .= C
-            StridedView(view(big, 2:(M + 1), 2:(N + 1)))
-        else
-            StridedView(C)
-        end
-        return (Cv, Av, (1,), Bv, (2,), (1, 2))
-    end
-end
+include("helpers.jl")
 
 @testset "outer path: which plans it takes ($T)" for T in (Float64, Float32, ComplexF64)
-    W = QuasiStrided._dot_lanewidth(T)
+    W = _lanes(T)
     for variant in (:plain, :bstrided, :coffset, :multiM)
         p = plan_contract(_outer_maker(T, 16, 9, 1; variant)()...)
         @test _outer_takes(p) == (T <: Real)
@@ -49,20 +20,18 @@ end
     @test !_outer_takes(_mm_plan(zeros(T, 16, 9), randn(T, 16, 2), randn(T, 2, 9)))
 end
 
-@testset "outer path: matches the nest and the reference ($T)" for T in (Float64, Float32)
-    W = QuasiStrided._dot_lanewidth(T)
+@testset "outer path: matches the reference ($T)" for T in (Float64, Float32)
+    W = _lanes(T)
     for (idx, (M, N)) in enumerate(((W, 1), (2W + 1, 13), (63, 63))), variant in (:plain, :bstrided, :coffset),
             (alpha, beta) in ((1.0, 0.0), (2.5, -0.75), (1.0, 1.0))
         mk = _outer_maker(T, M, N, 10 + idx; variant)
         C_out, plan = _run_fresh(execute!, mk, alpha, beta)
-        C_nest, _ = _run_fresh(_run_nest!, mk, alpha, beta)
         @test _outer_takes(plan) == (axis_length(plan.mgroup) >= W)
-        @test C_out ≈ C_nest
         @test C_out ≈ _ref_of(mk, alpha, beta)
     end
     # Composite M, several N blocks; and a singleton M beside a long N, which
     # swaps roles and runs on the 9-long N with a scalar tail.
-    for (mk, kw) in ((_outer_maker(T, 32, 40, 50; variant = :multiM), (nc = 6,)), (_outer_maker(T, 1, 9, 77), (;)))
+    for (mk, kw) in ((_outer_maker(T, 32, 40, 50; variant = :multiM), (n_block = 6,)), (_outer_maker(T, 1, 9, 77), (;)))
         C_out, plan = _run_fresh(execute!, mk, 1.5, 0.5; kw...)
         @test _outer_takes(plan) == (axis_length(plan.mgroup) >= W)
         @test C_out ≈ _ref_of(mk, 1.5, 0.5)
@@ -74,7 +43,7 @@ end
 end
 
 @testset "outer path: bounds, allocations, the backend ($T)" for T in (Float64, Float32)
-    W = QuasiStrided._dot_lanewidth(T)
+    W = _lanes(T)
     M, N = 2W, 5
     # One element short on each operand: rejected before any write.
     for (sa, sb, sc) in ((M - 1, N, M * N), (M, N - 1, M * N), (M, N, M * N - 1))
@@ -86,7 +55,7 @@ end
         @test_throws BoundsError execute!(plan, 1.0, 0.0)
         @test all(iszero, plan.Cstorage)
     end
-    plan = plan_contract(_outer_maker(T, 64, 50, 6)()...; oracle = false, nc = 12)
+    plan = plan_contract(_outer_maker(T, 64, 50, 6)()...; n_block = 12)
     @test _outer_takes(plan)
     execute!(plan, 1.0, 0.0)
     @test (@allocated execute!(plan, 1.0, 0.0)) == 0 skip = (VERSION < v"1.11")
@@ -95,20 +64,3 @@ end
     TO.tensorcontract!(C, a, pA, false, b, pB, false, pAB, 1.0, 0.0, QuasiStridedBackend())
     @test C ≈ a * transpose(b)
 end
-
-@testset "the mode switches override path selection" begin
-    d, o, u = QuasiStrided._DOT_MODE, QuasiStrided._OUTER_MODE, QuasiStrided._UNPACKED_B_MODE
-    pd = plan_contract(_mm_maker(Float64, 1, 64, 9, 1)()...)
-    po = plan_contract(_outer_maker(Float64, 16, 9, 1)()...)
-    pu = plan_contract(_mm_maker(Float64, 20, 12, 9, 1)()...)
-    ps = plan_contract(_mm_maker(Float64, 20, 12, 9, 1; B = :transposed)()...)
-    @test _dot_takes(pd) && _outer_takes(po) && _ub_takes(pu) && !_ub_takes(ps)
-    try
-        d[] = o[] = u[] = :never
-        @test !_dot_takes(pd) && !_outer_takes(po) && !_ub_takes(pu)
-        u[] = :always
-        @test _ub_takes(ps)
-    finally
-        d[] = o[] = u[] = :auto
-    end
-end
diff --git a/test/execution/test_scalar_vs_simd.jl b/test/execution/test_scalar_vs_simd.jl
deleted file mode 100644
index 4c1079d..0000000
--- a/test/execution/test_scalar_vs_simd.jl
+++ /dev/null
@@ -1,11 +0,0 @@
-@testset "driver: ScalarKernel and SIMDKernel agree through execute!" begin
-    rng = MersenneTwister(20260908)
-    Amat, Bmat, Cstart = rand(rng, 11, 13), rand(rng, 13, 9), rand(rng, 11, 9)
-    for (m, n, kc) in ((Val(8), Val(6), 5), (Val(4), Val(3), 4))
-        Cs, Cv = copy(Cstart), copy(Cstart)
-        execute!(_mm_plan(Cs, Amat, Bmat; kernel = ScalarKernel(m, n, Float64), kc = kc), 2.5, 0.75)
-        execute!(_mm_plan(Cv, Amat, Bmat; kernel = SIMDKernel(m, n, Float64), kc = kc), 2.5, 0.75)
-        @test Cs ≈ 2.5 .* (Amat * Bmat) .+ 0.75 .* Cstart
-        @test isapprox(Cs, Cv; atol = 1.0e-10)
-    end
-end
diff --git a/test/execution/test_unpackedb.jl b/test/execution/test_unpackedb.jl
index a20f38a..6d59547 100644
--- a/test/execution/test_unpackedb.jl
+++ b/test/execution/test_unpackedb.jl
@@ -1,9 +1,9 @@
 # The unpacked-B path: `execute!` reads B in place through an `UnpackedBView`
-# where `_unpacked_b_rule` says so. The result must be bitwise the packed nest's
+# where `unpacked_b_rule` says so. The result must be bitwise the packed nest's
 # (same arithmetic, same values, different address), and the packed-B buffer
 # must stay untouched.
 
-_ub_takes(plan) = _path_of(plan) isa QuasiStrided._NestPath{true}
+include("helpers.jl")
 
 # Poison the packed-B buffer, then run.
 function _ub_run!(plan, alpha, beta)
@@ -16,21 +16,21 @@ _ub_untouched(plan) = all(isnan, plan.workspace.packed_b)
 # and the reference.
 function _ub_check(mk, alpha, beta; conjA = false, conjB = false, plankw...)
     C_unp, plan = _run_fresh(_ub_run!, mk, alpha, beta; conjA, conjB, plankw...)
-    C_packed, _ = _run_fresh(_run_nest!, mk, alpha, beta; conjA, conjB, plankw...)
+    C_packed, _ = _run_nest(mk, alpha, beta; conjA, conjB, plankw...)
     @test _ub_takes(plan)
     @test _ub_untouched(plan)
     @test C_unp == C_packed
     return @test C_unp ≈ _ref_of(mk, alpha, beta; conjA, conjB)
 end
 
-const _UB_TYPES = (Float64, Float32, ComplexF64, ComplexF32)
+const UB_TYPES = (Float64, Float32, ComplexF64, ComplexF32)
 
-@testset "unpacked B: which plans read B in place ($T)" for T in _UB_TYPES
+@testset "unpacked B: which plans read B in place ($T)" for T in UB_TYPES
     planof(M; B = :dense, kw...) = plan_contract(_mm_maker(T, M, 12, 9, 1; B)()...; kw...)
     @test _ub_takes(planof(20)) && _ub_takes(planof(20; B = :reversed))
     # K strided in B stays packed, as does an M above the cutoff.
     @test !_ub_takes(planof(20; B = :transposed)) && !_ub_takes(planof(20; B = :gap))
-    MMAX = QuasiStrided._UNPACKED_B_MMAX
+    MMAX = QuasiStrided.UNPACKED_B_MMAX
     @test _ub_takes(planof(MMAX)) && !_ub_takes(planof(MMAX + 1))
     # K = 1 (a rank-0 K group, step 0).
     Kv = (StridedView(zeros(T, 20, 9)), StridedView(randn(T, 20)), (1,), StridedView(randn(T, 9)), (2,), (1, 2))
@@ -46,18 +46,18 @@ const _UB_TYPES = (Float64, Float32, ComplexF64, ComplexF32)
     @test !_ub_takes(planof(20; kernel = k))
 end
 
-@testset "unpacked B: bitwise the packed nest ($T)" for T in _UB_TYPES
+@testset "unpacked B: bitwise the packed nest ($T)" for T in UB_TYPES
     for (idx, (M, K, N)) in enumerate(((2, 3, 1), (17, 9, 13), (33, 64, 5))), B in (:dense, :reversed),
             (alpha, beta) in ((1.0, 0.0), (2.5, -0.75), (1.0, 1.0))
         _ub_check(_mm_maker(T, M, K, N, 10 + idx; B), alpha, beta)
     end
-    # Several jc/pc/ic blocks with tails, explicit kernel shapes.
+    # Several N/K/M blocks with tails, explicit kernel shapes.
     k0 = plan_contract(_mm_maker(T, 64, 8, 8, 2)()...).kernel
     W = lanewidth(k0)
     kernels = T <: Real ? (k0, SIMDKernel(Val(8), Val(6), T)) :
         (k0, QuasiStrided.PlanarKernel(Val(W), Val(5), T, Val(W)), QuasiStrided.FMAddSubKernel(Val(W), Val(5), T, Val(W)))
-    for k in kernels, (mc, kc, nc) in ((8, 3, 6), (40, 1, 100))
-        _ub_check(_mm_maker(T, 2 * mr(k) + 1, 13, 2 * nr(k) + 1, 3), 1.5, 0.5; kernel = k, mc, kc, nc)
+    for k in kernels, (m_block, k_block, n_block) in ((8, 3, 6), (40, 1, 100))
+        _ub_check(_mm_maker(T, 2 * tile_size(k, 1) + 1, 13, 2 * tile_size(k, 2) + 1, 3), 1.5, 0.5; kernel = k, m_block, k_block, n_block)
     end
     # beta = 0 never reads a NaN C.
     _ub_check(_mm_maker(T, 10, 6, 7, 3; Cfill = NaN), 2.0, 0.0)
@@ -91,14 +91,14 @@ end
     @test all(iszero, Cm)
 end
 
-@testset "unpacked B: allocation-free, and through the backend ($T)" for T in _UB_TYPES
+@testset "unpacked B: allocation-free, and through the backend ($T)" for T in UB_TYPES
     Amat, Bmat, Cmat = randn(T, 40, 50), randn(T, 50, 37), zeros(T, 40, 37)
-    plan = _mm_plan(Cmat, Amat, Bmat; kc = 16, nc = 12)
+    plan = _mm_plan(Cmat, Amat, Bmat; k_block = 16, n_block = 12)
     @test _ub_takes(plan)
     allocs = _steady_allocs!(execute!, plan, Cmat)
     @test allocs == 0 skip = (VERSION < v"1.11")
     @test Cmat ≈ Amat * Bmat
-    # The backend runs the path predicted before planning (`_path_hint`).
+    # The backend plans and runs in one call.
     fill!(Cmat, 0)
     TO.tensorcontract!(Cmat, Amat, ((1,), (2,)), false, Bmat, ((1,), (2,)), false, ((1, 2), ()), 1.0, 0.0, QuasiStridedBackend())
     @test Cmat ≈ Amat * Bmat
diff --git a/test/execution/test_workspace.jl b/test/execution/test_workspace.jl
index 73c1b68..bec3dca 100644
--- a/test/execution/test_workspace.jl
+++ b/test/execution/test_workspace.jl
@@ -1,166 +1,51 @@
-# ContractWorkspace, the `workspace`/`allocator`/`oracle` keywords, and the
-# SIMDKernel default.
-
-_ws_lengths(ws) = [
-    length(getfield(ws, f)) for f in fieldnames(typeof(ws)) if getfield(ws, f) isa AbstractVector
-]
-
-@testset "plan_contract: SIMDKernel is the engine-wide default kernel" begin
-    for T in (Float64, Float32)
-        Random.seed!(5150)
-        Amat, Bmat = randn(T, 9, 10), randn(T, 10, 8)
-        Cmat = zeros(T, 9, 8)
-        plan = _mm_plan(Cmat, Amat, Bmat)
-
-        # The shape is hardware- and extent-dependent: pin the resolution.
-        @test plan.kernel isa QuasiStrided.SIMDKernel
-        @test QuasiStrided.scalartype(plan.kernel) === T
-        @test plan.kernel === QuasiStrided._default_kernel(T, size(Amat, 1), size(Bmat, 2))
-        execute!(plan, one(T), zero(T))
-        @test Cmat ≈ Amat * Bmat
-
-        Cmat2 = zeros(T, 9, 8)
-        contract!(
-            StridedView(Cmat2), one(T), StridedView(Amat), (1, 2),
-            StridedView(Bmat), (2, 3), zero(T), (1, 3)
-        )
-        @test Cmat2 == Cmat
-    end
-end
-
-@testset "ContractWorkspace: reuse across shapes is bitwise identical to fresh plans" begin
-    kernel = ScalarKernel(Val(4), Val(3), Float64)
-    mc, kc, nc = 8, 6, 7
-    alpha, beta = 1.75, -0.5
+# ContractWorkspace and the `allocator` keyword.
 
-    # Not monotone: sized by the first, grown by the second, then oversized.
-    shapes = ((13, 11, 10), (23, 19, 17), (4, 3, 2), (9, 10, 8), (1, 1, 1), (16, 5, 6))
+include("helpers.jl")
 
-    ws = nothing
-    lengths_before = nothing
-    for (idx, (Ma, Ka, Na)) in enumerate(shapes)
-        Random.seed!(31_000 + idx)
-        Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-        Cstart = randn(Ma, Na)
-
-        Cfresh = copy(Cstart)
-        execute!(_mm_plan(Cfresh, Amat, Bmat; kernel = kernel, mc = mc, kc = kc, nc = nc), alpha, beta)
-
-        Creuse = copy(Cstart)
-        plan = _mm_plan(
-            Creuse, Amat, Bmat;
-            kernel = kernel, mc = mc, kc = kc, nc = nc, workspace = ws
-        )
-        execute!(plan, alpha, beta)
-
-        @test Creuse == Cfresh
-
-        if ws !== nothing
-            @test plan.workspace === ws
-            @test all(_ws_lengths(ws) .>= lengths_before)
-        end
-        ws = plan.workspace
-        lengths_before = _ws_lengths(ws)
-    end
-
-    Amat32, Bmat32, Cmat32 = randn(Float32, 4, 4), randn(Float32, 4, 4), zeros(Float32, 4, 4)
-    @test_throws ArgumentError _mm_plan(
-        Cmat32, Amat32, Bmat32;
-        kernel = ScalarKernel(Val(4), Val(3), Float32), workspace = ws
-    )
-end
-
-@testset "ContractWorkspace: an oversized reused buffer is not read beyond its live region" begin
+@testset "ContractWorkspace: plan reuse refills every buffer before reading it" begin
     kernel = ScalarKernel(Val(4), Val(3), Float64)
-    mc, kc, nc = 8, 6, 7
     alpha, beta = 2.5, -0.75
 
     Random.seed!(606)
-    Abig, Bbig = randn(23, 19), randn(19, 17)
-    Cbig = zeros(23, 17)
-    big = _mm_plan(Cbig, Abig, Bbig; kernel = kernel, mc = mc, kc = kc, nc = nc)
-    execute!(big, 1.0, 0.0)
-    ws = big.workspace
-
-    Ma, Ka, Na = 5, 4, 3
-    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-    Cstart = randn(Ma, Na)
-
+    Amat, Bmat = randn(23, 19), randn(19, 17)
+    Cstart = randn(23, 17)
     Cref = copy(Cstart)
-    execute!(_mm_plan(Cref, Amat, Bmat; kernel = kernel, mc = mc, kc = kc, nc = nc), alpha, beta)
+    execute!(_mm_plan(Cref, Amat, Bmat; kernel = kernel, m_block = 8, k_block = 6, n_block = 7), alpha, beta)
+
+    C = copy(Cstart)
+    plan = _mm_plan(C, Amat, Bmat; kernel = kernel, m_block = 8, k_block = 6, n_block = 7)
+    execute!(plan, alpha, beta)
+    copyto!(C, Cstart)
 
-    # Poison every reused buffer: a stale packed slot yields NaN, a stale
-    # offset or descriptor addresses far outside the operand.
+    # A stale packed slot yields NaN, a stale offset or descriptor addresses far
+    # outside the operand.
+    ws = plan.workspace
     fill!(ws.packed_a, NaN)
     fill!(ws.packed_b, NaN)
-    for buf in (ws.m_buf_A, ws.m_buf_C, ws.n_buf_B, ws.n_buf_C, ws.k_buf_A, ws.k_buf_B)
+    for buf in (ws.m.offsets..., ws.n.offsets..., ws.k...)
         fill!(buf, typemin(Int) ÷ 4)
     end
     poison = BlockDescriptor(typemin(Int) ÷ 4, 0, 1, true)
-    for desc in (ws.m_desc_A, ws.m_desc_C, ws.n_desc_B, ws.n_desc_C)
-        fill!(desc, poison)
-    end
-
-    lengths_before = _ws_lengths(ws)
-    Cpoisoned = copy(Cstart)
-    plan = _mm_plan(
-        Cpoisoned, Amat, Bmat;
-        kernel = kernel, mc = mc, kc = kc, nc = nc, workspace = ws
-    )
-    @test _ws_lengths(ws) == lengths_before
-    @test length(ws.packed_a) > cld(Ma, 4) * 4 * min(kc, Ka)
-    @test length(ws.packed_b) > cld(Na, 3) * 3 * min(kc, Ka)
+    foreach(d -> fill!(d, poison), (ws.m.descriptors..., ws.n.descriptors...))
 
     execute!(plan, alpha, beta)
-    @test all(isfinite, Cpoisoned)
-    @test Cpoisoned == Cref
-end
+    @test C == Cref
 
-@testset "plan_contract: oracle = false skips execute_tilewise!'s buffers" begin
-    Random.seed!(909)
-    kernel = ScalarKernel(Val(4), Val(3), Float64)
-    Ma, Ka, Na = 9, 10, 8
-    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-
-    Cmat = zeros(Ma, Na)
-    plan = _mm_plan(Cmat, Amat, Bmat; kernel = kernel, kc = 4, oracle = false)
-    ws = plan.workspace
-
-    @test isempty(ws.tw_packed_a)
-    @test isempty(ws.tw_packed_b)
-    @test isempty(ws.tw_k_buf_A)
-    @test isempty(ws.tw_k_buf_B)
-    # The tile buffers serve the beta-only pass too.
-    @test length(ws.tile_m_buf_A) == 4
-    @test length(ws.tile_n_buf_C) == 3
-
-    execute!(plan, 1.0, 0.0)
-    @test Cmat ≈ Amat * Bmat
-
-    Cstart = randn(Ma, Na)
-    Cbeta = copy(Cstart)
-    execute!(_mm_plan(Cbeta, Amat, Bmat; kernel = kernel, oracle = false), 0.0, 0.5)
-    @test Cbeta ≈ 0.5 .* Cstart
-
-    @test_throws ArgumentError execute_tilewise!(plan, 1.0, 0.0)
-
-    Ctw = zeros(Ma, Na)
-    plan_tw = _mm_plan(Ctw, Amat, Bmat; kernel = kernel, kc = 4, workspace = ws, oracle = true)
-    @test plan_tw.workspace === ws
-    @test !isempty(ws.tw_packed_a)
-    execute_tilewise!(plan_tw, 1.0, 0.0)
-    @test Ctw ≈ Amat * Bmat
+    # The beta-only pass borrows the M/N offset buffers.
+    foreach(buf -> fill!(buf, typemin(Int) ÷ 4), (ws.m.offsets..., ws.n.offsets...))
+    execute!(plan, 0.0, 0.5)
+    @test C == 0.5 .* Cref
 end
 
-@testset "plan_contract: explicit allocators size the packed panels exactly once" begin
+@testset "plan_contract: explicit allocators serve the packed panels" begin
     Random.seed!(1717)
     kernel = SIMDKernel(Val(4), Val(3), Float64)
     Ma, Ka, Na = 19, 23, 17
-    mc, kc, nc = 8, 6, 7
+    m_block, k_block, n_block = 8, 6, 7
     Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
 
     Cdefault = zeros(Ma, Na)
-    default_plan = _mm_plan(Cdefault, Amat, Bmat; kernel = kernel, mc = mc, kc = kc, nc = nc)
+    default_plan = _mm_plan(Cdefault, Amat, Bmat; kernel = kernel, m_block = m_block, k_block = k_block, n_block = n_block)
     execute!(default_plan, 1.5, 0.0)
     @test default_plan.workspace.packed_a isa Vector{Float64}
 
@@ -170,18 +55,17 @@ end
         Cmat = zeros(Ma, Na)
         plan = _mm_plan(
             Cmat, Amat, Bmat;
-            kernel = kernel, mc = mc, kc = kc, nc = nc,
-            allocator = allocator, oracle = false
+            kernel = kernel, m_block = m_block, k_block = k_block, n_block = n_block,
+            allocator = allocator
         )
         ws = plan.workspace
 
         @test isconcretetype(typeof(ws))
         @test all(isconcretetype, fieldtypes(typeof(ws)))
-        @test length(ws.packed_a) == cld(plan.blocking.mc, 4) * 4 * plan.blocking.kc
-        @test length(ws.packed_b) == cld(plan.blocking.nc, 3) * 3 * plan.blocking.kc
-        @test isempty(ws.tw_packed_a)
-        @test ws.m_buf_A isa Vector{Int}
-        @test ws.k_buf_B isa Vector{Int}
+        @test length(ws.packed_a) == cld(plan.blocking.m_block, 4) * 4 * plan.blocking.k_block
+        @test length(ws.packed_b) == cld(plan.blocking.n_block, 3) * 3 * plan.blocking.k_block
+        @test ws.m.offsets[1] isa Vector{Int}
+        @test ws.k[2] isa Vector{Int}
 
         execute!(plan, 1.5, 0.0)
         @test Cmat == Cdefault
@@ -189,24 +73,6 @@ end
         QuasiStrided.release!(ws, allocator)
         TO.allocator_reset!(allocator, checkpoint)
     end
-
-    # Allocator-owned temporaries are never resized.
-    manual = TO.ManualAllocator()
-    Cmanual = zeros(Ma, Na)
-    manual_plan = _mm_plan(
-        Cmanual, Amat, Bmat;
-        kernel = kernel, mc = mc, kc = kc, nc = nc, allocator = manual, oracle = false
-    )
-    @test_throws MethodError QuasiStrided.reserve!(
-        manual_plan.workspace, kernel, manual_plan.blocking, false
-    )
-    QuasiStrided.release!(manual_plan.workspace, manual)
-
-    @test_throws ArgumentError _mm_plan(
-        zeros(Ma, Na), Amat, Bmat;
-        kernel = kernel, allocator = TO.ManualAllocator(),
-        workspace = default_plan.workspace
-    )
 end
 
 @testset "ContractWorkspace: storage type T, packed panels of real(T)" begin
@@ -214,23 +80,28 @@ end
     k32 = SIMDKernel(Val(8), Val(6), Float32)
     b = Blocking(16, 8, 12)
 
-    ws = QuasiStrided.ContractWorkspace(Float64, k64, b; oracle = true)
+    ws = QuasiStrided.ContractWorkspace(Float64, k64, b)
     @test ws isa QuasiStrided.ContractWorkspace{Float64, Vector{Float64}}
     @test eltype(ws.packed_a) === Float64
 
-    wsc = QuasiStrided.ContractWorkspace(ComplexF64, k64, b; oracle = true)
+    wsc = QuasiStrided.ContractWorkspace(ComplexF64, k64, b)
     @test wsc isa QuasiStrided.ContractWorkspace{ComplexF64, Vector{Float64}}
-    @test eltype(wsc.packed_a) === Float64 === eltype(wsc.tw_packed_b)
+    @test eltype(wsc.packed_a) === Float64 === eltype(wsc.packed_b)
     @test all(isconcretetype, fieldtypes(typeof(wsc)))
     @test !any(t -> t isa Union, fieldtypes(typeof(wsc)))
 
     @test_throws ArgumentError QuasiStrided.ContractWorkspace(ComplexF64, k32, b)
     @test_throws ArgumentError QuasiStrided.ContractWorkspace(Float64, k32, b)
     @test_throws ArgumentError QuasiStrided.ContractWorkspace(ComplexF32, k64, b)
+end
 
-    Amat, Bmat, Cmat = randn(6, 5), randn(5, 4), zeros(6, 4)
-    @test_throws ArgumentError plan_contract(
-        StridedView(Cmat), StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3), (1, 3);
-        workspace = wsc
-    )
+@testset "ContractWorkspace: the dot and outer-product paths get no packed panels" begin
+    dot = plan_contract(StridedView(zeros(ComplexF64, 1, 9)), StridedView(randn(ComplexF64, 1, 64)), (1, 2), StridedView(randn(ComplexF64, 64, 9)), (2, 3), (1, 3))
+    outer = plan_contract(StridedView(zeros(64, 40)), StridedView(randn(64)), (1,), StridedView(randn(40)), (2,), (1, 2))
+    @test dot.path isa QuasiStrided.DotPath && outer.path isa QuasiStrided.OuterPath
+    for plan in (dot, outer)
+        @test isempty(plan.workspace.packed_a) && isempty(plan.workspace.packed_b)
+    end
+    @test length(dot.workspace.dot_vector) == 2 * dot.blocking.k_block
+    @test isempty(outer.workspace.dot_vector)
 end
diff --git a/test/forced_isa_runner.jl b/test/forced_isa_runner.jl
index 6e90022..cbccec1 100644
--- a/test/forced_isa_runner.jl
+++ b/test/forced_isa_runner.jl
@@ -1,42 +1,19 @@
 # Run the whole test suite as if the host had a different vector ISA, to catch
 # tests that assert something true only on the host they were written on:
 #
-#   QS_FAKE_ISA=avx2 QS_FAKE_VB=32 QS_FAKE_NREG=16 \
-#       julia --project=. test/forced_isa_runner.jl
+#   QS_FAKE_ISA=avx2 julia --project=. test/forced_isa_runner.jl
 #
-# Useful triples: avx512/64/32, avx2/32/16, neon/16/32, unknown/0/0. The cache
+# QS_FAKE_ISA is one of avx512 (the default), avx2, neon, unknown. The cache
 # levels default to "not detected"; QS_FAKE_L1D, QS_FAKE_L2 (bytes) and
 # QS_FAKE_L2_SHARING (CPUs) model a specific host, e.g. a 3-CPU M1:
 #
-#   QS_FAKE_ISA=neon QS_FAKE_VB=16 QS_FAKE_NREG=32 QS_FAKE_L1D=131072 \
-#       QS_FAKE_L2=12582912 QS_FAKE_L2_SHARING=3 julia --project=. test/forced_isa_runner.jl
+#   QS_FAKE_ISA=neon QS_FAKE_L1D=131072 QS_FAKE_L2=12582912 QS_FAKE_L2_SHARING=3 \
+#       julia --project=. test/forced_isa_runner.jl
 #
-# "runs on this host without throwing" in hardware/test_target.jl fails by
-# construction here. Run from the test environment for the Bumper testsets.
-
-using QuasiStrided
-const _QS = QuasiStrided
-
-_QS._TARGET[] = _QS.TargetProfile(
-    Symbol(get(ENV, "QS_FAKE_ISA", "avx512")), Sys.ARCH, "forced-isa-runner",
-    parse(Int, get(ENV, "QS_FAKE_VB", "64")),
-    parse(Int, get(ENV, "QS_FAKE_NREG", "32")),
-    let l1d = parse(Int, get(ENV, "QS_FAKE_L1D", "0"))
-        _QS.CacheLevel(l1d, 0, 0, l1d > 0 ? 1 : 0)
-    end,
-    _QS.CacheLevel(
-        parse(Int, get(ENV, "QS_FAKE_L2", "0")), 0, 0,
-        parse(Int, get(ENV, "QS_FAKE_L2_SHARING", "0"))
-    ),
-    _QS.CacheLevel()
-)
+# Arguments are passed on to runtests.jl. "runs on this host without throwing"
+# in hardware/test_target.jl fails by construction here.
 
-let p = _QS.target_profile()
-    println(
-        "forced target: isa=", p.isa, " vector_bytes=", p.vector_bytes,
-        " nregisters=", p.nregisters, " l1d=", p.l1d.bytes, " l2=", p.l2.bytes,
-        "/", p.l2.sharing
-    )
-end
+using Pkg
 
-include(joinpath(@__DIR__, "runtests.jl"))
+get!(ENV, "QS_FAKE_ISA", "avx512")
+Pkg.test("QuasiStrided"; test_args = ARGS)
diff --git a/test/hardware/test_target.jl b/test/hardware/test_target.jl
index 871c69c..a6fc9c8 100644
--- a/test/hardware/test_target.jl
+++ b/test/hardware/test_target.jl
@@ -1,40 +1,24 @@
 # Hardware detection: it never throws, and every failure path resolves to the fallbacks.
 
+include("../helpers.jl")
+
 using StridedViews: StridedView
 
 @testset "target detection" begin
     @testset "runs on this host without throwing" begin
         p = target_profile()
         # Logged so that a host-dependent CI failure can be read off the log.
-        @info "target profile" p Sys.CPU_NAME QuasiStrided._isa_from_cpuid() VERSION
+        @info "target profile" p Sys.CPU_NAME VERSION
         @test p.isa in VALID_ISAS
-        @test p.arch === Sys.ARCH
-        @test _detect_target().isa === p.isa
-        if p.isa === :unknown
-            @test (p.vector_bytes, p.nregisters) == (0, 0)
-        else
-            @test p.nregisters > 0
-            @test p.vector_bytes > 0 && ispow2(p.vector_bytes)
-        end
+        @test detect_target().isa === p.isa
+        @test_throws ArgumentError synthetic(:sse)
     end
 
-    @testset "CPU name table and CPUID probe agree" begin
-        probe = QuasiStrided._isa_from_cpuid()
-        @test probe in (:avx512, :avx2, :unknown)
-        if Sys.ARCH === :x86_64
-            rank = QuasiStrided._isa_rank
-            table = get(QuasiStrided._UARCH_ISA, Sys.CPU_NAME, :miss)
-            # A probe narrower than the table is a masked hypervisor, not a table
-            # bug. Julia 1.10 (LLVM 15) names AVX-512 Zen 4/5 "znver3", so there a
-            # wider probe is not a table bug either.
-            stale = VERSION < v"1.11" ? ("znver3",) : ()
-            (table === :miss || probe === :unknown || Sys.CPU_NAME in stale) ||
-                @test rank(probe) <= rank(table)
-            if table !== :miss && probe !== :unknown
-                @test _detect_isa() === (rank(probe) < rank(table) ? probe : table)
-            end
-            # If Base's undocumented CPUID names move, every unlisted CPU would
-            # silently lose its derived shape.
+    if Sys.ARCH === :x86_64
+        @testset "the ISA is the CPUID probe's" begin
+            @test detect_isa() === QuasiStrided.isa_from_cpuid()
+            # If Base's undocumented CPUID names move, every x86 host would
+            # silently fall back to `:unknown`.
             C = Base.BinaryPlatforms.CPUID
             @test isdefined(C, :JL_X86_avx512f)
             @test isdefined(C, :JL_X86_avx2)
@@ -47,7 +31,7 @@ using StridedViews: StridedView
             @test topo === nothing || topo isa NamedTuple
             topo === nothing && continue
             for lvl in (topo.l1d, topo.l2, topo.l3)
-                @test all(>=(0), (lvl.bytes, lvl.ways, lvl.line, lvl.sharing))
+                @test all(>=(0), (lvl.bytes, lvl.line, lvl.sharing))
             end
         end
     end
@@ -57,10 +41,10 @@ using StridedViews: StridedView
                 "32K" => 32 * 1024, "25344K" => 25344 * 1024, "2M" => 2 * 1024 * 1024,
                 "512" => 512, "" => 0, "garbage" => 0,
             )
-            @test _parse_size(str) == want
+            @test parse_size(str) == want
         end
         for (str, want) in ("0,16" => 2, "0-7,16-23" => 16, "3" => 1, "" => 0)
-            @test _count_cpu_list(str) == want
+            @test count_cpu_list(str) == want
         end
     end
 end
diff --git a/test/helpers.jl b/test/helpers.jl
index 40966d2..884438f 100644
--- a/test/helpers.jl
+++ b/test/helpers.jl
@@ -1,15 +1,33 @@
-# Fixtures and bindings shared by all test files (included first by runtests.jl).
+# Fixtures and bindings shared by all test files. Every test file includes this
+# file or its folder's helpers.jl, which includes it.
 
+using Test
+using Random
+using QuasiStrided
+using QuasiStrided: AxisGroup, axis_length, fill_offsets!, BlockDescriptor,
+    describe_block, block_descriptors!, Descriptor, tile_size,
+    scalartype, packed_a_offset, packed_b_offset, packed_a_length, packed_b_length,
+    AffineAxis, Tile, checked_tile_storage_bounds, pack!, sliver_spec,
+    zero_accumulator, add_tile, store_tile!, execute_tile!, lanewidth, contract!,
+    Blocking, default_blocking, ScalarKernel, SIMDKernel, TargetProfile, CacheLevel,
+    target_profile, cache_topology, unknown_target, detect_isa, detect_target,
+    derived_shape, fallback_shape, shape_override, kernel_from_shape,
+    fallback_blocking, kernel_shapes, parse_size, count_cpu_list, NR_DEFAULT,
+    rule_applies, isa_nregisters, sliver_width, realtype,
+    PlanarKernel, OneMKernel, FMAddSubKernel, accumulator_planes, pack_formats,
+    reals_per_element, modelled_blocking, kernel_blocking,
+    planar_pressure, pack_split, is_split, NestPath,
+    plan_contract, execute!, ContractPlan
 using StridedViews: StridedView, offset
+import TensorOperations as TO
 
-# `const` bindings rather than `using QuasiStrided: ...`, so runtests.jl must
-# not import these names too.
-const plan_contract = QuasiStrided.plan_contract
-const execute! = QuasiStrided.execute!
-const ContractPlan = QuasiStrided.ContractPlan
-const execute_tilewise! = QuasiStrided.execute_tilewise!
+_path_of(plan) = plan.path
 
-import TensorOperations as TO
+# Offsets of coordinate `q` of an `AxisGroup` in every map, by direct decoding.
+function offsets(g::AxisGroup{D, P}, q::Int) where {D, P}
+    c = Tuple(CartesianIndices(g.lengths)[q + 1])
+    return ntuple(p -> sum((c[d] - 1) * g.strides[p][d] for d in 1:D; init = 0), P)
+end
 
 # Plan for the matmul C[m,n] = sum_k A[m,k]*B[k,n].
 function _mm_plan(Cmat, Amat, Bmat; kwargs...)
@@ -38,17 +56,20 @@ function _worked_fixture()
     return A, B, Cref
 end
 
-const _INDA = (1, 2, 3)
-const _INDB = (2, 4)
-const _INDC = (1, 4, 3)
-
-using QuasiStrided: TargetProfile, CacheLevel
+const INDA = (1, 2, 3)
+const INDB = (2, 4)
+const INDC = (1, 4, 3)
 
 const VALID_ISAS = (:avx512, :avx2, :neon, :unknown)
-synthetic(isakey, vb; nregisters::Int = 32) = TargetProfile(
-    isakey, Sys.ARCH, "synthetic", vb, nregisters,
-    CacheLevel(), CacheLevel(), CacheLevel()
-)
+synthetic(isakey) = TargetProfile(isakey, "synthetic", CacheLevel(), CacheLevel(), CacheLevel())
+
+# The kernel `plan_contract` picks for `T` on this host: at its own shape, and
+# for an M extent of `m_length` with C contiguous.
+host_kernel(::Type{T}) where {T} = kernel_from_shape(derived_shape(target_profile(), T), T)
+function auto_kernel(::Type{T}, m_length::Int) where {T}
+    shape, K = QuasiStrided.select_shape(T, QuasiStrided.default_kernel_type(T), m_length, 0, m_length)
+    return kernel_from_shape(shape, T, K)
+end
 
 # Permuted A (with a zero-stride axis), negative-stride B, offset sliced C.
 function scattered_fixture(::Type{T}, a_n = 32, k_n = 32, b_n = 8, n_n = 32) where {T}
@@ -63,7 +84,70 @@ end
 # Steady-state allocation of one `pack!` call. `::F where {F}` forces
 # specialization on the pass-through `transform`; without it the dynamic call
 # allocates on Julia 1.10.
-function steady_pack_allocs(pack!::P, packed, source, kernel, transform::F) where {P, F}
-    pack!(packed, source, kernel, transform)
-    return @allocated pack!(packed, source, kernel, transform)
+function steady_pack_allocs(packed, source, spec, transform::F) where {F}
+    pack!(packed, source, spec, transform)
+    return @allocated pack!(packed, source, spec, transform)
+end
+
+# Engine-free reference: alpha * sum_K conj?(A) conj?(B) + beta * C, one loop
+# over every label's range (`getindex` applies a view's `op`, the flag goes on top).
+function _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA = false, conjB = false, alpha = 1, beta = 0)
+    labels = unique((indA..., indB...))
+    ext = Dict{Int, Int}()
+    for (l, s) in zip(indA, size(Av))
+        ext[l] = s
+    end
+    for (l, s) in zip(indB, size(Bv))
+        ext[l] = s
+    end
+    T = eltype(Cstart)
+    acc = zeros(T, size(Cstart))
+    pA = map(l -> Int(findfirst(==(l), labels)), indA)
+    pB = map(l -> Int(findfirst(==(l), labels)), indB)
+    pC = map(l -> Int(findfirst(==(l), labels)), indC)
+    dims = Tuple(ext[l] for l in labels)
+    _lo_reference_loop!(acc, Av, pA, Bv, pB, pC, dims, conjA, conjB)
+    return alpha .* acc .+ beta .* Cstart
+end
+
+function _lo_reference_loop!(
+        acc, Av, pA::NTuple{NA, Int}, Bv, pB::NTuple{NB, Int}, pC::NTuple{NC, Int},
+        dims::NTuple{NL, Int}, conjA::Bool, conjB::Bool
+    ) where {NA, NB, NC, NL}
+    for I in CartesianIndices(dims)
+        a = Av[ntuple(d -> I[pA[d]], Val(NA))...]
+        b = Bv[ntuple(d -> I[pB[d]], Val(NB))...]
+        conjA && (a = conj(a))
+        conjB && (b = conj(b))
+        acc[ntuple(d -> I[pC[d]], Val(NC))...] += a * b
+    end
+    return acc
+end
+
+# Line-by-line packing. intensli_7, C[e,c,b,f,a] = A[a,b,c,d,e] * B[d,f], splits A
+# (K steps of a page or more, every eltype); C[a1,au,f1,f2] = A[au,k,a1] * B[f2,k,f1]
+# splits both operands (K steps within a page, real only).
+const SP_I7 = ((1, 2, 3, 4, 5), (4, 6), (5, 3, 2, 6, 1))
+const SP_BOTH = ((2, 3, 1), (5, 3, 4), (1, 2, 4, 5))
+
+function _sp_views(T, (iA, iB, iC), ext, TA = T)
+    arr(S, I) = StridedView(randn(S, map(l -> ext[l], I)))
+    return (arr(T, iC), arr(TA, iA), iA, arr(T, iB), iB, iC)
+end
+
+# The plan with every structurally eligible group split, whatever this host's L2:
+# the planner's decision at a zero L2 threshold, replanned at its block extents.
+function _sp_forced_plan(Cv, Av, iA, Bv, iB, iC; kw...)
+    p = plan_contract(Cv, Av, iA, Bv, iB, iC; kw...)
+    k, k_block, d, T = p.kernel, p.blocking.k_block, default_blocking(p.kernel), eltype(Cv)
+    function split(g, i, eff, req)
+        R = tile_size(k, i)
+        return pack_split(g, p.kgroup, i, R, pack_formats(typeof(k))[i], sizeof(T), k_block, eff, cld(req, R) * R, d.k_block; l2bytes = 0)
+    end
+    (m_block, ms) = split(p.mgroup, 1, p.blocking.m_block, something(get(kw, :m_block, nothing), d.m_block))
+    (n_block, ns) = split(p.ngroup, 2, p.blocking.n_block, d.n_block)
+    q = plan_contract(Cv, Av, iA, Bv, iB, iC; kw..., kernel = k, m_block, n_block)
+    @assert q.mgroup == p.mgroup && q.ngroup == p.ngroup
+    path = QuasiStrided.nest_path(false, q.mgroup, q.ngroup, q.kgroup, is_split(ms), is_split(ns))
+    return ContractPlan(q; path, mpack = ms, npack = ns)
 end
diff --git a/test/integrations/test_tensoroperations.jl b/test/integrations/test_tensoroperations.jl
index 6076c8b..51fa406 100644
--- a/test/integrations/test_tensoroperations.jl
+++ b/test/integrations/test_tensoroperations.jl
@@ -1,5 +1,7 @@
 # `QuasiStridedBackend` against TensorOperations' own backends and explicit references.
 
+include("../helpers.jl")
+
 using TensorOperations
 using TensorOperations: StridedNative
 using StridedViews: StridedView
@@ -12,10 +14,9 @@ const to_native = StridedNative()
 # NaN in C catches a kernel that computes `0 * C` instead of ignoring C when β == 0.
 poison!(C) = fill!(C, convert(eltype(C), NaN))
 
-const complex_eltypes = (ComplexF32, ComplexF64)
-const all_eltypes = (Float32, Float64, complex_eltypes...)
+const all_eltypes = (Float32, Float64, ComplexF32, ComplexF64)
 
-const _MATMUL_PAB = ((1,), (2,)), ((1,), (2,)), ((1, 2), ())
+const MATMUL_PAB = ((1,), (2,)), ((1,), (2,)), ((1, 2), ())
 
 @testset "tensorcontract! agrees with StridedNative (eltype = $T)" for T in all_eltypes
     Random.seed!(1234567)
@@ -27,7 +28,7 @@ const _MATMUL_PAB = ((1,), (2,)), ((1,), (2,)), ((1, 2), ())
     )
     for (szA, szB, pA, pB, pAB, szC) in cases
         A, B = randn(T, szA), randn(T, szB)
-        for conjA in (false, true), conjB in (false, true),
+        for (conjA, conjB) in (T <: Complex ? ((false, false), (true, true)) : ((false, false),)),
                 (α, β) in ((one(T), zero(T)), (rand(T), zero(T)), (rand(T), rand(T)))
             Cn = randn(T, szC)
             iszero(β) && poison!(Cn)
@@ -51,9 +52,10 @@ end
 end
 
 # `conjA`/`conjB` and each operand's `StridedView.op` compose by xor.
-@testset "conjugation: flags x StridedView.op (eltype = $T)" for T in complex_eltypes
+@testset "conjugation: flags x StridedView.op" begin
     Random.seed!(20260914)
-    pA, pB, pAB = _MATMUL_PAB
+    T = ComplexF64
+    pA, pB, pAB = MATMUL_PAB
     M, N = randn(T, (4, 4)), randn(T, (4, 4))
     # `conj(::Matrix)` materialises; `conj(::StridedView)` only sets `op`.
     wrappers = (identity, adjoint, transpose, conj)
@@ -86,7 +88,7 @@ end
 
 @testset "conjugated output view (eltype = $T)" for T in all_eltypes
     Random.seed!(271828)
-    pA, pB, pAB = _MATMUL_PAB
+    pA, pB, pAB = MATMUL_PAB
     A, B = randn(T, (4, 4)), randn(T, (4, 4))
     conjviews = (
         conj(StridedView(zeros(T, (4, 4)))), adjoint(zeros(T, (4, 4))),
@@ -112,7 +114,7 @@ end
         (randn(T, (3, 4)), randn(T, (4, 3)), ((), (1, 2)), ((2, 1), ()), ((), ()), (), false, false),
         (
             view(randn(T, (6, 8)), 1:2:6, 1:2:8), view(randn(T, (8, 10)), 1:2:8, 1:2:10),
-            _MATMUL_PAB..., (3, 5), false, true,
+            MATMUL_PAB..., (3, 5), false, true,
         ),
     )
     for (A, B, pA, pB, pAB, szC, conjA, conjB) in cases
@@ -127,9 +129,9 @@ end
     end
 end
 
-@testset "@tensor / ncon integration (eltype = $T)" for T in (Float64, ComplexF64)
+@testset "@tensor / ncon integration" begin
     Random.seed!(112233)
-    A, B, C = randn(T, (5, 5, 5, 5)), randn(T, (5, 5, 5)), randn(T, (5, 5, 5))
+    A, B, C = randn(ComplexF64, (5, 5, 5, 5)), randn(ComplexF64, (5, 5, 5)), randn(ComplexF64, (5, 5, 5))
     @tensor backend = qsbackend D[a, b, c, d] := A[a, e, c, f] * B[g, d, e] * C[g, f, b]
     @tensor Dref[a, b, c, d] := A[a, e, c, f] * B[g, d, e] * C[g, f, b]
     @test D ≈ Dref
@@ -138,7 +140,7 @@ end
 end
 
 @testset "hard-reject: ineligible eltypes and non-strided operands" begin
-    pA, pB, pAB = _MATMUL_PAB
+    pA, pB, pAB = MATMUL_PAB
     # (eltype A, eltype B, eltype C): types outside the four, and complex into real.
     for (TA, TB, TC) in (
             (Float16, Float16, Float16), (Complex{Float16}, Complex{Float16}, Complex{Float16}),
@@ -176,7 +178,7 @@ end
 end
 
 @testset "hard-reject: C aliasing an input (eltype = $T)" for T in (Float64, ComplexF64)
-    pA, pB, pAB = _MATMUL_PAB
+    pA, pB, pAB = MATMUL_PAB
     A, B = randn(T, (4, 4)), randn(T, (4, 4))
     M = randn(T, (8, 4))
     # Regression: Base's `mightalias` misses a `PermutedDimsArray` of the input.
@@ -204,82 +206,28 @@ end
     @test c1 == c2
 end
 
-# Run `f` with an empty workspace pool on the current task (not a spawned one:
-# `@test` finds its testset through task-local storage too), restoring it after.
-function _qs_with_clean_pool(f)
-    key = QuasiStrided._QS_WORKSPACE_KEY
-    tls = task_local_storage()
-    prior = get(tls, key, nothing)
-    delete!(tls, key)
-    try
-        return f()
-    finally
-        prior === nothing ? delete!(tls, key) : (tls[key] = prior)
-    end
-end
-
-_qs_haspool() = haskey(task_local_storage(), QuasiStrided._QS_WORKSPACE_KEY)
-
-@testset "workspace pooling: default path reuses a task-local workspace" begin
-    Random.seed!(90210)
-    A, B = randn(20, 30), randn(30, 25)
-    run_once() = (C = zeros(20, 25); @tensor backend = qsbackend C[i, j] = A[i, k] * B[k, j]; C)
-
-    steady = _qs_with_clean_pool() do
-        @test !_qs_haspool()
-        @test run_once() ≈ A * B
-        pool = task_local_storage(QuasiStrided._QS_WORKSPACE_KEY)
-        ws = pool[Float64]
-        steady = @allocated run_once()
-        @test pool[Float64] === ws
-        steady
-    end
-    # Julia 1.10 does not keep SIMDKernel's accumulator in registers.
-    @test steady < 20_000 skip = (VERSION < v"1.11")
-    Cv, Av, Bv = StridedView(zeros(20, 25)), StridedView(A), StridedView(B)
-    cold = @allocated plan_contract(Cv, Av, (1, -1), Bv, (-1, 2), (1, 2); oracle = false)
-    @test cold - steady > 5_000 skip = (VERSION < v"1.11")
-end
-
-@testset "workspace pooling: explicit allocators never touch the pool" begin
+@testset "tensorcontract!: allocator-routed workspace, released per call" begin
     Random.seed!(13571113)
     A, B = randn(20, 30), randn(30, 25)
-    _qs_with_clean_pool() do
-        for _ in 1:2
-            C1, C2, C3 = zeros(20, 25), zeros(20, 25), zeros(20, 25)
-            @tensor backend = qsbackend allocator = TensorOperations.ManualAllocator() C1[i, j] = A[i, k] * B[k, j]
-            @tensor backend = qsbackend allocator = TensorOperations.BufferAllocator() C2[i, j] = A[i, k] * B[k, j]
-            @no_escape begin
-                @tensor backend = qsbackend allocator = default_buffer() C3[i, j] = A[i, k] * B[k, j]
-            end
-            @test C1 ≈ C2 ≈ C3 ≈ A * B
+    buffer = TensorOperations.BufferAllocator()
+    for _ in 1:2
+        C1, C2, C3 = zeros(20, 25), zeros(20, 25), zeros(20, 25)
+        @tensor backend = qsbackend allocator = TensorOperations.ManualAllocator() C1[i, j] = A[i, k] * B[k, j]
+        @tensor backend = qsbackend allocator = buffer C2[i, j] = A[i, k] * B[k, j]
+        @no_escape begin
+            @tensor backend = qsbackend allocator = default_buffer() C3[i, j] = A[i, k] * B[k, j]
         end
-        @test !_qs_haspool()
-        C = zeros(20, 25)
-        @tensor backend = qsbackend C[i, j] = A[i, k] * B[k, j]
-        @test _qs_haspool()
+        @test C1 ≈ C2 ≈ C3 ≈ A * B
     end
+    @test isempty(buffer)
 end
 
-# One pooled workspace per eltype, grown and then reused oversized.
-@testset "workspace pooling: correctness across shapes and eltypes on one task" begin
-    Random.seed!(2024)
-    _qs_with_clean_pool() do
-        for (m, k, n) in ((6, 8, 5), (37, 41, 29), (3, 3, 3), (17, 90, 2))
-            A, B = randn(m, k), randn(k, n)
-            C = fill(NaN, m, n)
-            @tensor backend = qsbackend C[i, j] = A[i, k] * B[k, j]
-            @test C ≈ A * B
-        end
-        for T in (Float64, ComplexF64, Float32, ComplexF32, Float64, ComplexF64)
-            A, B = randn(T, (12, 7)), randn(T, (7, 9))
-            C = fill(convert(T, NaN), (12, 9))
-            @tensor backend = qsbackend C[i, j] = A[i, k] * B[k, j]
-            @test C ≈ A * B
-        end
-        pool = task_local_storage(QuasiStrided._QS_WORKSPACE_KEY)
-        for T in all_eltypes
-            @test pool[T] isa QuasiStrided.ContractWorkspace{T, Vector{real(T)}}
-        end
-    end
+@testset "tensorcontract!: the default path allocates no more than planning" begin
+    A, B, C = randn(20, 30), randn(30, 25), zeros(20, 25)
+    run_once() = TO.tensorcontract!(C, A, ((1,), (2,)), false, B, ((1,), (2,)), false, ((1, 2), ()), 1.0, 0.0, qsbackend)
+    Cv, Av, Bv = StridedView(C), StridedView(A), StridedView(B)
+    plan_once() = plan_contract(Cv, Av, (1, -1), Bv, (-1, 2), (1, 2))
+    run_once(); plan_once()
+    @test C ≈ A * B
+    @test (@allocated run_once()) <= (@allocated plan_once()) skip = (VERSION < v"1.11")
 end
diff --git a/test/layout/test_axis_group.jl b/test/layout/test_axis_group.jl
index 4cfcfbc..384a584 100644
--- a/test/layout/test_axis_group.jl
+++ b/test/layout/test_axis_group.jl
@@ -1,5 +1,7 @@
 # AxisGroup indexing against an oracle built on `CartesianIndices` (first axis
-# fastest), never on offsets/fill_offsets!/block_descriptors! themselves.
+# fastest), never on fill_offsets!/block_descriptors! themselves.
+
+include("../helpers.jl")
 
 using QuasiStrided: affine_ramp
 
@@ -47,29 +49,20 @@ end
         full = oracle_offsets(lengths, strides)
         Q = axis_length(g)
         @test Q == length(full)
-        @test [offsets(g, q) for q in 0:(Q - 1)] == full
-        @test_throws BoundsError offsets(g, Q)
-        @test_throws BoundsError offsets(g, -1)
         isramp, steps = affine_ramp(g)
         if Q > 0
             step1 = Q > 1 ? full[2] : ntuple(_ -> 0, P)
             @test isramp == (full == [step1 .* q for q in 0:(Q - 1)])
             isramp && @test steps == step1
         end
-        # normalize_group is planning-time only: check it at the pair arity.
-        gn = P == 2 ? normalize_group(g) : g
-        @test axis_length(gn) == Q
         for _ in 1:4
             first = rand(rng, 0:Q)
             count = rand(rng, 0:(Q - first))
             bufs = ntuple(_ -> fill(-1, count + 2), P)   # the suffix must stay untouched
             descs = block_descriptors!(bufs, g, first, count)
-            bufsn = ntuple(_ -> zeros(Int, count), P)
-            fill_offsets!(bufsn, gn, first, count)
             for p in 1:P
                 expected = [full[i + 1][p] for i in first:(first + count - 1)]
                 @test bufs[p] == [expected; -1; -1]
-                @test bufsn[p] == expected
                 d = descs[p]
                 affine = count <= 1 || expected == [expected[1] + t * (expected[2] - expected[1]) for t in 0:(count - 1)]
                 @test d.regular == affine && d.count == count
@@ -92,17 +85,6 @@ end
     @test offsets(g1, 0) == (0,)
 end
 
-@testset "normalize_group: folds only where every map folds" begin
-    folded = normalize_group(AxisGroup((3, 2), ((1, 3), (2, 6))))
-    @test folded.lengths == (6,) && folded.strides == ((1,), (2,))
-    @test normalize_group(AxisGroup((4, 3), ((-1, -4),))).lengths == (12,)
-    # map 1 alone would fold, map 2 does not: the group must not.
-    @test normalize_group(AxisGroup((3, 2), ((1, 3), (1, 10)))).lengths == (3, 2)
-    g = normalize_group(AxisGroup((1, 1, 1), ((5, 6, 7), (8, 9, 10))))
-    @test g.lengths == () && length(g.strides) == 2 && offsets(g, 0) == (0, 0)
-    @test normalize_group(AxisGroup((3, 1, 2), ((1, 999, 3),))).lengths == (6,)
-end
-
 @testset "AxisGroup: constructor validation and overflow policy" begin
     @test_throws ArgumentError AxisGroup((-1,), ((1,),))
     @test_throws ArgumentError AxisGroup((3, -2), ((1, 1),))
@@ -125,8 +107,6 @@ end
     short, ok = fill(-7, Q - 1), fill(-7, Q)
     @test_throws DimensionMismatch fill_offsets!((short, ok), g, 0, Q)
     @test ok == fill(-7, Q)
-    @test_throws ArgumentError fill_offsets!((ok, ok), g, 0, Q)    # aliased buffers
-    @test ok == fill(-7, Q)
     fill_offsets!((ok, short), g, Q, 0)                            # empty interval at Q
     @test ok == fill(-7, Q)
 end
@@ -145,3 +125,89 @@ end
     @test_throws ArgumentError describe_block([1, 2, 3], -1, 1)
     @test_throws DimensionMismatch describe_block([1, 2, 3], 2, 2)
 end
+
+# AxisGroups built from StridedViews, cross-checked against StridedView's own
+# indexing.
+@testset "AxisGroup over a StridedView reproduces its indexing ($name)" for (name, v) in (
+        ("permuted", permutedims(StridedView(reshape(collect(1.0:30.0), 3, 5, 2)), (3, 1, 2))),
+        ("sliced", view(StridedView(reshape(collect(1.0:60.0), 3, 5, 4)), 2:3, 1:3, 4:2:4)),
+        ("permuted and sliced", permutedims(view(StridedView(reshape(collect(1.0:120.0), 4, 5, 6)), 2:4, 2:5, 1:2:5), (3, 1, 2))),
+        ("negative stride", StridedView(collect(1.0:12.0), (4, 3), (-1, 3), 3)),
+        ("zero stride", StridedView(collect(1.0:5.0), (5, 3), (1, 0), 0)),
+    )
+    g = AxisGroup(size(v), (Base.strides(v),))
+    @test axis_length(g) == length(v)
+    for (q, ci) in enumerate(CartesianIndices(size(v)))
+        (o,) = offsets(g, q - 1)
+        @test parent(v)[offset(v) + o + 1] == v[ci]
+    end
+end
+
+@testset "AxisGroup from labels matches a direct construction" begin
+    A, B, C = StridedView(randn(3, 5, 2)), StridedView(randn(5, 4)), StridedView(zeros(3, 4, 2))
+    indA, indB, indC = (1, 2, 3), (2, 4), (1, 4, 3)   # A[a,k,b] B[k,n] C[a,n,b]
+    M = AxisGroup((1, 3), (indA, A), (indC, C))
+    @test (M.lengths, M.strides) == ((3, 2), ((1, 15), (1, 12)))
+    K = AxisGroup((2,), (indA, A), (indB, B))
+    @test (K.lengths, K.strides) == ((5,), ((3,), (1,)))
+    @test_throws DimensionMismatch AxisGroup((2,), (indA, A), (indB, StridedView(randn(6, 4))))
+
+    Random.seed!(1234)
+    for trial in 1:20
+        nd1 = rand(1:4)
+        nd2 = rand(nd1:5)
+        shared = rand(1:nd1)                      # how many labels the group has
+        dims1 = ntuple(_ -> rand(1:4), nd1)
+        v1 = StridedView(randn(dims1))
+        ind1 = ntuple(identity, nd1)
+        labels = shuffle(collect(ind1))[1:shared]
+        # v2 carries the same labels (same lengths) plus filler.
+        ind2 = (labels..., ntuple(d -> 100 + d, nd2 - shared)...)
+        dims2 = (
+            ntuple(d -> size(v1, findfirst(==(labels[d]), ind1)::Int), shared)...,
+            ntuple(_ -> rand(1:4), nd2 - shared)...,
+        )
+        v2 = StridedView(randn(dims2))
+
+        g = AxisGroup(Tuple(labels), (ind1, v1), (ind2, v2))
+        s1 = Base.strides(v1)
+        s2 = Base.strides(v2)
+        p1 = ntuple(d -> findfirst(==(labels[d]), ind1)::Int, shared)
+        p2 = ntuple(d -> findfirst(==(labels[d]), ind2)::Int, shared)
+        @test g.lengths == ntuple(d -> size(v1, p1[d]), shared)
+        @test g.strides[1] == ntuple(d -> s1[p1[d]], shared)
+        @test g.strides[2] == ntuple(d -> s2[p2[d]], shared)
+        @test g isa AxisGroup{shared, 2}
+        @test isconcretetype(typeof(g))
+        @test Base.return_types(
+            AxisGroup, (typeof(Tuple(labels)), Tuple{typeof(ind1), typeof(v1)}, Tuple{typeof(ind2), typeof(v2)})
+        ) == [AxisGroup{shared, 2}]
+    end
+
+    v1 = StridedView(randn(3, 4))
+    v2 = StridedView(randn(5, 4))
+    @test_throws DimensionMismatch AxisGroup((1,), ((1, 2), v1), ((1, 2), v2))
+
+    # Rank zero: an outer product's K group.
+    g0 = AxisGroup((), ((1, 2), v1), ((1, 2), v2))
+    @test g0 isa AxisGroup{0, 2}
+    @test axis_length(g0) == 1
+end
+
+@testset "affine_ramp classifies exactly the rank-<=1 folds" begin
+    ar = QuasiStrided.affine_ramp
+
+    @test ar(AxisGroup((), ((), ()))) == (true, (0, 0))
+    @test ar(AxisGroup((7,), ((3,), (-2,)))) == (true, (3, -2))
+    # Singleton dimensions never advance, whatever their stride claims.
+    @test ar(AxisGroup((1, 7, 1), ((99, 3, -4), (5, -2, 8)))) == (true, (3, -2))
+    # Foldable on both maps, or on one only.
+    @test ar(AxisGroup((4, 5), ((1, 4), (2, 8)))) == (true, (1, 2))
+    @test first(ar(AxisGroup((4, 5), ((1, 4), (2, 9))))) == false
+    @test first(ar(AxisGroup((16, 16, 16), ((1, 256, 4096), (1, 256, 4096))))) == false
+    # A three-deep fold uses the accumulated length.
+    @test ar(AxisGroup((2, 3, 4), ((1, 2, 6), (5, 10, 30)))) == (true, (1, 5))
+    @test first(ar(AxisGroup((2, 3, 4), ((1, 2, 4), (5, 10, 30))))) == false
+    # Empty domain is vacuously a ramp.
+    @test first(ar(AxisGroup((0, 3), ((1, 4), (1, 4))))) == true
+end
diff --git a/test/layout/test_stridedviews_axisgroup.jl b/test/layout/test_stridedviews_axisgroup.jl
deleted file mode 100644
index 2f648c4..0000000
--- a/test/layout/test_stridedviews_axisgroup.jl
+++ /dev/null
@@ -1,30 +0,0 @@
-# AxisGroups built from StridedViews, cross-checked against StridedView's own
-# indexing.
-
-using StridedViews: StridedView, offset
-using QuasiStrided: _build_pair_group
-
-@testset "AxisGroup over a StridedView reproduces its indexing ($name)" for (name, v) in (
-        ("permuted", permutedims(StridedView(reshape(collect(1.0:30.0), 3, 5, 2)), (3, 1, 2))),
-        ("sliced", view(StridedView(reshape(collect(1.0:60.0), 3, 5, 4)), 2:3, 1:3, 4:2:4)),
-        ("permuted and sliced", permutedims(view(StridedView(reshape(collect(1.0:120.0), 4, 5, 6)), 2:4, 2:5, 1:2:5), (3, 1, 2))),
-        ("negative stride", StridedView(collect(1.0:12.0), (4, 3), (-1, 3), 3)),
-        ("zero stride", StridedView(collect(1.0:5.0), (5, 3), (1, 0), 0)),
-    )
-    g = AxisGroup(size(v), (Base.strides(v),))
-    @test axis_length(g) == length(v)
-    for (q, ci) in enumerate(CartesianIndices(size(v)))
-        (o,) = offsets(g, q - 1)
-        @test parent(v)[offset(v) + o + 1] == v[ci]
-    end
-end
-
-@testset "_build_pair_group: worked example from label positions" begin
-    A, B, C = StridedView(randn(3, 5, 2)), StridedView(randn(5, 4)), StridedView(zeros(3, 4, 2))
-    indA, indB, indC = (1, 2, 3), (2, 4), (1, 4, 3)   # A[a,k,b] B[k,n] C[a,n,b]
-    M = _build_pair_group((1, 3), indA, A, indC, C)
-    @test (M.lengths, M.strides) == ((3, 2), ((1, 15), (1, 12)))
-    K = _build_pair_group((2,), indA, A, indB, B)
-    @test (K.lengths, K.strides) == ((5,), ((3,), (1,)))
-    @test_throws DimensionMismatch _build_pair_group((2,), indA, A, indB, StridedView(randn(6, 4)))
-end
diff --git a/test/layout/test_tiles.jl b/test/layout/test_tiles.jl
index beb50e7..5e859eb 100644
--- a/test/layout/test_tiles.jl
+++ b/test/layout/test_tiles.jl
@@ -1,70 +1,132 @@
-# Tile axes and QSTile addressing, against hand-computed addresses.
+# Tile axes and Tile addressing, against hand-computed addresses.
 
-using QuasiStrided: PtrScatterAxis, QSTile, axis_offset, tile_offset, tile_load, tile_store!,
-    checked_span_bounds, descriptor_offset_range
+include("../helpers.jl")
 
-@testset "tile axes: addressing, borrowing, validation" begin
-    @test [axis_offset(AffineAxis(10, 3, 5), t) for t in 0:4] == [10, 13, 16, 19, 22]
-    @test [axis_offset(AffineAxis(20, -4, 4), t) for t in 0:3] == [20, 16, 12, 8]
-    @test [axis_offset(AffineAxis(7, 0, 3), t) for t in 0:2] == [7, 7, 7]
-    offs = [5, -3, 100, 0, 42]
-    ax = ScatterAxis(offs, 3)                 # a strict prefix of `offs`
-    @test axis_length(ax) == 3
-    @test [axis_offset(ax, t) for t in 0:2] == offs[1:3]
-    offs[2] = 999                              # borrowed, not copied
-    @test axis_offset(ax, 1) == 999
-    GC.@preserve offs begin
-        pax = PtrScatterAxis(pointer(offs), 5)
-        @test [axis_offset(pax, t) for t in 0:4] == offs
-        @test axis_offset_range(pax) == (0, 999)
-    end
-    @test_throws ArgumentError AffineAxis(0, 1, -1)
-    @test_throws ArgumentError ScatterAxis(offs, -1)
-    @test_throws DimensionMismatch ScatterAxis(offs, 6)
-    @test_throws ArgumentError PtrScatterAxis(pointer(offs), -1)
-end
+using QuasiStrided: checked_span_bounds, descriptor_offset_range, is_unit_stride
 
-@testset "axis_from_descriptor: regular -> AffineAxis, irregular -> borrowed ScatterAxis" begin
-    buf = [99, 99, 7, 10, 13, 16, -1]
-    ax = axis_from_descriptor(describe_block(buf, 2, 4), buf, 2)
-    @test ax isa AffineAxis && (ax.base, ax.stride, axis_length(ax)) == (7, 3, 4)
-    bufi = [-1, -1, 0, 5, 1, 6, -1]
-    d = describe_block(bufi, 2, 4)
-    axi = axis_from_descriptor(d, bufi, 2)
-    @test axi isa ScatterAxis && [axis_offset(axi, t) for t in 0:3] == bufi[3:6]
-    @test descriptor_offset_range(d, bufi, 2) == axis_offset_range(axi) == (0, 6)
-    bufi[3] = 555
-    @test axis_offset(axi, 0) == 555
-    @test axis_from_descriptor(describe_block(Int[], 0), Int[]) isa AffineAxis
+@testset "AffineAxis: offsets, validation" begin
+    @test AffineAxis(10, 3, 5) == [10, 13, 16, 19, 22]
+    @test AffineAxis(20, -4, 4) == [20, 16, 12, 8]
+    @test AffineAxis(7, 0, 3) == [7, 7, 7]
+    @test_throws BoundsError AffineAxis(7, 0, 3)[4]
+    @test_throws ArgumentError AffineAxis(0, 1, -1)
+    @test is_unit_stride(AffineAxis(3, 1, 2)) && !is_unit_stride(AffineAxis(3, 2, 2))
+    @test !is_unit_stride(view([0, 1, 2], 1:3))
 end
 
-@testset "QSTile: base + row_offset(i) + col_offset(j), every axis combination" begin
+@testset "Tile: base + rows[i] + cols[j], every axis combination" begin
     rowoffs, coloffs = [0, 100, 5, -20], [3, -7, 42]
-    for rows in (AffineAxis(2, 3, 4), ScatterAxis(rowoffs, 4)), cols in (AffineAxis(1, 10, 3), ScatterAxis(coloffs, 3))
+    for rows in (AffineAxis(2, 3, 4), view(rowoffs, 1:4)), cols in (AffineAxis(1, 10, 3), view(coloffs, 1:3))
         storage = zeros(200)
-        t = SourceTile(storage, 50, rows, cols)
-        @test (nrows(t), ncols(t)) == (4, 3)
-        for i in 0:3, j in 0:2
-            addr = 50 + (rows isa AffineAxis ? 2 + 3i : rowoffs[i + 1]) + (cols isa AffineAxis ? 1 + 10j : coloffs[j + 1])
-            @test tile_offset(t, i, j) == addr
-            tile_store!(t, i, j, 1000.0i + j)
-            @test storage[addr + 1] == tile_load(t, i, j) == 1000.0i + j
+        t = Tile(storage, 50, rows, cols)
+        @test size(t) == (4, 3)
+        for i in 1:4, j in 1:3
+            addr = 50 + rows[i] + cols[j]
+            t[i, j] = 1000.0i + j
+            @test storage[addr + 1] == t[i, j] == 1000.0i + j
         end
     end
+    @test_throws BoundsError Tile(zeros(3), 0, AffineAxis(0, 1, 2), AffineAxis(0, 2, 2))[2, 2]
 end
 
 @testset "storage bounds: offset ranges and span checks" begin
-    @test axis_offset_range(AffineAxis(10, -3, 4)) == (1, 10)
-    @test axis_offset_range(ScatterAxis([4, -2, 9], 2)) == (-2, 4)
-    @test axis_offset_range(AffineAxis(5, 1, 0)) == (0, -1)
-    @test_throws OverflowError axis_offset_range(AffineAxis(typemax(Int), 1, 2))
+    @test extrema(AffineAxis(10, -3, 4)) == (1, 10)
+    @test_throws OverflowError extrema(AffineAxis(typemax(Int), 1, 2))
+    @test_throws ArgumentError extrema(AffineAxis(5, 1, 0))
+    buf = [99, 99, 7, 10, 13, 16, -1]
+    @test descriptor_offset_range(describe_block(buf, 2, 4), buf, 2) == (7, 16)
+    bufi = [-1, -1, 0, 5, 1, 6, -1]
+    @test descriptor_offset_range(describe_block(bufi, 2, 4), bufi, 2) == (0, 6)
+    @test descriptor_offset_range(describe_block(Int[], 0), Int[], 0) == (0, -1)
     storage = zeros(20)
-    @test checked_tile_storage_bounds(SourceTile(storage, 0, AffineAxis(0, 1, 4), AffineAxis(0, 5, 4))) === nothing
-    @test_throws BoundsError checked_tile_storage_bounds(SourceTile(storage, 2, AffineAxis(0, 1, 4), AffineAxis(0, 5, 4)))
-    @test_throws BoundsError checked_tile_storage_bounds(SourceTile(storage, 0, AffineAxis(-1, 1, 4), AffineAxis(0, 5, 4)))
+    @test checked_tile_storage_bounds(Tile(storage, 0, AffineAxis(0, 1, 4), AffineAxis(0, 5, 4))) === nothing
+    @test_throws BoundsError checked_tile_storage_bounds(Tile(storage, 2, AffineAxis(0, 1, 4), AffineAxis(0, 5, 4)))
+    @test_throws BoundsError checked_tile_storage_bounds(Tile(storage, 0, AffineAxis(-1, 1, 4), AffineAxis(0, 5, 4)))
+    @test_throws BoundsError checked_tile_storage_bounds(Tile(storage, 0, view([4, -2, 9], 1:2), AffineAxis(0, 5, 4)))
     # An empty axis reads nothing, whatever the other axis addresses.
-    @test checked_tile_storage_bounds(SourceTile(storage, 0, AffineAxis(0, 1, 0), AffineAxis(500, 1, 3))) === nothing
+    @test checked_tile_storage_bounds(Tile(storage, 0, AffineAxis(0, 1, 0), AffineAxis(500, 1, 3))) === nothing
     @test checked_span_bounds(0, (0, 9), (0, 10), 20) === nothing
     @test_throws BoundsError checked_span_bounds(0, (0, 9), (0, 11), 20)
     @test checked_span_bounds(-100, (0, -1), (0, 5), 20) === nothing
 end
+
+@testset "checked_span_bounds is equivalent to the per-tile check" begin
+    # For a region split into slivers, checking the union range once accepts
+    # exactly what checking each sliver accepts.
+    Random.seed!(99)
+    for trial in 1:150
+        nrow = rand(1:9)
+        ncol = rand(1:5)
+        rowoffs = [rand(-20:20) for _ in 1:nrow]
+        coloffs = [rand(-20:20) for _ in 1:ncol]
+        base = rand(-5:30)
+        len = rand(1:60)
+        reg = rand(1:4)                      # sliver height
+        nsliv = cld(nrow, reg)
+
+        cols = view(coloffs, 1:ncol)
+        persliver = true
+        for s in 0:(nsliv - 1)
+            first = s * reg
+            cnt = min(reg, nrow - first)
+            rows = view(rowoffs, (first + 1):(first + cnt))
+            ok = try
+                checked_tile_storage_bounds(base, rows, cols, len)
+                true
+            catch e
+                e isa BoundsError || rethrow()
+                false
+            end
+            persliver &= ok
+        end
+
+        blockrange = (minimum(rowoffs), maximum(rowoffs))
+        colrange = (minimum(coloffs), maximum(coloffs))
+        blockok = try
+            QuasiStrided.checked_span_bounds(base, blockrange, colrange, len)
+            true
+        catch e
+            e isa BoundsError || rethrow()
+            false
+        end
+        @test blockok == persliver
+    end
+
+    @test QuasiStrided.checked_span_bounds(0, (0, -1), (0, 0), 1) === nothing
+    @test QuasiStrided.checked_span_bounds(0, (0, 0), (0, -1), 1) === nothing
+    @test_throws BoundsError QuasiStrided.checked_span_bounds(0, (0, 0), (0, 0), 0)
+end
+
+@testset "descriptor_offset_range agrees with extrema" begin
+    Random.seed!(7)
+    for trial in 1:100
+        n = rand(1:8)
+        buf = [rand(-30:30) for _ in 1:n]
+        rand() < 0.4 && (buf = [3 + 5 * (t - 1) for t in 1:n])   # force a regular run
+        d = describe_block(buf, 0, n)
+        GC.@preserve buf @test QuasiStrided.descriptor_offset_range(d, buf, 0) == extrema(QuasiStrided.axis_of(d, buf, 0))
+    end
+    @test QuasiStrided.descriptor_offset_range(BlockDescriptor(0, 0, 0, true), Int[], 0) == (0, -1)
+end
+
+# `@inbounds` reaches the storage check only through an inlined call.
+pcf_inbounds_pack!(args...) = @inbounds pack!(args...)
+pcf_inbounds_execute_tile!(args...) = @inbounds execute_tile!(args...)
+
+@testset "@inbounds skips only the storage bounds check" begin
+    kernel = SIMDKernel(Val(8), Val(6), Float64)
+    src = Tile(collect(1.0:64.0), 0, AffineAxis(0, 1, 8), AffineAxis(0, 8, 4))
+    a = sliver_spec(kernel, 1)
+    @test_throws DimensionMismatch pcf_inbounds_pack!(zeros(3), src, a, identity)
+    @test_throws ArgumentError pcf_inbounds_pack!(zeros(Float32, 64), src, a, identity)
+    toowide = Tile(collect(1.0:200.0), 0, AffineAxis(0, 1, 9), AffineAxis(0, 16, 4))
+    @test_throws ArgumentError pcf_inbounds_pack!(zeros(200), toowide, a, identity)
+
+    dest = Tile(zeros(8 * 6), 0, AffineAxis(0, 1, 8), AffineAxis(0, 8, 6))
+    @test_throws DimensionMismatch pcf_inbounds_execute_tile!(
+        kernel, dest, zeros(3), zeros(6 * 4), 4, 1.0, 0.0
+    )
+    @test_throws ArgumentError pcf_inbounds_execute_tile!(
+        kernel, dest, zeros(8 * 4), zeros(6 * 4), -1, 1.0, 0.0
+    )
+end
diff --git a/test/microkernels/helpers.jl b/test/microkernels/helpers.jl
new file mode 100644
index 0000000..f6ddcbf
--- /dev/null
+++ b/test/microkernels/helpers.jl
@@ -0,0 +1,209 @@
+# The microkernel contract shared by every kernel (`mk_contract`). Each kernel
+# file calls `mk_contract` on its own shapes.
+#
+# The oracles are test-local: packed panels are written out literally from each
+# format's layout and the accumulator is read back from its documented layout,
+# never through the engine's packers or offset accessors.
+
+include("../helpers.jl")
+using QuasiStrided: SIMDKernel, PlanarKernel, OneMKernel, FMAddSubKernel
+using SIMD: Vec
+using StridedViews: StridedView
+
+# `[x0, y0, x1, y1, ...]`
+mk_ilv(x, y) = vec(permutedims(hcat(x, y)))
+mk_cols(f, M) = reduce(vcat, [f(c) for c in eachcol(M)])
+
+# Packed A (MR x k_block_length) and B (k_block_length x NR), one K step after another.
+mk_pack_a(::Union{ScalarKernel, SIMDKernel}, A) = vec(A)
+mk_pack_a(::PlanarKernel, A) = mk_cols(c -> [real(c); imag(c)], A)
+mk_pack_a(::OneMKernel, A) =
+    mk_cols(c -> [mk_ilv(real(c), imag(c)); mk_ilv(-imag(c), real(c))], A)
+mk_pack_a(::FMAddSubKernel, A) = mk_cols(c -> mk_ilv(real(c), imag(c)), A)
+mk_pack_b(::Union{ScalarKernel, SIMDKernel}, B) = vec(permutedims(B))
+mk_pack_b(k, B) = mk_cols(c -> [real(c); imag(c)], permutedims(B))
+mk_pack(k, A, B) = (mk_pack_a(k, A), mk_pack_b(k, B))
+
+# Element (i, j), zero-based, of an accumulator.
+mk_read(k::ScalarKernel, acc, i, j) = acc[i + tile_size(k, 1) * j + 1]
+function mk_read(k::SIMDKernel, acc, i, j)
+    W = lanewidth(k)
+    return acc[i ÷ W + (tile_size(k, 1) ÷ W) * j + 1][i % W + 1]
+end
+function mk_read(k::PlanarKernel, acc, i, j)
+    W = lanewidth(k)
+    idx = i ÷ W + (tile_size(k, 1) ÷ W) * j + 1
+    return Complex(acc[idx][i % W + 1], acc[length(acc) ÷ 2 + idx][i % W + 1])
+end
+function mk_read(k::Union{OneMKernel, FMAddSubKernel}, acc, i, j)
+    W = lanewidth(k)
+    v, u = divrem(i, W ÷ 2)
+    vec = acc[v + (2 * tile_size(k, 1) ÷ W) * j + 1]
+    return Complex(vec[2u + 1], vec[2u + 2])
+end
+
+mk_fill_acc(k, x) = map(v -> typeof(v)(x), zero_accumulator(k))
+mk_nan(T) = T <: Complex ? T(NaN, NaN) : T(NaN)
+mk_inf(T) = T <: Complex ? T(Inf, Inf) : T(Inf)
+mk_tol(T) = real(T) === Float64 ? 1.0e-11 : 2.0f-4
+mk_close(got, want, T) = all(abs.(got .- want) .<= mk_tol(T) .* max.(1, abs.(want)))
+mk_alphabeta(T) = T <: Complex ?
+    ((one(T), zero(T)), (T(2.5, -1), T(-1.75, 0.5)), (one(T), one(T)), (zero(T), T(3, 1)), (T(1, 1), T(2, 0))) :
+    ((one(T), zero(T)), (T(2.5), T(-1.75)), (one(T), one(T)), (zero(T), T(3)), (T(1.5), T(2)))
+
+# The storage the driver hands `store_tile!`: `Memory{T}` on Julia >= 1.11.
+mk_dense(v::AbstractVector{T}) where {T} = copyto!(parent(StridedView(zeros(T, length(v)))), v)
+
+# Element types of the test operands A and B; the mixed-domain kernels differ.
+mk_optypes(k) = (scalartype(k), scalartype(k))
+
+mk_run_acc(k, pa, pb, k_block_length) = add_tile(k, zero_accumulator(k), pa, pb, k_block_length)
+mk_run_exec(k, dst, pa, pb, k_block_length, alpha, beta) = (execute_tile!(k, dst, pa, pb, k_block_length, alpha, beta); nothing)
+
+# `full = false` checks only add_tile against the reference and allocations.
+# Separate functions, so the light check does not compile the full one.
+function mk_contract(k; full::Bool = true)
+    return @testset "$(nameof(typeof(k))){$(tile_size(k, 1)),$(tile_size(k, 2)),$(scalartype(k))}" begin
+        mk_contract_light(k)
+        full && mk_contract_full(k)
+    end
+end
+
+function mk_contract_light(k)
+    T = scalartype(k)
+    TA, TB = mk_optypes(k)
+    MR, NR = tile_size(k)
+    rng = MersenneTwister(100MR + NR)
+    k_block_length = 5
+    A = rand(rng, TA, MR, k_block_length)
+    B = rand(rng, TB, k_block_length, NR)
+    pa, pb = mk_pack(k, A, B)
+    @test (length(pa), length(pb)) == (packed_a_length(k, k_block_length), packed_b_length(k, k_block_length))
+    acc = mk_run_acc(k, pa, pb, k_block_length)
+    @test mk_close([mk_read(k, acc, i, j) for i in 0:(MR - 1), j in 0:(NR - 1)], A * B, T)
+
+    # Allocation-free, including a scattered destination and a dense one
+    # with a partial row block. Julia 1.10 does not keep the tuple
+    # accumulator in registers.
+    m = max(1, MR - 1)
+    skip = VERSION < v"1.11"
+    ab = (T(2), T(0.5))
+    scat = Tile(zeros(T, MR * NR), 0, view(collect(0:(MR - 1)), 1:MR), AffineAxis(0, MR, NR))
+    part = Tile(mk_dense(zeros(T, m * NR)), 0, AffineAxis(0, 1, m), AffineAxis(0, m, NR))
+    mk_run_acc(k, pa, pb, k_block_length)
+    @test (@allocated mk_run_acc(k, pa, pb, k_block_length)) == 0 skip = skip
+    for dst in (scat, part)
+        mk_run_exec(k, dst, pa, pb, k_block_length, ab...)
+        @test (@allocated mk_run_exec(k, dst, pa, pb, k_block_length, ab...)) == 0 skip = skip
+    end
+    return nothing
+end
+
+function mk_contract_full(k)
+    T = scalartype(k)
+    TA, TB = mk_optypes(k)
+    R = real(T)
+    MR, NR = tile_size(k)
+    rng = MersenneTwister(100MR + NR + 1)
+    m = max(1, MR - 1)
+    k_block_length = 5
+    A = rand(rng, TA, MR, k_block_length)
+    B = rand(rng, TB, k_block_length, NR)
+    pa, pb = mk_pack(k, A, B)
+    acc = mk_run_acc(k, pa, pb, k_block_length)
+
+    acc0 = zero_accumulator(k)
+    @test all(iszero(mk_read(k, acc0, i, j)) for i in 0:(MR - 1), j in 0:(NR - 1))
+    @test add_tile(k, acc0, R[], R[], 0) === acc0
+    @test_throws ArgumentError add_tile(k, acc0, R[], R[], -1)
+    # Splitting k_block_length across calls composes.
+    la, lb = length(pa) ÷ k_block_length, length(pb) ÷ k_block_length
+    accs = zero_accumulator(k)
+    for p in 0:(k_block_length - 1)
+        accs = add_tile(k, accs, pa[(p * la + 1):((p + 1) * la)], pb[(p * lb + 1):((p + 1) * lb)], 1)
+    end
+    @test all(mk_read(k, accs, i, j) ≈ mk_read(k, acc, i, j) for i in 0:(MR - 1), j in 0:(NR - 1))
+
+    # alpha*A*B + beta*C on the vector-store and scalar-store paths, every
+    # alpha/beta branch, partial tiles; old C is NaN whenever beta == 0.
+    pad, sentinel = 2, T(-77)
+    extents = unique(((MR, NR), (1, 1), (m, NR), (MR, max(1, NR - 1)), (MR ÷ 2 + 1, min(2, NR)), (0, 0)))
+    for k_block_length in (0, 1, 5), (alpha, beta) in mk_alphabeta(T), (m, n) in extents, scattered in (false, true)
+        A = rand(rng, TA, MR, k_block_length)
+        B = rand(rng, TB, k_block_length, NR)
+        pa, pb = k_block_length == 0 ? (R[], R[]) : mk_pack(k, A, B)
+        Cold = iszero(beta) ? fill(mk_nan(T), m * n) : rand(rng, T, m * n)
+        storage = [fill(sentinel, pad); Cold; fill(sentinel, pad)]
+        scattered || (storage = mk_dense(storage))
+        rows = scattered ? view(collect(0:(m - 1)), 1:m) : AffineAxis(0, 1, m)
+        execute_tile!(k, Tile(storage, pad, rows, AffineAxis(0, m, n)), pa, pb, k_block_length, alpha, beta)
+        AB = (A * B)[1:m, 1:n]
+        want = iszero(beta) ? alpha .* vec(AB) : alpha .* vec(AB) .+ beta .* Cold
+        @test mk_close(storage[(pad + 1):(pad + m * n)], want, T)
+        @test all(==(sentinel), storage[[1:pad; (pad + m * n + 1):(2pad + m * n)]])
+    end
+
+    # Nonfinite padding lanes (rows >= m, columns >= n) never reach C.
+    m, n = max(1, MR - 1), max(1, NR - 1)
+    A = rand(rng, TA, MR, 2)
+    B = rand(rng, TB, 2, NR)
+    A[(m + 1):end, :] .= mk_inf(TA)
+    B[:, (n + 1):end] .= mk_inf(TB)
+    pa, pb = mk_pack(k, A, B)
+    acc = mk_run_acc(k, pa, pb, 2)
+    @test any(!isfinite(mk_read(k, acc, i, j)) for i in 0:(MR - 1), j in 0:(NR - 1))
+    for (storage, rows) in ((mk_dense(fill(mk_nan(T), m * n)), AffineAxis(0, 1, m)), (fill(mk_nan(T), m * n), view(collect(0:(m - 1)), 1:m)))
+        execute_tile!(k, Tile(storage, 0, rows, AffineAxis(0, m, n)), pa, pb, 2, one(T), zero(T))
+        @test mk_close(storage, vec(A[1:m, :] * B[:, 1:n]), T)
+    end
+
+    # alpha == 0 never reads acc or the panels; k_block_length == 0 never reads the panels.
+    fulltile(s) = Tile(s, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, NR))
+    storage = mk_dense(fill(T(2), MR * NR))
+    store_tile!(fulltile(storage), mk_fill_acc(k, R(NaN)), zero(T), T(3), k)
+    @test all(==(T(6)), storage)
+    fill!(storage, mk_nan(T))
+    execute_tile!(k, fulltile(storage), R[], R[], 5, zero(T), zero(T))
+    @test all(iszero, storage)
+    empty = Tile(T[], 0, AffineAxis(0, 1, 0), AffineAxis(0, 0, 0))
+    @test store_tile!(empty, acc, one(T), zero(T), k) === empty
+    @test execute_tile!(k, empty, pa, pb, 2, one(T), one(T)) === empty
+
+    # Rejected inputs.
+    st = zeros(T, (MR + 1) * (NR + 1))
+    @test_throws ArgumentError execute_tile!(k, Tile(st, 0, AffineAxis(0, 1, MR + 1), AffineAxis(0, MR + 1, NR)), pa, pb, 2, one(T), zero(T))
+    @test_throws ArgumentError execute_tile!(k, Tile(st, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, NR + 1)), pa, pb, 2, one(T), zero(T))
+    @test_throws ArgumentError execute_tile!(k, fulltile(st), pa, pb, -1, one(T), zero(T))
+    @test_throws DimensionMismatch execute_tile!(k, fulltile(st), pa[1:(end - 1)], pb, 2, one(T), zero(T))
+    @test_throws DimensionMismatch execute_tile!(k, fulltile(st), pa, pb[1:(end - 1)], 2, one(T), zero(T))
+    # Out-of-bounds destination storage, before any write.
+    canary = fill(T(999), MR * NR)
+    @test_throws BoundsError execute_tile!(k, Tile(canary, 1, AffineAxis(0, 1, MR), AffineAxis(0, MR, NR)), pa, pb, 2, one(T), T(2))
+    @test all(==(T(999)), canary)
+
+    # Destination layouts: each lands on exactly its own addresses.
+    A = rand(rng, TA, MR, k_block_length)
+    B = rand(rng, TB, k_block_length, NR)
+    pa, pb = mk_pack(k, A, B)
+    AB = A * B
+    ld = m + 3
+    perm = randperm(rng, ld)[1:m] .- 1
+    cperm = ld .* (randperm(rng, n) .- 1)
+    nanbuf(len) = fill(mk_nan(T), len)
+    layouts = (
+        # (storage, base, rows, cols, zero-based address of (i, j))
+        (nanbuf(ld * n), 0, view(perm, 1:m), AffineAxis(0, ld, n), (i, j) -> perm[i + 1] + ld * j),
+        (mk_dense(nanbuf(ld * n)), (m - 1) + ld * (n - 1), AffineAxis(0, -1, m), AffineAxis(0, -ld, n), (i, j) -> (m - 1 - i) + ld * (n - 1 - j)),
+        (mk_dense(nanbuf(2ld * n)), 0, AffineAxis(0, 2, m), AffineAxis(0, 2ld, n), (i, j) -> 2i + 2ld * j),
+        (mk_dense(nanbuf(ld * n)), 0, AffineAxis(0, 1, m), AffineAxis(0, ld, n), (i, j) -> i + ld * j),
+        (mk_dense(nanbuf(ld * n)), 0, AffineAxis(0, 1, m), view(cperm, 1:n), (i, j) -> i + cperm[j + 1]),
+        (view(nanbuf(ld * n + 4), 3:(ld * n + 2)), 0, AffineAxis(0, 1, m), AffineAxis(0, ld, n), (i, j) -> i + ld * j),
+    )
+    for (storage, base, rows, cols, addr) in layouts
+        execute_tile!(k, Tile(storage, base, rows, cols), pa, pb, k_block_length, one(T), zero(T))
+        got = [storage[addr(i, j) + 1] for i in 0:(m - 1), j in 0:(n - 1)]
+        @test mk_close(got, AB[1:m, 1:n], T)
+        @test count(!isnan, storage) == m * n
+    end
+    return nothing
+end
diff --git a/test/microkernels/test_fmaddsub_kernel.jl b/test/microkernels/test_fmaddsub_kernel.jl
index e4fa535..39d25a5 100644
--- a/test/microkernels/test_fmaddsub_kernel.jl
+++ b/test/microkernels/test_fmaddsub_kernel.jl
@@ -1,23 +1,23 @@
-using QuasiStrided: FMAddSubKernel, FMAddSubMethod, PlanarKernel, PlanarMethod, OneMKernel,
-    InterleavedFormat, SourceTile, complex_method, lanewidth, kernel_shapes, packed_panel,
-    _kernel_from_shape, _default_method, accumulator_planes, target_profile, PackedPanel
+include("helpers.jl")
+
+using QuasiStrided: FMAddSubKernel, lanewidth, kernel_shapes, packed_panel,
+    accumulator_planes, target_profile, PackedPanel
 using SIMD: Vec
 using InteractiveUtils: code_native
 
-const _QSF = QuasiStrided
+const QSF = QuasiStrided
 
 @testset "FMAddSubKernel" begin
     full = ((ComplexF64, (12, 8, 8)), (ComplexF32, (8, 5, 8)))
     for (T, (MR, NR, W)) in full
         mk_contract(FMAddSubKernel(Val(MR), Val(NR), T, Val(W)))
     end
-    for T in (ComplexF64, ComplexF32), s in (kernel_shapes(T, FMAddSubMethod())..., (2, 3, 4))
+    for T in (ComplexF64, ComplexF32), s in (kernel_shapes(T, FMAddSubKernel)..., (2, 3, 4))
         (T, s) in full || mk_contract(FMAddSubKernel(Val(s[1]), Val(s[2]), T, Val(s[3])); full = false)
     end
 
     @testset "construction" begin
-        @test complex_method(FMAddSubKernel(Val(8), Val(4), ComplexF64)) === FMAddSubMethod()
-        @test accumulator_planes(FMAddSubMethod()) == 1
+        @test accumulator_planes(FMAddSubKernel) == 1
         @test lanewidth(FMAddSubKernel(Val(8), Val(4), ComplexF32)) == 8
         @test_throws ArgumentError FMAddSubKernel(Val(12), Val(8), ComplexF64, Val(16))
         @test_throws ArgumentError FMAddSubKernel(Val(3), Val(4), ComplexF64, Val(3))  # odd W
@@ -26,20 +26,20 @@ const _QSF = QuasiStrided
         @test_throws ArgumentError FMAddSubKernel(Val(8), Val(4), Float64, Val(4))
     end
 
-    @testset "_fmaddsub is lane-exact x86 fmaddsub; _swap_pairs swaps pairs" begin
+    @testset "fmaddsub is lane-exact x86 fmaddsub; swap_pairs swaps pairs" begin
         rng = MersenneTwister(0xADD5)
         for R in (Float64, Float32), N in (2, 4, 8, 16), _ in 1:10
             x, y, c = (Vec{N, R}(ntuple(_ -> randn(rng, R), N)) for _ in 1:3)
             # One fused rounding per lane, with an exactly negated addend in even lanes.
-            @test Tuple(_QSF._fmaddsub(x, y, c)) ===
+            @test Tuple(QSF.fmaddsub(x, y, c)) ===
                 ntuple(l -> isodd(l) ? fma(x[l], y[l], -c[l]) : fma(x[l], y[l], c[l]), N)
-            @test Tuple(_QSF._swap_pairs(x)) === ntuple(l -> isodd(l) ? x[l + 1] : x[l - 1], N)
+            @test Tuple(QSF.swap_pairs(x)) === ntuple(l -> isodd(l) ? x[l + 1] : x[l - 1], N)
         end
         x = Vec{4, Float64}((0.0, -0.0, Inf, 1.0))
         y = Vec{4, Float64}((1.0, 1.0, 1.0, NaN))
         c = Vec{4, Float64}((0.0, 0.0, 1.0, 1.0))
         @test isequal(
-            Tuple(_QSF._fmaddsub(x, y, c)),
+            Tuple(QSF.fmaddsub(x, y, c)),
             (fma(0.0, 1.0, -0.0), fma(-0.0, 1.0, 0.0), fma(Inf, 1.0, -1.0), fma(1.0, NaN, 1.0))
         )
     end
@@ -50,9 +50,9 @@ const _QSF = QuasiStrided
             b = Complex{R}(7, -2)
             c = Vec{2, R}((R(11), R(13)))
             br, bi = Vec{2, R}(real(b)), Vec{2, R}(imag(b))
-            right = _QSF._fmaddsub(a, br, _QSF._fmaddsub(_QSF._swap_pairs(a), bi, c))
+            right = QSF.fmaddsub(a, br, QSF.fmaddsub(QSF.swap_pairs(a), bi, c))
             @test Complex(right[1], right[2]) == Complex{R}(11, 13) + Complex{R}(3, 5) * b
-            wrong = _QSF._fmaddsub(_QSF._swap_pairs(a), bi, _QSF._fmaddsub(a, br, c))
+            wrong = QSF.fmaddsub(QSF.swap_pairs(a), bi, QSF.fmaddsub(a, br, c))
             @test wrong[1] == R(11) + R(5) * imag(b) - R(3) * real(b)
         end
     end
@@ -68,7 +68,7 @@ const _QSF = QuasiStrided
     end
 
     @testset "instruction selection: vfmaddsub, no separate mul/add/sub, no spill" begin
-        # Exact instruction counts in the hot loop of `accumulate`, so only on
+        # Exact instruction counts in the hot loop of `add_tile`, so only on
         # an FMA3 x86 host and not on hosted CI, whose virtualized CPU feature
         # sets do not reliably match.
         isa = target_profile().isa
@@ -93,7 +93,7 @@ const _QSF = QuasiStrided
             R = real(T)
             asm = sprint() do io
                 code_native(
-                    io, Base.accumulate,
+                    io, QuasiStrided.add_tile,
                     (typeof(k), typeof(zero_accumulator(k)), PackedPanel{R}, PackedPanel{R}, Int);
                     debuginfo = :none, syntax = :intel
                 )
@@ -107,67 +107,4 @@ const _QSF = QuasiStrided
             @test count(r"\[r[sb]p", loop) == 0 skip = !has_fma
         end
     end
-
-    @testset "pack_a! InterleavedFormat: scalar loop and fast path vs local layout" begin
-        # Bitwise (`isequal` separates -0.0): packing is a copy, or a sign flip under conj.
-        for T in (ComplexF64, ComplexF32), (MR, NR, W) in (kernel_shapes(T, FMAddSubMethod())..., (3, 2, 2))
-            R = real(T)
-            k = FMAddSubKernel(Val(MR), Val(NR), T, Val(W))
-            kc, lda, base = 7, MR + 3, 2
-            vals = [T(10i + 1, -(10i + 2)) for i in 1:(lda * kc + 4)]
-            vals[5] = T(0, 0)
-            vals[9] = T(R(-0.0), R(0))
-            for f in (identity, conj), m in (MR, max(1, MR - 1))
-                src = SourceTile(vals, base, AffineAxis(0, 1, m), AffineAxis(0, lda, kc))
-                A = zeros(T, MR, kc)
-                A[1:m, :] = f.(reshape(vals[(base + 1):(base + lda * kc)], lda, kc)[1:m, :])
-                want = mk_pack_a(k, A)
-                bufv = fill(R(-777), packed_a_length(k, kc))  # a Vector: the scalar loop
-                pack_a!(bufv, src, k, f)
-                @test isequal(bufv, want)
-                bufp = fill(R(-777), packed_a_length(k, kc))  # a PackedPanel: the fast path where gated in
-                GC.@preserve bufp pack_a!(packed_panel(bufp, 1, length(bufp)), src, k, f)
-                @test isequal(bufp, want)
-            end
-            src = SourceTile(vals, base, AffineAxis(0, 1, MR), AffineAxis(0, lda, kc))
-            bufp = zeros(R, packed_a_length(k, kc))
-            GC.@preserve bufp begin
-                pp = packed_panel(bufp, 1, length(bufp))
-                @test _QSF._pack_complex_contiguous_eligible(
-                    pp, vals, src.rows, identity, InterleavedFormat(), MR, Val(MR), T
-                ) == _QSF._complex_fastpath_isa_eligible()
-            end
-        end
-    end
-
-    @testset "blocking and selection" begin
-        for T in (ComplexF64, ComplexF32)
-            bf = default_blocking(FMAddSubKernel(Val(8), Val(8), T, Val(8)))
-            bp = default_blocking(PlanarKernel(Val(8), Val(8), T, Val(8)))
-            @test (bf.mc, bf.kc, bf.nc) == (bp.mc, bp.kc, bp.nc)  # planar's packed reals
-            for s in kernel_shapes(T, FMAddSubMethod())
-                @test _kernel_from_shape(s, T, FMAddSubMethod()) isa FMAddSubKernel{s[1], s[2], T, s[3]}
-            end
-            @test_throws ArgumentError _kernel_from_shape((7, 7, 7), T, FMAddSubMethod())
-            @test !(_QSF._default_kernel(T, 1024, 1024) isa FMAddSubKernel)
-        end
-    end
-
-    mk_e2e(ComplexF64, FMAddSubKernel(Val(4), Val(5), ComplexF64, Val(4)))
-    mk_e2e(ComplexF32, FMAddSubKernel(Val(8), Val(5), ComplexF32, Val(8)))
-
-    @testset "end to end: permuted/strided tensor contraction" begin
-        T = ComplexF64
-        rng = MersenneTwister(99)
-        A = rand(rng, T, 5, 9, 7)  # a, k, b: non-unit-stride M composite
-        B = rand(rng, T, 6, 9)     # n, k: transposed
-        C = zeros(T, 5, 6, 7)
-        plan = plan_contract(
-            StridedView(C), StridedView(A), (1, 2, 3), StridedView(B), (4, 2), (1, 4, 3);
-            kernel = FMAddSubKernel(Val(12), Val(8), T, Val(8))
-        )
-        execute!(plan, one(T), zero(T))
-        want = [sum(A[a, k, b] * B[n, k] for k in 1:9) for a in 1:5, n in 1:6, b in 1:7]
-        @test maximum(abs, C .- want) <= 64 * mk_tol(T)
-    end
 end
diff --git a/test/microkernels/test_mixed_kernel.jl b/test/microkernels/test_mixed_kernel.jl
index c501be3..365abdc 100644
--- a/test/microkernels/test_mixed_kernel.jl
+++ b/test/microkernels/test_mixed_kernel.jl
@@ -1,3 +1,5 @@
+include("helpers.jl")
+
 using QuasiStrided: ComplexRealKernel, RealComplexKernel, packed_panel
 
 mk_optypes(k::ComplexRealKernel) = (scalartype(k), real(scalartype(k)))
@@ -9,12 +11,12 @@ mk_pack_b(::RealComplexKernel, B) = mk_cols(c -> mk_ilv(real(c), imag(c)), permu
 function mk_read(k::ComplexRealKernel, acc, i, j)
     W = lanewidth(k)
     v, u = divrem(i, W ÷ 2)
-    vec = acc[v + (2 * mr(k) ÷ W) * j + 1]
+    vec = acc[v + (2 * tile_size(k, 1) ÷ W) * j + 1]
     return Complex(vec[2u + 1], vec[2u + 2])
 end
 function mk_read(k::RealComplexKernel, acc, i, j)
     W = lanewidth(k)
-    MV = mr(k) ÷ W
+    MV = tile_size(k, 1) ÷ W
     v, u = divrem(i, W)
     return Complex(acc[v + MV * 2j + 1][u + 1], acc[v + MV * (2j + 1) + 1][u + 1])
 end
@@ -33,9 +35,9 @@ end
     @testset "construction" begin
         cr = ComplexRealKernel(Val(8), Val(4), ComplexF32)
         rc = RealComplexKernel(Val(8), Val(4), ComplexF64)
-        @test cr.inner isa SIMDKernel{16, 4, Float32, 8}
-        @test rc.inner isa SIMDKernel{8, 8, Float64, 4}
-        @test (packed_a_per_k(cr), packed_b_per_k(cr), packed_a_per_k(rc), packed_b_per_k(rc)) == (16, 4, 8, 8)
+        @test QuasiStrided.inner(cr) isa SIMDKernel{16, 4, Float32, 8}
+        @test QuasiStrided.inner(rc) isa SIMDKernel{8, 8, Float64, 4}
+        @test (sliver_width(cr)..., sliver_width(rc)...) == (16, 4, 8, 8)
         @test_throws ArgumentError ComplexRealKernel(Val(3), Val(4), ComplexF64, Val(3))  # odd W
         @test_throws ArgumentError RealComplexKernel(Val(6), Val(4), ComplexF64, Val(4))
         @test_throws ArgumentError ComplexRealKernel(Val(8), Val(4), Float64)
@@ -43,7 +45,7 @@ end
     end
 
     # Packing from storage of another precision, `conj` on both sides.
-    @testset "pack -> accumulate -> store: $(nameof(K)) $T from $SA x $SB" for (K, T, SA, SB, MR, NR, W) in (
+    @testset "pack -> add_tile -> store: $(nameof(K)) $T from $SA x $SB" for (K, T, SA, SB, MR, NR, W) in (
             (ComplexRealKernel, ComplexF32, ComplexF64, Float64, 8, 5, 8),
             (RealComplexKernel, ComplexF32, Float64, ComplexF64, 16, 3, 8),
             (ComplexRealKernel, ComplexF64, ComplexF64, Float32, 12, 8, 8),
@@ -52,28 +54,28 @@ end
         k = K(Val(MR), Val(NR), T, Val(W))
         R = real(T)
         rng = MersenneTwister(7)
-        kc, lda = 6, MR + 2
-        Av, Bv = rand(rng, SA, lda * kc + 1), rand(rng, SB, kc * NR)
+        k_block_length, lda = 6, MR + 2
+        Av, Bv = rand(rng, SA, lda * k_block_length + 1), rand(rng, SB, k_block_length * NR)
         for f in (identity, conj), (m, n) in ((MR, NR), (MR - 1, NR - 1)), panel in (false, true)
-            srcA = SourceTile(Av, 1, AffineAxis(0, 1, m), AffineAxis(0, lda, kc))
-            srcB = SourceTile(Bv, 0, AffineAxis(0, NR, kc), AffineAxis(0, 1, n))
-            A = zeros(T, MR, kc)
-            B = zeros(T, kc, NR)
-            A[1:m, :] = f.(reshape(Av[2:(1 + lda * kc)], lda, kc)[1:m, :])
-            B[:, 1:n] = f.(permutedims(reshape(Bv, NR, kc))[:, 1:n])
+            srcA = Tile(Av, 1, AffineAxis(0, 1, m), AffineAxis(0, lda, k_block_length))
+            srcB = Tile(Bv, 0, AffineAxis(0, NR, k_block_length), AffineAxis(0, 1, n))
+            A = zeros(T, MR, k_block_length)
+            B = zeros(T, k_block_length, NR)
+            A[1:m, :] = f.(reshape(Av[2:(1 + lda * k_block_length)], lda, k_block_length)[1:m, :])
+            B[:, 1:n] = f.(permutedims(reshape(Bv, NR, k_block_length))[:, 1:n])
             TA, TB = mk_optypes(k)
-            pa, pb = zeros(R, packed_a_length(k, kc)), zeros(R, packed_b_length(k, kc))
+            pa, pb = zeros(R, packed_a_length(k, k_block_length)), zeros(R, packed_b_length(k, k_block_length))
             GC.@preserve pa pb begin
                 dpa = panel ? packed_panel(pa, 1, length(pa)) : pa
                 dpb = panel ? packed_panel(pb, 1, length(pb)) : pb
-                pack_a!(dpa, srcA, k, f)
-                pack_b!(dpb, srcB, k, f)
+                pack!(dpa, srcA, sliver_spec(k, 1), f)
+                pack!(dpb, transpose(srcB), sliver_spec(k, 2), f)
             end
             @test isequal((pa, pb), mk_pack(k, TA.(A), TB.(B)))
             alpha, beta = T(1.5, -0.5), T(0.25, 1)
             C0 = rand(rng, T, m * n)
             got = mk_dense(copy(C0))
-            execute_tile!(k, DestinationTile(got, 0, AffineAxis(0, 1, m), AffineAxis(0, m, n)), pa, pb, kc, alpha, beta)
+            execute_tile!(k, Tile(got, 0, AffineAxis(0, 1, m), AffineAxis(0, m, n)), pa, pb, k_block_length, alpha, beta)
             @test mk_close(got, alpha .* vec((A * B)[1:m, 1:n]) .+ beta .* C0, T)
         end
     end
@@ -81,28 +83,21 @@ end
     @testset "end to end: $(nameof(typeof(k))) $TA x $TB -> $TC, B $mode" for (k, TA, TB, TC, acc, mode) in (
             (ComplexRealKernel(Val(12), Val(8), ComplexF64, Val(8)), ComplexF64, Float64, ComplexF64, nothing, :always),
             (ComplexRealKernel(Val(12), Val(8), ComplexF64, Val(8)), ComplexF64, Float64, ComplexF64, nothing, :never),
-            (ComplexRealKernel(Val(8), Val(5), ComplexF32, Val(8)), ComplexF32, Float64, ComplexF32, Float32, :auto),
-            (RealComplexKernel(Val(24), Val(4), ComplexF64, Val(8)), Float64, ComplexF64, ComplexF64, nothing, :auto),
             (RealComplexKernel(Val(16), Val(3), ComplexF32, Val(8)), Float64, ComplexF32, ComplexF32, Float32, :auto),
         )
         rng = MersenneTwister(4242)
         A, B, C0 = rand(rng, TA, 37, 41), rand(rng, TB, 41, 23), rand(rng, TC, 37, 23)
         alpha, beta = 1.5 - 0.25im, -0.75 + 0.5im
-        saved = QuasiStrided._UNPACKED_B_MODE[]
-        QuasiStrided._UNPACKED_B_MODE[] = mode
-        try
-            for (cA, cB) in ((false, false), (true, true))
-                C = copy(C0)
-                plan = plan_contract(
-                    StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3);
-                    kernel = k, kc = 16, conjA = cA, conjB = cB, accumulator = acc
-                )
-                execute!(plan, alpha, beta)
-                want = alpha .* ((cA ? conj.(A) : A) * (cB ? conj.(B) : B)) .+ beta .* C0
-                @test maximum(abs, C .- want) <= 64 * mk_tol(TC) * maximum(abs, want)
-            end
-        finally
-            QuasiStrided._UNPACKED_B_MODE[] = saved
+        for (cA, cB) in ((false, false), (true, true))
+            C = copy(C0)
+            plan = plan_contract(
+                StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3);
+                kernel = k, k_block = 16, conjA = cA, conjB = cB, accumulator = acc,
+                path_modes = QuasiStrided.PathModes(unpacked_b = mode)
+            )
+            execute!(plan, alpha, beta)
+            want = alpha .* ((cA ? conj.(A) : A) * (cB ? conj.(B) : B)) .+ beta .* C0
+            @test maximum(abs, C .- want) <= 64 * mk_tol(TC) * maximum(abs, want)
         end
     end
 end
diff --git a/test/microkernels/test_onem_kernel.jl b/test/microkernels/test_onem_kernel.jl
index 9b8c7d6..a4c8719 100644
--- a/test/microkernels/test_onem_kernel.jl
+++ b/test/microkernels/test_onem_kernel.jl
@@ -1,21 +1,20 @@
-using QuasiStrided: OneMKernel, OneMMethod, PlanarKernel, PlanarMethod, OneEFormat,
-    PlanarFormat, ComplexKernelDescriptor, complex_method, lanewidth, kernel_shapes,
-    _kernel_from_shape, _default_method
+include("helpers.jl")
+
+using QuasiStrided: OneMKernel, lanewidth, kernel_shapes
 
 @testset "OneMKernel" begin
     full = ((ComplexF64, (12, 8, 8)), (ComplexF32, (8, 6, 8)))
     for (T, (MR, NR, W)) in full
         mk_contract(OneMKernel(Val(MR), Val(NR), T, Val(W)))
     end
-    for T in (ComplexF64, ComplexF32), s in (kernel_shapes(T, OneMMethod())..., (8, 4, 4))
+    for T in (ComplexF64, ComplexF32), s in (kernel_shapes(T, OneMKernel)..., (8, 4, 4))
         (T, s) in full || mk_contract(OneMKernel(Val(s[1]), Val(s[2]), T, Val(s[3])); full = false)
     end
 
     @testset "construction" begin
         k = OneMKernel(Val(12), Val(8), ComplexF64, Val(8))
-        @test k.inner isa SIMDKernel{24, 8, Float64, 8}  # the real kernel, at 2MR rows
-        @test zero_accumulator(k) === zero_accumulator(k.inner)
-        @test complex_method(k) === OneMMethod()
+        @test QuasiStrided.inner(k) isa SIMDKernel{24, 8, Float64, 8}  # the real kernel, at 2MR rows
+        @test zero_accumulator(k) === zero_accumulator(QuasiStrided.inner(k))
         @test lanewidth(OneMKernel(Val(8), Val(4), ComplexF32)) == 8
         # 2MR, not MR, must divide by W; W must be even even where 2MR divides.
         @test_throws ArgumentError OneMKernel(Val(12), Val(8), ComplexF64, Val(16))
@@ -23,33 +22,12 @@ using QuasiStrided: OneMKernel, OneMMethod, PlanarKernel, PlanarMethod, OneEForm
         @test_throws ArgumentError OneMKernel(Val(8), Val(4), ComplexF64, Val(0))
         @test_throws ArgumentError OneMKernel(Val(8), Val(4), Float64)
         @test_throws ArgumentError OneMKernel(Val(8), Val(4), Float64, Val(4))
-        wrong = SIMDKernel(Val(12), Val(8), Float64, Val(4))
-        d = ComplexKernelDescriptor(Val(12), Val(8), ComplexF64, OneEFormat(), PlanarFormat())
-        @test_throws ArgumentError OneMKernel{12, 8, ComplexF64, 8, typeof(wrong)}(d, wrong)
-        # The error reports the logical kc, not the doubled real one.
+        # The error reports the logical k_block_length, not the doubled real one.
         err = try
-            accumulate(k, zero_accumulator(k), Float64[], Float64[], -3)
+            add_tile(k, zero_accumulator(k), Float64[], Float64[], -3)
         catch e
             e
         end
-        @test err isa ArgumentError && occursin("kc = -3", err.msg)
+        @test err isa ArgumentError && occursin("k_block_length = -3", err.msg)
     end
-
-    @testset "blocking and selection" begin
-        for T in (ComplexF64, ComplexF32)
-            bm = default_blocking(OneMKernel(Val(8), Val(8), T, Val(8)))
-            bp = default_blocking(PlanarKernel(Val(8), Val(8), T, Val(8)))
-            @test (bm.mc, bm.kc, bm.nc) == (bp.mc ÷ 2, bp.kc, bp.nc)  # twice the packed A reals
-            for s in kernel_shapes(T, OneMMethod())
-                @test _kernel_from_shape(s, T, OneMMethod()) isa OneMKernel{s[1], s[2], T, s[3]}
-            end
-            @test_throws ArgumentError _kernel_from_shape((7, 7, 7), T, OneMMethod())
-            # Never the default: method ranking does not transfer between machines.
-            @test _default_method(T) === PlanarMethod()
-            @test QuasiStrided._default_kernel(T, 1024, 1024) isa PlanarKernel
-        end
-    end
-
-    mk_e2e(ComplexF64, OneMKernel(Val(12), Val(8), ComplexF64, Val(8)))
-    mk_e2e(ComplexF32, OneMKernel(Val(24), Val(8), ComplexF32, Val(16)))
 end
diff --git a/test/microkernels/test_planar_kernel.jl b/test/microkernels/test_planar_kernel.jl
index 9163919..ed26043 100644
--- a/test/microkernels/test_planar_kernel.jl
+++ b/test/microkernels/test_planar_kernel.jl
@@ -1,4 +1,6 @@
-using QuasiStrided: PlanarKernel, PlanarMethod, complex_method, lanewidth,
+include("helpers.jl")
+
+using QuasiStrided: PlanarKernel, lanewidth,
     KERNEL_SHAPES_C64_PLANAR, KERNEL_SHAPES_C32_PLANAR
 
 @testset "PlanarKernel" begin
@@ -11,14 +13,9 @@ using QuasiStrided: PlanarKernel, PlanarMethod, complex_method, lanewidth,
     end
 
     k = PlanarKernel(Val(16), Val(6), ComplexF64, Val(8))
-    @test complex_method(k) === PlanarMethod()
     @test lanewidth(PlanarKernel(Val(8), Val(4), ComplexF64)) == 4  # from the REAL type
     @test lanewidth(PlanarKernel(Val(8), Val(4), ComplexF32)) == 8
     @test_throws ArgumentError PlanarKernel(Val(6), Val(4), ComplexF64, Val(4))
     @test_throws ArgumentError PlanarKernel(Val(8), Val(4), ComplexF64, Val(0))
     @test_throws ArgumentError PlanarKernel(Val(8), Val(4), Float64)
-    # A complex kernel is never asked for a single-plane offset.
-    @test_throws MethodError QuasiStrided.packed_a_offset(k, 0, 0)
-
-    mk_e2e(ComplexF64, nothing)
 end
diff --git a/test/microkernels/test_planar_store_fastpath.jl b/test/microkernels/test_planar_store_fastpath.jl
index e9a4441..7a1c0d1 100644
--- a/test/microkernels/test_planar_store_fastpath.jl
+++ b/test/microkernels/test_planar_store_fastpath.jl
@@ -1,9 +1,9 @@
-# The vectorized complex store fast paths (planar here, fmaddsub in
-# test_fmaddsub_store_fastpath.jl, which reuses `mk_store_fastpath`).
+# The vectorized complex store fast paths: split (planar) and lane pairs
+# (1m, fmaddsub).
 #
 # Values are pinned two ways. On the elements the fast path vectorizes (full
 # row blocks) it must match, bitwise, an independent transcription of Base's
-# `Complex` `*`/`muladd` expression trees (the arithmetic `_axpby_tile!` does).
+# `Complex` `*`/`muladd` expression trees (the arithmetic `axpby_tile!` does).
 # Against the scalar store it is compared with a tolerance only: LLVM contracts
 # Base's scalar complex `muladd` depending on inlining context, so the scalar
 # path is not bit-reproducible even against itself.
@@ -11,10 +11,12 @@
 # The fast path ships for AVX-512 only; every expectation derives from the live
 # profile, so `test/forced_isa_runner.jl` checks the other ISAs too.
 
-using QuasiStrided: PlanarKernel, FMAddSubKernel, KERNEL_SHAPES_C64_FMADDSUB, KERNEL_SHAPES_C32_FMADDSUB, PtrScatterAxis, TargetProfile, CacheLevel,
+include("helpers.jl")
+
+using QuasiStrided: PlanarKernel, FMAddSubKernel, OneMKernel, KERNEL_SHAPES_C64_ONEM, KERNEL_SHAPES_C64_FMADDSUB, KERNEL_SHAPES_C32_FMADDSUB, TargetProfile, CacheLevel,
     target_profile, unknown_target, KERNEL_SHAPES_C64_PLANAR, KERNEL_SHAPES_C32_PLANAR
 
-const STORE_FASTPATH_ON = QuasiStrided._complex_fastpath_isa_eligible()
+const STORE_FASTPATH_ON = QuasiStrided.complex_fastpath_isa_eligible()
 
 # `@noinline` identity: keeps LLVM from contracting separately rounded products.
 @noinline barrier(x) = x
@@ -36,7 +38,7 @@ function ref_axpby(alpha::T, rr::R, ri::R, beta::T, cold::T) where {T, R}
     return Complex(fma(ar, rr, barrier(-fma(ai, ri, -xr))), fma(ar, ri, barrier(fma(ai, rr, xi))))
 end
 
-# Every `_axpby_tile!` branch, plus purely imaginary and real non-unit beta.
+# Every `axpby_tile!` branch, plus purely imaginary and real non-unit beta.
 mk_store_ab(T) = (
     (one(T), zero(T)), (T(-0.5, 0.25), zero(T)), (one(T), one(T)), (T(2, -1), one(T)),
     (T(2.5, -1), T(-1.75, 0.5)), (one(T), T(2, 0)), (T(1, 1), T(0, -3)),
@@ -64,11 +66,11 @@ function mk_store_fastpath(K, T, shapes; beta0_exact = false, S = T)
             cold = [S(2rand(rng) - 1, 2rand(rng) - 1) for _ in 1:(m * n)]
             for (alpha, beta) in mk_store_ab(T)
                 fast = mk_dense(cold)
-                dfast = DestinationTile(fast, 0, AffineAxis(0, 1, m), AffineAxis(0, m, n))
-                @test QuasiStrided._complex_vector_eligible(dfast, T) == STORE_FASTPATH_ON
+                dfast = Tile(fast, 0, AffineAxis(0, 1, m), AffineAxis(0, m, n))
+                @test QuasiStrided.vector_store_eligible(QuasiStrided.AccumulatorLayout(k), dfast, T) == STORE_FASTPATH_ON
                 store_tile!(dfast, acc, alpha, beta, k)
                 scal = copy(cold)  # scattered rows: always the scalar store
-                store_tile!(DestinationTile(scal, 0, ScatterAxis(collect(0:(m - 1)), m), AffineAxis(0, m, n)), acc, alpha, beta, k)
+                store_tile!(Tile(scal, 0, view(collect(0:(m - 1)), 1:m), AffineAxis(0, m, n)), acc, alpha, beta, k)
                 want = [S(ref_axpby(alpha, reim(mk_read(k, acc, i, j))..., beta, T(cold[i + j * m + 1]))) for i in 0:(m - 1), j in 0:(n - 1)]
                 got = reshape(collect(fast), m, n)
                 vectorized = STORE_FASTPATH_ON ? (1:((m ÷ blk) * blk)) : (1:0)
@@ -92,32 +94,21 @@ end
         m, n = 16, 4
         storage = zeros(T, 4 * m * n)
         eligible(s, rows, cols = AffineAxis(0, m, n)) =
-            QuasiStrided._complex_vector_eligible(DestinationTile(s, 0, rows, cols), T)
+            QuasiStrided.vector_store_eligible(QuasiStrided.SplitLayout(), Tile(s, 0, rows, cols), T)
         @test eligible(storage, AffineAxis(0, 1, m)) == STORE_FASTPATH_ON
         @test !eligible(storage, AffineAxis(0, 2, m), AffineAxis(0, 2m, n))
-        @test !QuasiStrided._complex_vector_eligible(DestinationTile(storage, m - 1, AffineAxis(0, -1, m), AffineAxis(0, m, n)), T)
-        @test !eligible(storage, ScatterAxis(collect(0:(m - 1)), m))
-        ptr_rows = collect(0:(m - 1))
-        GC.@preserve ptr_rows @test !eligible(storage, PtrScatterAxis(pointer(ptr_rows), m))
+        @test !QuasiStrided.vector_store_eligible(QuasiStrided.SplitLayout(), Tile(storage, m - 1, AffineAxis(0, -1, m), AffineAxis(0, m, n)), T)
+        @test !eligible(storage, view(collect(0:(m - 1)), 1:m))
         @test !eligible(view(storage, 1:(m * n)), AffineAxis(0, 1, m))
         @test !eligible(reshape(storage, 4m, n), AffineAxis(0, 1, m))
         @test eligible(zeros(ComplexF32, m * n), AffineAxis(0, 1, m)) == STORE_FASTPATH_ON
         @test !eligible(zeros(Float64, m * n), AffineAxis(0, 1, m))
     end
-
-    @testset "ISA gate: AVX-512 only" begin
-        profile(key, vb, nreg) = TargetProfile(key, Sys.ARCH, "t", vb, nreg, CacheLevel(), CacheLevel(), CacheLevel())
-        @test QuasiStrided._complex_fastpath_isa_eligible(profile(:avx512, 64, 32))
-        for (key, vb, nreg) in ((:avx2, 32, 16), (:neon, 16, 32), (:unknown, 0, 0))
-            @test !QuasiStrided._complex_fastpath_isa_eligible(profile(key, vb, nreg))
-        end
-        @test !QuasiStrided._complex_fastpath_isa_eligible(unknown_target())
-        @test STORE_FASTPATH_ON == (target_profile().vector_bytes == QuasiStrided._isa_vector_bytes(Val(:avx512)))
-    end
 end
 
 
-@testset "fmaddsub store fast path" begin
+@testset "lane-pair store fast path" begin
+    mk_store_fastpath(OneMKernel, ComplexF64, KERNEL_SHAPES_C64_ONEM[[1, end]]; beta0_exact = true)
     mk_store_fastpath(FMAddSubKernel, ComplexF64, KERNEL_SHAPES_C64_FMADDSUB; beta0_exact = true)
     mk_store_fastpath(FMAddSubKernel, ComplexF32, KERNEL_SHAPES_C32_FMADDSUB; beta0_exact = true)
     mk_store_fastpath(FMAddSubKernel, ComplexF64, KERNEL_SHAPES_C64_FMADDSUB[[1, end]]; beta0_exact = true, S = ComplexF32)
diff --git a/test/microkernels/test_scalar_kernel.jl b/test/microkernels/test_scalar_kernel.jl
index 5c47933..f9d75c9 100644
--- a/test/microkernels/test_scalar_kernel.jl
+++ b/test/microkernels/test_scalar_kernel.jl
@@ -1,233 +1,4 @@
-# The microkernel contract shared by every kernel (`mk_contract`), plus the
-# ScalarKernel runs. Each kernel file calls `mk_contract` on its own shapes.
-#
-# The oracles are test-local: packed panels are written out literally from each
-# format's layout and the accumulator is read back from its documented layout,
-# never through the engine's packers or offset accessors.
-
-using Random
-using QuasiStrided: SIMDKernel, PlanarKernel, OneMKernel, FMAddSubKernel, QSTile
-using SIMD: Vec
-using StridedViews: StridedView
-
-# `[x0, y0, x1, y1, ...]`
-mk_ilv(x, y) = vec(permutedims(hcat(x, y)))
-mk_cols(f, M) = reduce(vcat, [f(c) for c in eachcol(M)])
-
-# Packed A (MR x kc) and B (kc x NR), one K step after another.
-mk_pack_a(::Union{ScalarKernel, SIMDKernel}, A) = vec(A)
-mk_pack_a(::PlanarKernel, A) = mk_cols(c -> [real(c); imag(c)], A)
-mk_pack_a(::OneMKernel, A) =
-    mk_cols(c -> [mk_ilv(real(c), imag(c)); mk_ilv(-imag(c), real(c))], A)
-mk_pack_a(::FMAddSubKernel, A) = mk_cols(c -> mk_ilv(real(c), imag(c)), A)
-mk_pack_b(::Union{ScalarKernel, SIMDKernel}, B) = vec(permutedims(B))
-mk_pack_b(k, B) = mk_cols(c -> [real(c); imag(c)], permutedims(B))
-mk_pack(k, A, B) = (mk_pack_a(k, A), mk_pack_b(k, B))
-
-# Element (i, j), zero-based, of an accumulator.
-mk_read(::ScalarKernel, acc, i, j) = acc[i + 1, j + 1]
-function mk_read(k::SIMDKernel, acc, i, j)
-    W = lanewidth(k)
-    return acc[i ÷ W + (mr(k) ÷ W) * j + 1][i % W + 1]
-end
-function mk_read(k::PlanarKernel, acc, i, j)
-    W = lanewidth(k)
-    idx = i ÷ W + (mr(k) ÷ W) * j + 1
-    return Complex(acc[idx][i % W + 1], acc[length(acc) ÷ 2 + idx][i % W + 1])
-end
-function mk_read(k::Union{OneMKernel, FMAddSubKernel}, acc, i, j)
-    W = lanewidth(k)
-    v, u = divrem(i, W ÷ 2)
-    vec = acc[v + (2 * mr(k) ÷ W) * j + 1]
-    return Complex(vec[2u + 1], vec[2u + 2])
-end
-
-mk_fill_acc(k, x) = (acc = zero_accumulator(k); acc isa AbstractMatrix ? fill(x, size(acc)) : map(v -> typeof(v)(x), acc))
-mk_nan(T) = T <: Complex ? T(NaN, NaN) : T(NaN)
-mk_inf(T) = T <: Complex ? T(Inf, Inf) : T(Inf)
-mk_tol(T) = real(T) === Float64 ? 1.0e-11 : 2.0f-4
-mk_close(got, want, T) = all(abs.(got .- want) .<= mk_tol(T) .* max.(1, abs.(want)))
-mk_alphabeta(T) = T <: Complex ?
-    ((one(T), zero(T)), (T(2.5, -1), T(-1.75, 0.5)), (one(T), one(T)), (zero(T), T(3, 1)), (T(1, 1), T(2, 0))) :
-    ((one(T), zero(T)), (T(2.5), T(-1.75)), (one(T), one(T)), (zero(T), T(3)), (T(1.5), T(2)))
-
-# The storage the driver hands `store_tile!`: `Memory{T}` on Julia >= 1.11.
-mk_dense(v::AbstractVector{T}) where {T} = copyto!(parent(StridedView(zeros(T, length(v)))), v)
-
-# Element types of the test operands A and B; the mixed-domain kernels differ.
-mk_optypes(k) = (scalartype(k), scalartype(k))
-
-mk_run_acc(k, pa, pb, kc) = accumulate(k, zero_accumulator(k), pa, pb, kc)
-mk_run_exec(k, dst, pa, pb, kc, alpha, beta) = (execute_tile!(k, dst, pa, pb, kc, alpha, beta); nothing)
-
-# `full = false` checks only accumulate against the reference and allocations.
-# Separate functions, so the light check does not compile the full one.
-function mk_contract(k; full::Bool = true)
-    return @testset "$(nameof(typeof(k))){$(mr(k)),$(nr(k)),$(scalartype(k))}" begin
-        mk_contract_light(k)
-        full && mk_contract_full(k)
-    end
-end
-
-function mk_contract_light(k)
-    T = scalartype(k)
-    TA, TB = mk_optypes(k)
-    MR, NR = mr(k), nr(k)
-    rng = MersenneTwister(100MR + NR)
-    kc = 5
-    A = rand(rng, TA, MR, kc)
-    B = rand(rng, TB, kc, NR)
-    pa, pb = mk_pack(k, A, B)
-    @test (length(pa), length(pb)) == (packed_a_length(k, kc), packed_b_length(k, kc))
-    acc = mk_run_acc(k, pa, pb, kc)
-    @test mk_close([mk_read(k, acc, i, j) for i in 0:(MR - 1), j in 0:(NR - 1)], A * B, T)
-
-    # Allocation-free, including a scattered destination and a dense one
-    # with a partial row block. Julia 1.10 does not keep the tuple
-    # accumulator in registers.
-    m = max(1, MR - 1)
-    if !(k isa ScalarKernel)
-        skip = VERSION < v"1.11"
-        ab = (T(2), T(0.5))
-        scat = DestinationTile(zeros(T, MR * NR), 0, ScatterAxis(collect(0:(MR - 1)), MR), AffineAxis(0, MR, NR))
-        part = DestinationTile(mk_dense(zeros(T, m * NR)), 0, AffineAxis(0, 1, m), AffineAxis(0, m, NR))
-        mk_run_acc(k, pa, pb, kc)
-        @test (@allocated mk_run_acc(k, pa, pb, kc)) == 0 skip = skip
-        for dst in (scat, part)
-            mk_run_exec(k, dst, pa, pb, kc, ab...)
-            @test (@allocated mk_run_exec(k, dst, pa, pb, kc, ab...)) == 0 skip = skip
-        end
-    end
-    return nothing
-end
-
-function mk_contract_full(k)
-    T = scalartype(k)
-    TA, TB = mk_optypes(k)
-    R = real(T)
-    MR, NR = mr(k), nr(k)
-    rng = MersenneTwister(100MR + NR + 1)
-    m = max(1, MR - 1)
-    kc = 5
-    A = rand(rng, TA, MR, kc)
-    B = rand(rng, TB, kc, NR)
-    pa, pb = mk_pack(k, A, B)
-    acc = mk_run_acc(k, pa, pb, kc)
-
-    acc0 = zero_accumulator(k)
-    @test all(iszero(mk_read(k, acc0, i, j)) for i in 0:(MR - 1), j in 0:(NR - 1))
-    @test accumulate(k, acc0, R[], R[], 0) === acc0
-    @test_throws ArgumentError accumulate(k, acc0, R[], R[], -1)
-    # Splitting kc across calls composes.
-    la, lb = length(pa) ÷ kc, length(pb) ÷ kc
-    accs = zero_accumulator(k)
-    for p in 0:(kc - 1)
-        accs = accumulate(k, accs, view(pa, (p * la + 1):((p + 1) * la)), view(pb, (p * lb + 1):((p + 1) * lb)), 1)
-    end
-    @test all(mk_read(k, accs, i, j) ≈ mk_read(k, acc, i, j) for i in 0:(MR - 1), j in 0:(NR - 1))
-
-    # alpha*A*B + beta*C on the vector-store and scalar-store paths, every
-    # alpha/beta branch, partial tiles; old C is NaN whenever beta == 0.
-    pad, sentinel = 2, T(-77)
-    extents = unique(((MR, NR), (1, 1), (m, NR), (MR, max(1, NR - 1)), (MR ÷ 2 + 1, min(2, NR)), (0, 0)))
-    for kc in (0, 1, 5), (alpha, beta) in mk_alphabeta(T), (m, n) in extents, scattered in (false, true)
-        A = rand(rng, TA, MR, kc)
-        B = rand(rng, TB, kc, NR)
-        pa, pb = kc == 0 ? (R[], R[]) : mk_pack(k, A, B)
-        Cold = iszero(beta) ? fill(mk_nan(T), m * n) : rand(rng, T, m * n)
-        storage = [fill(sentinel, pad); Cold; fill(sentinel, pad)]
-        scattered || (storage = mk_dense(storage))
-        rows = scattered ? ScatterAxis(collect(0:(m - 1)), m) : AffineAxis(0, 1, m)
-        execute_tile!(k, DestinationTile(storage, pad, rows, AffineAxis(0, m, n)), pa, pb, kc, alpha, beta)
-        AB = (A * B)[1:m, 1:n]
-        want = iszero(beta) ? alpha .* vec(AB) : alpha .* vec(AB) .+ beta .* Cold
-        @test mk_close(storage[(pad + 1):(pad + m * n)], want, T)
-        @test all(==(sentinel), storage[[1:pad; (pad + m * n + 1):(2pad + m * n)]])
-    end
-
-    # Nonfinite padding lanes (rows >= m, columns >= n) never reach C.
-    m, n = max(1, MR - 1), max(1, NR - 1)
-    A = rand(rng, TA, MR, 2)
-    B = rand(rng, TB, 2, NR)
-    A[(m + 1):end, :] .= mk_inf(TA)
-    B[:, (n + 1):end] .= mk_inf(TB)
-    pa, pb = mk_pack(k, A, B)
-    acc = mk_run_acc(k, pa, pb, 2)
-    @test any(!isfinite(mk_read(k, acc, i, j)) for i in 0:(MR - 1), j in 0:(NR - 1))
-    for (storage, rows) in ((mk_dense(fill(mk_nan(T), m * n)), AffineAxis(0, 1, m)), (fill(mk_nan(T), m * n), ScatterAxis(collect(0:(m - 1)), m)))
-        execute_tile!(k, DestinationTile(storage, 0, rows, AffineAxis(0, m, n)), pa, pb, 2, one(T), zero(T))
-        @test mk_close(storage, vec(A[1:m, :] * B[:, 1:n]), T)
-    end
-
-    # alpha == 0 never reads acc or the panels; kc == 0 never reads the panels.
-    fulltile(s) = DestinationTile(s, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, NR))
-    storage = mk_dense(fill(T(2), MR * NR))
-    store_tile!(fulltile(storage), mk_fill_acc(k, R(NaN)), zero(T), T(3), k)
-    @test all(==(T(6)), storage)
-    execute_tile!(k, fulltile(storage), R[], R[], 5, zero(T), zero(T))
-    @test all(iszero, storage)
-    empty = DestinationTile(T[], 0, AffineAxis(0, 1, 0), AffineAxis(0, 0, 0))
-    @test store_tile!(empty, acc, one(T), zero(T), k) === empty
-    @test execute_tile!(k, empty, pa, pb, 2, one(T), one(T)) === empty
-
-    # Rejected inputs.
-    st = zeros(T, (MR + 1) * (NR + 1))
-    @test_throws ArgumentError execute_tile!(k, DestinationTile(st, 0, AffineAxis(0, 1, MR + 1), AffineAxis(0, MR + 1, NR)), pa, pb, 2, one(T), zero(T))
-    @test_throws ArgumentError execute_tile!(k, DestinationTile(st, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, NR + 1)), pa, pb, 2, one(T), zero(T))
-    @test_throws ArgumentError execute_tile!(k, fulltile(st), pa, pb, -1, one(T), zero(T))
-    @test_throws DimensionMismatch execute_tile!(k, fulltile(st), pa[1:(end - 1)], pb, 2, one(T), zero(T))
-    @test_throws DimensionMismatch execute_tile!(k, fulltile(st), pa, pb[1:(end - 1)], 2, one(T), zero(T))
-
-    # Destination layouts: each lands on exactly its own addresses.
-    A = rand(rng, TA, MR, kc)
-    B = rand(rng, TB, kc, NR)
-    pa, pb = mk_pack(k, A, B)
-    AB = A * B
-    ld = m + 3
-    perm = randperm(rng, ld)[1:m] .- 1
-    cperm = ld .* (randperm(rng, n) .- 1)
-    nanbuf(len) = fill(mk_nan(T), len)
-    layouts = (
-        # (storage, base, rows, cols, zero-based address of (i, j))
-        (nanbuf(ld * n), 0, ScatterAxis(perm, m), AffineAxis(0, ld, n), (i, j) -> perm[i + 1] + ld * j),
-        (mk_dense(nanbuf(ld * n)), (m - 1) + ld * (n - 1), AffineAxis(0, -1, m), AffineAxis(0, -ld, n), (i, j) -> (m - 1 - i) + ld * (n - 1 - j)),
-        (mk_dense(nanbuf(2ld * n)), 0, AffineAxis(0, 2, m), AffineAxis(0, 2ld, n), (i, j) -> 2i + 2ld * j),
-        (mk_dense(nanbuf(ld * n)), 0, AffineAxis(0, 1, m), AffineAxis(0, ld, n), (i, j) -> i + ld * j),
-        (mk_dense(nanbuf(ld * n)), 0, AffineAxis(0, 1, m), ScatterAxis(cperm, n), (i, j) -> i + cperm[j + 1]),
-        (view(nanbuf(ld * n + 4), 3:(ld * n + 2)), 0, AffineAxis(0, 1, m), AffineAxis(0, ld, n), (i, j) -> i + ld * j),
-    )
-    for (storage, base, rows, cols, addr) in layouts
-        execute_tile!(k, DestinationTile(storage, base, rows, cols), pa, pb, kc, one(T), zero(T))
-        got = [storage[addr(i, j) + 1] for i in 0:(m - 1), j in 0:(n - 1)]
-        @test mk_close(got, AB[1:m, 1:n], T)
-        @test count(!isnan, storage) == m * n
-    end
-    return nothing
-end
-
-# A named-kernel plan end to end: several K panels, tiles straddling both ways,
-# conjugation.
-function mk_e2e(T, kernel)
-    rng = MersenneTwister(4242)
-    M, N, K = 37, 23, 41
-    A = rand(rng, T, M, K)
-    B = rand(rng, T, K, N)
-    Cinit = rand(rng, T, M, N)
-    alpha, beta = T <: Complex ? (T(1.5, -0.25), T(-0.75, 0.5)) : (T(1.5), T(-0.75))
-    conjs = T <: Complex ? ((false, false), (true, false), (false, true)) : ((false, false),)
-    return @testset "end to end $(kernel === nothing ? "default kernel" : nameof(typeof(kernel))) $T" begin
-        for (cA, cB) in conjs
-            C = copy(Cinit)
-            plan = plan_contract(
-                StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3);
-                kernel, kc = 16, conjA = cA, conjB = cB
-            )
-            execute!(plan, alpha, beta)
-            want = alpha .* ((cA ? conj.(A) : A) * (cB ? conj.(B) : B)) .+ beta .* Cinit
-            @test maximum(abs, C .- want) <= 64 * mk_tol(T) * maximum(abs, want)
-        end
-    end
-end
+include("helpers.jl")
 
 @testset "ScalarKernel" begin
     for (MR, NR, T) in ((4, 3, Float64), (2, 2, Float32))
diff --git a/test/microkernels/test_simd_kernel.jl b/test/microkernels/test_simd_kernel.jl
index 7feecb6..f32341b 100644
--- a/test/microkernels/test_simd_kernel.jl
+++ b/test/microkernels/test_simd_kernel.jl
@@ -1,4 +1,6 @@
-using QuasiStrided: SIMDKernel, lanewidth, _vector_store_eligible, kernel_shapes
+include("helpers.jl")
+
+using QuasiStrided: SIMDKernel, lanewidth, vector_store_eligible, RealLayout, kernel_shapes
 using StridedViews: StridedView
 
 @testset "SIMDKernel" begin
@@ -18,19 +20,19 @@ using StridedViews: StridedView
     @test_throws ArgumentError SIMDKernel(Val(6), Val(4), Float64, Val(4))
     @test_throws ArgumentError SIMDKernel(Val(6), Val(4), Float64, Val(0))
 
-    @testset "_vector_store_eligible: unit-stride rows into 1-D dense real storage" begin
+    @testset "vector_store_eligible: unit-stride rows into 1-D dense real storage" begin
         for T in (Float64, Float32)
             m, n = 8, 8
             rows, cols = AffineAxis(0, 1, m), AffineAxis(0, m, n)
             mem = parent(StridedView(zeros(T, m * n)))  # `Memory{T}` on Julia >= 1.11
-            @test _vector_store_eligible(DestinationTile(mem, 0, rows, cols), T)
-            @test _vector_store_eligible(DestinationTile(zeros(T, m * n), 0, rows, cols), T)
-            @test !_vector_store_eligible(DestinationTile(view(zeros(T, m * n + 4), 3:(m * n + 2)), 0, rows, cols), T)
-            @test !_vector_store_eligible(DestinationTile(zeros(T, m, n), 0, rows, cols), T)
-            @test !_vector_store_eligible(DestinationTile(zeros(T, 2m * n), 0, AffineAxis(0, 2, m), AffineAxis(0, 2m, n)), T)
-            @test !_vector_store_eligible(DestinationTile(mem, 0, ScatterAxis(collect(0:(m - 1)), m), cols), T)
-            @test _vector_store_eligible(DestinationTile(mem, 0, rows, cols), T === Float64 ? Float32 : Float64)
-            @test !_vector_store_eligible(DestinationTile(zeros(complex(T), m * n), 0, rows, cols), T)
+            @test vector_store_eligible(RealLayout(), Tile(mem, 0, rows, cols), T)
+            @test vector_store_eligible(RealLayout(), Tile(zeros(T, m * n), 0, rows, cols), T)
+            @test !vector_store_eligible(RealLayout(), Tile(view(zeros(T, m * n + 4), 3:(m * n + 2)), 0, rows, cols), T)
+            @test !vector_store_eligible(RealLayout(), Tile(zeros(T, m, n), 0, rows, cols), T)
+            @test !vector_store_eligible(RealLayout(), Tile(zeros(T, 2m * n), 0, AffineAxis(0, 2, m), AffineAxis(0, 2m, n)), T)
+            @test !vector_store_eligible(RealLayout(), Tile(mem, 0, view(collect(0:(m - 1)), 1:m), cols), T)
+            @test vector_store_eligible(RealLayout(), Tile(mem, 0, rows, cols), T === Float64 ? Float32 : Float64)
+            @test !vector_store_eligible(RealLayout(), Tile(zeros(complex(T), m * n), 0, rows, cols), T)
         end
     end
 
@@ -41,11 +43,11 @@ using StridedViews: StridedView
             acc = map(v -> typeof(v)(ntuple(_ -> T(2rand(rng) - 1), lanewidth(k))), zero_accumulator(k))
             cold = S.(2 .* rand(rng, m * n) .- 1)
             fast = mk_dense(cold)
-            dfast = DestinationTile(fast, 0, AffineAxis(0, 1, m), AffineAxis(0, m, n))
-            @test _vector_store_eligible(dfast, T)
+            dfast = Tile(fast, 0, AffineAxis(0, 1, m), AffineAxis(0, m, n))
+            @test vector_store_eligible(RealLayout(), dfast, T)
             store_tile!(dfast, acc, alpha, beta, k)
             scal = copy(cold)
-            store_tile!(DestinationTile(scal, 0, ScatterAxis(collect(0:(m - 1)), m), AffineAxis(0, m, n)), acc, alpha, beta, k)
+            store_tile!(Tile(scal, 0, view(collect(0:(m - 1)), 1:m), AffineAxis(0, m, n)), acc, alpha, beta, k)
             @test mk_close(fast, scal, Float32)
         end
     end
diff --git a/test/packing/helpers.jl b/test/packing/helpers.jl
new file mode 100644
index 0000000..27defe6
--- /dev/null
+++ b/test/packing/helpers.jl
@@ -0,0 +1,73 @@
+# Reference packed layouts and fixtures shared by the packing test files.
+
+include("../helpers.jl")
+
+using QuasiStrided: RealFormat, PlanarFormat, OneEFormat, InterleavedFormat, PackedPanel,
+    packed_panel, packed_length, copies_unchanged, real_contiguous_eligible
+
+# Packed layouts written from the format definitions, not from the offset
+# helpers. `g(t, p)` is the source element at lane `t`, K step `p`; lanes
+# `>= valid` are padding and stay literal `+0.0`.
+_ref_emit!(o, ::RealFormat, vr, p, t, z) = (o[vr * p + t + 1] = z)
+function _ref_emit!(o, ::PlanarFormat, vr, p, t, z)
+    o[2vr * p + t + 1] = real(z)
+    return o[2vr * p + vr + t + 1] = imag(z)
+end
+function _ref_emit!(o, ::InterleavedFormat, vr, p, t, z)
+    o[2vr * p + 2t + 1] = real(z)
+    return o[2vr * p + 2t + 2] = imag(z)
+end
+function _ref_emit!(o, ::OneEFormat, vr, p, t, z)   # [[re, -im], [im, re]]
+    b = 4vr * p
+    o[b + 2t + 1], o[b + 2t + 2] = real(z), imag(z)
+    return o[b + 2vr + 2t + 1], o[b + 2vr + 2t + 2] = -imag(z), real(z)
+end
+_ref_rpe(::RealFormat) = 1
+_ref_rpe(::Union{PlanarFormat, InterleavedFormat}) = 2
+_ref_rpe(::OneEFormat) = 4
+function ref_pack(fmt, ::Type{T}, vr, k_block_length, valid, g, f) where {T}
+    out = zeros(real(T), _ref_rpe(fmt) * vr * k_block_length)
+    for p in 0:(k_block_length - 1), t in 0:(valid - 1)
+        _ref_emit!(out, fmt, vr, p, t, convert(T, f(g(t, p))))
+    end
+    return out
+end
+
+resized(ax::AffineAxis, n) = AffineAxis(ax.base, ax.stride, n)
+resized(ax::SubArray, n) = view(parent(ax), 1:n)
+
+# A sliver source with lanes along `lane` and K steps along `step` (B's tile
+# transposed), and its direct-indexing reader.
+function pack_fixture(storage, base, lane, step)
+    return Tile(storage, base, lane, step), (t, p) -> storage[base + lane[t + 1] + step[p + 1] + 1]
+end
+
+# Packs `src` into a destination of kind `dst` (canaried unless a bare Vector)
+# and returns the packed prefix and whether the canaries survived.
+function pack_into(dst, R, len, src, spec, f)
+    buf = fill(R(-777), len + 12)
+    if dst === :vector
+        v = buf[1:len]
+        @test pack!(v, src, spec, f) === v
+        return v, true
+    end
+    GC.@preserve buf begin
+        d = packed_panel(buf, 5, len)
+        @test pack!(d, src, spec, f) === d
+    end
+    return buf[5:(4 + len)], all(==(R(-777)), buf[1:4]) && all(==(R(-777)), buf[(5 + len):end])
+end
+
+const SCATTER_LANES = [5, 30, 1, 17, 9, 44, 2, 23, 11, 38, 7, 60, 14, 51, 3, 29]
+const SCATTER_STEPS = [7, 900, 300, 1500, 60, 1210, 420]
+
+# Exactly representable in Float32, with signed and unsigned zeros sprinkled in:
+# `conj` and 1e's `-im` are sign flips.
+function complex_value(::Type{T}, i) where {T}
+    R = real(T)
+    i % 17 == 0 && return T(R(0), R(0))
+    i % 19 == 0 && return T(R(3), R(0))
+    i % 23 == 0 && return T(R(0), R(-5))
+    return T(R(10i + 1), R(-(10i + 2)))
+end
+complex_storage(::Type{T}, n) where {T} = [complex_value(T, i) for i in 1:n]
diff --git a/test/packing/test_format.jl b/test/packing/test_format.jl
new file mode 100644
index 0000000..2b3a326
--- /dev/null
+++ b/test/packing/test_format.jl
@@ -0,0 +1,39 @@
+include("../helpers.jl")
+
+using QuasiStrided: RealFormat, PlanarFormat, OneEFormat,
+    InterleavedFormat, realtype, sliver_width
+
+@testset "Descriptor" begin
+    k = Descriptor(Val(8), Val(6), Float64)
+    @test (tile_size(k)..., scalartype(k), realtype(k)) == (8, 6, Float64, Float64)
+    @test packed_a_offset(k, 4, 3) == 3 + 8 * 2
+    @test packed_b_offset(k, 6, 3) == 5 + 6 * 2
+    @test packed_a_length(k, 0) == 0
+    @test packed_a_length(k, 4) == 32
+    @test packed_b_length(k, 4) == 24
+
+    @test_throws ArgumentError Descriptor(Val(0), Val(6), Float64)
+    @test_throws ArgumentError Descriptor(Val(8), Val(-1), Float64)
+    @test_throws ArgumentError Descriptor(Val(8), Val(6), Int)
+end
+
+@testset "Descriptor: lengths count reals at a logical k_block_length ($T)" for
+    T in (ComplexF64, ComplexF32)
+
+    MR, NR = 8, 6
+    planar = Descriptor(Val(MR), Val(NR), T, PlanarFormat(), PlanarFormat())
+    onem = Descriptor(Val(MR), Val(NR), T, OneEFormat(), PlanarFormat())
+    fmas = Descriptor(Val(MR), Val(NR), T, InterleavedFormat(), PlanarFormat())
+    @test realtype(planar) === real(T)
+    @test (sliver_width(planar, 1), sliver_width(onem, 1), sliver_width(fmas, 1)) ==
+        (2MR, 4MR, 2MR)
+    @test sliver_width(planar, 2) == sliver_width(onem, 2) == sliver_width(fmas, 2) == 2NR
+    @test packed_a_length(onem, 7) == 4MR * 7
+    @test packed_b_length(planar, 7) == 2NR * 7
+    @test packed_a_offset(planar, 3, 2, 1) == 2MR + MR + 2
+
+    @test_throws ArgumentError Descriptor(Val(MR), Val(NR), T, RealFormat(), PlanarFormat())
+    @test sliver_width(Descriptor(Val(MR), Val(NR), T, RealFormat(), InterleavedFormat()))[2] == 2NR
+    @test_throws ArgumentError Descriptor(Val(MR), Val(NR), Float64, PlanarFormat(), PlanarFormat())
+    @test_throws ArgumentError Descriptor(Val(0), Val(NR), T, PlanarFormat(), PlanarFormat())
+end
diff --git a/test/packing/test_kernel_descriptor.jl b/test/packing/test_kernel_descriptor.jl
deleted file mode 100644
index ee171bb..0000000
--- a/test/packing/test_kernel_descriptor.jl
+++ /dev/null
@@ -1,36 +0,0 @@
-using QuasiStrided: ComplexKernelDescriptor, RealFormat, PlanarFormat, OneEFormat,
-    InterleavedFormat, realtype, packed_a_per_k, packed_b_per_k
-
-@testset "KernelDescriptor" begin
-    k = KernelDescriptor(Val(8), Val(6), Float64)
-    @test (mr(k), nr(k), scalartype(k), realtype(k)) == (8, 6, Float64, Float64)
-    @test packed_a_offset(k, 3, 2) == 3 + 8 * 2
-    @test packed_b_offset(k, 5, 2) == 5 + 6 * 2
-    @test packed_a_length(k, 0) == 0
-    @test packed_a_length(k, 4) == 32
-    @test packed_b_length(k, 4) == 24
-
-    @test_throws ArgumentError KernelDescriptor(Val(0), Val(6), Float64)
-    @test_throws ArgumentError KernelDescriptor(Val(8), Val(-1), Float64)
-    @test_throws ArgumentError KernelDescriptor(Val(8), Val(6), Int)
-end
-
-@testset "ComplexKernelDescriptor: lengths count reals at a logical kc ($T)" for
-    T in (ComplexF64, ComplexF32)
-
-    MR, NR = 8, 6
-    planar = ComplexKernelDescriptor(Val(MR), Val(NR), T, PlanarFormat(), PlanarFormat())
-    onem = ComplexKernelDescriptor(Val(MR), Val(NR), T, OneEFormat(), PlanarFormat())
-    fmas = ComplexKernelDescriptor(Val(MR), Val(NR), T, InterleavedFormat(), PlanarFormat())
-    @test realtype(planar) === real(T)
-    @test (packed_a_per_k(planar), packed_a_per_k(onem), packed_a_per_k(fmas)) ==
-        (2MR, 4MR, 2MR)
-    @test packed_b_per_k(planar) == packed_b_per_k(onem) == packed_b_per_k(fmas) == 2NR
-    @test packed_a_length(onem, 7) == 4MR * 7
-    @test packed_b_length(planar, 7) == 2NR * 7
-
-    @test_throws ArgumentError ComplexKernelDescriptor(Val(MR), Val(NR), T, RealFormat(), PlanarFormat())
-    @test packed_b_per_k(ComplexKernelDescriptor(Val(MR), Val(NR), T, RealFormat(), InterleavedFormat())) == 2NR
-    @test_throws ArgumentError ComplexKernelDescriptor(Val(MR), Val(NR), Float64, PlanarFormat(), PlanarFormat())
-    @test_throws ArgumentError ComplexKernelDescriptor(Val(0), Val(NR), T, PlanarFormat(), PlanarFormat())
-end
diff --git a/test/packing/test_line_packing.jl b/test/packing/test_line_packing.jl
new file mode 100644
index 0000000..e5f9140
--- /dev/null
+++ b/test/packing/test_line_packing.jl
@@ -0,0 +1,35 @@
+# Line-by-line packing (`pack_split`): the planner's decision and the split plans end to end.
+
+include("../helpers.jl")
+
+@testset "line-by-line packing: the planner splits A of intensli_7 past the cache" begin
+    plan_of(d) = plan_contract(_sp_views(Float64, SP_I7, ntuple(_ -> d, 6))...)
+    p = plan_of(16)
+    k, b = p.kernel, p.blocking
+    splits(l2bytes) = is_split(pack_split(p.mgroup, p.kgroup, 1, tile_size(k, 1), pack_formats(typeof(k))[1], 8, b.k_block, b.m_block, b.m_block, default_blocking(k).k_block; l2bytes)[2])
+    @test splits(2^20) && !splits(2^24)  # a 4 MB reuse window
+    host = splits(QuasiStrided.split_capacity(target_profile(), true))
+    @test is_split(p.mpack) == host
+    host && @test _path_of(p) isa NestPath{false, <:Any, (true, false)}
+    @test _path_of(plan_of(4)) isa NestPath{<:Any, <:Any, (false, false)}
+end
+
+@testset "line-by-line packing: contractions ($T)" for T in (Float64, Float32, ComplexF64, ComplexF32)
+    kernels = T === ComplexF64 ? (nothing, OneMKernel(Val(4), Val(4), T), FMAddSubKernel(Val(8), Val(4), T)) : (nothing,)
+    for (ind, ext, m_block) in (
+                (SP_I7, (8, 8, 8, 3, 6, 5), nothing), (SP_I7, (6, 8, 11, 5, 10, 7), 48),
+                (SP_BOTH, (20, 16, 9, 20, 8), nothing), (SP_BOTH, (13, 12, 5, 11, 12), 64),
+            ), kernel in kernels, conjB in (T <: Complex ? (false, true) : (false,)), beta in (0, 0.7)
+        T <: Complex && ind === SP_BOTH && continue  # K steps within a page: complex never splits
+        Cv, Av, iA, Bv, iB, iC = _sp_views(T, ind, ext)
+        iszero(beta) && fill!(Cv, NaN)
+        Cref = _lo_reference(iszero(beta) ? zero(Array(Cv)) : Array(Cv), Av, iA, Bv, iB, iC; conjB, alpha = 1.3, beta)
+        plan = _sp_forced_plan(Cv, Av, iA, Bv, iB, iC; conjB, m_block, kernel)
+        @test _path_of(plan) isa NestPath{false, <:Any, (true, ind === SP_BOTH)}
+        execute!(plan, 1.3, beta)
+        @test Array(Cv) ≈ Cref rtol = 100 * eps(real(T))
+    end
+    plan = _sp_forced_plan(_sp_views(T, T <: Complex ? SP_I7 : SP_BOTH, (20, 16, 9, 20, 8, 5))...)
+    execute!(plan, 1, 0)
+    @test (@allocated execute!(plan, 1, 0)) == 0 skip = (VERSION < v"1.11")
+end
diff --git a/test/packing/test_pack_complex.jl b/test/packing/test_pack_complex.jl
index 2b3bf0a..2916b87 100644
--- a/test/packing/test_pack_complex.jl
+++ b/test/packing/test_pack_complex.jl
@@ -1,76 +1,69 @@
-# Complex packing against test_pack_real.jl's reference layouts. `transform`
+# Complex packing against the reference layouts. `transform`
 # must apply to the complex element before it is split (per real half, `conj`
 # would be a silent no-op). Packing is exact, so comparisons are bitwise
 # `isequal`, which also separates `+0.0` from `-0.0`.
 
-# Exactly representable in Float32, with signed and unsigned zeros sprinkled in:
-# `conj` and 1e's `-im` are sign flips.
-function complex_value(::Type{T}, i) where {T}
-    R = real(T)
-    i % 17 == 0 && return T(R(0), R(0))
-    i % 19 == 0 && return T(R(3), R(0))
-    i % 23 == 0 && return T(R(0), R(-5))
-    return T(R(10i + 1), R(-(10i + 2)))
-end
-complex_storage(::Type{T}, n) where {T} = [complex_value(T, i) for i in 1:n]
+include("helpers.jl")
 
 const COMPLEX_FORMATS = (
     (PlanarFormat(), PlanarFormat()), (OneEFormat(), PlanarFormat()),
     (InterleavedFormat(), PlanarFormat()), (OneEFormat(), OneEFormat()),
 )
 
-@testset "complex pack_a!/pack_b! ($T, $(typeof(fa)), $(typeof(fb))) vs reference" for
+@testset "complex pack! ($T, $(typeof(fa)), $(typeof(fb))) vs reference" for
     T in (ComplexF64, ComplexF32), (fa, fb) in COMPLEX_FORMATS
 
     MR, NR = 4, 3
-    kernel = ComplexKernelDescriptor(Val(MR), Val(NR), T, fa, fb)
+    kernel = Descriptor(Val(MR), Val(NR), T, fa, fb)
     R = real(T)
     storage = complex_storage(T, 4000)
     calls = Ref(0)
     counting = z -> (calls[] += 1; 2z + one(T))   # nonzero at zero
-    for (side, pack!, PD, fmt) in ((:a, pack_a!, MR, fa), (:b, pack_b!, NR, fb)), kc in (1, 5)
+    for (i, PD, fmt) in ((1, MR, fa), (2, NR, fb)), k_block_length in (1, 5)
         fixtures = (
-            (AffineAxis(0, 1, PD), AffineAxis(0, 97, kc)),
-            (AffineAxis(40, -1, PD), AffineAxis(3000, -97, kc)),
-            (ScatterAxis(SCATTER_LANES, PD), ScatterAxis(SCATTER_STEPS, kc)),
+            (AffineAxis(0, 1, PD), AffineAxis(0, 97, k_block_length)),
+            (AffineAxis(40, -1, PD), AffineAxis(3000, -97, k_block_length)),
+            (view(SCATTER_LANES, 1:PD), view(SCATTER_STEPS, 1:k_block_length)),
         )
-        len = _ref_rpe(fmt) * PD * kc
+        len = _ref_rpe(fmt) * PD * k_block_length
         for (lane, step) in fixtures, valid in (PD, 1, 0)
-            src, g = pack_fixture(side, storage, 500, resized(lane, valid), step)
+            src, g = pack_fixture(storage, 500, resized(lane, valid), step)
             for f in (identity, conj)
-                got, _ = pack_into(pack!, :vector, R, len, src, kernel, f)
-                @test all(isequal.(got, ref_pack(fmt, T, PD, kc, valid, g, f)))
+                got, _ = pack_into(:vector, R, len, src, sliver_spec(kernel, i), f)
+                @test all(isequal.(got, ref_pack(fmt, T, PD, k_block_length, valid, g, f)))
             end
             calls[] = 0
-            got, canaries = pack_into(pack!, :view, R, len, src, kernel, counting)
-            @test all(isequal.(got, ref_pack(fmt, T, PD, kc, valid, g, z -> 2z + one(T))))
-            @test calls[] == valid * kc   # once per element, not per real half
+            got, canaries = pack_into(:panel, R, len, src, sliver_spec(kernel, i), counting)
+            @test all(isequal.(got, ref_pack(fmt, T, PD, k_block_length, valid, g, z -> 2z + one(T))))
+            @test calls[] == valid * k_block_length   # once per element, not per real half
             @test canaries
         end
     end
 end
 
-@testset "complex packing: validation before any write, kc == 0 is a no-op" begin
-    kernel = ComplexKernelDescriptor(Val(4), Val(3), ComplexF64, PlanarFormat(), PlanarFormat())
+@testset "complex packing: validation before any write, k_block_length == 0 is a no-op" begin
+    kernel = Descriptor(Val(4), Val(3), ComplexF64, PlanarFormat(), PlanarFormat())
     storage = fill(ComplexF64(3, 4), 100)
-    src = SourceTile(storage, 0, AffineAxis(0, 1, 4), AffineAxis(0, 8, 2))
+    src = Tile(storage, 0, AffineAxis(0, 1, 3), AffineAxis(0, 8, 2))
+    a, b = sliver_spec(kernel, 1), sliver_spec(kernel, 2)
     # The buffer holds realtype(kernel), not scalartype(kernel).
-    @test_throws ArgumentError pack_a!(zeros(ComplexF64, 1000), src, kernel, identity)
-    @test_throws ArgumentError pack_b!(zeros(ComplexF64, 1000), src, kernel, identity)
-    @test_throws ArgumentError pack_a!(zeros(Float32, 1000), src, kernel, identity)
+    @test_throws ArgumentError pack!(zeros(ComplexF64, 1000), src, a, identity)
+    @test_throws ArgumentError pack!(zeros(ComplexF64, 1000), src, b, identity)
+    @test_throws ArgumentError pack!(zeros(Float32, 1000), src, a, identity)
     canary = fill(-42.0, 1000)
-    @test_throws ArgumentError pack_a!(canary, SourceTile(storage, 0, AffineAxis(0, 1, 5), src.cols), kernel, identity)
-    @test_throws ArgumentError pack_b!(canary, SourceTile(storage, 0, src.cols, AffineAxis(0, 1, 4)), kernel, identity)
+    @test_throws ArgumentError pack!(canary, Tile(storage, 0, AffineAxis(0, 1, 5), src.cols), a, identity)
+    @test_throws ArgumentError pack!(canary, Tile(storage, 0, AffineAxis(0, 1, 4), src.cols), b, identity)
     # A buffer sized as if it held complex elements is half as long as needed.
-    @test_throws DimensionMismatch pack_a!(zeros(Float64, 4 * 2), src, kernel, identity)
-    @test_throws BoundsError pack_a!(canary, SourceTile(storage, 90, src.rows, src.cols), kernel, identity)
+    @test_throws DimensionMismatch pack!(zeros(Float64, 4 * 2), src, a, identity)
+    @test_throws BoundsError pack!(canary, Tile(storage, 90, src.rows, src.cols), a, identity)
     @test all(==(-42.0), canary)
 
     read = Ref(false)
     spy = z -> (read[] = true; z)
     packed = fill(-42.0, 8)
-    @test pack_a!(packed, SourceTile(storage, 0, AffineAxis(0, 1, 3), AffineAxis(0, 8, 0)), kernel, spy) === packed
-    @test pack_b!(packed, SourceTile(storage, 0, AffineAxis(0, 1, 0), AffineAxis(0, 8, 3)), kernel, spy) === packed
+    for spec in (a, b)
+        @test pack!(packed, Tile(storage, 0, AffineAxis(0, 1, 3), AffineAxis(0, 8, 0)), spec, spy) === packed
+    end
     @test all(==(-42.0), packed)
     @test !read[]
 end
@@ -79,40 +72,28 @@ end
     T in (ComplexF64, ComplexF32), (fa, fb) in COMPLEX_FORMATS[1:2]
 
     function run(::Type{T}, fa, fb) where {T}
-        MR, NR, kc = 8, 6, 4
-        kernel = ComplexKernelDescriptor(Val(MR), Val(NR), T, fa, fb)
-        R = real(T)
+        MR, NR, k_block_length = 8, 6, 4
+        kernel = Descriptor(Val(MR), Val(NR), T, fa, fb)
         storage = rand(T, 4000)
-        bufa = zeros(R, packed_a_length(kernel, kc))
-        bufb = zeros(R, packed_b_length(kernel, kc))
-        ro, co, ro_b = collect(0:(MR - 1)) .* 3, [0, 100, 250, 400], collect(0:(NR - 1)) .* 5
+        steps, lanes = [0, 100, 250, 400], collect(0:(max(MR, NR) - 1)) .* 3
         fast = Int[]
         slow = Int[]
-        GC.@preserve bufa bufb begin
-            pa = packed_panel(bufa, 1, length(bufa))
-            pb = packed_panel(bufb, 1, length(bufb))
-            full_a = SourceTile(storage, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, kc))
-            full_b = SourceTile(storage, 0, AffineAxis(0, 1, kc), AffineAxis(0, kc, NR))
-            for f in (identity, conj)   # the contiguous fast path, where the ISA has it
-                push!(fast, steady_pack_allocs(pack_a!, pa, full_a, kernel, f))
-                push!(fast, steady_pack_allocs(pack_b!, pb, full_b, kernel, f))
-            end
-            srcs_a = (
-                full_a, SourceTile(storage, 0, ScatterAxis(ro, MR), ScatterAxis(co, kc)),
-                SourceTile(storage, 0, AffineAxis(0, 1, MR - 1), AffineAxis(0, MR, kc)),
-                SourceTile(storage, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, 0)),
-            )
-            srcs_b = (
-                full_b, SourceTile(storage, 0, ScatterAxis(co, kc), ScatterAxis(ro_b, NR)),
-                SourceTile(storage, 0, AffineAxis(0, 1, kc), AffineAxis(0, kc, NR - 1)),
+        for (i, L) in ((1, MR), (2, NR))
+            spec = sliver_spec(kernel, i)
+            buf = zeros(real(T), packed_length(spec, k_block_length))
+            full = Tile(storage, 0, AffineAxis(0, 1, L), AffineAxis(0, L, k_block_length))
+            srcs = (
+                full, Tile(storage, 0, view(lanes, 1:L), view(steps, 1:k_block_length)),
+                Tile(storage, 0, AffineAxis(0, 1, L - 1), AffineAxis(0, L, k_block_length)),
+                Tile(storage, 0, AffineAxis(0, 1, L), AffineAxis(0, L, 0)),
             )
-            for s in srcs_a, f in (identity, conj)
-                push!(slow, steady_pack_allocs(pack_a!, bufa, s, kernel, f))
+            GC.@preserve buf for f in (identity, conj)   # the contiguous fast path, where the ISA has it
+                push!(fast, steady_pack_allocs(packed_panel(buf, 1, length(buf)), full, spec, f))
             end
-            for s in srcs_b, f in (identity, conj)
-                push!(slow, steady_pack_allocs(pack_b!, bufb, s, kernel, f))
+            for s in srcs, f in (identity, conj)
+                push!(slow, steady_pack_allocs(buf, s, spec, f))
             end
-            push!(slow, steady_pack_allocs(pack_a!, bufa, full_a, kernel, z -> 2z + oneunit(z)))
+            push!(slow, steady_pack_allocs(buf, full, spec, z -> 2z + oneunit(z)))
         end
         return fast, slow
     end
diff --git a/test/packing/test_pack_complex_contiguous.jl b/test/packing/test_pack_complex_contiguous.jl
deleted file mode 100644
index c6b2575..0000000
--- a/test/packing/test_pack_complex_contiguous.jl
+++ /dev/null
@@ -1,114 +0,0 @@
-# The vectorized complex packing fast path (`_pack_complex_contiguous!`),
-# checked bitwise against test_pack_real.jl's reference layouts. Gate
-# expectations derive from the live profile, so test/forced_isa_runner.jl
-# checks the same outputs with the fast path off.
-
-using QuasiStrided: target_profile, unknown_target, TargetProfile, CacheLevel,
-    kernel_shapes, PlanarMethod, OneMMethod, FMAddSubMethod
-
-const QS = QuasiStrided
-const FASTPATH_ON = QS._complex_fastpath_isa_eligible()
-
-# The extremes of each method's menu plus extents that are not multiples of any
-# lane width (interleaved shares 1e's shuffle); B is planar under every method.
-_menu_extremes(T, method, i) = extrema(s[i] for s in kernel_shapes(T, method))
-const FAST_A_CASES = [
-    (T, fa, MR) for T in (ComplexF64, ComplexF32)
-        for (fa, method, extra) in (
-            (PlanarFormat(), PlanarMethod(), (1, 7)), (OneEFormat(), OneMMethod(), (1, 7)),
-            (InterleavedFormat(), FMAddSubMethod(), ()),
-        )
-        for MR in unique((_menu_extremes(T, method, 1)..., extra...))
-]
-const FAST_B_NRS = (1, 3, 7, 8)
-
-# Packs into a `PackedPanel` (the only destination the gate admits).
-# `S` is the storage eltype; a mixed one holds values `T` must round.
-function check_panel(side, kernel, T, PD, fmt, lane, step, f; S = T)
-    storage = S === T ? complex_storage(T, 40000) : S.(complex_storage(ComplexF64, 40000) ./ 3)
-    src, g = pack_fixture(side, storage, 17, lane, step)
-    pack! = side === :a ? pack_a! : pack_b!
-    len = _ref_rpe(fmt) * PD * axis_length(step)
-    got, canaries = pack_into(pack!, :panel, real(T), len, src, kernel, f)
-    @test canaries
-    @test all(isequal.(got, ref_pack(fmt, T, PD, axis_length(step), axis_length(lane), g, f)))
-    return storage, src
-end
-
-@testset "complex pack fast path: A panel, $T / $(typeof(fa)) / MR=$MR" for (T, fa, MR) in FAST_A_CASES
-    kernel = ComplexKernelDescriptor(Val(MR), Val(3), T, fa, PlanarFormat())
-    for f in (identity, conj), S in (T, T === ComplexF64 ? ComplexF32 : ComplexF64)
-        storage, src = check_panel(:a, kernel, T, MR, fa, AffineAxis(0, 1, MR), AffineAxis(0, 997, 5), f; S)
-        pp = packed_panel(zeros(real(T), 1), 1, 1)
-        @test QS._pack_complex_contiguous_eligible(pp, storage, src.rows, f, fa, MR, Val(MR), T) ==
-            FASTPATH_ON
-    end
-end
-
-@testset "complex pack fast path: B panel, $T / NR=$NR" for T in (ComplexF64, ComplexF32), NR in FAST_B_NRS
-    kernel = ComplexKernelDescriptor(Val(4), Val(NR), T, PlanarFormat(), PlanarFormat())
-    for f in (identity, conj), S in (T, T === ComplexF64 ? ComplexF32 : ComplexF64)
-        storage, src = check_panel(:b, kernel, T, NR, PlanarFormat(), AffineAxis(0, 1, NR), AffineAxis(0, 997, 5), f; S)
-        pp = packed_panel(zeros(real(T), 1), 1, 1)
-        @test QS._pack_complex_contiguous_eligible(pp, storage, src.cols, f, PlanarFormat(), NR, Val(NR), T) ==
-            FASTPATH_ON
-    end
-end
-
-@testset "complex pack fast path: scattered K steps, 1e B, ineligible shapes ($T)" for T in (ComplexF64, ComplexF32)
-    MR, NR, kc = 8, 6, 6
-    koffs = [((p * 5) % 7) * 1013 + 3p for p in 0:(kc - 1)]
-    for fa in (PlanarFormat(), OneEFormat(), InterleavedFormat()), f in (identity, conj)
-        kernel = ComplexKernelDescriptor(Val(MR), Val(NR), T, fa, OneEFormat())
-        # The lane axis must be unit-stride; the step axis may scatter.
-        check_panel(:a, kernel, T, MR, fa, AffineAxis(0, 1, MR), ScatterAxis(koffs, kc), f)
-        check_panel(:b, kernel, T, NR, OneEFormat(), AffineAxis(0, 1, NR), AffineAxis(0, 997, kc), f)
-        # Ineligible shapes fall back to the scalar loop, into the same panel.
-        for lane in (AffineAxis(20, -1, MR), AffineAxis(0, 3, MR), AffineAxis(0, 1, MR - 3))
-            check_panel(:a, kernel, T, MR, fa, lane, AffineAxis(3000, -97, kc), f)
-        end
-    end
-end
-
-@testset "complex pack fast path: eligibility gate, one violation at a time" begin
-    T = ComplexF64
-    MR = 8
-    storage = complex_storage(T, 4000)
-    buf = zeros(Float64, 64)
-    offs = collect(0:(MR - 1))
-    GC.@preserve buf offs begin
-        pk = packed_panel(buf, 1, length(buf))
-        elig(;
-            packed = pk, store = storage, ax = AffineAxis(0, 1, MR), tr = identity,
-            fmt = PlanarFormat(), valid = MR,
-        ) = QS._pack_complex_contiguous_eligible(packed, store, ax, tr, fmt, valid, Val(MR), T)
-
-        @test elig() == FASTPATH_ON
-        @test elig(tr = conj) == FASTPATH_ON
-        @test elig(fmt = OneEFormat()) == FASTPATH_ON
-        @test elig(fmt = InterleavedFormat()) == FASTPATH_ON
-        @test !elig(packed = buf)                                      # not a PackedPanel
-        @test !elig(packed = packed_panel(Float32[0.0f0], 1, 1))      # wrong real type
-        @test !elig(store = view(storage, 1:100))                      # not a DenseVector
-        @test !elig(store = collect(reshape(storage, 40, 100)))        # rank 2
-        @test elig(store = ComplexF32.(storage)) == FASTPATH_ON         # converted lanes
-        @test !elig(store = real.(storage))                            # real storage
-        @test !elig(ax = AffineAxis(0, 2, MR))
-        @test !elig(ax = AffineAxis(0, -1, MR))
-        @test !elig(ax = ScatterAxis(offs, MR))
-        @test !elig(ax = PtrScatterAxis(pointer(offs), MR))
-        @test !elig(valid = MR - 1)                                    # padding lanes
-        @test !elig(tr = z -> 2z)
-        @test !elig(fmt = RealFormat())
-    end
-end
-
-@testset "complex pack fast path: ISA gate is a register-width question" begin
-    profile(key, vb, nreg) = TargetProfile(key, Sys.ARCH, "t", vb, nreg, CacheLevel(), CacheLevel(), CacheLevel())
-    @test QS._complex_fastpath_isa_eligible(profile(:avx512, 64, 32))
-    for (key, vb, nreg) in ((:avx2, 32, 16), (:neon, 16, 32), (:unknown, 0, 0))
-        @test !QS._complex_fastpath_isa_eligible(profile(key, vb, nreg))
-    end
-    @test !QS._complex_fastpath_isa_eligible(unknown_target())
-    @test FASTPATH_ON == (target_profile().vector_bytes == QS._isa_vector_bytes(Val(:avx512)))
-end
diff --git a/test/packing/test_pack_contiguous.jl b/test/packing/test_pack_contiguous.jl
new file mode 100644
index 0000000..f89d7c2
--- /dev/null
+++ b/test/packing/test_pack_contiguous.jl
@@ -0,0 +1,134 @@
+# The contiguous packing fast paths: the real one, and the vectorized complex
+# one (`pack_complex_contiguous!`) checked bitwise against the reference layouts. Gate
+# expectations derive from the live profile, so test/forced_isa_runner.jl
+# checks the same outputs with the fast path off.
+
+include("helpers.jl")
+
+using QuasiStrided: target_profile, unknown_target, TargetProfile, CacheLevel,
+    kernel_shapes, PlanarKernel, OneMKernel, FMAddSubKernel, SliverSpec, complex_contiguous_eligible,
+    complex_fastpath_isa_eligible
+
+const FASTPATH_ON = complex_fastpath_isa_eligible()
+
+# The extremes of each kernel's menu plus extents that are not multiples of any
+# lane width (interleaved shares 1e's shuffle); B is planar under every kernel.
+_menu_extremes(T, K, i) = extrema(s[i] for s in kernel_shapes(T, K))
+# Every 1m menu MR: no other test compiles the 1e A packing.
+_menu_rows(T, K) = K === OneMKernel ? Tuple(s[1] for s in kernel_shapes(T, K)) : _menu_extremes(T, K, 1)
+const FAST_A_CASES = [
+    (T, fa, MR) for T in (ComplexF64, ComplexF32)
+        for (fa, K, extra) in (
+            (PlanarFormat(), PlanarKernel, (1, 7)), (OneEFormat(), OneMKernel, (1, 7)),
+            (InterleavedFormat(), FMAddSubKernel, ()),
+        )
+        for MR in unique((_menu_rows(T, K)..., extra...))
+]
+const FAST_B_NRS = (1, 3, 7, 8)
+
+# Packs into a `PackedPanel` (the only destination the gate admits).
+# `S` is the storage eltype; a mixed one holds values `T` must round.
+function check_panel(spec, T, PD, fmt, lane, step, f; S = T)
+    storage = S === T ? complex_storage(T, 40000) : S.(complex_storage(ComplexF64, 40000) ./ 3)
+    src, g = pack_fixture(storage, 17, lane, step)
+    len = _ref_rpe(fmt) * PD * length(step)
+    got, canaries = pack_into(:panel, real(T), len, src, spec, f)
+    @test canaries
+    @test all(isequal.(got, ref_pack(fmt, T, PD, length(step), length(lane), g, f)))
+    return storage, src
+end
+
+@testset "complex pack fast path: A panel, $T / $(typeof(fa)) / MR=$MR" for (T, fa, MR) in FAST_A_CASES
+    kernel = Descriptor(Val(MR), Val(3), T, fa, PlanarFormat())
+    for f in (identity, conj), S in (T, T === ComplexF64 ? ComplexF32 : ComplexF64)
+        storage, src = check_panel(sliver_spec(kernel, 1), T, MR, fa, AffineAxis(0, 1, MR), AffineAxis(0, 997, 5), f; S)
+        @test complex_contiguous_eligible(src, sliver_spec(kernel, 1), f, MR) == FASTPATH_ON
+    end
+end
+
+@testset "complex pack fast path: B panel, $T / NR=$NR" for T in (ComplexF64, ComplexF32), NR in FAST_B_NRS
+    kernel = Descriptor(Val(4), Val(NR), T, PlanarFormat(), PlanarFormat())
+    for f in (identity, conj), S in (T, T === ComplexF64 ? ComplexF32 : ComplexF64)
+        storage, src = check_panel(sliver_spec(kernel, 2), T, NR, PlanarFormat(), AffineAxis(0, 1, NR), AffineAxis(0, 997, 5), f; S)
+        @test complex_contiguous_eligible(src, sliver_spec(kernel, 2), f, NR) == FASTPATH_ON
+    end
+end
+
+@testset "complex pack fast path: scattered K steps, 1e B, ineligible shapes ($T)" for T in (ComplexF64, ComplexF32)
+    MR, NR, k_block_length = 8, 6, 6
+    koffs = [((p * 5) % 7) * 1013 + 3p for p in 0:(k_block_length - 1)]
+    for fa in (PlanarFormat(), OneEFormat(), InterleavedFormat()), f in (identity, conj)
+        kernel = Descriptor(Val(MR), Val(NR), T, fa, OneEFormat())
+        # The lane axis must be unit-stride; the step axis may scatter.
+        check_panel(sliver_spec(kernel, 1), T, MR, fa, AffineAxis(0, 1, MR), view(koffs, 1:k_block_length), f)
+        check_panel(sliver_spec(kernel, 2), T, NR, OneEFormat(), AffineAxis(0, 1, NR), AffineAxis(0, 997, k_block_length), f)
+        # Ineligible shapes fall back to the scalar loop, into the same panel.
+        for lane in (AffineAxis(20, -1, MR), AffineAxis(0, 3, MR), AffineAxis(0, 1, MR - 3))
+            check_panel(sliver_spec(kernel, 1), T, MR, fa, lane, AffineAxis(3000, -97, k_block_length), f)
+        end
+    end
+end
+
+@testset "complex pack fast path: eligibility gate, one violation at a time" begin
+    T = ComplexF64
+    MR = 8
+    storage = complex_storage(T, 4000)
+    offs = collect(0:(MR - 1))
+    elig(;
+        store = storage, ax = AffineAxis(0, 1, MR), tr = identity, fmt = PlanarFormat(), valid = MR,
+    ) = complex_contiguous_eligible(Tile(store, 0, ax, AffineAxis(0, MR, 2)), SliverSpec{1, MR, typeof(fmt), T}(), tr, valid)
+
+    @test elig() == FASTPATH_ON
+    @test elig(tr = conj) == FASTPATH_ON
+    @test elig(fmt = OneEFormat()) == FASTPATH_ON
+    @test elig(fmt = InterleavedFormat()) == FASTPATH_ON
+    @test !elig(store = view(storage, 1:100))                      # not a DenseVector
+    @test !elig(store = collect(reshape(storage, 40, 100)))        # rank 2
+    @test elig(store = ComplexF32.(storage)) == FASTPATH_ON         # converted lanes
+    @test !elig(store = real.(storage))                            # real storage
+    @test !elig(ax = AffineAxis(0, 2, MR))
+    @test !elig(ax = AffineAxis(0, -1, MR))
+    @test !elig(ax = view(offs, 1:MR))
+    @test !elig(valid = MR - 1)                                    # padding lanes
+    @test !elig(tr = z -> 2z)
+    @test !elig(fmt = RealFormat())
+end
+
+@testset "complex pack fast path: ISA gate is a register-width question" begin
+    @test complex_fastpath_isa_eligible(synthetic(:avx512))
+    for key in (:avx2, :neon, :unknown)
+        @test !complex_fastpath_isa_eligible(synthetic(key))
+    end
+    @test FASTPATH_ON == (target_profile().isa === :avx512)
+end
+
+@testset "pack! contiguous fast path: fires exactly when eligible ($T, L=$L, side $i)" for
+    T in (Float64, Float32), (L, i) in ((4, 1), (16, 1), (6, 2))
+
+    kernel = Descriptor(Val(L), Val(L), T)
+    vals = T.(collect(1.0:2000.0))
+    mixed = (T === Float64 ? Float32 : Float64).(collect(1.0:2000.0) ./ 3)
+    storages = @static isdefined(Base, :Memory) ? (vals, copyto!(Memory{T}(undef, 2000), vals), mixed) : (vals, mixed)
+    koffs = [7, 900, 300, 1500]
+    contig = collect(0:(L - 1))
+    spec = sliver_spec(kernel, i)
+    for storage in storages
+        steps = Any[AffineAxis(0, L, 5), AffineAxis(1800, -L, 6), view(koffs, 1:4)]
+        lanes = Any[
+            (AffineAxis(0, 1, L), true), (AffineAxis(5, 1, L), true),
+            (AffineAxis(0, 2, L), false), (AffineAxis(L + 3, -1, L), false),
+            (AffineAxis(0, 1, L - 1), false), (view(contig, 1:L), false),
+        ]
+        for (lane, eligible) in lanes, step in steps, f in (identity, conj, x -> -x)
+            src, g = pack_fixture(storage, 11, lane, step)
+            k_block_length = length(step)
+            @test real_contiguous_eligible(src, spec, f, length(lane)) ==
+                (eligible && (f === identity || f === conj))
+            got, canaries = pack_into(:panel, T, L * k_block_length, src, spec, f)
+            @test got == ref_pack(RealFormat(), T, L, k_block_length, length(lane), g, f)
+            @test canaries
+        end
+    end
+    @test copies_unchanged(conj, T)
+    @test !copies_unchanged(conj, complex(T))   # conj is not the identity on complex
+end
diff --git a/test/packing/test_pack_real.jl b/test/packing/test_pack_real.jl
index 0d315a2..9fe0e62 100644
--- a/test/packing/test_pack_real.jl
+++ b/test/packing/test_pack_real.jl
@@ -1,213 +1,107 @@
-# pack_a!/pack_b! for real kernels against direct storage indexing. The
-# reference layouts and fixtures here are shared with the two complex packing
-# files included after this one.
+# pack! for real kernels against direct storage indexing.
 
-using QuasiStrided: RealFormat, PlanarFormat, OneEFormat, InterleavedFormat, PackedPanel,
-    packed_panel, PtrScatterAxis, ComplexKernelDescriptor, _copies_unchanged,
-    _pack_a_contiguous_eligible
+include("helpers.jl")
 
-# Packed layouts written from the format definitions, not from the offset
-# helpers. `g(t, p)` is the source element at lane `t`, K step `p`; lanes
-# `>= valid` are padding and stay literal `+0.0`.
-_ref_emit!(o, ::RealFormat, vr, p, t, z) = (o[vr * p + t + 1] = z)
-function _ref_emit!(o, ::PlanarFormat, vr, p, t, z)
-    o[2vr * p + t + 1] = real(z)
-    return o[2vr * p + vr + t + 1] = imag(z)
-end
-function _ref_emit!(o, ::InterleavedFormat, vr, p, t, z)
-    o[2vr * p + 2t + 1] = real(z)
-    return o[2vr * p + 2t + 2] = imag(z)
-end
-function _ref_emit!(o, ::OneEFormat, vr, p, t, z)   # [[re, -im], [im, re]]
-    b = 4vr * p
-    o[b + 2t + 1], o[b + 2t + 2] = real(z), imag(z)
-    return o[b + 2vr + 2t + 1], o[b + 2vr + 2t + 2] = -imag(z), real(z)
-end
-_ref_rpe(::RealFormat) = 1
-_ref_rpe(::Union{PlanarFormat, InterleavedFormat}) = 2
-_ref_rpe(::OneEFormat) = 4
-function ref_pack(fmt, ::Type{T}, vr, kc, valid, g, f) where {T}
-    out = zeros(real(T), _ref_rpe(fmt) * vr * kc)
-    for p in 0:(kc - 1), t in 0:(valid - 1)
-        _ref_emit!(out, fmt, vr, p, t, convert(T, f(g(t, p))))
-    end
-    return out
-end
-
-ref_offs(ax::AffineAxis) = [ax.base + t * ax.stride for t in 0:(ax.count - 1)]
-ref_offs(ax::ScatterAxis) = collect(ax.offsets[1:ax.count])
-ref_offs(ax::PtrScatterAxis) = [unsafe_load(ax.offsets, t + 1) for t in 0:(ax.count - 1)]
-resized(ax::AffineAxis, n) = AffineAxis(ax.base, ax.stride, n)
-resized(ax::ScatterAxis, n) = ScatterAxis(ax.offsets, n)
-resized(ax::PtrScatterAxis, n) = PtrScatterAxis(ax.offsets, n)
-
-# An A (`lane` = rows) or B (`lane` = cols) source over `storage`, and its
-# direct-indexing reader.
-function pack_fixture(side, storage, base, lane, step)
-    lo, so = ref_offs(lane), ref_offs(step)
-    src = side === :a ? SourceTile(storage, base, lane, step) : SourceTile(storage, base, step, lane)
-    return src, (t, p) -> storage[base + lo[t + 1] + so[p + 1] + 1]
-end
-
-# Packs `src` into a destination of kind `dst` (canaried unless a bare Vector)
-# and returns the packed prefix and whether the canaries survived.
-function pack_into(pack!, dst, R, len, src, kernel, f)
-    buf = fill(R(-777), len + 12)
-    if dst === :vector
-        v = buf[1:len]
-        @test pack!(v, src, kernel, f) === v
-        return v, true
-    end
-    GC.@preserve buf begin
-        d = dst === :view ? view(buf, 5:(4 + len)) : packed_panel(buf, 5, len)
-        @test pack!(d, src, kernel, f) === d
-    end
-    return buf[5:(4 + len)], all(==(R(-777)), buf[1:4]) && all(==(R(-777)), buf[(5 + len):end])
-end
-
-const SCATTER_LANES = [5, 30, 1, 17, 9, 44, 2, 23, 11, 38, 7, 60, 14, 51, 3, 29]
-const SCATTER_STEPS = [7, 900, 300, 1500, 60, 1210, 420]
-
-@testset "pack_a!/pack_b! ($T): every stride kind and tail width vs direct indexing" for
-    T in (Float64, Float32)
-
-    MR, NR, kc = 8, 6, 5
-    kernel = KernelDescriptor(Val(MR), Val(NR), T)
+@testset "pack! ($T): every stride kind and tail width vs direct indexing" for T in (Float64, Float32)
+    MR, NR, k_block_length = 8, 6, 5
+    kernel = Descriptor(Val(MR), Val(NR), T)
     storage = T.(collect(1.0:2000.0))
     calls = Ref(0)
     counting = x -> (calls[] += 1; 3x + 1000)   # nonzero at zero: padding must bypass it
     lanes = Any[
         AffineAxis(0, 1, 8), AffineAxis(3, 7, 8), AffineAxis(40, -1, 8), AffineAxis(20, 0, 8),
-        ScatterAxis(SCATTER_LANES, 8),
+        view(SCATTER_LANES, 1:8),
     ]
-    steps = Any[AffineAxis(0, 64, kc), AffineAxis(700, -97, kc), ScatterAxis(SCATTER_STEPS, kc)]
-    for (side, pack!, PD) in ((:a, pack_a!, MR), (:b, pack_b!, NR)),
-            lane in lanes, step in steps, valid in (PD, 1, 0), dst in (:vector, :view)
-        src, g = pack_fixture(side, storage, 11, resized(lane, valid), step)
+    steps = Any[AffineAxis(0, 64, k_block_length), AffineAxis(700, -97, k_block_length), view(SCATTER_STEPS, 1:k_block_length)]
+    for (spec, L) in ((sliver_spec(kernel, 1), MR), (sliver_spec(kernel, 2), NR)),
+            lane in lanes, step in steps, valid in (L, 1, 0), dst in (:vector, :panel)
+        src, g = pack_fixture(storage, 11, resized(lane, valid), step)
         calls[] = 0
-        got, canaries = pack_into(pack!, dst, T, PD * kc, src, kernel, counting)
-        @test got == ref_pack(RealFormat(), T, PD, kc, valid, g, x -> 3x + 1000)
-        @test calls[] == valid * kc
+        got, canaries = pack_into(dst, T, L * k_block_length, src, spec, counting)
+        @test got == ref_pack(RealFormat(), T, L, k_block_length, valid, g, x -> 3x + 1000)
+        @test calls[] == valid * k_block_length
         @test canaries
     end
     # Every tail width, at the minimal and a longer K depth.
     negate = x -> -x
-    for (side, pack!, PD) in ((:a, pack_a!, MR), (:b, pack_b!, NR)), valid in 0:PD, kc1 in (1, 5)
-        src, g = pack_fixture(side, storage, 0, AffineAxis(2, 3, valid), AffineAxis(0, 40, kc1))
-        got, _ = pack_into(pack!, :vector, T, PD * kc1, src, kernel, negate)
-        @test got == ref_pack(RealFormat(), T, PD, kc1, valid, g, negate)
+    for (spec, L) in ((sliver_spec(kernel, 1), MR), (sliver_spec(kernel, 2), NR)), valid in 0:L, kc1 in (1, 5)
+        src, g = pack_fixture(storage, 0, AffineAxis(2, 3, valid), AffineAxis(0, 40, kc1))
+        got, _ = pack_into(:vector, T, L * kc1, src, spec, negate)
+        @test got == ref_pack(RealFormat(), T, L, kc1, valid, g, negate)
     end
 end
 
-@testset "pack_a! contiguous fast path: fires exactly when eligible ($T, MR=$MR)" for
-    T in (Float64, Float32), MR in (4, 16)
-
-    kernel = KernelDescriptor(Val(MR), Val(3), T)
-    vals = T.(collect(1.0:2000.0))
-    mixed = (T === Float64 ? Float32 : Float64).(collect(1.0:2000.0) ./ 3)
-    storages = @static isdefined(Base, :Memory) ? (vals, copyto!(Memory{T}(undef, 2000), vals), mixed) : (vals, mixed)
-    koffs = [7, 900, 300, 1500]
-    contig = collect(0:(MR - 1))
-    GC.@preserve koffs contig for storage in storages
-        steps = Any[AffineAxis(0, MR, 5), AffineAxis(1800, -MR, 6), PtrScatterAxis(pointer(koffs), 4)]
-        lanes = Any[
-            (AffineAxis(0, 1, MR), true), (AffineAxis(5, 1, MR), true),
-            (AffineAxis(0, 2, MR), false), (AffineAxis(MR + 3, -1, MR), false),
-            (AffineAxis(0, 1, MR - 1), false), (PtrScatterAxis(pointer(contig), MR), false),
-        ]
-        for (lane, eligible) in lanes, step in steps, f in (identity, conj, x -> -x)
-            src, g = pack_fixture(:a, storage, 11, lane, step)
-            kc = axis_length(step)
-            pp = packed_panel(zeros(T, 1), 1, 1)
-            @test _pack_a_contiguous_eligible(pp, src, f, nrows(src), Val(MR), T) ==
-                (eligible && (f === identity || f === conj))
-            @test !_pack_a_contiguous_eligible(zeros(T, 1), src, f, nrows(src), Val(MR), T)
-            got, canaries = pack_into(pack_a!, :panel, T, MR * kc, src, kernel, f)
-            @test got == ref_pack(RealFormat(), T, MR, kc, nrows(src), g, f)
-            @test canaries
-        end
-    end
-    @test _copies_unchanged(conj, T)
-    @test !_copies_unchanged(conj, complex(T))   # conj is not the identity on complex
+@testset "pack!: B packs as A packs its transposed tile" begin
+    kernel = Descriptor(Val(6), Val(6), Float64)
+    storage = collect(1.0:2000.0)
+    tile_b = Tile(storage, 3, view(SCATTER_STEPS, 1:5), AffineAxis(0, 1, 6))   # K x N
+    got_b, _ = pack_into(:panel, Float64, 30, transpose(tile_b), sliver_spec(kernel, 2), identity)
+    got_a, _ = pack_into(:panel, Float64, 30, transpose(tile_b), sliver_spec(kernel, 1), identity)
+    @test got_b == got_a
 end
 
-@testset "pack_a!/pack_b!: kc == 0 reads and writes nothing" begin
-    kernel = KernelDescriptor(Val(4), Val(3), Float64)
+@testset "pack!: k_block_length == 0 reads and writes nothing" begin
+    kernel = Descriptor(Val(4), Val(3), Float64)
     storage = fill(3.0, 10)
     read = Ref(false)
     spy = x -> (read[] = true; x)
     packed = fill(-42.0, 8)
-    @test pack_a!(packed, SourceTile(storage, 0, AffineAxis(0, 1, 3), AffineAxis(0, 1, 0)), kernel, spy) === packed
-    @test pack_b!(packed, SourceTile(storage, 0, AffineAxis(0, 1, 0), AffineAxis(0, 1, 3)), kernel, spy) === packed
+    for i in 1:2
+        @test pack!(packed, Tile(storage, 0, AffineAxis(0, 1, 3), AffineAxis(0, 1, 0)), sliver_spec(kernel, i), spy) === packed
+    end
     @test packed == fill(-42.0, 8)
     @test !read[]
 end
 
-@testset "pack_a!/pack_b!: invalid metadata rejected before mutation" begin
-    kernel = KernelDescriptor(Val(4), Val(3), Float64)
-    kernel32 = KernelDescriptor(Val(4), Val(3), Float32)
+@testset "pack!: invalid metadata rejected before mutation" begin
+    kernel = Descriptor(Val(4), Val(3), Float64)
+    kernel32 = Descriptor(Val(4), Val(3), Float32)
     storage = fill(9.0, 20)
-    tile(m, n, base = 0) = SourceTile(storage, base, AffineAxis(0, 1, m), AffineAxis(0, 1, n))
-    for (pack!, bad, ok, short) in ((pack_a!, tile(5, 3), tile(4, 3), 11), (pack_b!, tile(3, 4), tile(3, 3), 8))
+    tile(m, n, base = 0) = Tile(storage, base, AffineAxis(0, 1, m), AffineAxis(0, 1, n))
+    for (i, bad, ok, short) in ((1, tile(5, 3), tile(4, 3), 11), (2, tile(4, 3), tile(3, 3), 8))
+        spec = sliver_spec(kernel, i)
         canary = fill(-1.0, 100)
-        @test_throws ArgumentError pack!(canary, bad, kernel, identity)     # m > MR / n > NR
-        @test_throws ArgumentError pack!(canary, ok, kernel32, identity)    # eltype mismatch
-        @test_throws DimensionMismatch pack!(fill(-1.0, short), ok, kernel, identity)
-        @test_throws BoundsError pack!(canary, tile(nrows(ok), ncols(ok), 18), kernel, identity)
+        @test_throws ArgumentError pack!(canary, bad, spec, identity)                      # lanes > L
+        @test_throws ArgumentError pack!(canary, ok, sliver_spec(kernel32, i), identity)   # eltype mismatch
+        @test_throws DimensionMismatch pack!(fill(-1.0, short), ok, spec, identity)
+        @test_throws BoundsError pack!(canary, tile(size(ok)..., 18), spec, identity)
         @test canary == fill(-1.0, 100)
     end
 end
 
-@testset "pack_a!/pack_b!: zero steady-state allocation" begin
+@testset "pack!: zero steady-state allocation" begin
     nontrivial(x) = 2x + 1
-    # Every destination kind, affine/scattered/pointer-scattered axes, tails and
-    # kc == 0; the ScalarKernel/SIMDKernel forwarding methods on a subset.
+    # Every destination kind, affine/scattered axes, tails and
+    # k_block_length == 0; the ScalarKernel/SIMDKernel forwarding methods on a subset.
     function run(ctor, ::Type{T}, MR, NR, full) where {T}
         kernel = ctor(Val(MR), Val(NR), T)
-        kc = 7
+        k_block_length = 7
         storage = rand(T, 4000)
         koffs = [0, MR, 3MR, 2MR, 5MR, 4MR, 6MR]
         lanes = collect(0:(max(MR, NR) - 1)) .* 3
-        bufa = zeros(T, MR * kc + 8)
-        bufb = zeros(T, NR * kc + 8)
         bytes = Int[]
-        GC.@preserve bufa bufb koffs begin
-            pa = packed_panel(bufa, 1, MR * kc)
-            dsts_a = (bufa, view(bufa, 3:(2 + MR * kc)), pa)
-            dsts_b = (bufb, view(bufb, 3:(2 + NR * kc)), packed_panel(bufb, 1, NR * kc))
-            pk = PtrScatterAxis(pointer(koffs), kc)
-            srcs_a = (
-                SourceTile(storage, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, kc)),
-                SourceTile(storage, 0, AffineAxis(0, 1, MR), pk),
-                SourceTile(storage, 0, AffineAxis(0, 2, MR - 1), AffineAxis(0, 2MR, kc)),
-                SourceTile(storage, 0, ScatterAxis(lanes, MR), ScatterAxis(koffs, kc)),
-                SourceTile(storage, 0, AffineAxis(0, 1, MR), AffineAxis(0, MR, 0)),
-            )
-            srcs_b = (
-                SourceTile(storage, 0, AffineAxis(0, 1, kc), AffineAxis(0, kc, NR)),
-                SourceTile(storage, 0, pk, AffineAxis(0, kc, NR - 1)),
-                SourceTile(storage, 0, ScatterAxis(koffs, kc), ScatterAxis(lanes, NR)),
-                SourceTile(storage, 0, AffineAxis(0, 1, 0), AffineAxis(0, kc, NR)),
+        for (i, L) in ((1, MR), (2, NR))
+            spec = sliver_spec(kernel, i)
+            buf = zeros(T, L * k_block_length + 8)
+            pk = view(koffs, 1:k_block_length)
+            srcs = (
+                Tile(storage, 0, AffineAxis(0, 1, L), AffineAxis(0, L, k_block_length)),
+                Tile(storage, 0, AffineAxis(0, 1, L), pk),
+                Tile(storage, 0, AffineAxis(0, 2, L - 1), AffineAxis(0, 2L, k_block_length)),
+                Tile(storage, 0, view(lanes, 1:L), pk),
+                Tile(storage, 0, AffineAxis(0, 1, L), AffineAxis(0, L, 0)),
             )
-            if !full
-                srcs_a, srcs_b, dsts_a, dsts_b = srcs_a[1:1], srcs_b[1:1], dsts_a[1:2], dsts_b[1:2]
-            end
-            for d in dsts_a
-                for s in srcs_a
-                    push!(bytes, steady_pack_allocs(pack_a!, d, s, kernel, identity))
+            GC.@preserve buf for d in (buf, packed_panel(buf, 1, L * k_block_length))
+                for s in (full ? srcs : srcs[1:1]), f in (identity, conj)
+                    push!(bytes, steady_pack_allocs(d, s, spec, f))
                 end
-                push!(bytes, steady_pack_allocs(pack_a!, d, srcs_a[1], kernel, nontrivial))
-            end
-            for d in dsts_b, s in srcs_b
-                push!(bytes, steady_pack_allocs(pack_b!, d, s, kernel, identity))
+                push!(bytes, steady_pack_allocs(d, srcs[1], spec, nontrivial))
             end
-            push!(bytes, steady_pack_allocs(pack_b!, dsts_b[1], srcs_b[1], kernel, nontrivial))
-            push!(bytes, steady_pack_allocs(pack_a!, pa, srcs_a[1], kernel, conj))
         end
         return bytes
     end
-    @test all(iszero, run(KernelDescriptor, Float64, 16, 6, true))
-    @test all(iszero, run(KernelDescriptor, Float32, 32, 6, true))
+    @test all(iszero, run(Descriptor, Float64, 16, 6, true))
+    @test all(iszero, run(Descriptor, Float32, 32, 6, true))
     @test all(iszero, run(ScalarKernel, Float64, 8, 6, false))
     @test all(iszero, run(SIMDKernel, Float64, 8, 6, false))
 end
diff --git a/test/planning/helpers.jl b/test/planning/helpers.jl
new file mode 100644
index 0000000..2bd2cdc
--- /dev/null
+++ b/test/planning/helpers.jl
@@ -0,0 +1,26 @@
+include("../helpers.jl")
+
+# Label order within M/N and the M/N orientation swap.
+const _lo_order = QuasiStrided.order_free_labels
+const _lo_run = QuasiStrided.leading_unit_run
+_lo_swap(morder, norder, indC, C, m_tile_asis, m_tile_swapped = m_tile_asis) = QuasiStrided.prefer_swap(
+    _lo_run(morder, indC, C), _lo_run(norder, indC, C), m_tile_asis, m_tile_swapped
+)
+
+# A view with these strides over dummy data (only strides/size are read).
+_lo_view(sz::NTuple{N, Int}, st::NTuple{N, Int}) where {N} =
+    StridedView(zeros(Float64, 4096), sz, st, 2048, identity)
+
+# The four TCCG `ccsd_t_*` shapes, C stored in (a,b,c,i,j,k) order, labelled
+# as the TensorOperations adapter labels them.
+const LO_IC = (:a, :b, :c, :i, :j, :k)
+const LO_CASES = (
+    ("ccsd_t_1", (:i, :j, :m, :a), (:m, :k, :b, :c)),
+    ("ccsd_t_2", (:i, :j, :m, :b), (:m, :k, :a, :c)),
+    ("ccsd_t_3", (:i, :j, :m, :c), (:m, :k, :a, :b)),
+    ("ccsd_t_4", (:i, :k, :m, :b), (:m, :j, :a, :c)),
+)
+function _lo_labels(IA, IB)
+    pA, pB, pAB = TO.contract_indices(IA, IB, LO_IC)
+    return QuasiStrided.contraction_labels(pA, pB, pAB), (pA, pB, pAB)
+end
diff --git a/test/planning/test_blocking.jl b/test/planning/test_blocking.jl
new file mode 100644
index 0000000..fbc9074
--- /dev/null
+++ b/test/planning/test_blocking.jl
@@ -0,0 +1,89 @@
+include("../helpers.jl")
+
+@testset "Blocking: field validation" begin
+    b = Blocking(4, 8, 16)
+    @test b.m_block == 4 && b.k_block == 8 && b.n_block == 16
+
+    @test_throws ArgumentError Blocking(0, 8, 16)
+    @test_throws ArgumentError Blocking(4, 0, 16)
+    @test_throws ArgumentError Blocking(4, 8, 0)
+    @test_throws ArgumentError Blocking(-1, 8, 16)
+end
+
+@testset "default_blocking: dispatches on kernel scalar type" begin
+    bf64 = default_blocking(ScalarKernel(Val(8), Val(6), Float64))
+    bf32 = default_blocking(ScalarKernel(Val(8), Val(6), Float32))
+    @test bf64 isa Blocking
+    @test bf32 isa Blocking
+    @test bf64.m_block >= 1 && bf64.k_block >= 1 && bf64.n_block >= 1
+    @test bf32.m_block >= 1 && bf32.k_block >= 1 && bf32.n_block >= 1
+    # Same kernel shape, different scalar type, through SIMDKernel too.
+    @test default_blocking(SIMDKernel(Val(8), Val(6), Float64)) == bf64
+end
+
+@testset "analytical blocking model" begin
+    KiB, MiB = 1024, 1024^2
+    # No SMT with an L3 shared by 4 cores; SMT 2 with an L3 shared by 8 cores.
+    nosmt = TargetProfile(
+        :avx2, "znver2", CacheLevel(32KiB, 64, 1),
+        CacheLevel(512KiB, 64, 1), CacheLevel(16MiB, 64, 4)
+    )
+    smt2 = TargetProfile(
+        :avx512, "cascadelake", CacheLevel(32KiB, 64, 2),
+        CacheLevel(1MiB, 64, 2), CacheLevel(25952256, 64, 16)
+    )
+    @test modelled_blocking(nosmt, 8, 6, 8, 8) === Blocking(96, 341, 1728)
+    @test modelled_blocking(nosmt, 16, 6, 4, 4) === Blocking(96, 682, 1728)
+    @test modelled_blocking(smt2, 16, 6, 8, 8) === Blocking(192, 341, 1572)
+    # A complex kernel keeps the real default kernel's `k_block` and blocks M
+    # and N by its packed bytes: 1m packs 4 reals per A element, 2 per B element.
+    @test default_blocking(kernel_from_shape((12, 8, 8), ComplexF64, OneMKernel), nosmt) === Blocking(24, 341, 864)
+    for p in (nosmt, smt2), T in (Float64, Float32, ComplexF64, ComplexF32), K in (SIMDKernel, PlanarKernel, OneMKernel, FMAddSubKernel)
+        for shape in kernel_shapes(T, K)
+            k = kernel_from_shape(shape, T, K)
+            b = default_blocking(k, p)
+            MR, NR = tile_size(k)
+            @test b.m_block % MR == 0 && b.n_block % NR == 0
+            real_default = kernel_from_shape(derived_shape(p, real(T)), real(T), SIMDKernel)
+            @test b.k_block == default_blocking(real_default, p).k_block
+        end
+    end
+    # No L3: the B panel is budgeted from the L2 alone.
+    nol3 = TargetProfile(
+        :neon, "", CacheLevel(64KiB, 64, 1),
+        CacheLevel(4MiB, 64, 4), CacheLevel()
+    )
+    @test modelled_blocking(nol3, 4, 6, 8, 8).n_block == (1MiB ÷ (682 * 8)) ÷ 6 * 6
+    tiny = TargetProfile(
+        :avx2, "", CacheLevel(64, 64, 1), CacheLevel(64, 64, 1), CacheLevel()
+    )
+    @test modelled_blocking(tiny, 8, 6, 8, 8) === Blocking(8, 1, 6)
+    @test modelled_blocking(unknown_target(), 8, 6, 8, 8) === nothing
+    @test modelled_blocking(
+        TargetProfile(:avx2, "", CacheLevel(32KiB, 64, 1), CacheLevel(), CacheLevel()),
+        8, 6, 8, 8
+    ) === nothing
+end
+
+@testset "undetected caches: the fallback row scaled by packed reals" begin
+    u = unknown_target()
+    for T in (ComplexF64, ComplexF32), K in (PlanarKernel, OneMKernel, FMAddSubKernel)
+        b = default_blocking(kernel_from_shape(first(kernel_shapes(T, K)), T, K), u)
+        base = fallback_blocking(real(T))
+        @test b.k_block === base.k_block
+        @test b.m_block === base.m_block ÷ reals_per_element(pack_formats(K)[1])
+        @test b.n_block === base.n_block ÷ reals_per_element(pack_formats(K)[2])
+    end
+    @test default_blocking(kernel_from_shape((24, 3, 8), ComplexF64, PlanarKernel), u) === Blocking(64, 256, 384)
+end
+
+@testset "1m and FMAddSub kernels block by their packed reals on this host" begin
+    for T in (ComplexF64, ComplexF32)
+        bp = default_blocking(PlanarKernel(Val(8), Val(8), T, Val(8)))
+        bm = default_blocking(OneMKernel(Val(8), Val(8), T, Val(8)))
+        bf = default_blocking(FMAddSubKernel(Val(8), Val(8), T, Val(8)))
+        # 1m: twice the packed A reals, rounded to MR = 8. FMAddSub: planar's.
+        @test (bm.k_block, bm.n_block) == (bp.k_block, bp.n_block) && bp.m_block - 2 * bm.m_block in (0, 8)
+        @test bf == bp
+    end
+end
diff --git a/test/planning/test_kernel_selection.jl b/test/planning/test_kernel_selection.jl
index 196ff96..c2bd1f7 100644
--- a/test/planning/test_kernel_selection.jl
+++ b/test/planning/test_kernel_selection.jl
@@ -1,173 +1,180 @@
 # Register shape, kernel and blocking selection from a `TargetProfile`.
 
+include("helpers.jl")
+
 using StridedViews: StridedView
 
 @testset "real shape selection" begin
     @testset "unknown target: fallback shape and blocking" begin
         u = unknown_target()
         for T in (Float64, Float32)
-            @test _derived_shape(u, T) === _fallback_shape(T)
-            k = _kernel_for(u, T)
+            @test derived_shape(u, T) === fallback_shape(T)
+            k = kernel_from_shape(derived_shape(u, T), T)
             @test k isa SIMDKernel
-            @test (mr(k), nr(k), lanewidth(k)) === _fallback_shape(T)
-            @test _real_blocking_row(u, T) === _fallback_blocking(T)
+            @test (tile_size(k)..., lanewidth(k)) === fallback_shape(T)
+            @test default_blocking(k, u) === fallback_blocking(T)
         end
-        @test _fallback_blocking(Float64) === Blocking(128, 256, 768)
-        @test _fallback_blocking(Float32) === Blocking(96, 768, 1152)
-        # The type-argument form ignores detection.
-        @test default_blocking(Float64) === _fallback_blocking(Float64)
-        @test default_blocking(Float32) === _fallback_blocking(Float32)
+        @test fallback_blocking(Float64) === Blocking(128, 256, 768)
+        @test fallback_blocking(Float32) === Blocking(96, 768, 1152)
     end
 
     @testset "rule: MR = MV*W, NR = 6; MV = 4 on Intel :avx512, 2 on :avx2 and AMD" begin
         for (isakey, vb, MV) in ((:avx512, 64, 4), (:avx2, 32, 2)), T in (Float64, Float32)
             W = vb ÷ sizeof(T)
-            @test _derived_shape(synthetic(isakey, vb), T) === (MV * W, NR_DEFAULT, W)
-            @test QuasiStrided._rule_mv(Val(isakey), RealMethod()) == MV
-            @test QuasiStrided._rule_shape(vb, T, MV) === (MV * W, NR_DEFAULT, W)
+            @test derived_shape(synthetic(isakey), T) === (MV * W, NR_DEFAULT, W)
+            @test QuasiStrided.rule_mv(isakey, SIMDKernel) == MV
+            @test QuasiStrided.rule_shape(vb, T, MV) === (MV * W, NR_DEFAULT, W)
         end
-        for m in (PlanarMethod(), OneMMethod(), FMAddSubMethod()), key in (:avx512, :avx2)
-            @test QuasiStrided._rule_mv(Val(key), m) == 2
+        for K in (PlanarKernel, OneMKernel, FMAddSubKernel), key in (:avx512, :avx2)
+            @test QuasiStrided.rule_mv(key, K) == 2
         end
         for (cpu, MV) in (("znver4", 2), ("znver5", 2), ("icelake-server", 4), ("cascadelake", 4)),
                 T in (Float64, Float32)
-            p = TargetProfile(:avx512, Sys.ARCH, cpu, 64, 32, CacheLevel(), CacheLevel(), CacheLevel())
+            p = TargetProfile(:avx512, cpu, CacheLevel(), CacheLevel(), CacheLevel())
             W = 64 ÷ sizeof(T)
-            @test _derived_shape(p, T) === (MV * W, NR_DEFAULT, W)
-            @test _derived_shape(p, ComplexF64) === _derived_shape(synthetic(:avx512, 64), ComplexF64)
+            @test derived_shape(p, T) === (MV * W, NR_DEFAULT, W)
+            @test derived_shape(p, ComplexF64) === derived_shape(synthetic(:avx512), ComplexF64)
         end
-        @test _derived_shape(synthetic(:avx2, 32), Float64) === _fallback_shape(Float64)
+        @test derived_shape(synthetic(:avx2), Float64) === fallback_shape(Float64)
         # ISAs without a rule get the fallback shape, whatever their width.
-        for T in (Float64, Float32), vb in (0, 16, 32, 64)
-            @test _derived_shape(synthetic(:neon, vb), T) === _fallback_shape(T)
-            @test _derived_shape(synthetic(:unknown, vb), T) === _fallback_shape(T)
+        for T in (Float64, Float32)
+            @test derived_shape(synthetic(:neon), T) === fallback_shape(T)
+            @test derived_shape(synthetic(:unknown), T) === fallback_shape(T)
         end
         # No real override row on any ISA: the rule is the optimum.
         for T in (Float64, Float32), key in VALID_ISAS
-            @test _shape_override(Val(key), T) === nothing
+            @test shape_override(key, T) === nothing
         end
-        @test _rule_applies(Val(:avx2), RealMethod()) && _rule_applies(Val(:avx512), RealMethod())
+        @test rule_applies(:avx2, SIMDKernel) && rule_applies(:avx512, SIMDKernel)
     end
 
     @testset "every real menu shape is constructible and fits the register file" begin
         for T in (Float64, Float32), (MR, NR, W) in kernel_shapes(T)
             @test MR % W == 0
             k = SIMDKernel(Val(MR), Val(NR), T, Val(W))
-            @test (mr(k), nr(k), lanewidth(k)) == (MR, NR, W)
+            @test (tile_size(k)..., lanewidth(k)) == (MR, NR, W)
             @test (MR ÷ W) * NR + (MR ÷ W) <= 32
-            @test packed_a_per_k(k) === MR && packed_b_per_k(k) === NR
+            @test sliver_width(k) === (MR, NR)
             @test realtype(k) === T === scalartype(k)
-            @test complex_method(k) === RealMethod()
             @test packed_a_length(k, 7) === MR * 7 && packed_b_length(k, 7) === NR * 7
         end
         for T in (Float64, Float32)
             W = 64 ÷ sizeof(T)
             # The MV = 2 sibling stays in the menu as the step-down target.
             @test (2 * W, NR_DEFAULT, W) in kernel_shapes(T)
-            @test kernel_shapes(T, RealMethod()) === kernel_shapes(T)
-            k = _default_kernel(T)
+            @test kernel_shapes(T, SIMDKernel) === kernel_shapes(T)
+            k = host_kernel(T)
             @test k isa SIMDKernel && scalartype(k) === T
-            @test (mr(k), nr(k), lanewidth(k)) in kernel_shapes(T)
-        end
-    end
-
-    @testset "shipped defaults are allocation-free on a scattered destination" begin
-        for T in (Float64, Float32)
-            plan = QuasiStrided.plan_contract(scattered_fixture(T)...)
-            QuasiStrided.execute!(plan, one(T), zero(T))
-            QuasiStrided.execute!(plan, one(T), zero(T))
-            @test (@allocated QuasiStrided.execute!(plan, one(T), zero(T))) == 0 skip = (VERSION < v"1.11")
+            @test (tile_size(k)..., lanewidth(k)) in kernel_shapes(T)
         end
     end
 
     @testset "extent demotion when M cannot fill a register tile" begin
         for T in (Float64, Float32)
-            MR = mr(_default_kernel(T))
-            @test mr(_default_kernel(T, 4 * MR, 256)) == MR
-            small = _default_kernel(T, 1, 256)
-            @test (mr(small), nr(small), lanewidth(small)) === _fallback_shape(T)
-            @test mr(_default_kernel(T, 0, 256)) == MR        # empty must not demote
+            MR = tile_size(host_kernel(T), 1)
+            @test tile_size(auto_kernel(T, 4 * MR), 1) == MR
+            small = auto_kernel(T, 1)
+            @test (tile_size(small)..., lanewidth(small)) === fallback_shape(T)
+            @test tile_size(auto_kernel(T, 0), 1) == MR        # empty must not demote
         end
     end
 
-    @testset "_extent_shape: MV = 4 steps down to MV = 2 where it pads less" begin
-        ext(shape, T, Qm) = QuasiStrided._extent_shape(shape, T, RealMethod(), Qm)
+    @testset "extent_shape: MV = 4 steps down to MV = 2 where it pads less" begin
+        ext(shape, T, m_length) = QuasiStrided.extent_shape(shape, T, SIMDKernel, m_length)
         for T in (Float64, Float32)
-            tall = _derived_shape(synthetic(:avx512, 64), T)
+            tall = derived_shape(synthetic(:avx512), T)
             MR, NR, W = tall
             half = (2 * W, NR, W)
             @test ext(tall, T, 0) === tall
-            for Qm in (1, 2 * W - 1, 2 * W, MR - 1, MR + 1, MR + W, MR + 2 * W)
-                @test ext(tall, T, Qm) === half
+            for m_length in (1, 2 * W - 1, 2 * W, MR - 1, MR + 1, MR + W, MR + 2 * W)
+                @test ext(tall, T, m_length) === half
             end
-            for Qm in (MR, MR + 2 * W + 1, 2 * MR - 1, 2 * MR, 2 * MR + 1, 3 * MR + W, 100 * MR)
-                @test ext(tall, T, Qm) === tall
+            for m_length in (MR, MR + 2 * W + 1, 2 * MR - 1, 2 * MR, 2 * MR + 1, 3 * MR + W, 100 * MR)
+                @test ext(tall, T, m_length) === tall
             end
-            # Never below MV = 2, and complex methods are untouched.
-            avx2 = _derived_shape(synthetic(:avx2, 32), T)
+            # Never below MV = 2, and complex kernels are untouched.
+            avx2 = derived_shape(synthetic(:avx2), T)
             @test ext(avx2, T, 3) === avx2
-            cs = _derived_shape(synthetic(:avx512, 64), ComplexF64)
-            @test QuasiStrided._extent_shape(cs, ComplexF64, PlanarMethod(), 3) === cs
-            # Through `_default_kernel`, where the host's shape is the tall one.
-            if _derived_shape(target_profile(), T) === tall
-                @test (mr(_default_kernel(T, MR + W, 256)), nr(_default_kernel(T, MR + W, 256))) == (2 * W, NR)
-                @test mr(_default_kernel(T, 2 * W, 256)) == 2 * W
-                @test mr(_default_kernel(T, 2 * W - 1, 256)) == _fallback_shape(T)[1]
-                @test mr(_default_kernel(T, 2 * MR, 256)) == MR
+            cs = derived_shape(synthetic(:avx512), ComplexF64)
+            @test QuasiStrided.extent_shape(cs, ComplexF64, PlanarKernel, 3) === cs
+            # Through `auto_kernel`, where the host's shape is the tall one.
+            if derived_shape(target_profile(), T) === tall
+                @test tile_size(auto_kernel(T, MR + W)) == (2 * W, NR)
+                @test tile_size(auto_kernel(T, 2 * W), 1) == 2 * W
+                @test tile_size(auto_kernel(T, 2 * W - 1), 1) == fallback_shape(T)[1]
+                @test tile_size(auto_kernel(T, 2 * MR), 1) == MR
             end
         end
     end
 
-    @testset "_store_shape: MV = 4 steps down where C's run breaks its slivers" begin
-        st = QuasiStrided._store_shape
+    @testset "fit_to_run: C's run along M decides the real shape" begin
+        fit(shape, T, m_length, k_length, run) =
+            QuasiStrided.fit_to_run(shape, T, SIMDKernel, m_length, k_length, run)
+        largest_divisor(T, run) = argmax(s -> (run % s[1] == 0, s[1]), kernel_shapes(T))
+        deep = 10^6
         for T in (Float64, Float32)
-            tall = _derived_shape(synthetic(:avx512, 64), T)
+            tall = derived_shape(synthetic(:avx512), T)
             MR, NR, W = tall
             half = (2 * W, NR, W)
-            Qm = 64 * MR
-            for run in (Qm, MR, 2 * MR, 5 * MR)                  # every tall sliver whole
-                @test st(tall, T, RealMethod(), Qm, run) === tall
+            m_length = 64 * MR
+            # MV = 4 -> MV = 2 at any K.
+            for run in (m_length, MR, 2 * MR, 5 * MR)                  # every tall sliver whole
+                @test fit(tall, T, m_length, deep, run) === tall
             end
-            @test st(tall, T, RealMethod(), 3 * W, 3 * W) === tall
-            for run in (2 * W, 3 * W, 6 * W, MR + 2 * W, Qm - 1)
-                @test st(tall, T, RealMethod(), Qm, run) === half
+            @test fit(tall, T, 3 * W, deep, 3 * W) === tall
+            for run in (2 * W, 3 * W, 6 * W, MR + 2 * W, m_length - 1)
+                @test fit(tall, T, m_length, deep, run) === half
             end
             for run in (1, W, 2 * W - 1)                          # below one half tile
-                @test st(tall, T, RealMethod(), Qm, run) === tall
+                @test fit(tall, T, m_length, deep, run) === tall
             end
-            @test st(half, T, RealMethod(), Qm, 3 * W) === half
-            @test st(_fallback_shape(T), T, RealMethod(), Qm, 3 * W) === _fallback_shape(T)
-            cs = _derived_shape(synthetic(:avx512, 64), ComplexF64)
-            @test st(cs, ComplexF64, PlanarMethod(), Qm, 3 * W) === cs
-            if _derived_shape(target_profile(), T) === tall
-                @test QuasiStrided._default_shape(T, Qm, 256, 2 * W)[1] === half
-                @test QuasiStrided._default_shape(T, Qm, 256, MR)[1] === tall
-                @test QuasiStrided._default_shape(T, Qm, 256)[1] === tall   # no run given
+            @test fit(half, T, m_length, deep, 3 * W) === half
+            # Then, at shallow K, the largest menu shape whose `MR` divides the run.
+            @test fit(tall, T, m_length, 1, 3 * W) === largest_divisor(T, 3 * W)
+            kmax = T === Float64 ? QuasiStrided.RUN_DEMOTE_KMAX_F64 : QuasiStrided.RUN_DEMOTE_KMAX_F32
+            for shape in kernel_shapes(T)
+                S = shape[1]
+                @test fit(shape, T, 1000, 1, 3 * S) === shape
+                @test fit(shape, T, 7, 1, 7) === shape
+                @test fit(shape, T, 1000, kmax + 1, 4) === shape
+                for run in (1, 4, 8, 12, 16, 20, 24, 48)
+                    (run % S == 0 || (S == 4 * shape[3] && run >= 2 * shape[3])) && continue
+                    want = any(s -> run % s[1] == 0, kernel_shapes(T)) ? largest_divisor(T, run) : shape
+                    @test fit(shape, T, 1000, kmax, run) === want
+                end
+            end
+            cs = derived_shape(synthetic(:avx512), ComplexF64)
+            @test QuasiStrided.fit_to_run(cs, ComplexF64, PlanarKernel, m_length, 1, 1) === cs
+            if derived_shape(target_profile(), T) === tall
+                select(run) = QuasiStrided.select_shape(T, SIMDKernel, m_length, deep, run)[1]
+                @test select(2 * W) === half
+                @test select(MR) === tall
+                @test select(m_length) === tall
             end
         end
     end
 
-    @testset "_store_shape feeds the swap: ccsd_t_2 / ao2mo_2 at dim 16" begin
+    @testset "fit_to_run feeds the swap: ccsd_t_2 / ao2mo_2 at dim 16" begin
         # Regression: C's only unit run is 16 long, on the N side. Judged
-        # against mr = 32 the swap was declined and every tile stored scattered.
+        # against m_tile = 32 the swap was declined and every tile stored scattered.
         T = Float64
-        if _derived_shape(target_profile(), T)[1] == 32
+        if derived_shape(target_profile(), T)[1] == 32
             d = 16
             a, b, c, i, j, k, m = 1, 2, 3, 4, 5, 6, -1
             Bv = StridedView(randn(T, d, d, d, d))
             plan = QuasiStrided.plan_contract(
                 StridedView(zeros(T, d, d, d, d, d, d)), StridedView(randn(T, d, d, d, d)),
-                (i, j, m, b), Bv, (m, k, a, c), (a, b, c, i, j, k); oracle = false
+                (i, j, m, b), Bv, (m, k, a, c), (a, b, c, i, j, k)
             )
-            @test mr(plan.kernel) == 16
+            @test tile_size(plan.kernel, 1) == 16
             @test plan.Astorage === parent(Bv)
             q, r, s = -1, 3, 4
             B2 = StridedView(randn(T, d, d, d, d))
             plan2 = QuasiStrided.plan_contract(
                 StridedView(zeros(T, d, d, d, d)), StridedView(randn(T, d, d)), (q, b),
-                B2, (a, q, r, s), (a, b, r, s); oracle = false
+                B2, (a, q, r, s), (a, b, r, s)
             )
-            @test mr(plan2.kernel) == 16
+            @test tile_size(plan2.kernel, 1) == 16
             @test plan2.Astorage === parent(B2)
             @test axis_length(plan2.mgroup) == d^3
         end
@@ -177,46 +184,45 @@ end
 @testset "complex shape selection" begin
     for (T, W, swept) in ((ComplexF64, 8, (24, 3, 8)), (ComplexF32, 16, (48, 3, 16)))
         # W counts REAL lanes; the AVX-512 override replaces the spilling rule shape.
-        @test QuasiStrided._rule_shape(64, T, 2) === (2 * W, NR_DEFAULT, W)
-        @test _shape_override(Val(:avx512), T) === swept
-        @test _derived_shape(synthetic(:avx512, 64), T) === swept === first(kernel_shapes(T, PlanarMethod()))
-        @test Set(kernel_shapes(T, PlanarMethod())) == Set(
+        @test QuasiStrided.rule_shape(64, T, 2) === (2 * W, NR_DEFAULT, W)
+        @test shape_override(:avx512, T) === swept
+        @test derived_shape(synthetic(:avx512), T) === swept === first(kernel_shapes(T, PlanarKernel))
+        @test Set(kernel_shapes(T, PlanarKernel)) == Set(
             (
-                (2 * W, NR_DEFAULT, W), swept, (W, 8, W), _shape_override(Val(:avx2), T),
-                _shape_override(Val(:neon), T), (W ÷ 4, NR_DEFAULT, W ÷ 4),
+                (2 * W, NR_DEFAULT, W), swept, (W, 8, W), shape_override(:avx2, T),
+                (W ÷ 2, NR_DEFAULT, W ÷ 4), (W ÷ 4, NR_DEFAULT, W ÷ 4),
             )
         )
         # Every override row fits its ISA's register file with room to spare.
-        for (key, nreg) in ((:avx512, 32), (:avx2, 16), (:neon, 32))
-            ovr = _shape_override(Val(key), T)
-            @test _planar_pressure(ovr...) < nreg
-            @test ovr in kernel_shapes(T, PlanarMethod())
+        for (key, nreg) in ((:avx512, 32), (:avx2, 16))
+            ovr = shape_override(key, T)
+            @test planar_pressure(ovr...) < nreg
+            @test ovr in kernel_shapes(T, PlanarKernel)
         end
-        @test _fallback_shape(T) === (8, NR_DEFAULT, _fallback_shape(real(T))[3])
+        @test fallback_shape(T) === (8, NR_DEFAULT, fallback_shape(real(T))[3])
         # Off :avx512 an override row wins whatever the width; without a row
         # the shape is fitted to the register budget.
-        for key in (:avx2, :neon), vb in (0, 16, 32, 64), nreg in (0, 16, 32)
-            @test !_rule_applies(Val(key), PlanarMethod())
-            @test _derived_shape(synthetic(key, vb; nregisters = nreg), T) === _shape_override(Val(key), T)
+        @test derived_shape(synthetic(:avx2), T) === shape_override(:avx2, T)
+        for key in (:avx2, :neon, :unknown)
+            @test !rule_applies(key, PlanarKernel)
         end
-        for key in (:unknown, :somethingelse), vb in (0, 16, 32, 64), nreg in (0, 16, 32)
-            @test !_rule_applies(Val(key), PlanarMethod())
-            @test _shape_override(Val(key), T) === nothing
-            shape = _derived_shape(synthetic(key, vb; nregisters = nreg), T)
-            @test _planar_pressure(shape...) <= (nreg > 0 ? nreg : 16)
+        for key in (:neon, :unknown)
+            @test shape_override(key, T) === nothing
         end
-        @test _derived_shape(synthetic(:avx512, 0), T) in kernel_shapes(T, PlanarMethod())
+        @test planar_pressure(derived_shape(synthetic(:unknown), T)...) <= 16
     end
-    @test _rule_applies(Val(:avx512), PlanarMethod())
-    @test _planar_pressure(_fallback_shape(ComplexF64)...) == 30
-    @test _planar_pressure(_fallback_shape(ComplexF32)...) == 16
+    @test rule_applies(:avx512, PlanarKernel)
+    @test derived_shape(synthetic(:neon), ComplexF64) === (4, 6, 2)
+    @test derived_shape(synthetic(:neon), ComplexF32) === (8, 6, 4)
+    @test planar_pressure(fallback_shape(ComplexF64)...) == 30
+    @test planar_pressure(fallback_shape(ComplexF32)...) == 16
 
     # Complex menus fit AVX-512 and stay bounded.
-    nreg = _isa_nregisters(Val(:avx512))
+    nreg = isa_nregisters(:avx512)
     target_profile().isa === :avx512 && @test target_profile().nregisters == nreg
-    for T in (ComplexF64, ComplexF32), m in (PlanarMethod(), OneMMethod())
-        planes = accumulator_planes(m)
-        for (MR, NR, W) in kernel_shapes(T, m)
+    for T in (ComplexF64, ComplexF32), K in (PlanarKernel, OneMKernel)
+        planes = accumulator_planes(K)
+        for (MR, NR, W) in kernel_shapes(T, K)
             rows = (2 * MR) ÷ planes
             @test rows % W == 0
             mv = rows ÷ W
@@ -224,194 +230,261 @@ end
         end
     end
     for T in (ComplexF64, ComplexF32)
-        @test length(kernel_shapes(T, PlanarMethod())) <= 6
-        @test length(kernel_shapes(T, OneMMethod())) <= 4
+        @test length(kernel_shapes(T, PlanarKernel)) <= 6
+        @test length(kernel_shapes(T, OneMKernel)) <= 4
     end
 end
 
 @testset "mixed-domain selection: the real default of real(T), mapped" begin
-    CR, RC = QuasiStrided.ComplexRealMethod(), QuasiStrided.RealComplexMethod()
+    CR, RC = QuasiStrided.ComplexRealKernel, QuasiStrided.RealComplexKernel
     mapped(m, (MR, NR, W)) = m === CR ? (MR ÷ 2, NR, W) : (MR, NR ÷ 2, W)
-    dmethod = QuasiStrided._default_method
+    dkernel = QuasiStrided.default_kernel_type
     for T in (ComplexF64, ComplexF32)
         R = real(T)
         @test all(((MR, NR, W),) -> iseven(NR) && iseven(W), kernel_shapes(R))
         for m in (CR, RC)
             @test kernel_shapes(T, m) === map(s -> mapped(m, s), kernel_shapes(R))
             for shape in kernel_shapes(T, m)
-                k = QuasiStrided._kernel_from_shape(shape, T, m)
-                @test complex_method(k) === m && (mr(k), nr(k), lanewidth(k)) === shape
+                k = QuasiStrided.kernel_from_shape(shape, T, m)
+                @test k isa m && (tile_size(k)..., lanewidth(k)) === shape
             end
         end
-        @test dmethod(T, T, R) === dmethod(T, ComplexF32, Float64) === CR
-        @test dmethod(T, R, T) === dmethod(T, Float32, ComplexF64) === RC
-        @test dmethod(T, R, R) === dmethod(T, T, T) === dmethod(T, ComplexF32, T) === PlanarMethod()
-        @test dmethod(R, Float32, Float64) === RealMethod()
+        @test dkernel(T, T, R) === dkernel(T, ComplexF32, Float64) === CR
+        @test dkernel(T, R, T) === dkernel(T, Float32, ComplexF64) === RC
+        @test dkernel(T, R, R) === dkernel(T, T, T) === dkernel(T, ComplexF32, T) === PlanarKernel
+        @test dkernel(R, Float32, Float64) === SIMDKernel
     end
-    # The real extent, store and small-M demotions carry over.
-    saved = QuasiStrided._TARGET[]
+    # Every real step carries over.
+    saved = QuasiStrided.TARGET[]
     try
-        for (key, vb, nreg) in ((:avx512, 64, 32), (:avx2, 32, 16), (:neon, 16, 32))
-            QuasiStrided._TARGET[] = synthetic(key, vb; nregisters = nreg)
-            for T in (ComplexF64, ComplexF32), m in (CR, RC), Qm in (1, 3, 17, 40, 4096), run in (0, 1, 8, Qm)
-                real_problem = m === CR ? (2 * Qm, 50, 2 * run) : (Qm, 100, run)
-                @test QuasiStrided._default_shape(T, m, Qm, 50, run) ===
-                    (mapped(m, QuasiStrided._default_shape(real(T), real_problem...)[1]), m)
+        for key in (:avx512, :avx2, :neon)
+            QuasiStrided.TARGET[] = synthetic(key)
+            for T in (ComplexF64, ComplexF32), m in (CR, RC), m_length in (1, 3, 17, 40, 4096),
+                    run in (0, 1, 8, m_length), k_length in (1, 1000)
+                real_m, real_run = m === CR ? (2 * m_length, 2 * run) : (m_length, run)
+                real_shape = QuasiStrided.select_shape(real(T), SIMDKernel, real_m, k_length, real_run)[1]
+                @test QuasiStrided.select_shape(T, m, m_length, k_length, run) === (mapped(m, real_shape), Val(m))
             end
         end
     finally
-        QuasiStrided._TARGET[] = saved
+        QuasiStrided.TARGET[] = saved
     end
 end
 
-@testset "_derived_shape is always a constructible member of the method's menu" begin
-    methods = (
-        (Float64, RealMethod()), (Float32, RealMethod()), (ComplexF64, PlanarMethod()),
-        (ComplexF32, PlanarMethod()), (ComplexF64, OneMMethod()), (ComplexF32, OneMMethod()),
+@testset "derived_shape is always a constructible member of the kernel's menu" begin
+    pairs = (
+        (Float64, SIMDKernel), (Float32, SIMDKernel), (ComplexF64, PlanarKernel),
+        (ComplexF32, PlanarKernel), (ComplexF64, OneMKernel), (ComplexF32, OneMKernel),
     )
-    for (T, m) in methods, isakey in (VALID_ISAS..., :somethingelse),
-            vb in (0, 16, 32, 64, 128), nreg in (0, 16, 32)
-        shape = _derived_shape(synthetic(isakey, vb; nregisters = nreg), T, m)
+    for (T, m) in pairs, isakey in VALID_ISAS
+        shape = derived_shape(synthetic(isakey), T, m)
         @test shape in kernel_shapes(T, m)
-        k = QuasiStrided._kernel_from_shape(shape, T, m)
-        @test (mr(k), nr(k), lanewidth(k)) === shape
+        k = QuasiStrided.kernel_from_shape(shape, T, m)
+        @test (tile_size(k)..., lanewidth(k)) === shape
     end
 end
 
-@testset "analytical blocking model" begin
-    KiB, MiB = 1024, 1024^2
-    # No SMT with an L3 shared by 4 cores; SMT 2 with an L3 shared by 8 cores.
-    nosmt = TargetProfile(
-        :avx2, :x86_64, "znver2", 32, 16, CacheLevel(32KiB, 8, 64, 1),
-        CacheLevel(512KiB, 8, 64, 1), CacheLevel(16MiB, 16, 64, 4)
-    )
-    smt2 = TargetProfile(
-        :avx512, :x86_64, "cascadelake", 64, 32, CacheLevel(32KiB, 8, 64, 2),
-        CacheLevel(1MiB, 16, 64, 2), CacheLevel(25952256, 11, 64, 16)
-    )
-    @test _modelled_blocking(nosmt, Float64, 8, 6) === Blocking(96, 341, 1728)
-    @test _modelled_blocking(nosmt, Float32, 16, 6) === Blocking(96, 682, 1728)
-    @test _modelled_blocking(smt2, Float64, 16, 6) === Blocking(192, 341, 1572)
-    @test _modelled_blocking(nosmt, Float64) === _modelled_blocking(nosmt, Float64, 8, 6)
-    for p in (nosmt, smt2), T in (Float64, Float32)
-        b = _modelled_blocking(p, T)
-        MR, NR, _ = _derived_shape(p, T)
-        @test b.mc % MR == 0 && b.nc % NR == 0
-        @test NR * b.kc * sizeof(T) <= p.l1d.bytes ÷ 2
-        @test _real_blocking_row(p, T) === b
-    end
-    # No L3: the B panel is budgeted from the L2 alone.
-    nol3 = TargetProfile(
-        :neon, :aarch64, "", 16, 32, CacheLevel(64KiB, 4, 64, 1),
-        CacheLevel(4MiB, 16, 64, 4), CacheLevel()
-    )
-    @test _modelled_blocking(nol3, Float64, 4, 6).nc == (1MiB ÷ (682 * 8)) ÷ 6 * 6
-    tiny = TargetProfile(
-        :avx2, :x86_64, "", 32, 16, CacheLevel(64, 1, 64, 1), CacheLevel(64, 1, 64, 1), CacheLevel()
+@testset "pack_formats agrees with every kernel's descriptor" begin
+    QS = QuasiStrided
+    kernels = (
+        ScalarKernel(Val(4), Val(2), Float64), SIMDKernel(Val(8), Val(4), Float32),
+        QS.PlanarKernel(Val(4), Val(2), ComplexF64), QS.OneMKernel(Val(4), Val(2), ComplexF64),
+        QS.FMAddSubKernel(Val(4), Val(2), ComplexF64), QS.ComplexRealKernel(Val(4), Val(2), ComplexF64),
+        QS.RealComplexKernel(Val(4), Val(2), ComplexF64),
     )
-    @test _modelled_blocking(tiny, Float64, 8, 6) === Blocking(8, 1, 6)
-    @test _modelled_blocking(unknown_target(), Float64, 8, 6) === nothing
-    @test _modelled_blocking(
-        TargetProfile(:avx2, :x86_64, "", 32, 16, CacheLevel(32KiB, 8, 64, 1), CacheLevel(), CacheLevel()),
-        Float64, 8, 6
-    ) === nothing
-end
-
-@testset "complex blocking is the real row scaled by packed reals" begin
-    for base in (_fallback_blocking(Float64), _fallback_blocking(Float32), Blocking(1, 5, 1))
-        for m in (PlanarMethod(), OneMMethod(), FMAddSubMethod())
-            b = _scale_blocking(base, m)
-            @test b.kc === base.kc
-            @test b.mc === max(1, base.mc ÷ a_reals(m))
-            @test b.nc === max(1, base.nc ÷ b_reals(m))
-        end
-    end
-    @test _scale_blocking(_fallback_blocking(Float64), PlanarMethod()) === Blocking(64, 256, 384)
-    @test _scale_blocking(_fallback_blocking(Float64), OneMMethod()) === Blocking(32, 256, 384)
-    for T in (ComplexF64, ComplexF32)
-        row = _real_blocking_row(target_profile(), real(T))
-        @test default_blocking(_default_kernel(T)) === _scale_blocking(row, PlanarMethod())
-    end
-    for T in (Float64, Float32)
-        @test default_blocking(_default_kernel(T)) === _real_blocking_row(target_profile(), T)
+    for k in kernels
+        @test pack_formats(typeof(k)) === (QS.a_format(k), QS.b_format(k))
     end
 end
 
 @testset "kernel construction: the complex default, 1m by name, and throws" begin
     for T in (ComplexF64, ComplexF32)
-        kernel = _default_kernel(T)
+        kernel = host_kernel(T)
         @test kernel isa QuasiStrided.PlanarKernel
         @test scalartype(kernel) === T && realtype(kernel) === real(T)
-        @test complex_method(kernel) === PlanarMethod() === QuasiStrided._default_method(T)
-        shape = (mr(kernel), nr(kernel), lanewidth(kernel))
+        @test QuasiStrided.default_kernel_type(T) === PlanarKernel
+        shape = (tile_size(kernel)..., lanewidth(kernel))
         profile = target_profile()
-        @test _planar_pressure(shape...) <= (profile.nregisters > 0 ? profile.nregisters : 16)
-        profile.isa === :avx512 && @test shape === first(kernel_shapes(T, PlanarMethod()))
-        @test _default_kernel(T, 1024, 1024) isa QuasiStrided.PlanarKernel
+        @test planar_pressure(shape...) <= (profile.nregisters > 0 ? profile.nregisters : 16)
+        profile.isa === :avx512 && @test shape === first(kernel_shapes(T, PlanarKernel))
+        @test auto_kernel(T, 1024) isa QuasiStrided.PlanarKernel
         # The small-M demotion: FMAddSub on AVX-512, planar elsewhere.
-        small = _default_kernel(T, 1, 1)
+        small = auto_kernel(T, 1)
         @test small isa (profile.isa === :avx512 ? QuasiStrided.FMAddSubKernel : QuasiStrided.PlanarKernel)
 
-        shape1m = first(kernel_shapes(T, OneMMethod()))
-        k1m = QuasiStrided._kernel_from_shape(shape1m, T, OneMMethod())
-        @test k1m isa QuasiStrided.OneMKernel && complex_method(k1m) === OneMMethod()
-        @test (mr(k1m), nr(k1m), lanewidth(k1m)) === shape1m
-        # A method with no kernel for `T` throws, naming itself.
+        shape1m = first(kernel_shapes(T, OneMKernel))
+        k1m = QuasiStrided.kernel_from_shape(shape1m, T, OneMKernel)
+        @test k1m isa OneMKernel
+        @test (tile_size(k1m)..., lanewidth(k1m)) === shape1m
+        # A kernel type with no menu for `T` throws, naming itself.
         err = try
-            QuasiStrided._kernel_from_shape(shape1m, T, RealMethod())
+            QuasiStrided.kernel_from_shape(shape1m, T, SIMDKernel)
         catch e
             e
         end
         @test err isa ArgumentError
-        @test occursin("RealMethod", err.msg) && occursin(string(T), err.msg)
+        @test occursin("SIMDKernel", err.msg) && occursin(string(T), err.msg)
+    end
+    for T in (ComplexF64, ComplexF32), K in (PlanarKernel, OneMKernel, FMAddSubKernel)
+        for shape in kernel_shapes(T, K)
+            k = kernel_from_shape(shape, T, K)
+            @test k isa K && scalartype(k) === T && (tile_size(k)..., lanewidth(k)) === shape
+        end
+        @test_throws ArgumentError kernel_from_shape((7, 7, 7), T, K)
     end
     for T in (Float16, Int, ComplexF16)
-        @test_throws ArgumentError QuasiStrided._kernel_from_shape((8, 6, 4), T)
+        @test_throws ArgumentError QuasiStrided.kernel_from_shape((8, 6, 4), T)
     end
-    @test_throws ArgumentError QuasiStrided._kernel_from_shape((8, 6, 4), Float64, OneMMethod())
-    @test_throws ArgumentError QuasiStrided._kernel_from_shape((8, 6, 5), Float64)
-    @test_throws ArgumentError QuasiStrided._menu_val((8, 6, 5), Float64, RealMethod())
-    @test QuasiStrided._menu_val((8, 6, 4), Float64, RealMethod()) === Val((8, 6, 4))
+    @test_throws ArgumentError QuasiStrided.kernel_from_shape((8, 6, 4), Float64, OneMKernel)
+    @test_throws ArgumentError QuasiStrided.kernel_from_shape((8, 6, 5), Float64)
+    @test_throws ArgumentError QuasiStrided.menu_val((8, 6, 5), Float64, SIMDKernel)
+    @test QuasiStrided.menu_val((8, 6, 4), Float64, SIMDKernel) === Val(SIMDKernel{8, 6, Float64, 4})
 end
 
-@testset "_small_m_shape: AVX-512 complex small-M demotion to FMAddSub" begin
-    sms(T, Qm, p = synthetic(:avx512, 64)) =
-        QuasiStrided._small_m_shape(QuasiStrided._small_m_candidates(Val(p.isa), p, T), Qm)
+@testset "small_m_shape: AVX-512 complex small-M demotion to FMAddSub" begin
+    sms(T, m_length, p = synthetic(:avx512)) = QuasiStrided.small_m_shape(p, T, m_length)
     # Least padded rows, then the larger tile.
     @test sms(ComplexF64, 12) === (12, 8, 8)
     @test sms(ComplexF64, 16) === (8, 8, 8)
     @test sms(ComplexF64, 20) === (12, 8, 8)
     @test sms(ComplexF32, 12) === (16, 8, 16)
     @test sms(ComplexF32, 16) === (16, 8, 16)
-    for T in (ComplexF64, ComplexF32), Qm in 1:47
-        shape = sms(T, Qm)
-        @test shape in kernel_shapes(T, FMAddSubMethod())
+    for T in (ComplexF64, ComplexF32), m_length in 1:47
+        shape = sms(T, m_length)
+        @test shape in kernel_shapes(T, FMAddSubKernel)
         @test shape[3] == 64 ÷ sizeof(real(T))
     end
     @test sms(Float64, 4) === nothing
     for isakey in (:avx2, :neon, :unknown), T in (ComplexF64, ComplexF32)
-        @test sms(T, 2, synthetic(isakey, 32)) === nothing
+        @test sms(T, 2, synthetic(isakey)) === nothing
     end
 end
 
-@testset "_demote_shape_for_run: largest menu shape whose mr divides the run" begin
-    demote = QuasiStrided._demote_shape_for_run
-    for T in (Float64, Float32), shape in kernel_shapes(T)
-        MR = shape[1]
-        @test demote(T, shape, RealMethod(), 3 * MR, 1000, 1) === shape
-        @test demote(T, shape, RealMethod(), 7, 7, 1) === shape
-        kmax = T === Float64 ? QuasiStrided._RUN_DEMOTE_KMAX_F64 : QuasiStrided._RUN_DEMOTE_KMAX_F32
-        @test demote(T, shape, RealMethod(), 1, 1000, kmax + 1) === shape
-        for run in (1, 4, 8, 12, 16, 20, 24, 48)
-            run % MR == 0 && continue
-            fits = [s for s in kernel_shapes(T) if run % s[1] == 0]
-            want = isempty(fits) ? shape : fits[argmax(first.(fits))]
-            @test demote(T, shape, RealMethod(), run, 1000, 1) === want
+@testset "run-length-aware kernel demotion" begin
+    # ccsd_t_1 with C's leading run exactly `d` and m_length != run, so only
+    # `run % m_tile == 0` avoids demotion. Expectations are derived from the
+    # menu, so this holds on every ISA.
+    d = 16
+    extra = 4
+    IA = (:i, :j, :m, :a)
+    IB = (:m, :k, :b, :c)
+    IC = (:a, :b, :c, :i, :j, :k)
+    (indA, indB, indC), _ = _lo_labels(IA, IB)
+
+    for T in (Float64, Float32)
+        A = randn(T, extra, extra, extra, d)  # (i, j, m, a)
+        B = randn(T, extra, extra, extra, extra)  # (m, k, b, c)
+        C = zeros(T, d, extra, extra, extra, extra, extra)  # (a, b, c, i, j, k)
+        Av, Bv, Cv = StridedView(A), StridedView(B), StridedView(C)
+
+        mlab, nlab, klab = QuasiStrided.classify_labels(indA, indB, indC)
+        msorted = _lo_order(mlab, indC, Cv)
+        run = _lo_run(msorted, indC, Cv)
+        cpos(l) = findfirst(==(l), indC)::Int
+        m_length = prod(size(Cv, cpos(l)) for l in mlab)
+        n_length = prod(size(Cv, cpos(l)) for l in nlab)
+
+        plan = plan_contract(Cv, Av, indA, Bv, indB, indC)
+        @test plan.Astorage === parent(Av)
+
+        default_kernel = auto_kernel(T, m_length)
+        default_m_tile = tile_size(default_kernel, 1)
+        if m_length == run || run % default_m_tile == 0
+            @test plan.kernel === default_kernel
+        else
+            candidates = [sh[1] for sh in QuasiStrided.kernel_shapes(T) if run % sh[1] == 0]
+            if isempty(candidates)
+                @test plan.kernel === default_kernel
+            else
+                @test run % tile_size(plan.kernel, 1) == 0
+                @test tile_size(plan.kernel, 1) == maximum(candidates)
+            end
         end
+
+        Cref = _lo_reference(C, Av, indA, Bv, indB, indC; alpha = 1.3, beta = -0.7)
+        Cex = copy(C)
+        plan_ex = plan_contract(StridedView(Cex), Av, indA, Bv, indB, indC)
+        execute!(plan_ex, 1.3, -0.7)
+        @test Cex ≈ Cref
     end
-    # Complex kernels are never demoted.
-    for T in (ComplexF64, ComplexF32)
-        shape = first(kernel_shapes(T, PlanarMethod()))
-        @test demote(T, shape, PlanarMethod(), 1, 1000, 1) === shape
+
+    # Plain GEMM: `m_length == run`, so no demotion; SIMDKernel is the
+    # engine-wide default, and `contract!` runs the same plan.
+    for T in (Float64, Float32)
+        Ma, Ka, Na = 37, 11, 23
+        Amat = randn(T, Ma, Ka)
+        Bmat = randn(T, Ka, Na)
+        Cmat = zeros(T, Ma, Na)
+        Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
+        plan = plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3))
+        @test plan.kernel isa SIMDKernel && plan.kernel === auto_kernel(T, Ma)
+
+        execute!(plan, one(T), zero(T))
+        @test Cmat ≈ Amat * Bmat
+        C2 = zeros(T, Ma, Na)
+        contract!(StridedView(C2), one(T), Av, (1, 2), Bv, (2, 3), zero(T), (1, 3))
+        @test C2 == Cmat
+    end
+end
+
+@testset "run-length demotion K-depth guard: deep-K does not demote, shallow-K does" begin
+    # C[a,b,c,i,j,k] = A[i,j,m,a] * B[m,k,b,c], i=j=k=b=c=6: k_length = m is swept.
+    IA = (:i, :j, :m, :a)
+    IB = (:m, :k, :b, :c)
+    IC = (:a, :b, :c, :i, :j, :k)
+    (indA, indB, indC), _ = _lo_labels(IA, IB)
+
+    function _run_demote_fixture(::Type{T}, a::Int, m::Int) where {T}
+        i = j = k = b = c = 6
+        A = randn(T, i, j, m, a)
+        B = randn(T, m, k, b, c)
+        C = zeros(T, a, b, c, i, j, k)
+        return StridedView(C), StridedView(A), StridedView(B)
+    end
+
+    kmax_of(::Type{Float64}) = QuasiStrided.RUN_DEMOTE_KMAX_F64
+    kmax_of(::Type{Float32}) = QuasiStrided.RUN_DEMOTE_KMAX_F32
+
+    for (T, a) in ((Float64, 8), (Float32, 16))
+        m_length = a * 36
+        n_length = 216
+        default_kernel = auto_kernel(T, m_length)
+
+        # Deep K never demotes; the fixture never swaps.
+        m_deep = 2 * kmax_of(T)
+        Cv, Av, Bv = _run_demote_fixture(T, a, m_deep)
+        plan_deep = plan_contract(Cv, Av, indA, Bv, indB, indC)
+        @test plan_deep.Astorage === parent(Av)
+        @test plan_deep.kernel === default_kernel
+
+        # Shallow K demotes where the default's `m_tile` breaks the run (ISA-dependent).
+        m_shallow = 8
+        Cv2, Av2, Bv2 = _run_demote_fixture(T, a, m_shallow)
+        plan_shallow = plan_contract(Cv2, Av2, indA, Bv2, indB, indC)
+        @test plan_shallow.Astorage === parent(Av2)
+        mlab, = QuasiStrided.classify_labels(indA, indB, indC)
+        msorted = _lo_order(mlab, indC, Cv2)
+        run = _lo_run(msorted, indC, Cv2)
+        if m_length == run || run % tile_size(default_kernel, 1) == 0
+            @test plan_shallow.kernel === default_kernel
+        else
+            @test plan_shallow.kernel !== default_kernel
+            @test typeof(plan_shallow.kernel) !== typeof(default_kernel)
+            @test run % tile_size(plan_shallow.kernel, 1) == 0
+        end
+
+        # The guard is `k_length > kmax`: `k_length == kmax` may still demote.
+        Cv_b, Av_b, Bv_b = _run_demote_fixture(T, a, kmax_of(T))
+        plan_b = plan_contract(Cv_b, Av_b, indA, Bv_b, indB, indC)
+        run_b = _lo_run(msorted, indC, Cv_b)  # same M order at every m in this fixture
+        if m_length == run_b || run_b % tile_size(default_kernel, 1) == 0
+            @test plan_b.kernel === default_kernel
+        else
+            @test plan_b.kernel !== default_kernel
+        end
+
+        Cv_b1, Av_b1, Bv_b1 = _run_demote_fixture(T, a, kmax_of(T) + 1)
+        plan_b1 = plan_contract(Cv_b1, Av_b1, indA, Bv_b1, indB, indC)
+        @test plan_b1.kernel === default_kernel
     end
 end
diff --git a/test/planning/test_labels.jl b/test/planning/test_labels.jl
new file mode 100644
index 0000000..bf3b916
--- /dev/null
+++ b/test/planning/test_labels.jl
@@ -0,0 +1,425 @@
+include("helpers.jl")
+
+@testset "classify_labels" begin
+    for (indA, indB, indC, want) in (
+            ((1, 2), (2, 3), (1, 3), ((1,), (3,), (2,))),                          # GEMM
+            ((1, 2), (2, 3), (3, 1), ((1,), (3,), (2,))),                          # transposed C
+            ((1, 2, 3, 4), (3, 5, 6, 7), (4, 6, 7, 1, 2, 5), ((1, 2, 4), (5, 6, 7), (3,))),
+            ((1, 2), (3, 1, 4, 5), (3, 2, 4, 5), ((2,), (3, 4, 5), (1,))),
+            ((1, 2, 3, 4), (3, 4, 5, 6), (1, 2, 5, 6), ((1, 2), (5, 6), (3, 4))),
+            ((1,), (1, 2), (2,), ((), (2,), (1,))),                                # no M
+            ((1, 2), (3, 4), (1, 2, 3, 4), ((1, 2), (3, 4), ())),                  # outer product
+        )
+        got = QuasiStrided.classify_labels(indA, indB, indC)
+        @test got === want
+        @test map(length, got) == QuasiStrided.group_ranks(length(indA), length(indB), length(indC))
+    end
+    @test_throws ArgumentError QuasiStrided.classify_labels((1, 1), (1, 2), (1, 2))
+    @test_throws ArgumentError QuasiStrided.classify_labels((1, 2), (2, 3), (1, 2, 3))  # all three
+    @test_throws ArgumentError QuasiStrided.classify_labels((1, 2), (3, 4), (1, 3))     # dangling in A
+    @test_throws ArgumentError QuasiStrided.classify_labels((1, 2), (3, 4), (1, 2, 3, 9))
+end
+
+@testset "label order: order_free_labels sorts by |C-stride|, stably" begin
+    Cv = _lo_view((5, 3, 2, 4), (12, 1, 60, 3))
+    indC = (10, 20, 30, 40)
+    labels = (10, 20, 30, 40)
+    @test _lo_order(labels, indC, Cv) === (20, 40, 10, 30)
+    @test _lo_order((40, 10), indC, Cv) === (40, 10)  # a subset: only its own members
+    @test _lo_order((30, 20), indC, Cv) === (20, 30)
+
+    # Ties keep input order, whichever way the input is given.
+    Ct = _lo_view((2, 3, 4), (1, 1, 1))
+    @test _lo_order((7, 8, 9), (7, 8, 9), Ct) === (7, 8, 9)
+    @test _lo_order((9, 7, 8), (7, 8, 9), Ct) === (9, 7, 8)
+
+    # Negative strides sort by magnitude.
+    Cn = _lo_view((3, 4), (-1, 4))
+    @test _lo_order((20, 10), (10, 20), Cn) === (10, 20)
+    Cn2 = _lo_view((3, 4), (4, -1))
+    @test _lo_order((10, 20), (10, 20), Cn2) === (20, 10)
+
+    @test _lo_order((), indC, Cv) === ()
+    @test _lo_order((30,), indC, Cv) === (30,)
+
+    # Against a stable `sortperm`, randomized.
+    Random.seed!(20260921)
+    for trial in 1:100
+        nd = rand(1:5)
+        C = StridedView(randn(ntuple(_ -> rand(1:4), nd)))
+        st = Base.strides(C)
+        labels = shuffle(collect(1:nd))[1:rand(1:nd)]
+        got = _lo_order(Tuple(labels), ntuple(identity, nd), C)
+        @test got isa NTuple{length(labels), Int}
+        @test collect(got) == labels[sortperm([abs(st[l]) for l in labels]; alg = Base.Sort.DEFAULT_STABLE)]
+    end
+end
+
+@testset "label order: leading_unit_run / prefer_swap" begin
+    d = 4
+    C6 = StridedView(zeros(Float64, d, d, d, d, d, d))  # strides 1, d, d^2, ...
+    indC = (1, 2, 3, 4, 5, 6)                            # a,b,c,i,j,k
+    a, b, c, i, j, k = indC
+
+    @test _lo_run((a, i, j), indC, C6) == d          # ccsd_t_1's sorted M: run stops at i
+    @test _lo_run((a, b, k), indC, C6) == d^2        # ccsd_t_3's sorted N: b is C-adjacent to a
+    @test _lo_run((a, b, c, i, j, k), indC, C6) == d^6
+    @test _lo_run((b, i, j), indC, C6) == 1          # no unit-stride head
+    @test _lo_run((a, c, b), indC, C6) == d          # sorted order is the caller's job
+    @test _lo_run((), indC, C6) == 1
+
+    # A descending axis is not a unit-stride run.
+    @test _lo_run((10, 20), (10, 20), _lo_view((3, 4), (-1, 3))) == 1
+    # Singleton axes are skipped whatever their stride; an empty axis ends it.
+    @test _lo_run((10, 20), (10, 20), _lo_view((1, 6), (5, 1))) == 6
+    @test _lo_run((10, 20), (10, 20), _lo_view((6, 1), (1, 17))) == 6
+    @test _lo_run((10, 20), (10, 20), _lo_view((0, 6), (1, 1))) == 0
+
+    # The swap rule on the ccsd_t shapes at dim 4, with `m_tile` played by hand.
+    # ccsd_t_2: sorted M = (b,i,j) (run 1), sorted N = (a,c,k) (run 4).
+    @test _lo_swap((b, i, j), (a, c, k), indC, C6, 4)        # 4-wide kernel: swap
+    @test !_lo_swap((b, i, j), (a, c, k), indC, C6, 8)       # 8-wide: 4 < 8, do not swap
+    # ccsd_t_3: sorted N = (a,b,k) (run 16): the adjacent label extends it.
+    @test _lo_swap((c, i, j), (a, b, k), indC, C6, 8)
+    @test _lo_swap((c, i, j), (a, b, k), indC, C6, 16)
+    @test !_lo_swap((c, i, j), (a, b, k), indC, C6, 32)
+    # ccsd_t_1: M already has the run; never swap, whatever m_tile says.
+    @test !_lo_swap((a, i, j), (b, c, k), indC, C6, 4)
+    @test !_lo_swap((a, i, j), (b, c, k), indC, C6, 8)
+    # Two-m_tile form: each orientation is judged against the kernel it would run.
+    @test _lo_swap((b, i, j), (a, c, k), indC, C6, 8, 4)
+    @test !_lo_swap((b, i, j), (a, c, k), indC, C6, 8, 8)
+    @test !_lo_swap((a, i, j), (b, c, k), indC, C6, 4, 4)
+    # Nothing to swap onto.
+    @test !_lo_swap((b, i, j), (), indC, C6, 1)
+end
+
+@testset "label order: leading_unit_run's full-coverage condition is a single-map affine_ramp on C's own strides" begin
+    # The whole composite is one run iff C's own single-map group is a unit
+    # ramp. Empty and all-singleton composites are excluded: `affine_ramp`
+    # reports step 0 there while the run is trivially 1.
+    rng = Random.MersenneTwister(0x01E3A3E1)
+    ntested = 0
+    while ntested < 300
+        D = rand(rng, 1:5)
+        indCr = ntuple(identity, D)
+        lens = ntuple(_ -> rand(rng, (1, 2, 3, 5)), D)
+        strides = ntuple(_ -> rand(rng, (-3, -1, 1, 2, 3, 7)), D)
+        Cr = _lo_view(lens, strides)
+        nlabels = rand(rng, 1:D)
+        order = Tuple(Random.shuffle(rng, collect(1:D))[1:nlabels])
+        m_length = prod(lens[l] for l in order)
+        m_length == 1 && continue
+        ntested += 1
+
+        run = QuasiStrided.leading_unit_run(order, indCr, Cr)
+
+        clens = ntuple(d -> lens[order[d]], nlabels)
+        cstrides = ntuple(d -> strides[order[d]], nlabels)
+        cgroup = QuasiStrided.AxisGroup(clens, (cstrides,))
+        (isramp, steps) = QuasiStrided.affine_ramp(cgroup)
+
+        @test (run == m_length) == (isramp && steps[1] == 1)
+    end
+end
+
+@testset "label order: pinning test on the ccsd_t shapes (composite order and swap)" begin
+    d = 5
+    for (name, IA, IB) in LO_CASES
+        (indA, indB, indC), _ = _lo_labels(IA, IB)
+        A = randn(d, d, d, d)
+        B = randn(d, d, d, d)
+        C = zeros(d, d, d, d, d, d)
+        Av, Bv, Cv = StridedView(A), StridedView(B), StridedView(C)
+        cst = Base.strides(Cv)
+        cstride(l) = cst[findfirst(==(l), indC)]
+        mlab, nlab, klab = QuasiStrided.classify_labels(indA, indB, indC)
+        @test length(klab) == 1
+        kA = Base.strides(Av)[findfirst(==(klab[1]), indA)]
+        kB = Base.strides(Bv)[findfirst(==(klab[1]), indB)]
+
+        msorted = Tuple(sort(collect(mlab); by = cstride))
+        nsorted = Tuple(sort(collect(nlab); by = cstride))
+        @test _lo_order(mlab, indC, Cv) == msorted
+        @test _lo_order(nlab, indC, Cv) == nsorted
+        mrun = _lo_run(msorted, indC, Cv)
+        nrun = _lo_run(nsorted, indC, Cv)
+        # ccsd_t_1 carries C's unit axis on A (run d); the others carry it on B.
+        @test (name == "ccsd_t_1") == (mrun == d)
+        @test nrun == (name == "ccsd_t_1" ? 1 : name == "ccsd_t_3" ? d^2 : d)
+
+        # Named kernels, host-independent: m_tile = 4 swaps 2/3/4, m_tile = 8 only 3.
+        for (kernel, expect_swap) in (
+                (ScalarKernel(Val(4), Val(3), Float64), name != "ccsd_t_1"),
+                (SIMDKernel(Val(8), Val(6), Float64), name == "ccsd_t_3"),
+            )
+            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel)
+            swapped = plan.Astorage === parent(Bv)
+            @test swapped == expect_swap
+            @test swapped == _lo_swap(msorted, nsorted, indC, Cv, tile_size(kernel, 1))
+            if swapped
+                # B feeds M: mgroup's maps are (B, C) over the sorted N labels.
+                @test plan.mgroup.strides[2] == Tuple(cstride(l) for l in nsorted)
+                @test plan.ngroup.strides[2] == Tuple(cstride(l) for l in msorted)
+                @test plan.kgroup.strides == ((kB,), (kA,))
+                @test plan.Bstorage === parent(Av)
+                @test plan.Abase == offset(Bv) && plan.Bbase == offset(Av)
+            else
+                @test plan.mgroup.strides[2] == Tuple(cstride(l) for l in msorted)
+                @test plan.ngroup.strides[2] == Tuple(cstride(l) for l in nsorted)
+                @test plan.kgroup.strides == ((kA,), (kB,))
+                @test plan.Bstorage === parent(Bv)
+            end
+            # The C map of each composite is ascending, whichever operand fed it.
+            @test issorted(abs.(plan.mgroup.strides[2]))
+            @test issorted(abs.(plan.ngroup.strides[2]))
+            @test plan.mgroup.lengths == ntuple(_ -> d, 3)
+            @test plan.ngroup.lengths == ntuple(_ -> d, 3)
+        end
+
+        # Default kernel: the same rule at this machine's `m_tile`.
+        plan = plan_contract(Cv, Av, indA, Bv, indB, indC)
+        m_tile = tile_size(plan.kernel, 1)
+        @test (plan.Astorage === parent(Bv)) == (mrun < m_tile && nrun >= m_tile)
+    end
+end
+
+@testset "label order: plain matmul is unchanged; a transposed output swaps" begin
+    Ma, Ka, Na = 9, 4, 12
+    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
+    kernel = SIMDKernel(Val(8), Val(6), Float64)
+    # One view per operand: on Julia 1.10 `parent` of two fresh views of the
+    # same array need not be `===`.
+    Av, Bv = StridedView(Amat), StridedView(Bmat)
+
+    Cmat = zeros(Ma, Na)
+    p = plan_contract(StridedView(Cmat), Av, (1, 2), Bv, (2, 3), (1, 3); kernel = kernel)
+    @test p.Astorage === parent(Av)
+    @test p.mgroup.strides == ((1,), (1,))
+    @test p.ngroup.strides == ((Ka,), (Ma,))
+    execute!(p, 1.0, 0.0)
+    @test Cmat ≈ Amat * Bmat
+
+    # Into C's transpose: N's 12-wide run >= m_tile = 8, so B feeds M.
+    Ct = zeros(Na, Ma)
+    pt = plan_contract(StridedView(Ct), Av, (1, 2), Bv, (2, 3), (3, 1); kernel = kernel)
+    @test pt.Astorage === parent(Bv)
+    @test pt.mgroup.strides == ((Ka,), (1,))      # (B, C) maps over label 3
+    @test pt.ngroup.strides == ((1,), (Na,))      # (A, C) maps over label 1
+    @test pt.kgroup.strides == ((1,), (Ma,))      # (B, A) maps over label 2
+    execute!(pt, 1.0, 0.0)
+    @test Ct ≈ transpose(Amat * Bmat)
+    # ... but not when the run is too short for the kernel.
+    Ct2 = zeros(6, Ma)
+    Bv6 = StridedView(Bmat[:, 1:6])
+    pt2 = plan_contract(StridedView(Ct2), Av, (1, 2), Bv6, (2, 3), (3, 1); kernel = kernel)
+    @test pt2.Astorage === parent(Av)
+end
+
+@testset "label order: correctness on ccsd_t shapes, permuted/sliced C, alpha/beta, conj" begin
+    Random.seed!(0x1ABE_10DE)
+    d = 6
+    # C is a sliced, permuted view of a padded (c, k, a, j, b, i) array.
+    perm = (3, 5, 1, 6, 4, 2)  # output axis p takes physical axis perm[p]
+    for T in (Float64, ComplexF64)
+        rtol = 200 * d * eps(real(T))
+        for (name, IA, IB) in LO_CASES, (conjA, conjB) in ((false, false), (true, true))
+            (T <: Real) && conjA && continue  # conj is the identity on the real path
+            (indA, indB, indC), (pA, pB, pAB) = _lo_labels(IA, IB)
+            A = randn(T, d, d, d, d)
+            B = randn(T, d, d, d, d)
+            Av = conjA ? StridedView(A, size(A), strides(A), 0, conj) : StridedView(A)
+            Bv = StridedView(B)
+            Cbig = randn(T, d + 1, d + 2, d, d + 1, d, d + 3)
+            Csub = view(Cbig, 1:d, 2:(d + 1), :, 2:(d + 1), :, 3:(d + 2))
+            Cv = permutedims(StridedView(Csub), perm)
+            @test offset(Cv) != 0
+            @test !issorted(Base.strides(Cv))
+            Cstart = copy(Cv)
+            alpha = T <: Complex ? T(1.3, -0.4) : T(1.3)
+            beta = T <: Complex ? T(0.7, 0.2) : T(0.7)
+
+            Cref = _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA, conjB, alpha, beta)
+
+            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; conjA = conjA, conjB = conjB)
+            execute!(plan, alpha, beta)
+            @test isapprox(copy(Cv), Cref; rtol = rtol)
+        end
+    end
+end
+
+@testset "label order: the swap never fires for complex kernels (guarded by T <: Real, deliberately deferred)" begin
+    # ccsd_t_3 would swap for a real dtype at this m_tile; the transforms follow
+    # the flag XOR A's `conj` op.
+    d = 4
+    for T in (ComplexF64, ComplexF32)
+        W = QuasiStrided.default_lanewidth(real(T))
+        kernel = QuasiStrided.PlanarKernel(Val(W), Val(8), T, Val(W))
+        @test tile_size(kernel, 1) <= 16
+        (indA, indB, indC), _ = _lo_labels(LO_CASES[3][2], LO_CASES[3][3])
+        A = randn(T, d, d, d, d)
+        B = randn(T, d, d, d, d)
+        C = randn(T, d, d, d, d, d, d)
+        Av = StridedView(A, size(A), strides(A), 0, conj)
+        Bv = StridedView(B)
+        Cv = StridedView(C)
+        alpha, beta = T(0.5, 1.5), T(-1.0, 0.25)
+        for (conjA, conjB) in ((true, true), (true, false), (false, true))
+            Cstart = copy(C)
+            Cref = _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA, conjB, alpha, beta)
+            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, conjA = conjA, conjB = conjB)
+            @test plan.Astorage === parent(Av)   # the swap did NOT fire (complex)
+            @test plan.atransform === (conjA ? identity : conj)
+            @test plan.btransform === (conjB ? conj : identity)
+            execute!(plan, alpha, beta)
+            @test isapprox(C, Cref; rtol = 200 * d * eps(real(T)))
+            copyto!(C, Cstart)
+        end
+    end
+end
+
+@testset "label order: the adapter path reaches the reordered plan" begin
+    d = 6
+    for (name, IA, IB) in LO_CASES
+        (indA, indB, indC), (pA, pB, pAB) = _lo_labels(IA, IB)
+        A, B, C = randn(d, d, d, d), randn(d, d, d, d), randn(d, d, d, d, d, d)
+        Cref = _lo_reference(C, StridedView(A), indA, StridedView(B), indB, indC; alpha = 0.9, beta = -0.5)
+        TO.tensorcontract!(C, A, pA, false, B, pB, false, pAB, 0.9, -0.5, QuasiStrided.QuasiStridedBackend())
+        @test isapprox(C, Cref; rtol = 200 * d * eps())
+    end
+end
+
+# Contracted-label order. Labels a=1 b=2 c=3 d=4 e=5 with distinct extents.
+# `KO_EXT` fits any L2; `KO_BIG` makes B's lines touched before `d` advances
+# (b*c*e*64 B) exceed THIS host's L2 share, with e >= 40, so the model reorders
+# K wherever the suite runs.
+function _ko_big(l2 = QuasiStrided.l2_core_bytes(target_profile()))
+    e = max(40, fld(l2, 40 * 40 * 64) + 1)
+    return Dict(1 => 9, 2 => 40, 3 => 40, 4 => 5, 5 => e)
+end
+const KO_EXT = Dict(1 => 9, 2 => 3, 3 => 4, 4 => 5, 5 => 6)
+const KO_BIG = _ko_big()
+_ko_array(::Type{T}, ind, ext = KO_EXT) where {T} = randn(T, Tuple(ext[l] for l in ind)...)
+_ko_stride(v, ind, l) = Base.strides(v)[findfirst(==(l), ind)]
+
+function _ko_order(Av, indA, Bv, indB, Cv, indC; l2bytes)
+    mlabels, nlabels, klabels = QuasiStrided.classify_labels(indA, indB, indC)
+    morder = QuasiStrided.order_free_labels(mlabels, indC, Cv)
+    norder = QuasiStrided.order_free_labels(nlabels, indC, Cv)
+    ext(ls) = prod((size(Cv, findfirst(==(l), indC)) for l in ls); init = 1)
+    return QuasiStrided.order_contract_labels(
+        klabels, indA, Av, morder, indB, Bv, norder, ext(mlabels), ext(nlabels), l2bytes
+    )
+end
+
+@testset "K order: cost model picks among indA / A-sorted / B-sorted" begin
+    T = Float64
+    Av = StridedView(_ko_array(T, (1, 2, 3, 4)))   # A[a,b,c,d]: a unit-stride, 9 >= a line
+    Cv = StridedView(zeros(T, KO_EXT[1], KO_EXT[5]))
+
+    # contract_scrambled, B[d,c,b,e]: B-sorted once the lines in flight exceed L2.
+    Bs = StridedView(_ko_array(T, (4, 3, 2, 5)))
+    @test _ko_order(Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), Cv, (1, 5); l2bytes = 0) == (4, 3, 2)
+    @test _ko_order(Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), Cv, (1, 5); l2bytes = 1 << 20) == (2, 3, 4)
+
+    # gemm_ready B[b,c,d,e] and b_permuted B[b,e,c,d]: B-sorted == indA order.
+    for indB in ((2, 3, 4, 5), (2, 5, 3, 4))
+        Bv = StridedView(_ko_array(T, indB))
+        @test _ko_order(Av, (1, 2, 3, 4), Bv, indB, Cv, (1, 5); l2bytes = 0) == (2, 3, 4)
+    end
+
+    # TRG-shaped: sorting by B would give A a page-crossing K walk to save
+    # refetches of a small B, so indA order stays.
+    At = StridedView(randn(T, 8, 8, 8, 8, 8))
+    Bt = StridedView(randn(T, 8, 8, 8))
+    Ct = StridedView(zeros(T, 8, 8, 8, 8))
+    for l2bytes in (0, 1 << 20)
+        @test _ko_order(At, (1, 2, 3, 4, 5), Bt, (5, 6, 2), Ct, (1, 3, 4, 6); l2bytes) == (2, 5)
+    end
+
+    p = plan_contract(StridedView(zeros(T, 3, 5)), StridedView(randn(T, 3, 4)), (1, 2), StridedView(randn(T, 4, 5)), (2, 3), (1, 3))
+    @test p.kgroup.strides == ((3,), (1,))
+    # A singleton K axis is skipped as `kfast` and as `u`.
+    A1 = StridedView(randn(T, 9, 1, 4, 5))
+    B1 = StridedView(randn(T, 1, 5, 4, 6))
+    o = _ko_order(A1, (1, 2, 3, 4), B1, (2, 4, 3, 5), Cv, (1, 5); l2bytes = 0)
+    @test sort(collect(o)) == [2, 3, 4]
+    @test filter(!=(2), o) == (4, 3)  # B-sorted among the non-singletons
+end
+
+@testset "K order: static-length tuple, inferred, allocation-free" begin
+    T = Float64
+    ext = KO_BIG
+    Av = StridedView(_ko_array(T, (1, 2, 3, 4), ext))
+    Bs = StridedView(_ko_array(T, (4, 3, 2, 5), ext))
+    Cv = StridedView(zeros(T, ext[1], ext[5]))
+    klabels, morder, norder = (2, 3, 4), (1,), (5,)
+    f(l2) = QuasiStrided.order_contract_labels(klabels, (1, 2, 3, 4), Av, morder, (4, 3, 2, 5), Bs, norder, ext[1], ext[5], l2)
+    g() = QuasiStrided.order_contract_labels(klabels, (1, 2, 3, 4), Av, morder, (4, 3, 2, 5), Bs, norder, ext[1], ext[5])
+    @test @inferred(f(0)) === (4, 3, 2)
+    @test @inferred(g()) isa NTuple{3, Int}
+    f(0); g()
+    @test (@allocated f(0)) == 0 skip = (VERSION < v"1.11")
+    @test (@allocated g()) == 0 skip = (VERSION < v"1.11")
+    h1() = QuasiStrided.order_contract_labels((2,), (1, 2), Av, (1,), (2, 5), Bs, (5,), 9, 40)
+    h0() = QuasiStrided.order_contract_labels((), (1,), Av, (1,), (5,), Bs, (5,), 9, 40)
+    @test @inferred(h1()) === (2,)
+    @test @inferred(h0()) === ()
+end
+
+@testset "K order: plan_contract flips contract_scrambled at an L2-exceeding size" begin
+    T = Float64
+    ext = KO_BIG
+    @test ext[2] * ext[3] * ext[5] * 64 > QuasiStrided.l2_core_bytes(target_profile())
+    Av = StridedView(_ko_array(T, (1, 2, 3, 4), ext))
+    Bs = StridedView(_ko_array(T, (4, 3, 2, 5), ext))   # B[d,c,b,e]
+    Cv = StridedView(zeros(T, ext[1], ext[5]))
+    plan = plan_contract(Cv, Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), (1, 5))
+    @test plan.kgroup.lengths == (5, 40, 40)
+    @test plan.kgroup.strides[2] == (1, 5, 200)
+    @test plan.kgroup.strides[1] == Tuple(_ko_stride(Av, (1, 2, 3, 4), l) for l in (4, 3, 2))
+
+    # gemm_ready at the same size keeps indA order.
+    Bg = StridedView(_ko_array(T, (2, 3, 4, 5), ext))
+    p = plan_contract(Cv, Av, (1, 2, 3, 4), Bg, (2, 3, 4, 5), (1, 5))
+    @test p.kgroup.lengths == (40, 40, 5)
+    @test p.kgroup.strides[1] == (9, 360, 14400)
+
+    # Swapped (C stored as (e, a)): the same K order with the maps exchanged.
+    Ct = StridedView(zeros(T, ext[5], ext[1]))
+    kernel = SIMDKernel(Val(8), Val(6), T)
+    pt = plan_contract(Ct, Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), (5, 1); kernel = kernel)
+    @test pt.Astorage === parent(Bs)
+    @test pt.kgroup.lengths == (5, 40, 40)
+    @test pt.kgroup.strides[1] == (1, 5, 200)                     # B's map first
+    @test pt.kgroup.strides[2] == (14400, 360, 9)                 # then A's
+end
+
+@testset "K order: correctness on scrambled K (alpha/beta, conj, both orientations)" begin
+    Random.seed!(0x5C7A_0B1E)
+    ext = KO_BIG
+    for T in (Float64, ComplexF64)
+        rtol = 500 * eps(real(T))
+        alpha = T <: Complex ? T(1.3, -0.4) : T(1.3)
+        beta = T <: Complex ? T(0.7, 0.2) : T(0.7)
+        for (indA, indB, indC) in (
+                    ((1, 2, 3, 4), (4, 3, 2, 5), (1, 5)),   # scrambled, C[a,e] (reordered K)
+                    ((1, 2, 3, 4), (4, 3, 2, 5), (5, 1)),   # scrambled, C[e,a] (swap for real T)
+                    ((4, 3, 2, 1), (2, 3, 4, 5), (1, 5)),   # A transposed, K inner in both
+                    ((4, 3, 2, 1), (3, 2, 4, 5), (5, 1)),   # both scrambled, C transposed
+                ), (conjA, conjB) in ((false, false), (true, true))
+            (T <: Real) && conjA && continue
+            A = _ko_array(T, indA, ext)
+            B = _ko_array(T, indB, ext)
+            Av = conjA ? StridedView(A, size(A), strides(A), 0, conj) : StridedView(A)
+            Bv = StridedView(B)
+            C = randn(T, Tuple(ext[l] for l in indC)...)
+            Cstart = copy(C)
+            Cv = StridedView(C)
+            Cref = _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA, conjB, alpha, beta)
+            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; conjA = conjA, conjB = conjB)
+            execute!(plan, alpha, beta)
+            @test isapprox(C, Cref; rtol = rtol)
+        end
+    end
+end
diff --git a/test/planning/test_per_call_overhead.jl b/test/planning/test_per_call_overhead.jl
deleted file mode 100644
index 7722866..0000000
--- a/test/planning/test_per_call_overhead.jl
+++ /dev/null
@@ -1,546 +0,0 @@
-# Planning helpers, the once-per-macro-block storage-bounds check, and the
-# closed-form (`affine_ramp`) block description against the buffer path.
-
-using StridedViews: StridedView, offset
-
-const QS = QuasiStrided
-const _pcf_plan = QuasiStrided.plan_contract
-const _pcf_exec = QuasiStrided.execute!
-const _pcf_exec_tw = QuasiStrided.execute_tilewise!
-const _pcf_Plan = QuasiStrided.ContractPlan
-
-@testset "per-call floor: _classify_labels" begin
-    for (indA, indB, indC, want) in (
-            ((1, 2), (2, 3), (1, 3), ((1,), (3,), (2,))),                          # GEMM
-            ((1, 2), (2, 3), (3, 1), ((1,), (3,), (2,))),                          # transposed C
-            ((1, 2, 3, 4), (3, 5, 6, 7), (4, 6, 7, 1, 2, 5), ((1, 2, 4), (5, 6, 7), (3,))),
-            ((1, 2), (3, 1, 4, 5), (3, 2, 4, 5), ((2,), (3, 4, 5), (1,))),
-            ((1, 2, 3, 4), (3, 4, 5, 6), (1, 2, 5, 6), ((1, 2), (5, 6), (3, 4))),
-            ((1,), (1, 2), (2,), ((), (2,), (1,))),                                # no M
-            ((1, 2), (3, 4), (1, 2, 3, 4), ((1, 2), (3, 4), ())),                  # outer product
-        )
-        got = QS._classify_labels(indA, indB, indC)
-        @test got === want
-        @test map(length, got) == QS._group_ranks(length(indA), length(indB), length(indC))
-    end
-    @test_throws ArgumentError QS._classify_labels((1, 1), (1, 2), (1, 2))
-    @test_throws ArgumentError QS._classify_labels((1, 2), (2, 3), (1, 2, 3))  # all three
-    @test_throws ArgumentError QS._classify_labels((1, 2), (3, 4), (1, 3))     # dangling in A
-    @test_throws ArgumentError QS._classify_labels((1, 2), (3, 4), (1, 2, 3, 9))
-end
-
-@testset "per-call floor: _build_pair_group matches a direct construction" begin
-    Random.seed!(1234)
-    for trial in 1:60
-        nd1 = rand(1:4)
-        nd2 = rand(nd1:5)
-        shared = rand(1:nd1)                      # how many labels the group has
-        dims1 = ntuple(_ -> rand(1:4), nd1)
-        v1 = StridedView(randn(dims1))
-        ind1 = ntuple(identity, nd1)
-        labels = shuffle(collect(ind1))[1:shared]
-        # v2 carries the same labels (same lengths) plus filler.
-        ind2 = (labels..., ntuple(d -> 100 + d, nd2 - shared)...)
-        dims2 = (
-            ntuple(d -> size(v1, findfirst(==(labels[d]), ind1)::Int), shared)...,
-            ntuple(_ -> rand(1:4), nd2 - shared)...,
-        )
-        v2 = StridedView(randn(dims2))
-
-        g = QS._build_pair_group(Tuple(labels), ind1, v1, ind2, v2)
-        s1 = Base.strides(v1)
-        s2 = Base.strides(v2)
-        p1 = ntuple(d -> findfirst(==(labels[d]), ind1)::Int, shared)
-        p2 = ntuple(d -> findfirst(==(labels[d]), ind2)::Int, shared)
-        @test g.lengths == ntuple(d -> size(v1, p1[d]), shared)
-        @test g.strides[1] == ntuple(d -> s1[p1[d]], shared)
-        @test g.strides[2] == ntuple(d -> s2[p2[d]], shared)
-        @test g isa AxisGroup{shared, 2}
-        @test isconcretetype(typeof(g))
-        @test Base.return_types(
-            QS._build_pair_group, (typeof(Tuple(labels)), typeof(ind1), typeof(v1), typeof(ind2), typeof(v2))
-        ) == [AxisGroup{shared, 2}]
-    end
-
-    v1 = StridedView(randn(3, 4))
-    v2 = StridedView(randn(5, 4))
-    @test_throws DimensionMismatch QS._build_pair_group((1,), (1, 2), v1, (1, 2), v2)
-
-    # Rank zero: an outer product's K group.
-    g0 = QS._build_pair_group((), (1, 2), v1, (1, 2), v2)
-    @test g0 isa AxisGroup{0, 2}
-    @test axis_length(g0) == 1
-end
-
-@testset "per-call floor: plan_contract allocation stays under a ceiling" begin
-    # A ceiling that a `Set`/`Vector`-based planner would exceed several-fold.
-    A = randn(64, 64); B = randn(64, 64); C = zeros(64, 64)
-    Av, Bv, Cv = StridedView(A), StridedView(B), StridedView(C)
-    p = _pcf_plan(Cv, Av, (1, 2), Bv, (2, 3), (1, 3))
-    ws = p.workspace
-    f() = _pcf_plan(Cv, Av, (1, 2), Bv, (2, 3), (1, 3); workspace = ws)
-    f()
-    @test (@allocated f()) <= 3000
-end
-
-@testset "per-call floor: checked_span_bounds is equivalent to the per-tile check" begin
-    # For a region split into slivers, checking the union range once accepts
-    # exactly what checking each sliver accepts.
-    Random.seed!(99)
-    for trial in 1:150
-        nrow = rand(1:9)
-        ncol = rand(1:5)
-        rowoffs = [rand(-20:20) for _ in 1:nrow]
-        coloffs = [rand(-20:20) for _ in 1:ncol]
-        base = rand(-5:30)
-        len = rand(1:60)
-        reg = rand(1:4)                      # sliver height
-        nsliv = cld(nrow, reg)
-
-        cols = ScatterAxis(coloffs, ncol)
-        persliver = true
-        for s in 0:(nsliv - 1)
-            first = s * reg
-            cnt = min(reg, nrow - first)
-            rows = ScatterAxis(view(rowoffs, (first + 1):(first + cnt)), cnt)
-            ok = try
-                checked_tile_storage_bounds(base, rows, cols, len)
-                true
-            catch e
-                e isa BoundsError || rethrow()
-                false
-            end
-            persliver &= ok
-        end
-
-        blockrange = (minimum(rowoffs), maximum(rowoffs))
-        colrange = (minimum(coloffs), maximum(coloffs))
-        blockok = try
-            QS.checked_span_bounds(base, blockrange, colrange, len)
-            true
-        catch e
-            e isa BoundsError || rethrow()
-            false
-        end
-        @test blockok == persliver
-    end
-
-    @test QS.checked_span_bounds(0, (0, -1), (0, 0), 1) === nothing
-    @test QS.checked_span_bounds(0, (0, 0), (0, -1), 1) === nothing
-    @test_throws BoundsError QS.checked_span_bounds(0, (0, 0), (0, 0), 0)
-end
-
-@testset "per-call floor: _classify_slivers! accumulates the TRUE block range" begin
-    # The range handed to `checked_span_bounds` is the true min/max over the
-    # whole block; a too-small range would silently under-validate.
-    Random.seed!(20260922)
-    for trial in 1:150
-        blocklen = rand(1:24)
-        reg = rand(1:5)
-        nsliv = cld(blocklen, reg)
-        buf1 = [rand(-40:40) for _ in 1:blocklen]
-        buf2 = [rand(-40:40) for _ in 1:blocklen]
-        d1 = Vector{BlockDescriptor}(undef, nsliv)
-        d2 = Vector{BlockDescriptor}(undef, nsliv)
-        (r1, r2) = QS._classify_slivers!(d1, d2, buf1, buf2, blocklen, reg, nsliv)
-        @test r1 == (minimum(buf1), maximum(buf1))
-        @test r2 == (minimum(buf2), maximum(buf2))
-        @test all(s -> d1[s].count == min(reg, blocklen - (s - 1) * reg), 1:nsliv)
-    end
-
-    # Both extremes in an interior sliver.
-    blocklen, reg = 18, 6                      # slivers 1:6, 7:12, 13:18
-    buf1 = fill(1, blocklen); buf1[8] = 500; buf1[9] = -500   # sliver 2, irregular
-    buf2 = fill(2, blocklen)
-    buf2[7:12] .= [0, -7, -14, -21, -28, -35]                 # sliver 2, REGULAR, stride -7
-    d1 = Vector{BlockDescriptor}(undef, 3)
-    d2 = Vector{BlockDescriptor}(undef, 3)
-    (r1, r2) = QS._classify_slivers!(d1, d2, buf1, buf2, blocklen, reg, 3)
-    @test !d1[2].regular && d1[2].count == 6        # scan branch
-    @test d2[2].regular && d2[2].stride == -7       # affine branch, negative stride
-    @test r1 == (-500, 500)
-    @test r2 == (-35, 2)
-    @test QS.descriptor_offset_range(d1[1], buf1, 0) == (1, 1)
-    @test QS.descriptor_offset_range(d1[3], buf1, 12) == (1, 1)
-end
-
-@testset "per-call floor: descriptor_offset_range agrees with axis_offset_range" begin
-    Random.seed!(7)
-    for trial in 1:100
-        n = rand(1:8)
-        buf = [rand(-30:30) for _ in 1:n]
-        rand() < 0.4 && (buf = [3 + 5 * (t - 1) for t in 1:n])   # force a regular run
-        d = describe_block(buf, 0, n)
-        ax = QS._axis_of(d, buf, 0)
-        @test QS.descriptor_offset_range(d, buf, 0) == axis_offset_range(ax)
-    end
-    @test QS.descriptor_offset_range(BlockDescriptor(0, 0, 0, true), Int[], 0) == (0, -1)
-end
-
-# Counts `length` calls: the hoisted bounds check asks once per operand per
-# block, a per-tile check once per tile. Not a `DenseVector`, so the fast paths
-# stay off.
-mutable struct CountingStorage{T} <: AbstractVector{T}
-    data::Vector{T}
-    n::Int
-end
-CountingStorage(v::Vector{T}) where {T} = CountingStorage{T}(v, 0)
-Base.size(c::CountingStorage) = size(c.data)
-Base.length(c::CountingStorage) = (c.n += 1; length(c.data))
-Base.@propagate_inbounds Base.getindex(c::CountingStorage, i::Int) = c.data[i]
-Base.@propagate_inbounds Base.setindex!(c::CountingStorage, v, i::Int) = (c.data[i] = v)
-Base.IndexStyle(::Type{<:CountingStorage}) = IndexLinear()
-
-@testset "per-call floor: the destination bounds check runs once per macro block" begin
-    Ma, Ka, Na = 40, 7, 30
-    kernel = SIMDKernel(Val(8), Val(6), Float64)
-    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-    Cmat = zeros(Ma, Na)
-    base = _pcf_plan(
-        StridedView(Cmat), StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3),
-        (1, 3); kernel = kernel
-    )
-
-    # One (jc, pc, ic) block, so the hoisted checks run once.
-    @test base.blocking.mc >= Ma && base.blocking.nc >= Na && base.blocking.kc >= Ka
-    m_slivers = cld(Ma, mr(kernel))
-    n_slivers = cld(Na, nr(kernel))
-    ntiles = m_slivers * n_slivers
-    @test ntiles >= 20   # a per-tile check would be at least this many calls
-
-    cstore = CountingStorage(zeros(Ma * Na))
-    astore = CountingStorage(copy(vec(Amat)))
-    bstore = CountingStorage(copy(vec(Bmat)))
-    p = _pcf_Plan(
-        base.kernel, base.mgroup, base.ngroup, base.kgroup, base.blocking,
-        astore, 0, bstore, 0, cstore, 0,
-        base.atransform, base.btransform, base.workspace, base.mpack, base.npack,
-    )
-    astore.n = 0; bstore.n = 0; cstore.n = 0
-    _pcf_exec(p, 1.0, 0.0)
-    @test reshape(cstore.data, Ma, Na) ≈ Amat * Bmat
-
-    @test cstore.n == 1
-    @test astore.n == 1
-    @test bstore.n == 1
-
-    # The oracle checks per tile.
-    fill!(cstore.data, 0.0)
-    astore.n = 0; bstore.n = 0; cstore.n = 0
-    _pcf_exec_tw(p, 1.0, 0.0)
-    @test reshape(cstore.data, Ma, Na) ≈ Amat * Bmat
-    @test cstore.n >= ntiles
-end
-
-@testset "per-call floor: a block that must be rejected is still rejected" begin
-    Ma, Ka, Na = 40, 7, 30
-    kernel = SIMDKernel(Val(8), Val(6), Float64)
-    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-    Cmat = zeros(Ma, Na)
-    base = _pcf_plan(
-        StridedView(Cmat), StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3),
-        (1, 3); kernel = kernel
-    )
-
-    function replan(;
-            Cstorage = vec(Cmat), Astorage = vec(Amat), Bstorage = vec(Bmat),
-            Cbase = 0, Abase = 0, Bbase = 0
-        )
-        return _pcf_Plan(
-            base.kernel, base.mgroup, base.ngroup, base.kgroup, base.blocking,
-            Astorage, Abase, Bstorage, Bbase, Cstorage, Cbase,
-            base.atransform, base.btransform, base.workspace, base.mpack, base.npack,
-        )
-    end
-
-    # One element short: rejected before anything is written.
-    short_C = zeros(Ma * Na - 1)
-    @test_throws BoundsError _pcf_exec(replan(Cstorage = short_C), 1.0, 0.0)
-    @test all(iszero, short_C)
-    @test_throws BoundsError _pcf_exec_tw(replan(Cstorage = short_C), 1.0, 0.0)
-
-    @test_throws BoundsError _pcf_exec(replan(Cbase = -1), 1.0, 0.0)
-
-    @test_throws BoundsError _pcf_exec(replan(Astorage = zeros(Ma * Ka - 1)), 1.0, 0.0)
-    @test_throws BoundsError _pcf_exec(replan(Bstorage = zeros(Ka * Na - 1)), 1.0, 0.0)
-    @test_throws BoundsError _pcf_exec(replan(Abase = -1), 1.0, 0.0)
-    @test_throws BoundsError _pcf_exec(replan(Bbase = -1), 1.0, 0.0)
-
-    exact = zeros(Ma * Na)
-    _pcf_exec(replan(Cstorage = exact), 1.0, 0.0)
-    @test reshape(exact, Ma, Na) ≈ Amat * Bmat
-end
-
-@testset "per-call floor: rejection when the binding address is in an INTERIOR sliver" begin
-    # C[m,n1,n2] = A[m,k] * B[k,n1,n2] with C reversed along n2: the N
-    # offsets climb within each n1 run and fall at its boundary, so the block
-    # maximum sits in an interior, irregular sliver (2 of 7).
-    M, K, N1, N2 = 20, 4, 13, 3
-    kernel = SIMDKernel(Val(8), Val(6), Float64)
-    Amat = randn(M, K)
-    Barr = randn(K, N1, N2)
-    Cfull = zeros(M, N1, N2)
-    Cr = view(Cfull, :, :, N2:-1:1)
-    Av, Bv, Cv = StridedView(Amat), StridedView(Barr), StridedView(Cr)
-
-    base = _pcf_plan(Cv, Av, (1, 2), Bv, (2, 3, 4), (1, 3, 4); kernel = kernel)
-    @test base.Astorage === parent(Av)                   # no M/N swap: M's run is 20 >= 8
-    @test !first(QS.affine_ramp(base.ngroup))            # the buffer path, not the ramp path
-    Qn = axis_length(base.ngroup)
-    @test Qn == N1 * N2
-    @test base.blocking.nc >= Qn                         # one jc block, so 7 slivers
-    nsliv = cld(Qn, nr(kernel))
-    @test nsliv == 7
-
-    noffs = [offsets(base.ngroup, q)[2] for q in 0:(Qn - 1)]
-    binding = argmax(noffs) - 1                          # zero-based logical coordinate
-    @test binding == N1 - 1
-    @test 0 < binding ÷ nr(kernel) < nsliv - 1           # a strictly interior sliver
-    @test maximum(noffs[1:nr(kernel)]) < noffs[binding + 1]                 # not the first
-    @test maximum(noffs[(1 + (nsliv - 1) * nr(kernel)):end]) < noffs[binding + 1]  # not the last
-
-    _pcf_exec(base, 1.0, 0.0)
-    ref = zeros(M, N1, N2)
-    for m in 1:M, n1 in 1:N1, n2 in 1:N2
-        ref[m, n1, n2] = sum(Amat[m, k] * Barr[k, n1, n2] for k in 1:K)
-    end
-    @test Cr ≈ ref
-
-    # One element short: only the address at `binding` overflows.
-    short_C = zeros(M * N1 * N2 - 1)
-    pshort = _pcf_Plan(
-        base.kernel, base.mgroup, base.ngroup, base.kgroup, base.blocking,
-        base.Astorage, base.Abase, base.Bstorage, base.Bbase, short_C, base.Cbase,
-        base.atransform, base.btransform, base.workspace, base.mpack, base.npack,
-    )
-    @test_throws BoundsError _pcf_exec(pshort, 1.0, 0.0)
-    @test all(iszero, short_C)                            # nothing written before the throw
-
-    # A first- or last-sliver-only range would accept it.
-    moffs = [offsets(base.mgroup, q)[2] for q in 0:(axis_length(base.mgroup) - 1)]
-    mrange = (minimum(moffs), maximum(moffs))
-    NR = nr(kernel)
-    truerange = (minimum(noffs), maximum(noffs))
-    firstonly = (minimum(noffs[1:NR]), maximum(noffs[1:NR]))
-    lastonly = let tail = noffs[(1 + (nsliv - 1) * NR):end]
-        (minimum(tail), maximum(tail))
-    end
-    shortlen = length(short_C)
-    @test_throws BoundsError QS.checked_span_bounds(base.Cbase, mrange, truerange, shortlen)
-    @test QS.checked_span_bounds(base.Cbase, mrange, firstonly, shortlen) === nothing
-    @test QS.checked_span_bounds(base.Cbase, mrange, lastonly, shortlen) === nothing
-
-    # The oracle rejects too, but only at the offending tile, after writing
-    # the ones before it.
-    fill!(short_C, 0.0)
-    @test_throws BoundsError _pcf_exec_tw(pshort, 1.0, 0.0)
-    @test any(!iszero, short_C)
-
-    # An interior-sliver minimum: the base shifted down by one.
-    plow = _pcf_Plan(
-        base.kernel, base.mgroup, base.ngroup, base.kgroup, base.blocking,
-        base.Astorage, base.Abase, base.Bstorage, base.Bbase,
-        zeros(M * N1 * N2), base.Cbase - 1,
-        base.atransform, base.btransform, base.workspace, base.mpack, base.npack,
-    )
-    @test_throws BoundsError _pcf_exec(plow, 1.0, 0.0)
-end
-
-@testset "per-call floor: the unsafe_* packers keep every non-bounds check" begin
-    kernel = SIMDKernel(Val(8), Val(6), Float64)
-    src = SourceTile(collect(1.0:64.0), 0, AffineAxis(0, 1, 8), AffineAxis(0, 8, 4))
-    packed = zeros(8 * 4)
-
-    ref = zeros(8 * 4)
-    pack_a!(ref, src, kernel, identity)
-    QS.unsafe_pack_a!(packed, src, kernel, identity)
-    @test packed == ref
-
-    # Only the bounds checks are skipped.
-    @test_throws DimensionMismatch QS.unsafe_pack_a!(zeros(3), src, kernel, identity)
-    @test_throws ArgumentError QS.unsafe_pack_a!(zeros(Float32, 64), src, kernel, identity)
-    toowide = SourceTile(collect(1.0:200.0), 0, AffineAxis(0, 1, 9), AffineAxis(0, 16, 4))
-    @test_throws ArgumentError QS.unsafe_pack_a!(zeros(200), toowide, kernel, identity)
-
-    srcB = SourceTile(collect(1.0:64.0), 0, AffineAxis(0, 1, 4), AffineAxis(0, 4, 6))
-    refB = zeros(6 * 4)
-    packedB = zeros(6 * 4)
-    pack_b!(refB, srcB, kernel, identity)
-    QS.unsafe_pack_b!(packedB, srcB, kernel, identity)
-    @test packedB == refB
-    @test_throws DimensionMismatch QS.unsafe_pack_b!(zeros(3), srcB, kernel, identity)
-
-    dest = DestinationTile(zeros(8 * 6), 0, AffineAxis(0, 1, 8), AffineAxis(0, 8, 6))
-    @test_throws DimensionMismatch QS.unsafe_execute_tile!(
-        kernel, dest, zeros(3), zeros(6 * 4), 4, 1.0, 0.0
-    )
-    @test_throws ArgumentError QS.unsafe_execute_tile!(
-        kernel, dest, zeros(8 * 4), zeros(6 * 4), -1, 1.0, 0.0
-    )
-    d1 = DestinationTile(zeros(8 * 6), 0, AffineAxis(0, 1, 8), AffineAxis(0, 8, 6))
-    d2 = DestinationTile(zeros(8 * 6), 0, AffineAxis(0, 1, 8), AffineAxis(0, 8, 6))
-    execute_tile!(kernel, d1, ref, refB, 4, 1.0, 0.0)
-    QS.unsafe_execute_tile!(kernel, d2, ref, refB, 4, 1.0, 0.0)
-    @test d1.storage == d2.storage
-end
-
-@testset "per-call floor: affine_ramp classifies exactly the rank-<=1 folds" begin
-    ar = QS.affine_ramp
-
-    @test ar(AxisGroup((), ((), ()))) == (true, (0, 0))
-    @test ar(AxisGroup((7,), ((3,), (-2,)))) == (true, (3, -2))
-    # Singleton dimensions never advance, whatever their stride claims.
-    @test ar(AxisGroup((1, 7, 1), ((99, 3, -4), (5, -2, 8)))) == (true, (3, -2))
-    # Foldable on both maps, or on one only.
-    @test ar(AxisGroup((4, 5), ((1, 4), (2, 8)))) == (true, (1, 2))
-    @test first(ar(AxisGroup((4, 5), ((1, 4), (2, 9))))) == false
-    @test first(ar(AxisGroup((16, 16, 16), ((1, 256, 4096), (1, 256, 4096))))) == false
-    # A three-deep fold uses the accumulated length.
-    @test ar(AxisGroup((2, 3, 4), ((1, 2, 6), (5, 10, 30)))) == (true, (1, 5))
-    @test first(ar(AxisGroup((2, 3, 4), ((1, 2, 4), (5, 10, 30))))) == false
-    # Empty domain is vacuously a ramp.
-    @test first(ar(AxisGroup((0, 3), ((1, 4), (1, 4))))) == true
-
-    # For every ramp, offsets(g, q) == q .* steps.
-    Random.seed!(5150)
-    for trial in 1:100
-        D = rand(1:3)
-        lens = ntuple(_ -> rand(1:4), D)
-        strd = ntuple(_ -> ntuple(_ -> rand(-6:6), D), 2)
-        g = AxisGroup(lens, strd)
-        (isramp, steps) = ar(g)
-        Q = axis_length(g)
-        if isramp
-            for q in 0:(Q - 1)
-                @test offsets(g, q) == (q * steps[1], q * steps[2])
-            end
-        else
-            Q >= 2 || continue
-            s = offsets(g, 1)
-            @test any(q -> offsets(g, q) != (q * s[1], q * s[2]), 0:(Q - 1))
-        end
-        Q > 0 && @test isramp == (length(normalize_group(g).lengths) <= 1)
-    end
-end
-
-@testset "per-call floor: _ramp_slivers! reproduces _classify_slivers! exactly" begin
-    Random.seed!(31337)
-    for trial in 1:150
-        D = rand(1:3)
-        lens = ntuple(_ -> rand(1:5), D)
-        # A ramp by construction half the time.
-        strd = if rand() < 0.5
-            s1 = rand(-5:5); s2 = rand(-5:5)
-            acc = 1
-            t1 = Int[]; t2 = Int[]
-            for d in 1:D
-                push!(t1, acc * s1); push!(t2, acc * s2)
-                acc *= lens[d]
-            end
-            (Tuple(t1), Tuple(t2))
-        else
-            ntuple(_ -> ntuple(_ -> rand(-5:5), D), 2)
-        end
-        g = AxisGroup(lens, strd)
-        Q = axis_length(g)
-        Q == 0 && continue
-        (isramp, steps) = QS.affine_ramp(g)
-        isramp || continue
-
-        reg = rand(1:4)
-        first = rand(0:(Q - 1))
-        blocklen = rand(1:(Q - first))
-        nsliv = cld(blocklen, reg)
-
-        buf1 = zeros(Int, blocklen); buf2 = zeros(Int, blocklen)
-        d1 = Vector{BlockDescriptor}(undef, nsliv)
-        d2 = Vector{BlockDescriptor}(undef, nsliv)
-        fill_offsets!((buf1, buf2), g, first, blocklen)
-        want = QS._classify_slivers!(d1, d2, buf1, buf2, blocklen, reg, nsliv)
-
-        r1 = Vector{BlockDescriptor}(undef, nsliv)
-        r2 = Vector{BlockDescriptor}(undef, nsliv)
-        got = QS._ramp_slivers!(r1, r2, steps[1], steps[2], first, blocklen, reg, nsliv)
-
-        for s in 1:nsliv
-            @test r1[s].base == d1[s].base && r1[s].stride == d1[s].stride
-            @test r1[s].count == d1[s].count && r1[s].regular == d1[s].regular
-            @test r2[s].base == d2[s].base && r2[s].stride == d2[s].stride
-            @test r2[s].count == d2[s].count && r2[s].regular == d2[s].regular
-        end
-        @test got == want
-    end
-end
-
-@testset "per-call floor: ramp and buffer paths give the same contraction" begin
-    Random.seed!(424242)
-    kernel = SIMDKernel(Val(8), Val(6), Float64)
-
-    function check(Csz, Asz, Bsz, indA, indB, indC; kw...)
-        A = randn(Asz); B = randn(Bsz); C = randn(Csz)
-        C0 = copy(C)
-        p = _pcf_plan(
-            StridedView(C), StridedView(A), indA, StridedView(B), indB, indC; kw...
-        )
-        _pcf_exec(p, 2.0, -0.5)
-        ref = copy(C0)
-        p2 = _pcf_plan(
-            StridedView(ref), StridedView(A), indA, StridedView(B), indB, indC; kw...
-        )
-        _pcf_exec_tw(p2, 2.0, -0.5)
-        @test C ≈ ref
-        return p
-    end
-
-    p = check((40, 30), (40, 7), (7, 30), (1, 2), (2, 3), (1, 3); kernel = kernel)
-    @test first(QS.affine_ramp(p.mgroup)) && first(QS.affine_ramp(p.ngroup)) &&
-        first(QS.affine_ramp(p.kgroup))
-
-    # ao2mo_2: a ramp on M and K but not on N.
-    d = 6
-    p = check(
-        (d, d, d, d), (d, d), (d, d, d, d),
-        (1, 2), (3, 1, 4, 5), (3, 2, 4, 5); kernel = kernel
-    )
-    @test first(QS.affine_ramp(p.mgroup))
-    @test first(QS.affine_ramp(p.kgroup))
-    @test !first(QS.affine_ramp(p.ngroup))   # the mixed path, both branches live
-
-    # Several macro blocks, so ramp descriptors start at a nonzero `first`.
-    check(
-        (40, 30), (40, 21), (21, 30), (1, 2), (2, 3), (1, 3);
-        kernel = kernel, mc = 8, kc = 5, nc = 6
-    )
-    # Non-ramp composites on both sides (rank-4 operands, non-folding order).
-    d = 5
-    check(
-        (d, d, d, d, d, d), (d, d, d, d), (d, d, d, d),
-        (1, 2, 3, 4), (3, 5, 6, 7), (4, 6, 7, 1, 2, 5); kernel = kernel
-    )
-end
-
-@testset "per-call floor: execute! still allocates nothing in steady state" begin
-    Ma, Ka, Na = 40, 21, 30
-    A = randn(Ma, Ka); B = randn(Ka, Na); C = zeros(Ma, Na)
-    p = _pcf_plan(
-        StridedView(C), StridedView(A), (1, 2), StridedView(B), (2, 3), (1, 3)
-    )
-    _pcf_exec(p, 1.0, 0.0)
-    _pcf_exec(p, 1.0, 0.0)
-    allocs = @allocated _pcf_exec(p, 1.0, 0.0)
-    @test C ≈ A * B
-    @test allocs == 0 skip = (VERSION < v"1.11")
-
-    # Permuted A, reversed B, sliced C: the non-ramp path.
-    Ap = permutedims(randn(Ka, Ma), (2, 1))
-    Bn = view(randn(Ka, 2Na), :, (2Na):-1:(Na + 1))
-    Cs = view(zeros(2Ma, Na), 1:Ma, :)
-    ps = _pcf_plan(
-        StridedView(Cs), StridedView(Ap), (1, 2), StridedView(Bn), (2, 3), (1, 3)
-    )
-    _pcf_exec(ps, 1.0, 0.0)
-    _pcf_exec(ps, 1.0, 0.0)
-    allocs_s = @allocated _pcf_exec(ps, 1.0, 0.0)
-    @test Cs ≈ Ap * Bn
-    @test allocs_s == 0 skip = (VERSION < v"1.11")
-end
diff --git a/test/planning/test_plan.jl b/test/planning/test_plan.jl
new file mode 100644
index 0000000..ce3569a
--- /dev/null
+++ b/test/planning/test_plan.jl
@@ -0,0 +1,172 @@
+include("../execution/helpers.jl")
+
+@testset "driver: label validation errors" begin
+    Amat = randn(3, 4)
+    Bmat = randn(4, 5)
+    Cmat = zeros(3, 5)
+    Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
+
+    # Mismatched shared-label length: B's k axis is 6, A's is 4.
+    Bv_bad = StridedView(randn(6, 5))
+    @test_throws DimensionMismatch contract!(Cv, 1.0, Av, (1, 2), Bv_bad, (2, 3), 0.0, (1, 3))
+
+    # Diagonal: repeated label within indA, then within indC.
+    Avsq = StridedView(randn(4, 4))
+    @test_throws ArgumentError contract!(Cv, 1.0, Avsq, (1, 1), Bv, (2, 3), 0.0, (1, 3))
+    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (1, 1, 3)[1:2])
+
+    # Label in indC absent from both indA and indB.
+    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (1, 9))
+
+    # Dangling label: only in indA, then only in indB. Distinct code paths
+    # (the A loop vs. the B loop in classify_labels).
+    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (5, 3), 0.0, (1, 3))
+    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 9), 0.0, (1, 3))
+
+    # Label present in all three (batch-like), unsupported.
+    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (2, 3))
+end
+
+@testset "driver: eltype validation errors" begin
+    mk(TA, TB, TC) = (StridedView(zeros(TC, 3, 5)), StridedView(ones(TA, 3, 4)), (1, 2), StridedView(ones(TB, 4, 5)), (2, 3), (1, 3))
+    for eltypes in ((Float16, Float16, Float16), (Float64, Float64, BigFloat), (ComplexF64, Float64, Float64))
+        @test_throws ArgumentError plan_contract(mk(eltypes...)...)
+    end
+end
+
+@testset "plan_contract: m_block/k_block/n_block keywords are validated and rounded" begin
+    kernel = ScalarKernel(Val(4), Val(3), Float64)
+    Ma, Ka, Na = 9, 10, 8
+    Amat, Bmat, Cmat = randn(Ma, Ka), randn(Ka, Na), zeros(Ma, Na)
+    Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
+    indA, indB, indC = (1, 2), (2, 3), (1, 3)
+
+    @test_throws ArgumentError plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, m_block = 0)
+    @test_throws ArgumentError plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, k_block = 0)
+    @test_throws ArgumentError plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, n_block = -3)
+
+    # m_block=5 with MR=4 rounds up to 8, then clamps to roundup(Ma=9,4)=12 -> 8.
+    plan = _mm_plan(Cmat, Amat, Bmat; kernel = kernel, m_block = 5, k_block = 100, n_block = 100)
+    @test plan.blocking.m_block == 8
+    @test plan.blocking.k_block == 10  # clamped to k_length
+    @test plan.blocking.n_block == 9   # NR=3: roundup(8,3)=9, requested 100 clamped down to that
+end
+
+@testset "op_conjugates is a total table with a throwing fallback" begin
+    @test QuasiStrided.op_conjugates(identity) === false
+    @test QuasiStrided.op_conjugates(conj) === true
+    @test QuasiStrided.op_conjugates(transpose) === false   # elementwise identity
+    @test QuasiStrided.op_conjugates(adjoint) === true
+    @test_throws ArgumentError QuasiStrided.op_conjugates(sin)
+
+    # A real element type is conjugated by nothing; a complex one composes
+    # the flag and the op with XOR.
+    for op in (identity, conj, transpose, adjoint), flag in (false, true)
+        v = StridedView(randn(16), (4, 4), (1, 4), 0, op)
+        @test QuasiStrided.isconj(v, flag) === false
+    end
+    for (op, oc) in ((identity, false), (conj, true), (transpose, false), (adjoint, true)),
+            flag in (false, true)
+        v = StridedView(randn(ComplexF64, 16), (4, 4), (1, 4), 0, op)
+        @test QuasiStrided.isconj(v, flag) === (flag ⊻ oc)
+    end
+end
+
+@testset "conjA/conjB add no specialization on the real path" begin
+    Random.seed!(97531)
+    Ma, Ka, Na = 12, 9, 7
+    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
+    Cmat = zeros(Ma, Na)
+    base = _mm_plan(Cmat, Amat, Bmat)
+
+    for ca in (false, true), cb in (false, true)
+        plan = _mm_plan(Cmat, Amat, Bmat; conjA = ca, conjB = cb)
+        @test typeof(plan.atransform) === typeof(identity)
+        @test typeof(plan.btransform) === typeof(identity)
+        @test typeof(plan) === typeof(base)
+        fill!(Cmat, 0.0)
+        execute!(plan, 1.0, 0.0)
+        @test Cmat ≈ Amat * Bmat
+    end
+
+    # A real eltype collapses a view's `conj` op to identity.
+    Av = conj(StridedView(Amat))
+    @test Av.op === identity
+    plan = plan_contract(
+        StridedView(Cmat), Av, (1, 2), StridedView(Bmat), (2, 3), (1, 3); conjA = true
+    )
+    @test typeof(plan) === typeof(base)
+    fill!(Cmat, 0.0)
+    execute!(plan, 1.0, 0.0)
+    @test Cmat ≈ Amat * Bmat
+end
+
+@testset "plan_contract rejects a conjugated output, but not a real adjoint" begin
+    Random.seed!(2469)
+    Amat, Bmat = randn(6, 5), randn(5, 4)
+
+    # A real adjoint output has op === identity and is accepted.
+    Cadj = adjoint(zeros(4, 6))
+    Cv = StridedView(Cadj)
+    @test Cv.op === identity
+    plan = plan_contract(Cv, StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3), (1, 3))
+    execute!(plan, 1.0, 0.0)
+    @test Cadj ≈ Amat * Bmat
+
+    # A conjugated complex output is rejected (checked by message).
+    Ac, Bc = randn(ComplexF64, 6, 5), randn(ComplexF64, 5, 4)
+    Cc = zeros(ComplexF64, 24)
+    for op in (conj, adjoint)
+        Ccv = StridedView(Cc, (6, 4), (1, 6), 0, op)
+        err = try
+            plan_contract(Ccv, StridedView(Ac), (1, 2), StridedView(Bc), (2, 3), (1, 3))
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("conjugated", err.msg)
+    end
+    # A non-conjugating op on a complex output is accepted.
+    Ctv = StridedView(Cc, (6, 4), (1, 6), 0, transpose)
+    execute!(plan_contract(Ctv, StridedView(Ac), (1, 2), StridedView(Bc), (2, 3), (1, 3)), 1.0, 0.0)
+    @test reshape(Cc, 6, 4) ≈ Ac * Bc
+    # StridedViews bounds `op` to exactly the four functions `op_conjugates`
+    # tabulates; fail here if that ever widens.
+    @test_throws TypeError StridedView(Cc, (6, 4), (1, 6), 0, sin)
+    Fbound = fieldtype(typeof(StridedView(Cc, (6, 4), (1, 6), 0, conj)), :op)
+    @test Fbound === typeof(conj)
+    optypes = Base.unwrap_unionall(StridedView).parameters[4].ub
+    @test Set(Base.uniontypes(optypes)) ==
+        Set((typeof(identity), typeof(conj), typeof(transpose), typeof(adjoint)))
+end
+
+@testset "plan_contract and contract! reject an output aliased with an input" begin
+    M = randn(8, 4)
+    Cv, Av, Bv = StridedView(M)[1:4, :], StridedView(M)[5:8, :], StridedView(randn(4, 4))
+    @test_throws ArgumentError plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3))
+    @test_throws ArgumentError plan_contract(Cv, Bv, (1, 2), Av, (2, 3), (1, 3))
+    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (1, 3))
+end
+
+@testset "plan_contract allocation stays under a ceiling" begin
+    # A ceiling that a `Set`/`Vector`-based planner would exceed several-fold.
+    A = randn(64, 64); B = randn(64, 64); C = zeros(64, 64)
+    Av, Bv, Cv = StridedView(A), StridedView(B), StridedView(C)
+    p = plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3))
+    ws() = QuasiStrided.ContractWorkspace(Float64, p.kernel, p.blocking)
+    ws()
+    f() = plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3))
+    f()
+    @test (@allocated f()) <= 3000 + (@allocated ws())
+end
+
+@testset "the path modes override path selection" begin
+    pd(; kw...) = plan_contract(_mm_maker(Float64, 1, 64, 9, 1)()...; kw...)
+    po(; kw...) = plan_contract(_outer_maker(Float64, 16, 9, 1)()...; kw...)
+    pu(; kw...) = plan_contract(_mm_maker(Float64, 20, 12, 9, 1)()...; kw...)
+    ps(; kw...) = plan_contract(_mm_maker(Float64, 20, 12, 9, 1; B = :transposed)()...; kw...)
+    @test _dot_takes(pd()) && _outer_takes(po()) && _ub_takes(pu()) && !_ub_takes(ps())
+    @test !_dot_takes(pd(; path_modes = NEST_ONLY)) && !_outer_takes(po(; path_modes = NEST_ONLY)) &&
+        !_ub_takes(pu(; path_modes = NEST_ONLY))
+    @test _ub_takes(ps(; path_modes = QuasiStrided.PathModes(unpacked_b = :always)))
+end
diff --git a/test/planning/test_plan_contract.jl b/test/planning/test_plan_contract.jl
deleted file mode 100644
index df71923..0000000
--- a/test/planning/test_plan_contract.jl
+++ /dev/null
@@ -1,776 +0,0 @@
-@testset "driver: label validation errors" begin
-    Amat = randn(3, 4)
-    Bmat = randn(4, 5)
-    Cmat = zeros(3, 5)
-    Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
-
-    # Mismatched shared-label length: B's k axis is 6, A's is 4.
-    Bv_bad = StridedView(randn(6, 5))
-    @test_throws DimensionMismatch contract!(Cv, 1.0, Av, (1, 2), Bv_bad, (2, 3), 0.0, (1, 3))
-
-    # Diagonal: repeated label within indA, then within indC.
-    Avsq = StridedView(randn(4, 4))
-    @test_throws ArgumentError contract!(Cv, 1.0, Avsq, (1, 1), Bv, (2, 3), 0.0, (1, 3))
-    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (1, 1, 3)[1:2])
-
-    # Label in indC absent from both indA and indB.
-    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (1, 9))
-
-    # Dangling label: only in indA, then only in indB. Distinct code paths
-    # (the A loop vs. the B loop in _classify_labels).
-    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (5, 3), 0.0, (1, 3))
-    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 9), 0.0, (1, 3))
-
-    # Label present in all three (batch-like), unsupported.
-    @test_throws ArgumentError contract!(Cv, 1.0, Av, (1, 2), Bv, (2, 3), 0.0, (2, 3))
-end
-
-@testset "driver: eltype validation errors" begin
-    mk(TA, TB, TC) = (StridedView(zeros(TC, 3, 5)), StridedView(ones(TA, 3, 4)), (1, 2), StridedView(ones(TB, 4, 5)), (2, 3), (1, 3))
-    for eltypes in ((Float16, Float16, Float16), (Float64, Float64, BigFloat), (ComplexF64, Float64, Float64))
-        @test_throws ArgumentError plan_contract(mk(eltypes...)...)
-    end
-    ws = plan_contract(mk(Float32, Float32, Float32)...).workspace
-    @test_throws ArgumentError plan_contract(mk(Float32, Float32, Float32)...; accumulator = Float64, workspace = ws)
-    @test plan_contract(mk(Float32, Float64, Float32)...; accumulator = Float32, workspace = ws).workspace === ws
-end
-
-
-@testset "Blocking: field validation" begin
-    b = Blocking(4, 8, 16)
-    @test b.mc == 4 && b.kc == 8 && b.nc == 16
-
-    @test_throws ArgumentError Blocking(0, 8, 16)
-    @test_throws ArgumentError Blocking(4, 0, 16)
-    @test_throws ArgumentError Blocking(4, 8, 0)
-    @test_throws ArgumentError Blocking(-1, 8, 16)
-end
-
-@testset "default_blocking: dispatches on kernel scalar type" begin
-    bf64 = default_blocking(ScalarKernel(Val(8), Val(6), Float64))
-    bf32 = default_blocking(ScalarKernel(Val(8), Val(6), Float32))
-    @test bf64 isa Blocking
-    @test bf32 isa Blocking
-    @test bf64.mc >= 1 && bf64.kc >= 1 && bf64.nc >= 1
-    @test bf32.mc >= 1 && bf32.kc >= 1 && bf32.nc >= 1
-    # Same kernel shape, different scalar type, through SIMDKernel too.
-    @test default_blocking(SIMDKernel(Val(8), Val(6), Float64)) == bf64
-end
-
-@testset "plan_contract: mc/kc/nc keywords are validated and rounded" begin
-    kernel = ScalarKernel(Val(4), Val(3), Float64)
-    Ma, Ka, Na = 9, 10, 8
-    Amat, Bmat, Cmat = randn(Ma, Ka), randn(Ka, Na), zeros(Ma, Na)
-    Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
-    indA, indB, indC = (1, 2), (2, 3), (1, 3)
-
-    @test_throws ArgumentError plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, mc = 0)
-    @test_throws ArgumentError plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, kc = 0)
-    @test_throws ArgumentError plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, nc = -3)
-
-    # mc=5 with MR=4 rounds up to 8, then clamps to roundup(Ma=9,4)=12 -> 8.
-    plan = _mm_plan(Cmat, Amat, Bmat; kernel = kernel, mc = 5, kc = 100, nc = 100)
-    @test plan.blocking.mc == 8
-    @test plan.blocking.kc == 10  # clamped to Qk
-    @test plan.blocking.nc == 9   # NR=3: roundup(8,3)=9, requested 100 clamped down to that
-end
-
-
-@testset "_op_conjugates is a total table with a throwing fallback" begin
-    @test QuasiStrided._op_conjugates(identity) === false
-    @test QuasiStrided._op_conjugates(conj) === true
-    @test QuasiStrided._op_conjugates(transpose) === false   # elementwise identity
-    @test QuasiStrided._op_conjugates(adjoint) === true
-    @test_throws ArgumentError QuasiStrided._op_conjugates(sin)
-
-    # A real element type is conjugated by nothing; a complex one composes
-    # the flag and the op with XOR.
-    for op in (identity, conj, transpose, adjoint), flag in (false, true)
-        v = StridedView(randn(16), (4, 4), (1, 4), 0, op)
-        @test QuasiStrided._qs_isconj(v, flag) === false
-    end
-    for (op, oc) in ((identity, false), (conj, true), (transpose, false), (adjoint, true)),
-            flag in (false, true)
-        v = StridedView(randn(ComplexF64, 16), (4, 4), (1, 4), 0, op)
-        @test QuasiStrided._qs_isconj(v, flag) === (flag ⊻ oc)
-    end
-end
-
-@testset "conjA/conjB add no specialization on the real path" begin
-    Random.seed!(97531)
-    Ma, Ka, Na = 12, 9, 7
-    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-    Cmat = zeros(Ma, Na)
-    base = _mm_plan(Cmat, Amat, Bmat)
-
-    for ca in (false, true), cb in (false, true)
-        plan = _mm_plan(Cmat, Amat, Bmat; conjA = ca, conjB = cb)
-        @test typeof(plan.atransform) === typeof(identity)
-        @test typeof(plan.btransform) === typeof(identity)
-        @test typeof(plan) === typeof(base)
-        fill!(Cmat, 0.0)
-        execute!(plan, 1.0, 0.0)
-        @test Cmat ≈ Amat * Bmat
-        fill!(Cmat, 0.0)
-        execute_tilewise!(plan, 1.0, 0.0)
-        @test Cmat ≈ Amat * Bmat
-    end
-
-    # A real eltype collapses a view's `conj` op to identity.
-    Av = conj(StridedView(Amat))
-    @test Av.op === identity
-    plan = plan_contract(
-        StridedView(Cmat), Av, (1, 2), StridedView(Bmat), (2, 3), (1, 3); conjA = true
-    )
-    @test typeof(plan) === typeof(base)
-    fill!(Cmat, 0.0)
-    execute!(plan, 1.0, 0.0)
-    @test Cmat ≈ Amat * Bmat
-end
-
-@testset "plan_contract rejects a conjugated output, but not a real adjoint" begin
-    Random.seed!(2469)
-    Amat, Bmat = randn(6, 5), randn(5, 4)
-
-    # A real adjoint output has op === identity and is accepted.
-    Cadj = adjoint(zeros(4, 6))
-    Cv = StridedView(Cadj)
-    @test Cv.op === identity
-    plan = plan_contract(Cv, StridedView(Amat), (1, 2), StridedView(Bmat), (2, 3), (1, 3))
-    execute!(plan, 1.0, 0.0)
-    @test Cadj ≈ Amat * Bmat
-
-    # A conjugated complex output is rejected (checked by message).
-    Ac, Bc = randn(ComplexF64, 6, 5), randn(ComplexF64, 5, 4)
-    Cc = zeros(ComplexF64, 24)
-    for op in (conj, adjoint)
-        Ccv = StridedView(Cc, (6, 4), (1, 6), 0, op)
-        err = try
-            plan_contract(Ccv, StridedView(Ac), (1, 2), StridedView(Bc), (2, 3), (1, 3))
-        catch e
-            e
-        end
-        @test err isa ArgumentError
-        @test occursin("conjugated", err.msg)
-    end
-    # StridedViews bounds `op` to exactly the four functions `_op_conjugates`
-    # tabulates; fail here if that ever widens.
-    @test_throws TypeError StridedView(Cc, (6, 4), (1, 6), 0, sin)
-    Fbound = fieldtype(typeof(StridedView(Cc, (6, 4), (1, 6), 0, conj)), :op)
-    @test Fbound === typeof(conj)
-    optypes = Base.unwrap_unionall(StridedView).parameters[4].ub
-    @test Set(Base.uniontypes(optypes)) ==
-        Set((typeof(identity), typeof(conj), typeof(transpose), typeof(adjoint)))
-end
-
-
-# Label order within M/N and the M/N orientation swap.
-const _lo_order = QuasiStrided._order_free_labels
-const _lo_run = QuasiStrided._leading_unit_run
-_lo_swap(morder, norder, indC, C, mr_asis, mr_swapped = mr_asis) = QuasiStrided._prefer_swap(
-    _lo_run(morder, indC, C), _lo_run(norder, indC, C), mr_asis, mr_swapped
-)
-
-# A view with these strides over dummy data (only strides/size are read).
-_lo_view(sz::NTuple{N, Int}, st::NTuple{N, Int}) where {N} =
-    StridedView(zeros(Float64, 4096), sz, st, 2048, identity)
-
-# The four TCCG `ccsd_t_*` shapes, C stored in (a,b,c,i,j,k) order, labelled
-# as the TensorOperations adapter labels them.
-const _LO_IC = (:a, :b, :c, :i, :j, :k)
-const _LO_CASES = (
-    ("ccsd_t_1", (:i, :j, :m, :a), (:m, :k, :b, :c)),
-    ("ccsd_t_2", (:i, :j, :m, :b), (:m, :k, :a, :c)),
-    ("ccsd_t_3", (:i, :j, :m, :c), (:m, :k, :a, :b)),
-    ("ccsd_t_4", (:i, :k, :m, :b), (:m, :j, :a, :c)),
-)
-function _lo_labels(IA, IB)
-    pA, pB, pAB = TO.contract_indices(IA, IB, _LO_IC)
-    return QuasiStrided._qs_labels(pA, pB, pAB), (pA, pB, pAB)
-end
-
-# Engine-free reference: alpha * sum_K conj?(A) conj?(B) + beta * C, one loop
-# over every label's range (`getindex` applies a view's `op`, the flag goes on top).
-function _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA = false, conjB = false, alpha = 1, beta = 0)
-    labels = unique((indA..., indB...))
-    ext = Dict{Int, Int}()
-    for (l, s) in zip(indA, size(Av))
-        ext[l] = s
-    end
-    for (l, s) in zip(indB, size(Bv))
-        ext[l] = s
-    end
-    T = eltype(Cstart)
-    acc = zeros(T, size(Cstart))
-    pA = map(l -> Int(findfirst(==(l), labels)), indA)
-    pB = map(l -> Int(findfirst(==(l), labels)), indB)
-    pC = map(l -> Int(findfirst(==(l), labels)), indC)
-    dims = Tuple(ext[l] for l in labels)
-    _lo_reference_loop!(acc, Av, pA, Bv, pB, pC, dims, conjA, conjB)
-    return alpha .* acc .+ beta .* Cstart
-end
-
-function _lo_reference_loop!(
-        acc, Av, pA::NTuple{NA, Int}, Bv, pB::NTuple{NB, Int}, pC::NTuple{NC, Int},
-        dims::NTuple{NL, Int}, conjA::Bool, conjB::Bool
-    ) where {NA, NB, NC, NL}
-    for I in CartesianIndices(dims)
-        a = Av[ntuple(d -> I[pA[d]], Val(NA))...]
-        b = Bv[ntuple(d -> I[pB[d]], Val(NB))...]
-        conjA && (a = conj(a))
-        conjB && (b = conj(b))
-        acc[ntuple(d -> I[pC[d]], Val(NC))...] += a * b
-    end
-    return acc
-end
-
-@testset "label order: _order_free_labels sorts by |C-stride|, stably" begin
-    Cv = _lo_view((5, 3, 2, 4), (12, 1, 60, 3))
-    indC = (10, 20, 30, 40)
-    labels = (10, 20, 30, 40)
-    @test _lo_order(labels, indC, Cv) === (20, 40, 10, 30)
-    @test _lo_order((40, 10), indC, Cv) === (40, 10)  # a subset: only its own members
-    @test _lo_order((30, 20), indC, Cv) === (20, 30)
-
-    # Ties keep input order, whichever way the input is given.
-    Ct = _lo_view((2, 3, 4), (1, 1, 1))
-    @test _lo_order((7, 8, 9), (7, 8, 9), Ct) === (7, 8, 9)
-    @test _lo_order((9, 7, 8), (7, 8, 9), Ct) === (9, 7, 8)
-
-    # Negative strides sort by magnitude.
-    Cn = _lo_view((3, 4), (-1, 4))
-    @test _lo_order((20, 10), (10, 20), Cn) === (10, 20)
-    Cn2 = _lo_view((3, 4), (4, -1))
-    @test _lo_order((10, 20), (10, 20), Cn2) === (20, 10)
-
-    @test _lo_order((), indC, Cv) === ()
-    @test _lo_order((30,), indC, Cv) === (30,)
-
-    # Against a stable `sortperm`, randomized.
-    Random.seed!(20260921)
-    for trial in 1:100
-        nd = rand(1:5)
-        C = StridedView(randn(ntuple(_ -> rand(1:4), nd)))
-        st = Base.strides(C)
-        labels = shuffle(collect(1:nd))[1:rand(1:nd)]
-        got = _lo_order(Tuple(labels), ntuple(identity, nd), C)
-        @test got isa NTuple{length(labels), Int}
-        @test collect(got) == labels[sortperm([abs(st[l]) for l in labels]; alg = Base.Sort.DEFAULT_STABLE)]
-    end
-end
-
-@testset "label order: _leading_unit_run / _prefer_swap" begin
-    d = 4
-    C6 = StridedView(zeros(Float64, d, d, d, d, d, d))  # strides 1, d, d^2, ...
-    indC = (1, 2, 3, 4, 5, 6)                            # a,b,c,i,j,k
-    a, b, c, i, j, k = indC
-
-    @test _lo_run((a, i, j), indC, C6) == d          # ccsd_t_1's sorted M: run stops at i
-    @test _lo_run((a, b, k), indC, C6) == d^2        # ccsd_t_3's sorted N: b is C-adjacent to a
-    @test _lo_run((a, b, c, i, j, k), indC, C6) == d^6
-    @test _lo_run((b, i, j), indC, C6) == 1          # no unit-stride head
-    @test _lo_run((a, c, b), indC, C6) == d          # sorted order is the caller's job
-    @test _lo_run((), indC, C6) == 1
-
-    # A descending axis is not a unit-stride run.
-    @test _lo_run((10, 20), (10, 20), _lo_view((3, 4), (-1, 3))) == 1
-    # Singleton axes are skipped whatever their stride; an empty axis ends it.
-    @test _lo_run((10, 20), (10, 20), _lo_view((1, 6), (5, 1))) == 6
-    @test _lo_run((10, 20), (10, 20), _lo_view((6, 1), (1, 17))) == 6
-    @test _lo_run((10, 20), (10, 20), _lo_view((0, 6), (1, 1))) == 0
-
-    # The swap rule on the ccsd_t shapes at dim 4, with `mr` played by hand.
-    # ccsd_t_2: sorted M = (b,i,j) (run 1), sorted N = (a,c,k) (run 4).
-    @test _lo_swap((b, i, j), (a, c, k), indC, C6, 4)        # 4-wide kernel: swap
-    @test !_lo_swap((b, i, j), (a, c, k), indC, C6, 8)       # 8-wide: 4 < 8, do not swap
-    # ccsd_t_3: sorted N = (a,b,k) (run 16): the adjacent label extends it.
-    @test _lo_swap((c, i, j), (a, b, k), indC, C6, 8)
-    @test _lo_swap((c, i, j), (a, b, k), indC, C6, 16)
-    @test !_lo_swap((c, i, j), (a, b, k), indC, C6, 32)
-    # ccsd_t_1: M already has the run; never swap, whatever mr says.
-    @test !_lo_swap((a, i, j), (b, c, k), indC, C6, 4)
-    @test !_lo_swap((a, i, j), (b, c, k), indC, C6, 8)
-    # Two-mr form: each orientation is judged against the kernel it would run.
-    @test _lo_swap((b, i, j), (a, c, k), indC, C6, 8, 4)
-    @test !_lo_swap((b, i, j), (a, c, k), indC, C6, 8, 8)
-    @test !_lo_swap((a, i, j), (b, c, k), indC, C6, 4, 4)
-    # Nothing to swap onto.
-    @test !_lo_swap((b, i, j), (), indC, C6, 1)
-end
-
-@testset "label order: _leading_unit_run's full-coverage condition is a single-map affine_ramp on C's own strides" begin
-    # The whole composite is one run iff C's own single-map group is a unit
-    # ramp. Empty and all-singleton composites are excluded: `affine_ramp`
-    # reports step 0 there while the run is trivially 1.
-    rng = Random.MersenneTwister(0x01E3A3E1)
-    ntested = 0
-    while ntested < 300
-        D = rand(rng, 1:5)
-        indCr = ntuple(identity, D)
-        lens = ntuple(_ -> rand(rng, (1, 2, 3, 5)), D)
-        strides = ntuple(_ -> rand(rng, (-3, -1, 1, 2, 3, 7)), D)
-        Cr = _lo_view(lens, strides)
-        nlabels = rand(rng, 1:D)
-        order = Tuple(Random.shuffle(rng, collect(1:D))[1:nlabels])
-        Qm = prod(lens[l] for l in order)
-        Qm == 1 && continue
-        ntested += 1
-
-        run = QuasiStrided._leading_unit_run(order, indCr, Cr)
-
-        clens = ntuple(d -> lens[order[d]], nlabels)
-        cstrides = ntuple(d -> strides[order[d]], nlabels)
-        cgroup = QuasiStrided.AxisGroup(clens, (cstrides,))
-        (isramp, steps) = QuasiStrided.affine_ramp(cgroup)
-
-        @test (run == Qm) == (isramp && steps[1] == 1)
-    end
-end
-
-@testset "label order: pinning test on the ccsd_t shapes (composite order and swap)" begin
-    d = 5
-    for (name, IA, IB) in _LO_CASES
-        (indA, indB, indC), _ = _lo_labels(IA, IB)
-        A = randn(d, d, d, d)
-        B = randn(d, d, d, d)
-        C = zeros(d, d, d, d, d, d)
-        Av, Bv, Cv = StridedView(A), StridedView(B), StridedView(C)
-        cst = Base.strides(Cv)
-        cstride(l) = cst[findfirst(==(l), indC)]
-        mlab, nlab, klab = QuasiStrided._classify_labels(indA, indB, indC)
-        @test length(klab) == 1
-        kA = Base.strides(Av)[findfirst(==(klab[1]), indA)]
-        kB = Base.strides(Bv)[findfirst(==(klab[1]), indB)]
-
-        msorted = Tuple(sort(collect(mlab); by = cstride))
-        nsorted = Tuple(sort(collect(nlab); by = cstride))
-        @test _lo_order(mlab, indC, Cv) == msorted
-        @test _lo_order(nlab, indC, Cv) == nsorted
-        mrun = _lo_run(msorted, indC, Cv)
-        nrun = _lo_run(nsorted, indC, Cv)
-        # ccsd_t_1 carries C's unit axis on A (run d); the others carry it on B.
-        @test (name == "ccsd_t_1") == (mrun == d)
-        @test nrun == (name == "ccsd_t_1" ? 1 : name == "ccsd_t_3" ? d^2 : d)
-
-        # Named kernels, host-independent: mr = 4 swaps 2/3/4, mr = 8 only 3.
-        for (kernel, expect_swap) in (
-                (ScalarKernel(Val(4), Val(3), Float64), name != "ccsd_t_1"),
-                (SIMDKernel(Val(8), Val(6), Float64), name == "ccsd_t_3"),
-            )
-            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel)
-            swapped = plan.Astorage === parent(Bv)
-            @test swapped == expect_swap
-            @test swapped == _lo_swap(msorted, nsorted, indC, Cv, mr(kernel))
-            if swapped
-                # B feeds M: mgroup's maps are (B, C) over the sorted N labels.
-                @test plan.mgroup.strides[2] == Tuple(cstride(l) for l in nsorted)
-                @test plan.ngroup.strides[2] == Tuple(cstride(l) for l in msorted)
-                @test plan.kgroup.strides == ((kB,), (kA,))
-                @test plan.Bstorage === parent(Av)
-                @test plan.Abase == offset(Bv) && plan.Bbase == offset(Av)
-            else
-                @test plan.mgroup.strides[2] == Tuple(cstride(l) for l in msorted)
-                @test plan.ngroup.strides[2] == Tuple(cstride(l) for l in nsorted)
-                @test plan.kgroup.strides == ((kA,), (kB,))
-                @test plan.Bstorage === parent(Bv)
-            end
-            # The C map of each composite is ascending, whichever operand fed it.
-            @test issorted(abs.(plan.mgroup.strides[2]))
-            @test issorted(abs.(plan.ngroup.strides[2]))
-            @test plan.mgroup.lengths == ntuple(_ -> d, 3)
-            @test plan.ngroup.lengths == ntuple(_ -> d, 3)
-        end
-
-        # Default kernel: the same rule at this machine's `mr`.
-        plan = plan_contract(Cv, Av, indA, Bv, indB, indC)
-        MRk = mr(plan.kernel)
-        @test (plan.Astorage === parent(Bv)) == (mrun < MRk && nrun >= MRk)
-    end
-end
-
-@testset "run-length-aware kernel demotion" begin
-    # ccsd_t_1 with C's leading run exactly `d` and Qm != run, so only
-    # `run % mr == 0` avoids demotion. Expectations are derived from the
-    # menu, so this holds on every ISA.
-    d = 16
-    extra = 4
-    IA = (:i, :j, :m, :a)
-    IB = (:m, :k, :b, :c)
-    IC = (:a, :b, :c, :i, :j, :k)
-    (indA, indB, indC), _ = _lo_labels(IA, IB)
-
-    for T in (Float64, Float32)
-        A = randn(T, extra, extra, extra, d)  # (i, j, m, a)
-        B = randn(T, extra, extra, extra, extra)  # (m, k, b, c)
-        C = zeros(T, d, extra, extra, extra, extra, extra)  # (a, b, c, i, j, k)
-        Av, Bv, Cv = StridedView(A), StridedView(B), StridedView(C)
-
-        mlab, nlab, klab = QuasiStrided._classify_labels(indA, indB, indC)
-        msorted = _lo_order(mlab, indC, Cv)
-        run = _lo_run(msorted, indC, Cv)
-        cpos(l) = findfirst(==(l), indC)::Int
-        Qm = prod(size(Cv, cpos(l)) for l in mlab)
-        Qn = prod(size(Cv, cpos(l)) for l in nlab)
-
-        plan = plan_contract(Cv, Av, indA, Bv, indB, indC)
-        @test plan.Astorage === parent(Av)
-
-        default_kernel = QuasiStrided._default_kernel(T, Qm, Qn)
-        default_mr = mr(default_kernel)
-        if Qm == run || run % default_mr == 0
-            @test plan.kernel === default_kernel
-        else
-            candidates = [sh[1] for sh in QuasiStrided.kernel_shapes(T) if run % sh[1] == 0]
-            if isempty(candidates)
-                @test plan.kernel === default_kernel
-            else
-                @test run % mr(plan.kernel) == 0
-                @test mr(plan.kernel) == maximum(candidates)
-            end
-        end
-
-        Cref = _lo_reference(C, Av, indA, Bv, indB, indC; alpha = 1.3, beta = -0.7)
-        Ctw = copy(C)
-        plan_tw = plan_contract(
-            StridedView(Ctw), Av, indA, Bv, indB, indC; kernel = plan.kernel
-        )
-        execute_tilewise!(plan_tw, 1.3, -0.7)
-        @test Ctw ≈ Cref
-
-        Cex = copy(C)
-        plan_ex = plan_contract(StridedView(Cex), Av, indA, Bv, indB, indC)
-        execute!(plan_ex, 1.3, -0.7)
-        @test Cex ≈ Cref
-    end
-
-    # Plain GEMM: `Qm == run`, so no demotion.
-    for T in (Float64, Float32)
-        Ma, Ka, Na = 37, 11, 23
-        Amat = randn(T, Ma, Ka)
-        Bmat = randn(T, Ka, Na)
-        Cmat = zeros(T, Ma, Na)
-        Av, Bv, Cv = StridedView(Amat), StridedView(Bmat), StridedView(Cmat)
-        plan = plan_contract(Cv, Av, (1, 2), Bv, (2, 3), (1, 3))
-        @test plan.kernel === QuasiStrided._default_kernel(T, Ma, Na)
-
-        Cref = Amat * Bmat
-        execute!(plan, 1.0, 0.0)
-        @test Cmat ≈ Cref
-    end
-end
-
-@testset "run-length demotion K-depth guard: deep-K does not demote, shallow-K does" begin
-    # C[a,b,c,i,j,k] = A[i,j,m,a] * B[m,k,b,c], i=j=k=b=c=6: Qk = m is swept.
-    IA = (:i, :j, :m, :a)
-    IB = (:m, :k, :b, :c)
-    IC = (:a, :b, :c, :i, :j, :k)
-    (indA, indB, indC), _ = _lo_labels(IA, IB)
-
-    function _run_demote_fixture(::Type{T}, a::Int, m::Int) where {T}
-        i = j = k = b = c = 6
-        A = randn(T, i, j, m, a)
-        B = randn(T, m, k, b, c)
-        C = zeros(T, a, b, c, i, j, k)
-        return StridedView(C), StridedView(A), StridedView(B)
-    end
-
-    kmax_of(::Type{Float64}) = QuasiStrided._RUN_DEMOTE_KMAX_F64
-    kmax_of(::Type{Float32}) = QuasiStrided._RUN_DEMOTE_KMAX_F32
-
-    for (T, a) in ((Float64, 8), (Float32, 16))
-        Qm = a * 36
-        Qn = 216
-        default_kernel = QuasiStrided._default_kernel(T, Qm, Qn)
-
-        # Deep K never demotes; the fixture never swaps.
-        m_deep = 2 * kmax_of(T)
-        Cv, Av, Bv = _run_demote_fixture(T, a, m_deep)
-        plan_deep = plan_contract(Cv, Av, indA, Bv, indB, indC)
-        @test plan_deep.Astorage === parent(Av)
-        @test plan_deep.kernel === default_kernel
-
-        # Shallow K demotes where the default's `mr` breaks the run (ISA-dependent).
-        m_shallow = 8
-        Cv2, Av2, Bv2 = _run_demote_fixture(T, a, m_shallow)
-        plan_shallow = plan_contract(Cv2, Av2, indA, Bv2, indB, indC)
-        @test plan_shallow.Astorage === parent(Av2)
-        mlab, = QuasiStrided._classify_labels(indA, indB, indC)
-        msorted = _lo_order(mlab, indC, Cv2)
-        run = _lo_run(msorted, indC, Cv2)
-        if Qm == run || run % mr(default_kernel) == 0
-            @test plan_shallow.kernel === default_kernel
-        else
-            @test plan_shallow.kernel !== default_kernel
-            @test typeof(plan_shallow.kernel) !== typeof(default_kernel)
-            @test run % mr(plan_shallow.kernel) == 0
-        end
-
-        # The guard is `Qk > kmax`: `Qk == kmax` may still demote.
-        Cv_b, Av_b, Bv_b = _run_demote_fixture(T, a, kmax_of(T))
-        plan_b = plan_contract(Cv_b, Av_b, indA, Bv_b, indB, indC)
-        run_b = _lo_run(msorted, indC, Cv_b)  # same M order at every m in this fixture
-        if Qm == run_b || run_b % mr(default_kernel) == 0
-            @test plan_b.kernel === default_kernel
-        else
-            @test plan_b.kernel !== default_kernel
-        end
-
-        Cv_b1, Av_b1, Bv_b1 = _run_demote_fixture(T, a, kmax_of(T) + 1)
-        plan_b1 = plan_contract(Cv_b1, Av_b1, indA, Bv_b1, indB, indC)
-        @test plan_b1.kernel === default_kernel
-    end
-end
-
-@testset "label order: plain matmul is unchanged; a transposed output swaps" begin
-    Ma, Ka, Na = 9, 4, 12
-    Amat, Bmat = randn(Ma, Ka), randn(Ka, Na)
-    kernel = SIMDKernel(Val(8), Val(6), Float64)
-    # One view per operand: on Julia 1.10 `parent` of two fresh views of the
-    # same array need not be `===`.
-    Av, Bv = StridedView(Amat), StridedView(Bmat)
-
-    Cmat = zeros(Ma, Na)
-    p = plan_contract(StridedView(Cmat), Av, (1, 2), Bv, (2, 3), (1, 3); kernel = kernel)
-    @test p.Astorage === parent(Av)
-    @test p.mgroup.strides == ((1,), (1,))
-    @test p.ngroup.strides == ((Ka,), (Ma,))
-    execute!(p, 1.0, 0.0)
-    @test Cmat ≈ Amat * Bmat
-
-    # Into C's transpose: N's 12-wide run >= mr = 8, so B feeds M.
-    Ct = zeros(Na, Ma)
-    pt = plan_contract(StridedView(Ct), Av, (1, 2), Bv, (2, 3), (3, 1); kernel = kernel)
-    @test pt.Astorage === parent(Bv)
-    @test pt.mgroup.strides == ((Ka,), (1,))      # (B, C) maps over label 3
-    @test pt.ngroup.strides == ((1,), (Na,))      # (A, C) maps over label 1
-    @test pt.kgroup.strides == ((1,), (Ma,))      # (B, A) maps over label 2
-    execute!(pt, 1.0, 0.0)
-    @test Ct ≈ transpose(Amat * Bmat)
-    # ... but not when the run is too short for the kernel.
-    Ct2 = zeros(6, Ma)
-    Bv6 = StridedView(Bmat[:, 1:6])
-    pt2 = plan_contract(StridedView(Ct2), Av, (1, 2), Bv6, (2, 3), (3, 1); kernel = kernel)
-    @test pt2.Astorage === parent(Av)
-end
-
-@testset "label order: correctness on ccsd_t shapes, permuted/sliced C, alpha/beta, conj" begin
-    Random.seed!(0x1ABE_10DE)
-    d = 6
-    # C is a sliced, permuted view of a padded (c, k, a, j, b, i) array.
-    perm = (3, 5, 1, 6, 4, 2)  # output axis p takes physical axis perm[p]
-    for T in (Float64, Float32, ComplexF64, ComplexF32)
-        rtol = 200 * d * eps(real(T))
-        for (name, IA, IB) in _LO_CASES, (conjA, conjB) in ((false, false), (true, true))
-            (T <: Real) && conjA && continue  # conj is the identity on the real path
-            (indA, indB, indC), (pA, pB, pAB) = _lo_labels(IA, IB)
-            A = randn(T, d, d, d, d)
-            B = randn(T, d, d, d, d)
-            Av = conjA ? StridedView(A, size(A), strides(A), 0, conj) : StridedView(A)
-            Bv = StridedView(B)
-            Cbig = randn(T, d + 1, d + 2, d, d + 1, d, d + 3)
-            Csub = view(Cbig, 1:d, 2:(d + 1), :, 2:(d + 1), :, 3:(d + 2))
-            Cv = permutedims(StridedView(Csub), perm)
-            @test offset(Cv) != 0
-            @test !issorted(Base.strides(Cv))
-            Cstart = copy(Cv)
-            alpha = T <: Complex ? T(1.3, -0.4) : T(1.3)
-            beta = T <: Complex ? T(0.7, 0.2) : T(0.7)
-
-            Cref = _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA, conjB, alpha, beta)
-
-            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; conjA = conjA, conjB = conjB)
-            execute!(plan, alpha, beta)
-            @test isapprox(copy(Cv), Cref; rtol = rtol)
-
-            copyto!(Csub, permutedims(Cstart, invperm(perm)))
-            plan_tw = plan_contract(Cv, Av, indA, Bv, indB, indC; conjA = conjA, conjB = conjB)
-            @test (plan_tw.Astorage === parent(Bv)) == (plan.Astorage === parent(Bv))
-            execute_tilewise!(plan_tw, alpha, beta)
-            @test isapprox(copy(Cv), Cref; rtol = rtol)
-        end
-    end
-end
-
-@testset "label order: the swap never fires for complex kernels (guarded by T <: Real, deliberately deferred)" begin
-    # ccsd_t_3 would swap for a real dtype at this mr; the transforms follow
-    # the flag XOR A's `conj` op.
-    d = 4
-    for T in (ComplexF64, ComplexF32)
-        W = QuasiStrided._default_lanewidth(real(T))
-        kernel = QuasiStrided.PlanarKernel(Val(W), Val(8), T, Val(W))
-        @test mr(kernel) <= 16
-        (indA, indB, indC), _ = _lo_labels(_LO_CASES[3][2], _LO_CASES[3][3])
-        A = randn(T, d, d, d, d)
-        B = randn(T, d, d, d, d)
-        C = randn(T, d, d, d, d, d, d)
-        Av = StridedView(A, size(A), strides(A), 0, conj)
-        Bv = StridedView(B)
-        Cv = StridedView(C)
-        alpha, beta = T(0.5, 1.5), T(-1.0, 0.25)
-        for (conjA, conjB) in ((true, true), (true, false), (false, true))
-            Cstart = copy(C)
-            Cref = _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA, conjB, alpha, beta)
-            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; kernel = kernel, conjA = conjA, conjB = conjB)
-            @test plan.Astorage === parent(Av)   # the swap did NOT fire (complex)
-            @test plan.atransform === (conjA ? identity : conj)
-            @test plan.btransform === (conjB ? conj : identity)
-            execute!(plan, alpha, beta)
-            @test isapprox(C, Cref; rtol = 200 * d * eps(real(T)))
-            copyto!(C, Cstart)
-        end
-    end
-end
-
-@testset "label order: the adapter path reaches the reordered plan" begin
-    d = 6
-    for T in (Float64, ComplexF64), (name, IA, IB) in _LO_CASES
-        (indA, indB, indC), (pA, pB, pAB) = _lo_labels(IA, IB)
-        A = randn(T, d, d, d, d)
-        B = randn(T, d, d, d, d)
-        C = randn(T, d, d, d, d, d, d)
-        alpha = T <: Complex ? T(0.9, 0.3) : T(0.9)
-        beta = T <: Complex ? T(-0.5, 0.1) : T(-0.5)
-        Cref = _lo_reference(C, StridedView(A), indA, StridedView(B), indB, indC; alpha, beta)
-        TO.tensorcontract!(C, A, pA, false, B, pB, false, pAB, alpha, beta, QuasiStrided.QuasiStridedBackend())
-        @test isapprox(C, Cref; rtol = 200 * d * eps(real(T)))
-    end
-end
-
-# Contracted-label order. Labels a=1 b=2 c=3 d=4 e=5 with distinct extents.
-# `_KO_EXT` fits any L2; `_KO_BIG` makes B's lines touched before `d` advances
-# (b*c*e*64 B) exceed THIS host's L2 share, with e >= 40, so the model reorders
-# K wherever the suite runs.
-function _ko_big(l2 = QuasiStrided._l2_core_bytes(Float64))
-    e = max(40, fld(l2, 40 * 40 * 64) + 1)
-    return Dict(1 => 9, 2 => 40, 3 => 40, 4 => 5, 5 => e)
-end
-const _KO_EXT = Dict(1 => 9, 2 => 3, 3 => 4, 4 => 5, 5 => 6)
-const _KO_BIG = _ko_big()
-_ko_array(::Type{T}, ind, ext = _KO_EXT) where {T} = randn(T, Tuple(ext[l] for l in ind)...)
-_ko_stride(v, ind, l) = Base.strides(v)[findfirst(==(l), ind)]
-
-function _ko_order(Av, indA, Bv, indB, Cv, indC; l2bytes)
-    mlabels, nlabels, klabels = QuasiStrided._classify_labels(indA, indB, indC)
-    morder = QuasiStrided._order_free_labels(mlabels, indC, Cv)
-    norder = QuasiStrided._order_free_labels(nlabels, indC, Cv)
-    ext(ls) = prod((size(Cv, findfirst(==(l), indC)) for l in ls); init = 1)
-    return QuasiStrided._choose_k_order(
-        klabels, indA, Av, morder, indB, Bv, norder, ext(mlabels), ext(nlabels), l2bytes
-    )
-end
-
-@testset "K order: cost model picks among indA / A-sorted / B-sorted" begin
-    T = Float64
-    Av = StridedView(_ko_array(T, (1, 2, 3, 4)))   # A[a,b,c,d]: a unit-stride, 9 >= a line
-    Cv = StridedView(zeros(T, _KO_EXT[1], _KO_EXT[5]))
-
-    # contract_scrambled, B[d,c,b,e]: B-sorted once the lines in flight exceed L2.
-    Bs = StridedView(_ko_array(T, (4, 3, 2, 5)))
-    @test _ko_order(Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), Cv, (1, 5); l2bytes = 0) == (4, 3, 2)
-    @test _ko_order(Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), Cv, (1, 5); l2bytes = 1 << 20) == (2, 3, 4)
-
-    # gemm_ready B[b,c,d,e] and b_permuted B[b,e,c,d]: B-sorted == indA order.
-    for indB in ((2, 3, 4, 5), (2, 5, 3, 4))
-        Bv = StridedView(_ko_array(T, indB))
-        @test _ko_order(Av, (1, 2, 3, 4), Bv, indB, Cv, (1, 5); l2bytes = 0) == (2, 3, 4)
-    end
-
-    # TRG-shaped: sorting by B would give A a page-crossing K walk to save
-    # refetches of a small B, so indA order stays.
-    At = StridedView(randn(T, 8, 8, 8, 8, 8))
-    Bt = StridedView(randn(T, 8, 8, 8))
-    Ct = StridedView(zeros(T, 8, 8, 8, 8))
-    for l2bytes in (0, 1 << 20)
-        @test _ko_order(At, (1, 2, 3, 4, 5), Bt, (5, 6, 2), Ct, (1, 3, 4, 6); l2bytes) == (2, 5)
-    end
-
-    p = plan_contract(StridedView(zeros(T, 3, 5)), StridedView(randn(T, 3, 4)), (1, 2), StridedView(randn(T, 4, 5)), (2, 3), (1, 3))
-    @test p.kgroup.strides == ((3,), (1,))
-    # A singleton K axis is skipped as `kfast` and as `u`.
-    A1 = StridedView(randn(T, 9, 1, 4, 5))
-    B1 = StridedView(randn(T, 1, 5, 4, 6))
-    o = _ko_order(A1, (1, 2, 3, 4), B1, (2, 4, 3, 5), Cv, (1, 5); l2bytes = 0)
-    @test sort(collect(o)) == [2, 3, 4]
-    @test filter(!=(2), o) == (4, 3)  # B-sorted among the non-singletons
-end
-
-@testset "K order: static-length tuple, inferred, allocation-free" begin
-    T = Float64
-    ext = _KO_BIG
-    Av = StridedView(_ko_array(T, (1, 2, 3, 4), ext))
-    Bs = StridedView(_ko_array(T, (4, 3, 2, 5), ext))
-    Cv = StridedView(zeros(T, ext[1], ext[5]))
-    klabels, morder, norder = (2, 3, 4), (1,), (5,)
-    f(l2) = QuasiStrided._choose_k_order(klabels, (1, 2, 3, 4), Av, morder, (4, 3, 2, 5), Bs, norder, ext[1], ext[5], l2)
-    g() = QuasiStrided._order_contract_labels(klabels, (1, 2, 3, 4), Av, morder, (4, 3, 2, 5), Bs, norder, ext[1], ext[5])
-    @test @inferred(f(0)) === (4, 3, 2)
-    @test @inferred(g()) isa NTuple{3, Int}
-    f(0); g()
-    @test (@allocated f(0)) == 0 skip = (VERSION < v"1.11")
-    @test (@allocated g()) == 0 skip = (VERSION < v"1.11")
-    h1() = QuasiStrided._order_contract_labels((2,), (1, 2), Av, (1,), (2, 5), Bs, (5,), 9, 40)
-    h0() = QuasiStrided._order_contract_labels((), (1,), Av, (1,), (5,), Bs, (5,), 9, 40)
-    @test @inferred(h1()) === (2,)
-    @test @inferred(h0()) === ()
-end
-
-@testset "K order: plan_contract flips contract_scrambled at an L2-exceeding size" begin
-    T = Float64
-    ext = _KO_BIG
-    @test ext[2] * ext[3] * ext[5] * 64 > QuasiStrided._l2_core_bytes(T)
-    Av = StridedView(_ko_array(T, (1, 2, 3, 4), ext))
-    Bs = StridedView(_ko_array(T, (4, 3, 2, 5), ext))   # B[d,c,b,e]
-    Cv = StridedView(zeros(T, ext[1], ext[5]))
-    plan = plan_contract(Cv, Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), (1, 5))
-    @test plan.kgroup.lengths == (5, 40, 40)
-    @test plan.kgroup.strides[2] == (1, 5, 200)
-    @test plan.kgroup.strides[1] == Tuple(_ko_stride(Av, (1, 2, 3, 4), l) for l in (4, 3, 2))
-
-    # gemm_ready at the same size keeps indA order.
-    Bg = StridedView(_ko_array(T, (2, 3, 4, 5), ext))
-    p = plan_contract(Cv, Av, (1, 2, 3, 4), Bg, (2, 3, 4, 5), (1, 5))
-    @test p.kgroup.lengths == (40, 40, 5)
-    @test p.kgroup.strides[1] == (9, 360, 14400)
-
-    # Swapped (C stored as (e, a)): the same K order with the maps exchanged.
-    Ct = StridedView(zeros(T, ext[5], ext[1]))
-    kernel = SIMDKernel(Val(8), Val(6), T)
-    pt = plan_contract(Ct, Av, (1, 2, 3, 4), Bs, (4, 3, 2, 5), (5, 1); kernel = kernel)
-    @test pt.Astorage === parent(Bs)
-    @test pt.kgroup.lengths == (5, 40, 40)
-    @test pt.kgroup.strides[1] == (1, 5, 200)                     # B's map first
-    @test pt.kgroup.strides[2] == (14400, 360, 9)                 # then A's
-end
-
-@testset "K order: correctness on scrambled K (all dtypes, alpha/beta, conj, both orientations, oracle)" begin
-    Random.seed!(0x5C7A_0B1E)
-    ext = _KO_BIG
-    for T in (Float64, Float32, ComplexF64, ComplexF32)
-        rtol = 500 * eps(real(T))
-        alpha = T <: Complex ? T(1.3, -0.4) : T(1.3)
-        beta = T <: Complex ? T(0.7, 0.2) : T(0.7)
-        for (indA, indB, indC) in (
-                    ((1, 2, 3, 4), (4, 3, 2, 5), (1, 5)),   # scrambled, C[a,e] (reordered K)
-                    ((1, 2, 3, 4), (4, 3, 2, 5), (5, 1)),   # scrambled, C[e,a] (swap for real T)
-                    ((4, 3, 2, 1), (2, 3, 4, 5), (1, 5)),   # A transposed, K inner in both
-                    ((4, 3, 2, 1), (3, 2, 4, 5), (5, 1)),   # both scrambled, C transposed
-                ), (conjA, conjB) in ((false, false), (true, true))
-            (T <: Real) && conjA && continue
-            A = _ko_array(T, indA, ext)
-            B = _ko_array(T, indB, ext)
-            Av = conjA ? StridedView(A, size(A), strides(A), 0, conj) : StridedView(A)
-            Bv = StridedView(B)
-            C = randn(T, Tuple(ext[l] for l in indC)...)
-            Cstart = copy(C)
-            Cv = StridedView(C)
-            Cref = _lo_reference(Cstart, Av, indA, Bv, indB, indC; conjA, conjB, alpha, beta)
-            plan = plan_contract(Cv, Av, indA, Bv, indB, indC; conjA = conjA, conjB = conjB)
-            execute!(plan, alpha, beta)
-            @test isapprox(C, Cref; rtol = rtol)
-            copyto!(C, Cstart)
-            plan_tw = plan_contract(Cv, Av, indA, Bv, indB, indC; conjA = conjA, conjB = conjB)
-            execute_tilewise!(plan_tw, alpha, beta)
-            @test isapprox(C, Cref; rtol = rtol)
-        end
-    end
-end
diff --git a/test/quality/test_aqua.jl b/test/quality/test_aqua.jl
index d0e4945..ccfc375 100644
--- a/test/quality/test_aqua.jl
+++ b/test/quality/test_aqua.jl
@@ -5,8 +5,8 @@ using QuasiStrided
 @testset "Aqua" begin
     Aqua.test_all(
         QuasiStrided;
-        # Every flagged ambiguity is between methods of upstream packages.
-        ambiguities = false,
+        # Ambiguities between methods of upstream packages are not ours to fix.
+        ambiguities = (recursive = false,),
         # Flags `acc::NTuple{NV, Vec{W, R}}` signatures, which leave `W`/`R`
         # unbound only for an empty accumulator, which no kernel has.
         unbound_args = false,
diff --git a/test/runtests.jl b/test/runtests.jl
index cda2519..210379b 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1,64 +1,40 @@
-using Test
-using Random
+# Every test/**/test_*.jl file runs in its own module, on a pool of worker
+# processes. Arguments select files by name prefix, e.g.
+#
+#   Pkg.test("QuasiStrided"; test_args = ["execution/test_dot", "packing"])
+#
+# and `--list`, `--jobs=N`, `--verbose` are the runner's own. `Pkg.test` runs
+# with `--check-bounds=yes`, kept deliberately: it also runs the per-tile bounds
+# checks that `@inbounds` skips. `Pkg.test(; julia_args = ["--check-bounds=auto"])`
+# is the fast local run.
+
+using ParallelTestRunner
 using QuasiStrided
-# Internal names the test files use unqualified.
-using QuasiStrided: AxisGroup, axis_length, offsets, fill_offsets!, BlockDescriptor,
-    describe_block, block_descriptors!, normalize_group, KernelDescriptor, mr, nr,
-    scalartype, packed_a_offset, packed_b_offset, packed_a_length, packed_b_length,
-    AffineAxis, ScatterAxis, SourceTile, DestinationTile, axis_from_descriptor, nrows,
-    ncols, axis_offset_range, checked_tile_storage_bounds, pack_a!, pack_b!,
-    zero_accumulator, accumulate, store_tile!, execute_tile!, lanewidth, contract!,
-    Blocking, default_blocking, ScalarKernel, SIMDKernel, TargetProfile, CacheLevel,
-    target_profile, cache_topology, unknown_target, _detect_isa, _detect_target,
-    _derived_shape, _fallback_shape, _shape_override, _kernel_for, _default_kernel,
-    _fallback_blocking, kernel_shapes, _parse_size, _count_cpu_list, NR_DEFAULT,
-    _rule_applies, _isa_nregisters, packed_a_per_k, packed_b_per_k, realtype,
-    complex_method, RealMethod, PlanarMethod, OneMMethod, accumulator_planes, a_reals,
-    b_reals, FMAddSubMethod, _modelled_blocking, _scale_blocking, _real_blocking_row,
-    _planar_pressure, _pack_split, _NestPath
-# plan_contract, execute! and ContractPlan are bound in helpers.jl instead.
 
-# All files share one scope, so helper names must be unique across files.
-@testset "QuasiStrided.jl" begin
-    include("helpers.jl")
-
-    include("hardware/test_target.jl")
-
-    include("layout/test_axis_group.jl")
-    include("layout/test_stridedviews_axisgroup.jl")
-    include("layout/test_tiles.jl")
-
-    include("packing/test_kernel_descriptor.jl")
-    # Defines `ref_pack`/`pack_fixture`, which the two complex packing files reuse.
-    include("packing/test_pack_real.jl")
-    include("packing/test_pack_complex.jl")
-    include("packing/test_pack_complex_contiguous.jl")
-
-    # Defines the `mk_*` kernel-contract helpers the other microkernel files use.
-    include("microkernels/test_scalar_kernel.jl")
-    include("microkernels/test_simd_kernel.jl")
-    include("microkernels/test_planar_kernel.jl")
-    include("microkernels/test_planar_store_fastpath.jl")
-    include("microkernels/test_onem_kernel.jl")
-    include("microkernels/test_fmaddsub_kernel.jl")
-    include("microkernels/test_mixed_kernel.jl")
-
-    include("planning/test_kernel_selection.jl")
-    include("planning/test_plan_contract.jl")
-    include("planning/test_per_call_overhead.jl")
-
-    include("execution/test_manual_pipeline.jl")
-    include("execution/test_execute.jl")
-    include("execution/test_workspace.jl")
-    include("execution/test_scalar_vs_simd.jl")
-    include("execution/test_macro_blocking.jl")
-    # These use test_execute.jl's shared helpers and brute-force reference.
-    include("execution/test_unpackedb.jl")
-    include("execution/test_dot.jl")
-    include("execution/test_outer.jl")
-    include("execution/test_mixed.jl")
-
-    # Last: its `using TensorOperations` makes `scalartype` ambiguous for later files.
-    include("integrations/test_tensoroperations.jl")
-    include("quality/test_aqua.jl")
+testsuite = find_tests(@__DIR__)
+filter!(p -> startswith(basename(first(p)), "test_"), testsuite)
+
+# Set by forced_isa_runner.jl: every worker runs on that target.
+fake_target = :()
+if haskey(ENV, "QS_FAKE_ISA")
+    fake_target = quote
+        using QuasiStrided: TARGET, TargetProfile, CacheLevel
+        TARGET[] = TargetProfile(
+            Symbol(ENV["QS_FAKE_ISA"]), "forced-isa-runner",
+            let l1d = parse(Int, get(ENV, "QS_FAKE_L1D", "0"))
+                CacheLevel(l1d, 0, l1d > 0 ? 1 : 0)
+            end,
+            CacheLevel(parse(Int, get(ENV, "QS_FAKE_L2", "0")), 0, parse(Int, get(ENV, "QS_FAKE_L2_SHARING", "0"))),
+            CacheLevel()
+        )
+    end
+    eval(fake_target)
+    let p = QuasiStrided.target_profile()
+        println(
+            "forced target: isa=", p.isa, " vector_bytes=", p.vector_bytes, " nregisters=", p.nregisters,
+            " l1d=", p.l1d.bytes, " l2=", p.l2.bytes, "/", p.l2.sharing
+        )
+    end
 end
+
+runtests(QuasiStrided, ARGS; testsuite, init_worker_code = fake_target)