test: close concave union crossing and transit ownership

test: define union space-time event ownership contract
test: prepare matched shifted GPU spacing ladder
2026-10-18 13:35:06 -07:00 · 2026-10-18 13:20:35 -07:00 · 2026-10-18 12:35:05 -07:00 · 2026-10-18 12:03:35 -07:00 · 2026-10-18 11:13:50 -07:00 · 2026-10-18 10:47:51 -07:00
127 changed files with 5383 additions and 6319 deletions
@@ -112,9 +112,8 @@ from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
 cfg = LBMConfig(nx=32, ny=24, viscosity=.1)
 body = SimObject(0, geometry=CircleGeometry(16.0, 12.0, 2.15), center=(16.0, 12.0), radius=2.15,
                 surface_actuation=SurfaceActuation(0.7, 0.85, 0.002))  # angle, half-width, speed
-with CudaContext(0) as ctx, FixedPatchStepper(cfg, context=ctx, refinements=[(8, 6, 24, 18)],
-                                              level_blocks=[None, (16, 20)],
-                                              level_objects=[(), (body,)]) as run:
+with CudaContext(0) as ctx, FixedPatchStepper(cfg, (8, 6, 24, 18), context=ctx,
+                                              fine_objects=[body], fine_block=(16, 20)) as run:
    rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
    # (9, ny, nx) postcollision populations per level; non-leaf cells are discarded.
    run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
@@ -124,9 +123,7 @@ with CudaContext(0) as ctx, FixedPatchStepper(cfg, context=ctx, refinements=[(8,
 ```

 Scope and limits:
- The examples below use D2Q9, SRT, FP32, double buffer, unshifted, no LES or
-  forcing. Fixed 2:1 hierarchies use level lists of arbitrary depth; two- and
-  three-level examples below use that same constructor.
+- D2Q9, SRT, FP32, double buffer, unshifted, no LES or forcing; fixed 2:1 patch(es), two levels (or one nested third).
 - `coarse_boundary="periodic"` (default) or `"slot_reservoir"` (bottom slot, top
  reservoir; patch needs `y0 >= 4`, `y1 <= ny-4`). Periodic mode ignores the wall/slot config fields.
 - Object centers/radii use the coarse **cell-edge** frame (cell `I` spans `[I, I+1)`),
@@ -134,51 +131,46 @@ Scope and limits:
 - Bodies must be stationary circles whose whole boundary stencil lies in the fine
  active region, clear of the coarse/fine transfer cells; violations are rejected
  before any GPU allocation.
- `level_blocks=[None, (by, bx)]` stores the fine level in fixed-size blocks; `by`/`bx` must
+- `fine_block=(by, bx)` stores the fine level in fixed-size blocks; `by`/`bx` must
  divide the WHOLE fine allocation, i.e. `2*(y1-y0)+8` by `2*(x1-x0)+8` including the
  four-cell ghost band. It gives results identical to dense storage and is
  infrastructure for future block AMR, not a speedup.
- Several regions: pass a sequence of `(x0, y0, x1, y1)` rectangles as
-  `refinements[0]`, with both levels blocked (`level_blocks`). Transfers are built once
-  from their union; adjacent, overlapping and concave unions are accepted when
-  their actual dependencies close. There is no fixed rectangle-gap rule.
-  The fine level is then one level-wide grid `(2*ny, 2*nx)`:
+- Several separated patches: pass a sequence of `(x0, y0, x1, y1)`
+  rectangles as `bounds`, at least 4 coarse cells apart, with both `fine_block`
+  and `base_block`. The fine level is then one level-wide grid `(2*ny, 2*nx)`:
  `run.patch.fine_shape` gives it, `initialize`/`download` use it, and only the
-  grid-aligned tiles intersecting the union plus its four-cell ghost band are stored.
-  Block sizes must divide the level-wide grid; rectangle edges need not align
-  with tiles. Order of rectangles does not matter. L1 bodies/Jets (`level_objects[1]`/`level_jets[1]`) work
-  as for one patch: each circle (same coarse cell-edge frame) must lie wholly
-  inside the union's active region with
+  patch windows (active region plus 4-cell ghost band, origin `(2*y0-4, 2*x0-4)`)
+  are stored; each window must align with `fine_block`. Order of rectangles does
+  not matter. `fine_objects`/`jets` work as for one patch: each circle (same
+  coarse cell-edge frame) must lie wholly inside one patch's active region with
  its boundary stencil clear of transfer cells; a jet may not select links of two
-  different bodies, even across regions. Wall-touching patches remain unsupported.
-  For nesting, add further `refinements` entries as shown below.
+  different bodies, even across patches. No wall-touching patches or nesting yet.

  ```python
  cfg = LBMConfig(nx=32, ny=16, viscosity=.1)
  rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
  with CudaContext(0) as ctx, FixedPatchStepper(
-          cfg, context=ctx, refinements=[((4, 4, 12, 12), (16, 4, 24, 12))],
-          level_blocks=[(4, 4), (4, 4)]) as run:
+          cfg, ((4, 4, 12, 12), (16, 4, 24, 12)), context=ctx,
+          fine_block=(4, 4), base_block=(4, 4)) as run:
      run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
                     np.broadcast_to(rest, (9, *run.patch.fine_shape)))  # (9, 32, 64)
      run.step(32)
      coarse_g, fine_g = run.download()  # coarse: NaN on every covered cell;
                                         # fine: NaN on every non-ACTIVE cell
  ```
- Three-level nested windows: pass two scalar rectangles in `refinements` —
-  L1 in L0 cells, L2 in **L1 window cells** (the parent's fine grid including its
-  4-cell ghost band) — plus all three `level_blocks` entries. L2 must sit inside
-  L1's ACTIVE cells, away from L1's ghost band and transfer footprint (checked
-  before any GPU allocation). `initialize` and `download` take/return three
-  arrays; each level is NaN on its non-ACTIVE (and child-covered) cells. One
-  coarse step = 2 L1 steps = 4 L2 steps. One L1 window only in this scalar
-  chain. Optional stationary circles and Jets live on L2 via `level_objects[2]`
-  and `level_jets[2]`; L1 bodies/Jets retain their L1 meaning and must be empty
-  in this mode. All object and Jet geometry uses the **L0 edge frame**, not the
-  child bounds' L1 window frame. L2 has dx=dt=0.25, so prescribed lattice
-  velocity is unchanged. Each whole body and its BFL stencil must be inside L2
-  ACTIVE cells, outside the transfer footprint. A Jet may select one physical
-  body across multiple blocks, never two bodies.
+- Three levels (one nested chain): add `child=(x0, y0, x1, y1)` in
+  **L1 window cells** (the patch's fine grid including its 4-cell ghost band) and
+  `child_block`, with `fine_block` and `base_block`. L2 must sit inside L1's
+  ACTIVE cells, away from L1's ghost band and transfer footprint (checked before
+  any GPU allocation). `initialize` and `download` take/return three arrays; each
+  level is NaN on its non-ACTIVE (and child-covered) cells. One coarse step = 2 L1
+  steps = 4 L2 steps. One L1 patch only. Optional stationary circles and Jets
+  live on L2 via `child_objects` and `child_jets`; `fine_objects`/`jets` retain
+  their L1 meaning and must be empty in this mode. All object and Jet geometry
+  uses the **L0 edge frame**, not the child bounds' L1 window frame. L2 has
+  dx=dt=0.25, so prescribed lattice velocity is unchanged. Each whole body and
+  its BFL stencil must be inside L2 ACTIVE cells, outside the transfer footprint.
+  A Jet may select one physical body across multiple blocks, never two bodies.

  ```python
  from CelerisLab.body.geometry.circle import CircleGeometry
@@ -190,9 +182,9 @@ Scope and limits:
  jet = Jet(Tube((6.5, 8.), 0., 3., .3), Parallel(0.), amplitude=.002)
  rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
  with CudaContext(0) as ctx, FixedPatchStepper(
-          cfg, context=ctx, refinements=[(4, 4, 12, 12), (8, 8, 16, 16)],
-          level_blocks=[(4, 4)] * 3, level_objects=[(), (), (body,)],
-          level_jets=[(), (), (jet,)]) as run:
+          cfg, (4, 4, 12, 12), context=ctx, fine_block=(4, 4), base_block=(4, 4),
+          child=(8, 8, 16, 16), child_block=(4, 4),
+          child_objects=[body], child_jets=[jet]) as run:
      shapes = (run.patch.coarse_shape, run.patch.fine_shape, run.child_patch.fine_shape)
      run.initialize(*(np.broadcast_to(rest, (9, *s)) for s in shapes))  # 16², 24², 24²
      run.step(4)
@@ -200,30 +192,14 @@ Scope and limits:
      run.step(4)
      coarse_g, l1_g, l2_g = run.download()  # solids/covered/nonleaves are NaN
  ```
- Level lists (the only constructor): `refinements[l]` describes level `l+1`
-  in allocated level-`l` integer cells; use a rectangle list for a union, or a
-  scalar rectangle for a single window (a scalar child requires a scalar
-  parent). `level_blocks`, `level_objects` and `level_jets` each have one entry
-  per level, including L0. Three or more levels require all-blocked storage and
-  bodies/Jets only on the finest level. Every adjacent pair must preserve
-  inherited ACTIVE coverage, valid donors/receivers, surviving pulls and the
-  upstream transfer footprint. Level `l` takes `2**l` steps per base interval.
-  This describes implemented topology and scheduling, not accuracy or
-  convergence qualification.
- Blocked body levels can enable `observe_raw_exchange=True` and call
-  `read_raw_exchange(body_id, level=...)` after a completed base interval.
-  It reduces unique cut-link observations into wall/aperture/total force,
-  torque and mass exchange in base-lattice units per unit depth, for the last
-  base interval (default) or `window="last_substep"`.
-  `observe_window_exchange=True`, alongside `observe_raw_exchange=True`, enables
-  `start_exchange_window()` / `read_exchange_window(body_id, level=...)` across
-  completed base intervals. These are raw boundary-reaction diagnostics, not a general
-  stress or nozzle-load accuracy claim; dense body layouts are unsupported.
- Not available: checkpoints, moving bodies, L1 bodies/Jets in a three-level
-  chain, automatic dynamic refinement, `Simulation` integration. Qualification
-  depends on the tested configuration; see [the validation scope](docs/validation/2d_scope.md).
-  CPU topology/schedule tests alone do not establish GPU numerical correctness,
-  general convergence or long-time stability.
+- Not available: per-link surface exchange/force readout in blocked mode,
+  checkpoints, moving bodies, L1 bodies/Jets in a three-level chain,
+  several patches per level with nesting, dynamic refinement, `Simulation`
+  integration. Validation so far is storage/operator equivalence and short runs,
+  not accuracy, convergence or long-time stability. The new L2-body GPU gates
+  (layouts, masks, amplitude reversal, legacy equivalence) and independent
+  every-substep numerical replay remain required acceptance checks; CPU tests
+  alone do not establish GPU numerical correctness.

 ## Installation

@@ -1,35 +0,0 @@
-# Compatibility and API changes
-
-Changes that can make a previously accepted setup or call behave differently.
-Each entry names the commit, the affected entry points and the observable result.
-
-## 87c3a31: cut-link ownership is validated for every body
-
-`validate_cut_link_ownership` (`body/preprocess/flag_overlay.py`) now runs for
-passive bodies as well as Jet/aperture bodies. Every cut link must have an
-active fluid receiver (FLUID set, SOLID clear), and each `(receiver, direction)`
-population may have only one writer.
-
-Rejected with `ValueError`, before flags, populations or device buffers change:
-
-1. Overlapping or touching passive solids whose cut links write the same
-   population ("Boundary requires unique cut-link writers").
-2. A body whose cut-link receiver is a non-fluid cell, e.g. a channel wall row
-   or the inlet/outlet column ("Cut links must have active fluid receivers").
-
-Both were previously accepted silently for passive bodies; the interpolated
-boundary then had undefined results. The rules apply to the cut links of all
-bodies together, so a passive body overlapping a Jet body is rejected as well.
-The check runs in `Simulation.initialize`, runtime body sync (`sync_bodies`),
-checkpoint save and checkpoint load (`common/checkpoint.py`). Load validates
-before restoring anything, so a checkpoint whose saved geometry violates either
-rule no longer restores; rebuild the geometry with separated bodies.
-
-## 87c3a31: `Simulation.read_surface_exchange` accepts Jet-driven bodies
-
-`read_surface_exchange(id)` previously required `SurfaceActuation` on the body.
-It now also accepts bodies that own Jet aperture links, including Jets with zero
-or negative amplitude (the aperture test is geometric). Bodies with neither
-`SurfaceActuation` nor aperture links still raise
-`ValueError("Body has no surface actuation")`. The value is unchanged: the latest
-step's wall/aperture exchange, not total nozzle force.
@@ -1,57 +0,0 @@
-# Experimental projected G explosion
-
-`FixedPatchStepper(..., explosion="projected_linear")` changes only the existing
-G-to-G explosion reconstruction. The omitted/default `"constant"` selector retains
-the same kernel, launch arguments and device allocations. Projected mode adds two
-compact tables per adjacent pair; recursion, collision, BFL, restriction, buffer
-ownership and synchronized publication are unchanged. `remap_child` preserves it.
-
-Runtime eligibility is periodic-root, fully blocked D2Q9/SRT/FP32, body/Jet-free,
-without LES; the fixed-patch backend has no forcing interface. Shifted and unshifted
-storage use the same reconstruction. One generic builder handles scalar windows,
-unique union rows and all adjacent hierarchy pairs without depth/rectangle caps.
-Donors are original explosion donors intersected with owned, uncovered ACTIVE
-cells. An axis uses centered differences only if both neighbors are legal;
-otherwise both addresses repeat the center. Nested layout periodicity is explicit.
-No covered cells, holes, inactive cells or stale halo copies enter the stencil.
-
-The 33-line kernel is unchanged from our `519473a` experiment and retains its
-mathematical attribution. Host tests cover union decomposition, concavity, narrow
-gaps, grazing packet paths, offsets, sparse/nested owner addresses, three/four-level
-source timing, unchanged constant dispatch, remapping and shifted/unshifted actual
-kernel arithmetic compiled as host C++. These are not CUDA or flow validation.
-
-## Reviewed bounded evidence
-
-The `1aa8110` CUDA gate, with production exactly `a135252`, passed exact-dev
-omitted/default and explicit-constant equivalence, per-population reconstruction,
-scalar/union/four-level scheduling, alternate layouts, and changed remapping in
-both storage modes. Operator maximum error was 2.98023224e-8; the eight-step
-concave replay maximum was 1.58037614e-7. Whole-step mass/momentum remain
-finite diagnostics, not an FP32 conservation certificate. Reviewed evidence:
-`7aa66ff0542175092753ea099f40b903ece0527e`.
-
-The fresh four-case `2cf9853` N128/256 Taylor–Green repeat retained all `11901a7`
-settings and gates. All 20 main scalar rows and 260 early-pressure samples matched
-the older receipts exactly; this is not field-array equality. Projected worst
-velocity was 0.001995299260844 versus 0.002 (only 0.235% margin), pressure
-0.012157174904932 and energy 0.001184362645162. Constant velocity
-0.004418076615223 failed its gate, so the aggregate verdict remains false.
-The projected early sampled pressure peak was 0.021621453573334; it remains a
-descriptive sampled maximum. Reviewed evidence: `90849a55cad4a0da9b72747da7bfe6eb75962a44`.
-
-The old N64 projected failures remain relevant. These results support only this
-bounded plumbing gate and short periodic Re100 smooth-decay experiment. They do
-not establish union/multilevel physics accuracy, convergence, long-time stability,
-body/Jet, boundary, forcing, MRT or LES suitability. Constant remains the default.
-
-## Separate LES source profile
-
-The two older LES source manifests and the historical default are unchanged and
-correctly reject this different source tree. The existing LES runner now offers
-`--experiment a135252`, pinning all 101 actual committed corrected source files.
-Its explicit baseline-header override describes only a synthetic isolated reverse
-control, never the committed a135252 header. The unchanged corrected-only uniform
-LES regression (Cs=0/.16/1) is the remaining integration gate; no LES result is
-inherited from the projected evidence. The separate historical jet-CV `channel.py`
-pin mismatch predates this port and is not addressed here.
@@ -25,7 +25,7 @@ under the alternate compile branch.
 - No LES, no external forcing (`d_params` force fields stay zero).
 - Shifted Jets stay SRT-only: `body/jets.py` keeps its existing guard. This extension does not
  provide shifted MRT Jets.
- `PeriodicBlockStepper` (uniform blocked stepper) remained SRT-only; it was removed in 8e1feff and its single-level capability, still SRT-only, is `FixedPatchStepper(refinements=[])`.
+- `PeriodicBlockStepper` (uniform blocked stepper) remains SRT-only.

 ## Evidence status
 CPU: `tests/unit/test_refinement_mrt.py` (host guards, source contract). GPU:
@@ -1,6 +1,6 @@
 # Blocked AMR root channel increment

-Opt in with `FixedPatchStepper(..., coarse_boundary="channel", refinements=[bounds], level_blocks=[(by,bx), (fy,fx)])`. Every level must be blocked. The supported boundary is the existing uniform D2Q9/SRT/FP32 double-buffer channel: local Zou-He west inlet, pressure-NEQ east outlet, stationary halfway bounce-back y walls. Uniform and parabolic inlet profiles and shifted/unshifted storage are supported; the existing configuration guards still reject MRT/LES and incompatible storage. This does not change the external DFG MRT reference.
+Opt in with `FixedPatchStepper(..., coarse_boundary="channel", base_block=(by,bx), fine_block=(fy,fx))`, or the existing level-list form. Every level must be blocked. The supported boundary is the existing uniform D2Q9/SRT/FP32 double-buffer channel: local Zou-He west inlet, pressure-NEQ east outlet, stationary halfway bounce-back y walls. Uniform and parabolic inlet profiles and shifted/unshifted storage are supported; the existing configuration guards still reject MRT/LES and incompatible storage. This does not change the external DFG MRT reference.

 `step/block_channel.cu` is a small root-only kernel. Fine kernels, transfer kernels and recursive hop scheduling are unchanged. Global coordinates and the global profile height/velocity are separate from block-local storage strides. Corner ownership and collision phases match `OneStep`:

@@ -1,393 +0,0 @@
-# Evidence index (draft, R0)
-
-Active-tree evidence at candidate 0f8fdbc30ea640c764b38ee598d8f4d135c81c85, classified for the release cleanup
-(thread C0C78UFKGRM 1793021833.593279). Draft for review: nothing is removed by this file.
-Recovery of any listed file: `git show 0f8fdbc3:<path>` (blob id given; an immutable tag is requested as anchor).
-
-Classes: K = conclusion kept in the active tree; K-code = tested research code kept; D-snapshot = pre-Gitea
-patch/diff transport (code landed in git from ed1a6ee on; not yet verified hunk by hunk); P-pin = generated hash inventories, git-status dumps and manifests;
-R-raw = run outputs, logs, signals, frames, one-shot run scripts and handoff notes. D, P, R leave the active tree in R1.
-No file under src/ or a test reads any of these paths (git grep at 0f8fdbc3); runners under tests/validation
-that read research/j* are handled in R2.
-
-| Class | Files | Bytes |
-|---|---:|---:|
-| K | 31 | 196,506 |
-| K-code | 3 | 24,324 |
-| D-snapshot | 18 | 338,948 |
-| P-pin | 50 | 979,177 |
-| R-raw | 142 | 3,790,554 |
-
-## (root)
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| BASELINE_JET_AMR.txt | R-raw | 5,244 | 62aa2a66dc05 |
-
-## output
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| round3_compatibility_summary.md | R-raw | 4,366 | f243318f5591 |
-
-## research/fine_surface_20261014
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 54,507 | 71a4543ead37 |
-| cpu_device_guard_cmd.txt | R-raw | 241 | 06e0f35d92b3 |
-| cpu_device_guard_exit.txt | R-raw | 2 | 573541ac9702 |
-| cpu_device_guard_stdout.txt | R-raw | 98 | 424d584a031c |
-| cpu_existing_runs.json | R-raw | 650 | 3179536407b7 |
-| cpu_final_run.json | R-raw | 386 | 523fadb3fec9 |
-| cpu_final_stdout.txt | R-raw | 99 | 9cfe73da3858 |
-| cpu_lifecycle_run.json | R-raw | 387 | 5b403b9e2f30 |
-| cpu_lifecycle_stdout.txt | R-raw | 112 | 3c5c49b285fa |
-| cpu_maps_stdout.txt | R-raw | 95 | 71dd87f9faf9 |
-| cpu_preallocation_run.json | R-raw | 337 | fa6e96d98cdd |
-| cpu_preallocation_stdout.txt | R-raw | 98 | 5d643576f251 |
-| cpu_shared_kernel_stdout.txt | R-raw | 98 | 8a0c046bb9b1 |
-| cpu_surface_command.txt | R-raw | 113 | 2a5ff31e8d06 |
-| cpu_surface_exit.txt | R-raw | 2 | 573541ac9702 |
-| cpu_surface_projection_command.txt | R-raw | 171 | 70b7f5c62c1a |
-| cpu_surface_projection_exit.txt | R-raw | 2 | 573541ac9702 |
-| cpu_surface_projection_stdout.txt | R-raw | 113 | efd37a149cc1 |
-| cpu_surface_stdout.txt | R-raw | 99 | 9cfe73da3858 |
-| gpu_preparation_run1.py | R-raw | 14,043 | ee586d035b7a |
-| gpu_run.json | R-raw | 2,943 | 15b8ba70d528 |
-| gpu_stdout.txt | R-raw | 5,424 | c5216e0267f3 |
-| gpu_test_run1.py | R-raw | 15,479 | f30376abc97f |
-| incremental.diff | D-snapshot | 53,853 | 318d92e7d177 |
-| manifest.json | P-pin | 8,411 | 8281338416af |
-| report.txt | K | 8,373 | 6b9e5123e414 |
-
-## research/fine_surface_joint_20261014
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline_00.json | P-pin | 21,302 | 4ae101ebd02b |
-| baseline_01.json | P-pin | 26,191 | 548cf7b3b494 |
-| baseline_02.json | P-pin | 22,440 | e0421e7a4052 |
-| baseline_03.json | P-pin | 8,584 | da99b45f32a4 |
-| blow_boundary.csv | R-raw | 12,536 | e13363b69457 |
-| blow_collisions.csv | R-raw | 19,145 | 5d5b395486bb |
-| blow_ledger.csv | R-raw | 15,977 | b43bbfd0b8d2 |
-| blow_propagation.csv | R-raw | 9,714 | f06d80d296ca |
-| blow_signals.npz | R-raw | 221,114 | 528adf75baa2 |
-| blow_summary.json | R-raw | 4,113 | 32285ac15be3 |
-| command.txt | R-raw | 232 | 510ecb2925dd |
-| criteria.txt | K | 7,480 | dd36e76a3be1 |
-| frozen.json | R-raw | 11,972 | b5a3324e8686 |
-| gpu_run.json | R-raw | 1,955 | 67ac4785f7e4 |
-| incremental.diff | D-snapshot | 625 | e03c132d22df |
-| integrity.json | P-pin | 826 | a8b6e4be88d2 |
-| manifest.json | P-pin | 4,388 | d2af50260c39 |
-| regions.json | R-raw | 27,525 | 7bba26904221 |
-| report.txt | K | 8,207 | d7571e068ad3 |
-| result.json | R-raw | 11,442 | 9580c2686e70 |
-| review.txt | K | 2,117 | bbe1d8a83d47 |
-| runner.py | R-raw | 5,847 | 812973acc000 |
-| stdout.txt | R-raw | 19,940 | c9218e2e48fc |
-| suction_boundary.csv | R-raw | 12,505 | b870be05e6c0 |
-| suction_collisions.csv | R-raw | 19,173 | 2de48c0a84ab |
-| suction_ledger.csv | R-raw | 16,208 | 92cf1f44911e |
-| suction_propagation.csv | R-raw | 9,720 | f017bcc3ca6f |
-| suction_signals.npz | R-raw | 220,058 | 66d06cf2d909 |
-| suction_summary.json | R-raw | 4,126 | d70a1d371950 |
-| validate.py | R-raw | 19,576 | 37441febd168 |
-| zero_boundary.csv | R-raw | 11,491 | 65c92e48c974 |
-| zero_collisions.csv | R-raw | 18,915 | 027cb8ff6b23 |
-| zero_ledger.csv | R-raw | 16,051 | 34a99bb89dd7 |
-| zero_signals.npz | R-raw | 127,958 | a966f093a9cd |
-| zero_summary.json | R-raw | 1,508 | 6e033f991438 |
-
-## research/fixed_patch_jet_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 69,721 | 91ad9c4d1e88 |
-| before.json | R-raw | 690 | 06e1b6278a29 |
-| fixed_patch_jet.py | R-raw | 9,646 | 6fbdcd9a076b |
-| incremental.patch | D-snapshot | 9,891 | b43129d82c69 |
-| manifest.json | P-pin | 1,967 | 08daa0248f60 |
-| notes.txt | K | 2,214 | 50070fe54efb |
-| results.json | R-raw | 1,100 | d959a6a1cc2c |
-| stdout.txt | R-raw | 1,272 | eccdc0f6b16a |
-
-## research/fixed_patch_jet_closure_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 72,692 | 8a157af82ecf |
-| cpu_results.json | R-raw | 628 | 8e4a1c090c93 |
-| cpu_stdout.txt | R-raw | 590 | d800b783fe47 |
-| incremental.patch | D-snapshot | 3,490 | a9a486c68afd |
-| layout_uncropped.png | R-raw | 51,785 | 0cf1cfa5e99d |
-| manifest.json | P-pin | 1,849 | 31cf0c739241 |
-| notes.txt | K | 3,023 | 0f7e7bdfd0e6 |
-
-## research/fixed_patch_jet_records_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 71,228 | a8e967f76e08 |
-| before.json | R-raw | 690 | ebd6f4251fc2 |
-| fixed_patch_jet.py | R-raw | 10,650 | f6b299885da0 |
-| incremental.patch | D-snapshot | 5,539 | c7f4d0c02ccc |
-| manifest.json | P-pin | 2,057 | 1d616c2541df |
-| notes.txt | K | 2,449 | b58cec14d359 |
-| results.json | R-raw | 1,136 | 788af64a6ebd |
-| stdout.txt | R-raw | 20,750 | a765b06deefa |
-
-## research/j1-2026-10-12
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| REVIEW.md | K | 7,667 | 8f469daef054 |
-| baseline-status.txt | P-pin | 2,601 | 64ca05ab952e |
-| baseline.json | P-pin | 23,052 | ab5852bcb0ef |
-| incremental.diff | D-snapshot | 29,912 | dd9c4e688888 |
-| results.json | R-raw | 68,294 | 56547aa8a678 |
-
-## research/j2-slot-2026-10-12
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| REVIEW.md | K | 12,930 | 69fa4d3bccd3 |
-| baseline-status.txt | P-pin | 2,825 | e711afb0016c |
-| baseline.json | P-pin | 24,660 | 286e023da94f |
-| incremental.diff | D-snapshot | 25,231 | 649f3b5d168d |
-| results.json | R-raw | 477,249 | b4272e25179d |
-
-## research/j3-coverage-2026-10-12
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| REVIEW.md | K | 11,409 | 5887cf73dce2 |
-| baseline-status.txt | P-pin | 3,055 | 78e88356caa3 |
-| baseline.json | P-pin | 30,407 | 095972547a7f |
-| incremental.diff | D-snapshot | 20,114 | f0d502dc5c5b |
-| negative-budget-20744.h5 | R-raw | 88,017 | 693b133be84d |
-| negative-end-20760.h5 | R-raw | 88,174 | 429270d263d4 |
-| restart-21280.h5 | R-raw | 88,062 | 74900affae38 |
-| restart-reference-21296.h5 | R-raw | 88,154 | 7510ee97885b |
-| results.json | R-raw | 296,314 | 7806b10e65cb |
-| verification.json | K | 1,468 | 78a07c47aea4 |
-
-## research/j3-lag-2026-10-12
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| REVIEW.md | K | 11,732 | 34fe5dbb2cae |
-| baseline-status.txt | P-pin | 2,968 | 6ae6094ea9d7 |
-| baseline.json | P-pin | 26,505 | 5c289d14ff30 |
-| end-21280.h5 | R-raw | 92,366 | f30b209179ab |
-| incremental.diff | D-snapshot | 15,790 | 5c6c485e1f75 |
-| results.json | R-raw | 21,718 | 2bf58939129c |
-| start-20760.h5 | R-raw | 92,247 | ae0abd05190c |
-
-## research/j3-offline-2026-10-12
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| REVIEW.md | K | 6,271 | a76e1b486bd2 |
-| lags.csv | R-raw | 1,104 | dd3136dd2dc2 |
-| localization.png | R-raw | 136,013 | 74b56f3e814c |
-| regions.csv | R-raw | 2,126 | 5d361e6872af |
-| results.json | R-raw | 8,852 | bf77b0f534d4 |
-
-## research/j3-reservoir-2026-10-12
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| REVIEW.md | K | 13,563 | a74b67a64e0d |
-| baseline-status.txt | P-pin | 2,896 | a318e077dfae |
-| baseline.json | P-pin | 25,571 | 060502ea7dd8 |
-| incremental.diff | D-snapshot | 22,898 | 8e2c79a86c98 |
-| results.json | R-raw | 182,747 | 7fd5e51a1785 |
-
-## research/refinement_example_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 8,286 | 591478100da8 |
-| before.json | R-raw | 818 | 7ab0962775b1 |
-| incremental.patch | D-snapshot | 8,682 | 7ad8719d0167 |
-| manifest.json | P-pin | 1,798 | bf1eee8a7cf8 |
-| notes.txt | K | 1,185 | 7ff019ad023d |
-| results.json | R-raw | 1,118 | 94697b0988b9 |
-| stdout.txt | R-raw | 325 | 501446f557f4 |
-
-## research/refinement_followup_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.txt | K | 4,887 | af65e889f20e |
-| baseline.json | P-pin | 5,343 | 7c60ad8ad692 |
-| cleanup.json | R-raw | 1,253 | 15cf342fba2e |
-| cpu_results.json | R-raw | 1,056 | 1166dffd2a09 |
-| cpu_results_attempt1.json | R-raw | 642 | d139d5508105 |
-| cpu_stdout.txt | R-raw | 499 | d1b33ea20563 |
-| cpu_stdout_attempt1.txt | R-raw | 879 | 6a9fe7fce39a |
-| gpu_before.json | R-raw | 589 | 46762a0ab207 |
-| gpu_before_no_launch.json | R-raw | 589 | 074982d1b2d4 |
-| gpu_rectangle_before.json | R-raw | 589 | 831e3793339f |
-| gpu_rectangle_before_no_launch_1791886104981638567.json | R-raw | 589 | c33885d50bfd |
-| gpu_rectangle_results.json | R-raw | 1,003 | 9c6da219ac6c |
-| gpu_rectangle_stdout.txt | R-raw | 332 | 9185bf303954 |
-| gpu_results.json | R-raw | 1,189 | 53e4f1c44de1 |
-| gpu_seed1_before.json | R-raw | 589 | c77ea3485f84 |
-| gpu_seed1_results.json | R-raw | 996 | b718e8af84e4 |
-| gpu_seed1_stdout.txt | R-raw | 306 | 4d7de0897137 |
-| gpu_stdout.txt | R-raw | 68 | b0956fe3cdb0 |
-| incremental.patch | D-snapshot | 16,836 | 9df25d8c177a |
-| manifest.json | P-pin | 4,410 | 177704d6f1ae |
-| run_gpu.py | R-raw | 5,237 | b5af3f0d4f79 |
-
-## research/refinement_prepare_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.txt | K | 8,939 | 8e210c28c7c5 |
-| baseline.json | P-pin | 46,348 | d5f257216b8d |
-| incremental.patch | D-snapshot | 15,751 | 0ddb32550584 |
-| manifest.json | P-pin | 2,113 | 9fd94ccf2c3e |
-| validation.json | R-raw | 3,567 | f057e7cbcd35 |
-| validation.txt | R-raw | 873 | 594daa45c58c |
-
-## research/refinement_slot_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 67,717 | d498081e7c50 |
-| before.json | R-raw | 690 | 430e76b3aa8a |
-| cpu_results.json | R-raw | 1,421 | 4f6bc4d9428f |
-| incremental.patch | D-snapshot | 18,676 | 67a3e8cc9e68 |
-| manifest.json | P-pin | 2,270 | 6515458290f4 |
-| notes.txt | K | 2,612 | 08a713ba4b37 |
-| results.json | R-raw | 1,160 | 03e683027ba8 |
-| stdout.txt | R-raw | 643 | d57b91769826 |
-
-## research/refinement_slot_followup_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 68,536 | 89a26ce79438 |
-| before.json | R-raw | 690 | e707df192ff2 |
-| incremental.patch | D-snapshot | 495 | c6f6fa11237d |
-| manifest.json | P-pin | 1,920 | 4840243a33aa |
-| notes.txt | K | 1,549 | 4b77583ca116 |
-| planar_velocity.cuh | R-raw | 1,911 | 87db7466c843 |
-| planar_velocity.sha256 | P-pin | 251 | 6694c4a1c1f0 |
-| results.json | R-raw | 1,050 | 6ef6eda854c6 |
-| stdout.txt | R-raw | 1,160 | 461860351c0c |
-
-## research/refinement_step_20261013
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.txt | K | 10,671 | 88d6f24743f5 |
-| baseline.json | P-pin | 40,620 | 20f61559dd38 |
-| cpu_validation.json | R-raw | 1,231 | 7999fd30018c |
-| gpu_failure_validation.json | R-raw | 868 | 5f6db65ee4f9 |
-| gpu_failure_validation.txt | R-raw | 248 | d9a570a1e9e9 |
-| gpu_validation.json | R-raw | 672 | 2028f59e1055 |
-| gpu_validation.txt | R-raw | 632 | 9699918ee127 |
-| incremental.patch | D-snapshot | 26,516 | d95f9347633d |
-| manifest.json | P-pin | 2,075 | 32a7f1a7309e |
-
-## research/repair-2026-10-10
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| TRON_HANDOFF.md | R-raw | 25,208 | a339786c7944 |
-| baseline-hashes.json | P-pin | 16,020 | 9b4e24cb1d10 |
-| baseline-status.txt | P-pin | 429 | 515be249b638 |
-| checkpoint-domain-2026-10-12.diff | D-snapshot | 14,443 | 035ed630dda1 |
-| classic-results.json | R-raw | 244,729 | 7297aa0d5bca |
-| classic-signals.npz | R-raw | 630,332 | 8cf6d1218aa0 |
-| final-gpu.log | R-raw | 191 | a0eec1a8ea31 |
-| final-unit.log | R-raw | 188 | 94efba2f1d42 |
-| provenance.json | P-pin | 1,020 | 25e22b4f0696 |
-| repair-architecture.md | K | 9,498 | 12051c3e8571 |
-| repair-numerical.md | K | 10,769 | 0c5757fe5f36 |
-| repair-state.md | K | 8,481 | 3c7f2d5b687a |
-| simplification-checks.log | R-raw | 1,045 | fa9d464be740 |
-
-## research/shear_refinement
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.md | K-code | 4,142 | 67bdd8ed622b |
-| boundary_shear_tagging.py | K-code | 13,859 | b5415a1c4ea1 |
-| example.py | K-code | 6,323 | 66295d3f0273 |
-
-## research/surface_actuation_20261014
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| baseline.json | P-pin | 54,139 | 0ad06888dbeb |
-| cpu_checkpoint_run.json | R-raw | 400 | 39681b60ff15 |
-| cpu_checkpoint_stdout.txt | R-raw | 114 | 929e4b8d4f46 |
-| cpu_initial.txt | R-raw | 620 | 29213c58a679 |
-| cpu_surface_command.txt | R-raw | 118 | 6d8c615a6e03 |
-| cpu_surface_exit.txt | R-raw | 2 | 573541ac9702 |
-| cpu_surface_stdout.txt | R-raw | 99 | ee9237fc26e5 |
-| gpu_run.json | R-raw | 1,698 | dc8f87eafaa9 |
-| gpu_stdout.txt | R-raw | 159 | b262891e52c3 |
-| incremental.diff | D-snapshot | 50,206 | 43090a1a8b11 |
-| manifest.json | P-pin | 7,527 | 35daa01271cb |
-| report.txt | K | 5,078 | 1162a6479f9f |
-
-## research/wall_seam_pulse_20261014
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| analyze.py | R-raw | 10,343 | ed7cf6999a49 |
-| interpretation.txt | K | 3,514 | 90935db2aa99 |
-| results.json | R-raw | 15,137 | 678a0759871a |
-| run.json | R-raw | 1,170 | 53e303fd0d5d |
-| sources.csv | R-raw | 2,313 | 40d3736b8ef1 |
-| stdout.txt | R-raw | 1,179 | 756d8c38e213 |
-
-## tests/validation/multigrid/cpuref_0_3_evidence
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.txt | K | 4,133 | 62897bfd9812 |
-| README_grok.md | K | 1,751 | 2d36e05661a8 |
-| baseline.json | P-pin | 39,291 | 188491096547 |
-| manifest.json | P-pin | 3,495 | 10c19f5fe5ca |
-| results_horsea.json | R-raw | 2,281 | 3b163384e376 |
-| stdout_grok.txt | R-raw | 7,143 | 5a0c270ea4ae |
-| stdout_horsea.txt | R-raw | 9,013 | adff8bb8d295 |
-
-## tests/validation/multigrid/local_stress_v1_evidence
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.txt | K | 8,239 | 3513fd294223 |
-| TABLE_local_stress_observable_v1.md | K | 2,967 | 6115dcde0f46 |
-| baseline.json | P-pin | 43,991 | ab631ea4f2ad |
-| comparison.json | R-raw | 13,248 | d7d1b36eb247 |
-| manifest.json | P-pin | 4,132 | c6c44d8125cd |
-| results_horsea.json | R-raw | 2,671 | 79bdf001f948 |
-| run_once.py | R-raw | 4,313 | fa9c5239e993 |
-| source_manifest.json | P-pin | 622 | 0516f1860407 |
-| stdout_horsea.txt | R-raw | 17,091 | a20c554693df |
-| stdout_local_stress_observable_v1.txt | R-raw | 12,238 | 692ffe1a05da |
-
-## tests/validation/multigrid/shear_v0_2_evidence
-
-| File | Class | Bytes | Blob |
-|---|---|---:|---|
-| README.txt | K | 7,220 | 772f74ad40ff |
-| baseline.json | P-pin | 41,751 | 70d9c9fa71c0 |
-| comparison.json | R-raw | 7,679 | 0af8736f9a01 |
-| joint_report.md | K | 6,110 | eed871221298 |
-| manifest.json | P-pin | 3,796 | b22d03a1ba9e |
-| results_horsea.json | R-raw | 1,957 | b2cd48a07a08 |
-| run_once.py | R-raw | 3,245 | 0b8d5e21f326 |
-| source_manifest.json | P-pin | 574 | 4d1c742690c7 |
-| stdout_grok.txt | R-raw | 7,950 | 0e80b1aba7f6 |
-| stdout_horsea.txt | R-raw | 11,421 | 3c867cdac197 |
@@ -1,26 +1,23 @@
-# Fixed three-level rectangle unions
+# Fixed three-level separated patches

-This page describes three-level `FixedPatchStepper` setups built from the
-`refinements` level list, with rectangle unions on either adjacent pair. The
-same constructor supports arbitrary depth; three or more levels require
-all-blocked storage and bodies/Jets only on the finest level. This is not
-general AMR: there is no per-region timestep, moving geometry, automatic
-dynamic refinement or L1 body support in the three-level form.
+`FixedPatchStepper` supports exactly three static, blocked levels with separated
+rectangle sets on either adjacent pair. This is not general AMR: there is no
+per-region timestep, moving geometry, dynamic refinement or L1 body support.
 All regions share one current/spare buffer pair per level. The existing schedule
 advances L0 once, L1 twice and L2 four times per base step, with aggregate transfers.
 No CUDA kernel changes are involved.

 ## Explicit coordinate frames

-For a single scalar parent patch, pass a scalar rectangle as `refinements[1]`:
-`(x0,y0,x1,y1)` in half-open integer indices of the allocated L1 window,
-including its ghost band.
+Keep the existing scalar `child=(x0,y0,x1,y1)` for a single scalar parent patch.
+Its coordinates retain their original meaning: half-open integer indices in the
+allocated L1 window, including its ghost band.

-A rectangle list as `refinements[1]` accepts a scalar or a set parent and
-interprets every rectangle in the actual allocated L1 array, including ghost
-bands and holes. It never infers region-local coordinates. The physical root
-cell edge corresponding to an L1 index `(x,y)` is
-`parent.fine_origin + (x,y)/2`:
+The new keyword `child_rectangles_in_parent=[...]` is mutually exclusive with
+`child`. It accepts a scalar or a set parent and interprets every rectangle in
+the actual allocated L1 array, including ghost bands and holes. It never infers
+region-local coordinates. The physical root cell edge corresponding to an L1
+index `(x,y)` is `parent.fine_origin + (x,y)/2`:

 - A scalar L1 parent has a shifted window origin.
 - A set L1 parent has origin `(0,0)` and public shape `(2*ny,2*nx)`.
@@ -33,23 +30,20 @@ are physically equivalent to parent set `[(4,4,12,12)]` with child set
 `[(8,8,16,16)]`. Reusing the same numbers after changing the parent frame can
 move the physical region.

-Both adjacent pairs are built from their unions, without a fixed rectangle-gap
-rule. Adjacent, overlapping and concave unions are accepted only when their
-actual transfer dependencies close. The whole child union must preserve
-inherited ACTIVE coverage, uncovered ACTIVE donors/receivers, surviving pulls, and the upstream
+Both adjacent pairs require a Chebyshev gap of at least four in their own
+parent-cell units. The whole child union must preserve inherited ACTIVE
+coverage, uncovered ACTIVE donors/receivers, surviving pulls, and the upstream
 restriction footprint. Sparse holes remain unowned; inherited INNER remains
-stream-only and OUTER remains invalid. Block sizes must divide their allocated
-level grids. Sparse storage owns every grid-aligned tile intersecting the union
-plus its four-cell ghost band; rectangle and support edges need not align with
-tile edges.
+stream-only and OUTER remains invalid. Block sizes must align with every
+support edge, including its four-cell ghost band.

 ## Example

 ```python
 run = FixedPatchStepper(
-    cfg, context=ctx,
-    refinements=[[(4, 4, 20, 28), (24, 4, 44, 28)], [(16, 16, 32, 40), (56, 16, 80, 40)]],
-    level_blocks=[(4, 4)] * 3,
+    cfg, [(4, 4, 20, 28), (24, 4, 44, 28)], context=ctx,
+    base_block=(4, 4), fine_block=(4, 4), child_block=(4, 4),
+    child_rectangles_in_parent=[(16, 16, 32, 40), (56, 16, 80, 40)],
 )
 ```

@@ -57,7 +51,7 @@ This example uses a 48x32 root. `initialize` and `download` use three Q-major
 dense arrays. Public arrays and masks still scale with the full allocated
 extent; sparse device buffers do not remove that host-memory limit.

-Stationary whole-circle L2 bodies and Jets (`level_objects[2]`, `level_jets[2]`) use root edge
+Stationary whole-circle `child_objects` and `child_jets` use root edge
 coordinates and a single L2 boundary object. Body IDs are physical object-list
 positions, not region IDs or caller `obj_id`. Complete boundary stencils must
 avoid the transfer footprint. Change a child Jet with
@@ -71,12 +65,6 @@ CPU geometry, table, pre-CUDA rejection, schedule and cleanup tests:
 PYTHONPATH=src python -m unittest discover -s tests/unit -p 'test_refinement*.py' -v
 ```

-`tests/unit/test_union_refinement.py` covers union dependencies and tile
-ownership; `tests/unit/test_hierarchy.py` covers composed geometry through four
-levels. `tests/unit/test_raw_exchange.py` checks the four-level host schedule
-with CUDA mocks. These establish topology/control-flow coverage, not numerical
-qualification at every depth or interface shape.
-
 Explicit GPU gates are in
 `tests/validation/multigrid/test_refinement_three_level_multipatch_gpu.py`.
 They cover physical-frame equivalence, twins, asymmetric refinement, multiple
@@ -1,26 +0,0 @@
-# Device state lifecycle (uniform Simulation, FixedPatchStepper)
-
-State is grouped by what a change invalidates. This file describes the code as
-it is; it adds no framework. Line references are to candidate 0f8fdbc3.
-
-| Class | Contents | How it changes | Owner rule |
-|---|---|---|---|
-| 1. Module and its globals | Compile-time (visible to the compiler, fixed per module): `config.h` macros incl. `NX`/`NY`, `COLLISION_MODEL`, `BLOCK_ROOT_BC`, `WALL_*`. Runtime per-module globals (not visible to the compiler; written by host code): `__constant__` `d_params`, `d_w`, `d_cx`, `d_cy`, `d_block_channel`, `d_block_wall`; plus bound kernel handles | Globals are written once by the owner right after `load_module`. Uniform grid: `Simulation._recompile` (construction, body-topology sync) loads a new module and re-uploads; `update_runtime_params` rewrites `d_params` (omega, force, n_objects) between runs. Steppers: never rewritten after construction, so they are immutable for the instance's lifetime although they are runtime values. The blocked slot/reservoir root reads its slot from the `d_block_wall` constant (the former dense route used `WALL_*` macros; both were bit-identical in the parity gates). | Every owner loads its own module (`compiler.load_module` = `module_from_file`, no cache). A loaded module is never shared between live owners: globals are per module, so sharing would share mutable `d_params`. |
-| 2. Geometry, layout, tables | flags, curved-link tables, block layouts and halo pairs, transfer (explode/coalesce) tables, block kinds | Immutable for the life of an instance. Uniform grid: rebuilt by body sync. `FixedPatchStepper`: a geometry change is a new instance (`remap_child`), committed only after a successful transfer. | No in-place table edits. |
-| 3. Controls and dependent boundary columns | Jet amplitude -> per-link `surface_velocity`; body actions (uniform grid) | Between steps, without a table or module rebuild (`set_jet_amplitude`). | Input (index, level, amplitude) is validated before any device write; invalid input changes nothing and the instance stays usable. The host copy commits only after the upload returned. Any error after validation leaves the device column undefined and fails the instance: `FixedPatchStepper` status `failed`, `Simulation._failed`; every later call except `close()` raises, `close()` still releases resources and stays retryable. |
-| 4. Per-step state | population double buffers and their parity, raw-exchange ledgers, observations | Device-only during `step(n)` / `run(n)`; buffer swaps are host-handle swaps. | Valid on the host only after the single wait at the end of the call. |
-
-Storage routes are separate concerns:
-
- Original uniform grid (`uniform.cu`, `Simulation`): whole-domain `NX`/`NY`.
- Blocked levels (`blocked.cu`; every `FixedPatchStepper` level, including the
-  single level of `refinements=[]`): `NX`/`NY` are one block window including halo.
- Dense refinement levels (`refinement.cu`) were removed: `level_blocks` is
-  required and every refinement level is blocked.
-
-A single-rectangle refinement (`FixedPatch2D`) is stored in its own fine
-window frame (`FixedPatchStepper.__init__`,
-`BlockLayout2D.build(*pair.fine_shape, ...)`). Only a rectangle set
-(`FixedPatchSet2D`) uses the level-wide frame `(2*ny, 2*nx)`, whose
-`fine_layout` requires that full grid to be divisible by the tile
-(`refinement.py:240-252`).
@@ -1,89 +0,0 @@
-# Supported settings: 2D Jet + fixed multilevel refinement (candidate 888c8038)
-
-Every entry names the guard that enforces it (file and function or kernel guard,
-at source revision 888c80381c006e976be2af8a452288729fc17c1b) and, where one
-exists, an existing test that exercises it. A setting not listed here is not
-claimed. Observations at the end are tied to the exact case in which they were
-measured; they are not general bounds.
-
-## Lattice, storage, collision
-
-| Setting | Supported | Guard |
-|---|---|---|
-| Dimension / lattice | 2D D2Q9 only (3D refinement is future work) | `lbm/refinement.py` `FixedPatch2D.from_config`; `#error` guards in `lbm/kernels/blocked.cu` |
-| Precision / streaming | FP32 storage, double buffer | same guards |
-| Collision on refinement levels | SRT or MRT; TRT and LES rejected | `lbm/refinement.py` `FixedPatch2D.from_config` (re-checked for fine boundaries in `prepare_fine_boundary`) |
-| Shifted (ddf_shifting) storage | supported (every level is blocked); one representation on all levels | `lbm/refinement_stepper.py` `FixedPatchStepper._check_storage` |
-| Fine relaxation | 1/tau_fine must lie inside the configured omega guards | `lbm/refinement.py` `FixedPatch2D.from_config` |
-| Single blocked level `FixedPatchStepper(refinements=[], level_blocks=[(by, bx)], level_objects=[circles])` (replaces `PeriodicBlockStepper`, removed in 8e1feff) | doubly periodic, SRT only, no LES/Jets/projection/exchange observation, stationary passive circles; `download()` returns a 1-tuple | `lbm/refinement_stepper.py` `_check_levels`, `FixedPatchStepper.__init__`; `lbm/blocks.py` `static_circle_tables` |
-| Refinement storage | blocked on every level: `level_blocks` is required, one tile `(by, bx)` per level dividing that level; a whole-level tile (`(ny, nx)` at the root, the fine window shape for one rectangle) always divides. Dense and mixed dense/blocked storage were removed (parity of D/D, D/B and B/B recorded at 1573942 and 2469af7) | `lbm/refinement_stepper.py` `_check_levels`, `FixedPatchStepper.__init__` |
-
-Tests: `tests/unit/test_refinement_mrt.py`, `tests/validation/multigrid/test_refinement_mrt_gpu.py`,
-`tests/unit/test_shifted_storage.py`, `tests/unit/test_shifted_block_operators.py`.
-
-## Refinement hierarchy (`FixedPatchStepper(cfg, *, context, refinements, ...)`)
-
-| Setting | Supported | Guard |
-|---|---|---|
-| Depth | at least one refinement level; one entry per level in `level_blocks`/`level_objects`/`level_jets` | `lbm/refinement_stepper.py` `_check_levels` |
-| Single L1 rectangle | two-coarse-cell margin to the domain edge | `lbm/refinement.py` `FixedPatch2D.from_config` |
-| Several L1 rectangles (union) | require `level_blocks[0]` and `level_blocks[1]`; transfers must close (dependency checks, no fixed gap rule) | `lbm/refinement_stepper.py` `_check_levels`; `lbm/refinement.py` `_check_parent_pull_closure` |
-| Nested levels | depth >= 3 must be all blocked; a blocked level requires blocked levels below; a scalar child needs a scalar parent | `lbm/refinement_stepper.py` `_check_levels`; `lbm/hierarchy.py` `build_hierarchy` |
-| Nested transfer support | child only over inherited ACTIVE cells, donors/receivers uncovered ACTIVE, no child over the parent restriction footprint | `lbm/refinement.py` `_nested_kind` |
-| Tile shape | positive `(by, bx)`; the level allocation must be divisible by the tile (no partial tiles yet) | `lbm/refinement_stepper.py` `_check_levels`, `lbm/refinement.py` `FixedPatchSet2D.fine_layout` (shape); `lbm/blocks.py` `BlockLayout2D.build` (divisibility) |
-| Coarse boundary | `periodic`, `slot_reservoir` or `channel` | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__` |
-| `slot_reservoir` | on-site velocity bottom slot, reservoir top, velocity 0, 2 <= slot width < nx, patch rows 4..ny-4 | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__`; `lbm/refinement.py` `prepare_fine_boundary` |
-| `channel` | all levels blocked; Zou-He inlet, pressure-NEQ outlet, stationary bounce-back walls; transfers away from the closure | `lbm/channel.py` `validate_channel_config`, `validate_channel_transfers` |
-| Explosion | `constant` (default); `projected_linear` only periodic, all-blocked SRT, no bodies/Jets, no LES (experimental) | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__` |
-| L2 runtime remap (`remap_child`) | periodic three-level L2 sets only, no L0/L1 bodies, identical pinned boundary | `lbm/refinement_stepper.py` `FixedPatchStepper.remap_child` |
-
-Tests: `tests/unit/test_refinement_three_level_multipatch.py`, `tests/validation/multigrid/test_refinement_multipatch.py`,
-`test_refinement_three_level.py`, `test_refinement_three_level_multipatch_gpu.py`, `test_refinement_blocked_base.py`,
-`test_refinement_blocked_fine.py`, `test_channel_root_gpu.py`, `tests/unit/test_channel_root.py`,
-`tests/unit/test_projected_pair_stepper.py`, `test_runtime_child_remap_gpu.py`, `test_pinned_body_remap_gpu.py`.
-
-## Bodies and Jets on refined levels
-
-| Setting | Supported | Guard |
-|---|---|---|
-| Bodies | stationary circles without sensor/force-region roles, entirely inside the patch union, fully resolved, disjoint, stencil away from the two-hop transfer footprint | `lbm/refinement.py` `prepare_fine_boundary` |
-| Level | not on L0; only on the finest level of a nested hierarchy | `lbm/refinement_stepper.py` `_check_levels` |
-| Jet condition | velocity only; `pressure` is reserved and raises NotImplementedError | `body/jets.py` `Jet.__post_init__` |
-| Jet geometry | each Jet selects resolved links of exactly one stationary body; no Jet/Jet or Jet/SurfaceActuation overlap; abs(amplitude) < 1 lattice | `body/jets.py` `Jet.__post_init__`, `jet_link_shapes`, `_surface_links` |
-| Jets with shifted storage | only in the all-blocked stepper with SRT and no LES | `body/jets.py` `_surface_links` |
-| SurfaceActuation | unshifted storage only | `body/objects.py` `SimObject.validate_surface_actuation` |
-| Raw boundary exchange (force) | blocked body levels only; the window ledger requires `observe_raw_exchange` | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__` |
-| Checkpoint with Jets | refused | `simulation.py` `Simulation.save_checkpoint` |
-
-Raw exchange is the cut-link momentum reaction (wall + aperture), not a validated
-nozzle thrust or stress load. Jet amplitude is a lattice velocity, not a flow rate.
-
-Tests: `tests/unit/test_jets.py`, `test_jets_review.py`, `test_shifted_jets.py`, `test_raw_exchange.py`,
-`tests/validation/multigrid/test_refinement_jets.py`, `test_shifted_jets_gpu.py`, `test_raw_exchange_gpu.py`,
-`test_exchange_window.py`, `test_fine_surface_gpu.py`.
-
-## Observations from specific tested cases (not general bounds)
-
- SRT channel root vs uniform OneStep, strict-parity test
-  `tests/validation/multigrid/test_channel_root_gpu.py::ChannelRootGPU::test_uniform_matched_root`:
-  in one of its 18 sub-cases (2 storage modes x 3 profile/clamp/damp settings x 3 blocks; which
-  one is not recorded), 1 of the 4320 compared values differs, max abs 2.33e-10, max rel 1.77e-7
-  (about 2 ULP). The test remains failed; its cause and any general bound are unresolved.
- MRT root parity test
-  `tests/validation/multigrid/test_refinement_mrt_gpu.py::RefinementMRTGPU::test_uniform_matched_mrt_root`
-  (12 sub-cases: 2 storage modes x 2 profiles x 3 blocks, default outlet settings) passed bitwise
-  in the Horsea focused GPU run at K1 7813334 (2026-10-21).
- Periodic Taylor-Green Re 100, measured at 36ffc8b1 (V3 matched pair, N128 depth 2):
-  every per-sample screen passed; the constant explosion's aggregate worst velocity L2,
-  0.004418, exceeds its preregistered 0.002 budget, while projected_linear passed that budget.
- Curved-wall pressure (pilot harness, exact-q analytic annulus, tau 0.8): the coarse swirl r1
-  case exceeded its terminal density-gain cap (1.105e-4 vs 1e-4), so the frozen 9-case matrix
-  is NOT_ESTABLISHED. No validated fix exists. This is a pilot harness, not production code.
- DFG 2D-1 Re 20 (V4, SRT, t* 60, pressure-NEQ outlet and local Zou-He inlet): refined and uniform
-  runs were NOT_STEADY under the frozen steady rule, so no interval verdict was given.
-
-## Not supported in this release
-
-3D, dynamic/automatic AMR (tagging, time-varying hierarchies beyond `remap_child`),
-moving bodies on refined levels, pressure Jets, Jet checkpoints, LES or TRT on refined
-levels, partial (non-dividing) tiles.
@@ -1,15 +1,11 @@
 # Synchronized leaf G remap and manual continuation

 This is a CPU state-transfer component, **not a runtime adaptive solver**.
-It changes only an L2 rectangle union in a three-level periodic hierarchy.
-The body-free case is shown first; stationary L2 bodies/Jets follow the bounded
-support contract below. L0/L1 topology, relaxation parameters, direction order,
+It changes only a separated L2 rectangle set in a three-level, body-free,
+periodic hierarchy. L0/L1 topology, relaxation parameters, direction order,
 physical frame and completed time remain unchanged. Existing geometry checks
-validate child support/nesting and actual transfer dependencies, without a fixed
-rectangle-gap rule. The three-level remap limit is unchanged by the stepper's
-arbitrary-depth level-list support. The CPU helper itself adds no CUDA,
-scheduler, allocator, boundary handling, collision or ghost refill. A bounded
-runtime adapter is described below.
+validate child support/nesting and separation. The CPU helper itself adds no CUDA, scheduler, allocator, boundary handling,
+collision or ghost refill. A bounded runtime adapter is described below.

 ```python
 from CelerisLab.lbm.refinement import FixedPatchSet2D
@@ -33,13 +29,11 @@ origin is retained. Physical lower edges are `origin + spacing*(x,y)` on L0,
 `origin + spacing*(parent.fine_origin + (x,y)/4)` on L2.

 Factory options `coarse_boundary` and `objects` must declare `"periodic"` and
-an empty collection; L2 bodies use `child_objects` as described below.
-LBMConfig's channel settings do not select this operator's boundary mode.
-Geometry metadata is factory-created;
+an empty body collection (all levels). LBMConfig's channel settings do not
+select this operator's boundary mode. Geometry metadata is factory-created;
 manual mutation/forging of metadata is unsupported. Caller certifies the
-actual state matches the declared boundary and has no forcing, that all device
-work and old readers are quiescent, and that inputs are the **current owned-leaf
-postcollision G**.
+actual state has no bodies/forcing, that all device work and old readers are
+quiescent, and that inputs are the **current owned-leaf postcollision G**.
 Count/phase stamps check consistency, not freshness or active-buffer identity.

 `current_g` is three NumPy Q-major arrays `(9,ny,nx)`. For blocked inputs,
@@ -79,10 +73,9 @@ PYTHONPATH=src python -m unittest discover -s tests/unit -p 'test_synchronized_r

 `replacement = current.remap_child(rectangles)` returns a new ready
 `FixedPatchStepper` at the **same absolute step_count**. It supports only
-periodic three-level runs with no L0/L1 bodies and an existing L2
-`FixedPatchSet2D`; stationary L2 bodies/Jets follow the support contract below.
-Scalar or union L1 parents are supported; scalar `child=` is deliberately
-rejected. L0/L1, relaxation and block sizes stay fixed.
+body-free periodic three-level runs whose existing L2 uses
+`child_rectangles_in_parent`. Scalar or union L1 parents are supported; scalar
+`child=` is deliberately rejected. L0/L1, relaxation and block sizes stay fixed.
 No tagger, scheduler, in-place replacement, or general rollback is provided.

 The method holds the stepper lock, validates geometry, synchronizes its stream,
@@ -120,14 +113,13 @@ Per-population conservation is not an advancement target under collision.
 ### Bounded pinned-body extension

 `replacement = current.remap_child(rectangles, child_objects=original_objects)`
-also accepts stationary Circles inside the L2 union. Each body's **physical
-boundary, complete BFL support and current per-link velocity must remain
-identical**. Rectangles are not pinned: they may be split, merged or resized,
-and other fluid coverage may change, including within the same connected union,
-provided that physical support is unchanged. Existing nesting, union transfer
-dependencies, full-circle containment, reverse cut-link
-coverage and two-hop BFL transfer-footprint checks still apply. This is manual
-remapping, not adaptive body tracking or runtime body editing.
+also accepts stationary Circles in separated L2 rectangles. Every body’s
+**complete containing rectangle must remain identical**. Several bodies may
+share one pinned rectangle; there need not be any fluid-only rectangles.
+Separated fluid-only rectangles may be added, removed or moved. Existing
+nesting, four-cell gap, full-circle containment, reverse cut-link coverage and two-hop BFL
+transfer-footprint checks still apply. This is manual remapping, not adaptive
+body tracking or runtime body editing.

 Supply all original root edge-frame definitions in their construction order.
 Do not pass `current.child_boundary.objects`: those are projected fine-local copies.
@@ -136,8 +128,8 @@ state, remapping reprojects the supplied definition onto the old topology and
 compares exact ordered circle centers/radii, flags, physical cut links, body
 IDs, q, lever arms, hits, BFL support,
 legacy SurfaceActuation specification and current per-link velocity against
-the existing boundary. Omission, changed geometry/actuation or changed physical
-boundary/BFL support fail without device reads or allocations; reordered bodies fail
+the existing boundary. Omission, changed geometry/actuation and changed body
+rectangle fail without device reads or allocations; reordered bodies fail
 too. Root object IDs are still assigned by list position, as in the constructor.

 Jets are taken from the live L2 boundary, including the most recent successful
@@ -149,16 +141,12 @@ boundary and velocities must match exactly.
 typed `FineBoundary2D`; it derives L2 fluid leaves as ACTIVE minus SOLID. No
 caller mask is accepted. Solids, ghosts and holes are never donors and remain
 NaN, physical-fluid overlap is exact, and exposed L1 still restricts all four
-old fluid children. The helper checks old/new physical boundary and velocity
-equality too. Its immutable `pinned_rectangles` is legacy containment metadata,
-not a remap eligibility constraint; it may be empty for a seam-spanning body.
-Scalar-parent window offsets remain part of the coordinate conversion.
+old fluid children. The helper checks the old/new body pins and boundary too.
+Its immutable `pinned_rectangles` is a canonical, deduplicated tuple, empty for body-free layouts; rectangle input
+order does not affect it. Scalar-parent window offsets remain part of the
+coordinate conversion.

-Focused CPU mocks: `tests/unit/test_pinned_body_remap.py`.
-`tests/unit/test_union_body_support.py` also checks seam-spanning circles,
-rectangle repartition/resize, unchanged physical support and live-Jet
-preservation. These host checks do not establish GPU evolution accuracy.
-GPU declarations:
+Focused CPU mocks: `tests/unit/test_pinned_body_remap.py`. GPU declarations:
 `tests/validation/multigrid/test_pinned_body_remap_gpu.py`, covering no-op
 next-step bitwise identity, moved-fluid A→B→A, current-amplitude preservation,
 physical boundary/velocity equality, source independence and absolute counts.
@@ -1,49 +0,0 @@
-# DFG 2D-1 (Re 20) against the official reference intervals
-
-`tests/validation/run_dfg_re20.py` runs the steady DFG 2D-1 case on the refined
-channel root (D40 root, D80 wide fine patch) and on the uniform D80 grid. Geometry,
-inflow, initial state, layout and observation are those of the pinned Re100 runner
-(`run_refined_dfg.py`, `re100_helpers.py`, both unchanged); only the lattice
-viscosity is set for Re 20 (root tau 0.56, fine 0.62, uniform 0.62, lattice speed 0.01).
-
-Label: "compared against the official reference bands", not a full benchmark
-certification: the outlet is pressure-NEQ (`neq_extrap`), not do-nothing, and the
-inlet is local Zou-He.
-
-## Quantities
-
- Cd = 2 Fx / (rho U^2 D), Cl = 2 Fy / (rho U^2 D), interval means over each sample.
- p_diff = p(0.15, 0.2) - p(0.25, 0.2), linear extrapolation to the exact surface
-  points (`re100_helpers.pressure_probes`). The helper returns dp / (rho U^2) in
-  scaled units; p_diff = dp * 0.04 for U = 0.2 m/s, rho = 1. Both are reported.
- Official intervals (Schaefer & Turek 1996): Cd [5.57, 5.59], Cl [0.0104, 0.0110],
-  p_diff [0.1172, 0.1176].
-
-## Bounds and steady rule (frozen before any run)
-
- End time t* = 60 (30 s physical): 240,000 refined root steps, 480,000 uniform steps.
- One sample every t* = 0.5 (0.25 s) at the end of a synchronized root step; Cd and
-  Cl are interval means. Trailing window t* 50..60 inclusive (21 samples).
- Steady rule (our engineering choice, not official): in the window, for each of Cd,
-  Cl, p_diff, max - min <= 10 % and |least-squares slope x window| <= 2 % of its
-  official interval width (range 2e-3 / 6e-5 / 4e-5; slope 4e-4 / 1.2e-5 / 8e-6).
-  Absolute limits, so the small Cl is never a divisor. Never relaxed after a run.
- The verdict uses the window mean; the distance to the nearest interval edge is
-  reported for each quantity (negative outside).
- Force sign: fluid on cylinder, x along the inflow, y up from the bottom wall; Cd > 0
-  and the official Cl > 0 (`cd_positive` is reported).
- Not steady at t* = 60: status `NOT_STEADY`, no interval verdict. Health limits
-  (Mach <= 0.2, rho in [0.5, 1.5]) stop the run with `UNHEALTHY`.
- Steady: `WITHIN_INTERVALS` or `OUTSIDE_INTERVALS`, with the per-quantity verdict.
-
-## Run
-
-```
-python tests/validation/run_dfg_re20.py --output <new-dir> --plan
-CUDA_VISIBLE_DEVICES=<n> python tests/validation/run_dfg_re20.py --case both \
-    --collision SRT --output <new-dir> --max-wall-seconds <cap>
-```
-
-The uniform D80 control separates method error from refinement error. `--plan` writes `plan.json` only. A GPU run writes `plan.json` and `result.json`
-(per case: lattice parameters, every sample, window ranges, status, verdict).
-Host contract tests: `tests/unit/test_dfg_re20.py`.
@@ -56,62 +56,3 @@ Root must independently review and admit any execution. An admitted paired pilot
 the existing watchdog, device selection, `--gpu-gates-approved`, positive
 `--max-wall-seconds` and a new output directory, adding only `--exchange-window` to the
 selected collision's pilot command. No GPU or remote action was performed for this patch.
-
-## Public Jet diagnostic option
-
-`--collision MRT --exchange-window --jet-scenario zero|fixed|reverse` selects
-unshifted FP32, no LES, constant transfer on both existing public backends. Default
-`none` and the historical manifests remain unchanged. `zero` registers both Jets at
-zero amplitude and retains every existing DFG verdict, including pressure. `fixed`
-uses outward radial parabolic sectors at pi/2 and 3pi/2, half-width pi/12, peaks
-(+.001,-.001). Both use the existing D40/D80 geometry and U=.01. Sector origins are
-(80.5,81) in root edge coordinates and (160,160.5) in uniform node coordinates;
-radial extent is [0,1.005R]. `reverse` keeps those peaks through t*=300, updates both
-public setters at that completed boundary, and continues to 305 with opposite signs.
-
-Fixed diagnostic windows are 250–260, 260–270, 270–280, 280–290 and 290–300; reversal
-adds 300–305. Histories retain exact interval endpoints and root/uniform lattice
-impulses. The refined window uses total exchange; uniform uses public `read_force`
-batch averages. Driven windows report mean/min/max/RMS Cd/Cl without applying DFG
-reference or periodicity gates. Exit zero means healthy execution, not qualification;
-`matched_case_pass` remains false. No independent CV or stress-load claim is made.
-
-This opt-in records current source/helper hashes with the existing manifest format,
-checkout revision/dirty state and runner hash. Pilot/full must match that snapshot
-and the exact scenario. It does not relabel current source as historical evidence.
-Use the existing bounded plan/pilot/full commands with the three option flags above;
-full requires the matching completed t*=5 paired pilot. `step_seconds` includes force
-readback; observation/overhead and total wall time are separate, not kernel throughput.
-
-Add `--observe-cv` to record independent scalar control-volume samples from the
-already downloaded public macros. The pilot exercises this path at t*=.02..5;
-full records 501 endpoints at 290..300. Each `cv_history.jsonl` row contains actual
-root time, preceding interval start/duration/impulse, and two inventories/outward
-fluxes ordered [mass,Px,Py]. Exclude the first row's preceding impulse: that row
-supplies the initial inventory. Uniform native impulse converts by .5² to root
-units; refined ledger impulse is already in root units. Explicit native-aligned
-contours differ by .25 root cells in x and are recorded in the plan. Cropping
-retains the two-cell face-gradient stencils. No fields or per-link arrays are saved.
-`cv_observation_seconds` is the CV portion of observation/overhead time. Helper hash
-and the observation flag must match pilot/full. Time integration, temporal
-coarsening and any physical assessment remain separate offline work.
-
-## Bounded resolution and placement controls
-
-Defaults remain `--case both --uniform-diameter 80 --placement wide`. Single-case
-runs use `--case uniform` or `--case refined` and never report a matched-case pass.
-Their own reference/periodicity or driven-diagnostic results remain available.
-A single zero-Jet full run exits successfully only when its periodicity and the
-unchanged complete DFG reference verdict pass; driven completion is not qualification.
-
-The D160 option requires `--case uniform --uniform-diameter 160` and an explicit
-public Jet scenario. U and Jet speeds stay .01 and ±.001; viscosity is .016,
-grid 3521×658, center (320,320.5), radius80. CV uses root spacing/time factor .25,
-origin (.375,.75), impulse factor .0625, root viscosity .004, and x-face shift .125.
-
-`--case refined --placement compact` selects root bounds (48,48,128,128), fine
-168×168 and origin (46,46), with the same D40/fineD80 body/Jet resolution. Its CV
-contours are (52,52,112,112) and (50,50,120,120); complete face-gradient stencils
-are clear of both solids and the transfer footprint. Compact is refined-only.
-CV metadata gives each grid's spacing/origin/contours explicitly. Case, uniform
-diameter and placement must match the newly completed pilot in every receipt.
@@ -1,9 +1,9 @@
 """Public API demo: fixed 2:1 patch with a stationary, optionally actuated circle.

 From this checkout, after checking the selected physical GPU is idle:
-    PYTHONPATH="$PWD/src" CUDA_VISIBLE_DEVICES=0 python examples/fixed_patch_circle.py
-    ... --speed -0.002 --mode slot_reservoir
-Both levels use blocked storage (--base-block, --fine-block tiles).
+    PYTHONPATH="$PWD/src" CUDA_VISIBLE_DEVICES=0 python examples/fixed_patch_circle.py --fine-block 16 20
+    ... --speed -0.002 --fine-block 16 20 --mode slot_reservoir
+Omit --fine-block for the (equivalent) dense fine storage.

 A short smoke run (default 128 coarse steps): it shows setup, stepping and
 fluid-only diagnostics, not a developed flow, accuracy or long-time stability.
@@ -71,10 +71,8 @@ def main():
    parser.add_argument("--mode", choices=("periodic", "slot_reservoir"), default="periodic")
    parser.add_argument("--speed", type=float, default=.002,
                        help="normal surface velocity, coarse lattice units (+ blows, - sucks, 0 passive)")
-    parser.add_argument("--base-block", type=int, nargs=2, metavar=("BY", "BX"), default=(12, 8),
-                        help="root tile; must divide the 24 x 32 root")
-    parser.add_argument("--fine-block", type=int, nargs=2, metavar=("BY", "BX"), default=(16, 20),
-                        help="fine tile; must divide the whole fine allocation (32 x 40 here)")
+    parser.add_argument("--fine-block", type=int, nargs=2, metavar=("BY", "BX"),
+                        help="blocked fine storage; must divide the whole fine allocation (32 x 40 here)")
    parser.add_argument("--steps", type=int, default=128)
    args = parser.parse_args()
    if args.steps < 0:
@@ -88,20 +86,20 @@ def main():
    body = SimObject(0, geometry=CircleGeometry(*CENTER, RADIUS), center=CENTER, radius=RADIUS,
                     surface_actuation=spec)
    cfg = config(args.mode)
+    fine_block = tuple(args.fine_block) if args.fine_block else None
    # The caller owns the CUDA context; the stepper must be closed first (the
    # nested with-statement does that).
    with CudaContext(0) as context, FixedPatchStepper(
-            cfg, context=context, coarse_boundary=args.mode, refinements=[BOUNDS],
-            level_blocks=[tuple(args.base_block), tuple(args.fine_block)],
-            level_objects=[(), (body,)]) as run:
+            cfg, BOUNDS, context=context, coarse_boundary=args.mode,
+            fine_objects=[body], fine_block=fine_block) as run:
        p = run.patch
        # Rest equilibrium is already postcollision G, so no initial collision is
        # needed. Non-leaf entries (covered, ghost, solid) are discarded by initialize.
        rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
        run.initialize(np.broadcast_to(rest, (9, *p.coarse_shape)),
                       np.broadcast_to(rest, (9, *p.fine_shape)))
-        storage = f"blocked root {tuple(args.base_block)} fine {tuple(args.fine_block)}"
-        print(f"mode={args.mode} storage={storage} speed={args.speed:+g} "
+        storage = f"blocked {fine_block}" if fine_block else "dense"
+        print(f"mode={args.mode} fine storage={storage} speed={args.speed:+g} "
              f"(fine allocation {p.fine_shape[0]}x{p.fine_shape[1]}, fine origin {p.fine_origin})")
        masks = leaf_masks(run, args.mode)
        start = leaf_diagnostics(*run.download(), masks)
@@ -31,7 +31,6 @@ from CelerisLab.lbm.refinement import ACTIVE
 from CelerisLab.lbm.refinement_stepper import FixedPatchStepper

 BOUNDS, AMPLITUDE, WIDTH = (16, 4, 32, 28), .02, 12
-LEVEL_BLOCKS = [(12, 8), (8, 8)]  # blocked storage: 48x48 root, 56x40 fine window
 TIMES, MAX_MACH, MAX_SECONDS = (0, 300, 1200), .1, 120


@@ -133,8 +132,7 @@ def main():
                  lattice_model='D2Q9', collision='SRT', streaming='double_buffer',
                  store_precision='FP32', ddf_shifting=False, les_enabled=False)
    report = dict(config=dict(nx=48, ny=48, bounds=BOUNDS, W=WIDTH, A=AMPLITUDE, nu=.1,
-                              rho=1, tau_coarse=.8, tau_fine=1.1, coarse_boundary='slot_reservoir',
-                              level_blocks=LEVEL_BLOCKS),
+                              rho=1, tau_coarse=.8, tau_fine=1.1, coarse_boundary='slot_reservoir'),
                  guards=dict(check_every=50, positive_density=True, finite=True,
                              max_Mach=MAX_MACH, max_seconds=MAX_SECONDS,
                              timing='cooperative checks, not an exact interruption deadline'),
@@ -150,9 +148,8 @@ def main():
                  samples=[], status='running', last_synchronized_coarse_step=0)
    start, run = time.monotonic(), None
    try:
-        with CudaContext(0) as context, FixedPatchStepper(cfg, context=context,
-                coarse_boundary='slot_reservoir', refinements=[BOUNDS],
-                level_blocks=LEVEL_BLOCKS) as run:
+        with CudaContext(0) as context, FixedPatchStepper(cfg, BOUNDS, context=context,
+                coarse_boundary='slot_reservoir') as run:
            p = run.patch
            masks = [np.ones(p.coarse_shape, bool), p.fine_kind == ACTIVE]
            masks[0][[0, -1]] = False
@@ -48,8 +48,7 @@ def main():
                  nx=16, ny=16, viscosity=.1, velocity=1e-3, rho=1.0,
                  lattice_model="D2Q9", collision="SRT", streaming="double_buffer",
                  store_precision="FP32", ddf_shifting=False, les_enabled=False)
-    with CudaContext(0) as context, PeriodicPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)],
-                                                           level_blocks=[(16, 16), (24, 24)]) as run:
+    with CudaContext(0) as context, PeriodicPatchStepper(cfg, (4, 4, 12, 12), context=context) as run:
        p = run.patch
        coarse = shear_equilibrium(p.coarse_shape, (0, 0), 1.0, cfg.ny)
        fine = shear_equilibrium(p.fine_shape, p.fine_origin, .5, cfg.ny)
@@ -207,30 +207,22 @@ def surface_link_velocity(objects, cfg, flags, fluid_idx, dir, body_id, rx, ry,
                          jets=(), hits=None, *, _shifted_blocked=False):
    """Per-link prescribed surface velocity (n, 2) FP32 and aperture mask.

-    See _surface_links, which also returns the unit-amplitude jet shapes.
-    """
-    return _surface_links(objects, cfg, flags, fluid_idx, dir, body_id, rx, ry, jets, hits,
-                          _shifted_blocked=_shifted_blocked)[:2]
-
-
-def _surface_links(objects, cfg, flags, fluid_idx, dir, body_id, rx, ry,
-                   jets=(), hits=None, *, _shifted_blocked=False):
-    """(velocity, aperture, jet shape, jet id); the last two are None without jets.
-
    Host-only and storage-neutral: rows follow the given physical cut-link
-    order. Returns all None when neither an object carries surface
+    order. Returns (None, None) when neither an object carries surface
    actuation nor a jet is given. Jets need true FP64 ``hits`` (n, 2) and may
    not share a link with each other or with a legacy aperture.
    Shifted storage is privately enabled only by the all-blocked stepper.
    """
    enabled = [obj for obj in objects if obj.surface_actuation is not None]
    if not enabled and not jets:
-        return None, None, None, None
-    from .preprocess.flag_overlay import validate_cut_link_ownership
-    validate_cut_link_ownership(flags, fluid_idx, dir, cfg.nq)
+        return None, None
+    from ..lbm.descriptors import FLUID, SOLID
+    if np.any((flags[fluid_idx] & FLUID) == 0) or np.any(flags[fluid_idx] & SOLID):
+        raise ValueError("Surface cut links must have active fluid receivers")
+    if len(np.unique(fluid_idx.astype(np.uint64)*cfg.nq+dir)) != len(dir):
+        raise ValueError("Surface boundary requires unique cut-link writers")
    surface_velocity = np.zeros((len(dir), 2), np.float32)
    surface_aperture = np.zeros(len(dir), bool)
-    shape = jet_id = None
    for obj in enabled:
        obj.validate_surface_actuation(cfg)
        selected = body_id == obj.obj_id
@@ -263,4 +255,4 @@ def _surface_links(objects, cfg, flags, fluid_idx, dir, body_id, rx, ry,
            raise ValueError("Jet overlaps a SurfaceActuation aperture")
        surface_velocity[driven] = jet_link_velocity(jets, shape, jet_id)[driven]
        surface_aperture |= driven
-    return surface_velocity, surface_aperture, shape, jet_id
+    return surface_velocity, surface_aperture
@@ -11,7 +11,7 @@ Responsibilities:

 Design::
  Packed ``obs`` layout matches ``generate_config(..., n_objects=count)`` and
-  ``config_obs.h`` macros. Host sizing uses :func:`~CelerisLab.cuda.compiler.obs_layout`.
+  ``config_obs.h`` macros. Host sizing uses :func:`~CelerisLab.cuda.compiler_v2.obs_layout`.

  Pending edits are lightweight: only the "intent" (add / remove) is stored.
  All derived quantities (flags, compact lists, GPU buffers) are built at
@@ -27,8 +27,8 @@ import pycuda.driver as cuda

 from .objects import SimObject
 from .registry import BodyRegistry
-from .preprocess.flag_overlay import merge_flag_masks, validate_cut_link_ownership
-from ..cuda.compiler import obs_layout
+from .preprocess.flag_overlay import merge_flag_masks
+from ..cuda.compiler_v2 import obs_layout
 from ..cuda.obs_layout import ObsLayout
 from ..lbm.descriptors import (
    FLUID, SOLID,
@@ -369,9 +369,9 @@ class ObjectManager:

        Args:
            objects: List of SimObject instances to process.
-            domain_flags: Optional uint16 flags for receiver/donor classification.
+            domain_flags: Optional uint16 flags for donor-cell classification.
            sensor_cell_counts_out: Int array to fill with per-object sensor
-                cell counts after the full geometry has passed validation.
+                cell counts.  If provided, ``fill(0)`` is called first.
            hits_out: List that receives one FP64 (n, 2) array of true hit
                points row-aligned with the cut-link columns (for Jets).

@@ -394,8 +394,8 @@ class ObjectManager:
        active_fluid = ((domain_flags & FLUID) != 0) & ((domain_flags & SOLID) == 0)
        force_owners: set[int] = set()

-        sensor_counts = (np.zeros_like(sensor_cell_counts_out)
-                         if sensor_cell_counts_out is not None else None)
+        if sensor_cell_counts_out is not None:
+            sensor_cell_counts_out.fill(0)

        ez = None
        if self.cfg and self.cfg.is_d3q19:
@@ -430,9 +430,9 @@ class ObjectManager:
                if len(cells) > 0:
                    s_cells.append(cells)
                    s_ids.append(ids)
-                    if (sensor_counts is not None
-                            and 0 <= obj.obj_id < sensor_counts.size):
-                        sensor_counts[obj.obj_id] = int(len(cells))
+                    if (sensor_cell_counts_out is not None
+                            and 0 <= obj.obj_id < sensor_cell_counts_out.size):
+                        sensor_cell_counts_out[obj.obj_id] = int(len(cells))
            if obj.is_force_region and hasattr(obj, 'get_sensor_list'):
                cells, ids = obj.get_sensor_list(self.nx, self.ny, self.nz)
                keep = active_fluid[cells]
@@ -461,9 +461,8 @@ class ObjectManager:
        r_fr_ids = np.concatenate(fr_ids) if fr_ids else np.zeros(0, dtype=np.int32)

        r_hit = np.concatenate(cl_hit) if cl_hit else np.zeros((0, 2))
-        # Passive walls need the same ownership guarantees as driven walls.
-        # Overlapping solids are not a supported union-boundary operation.
-        validate_cut_link_ownership(domain_flags, r_idx, r_dir, self.nq)
+        if hits_out is not None:
+            hits_out.append(r_hit)
        if self.jets or any(obj.surface_actuation is not None for obj in objects):
            # Reject unresolved apertures/ownership before sync or restart mutates state.
            from ..lbm.curved_links import CurvedLinkSoA
@@ -471,11 +470,6 @@ class ObjectManager:
            links.assign_host(r_idx, r_dir, r_q, r_bid, r_rx, r_ry, r_rz, r_fallback)
            links.assign_surface(objects, self.cfg, domain_flags, jets=self.jets, hits=r_hit)

-        if sensor_cell_counts_out is not None:
-            sensor_cell_counts_out[:] = sensor_counts
-        if hits_out is not None:
-            hits_out.append(r_hit)
-
        return (
            r_idx, r_dir, r_q, r_bid,
            r_rx, r_ry, r_rz, r_fallback,
@@ -493,6 +487,8 @@ class ObjectManager:
                the caller has already prepared and uploaded the final flag field
                for this geometry, such as during initialization.
        """
+        self._telemetry_field = field
+
        next_flags = self.build_flags(field.build_channel_flags()) if rebuild_flags else field.flag
        hits = []

@@ -503,7 +499,6 @@ class ObjectManager:
            fr_cells, fr_obj_id,
        ) = self.build_compact_lists(domain_flags=next_flags, hits_out=hits)

-        self._telemetry_field = field
        if rebuild_flags:
            field.flag = next_flags
            field.upload_flags()
@@ -1,6 +1,6 @@
 # CelerisLab/body/preprocess/flag_overlay.py
 """
-Flag overlay and cut-link ownership checks against the merged domain.
+Flag overlay: merge per-object flag masks onto a clean domain base.
 """

 from __future__ import annotations
@@ -12,15 +12,6 @@ import numpy as np
 from ...lbm.descriptors import FLUID, SOLID, SENSOR_FLAG, FRC_REGION


-def validate_cut_link_ownership(flags, fluid_idx, directions, nq):
-    """Reject solid receivers and multiple writers to one population."""
-    if np.any((flags[fluid_idx] & FLUID) == 0) or np.any(flags[fluid_idx] & SOLID):
-        raise ValueError("Cut links must have active fluid receivers")
-    writers = fluid_idx.astype(np.uint64) * nq + directions
-    if len(np.unique(writers)) != len(directions):
-        raise ValueError("Boundary requires unique cut-link writers")
-
-
 def merge_flag_masks(
    base: np.ndarray,
    masks: List[np.ndarray],
@@ -7,7 +7,7 @@ Two JSON files:
  config_body.json – object list

 LBMConfig / BodyConfig are plain dataclasses; they translate to
-macro dicts consumed by `cuda/compiler.py` for header generation.
+macro dicts consumed by `cuda/compiler_v2.py` for header generation.
 """

 import json
@@ -60,14 +60,14 @@ Python `config.py` 只负责读取和校验，不是配置位置。显式配置

 **`lbm/kernels/config/*.h` 由编译器根据 `LBMConfig` 自动生成，请勿手改。**

-仓库中检入的 `config/*.h` 可能是历史版本。`compiler.generate_config` 会复制 kernel 源码到独立临时构建目录，并在副本中生成配置；不会改写包内头文件或 PTX。返回目录须显式传给 `compile_kernel(build_dir=...)`，编译结果与配置摘要均保存在该目录。`Simulation` 负责目录清理；直接使用编译器的调用者须调用 `cleanup_build_dir()`。跳过生成配置直接编译仓库中的 `uniform.cu` 属不受支持用法。
+仓库中检入的 `config/*.h` 可能是历史版本。`compiler_v2.generate_config` 会复制 kernel 源码到独立临时构建目录，并在副本中生成配置；不会改写包内头文件或 PTX。返回目录须显式传给 `compile_kernel(build_dir=...)`，编译结果与配置摘要均保存在该目录。`Simulation` 负责目录清理；直接使用编译器的调用者须调用 `cleanup_build_dir()`。跳过生成配置直接编译仓库中的 `kernel_v2.cu` 属不受支持用法。

 ```
 config_lbm.json
  ↓  load_lbm_config()
 config.py:LBMConfig       (读取 + 校验)
  ↓  to_macros()
-cuda/compiler.py          (独立构建目录中生成 config/*.h)
+cuda/compiler_v2.py       (独立构建目录中生成 config/*.h)
  ↓
 config_grid.h             → NX, NY, NZ, NT, LATTICE_MODEL；
                            DIM / NQ 由 LATTICE_MODEL 推导写入（与 grid.lattice_model 一致，非 JSON 顶层字段）
@@ -1,4 +1,4 @@
 """CUDA build helpers (compilation itself does not need a live context)."""
-from . import compiler
+from . import compiler_v2 as compiler

 __all__ = ["compiler"]
@@ -1,13 +1,11 @@
-# CelerisLab/cuda/compiler.py
+# CelerisLab/cuda/compiler_v2.py
 """
 Kernel configuration, compilation, and module loading.

-Owners call build_module(cfg, entry, arch=...), then set_params(module, omega, ...).
-build_module runs, in a private directory it removes afterwards:
+Workflow:
  1. build_dir = generate_config(lbm_cfg, n_objects) — isolated source snapshot
-  2. compile_kernel(arch, source=entry, build_dir=build_dir) — nvcc -ptx
+  2. compile_kernel(arch, build_dir=build_dir)       — nvcc -ptx kernel_v2.cu
  3. load_module(ptx_path)              — PyCUDA module from PTX
-Entries: uniform.cu (uniform grid), blocked.cu (every blocked level, single or refined).
 """

 from __future__ import annotations
@@ -18,6 +16,7 @@ import shutil
 import tempfile
 import hashlib
 import json
+from contextvars import ContextVar
 from dataclasses import asdict
 from pathlib import Path
 from typing import Optional
@@ -34,6 +33,9 @@ _KERNEL_DIR = os.path.join(
 )


+_last_build_dir = ContextVar("celeris_last_build_dir", default=None)
+_last_ptx_path = ContextVar("celeris_last_ptx_path", default=None)
+

 def kernel_path(filename: str) -> str:
    return os.path.join(_KERNEL_DIR, filename)
@@ -52,16 +54,14 @@ def _write(path: str, content: str):


 def generate_config(cfg: LBMConfig, n_objects: int = 0,
-                    *, build_root: Optional[str] = None, block_root_bc: int = 0) -> str:
+                    *, build_root: Optional[str] = None) -> str:
    """Snapshot kernels and render headers in a fresh private directory.

-    Returns its path; pass it to compile_kernel(build_dir=...). The caller owns cleanup_build_dir() once the loaded module is no longer
+    Returns its path. Pass it explicitly to compile_kernel for interleaved
+    builds. Legacy generate_config(); compile_kernel() remains context-local.
+    The caller owns cleanup_build_dir() once the loaded module is no longer
    needed for recompilation/debugging. No package files are changed.
-    block_root_bc specializes a blocked root module; fine/dense builds use 0.
    """
-    if (isinstance(block_root_bc, bool) or not isinstance(block_root_bc, int)
-            or block_root_bc not in (0, 1, 2)):
-        raise ValueError("block_root_bc must be an integer mode 0, 1 or 2")
    macros = cfg.to_macros()
    if isinstance(n_objects, bool) or not isinstance(n_objects, int) or n_objects < 0:
        raise ValueError("n_objects must be a nonnegative integer")
@@ -71,19 +71,20 @@ def generate_config(cfg: LBMConfig, n_objects: int = 0,
    try:
        shutil.copytree(_KERNEL_DIR, build_dir, dirs_exist_ok=True,
                        ignore=shutil.ignore_patterns("*.ptx", "*.cubin", "*.tmp"))
-        _render_config(macros, n_objects, os.path.join(build_dir, "config"),
-                       block_root_bc=block_root_bc)
+        _render_config(macros, n_objects, os.path.join(build_dir, "config"))
        digest = hashlib.sha256()
        for path in sorted(Path(build_dir).rglob("*")):
            if path.is_file():
                digest.update(str(path.relative_to(build_dir)).encode())
                digest.update(path.read_bytes())
        metadata = {"source_sha256": digest.hexdigest(), "config": asdict(cfg),
-                    "n_objects": n_objects, "block_root_bc": block_root_bc}
+                    "n_objects": n_objects}
        _write(os.path.join(build_dir, ".celeris-build"), json.dumps(metadata, sort_keys=True))
    except BaseException:
        shutil.rmtree(build_dir)
        raise
+    _last_build_dir.set(build_dir)
+    _last_ptx_path.set(None)
    return build_dir


@@ -95,9 +96,12 @@ def cleanup_build_dir(build_dir: Optional[str]) -> None:
    if path == Path(_KERNEL_DIR).resolve() or not (path / ".celeris-build").is_file():
        raise ValueError("Refusing to remove a directory not owned by the compiler")
    shutil.rmtree(path)
+    if _last_build_dir.get() == str(build_dir):
+        _last_build_dir.set(None)
+        _last_ptx_path.set(None)


-def _render_config(m: dict, n_objects: int, cdir: str, *, block_root_bc: int = 0):
+def _render_config(m: dict, n_objects: int, cdir: str):
    _write(os.path.join(cdir, "config_grid.h"), f"""{_HEADER}\
 // Layer: Global / Grid
 #ifndef CELERIS_CONFIG_GRID_H
@@ -161,9 +165,6 @@ def _render_config(m: dict, n_objects: int, cdir: str, *, block_root_bc: int = 0
 #define STORE_PRECISION  {m['STORE_PRECISION']}
 #define USE_DDF_SHIFTING {m['USE_DDF_SHIFTING']}

-// Internal blocked root mode: 0=periodic/fine, 1=slot/reservoir, 2=channel.
-#define BLOCK_ROOT_BC {block_root_bc}
-
 #define USE_LES {m['USE_LES']}
 #define LES_CS  {m['LES_CS']}
 #define LES_CLOSED_FORM {m['LES_CLOSED_FORM']}
@@ -240,9 +241,13 @@ def _render_config(m: dict, n_objects: int, cdir: str, *, block_root_bc: int = 0
 # ---------------------------------------------------------------------------
 # Compilation
 # ---------------------------------------------------------------------------
-def compile_kernel(arch: str = "sm_70", source: str = "uniform.cu",
-                   output: Optional[str] = None, *, build_dir: str) -> str:
-    """Compile the snapshot in build_dir (from generate_config); never package headers."""
+def compile_kernel(arch: str = "sm_70", source: str = "kernel_v2.cu",
+                   output: Optional[str] = None, *,
+                   build_dir: Optional[str] = None) -> str:
+    """Compile a generated private source snapshot; never use package headers."""
+    # A failed attempt must not make implicit load_module() reuse older code.
+    _last_ptx_path.set(None)
+    build_dir = build_dir or _last_build_dir.get()
    if not build_dir or not (Path(build_dir) / ".celeris-build").is_file():
        raise RuntimeError("Call generate_config() and pass its build_dir before compiling")
    root = Path(build_dir).resolve()
@@ -267,36 +272,23 @@ def compile_kernel(arch: str = "sm_70", source: str = "uniform.cu",
    finally:
        if os.path.exists(tmp):
            os.unlink(tmp)
+    _last_ptx_path.set(str(dst))
    return str(dst)


-def load_module(ptx_path: str):
-    """Load one compiled PTX file as a new PyCUDA module."""
+def load_module(ptx_path: Optional[str] = None):
+    """Load explicit PTX or the last PTX compiled in this Python context."""
+    ptx_path = ptx_path or _last_ptx_path.get()
+    if not ptx_path:
+        raise RuntimeError("No compiled PTX; call compile_kernel() first")
    import pycuda.driver as cuda
    return cuda.module_from_file(ptx_path)


-def build_module(cfg: LBMConfig, source: str, *, arch: str, n_objects: int = 0,
-                 block_root_bc: int = 0):
-    """Generate, compile and load one private module; the build directory is removed.
+# ---------------------------------------------------------------------------
+# Back-compat helpers (used by test scripts)
+# ---------------------------------------------------------------------------

-    The single build path of every owner (Simulation, FixedPatchStepper levels).
-    Each call returns a NEW module: callers must not share it, because its
-    globals (d_params, ...) are mutable per module.
-    """
-    build_dir = generate_config(cfg, n_objects=n_objects, block_root_bc=block_root_bc)
-    try:
-        return load_module(compile_kernel(arch, source=source, build_dir=build_dir))
-    finally:
-        cleanup_build_dir(build_dir)
-
-
-def set_params(module, omega: float, fx: float = 0.0, fy: float = 0.0, fz: float = 0.0,
-               n_objects: int = 0) -> None:
-    """Write the module's __constant__ LBMParams (core/params.cuh layout)."""
-    import struct
-    import pycuda.driver as cuda
-    ptr, size = module.get_global("d_params")
-    if size != struct.calcsize("=ffffI"):
-        raise RuntimeError("LBMParams host/device layout mismatch")
-    cuda.memcpy_htod(ptr, struct.pack("=ffffI", omega, fx, fy, fz, n_objects))
+def compile_kernel_v2(arch: str = "sm_70") -> str:
+    """Alias for compile_kernel() kept for test-script compatibility."""
+    return compile_kernel(arch=arch)
@@ -2,7 +2,7 @@
 """Packed ``obs`` buffer layout for force / torque / sensor telemetry.

 Usage::
-    Host code (e.g. ``ObjectManager``) and ``compiler.generate_config`` must use
+    Host code (e.g. ``ObjectManager``) and ``compiler_v2.generate_config`` must use
    the same ``dim`` and ``n_objects`` so allocation sizes match device macros.

 Design::
@@ -0,0 +1,286 @@
+# CelerisLab/lbm/block_stepper.py
+"""Opt-in periodic backend for one BlockLayout2D level, optional static circles.
+
+D2Q9/SRT/FP32 unforced double buffers. Each step refreshes every halo from
+its owner core, then pulls/collides core cells into the spare buffer, then
+swaps. Only halo pair tables are uploaded; dense ownership stays on the host.
+The caller owns the CudaContext and must close this backend before it.
+Optional ``objects`` are stationary passive circles (static linear BFL via
+receiver-local staging: halo refresh -> cut links -> pull, no copy between).
+No force/actuation readout, motion, walls, refinement, checkpoint or runtime
+parameter mutation; wall/slot/inlet fields in cfg are ignored.
+"""
+from dataclasses import replace
+from numbers import Integral
+import struct
+from threading import RLock
+
+import numpy as np
+import pycuda.driver as cuda
+
+from ..cuda import compiler_v2 as compiler
+from .blocks import NQ, BlockLayout2D, blocked_link_tables
+from .descriptors import D2Q9_EX, D2Q9_EY, FLUID, SOLID
+from .population_storage import _StoredPopulations, _encode_physical, _decode_stored
+
+MAX_GRID_DIM = 65535  # CUDA gridDim.y/z limit (rows, blocks)
+
+
+def _static_circles(layout, objects):
+    """Host tables for stationary circles; rejects before any CUDA work.
+
+    Every periodic neighbor of every fluid core is inspected, including domain
+    edges that CircleGeometry does not enumerate, so clipped or incomplete
+    geometry cannot pass. Each physical link has one receiver-owning block.
+    """
+    from ..body.geometry.circle import CircleGeometry
+
+    ny, nx = layout.shape
+    flags = np.full(ny * nx, FLUID, np.uint16)
+    for obj in objects:
+        if (type(obj.geometry) is not CircleGeometry or obj.is_sensor or obj.is_force_region
+                or obj.surface_actuation is not None
+                or any(getattr(obj.state, name) != 0 for name in ("vx", "vy", "omega"))
+                or any(vars(obj.control).values())):
+            raise ValueError("Block bodies must be stationary passive circles")
+        cx, cy = obj.geometry.center
+        radius = obj.geometry._radius
+        if not np.isfinite([cx, cy, radius]).all() or radius <= 0:
+            raise ValueError("Block circle center/radius must be finite with radius > 0")
+        mask = obj.geometry.build_flag_mask(nx, ny)
+        solid = (mask & SOLID) != 0
+        if not solid.any() or np.any(flags[solid] & SOLID):
+            raise ValueError("Block circles must be resolved and disjoint")
+        flags[solid] = mask[solid]
+    solid = ((flags & SOLID) != 0).reshape(ny, nx)
+    if solid[[0, -1]].any() or solid[:, [0, -1]].any():
+        raise ValueError("Block circles must not touch the domain edge")
+    links = [link for obj in objects
+             for link in obj.geometry.build_cut_links(nx, ny, domain_flags=flags)]
+    def source(r, q):
+        y, x = divmod(r, nx)
+        return (y + D2Q9_EY[q]) % ny, (x + D2Q9_EX[q]) % nx
+    receivers = {(int(link.fluid_idx), int(link.dir)) for link in links}
+    required = {(int(r), q) for r in np.flatnonzero(~solid.ravel())
+                for q in range(1, NQ) if solid[source(r, q)]}
+    if len(receivers) != len(links) or receivers != required:
+        raise ValueError("Cut links must cover every fluid pull from a solid exactly once")
+    tables, _ = blocked_link_tables(
+        layout, flags, np.array([link.fluid_idx for link in links], np.uint32),
+        np.array([link.dir for link in links], np.uint8),
+        np.array([link.q for link in links], np.float32),
+        np.array([link.fallback for link in links], np.uint8))
+    return dict(solid=solid, **tables)
+
+
+class PeriodicBlockStepper:
+    """G->G stepping of Q-major (9, ny, nx) postcollision populations.
+
+    On a device/launch failure the instance becomes unusable: close and
+    recreate it rather than assuming a partially advanced buffer rolled back.
+    """
+    def __init__(self, cfg, layout, *, context, objects=()):
+        if not isinstance(layout, BlockLayout2D) or layout.periodic != (True, True):
+            raise ValueError("PeriodicBlockStepper requires a doubly periodic BlockLayout2D")
+        checked = replace(cfg)
+        checked.validate()
+        if (not checked.is_d2q9 or checked.collision != "SRT"
+                or checked.streaming != "double_buffer" or checked.store_precision != "FP32"
+                or checked.les_enabled
+                or (checked.ny, checked.nx) != layout.shape):
+            raise ValueError("PeriodicBlockStepper requires matching D2Q9/SRT/FP32/"
+                             "double_buffer config without LES")
+        ly, lx = layout.local_shape
+        pairs = len(layout.halo_dst)
+        tpb = checked.threads_per_block
+        if layout.nblocks > MAX_GRID_DIM or ly > MAX_GRID_DIM or not 0 < pairs < 2**31:
+            raise ValueError("block count, block rows or halo pairs exceed launch limits")
+        objects = tuple(objects)  # an empty iterable takes the body-free path
+        self.boundary = _static_circles(layout, objects) if objects else None
+        links = 0 if self.boundary is None else len(self.boundary["cell"])
+        if links >= 2**31:
+            raise ValueError("cut links exceed launch limits")
+        self._ddf_shifting = bool(checked.ddf_shifting)
+        self.layout = layout
+        self.ctx = context
+        self._links = links
+        self._link_grid = ((links + tpb - 1) // tpb, 1)
+        # Wall/slot fields are not applied; neutralize them like the fine patch level.
+        self._local_cfg = replace(checked, nx=lx, ny=ly, y_wall_bc="bounce_back", top_wall_bc="velocity",
+                                  wall_slot_width=0, wall_normal_velocity=0.0, velocity=0.0)
+        self._block = (tpb, 1, 1)
+        self._grid = ((lx + tpb - 1) // tpb, ly, layout.nblocks)
+        self._copy_grid = ((pairs + tpb - 1) // tpb, 1)
+        self._bytes = int(np.prod(layout.blocked_shape)) * 4
+        self._lock = RLock()
+        self._status = "new"
+        self._step_count = 0
+        self._allocations = []
+        self._stream = self._module = self._copy = self._step = self._curved = None
+        self._tables = {}
+        with self.ctx.activate():
+            try:
+                free, _ = cuda.mem_get_info()
+                tables = sum(a.nbytes for k, a in (self.boundary or {}).items() if k != "solid")
+                if 2 * self._bytes + layout.halo_dst.nbytes + layout.halo_src.nbytes + tables > free:
+                    raise MemoryError("blocked buffers exceed free device memory")
+                self._stream = cuda.Stream()
+                config = self._local_cfg
+                config.validate()
+                if not np.isclose(config.omega, 1 / (3 * checked.viscosity + .5), rtol=1e-14, atol=0):
+                    raise RuntimeError("block omega/tau mismatch")
+                build = compiler.generate_config(config)
+                try:
+                    ptx = compiler.compile_kernel(self.ctx.sm_arch, source="blocks.cu", build_dir=build)
+                    module = compiler.load_module(ptx)
+                finally:
+                    compiler.cleanup_build_dir(build)
+                ptr, size = module.get_global("d_params")
+                if size != struct.calcsize("=ffffI"):
+                    raise RuntimeError("LBMParams host/device layout mismatch")
+                cuda.memcpy_htod(ptr, struct.pack("=ffffI", config.omega, 0, 0, 0, 0))
+                self._module = module
+                self._current = self._allocate(self._bytes)
+                self._spare = self._allocate(self._bytes)
+                self._dst = self._upload(layout.halo_dst)
+                self._src = self._upload(layout.halo_src)
+                self._copy = module.get_function("BlockHaloCopy")
+                self._step = module.get_function("BlockStep")
+                if self.boundary is not None:
+                    self._tables = {k: self._upload(a) for k, a in self.boundary.items() if k != "solid"}
+                    self._curved = module.get_function("BlockCurvedBoundary")
+            except BaseException:
+                try:
+                    self.close()
+                except Exception:
+                    pass  # Preserve the original construction failure.
+                raise
+
+    def _allocate(self, size):
+        pointer = cuda.mem_alloc(size)
+        self._allocations.append(pointer)
+        return pointer
+
+    def _upload(self, array):
+        array = np.ascontiguousarray(array)
+        pointer = self._allocate(array.nbytes)
+        cuda.memcpy_htod(pointer, array)
+        return pointer
+
+    def _require(self, *states):
+        if self._status not in states:
+            raise RuntimeError(f"Block stepper is {self._status}; expected {' or '.join(states)}")
+
+    @property
+    def step_count(self):
+        return self._step_count
+
+    def initialize(self, g):
+        """Upload dense G_0; the spare buffer starts NaN so stale halos cannot hide."""
+        with self._lock, self.ctx.activate():
+            self._require("new", "ready")
+            dense = np.array(g, dtype=np.float64 if self._ddf_shifting else np.float32,
+                             order="C", copy=True)
+            if dense.shape != (NQ, *self.layout.shape):
+                raise ValueError("Expected a Q-major (9, ny, nx) array")
+            fluid = np.ones(self.layout.shape, bool) if self.boundary is None else ~self.boundary["solid"]
+            if not np.isfinite(dense[:, fluid]).all() or (dense[:, fluid].sum(axis=0) <= 0).any():
+                raise ValueError("Fluid populations must be finite with positive density")
+            dense[:, ~fluid] = np.nan  # Solid cores are deliberately invalid.
+            encoded = _encode_physical(dense, self._ddf_shifting)
+            values = encoded[:, fluid]
+            if (not np.isfinite(values).all()
+                    or (values.sum(axis=0, dtype=np.float64) + int(self._ddf_shifting) <= 0).any()):
+                raise ValueError("Stored fluid populations must be finite with positive density")
+            blocked = self.layout.to_blocked(encoded)
+            spare = np.full_like(blocked, np.nan)
+            try:
+                cuda.memcpy_htod(self._current, blocked)
+                cuda.memcpy_htod(self._spare, spare)
+                self._step_count = 0
+                self._status = "ready"
+            except BaseException:
+                self._status = "failed"
+                raise
+
+    def step(self, n=1):
+        """Advance n steps: halo refresh, then core pull/collide, per step."""
+        if isinstance(n, bool) or not isinstance(n, Integral) or n < 0:
+            raise ValueError("n must be a nonnegative integer")
+        with self._lock, self.ctx.activate():
+            self._require("ready")
+            kw = dict(block=self._block, stream=self._stream)
+            try:
+                self._status = "advancing"
+                for _ in range(n):
+                    self._copy(self._current, self._dst, self._src,
+                               np.uint32(len(self.layout.halo_dst)), grid=self._copy_grid, **kw)
+                    if self._curved is not None:
+                        t = self._tables
+                        self._curved(self._current, t["block"], t["cell"], t["dir"], t["q"],
+                                     t["fallback"], np.uint32(self._links), np.uintp(0),  # no actuation
+                                     np.uintp(0), np.uintp(0), np.uintp(0),  # no observation
+                                     grid=self._link_grid, **kw)
+                    self._step(self._current, self._spare, np.uint32(self.layout.halo),
+                               self._tables.get("flags", np.uintp(0)), np.uintp(0),  # no kind
+                               grid=self._grid, **kw)
+                    self._stream.synchronize()
+                    self._current, self._spare = self._spare, self._current
+                    self._step_count += 1
+                self._status = "ready"
+            except BaseException:
+                self._status = "failed"
+                raise
+
+    def download(self):
+        """Return physical core populations (FP64 when shifted); no host cache."""
+        snapshot = self._download_raw()
+        return _decode_stored(snapshot.values[0], snapshot.shifted)
+
+    def _download_raw(self):
+        """Return one tagged dense FP32 population array without conversion."""
+        with self._lock, self.ctx.activate():
+            self._require("ready")
+            blocked = np.empty(self.layout.blocked_shape, np.float32)
+            try:
+                cuda.memcpy_dtoh(blocked, self._current)
+            except BaseException:
+                self._status = "failed"
+                raise
+            return _StoredPopulations((self.layout.to_dense(blocked),), self._ddf_shifting)
+
+    def close(self):
+        """Release owned resources; retain them for retry if context activation fails."""
+        with self._lock:
+            if self._status == "closed":
+                return
+            self._status = "failed"
+            with self.ctx.activate():
+                self._status = "closed"
+                error = None
+                try:
+                    if self._stream is not None:
+                        self._stream.synchronize()
+                except Exception as exc:
+                    error = exc
+                self._copy = self._step = self._curved = self._module = None
+                self._tables = {}
+                for pointer in self._allocations:
+                    try:
+                        pointer.free()
+                    except Exception as exc:
+                        error = error or exc
+                self._allocations.clear()
+                self._stream = None
+                if error is not None:
+                    raise error
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        try:
+            self.close()
+        except Exception:
+            if exc[0] is None:
+                raise
@@ -31,7 +31,7 @@ receiver-local boundary values: the solid's owner-core copy of that slot may
 be stale, which is distinct from the unique core ownership of stored state.
 No moving geometry is implied.
 """
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 from numbers import Integral
 from types import SimpleNamespace

@@ -373,84 +373,3 @@ def blocked_link_tables(layout, flags, fluid_idx, dir, q, fallback):
                  dir=columns[1].astype(np.uint8), q=columns[2].astype(np.float32),
                  fallback=columns[3].astype(np.uint8))
    return tables, mapped
-
-
-# One blocked level as FixedPatchStepper builds and launches it (any depth). Raw argument orders of the blocked.cu kernels live only here.
-
-def level_config(cfg, layout, tau):
-    """Kernel config of one blocked level: NX/NY = block window incl. halo.
-
-    Physical wall/slot/inlet fields are neutralized; a blocked root gets them
-    from its module globals (d_block_wall/d_block_channel) instead.
-    """
-    ly, lx = layout.local_shape
-    local = replace(cfg, nx=lx, ny=ly, y_wall_bc="bounce_back", top_wall_bc="velocity",
-                    wall_slot_width=0, wall_normal_velocity=0.0, velocity=0.0)
-    local.validate()
-    if not np.isclose(local.omega, 1 / tau, rtol=1e-14, atol=0):
-        raise RuntimeError("block level omega/tau mismatch")
-    return local
-
-
-def launch_halo_copy(kernel, buffer, dst, src, count, *, block, stream):
-    """BlockHaloCopy over ``count`` uploaded (dst, src) block-cell pairs."""
-    kernel(buffer, dst, src, np.uint32(count),
-           grid=((count + block[0] - 1) // block[0], 1), block=block, stream=stream)
-
-
-def launch_curved_boundary(kernel, buffer, tables, count, *, block, stream,
-                           velocity=None, rx=None, ry=None, raw=None):
-    """BlockCurvedBoundary on uploaded link tables; None = no actuation/observation."""
-    none = np.uintp(0)
-    kernel(buffer, tables["block"], tables["cell"], tables["dir"], tables["q"], tables["fallback"],
-           np.uint32(count), none if velocity is None else velocity,
-           none if rx is None else rx, none if ry is None else ry, none if raw is None else raw,
-           grid=((count + block[0] - 1) // block[0], 1), block=block, stream=stream)
-
-
-def static_circle_tables(layout, objects):
-    """Host tables for stationary circles; rejects before any CUDA work.
-
-    Every periodic neighbor of every fluid core is inspected, including domain
-    edges that CircleGeometry does not enumerate, so clipped or incomplete
-    geometry cannot pass. Each physical link has one receiver-owning block.
-    """
-    from ..body.geometry.circle import CircleGeometry
-    from .descriptors import FLUID, SOLID
-
-    ny, nx = layout.shape
-    flags = np.full(ny * nx, FLUID, np.uint16)
-    for obj in objects:
-        if (type(obj.geometry) is not CircleGeometry or obj.is_sensor or obj.is_force_region
-                or obj.surface_actuation is not None
-                or any(getattr(obj.state, name) != 0 for name in ("vx", "vy", "omega"))
-                or any(vars(obj.control).values())):
-            raise ValueError("Block bodies must be stationary passive circles")
-        cx, cy = obj.geometry.center
-        radius = obj.geometry._radius
-        if not np.isfinite([cx, cy, radius]).all() or radius <= 0:
-            raise ValueError("Block circle center/radius must be finite with radius > 0")
-        mask = obj.geometry.build_flag_mask(nx, ny)
-        solid = (mask & SOLID) != 0
-        if not solid.any() or np.any(flags[solid] & SOLID):
-            raise ValueError("Block circles must be resolved and disjoint")
-        flags[solid] = mask[solid]
-    solid = ((flags & SOLID) != 0).reshape(ny, nx)
-    if solid[[0, -1]].any() or solid[:, [0, -1]].any():
-        raise ValueError("Block circles must not touch the domain edge")
-    links = [link for obj in objects
-             for link in obj.geometry.build_cut_links(nx, ny, domain_flags=flags)]
-    def source(r, q):
-        y, x = divmod(r, nx)
-        return (y + D2Q9_EY[q]) % ny, (x + D2Q9_EX[q]) % nx
-    receivers = {(int(link.fluid_idx), int(link.dir)) for link in links}
-    required = {(int(r), q) for r in np.flatnonzero(~solid.ravel())
-                for q in range(1, NQ) if solid[source(r, q)]}
-    if len(receivers) != len(links) or receivers != required:
-        raise ValueError("Cut links must cover every fluid pull from a solid exactly once")
-    tables, _ = blocked_link_tables(
-        layout, flags, np.array([link.fluid_idx for link in links], np.uint32),
-        np.array([link.dir for link in links], np.uint8),
-        np.array([link.q for link in links], np.float32),
-        np.array([link.fallback for link in links], np.uint8))
-    return dict(solid=solid, **tables)
@@ -94,10 +94,12 @@ class CurvedLinkSoA:
        """
        self.surface_velocity = self.aperture = None
        self.jets, self.jet_shape, self.jet_id = tuple(jets), None, None
-        from ..body.jets import _surface_links
-        self.surface_velocity, self.aperture, self.jet_shape, self.jet_id = _surface_links(
+        self.surface_velocity, self.aperture = surface_link_velocity(
            objects, cfg, flags, self.fluid_idx, self.dir, self.body_id, self.rx, self.ry,
            jets=self.jets, hits=hits)
+        if self.jets:
+            from ..body.jets import jet_link_shapes
+            self.jet_shape, self.jet_id = jet_link_shapes(self.jets, hits)

    def set_jet_amplitude(self, index, amplitude, stream=None):
        """Rewrite jet rows from cached shapes; re-upload only the velocity column.
@@ -1,49 +0,0 @@
-// CelerisLab/lbm/kernels/blocked.cu
-// One fixed-size blocked level (lbm/blocks.py layout), specialized at compile
-// time for periodic/fine, slot/reservoir or channel stepping. Separate
-// compilation entry: NX, NY are the block window including halo, so index_f
-// and linear_index address one block; blockIdx.z selects the block, whose
-// populations start at b*NQ*TOTAL_CELLS (block-contiguous, Q-major inside).
-#include <stdint.h>
-#include <math.h>
-#include "config.h"
-#include "core/precision.cuh"
-#include "core/descriptors.cuh"
-#include "core/layout.cuh"
-#include "core/params.cuh"
-#include "core/flags.cuh"
-#include "core/obs.cuh"
-#include "core/cell_kind.cuh"
-#include "operators/macro.cuh"
-#include "operators/collision_srt.cuh"
-#if COLLISION_MODEL == 2
-#include "operators/collision_mrt.cuh"
-#endif
-#include "streaming/pull_double_buffer.cuh"
-#include "boundary/curved_boundary.cuh"
-
-#if DIM != 2 || NQ != 9 || (COLLISION_MODEL != 0 && COLLISION_MODEL != 2) || STORE_PRECISION != 0 || USE_LES || STREAMING_MODEL != 0
-#error "Blocks require FP32 D2Q9 SRT or MRT double buffers without LES"
-#endif
-#ifndef BLOCK_ROOT_BC
-#error "Blocks require a generated BLOCK_ROOT_BC mode"
-#elif BLOCK_ROOT_BC < 0 || BLOCK_ROOT_BC > 2
-#error "BLOCK_ROOT_BC must be 0, 1 or 2"
-#endif
-
-#if BLOCK_ROOT_BC == 1
-#include "boundary/block_wall.cuh"
-#endif
-#if BLOCK_ROOT_BC != 2
-#include "operators/block_collision.cuh"
-#endif
-
-// Kernels, in definition order: transfers, boundary staging, then the one full
-// step selected for this module (BlockStep, or BlockChannelStep for a channel root).
-#include "step/block_transfer.cu"
-#include "step/block_boundary.cu"
-#if BLOCK_ROOT_BC != 2
-#include "step/block_step.cu"
-#else
-#include "step/block_channel.cu"
-#endif
@@ -0,0 +1,173 @@
+// CelerisLab/lbm/kernels/blocks.cu
+// One periodic level of fixed-size blocks (lbm/blocks.py layout). Separate
+// compilation entry: NX, NY are the block window including halo, so index_f
+// and linear_index address one block; blockIdx.z selects the block, whose
+// populations start at b*NQ*TOTAL_CELLS (block-contiguous, Q-major inside).
+#include <stdint.h>
+#include <math.h>
+#include "config.h"
+#include "core/precision.cuh"
+#include "core/descriptors.cuh"
+#include "core/layout.cuh"
+#include "core/params.cuh"
+#include "core/flags.cuh"
+#include "core/obs.cuh"
+#include "operators/macro.cuh"
+#include "operators/collision_srt.cuh"
+#if COLLISION_MODEL == 2
+#include "operators/collision_mrt.cuh"
+#endif
+#include "streaming/pull_double_buffer.cuh"
+#include "boundary/curved_boundary.cuh"
+#include "boundary/planar_velocity.cuh"
+
+#if DIM != 2 || NQ != 9 || (COLLISION_MODEL != 0 && COLLISION_MODEL != 2) || STORE_PRECISION != 0 || USE_LES || STREAMING_MODEL != 0
+#error "Blocks require FP32 D2Q9 SRT or MRT double buffers without LES"
+#endif
+
+// Fixed-patch cell kinds, matching refinement.py ACTIVE/INNER_GHOST/OUTER_GHOST.
+constexpr unsigned char KIND_ACTIVE = 0u, KIND_INNER = 1u, KIND_OUTER = 2u;
+
+// Zero-initialized for ordinary blocks/fine levels. Set only for parent walls;
+// NX/NY remain local storage strides, never physical wall coordinates.
+struct BlockWall { unsigned int nx, ny, slot_width; float amplitude; };
+extern "C" { __constant__ BlockWall d_block_wall; }
+
+// Halo refresh: block cell ids b*TOTAL_CELLS+c, sources are always core cells.
+extern "C" __global__ void BlockHaloCopy(
+    fpxx* f, const uint64_t* dst, const uint64_t* src, unsigned int count)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    const uint64_t d = dst[row], s = src[row];
+    fpxx* to = f + (d / TOTAL_CELLS) * NQ * TOTAL_CELLS;
+    const fpxx* from = f + (s / TOTAL_CELLS) * NQ * TOTAL_CELLS;
+    for (unsigned int q = 0; q < NQ; ++q)
+        to[index_f(d % TOTAL_CELLS, q)] = from[index_f(s % TOTAL_CELLS, q)];
+}
+
+// Fixed-patch explosion into blocked fine storage: target = owner block cell
+// id of a patch-ghost cell; donors are parent block cell ids. Dense parent
+// storage is the one-window case with coarse_cells = full domain size.
+extern "C" __global__ void BlockExplode(
+    const fpxx* coarse, fpxx* fine, const uint64_t* target, const uint64_t* donor,
+    unsigned int count, unsigned long coarse_cells)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    const uint64_t t = target[row];
+    fpxx* to = fine + (t / TOTAL_CELLS) * NQ * TOTAL_CELLS;
+    const uint64_t d = donor[row];
+    const fpxx* from = coarse + (d / coarse_cells) * NQ * coarse_cells;
+    for (unsigned int q = 0; q < NQ; ++q)
+        to[index_f(t % TOTAL_CELLS, q)] = from[q * coarse_cells + d % coarse_cells];
+}
+
+// Targets are receiver-local SOURCE slots for the immediately following pull.
+// Keep child summation order identical to PatchCoarseStep; no collision here.
+extern "C" __global__ void BlockCoalesce(
+    const fpxx* fine, fpxx* coarse, const uint64_t* target, const uint64_t* children,
+    unsigned int count)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    const uint64_t* s = children + 4ul * row;
+    coarse[target[row]] = 0.25f * (fine[s[0]] + fine[s[1]] + fine[s[2]] + fine[s[3]]);
+}
+
+// Static cut links, receiver-local staging: cell is the receiver's local core
+// cell, so the existing BFL writes the solid-source window image that this
+// block's next pull reads (no halo copy between this kernel and BlockStep).
+// surface_velocity (nullable, 2 floats per link): prescribed fluid velocity on
+// fixed geometry, same convention as CurvedBoundaryKernel. Optional raw rows
+// (jx,jy,torque,dm) are unique physical links, never body-observation slots.
+extern "C" __global__ void BlockCurvedBoundary(
+    fpxx* f, const uint32_t* block, const uint32_t* cell, const unsigned char* dir,
+    const float* q, const unsigned char* fallback, unsigned int count,
+    const float* surface_velocity, const float* rx, const float* ry, float* raw)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    float Uw = 0.0f, Vw = 0.0f;
+    if (surface_velocity != nullptr) {
+        const float u = surface_velocity[2 * row], v = surface_velocity[2 * row + 1];
+        if (u != 0.0f || v != 0.0f) { Uw = u; Vw = v; }
+    }
+    apply_bouzidi_link(dir[row], q[row], cell[row], f + (unsigned long)block[row] * NQ * TOTAL_CELLS,
+                       Uw, Vw, rx ? rx[row] : 0.0f, ry ? ry[row] : 0.0f,
+                       fallback[row], nullptr, -1, raw ? raw + 4ul * row : nullptr,
+                       raw ? raw + 4ul * row + 3 : nullptr);
+}
+
+// Same-stream BFL -> this row-owned accumulation -> pull step. No atomics,
+// no cross-row reduction and no history allocation proportional to substeps.
+extern "C" __global__ void BlockAccumulateExchange(
+    const float* raw, double* integral, unsigned int count, double h, double dt)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    const unsigned long k = 4ul * row;
+    const double impulse = h * dt;
+    integral[k] += impulse * (double)raw[k];
+    integral[k + 1] += impulse * (double)raw[k + 1];
+    integral[k + 2] += h * impulse * (double)raw[k + 2];
+    integral[k + 3] += h * h * (double)raw[k + 3];
+}
+
+// Pull/collide/store core cells only; halo cells of out are left untouched.
+// flags (block cell ids, nullable): solid cores store NaN and never collide.
+// kind (block cell ids, nullable = all ACTIVE): OUTER skips the pull and
+// stores NaN, INNER pulls without collision, ACTIVE pulls and collides.
+extern "C" __global__ void BlockStep(const fpxx* in, fpxx* out, unsigned int halo,
+                                     const uint16_t* flags, const unsigned char* kind) {
+    unsigned int x, y; unsigned long k;
+    index_from_thread(x, y, k);
+    if (x < halo || y < halo || x >= NX - halo || y >= NY - halo) return;
+    const unsigned long base = (unsigned long)blockIdx.z * NQ * TOTAL_CELLS;
+    const unsigned long cell = (unsigned long)blockIdx.z * TOTAL_CELLS + k;
+    const unsigned char cell_kind = kind != nullptr ? kind[cell] : KIND_ACTIVE;
+    float f[NQ];
+    if (cell_kind == KIND_OUTER || (flags != nullptr && is_solid(flags[cell]))) {
+        for (int q = 0; q < NQ; ++q) f[q] = NAN;
+    } else {
+        unsigned long j[NQ];
+        compute_neighbors(x, y, j);  // Core neighbors stay inside the window: no wrap.
+        stream_pull_load(k, f, in + base, j);
+        if (cell_kind == KIND_ACTIVE) {
+            if (d_block_wall.nx != 0) {
+                const unsigned int bx = NX - 2 * halo, by = NY - 2 * halo;
+                const unsigned int nbx = d_block_wall.nx / bx;
+                const unsigned int gx = (blockIdx.z % nbx) * bx + x - halo;
+                const unsigned int gy = (blockIdx.z / nbx) * by + y - halo;
+                if (gy == 1)
+                    reconstruct_bottom_velocity(f, 0.0f, bottom_wall_normal_velocity(
+                        gx, d_block_wall.nx, d_block_wall.slot_width, d_block_wall.amplitude));
+                else if (gy == d_block_wall.ny - 2) reconstruct_top_reservoir(f, RHO);
+            }
+#if COLLISION_MODEL == 2
+            // Uniform MRT sequence (collide_dispatch, zero forcing); SRT path below unchanged.
+            float rho, ux, uy;
+            compute_rho_u(f, rho, ux, uy);
+            collide_mrt_no_force(f, rho, ux, uy,
+                fminf(OMEGA_COLLISION_MAX, fmaxf(OMEGA_COLLISION_MIN, d_params.omega)));
+#else
+            float rho, ux, uy, feq[NQ];
+            compute_rho_u(f, rho, ux, uy);
+#if USE_DDF_SHIFTING
+            // Preserve the density perturbation before adding the unit reference.
+            const float drho = f[0]+f[1]+f[2]+f[3]+f[4]+f[5]+f[6]+f[7]+f[8];
+            const float jx = f[1]-f[2]+f[5]-f[6]+f[7]-f[8];
+            const float jy = f[3]-f[4]+f[5]-f[6]-f[7]+f[8];
+            compute_feq_from_momentum(drho, jx, jy, ux, uy, feq);
+#else
+            compute_feq(rho, ux, uy, feq);
+#endif
+            collide_srt_no_force(f, feq, d_params.omega);
+#endif
+        }
+    }
+    stream_pull_store(k, f, out + base);
+}
+
+// Root channel closure; fine and periodic levels keep BlockStep.
+#include "step/block_channel.cu"
@@ -1,20 +0,0 @@
-// Physical parent walls; NX/NY remain local storage strides.
-#ifndef CELERIS_BOUNDARY_BLOCK_WALL_CUH
-#define CELERIS_BOUNDARY_BLOCK_WALL_CUH
-
-#include "planar_velocity.cuh"
-
-struct BlockWall { unsigned int nx, ny, slot_width; float amplitude; };
-extern "C" { __constant__ BlockWall d_block_wall; }
-
-__device__ __forceinline__ void block_wall(float* f, unsigned int x, unsigned int y,
-                                         unsigned int halo) {
-    unsigned int gx, gy;
-    block_global_xy(x, y, halo, d_block_wall.nx, gx, gy);
-    if (gy == 1)
-        reconstruct_bottom_velocity(f, 0.0f, bottom_wall_normal_velocity(
-            gx, d_block_wall.nx, d_block_wall.slot_width, d_block_wall.amplitude));
-    else if (gy == d_block_wall.ny - 2) reconstruct_top_reservoir(f, RHO);
-}
-
-#endif
@@ -15,13 +15,10 @@
 // D2Q9 y-wall half-way bounce-back for pull double-buffer streaming.
 // ---------------------------------------------------------------------------
 #if LATTICE_MODEL == LATTICE_D2Q9
-// Rows 1 and top_row (= physical ny - 2) next to walls at rows 0 and ny - 1.
-// y is the physical row; k addresses the node in fi_in (a block window may
-// have NX/NY strides different from the physical extent).
-__device__ inline void apply_wall_bb_d2q9_rows(unsigned int y, unsigned int top_row,
-                                               float* __restrict__ f,
-                                               const fpxx* __restrict__ fi_in,
-                                               unsigned long k)
+__device__ inline void apply_wall_bb_d2q9_y_pull(unsigned int y,
+                                                  float* __restrict__ f,
+                                                  const fpxx* __restrict__ fi_in,
+                                                  unsigned long k)
 {
    if (y == 1) {
        // Directions sourced from y=0 wall in pull step: +y, +x+y, -x+y.
@@ -29,22 +26,14 @@ __device__ inline void apply_wall_bb_d2q9_rows(unsigned int y, unsigned int top_
        f[5] = load_ddf(fi_in, index_f(k, 6u));
        f[8] = load_ddf(fi_in, index_f(k, 7u));
    }
-    else if (y == top_row) {
-        // Directions sourced from the y = ny - 1 wall in pull step: -y, -x-y, +x-y.
+    else if (y == (unsigned int)(NY - 2)) {
+        // Directions sourced from y=NY-1 wall in pull step: -y, -x-y, +x-y.
        f[4] = load_ddf(fi_in, index_f(k, 3u));
        f[6] = load_ddf(fi_in, index_f(k, 5u));
        f[7] = load_ddf(fi_in, index_f(k, 8u));
    }
 }

-__device__ inline void apply_wall_bb_d2q9_y_pull(unsigned int y,
-                                                  float* __restrict__ f,
-                                                  const fpxx* __restrict__ fi_in,
-                                                  unsigned long k)
-{
-    apply_wall_bb_d2q9_rows(y, (unsigned int)(NY - 2), f, fi_in, k);
-}
-
 // ---------------------------------------------------------------------------
 // D2Q9 y-wall free-slip (specular reflection) for pull double-buffer streaming.
 //
@@ -8,9 +8,6 @@
 #define STORE_PRECISION  0
 #define USE_DDF_SHIFTING 0

-// Internal blocked root mode: 0=periodic/fine, 1=slot/reservoir, 2=channel.
-#define BLOCK_ROOT_BC 0
-
 #define USE_LES 0
 #define LES_CS  0.160000f
 #define LES_CLOSED_FORM 1
@@ -1,16 +0,0 @@
-// CelerisLab – core/cell_kind.cuh
-// Fixed-patch cell kinds stored per block cell, matching lbm/refinement.py
-// ACTIVE/INNER_GHOST/OUTER_GHOST: OUTER is invalid (stores NaN, no pull),
-// INNER streams without collision, ACTIVE pulls and collides.
-#ifndef CELERIS_CORE_CELL_KIND_CUH
-#define CELERIS_CORE_CELL_KIND_CUH
-
-constexpr unsigned char KIND_ACTIVE = 0u, KIND_INNER = 1u, KIND_OUTER = 2u;
-
-// NaN populations mark a cell without valid state (OUTER ghost or solid core).
-__device__ __forceinline__ void fill_invalid(float* f)
-{
-    for (int q = 0; q < NQ; ++q) f[q] = NAN;
-}
-
-#endif
@@ -53,18 +53,6 @@ __device__ __forceinline__ void index_from_thread(unsigned int& x,
    k = (unsigned long)y * NX + x;
 }

-// Global cell of window cell (x, y) in block blockIdx.z of a row-major,
-// full-domain block layout domain_nx cells wide. NX/NY are the local strides.
-__device__ __forceinline__ void block_global_xy(unsigned int x, unsigned int y,
-                                                unsigned int halo, unsigned int domain_nx,
-                                                unsigned int& gx, unsigned int& gy)
-{
-    const unsigned int bx = NX - 2 * halo, by = NY - 2 * halo;
-    const unsigned int nbx = domain_nx / bx;
-    gx = (blockIdx.z % nbx) * bx + x - halo;
-    gy = (blockIdx.z / nbx) * by + y - halo;
-}
-
 // ---------------------------------------------------------------------------
 // Neighbor list (periodic BCs via modular arithmetic)
 // ---------------------------------------------------------------------------
@@ -1,4 +1,4 @@
-// CelerisLab – uniform.cu
+// CelerisLab – kernel_v2.cu
 // ============================================================================
 // Compilation entry point (Stage 2 Architecture).
 //
@@ -7,7 +7,7 @@
 //
 // File layout (each <300 lines):
 //   operators/helpers.cuh  — bounce_back_swap, collide_dispatch
-//   step/init_flow.cu      — InitTubeFlow, InitEsoPull
+//   step/init_flow.cu      — InitTubeFlow_v2, InitEsoPull
 //   step/one_step_double.cu — OneStep (pull double-buffer)
 //   step/one_step_esopull.cu — EsoPullStep (single-buffer)
 //   step/aux_kernels.cu    — CurvedBoundaryKernel, SensorKernel
@@ -1,31 +0,0 @@
-// Collision used by periodic/fine and slot/reservoir BlockStep.
-#ifndef CELERIS_OPERATORS_BLOCK_COLLISION_CUH
-#define CELERIS_OPERATORS_BLOCK_COLLISION_CUH
-
-#include "../core/params.cuh"
-#include "macro.cuh"
-#include "collision_srt.cuh"
-#if COLLISION_MODEL == 2
-#include "collision_mrt.cuh"
-#endif
-
-__device__ __forceinline__ void block_collide(float* f) {
-#if COLLISION_MODEL == 2
-    collide_mrt_unforced(f);  // SRT path below unchanged.
-#else
-    float rho, ux, uy, feq[NQ];
-    compute_rho_u(f, rho, ux, uy);
-#if USE_DDF_SHIFTING
-    // Preserve the density perturbation before adding the unit reference.
-    const float drho = f[0]+f[1]+f[2]+f[3]+f[4]+f[5]+f[6]+f[7]+f[8];
-    const float jx = f[1]-f[2]+f[5]-f[6]+f[7]-f[8];
-    const float jy = f[3]-f[4]+f[5]-f[6]-f[7]+f[8];
-    compute_feq_from_momentum(drho, jx, jy, ux, uy, feq);
-#else
-    compute_feq(rho, ux, uy, feq);
-#endif
-    collide_srt_no_force(f, feq, d_params.omega);
-#endif
-}
-
-#endif
@@ -1,14 +0,0 @@
-// CelerisLab – operators/bounce_back_swap.cuh
-// Full-way bounce-back at a wall node: swap every opposite pair (paired
-// order q, q+1). Needs only NQ; shared by the uniform and blocked steps.
-#ifndef CELERIS_OPERATORS_BOUNCE_BACK_SWAP_CUH
-#define CELERIS_OPERATORS_BOUNCE_BACK_SWAP_CUH
-
-__device__ __forceinline__ void bounce_back_swap(float* f) {
-    #pragma unroll
-    for (int i = 1; i < NQ; i += 2) {
-        float t = f[i]; f[i] = f[i+1]; f[i+1] = t;
-    }
-}
-
-#endif
@@ -114,16 +114,6 @@ __device__ __forceinline__ void collide_mrt_no_force(float* __restrict__ g,
    collide_mrt(g, rho, ux, uy, Fin, omega);
 }

-// Unforced MRT with the clamped device omega, as in collide_dispatch with zero
-// forcing. Shared by the blocked, channel-root and dense-patch collisions.
-__device__ __forceinline__ void collide_mrt_unforced(float* __restrict__ g)
-{
-    float rho, ux, uy;
-    compute_rho_u(g, rho, ux, uy);
-    collide_mrt_no_force(g, rho, ux, uy,
-        fminf(OMEGA_COLLISION_MAX, fmaxf(OMEGA_COLLISION_MIN, d_params.omega)));
-}
-
 #elif LATTICE_MODEL == LATTICE_D3Q19

 __device__ __forceinline__ void collide_mrt(float* __restrict__ g,
@@ -5,7 +5,12 @@
 #ifndef CELERIS_OPERATORS_HELPERS_CUH
 #define CELERIS_OPERATORS_HELPERS_CUH

-#include "bounce_back_swap.cuh"
+__device__ __forceinline__ void bounce_back_swap(float* f) {
+    #pragma unroll
+    for (int i = 1; i < NQ; i += 2) {
+        float t = f[i]; f[i] = f[i+1]; f[i+1] = t;
+    }
+}

 __device__ __forceinline__ void collide_dispatch(
    float* f, float rho_n,
@@ -0,0 +1,130 @@
+// Fixed, unforced internal 2:1 patch. Separate compilation entry;
+// default OneStep/channel kernels are deliberately not included.
+#include <stdint.h>
+#include <math.h>
+#include "config.h"
+#include "core/precision.cuh"
+#include "core/descriptors.cuh"
+#include "core/layout.cuh"
+#include "core/params.cuh"
+#include "core/flags.cuh"
+#include "core/obs.cuh"
+#include "operators/macro.cuh"
+#include "operators/collision_srt.cuh"
+#if COLLISION_MODEL == 2
+#include "operators/collision_mrt.cuh"
+#endif
+#include "streaming/pull_double_buffer.cuh"
+#include "boundary/planar_velocity.cuh"
+#include "boundary/curved_boundary.cuh"
+
+extern "C" {
+#include "step/curved_double.cu"
+}
+
+#if DIM != 2 || NQ != 9 || (COLLISION_MODEL != 0 && COLLISION_MODEL != 2) || STORE_PRECISION != 0 || USE_DDF_SHIFTING || USE_LES || STREAMING_MODEL != 0
+#error "Refinement requires unshifted FP32 D2Q9 SRT or MRT double buffers without LES"
+#endif
+
+// Enabled only in the validation build; no diagnostic arrays in normal builds.
+#ifdef CELERIS_REFINEMENT_AUDIT
+extern "C" {
+__device__ unsigned int collision_counts[TOTAL_CELLS];
+__device__ unsigned int explosion_counts[TOTAL_CELLS];
+__device__ unsigned int incoming_counts[NQ * TOTAL_CELLS];
+}
+#endif
+
+__device__ __forceinline__ void patch_collide(float* f, unsigned long k) {
+#if COLLISION_MODEL == 2
+    float rho, ux, uy;
+    compute_rho_u(f, rho, ux, uy);
+    collide_mrt_no_force(f, rho, ux, uy,
+        fminf(OMEGA_COLLISION_MAX, fmaxf(OMEGA_COLLISION_MIN, d_params.omega)));
+#else
+    float rho, ux, uy, feq[NQ];
+    compute_rho_u(f, rho, ux, uy);
+    compute_feq(rho, ux, uy, feq);
+    collide_srt_no_force(f, feq, d_params.omega);
+#endif
+#ifdef CELERIS_REFINEMENT_AUDIT
+    ++collision_counts[k];
+#endif
+}
+
+extern "C" __global__ void PatchExplode(
+    const float* coarse, float* fine, const uint32_t* targets,
+    const uint32_t* donors, unsigned int count, unsigned long coarse_cells)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    for (unsigned int q = 0; q < NQ; ++q)
+        fine[index_f(targets[row], q)] = coarse[q * coarse_cells + donors[row]];
+#ifdef CELERIS_REFINEMENT_AUDIT
+    ++explosion_counts[targets[row]];
+#endif
+}
+
+extern "C" __global__ void PatchFineStep(const float* in, float* out, const uint16_t* flags) {
+    unsigned int x, y; unsigned long k;
+    index_from_thread(x, y, k);
+    if (x >= NX || y >= NY) return;
+    float f[NQ];
+    // Outer halo is invalid after EACH hop, including when reusing the buffer
+    // that held explosion data. Inner halo only streams; it never collides.
+    if (x < 2 || y < 2 || x >= NX - 2 || y >= NY - 2
+            || (flags != nullptr && is_solid(flags[k]))) {
+        for (int q = 0; q < NQ; ++q) f[q] = NAN;
+    } else {
+        unsigned long j[NQ];
+        compute_neighbors(x, y, j);  // These interior targets never wrap.
+        stream_pull_load(k, f, in, j);
+        if (x >= 4 && y >= 4 && x < NX - 4 && y < NY - 4)
+            patch_collide(f, k);
+    }
+    stream_pull_store(k, f, out);
+}
+
+extern "C" __global__ void PatchCoarseStep(
+    const float* in, float* out, const float* fine,
+    const uint64_t* targets, const uint64_t* children, unsigned int count,
+    unsigned int x0, unsigned int y0, unsigned int x1, unsigned int y1,
+    unsigned int wall_aware)
+{
+    unsigned int x, y; unsigned long k;
+    index_from_thread(x, y, k);
+    if (x >= NX || y >= NY) return;
+    // Both buffers were poisoned at initialization; covered cells stay invalid.
+    if (x >= x0 && x < x1 && y >= y0 && y < y1) return;
+    if (wall_aware && (y == 0 || y == NY - 1)) return;
+    unsigned long j[NQ];
+    compute_neighbors(x, y, j);
+    float f[NQ];
+    stream_pull_load(k, f, in, j);
+    if (x >= x0 - 1 && x <= x1 && y >= y0 - 1 && y <= y1) {
+        for (unsigned int q = 1; q < NQ; ++q) {
+            uint64_t slot = index_f(k, q);
+            unsigned int lo = 0, hi = count;
+            while (lo < hi) {
+                unsigned int mid = lo + (hi - lo) / 2;
+                if (targets[mid] < slot) lo = mid + 1;
+                else hi = mid;
+            }
+            if (lo < count && targets[lo] == slot) {
+                const uint64_t* s = children + 4ul * lo;
+                f[q] = 0.25f * (fine[s[0]] + fine[s[1]] + fine[s[2]] + fine[s[3]]);
+#ifdef CELERIS_REFINEMENT_AUDIT
+                ++incoming_counts[slot];
+#endif
+            }
+        }
+    }
+    // Includes the eight grazing-corner links with UNCOVERED coarse donors.
+    // All replacement arrivals must be in place before computing rho/u.
+    if (wall_aware) {
+        if (y == 1) reconstruct_bottom_velocity(f, 0.0f, bottom_wall_normal_velocity(x));
+        else if (y == NY - 2) reconstruct_top_reservoir(f, RHO);
+    }
+    patch_collide(f, k);
+    stream_pull_store(k, f, out);
+}
@@ -3,7 +3,7 @@
 // ApplyEsoPullCurvedKernel, SensorKernel, ForceRegionKernel.
 //
 // Launched on compact lists (n_curved / n_sensor / n_cells threads).
-// Included by uniform.cu.  No standalone compilation.
+// Included by kernel_v2.cu.  No standalone compilation.
 //
 // Double-buffer mode:
 //   CurvedBoundaryKernel runs BEFORE OneStep.
@@ -1,42 +0,0 @@
-// CelerisLab/lbm/kernels/step/block_boundary.cu
-// Receiver-local curved-boundary staging and its raw-exchange accumulation.
-// Part of the blocked.cu compilation entry; relies on its includes and guards.
-
-// Static cut links, receiver-local staging: cell is the receiver's local core
-// cell, so the existing BFL writes the solid-source window image that this
-// block's next pull reads (no halo copy between this kernel and BlockStep).
-// surface_velocity (nullable, 2 floats per link): prescribed fluid velocity on
-// fixed geometry, same convention as CurvedBoundaryKernel. Optional raw rows
-// (jx,jy,torque,dm) are unique physical links, never body-observation slots.
-extern "C" __global__ void BlockCurvedBoundary(
-    fpxx* f, const uint32_t* block, const uint32_t* cell, const unsigned char* dir,
-    const float* q, const unsigned char* fallback, unsigned int count,
-    const float* surface_velocity, const float* rx, const float* ry, float* raw)
-{
-    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= count) return;
-    float Uw = 0.0f, Vw = 0.0f;
-    if (surface_velocity != nullptr) {
-        const float u = surface_velocity[2 * row], v = surface_velocity[2 * row + 1];
-        if (u != 0.0f || v != 0.0f) { Uw = u; Vw = v; }
-    }
-    apply_bouzidi_link(dir[row], q[row], cell[row], f + (unsigned long)block[row] * NQ * TOTAL_CELLS,
-                       Uw, Vw, rx ? rx[row] : 0.0f, ry ? ry[row] : 0.0f,
-                       fallback[row], nullptr, -1, raw ? raw + 4ul * row : nullptr,
-                       raw ? raw + 4ul * row + 3 : nullptr);
-}
-
-// Same-stream BFL -> this row-owned accumulation -> pull step. No atomics,
-// no cross-row reduction and no history allocation proportional to substeps.
-extern "C" __global__ void BlockAccumulateExchange(
-    const float* raw, double* integral, unsigned int count, double h, double dt)
-{
-    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= count) return;
-    const unsigned long k = 4ul * row;
-    const double impulse = h * dt;
-    integral[k] += impulse * (double)raw[k];
-    integral[k + 1] += impulse * (double)raw[k + 1];
-    integral[k + 2] += h * impulse * (double)raw[k + 2];
-    integral[k + 3] += h * h * (double)raw[k + 3];
-}
@@ -1,12 +1,5 @@
-#if BLOCK_ROOT_BC != 2
-#error "BlockChannelStep requires BLOCK_ROOT_BC == 2"
-#endif
-
 // Root-only blocked counterpart of OneStep's D2Q9/SRT channel closure.
 // NX/NY are LOCAL strides; all physical boundary decisions use global coordinates.
-#include "../core/cell_kind.cuh"
-#include "../operators/bounce_back_swap.cuh"
-#include "../boundary/bounce_back.cuh"
 #include "../boundary/inlet/common.cuh"
 #include "../boundary/inlet/zou_he_local.cuh"
 #include "../boundary/outlet/pressure_neq.cuh"
@@ -22,13 +15,15 @@ extern "C" __global__ void BlockChannelStep(
    unsigned int x, y; unsigned long k;
    index_from_thread(x, y, k);
    if (x < halo || y < halo || x >= NX - halo || y >= NY - halo) return;
-    unsigned int gx, gy;
-    block_global_xy(x, y, halo, d_block_channel.nx, gx, gy);
+    const unsigned int bx = NX - 2 * halo, by = NY - 2 * halo;
+    const unsigned int nbx = d_block_channel.nx / bx;
+    const unsigned int gx = (blockIdx.z % nbx) * bx + x - halo;
+    const unsigned int gy = (blockIdx.z / nbx) * by + y - halo;
    const unsigned long base = (unsigned long)blockIdx.z * NQ * TOTAL_CELLS;
    const unsigned long cell = (unsigned long)blockIdx.z * TOTAL_CELLS + k;
    float f[NQ];
    if (kind != nullptr && kind[cell] == KIND_OUTER) {
-        fill_invalid(f);
+        for (int q = 0; q < NQ; ++q) f[q] = NAN;
    } else {
        unsigned long j[NQ];
        compute_neighbors(x, y, j);
@@ -36,21 +31,35 @@ extern "C" __global__ void BlockChannelStep(
        const bool wall = gy == 0 || gy == d_block_channel.ny - 1;
        const bool outlet = gx == d_block_channel.nx - 1;
        if (wall) {
-            bounce_back_swap(f);  // Wall owns all four corners; ghosts never collide.
+            // Wall owns all four corners. Ghosts pull and swap, never collide.
+            for (int q = 1; q < NQ; q += 2) {
+                const float t = f[q]; f[q] = f[q + 1]; f[q + 1] = t;
+            }
        } else if (gx == 0) {
            apply_zou_he_left_velocity_inlet_d2q9(
                f, inlet_target_u((float)gy, d_block_channel.ny, d_block_channel.velocity), 0.0f);
        } else if (outlet) {
            // Immutable input donor, receiver-local (also valid across a block seam).
            float donor[NQ];
-            load_node(in + base, k - 1, donor);
+            for (int q = 0; q < NQ; ++q)
+                donor[q] = load_ddf(in + base, index_f(k - 1, q));
            apply_pressure_outlet_d2q9(f, donor);
-        } else {
-            apply_wall_bb_d2q9_rows(gy, d_block_channel.ny - 2, f, in + base, k);
+        } else if (gy == 1) {
+            f[3] = load_ddf(in + base, index_f(k, 4));
+            f[5] = load_ddf(in + base, index_f(k, 6));
+            f[8] = load_ddf(in + base, index_f(k, 7));
+        } else if (gy == d_block_channel.ny - 2) {
+            f[4] = load_ddf(in + base, index_f(k, 3));
+            f[6] = load_ddf(in + base, index_f(k, 5));
+            f[7] = load_ddf(in + base, index_f(k, 8));
        }
        if (!wall && !outlet) {
 #if COLLISION_MODEL == 2
-            collide_mrt_unforced(f);
+            // Match uniform MRT arithmetic (collide_dispatch, zero forcing).
+            float rho, ux, uy;
+            compute_rho_u(f, rho, ux, uy);
+            collide_mrt_no_force(f, rho, ux, uy,
+                fminf(OMEGA_COLLISION_MAX, fmaxf(OMEGA_COLLISION_MIN, d_params.omega)));
 #else
            // Match uniform SRT arithmetic, including its shifted equilibrium path.
            float rho, ux, uy, feq[NQ], forcing[NQ] = {};
@@ -1,35 +0,0 @@
-// CelerisLab/lbm/kernels/step/block_step.cu
-// Generic blocked pull/collide/store for periodic/fine and slot/reservoir levels.
-// Part of the blocked.cu compilation entry; relies on its includes and guards.
-#if BLOCK_ROOT_BC == 2
-#error "BlockStep is not built for the channel root (BLOCK_ROOT_BC == 2)"
-#endif
-
-// Pull/collide/store core cells only; halo cells of out are left untouched.
-// flags (block cell ids, nullable): solid cores store NaN and never collide.
-// kind (block cell ids, nullable = all ACTIVE): OUTER skips the pull and
-// stores NaN, INNER pulls without collision, ACTIVE pulls and collides.
-extern "C" __global__ void BlockStep(const fpxx* in, fpxx* out, unsigned int halo,
-                                     const uint16_t* flags, const unsigned char* kind) {
-    unsigned int x, y; unsigned long k;
-    index_from_thread(x, y, k);
-    if (x < halo || y < halo || x >= NX - halo || y >= NY - halo) return;
-    const unsigned long base = (unsigned long)blockIdx.z * NQ * TOTAL_CELLS;
-    const unsigned long cell = (unsigned long)blockIdx.z * TOTAL_CELLS + k;
-    const unsigned char cell_kind = kind != nullptr ? kind[cell] : KIND_ACTIVE;
-    float f[NQ];
-    if (cell_kind == KIND_OUTER || (flags != nullptr && is_solid(flags[cell]))) {
-        fill_invalid(f);
-    } else {
-        unsigned long j[NQ];
-        compute_neighbors(x, y, j);  // Core neighbors stay inside the window: no wrap.
-        stream_pull_load(k, f, in + base, j);
-        if (cell_kind == KIND_ACTIVE) {
-#if BLOCK_ROOT_BC == 1
-            block_wall(f, x, y, halo);
-#endif
-            block_collide(f);
-        }
-    }
-    stream_pull_store(k, f, out + base);
-}
@@ -1,78 +0,0 @@
-// CelerisLab/lbm/kernels/step/block_transfer.cu
-// Same-level halo refresh and 2:1 explosion/coalescence between blocked levels.
-// Part of the blocked.cu compilation entry; relies on its includes and guards.
-
-// Halo refresh: block cell ids b*TOTAL_CELLS+c, sources are always core cells.
-extern "C" __global__ void BlockHaloCopy(
-    fpxx* f, const uint64_t* dst, const uint64_t* src, unsigned int count)
-{
-    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= count) return;
-    const uint64_t d = dst[row], s = src[row];
-    fpxx* to = f + (d / TOTAL_CELLS) * NQ * TOTAL_CELLS;
-    const fpxx* from = f + (s / TOTAL_CELLS) * NQ * TOTAL_CELLS;
-    for (unsigned int q = 0; q < NQ; ++q)
-        to[index_f(d % TOTAL_CELLS, q)] = from[index_f(s % TOTAL_CELLS, q)];
-}
-
-// Fixed-patch explosion into blocked fine storage: target = owner block cell
-// id of a patch-ghost cell; donors are parent block cell ids and coarse_cells
-// is the parent's block window size.
-extern "C" __global__ void BlockExplode(
-    const fpxx* coarse, fpxx* fine, const uint64_t* target, const uint64_t* donor,
-    unsigned int count, unsigned long coarse_cells)
-{
-    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= count) return;
-    const uint64_t t = target[row];
-    fpxx* to = fine + (t / TOTAL_CELLS) * NQ * TOTAL_CELLS;
-    const uint64_t d = donor[row];
-    const fpxx* from = coarse + (d / coarse_cells) * NQ * coarse_cells;
-    for (unsigned int q = 0; q < NQ; ++q)
-        to[index_f(t % TOTAL_CELLS, q)] = from[q * coarse_cells + d % coarse_cells];
-}
-
-// Experimental Schornbaum--Ruede (arXiv:1508.07982, Algorithm 2)
-// and Chen et al. (doi:10.1016/j.physa.2005.09.036) population interpolation.
-// Independent implementation of the mathematical stencil; no upstream source copied.
-// Stencil cells are owner cores; a disabled axis repeats its center twice.
-extern "C" __global__ void BlockExplodeProjected(
-    const fpxx* coarse, fpxx* fine, const uint64_t* target, const uint64_t* donor,
-    unsigned int count, unsigned long coarse_cells,
-    const uint64_t* neighbors, const float* offsets)
-{
-    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= count) return;
-    const uint64_t t = target[row], d = donor[row];
-    fpxx* to = fine + (t / TOTAL_CELLS) * NQ * TOTAL_CELLS;
-    for (unsigned int q = 0; q < NQ; ++q) {
-        float v[4];
-        for (unsigned int a = 0; a < 4; ++a) {
-            const uint64_t n = neighbors[4ul * row + a];
-            v[a] = coarse[(n / coarse_cells) * NQ * coarse_cells
-                          + q * coarse_cells + n % coarse_cells];
-        }
-        float gx = .5f * (v[1] - v[0]), gy = .5f * (v[3] - v[2]);
-        const float ex = d_cx[q], ey = d_cy[q];
-        if (q != 0) {
-            const float along = (ex * gx + ey * gy) / (ex * ex + ey * ey);
-            gx -= ex * along;
-            gy -= ey * along;
-        }
-        to[index_f(t % TOTAL_CELLS, q)] =
-            coarse[(d / coarse_cells) * NQ * coarse_cells + q * coarse_cells + d % coarse_cells]
-            + offsets[2ul * row] * gx + offsets[2ul * row + 1] * gy;
-    }
-}
-
-// Targets are receiver-local SOURCE slots for the immediately following pull.
-// Child summation order ((c0 + c1) + c2) + c3 is part of the numerics; no collision here.
-extern "C" __global__ void BlockCoalesce(
-    const fpxx* fine, fpxx* coarse, const uint64_t* target, const uint64_t* children,
-    unsigned int count)
-{
-    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= count) return;
-    const uint64_t* s = children + 4ul * row;
-    coarse[target[row]] = 0.25f * (fine[s[0]] + fine[s[1]] + fine[s[2]] + fine[s[3]]);
-}
@@ -3,7 +3,7 @@
 //
 // Decodes the EsoPull backing layout into physical distributions, then
 // computes rho/ux/uy.  Output is SoA: rho_out[N], ux_out[N], uy_out[N].
-// Included by uniform.cu.  No standalone compilation.
+// Included by kernel_v2.cu.  No standalone compilation.
 //
 // This kernel is the sole path for macroscopic diagnostics in EsoPull mode.
 // It uses the shared semantic helper layer (esopull_semantic_helpers.cuh).
@@ -5,7 +5,7 @@
 // or encodes physical DDF back to EsoPull backing layout.
 // Each thread handles one cell from a compact index list.
 //
-// Included by uniform.cu.  No standalone compilation.
+// Included by kernel_v2.cu.  No standalone compilation.
 // ============================================================================

 #ifndef CELERIS_STEP_ESOPULL_SYNC_CU
@@ -1,6 +1,6 @@
 // CelerisLab – step/init_flow.cu
 // Channel-flow initialization kernels (double-buffer and EsoPull).
-// Included by uniform.cu after all headers.  No standalone compilation.
+// Included by kernel_v2.cu after all headers.  No standalone compilation.
 // ============================================================================

 #ifndef CELERIS_STEP_INIT_FLOW_CU
@@ -73,9 +73,9 @@ __device__ __forceinline__ uint16_t finalize_domain_flag(
 }

 // ============================================================================
-// InitTubeFlow — double-buffer channel initialization
+// InitTubeFlow_v2 — double-buffer channel initialization
 // ============================================================================
-__global__ void InitTubeFlow(uint16_t* flag, fpxx* fi)
+__global__ void InitTubeFlow_v2(uint16_t* flag, fpxx* fi)
 {
 #if DIM == 2
    unsigned int x, y; unsigned long k;
@@ -1,6 +1,6 @@
 // CelerisLab – step/one_step_double.cu
 // Double-buffer PULL streaming step kernel.
-// Included by uniform.cu.  No standalone compilation.
+// Included by kernel_v2.cu.  No standalone compilation.
 // ============================================================================

 #ifndef CELERIS_STEP_ONE_STEP_DOUBLE_CU
@@ -1,6 +1,6 @@
 // CelerisLab – step/one_step_esopull.cu
 // Esoteric-Pull single-buffer step kernel.
-// Included by uniform.cu.  No standalone compilation.
+// Included by kernel_v2.cu.  No standalone compilation.
 //
 // CURVED BC: supported via PrepareEsoPullCurvedKernel + ApplyEsoPullCurvedKernel
 // in aux_kernels.cu, launched by stepper.py before EsoPullStep.
@@ -21,14 +21,6 @@
 //   i.e. the population traveling in direction i at node n
 //   arrived from the node at n - c_i  = neighbor in direction opp(i)
 // ---------------------------------------------------------------------------
-// load_node: all NQ populations of node n as stored (no streaming).
-__device__ __forceinline__ void load_node(const fpxx* __restrict__ fi, unsigned long n,
-                                          float* __restrict__ f)
-{
-    for (int q = 0; q < NQ; ++q)
-        f[q] = load_ddf(fi, index_f(n, q));
-}
-
 __device__ __forceinline__ void stream_pull_load(unsigned long n,
                                                 float* __restrict__ f,
                                                 const fpxx* __restrict__ fi,
@@ -14,16 +14,15 @@ from threading import RLock
 import numpy as np
 import pycuda.driver as cuda

-from ..cuda import compiler
-from .blocks import (BlockLayout2D, launch_curved_boundary, launch_halo_copy, level_config,
-                     static_circle_tables)
+from ..cuda import compiler_v2 as compiler
+from .blocks import BlockLayout2D
 from .channel import channel_masks, validate_channel_config, validate_channel_transfers
 from ..body.jets import jet_link_velocity
-from .hierarchy import build_hierarchy
+from .block_stepper import MAX_GRID_DIM
+from .hierarchy import build_hierarchy, is_rectangle
 from .refinement import ACTIVE, HALO, FixedPatch2D, FixedPatchSet2D, prepare_fine_boundary
 from .refinement_tables import (blocked_base_tables, blocked_fine_tables,  # noqa: F401 (re-export)
-                                blocked_kind, projected_explosion_tables, _prepare_blocked_boundary,
-                                _BlockedBoundary,
+                                blocked_kind, _prepare_blocked_boundary,
                                BLOCKED_BOUNDARY_DEVICE_COLUMNS)
 from .descriptors import SOLID
 from .raw_exchange import summarize_exchange
@@ -42,8 +41,6 @@ class _Pair:
    n_ghosts: int
    n_rows: int
    parent_cells: int    # parent block window cells (explode donor stride)
-    neighbors: object = None  # projected-only owner-core cells; constant allocates neither
-    offsets: object = None


@dataclass
@@ -66,148 +63,194 @@ def _level_name(level):
    return ("base", "fine", "child")[level] if level < 3 else f"level {level}"


-MAX_GRID_DIM = 65535  # CUDA gridDim.y/z limit (rows, blocks)
+def _legacy_levels(bounds, *, fine_block, base_block, child, child_block, child_rectangles_in_parent,
+                   fine_objects, jets, child_objects, child_jets):
+    """Normalise the original two/three-level keywords to per-level lists (original errors)."""
+    if child is not None and child_rectangles_in_parent is not None:
+        raise ValueError("child and child_rectangles_in_parent are mutually exclusive")
+    nested = child is not None or child_rectangles_in_parent is not None
+    bounds = tuple(bounds)
+    if not is_rectangle(bounds) and (fine_block is None or base_block is None):
+        raise ValueError("several patches require fine_block and base_block")
+    fine_objects, jets = tuple(fine_objects), tuple(jets)
+    child_objects, child_jets = tuple(child_objects), tuple(child_jets)
+    if not nested and (child_objects or child_jets):
+        raise ValueError("child_objects/child_jets require a nested child")
+    if base_block is not None and fine_block is None:
+        raise ValueError("base_block requires fine_block")
+    refinements, blocks = [bounds], [base_block, fine_block]
+    objects, level_jets = [(), fine_objects], [(), jets]
+    if nested:
+        if child is not None and not is_rectangle(bounds):
+            raise ValueError("scalar child requires one parent patch; use child_rectangles_in_parent")
+        if fine_block is None or base_block is None or child_block is None:
+            raise ValueError("a nested child needs fine_block, base_block and child_block")
+        if fine_objects or jets:
+            raise ValueError("a nested child supports bodies/Jets only on L2; use child_objects/child_jets")
+        refinements.append(tuple(child) if child is not None else tuple(child_rectangles_in_parent))
+        blocks.append(child_block)
+        objects.append(child_objects)
+        level_jets.append(child_jets)
+    return refinements, blocks, objects, level_jets
+
+
+def _initial_levels(level_g, coarse_g, fine_g, child_g):
+    """One tuple of per-level arrays from initialize()'s positional or legacy named form."""
+    if coarse_g is None and fine_g is None:
+        if child_g is not None and len(level_g) != 2:
+            raise TypeError("child_g needs exactly the coarse and fine arrays before it")
+        return tuple(level_g) + (() if child_g is None else (child_g,))
+    if level_g:
+        raise TypeError("pass level arrays positionally or as coarse_g/fine_g/child_g, not both")
+    if coarse_g is None or fine_g is None:
+        raise TypeError("coarse_g and fine_g are both required in the named form")
+    return (coarse_g, fine_g) + (() if child_g is None else (child_g,))
+

 def _check_levels(refinements, blocks, objects, jets):
-    """Candidate limits of the level lists, checked before any device work."""
+    """Candidate limits shared by the list and the legacy entry points."""
    depth = len(refinements) + 1
+    if depth < 2:
+        raise ValueError("at least one refinement level is required")
    for name, values in (("level_blocks", blocks), ("level_objects", objects), ("level_jets", jets)):
        if len(values) != depth:
            raise ValueError(f"{name} needs one entry per level ({depth})")
    for level, block in enumerate(blocks):
-        if (not isinstance(block, tuple) or len(block) != 2
-                or any(isinstance(v, (bool, np.bool_)) or not isinstance(v, Integral) or v <= 0
-                       for v in block)):
-            raise ValueError(f"level_blocks[{level}] must be a tile (by, bx) of positive integers; "
-                             "a whole-level tile ((ny, nx) at the root, the fine window shape "
-                             "for one rectangle) always divides its level")
-    if depth == 1:  # one blocked level: the root carries the static circles
-        if jets[0]:
-            raise ValueError("a single level has no Jets")
-        return
+        if block is not None and len(block) != 2:
+            raise ValueError(f"{_level_name(level)}_block must be (by, bx)")
    if objects[0] or jets[0]:
        raise ValueError("base-level bodies/Jets are not supported")
+    if any(blocks[level - 1] is not None and blocks[level] is None for level in range(1, depth)):
+        raise ValueError("a blocked level requires blocked refined levels below it")
+    if not is_rectangle(refinements[0]) and (blocks[0] is None or blocks[1] is None):
+        raise ValueError("several patches require fine_block and base_block")
    if depth > 2:
+        if any(block is None for block in blocks):
+            raise ValueError("three or more levels must all be blocked")
        if any(objects[level] or jets[level] for level in range(1, depth - 1)):
            raise ValueError("bodies/Jets are supported only on the finest level of a nested hierarchy")


 class FixedPatchStepper:
-    """D2Q9 SRT/MRT FP32 fixed 2:1 refinement hierarchy, built from level lists.
-
-    ``refinements[l]`` gives level l+1 in level-l integer cells: one rectangle
-    (x0, y0, x1, y1) (FixedPatch2D, a fine window with its own origin) or a
-    sequence of rectangles (FixedPatchSet2D, a dependency-validated union on one
-    level-wide grid, public fine arrays (2*ny, 2*nx), NaN outside ACTIVE cells);
-    see lbm.hierarchy. ``level_blocks`` (required), ``level_objects`` and
-    ``level_jets`` hold one entry per level, L0 included (L0 bodies/Jets are not
-    supported).
-    ``refinements=[]`` is one blocked level: periodic SRT root without LES,
-    Jets or exchange observation; its ``level_objects[0]`` are stationary
-    passive circles (static BFL).
+    """D2Q9/SRT/FP32, one unforced internal 2:1 patch in an x-periodic box.

    ``coarse_boundary`` is ``periodic`` (default) or ``slot_reservoir``:
    a bottom on-site slot and top fixed-density reservoir from ``cfg``.
-    ``channel`` matches uniform SRT Zou-He
+    ``channel`` requires all-blocked levels and matches uniform SRT Zou-He
    inlet, pressure-NEQ outlet and stationary bounce-back y walls. Boundary
    ghosts evolve internally but public downloads exclude them; initialization
    must supply their finite positive-density state. Transfers must avoid the
    actual channel closure footprint. Channel remapping is not supported.
    Periodic mode does not apply the wall/slot boundary fields in ``cfg``.
    Outer walls remain coarse; fine halo donors must be ordinary fluid.
+    ``fine_objects`` accepts fixed circles in coarse physical coordinates;
+    velocities are in coarse lattice units (dx=dt=1). Independent local copies
+    are projected at fine cell centers. Their complete stencil must be active
+    and disjoint from the actual two-hop transfer footprint.
+    These use the edge/cell-center frame (coarse centers I+.5), whereas ordinary Simulation objects use the integer-node frame.

-    Bodies are fixed circles in root (L0) physical coordinates; velocities are
-    in root lattice units (dx=dt=1). Independent local copies are projected at
-    fine cell centers; their complete stencil must be active and disjoint from
-    the actual two-hop transfer footprint. These use the edge/cell-center frame
-    (coarse centers I+.5), whereas ordinary Simulation objects use the
-    integer-node frame. Jets (body.jets.Jet) use the same frame and drive cut
-    links selected at their true hits; ``set_jet_amplitude(index, amplitude,
-    level=l)`` re-uploads the per-link velocity column only.
-
-    ``initialize(*level_g)`` accepts one physical Q-major (9, ny, nx) array per
-    level, already in postcollision phase. It does not collide or build channel
-    flags. Every ``step()`` publishes only after all levels complete on one
-    stream. On a device/launch failure the instance becomes unusable: close and
-    recreate it, rather than pretending a partially advanced buffer rolled back.
-
-    Every level is stored in blocked.cu storage with its ``level_blocks`` tile
-    (by, bx): the ENTIRE level shape, including the four-cell patch ghost band,
-    is partitioned by a BlockLayout2D with one-cell same-level halos; the tile
-    must divide the level (a whole-level tile always does). Patch kinds stay
-    per cell (OUTER invalid, INNER stream only, ACTIVE collide); halos are
-    gathered before each hop. Public arrays are dense (9, ny, nx); only the
-    allocation is blocked. Bodies are stationary circles, optionally
-    surface-actuated: prepare_fine_boundary decides legality on the dense grid,
-    then cut links are staged receiver-local per hop: halo -> BFL -> step, same
-    buffer. A blocked parent gathers halos before receiver-local coalescence
-    staging and pull/collision; covered cells are poisoned on every step.
+    ``initialize(coarse_g, fine_g)`` accepts physical Q-major (9,ny,nx) arrays
+    already in postcollision phase. It does not collide or build channel flags.
+    Every ``step()`` publishes only after both levels complete on one stream.
+    On a device/launch failure the instance becomes unusable: close and recreate
+    it, rather than pretending the partially advanced fine buffer rolled back.

+    ``fine_block=(by, bx)`` (opt-in) stores the fine level in
+    blocks.cu storage: the ENTIRE fine_shape, including the four-cell patch
+    ghost band, is partitioned by a non-periodic BlockLayout2D with one-cell
+    same-level halos. Patch kinds stay per cell (OUTER invalid, INNER stream
+    only, ACTIVE collide); halos are gathered before each fine hop. Public
+    arrays keep the dense (9, ny, nx) fine shape; only the allocation differs.
+    Blocked fine_objects are stationary circles, optionally surface-actuated:
+    prepare_fine_boundary decides legality on the dense fine grid, then cut
+    links are staged receiver-local per hop: halo -> BFL -> step, same buffer.
+    ``base_block=(by, bx)`` also blocks the parent; it requires ``fine_block``.
+    Parent halos precede receiver-local coalescence staging and pull/collision;
+    covered cells are explicitly poisoned on every step. Public shapes stay dense.
    ``observe_raw_exchange=True`` records blocked physical cut-link exchange
    without changing populations. read_raw_exchange reports the last complete
    base interval or last substep in base-lattice units per unit depth. This
-    is boundary momentum reaction, not a validated nozzle/stress load.
+    is boundary momentum reaction, not a validated nozzle/stress load. Dense
+    body layouts are not supported by this new diagnostic in this candidate.
    ``observe_window_exchange=True`` (requires observe_raw_exchange) adds a second
    per-link FP64 ledger accumulated by the same kernel between
    start_exchange_window() and read_exchange_window(); disabled by default.
+    ``jets`` (body.jets.Jet) use the same edge frame as ``fine_objects`` and
+    drive fine cut links selected at their true hits; ``set_jet_amplitude``
+    re-uploads the per-link velocity column only.

-    Nested levels: a child set's coordinates index the allocated parent array,
-    including ghost bands and holes: root edge = parent fine_origin + index / 2
-    (zero origin for a parent set; a scalar parent keeps its shifted window
-    origin). A scalar child requires a scalar parent. Rectangle unions impose no
-    fixed gap rule: adjacent, overlapping and concave unions are accepted when
-    their actual transfer dependencies close (FixedPatchSet2D /
-    nest_patch_set). All regions share one buffer pair per level and the fixed
-    schedule of 2**l hops per base step at level l. Bodies/Jets are supported only on the
-    finest level of a nested hierarchy (L2 dx=dt=.25 in root units, unchanged
-    lattice velocity); every whole circle and its BFL stencil must fit strictly
-    away from that level's transfer footprint.
+    Several patches: pass ``bounds`` as a sequence of (x0, y0, x1, y1)
+    rectangles (FixedPatchSet2D, dependency-validated union). This requires
+    fine_block and base_block; fine_objects/jets are projected once onto the
+    level-wide fine grid (each circle inside the union, body ids = object
+    positions, jet and writer checks level-wide), and
+    uses one level-wide fine grid (2*ny, 2*nx): public fine arrays have that
+    shape, NaN outside the patches' ACTIVE cells. The step sequence is the
+    blocked one above, with unique union transfers in one launch each.

-    ``explosion="projected_linear"`` selects experimental transverse linear
-    reconstruction on each adjacent pair. Default "constant" is unchanged.
-    Projected mode requires periodic root, all-blocked SRT levels without
-    bodies/Jets or LES; this backend supplies no forcing. Geometry is generic,
-    but union/multilevel GPU and matched-physics qualification remain pending.
+    Three-level separated unions: ``child_rectangles_in_parent=[...]`` is
+    mutually exclusive with scalar ``child`` and accepts either parent form.
+    Coordinates index the allocated L1 array, including ghost bands and holes:
+    root edge = patch.fine_origin + L1 index / 2. A parent set has origin zero;
+    a scalar parent retains its shifted window origin. The child set's public
+    extent is twice the allocated L1 shape, even though storage is sparse.
+    Each pair requires gap >= 4 in its own parent-cell units. All regions share
+    one buffer pair per level and the fixed 1:2:4 schedule; L2-only bodies/Jets
+    below apply unchanged, with object IDs assigned over the whole level.

-    One recursive hop advances every level: a child explodes from its parent's
-    current hop source, takes two hops, then the parent gathers halos, stages
-    restriction, applies BFL and steps.
+    Three-level single chain: ``child`` bounds use L1 window cells; all three
+    levels must be blocked. ``child_objects`` and ``child_jets`` use the L0
+    edge frame, with L2 dx=dt=.25 and unchanged lattice velocity. L1 bodies
+    and Jets remain unsupported in a chain. Every whole circle and its BFL
+    stencil must fit strictly away from the L2 transfer footprint. L2 runs
+    halo -> BFL -> step four times per base step. Runtime child Jet changes
+    require ``set_jet_amplitude(index, amplitude, level=2)``.
+
+    Level lists (any depth): ``refinements[l]`` gives level l+1 in level-l
+    integer cells (scalar window or rectangle list, see lbm.hierarchy);
+    ``level_blocks``/``level_objects``/``level_jets`` hold one entry per level,
+    L0 included. They are mutually exclusive with the legacy keywords above,
+    which are normalised to the same lists. One recursive hop advances every
+    level: a child explodes from its parent's current hop source, takes two
+    hops, then the parent gathers halos, stages restriction, applies BFL and
+    steps. Depth >= 3 must be fully blocked with bodies/Jets on the finest level.
    """
-    def __init__(self, cfg, *, context, refinements, coarse_boundary="periodic",
-                 level_blocks=None, level_objects=None, level_jets=None,
-                 observe_raw_exchange=False, observe_window_exchange=False, explosion="constant"):
+    def __init__(self, cfg, bounds=None, *, context, coarse_boundary="periodic", fine_objects=(),
+                 fine_block=None, base_block=None, jets=(), child=None, child_block=None,
+                 child_objects=(), child_jets=(), child_rectangles_in_parent=None,
+                 refinements=None, level_blocks=None, level_objects=None, level_jets=None,
+                 observe_raw_exchange=False, observe_window_exchange=False):
        if HALO != 4:
-            raise RuntimeError("the refinement transfers require a four-cell fine halo")
+            raise RuntimeError("refinement.cu requires a four-cell fine halo")
        if coarse_boundary not in ("periodic", "slot_reservoir", "channel"):
            raise ValueError("coarse_boundary must be periodic, slot_reservoir or channel")
-        depth = len(refinements) + 1
-        if level_blocks is None:
-            raise ValueError("level_blocks is required: one tile (by, bx) per level; a whole-level "
-                             "tile ((ny, nx) at the root, the fine window shape for one rectangle) "
-                             "always divides its level")
-        level_blocks = list(level_blocks)
-        level_objects = [()] * depth if level_objects is None else list(level_objects)
-        level_jets = [()] * depth if level_jets is None else list(level_jets)
+        if refinements is None:
+            if bounds is None:
+                raise ValueError("bounds or refinements is required")
+            if level_blocks is not None or level_objects is not None or level_jets is not None:
+                raise ValueError("level_blocks/level_objects/level_jets require refinements")
+            refinements, level_blocks, level_objects, level_jets = _legacy_levels(
+                bounds, fine_block=fine_block, base_block=base_block, child=child,
+                child_block=child_block, child_rectangles_in_parent=child_rectangles_in_parent,
+                fine_objects=fine_objects, jets=jets, child_objects=child_objects,
+                child_jets=child_jets)
+        else:
+            if (bounds is not None or child is not None or child_rectangles_in_parent is not None
+                    or fine_block is not None or base_block is not None or child_block is not None
+                    or tuple(fine_objects) or tuple(jets) or tuple(child_objects) or tuple(child_jets)):
+                raise ValueError("refinements and the legacy patch keywords are mutually exclusive")
+            depth = len(refinements) + 1
+            level_blocks = [None] * depth if level_blocks is None else list(level_blocks)
+            level_objects = [()] * depth if level_objects is None else list(level_objects)
+            level_jets = [()] * depth if level_jets is None else list(level_jets)
        level_objects = [tuple(o) for o in level_objects]
        level_jets = [tuple(j) for j in level_jets]
-        level_blocks = [tuple(b) if isinstance(b, (list, tuple)) else b for b in level_blocks]
+        level_blocks = [None if b is None else tuple(b) for b in level_blocks]
        _check_levels(refinements, level_blocks, level_objects, level_jets)
        depth = len(refinements) + 1
-        if explosion not in ("constant", "projected_linear"):
-            raise ValueError("explosion must be constant or projected_linear")
-        if explosion == "projected_linear" and (
-                coarse_boundary != "periodic"
-                or any(level_objects) or any(level_jets)
-                or cfg.collision != "SRT" or cfg.les_enabled):
-            raise ValueError("projected explosion requires periodic SRT levels "
-                             "without bodies/Jets or LES")
-        self._explosion = explosion
        self._ddf_shifting = bool(cfg.ddf_shifting)
-        if depth == 1 and (coarse_boundary != "periodic" or cfg.collision != "SRT" or cfg.les_enabled
-                           or explosion != "constant"
-                           or observe_raw_exchange or observe_window_exchange):
-            raise ValueError("a single level requires a periodic SRT root without LES, projection "
-                             "or exchange observation")
+        if self._ddf_shifting and any(b is None for b in level_blocks):
+            raise ValueError("shifted populations require all-blocked levels; dense/mixed is unsupported")
        self._channel = coarse_boundary == "channel"
        if self._channel:
            validate_channel_config(cfg, level_blocks)
@@ -224,29 +267,29 @@ class FixedPatchStepper:
                raise ValueError("slot_reservoir requires y0 >= 4 and y1 <= ny-4")
        self._layouts = []
        for level, block in enumerate(level_blocks):
-            if level == 0:
-                layout = BlockLayout2D.build(cfg.ny, cfg.nx, *block,
-                                             periodic=(True, not self._wall_aware))
-            elif isinstance(pairs[level - 1], FixedPatchSet2D):
-                layout = pairs[level - 1].fine_layout(block)
-            else:
-                layout = BlockLayout2D.build(*pairs[level - 1].fine_shape, *block,
-                                             periodic=(False, False))
-            if layout.nblocks > MAX_GRID_DIM or layout.local_shape[0] > MAX_GRID_DIM:
-                raise ValueError(f"{_level_name(level)} blocks exceed launch limits")
+            layout = None
+            if block is not None:
+                if level == 0:
+                    layout = BlockLayout2D.build(cfg.ny, cfg.nx, *block,
+                                                 periodic=(True, not self._wall_aware))
+                elif isinstance(pairs[level - 1], FixedPatchSet2D):
+                    layout = pairs[level - 1].fine_layout(block)
+                else:
+                    layout = BlockLayout2D.build(*pairs[level - 1].fine_shape, *block,
+                                                 periodic=(False, False))
+                if layout.nblocks > MAX_GRID_DIM or layout.local_shape[0] > MAX_GRID_DIM:
+                    raise ValueError(f"{_level_name(level)} blocks exceed launch limits")
            self._layouts.append(layout)
        if self._channel:
            base = blocked_base_tables(pairs[0], self._layouts[0], np.argsort(pairs[0].coalesce_coarse))
            validate_channel_transfers(pairs[0], self._layouts[0], base[1])
        # Kernel configurations per level (geometry configs live in self.hierarchy).
-        self._level_cfgs = [replace(cfg)]
-        if pairs:
-            fine_cfg = replace(cfg, nx=pairs[0].fine_shape[1], ny=pairs[0].fine_shape[0],
-                               viscosity=2 * cfg.viscosity)
-            if self._wall_aware:
-                fine_cfg = replace(fine_cfg, y_wall_bc="bounce_back", top_wall_bc="velocity",
-                                   wall_slot_width=0, wall_normal_velocity=0.0, velocity=0.0)
-            self._level_cfgs.append(fine_cfg)
+        fine_cfg = replace(cfg, nx=pairs[0].fine_shape[1], ny=pairs[0].fine_shape[0],
+                           viscosity=2 * cfg.viscosity)
+        if self._wall_aware:
+            fine_cfg = replace(fine_cfg, y_wall_bc="bounce_back", top_wall_bc="velocity",
+                               wall_slot_width=0, wall_normal_velocity=0.0, velocity=0.0)
+        self._level_cfgs = [replace(cfg), fine_cfg]
        for pair in pairs[1:]:
            parent = self._level_cfgs[-1]
            self._level_cfgs.append(replace(parent, nx=pair.fine_shape[1], ny=pair.fine_shape[0],
@@ -271,6 +314,9 @@ class FixedPatchStepper:
            spacings.append(spacing)
        if not isinstance(observe_raw_exchange, bool):
            raise ValueError("observe_raw_exchange must be bool")
+        if observe_raw_exchange and any(b is not None and layout is None
+                                      for b, layout in zip(self._boundary_hosts, self._layouts)):
+            raise ValueError("raw exchange currently requires blocked body levels")
        self._observe_raw_exchange = observe_raw_exchange
        if not isinstance(observe_window_exchange, bool):
            raise ValueError("observe_window_exchange must be bool")
@@ -284,18 +330,12 @@ class FixedPatchStepper:
        self._exchange_centers = tuple(tuple(tuple(o.geometry.center) for o in objects)
                                       for objects in level_objects)
        self._level_jets = level_jets
-        root = None
-        if depth == 1 and level_objects[0]:
-            tables = static_circle_tables(self._layouts[0], level_objects[0])
-            root = _BlockedBoundary(None, tables, (), False)
-        self._level_boundaries = [root] + [
+        self._level_boundaries = [None] + [
            _prepare_blocked_boundary(self._boundary_hosts[level], self._layouts[level],
                                      self._level_cfgs[level], level_jets[level],
                                      _shifted_blocked=self._ddf_shifting)
            for level in range(1, depth)]
        self._leaf = [kind == ACTIVE for kind in self.hierarchy.kinds]
-        if root is not None:
-            self._leaf[0] &= ~root.tables["solid"]
        for level in range(1, depth):
            host = self._boundary_hosts[level]
            if host is not None:
@@ -313,12 +353,11 @@ class FixedPatchStepper:
        self._allocations = []
        self._levels, self._pairs = [], []
        self._stream = None
+        self._fine_flags = self._fine_curved = self._curved = None
+        self._link_tables = {}
        self._block = (cfg.threads_per_block, 1, 1)
        with self.ctx.activate():
            try:
-                free, _ = cuda.mem_get_info()
-                if self._planned_bytes() > free:  # before any stream, module or buffer
-                    raise MemoryError("level buffers exceed free device memory")
                self._stream = cuda.Stream()
                for level in range(depth):
                    self._levels.append(self._build_level(level))
@@ -340,6 +379,21 @@ class FixedPatchStepper:
                                b.window_integral = self._allocate(count * 4 * 8)
                            b.accumulate = level.module.get_function("BlockAccumulateExchange")
                        b.kernel = level.module.get_function("BlockCurvedBoundary")
+                if self._level_boundaries[1] is not None:
+                    b = self._level_boundaries[1]
+                    self._fine_flags, self._link_tables, self._curved = b.flags, b.device, b.kernel
+                elif self._boundary_hosts[1] is not None:
+                    from .curved_links import CurvedLinkSoA
+                    boundary = self._boundary_hosts[1]
+                    self._fine_flags = self._upload(boundary.flags)
+                    # SoA owns its allocations; never also register them in _allocations.
+                    self._fine_curved = CurvedLinkSoA()
+                    self._fine_curved.assign_host(*boundary.curved_host)
+                    self._fine_curved.assign_surface(boundary.objects, fine_cfg, boundary.flags,
+                                                     jets=self._level_jets[1],
+                                                     hits=boundary.curved_hits)
+                    self._fine_curved.upload()
+                    self._curved = self._levels[1].module.get_function("CurvedBoundaryKernel")
            except BaseException:
                try:
                    self.close()
@@ -347,84 +401,88 @@ class FixedPatchStepper:
                    pass  # Preserve the original construction failure.
                raise

-    def _planned_bytes(self):
-        """Both G buffers, halo pairs and boundary columns of every level (transfer tables excluded).
-
-        A fail-fast lower bound only: passing it cannot guarantee that later
-        allocations succeed (other consumers, fragmentation, races).
-        """
-        total = 0
-        for index, layout in enumerate(self._layouts):
-            total += 2 * 4 * int(np.prod(layout.blocked_shape))
-            total += layout.halo_dst.nbytes + layout.halo_src.nbytes
-            b = self._level_boundaries[index]
-            if b is not None:
-                total += sum(np.asarray(v).nbytes for k, v in b.tables.items()
-                             if k == "flags" or k in BLOCKED_BOUNDARY_DEVICE_COLUMNS)
-        return total
-
    def _build_level(self, index):
        """Compile one level's step module and allocate its two G buffers."""
        layout, config = self._layouts[index], self._level_cfgs[index]
        pairs = self.hierarchy.pairs
-        tau = (pairs[0].tau_coarse if pairs else 3 * config.viscosity + .5) if index == 0 \
-            else pairs[index - 1].tau_fine
-        config = level_config(config, layout, tau)
-        name = "BlockChannelStep" if index == 0 and self._channel else "BlockStep"
-        block_root_bc = (2 if self._channel else 1 if self._wall_aware else 0) if index == 0 else 0
-        module = compiler.build_module(config, "blocked.cu", arch=self.ctx.sm_arch,
-                                       block_root_bc=block_root_bc)
-        compiler.set_params(module, config.omega)
+        tau = pairs[0].tau_coarse if index == 0 else pairs[index - 1].tau_fine
+        name, source = ("PatchCoarseStep" if index == 0 else "PatchFineStep"), "refinement.cu"
+        if layout is not None:
+            config = replace(config, nx=layout.local_shape[1], ny=layout.local_shape[0],
+                             y_wall_bc="bounce_back", top_wall_bc="velocity",
+                             wall_slot_width=0, wall_normal_velocity=0.0, velocity=0.0)
+            name, source = ("BlockChannelStep" if index == 0 and self._channel else "BlockStep"), "blocks.cu"
+        config.validate()
+        if not np.isclose(config.omega, 1 / tau, rtol=1e-14, atol=0):
+            raise RuntimeError("level omega/tau mismatch")
+        host = self._boundary_hosts[index]
+        n_objects = len(host.objects) if name == "PatchFineStep" and host is not None else 0
+        build = compiler.generate_config(config, n_objects=n_objects)
+        try:
+            ptx = compiler.compile_kernel(self.ctx.sm_arch, source=source, build_dir=build)
+            module = compiler.load_module(ptx)
+        finally:
+            compiler.cleanup_build_dir(build)
+        ptr, size = module.get_global("d_params")
+        if size != struct.calcsize("=ffffI"):
+            raise RuntimeError("LBMParams host/device layout mismatch")
+        cuda.memcpy_htod(ptr, struct.pack("=ffffI", config.omega, 0, 0, 0, n_objects))
        shape = (9, *self.hierarchy.kinds[index].shape)
-        size = int(np.prod(layout.blocked_shape)) * 4
-        grid = ((config.nx + self._block[0] - 1) // self._block[0], config.ny, layout.nblocks)
+        size = int(np.prod(shape if layout is None else layout.blocked_shape)) * 4
+        grid = ((config.nx + self._block[0] - 1) // self._block[0], config.ny,
+                1 if layout is None else layout.nblocks)
        level = _Level(shape, module, self._allocate(size), self._allocate(size),
                       module.get_function(name), grid, layout)
        level.boundary = self._level_boundaries[index]
-        level.halo_copy = module.get_function("BlockHaloCopy")
-        if len(layout.halo_dst):
-            level.halo_dst = self._upload(layout.halo_dst)
-            level.halo_src = self._upload(layout.halo_src)
-        if index == 0 and self._channel:
-            cfg = self._remap_cfg
-            ptr, size = module.get_global("d_block_channel")
-            if size != struct.calcsize("=IIf"):
-                raise RuntimeError("Block channel host/device layout mismatch")
-            cuda.memcpy_htod(ptr, struct.pack("=IIf", cfg.nx, cfg.ny, cfg.velocity))
-        if index == 0 and self._wall_aware:
-            cfg = self._remap_cfg
-            ptr, size = module.get_global("d_block_wall")
-            if size != struct.calcsize("=IIIf"):
-                raise RuntimeError("Block wall host/device layout mismatch")
-            cuda.memcpy_htod(ptr, struct.pack("=IIIf", cfg.nx, cfg.ny,
-                                            cfg.wall_slot_width, cfg.wall_normal_velocity))
+        if layout is not None:
+            level.halo_copy = module.get_function("BlockHaloCopy")
+            if len(layout.halo_dst):
+                level.halo_dst = self._upload(layout.halo_dst)
+                level.halo_src = self._upload(layout.halo_src)
+            if index == 0 and self._channel:
+                cfg = self._remap_cfg
+                ptr, size = module.get_global("d_block_channel")
+                if size != struct.calcsize("=IIf"):
+                    raise RuntimeError("Block channel host/device layout mismatch")
+                cuda.memcpy_htod(ptr, struct.pack("=IIf", cfg.nx, cfg.ny, cfg.velocity))
+            if index == 0 and self._wall_aware:
+                cfg = self._remap_cfg
+                ptr, size = module.get_global("d_block_wall")
+                if size != struct.calcsize("=IIIf"):
+                    raise RuntimeError("Block wall host/device layout mismatch")
+                cuda.memcpy_htod(ptr, struct.pack("=IIIf", cfg.nx, cfg.ny,
+                                                cfg.wall_slot_width, cfg.wall_normal_velocity))
        return level

    def _build_pair(self, index, pair):
        """Upload the transfer tables of levels (index, index+1) and the child's block kinds."""
        parent, child = self._levels[index], self._levels[index + 1]
        order = np.argsort(pair.coalesce_coarse)
-        ghosts, children, child_kind = blocked_fine_tables(pair, child.layout, order)
-        if index == 0:
-            donors, targets, parent_kind = blocked_base_tables(pair, parent.layout, order,
-                                                               self._wall_aware)
-        else:
-            # Nested pairs keep inherited INNER/OUTER and sparse holes of the parent.
-            donors, targets, parent_kind = blocked_base_tables(
-                pair, parent.layout, order, composed_kind=self.hierarchy.kinds[index])
-        result = _Pair(child.module.get_function("BlockExplode"),
-                       parent.module.get_function("BlockCoalesce"),
-                       self._upload(ghosts), self._upload(donors.astype(np.uint64)),
-                       self._upload(targets), self._upload(children), len(ghosts), len(targets),
-                       int(np.prod(parent.layout.local_shape)))
-        if self._explosion == "projected_linear":
-            neighbors, offsets = projected_explosion_tables(
-                pair, parent.layout, self.hierarchy.kinds[index])
-            result.explode = child.module.get_function("BlockExplodeProjected")
-            result.neighbors, result.offsets = self._upload(neighbors), self._upload(offsets)
-        child.kind = self._upload(blocked_kind(child.layout, self.hierarchy.kinds[index + 1]))
-        if index == 0:
-            parent.kind = self._upload(parent_kind)
+        fine = None if child.layout is None else blocked_fine_tables(pair, child.layout, order)
+        base = None
+        if parent.layout is not None:
+            if index == 0:
+                base = blocked_base_tables(pair, parent.layout, order, self._wall_aware)
+            else:
+                # Nested pairs keep inherited INNER/OUTER and sparse holes of the parent.
+                base = blocked_base_tables(pair, parent.layout, order,
+                                           composed_kind=self.hierarchy.kinds[index])
+        ghosts = pair.ghost_fine if fine is None else fine[0]
+        donors = pair.ghost_coarse if base is None else base[0]
+        if fine is not None:
+            donors = donors.astype(np.uint64)
+        targets = pair.coalesce_coarse[order] if base is None else base[1]
+        children = pair.coalesce_fine[order] if fine is None else fine[1]
+        result = _Pair(child.module.get_function("PatchExplode" if fine is None else "BlockExplode"),
+                       None if parent.layout is None else parent.module.get_function("BlockCoalesce"),
+                       self._upload(ghosts), self._upload(donors), self._upload(targets),
+                       self._upload(children), len(ghosts), len(targets),
+                       int(np.prod(pair.coarse_shape if parent.layout is None
+                                   else parent.layout.local_shape)))
+        if child.layout is not None:
+            child.kind = self._upload(blocked_kind(child.layout, self.hierarchy.kinds[index + 1]))
+        if index == 0 and base is not None:
+            parent.kind = self._upload(base[2])
        return result

    def _allocate(self, size):
@@ -457,14 +515,16 @@ class FixedPatchStepper:
    def _check_storage(self):
        if any(bool(c.ddf_shifting) != self._ddf_shifting for c in self._level_cfgs):
            raise ValueError("mixed population representations are unsupported")
+        if self._ddf_shifting and any(layout is None for layout in self._layouts):
+            raise ValueError("shifted populations require all-blocked levels")

-    def initialize(self, *level_g):
+    def initialize(self, *level_g, coarse_g=None, fine_g=None, child_g=None):
        """Upload physical postcollision G, encoding before any FP32 rounding.

        Shifted input should be physical FP64 to retain small perturbations.
        Public initialization resets the step count; non-leaves are discarded.
        """
-        given = tuple(level_g)
+        given = _initial_levels(level_g, coarse_g, fine_g, child_g)
        with self._lock, self.ctx.activate():
            self._require("new", "ready")
            self._check_storage()
@@ -501,13 +561,14 @@ class FixedPatchStepper:
                        or (values.sum(axis=0, dtype=np.float64) + int(self._ddf_shifting) <= 0).any()):
                    raise ValueError("Leaf populations must be finite with positive density")
            self._mask_nonstate(*arrays)
-            arrays = [level.layout.to_blocked(a) for a, level in zip(arrays, self._levels)]
+            arrays = [a if level.layout is None else level.layout.to_blocked(a)
+                      for a, level in zip(arrays, self._levels)]
            try:
                for level, array in zip(self._levels, arrays):
                    cuda.memcpy_htod(level.current, array)
-                    # A single level starts its spare NaN so stale halos cannot hide.
-                    cuda.memcpy_htod(level.spare, np.full_like(array, np.nan)
-                                     if len(self._levels) == 1 else array)
+                    cuda.memcpy_htod(level.spare, array)
+                if self._fine_curved is not None and self._fine_curved.link_exchange_gpu is not None:
+                    cuda.memset_d8(self._fine_curved.link_exchange_gpu, 0, self._fine_curved.count * 12)
                self._step_count = 0
                self._exchange_valid = False
                self._window_valid = False
@@ -587,11 +648,12 @@ class FixedPatchStepper:
                old, new, source, base_count=count, level_steps=(count, 2*count, 4*count),
                phase="postcollision_g", **options)
            candidate = type(self)(
-                cfg, context=self.ctx, refinements=[pairs[0].bounds, new.child.bounds],
-                level_blocks=[base_block, fine_block, child_block],
-                level_objects=[(), (), child_objects], level_jets=[(), (), jets],
+                cfg, pairs[0].bounds, context=self.ctx, base_block=base_block,
+                fine_block=fine_block, child_block=child_block,
+                child_rectangles_in_parent=new.child.bounds,
+                child_objects=child_objects, child_jets=jets,
                observe_raw_exchange=self._observe_raw_exchange,
-                observe_window_exchange=self._observe_window, explosion=self._explosion)
+                observe_window_exchange=self._observe_window)
            try:
                if self._ddf_shifting:
                    candidate._initialize_raw(_StoredPopulations(transferred.g, transferred.shifted))
@@ -606,6 +668,26 @@ class FixedPatchStepper:
                raise
            return candidate

+    def _apply_fine_boundary(self, buffer, **kw):
+        """Stage solid source slots; exchange buffer holds this fine substep only."""
+        cl = self._fine_curved
+        if cl is None:
+            if self._boundary_hosts[1] is not None:
+                raise RuntimeError("Fine boundary device buffers are missing")
+            return
+        if self._curved is None or cl.fluid_idx_gpu is None:
+            raise RuntimeError("Fine boundary device buffers are missing")
+        driven = bool(self._level_jets[1]) or any(
+            obj.surface_actuation is not None for obj in self._boundary_hosts[1].objects)
+        if driven and (cl.surface_velocity_gpu is None or cl.link_exchange_gpu is None):
+            raise RuntimeError("Surface boundary device buffers are missing")
+        self._curved(buffer, cl.fluid_idx_gpu, cl.dir_gpu, cl.q_gpu,
+                     cl.rx_gpu, cl.ry_gpu, cl.rz_gpu, cl.fallback_class_gpu, cl.body_id_gpu,
+                     np.uintp(0), np.uintp(0), np.uint32(cl.count),
+                     cl.surface_velocity_gpu if cl.surface_velocity_gpu is not None else np.uintp(0),
+                     cl.link_exchange_gpu if cl.link_exchange_gpu is not None else np.uintp(0),
+                     grid=((cl.count + self._block[0] - 1) // self._block[0], 1), **kw)
+
    def set_jet_amplitude(self, index, amplitude, *, level=1):
        """Replace one jet's amplitude between steps; no geometry/table rebuild.

@@ -629,7 +711,9 @@ class FixedPatchStepper:
                driven = jet_id >= 0
                velocity[driven] = jet_link_velocity(jets, shape, jet_id)[driven]
            try:
-                if velocity is not None:
+                if level == 1 and self._fine_curved is not None:
+                    self._fine_curved.set_jet_amplitude(index, amplitude, self._stream)
+                elif velocity is not None:
                    self._stream.synchronize()  # no in-flight step reads the column
                    cuda.memcpy_htod(boundary.device["surface_velocity"], velocity)
            except BaseException:
@@ -647,19 +731,21 @@ class FixedPatchStepper:
            return
        if b.kernel is None or b.flags is None:
            raise RuntimeError("Boundary device buffers are missing")
-        t = b.device
+        t, count = b.device, len(b.tables["cell"])
        velocity = t.get("surface_velocity")
        if b.actuated and velocity is None:
            raise RuntimeError("Surface velocity device buffer is missing")
-        launch_curved_boundary(b.kernel, buffer, t, len(b.tables["cell"]), velocity=velocity,
-                               rx=t.get("rx"), ry=t.get("ry"), raw=b.last_raw, **kw)
+        b.kernel(buffer, t["block"], t["cell"], t["dir"], t["q"], t["fallback"],
+                 np.uint32(count), velocity if velocity is not None else np.uintp(0),
+                 t.get("rx", np.uintp(0)), t.get("ry", np.uintp(0)),
+                 b.last_raw if b.last_raw is not None else np.uintp(0),
+                 grid=((count + self._block[0] - 1) // self._block[0], 1), **kw)

    def _advance(self, index, parent_buffer, **kw):
        """Explode from the given parent buffer, then two hops of level ``index``."""
        pair, level = self._pairs[index - 1], self._levels[index]
        pair.explode(parent_buffer, level.current, pair.ghosts, pair.donors, np.uint32(pair.n_ghosts),
                     np.uint64(pair.parent_cells),
-                     *((pair.neighbors, pair.offsets) if pair.neighbors is not None else ()),
                     grid=((pair.n_ghosts + self._block[0] - 1) // self._block[0], 1), **kw)
        self._hop(index, level.current, level.spare, **kw)
        self._hop(index, level.spare, level.current, **kw)
@@ -671,6 +757,19 @@ class FixedPatchStepper:
        nested = index + 1 < len(self._levels)
        if nested:
            self._advance(index + 1, src, **kw)
+        if level.layout is None:
+            if index == 0:  # dense root: PatchCoarseStep fuses restriction and collision
+                pair = self._pairs[0]
+                level.kernel(src, dst, self._levels[1].current, pair.targets, pair.children,
+                             np.uint32(pair.n_rows), *(np.uint32(v) for v in self.hierarchy.pairs[0].bounds),
+                             np.uint32(self._wall_aware), grid=level.grid, **kw)
+                return
+            if self._boundary_hosts[index] is not None and self._fine_flags is None:
+                raise RuntimeError("Fine boundary flags are missing")
+            self._apply_fine_boundary(src, **kw)
+            flags = self._fine_flags if self._fine_flags is not None else np.uintp(0)
+            level.kernel(src, dst, flags, grid=level.grid, **kw)
+            return
        # Child donors were read above; no halo gather may overwrite staged arrivals below.
        self._gather_halo(level, src, **kw)
        if nested:
@@ -691,50 +790,36 @@ class FixedPatchStepper:
                             np.float64(h), np.float64(h),
                             grid=((count + self._block[0] - 1) // self._block[0], 1), **kw)
        flags = np.uintp(0) if level.boundary is None else level.boundary.flags
-        kind = np.uintp(0) if level.kind is None else level.kind  # single level: all ACTIVE
-        level.kernel(src, dst, np.uint32(level.layout.halo), flags, kind, grid=level.grid, **kw)
+        level.kernel(src, dst, np.uint32(level.layout.halo), flags, level.kind, grid=level.grid, **kw)

    def _gather_halo(self, level, buffer, **kw):
        pairs = len(level.layout.halo_dst)
        if pairs:
-            launch_halo_copy(level.halo_copy, buffer, level.halo_dst, level.halo_src, pairs, **kw)
+            level.halo_copy(buffer, level.halo_dst, level.halo_src, np.uint32(pairs),
+                            grid=((pairs + self._block[0] - 1) // self._block[0], 1), **kw)

    def step(self, n=1):
-        """Advance G→G by n base intervals: level l takes 2**l hops per interval.
-
-        All n intervals are enqueued in order on the one stream, and the host waits
-        once, before returning; step(0) launches and waits for nothing. On return
-        the device work is complete, step_count and an open window cover all n
-        intervals, and the raw-exchange ledger holds the final interval only.
-
-        Asynchronous device errors surface at that single wait, so they are not
-        attributed to the interval that caused them; call step(1) repeatedly to
-        localize one (same launches, same bits). On any failure the instance is
-        failed, the exchange ledger and window are invalid, and step_count keeps
-        its value from entry to the failing call.
-        """
+        """Advance G→G by n base intervals: level l takes 2**l hops per interval."""
        if isinstance(n, bool) or not isinstance(n, Integral) or n < 0:
            raise ValueError("n must be a nonnegative integer")
        with self._lock, self.ctx.activate():
            self._require("ready")
-            if n == 0:
-                return
            root = self._levels[0]
            kw = dict(block=self._block, stream=self._stream)
            try:
                self._status = "advancing"
-                self._exchange_valid = False
                for _ in range(n):
-                    if self._observe_raw_exchange:  # stream-ordered: holds the last interval only
+                    if self._observe_raw_exchange:
+                        self._exchange_valid = False
                        for b in self._level_boundaries:
                            if b is not None:
                                cuda.memset_d8_async(b.interval_integral, 0,
                                                     len(b.tables["cell"]) * 32, self._stream)
                    self._hop(0, root.current, root.spare, **kw)
-                    root.current, root.spare = root.spare, root.current  # host handles only
-                self._stream.synchronize()
-                self._step_count += n
-                self._exchange_valid = self._observe_raw_exchange
+                    self._stream.synchronize()
+                    root.current, root.spare = root.spare, root.current
+                    self._step_count += 1
+                    self._exchange_valid = self._observe_raw_exchange
                self._status = "ready"
            except BaseException:
                self._window_valid = False
@@ -835,7 +920,7 @@ class FixedPatchStepper:
        with self._lock, self.ctx.activate():
            self._require("ready")
            self._check_storage()
-            arrays = [np.empty(level.layout.blocked_shape,
+            arrays = [np.empty(level.shape if level.layout is None else level.layout.blocked_shape,
                               np.float32) for level in self._levels]
            try:
                for level, array in zip(self._levels, arrays):
@@ -843,7 +928,7 @@ class FixedPatchStepper:
            except BaseException:
                self._status = "failed"
                raise
-            arrays = [level.layout.to_dense(a)
+            arrays = [a if level.layout is None else level.layout.to_dense(a)
                      for a, level in zip(arrays, self._levels)]
            self._mask_nonstate(*arrays)
            return _StoredPopulations(tuple(arrays), self._ddf_shifting)
@@ -869,6 +954,14 @@ class FixedPatchStepper:
                        b.window_integral = None
                self._levels.clear()
                self._pairs = []
+                if getattr(self, "_fine_curved", None) is not None:
+                    try:
+                        self._fine_curved.free()
+                    except Exception as exc:
+                        error = error or exc
+                    self._fine_curved = None
+                self._curved = self._fine_flags = None
+                self._link_tables = {}
                for pointer in self._allocations:
                    try:
                        pointer.free()
@@ -889,8 +982,8 @@ class FixedPatchStepper:
            if exc[0] is None:
                raise

-    # Read-only compatibility views over the level lists, kept on purpose for the existing
-    # tests and docs. Internal code must not use them; it reads hierarchy/_layouts/_level_*.
+    # Read-only compatibility views over the level lists. Internal code must not use them;
+    # REMOVE AFTER the existing tests/docs migrate to hierarchy/_layouts/_level_* lists.
    patch = property(lambda self: self.hierarchy.pairs[0])
    child_patch = property(lambda self: self.hierarchy.pairs[1] if self.hierarchy.depth > 2 else None)
    base_layout = property(lambda self: self._layouts[0])
@@ -8,7 +8,7 @@ from dataclasses import dataclass, replace
 import numpy as np

 from .blocks import blocked_link_tables
-from ..body.jets import _surface_links
+from ..body.jets import jet_link_shapes, surface_link_velocity
 from .descriptors import D2Q9_EX, D2Q9_EY
 from .refinement import ACTIVE, OUTER_GHOST

@@ -66,50 +66,6 @@ def blocked_base_tables(patch, layout, order, wall_aware=False, *, composed_kind
            blocked_kind(layout, dense_kind))


-def projected_explosion_tables(pair, parent_layout, composed_parent_kind):
-    """Experimental transverse linear explosion, in the pair's existing row order.
-
-    Schornbaum & Rüde (2016), arXiv:1508.07982, Algorithm 2, following
-    Chen et al., doi:10.1016/j.physa.2005.09.036. Independently implemented
-    from the mathematics: centered gradients, perpendicular projection and
-    child offsets +/-1/4. The kernel applies the projection per population.
-
-    Only original explosion donors that are owned, uncovered ACTIVE cells
-    may supply gradients. Both axis neighbors must be legal; otherwise repeat
-    the center twice for zero slope. Owner-core addresses avoid stale halos.
-    The same rule applies to scalar windows, unions and every adjacent pair;
-    nested layouts retain their own per-axis (usually nonperiodic) topology.
-    """
-    ny, nx = pair.coarse_shape
-    kind = np.asarray(composed_parent_kind)
-    if parent_layout.shape != pair.coarse_shape or kind.shape != pair.coarse_shape:
-        raise ValueError("projected explosion parent layout/kind has the wrong shape")
-    donor = pair.ghost_coarse.astype(np.intp)
-    legal = np.zeros(ny * nx, bool)
-    legal[donor] = True
-    legal &= (parent_layout.owned.ravel() & ~pair.covered.ravel()
-              & (kind.ravel() == ACTIVE))
-    if not legal[donor].all():
-        raise ValueError("projected explosion donors need owned uncovered parent ACTIVE cells")
-    y, x = np.divmod(donor, nx)
-    neighbors = np.repeat(donor[:, None], 4, axis=1)
-    for axis, (dx, dy) in enumerate(((1, 0), (0, 1))):
-        minus = ((y - dy) % ny) * nx + (x - dx) % nx
-        plus = ((y + dy) % ny) * nx + (x + dx) % nx
-        valid = legal[minus] & legal[plus]
-        if not parent_layout.periodic[axis]:
-            coordinate, extent = (x, nx) if axis == 0 else (y, ny)
-            valid &= (coordinate > 0) & (coordinate < extent - 1)
-        neighbors[valid, 2 * axis] = minus[valid]
-        neighbors[valid, 2 * axis + 1] = plus[valid]
-    fy, fx = np.divmod(pair.ghost_fine, pair.fine_shape[1])
-    ox, oy = pair.fine_origin
-    offsets = np.column_stack((ox + (fx + .5) / 2 - (x + .5),
-                               oy + (fy + .5) / 2 - (y + .5)))
-    return (np.ascontiguousarray(parent_layout.owner.ravel()[neighbors], dtype=np.uint64),
-            np.ascontiguousarray(offsets, dtype=np.float32))
-
-
 # Required device columns plus optional actuation; observation arms are uploaded
 # separately only when enabled. body_id/aperture remain host reduction metadata.
 BLOCKED_BOUNDARY_DEVICE_COLUMNS = ("block", "cell", "dir", "q", "fallback", "surface_velocity")
@@ -142,13 +98,11 @@ def _prepare_blocked_boundary(boundary, layout, cfg, jets, *, _shifted_blocked=F
    tables.update(body_id=np.asarray(body_id, np.int32), rx=np.asarray(rx, np.float32),
                  ry=np.asarray(ry, np.float32), aperture=np.zeros(len(dirs), bool))
    actuated = bool(jets) or any(o.surface_actuation is not None for o in boundary.objects)
-    jet_cache = None
    if actuated:
        cfg = replace(cfg)
        cfg.validate()
-        tables["surface_velocity"], tables["aperture"], shape, jet_id = _surface_links(
+        tables["surface_velocity"], tables["aperture"] = surface_link_velocity(
            boundary.objects, cfg, boundary.flags, fluid_idx, dirs, body_id, rx, ry,
            jets=jets, hits=boundary.curved_hits, _shifted_blocked=_shifted_blocked)
-        if jets:
-            jet_cache = (shape, jet_id)
-    return _BlockedBoundary(boundary, tables, jets, actuated, jet_cache)
+    return _BlockedBoundary(boundary, tables, jets, actuated,
+                            jet_link_shapes(jets, boundary.curved_hits) if jets else None)
@@ -28,7 +28,7 @@ class LBMStepper:
            self.boundary_values_gpu = cuda.mem_alloc((6 * cfg.nx + 2 * cfg.ny * cfg.nq) * 4)
        else:
            self.step_fn = module.get_function("OneStep")
-            self.init_fn = module.get_function("InitTubeFlow")
+            self.init_fn = module.get_function("InitTubeFlow_v2")

        self.curved_fn = module.get_function("CurvedBoundaryKernel")
        self.prepare_esopull_curved_fn = module.get_function("PrepareEsoPullCurvedKernel")
@@ -25,7 +25,7 @@ import pycuda.driver as cuda

 from .config import LBMConfig, BodyConfig, load_lbm_config, load_body_config
 from .cuda.context import CudaContext, context_bound
-from .cuda import compiler
+from .cuda import compiler_v2 as compiler
 from .lbm.field import LBMField
 from .lbm.stepper import LBMStepper
 from .body.objects import SimObject
@@ -46,8 +46,8 @@ class Simulation:
                 device_id: int = 0):
        # Internal stream for async DTOH coordination
        self._stream: Optional[cuda.Stream] = None
+        self._build_dir = None
        self._closed = False
-        self._failed = None  # reason after an uncertain device write; only close() remains

        # Load configs
        self.lbm_cfg = load_lbm_config(lbm_config_path)
@@ -59,7 +59,9 @@ class Simulation:
        try:
            with self.ctx.activate():
                arch = self._resolve_compile_arch()
-                self._module = compiler.build_module(self.lbm_cfg, "uniform.cu", arch=arch)
+                self._build_dir = compiler.generate_config(self.lbm_cfg, n_objects=0)
+                self._ptx_path = compiler.compile_kernel(arch=arch, build_dir=self._build_dir)
+                self._module = compiler.load_module(self._ptx_path)
                self._compiled_n_objects = 0
                self._allocation_signature = self.lbm_cfg.allocation_signature()
                self._compiled_viscosity = self.lbm_cfg.viscosity
@@ -173,26 +175,15 @@ class Simulation:
    def set_jet_amplitude(self, index: int, amplitude: float) -> None:
        """Change one jet's signed amplitude; re-uploads per-link velocity only.

-        Invalid input raises before any change. Any error after validation
-        leaves the host amplitude unchanged but the device column undefined,
-        so the Simulation is marked failed: every later call except close()
-        raises; close and recreate it.
+        Invalid input changes nothing. A device error leaves the host amplitude
+        unchanged but the device column undefined: treat it like any other CUDA
+        exception here and close/recreate the Simulation before stepping again.
        """
-        self._require_usable()
        jet = self.bodies.jets[index].with_amplitude(amplitude)
        if self._initialized:
-            try:
-                self.field.curved.set_jet_amplitude(index, amplitude, self.stream)
-            except BaseException as exc:
-                self._failed = f"jet amplitude upload failed: {exc!r}"
-                raise
+            self.field.curved.set_jet_amplitude(index, amplitude, self.stream)
        self.bodies.jets[index] = jet  # later geometry syncs keep the new amplitude

-    def _require_usable(self):
-        failed = getattr(self, "_failed", None)
-        if failed is not None:
-            raise RuntimeError(f"Simulation failed ({failed}); close() and recreate it")
-
    def remove_body(self, id: int) -> None:
        """Remove a body from the simulation.

@@ -345,20 +336,13 @@ class Simulation:
    def read_surface_exchange(self, id: int):
        """Latest step's wall/aperture (Fx,Fy,Tz) exchange, not total nozzle force.

-        Supports SurfaceActuation and Jet-driven bodies, including zero-amplitude
-        apertures. Passive bodies without an aperture are rejected.
        Unlike read_body this is not accumulated/time-averaged. It resets after
        geometry sync or checkpoint load; advance before interpreting it.
        """
-        self._require_usable()
-        obj = self.bodies.get(id)
-        curved = self.field.curved
-        has_aperture = (curved.aperture is not None
-                        and np.any(curved.aperture & (curved.body_id == id)))
-        if obj.surface_actuation is None and not has_aperture:
+        if self.bodies.get(id).surface_actuation is None:
            raise ValueError("Body has no surface actuation")
        self.stream.synchronize()
-        return curved.surface_exchange(id)
+        return self.field.curved.surface_exchange(id)

    @context_bound
    def read_body(self, id: int, *,
@@ -378,7 +362,6 @@ class Simulation:
            BodyTelemetry with fields ``force``, ``torque``, ``sensor``.
            ``sensor`` is a dim-length array of zeros for non-sensor bodies.
        """
-        self._require_usable()
        if self.bodies.obs_pinned is None:
            raise RuntimeError("No obs buffer. Call run() first.")
        if stream is None:
@@ -398,7 +381,6 @@ class Simulation:
        This is the most efficient readback for DRL control loops
        (single contiguous D2H copy, no Python per-body overhead).
        """
-        self._require_usable()
        if self.bodies.obs_pinned is None:
            raise RuntimeError("No obs buffer. Call run() first.")
        if stream is None:
@@ -424,8 +406,15 @@ class Simulation:
        self.lbm_cfg.validate_runtime()
        self._assert_allocation_contract()
        arch = self._resolve_compile_arch()
-        self._module = compiler.build_module(self.lbm_cfg, "uniform.cu", arch=arch,
-                                             n_objects=expected_n_objects)
+        next_dir = compiler.generate_config(self.lbm_cfg, n_objects=expected_n_objects)
+        try:
+            next_ptx = compiler.compile_kernel(arch=arch, build_dir=next_dir)
+            next_module = compiler.load_module(next_ptx)
+        except Exception:
+            compiler.cleanup_build_dir(next_dir)
+            raise
+        old_dir = self._build_dir
+        self._build_dir, self._ptx_path, self._module = next_dir, next_ptx, next_module
        self._compiled_n_objects = int(expected_n_objects)

        # Reconnect field and stepper to new module
@@ -443,6 +432,7 @@ class Simulation:
        self.stepper._step_count = _prev_step_count

        self._assert_object_count_contract(expected_count=expected_n_objects)
+        compiler.cleanup_build_dir(old_dir)

    def recompile(self):
        """Re-generate config headers and recompile kernel.
@@ -461,22 +451,18 @@ class Simulation:
    @context_bound
    def initialize(self):
        """Initialize flow field and sync objects to GPU."""
-        self._require_usable()
-        self._assert_allocation_contract()
-        # Validate the complete geometry before flags, populations or modules
-        # change. Compact-list construction publishes no outputs on failure.
-        next_flags = self.bodies.build_flags(self.field.build_channel_flags())
-        if self.bodies.jets and self.bodies.count == 0:
-            raise ValueError("Jets need bodies with cut links")
-        self.bodies.build_compact_lists_for(self.bodies.objects, next_flags)
-
        # Recompile if objects were added after construction.
+        self._assert_allocation_contract()
        if self._read_generated_n_objects() != self.bodies.count:
            self.recompile()

-        self.field.flag = next_flags
+        self.field.flag = self.field.build_channel_flags()
+        if self.bodies.count > 0:
+            self.field.flag = self.bodies.build_flags(self.field.flag)
        self.field.upload_flags()

+        if self.bodies.jets and self.bodies.count == 0:
+            raise ValueError("Jets need bodies with cut links")
        self.stepper.initialize()
        if self.bodies.count > 0:
            self.bodies.sync_to_gpu(self.field, rebuild_flags=False)
@@ -494,7 +480,6 @@ class Simulation:
        In EsoPull mode, the backing layout is decoded to physical DDF on
        GPU for the patched cells only, patched on host, then encoded back.
        """
-        self._require_usable()
        if not self._initialized:
            raise RuntimeError("Call initialize() before sync_bodies()")

@@ -590,7 +575,6 @@ class Simulation:
                sensor) on GPU and reset the step accumulator before stepping.
            checkpoint_interval: Nonnegative integer; if >0, save every N steps.
        """
-        self._require_usable()
        if not self._initialized:
            raise RuntimeError("Call initialize() first")
        steps = operator.index(steps)
@@ -655,12 +639,10 @@ class Simulation:
    @context_bound
    def get_macroscopic(self) -> Dict[str, np.ndarray]:
        """Download DDF and return rho, ux, uy [, uz]."""
-        self._require_usable()
        return self.field.get_macroscopic(step_id=self.stepper.step_count)

    @context_bound
    def get_ddf(self) -> np.ndarray:
-        self._require_usable()
        self.field.download_ddf(step_id=self.stepper.step_count)
        return self.field.ddf.copy()

@@ -674,27 +656,23 @@ class Simulation:

        Accepted: omega, fx, fy, fz, n_objects.
        """
-        self._require_usable()
        self.field.update_params(**kwargs)

    # -- Snapshots -----------------------------------------------------------
    @context_bound
    def snapshot(self):
        """Snapshot the flow field; restore keeps the current clock and controls."""
-        self._require_usable()
        self.field.snapshot(step_id=self.stepper.step_count)

    @context_bound
    def restore(self):
        """Restore the saved flow field at the current streaming parity."""
-        self._require_usable()
        self.field.restore(step_id=self.stepper.step_count)

    # -- Checkpoint / Restore (HDF5) ----------------------------------------
    @context_bound
    def save_checkpoint(self, path: str = None):
        """Save full simulation state to an HDF5 file."""
-        self._require_usable()
        from .common.checkpoint import save_checkpoint
        if self.bodies.jets:
            raise NotImplementedError("Jets are not checkpointed yet")
@@ -704,7 +682,6 @@ class Simulation:
    @context_bound
    def load_checkpoint(self, path: str):
        """Restore simulation state from an HDF5 checkpoint."""
-        self._require_usable()
        from .common.checkpoint import load_checkpoint
        if not self._initialized:
            self.initialize()
@@ -729,6 +706,8 @@ class Simulation:
                self._module = None
                self._stream = None
            ctx.close()
+        compiler.cleanup_build_dir(getattr(self, "_build_dir", None))
+        self._build_dir = None
        self._closed = True

    def __enter__(self):
@@ -1,66 +0,0 @@
-"""Checkpoint save -> load round trip for a scene with passive bodies. Requires GPU.
-
-A fresh Simulation with the same scene, restored from the checkpoint must hold the same populations,
-flags, body count and step count, and must stay bitwise identical to the original
-after both continue for the same number of steps. Checkpoints with Jets are
-refused (documented limitation) and are not covered here.
-"""
-
-import os
-import tempfile
-import unittest
-
-import numpy as np
-
-from ._cases import make_sim
-
-# Three separated cylinders (pinball-like); cut-link receivers stay in bulk fluid.
-CIRCLES = (((40, 32), 6), ((56, 22), 6), ((56, 42), 6))
-
-
-def scene():
-    sim = make_sim()
-    sim.initialize()
-    for center, radius in CIRCLES:
-        sim.add_body("circle", center=center, radius=radius)
-    sim.sync_bodies()
-    return sim
-
-
-class CheckpointBodiesGPU(unittest.TestCase):
-    def test_round_trip_is_bitwise_and_continues_identically(self):
-        sim = scene()
-        sim.run(60)
-        with tempfile.NamedTemporaryFile(suffix=".h5", delete=False) as f:
-            path = f.name
-        restored = None
-        try:
-            saved = sim.save_checkpoint(path)
-            # The loader requires the same body count and geometry: rebuild the scene.
-            restored = scene()
-            restored.load_checkpoint(saved)
-
-            self.assertEqual(restored.bodies.count, len(CIRCLES))
-            self.assertEqual(restored.stepper.step_count, sim.stepper.step_count)
-            np.testing.assert_array_equal(restored.get_flags(), sim.get_flags())
-            a, b = sim.get_ddf(), restored.get_ddf()
-            self.assertEqual(a.dtype, b.dtype)
-            self.assertEqual(a.tobytes(), b.tobytes())
-
-            sim.run(40)
-            restored.run(40)
-            self.assertEqual(restored.stepper.step_count, sim.stepper.step_count)
-            a, b = sim.get_ddf(), restored.get_ddf()
-            self.assertTrue(np.isfinite(a).all())
-            self.assertEqual(a.tobytes(), b.tobytes())
-            for i in range(len(CIRCLES)):
-                self.assertTrue(np.all(np.isfinite(restored.read_force(i))))
-        finally:
-            if restored is not None:
-                restored.close()
-            os.unlink(path)
-            sim.close()
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -1,53 +0,0 @@
-"""Direct Simulation Jet control upload; boundary-law accuracy is tested elsewhere."""
-import numpy as np
-import pycuda.driver as cuda
-
-from CelerisLab.body.jets import Jet, Radial, Sector
-from CelerisLab.lbm.descriptors import FLUID
-from ._cases import make_sim
-
-
-def test_simulation_jet_amplitude_upload_and_continued_steps():
-    # Same grid/circle/sector as the existing uniform surface-actuation fixture.
-    center = (16., 12.)
-    with make_sim(nx=32, ny=24, velocity=0) as sim:
-        sim.add_body("circle", center=center, radius=4.3)
-        index = sim.add_jet(Jet(Sector(center, .7, .85, 4.4),
-                                Radial(center, inward=False), "quartic", .002))
-        sim.initialize()
-        curved = sim.field.curved
-        shape, jet_id = curved.jet_shape.copy(), curved.jet_id.copy()
-        flags = sim.get_flags()
-        driven = jet_id == index
-        assert driven.any() and (~driven).any()
-        velocity_pointer = int(curved.surface_velocity_gpu)
-        previous = None
-        for interval, amplitude in enumerate((.002, -.001)):
-            if interval:
-                count = sim.stepper.step_count
-                sim.set_jet_amplitude(index, amplitude)
-                assert sim.stepper.step_count == count  # update does not step
-            expected = np.zeros_like(curved.surface_velocity)
-            expected[driven] = (amplitude * shape[driven]).astype(np.float32)
-            actual = np.empty_like(expected)
-            with sim.ctx.activate():
-                cuda.memcpy_dtoh(actual, curved.surface_velocity_gpu)
-            np.testing.assert_array_equal(actual, expected)  # actual device column
-            np.testing.assert_array_equal(curved.surface_velocity, expected)
-            assert np.any(actual[driven] != 0)
-            if previous is not None:
-                assert not np.array_equal(actual[driven], previous[driven])
-            previous = actual.copy()
-            assert sim.bodies.jets[index].amplitude == amplitude
-            assert curved.jets[index].amplitude == amplitude
-            assert int(curved.surface_velocity_gpu) == velocity_pointer
-            np.testing.assert_array_equal(curved.jet_shape, shape)
-            np.testing.assert_array_equal(curved.jet_id, jet_id)
-            np.testing.assert_array_equal(sim.get_flags(), flags)
-            sim.run(2)
-            assert sim.stepper.step_count == 2 * (interval + 1)
-            assert sim._failed is None
-            macro = sim.get_macroscopic()
-            fluid = (flags.reshape(24, 32) & FLUID) != 0
-            assert all(np.isfinite(value[fluid]).all() for value in macro.values())
-            assert np.all(macro["rho"][fluid] > 0)
@@ -6,14 +6,14 @@ import pycuda.driver as cuda
 import pytest

 import CelerisLab
-from CelerisLab.cuda import compiler
+from CelerisLab.cuda import compiler_v2
 from ._cases import make_sim


 def test_source_provenance():
    root = Path(__file__).resolve().parents[2] / "src/CelerisLab"
    assert Path(CelerisLab.__file__).resolve().parent == root
-    assert Path(compiler.kernel_path("uniform.cu")).resolve() == root / "lbm/kernels/uniform.cu"
+    assert Path(compiler_v2.kernel_path("kernel_v2.cu")).resolve() == root / "lbm/kernels/kernel_v2.cu"


 def test_two_contexts_interleaved_and_non_lifo_close():
@@ -21,7 +21,7 @@ def test_two_contexts_interleaved_and_non_lifo_close():
    first = make_sim(nx=32, ny=16)
    second = make_sim(nx=48, ny=24, streaming="esopull", shifted=True)
    try:
-        assert first._module is not second._module
+        assert first._build_dir != second._build_dir
        assert cuda.Context.get_current() == before
        first.initialize()
        second.initialize()
@@ -16,7 +16,6 @@
 #define NZ 1
 #define NT 1
 #define COLLISION_MODEL 0
-#define BLOCK_ROOT_BC 2
 #define USE_LES 0
 #define RHO 1.f
 #define U0 .025f
@@ -41,7 +40,7 @@ inline float __fdiv_rn(float a,float b){return a/b;}
 #include "boundary/inlet_outlet.cuh"
 #include "step/one_step_double.cu"
 #else
-#include "core/cell_kind.cuh"
+constexpr unsigned char KIND_OUTER=2;
 #include "step/block_channel.cu"
 #endif
 int main(){
@@ -1,46 +0,0 @@
-"""Check historical source manifests against their own recorded commit, not today's checkout."""
-
-import io
-from pathlib import Path
-import subprocess
-import tarfile
-
-ROOT = Path(__file__).resolve().parents[2]
-
-
-def _require(commit):
-    """Missing recorded history is an explicit failure, never a skip or a repin."""
-    found = subprocess.run(
-        ["git", "-C", str(ROOT), "cat-file", "-e", commit + "^{commit}"],
-        capture_output=True,
-    )
-    if found.returncode:
-        raise AssertionError(
-            f"Required history missing: commit {commit} is not in this clone; "
-            "fetch it instead of repinning or substituting"
-        )
-
-
-def tracked(commit, prefix="src"):
-    """Tracked paths under prefix at the recorded commit."""
-    _require(commit)
-    return set(
-        subprocess.check_output(
-            ["git", "-C", str(ROOT), "ls-tree", "-r", "--name-only", commit, prefix],
-            text=True,
-        ).splitlines()
-    )
-
-
-def historical_tree(commit, dest):
-    """Extract the tracked tree of the recorded commit into dest."""
-    _require(commit)
-    archive = subprocess.check_output(
-        ["git", "-C", str(ROOT), "archive", "--format=tar", commit]
-    )
-    dest = Path(dest)
-    dest.mkdir(parents=True, exist_ok=True)
-    extra = {"filter": "data"} if hasattr(tarfile, "data_filter") else {}
-    with tarfile.open(fileobj=io.BytesIO(archive)) as tar:
-        tar.extractall(dest, **extra)
-    return dest
@@ -83,32 +83,6 @@ assert abs(sum(compute_feq_d2q9(1.,0.,0.)) - 1.) < 1e-6


 class BuildContracts(unittest.TestCase):
-    def test_block_root_modes_are_rendered_and_recorded(self):
-        with tempfile.TemporaryDirectory() as root:
-            for mode in (0, 1, 2):
-                with self.subTest(mode=mode):
-                    build = compiler.generate_config(LBMConfig(), build_root=root, block_root_bc=mode)
-                    try:
-                        method = Path(build, "config/config_method.h").read_text()
-                        self.assertIn(f"#define BLOCK_ROOT_BC {mode}\n", method)
-                        metadata = json.loads(Path(build, ".celeris-build").read_text())
-                        self.assertEqual(metadata["block_root_bc"], mode)
-                        self.assertNotIn("block_root_bc", metadata["config"])
-                    finally:
-                        compiler.cleanup_build_dir(build)
-            build = compiler.generate_config(LBMConfig(), build_root=root)
-            try:
-                self.assertEqual(json.loads(Path(build, ".celeris-build").read_text())["block_root_bc"], 0)
-            finally:
-                compiler.cleanup_build_dir(build)
-
-    def test_invalid_block_root_mode_fails_before_snapshot(self):
-        for mode in (-1, 3, True, False, 1.0, "1", None):
-            with self.subTest(mode=mode), patch.object(compiler.tempfile, "mkdtemp") as allocate:
-                with self.assertRaisesRegex(ValueError, "block_root_bc"):
-                    compiler.generate_config(LBMConfig(), block_root_bc=mode)
-                allocate.assert_not_called()
-
    @staticmethod
    def fake_compile(command, check):
        source = Path(command[-3])
@@ -126,7 +100,8 @@ class BuildContracts(unittest.TestCase):
            def work(nx, count):
                build = compiler.generate_config(LBMConfig(nx=nx), count, build_root=root)
                barrier.wait()
-                output = compiler.compile_kernel(build_dir=build)
+                # Compatibility form is context-local even without explicit path.
+                output = compiler.compile_kernel()
                data = json.loads(Path(output).read_text())
                self.assertEqual(data, {"nx": nx, "objects": count})
                metadata = json.loads(Path(output + ".json").read_text())
@@ -155,7 +130,7 @@ class BuildContracts(unittest.TestCase):
            compiler.cleanup_build_dir(a)
            compiler.cleanup_build_dir(b)
            with self.assertRaises(RuntimeError):
-                compiler.compile_kernel(build_dir=a)  # removed snapshot is never compiled
+                compiler.compile_kernel()

    def test_failed_compile_cannot_implicitly_load_previous_artifact(self):
        with tempfile.TemporaryDirectory() as root:
@@ -168,7 +143,8 @@ class BuildContracts(unittest.TestCase):
                with self.assertRaises(subprocess.CalledProcessError):
                    compiler.compile_kernel(build_dir=build)
            self.assertEqual(Path(previous).read_bytes(), old_bytes)
-            self.assertEqual(sorted(Path(build).glob("uniform-*.ptx")), [])  # no partial output
+            with self.assertRaisesRegex(RuntimeError, "No compiled PTX"):
+                compiler.load_module()
            compiler.cleanup_build_dir(build)


@@ -50,7 +50,7 @@ def test_masks_and_minimal_footprint():
 def test_actual_closure_read_conflicts():
    pair, layout, targets = transfer((6, 6, 18, 14))
    validate_channel_transfers(pair, layout, targets)
-    for target in (layout.slot(int(layout.owner[5, -1]) - 1, 2),  # integer under NumPy 1 and 2
+    for target in (layout.slot(layout.owner[5, -1]-1, 2),
                   layout.slot(layout.owner[1, 4], 4),
                   layout.slot(layout.owner[-2, 4], 3)):
        with pytest.raises(ValueError, match="immutable"):
@@ -74,14 +74,14 @@ def test_evolved_ghost_snapshot_and_physical_download():
    from .test_refinement_three_level_multipatch import host_module
    host = host_module()
    storage = {}
-    host.compiler.build_module.return_value.get_global.side_effect = lambda name: (name, 12 if name == "d_block_channel" else 20)
+    host.compiler.load_module.return_value.get_global.side_effect = lambda name: (name, 12 if name == "d_block_channel" else 20)
    host.cuda.mem_alloc.side_effect = lambda size: Mock()
    host.cuda.memcpy_htod.side_effect = lambda ptr, a: storage.__setitem__(id(ptr), np.array(a, copy=True))
    host.cuda.memcpy_dtoh.side_effect = lambda a, ptr: np.copyto(a, storage[id(ptr)])
    context = Mock(activate=nullcontext, sm_arch="sm_70")
    cfg = LBMConfig(nx=24, ny=20, viscosity=.1, velocity=.025)
-    backend = host.FixedPatchStepper(cfg, context=context, coarse_boundary="channel",
-                                    refinements=[(6, 6, 18, 14)], level_blocks=[(4, 6), (4, 4)])
+    backend = host.FixedPatchStepper(cfg, (6, 6, 18, 14), context=context,
+                                    coarse_boundary="channel", base_block=(4, 6), fine_block=(4, 4))
    try:
        weights = np.array([4/9]+[1/9]*4+[1/36]*4)[:, None, None]
        arrays = [np.broadcast_to(weights, level.shape).copy() for level in backend._levels]
@@ -96,7 +96,6 @@ def test_evolved_ghost_snapshot_and_physical_download():
        arrays[0][0, 0, 0] = np.nan
        with pytest.raises(ValueError, match="finite"):
            backend.initialize(*arrays)
-        assert backend._levels[0].kernel == host.compiler.build_module.return_value.get_function("BlockChannelStep")
-        assert [call.kwargs["block_root_bc"] for call in host.compiler.build_module.call_args_list] == [2, 0]
+        assert backend._levels[0].kernel == host.compiler.load_module.return_value.get_function("BlockChannelStep")
    finally:
        backend.close()
@@ -1,79 +0,0 @@
-"""CPU-only contract tests for run_dfg_re20. Not CUDA or DFG acceptance evidence."""
-
-import sys
-from pathlib import Path
-import unittest
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "validation"))
-import run_dfg_re20 as v  # noqa: E402
-import run_refined_dfg as rr  # noqa: E402
-
-h, _ = rr.helpers(rr.DEFAULT_SOURCE)
-
-
-def rows(values, tstar_end=v.TSTAR_MAX):
-    n = int(round(tstar_end / v.SAMPLE_TSTAR))
-    return [dict(tstar=(i + 1) * v.SAMPLE_TSTAR, **values(i)) for i in range(n)]
-
-
-class Re20Contract(unittest.TestCase):
-    def test_lattice_parameters_and_bounds(self):
-        root, uniform = v.lattice_parameters(40), v.lattice_parameters(80)
-        self.assertAlmostEqual(root["tau"], 0.56, places=12)
-        self.assertAlmostEqual(uniform["tau"], 0.62, places=12)
-        self.assertEqual((root["steps"], root["interval"]), (240000, 2000))
-        self.assertEqual((uniform["steps"], uniform["interval"]), (480000, 4000))
-        self.assertAlmostEqual(v.plan()["refined_fine_tau"], 0.62, places=12)
-
-    def test_config_only_changes_viscosity(self):
-        base = v._re100_config(h, 40, "SRT", "none")
-        cfg, body, p = v.config(h, 40, "SRT")
-        self.assertAlmostEqual(cfg["physics"]["viscosity"], 0.01 * 40 / 20, places=15)
-        self.assertEqual((p["re"], p["viscosity"]), (20.0, cfg["physics"]["viscosity"]))
-        base[0]["physics"]["viscosity"] = cfg["physics"]["viscosity"]
-        self.assertEqual(base[0], cfg)
-        self.assertEqual(base[1], body)
-        with self.assertRaisesRegex(ValueError, "no Jets"):
-            v.config(h, 40, "MRT", "zero")
-
-    def test_units(self):
-        s = v.sample([2.0, -0.5], 4, 40, 3.0)
-        den = rr.SPEED**2 * 40 / 2
-        self.assertAlmostEqual(s["cd"], 2.0 / 4 / den)
-        self.assertAlmostEqual(s["cl"], -0.5 / 4 / den)
-        self.assertAlmostEqual(s["p_diff"], 3.0 * 0.04)
-        self.assertEqual(s["dp_scaled"], 3.0)
-
-    def test_steady_and_verdict(self):
-        inside = dict(cd=5.58, cl=0.0106, p_diff=0.1174)
-        out = v.summarize(rows(lambda i: inside))
-        self.assertEqual((out["status"], out["steady"], out["window_samples"]),
-                         ("WITHIN_INTERVALS", True, 21))
-        self.assertTrue(out["cd_positive"])
-        self.assertAlmostEqual(out["edge_distance"]["cl"], 0.0002)
-        self.assertTrue(all(out["verdict"].values()))
-        low = v.summarize(rows(lambda i: dict(inside, cl=0.0100)))
-        self.assertEqual(low["status"], "OUTSIDE_INTERVALS")
-        self.assertFalse(low["verdict"]["cl"])
-
-    def test_slow_drift_gives_no_verdict(self):
-        # Range 2e-5 passes (limit 6e-5); slope * window 2e-5 exceeds 1.2e-5.
-        out = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 1e-6 * i, p_diff=0.1174)))
-        self.assertEqual((out["status"], out["verdict"]), ("NOT_STEADY", None))
-        self.assertLessEqual(out["ranges"]["cl"], out["range_limits"]["cl"])
-        self.assertGreater(out["drifts"]["cl"], out["slope_limits"]["cl"])
-
-    def test_noise_range(self):
-        quiet = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 2e-5 * (i % 2), p_diff=0.1174)))
-        self.assertTrue(quiet["steady"])  # within the range limit, no trend
-        noisy = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 1e-4 * (i % 2), p_diff=0.1174)))
-        self.assertEqual(noisy["status"], "NOT_STEADY")
-        self.assertGreater(noisy["ranges"]["cl"], noisy["range_limits"]["cl"])
-
-    def test_incomplete_run_gives_no_verdict(self):
-        out = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106, p_diff=0.1174), tstar_end=30))
-        self.assertEqual((out["status"], out["verdict"]), ("INCOMPLETE", None))
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -1,70 +0,0 @@
-"""The public examples run all-blocked: their level tiles must reach the device unchanged.
-
-Host only: a context whose activation raises proves construction (layouts, tables,
-boundary checks) succeeded up to the first CUDA call.
-"""
-import ast
-from dataclasses import replace
-from pathlib import Path
-import unittest
-from unittest.mock import Mock
-
-from CelerisLab.body.geometry.circle import CircleGeometry
-from CelerisLab.body.objects import SimObject
-from CelerisLab.config import LBMConfig
-from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
-
-EXAMPLES = Path(__file__).resolve().parents[2] / "examples"
-
-
-def literal(name, constant):
-    """Module-level literal from an example, read without importing it (no pycuda)."""
-    tree = ast.parse((EXAMPLES / name).read_text())
-    for node in tree.body:
-        if isinstance(node, ast.Assign):
-            for target in node.targets:
-                names = target.elts if isinstance(target, ast.Tuple) else [target]
-                for i, t in enumerate(names):
-                    if isinstance(t, ast.Name) and t.id == constant:
-                        value = node.value.elts[i] if isinstance(target, ast.Tuple) else node.value
-                        return ast.literal_eval(value)
-    raise KeyError(constant)
-
-
-def forbidden():
-    return Mock(activate=Mock(side_effect=AssertionError("CUDA reached")), sm_arch="sm_70")
-
-
-class ExampleTiles(unittest.TestCase):
-    def test_fixed_patch_jet_tiles(self):
-        bounds, blocks = literal("fixed_patch_jet.py", "BOUNDS"), literal("fixed_patch_jet.py", "LEVEL_BLOCKS")
-        width, amplitude = literal("fixed_patch_jet.py", "WIDTH"), literal("fixed_patch_jet.py", "AMPLITUDE")
-        cfg = LBMConfig(nx=48, ny=48, viscosity=.1, velocity=0., wall_slot_width=width,
-                        wall_normal_velocity=amplitude, y_wall_bc="on_site_velocity",
-                        top_wall_bc="reservoir")
-        with self.assertRaisesRegex(AssertionError, "CUDA reached"):
-            FixedPatchStepper(cfg, context=forbidden(), coarse_boundary="slot_reservoir",
-                              refinements=[bounds], level_blocks=[tuple(b) for b in blocks])
-
-    def test_fixed_periodic_patch_tiles(self):
-        with self.assertRaisesRegex(AssertionError, "CUDA reached"):
-            FixedPatchStepper(LBMConfig(nx=16, ny=16, viscosity=.1, velocity=1e-3), context=forbidden(),
-                              refinements=[(4, 4, 12, 12)], level_blocks=[(16, 16), (24, 24)])
-
-    def test_fixed_patch_circle_default_tiles(self):
-        bounds = literal("fixed_patch_circle.py", "BOUNDS")
-        nx, ny = literal("fixed_patch_circle.py", "NX"), literal("fixed_patch_circle.py", "NY")
-        center, radius = literal("fixed_patch_circle.py", "CENTER"), literal("fixed_patch_circle.py", "RADIUS")
-        body = SimObject(0, geometry=CircleGeometry(*center, radius), center=center, radius=radius)
-        periodic = LBMConfig(nx=nx, ny=ny, viscosity=.1)
-        slot = replace(periodic, velocity=0, wall_normal_velocity=.001, wall_slot_width=8,
-                       y_wall_bc="on_site_velocity", top_wall_bc="reservoir")
-        for mode, cfg in (("periodic", periodic), ("slot_reservoir", slot)):
-            with self.subTest(mode=mode), self.assertRaisesRegex(AssertionError, "CUDA reached"):
-                FixedPatchStepper(cfg, context=forbidden(), coarse_boundary=mode,
-                                  refinements=[bounds], level_blocks=[(12, 8), (16, 20)],
-                                  level_objects=[(), (body,)])
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -8,7 +8,6 @@ import numpy as np
 ROOT = Path(__file__).resolve().parents[2]
 REPO = ROOT
 sys.path.insert(0, str(ROOT / "tests/validation"))
-sys.path.insert(0, str(ROOT / "tests/unit"))
 sys.path.insert(0, str(REPO / "src"))
 from run_jet_circle_cv import (
    CX,
@@ -17,10 +16,8 @@ from run_jet_circle_cv import (
    case,
    state,
    cv,
-    cv_from_macros,
    aperture_probe,
    measured_aperture_flux,
-    PIN,
    verify,
 )

@@ -31,39 +28,6 @@ def eq(rho, u, v):


 class Host(unittest.TestCase):
-    def test_public_macros_pressure_advection_and_cropped_frames(self):
-        for h, origin, shape, rect in (
-            (.5, (0., 0.), (48, 64), (5., 4., 25., 20.)),
-            (.5, (.25, .5), (48, 64), (5.25, 4., 25.25, 20.)),
-            (.25, (.375, .75), (96, 128), (5.125, 4., 25.125, 20.)),
-        ):
-            y, x = np.indices(shape)
-            x = origin[0] + h * (x + .5)
-            k, u, v = 1e-5, .02, -.01
-            rho = 1 + 3 * k * x  # p=(rho-1)/3=k*x
-            ux, uy, fluid = np.full(shape, u), np.full(shape, v), np.ones(shape, bool)
-            result = cv_from_macros(rho, ux, uy, fluid, origin, rect, .004, h)
-            expected = 320 * np.array([3*k*u, k + 3*k*u*u, 3*k*u*v])
-            np.testing.assert_allclose(result[1], expected, rtol=1e-11, atol=1e-13)
-            np.testing.assert_allclose(result, cv(eq(rho, u, v), fluid, origin, rect, .004, h), atol=1e-12)
-            x0, y0, x1, y1 = np.rint((np.array(rect)-np.tile(origin, 2))/h).astype(int)
-            selection = np.s_[y0-2:y1+2, x0-2:x1+2]
-            cropped_origin = np.asarray(origin) + h*np.array([x0-2, y0-2])
-            cropped = cv_from_macros(rho[selection], ux[selection], uy[selection],
-                                    fluid[selection], cropped_origin, rect, .004, h)
-            np.testing.assert_array_equal(cropped, result)
-
-    def test_public_macros_full_normal_viscous_stress(self):
-        y, x = np.indices((48, 64))
-        x = (x + .5) * .5
-        rho, ux, uy, fluid = np.ones_like(x), 1e-4*x*x, np.zeros_like(x), np.ones(x.shape, bool)
-        args = (rho, ux, uy, fluid, (0., 0.), (5., 4., 25., 20.))
-        _, viscous = cv_from_macros(*args, .004)
-        _, inviscid = cv_from_macros(*args, 0.)
-        np.testing.assert_allclose(viscous-inviscid, [0, -4*.004*1e-4*320, 0], atol=1e-13)
-        with self.assertRaisesRegex(ValueError, "matching 2D"):
-            cv_from_macros(rho, ux, uy[:-1], fluid, (0, 0), (5, 4, 25, 20), .004)
-
    def test_descriptor_and_uniform_closed_flux(self):
        from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY

@@ -168,13 +132,7 @@ class Host(unittest.TestCase):
        self.assertEqual(a["steps"] * 4, b["steps"])

    def test_source_pin(self):
-        from tempfile import TemporaryDirectory
-        from historical_tree import historical_tree
-
-        with self.assertRaisesRegex(RuntimeError, "Source hash mismatch"):
-            verify(REPO)
-        with TemporaryDirectory() as directory:
-            verify(historical_tree(PIN, directory))
+        verify(REPO)


 if __name__ == "__main__":
@@ -1,124 +0,0 @@
-"""Jet amplitude update failure contract (host doubles only, no CUDA numerics).
-
-Both owners validate before any device write, commit host state only after the
-upload returns, and refuse every later call except close() after an uncertain
-device write.
-"""
-from types import SimpleNamespace
-
-import numpy as np
-import pytest
-
-pytest.importorskip("pycuda.driver")
-from CelerisLab.body.jets import Jet, Radial, Sector
-from tests.unit.test_pinned_body_remap import ready
-from tests.unit.test_simulation_lifecycle import make_simulation
-
-BAD = (float("nan"), float("inf"), 1.)
-
-
-class Curved:
-    """Records uploads; ``fail`` raises once the write was attempted."""
-    def __init__(self):
-        self.writes, self.fail = [], False
-
-    def set_jet_amplitude(self, index, amplitude, stream):
-        self.writes.append((index, amplitude))
-        if self.fail:
-            raise RuntimeError("upload failed")
-
-
-def simulation(monkeypatch):
-    sim = make_simulation(monkeypatch)
-    jet = Jet(Sector((6., 5.), 0., .5, 4.), Radial((6., 5.)), "uniform", 1e-3)
-    sim._failed, sim._initialized = None, True
-    sim.bodies, sim.field = SimpleNamespace(jets=[jet]), SimpleNamespace(curved=Curved())
-    return sim, jet
-
-
-def test_simulation_invalid_input_writes_nothing_and_stays_usable(monkeypatch):
-    sim, jet = simulation(monkeypatch)
-    for amplitude in BAD:
-        with pytest.raises(ValueError):
-            sim.set_jet_amplitude(0, amplitude)
-    with pytest.raises(IndexError):
-        sim.set_jet_amplitude(1, 2e-3)
-    assert sim.field.curved.writes == [] and sim.bodies.jets[0] is jet and sim._failed is None
-    sim.set_jet_amplitude(0, 2e-3)  # retry after a rejected input
-    assert sim.field.curved.writes == [(0, 2e-3)] and sim.bodies.jets[0].amplitude == 2e-3
-    sim.close()
-
-
-def test_simulation_upload_failure_keeps_host_and_blocks_reuse(monkeypatch):
-    sim, jet = simulation(monkeypatch)
-    sim.field.curved.fail = True
-    with pytest.raises(RuntimeError, match="upload failed"):
-        sim.set_jet_amplitude(0, 2e-3)
-    assert sim.bodies.jets[0] is jet and sim._failed is not None
-    sim.field.curved.fail = False
-    for call in (lambda: sim.set_jet_amplitude(0, 2e-3), lambda: sim.run(1), sim.step,
-                 sim.sync_bodies, sim.initialize, sim.get_ddf, sim.get_macroscopic,
-                 lambda: sim.read_surface_exchange(0), lambda: sim.read_body(0),
-                 sim.read_bodies, sim.snapshot, sim.restore, sim.save_checkpoint,
-                 lambda: sim.load_checkpoint("x.h5"), lambda: sim.update_runtime_params(omega=1.)):
-        with pytest.raises(RuntimeError, match="Simulation failed"):
-            call()
-    assert sim.field.curved.writes == [(0, 2e-3)]
-    sim.close()  # cleanup still works
-    assert sim._closed and sim.ctx.is_closed
-
-
-def test_simulation_before_initialize_commits_host_only(monkeypatch):
-    sim, _ = simulation(monkeypatch)
-    sim._initialized = False
-    sim.set_jet_amplitude(0, -2e-3)
-    assert sim.field.curved.writes == [] and sim.bodies.jets[0].amplitude == -2e-3
-    sim.close()
-
-
-def stepper_state(run):
-    boundary = run._level_boundaries[2]
-    return boundary.tables["surface_velocity"].copy(), boundary.jets, run._level_jets[2]
-
-
-def test_stepper_invalid_input_writes_nothing_and_stays_ready():
-    run, module, _, _, _ = ready()
-    try:
-        velocity, jets, level_jets = stepper_state(run)
-        module.cuda.memcpy_htod.reset_mock()
-        for args, kw, error in [((0, a), {"level": 2}, ValueError) for a in BAD] + [
-                ((1, .01), {"level": 2}, IndexError), ((0, .01), {"level": 3}, ValueError)]:
-            with pytest.raises(error):
-                run.set_jet_amplitude(*args, **kw)
-        module.cuda.memcpy_htod.assert_not_called()
-        np.testing.assert_array_equal(run._level_boundaries[2].tables["surface_velocity"], velocity)
-        assert (run._level_boundaries[2].jets, run._level_jets[2]) == (jets, level_jets)
-        assert run._status == "ready"
-        run.set_jet_amplitude(0, .017, level=2)
-        assert run._level_jets[2][0].amplitude == .017
-    finally:
-        run.close()
-
-
-@pytest.mark.parametrize("where", ["upload", "synchronize"])
-def test_stepper_device_failure_keeps_host_and_blocks_reuse(where):
-    run, module, _, _, _ = ready()
-    try:
-        velocity, jets, level_jets = stepper_state(run)
-        if where == "upload":
-            module.cuda.memcpy_htod.side_effect = RuntimeError("upload failed")
-        else:
-            run._stream.synchronize.side_effect = RuntimeError("upload failed")
-        with pytest.raises(RuntimeError, match="upload failed"):
-            run.set_jet_amplitude(0, .017, level=2)
-        np.testing.assert_array_equal(run._level_boundaries[2].tables["surface_velocity"], velocity)
-        assert (run._level_boundaries[2].jets, run._level_jets[2]) == (jets, level_jets)
-        assert run._status == "failed"
-        module.cuda.memcpy_htod.side_effect = None
-        run._stream.synchronize.side_effect = None
-        for call in (lambda: run.set_jet_amplitude(0, .017, level=2), run.step, run.download):
-            with pytest.raises(RuntimeError, match="failed"):
-                call()
-    finally:
-        run.close()
-    assert run._status == "closed"
@@ -188,57 +188,6 @@ def jet_case(device, jets):
    return field, bodies


-def test_public_surface_exchange_for_jet_preserves_aperture_at_zero_and_reverse(device):
-    from CelerisLab.simulation import Simulation
-    jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)
-    field, bodies = jet_case(device, [jet])
-    sim = SimpleNamespace(bodies=bodies, field=field, _initialized=True,
-                          stream=SimpleNamespace(synchronize=device.synchronize))
-    sim._require_usable = Simulation._require_usable.__get__(sim)
-    cl = field.curved
-    assert bodies.get(0).surface_actuation is None
-    aperture, velocity = cl.aperture, cl.surface_velocity.copy()
-    assert aperture.any() and (~aperture).any()
-    # Synthetic per-link exchanges test readback/splitting, not kernel physics.
-    values = np.arange(cl.count * 3, dtype=np.float32).reshape(-1, 3)
-    device.htod(cl.link_exchange_gpu, values)
-    for amplitude in (2e-3, 0., -1e-3):
-        Simulation.set_jet_amplitude(sim, 0, amplitude)
-        result = Simulation.read_surface_exchange(sim, 0)
-        assert cl.aperture is aperture
-        np.testing.assert_array_equal(aperture, cl.jet_id >= 0)
-        np.testing.assert_allclose(cl.surface_velocity, velocity * (amplitude / 2e-3))
-        for name, mask in (("wall", ~aperture), ("aperture", aperture)):
-            np.testing.assert_array_equal(result[name], values[mask].sum(axis=0, dtype=np.float64))
-
-
-def test_public_surface_exchange_keeps_legacy_and_passive_guards(device):
-    from CelerisLab.simulation import Simulation
-    field = make_field(device)
-    bodies = manager(field, [circle(SurfaceActuation(0., .6, .002), radius=2.)])
-    bodies.sync_to_gpu(field)
-    sim = SimpleNamespace(bodies=bodies, field=field,
-                          stream=SimpleNamespace(synchronize=device.synchronize))
-    sim._require_usable = Simulation._require_usable.__get__(sim)
-    for value in Simulation.read_surface_exchange(sim, 0).values():
-        np.testing.assert_array_equal(value, 0.)
-    field.curved.free_gpu_columns()
-    with pytest.raises(RuntimeError, match="diagnostic is allocated"):
-        Simulation.read_surface_exchange(sim, 0)
-
-    # An exchange buffer elsewhere in the scene must not admit a passive body.
-    for jets in ([], [Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER))]):
-        field, bodies = jet_case(device, jets)
-        passive = bodies.add(circle(center=(2., 3.), radius=.6))
-        bodies.sync_to_gpu(field)
-        sim.bodies, sim.field = bodies, field
-        with pytest.raises(ValueError, match="Body has no surface actuation"):
-            Simulation.read_surface_exchange(sim, passive)
-        if not jets:
-            with pytest.raises(ValueError, match="Body has no surface actuation"):
-                Simulation.read_surface_exchange(sim, 0)
-
-
 def test_manager_passes_true_hits_and_reuploads_only_velocity(device):
    # CPU memory double only: checks host/device bookkeeping, not GPU numerics.
    jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)
@@ -15,10 +15,6 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "validation"))
 from run_uniform_les_flow import source_guard, decode_macros, HERE, HEADER

 ROOT = HERE.parents[1]
-sys.path.insert(0, str(ROOT / "tests/unit"))
-from historical_tree import historical_tree, tracked
-
-A135 = "a135252ae78b47b57d7e77d19001700b3bedac8b"


 class GuardTests(unittest.TestCase):
@@ -46,80 +42,52 @@ class GuardTests(unittest.TestCase):
            decode_macros(invalid, w, cx, cy)

    def test_current_corrected_pins(self):
-        with TemporaryDirectory() as directory:
-            root = historical_tree(A135, directory)
-            with patch("run_uniform_les_flow.subprocess.check_output", return_value="historical-tree\n"):
-                identity = source_guard(root, "corrected", "a135252")
-            # base_commit comes from the pins file; the mock only feeds checkout_commit.
-            self.assertEqual(identity["base_commit"], A135)
-            self.assertEqual(identity["checkout_commit"], "historical-tree")
+        self.assertEqual(
+            source_guard(ROOT, "corrected", "dev8403956")["base_commit"],
+            "8403956a9afc0b0bb89265cec374392013d89016",
+        )

    def test_corrected_and_tamper_guard(self):
-        pins = json.loads((HERE / "data/les_flow/source_pins_a135252.json").read_text())
+        pins = json.loads((HERE / "data/les_flow/source_pins_dev8403956.json").read_text())
        with TemporaryDirectory() as directory:
-            origin = historical_tree(A135, Path(directory) / "origin")
-            root = Path(directory) / "fixture"
+            root = Path(directory)
            for name in pins["sources"]:
                dest = root / name
                dest.parent.mkdir(parents=True, exist_ok=True)
-                shutil.copyfile(origin / name, dest)
+                shutil.copyfile(ROOT / name, dest)
            with patch(
                "run_uniform_les_flow.subprocess.check_output",
                return_value="isolated-fixture\n",
            ):
-                source_guard(root, "corrected", "a135252")
+                source_guard(root, "corrected", "dev8403956")
                with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
-                    source_guard(root, "baseline", "a135252")
-                for name in ("kernels/step/one_step_double.cu", "kernels/blocks.cu",
-                             "refinement_stepper.py", "refinement_tables.py"):
-                    target = root / "src/CelerisLab/lbm" / name
-                    original = target.read_bytes()
-                    target.write_bytes(original + b"\n// tamper\n")
-                    with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
-                        source_guard(root, "corrected", "a135252")
-                    target.write_bytes(original)
+                    source_guard(root, "baseline", "dev8403956")
+                target = root / "src/CelerisLab/lbm/kernels/step/one_step_double.cu"
+                target.write_bytes(target.read_bytes() + b"\n// tamper\n")
+                with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
+                    source_guard(root, "corrected", "dev8403956")

    def test_historical_default_and_manifest_unchanged(self):
-        historical = {
-            "historical": ("source_pins.json", "87ca033619da1fc02bee822bfc5681b518a92a155c3c3d1dbbe5265c96066b39"),
-            "dev8403956": ("source_pins_dev8403956.json", "58187908485f2af7c78677d53de98015878372444265ce9e667683b8ef5d410f"),
-        }
-        for experiment, (name, expected) in historical.items():
-            manifest = HERE / "data/les_flow" / name
-            self.assertEqual(hashlib.sha256(manifest.read_bytes()).hexdigest(), expected)
-            for variant in ("baseline", "corrected"):
-                with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
-                    source_guard(ROOT, variant, experiment)
-        with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
-            source_guard(ROOT, "corrected")  # Omission still uses the historical profile.
-
-    def test_current_manifest_pins_actual_corrected_tree(self):
-        pins = json.loads((HERE / "data/les_flow/source_pins_a135252.json").read_text())
-        self.assertEqual(pins["base_commit"], A135)
-        self.assertEqual(set(pins["sources"]), tracked(A135))
-        with TemporaryDirectory() as directory:
-            root = historical_tree(A135, directory)
-            for name, expected in pins["sources"].items():
-                self.assertEqual(hashlib.sha256((root / name).read_bytes()).hexdigest(), expected)
-            self.assertEqual(pins["sources"][HEADER], pins["candidate_header_sha256"])
-            self.assertNotEqual(pins["sources"][HEADER], pins["baseline_header_sha256"])
+        manifest = HERE / "data/les_flow/source_pins.json"
+        self.assertEqual(hashlib.sha256(manifest.read_bytes()).hexdigest(),
+                         "87ca033619da1fc02bee822bfc5681b518a92a155c3c3d1dbbe5265c96066b39")
+        for variant in ("baseline", "corrected"):
            with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
-                source_guard(root, "baseline", "a135252")
+                source_guard(ROOT, variant)

    def test_named_baseline_accepts_only_reversed_header(self):
-        pins = json.loads((HERE / "data/les_flow/source_pins_a135252.json").read_text())
+        pins = json.loads((HERE / "data/les_flow/source_pins_dev8403956.json").read_text())
        with TemporaryDirectory() as directory:
-            origin = historical_tree(A135, Path(directory) / "origin")
-            root = Path(directory) / "fixture"
+            root = Path(directory)
            for name in pins["sources"]:
                dest = root / name
                dest.parent.mkdir(parents=True, exist_ok=True)
-                shutil.copyfile(origin / name, dest)
+                shutil.copyfile(ROOT / name, dest)
            subprocess.run(["git", "apply", "--reverse", str(HERE / "les/data/smagorinsky_normalization.patch")], cwd=root, check=True)
            with patch("run_uniform_les_flow.subprocess.check_output", return_value="baseline-fixture\n"):
-                source_guard(root, "baseline", "a135252")
+                source_guard(root, "baseline", "dev8403956")
                with self.assertRaisesRegex(RuntimeError, "Source pin mismatch"):
-                    source_guard(root, "corrected", "a135252")
+                    source_guard(root, "corrected", "dev8403956")

    def test_gpu_requires_opt_in_before_import(self):
        with TemporaryDirectory() as directory:
@@ -135,6 +135,6 @@ def test_d2_entrypoint_compiles_in_isolation(tmp_path, model, shift, storage):
            source=re.sub(r"(#define\s+"+key+r"\s+)\S+",lambda match: match[1]+str(value),source)
        path.write_text(source)
    result=subprocess.run([nvcc,"-ptx","-arch=sm_70","-std=c++17",
-                           str(copy/"uniform.cu"),"-o",str(tmp_path/"kernel.ptx")],
+                           str(copy/"kernel_v2.cu"),"-o",str(tmp_path/"kernel.ptx")],
                          capture_output=True,text=True)
    assert result.returncode == 0, result.stderr
@@ -9,7 +9,7 @@ import pytest

 import CelerisLab
 from CelerisLab.config import LBMConfig, load_lbm_config
-from CelerisLab.cuda import compiler
+from CelerisLab.cuda import compiler_v2 as compiler
 from CelerisLab.common.checkpoint import save_checkpoint, load_checkpoint
 from .test_numerical_operators import compile_run
 from .test_state_regressions import device, make_field, manager
@@ -18,7 +18,7 @@ from .test_state_regressions import device, make_field, manager
 def test_planar_helper_moments_and_known_populations(tmp_path):
    root = Path(__file__).resolve().parents[2]
    assert Path(CelerisLab.__file__).resolve() == root/'src/CelerisLab/__init__.py'
-    assert Path(compiler.kernel_path('uniform.cu')).resolve() == root/'src/CelerisLab/lbm/kernels/uniform.cu'
+    assert Path(compiler.kernel_path('kernel_v2.cu')).resolve() == root/'src/CelerisLab/lbm/kernels/kernel_v2.cu'
    lines = compile_run(tmp_path, 'planar_velocity.cpp', dict(WALL_NORMAL_VELOCITY='0.0f'))
    cx = np.array([0,1,-1,0,0,1,-1,1,-1])
    cy = np.array([0,0,0,1,-1,1,-1,-1,1])
@@ -1,394 +0,0 @@
-"""CPU stencil and actual closed-interface packet budgets; no CUDA claims."""
-import numpy as np
-import unittest
-from pathlib import Path
-from dataclasses import replace
-import shutil
-import subprocess
-import tempfile
-
-from CelerisLab.config import LBMConfig
-from CelerisLab.lbm.blocks import BlockLayout2D
-from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
-from CelerisLab.lbm.refinement import FixedPatch2D, FixedPatchSet2D, ACTIVE, OUTER_GHOST
-from CelerisLab.lbm.refinement_tables import projected_explosion_tables
-from CelerisLab.lbm.hierarchy import build_hierarchy
-from tests.unit.test_hierarchy import CFG, FOUR
-
-E = np.array([D2Q9_EX, D2Q9_EY]).T
-W = np.array([4/9] + [1/9]*4 + [1/36]*4)
-
-
-def setup(union=False, bounds=(4, 4, 12, 12)):
-    cfg = LBMConfig(nx=16, ny=16, viscosity=.1)
-    p = (FixedPatchSet2D.from_config(cfg, [bounds]) if union else
-         FixedPatch2D.from_config(cfg, bounds))
-    layout = BlockLayout2D.build(16, 16, 4, 4, periodic=(True, True))
-    neighbors, offsets = projected_explosion_tables(p, layout, np.where(p.covered, OUTER_GHOST, ACTIVE))
-    inverse = np.full(layout.nblocks * np.prod(layout.local_shape), -1, dtype=int)
-    inverse[layout.owner.ravel()] = np.arange(256)
-    return p, inverse[neighbors], offsets
-
-
-def reconstruct(c, p, neighbors, offsets, project=True):
-    # Independent NumPy evaluation of the documented stencil; neighbors have
-    # been decoded from actual blocked owner IDs, not recomputed geometry.
-    values = c.reshape(9, -1)[:, neighbors]
-    g = .5 * (values[:, :, 1::2] - values[:, :, ::2])
-    if project:
-        g[1:] -= (np.einsum('qra,qa->qr', g[1:], E[1:]) /
-                  np.sum(E[1:]**2, axis=1)[:, None])[:, :, None] * E[1:, None, :]
-    out = c.reshape(9, -1)[:, p.ghost_coarse] + np.einsum('qra,ra->qr', g, offsets)
-    return out, g
-
-
-def check_legal_footprint_mean_and_characteristic(union, bounds):
-    p, neighbors, offsets = setup(union, bounds)
-    assert set(neighbors.ravel()) <= set(p.ghost_coarse)
-    assert not p.covered.ravel()[neighbors].any()
-    assert (neighbors >= 0).all()
-    c = np.random.default_rng(72).normal(size=(9,16,16))
-    c[:, p.covered] = np.nan  # poison every forbidden donor
-    out, g = reconstruct(c, p, neighbors, offsets)
-    assert np.isfinite(out).all()
-    np.testing.assert_allclose(np.einsum('qra,qa->qr', g, E), 0, atol=5e-16)
-    for d in np.unique(p.ghost_coarse):
-        rows = p.ghost_coarse == d
-        assert rows.sum() == 4
-        np.testing.assert_allclose(out[:, rows].mean(axis=1), c.reshape(9,-1)[:,d], atol=5e-16)
-        for q in range(1,9):
-            delta = offsets[rows, None, :] - offsets[None, rows, :]
-            # Parallel displacements have zero 2D cross product.
-            parallel = np.isclose(delta[...,0]*E[q,1]-delta[...,1]*E[q,0], 0)
-            diff = out[q, rows][:,None]-out[q, rows][None,:]
-            np.testing.assert_allclose(diff[parallel], 0, atol=5e-16)
-    const = np.broadcast_to(W[:,None,None], (9,16,16)).copy()
-    constant, _ = reconstruct(const,p,neighbors,offsets)
-    np.testing.assert_array_equal(constant, np.broadcast_to(W[:,None], constant.shape))
-
-
-def collide(f, tau):
-    rho = f.sum(axis=0)
-    u = np.einsum('qa,q...->a...', E, f) / rho
-    cu = np.einsum('qa,a...->q...', E, u)
-    eq = W[:,None] * rho * (1 + 3*cu + 4.5*cu**2 - 1.5*np.sum(u*u,axis=0))
-    return f + (eq-f)/tau
-
-
-def totals(c, f, p):
-    q = c[:,~p.covered].sum(axis=1)+.25*f[:,p.fine_kind==ACTIVE].sum(axis=1)
-    return np.r_[q.sum(), E.T@q]
-
-
-def check_full_two_hop_closed_corner_budget(union, collision, bounds):
-    p, neighbors, offsets = setup(union,bounds)
-    rng=np.random.default_rng(17)
-    c=W[:,None,None]*(1+rng.normal(0,.002,(9,16,16)))
-    f=W[:,None,None]*(1+rng.normal(0,.002,(9,*p.fine_shape)))
-    start=totals(c,f,p)
-    # Count exactly the eight coarse diagonal links whose source is also
-    # uncovered, but whose midpoint lies on the closed rectangular interface.
-    q, k=np.divmod(p.coalesce_coarse.astype(np.int64),256)
-    y,x=np.divmod(k,16)
-    grazing=~p.covered[y-E[q,1],x-E[q,0]]
-    assert grazing.sum()==8
-    c[:,p.covered]=np.nan
-    for _ in range(8):
-        f.reshape(9,-1)[:,p.ghost_fine]=reconstruct(c,p,neighbors,offsets)[0]
-        for _ in range(2):
-            f=np.array([np.roll(f[q],(ey,ex),(0,1)) for q,(ex,ey) in enumerate(E)])
-            f[:,p.fine_kind==OUTER_GHOST]=np.nan
-            if collision:
-                f[:,p.fine_kind==ACTIVE]=collide(f[:,p.fine_kind==ACTIVE],p.tau_fine)
-        out=np.array([np.roll(c[q],(ey,ex),(0,1)) for q,(ex,ey) in enumerate(E)])
-        packets=f.reshape(-1)[p.coalesce_fine].mean(axis=1)
-        assert np.isfinite(packets[grazing]).all()
-        out.reshape(-1)[p.coalesce_coarse]=packets
-        if collision:out[:,~p.covered]=collide(out[:,~p.covered],p.tau_coarse)
-        out[:,p.covered]=np.nan
-        c=out
-        np.testing.assert_allclose(totals(c,f,p),start,rtol=0,atol=2e-12)
-
-
-def check_projection_is_distinguished_by_characteristic_not_global_mass():
-    p,n,o=setup()
-    c=np.random.default_rng(8).normal(size=(9,16,16))
-    _,g=reconstruct(c,p,n,o,project=False)
-    assert np.max(abs(np.einsum('qra,qa->qr',g,E))) > .1
-
-
-
-
-class ProjectedExplosionTests(unittest.TestCase):
-    def test_stencil(self):
-        for union in (False, True):
-            for bounds in ((4,4,12,12),(2,3,9,10),(2,2,3,3)):
-                with self.subTest(union=union,bounds=bounds):
-                    check_legal_footprint_mean_and_characteristic(union,bounds)
-
-    def test_closed_interface(self):
-        for union in (False,True):
-            for collision in (False,True):
-                for bounds in ((4,4,12,12),(2,3,14,12),(2,2,3,3)):
-                    with self.subTest(union=union,collision=collision,bounds=bounds):
-                        check_full_two_hop_closed_corner_budget(union,collision,bounds)
-
-    def test_projection(self):
-        check_projection_is_distinguished_by_characteristic_not_global_mass()
-
-    def test_affine_and_shift_invariance(self):
-        p,n,o=setup()
-        y,x=np.indices((16,16))
-        c=np.array([.7+q*.01+x*.03+y*.05 for q in range(9)])
-        out,g=reconstruct(c,p,n,o)
-        available=n[:,::2]!=n[:,1::2]
-        gradient=np.array([.03,.05])*available
-        expected=np.broadcast_to(gradient,(9,*gradient.shape)).copy()
-        expected[1:]-=(np.einsum('qra,qa->qr',expected[1:],E[1:])/
-                       np.sum(E[1:]**2,axis=1)[:,None])[:,:,None]*E[1:,None,:]
-        np.testing.assert_allclose(g,expected,atol=2e-16)
-        shifted,_=reconstruct(c-W[:,None,None],p,n,o)
-        np.testing.assert_allclose(out-W[:,None],shifted,atol=5e-16)
-
-
-class ProjectedKernelTests(unittest.TestCase):
-    @unittest.skipUnless(shutil.which("g++"), "g++ is required for actual-kernel CPU arithmetic")
-    def test_actual_kernel_fp32_shifted_and_unshifted(self):
-        p, neighbors, offsets = setup(True)
-        parent = BlockLayout2D.build(16,16,4,4,periodic=(True,True))
-        child = p.fine_layout((8,4))  # deliberately unequal parent/child strides
-        ids, offsets = projected_explosion_tables(p,parent,np.where(p.covered,OUTER_GHOST,ACTIVE))
-        cells = int(np.prod(parent.local_shape))
-        targets = child.owner.ravel()[p.ghost_fine]
-        donors = parent.owner.ravel()[p.ghost_coarse]
-        source = (Path(__file__).resolve().parents[2] /
-                  "src/CelerisLab/lbm/kernels/step/block_transfer.cu").read_text()
-        kernel = source.split('extern "C" __global__ void BlockExplodeProjected(',1)[1]
-        kernel = 'void BlockExplodeProjected(' + kernel.split('// Targets are receiver-local SOURCE slots',1)[0]
-        def array(name, values, kind):
-            v = np.asarray(values).ravel()
-            text = ','.join(str(int(x)) if kind=='uint64_t' else float(x).hex()+'f' for x in v)
-            return f"{kind} {name}[] = {{{text}}};\n"
-        for shifted in (False,True):
-            c=np.random.default_rng(11).normal(0,.001,(9,16,16))
-            if not shifted:c+=W[:,None,None]
-            c=c.astype(np.float32)
-            packed=np.full(parent.nblocks*9*cells,np.nan,np.float32)
-            for q in range(9):packed[parent.slot(parent.owner.ravel(),q)]=c[q].ravel()
-            # All halo/covered inputs are poisoned; kernel must use legal cores.
-            for q in range(9):packed[parent.slot(parent.owner.ravel()[p.covered.ravel()],q)]=np.nan
-            # Hex initializer needs a portable expression for poisoned NaNs.
-            data=array('coarse',packed,'float').replace('nanf','NAN')
-            code = '#include <cstdint>\n#include <cmath>\n#include <cstdio>\nusing fpxx=float;\n'
-            code += f'constexpr unsigned NQ=9, TOTAL_CELLS={int(np.prod(child.local_shape))};\n'
-            code += 'struct Id {unsigned x;}; Id blockIdx{0},blockDim{1},threadIdx{0};\n'
-            code += 'unsigned index_f(unsigned k,unsigned q){return q*TOTAL_CELLS+k;}\n'
-            code += 'int d_cx[]={0,1,-1,0,0,1,-1,1,-1},d_cy[]={0,0,0,1,-1,1,-1,-1,1};\n'+kernel
-            code += data+array('target',targets,'uint64_t')+array('donor',donors,'uint64_t')
-            code += array('neighbor',ids,'uint64_t')+array('offset',offsets,'float')
-            code += f'float fine[{child.nblocks*9*int(np.prod(child.local_shape))}]={{}};\n'
-            code += f'int main(){{for(unsigned r=0;r<{len(targets)};++r){{threadIdx.x=r;BlockExplodeProjected(coarse,fine,target,donor,{len(targets)},{cells},neighbor,offset);}}'
-            code += f'for(unsigned q=0;q<9;++q)for(unsigned r=0;r<{len(targets)};++r){{auto t=target[r];printf("%.9g\\n",fine[(t/TOTAL_CELLS)*9*TOTAL_CELLS+q*TOTAL_CELLS+t%TOTAL_CELLS]);}}}}'
-            with tempfile.TemporaryDirectory() as folder:
-                src=Path(folder)/'kernel.cpp'; binary=Path(folder)/'kernel'
-                src.write_text(code)
-                subprocess.run(['g++','-std=c++17','-O2',str(src),'-o',str(binary)],check=True,capture_output=True)
-                result=np.fromstring(subprocess.check_output([str(binary)],text=True),sep=' ').reshape(9,-1)
-            expected,_=reconstruct(c.astype(float),p,neighbors,offsets)
-            np.testing.assert_allclose(result,expected,atol=6e-8,rtol=2e-7)
-
-
-UNIONS = [
-    [(8, 8, 24, 20)],
-    [(8, 8, 16, 20), (16, 8, 24, 20)],       # abutting
-    [(8, 8, 18, 20), (14, 8, 24, 20)],       # overlap
-    [(8, 8, 16, 20), (17, 8, 24, 20)],       # gap 1
-    [(8, 8, 16, 20), (18, 8, 24, 20)],       # gap 2
-    [(8, 8, 16, 20), (19, 8, 24, 20)],       # gap 3
-    [(8, 8, 20, 14), (8, 14, 14, 22)],       # L concavity
-    [(4, 4, 10, 10), (18, 16, 26, 26)],      # separated
-    [(4, 4, 5, 7), (4, 5, 7, 7)],           # known concave exit/re-entry path
-]
-
-
-def decode(layout, neighbors):
-    inverse = np.full(layout.hole, -1, dtype=int)
-    inverse[layout.owner[layout.owned]] = np.flatnonzero(layout.owned)
-    return inverse[neighbors]
-
-
-def check_pair_stencil(pair, layout, kind):
-    ids, offsets = projected_explosion_tables(pair, layout, kind)
-    neighbors = decode(layout, ids)
-    legal = set(map(int, pair.ghost_coarse))
-    assert len(np.unique(pair.ghost_fine)) == len(pair.ghost_fine)
-    assert set(neighbors.ravel()) <= legal
-    assert layout.owned.ravel()[neighbors].all()
-    assert (kind.ravel()[neighbors] == ACTIVE).all()
-    assert not pair.covered.ravel()[neighbors].any()
-    ny, nx = pair.coarse_shape
-    for row, donor in enumerate(pair.ghost_coarse):
-        y, x = divmod(int(donor), nx)
-        for axis, (dx, dy) in enumerate(((1, 0), (0, 1))):
-            ends = [(x - dx, y - dy), (x + dx, y + dy)]
-            expected = []
-            for xx, yy in ends:
-                outside = not (0 <= xx < nx and 0 <= yy < ny)
-                if outside and not layout.periodic[axis]:
-                    break
-                cell = (yy % ny) * nx + xx % nx
-                if cell not in legal:
-                    break
-                expected.append(cell)
-            if len(expected) != 2:
-                expected = [int(donor)] * 2
-            np.testing.assert_array_equal(neighbors[row, 2*axis:2*axis+2], expected)
-        fy, fx = divmod(int(pair.ghost_fine[row]), pair.fine_shape[1])
-        expected = [pair.fine_origin[0]+(fx+.5)/2-(x+.5),
-                    pair.fine_origin[1]+(fy+.5)/2-(y+.5)]
-        np.testing.assert_array_equal(offsets[row], expected)
-    assert set(offsets.ravel()) == {-.25, .25}
-    assert ids.dtype == np.uint64 and ids.flags.c_contiguous
-    assert offsets.dtype == np.float32 and offsets.flags.c_contiguous
-    return neighbors, offsets
-
-
-class GenericProjectedPairs(unittest.TestCase):
-    def test_single_window_and_singleton_union_exact_stencils(self):
-        for bounds in ((4,4,12,12), (2,3,9,10), (2,2,3,3)):
-            a, an, ao = setup(False, bounds)
-            b, bn, bo = setup(True, bounds)
-            np.testing.assert_array_equal(a.ghost_coarse, b.ghost_coarse)
-            np.testing.assert_array_equal(an, bn)
-            np.testing.assert_array_equal(ao, bo)
-            # Coordinates differ between scalar and union arrays; physical rows don't.
-            ay, ax = np.divmod(a.ghost_fine, a.fine_shape[1])
-            by, bx = np.divmod(b.ghost_fine, b.fine_shape[1])
-            np.testing.assert_array_equal(ax + 2*a.fine_origin[0], bx)
-            np.testing.assert_array_equal(ay + 2*a.fine_origin[1], by)
-
-    def test_union_decomposition_permutation_and_topologies(self):
-        cfg = LBMConfig(nx=30, ny=30, viscosity=.1)
-        layout = BlockLayout2D.build(30,30,6,5,periodic=(True,True))
-        stencils = []
-        for rectangles in UNIONS:
-            pair = FixedPatchSet2D.from_config(cfg, rectangles)
-            kind = np.where(pair.covered, OUTER_GHOST, ACTIVE)
-            n, o = check_pair_stencil(pair, layout, kind)
-            other = FixedPatchSet2D.from_config(cfg, rectangles[::-1])
-            on, oo = projected_explosion_tables(other, layout, kind)
-            np.testing.assert_array_equal(n, decode(layout, on))
-            np.testing.assert_array_equal(o, oo)
-            stencils.append((pair.ghost_fine, pair.ghost_coarse, n, o))
-            c = np.random.default_rng(92).normal(size=(9,30,30))
-            c[:, pair.covered] = np.nan
-            values, gradients = reconstruct(c, pair, n, o)
-            self.assertTrue(np.isfinite(values).all())
-            np.testing.assert_allclose(np.einsum('qra,qa->qr', gradients, E),0,atol=1e-15)
-            # q0 keeps its full gradient; no division by zero or forced zero.
-            expected_q0 = .5*(c[0].ravel()[n[:,1::2]]-c[0].ravel()[n[:,::2]])
-            np.testing.assert_array_equal(gradients[0], expected_q0)
-            self.assertGreater(np.max(abs(gradients[0])), .1)
-            for donor in np.unique(pair.ghost_coarse):
-                rows = pair.ghost_coarse == donor
-                self.assertEqual(rows.sum(),4)
-                np.testing.assert_allclose(values[:,rows].mean(axis=1),c.reshape(9,-1)[:,donor],atol=1e-15)
-                for q in range(1,9):
-                    delta = o[rows,None,:]-o[None,rows,:]
-                    parallel = delta[...,0]*E[q,1] == delta[...,1]*E[q,0]
-                    diff = values[q,rows][:,None]-values[q,rows][None,:]
-                    np.testing.assert_allclose(diff[parallel],0,atol=1e-15)
-        for split in stencils[1:3]:
-            for expected, actual in zip(stencils[0],split):
-                np.testing.assert_array_equal(actual,expected)
-
-    def test_nested_scalar_origins_sparse_holes_and_unequal_strides(self):
-        cases = [(CFG, FOUR), (LBMConfig(nx=16,ny=16,viscosity=.02),
-                               [(4,4,12,12),(8,8,16,16),(8,8,16,16)])]
-        for cfg, refs in cases:
-            hierarchy = build_hierarchy(cfg,refs)
-            for index,pair in enumerate(hierarchy.pairs):
-                if index == 0:
-                    layout = BlockLayout2D.build(cfg.ny,cfg.nx,4,4,periodic=(True,True))
-                else:
-                    prior = hierarchy.pairs[index-1]
-                    layout = (prior.fine_layout((4,8)) if isinstance(prior,FixedPatchSet2D)
-                              else BlockLayout2D.build(*prior.fine_shape,4,8,periodic=(False,False)))
-                kind = hierarchy.kinds[index]
-                n,o = check_pair_stencil(pair,layout,kind)
-                c = np.random.default_rng(index).normal(size=(9,*pair.coarse_shape))
-                c[:,~layout.owned | (kind != ACTIVE)] = np.nan
-                self.assertTrue(np.isfinite(reconstruct(c,pair,n,o)[0]).all())
-                if index and isinstance(pair,FixedPatchSet2D):
-                    self.assertTrue((~layout.owned).any())
-                self.assertEqual(layout.periodic, (index == 0, index == 0))
-
-    def test_periodicity_is_per_axis_and_missing_pairs_repeat_center(self):
-        cfg=LBMConfig(nx=16,ny=16,viscosity=.1)
-        p=FixedPatch2D.from_config(cfg,(2,2,14,14))
-        kind=np.where(p.covered,OUTER_GHOST,ACTIVE)
-        results=[]
-        for periodic in ((False,False),(True,False),(False,True),(True,True)):
-            layout=BlockLayout2D.build(16,16,4,4,periodic=periodic)
-            n,_=check_pair_stencil(p,layout,kind)
-            results.append(n)
-            y,x=np.divmod(p.ghost_coarse,16)
-            for axis,coordinate in enumerate((x,y)):
-                edge=(coordinate==0)|(coordinate==15)
-                if not periodic[axis]:
-                    np.testing.assert_array_equal(n[edge,2*axis:2*axis+2],
-                        np.repeat(p.ghost_coarse[edge,None],2,axis=1))
-        self.assertTrue((results[0]!=results[1]).any())
-        self.assertTrue((results[0]!=results[2]).any())
-        self.assertTrue((results[1]!=results[3]).any())
-
-    def test_invalid_parent_donors_reject_before_owner_lookup(self):
-        p,_,_=setup()
-        layout=BlockLayout2D.build(16,16,4,4)
-        kind=np.where(p.covered,OUTER_GHOST,ACTIVE)
-        for nonactive in (1,2,255):
-            bad=kind.copy(); bad.ravel()[p.ghost_coarse[0]]=nonactive
-            with self.assertRaisesRegex(ValueError,'ACTIVE'):
-                projected_explosion_tables(p,layout,bad)
-        with self.assertRaisesRegex(ValueError,'shape'):
-            projected_explosion_tables(p,layout,kind[:1])
-        hole_layout=BlockLayout2D.build(16,16,4,4,origins=[(0,0)])
-        with self.assertRaisesRegex(ValueError,'owned'):
-            projected_explosion_tables(p,hole_layout,kind)
-
-    def test_generic_two_hop_mass_and_momentum_budget(self):
-        cfg=LBMConfig(nx=30,ny=30,viscosity=.1)
-        layout=BlockLayout2D.build(30,30,6,5)
-        grazing_counts=set()
-        for rectangles in UNIONS:
-            pair=FixedPatchSet2D.from_config(cfg,rectangles)
-            ids,o=projected_explosion_tables(pair,layout,np.where(pair.covered,OUTER_GHOST,ACTIVE))
-            n=decode(layout,ids)
-            q,k=np.divmod(pair.coalesce_coarse.astype(np.int64),900)
-            y,x=np.divmod(k,30)
-            grazing=~pair.covered[(y-E[q,1])%30,(x-E[q,0])%30]
-            grazing_counts.add(int(grazing.sum()))
-            self.assertTrue(grazing.any())
-            for collision in (False,True):
-                rng=np.random.default_rng(17)
-                c=W[:,None,None]*(1+rng.normal(0,.002,(9,30,30)))
-                f=W[:,None,None]*(1+rng.normal(0,.002,(9,*pair.fine_shape)))
-                start=totals(c,f,pair)
-                c[:,pair.covered]=np.nan
-                for _ in range(4):
-                    f.reshape(9,-1)[:,pair.ghost_fine]=reconstruct(c,pair,n,o)[0]
-                    for _ in range(2):
-                        f=np.array([np.roll(f[q],(ey,ex),(0,1)) for q,(ex,ey) in enumerate(E)])
-                        f[:,pair.fine_kind==OUTER_GHOST]=np.nan
-                        if collision:
-                            f[:,pair.fine_kind==ACTIVE]=collide(f[:,pair.fine_kind==ACTIVE],pair.tau_fine)
-                    out=np.array([np.roll(c[q],(ey,ex),(0,1)) for q,(ex,ey) in enumerate(E)])
-                    packets=f.reshape(-1)[pair.coalesce_fine].mean(axis=1)
-                    self.assertTrue(np.isfinite(packets[grazing]).all())
-                    out.reshape(-1)[pair.coalesce_coarse]=packets
-                    if collision:
-                        out[:,~pair.covered]=collide(out[:,~pair.covered],pair.tau_coarse)
-                    out[:,pair.covered]=np.nan
-                    c=out
-                    np.testing.assert_allclose(totals(c,f,pair),start,rtol=0,atol=4e-12)
-        self.assertGreater(len(grazing_counts),1)  # not a hard-coded eight-corner oracle
@@ -1,162 +0,0 @@
-"""Host-only checks for the opt-in CUDA gate; never imports or compiles CUDA."""
-from copy import deepcopy
-import importlib.util
-from pathlib import Path
-import unittest
-from unittest.mock import patch
-
-import numpy as np
-
-from CelerisLab.config import LBMConfig
-from CelerisLab.lbm.blocks import BlockLayout2D
-from CelerisLab.lbm.hierarchy import build_hierarchy
-from CelerisLab.lbm.refinement import ACTIVE, OUTER_GHOST, FixedPatch2D, FixedPatchSet2D
-from CelerisLab.lbm.refinement_tables import projected_explosion_tables
-from tests.unit.test_hierarchy import CFG, FOUR
-from tests.unit.test_projected_explosion import decode, reconstruct, totals
-
-PATH = Path(__file__).resolve().parents[1] / 'validation/multigrid/check_projected_pairs.py'
-spec = importlib.util.spec_from_file_location('projected_pair_gate', PATH)
-gate = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(gate)
-
-
-class ProjectedGateOracle(unittest.TestCase):
-    def check_pair(self, pair, layout, kind):
-        ids, offsets = projected_explosion_tables(pair, layout, kind)
-        neighbors = decode(layout, ids)
-        coarse = np.random.default_rng(731).normal(size=(9, *pair.coarse_shape))
-        legal = np.zeros(pair.coarse_shape, bool)
-        legal.ravel()[pair.ghost_coarse] = True
-        coarse[:, ~legal] = np.nan
-        expected, _ = reconstruct(coarse, pair, neighbors, offsets)
-        # The coordinate oracle must not accidentally share production tables.
-        with patch('CelerisLab.lbm.refinement_tables.projected_explosion_tables',
-                   side_effect=AssertionError('oracle used production stencil')):
-            actual = gate.independent_explosion(coarse, pair, layout, kind)
-        np.testing.assert_allclose(actual, expected, rtol=0, atol=2e-15)
-        center = coarse.reshape(9, -1)[:, pair.ghost_coarse]
-        self.assertTrue(np.isfinite(actual).all())
-        self.assertGreater(np.max(abs(actual[0] - center[0])), .01)
-        self.assertGreater(np.max(abs(actual[1:] - center[1:])), .01)
-        return coarse, neighbors, offsets, actual
-
-    def test_scalar_union_nested_sparse_and_unequal_strides(self):
-        def fine_layout(pair, block):
-            return (pair.fine_layout(block) if isinstance(pair, FixedPatchSet2D) else
-                    BlockLayout2D.build(*pair.fine_shape, *block, periodic=(False,False)))
-        small = LBMConfig(nx=16, ny=16, viscosity=.02)
-        fixtures = [(small, [(4,4,12,12), (8,8,16,16), (8,8,16,16)]),
-                    (CFG, FOUR), (small, [[(4,4,5,7), (4,5,7,7)]])]
-        for cfg, refs in fixtures:
-            hierarchy = build_hierarchy(cfg, refs)
-            for index, pair in enumerate(hierarchy.pairs):
-                block, child_block = ((4,4), (4,8)) if index % 2 == 0 else ((4,8), (4,4))
-                layout = (BlockLayout2D.build(cfg.ny, cfg.nx, *block) if index == 0
-                          else fine_layout(hierarchy.pairs[index-1], block))
-                with self.subTest(refs=refs, pair=index):
-                    self.assertNotEqual(np.prod(layout.local_shape),
-                                        np.prod(fine_layout(pair, child_block).local_shape))
-                    if index and isinstance(pair, FixedPatchSet2D):
-                        self.assertTrue((~layout.owned).any())
-                    self.check_pair(pair, layout, hierarchy.kinds[index])
-
-    def test_axis_periodicity_and_mean_preserving_mutants(self):
-        pair = FixedPatch2D.from_config(LBMConfig(nx=16,ny=16,viscosity=.1), (2,2,14,14))
-        kind = np.where(pair.covered, OUTER_GHOST, ACTIVE)
-        outputs = []
-        for periodic in ((False,False), (True,False), (False,True), (True,True)):
-            layout = BlockLayout2D.build(16,16,4,4,periodic=periodic)
-            coarse, neighbors, offsets, actual = self.check_pair(pair, layout, kind)
-            outputs.append(actual)
-            donors, first, inverse = np.unique(pair.ghost_coarse, return_index=True, return_inverse=True)
-            wrong = neighbors[first[np.roll(np.arange(len(donors)), 1)]][inverse]
-            for bad_neighbors, bad_offsets in ((neighbors, -offsets), (wrong, offsets)):
-                mutant, _ = reconstruct(coarse, pair, bad_neighbors, bad_offsets)
-                self.assertGreater(np.max(abs(mutant - actual)), .01)
-                for donor in donors:
-                    rows = pair.ghost_coarse == donor
-                    self.assertEqual(rows.sum(), 4)
-                    np.testing.assert_allclose(mutant[:,rows].mean(axis=1),
-                                               coarse.reshape(9,-1)[:,donor], rtol=0, atol=1e-15)
-            bad_kind = kind.copy(); bad_kind.ravel()[pair.ghost_coarse[0]] = OUTER_GHOST
-            with self.assertRaisesRegex(AssertionError, 'illegal center donor'):
-                gate.independent_explosion(coarse, pair, layout, bad_kind)
-        for i, j in ((0,1), (0,2), (1,3), (2,3)):
-            self.assertGreater(np.max(abs(outputs[i] - outputs[j])), .01)
-
-    def test_concave_replay_preserves_existing_fp64_budget(self):
-        cfg, refs, blocks = gate.cases()['concave']
-        hierarchy = build_hierarchy(cfg, refs); pair = hierarchy.pairs[0]
-        layout = BlockLayout2D.build(cfg.ny, cfg.nx, *blocks[0])
-        rng = np.random.default_rng(17)
-        values = tuple(gate.W[:,None,None] * (1 + rng.normal(0,.002,(9,*shape)))
-                       for shape in (pair.coarse_shape, pair.fine_shape))
-        start = totals(*values, pair)
-        values[0][:,pair.covered] = np.nan
-        for _ in range(8):
-            values = gate.replay_two_hops(values, pair, layout, hierarchy.kinds[0])
-            np.testing.assert_allclose(totals(*values, pair), start, rtol=0, atol=4e-12)
-        self.assertEqual(gate.REPLAY_ATOL, 3e-6)  # CUDA replay bound is separate.
-
-
-class ProjectedGateReceipts(unittest.TestCase):
-    def test_digest_exact_finite_bits_and_nan_masks(self):
-        values = np.array([0., -0., np.nan, 1.], dtype=np.float32)
-        self.assertEqual(gate.digest(values), gate.digest(values.copy()))
-        payload = values.copy(); payload.view(np.uint32)[2] = 0x7fc00001
-        self.assertEqual(gate.digest(values), gate.digest(payload))
-        variants = [np.array([-0., -0., np.nan, 1.], np.float32),
-                    np.array([0., np.nan, -0., 1.], np.float32),
-                    np.array([0., -0., np.nan, np.nextafter(np.float32(1), np.float32(2))], np.float32),
-                    values.reshape(2,2), values.astype(np.float64)]
-        for changed in variants:
-            self.assertNotEqual(gate.digest(values), gate.digest(changed))
-        with self.assertRaisesRegex(AssertionError, 'infinite'):
-            gate.digest(np.array([np.inf]))
-
-    def test_snapshot_negative_controls_and_exact_dev_options(self):
-        snapshot = [dict(step=0, levels=[dict(raw='raw',public='public',active=4)],
-                         mass_momentum=[1.,0.,0.],observed_level_hops=[0,0])]
-        gate.compare_snapshots(snapshot, deepcopy(snapshot))
-        diagnostic = deepcopy(snapshot); diagnostic[0]['mass_momentum'][0] = 2.
-        gate.compare_snapshots(snapshot, diagnostic)  # Diagnostics are not bitwise gate fields.
-        mutants = [[]]
-        for key, value in (('raw','changed'), ('public','changed'), ('active',3)):
-            changed = deepcopy(snapshot); changed[0]['levels'][0][key] = value
-            mutants.append(changed)
-        changed = deepcopy(snapshot); changed[0]['step'] = 1; mutants.append(changed)
-        changed = deepcopy(snapshot); changed[0]['observed_level_hops'] = [0,1]; mutants.append(changed)
-        for changed in mutants:
-            with self.assertRaises(AssertionError):
-                gate.compare_snapshots(snapshot, changed)
-        self.assertEqual(gate.default_options('omitted'), {})
-        self.assertEqual(gate.default_options('constant'), {'explosion':'constant'})
-        self.assertEqual(gate.default_options('projected_linear'), {'explosion':'projected_linear'})
-
-    def test_baseline_receipt_rejects_provenance_and_contract_mutants(self):
-        keys = [f'{name}:shifted={shifted}' for name in gate.cases() for shifted in (False,True)]
-        good = dict(completed=True,dry_run=False,mode='baseline',production_revision=gate.BASE,
-                    source=dict(revision=gate.BASE,dirty=False),driver_sha256='driver',
-                    stops=list(gate.STOPS),operator_tolerance=[6e-8,2e-7],
-                    rest_tolerance=[3e-7,1e-6],replay_tolerance=[3e-6,0],default_snapshots=dict.fromkeys(keys, []),
-                    actual_build_sidecars=[{'ptx_sha256':'captured'}])
-        self.assertIs(gate.baseline_receipt(good, 'driver', keys), good)
-        mutants = dict(completed=False,dry_run=True,mode='candidate',production_revision='wrong',
-                       driver_sha256='wrong',stops=[0,1,2],operator_tolerance=[1e-6,2e-7],
-                       rest_tolerance=[3e-7,1e-5],replay_tolerance=[3e-6,1e-7],actual_build_sidecars=[],default_snapshots={})
-        for field, value in mutants.items():
-            bad = deepcopy(good); bad[field] = value
-            with self.subTest(field=field), self.assertRaises(ValueError):
-                gate.baseline_receipt(bad, 'driver', keys)
-        for changes in (dict(revision='wrong'), dict(dirty=True), dict(dirty=None)):
-            bad = deepcopy(good); bad['source'].update(changes)
-            with self.assertRaises(ValueError):
-                gate.baseline_receipt(bad, 'driver', keys)
-        bad = deepcopy(good); bad['default_snapshots']['unexpected'] = []
-        with self.assertRaises(ValueError):
-            gate.baseline_receipt(bad, 'driver', keys)
-
-
-if __name__ == '__main__':
-    unittest.main()
@@ -1,196 +0,0 @@
-"""Production host dispatch with CUDA doubles; no CUDA compilation or flow runs."""
-from contextlib import nullcontext
-from dataclasses import replace
-from unittest.mock import Mock
-import unittest
-
-import numpy as np
-
-from CelerisLab.config import LBMConfig
-from tests.unit.test_hierarchy import CFG, FOUR
-from tests.unit.test_refinement_three_level_multipatch import host_module
-
-
-def backend(**options):
-    host = host_module()
-    calls, allocations, storage = [], [], {}
-    context = Mock(activate=nullcontext, sm_arch='sm_70')
-    host.cuda.mem_alloc.side_effect = lambda size: allocate(size)
-
-    def allocate(size):
-        pointer = Mock(name=f'buffer{len(allocations)}', size=size)
-        allocations.append(pointer)
-        return pointer
-
-    def load(_):
-        module = Mock()
-        module.get_global.return_value = (Mock(), 20)
-        module.get_function.side_effect = lambda name: Mock(
-            name=name, side_effect=lambda *a, **kw: calls.append((name, a, kw)))
-        return module
-
-    host.compiler.build_module.side_effect = lambda *a, **k: load(None)
-    host.cuda.memcpy_htod.side_effect = lambda ptr, a: storage.__setitem__(id(ptr), np.array(a, copy=True))
-    host.cuda.memcpy_dtoh.side_effect = lambda a, ptr: np.copyto(a, storage[id(ptr)])
-    cfg = options.pop('cfg', CFG)
-    refinements = options.pop('refinements', FOUR)
-    blocks = options.pop('level_blocks', [(4, 4)] * (len(refinements) + 1))
-    run = host.FixedPatchStepper(cfg, context=context, refinements=refinements,
-                                level_blocks=blocks, **options)
-    run.initialize(*(np.full(level.shape, 1/9, np.float32) for level in run._levels))
-    return run, host, calls, allocations, storage
-
-
-def trace(run, calls, allocations, storage):
-    """Stable pointer identities expose allocations/arguments, not just kernel names."""
-    pointer = {id(value): index for index, value in enumerate(allocations)}
-    launches = [(name, tuple(('ptr', pointer[id(a)]) if id(a) in pointer else int(a)
-                            for a in args), kw['grid'], kw['block'])
-                for name, args, kw in calls]
-    uploads = [(index, value.dtype.str, value.shape, value.tobytes())
-               for index, ptr in enumerate(allocations) if (value := storage.get(id(ptr))) is not None]
-    return [p.size for p in allocations], uploads, launches
-
-
-class ProjectedPairDispatch(unittest.TestCase):
-    def test_omitted_and_constant_have_identical_allocations_uploads_and_launches(self):
-        results = []
-        for options in ({}, {'explosion': 'constant'}):
-            run, host, calls, allocations, storage = backend(**options)
-            self.assertEqual(run._explosion, 'constant')
-            self.assertTrue(all(p.neighbors is None and p.offsets is None for p in run._pairs))
-            run.step()
-            explosion = [args for name, args, _ in calls if name == 'BlockExplode']
-            self.assertEqual(len(explosion), 7)
-            self.assertTrue(all(len(args) == 6 for args in explosion))
-            self.assertFalse(any(name == 'BlockExplodeProjected' for name, _, _ in calls))
-            results.append(trace(run, calls, allocations, storage))
-            run.close()
-        self.assertEqual(*results)
-
-    def test_projected_adds_exactly_two_tables_per_adjacent_pair(self):
-        for depth in (2, 3, 4):
-            constant, _, _, ca, _ = backend(refinements=FOUR[:depth-1])
-            projected, _, calls, pa, storage = backend(
-                refinements=FOUR[:depth-1], explosion='projected_linear')
-            self.assertEqual(len(pa)-len(ca), 2*(depth-1))
-            for pair, geometry in zip(projected._pairs, projected.hierarchy.pairs):
-                self.assertEqual(storage[id(pair.neighbors)].shape, (len(geometry.ghost_fine), 4))
-                self.assertEqual(storage[id(pair.offsets)].shape, (len(geometry.ghost_fine), 2))
-                self.assertEqual(pair.neighbors.size, len(geometry.ghost_fine)*4*8)
-                self.assertEqual(pair.offsets.size, len(geometry.ghost_fine)*2*4)
-            projected.step()
-            explosions = [args for name, args, _ in calls if name == 'BlockExplodeProjected']
-            self.assertEqual(len(explosions), 2**(depth-1)-1)
-            self.assertTrue(all(len(args) == 8 for args in explosions))
-            self.assertFalse(any(name == 'BlockExplode' for name, _, _ in calls))
-            for args in explosions:
-                pair = next(p for p in projected._pairs if args[2] is p.ghosts)
-                self.assertIs(args[6], pair.neighbors)
-                self.assertIs(args[7], pair.offsets)
-                self.assertEqual(args[5], pair.parent_cells)
-            constant.close(); projected.close()
-
-    def test_three_and_four_level_schedule_has_fresh_midpoint_sources(self):
-        for depth in (3, 4):
-            for explosion in ('constant', 'projected_linear'):
-                run, host, calls, allocations, storage = backend(
-                    refinements=FOUR[:depth-1], explosion=explosion)
-                before = len(allocations)
-                events = []
-                for index, pair in enumerate(run._pairs):
-                    pair.explode.side_effect = lambda source, *a, index=index, **kw: events.append(('explode', index, source))
-                    pair.coalesce.side_effect = lambda child, source, *a, index=index, **kw: events.append(('restrict', index, source))
-                for index, level in enumerate(run._levels):
-                    level.kernel.side_effect = lambda source, *a, index=index, **kw: events.append(('step', index, source))
-                    level.halo_copy.side_effect = lambda source, *a, index=index, **kw: events.append(('halo', index, source))
-                expected = []
-
-                def hop(index, source):
-                    if index+1 < depth:
-                        expected.append(('explode', index, source))
-                        child = run._levels[index+1]
-                        hop(index+1, child.current)
-                        hop(index+1, child.spare)
-                    expected.append(('halo', index, source))
-                    if index+1 < depth:
-                        expected.append(('restrict', index, source))
-                    expected.append(('step', index, source))
-
-                hop(0, run._levels[0].current)
-                run.step()
-                self.assertEqual(events, expected)
-                self.assertEqual([level.kernel.call_count for level in run._levels], [2**i for i in range(depth)])
-                self.assertEqual(len(allocations), before)
-                self.assertEqual(run.step_count, 1)
-                for index in range(1, depth-1):
-                    feeds = [source for name, pair, source in events if name == 'explode' and pair == index]
-                    self.assertEqual(feeds, [run._levels[index].current, run._levels[index].spare] * (2**(index-1)))
-                run.close()
-
-    def test_scalar_windows_follow_the_same_pair_path(self):
-        run, _, _, _, _ = backend(cfg=LBMConfig(nx=16,ny=16,viscosity=.02),
-            refinements=[(4,4,12,12),(8,8,16,16),(8,8,16,16)],
-            level_blocks=[(4,4),(4,8),(8,4),(4,4)], explosion='projected_linear')
-        self.assertTrue(all(pair.neighbors is not None for pair in run._pairs))
-        self.assertEqual([pair.parent_cells for pair in run._pairs], [36,60,60])
-        run.step()
-        self.assertEqual([level.kernel.call_count for level in run._levels], [1,2,4,8])
-        run.close()
-
-    def test_physics_gate_precedes_context_and_allocations(self):
-        host = host_module()
-        context = Mock()
-        options = dict(refinements=FOUR[:1], level_blocks=[(4,4)]*2,
-                       explosion='projected_linear', context=context)
-        for cfg, changes in [(CFG, {'explosion':'unknown'}),
-                             (CFG, {'coarse_boundary':'slot_reservoir'}),
-                             (CFG, {'coarse_boundary':'channel'}),
-                             (CFG, {'level_objects':[(),(object(),)]}),
-                             (CFG, {'level_jets':[(),(object(),)]}),
-                             (replace(CFG,collision='MRT'), {}),
-                             (replace(CFG,les_enabled=True), {})]:
-            with self.subTest(changes=changes, cfg=cfg), self.assertRaisesRegex(ValueError,'explosion'):
-                host.FixedPatchStepper(cfg, **dict(options, **changes))
-        context.activate.assert_not_called()
-        host.cuda.mem_alloc.assert_not_called()
-        # The constant path still allows MRT.
-        for options in ({'cfg':replace(CFG,collision='MRT')},):
-            run, _, _, _, _ = backend(**options)
-            run.close()
-
-    def test_remap_preserves_selector_tables_and_constant_default(self):
-        for explosion in ('constant','projected_linear'):
-            run, host, _, _, storage = backend(refinements=FOUR[:2], explosion=explosion)
-            run._step_count = 7
-            old = run.download()
-            clone = run.remap_child(FOUR[1])
-            self.assertEqual(clone._explosion, explosion)
-            self.assertEqual(clone.step_count, 7)
-            for pair in clone._pairs:
-                self.assertEqual(pair.neighbors is None, explosion == 'constant')
-            for expected, actual in zip(old, clone.download()):
-                np.testing.assert_array_equal(actual,expected)
-            clone.step()
-            self.assertEqual((run.step_count,clone.step_count), (7,8))
-            clone.close(); run.close()
-
-    def test_changed_remap_geometry_keeps_projected_in_both_representations(self):
-        changed = [(22,22,42,42), (72,68,76,76)]
-        for shifted in (False, True):
-            run, _, _, _, _ = backend(cfg=replace(CFG,ddf_shifting=shifted),
-                refinements=FOUR[:2], explosion='projected_linear')
-            run._step_count = 3
-            before = run.download()
-            clone = run.remap_child(changed)
-            self.assertEqual(clone._explosion, 'projected_linear')
-            self.assertEqual(clone.hierarchy.pairs[1].bounds, tuple(changed))
-            self.assertNotEqual(clone._pairs[1].n_ghosts, run._pairs[1].n_ghosts)
-            for old, new in zip(run._pairs, clone._pairs):
-                self.assertIsNot(old.neighbors, new.neighbors)
-                self.assertIsNotNone(new.neighbors)
-            for expected, actual in zip(before, run.download()):
-                np.testing.assert_array_equal(actual, expected)
-            clone.step()
-            self.assertEqual((run.step_count, clone.step_count), (3, 4))
-            clone.close(); run.close()
@@ -25,7 +25,7 @@ def backend(observe=True, obj=None):
    module = Mock()
    module.get_global.return_value = (Mock(), 20)
    module.get_function.side_effect = lambda name: Mock(side_effect=lambda *a, **k: calls.append((name, a, k)))
-    host.compiler.build_module.return_value = module
+    host.compiler.load_module.return_value = module
    host.cuda.mem_alloc.side_effect = lambda n: Mock(size=n)
    host.cuda.memcpy_dtoh.side_effect = lambda array, pointer: array.fill(0)
    ctx = Mock(activate=nullcontext, sm_arch='sm_70')
@@ -153,6 +153,14 @@ class RawExchange(unittest.TestCase):
        run._stream.synchronize.side_effect = None
        run.close()

+    def test_dense_observation_rejected_before_device_access(self):
+        host = host_module()
+        ctx = Mock()
+        with self.assertRaisesRegex(ValueError, 'blocked body'):
+            host.FixedPatchStepper(LBMConfig(nx=32, ny=32, viscosity=.1), (4, 4, 28, 28),
+                                   context=ctx, fine_objects=[body(radius=2.15)], observe_raw_exchange=True)
+        ctx.activate.assert_not_called()
+
    def test_all_depth_weights(self):
        for level in (1, 2, 3, 7):
            self._check_weights_split_and_window(level)
@@ -5,7 +5,6 @@ import pytest

 ROOT = Path(__file__).resolve().parents[2]
 sys.path.insert(0, str(ROOT / "tests/validation"))
-sys.path.insert(0, str(ROOT / "tests/unit"))
 import re100_helpers as h
 import periodic as p

@@ -63,16 +62,13 @@ def test_periodic_synthetic():
    assert not p.assess(rows()[:100])["periodic"]


-def test_production_unmodified(tmp_path):
-    from historical_tree import historical_tree
-
+def test_production_unmodified():
    m = json.loads(
        (ROOT / "tests/validation/data/dfg_re100/source_manifest.json").read_text()
    )
    assert m["commit"] == h.PIN
-    origin = historical_tree(m["commit"], tmp_path)
    for name, digest in m["production_sha256"].items():
-        assert hashlib.sha256((origin / name).read_bytes()).hexdigest() == digest, name
+        assert hashlib.sha256((ROOT / name).read_bytes()).hexdigest() == digest, name


 def test_reference():
@@ -7,10 +7,7 @@ import numpy as np
 import unittest

 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "validation"))
-sys.path.insert(0, str(Path(__file__).resolve().parent))
 import run_refined_dfg as r
-from historical_tree import historical_tree
-from tempfile import TemporaryDirectory

 h, periodic = r.helpers(r.DEFAULT_SOURCE)

@@ -20,24 +17,11 @@ def test_source_pin():
    assert historical["commit"].startswith("cd3a657")
    mrt_history = json.loads((r.HERE / "data/refined_dfg/source_manifest_mrt.json").read_text())
    assert mrt_history["commit"].startswith("3ea131e")
-    with unittest.TestCase().assertRaisesRegex(RuntimeError, "Source mismatch"):
-        r.verify_source(r.DEFAULT_SOURCE, "MRT", "window")
+    assert r.verify_source(r.DEFAULT_SOURCE, "MRT", "window")["commit"].startswith("a233c90")
    with unittest.TestCase().assertRaisesRegex(RuntimeError, "Source mismatch"):
        r.verify_source(r.DEFAULT_SOURCE, "MRT")
    with unittest.TestCase().assertRaisesRegex(RuntimeError, "Source mismatch"):
        r.verify_source(r.DEFAULT_SOURCE, "SRT")
-    with TemporaryDirectory() as directory:
-        for collision, mode, prefix in (
-            ("SRT", "last_base_step", "cd3a657"),
-            ("MRT", "last_base_step", "3ea131e"),
-            ("MRT", "window", "a233c90"),
-        ):
-            name = {"SRT": "source_manifest.json", "MRT": "source_manifest_mrt.json"}[collision]
-            name = "source_manifest_window.json" if mode == "window" else name
-            commit = json.loads((r.HERE / "data/refined_dfg" / name).read_text())["commit"]
-            assert commit.startswith(prefix)
-            root = historical_tree(commit, Path(directory) / commit)
-            assert r.verify_source(root, collision, mode)["commit"] == commit


 def test_matched_units_and_planes():
@@ -157,47 +141,28 @@ def test_axis_specific_sampling_phase():
    np.testing.assert_allclose(fine_y - ((k + 43) - 0.5) * 0.00125, 0, atol=1e-15)


-def frozen_manifest(observation_mode):
-    """Frozen MRT manifest JSON as recorded, without hashing the working tree."""
-    name = "source_manifest_window.json" if observation_mode == "window" else "source_manifest_mrt.json"
-    return json.loads((r.HERE / "data/refined_dfg" / name).read_text())
-
-
-def selected_manifest(collision, observation_mode):
-    """The frozen manifest verify_source selects for (collision, observation_mode).
-
-    Source identity is owned by test_source_pin; this reads no checkout files.
-    """
-    return r.source_manifest(collision, observation_mode)
-
-
 def test_full_requires_completed_pilot():
    with unittest.TestCase().assertRaisesRegex(ValueError, "pilot-results"):
-        r.verify_pilot(None, frozen_manifest("window"))
+        r.verify_pilot(None, r.verify_source(r.DEFAULT_SOURCE, "MRT", "window"))


-def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_selection="both", uniform_diameter=80, placement="wide"):
+def pilot_fixture(path, observation_mode="window"):
    """Synthetic contract fixture only; never a physical result or run receipt."""
-    # Receipt-logic fixture: the frozen manifest verify_source returns for a matching tree.
-    # Source identity itself is checked only by test_source_pin.
-    manifest = (r.verify_source(r.DEFAULT_SOURCE, "MRT", "window", jet_scenario)
-                if observation_mode == "window" and jet_scenario != "none" else
-                frozen_manifest(observation_mode))
-    selection = dict(case_selection=case_selection, uniform_diameter=uniform_diameter, placement=placement)
+    manifest = (r.verify_source(r.DEFAULT_SOURCE, "MRT", "window")
+                if observation_mode == "window" else
+                json.loads((r.HERE / "data/refined_dfg/source_manifest_mrt.json").read_text()))
    (path / "plan.json").write_text(
        json.dumps(
            dict(
                source_manifest=manifest,
-                **selection,
                collision="MRT",
-                jet_scenario=jet_scenario,
                observation_mode=observation_mode,
-                bounds_root_edge=list(r.PLACEMENTS[placement]),
+                bounds_root_edge=list(r.BOUNDS),
                runner_sha256=r.runner_hash(),
            )
        )
    )
-    for case, diameter in r.selected_cases(case_selection, uniform_diameter):
+    for case, diameter in (("uniform", 80), ("refined", 40)):
        dest = path / case
        dest.mkdir()
        interval = round(0.02 * diameter / r.SPEED)
@@ -224,9 +189,7 @@ def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_sel
            json.dumps(
                dict(
                    case=case,
-                    **selection,
                    collision="MRT",
-                    jet_scenario=jet_scenario,
                    observation_mode=observation_mode,
                    mode="pilot",
                    status="pilot_complete",
@@ -243,9 +206,7 @@ def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_sel
            json.dumps(
                dict(
                    case=case,
-                    **selection,
                    collision="MRT",
-                    jet_scenario=jet_scenario,
                    observation_mode=observation_mode,
                    mode="pilot",
                    step=interval,
@@ -380,7 +341,7 @@ def test_record_actual_checkout_separately():
    actual = checkout_provenance(r.DEFAULT_SOURCE)
    assert len(actual["checkout_revision"]) == 40
    assert isinstance(actual["checkout_dirty"], bool)
-    assert selected_manifest("MRT", "window")["production_origin_commit"].startswith("d930")
+    assert r.verify_source(r.DEFAULT_SOURCE, "MRT", "window")["production_origin_commit"].startswith("d930")


 def test_window_plan_preserves_physics():
@@ -390,7 +351,7 @@ def test_window_plan_preserves_physics():
        assert baseline.pop("observation_mode") == "last_base_step"
        assert window.pop("observation_mode") == "window"
        assert baseline == window
-        assert selected_manifest(collision, "window")["observation_mode"] == "window"
+        assert r.verify_source(r.DEFAULT_SOURCE, collision, "window")["observation_mode"] == "window"
    with unittest.TestCase().assertRaises(ValueError):
        r.verify_source(r.DEFAULT_SOURCE, "MRT", "unknown")

@@ -490,169 +451,6 @@ def test_window_contract_rejection():
    assert not backend.events


-def test_public_jet_configuration_and_geometry():
-    for diameter, center, radius in ((40, (80.5, 81), 20), (80, (160, 160.5), 40)):
-        cfg, _, _ = r.config(h, diameter, "MRT", "fixed")
-        assert not cfg["method"]["ddf_shifting"] and not cfg["method"]["les"]["enabled"]
-        jets = r.public_jets(center, radius, "fixed")
-        assert [j.amplitude for j in jets] == [.001, -.001]
-        assert all(j.field.inward is False and j.profile == "parabolic" for j in jets)
-        assert all(j.region.r_max == radius * 1.005 for j in jets)
-        assert all(j.amplitude == 0 for j in r.public_jets(center, radius, "zero"))
-    cfg, _, _, host = r.host_geometry(r.DEFAULT_SOURCE, h, "MRT", "fixed")
-    assert not cfg.ddf_shifting and len(host.boundary_cells) > 0
-    assert r.public_jets((0, 0), 1, "none") == ()
-    with unittest.TestCase().assertRaises(ValueError):
-        r.config(h, 40, "SRT", "fixed")
-
-
-def test_public_jet_reversal_boundary_and_windows():
-    from types import SimpleNamespace
-
-    calls = []
-    handle = SimpleNamespace(set_jet_amplitude=lambda i, a: calls.append((i, a)))
-    for diameter in (40, 80):
-        boundary = round(250 * diameter / r.SPEED)
-        assert r.jet_interval(handle, "fixed", boundary - 3, 80, diameter) == (3, None)
-        switch = round(300 * diameter / r.SPEED)
-        assert r.jet_interval(handle, "reverse", switch - 3, 80, diameter) == (3, None)
-        assert not calls
-        n, event = r.jet_interval(handle, "reverse", switch, 80, diameter)
-        assert n == 80 and event["step"] == switch and event["tstar"] == 300
-        assert calls == [(0, -.001), (1, .001)]
-        calls.clear()
-        assert r.jet_interval(handle, "reverse", switch + 80, 80, diameter) == (80, None)
-        assert r.jet_interval(handle, "fixed", switch, 80, diameter) == (80, None)
-        assert not calls
-    rows = [dict(tstar=t, tstar_force=t - .5, cd=2.0, cl=-.1) for t in range(251, 306)]
-    windows = r.jet_diagnostics(rows, "reverse")
-    assert len(windows) == 6 and all(w["complete"] for w in windows)
-    assert all(w["cd"]["mean"] == 2 and np.isclose(w["cl"]["mean"], -.1) for w in windows)
-    assert windows[-1]["covered_tstar"] == 5
-    with unittest.TestCase().assertRaisesRegex(ValueError, "crosses"):
-        r.jet_diagnostics([dict(tstar=250.5, tstar_force=250, cd=1, cl=0)], "fixed")
-    assert r.plan(h, "MRT", "window", "reverse")["modes"]["full_tstar"] == 305
-
-
-def test_public_jet_source_and_pilot_separation():
-    from tempfile import TemporaryDirectory
-
-    with TemporaryDirectory() as tmp:
-        path = Path(tmp)
-        manifest = pilot_fixture(path, jet_scenario="fixed")
-        assert manifest["source_capture"].startswith("current checkout")
-        assert len(manifest["checkout_revision"]) == 40
-        assert r.verify_pilot(path, manifest, "MRT", "window", "fixed") == 3606.0
-        for scenario in ("none", "zero", "reverse"):
-            with unittest.TestCase().assertRaisesRegex(ValueError, "Jet scenario"):
-                r.verify_pilot(path, manifest, "MRT", "window", scenario)
-        for relative in ("uniform/summary.json", "refined/ready.json"):
-            receipt = path / relative
-            record = json.loads(receipt.read_text())
-            receipt.write_text(json.dumps(dict(record, jet_scenario="zero")))
-            with unittest.TestCase().assertRaises(ValueError):
-                r.verify_pilot(path, manifest, "MRT", "window", "fixed")
-            receipt.write_text(json.dumps(record))
-    with unittest.TestCase().assertRaises(ValueError):
-        r.verify_source(r.DEFAULT_SOURCE, "MRT", "last_base_step", "fixed")
-
-
-def test_cv_snapshot_common_units_and_window_endpoints():
-    records = []
-    for refined, shape, origin, diameter, impulse in (
-        (True, (240, 568), (38., 22.), 40, [4., -8.]),
-        (False, (330, 1761), (.25, .5), 80, [16., -32.]),
-        (False, (658, 3521), (.375, .75), 160, [64., -128.]),
-    ):
-        rho, ux, uy, fluid = np.ones(shape), np.full(shape, .01), np.zeros(shape), np.ones(shape, bool)
-        begin, n = round(290*diameter/r.SPEED), round(.02*diameter/r.SPEED)
-        record = r.cv_snapshot(rho, ux, uy, fluid, origin, refined, begin, n, diameter, impulse)
-        records.append(record)
-        np.testing.assert_allclose(record["outward_flux"], 0, atol=1e-12)
-        assert r.cv_selected(begin, diameter, "full") and not r.cv_selected(begin-n, diameter, "full")
-        end = round(300*diameter/r.SPEED)
-        assert r.cv_selected(end, diameter, "full") and not r.cv_selected(end+n, diameter, "full")
-        assert r.cv_selected(n, diameter, "pilot")
-        assert sum(r.cv_selected(step, diameter, "full") for step in range(begin-n, end+n+1, n)) == 501
-    for key in ("time_root", "interval_start_root", "interval_dt_root", "interval_impulse_root", "inventory"):
-        for record in records[1:]:
-            np.testing.assert_allclose(records[0][key], record[key], rtol=0, atol=1e-10)
-    assert records[0]["interval_dt_root"] == 80 and np.isclose(records[0]["tstar"], 290.02)
-    np.testing.assert_array_equal(records[0]["interval_impulse_root"], [4, -8])
-
-
-def test_cv_pilot_mode_and_helper_provenance():
-    from tempfile import TemporaryDirectory
-
-    manifest = r.verify_source(r.DEFAULT_SOURCE, "MRT", "window", "fixed", True)
-    assert "tests/validation/run_jet_circle_cv.py" in manifest["sha256"]
-    with TemporaryDirectory() as tmp:
-        path = Path(tmp)
-        old = pilot_fixture(path, jet_scenario="fixed")
-        with unittest.TestCase().assertRaisesRegex(ValueError, "CV observation mode"):
-            r.verify_pilot(path, old, "MRT", "window", "fixed", True)
-        for relative in ("plan.json", "uniform/summary.json", "refined/summary.json",
-                         "uniform/ready.json", "refined/ready.json"):
-            file = path / relative
-            record = json.loads(file.read_text())
-            record.update(observe_cv=True, cv_samples=250)
-            if relative == "plan.json":
-                record["source_manifest"] = manifest
-            file.write_text(json.dumps(record))
-        assert r.verify_pilot(path, manifest, "MRT", "window", "fixed", True) == 3606
-
-
-def test_compact_geometry_and_cv_stencils():
-    from CelerisLab.lbm.refinement import ACTIVE
-    from CelerisLab.lbm.descriptors import SOLID
-
-    _, pair, _, host = r.host_geometry(r.DEFAULT_SOURCE, h, "MRT", "fixed", "compact")
-    assert pair.fine_shape == (168, 168) and tuple(pair.fine_origin) == (46, 46)
-    fluid = (pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)
-    rho, ux, uy = np.ones(pair.fine_shape), np.full(pair.fine_shape, .01), np.zeros(pair.fine_shape)
-    record = r.cv_snapshot(rho, ux, uy, fluid, pair.fine_origin, True, 1160000, 80, 40, [1, 2], "compact")
-    np.testing.assert_allclose(record["outward_flux"], 0, atol=1e-12)
-    stencil = np.zeros(pair.fine_shape, bool)
-    for rect in r.cv_contours(True, 40, "compact"):
-        x0, y0, x1, y1 = np.rint((rect - np.tile(pair.fine_origin, 2))/.5).astype(int)
-        stencil[y0-2:y1+2, x0-2:x0+2] = stencil[y0-2:y1+2, x1-2:x1+2] = True
-        stencil[y0-2:y0+2, x0-2:x1+2] = stencil[y1-2:y1+2, x0-2:x1+2] = True
-    assert fluid[stencil].all() and not stencil.ravel()[host.transfer_fine_cells].any()
-
-
-def test_d160_config_and_single_case_receipts():
-    from tempfile import TemporaryDirectory
-    from unittest.mock import patch
-
-    cfg, _, p = r.config(h, 160, "MRT", "fixed")
-    assert (p["nx"], p["ny"], p["center"], p["radius"]) == (3521, 658, [320, 320.5], 80)
-    assert p["viscosity"] == .016 and p["mean_speed"] == .01 and not cfg["method"]["ddf_shifting"]
-    assert r.uniform_origin(160) == (.375, .75)
-    np.testing.assert_array_equal(r.cv_contours(False, 160), r.CV_CONTOURS + [.125, 0, .125, 0])
-    for scenario, expected_exit in (("fixed", 0), ("zero", 2)):
-        with TemporaryDirectory() as tmp:
-            path = Path(tmp)
-            manifest = pilot_fixture(path, jet_scenario=scenario, case_selection="uniform", uniform_diameter=160)
-            assert r.verify_pilot(path, manifest, "MRT", "window", scenario, False, "uniform", 160) == 1803
-            for selection, diameter, placement in (("both", 160, "wide"), ("uniform", 80, "wide"), ("uniform", 160, "compact")):
-                with unittest.TestCase().assertRaises(ValueError):
-                    r.verify_pilot(path, manifest, "MRT", "window", scenario, False, selection, diameter, placement)
-            # Synthetic dispatch/result check: no CUDA imports or execution.
-            output = path / "full"
-            argv = ["runner", "--collision", "MRT", "--exchange-window", "--jet-scenario", scenario,
-                    "--case", "uniform", "--uniform-diameter", "160", "--mode", "full",
-                    "--pilot-results", str(path), "--output", str(output), "--max-wall-seconds", "10", "--gpu-gates-approved"]
-            result = dict(case="uniform", healthy=True, periodic=scenario == "zero", jet_diagnostic_windows=[],
-                          status="driven_diagnostics_complete" if scenario == "fixed" else "periodic",
-                          reference_comparison=dict(reference_agreement=False))
-            with patch.object(sys, "argv", argv), patch.dict(r.os.environ, CUDA_VISIBLE_DEVICES="mock-no-gpu"), \
-                    patch.object(r, "run_case", return_value=result) as run:
-                assert r.main() == expected_exit and run.call_count == 1
-            comparison = json.loads((output / "comparison.json").read_text())
-            assert comparison["matched_case_pass"] is False and "refined_vs_uniform" not in comparison
-            assert comparison["status"].startswith("single_case_")
-
-
 if __name__ == "__main__":
    suite = unittest.TestSuite(
        unittest.FunctionTestCase(fn)
@@ -22,29 +22,23 @@ class RefinementMRTHost(unittest.TestCase):

    def test_srt_statements_and_guards_preserved(self):
        """MRT is an additive compile-time branch; SRT statements and other guards remain."""
-        blocks = (KERNELS / "blocked.cu").read_text() + (KERNELS / "step/block_step.cu").read_text()
+        blocks = (KERNELS / "blocks.cu").read_text()
        channel = (KERNELS / "step/block_channel.cu").read_text()
-        block_collision = (KERNELS / "operators/block_collision.cuh").read_text()
-        self.assertIn('#include "operators/block_collision.cuh"', blocks)
-        self.assertEqual(blocks.count("block_collide(f);"), 1)
+        refinement = (KERNELS / "refinement.cu").read_text()
        for text in ("compute_feq_from_momentum(drho, jx, jy, ux, uy, feq);",
                     "compute_feq(rho, ux, uy, feq);",
                     "collide_srt_no_force(f, feq, d_params.omega);"):
-            self.assertIn(text, block_collision)
+            self.assertIn(text, blocks)
        self.assertIn("collide_srt(f, feq, forcing, omega);", channel)
-        for source in (blocks,):
+        self.assertIn("collide_srt_no_force(f, feq, d_params.omega);", refinement)
+        for source in (blocks, refinement):
            self.assertIn("(COLLISION_MODEL != 0 && COLLISION_MODEL != 2)", source)
            self.assertIn("USE_LES", source)
            self.assertIn("STORE_PRECISION != 0", source)
            self.assertIn('#if COLLISION_MODEL == 2\n#include "operators/collision_mrt.cuh"\n#endif', source)
-        # One shared unforced MRT body; each blocked/patch path calls it exactly once.
-        mrt = (KERNELS / "operators/collision_mrt.cuh").read_text()
-        self.assertEqual(mrt.count("void collide_mrt_unforced("), 1)
-        for source in (blocks + "\n" + block_collision, channel):
-            self.assertEqual(source.count("collide_mrt_unforced(f);"), 1)
-            self.assertNotIn("collide_mrt_no_force(", source)
-            self.assertNotIn("compute_rho_u(f, rho, ux, uy);\n            collide_mrt", source)
-            self.assertNotRegex(source, r"compute_rho_u\(f, rho, ux, uy\);\s*collide_mrt")
+        self.assertIn("USE_DDF_SHIFTING ||", refinement)  # dense/mixed shifted stays rejected
+        for source in (blocks, channel, refinement):
+            self.assertEqual(source.count("collide_mrt_no_force("), 1)


 if __name__ == "__main__": unittest.main()
@@ -22,13 +22,12 @@ def host_module():
    tree.body=[node for node in tree.body if not (
        isinstance(node,ast.Import) and any(a.name=='pycuda.driver' for a in node.names)
        or isinstance(node,ast.ImportFrom) and node.module in (
-            'cuda','curved_links'))]
+            'cuda','block_stepper','curved_links'))]
    module=types.ModuleType('CelerisLab.lbm._test_host_refinement')
    module.__package__='CelerisLab.lbm'
    from CelerisLab.body.jets import surface_link_velocity
-    module.__dict__.update(cuda=Mock(),compiler=Mock(),
+    module.__dict__.update(cuda=Mock(),compiler=Mock(),MAX_GRID_DIM=65535,
                           surface_link_velocity=surface_link_velocity)
-    module.cuda.mem_get_info.return_value=(1<<40,1<<40)  # free-memory preflight passes
    exec(compile(tree,str(path),'exec'),module.__dict__)
    return module

@@ -174,10 +173,8 @@ def bodies_and_jets(speed=.002):
    return bodies,jets


-def levels(parents=PARENTS,children=CHILDREN,blocks=((4,4),)*3,objects=((),(),()),jets=((),(),())):
-    """Level-list constructor keywords for the L0 set, L1 set and L2 set used here."""
-    return dict(refinements=[parents,children],level_blocks=list(blocks),
-                level_objects=list(objects),level_jets=list(jets))
+KW=dict(base_block=(4,4),fine_block=(4,4),child_block=(4,4),
+        child_rectangles_in_parent=CHILDREN)


 def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_upload=False):
@@ -194,9 +191,9 @@ def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_up
        gpu.get_function.side_effect=lambda name: Mock(name=name)
        gpu.get_global.side_effect=lambda name: (Mock(),20 if name=='d_params' else 16)
        return gpu
-    module.compiler.build_module.side_effect=lambda *a,**k: load(None)
+    module.compiler.load_module.side_effect=load
    if fail_compile:
-        module.compiler.build_module.side_effect=[load(None),load(None),RuntimeError('L2 compile failed')]
+        module.compiler.compile_kernel.side_effect=['first','second',RuntimeError('L2 compile failed')]
    if fail_upload:
        def upload(*args):
            if len(allocations)>20:
@@ -204,8 +201,9 @@ def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_up
        module.cuda.memcpy_htod.side_effect=upload
    objects,jets=bodies_and_jets() if bodies else ((),())
    try:
-        run=module.FixedPatchStepper(CFG,context=context,
-            **levels(children=children,objects=((),(),objects),jets=((),(),jets)))
+        run=module.FixedPatchStepper(CFG,PARENTS,context=context,
+            child_objects=objects,child_jets=jets,
+            **dict(KW,child_rectangles_in_parent=children))
    except RuntimeError:
        for allocation in allocations:
            allocation.free.assert_called_once_with()
@@ -216,29 +214,28 @@ def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_up
 class ConstructorAndSchedule(unittest.TestCase):
    def test_invalid_inputs_fail_before_context_or_allocations(self):
        context=Mock()
-        b=(4,4)
-        cases=[dict(children=(8,8,16,16)),dict(children=[]),
-               dict(children=[(16,16,32)]),
-               dict(children=[(16.5,16,32,40)]),
-               dict(children=[(16,16,32,24),(16,27,32,55)]),
-               dict(children=[(40,16,48,40)]),
-               dict(children=[(8,16,32,40)]),
-               dict(blocks=(b,b,None)),dict(blocks=(b,None,b)),dict(blocks=(None,b,b)),
-               dict(blocks=(b,b,(5,4))),dict(blocks=(b,(5,4),b)),
-               dict(blocks=(b,b,(4,))),dict(children=(16,16,32,40))]
+        cases=[dict(child=(8,8,16,16)),dict(child_rectangles_in_parent=[]),
+               dict(child_rectangles_in_parent=[(16,16,32)]),
+               dict(child_rectangles_in_parent=[(16.5,16,32,40)]),
+               dict(child_rectangles_in_parent=[(16,16,32,24),(16,27,32,55)]),
+               dict(child_rectangles_in_parent=[(40,16,48,40)]),
+               dict(child_rectangles_in_parent=[(8,16,32,40)]),
+               dict(child_block=None),dict(fine_block=None),dict(base_block=None),
+               dict(child_block=(5,4)),dict(fine_block=(5,4)),
+               dict(child_block=(4,)),dict(child_rectangles_in_parent=(16,16,32,40))]
        for changes in cases:
            with self.subTest(changes=changes),self.assertRaises((ValueError,TypeError)):
-                host.FixedPatchStepper(CFG,context=context,**levels(**changes))
+                host.FixedPatchStepper(CFG,PARENTS,context=context,**dict(KW,**changes))
        with self.assertRaisesRegex(ValueError,'margin'):
-            host.FixedPatchStepper(CFG,context=context,**levels(parents=[(1,4,20,28),(23,4,44,28)]))
+            host.FixedPatchStepper(CFG,[(1,4,20,28),(23,4,44,28)],context=context,**KW)
        objects,jets=bodies_and_jets()
-        with self.assertRaisesRegex(ValueError,'only on the finest level'):
-            host.FixedPatchStepper(CFG,context=context,**levels(objects=((),objects,())))
+        with self.assertRaisesRegex(ValueError,'only on L2'):
+            host.FixedPatchStepper(CFG,PARENTS,context=context,fine_objects=objects,**KW)
        from CelerisLab.body.jets import Jet,Tube,Parallel
        spanning=Jet(Tube((10.5,14.),0.,25.,.3),Parallel(0.),amplitude=0.)
        with self.assertRaisesRegex(ValueError,'one jet'):
-            host.FixedPatchStepper(CFG,context=context,
-                                  **levels(objects=((),(),objects),jets=((),(),[spanning])))
+            host.FixedPatchStepper(CFG,PARENTS,context=context,child_objects=objects,
+                                  child_jets=[spanning],**KW)
        context.activate.assert_not_called()
        host.cuda.mem_alloc.assert_not_called()

@@ -316,23 +313,21 @@ class ConstructorAndSchedule(unittest.TestCase):



-class RemovedLegacyAPI(unittest.TestCase):
-    """The pre-level-list constructor/initialize forms are gone and fail loudly."""
+class InitialLevels(unittest.TestCase):
+    """initialize() entry adapter: positional per-level arrays or the legacy names, never both."""

-    def test_removed_constructor_forms_raise_type_error(self):
-        import inspect
-        context = Mock()
-        with self.assertRaises(TypeError):  # positional bounds
-            host.FixedPatchStepper(CFG, PARENTS, context=context)
-        removed = dict(bounds=PARENTS, fine_block=(4, 4), base_block=(4, 4), fine_objects=(),
-                       jets=(), child=(8, 8, 16, 16), child_block=(4, 4), child_objects=(),
-                       child_jets=(), child_rectangles_in_parent=CHILDREN)
-        for name, value in removed.items():
-            with self.subTest(keyword=name), self.assertRaises(TypeError):
-                host.FixedPatchStepper(CFG, context=context, **levels(), **{name: value})
-        context.activate.assert_not_called()
-        self.assertEqual(list(inspect.signature(host.FixedPatchStepper.initialize).parameters),
-                         ["self", "level_g"])  # no coarse_g/fine_g/child_g
+    def test_forms(self):
+        a, b, c = object(), object(), object()
+        f = host._initial_levels
+        self.assertEqual(f((a, b), None, None, None), (a, b))
+        self.assertEqual(f((a, b, c), None, None, None), (a, b, c))
+        self.assertEqual(f((a, b), None, None, c), (a, b, c))      # old initialize(c, f, child_g=g)
+        self.assertEqual(f((), a, b, None), (a, b))
+        self.assertEqual(f((), a, b, c), (a, b, c))
+        for args in (((a,), None, None, c), ((a, b, c), None, None, c), ((a,), a, b, None),
+                     ((), a, None, None), ((), None, b, c)):
+            with self.subTest(args=args), self.assertRaises(TypeError):
+                f(*args)


 if __name__=='__main__':
@@ -86,7 +86,7 @@ class RuntimeChildRemap(unittest.TestCase):
            before = run.download()
            old_allocations = list(allocations)
            if failure == 'construction':
-                operation = patch.object(module.compiler, 'build_module', side_effect=RuntimeError('candidate compile'))
+                operation = patch.object(module.compiler, 'compile_kernel', side_effect=RuntimeError('candidate compile'))
            else:
                initialize = type(run).initialize
                def fail(candidate, *arrays):
@@ -54,15 +54,16 @@ class ShiftedJets(unittest.TestCase):
                (Jet(Tube((10.,14.),0.,26.,.3),Parallel(0.)),))]
        for objects,jets in cases:
            with self.subTest(objects=len(objects),jets=len(jets)),self.assertRaises(ValueError):
-                module.FixedPatchStepper(CFG,context=None,refinements=[backend.PARENTS,A],
-                    level_blocks=[(4,4)]*3,level_objects=[(),(),objects],level_jets=[(),(),jets])
+                module.FixedPatchStepper(CFG,backend.PARENTS,context=None,
+                    base_block=(4,4),fine_block=(4,4),child_block=(4,4),
+                    child_rectangles_in_parent=A,child_objects=objects,child_jets=jets)
        for blocks in ((None,None,None),((4,4),None,(4,4))):
            with self.assertRaises(ValueError):
-                module.FixedPatchStepper(CFG,context=None,refinements=[backend.PARENTS,A],
-                    level_blocks=list(blocks),level_objects=[(),(),(body(),)],
-                    level_jets=[(),(),(jet(),)])
+                module.FixedPatchStepper(CFG,backend.PARENTS,context=None,
+                    base_block=blocks[0],fine_block=blocks[1],child_block=blocks[2],
+                    child_rectangles_in_parent=A,child_objects=(body(),),child_jets=(jet(),))
        module.cuda.mem_alloc.assert_not_called()
-        module.compiler.build_module.assert_not_called()
+        module.compiler.compile_kernel.assert_not_called()

    def test_switch_upload_only_then_raw_remap_keeps_live_velocity(self):
        run,module,allocations,storage,objects=ready();clone=None
@@ -1,4 +1,7 @@
 """CPU host contracts; mocked CUDA executes real lifecycle, not numerical kernels."""
+import ast
+import types
+from pathlib import Path
 from contextlib import nullcontext
 from dataclasses import replace
 import unittest
@@ -75,15 +78,13 @@ class ShiftedStorage(unittest.TestCase):

    def test_shifted_density_and_tag_validation(self):
        old,new = topology(A),topology(B)
-        a = tuple(np.where(m[None], np.float32(-.001), np.float32(np.nan)).repeat(9,axis=0)
-                  for m in old.leaf_masks)  # FP32 under NumPy 1 and 2 promotion rules
+        a = tuple(np.where(m[None], np.float32(-.001), np.nan).repeat(9,axis=0) for m in old.leaf_masks)
        remap(old,new,a)
        with self.assertRaisesRegex(ValueError,'representation'): remap(old,new,a,False)
        with self.assertRaisesRegex(ValueError,'FP32'): remap(old,new,tuple(x.astype(np.float64) for x in a))
        a[0][:,old.leaf_masks[0]] = -1
        with self.assertRaisesRegex(ValueError,'positive density'): remap(old,new,a)
-        rest = tuple(np.where(m[None],np.float32(0),np.float32(np.nan)).repeat(9,axis=0)
-                     for m in old.leaf_masks)
+        rest = tuple(np.where(m[None],np.float32(0),np.nan).repeat(9,axis=0) for m in old.leaf_masks)
        remap(old,new,rest)
        with self.assertRaisesRegex(ValueError,'positive density'):
            remap_synchronized(old,new,rest,base_count=7,level_steps=(7,14,28),phase='postcollision_g')
@@ -125,24 +126,33 @@ class ShiftedStorage(unittest.TestCase):
            with self.assertRaisesRegex(ValueError,'mixed'): run._download_raw()
        finally: run.close()

-    def test_missing_tiles_rejected_before_compilation(self):
+    def test_dense_or_mixed_shifted_rejected_before_compilation(self):
        module=backend.host_module()
        cfg=replace(backend.CFG,ddf_shifting=True)
-        for blocks in ([None,None],[(4,4),None],[None,(4,4)]):
-            with self.assertRaisesRegex(ValueError,'must be a tile'):
-                module.FixedPatchStepper(cfg,context=None,refinements=[(4,4,20,28)],
-                                         level_blocks=blocks)
-        module.compiler.build_module.assert_not_called()
+        for kwargs in ({},dict(base_block=(4,4)),dict(fine_block=(4,4))):
+            with self.assertRaisesRegex(ValueError,'all-blocked|base_block requires fine_block'):
+                module.FixedPatchStepper(cfg,(4,4,20,28),context=None,**kwargs)
+        module.compiler.compile_kernel.assert_not_called()

    def test_uniform_block_codec_and_raw_snapshot(self):
-        module = backend.host_module()  # single blocked level: FixedPatchStepper(refinements=[])
-        cuda, compiler = module.cuda, module.compiler
+        path = Path(backend.r.__file__).with_name('block_stepper.py')
+        tree = ast.parse(path.read_text())
+        tree.body = [n for n in tree.body if not (
+            isinstance(n, ast.Import) and any(a.name == 'pycuda.driver' for a in n.names)
+            or isinstance(n, ast.ImportFrom) and n.module == 'cuda')]
+        module = types.ModuleType('CelerisLab.lbm._test_block_host')
+        module.__package__ = 'CelerisLab.lbm'
+        cuda, compiler = Mock(), Mock()
+        module.__dict__.update(cuda=cuda,compiler=compiler)
+        exec(compile(tree,str(path),'exec'),module.__dict__)
+        cuda.mem_get_info.return_value=(10**9,10**9)
        cuda.mem_alloc.side_effect=lambda size: Mock()
        gpu=Mock();gpu.get_global.return_value=(Mock(),20)
-        compiler.build_module.return_value=gpu
+        compiler.load_module.return_value=gpu
        context=Mock(activate=nullcontext,sm_arch='sm_70')
+        layout=module.BlockLayout2D.build(16,16,4,4)
        cfg=replace(backend.CFG,nx=16,ny=16,ddf_shifting=True)
-        run=module.FixedPatchStepper(cfg,context=context,refinements=[],level_blocks=[(4,4)])
+        run=module.PeriodicBlockStepper(cfg,layout,context=context)
        storage={}
        cuda.memcpy_htod.side_effect=lambda p,a: storage.__setitem__(id(p),np.array(a,copy=True))
        cuda.memcpy_dtoh.side_effect=lambda a,p: np.copyto(a,storage[id(p)])
@@ -153,8 +163,7 @@ class ShiftedStorage(unittest.TestCase):
            self.assertTrue(raw.shifted)
            self.assertEqual(len(raw.values),1)
            self.assertTrue((raw.values[0][1]==np.float32(2**-35)).all())
-            (down,)=run.download()
-            np.testing.assert_array_equal(down,physical)
+            np.testing.assert_array_equal(run.download(),physical)
        finally: run.close()

    def test_passive_shifted_body_raw_remap_preserves_support(self):
@@ -36,10 +36,12 @@ def make_simulation(monkeypatch):
    sim = module.Simulation.__new__(module.Simulation)
    sim.ctx = Owner()
    sim._closed = False
+    sim._build_dir = "private-build"
    for name in ("stepper", "bodies", "field", "_module", "_stream"):
        setattr(sim, name, object())
    monkeypatch.setattr(module, "cuda", SimpleNamespace(
        Context=SimpleNamespace(synchronize=lambda: None)))
+    monkeypatch.setattr(module.compiler, "cleanup_build_dir", lambda path: None)
    return sim


@@ -55,7 +57,7 @@ def test_close_inside_activation_preserves_resources(monkeypatch):
    assert sim._closed and sim.ctx.is_closed


-@pytest.mark.parametrize("failure", ["synchronize", "detach"])
+@pytest.mark.parametrize("failure", ["synchronize", "detach", "directory"])
 def test_close_failure_is_retryable(monkeypatch, failure):
    sim = make_simulation(monkeypatch)
    if failure == "detach":
@@ -66,12 +68,17 @@ def test_close_failure_is_retryable(monkeypatch, failure):
            calls.append(args)
            if len(calls) == 1:
                raise RuntimeError(failure + " failed")
-        monkeypatch.setattr(module.cuda.Context, "synchronize", fail_once)
+        if failure == "synchronize":
+            monkeypatch.setattr(module.cuda.Context, "synchronize", fail_once)
+        else:
+            monkeypatch.setattr(module.compiler, "cleanup_build_dir", fail_once)
    with pytest.raises(RuntimeError, match="failed"):
        sim.close()
    assert not sim._closed
+    assert sim._build_dir == "private-build"
    sim.close()
    assert sim._closed and sim.ctx.is_closed
+    assert sim._build_dir is None
    sim.close()


@@ -1,218 +0,0 @@
-"""Host contract of FixedPatchStepper(refinements=[]): one blocked level (mocked driver).
-
-Per step: halo refresh -> static BFL (circles only) -> BlockStep with a null
-kind, one stream wait per step(n) call, NaN spare after initialize. An upload,
-launch, wait or download failure fails the instance and keeps its step count;
-close retains resources for retry when context activation fails.
-"""
-from contextlib import nullcontext
-from unittest.mock import MagicMock, Mock
-import unittest
-
-import numpy as np
-
-from CelerisLab.body.geometry.circle import CircleGeometry
-from CelerisLab.body.objects import SimObject
-from CelerisLab.config import LBMConfig
-from tests.unit.test_refinement_three_level_multipatch import host_module
-
-
-def circle(center=(15.5, 11.5), radius=4.3):
-    return SimObject(0, geometry=CircleGeometry(*center, radius), center=center, radius=radius)
-
-
-def backend(objects=(), failing_kernel=None, initialize=True):
-    host, log = host_module(), []
-    host.armed = False  # set True to make failing_kernel raise
-
-    def launch(name):
-        def run(*a, **k):
-            log.append((name, a))
-            if name == failing_kernel and host.armed:
-                raise RuntimeError(name + " launch failed")
-        return run
-
-    module = Mock()
-    module.get_global.return_value = (Mock(), 20)
-    module.get_function.side_effect = lambda name: Mock(side_effect=launch(name))
-    host.compiler.build_module.return_value = module
-    host.cuda.mem_alloc.side_effect = lambda size: Mock(size=size)
-    host.cuda.memcpy_htod.side_effect = lambda pointer, array: log.append(("upload", (pointer, array)))
-    run = host.FixedPatchStepper(LBMConfig(nx=32, ny=24, viscosity=.1),
-                                 context=Mock(activate=nullcontext, sm_arch="sm_70"),
-                                 refinements=[], level_blocks=[(12, 16)], level_objects=[objects])
-    run._stream.synchronize.side_effect = lambda: log.append(("sync", ()))
-    log.clear()
-    if initialize:
-        run.initialize(np.full(run._levels[0].shape, 1 / 9, np.float32))
-    return run, log, host
-
-
-def state():
-    return np.full((9, 24, 32), 1 / 9, np.float32)
-
-
-class SingleLevel(unittest.TestCase):
-    def test_spare_starts_nan_and_current_holds_state(self):
-        run, log, _ = backend()
-        level = run._levels[0]
-        uploads = {id(a[0]): a[1] for name, a in log if name == "upload"}
-        self.assertTrue(np.isnan(uploads[id(level.spare)]).all())
-        self.assertTrue(np.isfinite(level.layout.to_dense(uploads[id(level.current)])).all())
-
-    def test_launch_order_per_step(self):
-        for objects, order in (((), ["BlockHaloCopy", "BlockStep"]),
-                               ((circle(),), ["BlockHaloCopy", "BlockCurvedBoundary", "BlockStep"])):
-            with self.subTest(bodies=len(objects)):
-                run, log, _ = backend(objects)
-                log.clear()
-                run.step(2)
-                self.assertEqual([name for name, _ in log], order * 2 + ["sync"])
-                step = [a for name, a in log if name == "BlockStep"][0]
-                self.assertEqual(int(step[4]), 0)  # null kind: every core cell ACTIVE
-
-    def test_circle_solids_are_not_state(self):
-        run, _, _ = backend((circle(),))
-        solid = run._level_boundaries[0].tables["solid"]
-        self.assertTrue(solid.any())
-        np.testing.assert_array_equal(run._state[0], ~solid)
-
-    def test_initialize_upload_failure_fails_instance(self):
-        run, _, host = backend(initialize=False)
-        host.cuda.memcpy_htod.side_effect = RuntimeError("upload failed")
-        with self.assertRaisesRegex(RuntimeError, "upload failed"):
-            run.initialize(state())
-        with self.assertRaisesRegex(RuntimeError, "failed"):
-            run.step(1)
-
-    def test_launch_failure_fails_instance_and_keeps_step_count(self):
-        for kernel, objects in (("BlockHaloCopy", ()), ("BlockCurvedBoundary", (circle(),)),
-                                ("BlockStep", ())):
-            with self.subTest(kernel=kernel):
-                run, log, host = backend(objects, failing_kernel=kernel)
-                run.step(1)
-                host.armed = True
-                log.clear()
-                with self.assertRaisesRegex(RuntimeError, kernel + " launch failed"):
-                    run.step(2)
-                self.assertEqual(run.step_count, 1)
-                self.assertNotIn("sync", [name for name, _ in log])
-                with self.assertRaisesRegex(RuntimeError, "failed"):
-                    run.download()
-
-    def test_free_memory_preflight_before_stream_and_buffers(self):
-        for cfg, options in ((LBMConfig(nx=32, ny=24, viscosity=.1),
-                              dict(refinements=[], level_blocks=[(12, 16)])),
-                             (LBMConfig(nx=48, ny=48, viscosity=.02),  # every level counts
-                              dict(refinements=[[(6, 6, 26, 26)]], level_blocks=[(4, 4)] * 2))):
-            with self.subTest(depth=len(options["refinements"]) + 1):
-                host = host_module()
-                host.cuda.mem_get_info.return_value = (1024, 1 << 30)
-                with self.assertRaisesRegex(MemoryError, "exceed free device memory"):
-                    host.FixedPatchStepper(cfg, context=Mock(activate=nullcontext, sm_arch="sm_70"),
-                                           **options)
-                host.cuda.Stream.assert_not_called()
-                host.cuda.mem_alloc.assert_not_called()
-                host.compiler.build_module.assert_not_called()
-
-    def test_wait_failure_after_a_good_step_keeps_its_count(self):
-        run, _, _ = backend()
-        run.step(1)
-        run._stream.synchronize.side_effect = RuntimeError("device fault")
-        with self.assertRaises(RuntimeError):
-            run.step(2)
-        self.assertEqual((run.step_count, run._status), (1, "failed"))
-
-    def test_final_wait_failure_fails_instance_and_keeps_step_count(self):
-        run, _, _ = backend()
-        run._stream.synchronize.side_effect = RuntimeError("device error")
-        with self.assertRaisesRegex(RuntimeError, "device error"):
-            run.step(3)
-        self.assertEqual(run.step_count, 0)
-        with self.assertRaisesRegex(RuntimeError, "failed"):
-            run.step(1)
-
-    def test_step_n_waits_once_and_matches_n_single_steps(self):
-        many, log_many, _ = backend()
-        many.step(3)
-        single, log_single, _ = backend()
-        for _ in range(3):
-            single.step(1)
-        names = [name for name, _ in log_many]
-        self.assertEqual(names.count("sync"), 1)
-        self.assertEqual(names[-1], "sync")
-        self.assertEqual(names.count("BlockStep"), 3)
-
-        def roles(run, log):  # same launch order and buffer roles as three step(1) calls
-            level = run._levels[0]
-            tags = {id(level.current): "c", id(level.spare): "s"}
-            return [(n, tuple(tags.get(id(x), "-") for x in a)) for n, a in log if n != "sync"]
-        self.assertEqual(roles(many, log_many), roles(single, log_single))
-        self.assertIsNot(many._levels[0].current, many._levels[0].spare)
-        self.assertEqual((many.step_count, single.step_count), (3, 3))
-
-    def test_step_zero_launches_and_waits_for_nothing(self):
-        run, log, _ = backend()
-        log.clear()
-        run.step(0)
-        self.assertEqual((log, run.step_count), ([], 0))
-
-    def test_launch_failure_mid_batch_fails_without_waiting(self):
-        run, log, host = backend()
-        step = run._levels[0].kernel
-        calls = []
-
-        def failing(*args, **kwargs):
-            calls.append(1)
-            if len(calls) == 2:
-                raise RuntimeError("launch failure")
-            return step(*args, **kwargs)
-
-        run._levels[0].kernel = failing
-        log.clear()
-        with self.assertRaises(RuntimeError):
-            run.step(3)
-        self.assertNotIn("sync", [name for name, _ in log])
-        self.assertEqual((run.step_count, run._status), (0, "failed"))
-        with self.assertRaises(RuntimeError):
-            run.download()
-
-    def test_initialize_rejects_bad_state_before_upload(self):
-        run, log, _ = backend(initialize=False)
-        good = state()
-        for bad in (good[:, :-1], np.where(np.arange(32) == 3, np.nan, good), -good):
-            with self.assertRaises(ValueError):
-                run.initialize(bad)
-        self.assertNotIn("upload", [name for name, _ in log])
-        run.initialize(good)
-        self.assertEqual([name for name, _ in log].count("upload"), 2)
-
-    def test_download_failure_fails_instance(self):
-        run, _, host = backend()
-        host.cuda.memcpy_dtoh.side_effect = RuntimeError("read failed")
-        with self.assertRaisesRegex(RuntimeError, "read failed"):
-            run.download()
-        for operation in (run.download, run.step):
-            with self.assertRaisesRegex(RuntimeError, "failed"):
-                operation()
-
-    def test_activation_failure_retains_resources_for_retry(self):
-        run, _, _ = backend()
-        allocations, stream = run._allocations[:], run._stream
-        unavailable = MagicMock()
-        unavailable.__enter__.side_effect = RuntimeError("activation failed")
-        run.ctx.activate = Mock(side_effect=[unavailable, nullcontext()])
-        with self.assertRaisesRegex(RuntimeError, "activation failed"):
-            run.close()
-        self.assertEqual(run._status, "failed")
-        self.assertEqual(run._allocations, allocations)
-        self.assertIs(run._stream, stream)
-        run.close()
-        self.assertEqual(run._status, "closed")
-        self.assertEqual(run._levels, [])
-        for allocation in allocations:
-            allocation.free.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -238,82 +238,6 @@ def test_overlapping_force_regions_rejected(device):
        bodies.build_compact_lists(bodies.build_flags(field.flag))


-@pytest.mark.parametrize("second_x,error", [(14., "unique cut-link writers"),
-                                           (17., "active fluid receivers")])
-def test_passive_overlap_rejected_before_publishing_lists(second_x, error):
-    cfg = LBMConfig(nx=32, ny=24)
-    cfg.validate()
-    bodies = ObjectManager(cfg.nx, cfg.ny, cfg.nz, cfg.nq, cfg)
-    for x in (14., second_x):
-        bodies.add(obj(x=x, y=12., r=4.3))
-    bodies.add(obj(x=4., y=4., r=2., is_sensor=True))
-    counts = np.full(bodies.count, 91, np.int32)
-    hits = []
-    flags = bodies.build_flags(np.full(cfg.nx * cfg.ny, FLUID, np.uint16))
-    for domain_flags in (flags, None):
-        with pytest.raises(ValueError, match=error):
-            bodies.build_compact_lists_for(bodies.objects, domain_flags,
-                                          sensor_cell_counts_out=counts, hits_out=hits)
-        np.testing.assert_array_equal(counts, 91)
-        assert hits == []
-
-
-@pytest.mark.parametrize("centers", [((10., 12.), (22., 12.)),
-                                    ((10.5, 12.), (19.5, 12.))])
-def test_separated_passive_bodies_keep_valid_writers(centers):
-    # The second case has a subcell physical gap with a resolved fluid column.
-    cfg = LBMConfig(nx=32, ny=24)
-    cfg.validate()
-    bodies = ObjectManager(cfg.nx, cfg.ny, cfg.nz, cfg.nq, cfg)
-    for x, y in centers:
-        bodies.add(obj(x=x, y=y, r=4.3))
-    flags = bodies.build_flags(np.full(cfg.nx * cfg.ny, FLUID, np.uint16))
-    indices, directions, _, ids, *_ = bodies.build_compact_lists(flags)
-    assert set(ids) == {0, 1}
-    assert np.all(flags[indices] & FLUID) and not np.any(flags[indices] & SOLID)
-    assert len(np.unique(indices.astype(np.uint64) * cfg.nq + directions)) == len(indices)
-
-
-@pytest.mark.parametrize("entry", ["sync", "initialize", "runtime_edit"])
-@pytest.mark.parametrize("second_x", [5., 6.])
-def test_passive_overlap_failure_keeps_live_state(device, entry, second_x):
-    from CelerisLab.simulation import Simulation
-    field = make_field(device)
-    bodies = manager(field, [obj(), obj(x=9., y=3., r=1., is_sensor=True)])
-    bodies.sync_to_gpu(field)
-    overlapping = obj(x=second_x)
-    if entry == "runtime_edit":
-        bodies.stage_add(overlapping)
-    else:
-        bodies.add(overlapping)
-    objects = bodies.objects
-    flags, curved, counts = field.flag.copy(), field.curved.fluid_idx.copy(), bodies.sensor_cell_counts.copy()
-    action = bodies.action.copy()
-    buffers = [(block, bytes(block.data), block.freed) for block in device.blocks]
-    writes = device.writes
-    sim = SimpleNamespace(bodies=bodies, field=field, lbm_cfg=field.cfg,
-                          _initialized=entry == "runtime_edit",
-                          _assert_allocation_contract=lambda: None,
-                          stream=SimpleNamespace(synchronize=device.synchronize))
-    sim._require_usable = Simulation._require_usable.__get__(sim)
-    with pytest.raises(ValueError, match="active fluid receivers|unique cut-link writers"):
-        if entry == "sync":
-            bodies.sync_to_gpu(field)
-        elif entry == "initialize":
-            Simulation.initialize(sim)
-        else:
-            Simulation.sync_bodies(sim)
-    assert bodies.objects == objects
-    assert bodies.has_pending_edit() == (entry == "runtime_edit")
-    assert sim._initialized == (entry == "runtime_edit")
-    assert device.writes == writes and len(device.blocks) == len(buffers)
-    assert all(bytes(block.data) == data and block.freed == freed for block, data, freed in buffers)
-    np.testing.assert_array_equal(field.flag, flags)
-    np.testing.assert_array_equal(field.curved.fluid_idx, curved)
-    np.testing.assert_array_equal(bodies.sensor_cell_counts, counts)
-    np.testing.assert_array_equal(bodies.action, action)
-
-
 def test_action_upload_and_scratch_are_pinned(device):
    field = make_field(device, streaming="esopull")
    bodies = manager(field, [obj(is_force_region=True)])
@@ -1,170 +0,0 @@
-"""Host contract of FixedPatchStepper.step(n): one stream wait per call (mocked driver).
-
-All n base intervals are enqueued in order on the backend stream and the host
-waits once before step returns. Launch order and buffer arguments must equal n
-step(1) calls; completion metadata, raw-exchange and window ledgers, and failure
-invalidation are published only after that wait.
-"""
-from contextlib import nullcontext
-from unittest.mock import Mock
-import unittest
-
-import numpy as np
-
-from CelerisLab.config import LBMConfig
-from tests.unit.test_raw_exchange import body
-from tests.unit.test_refinement_three_level_multipatch import host_module
-
-BODY_LEVEL, HOPS = 3, 8  # body on L3: 2**3 hops per base interval
-
-
-def backend(window=False):
-    """Four-level host backend; every launch, memset and stream wait goes to one log."""
-    host = host_module()
-    log, allocations = [], []
-
-    def allocate(size):
-        allocations.append(Mock(size=size))
-        return allocations[-1]
-
-    module = Mock()
-    module.get_global.return_value = (Mock(), 20)
-    module.get_function.side_effect = lambda name: Mock(
-        side_effect=lambda *a, **k: log.append((name, a, k)))
-    host.compiler.build_module.return_value = module
-    host.cuda.mem_alloc.side_effect = allocate
-    host.cuda.memcpy_dtoh.side_effect = lambda array, pointer: array.fill(0)
-    host.cuda.memset_d8_async.side_effect = lambda *a: log.append(("memset", a, {}))
-    run = host.FixedPatchStepper(
-        LBMConfig(nx=48, ny=48, viscosity=.02), context=Mock(activate=nullcontext, sm_arch="sm_70"),
-        refinements=[[(6, 6, 26, 26)], [(20, 20, 44, 44)], [(56, 56, 72, 72)]],
-        level_blocks=[(4, 4)] * 4, level_objects=[(), (), (), (body(),)],
-        observe_raw_exchange=True, observe_window_exchange=window)
-    run._stream.synchronize.side_effect = lambda: log.append(("sync", (), {}))
-    run.initialize(*[np.full(level.shape, 1 / 9, np.float32) for level in run._levels])
-    log.clear()
-    return run, log, allocations
-
-
-def signature(log, allocations):
-    """Event names with device-pointer arguments replaced by allocation index."""
-    index = {id(a): i for i, a in enumerate(allocations)}
-    return [(name, tuple(index.get(id(a), "-") for a in args)) for name, args, _ in log]
-
-
-def names(log):
-    return [name for name, _, _ in log]
-
-
-class StepSync(unittest.TestCase):
-    def test_step1_waits_once_after_all_launches(self):
-        run, log, _ = backend()
-        run.step(1)
-        self.assertEqual(names(log).count("sync"), 1)
-        self.assertEqual(names(log)[-1], "sync")
-        self.assertEqual(names(log)[0], "memset")
-        self.assertEqual(names(log).count("BlockStep"), 1 + 2 + 4 + 8)
-        self.assertEqual(run.step_count, 1)
-        run.close()
-
-    def test_step_n_equals_n_step1_launches_with_one_wait(self):
-        single, single_log, single_alloc = backend()
-        for _ in range(3):
-            single.step(1)
-        batched, batched_log, batched_alloc = backend()
-        batched.step(3)
-        expected = [e for e in signature(single_log, single_alloc) if e[0] != "sync"]
-        got = signature(batched_log, batched_alloc)
-        self.assertEqual(got[-1][0], "sync")
-        self.assertEqual(names(batched_log).count("sync"), 1)
-        self.assertEqual(got[:-1], expected)  # same order, same ping-pong buffers
-        self.assertEqual(names(batched_log).count("memset"), 3)
-        self.assertEqual(batched.step_count, single.step_count)
-        index = [{id(a): i for i, a in enumerate(alloc)} for alloc in (single_alloc, batched_alloc)]
-        self.assertEqual(index[1][id(batched._levels[0].current)],
-                         index[0][id(single._levels[0].current)])
-        single.close()
-        batched.close()
-
-    def test_step0_launches_and_waits_for_nothing(self):
-        run, log, _ = backend()
-        run.step(2)
-        log.clear()
-        run.step(0)
-        self.assertEqual(log, [])
-        self.assertEqual(run.step_count, 2)
-        value = run.read_raw_exchange(0, level=BODY_LEVEL)  # step(0) keeps the ledger valid
-        self.assertEqual((value["time_start"], value["time_end"]), (1, 2))
-        run.close()
-
-    def test_completion_metadata_covers_all_intervals(self):
-        run, _, _ = backend()
-        with self.assertRaisesRegex(RuntimeError, "completed"):
-            run.read_raw_exchange(0, level=BODY_LEVEL)
-        run.step(3)
-        value = run.read_raw_exchange(0, level=BODY_LEVEL)
-        self.assertEqual((value["time_start"], value["time_end"], value["sample_count"]),
-                         (2, 3, HOPS))  # step(n) retains only the final base interval
-        run.step(2)
-        self.assertEqual(run.read_raw_exchange(0, level=BODY_LEVEL)["time_end"], 5)
-        run.close()
-
-    def test_window_accounting_across_batched_calls(self):
-        windows = []
-        for calls in ((1, 3), (4,), (1, 1, 1, 1)):
-            run, log, _ = backend(window=True)
-            run.step(1)
-            run.start_exchange_window()
-            log.clear()
-            for n in calls:
-                run.step(n)
-            self.assertEqual(names(log).count("BlockAccumulateExchange"), 2 * 4 * HOPS)
-            self.assertEqual(names(log).count("sync"), len(calls))
-            out = run.read_exchange_window(0, level=BODY_LEVEL)
-            windows.append((out["time_start"], out["time_end"], out["sample_count"]))
-            run.close()
-        self.assertEqual(windows, [(1., 5, 4 * HOPS)] * 3)
-
-    def test_failed_wait_publishes_nothing(self):
-        run, _, _ = backend(window=True)
-        run.step(2)
-        run.start_exchange_window()
-        run._stream.synchronize.side_effect = RuntimeError("device failure")
-        with self.assertRaisesRegex(RuntimeError, "device failure"):
-            run.step(3)
-        self.assertEqual(run.step_count, 2)  # value at entry to the failing call
-        self.assertFalse(run._exchange_valid)
-        self.assertFalse(run._window_valid)
-        for read in (lambda: run.read_raw_exchange(0, level=BODY_LEVEL),
-                     lambda: run.read_exchange_window(0, level=BODY_LEVEL), run.download,
-                     lambda: run.step(1)):
-            with self.assertRaisesRegex(RuntimeError, "failed"):
-                read()
-        run._stream.synchronize.side_effect = None
-        run.close()
-
-    def test_launch_error_mid_batch_skips_wait_and_fails(self):
-        run, log, _ = backend()
-        run.step(1)
-        log.clear()
-        hop, calls = run._hop, []
-
-        def failing(index, *args, **kw):
-            if index == 0:
-                calls.append(1)
-                if len(calls) == 2:
-                    raise RuntimeError("launch failure")
-            return hop(index, *args, **kw)
-        run._hop = failing
-        with self.assertRaisesRegex(RuntimeError, "launch failure"):
-            run.step(3)
-        self.assertNotIn("sync", names(log))
-        self.assertEqual(run.step_count, 1)
-        self.assertFalse(run._exchange_valid)
-        with self.assertRaisesRegex(RuntimeError, "failed"):
-            run.read_raw_exchange(0, level=BODY_LEVEL)
-        run.close()
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -12,15 +12,13 @@ from source_provenance import checkout_provenance
 import re100_helpers
 import run_jet_circle_cv

-sys.path.insert(0, str(ROOT / "tests/unit"))
-from historical_tree import historical_tree, tracked
-
 ORIGIN = "47b05bc8abfc957fe876b0c63bdb386e3c6cbaa5"


-def test_manifests_cover_current_source_and_preserve_origin(tmp_path):
-    assert re100_helpers.PIN == run_jet_circle_cv.PIN == ORIGIN
-    manifests = {}
+def test_manifests_cover_current_source_and_preserve_origin():
+    names = subprocess.check_output(
+        ["git", "-C", str(ROOT), "ls-files", "src"], text=True
+    ).splitlines()
    for group, hashes_key, revision_key in (
        ("dfg_re100", "production_sha256", "commit"),
        ("jet_circle_cv", "files", "revision"),
@@ -31,22 +29,18 @@ def test_manifests_cover_current_source_and_preserve_origin(tmp_path):
            ).read_text()
        )
        assert manifest[revision_key] == ORIGIN
+        assert set(manifest[hashes_key]) == set(names)
        assert manifest["source_origin_commits"][-1] == ORIGIN
        assert (
            manifest["historical_checkpoints"]["production"]
            == "d79e3f6f0a424f5bcc3a1a6d610313e49daf97a2"
        )
        assert "not inherited from d79" in manifest["experiment"]
-        manifests[group] = manifest[hashes_key]
-    # History-dependent checks last, so a missing commit masks nothing above.
-    names = tracked(ORIGIN)
-    origin = historical_tree(ORIGIN, tmp_path)
-    for group, hashes in manifests.items():
-        assert set(hashes) == set(names), group
-        for name, expected in hashes.items():
+        for name, expected in manifest[hashes_key].items():
            assert (
-                hashlib.sha256((origin / name).read_bytes()).hexdigest() == expected
+                hashlib.sha256((ROOT / name).read_bytes()).hexdigest() == expected
            ), name
+    assert re100_helpers.PIN == run_jet_circle_cv.PIN == ORIGIN


 def test_runtime_checkout_identity_is_separate_from_source_origin(tmp_path):
@@ -1,110 +0,0 @@
-{
-  "base_commit": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "production_origin_commit": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_experiment": "Explicit a135252 uniform SRT LES regression. Sources pin the committed corrected tree; baseline is a synthetic isolated reverse-header control, not the committed a135252 source. Historical profiles and receipts remain unchanged.",
-  "sources": {
-    "src/CelerisLab/__init__.py": "21cc469bd6e970a1f9ff5970c8eea4602065e41fc881854759ee565ee55c10c6",
-    "src/CelerisLab/body/__init__.py": "e4e0e8f0769a94428d5b02fac790443997556cfc5515a5f1ed1595d2c694d69d",
-    "src/CelerisLab/body/action_smoother.py": "b1a23ee6bbd4850b172cb8738c5c3546ee465a54189e6af9d8044f023d4687dc",
-    "src/CelerisLab/body/coupling/__init__.py": "c931f7eb318d48408c3e2febcc6917c88c8dcc1697cbf4329b1f340d94c35763",
-    "src/CelerisLab/body/coupling/soa_packer.py": "8ec26fd55ef74801bbd5ab6bd3d0a7dabc750cbd498aaac2ca4c61a0108ad3c9",
-    "src/CelerisLab/body/ddf_patch.py": "60fcfb7441e73bf290bcff41ca3a83da3e7ddad765d7247464e8f02e3043b4e2",
-    "src/CelerisLab/body/geometry/__init__.py": "ada88980ab672959aca9aa3a4c4aade3219524b2ab68110cd2a2f41e3e0ca90a",
-    "src/CelerisLab/body/geometry/base.py": "cceca14361ca2f34d34a3e43730e1a79b8ca81be00f0dd62e884db32b479419f",
-    "src/CelerisLab/body/geometry/circle.py": "7605ca7c21103f1d801ac73ab8dd18dffbdac425b2dee7b8858b283628a9e436",
-    "src/CelerisLab/body/jets.py": "4104c24af4651f4bb4f8d8fd36fb6d88f41c6e4469822f36e22e74c9ede31dac",
-    "src/CelerisLab/body/manager.py": "01b653d25bd9b4333379c8bfd12383596b686d2029f2e91b1c91b618540ec6b3",
-    "src/CelerisLab/body/objects.py": "8e63cee8faa9cc6243bcff428be628dfad73a02a9a3b8ece7d78c0a63406a08d",
-    "src/CelerisLab/body/preprocess/__init__.py": "dfd9d58bc07f626ab23a70053e31b88a6d9165d2e4c76a4e9f48abe674d3d2ec",
-    "src/CelerisLab/body/preprocess/flag_overlay.py": "831fc9e9736b758847759a085ff133eb49ec91318ace4fda76f85960138ee300",
-    "src/CelerisLab/body/registry.py": "fbb7327780adbdc6da15ebdb799980daf32df22ee974af0893d7409f177bbb68",
-    "src/CelerisLab/body/sync_plan.py": "3a15bfe9ebeb91482dbfc68850761ef39c872cc12d2efc795babd0c01e392323",
-    "src/CelerisLab/common/__init__.py": "d4dbde78bc97fccc9eabac9abae8f0f15c112c10ff8e9b45bd9401d4723df1ef",
-    "src/CelerisLab/common/_types.py": "aad2ff1a9033d4fd68783ad7123afb47201ddc58785cb6dc0246947037072a5f",
-    "src/CelerisLab/common/checkpoint.py": "b2f960aecd5ac27a3a7130b809ffad4709c44d522edef0359ab952654625410b",
-    "src/CelerisLab/common/pathline.py": "a1b6efcc0a076d0f1dc8d49a595779426d7d5626b00072a59bac710ff02ad046",
-    "src/CelerisLab/common/preprocess.py": "7fc78a08857cf8e98519500b094a1d896af189b6b15658ff9b388ed51bed4515",
-    "src/CelerisLab/common/render.py": "0e055476257eb2bcd11e733766e52195de02f8fad228f570a3511a7c831bdc29",
-    "src/CelerisLab/common/streakline/__init__.py": "13ff1cfa416fdd721a08a659e76b5a5a99b8d3201add10a83b7b0bc654bc1eec",
-    "src/CelerisLab/common/streakline/_config.py": "a9185ef68e9c7b5d5a1dc0b04a28341e2ad91d13c145a7c106636a878cf0a605",
-    "src/CelerisLab/common/streakline/_integrate.py": "3fbd4368b2c8d0e7fda40dc65aac5df02b085008b4c68acd83cb7ae45d33a13b",
-    "src/CelerisLab/common/streakline/_render.py": "236cd637414ee318c4d66f9aed32110d8dc42a100d65fde06172f7cd0ba62c65",
-    "src/CelerisLab/common/streakline/_streakline.py": "1a3e08daa706b5f83cdeb337e9a945a36ddf7583c40af1d0bb9d825ac954df37",
-    "src/CelerisLab/config.py": "2f1bba7515f5bc08cb3a8d140bcafe7fa0689e01b3b06494697bb2956a71530e",
-    "src/CelerisLab/configs/CONFIG.md": "41cafdbe525366c08aa9d0416ea026ccf0026ba7123b8a9b65f968a80d928e3a",
-    "src/CelerisLab/configs/config_body.json": "055f261f0828ca1d4f2bb694bd15b72bbcabe31d552326208f28e37f761adab1",
-    "src/CelerisLab/configs/config_lbm.json": "17e4311f1f250c6ece59177a8b6ff856b69a016c7c10267e774b030a0a390865",
-    "src/CelerisLab/configs/config_lbm_flume_mrt_zouhe.json": "8f593321db05a563a42931603a228d61cbcba06dfbe113262d5cd0ad93c0fe79",
-    "src/CelerisLab/configs/config_lbm_flume_trt_regularized.json": "f4bba8e6a4339fc3c4eb14f6e2f57c4b22993c73703c773d853edfbe34736e56",
-    "src/CelerisLab/configs/config_lbm_three_cylinder_triangle.json": "eeb8e7149dbe4aa6b3a9562802735aa950750dfbe2d972a0727e788573afa817",
-    "src/CelerisLab/cuda/__init__.py": "0d01dff9f0399c8baba822aab5ca0122a135f011008ed8a499ebd9f7e5b06aea",
-    "src/CelerisLab/cuda/compiler_v2.py": "c4cc3ec4445c8d75e6a253dd87963877117a722bc73b9d4811806fc6045d08c1",
-    "src/CelerisLab/cuda/context.py": "013dd4ec6d01d2fbd11afdfb103eac6a273bd9f798d663d761b851eeb27885e9",
-    "src/CelerisLab/cuda/obs_layout.py": "5ffb2c3aeeaaaaeb64f2cd8febfbcf4ad9919e5414020ad753cfade0683b21c2",
-    "src/CelerisLab/lbm/__init__.py": "7f60fb3aaae81501b510d08c2fedff44fcb05657260eb10b6f5cc91e7204306b",
-    "src/CelerisLab/lbm/block_stepper.py": "00b313daddc6e63d8ab8423c9190ca7e92ad291de20a2f6b80eb53e3f2d85ec7",
-    "src/CelerisLab/lbm/blocks.py": "1e644c5719993f418185ad4a10b6950a30636fc912befd9eab41ff48b4cf85cd",
-    "src/CelerisLab/lbm/channel.py": "40d0354e5dc97bcdb7e7b5c1e7f9303a109b7134d8a3af88b8ff4cd75ab5a095",
-    "src/CelerisLab/lbm/curved_links.py": "b6957fa13d13f864dba4f7364e93a39905d062dbb3ee9b3f5191add81fff0732",
-    "src/CelerisLab/lbm/descriptors.py": "c9f025dfc14da43b989047b84cc22bd05d5cc92c9ec695c1da68fdfb788e3f2b",
-    "src/CelerisLab/lbm/equilibrium.py": "2fb2f2bb7ff326d23abce80fc2a4c0907b17740ea3e29fe6ae079c5044783826",
-    "src/CelerisLab/lbm/field.py": "0e727eacc3706add4d8d15c418e9b631050871f831698d3ac689dd5f2c701b9b",
-    "src/CelerisLab/lbm/hierarchy.py": "f234975074f6b6d289d573ff6ea6832feae0e27cb04f80b37fe81792b13a12e7",
-    "src/CelerisLab/lbm/initializers.py": "dacf9586963e862d6d0a98ef1a066036be6f91e9d423720661d8ef2c1fb2df6a",
-    "src/CelerisLab/lbm/kernels/blocks.cu": "668e5cf14e88bdcfa281c2fa6c75c0f8f8cdbbfb8ba2ca03064ae02ef7ad0057",
-    "src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh": "aba3748c564ed91b161d268ef8b737b7c7be96a823063d201f3da684dd845233",
-    "src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh": "aeb16bfd483514fb03e15a2fed437d673c3b8b2fe68ab83edf4244ef593878ea",
-    "src/CelerisLab/lbm/kernels/boundary/esopull_curved_helpers.cuh": "b9b474bc4edaff05681c5443235472d04072d0d775fc0eb9c5967faef52b0258",
-    "src/CelerisLab/lbm/kernels/boundary/ibm_kernels.cuh": "e6909b547dc8d64cdd8a76a90660243a8f5fee535caa161b52b4dd8b7c29934b",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/channel_stabilized.cuh": "efe077afcbb6b731256a987c2fd79a1dbc470c902f87070d60421ea6cb13d4e2",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh": "59b38a89439878e00de7de16b9c7b03feff443fcc5a421593f7d2536dcbb7ab8",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/regularized.cuh": "943d4a571818bacb89c70bccfaac202691121e3e385803ce6309123a0a03ddaf",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh": "e73e66b853b1e4e0e30d8f4185d832aa414ce670a1813ce2b5459f2887f71f89",
-    "src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh": "de8b213a6da42c2e5e9f8966199fc66ea4541b85144a90f3f5dbad3c6ab63b97",
-    "src/CelerisLab/lbm/kernels/boundary/outlet/pressure_neq.cuh": "c8b2adc66d12fe602076ddc9693c5c208711fcaddb58aa9a31401a269f51c4c4",
-    "src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh": "501b2759d0e2e4280cb6fdd127d66a50fa89f6de48fc2cae9a7eafb11ae90bed",
-    "src/CelerisLab/lbm/kernels/config.h": "7d1124125e0b354558297934460e64c760fb68cdd7bf6d01a1238bb2eaab8c37",
-    "src/CelerisLab/lbm/kernels/config/config_grid.h": "1db3e030ebdc116cd7f02362d1fd077daac55e8f0b4329f6285948c224d3ca5d",
-    "src/CelerisLab/lbm/kernels/config/config_method.h": "4374e04a130f90f97d17cc20c40d2f9ea0ed0dd8603817d07f215d02266e247c",
-    "src/CelerisLab/lbm/kernels/config/config_objects.h": "db793af052c756561a190a3ff2cb93ee5fe28462ee4f97c6af80882b4dc8b072",
-    "src/CelerisLab/lbm/kernels/config/config_obs.h": "c11e2249359145b5c4cbaaf0487506fa77c1f4b82c7c169ddc574aa0babcd727",
-    "src/CelerisLab/lbm/kernels/config/config_physics.h": "8ac0990b168e1058588676cc05c80df8634cfd671dbc92a89246c3c372d83a4e",
-    "src/CelerisLab/lbm/kernels/core/descriptors.cuh": "8440bc14857da9007982650f828a23608eec9f7cc4bf772e8c8dc1239cb45356",
-    "src/CelerisLab/lbm/kernels/core/flags.cuh": "0025705f24710330d9d9195f713879bfb650a85a3449baef0e196b831af104ab",
-    "src/CelerisLab/lbm/kernels/core/layout.cuh": "1fbd820021c89ac3efcde24145996cb0147769e607e498e61f308ed3e0b13706",
-    "src/CelerisLab/lbm/kernels/core/obs.cuh": "b742b77c9f61e1f020fe9922c3838ae9d855e17b381154958b58f10a22938922",
-    "src/CelerisLab/lbm/kernels/core/params.cuh": "6e18bf730d936d940e3d85452f0714a2eaae31bf41002f9fd520ec5b372878dd",
-    "src/CelerisLab/lbm/kernels/core/precision.cuh": "849df14b4cce50af52399e4b8f3e997196f3ae5f1163f68e28df3e6b2507a8c4",
-    "src/CelerisLab/lbm/kernels/kernel_v2.cu": "c7bd3fb705b77261ba2441c52a24a7e6a7865c165cba088a1b75201c4d29c408",
-    "src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh": "aee444eb60c47a3fd518dca975d1af05425a0818a0ec6c3fb3f6150f60c2cb44",
-    "src/CelerisLab/lbm/kernels/operators/collision_srt.cuh": "6b7ff842f392c8f853d2d1a97cc69bfe50f21283f73e659404da07cf6c95f5e1",
-    "src/CelerisLab/lbm/kernels/operators/collision_trt.cuh": "9725b9840b9ad8b4ec7be61ff5d06d3151e86d1a87585c13f2fbf934d0d2c5f6",
-    "src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh": "969a430c1af03f32e3bd0df95d805e64f56334717c44dd4ba208ba503062a24b",
-    "src/CelerisLab/lbm/kernels/operators/helpers.cuh": "0b3a4d95d7d19f5fec09e5423b8f4cc99f8a226b541967425967330da5a051ec",
-    "src/CelerisLab/lbm/kernels/operators/macro.cuh": "2be20eb2b7d7f5522daaad7f4b57b1ff8cdf883efe4a67846a96783b2fe846a3",
-    "src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh": "a3db46c2e7d27530b2d1436e65cdbed0b72cc7e047bfbeef2a640877271b51aa",
-    "src/CelerisLab/lbm/kernels/refinement.cu": "b45aad9c022cecb64f7e968ec3cae2d8385a3cc430ee409700c404a3f4dd8cf8",
-    "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "578a5b20a157241ee678547059abb1372dd5a589ad06bb2c15b987eb01ca1013",
-    "src/CelerisLab/lbm/kernels/step/block_channel.cu": "ee8a31398b8e5233d977c816e6b8e060c1eb2ec71320e594226dbca55593c0d0",
-    "src/CelerisLab/lbm/kernels/step/curved_double.cu": "bfa7a1df1e939020314d49755045f7a85fe4a19cc1c68dbe62653c66c5e7c2b3",
-    "src/CelerisLab/lbm/kernels/step/esopull_macro.cu": "c73116020ca217ede1e4de27c8269c31f9d91e33433ac8252a21e9b14187c50f",
-    "src/CelerisLab/lbm/kernels/step/esopull_sync.cu": "c0ff3e72900c3ab89a05dd03684e96d3b740cf1672d565727fc2af165933d087",
-    "src/CelerisLab/lbm/kernels/step/init_flow.cu": "305be3bb12fc0d039acec1701baabcf0e8a35e683c49c34f2af8ca9867d2b29c",
-    "src/CelerisLab/lbm/kernels/step/one_step_double.cu": "f9f8242b38e8e0cf8425b75e2b0215bc15363c62eaa0fb43c761b8e0931bfdc9",
-    "src/CelerisLab/lbm/kernels/step/one_step_esopull.cu": "aa223b2744ae6c9125673df311a96ce588032c1ba58bebb11fd33ecb990f8ed4",
-    "src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh": "dd5a9091628b079efd97e53fd49e52d09dcee88529235db77a5648e02937af6e",
-    "src/CelerisLab/lbm/kernels/streaming/esopull_single_buffer.cuh": "77ed4ab9a0ebc5ff62a91a7c39066ef395391ae36e9040a69fb2bd8b1626dc79",
-    "src/CelerisLab/lbm/kernels/streaming/pull_double_buffer.cuh": "b65d741ed78b7b62f99531ba0c0ce1936663d8dc9640e7d7d16c707f1baf6549",
-    "src/CelerisLab/lbm/population_storage.py": "a6a86c29c52c892edfe4802fb773c387212e3f4cc86708d80e154986ddf88044",
-    "src/CelerisLab/lbm/raw_exchange.py": "9031a196006a0f74dee4028e6f3bb673bc19ef7959f9f04dde9e01f93293aeb3",
-    "src/CelerisLab/lbm/refinement.py": "100d5e46ac894f6008b61364cdad5d37c2ca7ed949d8d71405572d6366526417",
-    "src/CelerisLab/lbm/refinement_stepper.py": "536cd1d3482591e4ff57c4ae8e888c19e31701687d287aa509129df5b2a43be3",
-    "src/CelerisLab/lbm/refinement_tables.py": "0cbc0f29aabd0ab4ba1f912bd4d0ac2b430246584cb6ddf13dd28e10582accf3",
-    "src/CelerisLab/lbm/stepper.py": "0dcb7cd7ae87e33e3dc67a38b6aa43042fbe673e37d9ad165342ee1d695933ce",
-    "src/CelerisLab/lbm/synchronized_remap.py": "7400fc4beaffd4649d6a9c524d38ce5fd6fa7eeb32eb5332e4030a4b6648f197",
-    "src/CelerisLab/simulation.py": "0a03904dc6de88667d7af699005a289adf8b09f0976cb0d099b041f4830a8f4c"
-  },
-  "candidate_header_sha256": "a3db46c2e7d27530b2d1436e65cdbed0b72cc7e047bfbeef2a640877271b51aa",
-  "baseline_header_sha256": "ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501"
-}
@@ -30,7 +30,7 @@ original_module = gate.compile_module
 cache = {}
 def retain_compile(*args, **kwargs):
    result = original_compile(*args, **kwargs)
-    source = kwargs.get('source', 'uniform.cu')
+    source = kwargs.get('source', 'kernel_v2.cu')
    shutil.copyfile(result, a.output / (Path(source).stem + '.ptx'))
    metadata = Path(result + '.json')
    if metadata.exists(): shutil.copyfile(metadata, a.output / (Path(source).stem + '.ptx.json'))
@@ -1,425 +0,0 @@
-"""Bounded exact-source CUDA plumbing gate; never a flow-accuracy certificate.
-
-Run this driver externally against exact dev with --mode baseline first, then
-against the experimental source with --mode candidate --baseline <receipt>.
-Only scalar receipts/hashes and actual compiler sidecars are retained. Whole-step
-mass/momentum are diagnostics: no verified FP32 conservation bound is claimed.
-"""
-import argparse
-from contextlib import contextmanager
-from dataclasses import replace
-import hashlib
-import json
-import os
-import shutil
-from pathlib import Path
-import subprocess
-import sys
-
-import numpy as np
-
-BASE = 'ed9d8c937d446b854d6963bd92d718bb4fb98b96'
-PRODUCTION = 'a135252ae78b47b57d7e77d19001700b3bedac8b'
-STOPS = (0, 1, 2, 8)
-OPERATOR_ATOL, OPERATOR_RTOL = 6e-8, 2e-7
-REST_ATOL, REST_RTOL = 3e-7, 1e-6
-REPLAY_ATOL = 3e-6
-E = np.array([(0,0),(1,0),(-1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)])
-W = np.array([4/9]+[1/9]*4+[1/36]*4)
-
-
-def digest(array):
-    """All finite bits (including signed zero) and exact NaN mask; no NaN payloads."""
-    array = np.asarray(array)
-    if np.isinf(array).any():
-        raise AssertionError('infinite population')
-    finite = np.isfinite(array)
-    h = hashlib.sha256()
-    h.update(str((array.shape, array.dtype.str)).encode())
-    h.update(np.ascontiguousarray(finite).tobytes())
-    h.update(np.ascontiguousarray(array[finite]).tobytes())
-    return h.hexdigest()
-
-
-def independent_explosion(coarse, pair, layout, kind):
-    """Coordinate oracle; never reads the production neighbor/offset tables."""
-    ny, nx = pair.coarse_shape
-    legal = np.zeros((ny,nx), bool)
-    legal.ravel()[pair.ghost_coarse] = True
-    legal &= layout.owned & ~pair.covered & (kind == 0)
-    if not legal.ravel()[pair.ghost_coarse].all():
-        raise AssertionError('illegal center donor')
-    out = np.empty((9,len(pair.ghost_fine)))
-    flat = np.asarray(coarse, np.float64).reshape(9,-1)
-    for row, (target, donor) in enumerate(zip(pair.ghost_fine,pair.ghost_coarse)):
-        y,x = divmod(int(donor),nx)
-        gradient = np.zeros((9,2))
-        for axis, (dx,dy) in enumerate(((1,0),(0,1))):
-            ends = [(x-dx,y-dy),(x+dx,y+dy)]
-            if not layout.periodic[axis] and any(not (0<=xx<nx and 0<=yy<ny) for xx,yy in ends):
-                continue
-            ends = [(xx%nx,yy%ny) for xx,yy in ends]
-            if all(legal[yy,xx] for xx,yy in ends):
-                (xm,ym),(xp,yp) = ends
-                gradient[:,axis] = (flat[:,yp*nx+xp]-flat[:,ym*nx+xm])/2
-        for q in range(1,9):
-            gradient[q] -= E[q]*np.dot(E[q],gradient[q])/np.dot(E[q],E[q])
-        fy,fx = divmod(int(target),pair.fine_shape[1])
-        offset = np.array([pair.fine_origin[0]+(fx+.5)/2-(x+.5),
-                           pair.fine_origin[1]+(fy+.5)/2-(y+.5)])
-        out[:,row] = flat[:,int(donor)] + gradient@offset
-    return out
-
-
-def default_options(selector):
-    # Exact dev has no explosion keyword. Baseline and omitted paths pass none.
-    return {} if selector == 'omitted' else {'explosion':selector}
-
-
-def snapshot(run, raw):
-    from CelerisLab.lbm.refinement import ACTIVE, OUTER_GHOST
-    stored, public = raw(run), run.download()
-    hashes, totals = [], np.zeros(3)
-    for level,(values,visible,kind) in enumerate(zip(stored,public,run.hierarchy.kinds)):
-        active = kind == ACTIVE
-        if not np.isfinite(visible[:,active]).all() or not np.isnan(visible[:,~active]).all():
-            raise AssertionError('public ACTIVE/invalid mask mismatch')
-        if not np.isnan(values[:,kind==OUTER_GHOST]).all():
-            raise AssertionError('OUTER owner core is not poisoned')
-        population = visible[:,active].sum(axis=1,dtype=np.float64)*(.25**level)
-        totals += np.r_[population.sum(), E.T@population]
-        hashes.append(dict(raw=digest(values), public=digest(visible), active=int(active.sum())))
-    if not np.isfinite(totals).all():
-        raise AssertionError('nonfinite mass/momentum diagnostic')
-    return dict(step=run.step_count, levels=hashes, mass_momentum=totals.tolist())
-
-
-def initialize(run, rest=False):
-    arrays, origin, spacing = [], np.zeros(2), 1.
-    for index,level in enumerate(run._levels):
-        if index:
-            origin += spacing*np.asarray(run.hierarchy.pairs[index-1].fine_origin)
-            spacing /= 2
-        y,x = np.indices(level.shape[1:],dtype=np.float64)
-        x,y = origin[0]+spacing*(x+.5),origin[1]+spacing*(y+.5)
-        q = np.arange(9)[:,None,None]
-        values = np.broadcast_to(W[:,None,None],level.shape).copy()
-        if not rest:
-            # q-distinct smooth non-equilibrium G; same physical frame on all levels.
-            values += 1e-4*np.sin(.17*x+.23*y+q)
-        arrays.append(values)
-    run.initialize(*arrays)
-
-
-def operator_case(run, index):
-    import pycuda.driver as cuda
-    parent,child = run._levels[index:index+2]
-    geometry,pair = run.hierarchy.pairs[index],run._pairs[index]
-    c = np.random.default_rng(19+index).normal(0,.001,(9,*geometry.coarse_shape))
-    if not run._ddf_shifting:
-        c += W[:,None,None]
-    c = c.astype(np.float32)
-    legal = np.zeros(geometry.coarse_shape,bool)
-    legal.ravel()[geometry.ghost_coarse] = True
-    c[:,~legal] = np.nan
-    packed = parent.layout.to_blocked(c)
-    output = np.full(child.layout.blocked_shape,np.nan,np.float32)
-    cuda.memcpy_htod(parent.current,packed)
-    cuda.memcpy_htod(child.current,output)
-    calls, hop = [],run._hop
-    try:
-        run._hop = lambda *a,**kw: calls.append(a)
-        run._advance(index+1,parent.current,block=run._block,stream=run._stream)
-        run._stream.synchronize()
-    finally:
-        run._hop = hop
-    if calls != [(index+1,child.current,child.spare),(index+1,child.spare,child.current)]:
-        raise AssertionError('explosion changed two-hop launch contract')
-    cuda.memcpy_dtoh(output,child.current)
-    target = child.layout.owner.ravel()[geometry.ghost_fine]
-    slots = np.array([child.layout.slot(target,q) for q in range(9)])
-    actual = output.ravel()[slots]
-    expected = independent_explosion(c,geometry,parent.layout,run.hierarchy.kinds[index])
-    constant = c.reshape(9,-1)[:,geometry.ghost_coarse]
-    if not np.isfinite(actual).all() or np.max(abs(expected-constant)) <= 1e-5:
-        raise AssertionError('operator must exercise finite nonzero projected slopes')
-    np.testing.assert_allclose(actual,expected,atol=OPERATOR_ATOL,rtol=OPERATOR_RTOL)
-    untouched = np.ones(output.size,bool); untouched[slots.ravel()] = False
-    if not np.isnan(output.ravel()[untouched]).all():
-        raise AssertionError('explosion wrote outside its targets')
-    return dict(pair=index,rows=len(target),parent_stride=pair.parent_cells,
-                child_stride=int(np.prod(child.layout.local_shape)),
-                max_error_by_q=np.max(abs(actual-expected),axis=1).tolist(),
-                nonzero_projection=True,poisoned_nondonors=True,untouched_preserved=True)
-
-
-def replay_two_hops(values, pair, layout, kind):
-    """Existing FP64 two-hop algebra, using the independent coordinate oracle."""
-    from tests.unit.test_projected_explosion import collide
-    coarse,fine = (a.copy() for a in values)
-    fine.reshape(9,-1)[:,pair.ghost_fine] = independent_explosion(coarse,pair,layout,kind)
-    for _ in range(2):
-        fine = np.array([np.roll(fine[q],(ey,ex),(0,1)) for q,(ex,ey) in enumerate(E)])
-        fine[:,pair.fine_kind==2] = np.nan
-        active = pair.fine_kind==0
-        fine[:,active] = collide(fine[:,active],pair.tau_fine)
-    out = np.array([np.roll(coarse[q],(ey,ex),(0,1)) for q,(ex,ey) in enumerate(E)])
-    out.reshape(-1)[pair.coalesce_coarse] = fine.reshape(-1)[pair.coalesce_fine].mean(axis=1)
-    out[:,~pair.covered] = collide(out[:,~pair.covered],pair.tau_coarse)
-    out[:,pair.covered] = np.nan
-    return out,fine
-
-
-def run_case(ctx, case, shifted, selector, raw, projected=False, replay=False):
-    from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
-    cfg,refs,blocks = case
-    cfg = replace(cfg,velocity=0,ddf_shifting=shifted)
-    with FixedPatchStepper(cfg,context=ctx,refinements=refs,level_blocks=blocks,
-                           **default_options(selector)) as run:
-        operator = [operator_case(run,i) for i in range(len(run._pairs))] if projected else []
-        counts = [0]*len(run._levels)
-        for index,level in enumerate(run._levels):
-            def counted(*a, index=index, kernel=level.kernel, **kw):
-                counts[index] += 1
-                return kernel(*a,**kw)
-            level.kernel = counted
-        def check_counts(stop):
-            if counts != [stop*2**index for index in range(len(counts))]:
-                raise AssertionError('actual level hop counts differ from acoustic schedule')
-        rest = []
-        if projected:
-            initialize(run,rest=True)
-            for stop in STOPS:
-                run.step(stop-run.step_count)
-                check_counts(stop)
-                snapshot(run,raw)  # actual public and raw invalid masks at every stop
-                maximum = 0.
-                for values,kind in zip(run.download(),run.hierarchy.kinds):
-                    active = values[:,kind==0]
-                    np.testing.assert_allclose(active,np.broadcast_to(W[:,None],active.shape),
-                                               atol=REST_ATOL,rtol=REST_RTOL)
-                    maximum = max(maximum,float(np.max(abs(active-W[:,None]))))
-                rest.append(dict(step=stop,max_absolute_error=maximum))
-        counts[:] = [0]*len(counts)
-        initialize(run)
-        reference = tuple(a.astype(np.float64) for a in run.download()) if replay else None
-        snapshots,replay_errors,previous = [],[],0
-        for stop in STOPS:
-            run.step(stop-run.step_count)
-            if replay:
-                for _ in range(stop-previous):
-                    reference = replay_two_hops(reference,run.hierarchy.pairs[0],
-                                               run._levels[0].layout,run.hierarchy.kinds[0])
-                errors = []
-                for actual,expected,kind in zip(run.download(),reference,run.hierarchy.kinds):
-                    np.testing.assert_allclose(actual[:,kind==0],expected[:,kind==0],
-                                               atol=REPLAY_ATOL,rtol=0)
-                    errors.append(np.max(abs(actual[:,kind==0]-expected[:,kind==0]),axis=1).tolist())
-                replay_errors.append(dict(step=stop,max_error_by_level_q=errors))
-            check_counts(stop)
-            snapshots.append(dict(snapshot(run,raw),observed_level_hops=counts.copy())); previous = stop
-        change = (np.array(snapshots[-1]['mass_momentum'])-
-                  np.array(snapshots[0]['mass_momentum'])).tolist()
-        return dict(operator=operator,snapshots=snapshots,rest_fixed_point=rest,
-                    replay_max_errors=replay_errors,mass_momentum_change_diagnostic=change,
-                    conservation_status='diagnostic_only_no_FP32_bound')
-
-
-def compare_snapshots(actual,expected):
-    if len(actual) != len(expected):
-        raise AssertionError('snapshot count differs')
-    for got,want in zip(actual,expected):
-        if (got['step'] != want['step'] or got['levels'] != want['levels']
-                or got.get('observed_level_hops') != want.get('observed_level_hops')):
-            raise AssertionError('owner bits, public values or masks differ')
-
-
-def cases():
-    from CelerisLab.config import LBMConfig
-    from tests.unit.test_hierarchy import CFG, FOUR
-    scalar = (LBMConfig(nx=16,ny=16,viscosity=.02),
-              [(4,4,12,12),(8,8,16,16),(8,8,16,16)],
-              [(4,4),(4,8),(6,4),(4,6)])
-    four = (CFG,FOUR,[(6,8),(8,6),(12,8),(16,12)])
-    concave = (LBMConfig(nx=30,ny=30,viscosity=.1),
-               [[(4,4,5,7),(4,5,7,7)]],[(6,5),(4,6)])
-    return dict(scalar=scalar,four=four,concave=concave)
-
-
-def baseline_receipt(receipt, driver_hash, keys):
-    if (receipt.get('completed') is not True or receipt.get('dry_run') is not False
-            or receipt.get('mode') != 'baseline' or receipt.get('production_revision') != BASE
-            or receipt.get('source',{}).get('revision') != BASE
-            or receipt.get('source',{}).get('dirty') is not False
-            or receipt.get('driver_sha256') != driver_hash
-            or receipt.get('stops') != list(STOPS)
-            or receipt.get('operator_tolerance') != [OPERATOR_ATOL,OPERATOR_RTOL]
-            or receipt.get('rest_tolerance') != [REST_ATOL,REST_RTOL]
-            or receipt.get('replay_tolerance') != [REPLAY_ATOL,0]
-            or set(receipt.get('default_snapshots',{})) != set(keys)
-            or not receipt.get('actual_build_sidecars')):
-        raise ValueError('baseline receipt does not match the frozen exact-dev gate')
-    return receipt
-
-
-def remap_case(ctx, shifted, raw):
-    from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
-    cfg,refs,blocks = cases()['four']
-    with FixedPatchStepper(replace(cfg,velocity=0,ddf_shifting=shifted),context=ctx,
-            refinements=refs[:2],level_blocks=blocks[:3],explosion='projected_linear') as run:
-        initialize(run); run.step(1)
-        before = snapshot(run,raw)
-        with run.remap_child([(22,22,42,42),(72,68,76,76)]) as clone:
-            if clone._explosion != 'projected_linear' or any(p.neighbors is None for p in clone._pairs):
-                raise AssertionError('remap lost projected selection')
-            if clone.step_count != 1: raise AssertionError('remap lost synchronized count')
-            initial = snapshot(clone,raw)
-            clone.step(1)
-            after = snapshot(clone,raw)
-            if clone.step_count != 2: raise AssertionError('remap did not continue count')
-        compare_snapshots([snapshot(run,raw)],[before])
-        return dict(shifted=shifted,source_unchanged=True,initial=initial,continued=after)
-
-
-@contextmanager
-def capture_builds(report, save, baseline=None):
-    from CelerisLab.cuda import compiler_v2 as compiler
-    original = compiler.load_module
-    def load(path):
-        path = Path(path)
-        metadata = json.loads(Path(str(path)+'.json').read_text())
-        if metadata['ptx_sha256'] != hashlib.sha256(path.read_bytes()).hexdigest():
-            raise AssertionError('actual PTX and build sidecar disagree')
-        if baseline and (metadata['arch'],metadata['flags']) not in [
-                (m['arch'],m['flags']) for m in baseline['actual_build_sidecars']]:
-            raise AssertionError('baseline build architecture or flags differ')
-        report['actual_build_sidecars'].append(metadata)
-        save()  # capture AMR metadata before production cleanup removes scratch
-        return original(str(path))
-    compiler.load_module = load
-    try:
-        yield
-    finally:
-        compiler.load_module = original
-
-
-def preflight(repo, revision, mode):
-    git = lambda *a: subprocess.check_output(['git','-C',str(repo),*a],text=True).strip()
-    if git('rev-parse','HEAD') != revision or git('status','--porcelain'):
-        raise ValueError('requires the exact expected clean checkout')
-    source = BASE if mode == 'baseline' else PRODUCTION
-    if mode == 'baseline' and revision != BASE:
-        raise ValueError('baseline must be exact ed9d8c9')
-    if subprocess.call(['git','-C',str(repo),'diff','--quiet',source,'--','src']):
-        raise ValueError('production source differs from the frozen source revision')
-    return source
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument('--repo',type=Path,required=True)
-    parser.add_argument('--expected-revision',required=True)
-    parser.add_argument('--mode',choices=('baseline','candidate'),required=True)
-    parser.add_argument('--baseline',type=Path)
-    parser.add_argument('--output',type=Path,required=True)
-    parser.add_argument('--run-gpu',action='store_true')
-    parser.add_argument('--dry-run',action='store_true')
-    args = parser.parse_args()
-    if args.output.exists(): parser.error('output already exists')
-    selected = os.environ.get('CUDA_VISIBLE_DEVICES','')
-    if not args.dry_run and (not args.run_gpu or not selected or ',' in selected or selected=='-1'):
-        parser.error('--run-gpu and exactly one explicit CUDA_VISIBLE_DEVICES are required')
-    repo = args.repo.resolve()
-    source = preflight(repo,args.expected_revision,args.mode)
-    baseline = None
-    if args.mode == 'candidate':
-        if args.baseline is None: parser.error('candidate requires --baseline receipt')
-        baseline = json.loads(args.baseline.read_text())
-    sys.path[:0] = [str(repo/'src'),str(repo),str(repo/'tests/validation/multigrid'),
-                   str(repo/'tests/validation/taylor_green')]
-    import CelerisLab
-    if Path(CelerisLab.__file__).resolve() != repo/'src/CelerisLab/__init__.py':
-        raise RuntimeError('wrong imported checkout')
-    from run_case import provenance
-    driver_hash = hashlib.sha256(Path(__file__).read_bytes()).hexdigest()
-    keys = [f'{name}:shifted={shifted}' for name in cases() for shifted in (False,True)]
-    if baseline is not None: baseline_receipt(baseline,driver_hash,keys)
-    report = dict(mode=args.mode,production_revision=source,source=provenance(repo),
-                  driver_sha256=driver_hash,
-                  device_selection=selected,completed=False,dry_run=args.dry_run,
-                  operator_tolerance=[OPERATOR_ATOL,OPERATOR_RTOL],
-                  rest_tolerance=[REST_ATOL,REST_RTOL],replay_tolerance=[REPLAY_ATOL,0],stops=STOPS,
-                  conservation_status='diagnostic_only_no_FP32_bound',
-                  actual_build_sidecars=[],default_snapshots={},default_equivalence=[],
-                  projected_operator=[],union_multilevel_smoke=[],changed_remap=[])
-    args.output.parent.mkdir(parents=True,exist_ok=True)
-    def save():
-        text = json.dumps(report,indent=2,allow_nan=False)+'\n'
-        if len(text.encode()) > 8*1024*1024: raise RuntimeError('receipt exceeds 8 MiB cap')
-        temporary = args.output.with_suffix(args.output.suffix+'.tmp')
-        temporary.write_text(text); os.replace(temporary,args.output)
-    save()
-    if args.dry_run:
-        print('Source preflight only; no CUDA imports or execution.'); return
-    try:
-        from CelerisLab.cuda.context import CudaContext
-        from test_refinement_blocked_base import raw
-        with CudaContext(0) as ctx, capture_builds(report,save,baseline):
-            import pycuda.driver as cuda
-            report['device'] = dict(name=ctx.device.name(),pci_bus_id=ctx.device.pci_bus_id(),
-                                    capability=list(ctx.device.compute_capability()),
-                                    driver=cuda.get_driver_version(),runtime=list(cuda.get_version()))
-            nvcc = shutil.which('nvcc') or '/usr/local/cuda/bin/nvcc'
-            report['nvcc_version'] = subprocess.check_output([nvcc,'--version'],text=True).strip()
-            if baseline and (report['device'] != baseline.get('device')
-                             or report['nvcc_version'] != baseline.get('nvcc_version')
-                             or selected != baseline.get('device_selection')):
-                raise ValueError('baseline GPU/device selection or toolchain differs')
-            for name,case in cases().items():
-                for shifted in (False,True):
-                    key = f'{name}:shifted={shifted}'
-                    report['active_case'] = f'default:{key}'
-                    result = run_case(ctx,case,shifted,'omitted',raw)
-                    report['default_snapshots'][key] = result['snapshots']
-                    if baseline:
-                        compare_snapshots(result['snapshots'],baseline['default_snapshots'][key])
-                        explicit = run_case(ctx,case,shifted,'constant',raw)
-                        compare_snapshots(explicit['snapshots'],result['snapshots'])
-                        report['default_equivalence'].append(dict(case=key,passed=True))
-                    save()
-            if baseline:
-                for name,case in cases().items():
-                    for shifted in (False,True):
-                        report['active_case'] = f'projected:{name}:shifted={shifted}'
-                        result = run_case(ctx,case,shifted,'projected_linear',raw,True,name=='concave')
-                        cfg,refs,blocks = case
-                        if name == 'four':
-                            variant_refs = [list(reversed(rects)) for rects in refs]
-                        elif name == 'concave':
-                            variant_refs = [[(4,5,7,7),(4,4,5,5)]]  # same union, disjoint decomposition
-                        else:
-                            variant_refs = refs
-                        variant = (cfg,variant_refs,[(2,2)]*len(blocks))
-                        alternate = run_case(ctx,variant,shifted,'projected_linear',raw,True)
-                        compare_snapshots(alternate['snapshots'],result['snapshots'])
-                        report['projected_operator'].append(dict(case=name,shifted=shifted,rows=result['operator']))
-                        report['union_multilevel_smoke'].append(dict(case=name,shifted=shifted,result=result,
-                                                                   alternate_bits_identical=True))
-                        save()
-                for shifted in (False,True):
-                    report['active_case'] = f'changed-remap:shifted={shifted}'
-                    report['changed_remap'].append(remap_case(ctx,shifted,raw)); save()
-                expected_builds = {(s['arch'],tuple(s['flags'])) for s in baseline['actual_build_sidecars']}
-                actual_builds = {(s['arch'],tuple(s['flags'])) for s in report['actual_build_sidecars']}
-                if actual_builds != expected_builds:
-                    raise AssertionError('baseline build architecture or compiler flags differ')
-            report['completed'] = True
-            save()
-    except Exception as error:
-        report['error'] = f'{type(error).__name__}: {error}'
-        save(); raise
-    print(json.dumps(dict(completed=True,mode=args.mode,receipt=str(args.output))))
-
-
-if __name__ == '__main__':
-    main()
@@ -0,0 +1,263 @@
+"""Four opt-in shifted GPU controls: U64/U128/U256 and refined base128/fine256."""
+import argparse
+import hashlib
+import inspect
+import json
+import os
+from pathlib import Path
+import resource
+import subprocess
+import time
+
+import numpy as np
+import run_spacetime_gpu_n64 as old
+
+gpu,ref,tg,ROOT = old.gpu,old.ref,old.tg,old.ROOT
+BASE='26d0d3853c9d4d3cd6ae3f27653dced56f8c5fec'
+REFERENCE_SHA='9d154c989b087bf288f86d413db0f3067b73767b618c329d4b9e53c4eee00032'
+CASES=(('uniform64',64,False),('uniform128',128,False),('uniform256',256,False),('refined128',128,True))
+LIMITS=old.LIMITS
+SECONDS,RSS_MIB=600.,512.
+
+
+def setup(n, refined):
+    return dict(base_n=n,finest_n=2*n if refined else n,normalized_domain=[0.,1.,0.,1.],
+        re_L=100,U=.03,mach=.03*np.sqrt(3),viscosity=.0003*n,
+        tau=[.5+.0009*n]+([.5+.0018*n] if refined else []),
+        bounds=[n//8,n//8,7*n//8,3*n//4] if refined else None,
+        normalized_patch=[.125,.125,.875,.75] if refined else None,
+        intervals=16*n,sample_steps=[4*n,8*n,12*n,16*n],sample_times=list(old.TIMES),
+        early_steps=list(range(0,4*n+1,n//16)),early_times=(np.arange(65)*.001875).tolist(),
+        phase='arrival_f',storage='shifted_FP32',collision='SRT',
+        initialization='common analytic FP64 equilibrium at actual cell centers, production shifted codec')
+
+
+def pressure_projection(arrays,masks,t,n,viscosity):
+    """One global gauge and a weighted Gram fit, including unequal leaf areas."""
+    rows=[]
+    for level,(a,mask) in enumerate(zip(arrays,masks)):
+        rho=np.asarray(a[:,mask],np.float64).sum(axis=0)
+        x,y=tg.centers(mask.shape,level); x,y=x[mask],y[mask]
+        exact=tg.exact(x,y,t,n,viscosity)[2]
+        angle=4*np.pi/n
+        basis=np.column_stack((np.cos(angle*x),np.sin(angle*x),np.cos(angle*y),np.sin(angle*y)))
+        rows.append(((rho-1)/3,exact,np.full(len(rho),.25**level),basis))
+    p,exact,w,b=[np.concatenate(x) for x in zip(*rows)]
+    volume=w.sum(); p-=w@p/volume; exact-=w@exact/volume; e=p-exact
+    b-=w@b/volume
+    gram=b.T@(w[:,None]*b); rhs=b.T@(w*e)
+    coefficients=np.linalg.solve(gram,rhs); residual=e-b@coefficients
+    norm=float(w@(e*e)); exact_norm=float(w@(exact*exact)); remaining=float(w@(residual*residual))
+    projected=float(coefficients@gram@coefficients)
+    return dict(step=t,tstar=t*.03/n,absolute_rms=np.sqrt(norm/volume),relative_rms=np.sqrt(norm/exact_norm),
+        coefficients=coefficients.tolist(),basis=['cos_4pi_x','sin_4pi_x','cos_4pi_y','sin_4pi_y'],
+        residual_rms=np.sqrt(remaining/volume),residual_relative=np.sqrt(remaining/exact_norm),
+        gram_condition=float(np.linalg.cond(gram)),
+        orthogonality=(b.T@(w*residual)/volume).tolist(),energy_closure=(norm-projected-remaining)/volume)
+
+
+def load_reference(path):
+    if old.sha(path)!=REFERENCE_SHA:
+        raise ValueError('verified shifted N64 receipt differs')
+    data=json.loads(Path(path).read_text())
+    if (not data['completed'] or not data['passed'] or data['source']['commit']!=BASE
+            or data['setup']['storage']!='shifted_FP32' or data['setup']['bounds']!=[8,8,56,48]
+            or data['setup']['interval_count']!=1024 or len(data['rows'])!=4):
+        raise ValueError('N64 reference identity differs')
+    if tuple(row['tstar'] for row in data['rows'])!=old.TIMES:
+        raise ValueError('N64 reference sample times differ')
+    return data
+
+
+def source_identity(reference):
+    git=lambda *args:subprocess.check_output(['git',*args],cwd=ROOT,text=True).strip()
+    if git('status','--porcelain'):
+        raise RuntimeError('clean committed checkout required')
+    unchanged=['src','tests/validation/taylor_green/oracle.py']+[f'tests/validation/multigrid/{name}' for name in
+        ('spacetime_gpu.cu','spacetime_reference.py','cpu_reference.py','run_spacetime_gpu_n64.py','test_spacetime_gpu.py')]
+    subprocess.check_call(['git','diff','--exit-code',BASE,'--',*unchanged],cwd=ROOT)
+    previous=subprocess.check_output(['git','show',f'{BASE}:tests/validation/multigrid/spacetime_gpu.py'],cwd=ROOT,text=True)
+    # The raw interval schedule remains byte-for-byte unchanged despite the new owner.
+    method=inspect.getsource(gpu.SpaceTimeGPU.step)
+    if method not in previous or np.__version__!=reference['source']['numpy']:
+        raise RuntimeError('raw schedule or NumPy identity changed')
+    files=[Path(__file__),Path(gpu.__file__),Path(old.table_guard.__file__),Path(__file__).with_name('test_spacetime_gpu_ladder.py')]
+    return dict(commit=git('rev-parse','HEAD'),dirty=False,numpy=np.__version__,production_tree=git('rev-parse','HEAD:src'),
+        hashes={p.name:old.sha(p) for p in files},cuda_sha256=old.sha(Path(gpu.__file__).with_suffix('.cu')),
+        raw_schedule_sha256=hashlib.sha256(method.encode()).hexdigest(),unchanged_against=BASE,
+        reference_hashes=gpu.PINS)
+
+
+def directional(arrays,masks):
+    return sum(.25**level*np.asarray(a[:,m],np.float64).sum(axis=1) for level,(a,m) in enumerate(zip(arrays,masks)))
+
+
+def populations(run,refined,*,raw=False):
+    state=run._download_stored() if raw else run.download()
+    if not refined:
+        return (state,)
+    if state.phase!='arrival_f' or state.tick!=2*run.step_count:
+        raise AssertionError('refined sample is not synchronized arrival F')
+    return state.coarse_f,state.fine_f
+
+
+def assess(rows,health):
+    checks={key:all(np.isfinite(row[key]) and 0<=row[key]<=limit for row in rows) for key,limit in LIMITS.items()}
+    checks['population_health']=not any(health)
+    checks['sampled_population_positive']=all(row['minimum_population']>0 for row in rows)
+    return dict(worst={key:max(row[key] for row in rows) for key in LIMITS},campaign_checks=checks,
+        campaign_pass=all(checks.values()),accuracy_comparison_status='descriptive_only_no_new_threshold')
+
+
+def ratios(a,b,*,trend=False):
+    out=dict(ratio=a/b if b>0 else None,ratio_status='defined' if b>0 else 'zero_denominator')
+    if trend:
+        out.update(two_point_slope=np.log2(a/b) if a>0 and b>0 else None,
+            slope_status='defined' if a>0 and b>0 else 'zero_error_log_undefined')
+    return out
+
+
+def comparisons(runs,reference):
+    data={r['name']:r for r in runs}; data['refined64']=reference
+    out=[]
+    for refined,base,fine in (('refined64','uniform64','uniform128'),('refined128','uniform128','uniform256')):
+        for control in (base,fine):
+            out.append(dict(candidate=refined,control=control,control_spacing='base' if control==base else 'finest',
+                samples=[dict(tstar=a['tstar'],**{key:dict(candidate=a[key],control=b[key],**ratios(a[key],b[key]))
+                    for key in ('velocity_l2','pressure_l2','energy_relative')})
+                    for a,b in zip(data[refined]['rows'],data[control]['rows'])]))
+    trends=[]
+    for coarse,fine in (('uniform64','uniform128'),('uniform128','uniform256'),('refined64','refined128')):
+        trends.append(dict(coarse=coarse,fine=fine,samples=[dict(tstar=a['tstar'],**{
+            key:ratios(a[key],b[key],trend=True)
+            for key in ('velocity_l2','pressure_l2','energy_relative')})
+            for a,b in zip(data[coarse]['rows'],data[fine]['rows'])]))
+    return dict(controls=out,trends=trends,caveat='norm differences are not interface error; fixed Mach and two refined sizes do not certify convergence')
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--gpu-admitted',action='store_true'); p.add_argument('--reference-n64',type=Path,required=True)
+    p.add_argument('--output',type=Path,required=True); args=p.parse_args()
+    if not args.gpu_admitted or not os.environ.get('CUDA_VISIBLE_DEVICES'):
+        p.error('explicit GPU admission and CUDA_VISIBLE_DEVICES required')
+    if args.output.exists() or args.output.with_suffix(args.output.suffix+'.tmp').exists(): p.error('output or partial receipt exists; preserve it')
+    reference=load_reference(args.reference_n64); source=source_identity(reference); gpu.check_sources()
+    started=time.monotonic()
+    report=dict(completed=False,passed=False,source=source,runs=[],limits=dict(seconds=SECONDS,peak_rss_mib=RSS_MIB),
+        campaign_limits=LIMITS,reference=dict(sha256=REFERENCE_SHA,source=reference['source'],
+        coverage='verified refined base64/fine128 four-time rows only; early pressure trace unavailable'),
+        historical_pressure_gate=dict(scope='reused_refined64_only',**reference['historical_pressure_gate']),
+        n64_experimental_screen=dict(scope='reused_refined64_only',checks=reference['experimental_checks']),
+        frozen_cases=[setup(n,r) for _,n,r in CASES],early_trace_scope='65 predeclared rows per new run, no field snapshots',
+        cuda_visible_devices=os.environ['CUDA_VISIBLE_DEVICES'])
+    run=context=ledger=None
+    case_started=None
+    def save():
+        report['resources']=dict(seconds=time.monotonic()-started,peak_rss_mib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024,
+            rss_scope='Python process peak; external wrapper monitors process group and wall time')
+        report['resources']['within_limits']=report['resources']['seconds']<=SECONDS and report['resources']['peak_rss_mib']<=RSS_MIB
+        if report['completed'] and not report['resources']['within_limits']: report['passed']=False
+        if run is not None:
+            report['runs'][-1].update(completed_intervals=run.step_count,health_counts=run.health_counts.tolist(),
+                seconds=time.monotonic()-case_started)
+            if ledger is not None:
+                report['runs'][-1].update(ledger=ledger.snapshot(),audited_intervals=ledger.steps)
+        temporary=args.output.with_suffix(args.output.suffix+'.tmp')
+        ref.write_receipt(temporary,report); os.replace(temporary,args.output)
+    def cap():
+        if time.monotonic()-started>SECONDS or resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024>RSS_MIB:
+            raise RuntimeError('frozen aggregate resource cap exceeded')
+    save()
+    try:
+        from CelerisLab.cuda.context import CudaContext
+        context=CudaContext(0)
+        if context.name!=reference['device'] or context.sm_arch!=reference['sm_arch']:
+            raise RuntimeError('matched reference device identity differs')
+        report.update(device=context.name,sm_arch=context.sm_arch)
+        for name,n,refined in CASES:
+            cap(); ledger=None; case_started=time.monotonic(); cfg=old.LBMConfig(nx=n,ny=n,viscosity=.0003*n,velocity=0.,ddf_shifting=True)
+            case=dict(name=name,setup=setup(n,refined),completed=False,phase='setup',rows=[],early_pressure=[],prefixes=[],health_counts=[0]*6,
+                ledger_scope='all intervals; fine/transfer components are mathematically absent for uniform runs')
+            report['runs'].append(case); save()
+            run=gpu.SpaceTimeGPU(cfg,tuple(case['setup']['bounds']),context=context,allow_n128=True) if refined else gpu.UniformGPU(cfg,context=context)
+            case.update(build_metadata=run.build_metadata,device_allocations_bytes=run.device_bytes,
+                device_memory_scope='owner allocations; excludes driver/context/compiler')
+            expected_modules=None
+            if not refined and n in (64,128): expected_modules=[reference['build_metadata'][0 if n==64 else 1]]
+            if refined: expected_modules=[report['runs'][1]['build_metadata'][0],report['runs'][2]['build_metadata'][0]]
+            if expected_modules is not None:
+                if run.build_metadata!=expected_modules: raise RuntimeError('matched source/config/PTX metadata differs')
+                case['matched_build_metadata']=True
+            if any(m['flags']!=reference['build_metadata'][0]['flags'] for m in run.build_metadata):
+                raise RuntimeError('compiler flags differ from reference')
+            if refined:
+                case['tables']=old.table_guard.validate_tables(run.plan,run.tables,allow_n128=True)
+                masks=(run.plan.maps.coarse_active,run.plan.maps.fine_active)
+            else: masks=(np.ones((n,n),bool),)
+            analytic=tuple(tg.initial(m.shape,l,n,cfg.viscosity) for l,m in enumerate(masks))
+            initial=ref.cpu.State(*analytic) if refined else analytic[0]
+            physical=lambda:populations(run,refined)
+            stored=lambda:populations(run,refined,raw=True)
+            run.initialize(initial); raw0=stored(); direction0=directional(raw0,masks)
+            case['phase']='warm_reset'; warm_started=time.monotonic()
+            for _ in range(32): cap(); run.step()
+            case['warmup_seconds']=time.monotonic()-warm_started
+            run.initialize(initial)
+            for a,b in zip(raw0,stored()): np.testing.assert_array_equal(a.view(np.uint32),b.view(np.uint32))
+            if run.step_count or run.health_counts.any(): raise AssertionError('warm reset failed')
+            case['raw_reset_verified']=True; arrays=physical()
+            first=tg.metrics(arrays,masks,0,n,cfg.viscosity); mass0=first['mass']; moment0=ref.cpu.MOMENTS.T@directional(arrays,masks)
+            case['initial']=dict(mass=mass0,momentum=moment0[1:].tolist(),minimum_population=min(float(a[:,m].min()) for a,m in zip(arrays,masks)))
+            case['initial_quantization']=[float(abs(a[:,m]-b[:,m]).max()) for a,b,m in zip(arrays,analytic,masks)]
+            case['early_pressure'].append(pressure_projection(arrays,masks,0,n,cfg.viscosity))
+            ledger=old.LedgerTotals(); case['phase']='trajectory'; trajectory_started=time.monotonic()
+            case['all_interval_mass']=dict(maximum_relative=0.,step=0,signed_change_at_maximum=0.,limit=LIMITS['mass_relative'],passed=True)
+            for step in range(1,16*n+1):
+                cap(); measured=run.step(); ledger.add(measured)
+                if run.step_count!=step: raise AssertionError('interval count differs')
+                mass_change=float(ledger.sums[0].sum()); drift=abs(mass_change)/mass0
+                if drift>case['all_interval_mass']['maximum_relative']:
+                    case['all_interval_mass'].update(maximum_relative=drift,step=step,signed_change_at_maximum=mass_change,passed=drift<=LIMITS['mass_relative'])
+                if step in case['setup']['early_steps'] or step in case['setup']['sample_steps']:
+                    arrays=physical()
+                    if step in case['setup']['early_steps']:
+                        case['early_pressure'].append(pressure_projection(arrays,masks,step,n,cfg.viscosity)); save()
+                    if step in case['setup']['sample_steps']:
+                        row=tg.metrics(arrays,masks,step,n,cfg.viscosity,mass0)
+                        row.update(step=step,momentum_change=(ref.cpu.MOMENTS.T@directional(arrays,masks)-moment0)[1:].tolist(),
+                            mass_change=row['mass']-mass0,minimum_population=min(float(a[:,m].min()) for a,m in zip(arrays,masks)))
+                        if not all(np.isfinite(v).all() for v in row.values()): raise FloatingPointError('nonfinite sampled metric')
+                        case['rows'].append(row); prefix=ledger.snapshot(directional(stored(),masks)-direction0)
+                        prefix['physical_minus_raw_endpoint_moments']=(ref.cpu.MOMENTS.T@directional(arrays,masks)-moment0-ref.cpu.MOMENTS.T@np.array(prefix['endpoint_directional_change'])).tolist()
+                        case['prefixes'].append(prefix)
+                        if not prefix['closure_pass'] or not prefix['component_split_pass']: raise AssertionError('cumulative budget failed')
+                        save(); print(json.dumps(dict(case=name,**row),allow_nan=False),flush=True)
+            case.update(assess(case['rows'],run.health_counts))
+            cap(); case.update(completed=True,phase='completed',health_counts=run.health_counts.tolist(),audited_intervals=ledger.steps,
+                ledger=ledger.snapshot(),trajectory_seconds=time.monotonic()-trajectory_started,seconds=time.monotonic()-case_started)
+            case['passed']=case['campaign_pass'] and case['all_interval_mass']['passed'] and ledger.steps==16*n and len(case['early_pressure'])==65
+            run.close(); run=None; save()
+        cap(); report.update(completed=True,passed=all(c['passed'] for c in report['runs']),comparisons=comparisons(report['runs'],reference))
+    except Exception as exc:
+        report['failure']=repr(exc)
+        raise
+    finally:
+        if run is not None and ledger is not None:
+            current=report['runs'][-1]
+            current['failure_endpoint_status']='unavailable_owner_not_ready'
+            if run.status=='ready':
+                try:
+                    current['failure_endpoint']=ledger.snapshot(directional(populations(run,refined,raw=True),masks)-direction0)
+                    current['failure_endpoint_status']='measured'
+                except Exception as exc: current['failure_endpoint_status']=repr(exc)
+        for owner in (run,context):
+            if owner is not None:
+                try: owner.close()
+                except Exception as exc: report.setdefault('cleanup_errors',[]).append(repr(exc)); report['passed']=False
+        save()
+    return 0 if report['passed'] else 1
+
+
+if __name__=='__main__':
+    raise SystemExit(main())
@@ -0,0 +1,392 @@
+"""Opt-in, frozen N64 space-time GPU trajectory; no convergence certification."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import resource
+import subprocess
+import sys
+import time
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(ROOT/'src'))
+sys.path.insert(0, str(Path(__file__).parents[1]/'taylor_green'))
+from CelerisLab.config import LBMConfig
+import oracle as tg
+import spacetime_gpu as gpu
+import spacetime_table_guard as table_guard
+ref = gpu.ref
+
+CPU_SHA = '180eef90a1c3f43113fe18cc54981ee4723cfc0cc2724334907ff188022fa770'
+UNIFORM_SHA = '01e7415ae39456f2de7f0c3d331afb971c49d19353b43038650e32e80737f1e7'
+CUDA_SHA = 'afea11ea4a1c2c3800b2f6a7a8e81f5568989fc9e1cc02fb52d7e1ea3864e003'
+AUDIT_SHA = 'fba340b1533bec308b666ee84666df0ac9d08e2872be31ee379e2d1447565158'
+STEPS = (256, 512, 768, 1024)
+TIMES = (.12, .24, .36, .48)
+FACTORS = dict(velocity_l2=.8, pressure_l2=1., energy_relative=1.)
+LIMITS = dict(velocity_l2=.05, pressure_l2=.15, energy_relative=.05, mass_relative=1e-5)
+HEALTH = ('boundary_pre_nonfinite', 'boundary_pre_nonpositive', 'boundary_stored_nonfinite',
+          'boundary_stored_nonpositive', 'physical_population_nonfinite', 'physical_population_nonpositive')
+
+
+def sha(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def load_references(cpu_path, uniform_path):
+    for path, expected in ((cpu_path, CPU_SHA), (uniform_path, UNIFORM_SHA)):
+        if sha(path) != expected:
+            raise ValueError(f'pinned reference receipt differs: {path}')
+    cpu, uniform = [json.loads(Path(p).read_text()) for p in (cpu_path, uniform_path)]
+    assert cpu['completed'] and cpu['experimental_pass'] and not cpu['source']['dirty']
+    assert cpu['source']['commit'] == '07879bc52bfef8d95503146c55d3823c8b6f8d0a'
+    assert [r['mode'] for r in cpu['runs']] == ['constant_ivp', 'spacetime']
+    assert all(tuple(row['tstar'] for row in r['rows']) == TIMES for r in cpu['runs'])
+    assert uniform['completed'] and not uniform['source']['dirty']
+    assert uniform['source']['revision'] == '9805383f9c50d867e8555471baf5dbda8333a652'
+    assert (uniform['n'], uniform['depth'], uniform['viscosity']) == (64, 1, .0192)
+    assert uniform['limits'] == tg.LIMITS == LIMITS
+    return cpu, uniform
+
+
+def total(state, maps):
+    arrays = [a.astype(np.float64) for a in (state.coarse_f, state.fine_f)]
+    return ref.cpu.MOMENTS.T @ ref.directional(ref.cpu.State(*arrays), maps)
+
+
+def differing_fields(actual, expected):
+    """Compare serialized sample numerics exactly, including the sign of zero."""
+    if actual.keys() != expected.keys():
+        return ['field_set']
+    return [key for key in actual if np.asarray(actual[key]).dtype != np.asarray(expected[key]).dtype
+            or np.asarray(actual[key]).shape != np.asarray(expected[key]).shape
+            or np.asarray(actual[key]).tobytes() != np.asarray(expected[key]).tobytes()]
+
+
+def sample_difference(actual, expected):
+    """Descriptive comparison only; never an equivalence gate for different codecs."""
+    return {key:dict(reference=value,signed=(np.asarray(actual[key])-value).tolist(),
+                     absolute=np.abs(np.asarray(actual[key])-value).tolist()) for key,value in expected.items()}
+
+
+class LedgerTotals:
+    """Compensated directional sums; retain absolute step sums to expose cancellation."""
+    names = ('net_change','physical_collision','coarse_collision','fine0_collision','fine1_collision',
+             'child_rounding','child_interpolation','child_cast','register_rounding','receiver_rounding','unexplained')
+
+    def __init__(self):
+        self.sums = np.zeros((len(self.names),9)); self.correction = self.sums.copy()
+        self.absolute = self.sums.copy(); self.absolute_moments = np.zeros((len(self.names),3))
+        self.maxima = self.sums.copy(); self.max_steps = np.zeros(self.sums.shape,np.int64)
+        self.cells = np.zeros((3,4)); self.cell_correction = self.cells.copy()
+        self.steps = 0; self.bound = 0.; self.maximum = 0.
+
+    def add(self, ledger):
+        values = np.array([ledger[name] for name in self.names],np.float64)
+        cells = np.asarray(ledger['collision_cell_mass'],np.float64)
+        if (values.shape != self.sums.shape or not np.isfinite(values).all()
+                or cells.shape != (3,4) or not np.isfinite(cells).all()
+                or not np.isfinite(ledger['unexplained_bound']) or ledger['unexplained_bound'] <= 0):
+            raise AssertionError('invalid diagnostic ledger')
+        delta = values-self.correction
+        updated = self.sums+delta
+        self.correction = (updated-self.sums)-delta
+        self.sums = updated
+        self.absolute += abs(values)
+        self.absolute_moments += abs(values @ ref.cpu.MOMENTS)
+        larger = abs(values) > self.maxima
+        self.max_steps[larger] = self.steps+1; self.maxima = np.maximum(self.maxima,abs(values))
+        delta = cells-self.cell_correction
+        updated = self.cells+delta
+        self.cell_correction = (updated-self.cells)-delta; self.cells = updated
+        self.steps += 1; self.bound += ledger['unexplained_bound']
+        self.maximum = max(self.maximum,float(abs(values[-1]).max()))
+
+    def snapshot(self, endpoint_change=None):
+        values = dict(zip(self.names,self.sums))
+        accounted = sum(values[key] for key in ('physical_collision','child_rounding','register_rounding','receiver_rounding'))
+        closure = None if endpoint_change is None else endpoint_change-accounted
+        telescoping = None if endpoint_change is None else endpoint_change-values['net_change']
+        closure_pass = None if closure is None else max(float(abs(closure).max()),float(abs(telescoping).max())) <= self.bound
+        collision_split = values['physical_collision']-sum(values[key] for key in ('coarse_collision','fine0_collision','fine1_collision'))
+        child_split = values['child_rounding']-values['child_interpolation']-values['child_cast']
+        split_pass = max(float(abs(collision_split).max()),float(abs(child_split).max())) <= self.bound
+        return dict(intervals=self.steps, summed_per_step_bound=self.bound, max_step_unexplained=self.maximum,
+            closure_pass=closure_pass,component_split_pass=split_pass,
+            endpoint_status='not_measured' if endpoint_change is None else 'measured',
+            endpoint_directional_change=None if endpoint_change is None else endpoint_change.tolist(),
+            closure_residual=None if closure is None else closure.tolist(),
+            telescoping_residual=None if telescoping is None else telescoping.tolist(),
+            closure_mass_momentum=None if closure is None else (ref.cpu.MOMENTS.T@closure).tolist(),
+            collision_split_residual=collision_split.tolist(),child_split_residual=child_split.tolist(),
+            collision_cell_mass=dict(levels=['coarse','fine0','fine1'],columns=['net','positive','negative','l1'],
+                                     applied_volume_weights=[1.,.25,.25],values=self.cells.tolist()),
+            components={key:dict(directional=self.sums[i].tolist(),mass_momentum=(self.sums[i]@ref.cpu.MOMENTS).tolist(),
+                absolute_step_directional_sum=self.absolute[i].tolist(),
+                absolute_step_mass_momentum_sum=self.absolute_moments[i].tolist(),
+                max_absolute_interval=self.maxima[i].tolist(),max_absolute_interval_step=self.max_steps[i].tolist())
+                for i,key in enumerate(self.names)})
+
+
+def warm_and_reset(run, initial, check_cap, *, audit=False):
+    """Time 32 synchronized intervals, then restore exact uploaded arrival F."""
+    run.initialize(initial)
+    before = run.download()
+    started = time.monotonic()
+    for _ in range(32):
+        check_cap()
+        run.step(audit=audit)
+    seconds = time.monotonic()-started
+    warm_health = run.health_counts.tolist()
+    run.initialize(initial)
+    after = run.download()
+    for a, b in zip((before.coarse_f, before.fine_f), (after.coarse_f, after.fine_f)):
+        np.testing.assert_array_equal(a, b)
+    if run.step_count != 0 or after.tick != 0 or run.health_counts.any():
+        raise AssertionError('warm-up reset did not restore tick/counters')
+    return after, dict(intervals=32, seconds=seconds, estimated_1024_seconds=32*seconds,
+                       health_counts=warm_health, reset_verified=True, ledger_audit=audit)
+
+
+def assess(rows, cpu, uniform, health_counts):
+    if tuple(row['tstar'] for row in rows) != TIMES:
+        raise ValueError('four frozen sample times required')
+    worst = {key: max(row[key] for row in rows) for key in LIMITS}
+    campaign = {key: all(np.isfinite(row[key]) and 0 <= row[key] <= limit for row in rows)
+                for key, limit in LIMITS.items()}
+    campaign['population_health'] = not any(health_counts)
+    campaign['sampled_positive_finite'] = all(
+        np.isfinite(row[key]) and row[key] > 0 for row in rows
+        for key in ('minimum_population', 'minimum_boundary_pre', 'minimum_boundary_stored'))
+    baseline, candidate = cpu['runs']
+    thresholds = {key: factor*baseline['worst'][key] for key, factor in FACTORS.items()}
+    experimental = {key: all(np.isfinite(row[key]) and row[key] >= 0 for row in rows)
+                    and worst[key] <= threshold for key, threshold in thresholds.items()}
+    differences = []
+    for actual, expected in zip(rows, candidate['rows']):
+        delta = {}
+        for key, value in expected.items():
+            d = np.asarray(actual[key])-np.asarray(value)
+            delta[key] = dict(cpu=value, signed=d.tolist(), absolute=np.abs(d).tolist())
+        differences.append(dict(tstar=actual['tstar'], fields=delta))
+    historical_worst = max(row['pressure_l2'] for row in uniform['rows'] if row['tstar'] > 0)
+    historical_limit = max(2*historical_worst, .02)
+    assert historical_limit == .024506347612699403
+    return dict(worst=worst, campaign_checks=campaign, campaign_pass=all(campaign.values()),
+                experimental_thresholds=thresholds, experimental_checks=experimental,
+                experimental_pass=all(experimental.values()),
+                gpu_minus_cpu=dict(status='descriptive_only_no_equivalence_tolerance', rows=differences),
+                historical_pressure_gate=dict(status='historical_shifted_FP32_uniform_vs_unshifted_FP32_candidate',
+                    matched_storage=False, uniform_worst=historical_worst, threshold=historical_limit,
+                    candidate_worst=worst['pressure_l2'], passed=worst['pressure_l2'] <= historical_limit))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--gpu-admitted', action='store_true')
+    parser.add_argument('--cpu-receipt', type=Path, required=True)
+    parser.add_argument('--uniform-receipt', type=Path, required=True)
+    parser.add_argument('--audit-against', type=Path, help='audit every interval and compare exact saved 1779cf2 samples')
+    parser.add_argument('--shifted', action='store_true', help='opt-in shifted storage with all interval ledgers')
+    parser.add_argument('--unshifted-receipt', type=Path, help='pinned1779 comparison, descriptive only')
+    parser.add_argument('--output', type=Path, required=True)
+    args = parser.parse_args()
+    if not args.gpu_admitted or not os.environ.get('CUDA_VISIBLE_DEVICES'):
+        parser.error('explicit --gpu-admitted and CUDA_VISIBLE_DEVICES required')
+    if args.output.exists():
+        parser.error('output exists; preserve evidence and choose a new path')
+    if args.shifted != (args.unshifted_receipt is not None) or (args.shifted and args.audit_against):
+        parser.error('--shifted requires --unshifted-receipt and cannot use exact --audit-against')
+    exact_repeat = args.audit_against is not None
+    cpu, uniform = load_references(args.cpu_receipt, args.uniform_receipt)
+    previous = None
+    comparison_path = args.audit_against or args.unshifted_receipt
+    if comparison_path is not None:
+        if sha(comparison_path) != AUDIT_SHA:
+            raise ValueError('pinned GPU trajectory receipt differs')
+        previous = json.loads(comparison_path.read_text())
+        if previous['source']['numpy'] != np.__version__:
+            raise RuntimeError('audited repeat requires unchanged NumPy environment')
+    gpu.check_sources()
+    if sha(Path(gpu.__file__).with_suffix('.cu')) != CUDA_SHA:
+        raise RuntimeError('reviewed CUDA source changed')
+    source = dict(commit=subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=ROOT, text=True).strip(),
+        dirty=bool(subprocess.check_output(['git', 'status', '--porcelain'], cwd=ROOT, text=True)),
+        hashes={p.name: sha(p) for p in (Path(__file__), Path(gpu.__file__), Path(gpu.__file__).with_suffix('.cu'),
+                                      Path(__file__).with_name('test_spacetime_gpu.py'), Path(table_guard.__file__))},
+        reference_hashes=gpu.PINS, numpy=np.__version__, checkout=str(ROOT))
+    if source['dirty']:
+        raise RuntimeError('clean committed checkout required')
+    started = time.monotonic()
+    report = dict(scope='N64 experimental space-time GPU; no grid-convergence qualification',
+        completed=False, passed=False, source=source, rows=[], health_counts=[0]*6, health_labels=HEALTH,
+        setup=dict(n=64, bounds=[8,8,56,48], re_L=100, U=.03, viscosity=.0192, tau=[.5576,.6152],
+                   phase='arrival_f', storage='shifted_FP32' if args.shifted else 'unshifted_FP32', collision='SRT', interval_count=1024,
+                   initialization='common analytic FP64 field, encoded using production FP64 weights before FP32 upload' if args.shifted
+                       else 'same physical FP64 equilibrium as CPU, rounded to FP32 on upload',
+                   cpu_storage='FP64', sample_steps=STEPS, sample_times=TIMES),
+        references=dict(cpu_receipt_sha256=CPU_SHA, cpu_source=cpu['source'],
+            cpu_archive_drive_id='197F9nwDOGf_YROK1a46YpVvNrSldnH_w',
+            cpu_archive_sha256='850ddce3f5203ef38e76e5153e718a9b92e137d1fc388ba7cd12f5d47eab83b4',
+            uniform_receipt_sha256=UNIFORM_SHA, uniform_source=uniform['source'],
+            uniform_storage='historical_shifted_FP32'),
+        frozen_screen=dict(campaign_limits=LIMITS, experimental_factors=FACTORS,
+                           gpu_cpu_equivalence_tolerance=None, historical_pressure_threshold=.024506347612699403),
+        boundary_budget_status='pending_measurement' if previous else 'not_measured', max_directional_residual=None,
+        minima_scope='initial and four sampled physical arrival states; boundary minima at four samples',
+        limits=dict(seconds=180., peak_rss_mib=512.), cuda_visible_devices=os.environ['CUDA_VISIBLE_DEVICES'])
+    run = context = None
+    ledger_totals = LedgerTotals() if previous else None
+    if previous:
+        report['diagnostic'] = dict(completed=False, passed=False, reference_sha256=AUDIT_SHA,
+            reference_source=previous['source']['commit'], sample_checks=[], prefixes=[],
+            scope='net drift attribution; exact saved diagnostics only, not full-field trajectory certification' if exact_repeat
+                else 'raw stored-value ledger; unshifted and CPU comparisons descriptive, initial codecs differ')
+    phase = 'setup'
+
+    def save():
+        report['resources'] = dict(seconds=time.monotonic()-started,
+            peak_rss_mib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024,
+            device_allocations_bytes=None if run is None else run.device_bytes,
+            device_memory_scope='owner allocations; excludes compiler, driver and context')
+        if run is not None:
+            report['health_counts'] = run.health_counts.tolist()
+            report['completed_intervals'] = run.step_count
+        if ledger_totals is not None:
+            report['audited_intervals'] = ledger_totals.steps
+            if ledger_totals.steps:
+                report['boundary_budget_status'] = 'measured' if ledger_totals.steps==1024 else 'measured_prefix'
+                report['diagnostic']['accumulated'] = ledger_totals.snapshot()
+        ref.write_receipt(args.output, report)
+
+    def check_cap():
+        if time.monotonic()-started > 180 or resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024 > 512:
+            raise RuntimeError('frozen resource cap exceeded')
+
+    save()
+    try:
+        from CelerisLab.cuda.context import CudaContext
+        context = CudaContext(0)
+        config = LBMConfig(nx=64, ny=64, viscosity=.0192, velocity=0., ddf_shifting=args.shifted)
+        run = gpu.SpaceTimeGPU(config, (8,8,56,48), context=context)
+        report.update(device=context.name, sm_arch=context.sm_arch, build_metadata=run.build_metadata,
+                      table_sha256=gpu.table_hash(run.tables))
+        report['table_validation'] = table_guard.validate_tables(run.plan,run.tables)
+        if previous:
+            for key in ('device','sm_arch','table_sha256') + (('build_metadata',) if exact_repeat else ()):
+                if report[key] != previous[key]:
+                    raise AssertionError(f'audited repeat identity differs: {key}')
+        analytic = ref.cpu.State(tg.initial((64,64),0,64,.0192), tg.initial((128,128),1,64,.0192))
+        initial = analytic
+        phase = 'warm_reset'
+        initial, report['warmup'] = warm_and_reset(run, initial, check_cap, audit=previous is not None)
+        maps = run.plan.maps
+        masks = (maps.coarse_active, maps.fine_active)
+        arrays = (initial.coarse_f, initial.fine_f)
+        mass0 = tg.metrics(arrays, masks, 0, 64, .0192)['mass']
+        moment0 = total(initial, maps)
+        report['initial'] = dict(mass=mass0, momentum=moment0[1:].tolist(),
+            minimum_population=min(float(a[:,m].min()) for a,m in zip(arrays,masks)))
+        if exact_repeat and differing_fields(report['initial'],previous['initial']):
+            raise AssertionError('audited repeat initial state diagnostics differ')
+        raw_initial = run._download_stored() if args.shifted else initial
+        direction0 = ref.directional(ref.cpu.State(*(a.astype(np.float64) for a in
+            (raw_initial.coarse_f,raw_initial.fine_f))),maps)
+        if args.shifted:
+            errors=[]; unshifted_errors=[]
+            for raw,actual,wanted,mask in zip((raw_initial.coarse_f,raw_initial.fine_f),arrays,
+                    (analytic.coarse_f,analytic.fine_f),masks):
+                encoded=gpu._encode_physical(wanted,True)
+                np.testing.assert_array_equal(raw[:,mask].view(np.uint32),encoded[:,mask].view(np.uint32))
+                errors.append(float(abs(actual[:,mask]-wanted[:,mask]).max()))
+                unshifted_errors.append(float(abs(gpu._encode_physical(wanted,False)[:,mask]-wanted[:,mask]).max()))
+            report['warmup']['raw_reset_verified']=True
+            report['initial_quantization']=dict(maximum_population_error_by_level=errors,
+                unshifted_codec_error_by_level=unshifted_errors,
+                moment_change_vs_analytic=(moment0-total(analytic,maps)).tolist(),
+                cpu_start='pinned analytic FP64 trajectory, not reinitialized to decoded GPU upload',
+                matched_cpu_initial_bits=False)
+            report['unshifted_comparison']=dict(status='descriptive_only_codecs_have_different_initial_bits',
+                reference_sha256=AUDIT_SHA,initial=sample_difference(report['initial'],previous['initial']),rows=[])
+        save()
+        check_cap()
+        phase = 'trajectory'
+        trajectory_started = time.monotonic()
+        for step in range(1,1025):
+            check_cap()
+            ledger = run.step(audit=previous is not None)
+            if ledger_totals is not None:
+                ledger_totals.add(ledger)
+                report['max_directional_residual'] = ledger_totals.maximum
+            if step in STEPS:
+                state = run.download()
+                if state.tick != 2*step:
+                    raise AssertionError('sample is not synchronized arrival state')
+                arrays = (state.coarse_f, state.fine_f)
+                row = tg.metrics(arrays, masks, step, 64, .0192, mass0)
+                row.update(step=step, momentum_change=(total(state,maps)-moment0)[1:].tolist(),
+                           mass_change=row['mass']-mass0,
+                           minimum_population=min(float(a[:,m].min()) for a,m in zip(arrays,masks)))
+                if ledger_totals is not None:
+                    row['minimum_boundary_pre'] = ledger['minimum_pre']
+                    row['minimum_boundary_stored'] = ledger['minimum_stored']
+                else:
+                    with context.activate():
+                        row['minimum_boundary_pre'] = float(run.read(run.pre,(len(run.plan.groups),4),np.float64).min())
+                        row['minimum_boundary_stored'] = float(run.read(run.h,(len(run.plan.groups),4)).min())
+                if not all(np.isfinite(value).all() for value in row.values()):
+                    report['failed_sample'] = {key: repr(value) for key,value in row.items()}
+                    raise FloatingPointError('nonfinite sample diagnostic')
+                report['rows'].append(row)
+                if previous:
+                    expected=previous['rows'][len(report['rows'])-1]
+                    changed = differing_fields(row,expected) if exact_repeat else []
+                    report['diagnostic']['sample_checks'].append(dict(step=step,
+                        status='exact_repeat' if exact_repeat else 'descriptive_only',differing_fields=changed if exact_repeat else None))
+                    if args.shifted:
+                        report['unshifted_comparison']['rows'].append(dict(step=step,fields=sample_difference(row,expected)))
+                    raw_state=run._download_stored() if args.shifted else state
+                    endpoint = ref.directional(ref.cpu.State(*(a.astype(np.float64) for a in
+                        (raw_state.coarse_f,raw_state.fine_f))),maps)-direction0
+                    prefix = ledger_totals.snapshot(endpoint)
+                    if args.shifted:
+                        prefix['physical_minus_raw_endpoint_moments'] = (
+                            total(state,maps)-moment0-ref.cpu.MOMENTS.T@endpoint).tolist()
+                    report['diagnostic']['prefixes'].append(prefix)
+                    if not prefix['closure_pass'] or not prefix['component_split_pass']:
+                        raise AssertionError('cumulative ledger does not close within summed existing per-step bounds')
+                    if changed:
+                        raise AssertionError(f'audited repeat sample differs: {changed}')
+                save()
+                print(json.dumps(row, allow_nan=False), flush=True)
+        report['trajectory_seconds'] = time.monotonic()-trajectory_started
+        check_cap()
+        report.update(assess(report['rows'], cpu, uniform, run.health_counts))
+        if args.shifted:
+            report['historical_pressure_gate'].update(status='historical_shifted_FP32_uniform_vs_shifted_FP32_candidate',
+                matched_storage=True,matched_control=False)
+        report['completed'] = True
+        report['passed'] = report['campaign_pass'] and report['experimental_pass']
+        if previous:
+            report['diagnostic'].update(completed=True,passed=ledger_totals.steps==1024 and len(report['rows'])==4)
+    except Exception as exc:
+        report['failure'] = dict(phase=phase, error=repr(exc))
+        raise
+    finally:
+        # Preserve the primary failure and every completed sample even if cleanup fails.
+        for owner in (run, context):
+            if owner is not None:
+                try:
+                    owner.close()
+                except Exception as exc:
+                    report.setdefault('cleanup_errors', []).append(repr(exc))
+                    report['passed'] = False
+        save()
+    return 0 if report['passed'] else 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())
@@ -0,0 +1,165 @@
+// Test-only arrival-f space-time coupling. No production scheduler changes.
+#include <stdint.h>
+#include <math.h>
+#include "config.h"
+#include "core/precision.cuh"
+#include "core/descriptors.cuh"
+#include "core/layout.cuh"
+#include "operators/macro.cuh"
+#include "operators/collision_srt.cuh"
+#include "streaming/pull_double_buffer.cuh"
+
+#if DIM != 2 || NQ != 9 || COLLISION_MODEL != 0 || STORE_PRECISION != 0 || USE_LES || STREAMING_MODEL != 0
+#error "Space-time experiment requires FP32 D2Q9 SRT double buffers without LES"
+#endif
+
+__device__ __forceinline__ void collide(float* f, float omega) {
+    float rho, ux, uy, feq[NQ];
+    compute_rho_u(f, rho, ux, uy);
+#if USE_DDF_SHIFTING
+    // Same perturbation-preserving SRT branch as production BlockStep.
+    const float drho = f[0]+f[1]+f[2]+f[3]+f[4]+f[5]+f[6]+f[7]+f[8];
+    const float jx = f[1]-f[2]+f[5]-f[6]+f[7]-f[8];
+    const float jy = f[3]-f[4]+f[5]-f[6]-f[7]+f[8];
+    compute_feq_from_momentum(drho, jx, jy, ux, uy, feq);
+#else
+    compute_feq(rho, ux, uy, feq);
+#endif
+    collide_srt_no_force(f, feq, omega);
+}
+
+__device__ __forceinline__ double physical(double value, unsigned int q) {
+#if USE_DDF_SHIFTING
+    // Match population_storage.py's FP64 weights, not promoted FP32 d_w.
+    return value + (q == 0 ? 4.0/9.0 : (q < 5 ? 1.0/9.0 : 1.0/36.0));
+#else
+    return value;
+#endif
+}
+
+__device__ __forceinline__ void health(float stored, unsigned int q, unsigned int* counts) {
+    const double value = physical((double)stored, q);
+    if (!isfinite(value)) atomicAdd(counts + 4, 1u);
+    if (value <= 0.0f) atomicAdd(counts + 5, 1u);
+}
+
+extern "C" __global__ void CoarseStart(
+    const float* coarse, const float* fine, float* out, float omega,
+    unsigned int x0, unsigned int y0, unsigned int x1, unsigned int y1,
+    unsigned int* counts)
+{
+    unsigned int x, y; unsigned long k;
+    index_from_thread(x, y, k);
+    if (x >= NX || y >= NY) return;
+    const bool covered = x >= x0 && x < x1 && y >= y0 && y < y1;
+    float f[NQ];
+    for (unsigned int q = 0; q < NQ; ++q) {
+        const unsigned long s = q * 4ul * TOTAL_CELLS + 2ul * y * (2u * NX) + 2u * x;
+        f[q] = covered ? 0.25f * (fine[s] + fine[s+1] + fine[s+2u*NX] + fine[s+2u*NX+1])
+                       : coarse[index_f(k, q)];
+    }
+    collide(f, omega);
+    for (int q = 0; q < NQ; ++q) if (!covered) health(f[q], q, counts);
+    stream_pull_store(k, f, out);
+}
+
+extern "C" __global__ void Collide(
+    const float* in, float* out, const unsigned char* active, float omega,
+    unsigned int* counts)
+{
+    unsigned int x, y; unsigned long k;
+    index_from_thread(x, y, k);
+    if (x >= NX || y >= NY) return;
+    float f[NQ];
+    if (active == nullptr || active[k]) {
+        for (int q = 0; q < NQ; ++q) f[q] = in[index_f(k, q)];
+        collide(f, omega);
+        if (active != nullptr) for (int q = 0; q < NQ; ++q) health(f[q], q, counts);
+    } else {
+        for (int q = 0; q < NQ; ++q) f[q] = NAN;
+    }
+    stream_pull_store(k, f, out);
+}
+
+extern "C" __global__ void Pull(
+    const float* in, float* out, const unsigned char* active, unsigned int* counts)
+{
+    unsigned int x, y; unsigned long k;
+    index_from_thread(x, y, k);
+    if (x >= NX || y >= NY) return;
+    float f[NQ];
+    if (active == nullptr || active[k]) {
+        unsigned long j[NQ];
+        compute_neighbors(x, y, j);
+        stream_pull_load(k, f, in, j);
+        if (active != nullptr) for (int q = 0; q < NQ; ++q) health(f[q], q, counts);
+    } else {
+        for (int q = 0; q < NQ; ++q) f[q] = NAN;
+    }
+    stream_pull_store(k, f, out);
+}
+
+extern "C" __global__ void Interpolate(
+    const float* g0, const float* gp, const uint32_t* samples,
+    const uint32_t* origins, const int* sizes, const double* weights,
+    double* pre, float* h, unsigned int groups, unsigned int frozen,
+    unsigned int* counts)
+{
+    unsigned int group = blockIdx.x * blockDim.x + threadIdx.x;
+    if (group >= groups) return;
+    const int size = sizes[group];
+    const unsigned int q = origins[group] / TOTAL_CELLS;
+    for (int child = 0; child < 4; ++child) {
+        double value = frozen ? (double)g0[origins[group]] : 0.0;
+        if (!frozen) for (int j = 0; j < size; ++j) {
+            const float* source = j < size/2 ? g0 : gp;
+            value += weights[(4u*group+child)*10u+j] * (double)source[samples[10u*group+j]];
+        }
+        const float stored = __double2float_rn(value);
+        pre[4u*group+child] = value;
+        h[4u*group+child] = stored;
+        if (!isfinite(physical(value, q))) atomicAdd(counts, 1u);
+        if (physical(value, q) <= 0.0) atomicAdd(counts+1, 1u);
+        if (!isfinite(physical((double)stored, q))) atomicAdd(counts+2, 1u);
+        if (physical((double)stored, q) <= 0.0) atomicAdd(counts+3, 1u);
+    }
+}
+
+extern "C" __global__ void Inject(
+    float* fine, const float* h, const uint32_t* rows, unsigned int count,
+    unsigned int omit_first)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count || (omit_first && row == 0)) return;
+    fine[rows[2u*row]] = h[rows[2u*row+1]];
+}
+
+extern "C" __global__ void Register(
+    const float* predicted, const float* fine, const float* h,
+    const uint32_t* targets, const uint32_t* sources, const int* times,
+    double* registers, unsigned int count, int substep, int mutation)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    double value = substep == 0 ? -(double)predicted[targets[row]] : registers[row];
+    for (int j = 0; j < 4; ++j) {
+        const unsigned int slot = 4u*row+j;
+        const int when = times[slot];
+        if (when != substep && !(substep == 0 && when == -1)) continue;
+        if ((mutation == 1 && when == -1) || (mutation == 2 && when == 0)
+                || (mutation == 3 && when == 1)) continue;
+        value += 0.25 * (double)(when == -1 ? h[sources[slot]] : fine[sources[slot]]);
+    }
+    registers[row] = value;
+}
+
+extern "C" __global__ void ApplyRegisters(
+    float* predicted, const double* registers, const uint32_t* targets,
+    unsigned int count, unsigned int* counts)
+{
+    unsigned int row = blockIdx.x * blockDim.x + threadIdx.x;
+    if (row >= count) return;
+    const unsigned int slot = targets[row];
+    predicted[slot] = __double2float_rn((double)predicted[slot] + registers[row]);
+    health(predicted[slot], slot / TOTAL_CELLS, counts);
+}
@@ -0,0 +1,472 @@
+"""Test-only arrival-f GPU owner; CUDA compilation/execution requires admission."""
+from dataclasses import replace
+import hashlib
+from numbers import Integral
+from pathlib import Path
+
+import numpy as np
+import spacetime_reference as ref
+from CelerisLab.lbm.population_storage import _encode_physical, _decode_stored, _WEIGHTS
+
+PINS = {"spacetime_reference.py": "1fe13242b9a41062a1227db4a6f9b695165aefab7f4c0b3b2adff0c9023552bf",
+        "cpu_reference.py": "bba2a06a9f6517b32079ffff15e4060d8c3b7ed35f16ca134e1877226c9e4e1e",
+        "../taylor_green/oracle.py": "83e4d7425d45538278e9fb181af450a36358bd9a5ed6be57ff611dd9ae5eb35b"}
+
+
+def check_sources():
+    for name, expected in PINS.items():
+        if hashlib.sha256((Path(__file__).parent/name).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"reference source changed: {name}")
+
+
+def validate_config(config, *, uniform=False, allow_n128=False):
+    if type(uniform) is not bool or type(allow_n128) is not bool:
+        raise ValueError("admission flags must be bool")
+    cfg = replace(config)
+    cfg.validate()
+    if (cfg.nx != cfg.ny or not 8 <= cfg.nx <= (256 if uniform else (128 if allow_n128 else 64)) or cfg.nz != 1
+            or cfg.collision != "SRT" or not cfg.is_d2q9
+            or cfg.streaming != "double_buffer" or cfg.store_precision != "FP32"
+            or cfg.data_type != "FP32" or type(cfg.ddf_shifting) is not bool or cfg.les_enabled
+            or cfg.velocity != 0 or cfg.wall_slot_width or cfg.wall_normal_velocity):
+        raise ValueError("experiment requires periodic unforced square FP32 D2Q9/SRT within admitted size")
+    if uniform:
+        return (cfg,)
+    fine = replace(cfg, nx=2*cfg.nx, ny=2*cfg.ny, viscosity=2*cfg.viscosity)
+    fine.validate()
+    return cfg, fine
+
+
+def pack_plan(plan):
+    """Pack reviewed coordinate events; no production transfer builder imports."""
+    n, nf = plan.n, plan.nf
+    groups, receivers = plan.groups, plan.receivers
+    data = dict(samples=np.zeros((len(groups), 10), np.uint32),
+                origins=np.empty(len(groups), np.uint32), sizes=np.empty(len(groups), np.int32),
+                weights=np.zeros((len(groups), 4, 10), np.float64),
+                targets=(receivers[:, 0]*n*n+receivers[:, 1]).astype(np.uint32))
+    lookup = {tuple(row): i for i, row in enumerate(receivers)}
+    packets = [[] for _ in receivers]; incoming = [[], []]
+    for i, g in enumerate(groups):
+        size = len(g.samples)
+        if size not in (6, 10):
+            raise ValueError("unexpected interpolation stencil")
+        data['samples'][i, :size] = g.q*n*n+g.samples
+        data['origins'][i] = g.q*n*n+g.source
+        data['sizes'][i] = size
+        data['weights'][i, :, :size] = g.weights
+        for k, event in enumerate(g.events):
+            if event is None:
+                packets[lookup[(g.q, g.receiver)]].append((-1, 4*i+k))
+            else:
+                m, slot = event
+                incoming[m].append((g.q*nf*nf+slot, 4*i+k))
+    for m, outgoing in enumerate(plan.outgoing):
+        for q, source, target in outgoing:
+            packets[lookup[(int(q), int(target))]].append((m, int(q*nf*nf+source)))
+    if any(len(row) != 4 or len(set(row)) != 4 for row in packets):
+        raise ValueError("each receiver needs four distinct quarter-packets")
+    if len({packet for row in packets for packet in row}) != 4*len(receivers):
+        raise ValueError("packet has multiple receiver owners")
+    data['times'] = np.array([[t for t, _ in row] for row in packets], np.int32)
+    data['sources'] = np.array([[s for _, s in row] for row in packets], np.uint32)
+    for m, rows in enumerate(incoming):
+        data[f'incoming{m}'] = np.array(rows, np.uint32)
+        if len({slot for slot, _ in rows}) != len(rows):
+            raise ValueError("duplicate incoming writer")
+    return {key: np.ascontiguousarray(value) for key, value in data.items()}
+
+
+def table_hash(data):
+    digest = hashlib.sha256()
+    for key, value in sorted(data.items()):
+        digest.update(f"{key}:{value.dtype}:{value.shape}".encode()+value.tobytes())
+    return digest.hexdigest()
+
+
+def rounding_ledger(plan, tables, before, after, g0, predicted, fine_phases, pre, h, registers, *, shifted=False):
+    """Audit actual stored FP32 phases; never call a missing packet 'rounding'."""
+    maps, n = plan.maps, plan.n
+    f64 = lambda a: np.asarray(a, dtype=np.float64)
+    difference = f64(g0[:, maps.coarse_active])-f64(before.coarse_f[:, maps.coarse_active])
+    coarse_collision = difference.sum(axis=1)
+    cell_mass = [difference.sum(axis=0)]
+    collision = coarse_collision.copy(); fine_collision = []
+    for f, g in fine_phases:
+        difference = f64(g[:, maps.fine_active])-f64(f[:, maps.fine_active])
+        fine_collision.append(.25*difference.sum(axis=1))
+        cell_mass.append(.25*difference.sum(axis=0))
+        collision += fine_collision[-1]
+    np.testing.assert_array_equal(h, pre.astype(np.float32))
+    origins = f64(g0).ravel()[tables['origins']]
+    np.testing.assert_allclose(pre.mean(axis=1), origins, rtol=0, atol=2e-14)
+    group = np.bincount(tables['origins']//(n*n), weights=f64(h).mean(axis=1)-origins, minlength=9)
+    interpolation = np.bincount(tables['origins']//(n*n), weights=pre.mean(axis=1)-origins, minlength=9)
+    child_cast = np.bincount(tables['origins']//(n*n), weights=f64(h).mean(axis=1)-pre.mean(axis=1), minlength=9)
+    packet = np.empty(tables['times'].shape, np.float64)
+    for when, source in ((-1, h), (0, fine_phases[0][1]), (1, fine_phases[1][1])):
+        mask = tables['times'] == when
+        packet[mask] = f64(source).ravel()[tables['sources'][mask]]
+    p = f64(predicted).ravel()[tables['targets']]
+    ideal = -p + .25*packet.sum(axis=1)
+    reg_error = registers-ideal
+    bound = 16*np.finfo(float).eps*(abs(p)+.25*abs(packet).sum(axis=1))
+    if np.any(abs(reg_error) > bound):
+        raise AssertionError("receiver packet register mismatch (not roundoff)")
+    actual = after.coarse_f.ravel()[tables['targets']]
+    np.testing.assert_array_equal(actual, (p+registers).astype(np.float32))
+    q = tables['targets']//(n*n)
+    store_error = np.bincount(q, weights=f64(actual)-(p+registers), minlength=9)
+    register_error = np.bincount(q, weights=reg_error, minlength=9)
+    # directional() must sum converted arrays, not accumulate in FP32.
+    total = lambda s: ref.directional(ref.cpu.State(f64(s.coarse_f), f64(s.fine_f)), maps)
+    net = total(after)-total(before)
+    raw = net-collision
+    unexplained = raw-group-store_error-register_error
+    limit = float(64*np.finfo(float).eps*(total(before).sum()+int(shifted)*n*n))
+    np.testing.assert_allclose(unexplained, 0, rtol=0, atol=limit)
+    offset = _WEIGHTS.ravel()[tables['origins']//(n*n),None] if shifted else 0.
+    return dict(raw=raw.tolist(), net_change=net.tolist(), physical_collision=collision.tolist(),
+                coarse_collision=coarse_collision.tolist(), fine0_collision=fine_collision[0].tolist(),
+                fine1_collision=fine_collision[1].tolist(), child_interpolation=interpolation.tolist(),
+                child_cast=child_cast.tolist(),
+                collision_cell_mass=[[float(a.sum()),float(a[a>0].sum()),float(a[a<0].sum()),float(abs(a).sum())]
+                                     for a in cell_mass],
+                child_rounding=group.tolist(), receiver_rounding=store_error.tolist(),
+                register_rounding=register_error.tolist(), unexplained=unexplained.tolist(),
+                unexplained_bound=limit, minimum_pre=float((pre+offset).min()),
+                minimum_stored=float((f64(h)+offset).min()))
+
+
+class SpaceTimeGPU:
+    """Caller-owned context, one stream, explicit synchronized arrival state."""
+    def __init__(self, config, bounds, *, context, mode='spacetime', identity=False, allow_n128=False):
+        check_sources()
+        self.configs = validate_config(config,allow_n128=allow_n128)
+        if mode not in ('spacetime', 'frozen') or type(identity) is not bool:
+            raise ValueError("unsupported interpolation or debug collision mode")
+        self.bounds = tuple(bounds)
+        if len(self.bounds) != 4 or any(isinstance(v, bool) or not isinstance(v, Integral) for v in self.bounds):
+            raise ValueError("rectangle bounds must be four integers")
+        self.plan = ref.Plan(config.nx, self.bounds)
+        self.tables = pack_plan(self.plan)
+        self.ctx, self.mode, self.identity = context, mode, identity
+        self.allocations, self.modules, self.build_metadata = [], [], []
+        self.status, self.step_count, self.device_bytes = 'new', 0, 0
+        self.health_counts = np.zeros(6, np.uint64)
+        import pycuda.driver as cuda
+        from CelerisLab.cuda import compiler_v2 as compiler
+        root = Path(__file__).resolve().parents[3]
+        if Path(compiler._KERNEL_DIR).resolve() != root/'src/CelerisLab/lbm/kernels':
+            raise RuntimeError("wrong production kernel checkout")
+        self.cuda = cuda
+        with context.activate():
+            self.stream = cuda.Stream()
+            try:
+                source = Path(__file__).with_suffix('.cu')
+                for cfg in self.configs:
+                    build = compiler.generate_config(cfg)
+                    try:
+                        Path(build, source.name).write_bytes(source.read_bytes())
+                        ptx = compiler.compile_kernel(context.sm_arch, source=source.name, build_dir=build)
+                        self.modules.append(compiler.load_module(ptx))
+                        import json
+                        metadata = json.loads(Path(ptx+'.json').read_text())
+                        metadata['test_entry_sha256'] = hashlib.sha256(source.read_bytes()).hexdigest()
+                        self.build_metadata.append(metadata)
+                    finally:
+                        compiler.cleanup_build_dir(build)
+                self.device_tables = {key: self.upload(value) for key, value in self.tables.items()}
+                self.active = self.upload(self.plan.maps.fine_active.astype(np.uint8))
+                self.coarse = [self.allocate(9*config.nx**2*4) for _ in range(4)]
+                self.fine = [self.allocate(9*(2*config.nx)**2*4) for _ in range(3)]
+                self.pre = self.allocate(len(self.plan.groups)*4*8)
+                self.h = self.allocate(len(self.plan.groups)*4*4)
+                self.registers = self.allocate(len(self.plan.receivers)*8)
+                self.counts = self.allocate(6*4)
+            except BaseException:
+                try:
+                    self.close()
+                except Exception:
+                    pass
+                raise
+
+    def allocate(self, size):
+        pointer = self.cuda.mem_alloc(size)
+        self.allocations.append(pointer); self.device_bytes += size
+        return pointer
+
+    def upload(self, array):
+        pointer = self.allocate(array.nbytes)
+        self.cuda.memcpy_htod(pointer, array)
+        return pointer
+
+    def read(self, pointer, shape, dtype=np.float32):
+        self.stream.synchronize()
+        out = np.empty(shape, dtype)
+        self.cuda.memcpy_dtoh(out, pointer)
+        return out
+
+    def launch(self, level, name, *args, count=None):
+        cfg = self.configs[level]
+        nt = cfg.threads_per_block
+        grid = ((cfg.nx+nt-1)//nt, cfg.ny) if count is None else ((count+nt-1)//nt, 1)
+        self.modules[level].get_function(name)(*args, block=(nt,1,1), grid=grid, stream=self.stream)
+
+    def initialize(self, state):
+        if (self.status not in ('new', 'ready') or state.phase != 'arrival_f'
+                or isinstance(state.tick, bool) or not isinstance(state.tick, Integral) or state.tick != 0):
+            raise ValueError("initial synchronized arrival state with tick=0 required")
+        shifted = self.configs[0].ddf_shifting
+        arrays = []
+        for values, mask in zip((state.coarse_f,state.fine_f),
+                                (self.plan.maps.coarse_active,self.plan.maps.fine_active)):
+            if np.shape(values) != (9,*mask.shape):
+                raise ValueError("positive finite leaf populations and exact shapes required")
+            a = _encode_physical(values,shifted)
+            physical = _decode_stored(a,shifted)
+            if not np.isfinite(physical[:,mask]).all() or (physical[:,mask] <= 0).any():
+                raise ValueError("positive finite leaf populations and exact shapes required")
+            a[:,~mask] = np.nan
+            arrays.append(a)
+        with self.ctx.activate():
+            try:
+                self.cuda.memcpy_htod(self.coarse[0], arrays[0])
+                self.cuda.memcpy_htod(self.fine[0], arrays[1])
+            except BaseException:
+                self.status = 'failed'
+                raise
+        self.status, self.step_count = 'ready', 0
+        self.health_counts.fill(0)
+
+    def _download_stored(self):
+        """Private audit/reset snapshot; values remain in their storage representation."""
+        if self.status != 'ready':
+            raise RuntimeError(f"GPU owner is {self.status}")
+        try:
+            with self.ctx.activate():
+                arrays = [self.read(self.coarse[0], (9,self.plan.n,self.plan.n)),
+                          self.read(self.fine[0], (9,self.plan.nf,self.plan.nf))]
+        except BaseException:
+            self.status = 'failed'
+            raise
+        for a, mask in zip(arrays, (self.plan.maps.coarse_active,self.plan.maps.fine_active)):
+            a[:,~mask] = np.nan
+        return ref.cpu.State(*arrays, tick=2*self.step_count)
+
+    def download(self):
+        """Physical arrival populations; shifted values are reconstructed in FP64."""
+        stored = self._download_stored()
+        return ref.cpu.State(*(_decode_stored(a,self.configs[0].ddf_shifting)
+                               for a in (stored.coarse_f,stored.fine_f)),tick=stored.tick)
+
+    def step(self, *, mutation=0, audit=True):
+        """One interval; audit=False skips only host ledger snapshots, never health checks."""
+        if (self.status != 'ready' or type(mutation) is not int or mutation not in range(5)
+                or type(audit) is not bool or (mutation and not audit)):
+            raise RuntimeError("ready owner and known test mutation required")
+        before = self._download_stored() if audit else None
+        n, nf, t = self.plan.n, self.plan.nf, self.device_tables
+        ng, nr = len(self.plan.groups), len(self.plan.receivers)
+        u32, null = np.uint32, np.uintp(0)
+        omega = [np.float32(0 if self.identity else cfg.omega) for cfg in self.configs]
+        with self.ctx.activate():
+            try:
+                self.status = 'advancing'
+                self.cuda.memset_d32_async(self.counts, 0, 6, self.stream)
+                fc, g0, predicted, gp = self.coarse
+                self.launch(0, 'CoarseStart', fc,self.fine[0],g0,omega[0],
+                            *(u32(v) for v in self.bounds),self.counts)
+                self.launch(0, 'Pull', g0,predicted,null,self.counts)
+                self.launch(0, 'Collide', predicted,gp,null,omega[0],self.counts)
+                self.launch(0, 'Interpolate', g0,gp,t['samples'],t['origins'],t['sizes'],t['weights'],
+                            self.pre,self.h,u32(ng),u32(self.mode=='frozen'),self.counts,count=ng)
+                if audit:
+                    coarse_g = self.read(g0,(9,n,n)); prediction = self.read(predicted,(9,n,n))
+                fine_phases = []
+                for m in (0,1):
+                    f, out, g = self.fine
+                    if audit:
+                        old_f = self.read(f,(9,nf,nf))
+                    self.launch(1, 'Collide', f,g,self.active,omega[1],self.counts)
+                    if audit:
+                        fine_phases.append((old_f,self.read(g,(9,nf,nf))))
+                    self.launch(0, 'Register', predicted,g,self.h,t['targets'],t['sources'],t['times'],
+                                self.registers,u32(nr),np.int32(m),np.int32(mutation),count=nr)
+                    rows = self.tables[f'incoming{m}']
+                    self.launch(1, 'Inject', g,self.h,t[f'incoming{m}'],u32(len(rows)),u32(mutation==4),count=len(rows))
+                    self.launch(1, 'Pull', g,out,self.active,self.counts)
+                    self.fine[0], self.fine[1] = out, f
+                self.launch(0, 'ApplyRegisters', predicted,self.registers,t['targets'],u32(nr),self.counts,count=nr)
+                counts = self.read(self.counts,(6,),np.uint32)
+                self.health_counts += counts.astype(np.uint64)
+                if counts.any():
+                    raise AssertionError(f"boundary/leaf health failed: {counts.tolist()}")
+                ledger = dict(boundary_budget_status='not_measured',unexplained=None)
+                if audit:
+                    coarse_after = self.read(predicted,(9,n,n))
+                    coarse_after[:,~self.plan.maps.coarse_active] = np.nan
+                    after = ref.cpu.State(coarse_after,self.read(self.fine[0],(9,nf,nf)),tick=2*(self.step_count+1))
+                    ledger = rounding_ledger(self.plan,self.tables,before,after,coarse_g,prediction,fine_phases,
+                                             self.read(self.pre,(ng,4),np.float64),self.read(self.h,(ng,4)),
+                                             self.read(self.registers,(nr,),np.float64),
+                                             shifted=self.configs[0].ddf_shifting)
+                    ledger['boundary_budget_status'] = 'measured'
+                ledger['health_counts'] = counts.tolist()
+                self.coarse[0], self.coarse[2] = predicted, fc
+                self.step_count += 1
+                self.status = 'ready'
+                return ledger
+            except BaseException:
+                self.status = 'failed'
+                raise
+
+    def close(self):
+        if self.status == 'closed':
+            return
+        with self.ctx.activate():
+            error = None
+            try:
+                self.stream.synchronize()
+            except Exception as exc:
+                error = exc
+            failed = []
+            for pointer in self.allocations:
+                try:
+                    pointer.free()
+                except Exception as exc:
+                    error = error or exc
+                    failed.append(pointer)
+            self.allocations = failed
+            self.status = 'cleanup_failed' if failed else 'closed'
+            if not failed:
+                self.modules.clear()
+            if error:
+                raise error
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, kind, value, traceback):
+        try:
+            self.close()
+        except Exception:
+            if kind is None:
+                raise
+
+
+def uniform_ledger(before, after, collided, *, shifted):
+    """Periodic streaming permutes each direction; only collision changes its sum."""
+    a,b,g = [np.asarray(x,np.float64) for x in (before,after,collided)]
+    collision=(g-a).sum(axis=(1,2)); net=b.sum(axis=(1,2))-a.sum(axis=(1,2))
+    residual=net-collision
+    bound=float(64*np.finfo(float).eps*(a.sum()+int(shifted)*a.shape[1]*a.shape[2]))
+    np.testing.assert_allclose(residual,0,rtol=0,atol=bound)
+    cells=(g-a).sum(axis=0)
+    out={key:[0.]*9 for key in ('fine0_collision','fine1_collision','child_rounding',
+        'child_interpolation','child_cast','register_rounding','receiver_rounding')}
+    out.update(net_change=net.tolist(),physical_collision=collision.tolist(),coarse_collision=collision.tolist(),
+        unexplained=residual.tolist(),unexplained_bound=bound,
+        collision_cell_mass=[[float(cells.sum()),float(cells[cells>0].sum()),
+            float(cells[cells<0].sum()),float(abs(cells).sum())],[0.]*4,[0.]*4],
+        boundary_budget_status='not_applicable_uniform',inactive_components='fine, child, register, receiver')
+    return out
+
+
+class UniformGPU(SpaceTimeGPU):
+    """One explicit arrival-F level; reuse the reviewed kernels and owner helpers."""
+    def __init__(self, config, *, context, identity=False):
+        check_sources()
+        self.configs=validate_config(config,uniform=True)
+        if type(identity) is not bool:
+            raise ValueError('identity must be bool')
+        self.ctx,self.identity=context,identity
+        self.allocations,self.modules,self.build_metadata=[],[],[]
+        self.status,self.step_count,self.device_bytes='new',0,0
+        self.health_counts=np.zeros(6,np.uint64)
+        import pycuda.driver as cuda
+        from CelerisLab.cuda import compiler_v2 as compiler
+        if Path(compiler._KERNEL_DIR).resolve()!=Path(__file__).resolve().parents[3]/'src/CelerisLab/lbm/kernels':
+            raise RuntimeError('wrong production kernel checkout')
+        self.cuda=cuda
+        with context.activate():
+            self.stream=cuda.Stream()
+            try:
+                source=Path(__file__).with_suffix('.cu')
+                build=compiler.generate_config(self.configs[0])
+                try:
+                    Path(build,source.name).write_bytes(source.read_bytes())
+                    ptx=compiler.compile_kernel(context.sm_arch,source=source.name,build_dir=build)
+                    self.modules.append(compiler.load_module(ptx))
+                    import json
+                    metadata=json.loads(Path(ptx+'.json').read_text())
+                    metadata['test_entry_sha256']=hashlib.sha256(source.read_bytes()).hexdigest()
+                    self.build_metadata.append(metadata)
+                finally:
+                    compiler.cleanup_build_dir(build)
+                n=config.nx
+                self.buffers=[self.allocate(9*n*n*4) for _ in range(3)]
+                self.active=self.upload(np.ones((n,n),np.uint8))
+                self.counts=self.allocate(6*4)
+            except BaseException:
+                try:
+                    self.close()
+                except BaseException:
+                    pass
+                raise
+
+    def initialize(self, physical):
+        cfg=self.configs[0]
+        if self.status not in ('new','ready') or np.shape(physical)!=(9,cfg.ny,cfg.nx):
+            raise ValueError('ready owner and exact uniform population shape required')
+        stored=_encode_physical(physical,cfg.ddf_shifting)
+        decoded=_decode_stored(stored,cfg.ddf_shifting)
+        if not np.isfinite(decoded).all() or (decoded<=0).any():
+            raise ValueError('positive finite physical populations required')
+        try:
+            with self.ctx.activate():
+                self.cuda.memcpy_htod(self.buffers[0],stored)
+            self.health_counts[:]=0; self.step_count=0; self.status='ready'
+        except BaseException:
+            self.status='failed'
+            raise
+
+    def _download_stored(self):
+        if self.status!='ready':
+            raise RuntimeError('uniform owner is not ready')
+        try:
+            with self.ctx.activate():
+                n=self.configs[0].nx
+                return self.read(self.buffers[0],(9,n,n))
+        except BaseException:
+            self.status='failed'
+            raise
+
+    def download(self):
+        return _decode_stored(self._download_stored(),self.configs[0].ddf_shifting)
+
+    def step(self, *, audit=True):
+        if self.status!='ready' or type(audit) is not bool:
+            raise RuntimeError('ready owner and bool audit required')
+        cfg=self.configs[0]; shape=(9,cfg.ny,cfg.nx)
+        before=self._download_stored() if audit else None
+        with self.ctx.activate():
+            try:
+                self.status='advancing'
+                self.cuda.memset_d32_async(self.counts,0,6,self.stream)
+                f,g,out=self.buffers
+                self.launch(0,'Collide',f,g,self.active,np.float32(0 if self.identity else cfg.omega),self.counts)
+                self.launch(0,'Pull',g,out,self.active,self.counts)
+                counts=self.read(self.counts,(6,),np.uint32)
+                self.health_counts+=counts.astype(np.uint64)
+                if counts.any():
+                    raise AssertionError(f'uniform population health failed: {counts.tolist()}')
+                ledger=uniform_ledger(before,self.read(out,shape),self.read(g,shape),shifted=cfg.ddf_shifting) if audit else dict(
+                    boundary_budget_status='not_measured',unexplained=None)
+                ledger['health_counts']=counts.tolist()
+                self.buffers[0],self.buffers[2]=out,f
+                self.step_count+=1; self.status='ready'
+                return ledger
+            except BaseException:
+                self.status='failed'
+                raise
@@ -0,0 +1,334 @@
+"""Experimental FP64 BVP coupling: one periodic rectangle, D2Q9, ratio two.
+
+Guzik et al., https://www.osti.gov/servlets/purl/1226215, sections 3.2--3.5.
+Coordinate-generated stream events; CPUREF collision only, no production imports.
+This is a mathematical prototype, not a certified accuracy implementation.
+"""
+from dataclasses import dataclass
+from functools import lru_cache
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import resource
+import sys
+import subprocess
+import time
+
+import numpy as np
+import cpu_reference as cpu
+
+
+class Spec(cpu.Spec):
+    @property
+    def n_fine(self):
+        return 2 * self.n_coarse
+
+
+def geometry(n, bounds):
+    x0, y0, x1, y1 = bounds
+    if not (2 <= x0 < x1 <= n - 2 and 2 <= y0 < y1 <= n - 2):
+        raise ValueError("one interior rectangle with two coarse cells of clearance required")
+    y, x = np.indices((n, n))
+    covered = (x >= x0) & (x < x1) & (y >= y0) & (y < y1)
+    y, x = np.indices((2*n, 2*n))
+    active = (x >= 2*x0) & (x < 2*x1) & (y >= 2*y0) & (y < 2*y1)
+    inner = (x >= 2*x0-2) & (x < 2*x1+2) & (y >= 2*y0-2) & (y < 2*y1+2) & ~active
+    rows, links = [], []
+    for ky, kx in zip(*np.nonzero(~covered)):
+        for q, (cy, cx) in enumerate(zip(cpu.CY, cpu.CX)):
+            if any(active[2*ky+dy-cy, 2*kx+dx-cx]
+                   for dy in (0, 1) for dx in (0, 1)
+                   if 0 <= 2*ky+dy-cy < 2*n and 0 <= 2*kx+dx-cx < 2*n):
+                rows.append((q, ky, kx))
+                sy, sx = (ky-cy) % n, (kx-cx) % n
+                if not covered[sy, sx]:
+                    links.append(cpu.CornerLink(f"{kx}_{ky}_{q}", q, (sx, sy), (kx, ky)))
+    kind = np.where(active, 0, np.where(inner, 1, 2))
+    return cpu.Maps(~covered, covered, active, inner, kind == 2, kind,
+                    np.arange(2*n)//2, (np.arange(2*n)+.5)/2,
+                    np.array(rows, dtype=int), tuple(links))
+
+
+@lru_cache(None)
+def interpolation(kind, points):
+    """Return data coordinates, evaluation matrix, and constrained coefficient map."""
+    if kind == "face":
+        samples = np.array([(s, t) for t in (0., 1.) for s in (-1., 0., 1.)])
+        a = np.array([[1, s, t, s*t] for s, t in samples])
+        e = np.array([[1, s, t, s*t] for s, t in points])
+        b = e.mean(axis=0, keepdims=True)
+        d = np.zeros((1, 6)); d[0, 1] = 1
+    else:
+        cross = ((0, 0), (-1, 0), (1, 0), (0, -1), (0, 1))
+        samples = np.array([(x, y, t) for t in (0., 1.) for x, y in cross])
+        a = np.array([[1, x, y, t] for x, y, t in samples])
+        e = np.array([[1, x, y, t] for x, y, t in points])
+        b = np.stack((e.mean(axis=0), [0, 0, 0, 1]))
+        d = np.zeros((2, 10)); d[0, 0] = 1; d[1, 0] = -1; d[1, 5] = 1
+    kkt = np.block([[a.T @ a, b.T], [b, np.zeros((len(b), len(b)))]])
+    coeff = np.linalg.solve(kkt, np.vstack((a.T, d)))[:4]
+    if not np.allclose(b @ coeff, d, rtol=0, atol=2e-14):
+        raise AssertionError("invalid constrained interpolation matrix")
+    return samples, a, e, coeff
+
+
+@dataclass
+class Group:
+    q: int
+    source: int
+    receiver: int
+    kind: str
+    points: tuple
+    samples: np.ndarray
+    weights: np.ndarray
+    events: tuple  # (substep, fine ghost slot), or None for a leftover
+
+
+class Plan:
+    def __init__(self, n, bounds):
+        self.n, self.nf = n, 2*n
+        self.maps = geometry(n, bounds)
+        active = self.maps.fine_active
+        lo, hi = np.array(bounds[1::-1]), np.array(bounds[3:1:-1])
+        self.groups = []
+        for iy, ix in zip(*np.nonzero(self.maps.coarse_active)):
+            origin = np.array((iy, ix))
+            for q in range(1, 9):
+                c = np.array((cpu.CY[q], cpu.CX[q]))
+                starts = [2*origin + (dy, dx) for dy in (0, 1) for dx in (0, 1)]
+                events = []
+                for p in starts:
+                    event = None
+                    for m in (0, 1):
+                        old, new = p+m*c, p+(m+1)*c
+                        inside = lambda z: bool(np.all(z >= 0) and np.all(z < 2*n) and active[tuple(z)])
+                        if not inside(old) and inside(new):
+                            event = (m, int(old[0]*2*n+old[1]))
+                            break
+                    events.append(event)
+                if all(event is None for event in events):
+                    continue
+                axes = [j for j in range(2) if origin[j] < lo[j] or origin[j] >= hi[j]]
+                kind = "corner" if len(axes) == 2 else "face"
+                points = []
+                for p in starts:
+                    x = (p+.5)/2
+                    times = [(float(lo[j] if c[j] > 0 else hi[j])-x[j])/c[j] for j in axes]
+                    time = max(times)
+                    offset = x+c*time-(origin+.5+c*.5)
+                    points.append((float(offset[1]), float(offset[0]), float(time-.5))
+                                  if kind == "corner" else (float(offset[1-axes[0]]), float(time-.5)))
+                points = tuple(points)
+                samples, _, e, coeff = interpolation(kind, points)
+                indices = []
+                for row in samples:
+                    shift = np.array((row[1], row[0]), dtype=int) if kind == "corner" else np.eye(2, dtype=int)[1-axes[0]]*int(row[0])
+                    pos = (origin+shift) % n
+                    indices.append(int(pos[0]*n+pos[1]))
+                target = (origin+c) % n
+                self.groups.append(Group(q, int(iy*n+ix), int(target[0]*n+target[1]), kind,
+                                         points, np.array(indices), e @ coeff, tuple(events)))
+        self.outgoing = []
+        # m is zero-based: a substep-0 exit travels two fine spacings by
+        # synchronization; a substep-1 exit travels one.
+        for m in (0, 1):
+            records = []
+            for q in range(1, 9):
+                c = np.array((cpu.CY[q], cpu.CX[q]))
+                for y, x in zip(*np.nonzero(active)):
+                    p = np.array((y, x)); endpoint = p+c
+                    if not active[tuple(endpoint)]:
+                        target = (p+(2-m)*c)//2
+                        assert self.maps.coarse_active[tuple(target)]
+                        records.append((q, int(y*2*n+x), int(target[0]*n+target[1])))
+            self.outgoing.append(np.array(records, dtype=int))
+        incoming = [(m, g.q, slot) for g in self.groups for event in g.events
+                    if event is not None for m, slot in [event]]
+        assert len(incoming) == len(set(incoming)), "duplicate incoming writer"
+        expected = {(m, int(q), int((y-cpu.CY[q])*2*n+x-cpu.CX[q]))
+                    for m in (0, 1) for q in range(1, 9)
+                    for y, x in zip(*np.nonzero(active)) if not active[y-cpu.CY[q], x-cpu.CX[q]]}
+        assert set(incoming) == expected, "incoming coverage mismatch"
+        receivers = {(int(q), int(target)) for out in self.outgoing for q, _, target in out}
+        receivers |= {(g.q, g.receiver) for g in self.groups if None in g.events}
+        assert receivers == {(int(q), int(y*n+x)) for q, y, x in self.maps.coalesce}
+        self.receivers = np.array(sorted(receivers), dtype=int)
+
+
+def directional(state, maps):
+    return state.coarse_f[:, maps.coarse_active].sum(axis=1) + .25*state.fine_f[:, maps.fine_active].sum(axis=1)
+
+
+def advance(spec, plan, state, mode="spacetime", mutation=None):
+    """One arrival-to-arrival interval. 'frozen' disables space AND time variation."""
+    if mode not in ("frozen", "spacetime"):
+        raise ValueError(mode)
+    n, nf, maps = plan.n, plan.nf, plan.maps
+    if state.phase != "arrival_f" or state.tick % 2:
+        raise ValueError("synchronized arrival state required")
+    fc, ff = state.coarse_f.copy(), state.fine_f.copy()
+    covered_mean = ff.reshape(9, n, 2, n, 2).mean(axis=(2, 4))
+    fc[:, maps.coarse_covered] = covered_mean[:, maps.coarse_covered]
+    all_cells = np.ones((n, n), dtype=bool)
+    def collide(f, mask, tau):
+        return cpu._collide(spec, f, np.isfinite(f), tau, mask, np.zeros(mask.shape, dtype=int))
+    gc = collide(fc, all_cells, spec.tau_coarse)
+    collision = (gc[:, maps.coarse_active]-fc[:, maps.coarse_active]).sum(axis=1)
+    predicted = cpu._stream_periodic(gc)
+    gp = collide(predicted, all_cells, spec.tau_coarse) if mode == "spacetime" else gc
+    registers = np.zeros((9, n*n))
+    q, target = plan.receivers.T
+    registers[q, target] = -predicted.reshape(9, -1)[q, target]
+    incoming = [[], []]
+    group_error = 0.
+    min_boundary = float("inf")
+    negative_boundary = nonfinite_boundary = 0
+    dropped = False
+    for group in plan.groups:
+        q = group.q
+        count = len(group.samples)//2
+        data = np.concatenate((gc.reshape(9, -1)[q, group.samples[:count]], gp.reshape(9, -1)[q, group.samples[count:]]))
+        value = (group.weights @ data if mode == "spacetime"
+                 else np.full(4, gc.reshape(9, -1)[q, group.source]))
+        min_boundary = min(min_boundary, float(value.min()))
+        negative_boundary += int(np.count_nonzero(value < 0))
+        nonfinite_boundary += int(np.count_nonzero(~np.isfinite(value)))
+        group_error = max(group_error, abs(value.mean()-gc.reshape(9, -1)[q, group.source]))
+        for k, event in enumerate(group.events):
+            if event is None:
+                if mutation == "omit_leftover" and not dropped:
+                    dropped = True
+                else:
+                    registers[q, group.receiver] += .25*value[k]
+            else:
+                m, slot = event
+                incoming[m].append((q, slot, value[k]))
+    for m in (0, 1):
+        gf = collide(ff, maps.fine_active, spec.tau_fine)
+        collision += .25*(gf[:, maps.fine_active]-ff[:, maps.fine_active]).sum(axis=1)
+        out = plan.outgoing[m]
+        if mutation != f"omit_outgoing_{m}":
+            np.add.at(registers, (out[:, 0], out[:, 2]), .25*gf.reshape(9, -1)[out[:, 0], out[:, 1]])
+        for q, slot, value in incoming[m]:
+            gf.reshape(9, -1)[q, slot] = value
+        fresh = np.full_like(ff, np.nan)
+        for q in range(9):
+            moved = cpu._shift(gf[q], int(cpu.CY[q]), int(cpu.CX[q]), np.nan)
+            fresh[q, maps.fine_active] = moved[maps.fine_active]
+        if not np.isfinite(fresh[:, maps.fine_active]).all():
+            raise AssertionError("invalid fine incoming population")
+        ff = fresh
+    final_c = predicted + registers.reshape(9, n, n)
+    final_c[:, maps.coarse_covered] = np.nan
+    final = cpu.State(final_c, ff, tick=state.tick+2)
+    residual = directional(final, maps)-directional(state, maps)-collision
+    minimum = min(float(final_c[:, maps.coarse_active].min()), float(ff[:, maps.fine_active].min()))
+    return final, dict(directional_residual=residual, collision=collision,
+                       group_error=group_error, min_boundary=min_boundary, min_population=minimum,
+                       negative_boundary_count=negative_boundary, nonfinite_boundary_count=nonfinite_boundary)
+
+
+def write_receipt(path, result):
+    """Normalize NumPy scalars at the JSON boundary; reject other unknown types."""
+    def scalar(value):
+        if isinstance(value, np.generic):
+            return value.item()
+        raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")
+    path.write_text(json.dumps(result, indent=2, allow_nan=False, default=scalar)+"\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--n64", action="store_true", help="explicitly run the frozen 1024-interval experiment")
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--max-seconds",type=float,default=180.,help="wall-time cap, including plan generation")
+    parser.add_argument("--max-rss-mib",type=float,default=256.,help="Linux peak-RSS screening cap")
+    args = parser.parse_args()
+    if not args.n64:
+        parser.error("full trajectory requires --n64")
+    if args.output.exists():
+        parser.error("output exists; preserve prior evidence and choose a new path")
+    if not (np.isfinite(args.max_seconds) and args.max_seconds>0 and np.isfinite(args.max_rss_mib) and args.max_rss_mib>0):
+        parser.error("positive finite resource caps required")
+    started = time.monotonic()
+    sys.path.insert(0, str(Path(__file__).parents[1]/"taylor_green"))
+    import oracle as tg
+    plan = Plan(64, (8, 8, 56, 48))
+    spec = Spec(n_coarse=64, patch_lo=8, halo=16, tau_coarse=.5576, tau_fine=.6152, collision="srt")
+    arrays = [tg.initial((64,64), 0, 64, .0192), tg.initial((128,128), 1, 64, .0192)]
+    for a, mask in zip(arrays, (plan.maps.coarse_active, plan.maps.fine_active)):
+        a[:, ~mask] = np.nan
+    initial = cpu.State(*arrays)
+    mass0 = tg.metrics(arrays, (plan.maps.coarse_active, plan.maps.fine_active), 0, 64, .0192)["mass"]
+    metrics = ("velocity_l2", "pressure_l2", "energy_relative")
+    frozen_baseline = dict(zip(metrics, (.01131134574353476, .03592961319244149, .012514764591008386)))
+    budget_bound = float(64*np.finfo(float).eps*mass0)
+    root = Path(__file__).resolve().parents[3]
+    source = dict(commit=subprocess.check_output(["git", "rev-parse", "HEAD"],cwd=root,text=True).strip(),
+                  dirty=bool(subprocess.check_output(["git","status","--porcelain"],cwd=root,text=True)),
+                  hashes={p.name:hashlib.sha256(p.read_bytes()).hexdigest()
+                          for p in (Path(__file__),Path(cpu.__file__),Path(tg.__file__))},numpy=np.__version__)
+    result = dict(scope="experimental CPU FP64; no GPU/accuracy certification", source=source,
+                  screen=dict(velocity_factor=.8, pressure_factor=1., energy_factor=1.,
+                              directional_step_bound=budget_bound, mass_relative=1e-11,
+                              momentum_absolute=1e-9, baseline_metric_atol=1e-10),
+                  limits=dict(seconds=args.max_seconds,rss_mib=args.max_rss_mib),runs=[],completed=False)
+    def save():
+        result["resources"] = dict(seconds=time.monotonic()-started,peak_rss_mib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024)
+        write_receipt(args.output, result)
+    save()
+    try:
+        for mode in ("constant_ivp", "spacetime"):
+            measured = mode == "spacetime"
+            state = initial; record = dict(mode=mode,rows=[],
+                                          boundary_budget_status="measured" if measured else "not_measured",
+                                          max_directional_residual=0. if measured else None,
+                                          minimum_boundary=None,negative_boundary_count=0 if measured else None,
+                                          nonfinite_boundary_count=0 if measured else None)
+            result["runs"].append(record)
+            for k in range(1, 1025):
+                if time.monotonic()-started>args.max_seconds or resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024>args.max_rss_mib:
+                    raise RuntimeError("experiment resource cap exceeded")
+                if mode == "constant_ivp":
+                    state,_ = cpu.advance_coarse_once(spec,plan.maps,state)
+                else:
+                    state,diagnostic = advance(spec,plan,state)
+                    error = float(np.max(np.abs(diagnostic["directional_residual"])))
+                    record["max_directional_residual"] = max(record["max_directional_residual"],error)
+                    if np.isfinite(diagnostic["min_boundary"]):
+                        record["minimum_boundary"] = (diagnostic["min_boundary"] if record["minimum_boundary"] is None else min(record["minimum_boundary"],diagnostic["min_boundary"]))
+                    for name in ("negative_boundary_count","nonfinite_boundary_count"):
+                        record[name] += diagnostic[name]
+                    if (not np.isfinite(error) or error>budget_bound or diagnostic["group_error"]>2e-14
+                            or diagnostic["negative_boundary_count"] or diagnostic["nonfinite_boundary_count"]
+                            or not np.isfinite(diagnostic["min_boundary"]) or diagnostic["min_boundary"]<=0
+                            or not np.isfinite(diagnostic["min_population"]) or diagnostic["min_population"]<=0):
+                        record["failed_diagnostic"] = {name: repr(value) for name,value in diagnostic.items()}
+                        raise AssertionError("candidate directional/health invariant failed")
+                if k in (256,512,768,1024):
+                    row = tg.metrics((state.coarse_f,state.fine_f),(plan.maps.coarse_active,plan.maps.fine_active),k,64,.0192,mass0)
+                    row["momentum_change"] = (cpu.MOMENTS.T@(directional(state,plan.maps)-directional(initial,plan.maps)))[1:].tolist()
+                    record["rows"].append(row)
+                    save(); print(mode,k,json.dumps(row),flush=True)
+            record["worst"] = {key:max(row[key] for row in record["rows"]) for key in metrics}
+            if mode == "constant_ivp":
+                for key,value in frozen_baseline.items():
+                    if abs(record["worst"][key]-value)>1e-10:
+                        raise AssertionError(f"frozen baseline mismatch: {key}")
+        baseline,candidate = result["runs"]
+        result["checks"] = {key:candidate["worst"][key]<=factor*baseline["worst"][key]
+                            for key,factor in zip(metrics,(.8,1.,1.))}
+        result["checks"]["mass_momentum"] = all(row["mass_relative"]<=1e-11 and max(map(abs,row["momentum_change"]))<=1e-9 for row in candidate["rows"])
+        result["completed"] = True
+        result["experimental_pass"] = all(result["checks"].values())
+        save()
+        return 0 if result["experimental_pass"] else 1
+    except Exception as exc:
+        result["failure"] = dict(mode=mode,step=k,error=repr(exc))
+        save()
+        raise
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,92 @@
+"""N64/N128 admission check: exact topology and independently rational interpolation.
+
+Raw FP64 bytes are diagnostic: different LAPACK builds need not produce them
+identically. The 2e-14 ceiling is the existing interpolation constraint policy,
+not a universal LAPACK error theorem. This module never changes runtime weights.
+"""
+from fractions import Fraction as F
+from functools import lru_cache
+
+import numpy as np
+from spacetime_gpu import table_hash
+
+STRUCTURE_SHA = 'cd1842952c4dd4df82da8015454c25da9be12b983270236cc65b4044fa38e6e4'
+STRUCTURES = {64: (STRUCTURE_SHA, 532),
+              128: ('ee4ecb645674ae04eb87220a5217851405ccc0f45fbb0fe210499dcea5cd93b1', 1060)}
+ATOL = 2e-14
+
+
+def _transpose(a):
+    return list(map(list, zip(*a)))
+
+
+def _multiply(a, b):
+    return [[sum(x*y for x,y in zip(row,column)) for column in zip(*b)] for row in a]
+
+
+@lru_cache(None)
+def exact_weights(kind, points):
+    """Solve the small documented constrained fit using exact rational arithmetic."""
+    if kind == 'face':
+        a = [[F(1),F(s),F(t),F(s*t)] for t in (0,1) for s in (-1,0,1)]
+        e = [[F(1),F(s),F(t),F(s)*F(t)] for s,t in points]
+        b = [[sum(column)/4 for column in zip(*e)]]
+        d = [[F(int(j==1)) for j in range(6)]]
+    elif kind == 'corner':
+        a = [[F(1),F(x),F(y),F(t)] for t in (0,1) for x,y in ((0,0),(-1,0),(1,0),(0,-1),(0,1))]
+        e = [[F(1),F(x),F(y),F(t)] for x,y,t in points]
+        b = [[sum(column)/4 for column in zip(*e)], [F(0),F(0),F(0),F(1)]]
+        d = [[F(int(j==0)) for j in range(10)], [F(int(j==5)-int(j==0)) for j in range(10)]]
+    else:
+        raise ValueError('unsupported interpolation kind')
+    kkt = [r+s for r,s in zip(_multiply(_transpose(a),a),_transpose(b))]
+    kkt += [row+[F(0)]*len(b) for row in b]
+    rhs = _transpose(a)+d
+    n = len(kkt)
+    augmented = [row+data for row,data in zip(kkt,rhs)]
+    for j in range(n):
+        pivot = next(i for i in range(j,n) if augmented[i][j])
+        augmented[j],augmented[pivot] = augmented[pivot],augmented[j]
+        divisor = augmented[j][j]
+        augmented[j] = [v/divisor for v in augmented[j]]
+        for i in range(n):
+            if i != j:
+                factor = augmented[i][j]
+                augmented[i] = [x-factor*y for x,y in zip(augmented[i],augmented[j])]
+    solution = [row[n:] for row in augmented]
+    if _multiply(kkt,solution) != rhs:
+        raise AssertionError('exact interpolation solve failed')
+    return np.array(_multiply(e,solution[:4]), dtype=np.float64)
+
+
+def validate_tables(plan, tables, *, allow_n128=False):
+    """Reject topology, layout, padding, operator, or constraint changes separately."""
+    structure = table_hash({key:value for key,value in tables.items() if key != 'weights'})
+    admitted = (64,128) if allow_n128 is True else (64,)
+    if plan.n not in admitted or structure != STRUCTURES[plan.n][0]:
+        raise ValueError('frozen integer topology changed')
+    w = tables['weights']
+    if (w.dtype != np.dtype(np.float64) or w.shape != (STRUCTURES[plan.n][1],4,10) or len(plan.groups) != w.shape[0]
+            or not all(a.flags.c_contiguous for a in tables.values()) or not np.isfinite(w).all()):
+        raise ValueError('weight dtype/shape/layout/finiteness changed')
+    errors = dict(coefficient=0., constant=0., mean=0., temporal=0.)
+    for i,g in enumerate(plan.groups):
+        size = len(g.samples)
+        if size != tables['sizes'][i] or size != {'face':6,'corner':10}.get(g.kind) or len(g.points) != 4:
+            raise ValueError('interpolation group coverage/size changed')
+        if w[i,:,size:].tobytes() != np.zeros((4,10-size),np.float64).tobytes():
+            raise ValueError('weight padding is not exact positive zero')
+        actual = w[i,:,:size]
+        errors['coefficient'] = max(errors['coefficient'],float(abs(actual-exact_weights(g.kind,g.points)).max()))
+        errors['constant'] = max(errors['constant'],float(abs(actual.sum(axis=1)-1).max()))
+        central = np.zeros(size); central[1 if g.kind=='face' else 0] = 1
+        errors['mean'] = max(errors['mean'],float(abs(actual.mean(axis=0)-central).max()))
+        if g.kind == 'corner':
+            early,late = (g.points.index((0.,0.,t)) for t in (-.25,.25))
+            slope = np.zeros(size); slope[0],slope[5] = -1,1
+            errors['temporal'] = max(errors['temporal'],float(abs(2*(actual[late]-actual[early])-slope).max()))
+    if any(error > ATOL for error in errors.values()):
+        raise ValueError(f'exact interpolation/constraint check failed: {errors}; bound={ATOL}')
+    return dict(status='passed', structure_sha256=structure, raw_table_sha256=table_hash(tables),
+                coefficient_oracle='exact rational KKT, rounded once to FP64', atol=ATOL, rtol=0.,
+                maximum_absolute_errors=errors, positive_zero_padding=True)
@@ -0,0 +1,239 @@
+"""Host-only experimental union event contract; no solver or runtime admission.
+
+Consumes existing level-wide union geometry, never its legacy transfer tables.
+The frozen 707afe6 rectangle oracle remains independent and unchanged. Topology
+acceptance proves packet accounting, not interpolation accuracy or GPU support.
+"""
+from types import SimpleNamespace
+
+import numpy as np
+import spacetime_reference as ref
+
+
+class UnresolvedTopology(ValueError):
+    """An experimental coupling limitation, not a production geometry rejection."""
+    def __init__(self, code, **detail):
+        self.code, self.detail = code, detail
+        super().__init__(f"experimental space-time topology unresolved: {code}: {detail}")
+
+
+def owned_slots(layout, directions, cells):
+    """Map dense logical reads/writes to existing owner-core storage, not halos."""
+    cells = np.asarray(cells)
+    if not np.issubdtype(cells.dtype, np.integer) or np.any((cells < 0) | (cells >= np.prod(layout.shape))):
+        raise ValueError('invalid dense cell index')
+    owner = layout.owner.ravel()[cells]
+    if np.any(owner == layout.hole):
+        raise UnresolvedTopology('missing_block_owner', cells=cells[owner == layout.hole].tolist())
+    return layout.slot(owner, directions)
+
+
+def _first_entry(covered, origin, child, c):
+    """First continuous union entry of one characteristic, in exact quarter times.
+
+    Probe the cells immediately before/after each crossed grid line using integer
+    eighth-cell coordinates. Return only actual exterior faces of the UNION.
+    """
+    start4 = 4*origin + 2*child + 1
+    for t4 in (1, 3):
+        before = (2*start4 + c*(2*t4-1))//8
+        after = (2*start4 + c*(2*t4+1))//8
+        if not covered[tuple(before)] and covered[tuple(after)]:
+            axes = []
+            for j in range(2):
+                if before[j] != after[j]:
+                    neighbor = after.copy(); neighbor[j] = before[j]
+                    if not covered[tuple(neighbor)]: axes.append(j)
+            return t4, axes
+    return None
+
+
+def _crossing_time(covered, origin, position, c, axes):
+    """Fig.11 convex T uses the last plane; Fig.13 concave T uses the first.
+
+    Both use the same KKT formulation on different boundary geometry.
+    DOI/primary PDF: https://www.osti.gov/servlets/purl/1226215, §3.5.1.
+    """
+    times=[(origin[j]+int(c[j]>0)-position[j])/c[j] for j in axes]
+    if len(axes)==1: return times[0]
+    sides=[bool(covered[tuple(origin+np.eye(2,dtype=int)[j]*c[j])]) for j in axes]
+    if sides[0]!=sides[1]:
+        raise UnresolvedTopology('mixed_corner_support',source_yx=origin.tolist())
+    return min(times) if all(sides) else max(times)
+
+
+class UnionPlan:
+    """Two-level, level-wide square geometry; all coordinates are level-local.
+
+    Assumes a complete parent domain; does not validate nested parent coverage.
+    ``pair`` is existing FixedPatchSet2D geometry, even for one rectangle. Scalar
+    window origins and nested state coverage need their own contract; they are
+    explicitly unadmitted here. No global rectangle-gap rule is imposed.
+    """
+    phase = 'arrival_f'
+    runtime_supported = False
+    interpolation_accuracy = 'unqualified_for_new_unions'
+
+    def __init__(self, pair):
+        ny, nx = pair.coarse_shape
+        self.origin = tuple(pair.fine_origin)
+        if ny != nx or pair.fine_shape != (2*ny, 2*nx) or self.origin != (0., 0.):
+            raise UnresolvedTopology('requires_level_wide_square_pair',
+                                     coarse_shape=pair.coarse_shape, fine_shape=pair.fine_shape, origin=self.origin)
+        self.n, self.nf = nx, 2*nx
+        covered = np.array(pair.covered, dtype=bool, copy=True)
+        active = np.kron(covered, np.ones((2, 2), bool))
+        if not np.array_equal(active, pair.fine_kind == 0):
+            raise UnresolvedTopology('non_pair_active_coverage')
+        self.maps = SimpleNamespace(coarse_active=~covered, coarse_covered=covered, fine_active=active)
+        self.outgoing, transit = [[], []], []
+        # Guzik et al. §3.5.4, Fig.19 (https://www.osti.gov/servlets/purl/1226215):
+        # retain substep-0 outgoing G at source, then fill the substep-1 ghost.
+        # Rows are (q, fine source, next ghost); no covered coarse receiver credit.
+        for q in range(1, 9):
+            c = np.array((ref.cpu.CY[q], ref.cpu.CX[q]))
+            boundary = active & ~np.roll(active, tuple(-c), axis=(0, 1))
+            for y, x in zip(*np.nonzero(boundary)):
+                p = np.array((y, x))
+                for m in (0, 1):
+                    target = (p+(2-m)*c)//2
+                    if covered[tuple(target)]:
+                        if m != 0 or not active[tuple(p+2*c)]:
+                            raise UnresolvedTopology('unsupported_transit', q=q, substep=m, source_yx=p.tolist())
+                        ghost=p+c
+                        transit.append((q,int(y*self.nf+x),int(ghost[0]*self.nf+ghost[1])))
+                    else:
+                        self.outgoing[m].append((q, int(y*self.nf+x), int(target[0]*nx+target[1])))
+        self.outgoing = [np.array(x, dtype=np.int64).reshape(-1, 3) for x in self.outgoing]
+        self.transit = np.array(transit,dtype=np.int64).reshape(-1,3)
+        self.groups = []
+        for iy, ix in zip(*np.nonzero(~covered)):
+            origin = np.array((iy, ix))
+            # Two-cell production margins make all nearby probes in bounds.
+            if not covered[max(0,iy-1):iy+2,max(0,ix-1):ix+2].any(): continue
+            for q in range(1, 9):
+                c = np.array((ref.cpu.CY[q], ref.cpu.CX[q]))
+                children = [np.array((dy, dx)) for dy in (0, 1) for dx in (0, 1)]
+                starts = [2*origin+child for child in children]
+                events = []
+                for p in starts:
+                    event = None
+                    for m in (0, 1):
+                        old, new = p+m*c, p+(m+1)*c
+                        if not active[tuple(old)] and active[tuple(new)]:
+                            event = (m, int(old[0]*self.nf+old[1])); break
+                    events.append(event)
+                if all(e is None for e in events): continue
+                entries = [_first_entry(covered, origin, child, c) for child in children]
+                axes = sorted({j for entry in entries if entry is not None for j in entry[1]})
+                if not axes:
+                    raise UnresolvedTopology('missing_exterior_support', source_yx=origin.tolist(), q=q)
+                points = []
+                for p, entry, event in zip(starts, entries, events):
+                    position = (p+.5)/2
+                    time = _crossing_time(covered,origin,position,c,axes)
+                    if entry is not None and (4*time != entry[0] or event is None):
+                        raise UnresolvedTopology('nonconvex_entry_support', source_yx=origin.tolist(), q=q,
+                                                 quarter_time=entry[0], support_quarter_time=float(4*time))
+                    offset = position+c*time-(origin+.5+c*.5)
+                    points.append((float(offset[1]), float(offset[0]), float(time-.5)) if len(axes)==2
+                                  else (float(offset[1-axes[0]]), float(time-.5)))
+                kind = 'corner' if len(axes)==2 else 'face'; points = tuple(points)
+                samples, _, evaluation, coefficients = ref.interpolation(kind, points)
+                indices = []
+                for row in samples:
+                    shift = np.array((row[1],row[0]), int) if kind=='corner' else np.eye(2,dtype=int)[1-axes[0]]*int(row[0])
+                    pos = (origin+shift) % nx; indices.append(int(pos[0]*nx+pos[1]))
+                target = (origin+c) % nx
+                self.groups.append(ref.Group(q,int(iy*nx+ix),int(target[0]*nx+target[1]),kind,
+                    points,np.array(indices),evaluation@coefficients,tuple(events)))
+        receivers = {(int(q),int(target)) for rows in self.outgoing for q,_,target in rows}
+        receivers |= {(g.q,g.receiver) for g in self.groups if None in g.events}
+        self.receivers = np.array(sorted(receivers),dtype=np.int64).reshape(-1,2)
+        self.proof = validate_ownership(self)
+
+
+def validate_ownership(plan):
+    """Independent mask-based event coverage and four-quarter receiver accounting."""
+    n, nf, active = plan.n, plan.nf, plan.maps.fine_active
+    actual = [(m,g.q,slot) for g in plan.groups for e in g.events if e is not None for m,slot in [e]]
+    expected_transit={(q,int(y*nf+x),int((y+ref.cpu.CY[q])*nf+x+ref.cpu.CX[q]))
+        for q in range(1,9) for y,x in zip(*np.nonzero(active))
+        if not active[y+ref.cpu.CY[q],x+ref.cpu.CX[q]]
+        and active[y+2*ref.cpu.CY[q],x+2*ref.cpu.CX[q]]}
+    routes=[tuple(map(int,row)) for row in plan.transit]
+    if len(routes)!=len(set(routes)) or set(routes)!=expected_transit:
+        raise ValueError('transit provenance/uniqueness/coverage failed')
+    actual += [(1,q,ghost) for q,source,ghost in routes]
+    expected = {(m,q,int((y-ref.cpu.CY[q])*nf+x-ref.cpu.CX[q]))
+        for m in (0,1) for q in range(1,9) for y,x in zip(*np.nonzero(active))
+        if not active[y-ref.cpu.CY[q],x-ref.cpu.CX[q]]}
+    if len(actual)!=len(set(actual)) or set(actual)!=expected:
+        raise ValueError('incoming writer uniqueness/coverage failed')
+    packets = {tuple(map(int,row)):[] for row in plan.receivers}
+    if len(packets)!=len(plan.receivers): raise ValueError('duplicate coarse receiver')
+    anchors = set()
+    for i,g in enumerate(plan.groups):
+        if not 1<=g.q<9 or not 0<=g.source<n*n or not plan.maps.coarse_active.ravel()[g.source]:
+            raise ValueError('invalid coarse source anchor')
+        if (g.q,g.source) in anchors: raise ValueError('duplicate coarse source group')
+        anchors.add((g.q,g.source))
+        origin=np.array(divmod(g.source,n)); c=np.array((ref.cpu.CY[g.q],ref.cpu.CX[g.q]))
+        target=(origin+c)%n
+        if g.receiver!=target[0]*n+target[1]: raise ValueError('group receiver provenance failed')
+        ordered=[]; entries=[]
+        for dy,dx in ((0,0),(0,1),(1,0),(1,1)):
+            p=2*origin+(dy,dx); event=None
+            for m in (0,1):
+                old,new=p+m*c,p+(m+1)*c
+                if not active[tuple(old)] and active[tuple(new)]:
+                    event=(m,int(old[0]*nf+old[1])); break
+            ordered.append(event)
+            entries.append(_first_entry(plan.maps.coarse_covered,origin,np.array((dy,dx)),c))
+        if tuple(ordered)!=g.events or all(e is None for e in ordered):
+            raise ValueError('ordered child characteristic provenance failed')
+        axes=sorted({j for e in entries if e is not None for j in e[1]})
+        if not axes or g.kind!=('corner' if len(axes)==2 else 'face'):
+            raise ValueError('group supporting axes differ')
+        samples,_,evaluation,coefficients=ref.interpolation(g.kind,g.points)
+        indices=[]
+        for row in samples:
+            shift=np.array((row[1],row[0]),int) if g.kind=='corner' else np.eye(2,dtype=int)[1-axes[0]]*int(row[0])
+            pos=(origin+shift)%n; indices.append(int(pos[0]*n+pos[1]))
+        if not np.array_equal(g.samples,indices): raise ValueError('sample anchor provenance failed')
+        for k,(dy,dx) in enumerate(((0,0),(0,1),(1,0),(1,1))):
+            position=origin+(np.array((dy,dx))+.5)/2
+            time=_crossing_time(plan.maps.coarse_covered,origin,position,c,axes)
+            offset=position+c*time-(origin+.5+c*.5)
+            point=(float(offset[1]),float(offset[0]),float(time-.5)) if g.kind=='corner' else (float(offset[1-axes[0]]),float(time-.5))
+            if g.points[k]!=point: raise ValueError('evaluation point provenance failed')
+        source=np.zeros(len(g.samples)); source[0 if g.kind=='corner' else 1]=1
+        if (not np.allclose(g.weights,evaluation@coefficients,rtol=0,atol=2e-14)
+                or not np.allclose(g.weights.mean(axis=0),source,rtol=0,atol=2e-14)):
+            raise ValueError('group coefficients/directional budget failed')
+        for k,event in enumerate(g.events):
+            if event is None:
+                if (g.q,g.receiver) not in packets: raise ValueError('missing leftover receiver')
+                packets[(g.q,g.receiver)].append(('leftover',i,k))
+    for m,rows in enumerate(plan.outgoing):
+        expected_out = {(q,int(y*nf+x),int(((y+(2-m)*ref.cpu.CY[q])//2)*n+(x+(2-m)*ref.cpu.CX[q])//2))
+            for q in range(1,9) for y,x in zip(*np.nonzero(active))
+            if not active[y+ref.cpu.CY[q],x+ref.cpu.CX[q]]
+            and plan.maps.coarse_active[(y+(2-m)*ref.cpu.CY[q])//2,(x+(2-m)*ref.cpu.CX[q])//2]}
+        actual_out = [tuple(map(int,row)) for row in rows]
+        if len(actual_out)!=len(set(actual_out)) or set(actual_out)!=expected_out:
+            raise ValueError('outgoing uniqueness/coverage failed')
+        for q,slot,target in actual_out: packets[(q,target)].append(('outgoing',m,q,slot))
+    expected_receivers = {(q,int(y*n+x)) for y,x in zip(*np.nonzero(plan.maps.coarse_active))
+        for q in range(1,9) if any(active[2*y+dy-ref.cpu.CY[q],2*x+dx-ref.cpu.CX[q]]
+            for dy in (0,1) for dx in (0,1)
+            if 0<=2*y+dy-ref.cpu.CY[q]<nf and 0<=2*x+dx-ref.cpu.CX[q]<nf)}
+    if set(packets)!=expected_receivers: raise ValueError('coarse receiver coverage failed')
+    tokens=[token for row in packets.values() for token in row]
+    if any(len(row)!=4 for row in packets.values()) or len(tokens)!=len(set(tokens)):
+        raise ValueError('receiver needs four distinct quarter-packets')
+    return dict(topology='supported',incoming_events=len(actual),outgoing_events=sum(map(len,plan.outgoing)),
+        transit_events=len(routes),
+        groups=len(plan.groups),receivers=len(packets),receiver_quarter_packets=len(tokens),
+        interpolation_accuracy=plan.interpolation_accuracy,runtime_supported=False,
+        scope='pair-local ownership/coefficients; complete parent domain assumed, nested coverage unvalidated')
@@ -1,4 +1,4 @@
-"""Single blocked level, FixedPatchStepper(refinements=[]): CPU contracts plus short GPU cases.
+"""Periodic body-free block backend: CPU contract doubles plus one short GPU case.

 Frozen GPU gates (32x24, 8 steps, positive low-Mach non-equilibrium state):
 finite cores; bit-identical 1x1, 2x2 and 4x2 splits; max |G - FP64 oracle|
@@ -11,8 +11,9 @@ Mass/momentum drift is reported, not gated.
 from contextlib import nullcontext
 from pathlib import Path
 import resource
+from threading import RLock
 import unittest
-from unittest.mock import Mock, patch
+from unittest.mock import MagicMock, Mock, patch

 import numpy as np
 import pycuda.driver as cuda
@@ -20,10 +21,10 @@ import pycuda.driver as cuda
 from CelerisLab.body.geometry.circle import CircleGeometry
 from CelerisLab.body.objects import SimObject
 from CelerisLab.config import LBMConfig
-from CelerisLab.cuda import compiler
-from CelerisLab.lbm import refinement_stepper as implementation
-from CelerisLab.lbm.blocks import NO_DONOR, BlockLayout2D, static_circle_tables
-from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
+from CelerisLab.cuda import compiler_v2 as compiler
+from CelerisLab.lbm import block_stepper as implementation
+from CelerisLab.lbm.blocks import NO_DONOR, BlockLayout2D
+from CelerisLab.lbm.block_stepper import PeriodicBlockStepper
 from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY

 ROOT = Path(__file__).resolve().parents[3]
@@ -111,78 +112,72 @@ def totals(g):
    return g.sum(), (CX[:, None, None] * g).sum(), (CY[:, None, None] * g).sum()


-def single(cfg=None, *, context, block=(12, 16), objects=(), **kw):
-    """One periodic blocked level (the former PeriodicBlockStepper capability)."""
-    return FixedPatchStepper(cfg or config(), context=context, refinements=[], level_blocks=[block],
-                             level_objects=[tuple(objects)], **kw)
-
-
 class CpuContracts(unittest.TestCase):
-    """No device: driver doubles prove rejection before allocation."""
+    """No device: driver doubles prove rejection before allocation and lifecycle."""

    def forbidden_context(self):
        return Mock(activate=Mock(side_effect=AssertionError("CUDA reached")), sm_arch="sm_70")

    def test_unsupported_inputs_rejected_before_cuda(self):
-        for cfg, kw in ((None, dict(block=None)),
-                        (None, dict(coarse_boundary="channel")),
-                        (None, dict(coarse_boundary="slot_reservoir")),
-                        (config(collision="MRT"), {}),
-                        (config(les_enabled=True), {}),
-                        (None, dict(explosion="projected_linear")),
-                        (None, dict(observe_raw_exchange=True)),
-                        (None, dict(observe_raw_exchange=True, observe_window_exchange=True)),
-                        (None, dict(level_jets=[(object(),)]))):
-            with self.subTest(kw=kw), self.assertRaises(ValueError):
-                single(cfg, context=self.forbidden_context(), **kw)
+        layout = BlockLayout2D.build(NY, NX, 12, 16)
+        cases = ((config(), BlockLayout2D.build(NY, NX, 12, 16, periodic=(True, False))),
+                 (config(), BlockLayout2D.build(NY, NX * 2, 12, 16)),
+                 (config(collision="MRT"), layout),
+                 (config(), "layout"))
+        for cfg, lay in cases:
+            with self.subTest(cfg=cfg.collision, layout=getattr(lay, "periodic", lay)):
+                with self.assertRaises(ValueError):
+                    PeriodicBlockStepper(cfg, lay, context=self.forbidden_context())
        moving = circle()
        moving.state.vx = .01
        build_links = CircleGeometry.build_cut_links
        for objects in ([moving], [circle((1.5, 11.5), 2.0)], [circle(), circle()]):
            with self.assertRaises(ValueError):
-                single(context=self.forbidden_context(), objects=objects)
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context(), objects=objects)
        for center, radius in (((16.0, 12.0), -.1), ((16.0, 12.0), -.5), ((15.5, 11.5), np.nan),
                               ((np.inf, 11.5), 4.3), ((15.5, np.nan), 4.3)):
            with self.subTest(center=center, radius=radius), self.assertRaises(ValueError):
-                single(context=self.forbidden_context(), objects=[circle(center, radius)])
-        with patch.object(implementation, "static_circle_tables") as prepare:
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context(),
+                                     objects=[circle(center, radius)])
+        with patch.object(implementation, "_static_circles") as prepare:
            with self.assertRaisesRegex(AssertionError, "CUDA reached"):  # body-free path
-                single(context=self.forbidden_context(), objects=iter(()))
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context(), objects=iter(()))
            prepare.assert_not_called()
-        with self.assertRaisesRegex(AssertionError, "CUDA reached"):
-            single(context=self.forbidden_context(), objects=[circle()])
        with patch.object(CircleGeometry, "build_cut_links",
                          lambda geometry, *a, **k: build_links(geometry, *a, **k)[1:]):
            with self.assertRaisesRegex(ValueError, "cover every fluid pull"):
-                single(context=self.forbidden_context(), objects=[circle()])
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context(),
+                                     objects=[circle()])
        with patch.object(implementation, "MAX_GRID_DIM", 3):
            with self.assertRaisesRegex(ValueError, "launch limits"):
-                single(context=self.forbidden_context())
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context())

    def test_memory_and_param_layout_rejected_before_allocation(self):
+        layout = BlockLayout2D.build(NY, NX, 12, 16)
        context = Mock(activate=nullcontext, sm_arch="sm_70")
        with patch.object(cuda, "mem_get_info", return_value=(1024, 1 << 30)), \
                patch.object(cuda, "Stream") as stream, patch.object(cuda, "mem_alloc") as alloc:
-            with self.assertRaisesRegex(MemoryError, "exceed free device memory"):
-                single(context=context, objects=[circle()])
+            with self.assertRaises(MemoryError):
+                PeriodicBlockStepper(config(), layout, context=context)
            stream.assert_not_called()
            alloc.assert_not_called()
        module = Mock()
        module.get_global.return_value = (Mock(), 16)
-        with patch.object(cuda, "Stream"), patch.object(cuda, "mem_get_info", return_value=(1 << 40, 1 << 40)), patch.object(compiler, "generate_config"), \
+        with patch.object(cuda, "mem_get_info", return_value=(1 << 30, 1 << 30)), \
+                patch.object(cuda, "Stream"), patch.object(compiler, "generate_config"), \
                patch.object(compiler, "compile_kernel") as compile_kernel, \
                patch.object(compiler, "cleanup_build_dir"), \
                patch.object(compiler, "load_module", return_value=module), \
                patch.object(cuda, "mem_alloc") as alloc, patch.object(cuda, "memcpy_htod") as upload:
            with self.assertRaisesRegex(RuntimeError, "layout mismatch"):
-                single(context=context)
-            self.assertEqual(compile_kernel.call_args.kwargs["source"], "blocked.cu")
+                PeriodicBlockStepper(config(), layout, context=context)
+            self.assertEqual(compile_kernel.call_args.kwargs["source"], "blocks.cu")
            alloc.assert_not_called()
            upload.assert_not_called()

    def test_static_circle_tables(self):
        layout = BlockLayout2D.build(NY, NX, 12, 16)
-        tables = static_circle_tables(layout, (circle(),))
+        tables = implementation._static_circles(layout, (circle(),))
        links = CircleGeometry(*CENTER, RADIUS).build_cut_links(NX, NY, domain_flags=dense_flags())
        self.assertEqual(len(tables["cell"]), len(links))
        np.testing.assert_array_equal(tables["q"], np.array([l.q for l in links], np.float32))
@@ -190,11 +185,84 @@ class CpuContracts(unittest.TestCase):
        self.assertTrue((tables["flags"][solid_cells] & 2).all())
        self.assertEqual(int(np.count_nonzero(tables["flags"] & 2)), int(tables["solid"].sum()))

+    def fake_backend(self):
+        backend = PeriodicBlockStepper.__new__(PeriodicBlockStepper)
+        backend.layout = BlockLayout2D.build(NY, NX, 12, 16)
+        backend.ctx = Mock(activate=nullcontext)
+        backend._lock = RLock()
+        backend._status = "ready"
+        backend._step_count = 0
+        backend._stream = Mock()
+        backend._module = Mock()
+        backend._copy = backend._step = Mock()
+        backend.boundary, backend._curved, backend._tables, backend._links = None, None, {}, 0
+        backend._dst, backend._src = Mock(), Mock()
+        backend._block, backend._grid, backend._copy_grid = (32, 1, 1), (1, 1, 1), (1, 1)
+        backend._allocations = [Mock(), Mock()]
+        backend._current, backend._spare = backend._allocations
+        return backend

-class SingleLevelGPU(unittest.TestCase):
+    def test_initialize_rejects_bad_state_before_upload(self):
+        backend = self.fake_backend()
+        good = initial_state()
+        bad = (good[:, :-1], np.where(np.arange(NX) == 3, np.nan, good), -good)
+        with patch.object(cuda, "memcpy_htod") as upload:
+            for g in bad:
+                with self.assertRaises(ValueError):
+                    backend.initialize(g)
+            upload.assert_not_called()
+            backend.initialize(good)
+            self.assertEqual(upload.call_count, 2)
+            self.assertTrue(np.isnan(upload.call_args_list[1].args[1]).all())
+        backend.close()
+
+    def test_failed_launch_and_download_make_backend_unusable(self):
+        for failure in ("step", "download"):
+            backend = self.fake_backend()
+            if failure == "step":
+                backend._step = Mock(side_effect=RuntimeError("launch failed"))
+                with self.assertRaisesRegex(RuntimeError, "launch failed"):
+                    backend.step()
+            else:
+                with patch.object(cuda, "memcpy_dtoh", side_effect=RuntimeError("read failed")):
+                    with self.assertRaisesRegex(RuntimeError, "read failed"):
+                        backend.download()
+            for operation in (backend.download, backend.step):
+                with self.assertRaisesRegex(RuntimeError, "failed"):
+                    operation()
+            backend.close()
+            for allocation in backend_allocations(backend):
+                allocation.free.assert_called_once()
+
+    def test_activation_failure_retains_resources_for_retry(self):
+        backend = self.fake_backend()
+        allocations, stream, module = backend._allocations[:], backend._stream, backend._module
+        unavailable = MagicMock()
+        unavailable.__enter__.side_effect = RuntimeError("activation failed")
+        backend.ctx.activate = Mock(side_effect=[unavailable, nullcontext()])
+        with self.assertRaisesRegex(RuntimeError, "activation failed"):
+            backend.close()
+        self.assertEqual(backend._status, "failed")
+        self.assertEqual(backend._allocations, allocations)
+        self.assertIs(backend._stream, stream)
+        self.assertIs(backend._module, module)
+        backend.close()
+        self.assertEqual(backend._status, "closed")
+        self.assertIsNone(backend._module)
+        self.assertIsNone(backend._copy)
+        self.assertIsNone(backend._step)
+        for allocation in allocations:
+            allocation.free.assert_called_once()
+
+
+def backend_allocations(backend):
+    return (backend._current, backend._spare)
+
+
+class PeriodicBlockGPU(unittest.TestCase):
    def setUp(self):
        self.assertEqual(Path(implementation.__file__).resolve(),
-                         ROOT / "src/CelerisLab/lbm/refinement_stepper.py")
+                         ROOT / "src/CelerisLab/lbm/block_stepper.py")

    def tearDown(self):
        rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
@@ -205,13 +273,13 @@ class SingleLevelGPU(unittest.TestCase):
        g0 = initial_state()
        results = []
        with CudaContext(0) as context:
-            for split in SPLITS:
-                with single(context=context, block=split) as backend:
+            for by, bx in SPLITS:
+                layout = BlockLayout2D.build(NY, NX, by, bx)
+                with PeriodicBlockStepper(config(), layout, context=context) as backend:
                    backend.initialize(g0)
                    backend.step(STEPS)
                    self.assertEqual(backend.step_count, STEPS)
-                    (g,) = backend.download()
-                    results.append(g)
+                    results.append(backend.download())
        for (by, bx), g in zip(SPLITS, results):
            self.assertTrue(np.isfinite(g).all(), (by, bx))
            np.testing.assert_array_equal(g, results[0], err_msg=f"split {(by, bx)}")
@@ -238,17 +306,16 @@ class SingleLevelGPU(unittest.TestCase):
        g0 = initial_state()
        results = []
        with CudaContext(0) as context:
-            for split in SPLITS:
-                with single(context=context, block=split, objects=[circle()]) as backend:
-                    tables = backend._level_boundaries[0].tables
+            for by, bx in SPLITS:
+                layout = BlockLayout2D.build(NY, NX, by, bx)
+                with PeriodicBlockStepper(config(), layout, context=context, objects=[circle()]) as backend:
                    for key, values, dtype in (("q", [l.q for l in links], np.float32),
                                               ("dir", [l.dir for l in links], np.uint8),
                                               ("fallback", [l.fallback for l in links], np.uint8)):
-                        np.testing.assert_array_equal(tables[key], np.array(values, dtype))
+                        np.testing.assert_array_equal(backend.boundary[key], np.array(values, dtype))
                    backend.initialize(g0)
                    backend.step(STEPS)
-                    (g,) = backend.download()
-                    results.append(g)
+                    results.append(backend.download())
        for (by, bx), g in zip(SPLITS, results):
            self.assertTrue(np.isfinite(g[:, ~solid]).all(), (by, bx))
            self.assertTrue(np.isnan(g[:, solid]).all(), (by, bx))
@@ -11,7 +11,7 @@ import numpy as np
 import pycuda.driver as cuda

 from CelerisLab.config import LBMConfig
-from CelerisLab.cuda import compiler
+from CelerisLab.cuda import compiler_v2 as compiler
 from CelerisLab.cuda.context import CudaContext
 from CelerisLab.lbm.blocks import BlockLayout2D
 from CelerisLab.lbm.descriptors import FLUID, SOLID, BC_WALL, BC_INLET, BC_OUTLET
@@ -27,7 +27,7 @@ def state(ny, nx):

 def compile_module(cfg, context, source):
    cfg.validate()
-    build = compiler.generate_config(cfg, block_root_bc=2 if source == "blocked.cu" else 0)
+    build = compiler.generate_config(cfg)
    try:
        module = compiler.load_module(compiler.compile_kernel(context.sm_arch, source=source, build_dir=build))
    finally:
@@ -46,7 +46,7 @@ def run_root(cfg, context, initial, block=None, steps=8):
    try:
        layout = None if block is None else BlockLayout2D.build(cfg.ny, cfg.nx, *block)
        local = cfg if layout is None else replace(cfg, nx=layout.local_shape[1], ny=layout.local_shape[0])
-        module = compile_module(local, context, "uniform.cu" if layout is None else "blocked.cu")
+        module = compile_module(local, context, "kernel_v2.cu" if layout is None else "blocks.cu")
        data = initial if layout is None else layout.to_blocked(initial)
        current, spare = upload(data), upload(np.full_like(data, np.nan))
        tpb = cfg.threads_per_block
@@ -106,10 +106,9 @@ class ChannelRootGPU(unittest.TestCase):
                    cfg = LBMConfig(nx=48, ny=32, viscosity=.1, velocity=.015, ddf_shifting=shifted)
                    reference = None
                    for block in ((32,48), (8,8), (4,1)):
-                        with FixedPatchStepper(cfg, context=context, coarse_boundary="channel",
-                                refinements=[(8,6,40,26)], level_blocks=[block, (8,8)],
-                                level_objects=[(), (body,) if bodies else ()],
-                                level_jets=[(), (jet,) if bodies else ()]) as backend:
+                        with FixedPatchStepper(cfg, (8,6,40,26), context=context,
+                                coarse_boundary="channel", base_block=block, fine_block=(8,8),
+                                fine_objects=(body,) if bodies else (), jets=(jet,) if bodies else ()) as backend:
                            arrays = [state(*level.shape[1:]) for level in backend._levels]
                            backend.initialize(*arrays)
                            backend.step(4)
@@ -25,8 +25,8 @@ EPS = np.finfo(np.float64).eps


 def build(m, window=True, raw=True):
-    return FixedPatchStepper(config("periodic"), context=m["context"], refinements=[BOUNDS],
-                             level_blocks=[(3, 4), (16, 20)], level_objects=[(), (circle(),)],
+    return FixedPatchStepper(config("periodic"), BOUNDS, context=m["context"], base_block=(3, 4),
+                             fine_block=(16, 20), fine_objects=[circle()],
                             observe_raw_exchange=raw, observe_window_exchange=window)


@@ -109,11 +109,10 @@ class ExchangeWindowGPU(unittest.TestCase):
        from test_raw_exchange_gpu import BOUNDS as RB, CFG, circle as rc, jet, state
        from CelerisLab.cuda.context import CudaContext
        with CudaContext(0) as ctx:
-            kw = dict(context=ctx, refinements=[RB], level_blocks=[(12, 8), (16, 20)],
-                      level_objects=[(), (rc(),)], level_jets=[(), (jet(),)],
+            kw = dict(context=ctx, fine_block=(16, 20), fine_objects=[rc()], jets=[jet()],
                      observe_raw_exchange=True)
-            with FixedPatchStepper(CFG, observe_window_exchange=True, **kw) as windowed, \
-                 FixedPatchStepper(CFG, **kw) as plain:
+            with FixedPatchStepper(CFG, RB, observe_window_exchange=True, **kw) as windowed, \
+                 FixedPatchStepper(CFG, RB, **kw) as plain:
                arrays = [state(level.shape) for level in windowed._levels]
                windowed.initialize(*arrays)
                plain.initialize(*arrays)
@@ -201,11 +200,11 @@ class ExchangeWindowShiftedMRTGPU(unittest.TestCase):
        from CelerisLab.cuda.context import CudaContext
        cfg = LBMConfig(nx=32, ny=24, viscosity=.1, collision="MRT", ddf_shifting=True)
        with CudaContext(0) as ctx:
-            kw = dict(context=ctx, refinements=[RB], level_blocks=[(12, 8), (16, 20)],
-                      level_objects=[(), (rc(),)], observe_raw_exchange=True)
-            with FixedPatchStepper(cfg, observe_window_exchange=True, **kw) as windowed, \
-                 FixedPatchStepper(cfg, observe_window_exchange=True, **kw) as split, \
-                 FixedPatchStepper(cfg, **kw) as plain:
+            kw = dict(context=ctx, base_block=(12, 8), fine_block=(16, 20), fine_objects=[rc()],
+                      observe_raw_exchange=True)
+            with FixedPatchStepper(cfg, RB, observe_window_exchange=True, **kw) as windowed, \
+                 FixedPatchStepper(cfg, RB, observe_window_exchange=True, **kw) as split, \
+                 FixedPatchStepper(cfg, RB, **kw) as plain:
                arrays = [state(level.shape) for level in windowed._levels]
                for run in (windowed, split, plain):
                    run.initialize(*arrays)
@@ -1,17 +1,13 @@
-"""Two coarse/four fine steps: isolated fine circle on blocked storage, no flux-accuracy claim.
+"""Two coarse/four fine steps: isolated fine circle, no flux-accuracy claim.

-Run only through the bounded GPU runner after a fresh resource check. The fine
-step hook reads the actual output buffer; it never changes the stepping order.
-
-Retired with the dense refinement route (accepted losses, see the D2 commit):
-the dense-kernel per-hop flux ledger (fine/coarse transfer + boundary budget),
-the CurvedLinkSoA reflection oracle and the CELERIS_REFINEMENT_AUDIT collision
-counts. The blocked test keeps the four-hop comparison with the uniform solver,
-the raw-exchange mass sign and passive == zero actuation; raw exchange covers
-the boundary part only, not full population flux closure.
+Run only through the bounded GPU runner after a fresh resource check. The test
+hooks read actual kernel inputs/outputs; they never change the stepping order.
 """
 import importlib.util
+from contextlib import nullcontext
 from pathlib import Path
+from threading import RLock
+from types import SimpleNamespace
 from unittest.mock import Mock, patch

 import numpy as np
@@ -22,6 +18,7 @@ import CelerisLab
 from CelerisLab.body.geometry.circle import CircleGeometry
 from CelerisLab.body.objects import SimObject
 from CelerisLab.config import LBMConfig
+from CelerisLab.cuda import compiler_v2 as compiler
 from CelerisLab.cuda.context import CudaContext
 from CelerisLab.lbm import refinement_stepper as implementation
 from CelerisLab.lbm.descriptors import FLUID, SOLID
@@ -30,8 +27,10 @@ from CelerisLab.lbm.descriptors import FLUID, SOLID
 ROOT = Path(__file__).resolve().parents[3]
 CX = np.array([0, 1, -1, 0, 0, 1, -1, 1, -1])
 CY = np.array([0, 0, 0, 1, -1, 1, -1, -1, 1])
+OPP = np.array([0, 2, 1, 4, 3, 6, 5, 8, 7])
 W = np.array([4/9]+[1/9]*4+[1/36]*4)
 MOMENTS = np.stack((np.ones(9), CX, CY))
+GEOMETRY = ("fluid_idx", "dir", "q", "body_id", "rx", "ry", "rz", "fallback_class")
 BOUNDS = (4, 4, 20, 20)


@@ -54,6 +53,196 @@ def object_spec(speed):
                     radius=2.15, surface_actuation=surface(speed))


+def audit_compiler(original):
+    def compile_private(*args, **kwargs):
+        entry = Path(kwargs["build_dir"])/"fine_surface_audit.cu"
+        entry.write_text('#define CELERIS_REFINEMENT_AUDIT\n#include "refinement.cu"\n')
+        kwargs["source"] = entry.name
+        return original(*args, **kwargs)
+    return compile_private
+
+
+def reflection_oracle(before, cl, speed, *, verify_projection=True):
+    """FP64 BFL from frozen spatial populations, independent arc projection."""
+    flat = before.astype(float).reshape(9, -1)
+    radius = np.hypot(cl.rx.astype(float), cl.ry.astype(float))
+    delta = (np.arctan2(cl.ry.astype(float), cl.rx.astype(float))-.7+np.pi) % (2*np.pi)-np.pi
+    amplitude = 0 if speed is None else speed
+    strength = amplitude*np.maximum(0, 1-(delta/.85)**2)**2
+    velocity = strength[:, None]*np.column_stack((cl.rx, cl.ry))/radius[:, None]
+    if verify_projection and cl.surface_velocity is not None:
+        np.testing.assert_allclose(cl.surface_velocity, velocity, atol=3e-9, rtol=0)
+    incoming = []
+    for i, (k, d, q, fallback) in enumerate(zip(cl.fluid_idx, cl.dir, cl.q, cl.fallback_class)):
+        k, d, q = int(k), int(d), float(q)
+        rho = flat[:, k].sum()
+        dot = CX[d]*velocity[i, 0]+CY[d]*velocity[i, 1]
+        if fallback:
+            value = flat[d, k]-6*W[d]*rho*dot
+        elif q < .5:
+            value = 2*q*flat[d, k]+(1-2*q)*flat[d, k-CX[d]-40*CY[d]]-6*W[d]*rho*dot
+        else:
+            value = flat[d, k]/(2*q)+(1-1/(2*q))*flat[OPP[d], k]-3*W[d]*rho*dot/q
+        incoming.append(value)
+    return np.array(incoming)
+
+
+def fine_flux(before, staged, active, solid):
+    """Population ledger across the fine leaf boundary: solid versus halo.
+
+    Internal fluid-to-fluid streaming cancels pairwise; solid and halo packets
+    are counted in their actual direction, before any collision.
+    """
+    boundary, transfer = np.zeros(9), np.zeros(9)
+    magnitude = 0.0
+    for d, (cx, cy) in enumerate(zip(CX, CY)):
+        incoming = active & ~np.roll(active, (cy, cx), (0, 1))
+        outgoing = active & ~np.roll(active, (-cy, -cx), (0, 1))
+        from_solid = np.roll(solid, (cy, cx), (0, 1))
+        into_solid = np.roll(solid, (-cy, -cx), (0, 1))
+        received = np.roll(staged[d], (cy, cx), (0, 1)).astype(float)
+        sent = before[d].astype(float)
+        for vector, inc, out in ((boundary, incoming & from_solid, outgoing & into_solid),
+                                 (transfer, incoming & ~from_solid, outgoing & ~into_solid)):
+            assert np.isfinite(received[inc]).all() and np.isfinite(sent[out]).all()
+            vector[d] = received[inc].sum()-sent[out].sum()
+            magnitude += np.abs(received[inc]).sum()+np.abs(sent[out]).sum()
+    return boundary, transfer, magnitude
+
+
+def coarse_flux(before, fine, active):
+    """Derive every replacement from physical midpoints, not production tables."""
+    x0, y0, x1, y1 = BOUNDS
+    incoming = np.stack([np.roll(before[d], (CY[d], CX[d]), (0, 1)) for d in range(9)]).astype(float)
+    magnitude = 0.0
+    for y, x in np.argwhere(active):
+        for d in range(1, 9):
+            if x0 <= x+.5-CX[d]/2 <= x1 and y0 <= y+.5-CY[d]/2 <= y1:
+                a, b = 4+2*(x-x0), 4+2*(y-y0)
+                children = fine[d, b:b+2, a:a+2].astype(float)
+                assert children.shape == (2, 2) and np.isfinite(children).all()
+                incoming[d, y, x] = children.sum()/4
+                magnitude += np.abs(children).sum()/4
+    assert np.isfinite(incoming[:, active]).all()
+    # This retains the eight grazing-corner replacements of uncovered donors.
+    flux = (incoming[:, active]-before[:, active].astype(float)).sum(axis=1)
+    magnitude += np.abs(incoming[:, active]).sum()+np.abs(before[:, active]).sum(dtype=float)
+    return flux, magnitude
+
+
+def run_patch(speed, *, audit=True):
+    cfg = LBMConfig(nx=24, ny=24, viscosity=.05, velocity=0, rho=1)
+    coarse_active = np.ones((24, 24), bool)
+    coarse_active[4:20, 4:20] = False
+    source = object_spec(speed)
+    state = vars(source.state).copy()
+    with CudaContext(0) as context:
+        build = (patch.object(compiler, "compile_kernel", audit_compiler(compiler.compile_kernel))
+                 if audit else nullcontext())
+        with build:
+            backend = implementation.FixedPatchStepper(cfg, BOUNDS, context=context, fine_objects=[source])
+        with backend, context.activate():
+            c, f = backend._levels
+            cl = backend._fine_curved
+            geometry = {name: getattr(cl, name).copy() for name in GEOMETRY}
+            flags = backend.fine_boundary.flags.reshape(40, 40)
+            solid = (flags & SOLID) != 0
+            active = np.zeros((40, 40), bool)
+            active[4:-4, 4:-4] = True
+            active &= (flags & FLUID) != 0
+            active &= ~solid
+            local = backend.fine_boundary.objects[0]
+            assert local.center == (20., 20.) and local.radius == 4.3
+            assert source.center == (12.25, 12.25) and source.radius == 2.15
+            yy, xx = np.mgrid[:40, :40]
+            roi = active & ((xx-20)**2+(yy-20)**2 <= 9**2)
+            backend.initialize(rest((24, 24)), rest((40, 40)))
+            if audit:
+                for level in backend._levels:
+                    for name in ("collision_counts", "explosion_counts", "incoming_counts"):
+                        pointer, size = level.module.get_global(name)
+                        cuda.memset_d8(pointer, 0, size)
+            initial = backend.download()
+            initial_pop = initial[0][:, coarse_active].sum(axis=1, dtype=float)
+            initial_pop += .25*initial[1][:, active].sum(axis=1, dtype=float)
+            boundary, fine_transfer, coarse_transfer = np.zeros(9), np.zeros(9), np.zeros(9)
+            budget_sum, reflection_error, drive_mass = 0., 0., 0.
+            traces = []
+            original_curved, original_fine, original_coarse = backend._curved, f.kernel, c.kernel
+
+            def curved(*args, **kwargs):
+                nonlocal boundary, fine_transfer, budget_sum, reflection_error, drive_mass
+                backend._stream.synchronize()
+                before = read(args[0], f.shape)
+                expected = reflection_oracle(before, cl, speed)
+                original_curved(*args, **kwargs)
+                backend._stream.synchronize()
+                staged = read(args[0], f.shape)
+                d, k = cl.dir.astype(int), cl.fluid_idx.astype(int)
+                values = staged.reshape(9, -1)[OPP[d], k+CX[d]+40*CY[d]]
+                passive = reflection_oracle(before, cl, None, verify_projection=False)
+                drive_mass += .25*float(np.sum(values-passive))
+                error = float(np.max(np.abs(values-expected)))
+                reflection_error = max(reflection_error, error)
+                assert error <= 1e-7
+                np.testing.assert_array_equal(staged[:, active], before[:, active])
+                b, transfer, magnitude = fine_flux(before, staged, active, solid)
+                boundary += .25*b
+                fine_transfer += .25*transfer
+                budget_sum += .25*magnitude
+
+            def fine(*args, **kwargs):
+                nonlocal budget_sum
+                backend._stream.synchronize()
+                staged = read(args[0], f.shape)
+                original_fine(*args, **kwargs)
+                backend._stream.synchronize()
+                advanced = read(args[1], f.shape)
+                assert np.isfinite(advanced[:, active]).all()
+                assert np.isnan(advanced[:, solid]).all()
+                # Include actual collision operands in the FP32 rounding budget.
+                budget_sum += .25*np.abs(staged[:, active]).sum(dtype=float)
+                traces.append(advanced[:, roi].copy())
+
+            def coarse(*args, **kwargs):
+                nonlocal coarse_transfer, budget_sum
+                backend._stream.synchronize()
+                before, fine_values = read(args[0], c.shape), read(args[2], f.shape)
+                transfer, magnitude = coarse_flux(before, fine_values, coarse_active)
+                coarse_transfer += transfer
+                budget_sum += magnitude
+                return original_coarse(*args, **kwargs)
+
+            with patch.object(backend, "_curved", curved), patch.object(f, "kernel", fine), \
+                    patch.object(c, "kernel", coarse):
+                backend.step(2)
+            actual = backend.download()
+            population = actual[0][:, coarse_active].sum(axis=1, dtype=float)
+            population += .25*actual[1][:, active].sum(axis=1, dtype=float)
+            ledger = boundary+fine_transfer+coarse_transfer
+            error = MOMENTS@(population-initial_pop-ledger)
+            budget = 8*np.finfo(np.float32).eps*budget_sum
+            assert np.isfinite(budget_sum) and budget_sum > 0
+            assert np.max(np.abs(error)) <= budget
+            if speed:
+                assert speed*drive_mass > 0
+            assert len(traces) == 4 and backend.step_count == 2
+            if audit:
+                for level, mask, count in ((c, coarse_active, 2), (f, active, 4)):
+                    pointer, size = level.module.get_global("collision_counts")
+                    counts = read(pointer, mask.shape, np.uint32)
+                    assert size == counts.nbytes
+                    np.testing.assert_array_equal(counts, count*mask)
+            for name, values in geometry.items():
+                np.testing.assert_array_equal(getattr(cl, name), values)
+            assert vars(source.state) == state and source.geometry.center == source.center
+            print(f"speed={speed} audit={audit} BFL={reflection_error:.9g} ledger={error.tolist()} "
+                  f"budget={budget:.9g} boundary={list(MOMENTS@boundary)} "
+                  f"transfer={list(MOMENTS@(fine_transfer+coarse_transfer))} "
+                  f"drive_mass={drive_mass:+.9g}; counts={'PASS' if audit else 'normal build'}", flush=True)
+            return traces, roi, actual
+
+
 def uniform_reference(speed, roi):
    # Reuse the existing explicit config helper without importing unrelated tests.
    spec = importlib.util.spec_from_file_location("fine_surface_cases", ROOT/"tests/integration/_cases.py")
@@ -71,59 +260,61 @@ def uniform_reference(speed, roi):
        return traces


-def run_blocked_patch(speed):
-    """All-blocked run (whole-level tiles) of the same case; fine ROI after each fine hop."""
-    cfg = LBMConfig(nx=24, ny=24, viscosity=.05, velocity=0, rho=1)
-    source = object_spec(speed)
-    with CudaContext(0) as context:
-        with implementation.FixedPatchStepper(cfg, context=context, refinements=[BOUNDS],
-                                              level_blocks=[(24, 24), (40, 40)],
-                                              level_objects=[(), (source,)],
-                                              observe_raw_exchange=True) as backend:
-            c, f = backend._levels
-            flags = backend.fine_boundary.flags.reshape(40, 40)
-            active = np.zeros((40, 40), bool)
-            active[4:-4, 4:-4] = True
-            active &= ((flags & FLUID) != 0) & ((flags & SOLID) == 0)
-            yy, xx = np.mgrid[:40, :40]
-            roi = active & ((xx-20)**2+(yy-20)**2 <= 9**2)
-            backend.initialize(rest((24, 24)), rest((40, 40)))
-            traces, original = [], f.kernel
-
-            def fine(*args, **kwargs):
-                original(*args, **kwargs)
-                backend._stream.synchronize()
-                advanced = f.layout.to_dense(read(args[1], f.layout.blocked_shape))
-                assert np.isfinite(advanced[:, active]).all()
-                assert np.isnan(advanced[:, (flags & SOLID) != 0]).all()
-                traces.append(advanced[:, roi].copy())
-
-            with patch.object(f, "kernel", fine):
-                backend.step(2)
-            assert len(traces) == 4 and backend.step_count == 2
-            mass = backend.read_raw_exchange(0)["total"]["mass_into_fluid"]
-            return traces, roi, backend.download(), float(mass)
-
-
@pytest.mark.parametrize("speed", [0., .002, -.002])
-def test_fine_surface_blocked_matches_uniform_four_hops(speed):
-    """Blocked storage: fine ROI after each of four hops against the uniform 48^2 solver
-    (same tolerances as the dense test); blowing/suction drives mass with its sign;
-    zero actuation equals the passive circle bit for bit."""
-    actual, roi, final, mass = run_blocked_patch(speed)
+def test_fine_surface_four_hops(speed):
+    assert Path(CelerisLab.__file__).resolve() == ROOT/"src/CelerisLab/__init__.py"
+    assert Path(compiler._KERNEL_DIR).resolve() == ROOT/"src/CelerisLab/lbm/kernels"
+    assert Path(implementation.__file__).resolve() == ROOT/"src/CelerisLab/lbm/refinement_stepper.py"
+    actual, roi, final = run_patch(speed)
    reference = uniform_reference(speed, roi)
    for got, wanted in zip(actual, reference):
        np.testing.assert_allclose(got, wanted, atol=3e-6, rtol=0)
        np.testing.assert_allclose(MOMENTS@got.astype(float), MOMENTS@wanted.astype(float),
                                   atol=2e-5, rtol=0)
-    if speed:
-        assert speed*mass > 0
-    else:
-        passive, passive_roi, passive_final, _ = run_blocked_patch(None)
+    if speed == 0:
+        passive, passive_roi, passive_final = run_patch(None, audit=False)
        np.testing.assert_array_equal(passive_roi, roi)
        for got, wanted in zip(actual+list(final), passive+list(passive_final)):
            np.testing.assert_array_equal(got, wanted)
-    print(f"blocked speed={speed} four hops vs uniform PASS mass_into_fluid={mass:+.9g}", flush=True)
+
+
+@pytest.mark.parametrize("missing", ["surface_velocity_gpu", "link_exchange_gpu"])
+def test_missing_surface_device_buffer_rejects_before_launch(missing):
+    backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
+    backend.fine_boundary = SimpleNamespace(objects=[object_spec(.002)])
+    backend._fine_curved = SimpleNamespace(fluid_idx_gpu=object(),
+                                          surface_velocity_gpu=object(), link_exchange_gpu=object())
+    setattr(backend._fine_curved, missing, None)
+    backend._curved = Mock()
+    with pytest.raises(RuntimeError, match="Surface boundary device buffers are missing"):
+        backend._apply_fine_boundary(object())
+    backend._curved.assert_not_called()
+
+
+def test_close_frees_fine_boundary_after_stream_failure_once():
+    backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
+    backend.ctx = SimpleNamespace(activate=nullcontext)
+    backend._lock = RLock()
+    backend._status = "ready"
+    stream, soa, first, second = Mock(), Mock(), Mock(), Mock()
+    stream.synchronize.side_effect = RuntimeError("stream synchronization failed")
+    backend._stream = stream
+    backend._fine_curved = soa
+    backend._fine_flags = first
+    backend._curved = Mock()
+    backend._levels = [object(), object()]
+    backend._allocations = [first, second]
+    with pytest.raises(RuntimeError, match="stream synchronization failed"):
+        backend.close()
+    assert backend._status == "closed"
+    assert backend._levels == [] and backend._allocations == []
+    assert backend._fine_curved is None and backend._fine_flags is None
+    assert backend._curved is None and backend._stream is None
+    backend.close()
+    stream.synchronize.assert_called_once_with()
+    soa.free.assert_called_once_with()
+    first.free.assert_called_once_with()
+    second.free.assert_called_once_with()


 def test_cross_interface_donor_rejects_before_cuda():
@@ -134,8 +325,6 @@ def test_cross_interface_donor_rejects_before_cuda():
    context.activate.side_effect = AssertionError("must reject before CUDA activation")
    with patch.object(cuda, "mem_alloc") as allocate:
        with pytest.raises(ValueError, match="donor crosses"):
-            implementation.FixedPatchStepper(cfg, context=context, refinements=[BOUNDS],
-                                             level_blocks=[(24, 24), (40, 40)],
-                                             level_objects=[(), (source,)])
+            implementation.FixedPatchStepper(cfg, BOUNDS, context=context, fine_objects=[source])
        context.activate.assert_not_called()
        allocate.assert_not_called()
@@ -48,8 +48,9 @@ def make(context):
        for (x, y), amplitude in zip(centers, (.003, -.002))
    )
    run = FixedPatchStepper(
-        CFG, context=context, refinements=[PARENTS, START], level_blocks=[(4, 4)] * 3,
-        level_objects=[(), (), objects], level_jets=[(), (), jets],
+        CFG, PARENTS, context=context, base_block=(4, 4), fine_block=(4, 4),
+        child_block=(4, 4), child_rectangles_in_parent=START,
+        child_objects=objects, child_jets=jets,
    )
    return run, objects

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Codex	f287b460fd	test: close concave union crossing and transit ownership	2026-10-18 13:35:06 -07:00
Codex	90694e69af	test: define union space-time event ownership contract	2026-10-18 13:20:35 -07:00
Codex	707afe6bb2	test: prepare matched shifted GPU spacing ladder	2026-10-18 12:35:05 -07:00
Codex	26d0d3853c	test: admit audited shifted N64 space-time trajectory	2026-10-18 12:03:35 -07:00
Codex	e8b8c58995	test: add opt-in shifted storage to space-time GPU prototype	2026-10-18 11:13:50 -07:00
Codex	c2496c2103	test: accumulate same-trajectory space-time GPU rounding ledger	2026-10-18 10:47:51 -07:00
Codex	1779cf29f2	test: separate topology identity from FP64 table validation	2026-10-18 10:17:43 -07:00
Codex	5dcd3e0dbe	test: add bounded N64 space-time GPU trajectory harness	2026-10-18 09:32:21 -07:00
Codex	d61560d98a	test: add bounded space-time GPU packet prototype	2026-10-18 09:07:15 -07:00
Codex	3496a1e3c1	test: normalize NumPy scalars in space-time receipts	2026-10-18 08:55:41 -07:00
Codex	b983c1d095	test: prototype conservative space-time rectangle coupling	2026-10-18 08:55:41 -07:00