diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96355418..d35804e2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+This is a breaking release. It corrects the surface-EMG pipeline against Farina, Mesin, Martina & Merletti (2004). The problems were found through feedback from @joaohbbittar; thank you. Both the default route and `execution=` are affected.
+
+### Breaking changes
+
+This release changes default outputs; regenerate anything calibrated against earlier versions.
+
+- sEMG outputs change in amplitude, shape, duration and spectrum. Bipolar outputs from 0.5.0–0.13.0 are invalid. Durations, mean/median frequencies and conduction-velocity estimates from those versions are off by about 2× and must be regenerated.
+- Absolute sEMG amplitudes change by one to two orders of magnitude (amplitude no longer depends on conduction velocity). Anything calibrated in µV or mV against earlier outputs must be regenerated. To keep the earlier resistive (measured) skin layer, pass `skin_conductivity__S_per_m=4.88e-4 * pq.S / pq.m` to `Muscle`. To keep the earlier layers, pass `skin_thickness__mm=1.29 * pq.mm, fat_thickness__mm=0.3 * pq.mm`.
+- Pickled `SurfaceEMG` objects from earlier versions lack the new fibre properties; create them again.
+- The `execution=` MUAP disk-cache key changes, so templates cached by earlier versions are recomputed.
+- iEMG outputs change through the narrower end-plate spreads. Pass `IntramuscularEMG(..., nmj_coefficients="reference_code")` to reproduce earlier end-plates.
+
+### Fixed
+
+- **Longitudinal bipolar channels.** The angular integral B(k_z) is now complex. Keeping only its real part made `bipolar_longitudinal` channels about 10⁻⁷ of their true value and distorted rotated arrays. A bipolar channel now equals the difference of the two monopolar electrodes, on the default, `execution=` and `use_unified=True` routes.
+- **MUAP time axis.** MUAP templates are labelled with the rate of the grid they were computed on (window `K / v`). The previous label was 2× too high, so MUAPs looked half as long, spectra sat an octave high, and conduction velocity estimated from the output was 2× the value set.
+- **Rosenfalck IAP length scale.** The IAP is evaluated on the simulation's own z axis (λ = 1 mm, as published), not on `z / 2`. The stretched IAP was 2× too long; it now agrees with the independent time-domain path (`simulate_fiber_hybrid`).
+- **Fibre semi-lengths.** `L1` (towards +z) and `L2` were swapped, which moved both tendons by 2·z_i with the end-plate. Fibres now span `±fiber_length / 2` with the end-plate at z_i (`fiber_semi_lengths`).
+- **Fibre timing within a motor unit.** Each fibre's potential was circularly shifted onto its own peak before summation, misaligning fibres (up to ~60 % MUAP error on bipolar channels). All fibres now share the firing instant at the window centre.
+- **Mixed electrode-array shapes.** On the default route each array's MUAPs have that array's own grid shape; previously every array was broadcast into the first array's shape.
+- **Absolute sEMG amplitude.** Three scaling errors are corrected; together they made MUAPs labelled mV roughly 50-100× too large. A single fibre now matches an exact solution for a homogeneous insulated cylinder within 2 %.
+  - The Fourier transforms dropped their `dz` and `Fs/N` factors, so every potential was divided by the conduction velocity.
+  - The source was the bare Rosenfalck slope with an ad-hoc `A = 96/10`. It is now the core-conductor line current `σᵢ·π·(d/2)²·∂²Vm/∂z²` with the published `A = 96 mV/mm³`.
+  - The default skin conductivity was 4.88·10⁻⁴ S/m (measured composite skin, Botelho et al. 2019), which raised amplitudes 3.5-6×. It is now 1 S/m, as in Farina et al. (2004). That value comes from Roeleveld et al. (1997), who chose it so their model matched how biceps MUAPs fall off with depth and around the arm; it is an effective value, not a measured skin conductivity. MyoGen keeps it as a calibration: with the low-frequency skin conductivity of the IT'IS tissue database (0.15 S/m, the mean of 7 studies ranging 0.06–0.25 S/m; Baumgartner et al. 2025) the FDI plateau RMS is about 2.5-4× above published ranges (`benchmarks/semg_dispersion/`). A check against Roeleveld's fall-off data (`benchmarks/semg_roeleveld1997/`) was inconclusive and does not support 1 S/m as a skin property.
+- **Default skin and fat thickness (FDI).** Skin 1.29 → 1.2 mm (hand dorsum median, Li et al. 2018) and fat 0.3 → 1.3 mm, so the total depth to muscle is 2.5 mm, the low end of the FDI depth measured by Nishikawa et al. (2024); the fat value is derived from that total, not measured. Surface amplitudes from the default `Muscle` fall by about 40 %.
+- **Failed motor units raise.** On the default `SurfaceEMG` route an exception while simulating one motor unit was logged and replaced by an all-zero MUAP, which passes for a valid, silent unit. The exception is now re-raised with the unit and array index; the `ExecutionPolicy` route already raised.
+- **Angular sampling overflow raises.** With `sampling_points_in_theta_domain` ≥ 256 the scaled modified Bessel functions leave the float64 range at the highest angular orders (I_n underflows to 0, K_n overflows). The volume conductor replaced the overflowing entries with zero, which gave a singular system on the CPU and NaN MUAPs on the GPU. It now raises a `ValueError` that names the setting.
+
+### Added
+
+- `SurfaceEMG(fiber_diameter__um=50, intracellular_conductivity__S_m=1.01)` set the source strength; amplitude scales with the fibre cross-section.
+- `SurfaceEMG(iap_lambda__per_mm=1.0)` sets the length scale of the Rosenfalck IAP, `Vm = 96 (λz)³ e^{−λz} − 90` mV. The default, 1 / mm, is the published value and leaves outputs unchanged. Values below 1 stretch the IAP, lower the MUAP's spectral content and raise surface amplitude. On the FDI defaults, λ = 0.7 matched the median frequency (~175 vs ~165 Hz measured) and adjacent-pin RMS of the Delsys recordings of Botelho et al. (2019) at 25 % MVC; λ = 1 gives ~200 Hz. Botelho et al. used 0.5 in their own FE model for the same reason. Any value other than 1 is a fitted modelling assumption, from one subject. Supported on the default and `execution=` routes; `use_unified=True` refuses λ ≠ 1.
+- **Fibre dispersion in surface EMG.** `SurfaceEMG(fiber_dispersion=SurfaceFiberDispersion(...))` adds, each switched on independently:
+  - per-fibre end-plates from the two-layer nerve model of Akhmadeev et al. (2020), shared with intramuscular EMG;
+  - axon-branch conduction delays;
+  - motor-unit conduction velocity linear in recruitment threshold (Del Vecchio et al. 2017), and a spread of fibre velocities within each unit, each fibre propagating at its own velocity;
+  - a source scaled by fibre diameter (from the Nandedkar & Stålberg 1983 velocity–diameter line);
+  - tendon-end stagger: each fibre end in a band, independently or following a smooth random field across the cross-section so that neighbouring fibres end close together.
+
+  The realised spreads are reported per motor unit in `SurfaceEMG.fiber_dispersion_report`. The default is off and leaves outputs bit-identical. `SurfaceFiberDispersion.literature_candidate()` gives a preset whose values come from the literature or are marked as assumptions. The `execution=` route and `use_unified=True` refuse an active configuration.
+- `IntramuscularEMG(nmj_coefficients=...)` selects the end-plate spreads (see Changed).
+- `benchmarks/semg_dispersion/`: paired sweeps of these options on a limb-like cylinder and on the default (FDI) muscle.
+
+### Changed
+
+- **End-plate spreads in intramuscular EMG.** The two-layer end-plate model now uses the spreads printed in Akhmadeev et al. (2020, eq. 5-6) instead of the 1.5–2× wider values of their reference code: branch-point SD 1.0 + 2.5·s mm (was 1.5 + 4.0·s) and arborisation SD 0.25 + 1.0·s mm (was 0.5 + 1.5·s), with s the share of total threshold below the unit. In the sEMG limb sweep the realised within-unit end-plate SD fell from a median of 1.68 mm to 1.07 mm. iEMG MUAPs and signals change.
+- Citation corrected: the two-layer end-plate and recruitment-threshold model cited as "Konstantin et al. 2020" is Akhmadeev, Yu, Le Carpentier, Aoustin & Farina (2020); Konstantin is the first author's given name. The `konstantin` threshold mode keeps its name.
+- `Muscle.var_fiber_length__mm` is documented as the half-width of a uniform fibre-length variation (the FDI value of Jacobson et al. 1992), not a variance. Behaviour is unchanged.
+
 ## [0.13.0] - 2026-10-28
 
 Thanks to @joaohbbittar for the detailed report in #26, this release corrects the Fuglevand force model and the Hill muscle activation.
diff --git a/benchmarks/semg_dispersion/README.md b/benchmarks/semg_dispersion/README.md
new file mode 100644
index 00000000..fb3e0bb2
--- /dev/null
+++ b/benchmarks/semg_dispersion/README.md
@@ -0,0 +1,66 @@
+# Surface-EMG fibre-dispersion sweep
+
+Paired simulations behind the `SurfaceFiberDispersion` options and the
+`SurfaceFiberDispersion.literature_candidate()` preset. Each arm reuses the same
+muscle, fibres, spike trains and electrode as its scenario's baseline and
+changes only the dispersion configuration, so MUAPs are compared unit by unit.
+Fibre and spike hashes are stored in every output and checked when scoring.
+
+## Scenarios
+
+| Scenario | Muscle | Electrode |
+|---|---|---|
+| `limb` | cylinder r 15 mm, bone 3 mm, fat 4 mm, 70 ± 5 mm fibres, 350 fibres/mm², 100 MUs | bipolar, 5 mm contacts, IED 10 mm, 20 mm from the end-plate band |
+| `fdi` | default `Muscle` (tuned for the first dorsal interosseous), 120 MUs | bipolar, 2 mm contacts, IED 5 mm, 8 mm from the end-plate band |
+
+Both: 30 % excitation trapezoid, Fuglevand thresholds (50-fold range) recruited up
+to 70 % excitation, 8–35 Hz rate coding, ISI CV 0.2, 2048 Hz. Scoring applies a
+20–450 Hz band-pass and no noise.
+
+## Arms
+
+`arms.json` holds every arm per scenario (`baseline` is the undispersed model).
+Arms run before the published end-plate coefficients became the default pin
+`"nmj_coefficients": "reference_code"`, so they reproduce. `_skin_thickness__mm`
+is a harness key for the skin layer.
+
+Arms with `_spike_file` use NEURON spike trains of the calibrated FDI pool
+(spike times per unit and the pool thresholds), stored under `spikes/`; the
+path is relative to this directory.
+
+## Running
+
+```bash
+# from the repository root; PY selects the interpreter. Check that the
+# recorded myogen path (key "myogen" in each output) is this checkout; set
+# PYTHONPATH to the checkout if another one is installed.
+PY=python bash benchmarks/semg_dispersion/run_arms.sh fdi out/fdi           # all FDI arms
+PY=python bash benchmarks/semg_dispersion/run_arms.sh limb out/limb baseline candidate_published
+python benchmarks/semg_dispersion/score.py fdi out/fdi          # scorecard.tsv, semg_dispersion_sweep.pdf
+python benchmarks/semg_dispersion/plot_signals.py fdi out/fdi   # semg_dispersion_signals.pdf
+python benchmarks/semg_dispersion/plot_amplitude.py out/limb out/fdi out/amplitude.pdf
+```
+
+A limb arm takes about 20–25 min on CPU and an FDI arm about 5 min; the runner
+does three at a time and skips arms already present.
+
+## Findings (2026-10-31)
+
+- Within-unit fibre CV spread is the strongest lever on MUAP peak-to-peak; a
+  CV difference between units only rescales time.
+- In the limb scenario, dispersion mostly blunts the end-of-fibre phase of small
+  and mid units; plateau RMS falls by about 6 %. In the FDI scenario the short,
+  sharp MUAPs of large superficial units lose more, and plateau RMS falls by
+  about 17 %.
+- Tendon ends: a 5 mm band of independent ends lowers median MUAP
+  peak-to-peak by about 17 % (limb); ends correlated over 5 mm across the
+  cross-section, so that neighbours end close together, by about 11 %.
+- FDI skin thickness 1.29 → 3 mm lowers RMS by about 60 %; it is the strongest
+  amplitude lever found so far.
+- Skin conductivity matters more than thickness: at skin 1.2 mm and fat 1.3 mm,
+  1 → 0.15 S/m raises FDI plateau RMS about 3.3×. With 1 S/m and these
+  thicknesses the all-effects model falls inside published FDI ranges; with
+  0.15 S/m, the low-frequency skin conductivity of the IT'IS tissue database
+  (mean of 7 studies, 0.06–0.25 S/m), it is about 2.5–4× too high.
+
+`benchmarks/semg_versions` compares outputs before and after the unreleased surface-EMG fixes.
diff --git a/benchmarks/semg_dispersion/arms.json b/benchmarks/semg_dispersion/arms.json
new file mode 100644
index 00000000..876e1ce3
--- /dev/null
+++ b/benchmarks/semg_dispersion/arms.json
@@ -0,0 +1,1028 @@
+{
+ "limb": {
+  "baseline": {},
+  "nerve_cv_10_4": {
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    10.0,
+    4.0
+   ],
+   "nmj_coefficients": "reference_code"
+  },
+  "nerve_cv_5_2": {
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "nmj_coefficients": "reference_code"
+  },
+  "nerve_cv_2.5_1": {
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    2.5,
+    1.0
+   ],
+   "nmj_coefficients": "reference_code"
+  },
+  "nmj_intra_x0.5": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 0.5,
+   "nmj_coefficients": "reference_code"
+  },
+  "nmj_intra_x1": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nmj_coefficients": "reference_code"
+  },
+  "nmj_intra_x2": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 2.0,
+   "nmj_coefficients": "reference_code"
+  },
+  "nmj_two_layer_x1": {
+   "nmj_model": "two_layer",
+   "nmj_scatter_scale": 1.0,
+   "nmj_coefficients": "reference_code"
+  },
+  "fcv_within_5": {
+   "fiber_cv_within_mu_cov": 0.05
+  },
+  "fcv_within_10": {
+   "fiber_cv_within_mu_cov": 0.1
+  },
+  "fcv_inter_30": {
+   "fiber_cv_inter_mu_spread": 0.3
+  },
+  "fcv_both": {
+   "fiber_cv_inter_mu_spread": 0.3,
+   "fiber_cv_within_mu_cov": 0.05
+  },
+  "fcv_both_diameter": {
+   "fiber_cv_inter_mu_spread": 0.3,
+   "fiber_cv_within_mu_cov": 0.05,
+   "diameter_scales_source": true
+  },
+  "combined": {
+   "nmj_model": "two_layer",
+   "nerve_delays": true,
+   "fiber_cv_inter_mu_spread": 0.3,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "reference_code"
+  },
+  "combined_diameter": {
+   "nmj_model": "two_layer",
+   "nerve_delays": true,
+   "fiber_cv_inter_mu_spread": 0.3,
+   "fiber_cv_within_mu_cov": 0.05,
+   "diameter_scales_source": true,
+   "nmj_coefficients": "reference_code"
+  },
+  "candidate": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "nmj_coefficients": "reference_code"
+  },
+  "candidate_within5": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "reference_code"
+  },
+  "candidate_published": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published"
+  },
+  "tendon_w5": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0
+  },
+  "tendon_w10": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 10.0
+  },
+  "tendon_w5_corr2": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 2.0,
+   "tendon_end_jitter__mm": 0.3
+  },
+  "tendon_w5_corr5": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3
+  },
+  "tendon_w5_corr10": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 10.0,
+   "tendon_end_jitter__mm": 0.3
+  },
+  "full_diameter": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true
+  }
+ },
+ "fdi": {
+  "baseline": {},
+  "candidate_published": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published"
+  },
+  "tendon_w5": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0
+  },
+  "tendon_w5_corr5": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3
+  },
+  "tendon_w10": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 10.0
+  },
+  "full_diameter": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true
+  },
+  "baseline_skin2": {
+   "_skin_thickness__mm": 2.0
+  },
+  "full_skin2": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 2.0
+  },
+  "baseline_skin3": {
+   "_skin_thickness__mm": 3.0
+  },
+  "full_skin3": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 3.0
+  },
+  "baseline_s1.2_f1.3_sig1": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0
+  },
+  "full_s1.2_f1.3_sig1": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0
+  },
+  "baseline_s1.2_f1.3_sig0.15": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15
+  },
+  "full_s1.2_f1.3_sig0.15": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15
+  },
+  "baseline_s1.2_f0.3_sig0.15": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 0.3,
+   "_skin_conductivity__S_per_m": 0.15
+  },
+  "full_s1.2_f0.3_sig0.15": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 0.3,
+   "_skin_conductivity__S_per_m": 0.15
+  },
+  "baseline_s1.2_f2.0_sig0.15": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 2.0,
+   "_skin_conductivity__S_per_m": 0.15
+  },
+  "full_s1.2_f2.0_sig0.15": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 2.0,
+   "_skin_conductivity__S_per_m": 0.15
+  },
+  "baseline_s1.2_f1.3_sig1_d31.4": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 31.4
+  },
+  "full_s1.2_f1.3_sig1_d31.4": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 31.4
+  },
+  "baseline_s1.2_f1.3_sig0.15_d31.4": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 31.4
+  },
+  "full_s1.2_f1.3_sig0.15_d31.4": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 31.4
+  },
+  "baseline_s1.2_f1.3_sig1_d57.9": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9
+  },
+  "full_s1.2_f1.3_sig1_d57.9": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9
+  },
+  "baseline_s1.2_f1.3_sig0.15_d57.9": {
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9
+  },
+  "full_s1.2_f1.3_sig1_d57.9_deluca82": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   }
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_deluca82": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   }
+  },
+  "full_s1.2_f1.3_sig1_d57.9_deluca82_r5.3": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   },
+   "_muscle_radius__mm": 5.3
+  },
+  "full_s1.2_f1.3_sig1_d57.9_deluca82_rho267": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   },
+   "_fiber_density__per_mm2": 267.0
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_deluca82_r5.3": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   },
+   "_muscle_radius__mm": 5.3
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_deluca82_rho267": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   },
+   "_fiber_density__per_mm2": 267.0
+  },
+  "full_s1.2_f2.3_sig1_d57.9_deluca82_rho267": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 2.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   },
+   "_fiber_density__per_mm2": 267.0
+  },
+  "full_s1.2_f2.3_sig0.15_d57.9_deluca82_rho267": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 2.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_rate_model": {
+    "onset": 8.9,
+    "peak_early": 69.0,
+    "peak_late": 44.0,
+    "steepness": 1.55
+   },
+   "_fiber_density__per_mm2": 267.0
+  },
+  "full_s1.2_f1.3_sig1_d57.9_rho267_nrnVL_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/vl_dd_on_fdi/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_rho267_nrnVL_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/vl_dd_on_fdi/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig1_d57.9_rho350_nrnFDI70_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_spike_file": "spikes/nrn/fdi_rec70/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig1_d57.9_rho267_nrnFDI70_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec70/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_rho350_nrnFDI70_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_spike_file": "spikes/nrn/fdi_rec70/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_rho267_nrnFDI70_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec70/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig1_d57.9_rho267_nrnFDI52_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec52/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_rho267_nrnFDI52_25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec52/trap_25mvc.npz"
+  },
+  "full_s1.2_f1.3_sig1_d57.9_rho267_nrnFDI70_25exc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec70/trap_25exc.npz"
+  },
+  "full_s1.2_f1.3_sig0.15_d57.9_rho267_nrnFDI70_25exc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec70/trap_25exc.npz"
+  },
+  "delsys5_sig1_d57.9_rho267_nrnFDI52_fug25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 1.0,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec52_fug/trap_25mvc_fug.npz",
+   "_fs__Hz": 10240.0,
+   "_delsys5": {
+    "z__mm": [
+     0,
+     3,
+     6,
+     9,
+     12
+    ],
+    "rotation__deg": [
+     0,
+     45
+    ],
+    "theta__deg": [
+     0,
+     180
+    ]
+   }
+  },
+  "delsys5_sig0.15_d57.9_rho267_nrnFDI52_fug25mvc": {
+   "nmj_model": "two_layer_intra",
+   "nmj_scatter_scale": 1.0,
+   "nerve_delays": true,
+   "nerve_cvs__m_per_s": [
+    5.0,
+    2.0
+   ],
+   "fiber_cv_threshold_slope": 0.63,
+   "fiber_cv_within_mu_cov": 0.05,
+   "nmj_coefficients": "published",
+   "tendon_end_band__mm": 5.0,
+   "tendon_end_correlation__mm": 5.0,
+   "tendon_end_jitter__mm": 0.3,
+   "diameter_scales_source": true,
+   "_skin_thickness__mm": 1.2,
+   "_fat_thickness__mm": 1.3,
+   "_skin_conductivity__S_per_m": 0.15,
+   "_fiber_diameter__um": 57.9,
+   "_fiber_density__per_mm2": 267.0,
+   "_spike_file": "spikes/nrn/fdi_rec52_fug/trap_25mvc_fug.npz",
+   "_fs__Hz": 10240.0,
+   "_delsys5": {
+    "z__mm": [
+     0,
+     3,
+     6,
+     9,
+     12
+    ],
+    "rotation__deg": [
+     0,
+     45
+    ],
+    "theta__deg": [
+     0,
+     180
+    ]
+   }
+  }
+ }
+}
diff --git a/benchmarks/semg_dispersion/gen_arm.py b/benchmarks/semg_dispersion/gen_arm.py
new file mode 100644
index 00000000..ac55727d
--- /dev/null
+++ b/benchmarks/semg_dispersion/gen_arm.py
@@ -0,0 +1,185 @@
+"""Simulate one sweep arm: a frozen sEMG scenario with a fibre-dispersion configuration.
+
+Usage: python gen_arm.py <scenario> <label> <out.npz> <config-json> [n_jobs]
+
+Scenarios (muscle, spike trains, electrode and seeds are fixed; only the
+dispersion configuration changes, so arms are paired against the baseline):
+
+- ``limb``: limb-like cylinder, r 15 mm, bone 3 mm, fat 4 mm, 80 mm long,
+  70 +/- 5 mm fibres, 350 fibres/mm2, 100 MUs; bipolar 5 mm contacts, IED 10 mm,
+  centred 20 mm from the end-plate band.
+- ``fdi``: the default ``Muscle`` (tuned for the first dorsal interosseous),
+  120 MUs; bipolar 2 mm contacts, IED 5 mm, centred 8 mm from the end-plate band;
+  IAP window 150 mm so slow dispersed fibres fit.
+
+Both use a 30 % excitation trapezoid (2 s ramps, 4 s hold, 0.5 s rest at each
+end), Fuglevand thresholds over a 50-fold range recruited up to 70 % excitation,
+8-35 Hz rate coding with ISI CV 0.2, 2048 Hz. An empty configuration ({}) is the
+undispersed baseline. Harness-only keys set the outer layers:
+``_skin_thickness__mm`` (default 1.29), ``_fat_thickness__mm`` (limb 4, FDI 0.3),
+``_skin_conductivity__S_per_m`` (default 1) and ``_fiber_diameter__um`` (default 50).
+FDI only: ``_muscle_radius__mm`` (default 6.91) and ``_fiber_density__per_mm2`` (default 350).
+``_spike_file`` (npz with ``spikes`` and ``thresholds``; relative paths are relative to this directory,
+e.g. ``spikes/nrn/fdi_rec70/trap_25mvc.npz``) replaces the generated spike trains.
+FDI only: ``_fs__Hz`` (default 2048) sets the output and internal sampling rate. ``_delsys5`` replaces the
+bipolar pair with Delsys 5-pin sensors (0.5 mm pins at the corners and centre of a 5 x 5 mm square, as in
+Pereira Botelho et al. 2019): ``{"z__mm": [...], "rotation__deg": [...], "theta__deg": [...]}`` places one
+monopolar 3 x 3 grid (2.5 mm pitch, 0.25 mm radius) per combination; the five pins are its corners and centre,
+and channels are formed from them afterwards (saved as ``mono_emg``, time x sensor x 3 x 3).
+``_rate_model`` selects the rate coding: absent, the linear rule below; a dict
+``{"onset", "peak_early", "peak_late", "steepness"}`` (Hz, Hz, Hz, 1/excitation) the
+onion-skin exponential of De Luca & Contessa (2012), FR = peak - (peak - onset) *
+exp(-steepness * (E - threshold)), with the peak falling linearly by recruitment rank. Only the bipolar channel is simulated. The ``myogen`` that is imported
+(recorded in the output) must be the checkout under test; set PYTHONPATH if needed.
+"""
+import hashlib
+import json
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import quantities as pq
+from neo import Block, Segment, SpikeTrain
+
+import myogen
+from myogen import set_random_seed
+from myogen.simulator import Muscle, RecruitmentThresholds, SurfaceElectrodeArray, SurfaceEMG
+from myogen.simulator.core.emg.surface.fiber_dispersion import SurfaceFiberDispersion
+from myogen.utils.neo import signal_to_grid
+
+scenario, label, out, config = sys.argv[1], sys.argv[2], sys.argv[3], json.loads(sys.argv[4])
+n_jobs = int(sys.argv[5]) if len(sys.argv) > 5 else 6
+if scenario not in ("limb", "fdi"):
+    raise SystemExit(f"unknown scenario {scenario!r}")
+skin = config.pop("_skin_thickness__mm", 1.29)
+fat = config.pop("_fat_thickness__mm", 4.0 if scenario == "limb" else 0.3)
+skin_sigma = config.pop("_skin_conductivity__S_per_m", 1.0)
+diameter = config.pop("_fiber_diameter__um", 50.0)
+rate_model = config.pop("_rate_model", None)
+spike_file = config.pop("_spike_file", None)
+fdi_radius = config.pop("_muscle_radius__mm", 6.91)
+fdi_density = config.pop("_fiber_density__per_mm2", 350.0)
+fs_out = config.pop("_fs__Hz", 2048.0)
+delsys5 = config.pop("_delsys5", None)
+if "nerve_cvs__m_per_s" in config:
+    config["nerve_cvs__m_per_s"] = tuple(config["nerve_cvs__m_per_s"])
+dispersion = SurfaceFiberDispersion(**config)
+
+N_MU, FS = (100 if scenario == "limb" else 120), float(fs_out)
+RAMP, HOLD, LEVEL = 2.0, 4.0, 0.30
+DURATION = 2 * RAMP + HOLD + 1.0
+
+set_random_seed(42)
+thresholds, _ = RecruitmentThresholds(N=N_MU, recruitment_range__ratio=50, mode="fuglevand")
+if scenario == "limb":
+    muscle = Muscle(recruitment_thresholds=thresholds, radius__mm=15 * pq.mm, length__mm=80 * pq.mm,
+                    fiber_density__fibers_per_mm2=350 * pq.mm**-2, mean_fiber_length__mm=70 * pq.mm,
+                    var_fiber_length__mm=5 * pq.mm, radius_bone__mm=3 * pq.mm, fat_thickness__mm=fat * pq.mm,
+                    skin_thickness__mm=skin * pq.mm, skin_conductivity__S_per_m=skin_sigma * pq.S / pq.m)
+    radius = 15.0
+else:
+    muscle = Muscle(recruitment_thresholds=thresholds, radius__mm=fdi_radius * pq.mm,
+                    fiber_density__fibers_per_mm2=fdi_density * pq.mm**-2, skin_thickness__mm=skin * pq.mm,
+                    fat_thickness__mm=fat * pq.mm, skin_conductivity__S_per_m=skin_sigma * pq.S / pq.m)
+    radius = fdi_radius
+muscle.distribute_innervation_centers()
+muscle.generate_muscle_fiber_centers(verbose=False)
+muscle.assign_mfs2mns(verbose=False, n_jobs=n_jobs)
+counts = np.asarray(muscle.resulting_number_of_innervated_fibers)
+fibre_hash = hashlib.sha1(b"".join(
+    np.ascontiguousarray(muscle.resulting_fiber_assignment(i)).tobytes() for i in range(N_MU))).hexdigest()
+
+rng = np.random.default_rng(123)
+rte = np.asarray(thresholds, dtype=float)
+rte = rte / rte.max() * 0.7
+rank = np.argsort(np.argsort(rte)) / (N_MU - 1)  # 0 for the first recruited, 1 for the last
+
+
+def excitation(t):
+    t = t - 0.5
+    return LEVEL * np.clip(np.minimum(t / RAMP, (2 * RAMP + HOLD - t) / RAMP), 0, 1)
+
+
+trains, active = [], []
+if spike_file is not None:
+    # Spike times per unit (s) from a NEURON simulation of the same threshold array (fdi_spikes_force.py).
+    spike_path = Path(spike_file)
+    loaded = np.load(spike_path if spike_path.is_absolute() else Path(__file__).resolve().parent / spike_path,
+                     allow_pickle=True)
+    if not np.allclose(np.asarray(loaded["thresholds"]) / np.max(loaded["thresholds"]), rte / rte.max()):
+        raise SystemExit("spike file thresholds do not match the benchmark pool")
+    for times in loaded["spikes"]:
+        times = np.asarray(times, dtype=float); times = times[times < DURATION]
+        active.append(len(times) > 0)
+        trains.append(SpikeTrain(np.round(times * FS) / FS * pq.s, t_stop=DURATION * pq.s, sampling_rate=FS * pq.Hz))
+for mu in range(N_MU if spike_file is None else 0):
+    times, t = [], 0.0
+    while t < DURATION:
+        e = excitation(t)
+        if e < rte[mu]:
+            t += 1 / FS
+            continue
+        if rate_model is None:
+            rate = min(8.0 + 100 * (e - rte[mu]), 35.0)
+        else:
+            peak = rate_model["peak_early"] + rank[mu] * (rate_model["peak_late"] - rate_model["peak_early"])
+            rate = peak - (peak - rate_model["onset"]) * np.exp(-rate_model["steepness"] * (e - rte[mu]))
+        times.append(t)
+        t += rng.gamma(1 / 0.2**2, 0.2**2 / rate)
+    times = np.asarray([x for x in times if x < DURATION])
+    active.append(len(times) > 0)
+    trains.append(SpikeTrain(np.round(times * FS) / FS * pq.s, t_stop=DURATION * pq.s, sampling_rate=FS * pq.Hz))
+block = Block()
+seg = Segment()
+seg.spiketrains = trains
+block.segments.append(seg)
+spike_hash = hashlib.sha1(b"".join(np.asarray(st.magnitude).tobytes() for st in trains)).hexdigest()
+mus = [m for m in range(N_MU) if active[m] and counts[m] > 0]
+
+if scenario == "limb":
+    bip = SurfaceElectrodeArray(1, 1, 10 * pq.mm, 2.5 * pq.mm, center_point__mm_deg=(20 * pq.mm, 0 * pq.deg),
+                                bending_radius__mm=(radius + fat + skin) * pq.mm,
+                                differentiation_mode="bipolar_longitudinal")
+    kernel = None
+else:
+    bip = SurfaceElectrodeArray(1, 1, 5 * pq.mm, 1.0 * pq.mm, center_point__mm_deg=(8 * pq.mm, 0 * pq.deg),
+                                bending_radius__mm=(radius + fat + skin) * pq.mm,
+                                differentiation_mode="bipolar_longitudinal")
+    kernel = 150.0
+sensors = []
+if delsys5 is not None:
+    sensors = [(z, rot, th) for z in delsys5["z__mm"] for rot in delsys5["rotation__deg"] for th in delsys5["theta__deg"]]
+    arrays = [SurfaceElectrodeArray(3, 3, 2.5 * pq.mm, 0.25 * pq.mm, center_point__mm_deg=(z * pq.mm, th * pq.deg),
+                                    bending_radius__mm=(radius + fat + skin) * pq.mm, rotation_angle__deg=rot * pq.deg,
+                                    differentiation_mode="monopolar") for z, rot, th in sensors]
+else:
+    arrays = [bip]
+set_random_seed(7)
+semg = SurfaceEMG(muscle, arrays, sampling_frequency__Hz=FS * pq.Hz, MUs_to_simulate=mus,
+                  internal_sampling_frequency__Hz=FS * pq.Hz, fiber_dispersion=dispersion,
+                  iap_kernel_length__mm=kernel, fiber_diameter__um=diameter)
+t0 = time.time()
+muaps = semg.simulate_muaps(n_jobs=n_jobs, verbose=False, use_gpu=False)
+sig0 = muaps.groups[0].segments[mus[0]].analogsignals[0]
+emg_block = semg.simulate_surface_emg(block, verbose=False)
+emg = emg_block.groups[0].segments[0].analogsignals[0]
+if delsys5 is not None:
+    templates = np.zeros((0, 1, 1, 1))
+    mono = np.stack([np.asarray(signal_to_grid(g.segments[0].analogsignals[0].rescale(pq.mV)), dtype=np.float32)
+                     for g in emg_block.groups], axis=1)
+else:
+    templates = np.array([np.asarray(signal_to_grid(muaps.groups[0].segments[m].analogsignals[0].rescale(pq.mV)))
+                          for m in mus])
+    mono = np.zeros((0,))
+report = semg.fiber_dispersion_report or {}
+np.savez(out, label=label, scenario=scenario, myogen=myogen.__file__, config=json.dumps(config), skin=skin, fat=fat, skin_sigma=skin_sigma, diameter=diameter, radius=radius, density=fdi_density, rate_model=json.dumps(rate_model), spike_file=str(spike_file), mus=mus, counts=counts,
+         fibre_hash=fibre_hash, spike_hash=spike_hash, ramp=RAMP, hold=HOLD, level=LEVEL,
+         bip_muaps=templates, pair_muap_fs=float(sig0.sampling_rate.rescale(pq.Hz).magnitude),
+         bip_emg=np.asarray(signal_to_grid(emg.rescale(pq.mV))), mono_emg=mono, sensors=np.array(sensors),
+         sensor_pos_z=np.array([a.pos_z for a in arrays]) if delsys5 is not None else np.zeros(0),
+         sensor_pos_theta=np.array([a.pos_theta for a in arrays]) if delsys5 is not None else np.zeros(0), fs=float(emg.sampling_rate.rescale(pq.Hz).magnitude),
+         report=np.array({k: v for k, v in report.items() if k != "config"}, dtype=object),
+         seconds=time.time() - t0, allow_pickle=True)
+print(label, "fibres", int(counts[mus].sum()), "secs", round(time.time() - t0), "fibre", fibre_hash[:10],
+      "spikes", spike_hash[:10], flush=True)
diff --git a/benchmarks/semg_dispersion/plot_amplitude.py b/benchmarks/semg_dispersion/plot_amplitude.py
new file mode 100644
index 00000000..e8e2494d
--- /dev/null
+++ b/benchmarks/semg_dispersion/plot_amplitude.py
@@ -0,0 +1,134 @@
+"""Amplitude with every effect explored, limb scenario and default FDI cylinder.
+
+Usage: python plot_amplitude.py <limb_outdir> <fdi_outdir> <out.pdf>
+Arms: undispersed baseline; published candidate (two-layer end-plates, nerve 5/2 m/s,
+threshold-linear MU CV, 5 % within-MU CV); + correlated tendon ends (5 mm band,
+5 mm correlation, 0.3 mm jitter); + diameter-scaled source. 20-450 Hz band-pass, no noise.
+FDI literature values are drawn for orientation only: their electrodes differ from ours
+and our effort axis is excitation, not force.
+"""
+import sys
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+from matplotlib.backends.backend_pdf import PdfPages  # noqa: E402
+from scipy.signal import butter, resample, sosfiltfilt, welch  # noqa: E402
+
+LIMB, FDI, OUT = Path(sys.argv[1]), Path(sys.argv[2]), Path(sys.argv[3])
+SCENARIOS = [
+    ("Limb-like cylinder (r 15 mm, 70 mm fibres, fat 4 mm; bipolar 5 mm contacts, IED 10 mm)",
+     LIMB / "arm_baseline.npz", LIMB, False),
+    ("Default FDI cylinder (r 6.9 mm, 31.7 mm fibres, fat 0.3 mm; bipolar 2 mm contacts, IED 5 mm)",
+     FDI / "arm_baseline.npz", FDI, True),
+]
+ARMS = [("baseline", "undispersed (fixes only)"), ("candidate_published", "published candidate"),
+        ("tendon_w5_corr5", "+ correlated tendon ends"), ("full_diameter", "+ diameter-scaled source")]
+COLORS = ["k", "C0", "C2", "C3"]
+
+
+def load(base, here, name):
+    D = dict(np.load(base if name == "baseline" else here / f"arm_{name}.npz", allow_pickle=True))
+    B = dict(np.load(base, allow_pickle=True))
+    for key in ("fibre_hash", "spike_hash"):
+        assert str(D[key]) == str(B[key]), (name, key)
+    return D
+
+
+pdf = PdfPages(OUT)
+rows = []
+for title, base, here, fdi in SCENARIOS:
+    data = {n: load(base, here, n) for n, _ in ARMS}
+    B = data["baseline"]
+    fs = float(B["fs"])
+    sos = butter(4, [20, 450], btype="bandpass", fs=fs, output="sos")
+    ramp, hold, level = float(B["ramp"]), float(B["hold"]), float(B["level"])
+    t = np.arange(len(B["bip_emg"])) / fs
+    plateau = (t > 0.5 + ramp + 0.5) & (t < 0.5 + ramp + hold - 0.5)
+    nfib = np.array([B["counts"][m] for m in B["mus"]])
+
+    fig = plt.figure(figsize=(16.5, 9.5))
+    fig.suptitle(f"Amplitude with all explored effects: {title}\n30 % excitation trapezoid, 20–450 Hz, no noise",
+                 fontsize=11)
+    gs = fig.add_gridspec(4, 3, width_ratios=[1.3, 1, 1])
+    lim = 0
+    traces = {}
+    for name, _ in ARMS:
+        traces[name] = sosfiltfilt(sos, data[name]["bip_emg"][:, 0, 0] * 1.0)  # mV
+        lim = max(lim, np.max(np.abs(traces[name][(t >= 4.3) & (t <= 4.5)])))
+    for i, (name, label) in enumerate(ARMS):
+        ax = fig.add_subplot(gs[i, 0])
+        w = (t >= 4.3) & (t <= 4.5)
+        ax.plot(t[w], traces[name][w], color=COLORS[i], lw=0.8)
+        rms = np.sqrt(np.mean(traces[name][plateau] ** 2))
+        ax.set_ylim(-1.05 * lim, 1.05 * lim)
+        ax.set_ylabel(f"{label}\nRMS {rms:.3f} mV", fontsize=8)
+        ax.tick_params(labelsize=7)
+        if i == 0:
+            ax.set_title("200 ms of plateau (mV, same scale)", fontsize=9)
+        if i == len(ARMS) - 1:
+            ax.set_xlabel("s", fontsize=8)
+
+    ax = fig.add_subplot(gs[:2, 1])
+    centres = np.arange(0.7, 0.5 + ramp + 1.0, 0.05)
+    for i, (name, label) in enumerate(ARMS):
+        r = [np.sqrt(np.mean(traces[name][np.abs(t - c) <= 0.125] ** 2)) for c in centres]
+        exc = np.clip((centres - 0.5) / ramp, 0, 1) * level * 100
+        ax.plot(exc, r, color=COLORS[i], lw=1.4, label=label)
+    if fdi:
+        ax.errorbar([25], [0.21], yerr=[[0.08], [0.08]], fmt="s", color="m", capsize=4,
+                    label="Botelho 2019: 0.21 mV at 25 %MVC\n(1 subject, Delsys 5-pin)")
+    ax.set_xlabel("excitation (%)", fontsize=8)
+    ax.set_ylabel("RMS, 250 ms windows (mV)", fontsize=8)
+    ax.set_title("RMS along the ramp", fontsize=9)
+    ax.legend(fontsize=7)
+    ax.tick_params(labelsize=7)
+
+    ax = fig.add_subplot(gs[2:, 1])
+    for i, (name, label) in enumerate(ARMS):
+        f, p = welch(traces[name][plateau], fs=fs, nperseg=1024)
+        ax.semilogy(f, p, color=COLORS[i], lw=1.0, label=label)
+    ax.set_xlim(0, 500)
+    ax.set_xlabel("Hz", fontsize=8)
+    ax.set_ylabel("PSD (mV²/Hz)", fontsize=8)
+    ax.set_title("Plateau spectrum", fontsize=9)
+    ax.tick_params(labelsize=7)
+
+    ax = fig.add_subplot(gs[:3, 2])
+    for i, (name, label) in enumerate(ARMS):
+        m = data[name]["bip_muaps"][:, :, 0, 0]
+        ptp = np.ptp(resample(m, m.shape[1] * 8, axis=1), axis=1)
+        ax.scatter(nfib, ptp, s=9, color=COLORS[i], alpha=0.7, label=label)
+        f, p = welch(traces[name][plateau], fs=fs, nperseg=1024)
+        band = (f >= 20) & (f <= 450)
+        mnf = np.sum(f[band] * p[band]) / np.sum(p[band])
+        rows.append([title.split(" (")[0], label, f"{np.sqrt(np.mean(traces[name][plateau] ** 2)):.3f}",
+                     f"{mnf:.0f}", f"{np.median(ptp):.3f}", f"{np.percentile(ptp, 90):.2f}", f"{ptp.max():.2f}"])
+    if fdi:
+        ax.axhspan(0.05, 2.0, color="m", alpha=0.08,
+                   label="published single-MU PtP ≈0.05–2 mV\n(belly–tendon / Delsys; for orientation)")
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.set_xlabel("fibres in MU", fontsize=8)
+    ax.set_ylabel("MUAP peak-to-peak (mV)", fontsize=8)
+    ax.set_title("MUAP amplitude by MU size", fontsize=9)
+    ax.legend(fontsize=7)
+    ax.tick_params(labelsize=7)
+
+    ax = fig.add_subplot(gs[3, 2])
+    ax.axis("off")
+    mine = [r[1:] for r in rows if r[0] == title.split(" (")[0]]
+    tab = ax.table(cellText=mine, colLabels=["arm", "plateau RMS mV", "MNF Hz", "MUAP PtP median mV",
+                                             "p90 mV", "max mV"], loc="center", cellLoc="center")
+    tab.auto_set_font_size(False)
+    tab.set_fontsize(7)
+    tab.scale(1, 1.3)
+    fig.tight_layout(rect=(0, 0, 1, 0.94))
+    pdf.savefig(fig)
+    fig.savefig(OUT.with_name(f"amplitude_{'fdi' if fdi else 'limb'}.png"), dpi=100)
+    plt.close(fig)
+pdf.close()
+for r in rows:
+    print("\t".join(r))
diff --git a/benchmarks/semg_dispersion/plot_signals.py b/benchmarks/semg_dispersion/plot_signals.py
new file mode 100644
index 00000000..92616f79
--- /dev/null
+++ b/benchmarks/semg_dispersion/plot_signals.py
@@ -0,0 +1,155 @@
+"""Signal and MUAP views of the dispersion sweep, for judging the changes by eye.
+
+Usage: python plot_signals.py <limb|fdi> <outdir>   (outdir holds arm_<name>.npz, incl. arm_baseline.npz)
+Same recording chain as score_disp.py (20-450 Hz band-pass, no noise).
+Per factor: one page of EMG (whole recording, 1 s plateau, 100 ms plateau
+zoom, 250 ms at ~10 % effort) and one page of MUAPs (8 MUs, shared scale per MU).
+"""
+import json
+import sys
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+from matplotlib.backends.backend_pdf import PdfPages  # noqa: E402
+from scipy.signal import butter, resample, sosfiltfilt  # noqa: E402
+
+SCENARIO, here = sys.argv[1], Path(sys.argv[2])
+base_path = here / "arm_baseline.npz"
+ARMS = [a for a in json.loads((Path(__file__).with_name("arms.json")).read_text())[SCENARIO] if a != "baseline"]
+B = dict(np.load(base_path, allow_pickle=True))
+FS = float(B["fs"])
+SOS = butter(4, [20, 450], btype="bandpass", fs=FS, output="sos")
+GROUPS = {
+    "limb": {"Nerve-branch delays": ["nerve_cv_10_4", "nerve_cv_5_2", "nerve_cv_2.5_1"],
+             "End-plate scatter": ["nmj_intra_x0.5", "nmj_intra_x1", "nmj_intra_x2", "nmj_two_layer_x1"],
+             "Muscle-fibre CV": ["fcv_within_5", "fcv_within_10", "fcv_inter_30", "fcv_both", "fcv_both_diameter"],
+             "Combined": ["combined", "combined_diameter"],
+             "Literature-anchored candidate": ["candidate", "candidate_within5"],
+             "End-plate coefficients: code vs published": ["candidate_within5", "candidate_published"],
+             "Tendon-end band (on the published candidate)": ["candidate_published", "tendon_w5", "tendon_w10"],
+             "Correlated tendon ends (5 mm band, 0.3 mm jitter)": ["tendon_w5", "tendon_w5_corr2", "tendon_w5_corr5",
+                                                                   "tendon_w5_corr10"],
+             "All effects (+ diameter-scaled source)": ["tendon_w5_corr5", "full_diameter"]},
+    "fdi": {"FDI: published candidate and tendon ends": ["candidate_published", "tendon_w5", "tendon_w5_corr5",
+                                                         "tendon_w10"],
+            "FDI: all effects (+ diameter-scaled source)": ["tendon_w5_corr5", "full_diameter"],
+            "FDI: skin thickness 2 and 3 mm": ["baseline_skin2", "full_skin2", "baseline_skin3", "full_skin3"],
+            "FDI: literature layers, undispersed (skin 1.2 mm)": [
+                "baseline_s1.2_f1.3_sig1", "baseline_s1.2_f0.3_sig0.15", "baseline_s1.2_f1.3_sig0.15",
+                "baseline_s1.2_f2.0_sig0.15"],
+            "FDI: literature layers, all effects (skin 1.2 mm)": [
+                "full_s1.2_f1.3_sig1", "full_s1.2_f0.3_sig0.15", "full_s1.2_f1.3_sig0.15", "full_s1.2_f2.0_sig0.15"]},
+}[SCENARIO]
+LABELS = {"nerve_cv_10_4": "nerve CV 10/4 m/s", "nerve_cv_5_2": "nerve CV 5/2 m/s (iEMG default)",
+          "nerve_cv_2.5_1": "nerve CV 2.5/1 m/s (stress)", "nmj_intra_x0.5": "end-plate SD 0.6 mm",
+          "nmj_intra_x1": "end-plate SD 1.3 mm", "nmj_intra_x2": "end-plate SD 2.6 mm",
+          "nmj_two_layer_x1": "two-layer (MU centre moves too)", "fcv_within_5": "fibre CV CoV 5 % in MU",
+          "fcv_within_10": "fibre CV CoV 10 % in MU", "fcv_inter_30": "MU CV ±15 % by recruitment",
+          "fcv_both": "inter ±15 % + within 5 %", "fcv_both_diameter": "inter + within + diameter source",
+          "combined": "two-layer + nerve 5/2 + fibre CV", "combined_diameter": "combined + diameter source",
+          "candidate": "candidate",
+          "candidate_within5": "cand. +5 % (code)",
+          "candidate_published": "cand. +5 % (published)",
+          "tendon_w5": "independent ends, 5 mm band", "tendon_w10": "independent ends, 10 mm band",
+          "tendon_w5_corr2": "5 mm band, correlated over 2 mm", "tendon_w5_corr5": "5 mm band, correlated over 5 mm",
+          "tendon_w5_corr10": "5 mm band, correlated over 10 mm",
+          "full_diameter": "all effects + diameter-scaled source", "baseline_skin2": "undispersed, skin 2 mm",
+          "full_skin2": "all effects, skin 2 mm", "baseline_skin3": "undispersed, skin 3 mm",
+          "full_skin3": "all effects, skin 3 mm",
+          "baseline_s1.2_f1.3_sig1": "undispersed, fat 1.3 mm, skin σ 1 S/m",
+          "full_s1.2_f1.3_sig1": "all effects, fat 1.3 mm, skin σ 1 S/m",
+          "baseline_s1.2_f1.3_sig0.15": "undispersed, fat 1.3 mm, skin σ 0.15 S/m",
+          "full_s1.2_f1.3_sig0.15": "all effects, fat 1.3 mm, skin σ 0.15 S/m",
+          "baseline_s1.2_f0.3_sig0.15": "undispersed, fat 0.3 mm, skin σ 0.15 S/m",
+          "full_s1.2_f0.3_sig0.15": "all effects, fat 0.3 mm, skin σ 0.15 S/m",
+          "baseline_s1.2_f2.0_sig0.15": "undispersed, fat 2.0 mm, skin σ 0.15 S/m",
+          "full_s1.2_f2.0_sig0.15": "all effects, fat 2.0 mm, skin σ 0.15 S/m"}
+
+
+def chain(x_mV):
+    return sosfiltfilt(SOS, np.asarray(x_mV, float) * 1e3)
+
+
+def load(name):
+    D = B if name == "baseline" else dict(np.load(here / f"arm_{name}.npz", allow_pickle=True))
+    for key in ("fibre_hash", "spike_hash"):
+        assert str(D[key]) == str(B[key]), (name, key)
+    m = D["bip_muaps"][:, :, 0, 0] * 1e3
+    return chain(D["bip_emg"][:, 0, 0]), resample(m, m.shape[1] * 8, axis=1)
+
+
+t = np.arange(len(B["bip_emg"])) / FS
+ramp, hold, level = float(B["ramp"]), float(B["hold"]), float(B["level"])
+t10 = 0.5 + ramp * 0.10 / level
+mus = [int(m) for m in B["mus"]]
+nfib = np.array([B["counts"][m] for m in mus])
+x0, u0 = load("baseline")
+tm = (np.arange(u0.shape[1]) - u0.shape[1] // 2) / (float(B["pair_muap_fs"]) * 8) * 1e3
+by_size = np.argsort(nfib)
+pick = [int(by_size[int(q * (len(mus) - 1))]) for q in (0.0, 0.2, 0.4, 0.6, 0.8)]
+for k in np.argsort(np.ptp(u0, axis=1))[::-1]:
+    if len(pick) == 8:
+        break
+    if k not in pick:
+        pick.append(int(k))
+pick.sort(key=lambda k: nfib[k])
+
+WINDOWS = [("whole recording", 0, t[-1], False), ("1 s of plateau", 4.0, 5.0, False),
+           ("100 ms of plateau (grey = baseline)", 4.30, 4.40, True),
+           ("250 ms at ~10 % effort (grey = baseline)", t10 - 0.125, t10 + 0.125, True)]
+
+pdf = PdfPages(here / "semg_dispersion_signals.pdf")
+for gname, members in GROUPS.items():
+    names = ["baseline"] + members
+    data = {n: load(n) for n in names}
+    lim = 1.05 * max(np.max(np.abs(data[n][0])) for n in names)
+
+    fig, axs = plt.subplots(len(names), 4, figsize=(16.5, 2.0 + 1.55 * len(names)),
+                            gridspec_kw=dict(width_ratios=[1.4, 1.4, 1, 1]), squeeze=False)
+    fig.suptitle(f"{gname}: bipolar sEMG, 30 % MVC trapezoid (20–450 Hz, no noise; same y-scale in every panel"
+                 " of a column)", fontsize=12)
+    for row, n in enumerate(names):
+        x = data[n][0]
+        color = "k" if n == "baseline" else f"C{row - 1}"
+        for col, (title, a, b, overlay) in enumerate(WINDOWS):
+            ax = axs[row, col]
+            w = (t >= a) & (t <= b)
+            if overlay and n != "baseline":
+                ax.plot(t[w], x0[w], color="0.7", lw=1.4)
+            ax.plot(t[w], x[w], color=color, lw=0.6 if col < 2 else 1.0)
+            ylim = lim if col != 3 else 1.05 * max(np.max(np.abs(data[m][0][w])) for m in names)
+            ax.set_ylim(-ylim, ylim)
+            ax.set_xlim(a, b)
+            ax.tick_params(labelsize=7)
+            if row == 0:
+                ax.set_title(title, fontsize=9)
+            if col == 0:
+                rms = np.sqrt(np.mean(x[(t > 3.0) & (t < 6.0)] ** 2))
+                ax.set_ylabel(f"{LABELS.get(n, n)}\nRMS {rms:.0f} µV", fontsize=8)
+            if row == len(names) - 1:
+                ax.set_xlabel("s", fontsize=8)
+    fig.tight_layout(rect=(0, 0, 1, 0.96))
+    pdf.savefig(fig)
+    plt.close(fig)
+
+    fig, axs = plt.subplots(2, 4, figsize=(16.5, 8.3))
+    fig.suptitle(f"{gname}: MUAPs (bipolar, before band-pass). Black = baseline. Ordered by MU size.", fontsize=12)
+    for ax, k in zip(axs.flat, pick):
+        ax.plot(tm, u0[k], "k", lw=2.0, label="baseline")
+        for i, n in enumerate(members):
+            ax.plot(tm, data[n][1][k], color=f"C{i}", lw=1.1, label=LABELS.get(n, n))
+        ax.axhline(0, color="0.8", lw=0.6)
+        ax.set_xlim(-2, 18)
+        ax.set_title(f"MU {mus[k]}: {nfib[k]} fibres, baseline PtP {np.ptp(u0[k]):.0f} µV", fontsize=9)
+        ax.set_xlabel("ms from firing", fontsize=8)
+        ax.set_ylabel("µV", fontsize=8)
+        ax.tick_params(labelsize=7)
+    axs.flat[0].legend(fontsize=7, loc="lower left")
+    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    pdf.savefig(fig)
+    plt.close(fig)
+pdf.close()
+print("MUs shown:", [mus[k] for k in pick])
diff --git a/benchmarks/semg_dispersion/run_arms.sh b/benchmarks/semg_dispersion/run_arms.sh
new file mode 100644
index 00000000..cbeee613
--- /dev/null
+++ b/benchmarks/semg_dispersion/run_arms.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Simulate sweep arms of one scenario, three at a time, skipping finished ones.
+# Usage: bash run_arms.sh <limb|fdi> <outdir> [arm ...]   (all arms of the scenario if none given)
+# PY selects the interpreter (default: python).
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+scenario=$1; out=$2; shift 2
+PY=${PY:-python}
+mkdir -p "$out"
+arms=("$@")
+if [ ${#arms[@]} -eq 0 ]; then
+  mapfile -t arms < <($PY -c "import json,sys; print('\n'.join(json.load(open(sys.argv[1]))[sys.argv[2]]))" \
+    "$here/arms.json" "$scenario" | tr -d '\r')
+fi
+run_one() {
+  local a=$1
+  [ -f "$out/arm_$a.npz" ] && { echo "$a exists"; return; }
+  cfg=$($PY -c "import json,sys; print(json.dumps(json.load(open(sys.argv[1]))[sys.argv[2]][sys.argv[3]]))" \
+    "$here/arms.json" "$scenario" "$a")
+  OMP_NUM_THREADS=1 MKL_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 NUMBA_NUM_THREADS=2 \
+    $PY "$here/gen_arm.py" "$scenario" "$a" "$out/arm_$a.npz" "$cfg" 6 > "$out/log_$a.txt" 2>&1 \
+    || { echo "$a FAILED (see $out/log_$a.txt)"; return; }
+  tail -1 "$out/log_$a.txt"
+}
+export -f run_one; export out scenario PY here
+printf '%s\n' "${arms[@]}" | xargs -P 3 -I{} bash -c 'run_one "$@"' _ {}
diff --git a/benchmarks/semg_dispersion/score.py b/benchmarks/semg_dispersion/score.py
new file mode 100644
index 00000000..5ed59855
--- /dev/null
+++ b/benchmarks/semg_dispersion/score.py
@@ -0,0 +1,214 @@
+"""Scorecard for the dispersion sweep. Definitions fixed before any arm was scored.
+
+Usage: python score.py <limb|fdi> <outdir>   (outdir holds arm_<name>.npz, incl. arm_baseline.npz)
+
+Recording chain: 4th-order zero-phase 20-450 Hz band-pass, no added noise
+(noise is handled later). Plateau = 0.5 s after the ramp to 0.5 s before
+ramp-down. Signal features: plateau RMS; MNF and MDF of the Welch PSD
+(1024-sample segments) within 20-450 Hz; ramp RMS in 250 ms windows centred
+where excitation reaches 10 % and 20 %. MUAP features (bipolar templates
+before the chain, upsampled x8): peak-to-peak; duration = first to last
+sample with |MUAP| >= 10 % of its peak; MNF of the template within 20-450 Hz.
+Per-MU changes are paired against the baseline (same MU) before summarising;
+size groups are fibre-count terciles of the simulated MUs.
+"""
+import json
+import sys
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+from matplotlib.backends.backend_pdf import PdfPages  # noqa: E402
+from scipy.signal import butter, resample, sosfiltfilt, welch  # noqa: E402
+
+SCENARIO, here = sys.argv[1], Path(sys.argv[2])
+base_path = here / "arm_baseline.npz"
+ARMS = [a for a in json.loads((Path(__file__).with_name("arms.json")).read_text())[SCENARIO] if a != "baseline"]
+B = dict(np.load(base_path, allow_pickle=True))
+FS = float(B["fs"])
+SOS = butter(4, [20, 450], btype="bandpass", fs=FS, output="sos")
+GROUPS = {
+    "limb": {"Nerve-branch delays": ["nerve_cv_10_4", "nerve_cv_5_2", "nerve_cv_2.5_1"],
+             "End-plate scatter": ["nmj_intra_x0.5", "nmj_intra_x1", "nmj_intra_x2", "nmj_two_layer_x1"],
+             "Muscle-fibre CV": ["fcv_within_5", "fcv_within_10", "fcv_inter_30", "fcv_both", "fcv_both_diameter"],
+             "Combined": ["combined", "combined_diameter"],
+             "Literature-anchored candidate": ["candidate", "candidate_within5"],
+             "End-plate coefficients: code vs published": ["candidate_within5", "candidate_published"],
+             "Tendon-end band (on the published candidate)": ["candidate_published", "tendon_w5", "tendon_w10"],
+             "Correlated tendon ends (5 mm band, 0.3 mm jitter)": ["tendon_w5", "tendon_w5_corr2", "tendon_w5_corr5",
+                                                                   "tendon_w5_corr10"],
+             "All effects (+ diameter-scaled source)": ["tendon_w5_corr5", "full_diameter"]},
+    "fdi": {"FDI: published candidate and tendon ends": ["candidate_published", "tendon_w5", "tendon_w5_corr5",
+                                                         "tendon_w10"],
+            "FDI: all effects (+ diameter-scaled source)": ["tendon_w5_corr5", "full_diameter"],
+            "FDI: skin thickness 2 and 3 mm": ["baseline_skin2", "full_skin2", "baseline_skin3", "full_skin3"],
+            "FDI: literature layers, undispersed (skin 1.2 mm)": [
+                "baseline_s1.2_f1.3_sig1", "baseline_s1.2_f0.3_sig0.15", "baseline_s1.2_f1.3_sig0.15",
+                "baseline_s1.2_f2.0_sig0.15"],
+            "FDI: literature layers, all effects (skin 1.2 mm)": [
+                "full_s1.2_f1.3_sig1", "full_s1.2_f0.3_sig0.15", "full_s1.2_f1.3_sig0.15", "full_s1.2_f2.0_sig0.15"]},
+}[SCENARIO]
+
+
+def chain(x_mV):
+    return sosfiltfilt(SOS, np.asarray(x_mV, float) * 1e3)
+
+
+def band_mnf_mdf(f, p):
+    band = (f >= 20) & (f <= 450)
+    f, p = f[band], p[band]
+    c = np.cumsum(p)
+    return float(np.sum(f * p) / np.sum(p)), float(f[np.searchsorted(c, c[-1] / 2)])
+
+
+def load(path):
+    D = dict(np.load(path, allow_pickle=True))
+    for key in ("fibre_hash", "spike_hash"):
+        assert str(D[key]) == str(B[key]), (path, key)
+    assert list(D["mus"]) == list(B["mus"]), path
+    return D
+
+
+t = np.arange(len(B["bip_emg"])) / FS
+ramp, hold, level = float(B["ramp"]), float(B["hold"]), float(B["level"])
+plateau = (t > 0.5 + ramp + 0.5) & (t < 0.5 + ramp + hold - 0.5)
+mus = [int(m) for m in B["mus"]]
+nfib = np.array([B["counts"][m] for m in mus])
+tercile = np.digitize(nfib, np.quantile(nfib, [1 / 3, 2 / 3]))
+
+
+def ramp_rms(x, frac):
+    tc = 0.5 + ramp * frac / level
+    w = np.abs(t - tc) <= 0.125
+    return float(np.sqrt(np.mean(x[w] ** 2)))
+
+
+def muap_features(D):
+    m = D["bip_muaps"][:, :, 0, 0] * 1e3  # µV
+    fs = float(D["pair_muap_fs"]) * 8
+    up = resample(m, m.shape[1] * 8, axis=1)
+    ptp = np.ptp(up, axis=1)
+    dur, mnf = [], []
+    for u in up:
+        idx = np.nonzero(np.abs(u) >= 0.1 * np.max(np.abs(u)))[0]
+        dur.append((idx[-1] - idx[0]) / fs * 1e3)
+        f = np.fft.rfftfreq(len(u) * 4, 1 / fs)
+        p = np.abs(np.fft.rfft(u, len(u) * 4)) ** 2
+        mnf.append(band_mnf_mdf(f, p)[0])
+    return ptp, np.array(dur), np.array(mnf), up
+
+
+def score(D):
+    x = chain(D["bip_emg"][:, 0, 0])
+    f, p = welch(x[plateau], fs=FS, nperseg=1024)
+    mnf, mdf = band_mnf_mdf(f, p)
+    ptp, dur, mmnf, up = muap_features(D)
+    r = D["report"].item() if "report" in D and D["report"].size else {}
+    pick = (lambda k: float(np.nanmedian(np.asarray(r[k])[mus]))) if r else (lambda k: 0.0)
+    return dict(x=x, f=f, p=p, up=up, ptp=ptp, dur=dur, mmnf=mmnf,
+                row=dict(rms=float(np.sqrt(np.mean(x[plateau] ** 2))), mnf=mnf, mdf=mdf,
+                         rms10=ramp_rms(x, 0.10), rms20=ramp_rms(x, 0.20),
+                         zi_sd=pick("zi_sd__mm"), delay_sd=pick("delay_sd__ms"), cv_cov=pick("cv_cov"),
+                         amp=pick("amplitude_scale_mean") if r else 1.0))
+
+
+base = score(B)
+results = {"baseline": base}
+for name in ARMS:
+    path = here / f"arm_{name}.npz"
+    if path.exists():
+        results[name] = score(load(path))
+
+rows = []
+header = ["arm", "realised: end-plate SD mm", "nerve delay SD ms", "fibre CV CoV", "source scale",
+          "plateau RMS µV", "Δ%", "MNF Hz", "MDF Hz", "RMS@10% µV", "RMS@20% µV",
+          "MUAP PtP Δ% (med, paired)", "small / mid / large", "MUAP dur Δms (med)", "MUAP MNF Δ Hz (med)"]
+for name, R in results.items():
+    q = R["row"]
+    dptp = (R["ptp"] / base["ptp"] - 1) * 100
+    groups = " / ".join(f"{np.median(dptp[tercile == g]):+.1f}" for g in range(3))
+    rows.append([name, f"{q['zi_sd']:.2f}", f"{q['delay_sd']:.3f}", f"{q['cv_cov']:.3f}", f"{q['amp']:.3f}",
+                 f"{q['rms']:.1f}", f"{(q['rms'] / base['row']['rms'] - 1) * 100:+.1f}",
+                 f"{q['mnf']:.1f}", f"{q['mdf']:.1f}", f"{q['rms10']:.1f}", f"{q['rms20']:.1f}",
+                 f"{np.median(dptp):+.1f}", groups, f"{np.median(R['dur'] - base['dur']):+.2f}",
+                 f"{np.median(R['mmnf'] - base['mmnf']):+.1f}"])
+(here / "scorecard.tsv").write_text("\n".join("\t".join(r) for r in [header] + rows), encoding="utf-8")
+for r in rows:
+    print("\t".join(r))
+
+pdf = PdfPages(here / "semg_dispersion_sweep.pdf")
+fig = plt.figure(figsize=(16.5, 8.3))
+fig.suptitle("Dispersion sweep: bipolar sEMG, 30 % MVC plateau (20–450 Hz band-pass, no noise)", fontsize=13)
+ax = fig.add_axes([0.01, 0.12, 0.98, 0.8])
+ax.axis("off")
+tab = ax.table(cellText=rows, colLabels=header, loc="upper center", cellLoc="center")
+tab.auto_set_font_size(False)
+tab.set_fontsize(7)
+tab.scale(1, 1.5)
+fig.text(0.01, 0.02, __doc__.split("\n\n", 2)[2].replace("\n", " "), fontsize=7, wrap=True)
+pdf.savefig(fig)
+plt.close(fig)
+
+fig, axs = plt.subplots(2, 2, figsize=(11.7, 8.3))
+fig.suptitle("Change from the undispersed baseline", fontsize=13)
+names = [n for n in results if n != "baseline"]
+for ax, (key, label) in zip(axs.flat, (("rms", "plateau RMS (%)"), ("mnf", "MNF (Hz)"),
+                                       ("ptp", "MUAP peak-to-peak, median paired (%)"),
+                                       ("dur", "MUAP duration, median paired (ms)"))):
+    if key == "rms":
+        vals = [(results[n]["row"]["rms"] / base["row"]["rms"] - 1) * 100 for n in names]
+    elif key == "mnf":
+        vals = [results[n]["row"]["mnf"] - base["row"]["mnf"] for n in names]
+    elif key == "ptp":
+        vals = [np.median((results[n]["ptp"] / base["ptp"] - 1) * 100) for n in names]
+    else:
+        vals = [np.median(results[n]["dur"] - base["dur"]) for n in names]
+    colors = [f"C{next(i for i, g in enumerate(GROUPS.values()) if n in g)}" for n in names]
+    ax.barh(names, vals, color=colors)
+    ax.axvline(0, color="k", lw=0.8)
+    ax.set_title(label, fontsize=10)
+    ax.tick_params(labelsize=7)
+    ax.invert_yaxis()
+fig.tight_layout(rect=(0, 0, 1, 0.95))
+pdf.savefig(fig)
+plt.close(fig)
+
+for gname, members in GROUPS.items():
+    members = [m for m in members if m in results]
+    if not members:
+        continue
+    fig = plt.figure(figsize=(11.7, 8.3))
+    fig.suptitle(gname, fontsize=13)
+    gs = fig.add_gridspec(2, 3)
+    ax = fig.add_subplot(gs[0, :2])
+    ax.semilogy(base["f"], base["p"], "k", lw=1.5, label="baseline")
+    for i, m in enumerate(members):
+        ax.semilogy(results[m]["f"], results[m]["p"], color=f"C{i}", lw=1, label=m)
+    ax.set_xlim(0, 500)
+    ax.set_xlabel("Hz")
+    ax.set_ylabel("PSD µV²/Hz")
+    ax.legend(fontsize=7)
+    ax = fig.add_subplot(gs[0, 2])
+    z = (t >= 4.0) & (t <= 4.15)
+    ax.plot(t[z], base["x"][z], "k", lw=1, label="baseline")
+    ax.plot(t[z], results[members[-1]]["x"][z], color=f"C{len(members) - 1}", lw=0.8, label=members[-1])
+    ax.set_xlabel("s")
+    ax.set_ylabel("µV")
+    ax.legend(fontsize=7)
+    for col, g in enumerate(range(3)):
+        ax = fig.add_subplot(gs[1, col])
+        k = int(np.nonzero(tercile == g)[0][np.argsort(nfib[tercile == g])[np.sum(tercile == g) // 2]])
+        tm = (np.arange(base["up"].shape[1]) - base["up"].shape[1] // 2) / (float(B["pair_muap_fs"]) * 8) * 1e3
+        ax.plot(tm, base["up"][k], "k", lw=1.5, label="baseline")
+        for i, m in enumerate(members):
+            ax.plot(tm, results[m]["up"][k], color=f"C{i}", lw=1, label=m)
+        ax.set_xlim(-3, 25)
+        ax.set_title(f"MU {mus[k]} ({nfib[k]} fibres)", fontsize=9)
+        ax.set_xlabel("ms from firing")
+        ax.set_ylabel("µV")
+    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    pdf.savefig(fig)
+    plt.close(fig)
+pdf.close()
diff --git a/benchmarks/semg_dispersion/spikes/nrn/fdi_rec52/trap_25mvc.npz b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec52/trap_25mvc.npz
new file mode 100644
index 00000000..95c59cee
Binary files /dev/null and b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec52/trap_25mvc.npz differ
diff --git a/benchmarks/semg_dispersion/spikes/nrn/fdi_rec52_fug/trap_25mvc_fug.npz b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec52_fug/trap_25mvc_fug.npz
new file mode 100644
index 00000000..be515fdf
Binary files /dev/null and b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec52_fug/trap_25mvc_fug.npz differ
diff --git a/benchmarks/semg_dispersion/spikes/nrn/fdi_rec70/trap_25exc.npz b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec70/trap_25exc.npz
new file mode 100644
index 00000000..2a9048a0
Binary files /dev/null and b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec70/trap_25exc.npz differ
diff --git a/benchmarks/semg_dispersion/spikes/nrn/fdi_rec70/trap_25mvc.npz b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec70/trap_25mvc.npz
new file mode 100644
index 00000000..bd72c53e
Binary files /dev/null and b/benchmarks/semg_dispersion/spikes/nrn/fdi_rec70/trap_25mvc.npz differ
diff --git a/benchmarks/semg_dispersion/spikes/nrn/vl_dd_on_fdi/trap_25mvc.npz b/benchmarks/semg_dispersion/spikes/nrn/vl_dd_on_fdi/trap_25mvc.npz
new file mode 100644
index 00000000..ce246c1a
Binary files /dev/null and b/benchmarks/semg_dispersion/spikes/nrn/vl_dd_on_fdi/trap_25mvc.npz differ
diff --git a/benchmarks/semg_roeleveld1997/README.md b/benchmarks/semg_roeleveld1997/README.md
new file mode 100644
index 00000000..73aed8a3
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/README.md
@@ -0,0 +1,234 @@
+# Roeleveld et al. (1997) fall-off test of the skin conductivity
+
+MyoGen's default skin conductivity, 1 S/m, comes from Roeleveld et al. (1997),
+J Electromyogr Kinesiol 7:221–232. They chose it because, in their cylinder,
+only a well-conducting outer layer made the negative peak (Nu) of biceps
+motor-unit potentials fall off with depth and observation distance anywhere
+near the measured rates. Their simulated units had all 300 fibres at one point.
+They named missing territory size (real units 0.5–2.5 cm across) as an
+alternative explanation, and MyoGen spreads fibres over a territory.
+
+This benchmark repeats their test in MyoGen's surface volume conductor with
+point and distributed territories, at 1 S/m and at measured skin values:
+0.15 S/m (low-frequency skin in the IT'IS tissue database, mean of 7 studies)
+and 4.88·10⁻⁴ S/m (composite in-vivo skin, Gabriel et al. 1996).
+It answers how amplitude falls off relative to the nearest unit, not absolute
+amplitude, so it does not set the step-4 amplitude bands.
+
+## Setup
+
+`gen.py` follows their model III: cylinder r 35 mm, muscle r 32 mm, fat 1 mm,
+skin 2 mm, no bone; muscle 0.1 S/m radial, 0.5 S/m axial, fat 0.05 S/m; 120 mm
+fibres, 3.8 m/s; monopolar contacts 1.2 mm across. Electrode rows sit 0, 12, 24
+and 36 mm from each unit's end-plate (their electrodes 1–4); columns sit at 0,
+±12, ±24 and ±36 mm of arc (their positions A–D). Units are territory discs of
+radius ρ centred 5–15 mm below the skin surface, clipped to the muscle; depth
+is the realised centroid. ρ = 0 is a point unit (20 fibres at one point).
+
+The `Muscle` is built without its own fibre placement; fibre centres and unit
+assignment are set directly (the only fibre data `SurfaceEMG` reads). Each
+unit runs alone so the electrode rows follow its end-plate, which `gen.py`
+recovers by replaying `SurfaceEMG`'s seeded end-plate draw (`centre: "zone"`
+checks it: latencies on rows ±6 and ±18 mm from the end-plate must match).
+
+Differences from their model, kept as modelling assumptions: Rosenfalck
+intracellular action potential instead of their 4.8 mm tripole; no end-plate
+scatter within a unit (theirs: SD 3 mm); fibre length uniform ±4 mm with both
+ends moving together (theirs: each end SD 4 mm); one conduction velocity for
+all units (they fitted 3.0–3.8 m/s per unit).
+
+## Measured targets
+
+From Roeleveld et al. (1997), Discussion, citing their 52 biceps units: the
+negative peak falls with unit depth as depth^-1.8 and with radial
+observation distance from the unit as r^-1.0. Their Fig. 4 gives, for three
+representative units at 5, 7.5 and 15 mm, Nu above the unit (highest of
+electrodes 1–4) of 100 : 45 : 11 % measured, 100 : 43 : 9 % for model III
+(skin 1 S/m) and 100 : 35 : 4.6 % for model IIb (3 mm fat, no skin), with IIb
+at 5 mm 4.17 times model III at 5 mm.
+
+## Decision rule (fixed 2026-10-31, before any full run)
+
+1. **Numerical convergence.** Nu at A and D for the 5 mm point unit, at skin
+   1 S/m and 4.88·10⁻⁴ S/m, changes by under 2 % between the chosen angular
+   harmonics `M` and twice that, and between the chosen `n_t` and twice that.
+   *Amended after the check ran:* `M` = 256 and above returns all-zero MUAPs
+   (a numerical breakdown, see below), so `M` = 128 was checked against 160,
+   192 and 224 instead.
+
+   *Result (2026-10-31):* `M` = 128 is within 0.2 % of 224 at A–D, at 5 and
+   15 mm, for both skin values. `M` = 64 is not: it moves D by 3 % (1 S/m) and
+   53 % (4.88·10⁻⁴ S/m). Doubling `n_t` and both sampling rates
+   (256 at 2048/10 000 Hz → 512 at 4096/20 000 Hz) changes A–D by under 0.5 %.
+   Defaults: `M` 128, `n_t` 256, 2048 Hz, 10 000 Hz internal. The end-plate
+   replay holds: on the 5 mm point unit the peak latencies at ±6 and ±18 mm
+   from the replayed end-plate are equal, 3.2 ms apart (12 mm at 3.8 m/s).
+2. **Replication of their model** (point units). Model III (skin 1 S/m):
+   Nu-above ratios 7.5/5 and 15/5 mm within ±15 % of 0.43 and 0.09. Model IIb
+   (skin σ = fat σ = 0.05 S/m, same thicknesses, i.e. 3 mm of fat): within
+   ±15 % of 0.35 and 0.046, and IIb/III at 5 mm within ±15 % of 4.17. If
+   replication fails, stop: the comparison below would not mean anything.
+3. **Fall-off test.** Arms: skin σ ∈ {1, 0.15, 4.88·10⁻⁴} S/m × ρ ∈ {0, 2.5,
+   5, 7.5, 12.5} mm. For each, the depth exponent (log Nu at A, 24 mm row,
+   against log centroid depth, 5–15 mm) and the median lateral exponent (log
+   Nu against log distance over A–D).
+   - **Territory suffices:** at a measured σ (0.15 or 4.88·10⁻⁴), some
+     ρ ≤ 12.5 mm gives a depth exponent of 1.8 ± 0.3 and a lateral exponent
+     ≤ 1.3. Then 1 S/m loses its justification.
+   - **1 S/m needed:** only skin 1 S/m (any ρ) meets both. It stays, as a
+     documented effective value.
+   - **Neither:** inconclusive; the cylinder misses something else.
+   The outcome is reported; changing the default is Devon's decision.
+
+## Result of step 2 (2026-10-31): replication fails
+
+Point units, Nu above the unit (highest of the four rows), per fibre:
+
+| Ratio | MyoGen | Roeleveld | Off by | Limit ±15 % |
+|---|---|---|---|---|
+| III 7.5 / 5 mm | 0.367 | 0.43 | −15 % | borderline |
+| III 15 / 5 mm | 0.071 | 0.09 | −21 % | fail |
+| IIb 7.5 / 5 mm | 0.275 | 0.35 | −21 % | fail |
+| IIb 15 / 5 mm | 0.032 | 0.046 | −30 % | fail |
+| IIb / III at 5 mm | 4.88 | 4.17 | +17 % | fail |
+
+MyoGen's point units fall off faster with depth than Roeleveld's, and more so
+without the conducting skin. Per the rule, the fall-off arms (`s1`, `s0.15`,
+`s4.88e-4`, already run) are not interpreted. The listed difference most
+likely to cause this is end-plate scatter: theirs has SD 3 mm within a unit
+(about 0.8 ms at 3.8 m/s), which lowers the sharp potentials of shallow units
+more than the broad ones of deep units. Their compact tripole source would
+push the other way.
+
+### Rerun with their end-plate scatter (2026-10-31): replication passes
+
+MyoGen's two-layer end-plate model cannot give one fixed SD (its spread
+depends on unit size, 0.97–3.46 mm at the scale that gives about 3 mm), so
+production code is left alone. `replicate.py` uses the fact that the cylinder
+is unbounded along the fibres: moving an end-plate by d equals moving the
+electrode by −d, so the unit's expected MUAP is a single-fibre profile (one
+column, rows every 1 mm, `gen.py` with `z_rows_mm`) smoothed along z by a
+Gaussian of SD 3 mm. The fibre ends move with the end-plate here; theirs
+scatter on their own (SD 4 mm), which matters little 24–36 mm from the
+end-plate. Same limits as before:
+
+| Ratio | SD 0 | SD 3 mm | Roeleveld | Off by (3 mm) |
+|---|---|---|---|---|
+| III 7.5 / 5 mm | 0.367 | 0.408 | 0.43 | −5 % |
+| III 15 / 5 mm | 0.071 | 0.085 | 0.09 | −6 % |
+| IIb 7.5 / 5 mm | 0.275 | 0.317 | 0.35 | −10 % |
+| IIb 15 / 5 mm | 0.032 | 0.042 | 0.046 | −9 % |
+| IIb / III at 5 mm | 4.88 | 4.42 | 4.17 | +6 % |
+
+SD 0 reproduces the first run exactly, which checks the method. With the
+scatter, all five pass. The fall-off arms were run without scatter, so they
+do not match the replicated model; they need a rerun with the same 3 mm
+scatter (rows 12–36 mm around the 24 mm row, one column per position A–D)
+before step 3 is read.
+
+## Result of step 3 (2026-10-31): neither, inconclusive
+
+Arms rerun with the replicated model (`run_scatter_arms.sh`: one column per
+position A–D, rows 12–36 mm, smoothed with the 3 mm end-plate Gaussian;
+`falloff.py`). Target: depth exponent 1.8 ± 0.3 and lateral exponent ≤ 1.3
+(measured 1.0).
+
+| Skin S/m | ρ 0 | ρ 2.5 | ρ 5 | ρ 7.5 | ρ 12.5* |
+|---|---|---|---|---|---|
+| 1 | 2.54 / 1.73 | 2.68 / 1.80 | 2.70 / 1.94 | 2.48 / 2.02 | 0.97 / 0.83 |
+| 0.15 | 3.02 / 2.40 | 3.19 / 2.49 | 3.20 / 2.66 | 2.87 / 2.78 | 1.73 / 3.05 |
+| 4.88·10⁻⁴ | 3.40 / 2.75 | 3.60 / 2.86 | 3.56 / 3.06 | 3.11 / 3.21 | 1.70 / 3.61 |
+
+Depth exponent / median lateral exponent; no arm meets both.
+\*ρ 12.5 mm discs are mostly clipped by the muscle edge: centroids span only
+10.0–14.5 mm for nominal depths 5–15 mm, so its exponents describe the
+clipping, not a unit at that depth.
+
+- Territory does not explain the slow measured fall-off: from ρ 0 to 7.5 mm
+  the lateral exponent rises at every conductivity (nearby fibres boost the
+  potential right above the unit), the opposite of what was proposed.
+- 1 S/m is the closest of the three at every ρ ≤ 7.5 mm but still falls off
+  faster than measured (lateral 1.7–2.0 against 1.0, depth 2.5–2.7 against
+  1.8), as Roeleveld et al. also reported for their model III.
+- The measured values are much further off (lateral 2.4–3.2, depth 2.9–3.6).
+- Without the end-plate scatter all exponents are larger still (SD 0 run
+  of `falloff.py`), with the same ranking.
+
+Caveat: the measured depths came from scanning-EMG estimates of each unit's
+electrophysiological centre, here replaced by the fibre centroid. The 1.8 / 1.0
+exponents are the pooled fit over 52 units quoted in the Discussion (the
+regression itself is in Roeleveld et al. 1997b, not read); the lateral limit
+treats 1.0 as a within-unit slope, which that fit may not be. A direct check
+that needs no exponent is their Fig. 6 (measured/simulated Nu against
+distance for model III, which this setup replicates); done below.
+
+## Fig. 6 check (2026-10-31): no physical skin value fits
+
+Fig. 6 plots measured/simulated Nu against radial distance r from the unit,
+normalised to the 5 mm unit at A, using their average measured data. Model III
+(skin 1 S/m), read from the figure by eye (+-0.2):
+
+| unit depth | A | B | C | D |
+|---|---|---|---|---|
+| 5 mm (r 5/12/22/32) | 1.0 | 1.4 | 2.4 | 4.2 |
+| 7.5 mm | 1.4 | 1.6 | 2.5 | 3.9 |
+| 15 mm (r 15/30) | 2.2 | | | 3.4 |
+
+Our 1 S/m arm replicates III (step 2), so measured/ours at skin s is
+Fig6_III x ours(1 S/m) / ours(s). `fig6check.py` computes it from the point
+arms (`sc_s*_r0`); rows 12-36, end-plate SD 3 mm at the 24 mm row
+(their A row is 36 mm for the 5 and 15 mm units; the unsmoothed 36 mm row
+gives the same picture). 1 = match:
+
+| skin S/m | 5 mm: A B C D | 7.5 mm: A B C D | 15 mm: A D |
+|---|---|---|---|
+| 100 | 1.00 0.99 1.12 1.48 | 1.22 1.06 1.13 1.38 | 1.24 1.22 |
+| 10 | 1.00 1.05 1.27 1.76 | 1.25 1.13 1.29 1.65 | 1.38 1.46 |
+| 3 | 1.00 1.16 1.59 2.44 | 1.31 1.29 1.65 2.29 | 1.67 2.03 |
+| 1 | 1.00 1.40 2.40 4.20 | 1.40 1.60 2.50 3.90 | 2.20 3.40 |
+| 0.15 | 1.00 2.66 7.35 13.34 | 1.64 2.92 6.90 11.52 | 3.74 8.99 |
+| 4.88e-4 | 1.00 6.31 17.97 26.35 | 1.92 5.69 15.16 22.38 | 5.68 16.91 |
+
+Only about 100 S/m reproduces the measured spread, which is not a skin value.
+Measured skin conductivities are 3-6x further off than 1 S/m. The measured
+lateral and depth spread is therefore not a skin effect; 1 S/m is the
+least-bad value of a model that misses something, and its effect on absolute
+amplitude is not physically grounded. Step 3 found that territories steepen
+rather than flatten the fall-off, so territory size is not the missing piece
+either. The 3, 10 and 100 S/m arms were run for this check only (same grid as
+`run_scatter_arms.sh`, territory radius 0).
+
+## Side finding: angular resolution limit
+
+With `sampling_points_in_theta_domain` ≥ 256, `SurfaceEMG` returns MUAPs that
+are exactly zero for every electrode (seen at 256 and 512 in this geometry;
+224 works). The volume-conductor matrices replace NaN entries with zero
+(`volume_conductor.py`), which hides the failure. Fixed since: the scaled Bessel
+functions leave the float64 range at these orders, and `SurfaceEMG` now raises a
+`ValueError` naming `sampling_points_in_theta_domain`.
+
+## Running
+
+MUAPs go through the optimised CPU route (`simulate_muaps(execution=ExecutionPolicy())`),
+which reuses the conductor preparation across fibres. It matched the
+original route to 3·10⁻¹⁸ mV on the check units and runs at about 0.12 s per
+fibre here.
+
+```bash
+# from the repository root, with PYTHONPATH set to this checkout if needed
+# step 2 (replication), with and without end-plate scatter
+python benchmarks/semg_roeleveld1997/gen.py artifacts/semg_roeleveld1997/rep_III.npz '{"skin_sigma": 1.0, "rhos_mm": [0], "depths_mm": [5, 7.5, 15], "point_fibres": 1, "z_rows_mm": [-15, 51]}'
+python benchmarks/semg_roeleveld1997/gen.py artifacts/semg_roeleveld1997/rep_IIb.npz '{"skin_sigma": 0.05, "rhos_mm": [0], "depths_mm": [5, 7.5, 15], "point_fibres": 1, "z_rows_mm": [-15, 51]}'
+python benchmarks/semg_roeleveld1997/replicate.py artifacts/semg_roeleveld1997/rep_III.npz artifacts/semg_roeleveld1997/rep_IIb.npz 0 3
+# step 3 (fall-off), about 20 min with 15 processes
+PY=python bash benchmarks/semg_roeleveld1997/run_scatter_arms.sh artifacts/semg_roeleveld1997/scatter
+python benchmarks/semg_roeleveld1997/falloff.py artifacts/semg_roeleveld1997/scatter 3
+```
+
+`run_arms.sh` and `analyze.py` are the first, scatter-free version (sparse
+grid, positions on both sides); they are superseded by the commands above
+and kept only to reproduce the first run.
+
+Arms: `III` (skin 1 S/m) and `IIb` (skin σ = fat σ = 0.05 S/m) with point
+units; `s1` (1 S/m, territories), `s0.15` and `s4.88e-4` (point units and
+territories).
diff --git a/benchmarks/semg_roeleveld1997/analyze.py b/benchmarks/semg_roeleveld1997/analyze.py
new file mode 100644
index 00000000..b642fb89
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/analyze.py
@@ -0,0 +1,61 @@
+"""Fall-off of the monopolar negative peak (Nu) with depth and observation distance.
+
+Usage: python analyze.py <arm.npz> [<arm.npz> ...]
+
+Nu is the peak of the main propagating phase, per fibre (Roeleveld et al.
+normalised measured MUAPs by unit size). Its sign is taken from the
+shallowest unit at position A, 24 mm from the end-plate. For each arm:
+
+- ``above``: Nu above the unit, highest over the four rows (their Fig. 4 scale),
+  relative to the shallowest point unit.
+- depth exponent: slope of log Nu at A (24 mm row) against log centroid depth,
+  per territory radius.
+- lateral exponent: slope of log Nu against log distance from the territory
+  centroid to the electrode over positions A-D (both sides averaged), per unit,
+  then the median over depths.
+"""
+import json
+import sys
+
+import numpy as np
+
+ROW_24, COL_A = 2, 3
+
+
+def load(path):
+    d = np.load(path, allow_pickle=True)
+    muaps = d["muaps"]  # unit, row, col, time
+    point = np.flatnonzero(d["rho"] == 0)
+    ref = point[np.argmin(d["depth"][point])] if len(point) else int(np.argmin(d["depth"]))
+    trace = muaps[ref, ROW_24, COL_A]
+    sign = np.sign(trace[np.argmax(np.abs(trace))])
+    nu = (sign * muaps).max(axis=-1) / d["n_fibres"][:, None, None]
+    side = 0.5 * (nu[:, ROW_24, COL_A:] + nu[:, ROW_24, COL_A::-1])  # A, B, C, D
+    arc = d["col_arc_mm"][COL_A:]
+    rc = float(d["r_total"]) - d["centroid_depth"]
+    r = np.sqrt(rc[:, None] ** 2 + d["r_total"] ** 2 - 2 * rc[:, None] * d["r_total"] * np.cos(arc / d["r_total"]))
+    return d, nu, side, r, ref
+
+
+def slope(x, y):
+    return -np.polyfit(np.log(x), np.log(y), 1)[0]
+
+
+for path in sys.argv[1:]:
+    d, nu, side, r, ref = load(path)
+    cfg = json.loads(str(d["config"]))
+    above = nu[:, :, COL_A].max(axis=1)
+    print(f"\n{path}  skin {cfg.get('skin_sigma', 1.0)} S/m, fat {cfg.get('fat_sigma', 0.05)} S/m, "
+          f"M {cfg.get("M", 128)}, n_t {cfg.get("n_t", 256)}")
+    print("rho  depth  centroid  above/ref  Nu_A(24)  A:B:C:D        lateral_exp")
+    for mu in range(len(d["rho"])):
+        print(f"{d['rho'][mu]:4.1f} {d['depth'][mu]:6.1f} {d['centroid_depth'][mu]:8.2f} "
+              f"{above[mu] / above[ref]:9.3f} {side[mu, 0]:.3e} "
+              f"{':'.join(f'{v:.2f}' for v in side[mu] / side[mu, 0])}  {slope(r[mu], side[mu]):.2f}")
+    for rho in np.unique(d["rho"]):
+        sel = np.flatnonzero(d["rho"] == rho)
+        if len(sel) > 1:
+            lat = [slope(r[mu], side[mu]) for mu in sel]
+            print(f"rho {rho:4.1f}: depth exponent {slope(d['centroid_depth'][sel], side[sel, 0]):.2f} "
+                  f"(above, max over rows {slope(d['centroid_depth'][sel], above[sel]):.2f}), "
+                  f"lateral exponent median {np.median(lat):.2f} [{min(lat):.2f}, {max(lat):.2f}]")
diff --git a/benchmarks/semg_roeleveld1997/falloff.py b/benchmarks/semg_roeleveld1997/falloff.py
new file mode 100644
index 00000000..60ffb638
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/falloff.py
@@ -0,0 +1,75 @@
+"""Step 3 of the README rule: fall-off exponents with Roeleveld's end-plate scatter.
+
+Usage: python falloff.py <dir> [sd_mm]
+
+Reads ``sc_s<skin>_r<rho>.npz`` from ``run_scatter_arms.sh`` (one column per
+position A-D at 0/12/24/36 mm of arc, rows every 1 mm from 12 to 36 mm from
+the end-plate). Each profile is smoothed along z by a Gaussian of SD ``sd``
+(default 3 mm, as in ``replicate.py``) and read at the 24 mm row. Nu is per
+fibre, with its sign taken from the shallowest unit at A.
+
+- depth exponent: -slope of log Nu at A against log centroid depth (5-15 mm).
+- lateral exponent: -slope of log Nu against log distance from the territory
+  centroid to the electrode over A-D, per unit; the median over depths.
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+
+DEPTH_TARGET, DEPTH_TOL, LATERAL_MAX = 1.8, 0.3, 1.3
+MEASURED = (0.15, 0.000488)
+
+
+def slope(x, y):
+    return -np.polyfit(np.log(x), np.log(y), 1)[0]
+
+
+def arm(path, sd):
+    d = np.load(path, allow_pickle=True)
+    z = list(d["row_z_from_zone"])
+    prof = d["muaps"] / d["n_fibres"][:, None, None, None]  # unit, row, col, time
+    i = z.index(24)
+    if sd > 0:
+        half = int(round(4 * sd))
+        if i - half < 0 or i + half >= len(z):
+            raise SystemExit(f"rows {z[0]}..{z[-1]} too short for a {sd} mm kernel")
+        k = np.exp(-0.5 * (np.arange(-half, half + 1) / sd) ** 2)
+        trace = np.tensordot(k / k.sum(), prof[:, i - half:i + half + 1], axes=([0], [1]))
+    else:
+        trace = prof[:, i]
+    ref = trace[int(np.argmin(d["centroid_depth"])), 0]
+    nu = (np.sign(ref[np.argmax(np.abs(ref))]) * trace).max(axis=-1)  # unit, col
+    rt, rc = float(d["r_total"]), float(d["r_total"]) - d["centroid_depth"]
+    arc = d["col_arc_mm"]
+    r = np.sqrt(rc[:, None] ** 2 + rt ** 2 - 2 * rc[:, None] * rt * np.cos(arc / rt))
+    lateral = [slope(r[u], nu[u]) for u in range(len(nu))]
+    return dict(depth_exp=slope(d["centroid_depth"], nu[:, 0]), lateral=lateral,
+                centroid=d["centroid_depth"], nu=nu)
+
+
+out = Path(sys.argv[1])
+sd = float(sys.argv[2]) if len(sys.argv) > 2 else 3.0
+rows = []
+for path in sorted(out.glob("sc_s*_r*.npz")):
+    skin, rho = map(float, re.match(r"sc_s(.+)_r(.+)\.npz", path.name).groups())
+    a = arm(path, sd)
+    ok = abs(a["depth_exp"] - DEPTH_TARGET) <= DEPTH_TOL and np.median(a["lateral"]) <= LATERAL_MAX
+    rows.append((skin, rho, a["depth_exp"], float(np.median(a["lateral"])), min(a["lateral"]),
+                 max(a["lateral"]), a["centroid"].min(), a["centroid"].max(), ok))
+
+print(f"end-plate SD {sd} mm; target depth {DEPTH_TARGET} +- {DEPTH_TOL}, lateral <= {LATERAL_MAX} (measured 1.0)")
+print("skin S/m   rho mm  depth_exp  lateral median [min, max]   centroid mm   meets both")
+for skin, rho, de, lm, lmin, lmax, cmin, cmax, ok in sorted(rows):
+    print(f"{skin:<9g} {rho:6.1f} {de:10.2f} {lm:9.2f} [{lmin:.2f}, {lmax:.2f}]   {cmin:5.2f}-{cmax:5.2f}   {'yes' if ok else 'no'}")
+measured_ok = any(ok for skin, *_, ok in rows if skin in MEASURED)
+one_ok = any(ok for skin, *_, ok in rows if skin == 1.0)
+outcome = ("territory suffices" if measured_ok else "1 S/m needed" if one_ok else "neither: inconclusive")
+print(f"outcome: {outcome}")
+(out / f"falloff_sd{sd:g}.json").write_text(json.dumps(
+    {"sd_mm": sd, "outcome": outcome,
+     "rows": [dict(zip(("skin", "rho", "depth_exp", "lateral_median", "lateral_min", "lateral_max",
+                        "centroid_min", "centroid_max", "meets_both"), map(lambda v: v if isinstance(v, bool) else float(v), r)))
+              for r in rows]}, indent=1))
diff --git a/benchmarks/semg_roeleveld1997/fig6check.py b/benchmarks/semg_roeleveld1997/fig6check.py
new file mode 100644
index 00000000..4ec44fd5
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/fig6check.py
@@ -0,0 +1,29 @@
+"""Exponent-free check against Roeleveld 1997 Fig. 6 (model III curves, read from the figure, +-0.2)."""
+import sys, glob, re
+import numpy as np
+
+FIG6_III = {5.0: [1.0, 1.4, 2.4, 4.2], 7.5: [1.4, 1.6, 2.5, 3.9], 15.0: [2.2, np.nan, np.nan, 3.4]}
+
+def nu(path, row, sd):
+    d = np.load(path, allow_pickle=True)
+    z = list(d["row_z_from_zone"]); prof = d["muaps"] / d["n_fibres"][:, None, None, None]  # unit,row,col,t
+    i = z.index(row)
+    if sd > 0:
+        k = np.exp(-0.5 * (np.arange(-4 * sd, 4 * sd + 1) / sd) ** 2); k /= k.sum(); h = len(k) // 2
+        assert i - h >= 0 and i + h < len(z), "rows too short"
+        p = np.tensordot(k, prof[:, i - h:i + h + 1], axes=([0], [1]))  # unit,col,t
+    else:
+        p = prof[:, i]
+    ref = p[0, 0]; sign = np.sign(ref[np.argmax(np.abs(ref))])
+    n = (sign * p).max(axis=-1)  # unit, col
+    depth = list(d["depth"])
+    return {dp: n[depth.index(dp)] / n[depth.index(5.0), 0] for dp in FIG6_III}
+
+base = sys.argv[1]
+arms = {float(re.search(r"sc_s([0-9.e-]+)_r0", f).group(1)): f for f in glob.glob(base + "/sc_s*_r0.npz")}
+for row, sd in ((24, 3.0), (36, 0.0)):
+    ref = nu(arms[1.0], row, sd)
+    print(f"\nrow {row} mm, end-plate SD {sd}: measured/simulated Nu (1 = match), cols A B C D")
+    for s in sorted(arms, reverse=True):
+        a = nu(arms[s], row, sd)
+        print(f"  skin {s:<9g}" + "  ".join(f"{dp:>4} mm: " + " ".join(f"{v:5.2f}" for v in np.array(FIG6_III[dp]) * ref[dp] / a[dp]) for dp in FIG6_III))
diff --git a/benchmarks/semg_roeleveld1997/gen.py b/benchmarks/semg_roeleveld1997/gen.py
new file mode 100644
index 00000000..a76b069a
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/gen.py
@@ -0,0 +1,132 @@
+"""Simulate monopolar surface MUAPs in the biceps-like cylinder of Roeleveld et al. (1997).
+
+Usage: python gen.py <out.npz> <config-json>
+
+Geometry and conductivities follow Roeleveld et al. (1997), J Electromyogr
+Kinesiol 7:221-232 (their model III): cylinder radius 35 mm, muscle radius 32 mm,
+fat 1 mm, skin 2 mm, no bone; muscle 0.1 S/m radial and 0.5 S/m axial, fat
+0.05 S/m, skin 1 S/m; fibres 120 mm long, conduction velocity 3.8 m/s;
+monopolar contacts 1.2 mm in diameter. Config keys override these
+(``skin_sigma``, ``fat_sigma``, ``skin_mm``, ``fat_mm``) and set the motor
+units and the numerical resolution:
+
+- ``depths_mm``: territory centre depth below the skin surface.
+- ``rhos_mm``: territory radius; 0 puts ``point_fibres`` fibres at one point,
+  as Roeleveld et al. did, otherwise ``n_fibres`` fibres are drawn uniformly in
+  the disc and clipped to the muscle (so the realised centroid depth is stored).
+- ``M`` (angular harmonics), ``n_t`` (output samples), ``fs`` and ``fs_internal`` (Hz).
+- ``execution``: ``"policy"`` (default) uses the optimised CPU route
+  (``ExecutionPolicy``), ``"default"`` the original per-fibre route.
+- ``z_rows_mm``: ``[first, last]`` replaces the grid by one column above the
+  unit with rows every 1 mm from the end-plate (an odd count), for
+  ``replicate.py``. ``arcs_mm`` then places one such column at each arc
+  position (default ``[0]``, above the unit).
+- ``centre``: ``"roeleveld"`` puts the electrode rows 0, 12, 24 and 36 mm from
+  each unit's end-plate (their electrodes 1-4); ``"zone"`` centres the rows on
+  the end-plate (-18, -6, 6, 18 mm), to check the end-plate replication.
+
+Each unit is simulated on its own with seven columns around the circumference
+at 0, +-12, +-24 and +-36 mm of arc (their positions A-D on both sides), so the
+electrode rows can follow that unit's end-plate. ``SurfaceEMG`` draws each
+unit's end-plate offset from the global generator as its first draw; this
+script replays that draw from the same seed (``gen.py`` checks it with
+``centre: "zone"``). The ``Muscle`` is built without its own fibre placement:
+the fibre centres and their unit assignment are set directly, which are the
+only fibre data ``SurfaceEMG`` reads.
+"""
+import json
+import sys
+import time
+
+import numpy as np
+import quantities as pq
+
+import myogen
+from myogen import get_random_generator, set_random_seed
+from myogen.simulator import ExecutionPolicy, Muscle, RecruitmentThresholds, SurfaceElectrodeArray, SurfaceEMG
+from myogen.utils.neo import signal_to_grid
+
+out, cfg = sys.argv[1], json.loads(sys.argv[2])
+SKIN_SIGMA = cfg.get("skin_sigma", 1.0)
+FAT_SIGMA = cfg.get("fat_sigma", 0.05)
+SKIN_MM, FAT_MM, R_MUSCLE = cfg.get("skin_mm", 2.0), cfg.get("fat_mm", 1.0), 32.0
+R_TOTAL = R_MUSCLE + FAT_MM + SKIN_MM
+DEPTHS = cfg.get("depths_mm", [5.0, 6.0, 7.5, 10.0, 12.5, 15.0])
+RHOS = cfg.get("rhos_mm", [0.0, 2.5, 5.0, 7.5, 12.5])
+N_FIBRES, POINT_FIBRES = cfg.get("n_fibres", 300), cfg.get("point_fibres", 20)
+M, N_T = cfg.get("M", 128), cfg.get("n_t", 256)
+FS, FS_INT = cfg.get("fs", 2048.0), cfg.get("fs_internal", 10000.0)
+CENTRE = cfg.get("centre", "roeleveld")
+FAST = cfg.get("execution", "policy") == "policy"
+Z_ROWS = cfg.get("z_rows_mm")  # [first, last] row from the end-plate, 1 mm pitch
+ARCS = cfg.get("arcs_mm", [0.0])  # with z_rows_mm: one column per arc position
+CV, FIBRE_MM, FIBRE_VAR_MM = 3.8, 120.0, 4.0
+SEED_FIBRES, SEED_EMG = cfg.get("seed", 1), 7
+
+units = [(rho, depth) for rho in RHOS for depth in DEPTHS]
+rng = np.random.default_rng(SEED_FIBRES)
+positions, assignment, centroid_depth = [], [], []
+for mu, (rho, depth) in enumerate(units):
+    centre = np.array([R_TOTAL - depth, 0.0])
+    if rho == 0:
+        xy = np.repeat(centre[None], POINT_FIBRES, axis=0)
+    else:
+        xy = np.empty((0, 2))
+        while len(xy) < N_FIBRES:
+            cand = centre + rho * np.sqrt(rng.uniform(size=(4 * N_FIBRES, 1))) * np.stack(
+                [np.cos(a := rng.uniform(0, 2 * np.pi, 4 * N_FIBRES)), np.sin(a)], axis=1)
+            xy = np.vstack([xy, cand[np.hypot(*cand.T) < R_MUSCLE - 0.25]])
+        xy = xy[:N_FIBRES]
+    positions.append(xy)
+    assignment.append(np.full(len(xy), mu))
+    centroid_depth.append(R_TOTAL - np.hypot(*xy.mean(axis=0)))
+
+thresholds, _ = RecruitmentThresholds(N=len(units), recruitment_range__ratio=10, mode="fuglevand")
+muscle = Muscle(thresholds, radius__mm=R_MUSCLE * pq.mm, length__mm=150 * pq.mm,
+                mean_conduction_velocity__m_per_s=CV * pq.m / pq.s, mean_fiber_length__mm=FIBRE_MM * pq.mm,
+                var_fiber_length__mm=FIBRE_VAR_MM * pq.mm, radius_bone__mm=0 * pq.mm,
+                fat_thickness__mm=FAT_MM * pq.mm, skin_thickness__mm=SKIN_MM * pq.mm,
+                muscle_conductivity_radial__S_per_m=0.1 * pq.S / pq.m,
+                muscle_conductivity_longitudinal__S_per_m=0.5 * pq.S / pq.m,
+                fat_conductivity__S_per_m=FAT_SIGMA * pq.S / pq.m,
+                skin_conductivity__S_per_m=SKIN_SIGMA * pq.S / pq.m)
+muscle._muscle_fiber_centers__mm = np.vstack(positions) * pq.mm
+muscle._assignment = np.concatenate(assignment).astype(float)
+
+# Replay SurfaceEMG's end-plate draw: uniform over 10 % of the mean fibre length.
+set_random_seed(SEED_EMG)
+zones = get_random_generator().uniform(-FIBRE_MM * 0.1 / 2, FIBRE_MM * 0.1 / 2, size=len(units))
+
+muaps, t0 = [], time.time()
+for mu in range(len(units)):
+    if Z_ROWS is None:
+        z_centre = zones[mu] + (18.0 if CENTRE == "roeleveld" else 0.0)
+        ring = SurfaceElectrodeArray(4, 7, 12 * pq.mm, 0.6 * pq.mm,
+                                     center_point__mm_deg=(z_centre * pq.mm, 0 * pq.deg),
+                                     bending_radius__mm=R_TOTAL * pq.mm, differentiation_mode="monopolar")
+        rings = [ring]
+    else:
+        rings = [SurfaceElectrodeArray(Z_ROWS[1] - Z_ROWS[0] + 1, 1, 1 * pq.mm, 0.6 * pq.mm,
+                                       center_point__mm_deg=((zones[mu] + sum(Z_ROWS) / 2) * pq.mm,
+                                                             np.degrees(arc / R_TOTAL) * pq.deg),
+                                       bending_radius__mm=R_TOTAL * pq.mm, differentiation_mode="monopolar")
+                 for arc in ARCS]
+    set_random_seed(SEED_EMG)
+    semg = SurfaceEMG(muscle, rings, sampling_frequency__Hz=FS * pq.Hz, sampling_points_in_t_and_z_domains=N_T,
+                      sampling_points_in_theta_domain=M, MUs_to_simulate=[mu],
+                      internal_sampling_frequency__Hz=FS_INT * pq.Hz)
+    block = semg.simulate_muaps(n_jobs=1, verbose=False,
+                                execution=ExecutionPolicy(max_workers=1) if FAST else None)
+    grids = [np.asarray(signal_to_grid(g.segments[mu].analogsignals[0].rescale(pq.mV))) for g in block.groups]
+    muaps.append(np.moveaxis(np.concatenate(grids, axis=2), 0, -1))  # row, col (arrays side by side), time
+    sig = block.groups[0].segments[mu].analogsignals[0]
+    fs_muap = float(sig.sampling_rate.rescale(pq.Hz).magnitude)
+    print(f"unit {mu} rho {units[mu][0]} depth {units[mu][1]} fibres {len(positions[mu])} "
+          f"{time.time() - t0:.0f} s", flush=True)
+
+np.savez(out, myogen=myogen.__file__, config=json.dumps(cfg), rho=[u[0] for u in units],
+         depth=[u[1] for u in units], centroid_depth=centroid_depth, n_fibres=[len(p) for p in positions],
+         zones=zones, muaps=np.array(muaps), fs_muap=fs_muap, r_total=R_TOTAL, cv=CV,
+         row_z_from_zone=(np.array([0, 12, 24, 36]) - (0 if CENTRE == "roeleveld" else 18) if Z_ROWS is None
+                          else np.arange(Z_ROWS[0], Z_ROWS[1] + 1)),
+         col_arc_mm=np.arange(-3, 4) * 12.0 if Z_ROWS is None else np.asarray(ARCS, dtype=float), seconds=time.time() - t0)
diff --git a/benchmarks/semg_roeleveld1997/replicate.py b/benchmarks/semg_roeleveld1997/replicate.py
new file mode 100644
index 00000000..647d45dd
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/replicate.py
@@ -0,0 +1,51 @@
+"""Step 2 of the README rule with Roeleveld's end-plate scatter added.
+
+Usage: python replicate.py <III.npz> <IIb.npz> [sd_mm ...]
+
+Inputs come from ``gen.py`` with ``z_rows_mm`` (one column above each point
+unit, rows every 1 mm from its end-plate). MyoGen's cylinder is unbounded
+along the fibres, so moving a fibre's end-plate by d gives the same potential
+as moving the electrode by -d. A unit whose fibres have end-plates scattered
+normally with SD ``sd`` (Roeleveld et al. 1997: 3 mm) is therefore the
+single-fibre profile smoothed along z by that Gaussian. The fibre ends move
+with the end-plate here; in their model the ends scatter on their own.
+"""
+import sys
+
+import numpy as np
+
+TARGET = {"III": (0.43, 0.09), "IIb": (0.35, 0.046)}
+ROWS = (0, 12, 24, 36)
+
+
+def nu_above(path, sd):
+    d = np.load(path, allow_pickle=True)
+    z = d["row_z_from_zone"]
+    prof = d["muaps"][:, :, 0, :] / d["n_fibres"][:, None, None]  # unit, row, time
+    if sd > 0:
+        k = np.exp(-0.5 * (np.arange(-4 * sd, 4 * sd + 1) / sd) ** 2)
+        k /= k.sum()
+        half = len(k) // 2
+        need = [i for i, v in enumerate(z) if v in ROWS]
+        if z[need[0]] - z[0] < half or z[-1] - z[need[-1]] < half:
+            raise SystemExit(f"rows {z[0]}..{z[-1]} too short for a {sd} mm kernel")
+        prof = np.stack([np.tensordot(k, prof[:, i - half:i + half + 1], axes=([0], [1])) for i in need], axis=1)
+    else:
+        prof = prof[:, [list(z).index(r) for r in ROWS]]
+    ref = prof[0, ROWS.index(24)]
+    sign = np.sign(ref[np.argmax(np.abs(ref))])
+    above = (sign * prof).max(axis=-1).max(axis=1)
+    return dict(zip(d["depth"], above))
+
+
+for sd in [float(x) for x in sys.argv[3:]] or [0.0, 3.0]:
+    res = {name: nu_above(path, sd) for name, path in zip(("III", "IIb"), sys.argv[1:3])}
+    print(f"\nend-plate SD {sd} mm")
+    for name, a in res.items():
+        for depth, target in zip((7.5, 15.0), TARGET[name]):
+            r = a[depth] / a[5.0]
+            print(f"  {name} {depth:>4}/5 mm  {r:.3f}  target {target}  off {100 * (r / target - 1):+.0f} %  "
+                  f"{'pass' if abs(r / target - 1) <= 0.15 else 'FAIL'}")
+    r = res["IIb"][5.0] / res["III"][5.0]
+    print(f"  IIb/III at 5 mm  {r:.2f}  target 4.17  off {100 * (r / 4.17 - 1):+.0f} %  "
+          f"{'pass' if abs(r / 4.17 - 1) <= 0.15 else 'FAIL'}")
diff --git a/benchmarks/semg_roeleveld1997/run_arms.sh b/benchmarks/semg_roeleveld1997/run_arms.sh
new file mode 100644
index 00000000..404c9ff9
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/run_arms.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Run the Roeleveld arms in parallel: bash run_arms.sh <outdir>   (PY selects the interpreter)
+set -u
+OUT=${1:?outdir}; PY=${PY:-python}; mkdir -p "$OUT"
+export OMP_NUM_THREADS=2 MKL_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2 NUMBA_NUM_THREADS=2
+G=$(dirname "$0")/gen.py
+run() { [ -s "$OUT/$1.npz" ] || $PY "$G" "$OUT/$1.npz" "$2" > "$OUT/$1.log" 2>&1; echo "$1 exit $?"; }
+run III      '{"skin_sigma": 1.0, "rhos_mm": [0]}' &
+run IIb      '{"skin_sigma": 0.05, "rhos_mm": [0]}' &
+run s1       '{"skin_sigma": 1.0, "rhos_mm": [2.5, 5, 7.5, 12.5]}' &
+run s0.15    '{"skin_sigma": 0.15}' &
+run s4.88e-4 '{"skin_sigma": 0.000488}' &
+wait
diff --git a/benchmarks/semg_roeleveld1997/run_scatter_arms.sh b/benchmarks/semg_roeleveld1997/run_scatter_arms.sh
new file mode 100644
index 00000000..ded88d10
--- /dev/null
+++ b/benchmarks/semg_roeleveld1997/run_scatter_arms.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Fall-off arms for replicate-style end-plate scatter: one process per skin
+# conductivity and territory radius. bash run_scatter_arms.sh <outdir>
+set -u
+OUT=${1:?outdir}; PY=${PY:-python}; mkdir -p "$OUT"
+export OMP_NUM_THREADS=1 MKL_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 NUMBA_NUM_THREADS=1
+G=$(dirname "$0")/gen.py
+GRID='"z_rows_mm": [12, 36], "arcs_mm": [0, 12, 24, 36], "point_fibres": 1'
+run() { [ -s "$OUT/$1.npz" ] || $PY "$G" "$OUT/$1.npz" "$2" > "$OUT/$1.log" 2>&1; echo "$1 exit $?"; }
+for s in 1.0 0.15 0.000488; do
+  for rho in 0 2.5 5 7.5 12.5; do
+    run "sc_s${s}_r${rho}" "{\"skin_sigma\": $s, \"rhos_mm\": [$rho], $GRID}" &
+  done
+done
+wait
diff --git a/benchmarks/semg_versions/README.md b/benchmarks/semg_versions/README.md
new file mode 100644
index 00000000..964d839a
--- /dev/null
+++ b/benchmarks/semg_versions/README.md
@@ -0,0 +1,15 @@
+# Surface EMG before and after the unreleased surface-EMG fixes
+
+Simulates the same recording with two myogen checkouts and compares them
+through one recording chain (3 µV amplifier noise, 20–450 Hz band-pass). The
+limb-like scenario matches `benchmarks/semg_dispersion` (`limb`): muscle,
+fibres and spike trains are seeded identically and their hashes must agree.
+
+```bash
+# run once per checkout; <expected_worktree> is a path fragment that myogen.__file__ must contain
+PYTHONPATH=<old checkout> python benchmarks/semg_versions/gen_real.py old <old checkout> out/old.npz 350
+PYTHONPATH=<new checkout> python benchmarks/semg_versions/gen_real.py new <new checkout> out/new.npz 350
+python benchmarks/semg_versions/plot_real.py out    # semg_realistic_old_vs_new.pdf and PNGs
+```
+
+Each checkout keeps its own defaults, including skin conductivity.
diff --git a/benchmarks/semg_versions/gen_real.py b/benchmarks/semg_versions/gen_real.py
new file mode 100644
index 00000000..d018bc28
--- /dev/null
+++ b/benchmarks/semg_versions/gen_real.py
@@ -0,0 +1,107 @@
+"""Realistic frozen sEMG recording with whichever myogen is on sys.path.
+
+Usage: python gen_real.py <label> <expected_worktree> <out.npz> <density_per_mm2> [n_jobs] [max_mus]
+Muscle, end-plates, fibre lengths and spike trains are seeded identically; each code
+version keeps its own defaults (including skin conductivity).
+"""
+import hashlib
+import sys
+import time
+
+import numpy as np
+import quantities as pq
+from neo import Block, Segment, SpikeTrain
+
+label, expected, out, density = sys.argv[1], sys.argv[2], sys.argv[3], float(sys.argv[4])
+n_jobs = int(sys.argv[5]) if len(sys.argv) > 5 else 8
+max_mus = int(sys.argv[6]) if len(sys.argv) > 6 else None
+import myogen  # noqa: E402
+
+assert expected.lower() in myogen.__file__.lower(), myogen.__file__
+from myogen import set_random_seed  # noqa: E402
+from myogen.simulator import Muscle, RecruitmentThresholds, SurfaceElectrodeArray, SurfaceEMG  # noqa: E402
+from myogen.utils.neo import signal_to_grid  # noqa: E402
+
+N_MU, FS = 100, 2048.0
+RAMP, HOLD, LEVEL = 2.0, 4.0, 0.30  # s, s, fraction of max excitation
+DURATION = 2 * RAMP + HOLD + 1.0    # 0.5 s rest before and after
+
+# ---- muscle ------------------------------------------------------------------
+set_random_seed(42)
+thresholds, _ = RecruitmentThresholds(N=N_MU, recruitment_range__ratio=50, mode="fuglevand")
+muscle = Muscle(recruitment_thresholds=thresholds, radius__mm=15 * pq.mm, length__mm=80 * pq.mm,
+                fiber_density__fibers_per_mm2=density * pq.mm**-2, mean_fiber_length__mm=70 * pq.mm,
+                var_fiber_length__mm=5 * pq.mm, radius_bone__mm=3 * pq.mm, fat_thickness__mm=4 * pq.mm)
+muscle.distribute_innervation_centers()
+muscle.generate_muscle_fiber_centers(verbose=False)
+muscle.assign_mfs2mns(verbose=False, n_jobs=n_jobs)
+counts = np.asarray(muscle.resulting_number_of_innervated_fibers)
+fibre_hash = hashlib.sha1(b"".join(
+    np.ascontiguousarray(muscle.resulting_fiber_assignment(i)).tobytes() for i in range(N_MU))).hexdigest()
+skin = float(muscle.skin_conductivity__S_m.rescale(pq.S / pq.m).magnitude)
+
+# ---- spike trains: Fuglevand et al. (1993) rate coding, frozen ---------------
+rng = np.random.default_rng(123)
+rte = np.asarray(thresholds, dtype=float)
+rte = rte / rte.max() * 0.7  # last unit recruited at 70 % excitation
+
+
+def excitation(t):
+    t = t - 0.5
+    return LEVEL * np.clip(np.minimum(t / RAMP, (2 * RAMP + HOLD - t) / RAMP), 0, 1)
+
+
+trains, active = [], []
+for mu in range(N_MU):
+    times, t = [], 0.0
+    while t < DURATION:
+        e = excitation(t)
+        if e < rte[mu]:
+            t += 1 / FS
+            continue
+        rate = min(8.0 + 100 * (e - rte[mu]), 35.0)  # 8 Hz at recruitment, 1 Hz/%, 35 Hz peak
+        times.append(t)
+        t += rng.gamma(1 / 0.2**2, 0.2**2 / rate)  # ISI CV 0.2
+    times = np.asarray([x for x in times if x < DURATION])
+    active.append(len(times) > 0)
+    trains.append(SpikeTrain(np.round(times * FS) / FS * pq.s, t_stop=DURATION * pq.s, sampling_rate=FS * pq.Hz))
+block = Block()
+seg = Segment()
+seg.spiketrains = trains
+block.segments.append(seg)
+spike_hash = hashlib.sha1(b"".join(np.asarray(st.magnitude).tobytes() for st in trains)).hexdigest()
+mus = [m for m in range(N_MU) if active[m] and counts[m] > 0]
+if max_mus:
+    mus = mus[:max_mus]
+
+bend = 15 + 4 + 1.29
+pair = SurfaceElectrodeArray(2, 1, 10 * pq.mm, 2.5 * pq.mm, center_point__mm_deg=(20 * pq.mm, 0 * pq.deg),
+                             bending_radius__mm=bend * pq.mm, differentiation_mode="monopolar")
+bip = SurfaceElectrodeArray(1, 1, 10 * pq.mm, 2.5 * pq.mm, center_point__mm_deg=(20 * pq.mm, 0 * pq.deg),
+                            bending_radius__mm=bend * pq.mm, differentiation_mode="bipolar_longitudinal")
+
+
+def run(array):
+    set_random_seed(7)
+    semg = SurfaceEMG(muscle, [array], sampling_frequency__Hz=FS * pq.Hz, MUs_to_simulate=mus,
+                      internal_sampling_frequency__Hz=FS * pq.Hz)
+    t0 = time.time()
+    muaps = semg.simulate_muaps(n_jobs=n_jobs, verbose=False, use_gpu=False)
+    sig0 = muaps.groups[0].segments[mus[0]].analogsignals[0]
+    templates = np.array([np.asarray(signal_to_grid(muaps.groups[0].segments[m].analogsignals[0].rescale(pq.mV)))
+                          for m in mus])
+    emg = semg.simulate_surface_emg(block, verbose=False).groups[0].segments[0].analogsignals[0]
+    return dict(muaps=templates, muap_fs=float(sig0.sampling_rate.rescale(pq.Hz).magnitude),
+                emg=np.asarray(signal_to_grid(emg.rescale(pq.mV))), fs=float(emg.sampling_rate.rescale(pq.Hz).magnitude),
+                seconds=time.time() - t0)
+
+
+p, b = run(pair), run(bip)
+np.savez(out, label=label, myogen=myogen.__file__, mus=mus, counts=counts, rte=rte, skin=skin, density=density,
+         fibre_hash=fibre_hash, spike_hash=spike_hash, duration=DURATION, ramp=RAMP, hold=HOLD, level=LEVEL,
+         spike_times=np.array([np.asarray(trains[m].magnitude) for m in range(N_MU)], dtype=object),
+         pair_muaps=p["muaps"], pair_muap_fs=p["muap_fs"], pair_emg=p["emg"], fs=p["fs"],
+         bip_muaps=b["muaps"], bip_emg=b["emg"], allow_pickle=True)
+print(label, "density", density, "fibres total", int(counts.sum()), "simulated MUs", len(mus),
+      "fibres simulated", int(counts[mus].sum()), "skin", skin, "secs", round(p["seconds"]), round(b["seconds"]),
+      "fibre", fibre_hash[:10], "spikes", spike_hash[:10], flush=True)
diff --git a/benchmarks/semg_versions/plot_real.py b/benchmarks/semg_versions/plot_real.py
new file mode 100644
index 00000000..b56186a1
--- /dev/null
+++ b/benchmarks/semg_versions/plot_real.py
@@ -0,0 +1,173 @@
+"""Finished sEMG recordings (old = main, new = fixed) through one recording chain."""
+import sys
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+from matplotlib.backends.backend_pdf import PdfPages  # noqa: E402
+from scipy.signal import butter, sosfiltfilt, welch  # noqa: E402
+
+here = Path(sys.argv[1])
+O = dict(np.load(here / "old.npz", allow_pickle=True))
+N = dict(np.load(here / "new.npz", allow_pickle=True))
+for key in ("fibre_hash", "spike_hash"):
+    assert str(O[key]) == str(N[key]), key
+assert list(O["mus"]) == list(N["mus"])
+FS = float(N["fs"])
+CO, CN = "#c0392b", "#1f5fa8"
+NOISE_UV = 3.0
+SOS = butter(4, [20, 450], btype="bandpass", fs=FS, output="sos")
+
+
+def finish(x_mV, seed):
+    """Amplifier noise (same realisation for both versions) + 20-450 Hz band-pass; returns uV."""
+    noise = np.random.default_rng(seed).normal(0, NOISE_UV, len(x_mV))
+    return sosfiltfilt(SOS, x_mV * 1e3 + noise)
+
+
+def channels(D):
+    pair = D["pair_emg"][:, :, 0]
+    return dict(bip=finish(D["bip_emg"][:, 0, 0], 1), diff=finish(pair[:, 1] - pair[:, 0], 1),
+                mono=finish(pair[:, 0], 2))
+
+
+CO_, CN_ = channels(O), channels(N)
+t = np.arange(len(CN_["bip"])) / FS
+ramp, hold = float(N["ramp"]), float(N["hold"])
+plateau = (t > 0.5 + ramp + 0.5) & (t < 0.5 + ramp + hold - 0.5)
+
+
+def rms(x):
+    return float(np.sqrt(np.mean(x[plateau] ** 2)))
+
+
+def mnf_mdf(x):
+    f, p = welch(x[plateau], fs=FS, nperseg=1024)
+    band = (f >= 20) & (f <= 450)
+    f, p = f[band], p[band]
+    c = np.cumsum(p)
+    return float(np.sum(f * p) / np.sum(p)), float(f[np.searchsorted(c, c[-1] / 2)])
+
+
+def excitation(tt):
+    tt = tt - 0.5
+    return float(N["level"]) * np.clip(np.minimum(tt / ramp, (2 * ramp + hold - tt) / ramp), 0, 1)
+
+
+pdf = PdfPages(here / "semg_realistic_old_vs_new.pdf")
+
+
+def save(fig, name):
+    pdf.savefig(fig)
+    fig.savefig(here / f"{name}.png", dpi=150)
+    plt.close(fig)
+
+
+n_active = sum(len(s) > 0 for s in N["spike_times"])
+setup = (f"VL-like cylinder: r = 15 mm, bone 3 mm, fat 4 mm, skin 1.29 mm; 100 MUs, {int(N['counts'].sum())} fibres "
+         f"({float(N['density']):.0f}/mm²), 70 mm fibres, CV 4.2 m/s. Ramp to 30 % MVC (Fuglevand rate coding), "
+         f"{n_active} MUs active.\nBipolar 5 mm contacts, IED 10 mm, centred 20 mm from the end-plate band. Chain: "
+         f"+{NOISE_UV:.0f} µV RMS noise (same realisation), 4th-order 20–450 Hz zero-phase band-pass, 2048 Hz. "
+         f"Skin σ: old {float(O['skin']):.2g} S/m, new {float(N['skin']):.2g} S/m (each version's default).")
+
+# ---- page 1: whole contraction ---------------------------------------------------
+fig, axs = plt.subplots(4, 1, figsize=(11.7, 8.3), sharex=True, gridspec_kw=dict(height_ratios=[0.8, 2, 2, 2]))
+fig.suptitle("Finished bipolar sEMG, same muscle, spikes, electrodes and recording chain", fontsize=13)
+ax = axs[0]
+ax.plot(t, excitation(t) * 100, color="k")
+ax.set_ylabel("excitation\n% max", fontsize=8)
+spk = np.concatenate([np.asarray(s, float) for s in N["spike_times"]])
+ax2 = ax.twinx()
+ax2.hist(spk, bins=np.arange(0, t[-1], 0.1), color="0.7", alpha=0.6)
+ax2.set_ylabel("spikes / 100 ms", fontsize=8)
+for ax, x, c, title in ((axs[1], CO_["bip"], CO, "OLD (main): bipolar channel as MyoGen outputs it"),
+                        (axs[2], CO_["diff"], CO, "OLD (main): difference of the two monopolar contacts"),
+                        (axs[3], CN_["bip"], CN, "NEW (fixed): bipolar channel")):
+    ax.plot(t, x, color=c, lw=0.4)
+    ax.set_ylabel("µV")
+    ax.set_title(f"{title}   — plateau RMS {rms(x):,.1f} µV", fontsize=10, loc="left")
+axs[-1].set_xlabel("time (s)")
+fig.text(0.01, 0.005, setup, fontsize=7)
+fig.tight_layout(rect=(0, 0.06, 1, 0.96))
+save(fig, "r1_contraction")
+
+# ---- page 2: 300 ms zoom ------------------------------------------------------------
+z = (t >= 4.0) & (t <= 4.3)
+fig, axs = plt.subplots(3, 1, figsize=(11.7, 8.3), sharex=True)
+fig.suptitle("300 ms of the 30 % MVC plateau (each panel on its own scale)", fontsize=13)
+for ax, x, c, title in ((axs[0], CO_["bip"], CO, "OLD bipolar channel: only the 3 µV amplifier noise survives (P1)"),
+                        (axs[1], CO_["diff"], CO, "OLD, difference of monopolar contacts: MUAPs ~2× too short, amplitude in mV"),
+                        (axs[2], CN_["bip"], CN, "NEW bipolar channel")):
+    ax.plot(t[z], x[z], color=c, lw=0.8)
+    ax.set_ylabel("µV")
+    ax.set_title(title, fontsize=10, loc="left")
+axs[-1].set_xlabel("time (s)")
+fig.tight_layout(rect=(0, 0, 1, 0.95))
+save(fig, "r2_zoom")
+
+# ---- page 3: spectra ------------------------------------------------------------------
+fig, axs = plt.subplots(1, 2, figsize=(11.7, 5.5))
+fig.suptitle("Plateau power spectra after the recording chain", fontsize=13)
+for x, c, lab in ((CO_["diff"], CO, "old, monopolar difference"), (CN_["bip"], CN, "new, bipolar")):
+    f, p = welch(x[plateau], fs=FS, nperseg=1024)
+    mnf, mdf = mnf_mdf(x)
+    axs[0].semilogy(f, p, color=c, label=f"{lab}: MNF {mnf:.0f} Hz, MDF {mdf:.0f} Hz")
+    axs[1].plot(f, p / p.max(), color=c, label=lab)
+    axs[1].axvline(mnf, color=c, ls="--", lw=0.8)
+f, p = welch(CO_["bip"][plateau], fs=FS, nperseg=1024)
+axs[0].semilogy(f, p, color=CO, ls=":", label="old, bipolar channel (noise only)")
+axs[0].set_ylabel("PSD (µV²/Hz)")
+axs[1].set_ylabel("normalised PSD")
+for ax in axs:
+    ax.set_xlim(0, 500)
+    ax.set_xlabel("frequency (Hz)")
+    ax.legend(fontsize=8)
+fig.tight_layout(rect=(0, 0, 1, 0.93))
+save(fig, "r3_spectra")
+
+# ---- page 4: MUAP templates --------------------------------------------------------------
+mus, counts = [int(m) for m in N["mus"]], N["counts"]
+order = np.argsort([counts[m] for m in mus])
+picks = [order[0], order[len(order) // 2], order[-1]]
+fig, axs = plt.subplots(2, 3, figsize=(11.7, 7))
+fig.suptitle("Bipolar MUAP templates (MyoGen output before the recording chain)", fontsize=13)
+for col, k in enumerate(picks):
+    for row, (D, c, name, key) in enumerate(((O, CO, "old: monopolar difference", "diff"), (N, CN, "new: bipolar", "bip"))):
+        ax = axs[row, col]
+        if key == "diff":
+            m = (D["pair_muaps"][k][:, 1, 0] - D["pair_muaps"][k][:, 0, 0]) * 1e3
+        else:
+            m = D["bip_muaps"][k][:, 0, 0] * 1e3
+        fs = float(D["pair_muap_fs"])
+        tm = (np.arange(len(m)) - len(m) // 2) / fs * 1e3
+        ax.plot(tm, m, color=c)
+        ax.set_xlim(-5, 20)
+        ax.set_title(f"{name} — MU {mus[k]} ({int(counts[mus[k]])} fibres)\nPtP {np.ptp(m):,.1f} µV", fontsize=9)
+        ax.set_xlabel("ms from firing")
+        ax.set_ylabel("µV")
+fig.tight_layout(rect=(0, 0, 1, 0.94))
+save(fig, "r4_muaps")
+
+# ---- page 5: numbers -------------------------------------------------------------------------
+fig = plt.figure(figsize=(11.7, 5))
+fig.suptitle("Plateau summary (after noise + 20–450 Hz band-pass)", fontsize=13)
+ax = fig.add_axes([0.05, 0.25, 0.9, 0.6])
+ax.axis("off")
+rows = []
+for name, x in (("old: bipolar channel", CO_["bip"]), ("old: monopolar difference", CO_["diff"]),
+                ("old: monopolar", CO_["mono"]), ("new: bipolar channel", CN_["bip"]),
+                ("new: monopolar difference", CN_["diff"]), ("new: monopolar", CN_["mono"])):
+    mnf, mdf = mnf_mdf(x)
+    rows.append([name, f"{rms(x):,.1f}", f"{np.ptp(x[plateau]):,.0f}", f"{mnf:.0f}", f"{mdf:.0f}"])
+tab = ax.table(cellText=rows, colLabels=["signal", "RMS µV", "PtP µV", "MNF Hz", "MDF Hz"], loc="center",
+               cellLoc="center")
+tab.auto_set_font_size(False)
+tab.set_fontsize(9)
+tab.scale(1, 1.6)
+fig.text(0.05, 0.08, setup, fontsize=7.5)
+save(fig, "r5_summary")
+pdf.close()
+for r in rows:
+    print(r)
diff --git a/examples/01_basic/01_simulate_recruitment_thresholds.py b/examples/01_basic/01_simulate_recruitment_thresholds.py
index 9d67536b..cf27138b 100644
--- a/examples/01_basic/01_simulate_recruitment_thresholds.py
+++ b/examples/01_basic/01_simulate_recruitment_thresholds.py
@@ -13,7 +13,7 @@
 
 * **Fuglevand** model: Classic exponential distribution (*Fuglevand et al., 1993*)
 * **De Luca** model: Slope-corrected exponential distribution (*De Luca & Contessa, 2012*)
-* **Konstantin** model: Exponential with explicit maximum threshold control (*Konstantin et al., 2020*)
+* **Konstantin** model: Exponential with explicit maximum threshold control (*Akhmadeev et al., 2020*; the mode is named after the first author's given name, Konstantin)
 * **Combined** model: Hybrid approach combining De Luca shape with Konstantin scaling (*Ours*)
 """
 
diff --git a/myogen/simulator/core/emg/fiber_simulation.py b/myogen/simulator/core/emg/fiber_simulation.py
index 8272fc8d..b7b6e7e2 100644
--- a/myogen/simulator/core/emg/fiber_simulation.py
+++ b/myogen/simulator/core/emg/fiber_simulation.py
@@ -471,7 +471,7 @@ def simulate_fiber_hybrid(
     k_theta_diff = k_theta[1] - k_theta[0]
     k_z_diff = k_z[1] - k_z[0]
 
-    B_kz = np.zeros((channels[0], channels[1], len(k_z)))
+    B_kz = np.zeros((channels[0], channels[1], len(k_z)), dtype=complex)
     for ch_z in range(channels[0]):
         for ch_theta in range(channels[1]):
             arg_int = np.multiply(
diff --git a/myogen/simulator/core/emg/intramuscular/intramuscular_emg.py b/myogen/simulator/core/emg/intramuscular/intramuscular_emg.py
index 48fc34d3..468ae26a 100644
--- a/myogen/simulator/core/emg/intramuscular/intramuscular_emg.py
+++ b/myogen/simulator/core/emg/intramuscular/intramuscular_emg.py
@@ -38,6 +38,7 @@
 except (ImportError, Exception):
     HAS_CUPY = False
 
+from ..nerve_branches import NMJ_SCHEDULE_COEFFICIENTS, nmj_branch_schedule
 from .motor_unit_sim import MotorUnitSim
 
 
@@ -66,13 +67,17 @@ class IntramuscularEMG:
         By default, the endplate is located at the center of the muscle (50% of the muscle length).
     nmj_jitter__s : Quantity__s, default=35e-6 * pq.s
         Standard deviation of neuromuscular junction jitter in seconds.
-        Default is set to 35e-6 s as determined by Konstantin et al. 2020 [1].
+        Default is set to 35e-6 s as determined by Akhmadeev et al. 2020 [1].
     branch_cvs__m_per_s : tuple[Quantity__m_per_s, Quantity__m_per_s], default=(5.0 * pq.m / pq.s, 2.0 * pq.m / pq.s)
         Conduction velocities for the two-layer model of the neuromuscular junction in m/s.
-        Default is set to (5.0, 2.0) m/s as determined by Konstantin et al. 2020 [1].
+        Default is set to (5.0, 2.0) m/s as determined by Akhmadeev et al. 2020 [1].
 
         Note: The two-layer model is a simplification of the actual arborization pattern, but it is a good approximation for the purposes of this simulation.
-        Follows the implementation of Konstantin et al. 2020 [1].
+        Follows the implementation of Akhmadeev et al. 2020 [1].
+    nmj_coefficients : {"published", "reference_code"}, default="published"
+        z spreads of the two-layer end-plate model: the values printed in
+        Akhmadeev et al. 2020 [1], eq. 5-6, or those of their reference simulator
+        code (1.5-2 times wider; the default up to 0.13.0).
     MUs_to_simulate : list[int], optional
         Indices of motor units to simulate. If None, all motor units are simulated.
         Default is None. For computational efficiency, consider
@@ -92,7 +97,7 @@ class IntramuscularEMG:
 
     References
     ----------
-    [1] Konstantin, A., Yu, T., Le Carpentier, E., Aoustin, Y., Farina, D., 2020. Simulation of Motor Unit Action Potential Recordings From Intramuscular Multichannel Scanning Electrodes. IEEE Transactions on Biomedical Engineering 67, 2005–2014. https://doi.org/10.1109/TBME.2019.2953680
+    [1] Akhmadeev, K., Yu, T., Le Carpentier, E., Aoustin, Y., Farina, D., 2020. Simulation of Motor Unit Action Potential Recordings From Intramuscular Multichannel Scanning Electrodes. IEEE Transactions on Biomedical Engineering 67, 2005–2014. https://doi.org/10.1109/TBME.2019.2953680
     """
 
     def __init__(
@@ -108,7 +113,10 @@ def __init__(
             2.0 * pq.m / pq.s,
         ),
         MUs_to_simulate: list[int] | None = None,
+        nmj_coefficients: str = "published",
     ):
+        if nmj_coefficients not in NMJ_SCHEDULE_COEFFICIENTS:
+            raise ValueError(f"nmj_coefficients must be one of {tuple(NMJ_SCHEDULE_COEFFICIENTS)}")
         # Immutable public arguments - never modify these
         self.muscle_model = muscle_model
         self.electrode_array = electrode_array
@@ -118,6 +126,7 @@ def __init__(
         self.nmj_jitter__s = nmj_jitter__s
         self.branch_cvs__m_per_s = branch_cvs__m_per_s
         self.MUs_to_simulate = MUs_to_simulate
+        self.nmj_coefficients = nmj_coefficients
 
         # Private copies for internal modifications (extract magnitudes)
         self._muscle_model = muscle_model
@@ -267,33 +276,25 @@ def _simulate_neuromuscular_junctions(self, verbose: bool = True) -> None:
         """
         Simulate neuromuscular junction distributions for all motor units.
 
-        This implements the logic from s08_cl_init_muaps.m for generating
-        realistic NMJ branch patterns with size-dependent complexity.
+        Two-layer branch model of Akhmadeev et al. (2020) with the z spreads of
+        their eq. 5-6, growing with motor-unit size.
         """
         if not self._motor_units:
             raise ValueError("Must call _initialize_motor_units() first")
 
-        n_branches = 1 + np.round(
-            np.log(
-                self._muscle_model.recruitment_thresholds
-                / self._muscle_model.recruitment_thresholds[0]
-            )
+        n_branches, branches_z_std, arborization_z_std = nmj_branch_schedule(
+            self._muscle_model.recruitment_thresholds, self.nmj_coefficients
         )
 
         for mu_idx, mu_sim in enumerate(
             tqdm(self._motor_units, desc="Setting up NMJ distributions", unit="Simulator", disable=not verbose)
         ):
-            spread_factor = np.sum(self._muscle_model.recruitment_thresholds[:mu_idx]) / np.sum(
-                self._muscle_model.recruitment_thresholds
-            )
-
-            # Create NMJ distribution
             # Branch spread increases with motor unit size
             mu_sim.sim_nmj_branches_two_layers(
                 n_branches=int(n_branches[mu_idx]),
                 endplate_center=self._endplate_center__mm,
-                branches_z_std=1.5 + spread_factor * 4.0,
-                arborization_z_std=0.5 + spread_factor * 1.5,
+                branches_z_std=float(branches_z_std[mu_idx]),
+                arborization_z_std=float(arborization_z_std[mu_idx]),
             )
 
     def _calculate_muaps(self, n_jobs: int = -2, verbose: bool = True) -> INTRAMUSCULAR_MUAP__Block:
diff --git a/myogen/simulator/core/emg/intramuscular/motor_unit_sim.py b/myogen/simulator/core/emg/intramuscular/motor_unit_sim.py
index 694828ca..86ab3af8 100644
--- a/myogen/simulator/core/emg/intramuscular/motor_unit_sim.py
+++ b/myogen/simulator/core/emg/intramuscular/motor_unit_sim.py
@@ -13,7 +13,6 @@
 from typing import Optional, List
 
 import numpy as np
-from sklearn.cluster import KMeans
 from tqdm import tqdm
 
 try:
@@ -25,6 +24,7 @@
 
 from myogen import derive_subseed, get_random_generator
 from myogen.utils.decorators import beartowertype
+from ..nerve_branches import two_layer_nmj
 from .bioelectric import (
     get_current_density,
     get_elementary_current_response,
@@ -139,60 +139,22 @@ def sim_nmj_branches_two_layers(
         arborization_z_std : float
             Standard deviation of secondary arborization in mm
         """
-        rng = get_random_generator()
-
-        self.nerve_paths = np.zeros(
-            (self._number_of_muscle_fibers, 2)
-        )  # Point coordinates
-
-        kmeans = KMeans(
-            n_clusters=n_branches, init="k-means++", max_iter=100, random_state=derive_subseed(n_branches)
-        )
-        idx = kmeans.fit_predict(self.muscle_fiber_centers__mm)
-        c = kmeans.cluster_centers_
-
-        self.branch_points_xy = c
-        self.branch_points_z = endplate_center + branches_z_std * rng.standard_normal(
-            size=(n_branches, 1)
-        )
-
-        self._neuromuscular_z_coordinates__mm = np.array(
-            [
-                self.branch_points_z[idx[i]]
-                + arborization_z_std * rng.standard_normal()
-                for i in range(self._number_of_muscle_fibers)
-            ]
+        nmj_z, self.nerve_paths, branch_xy, branch_z, _ = two_layer_nmj(
+            self.muscle_fiber_centers__mm,
+            n_branches,
+            endplate_center,
+            branches_z_std,
+            arborization_z_std,
+            rng=get_random_generator(),
+            kmeans_seed=derive_subseed(n_branches),
+            return_branches=True,
         )
-
+        self.branch_points_xy = branch_xy
+        self.branch_points_z = branch_z
+        self._neuromuscular_z_coordinates__mm = nmj_z[:, None]
         self._actual_center = np.concatenate(
-            [
-                np.mean(self.muscle_fiber_centers__mm, axis=0),
-                np.mean(self._neuromuscular_z_coordinates__mm, axis=0),
-            ]
+            [np.mean(self.muscle_fiber_centers__mm, axis=0), [np.mean(nmj_z)]]
         )[None]
-        for i in range(self._number_of_muscle_fibers):
-            cluster_center = np.concatenate(
-                [
-                    self.branch_points_xy[idx[i]],
-                    self.branch_points_z[idx[i]],
-                ]
-            )[None]
-            nmj_coordinates = np.concatenate(
-                [
-                    self.muscle_fiber_centers__mm[i],
-                    self._neuromuscular_z_coordinates__mm[i],
-                ]
-            )[None]
-
-            # Extract scalar from the (1,)-shape norm result via .item() so the
-            # assignment to a 0-D slot doesn't trigger the numpy 1.25 ndim>0
-            # deprecation (float() of a (1,)-shape array hits the same path).
-            self.nerve_paths[i, 0] = np.linalg.norm(
-                self._actual_center - cluster_center, axis=-1
-            ).item()
-            self.nerve_paths[i, 1] = np.linalg.norm(
-                nmj_coordinates - cluster_center, axis=-1
-            ).item()
 
         # Calculate delays
         # self._calculate_nmj_delays()
diff --git a/myogen/simulator/core/emg/nerve_branches.py b/myogen/simulator/core/emg/nerve_branches.py
new file mode 100644
index 00000000..2a0a5763
--- /dev/null
+++ b/myogen/simulator/core/emg/nerve_branches.py
@@ -0,0 +1,88 @@
+"""Two-layer motor-nerve branching model (Akhmadeev et al. 2020).
+
+Single authority for where a motor unit's end-plates sit along its fibres and
+how far the action potential travels along the axon branches to reach them.
+Used by intramuscular EMG (``MotorUnitSim``) and surface EMG.
+
+Each motor unit's fibres are grouped into ``n_branches`` primary branches
+(k-means on the fibre cross-section positions). A branch point sits at
+``endplate_center + N(0, branches_z_std)``; each fibre's end-plate sits at its
+branch point's z plus ``N(0, arborization_z_std)``. The nerve path to a fibre
+is the distance from the motor unit's centre to its branch point (first layer)
+plus the distance from the branch point to the end-plate (second layer).
+"""
+from __future__ import annotations
+
+import numpy as np
+from sklearn.cluster import KMeans
+
+
+# (branch intercept, branch slope, arborisation intercept, arborisation slope), mm.
+# "reference_code": Akhmadeev's reference simulator (iemg_simulator, s08_cl_init_muaps.m).
+# "published": Akhmadeev et al. 2020, eq. 5-6 (a_mu = 1, b_mu = 2.5, a_sigma = 0.25, b_sigma = 1).
+NMJ_SCHEDULE_COEFFICIENTS = {
+    "reference_code": (1.5, 4.0, 0.5, 1.5),
+    "published": (1.0, 2.5, 0.25, 1.0),
+}
+
+
+def nmj_branch_schedule(
+    recruitment_thresholds: np.ndarray, coefficients: str = "published"
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Branch count and z spreads per motor unit, growing with motor-unit size.
+
+    Returns ``(n_branches, branches_z_std__mm, arborization_z_std__mm)``. The
+    spread factor is the share of total threshold below each unit;
+    ``coefficients`` picks a set from ``NMJ_SCHEDULE_COEFFICIENTS``.
+    """
+    if coefficients not in NMJ_SCHEDULE_COEFFICIENTS:
+        raise ValueError(f"coefficients must be one of {tuple(NMJ_SCHEDULE_COEFFICIENTS)}, got {coefficients!r}")
+    branch_a, branch_b, arbor_a, arbor_b = NMJ_SCHEDULE_COEFFICIENTS[coefficients]
+    thresholds = np.asarray(recruitment_thresholds, dtype=float)
+    n_branches = (1 + np.round(np.log(thresholds / thresholds[0]))).astype(int)
+    spread = np.concatenate([[0.0], np.cumsum(thresholds)[:-1]]) / np.sum(thresholds)
+    return n_branches, branch_a + spread * branch_b, arbor_a + spread * arbor_b
+
+
+def two_layer_nmj(
+    fiber_xy__mm: np.ndarray,
+    n_branches: int,
+    endplate_center__mm: float,
+    branches_z_std__mm: float,
+    arborization_z_std__mm: float,
+    *,
+    rng: np.random.Generator,
+    kmeans_seed: int,
+    return_branches: bool = False,
+):
+    """End-plate z per fibre and the two nerve-path lengths (mm) per fibre.
+
+    Returns ``(nmj_z, nerve_paths)`` with ``nerve_paths[:, 0]`` the motor-unit
+    centre to branch point distance and ``nerve_paths[:, 1]`` the branch point
+    to end-plate distance. With ``return_branches`` the branch points
+    ``(xy, z)`` and each fibre's branch index are appended.
+    """
+    fiber_xy__mm = np.asarray(fiber_xy__mm, dtype=float)
+    n_fibers = len(fiber_xy__mm)
+    kmeans = KMeans(n_clusters=n_branches, init="k-means++", max_iter=100, random_state=kmeans_seed)
+    idx = kmeans.fit_predict(fiber_xy__mm)
+    branch_xy = kmeans.cluster_centers_
+    branch_z = endplate_center__mm + branches_z_std__mm * rng.standard_normal(size=(n_branches, 1))
+    # One scalar draw per fibre, in fibre order (the published draw sequence).
+    nmj_z = np.array([branch_z[idx[i], 0] + arborization_z_std__mm * rng.standard_normal()
+                      for i in range(n_fibers)])
+
+    centre = np.concatenate([np.mean(fiber_xy__mm, axis=0), [np.mean(nmj_z)]])
+    branch = np.column_stack([branch_xy[idx], branch_z[idx, 0]])
+    nmj = np.column_stack([fiber_xy__mm, nmj_z])
+    paths = np.column_stack([np.linalg.norm(centre - branch, axis=1),
+                             np.linalg.norm(nmj - branch, axis=1)])
+    if return_branches:
+        return nmj_z, paths, branch_xy, branch_z, idx
+    return nmj_z, paths
+
+
+def nerve_delays__ms(nerve_paths__mm: np.ndarray, branch_cvs__m_per_s) -> np.ndarray:
+    """Axon-branch conduction time per fibre (ms): sum of path / velocity per layer."""
+    cvs = np.asarray(branch_cvs__m_per_s, dtype=float)  # m/s == mm/ms
+    return np.sum(np.asarray(nerve_paths__mm, dtype=float) / cvs[None, :], axis=1)
diff --git a/myogen/simulator/core/emg/runtime/semg.py b/myogen/simulator/core/emg/runtime/semg.py
index f88332be..81e72d0a 100644
--- a/myogen/simulator/core/emg/runtime/semg.py
+++ b/myogen/simulator/core/emg/runtime/semg.py
@@ -8,7 +8,11 @@
 from myogen import get_random_generator
 from myogen.utils.neo import create_grid_signal
 from ..electrodes import SurfaceElectrodeArray
-from ..surface.simulate_fiber import _simulate_fiber_v2_python
+from ..surface.simulate_fiber import (
+    _simulate_fiber_v2_python,
+    fiber_semi_lengths,
+    muap_sampling_rate__Hz,
+)
 from .session import ExecutionSession
 from .surface_preparation import SurfacePreparation
 from .cache import DiskCache, fingerprint
@@ -24,6 +28,9 @@ def simulate_muaps(owner, policy, n_jobs, verbose, use_gpu):
             raise ValueError("execution=ExecutionPolicy(backend='cpu') contradicts use_gpu=True")
         if owner._use_unified:
             raise ValueError("use_unified=True requires the existing route (execution=None)")
+        dispersion = getattr(owner, "_fiber_dispersion", None)
+        if dispersion is not None and dispersion.active:
+            raise ValueError("fiber_dispersion requires the existing route (execution=None)")
         if any(type(array) is not SurfaceElectrodeArray for array in owner._electrode_arrays):
             raise ValueError("Custom electrodes require the existing route (execution=None)")
         shapes = {(a.num_rows, a.num_cols) for a in owner._electrode_arrays}
@@ -52,8 +59,8 @@ def simulate_muaps(owner, policy, n_jobs, verbose, use_gpu):
         rows, cols = next(iter(shapes))
         shape = (rows, cols, N)
         final_samples = owner._sampling_points_in_t_and_z_domains
-        duration = (kernel_length / 2.0) / owner._mean_conduction_velocity__m_s / 1000
-        rate = (final_samples - 1) / duration
+        rate = muap_sampling_rate__Hz(owner._mean_conduction_velocity__m_s, N, final_samples,
+                                      kernel_length)
         # Source-grid arithmetic retains the original precision and complete
         # N x N grids. Estimate all live complex/native temporaries generously.
         workspace = N * N * 16 * 24 + N * M * 8 * 180 + rows * cols * N * 16 * 4
@@ -67,12 +74,14 @@ def simulate_muaps(owner, policy, n_jobs, verbose, use_gpu):
             radius = float(electrode.electrode_radius__mm.rescale(pq.mm).magnitude)
             preparation = SurfacePreparation()
             dependencies = (
-                "surface-muap-gitlab-fc077-v1", N, M, final_samples, kernel_length, rate,
+                "surface-muap-gitlab-fc077-v4", N, M, final_samples, kernel_length, rate,
                 owner._internal_sampling_frequency__Hz, owner._mean_conduction_velocity__m_s,
                 owner._radius_total, owner._radius_bone__mm,
                 owner._fat_thickness__mm, owner._skin_thickness__mm,
                 owner._muscle_conductivity_radial__S_m, owner._muscle_conductivity_longitudinal__S_m,
                 owner._fat_conductivity__S_m, owner._skin_conductivity__S_m,
+                owner._fiber_diameter__mm, owner._intracellular_conductivity__S_m,
+                owner._iap_lambda__per_mm,
                 vars(electrode), base_z, base_theta, radius,
             )
             results = {}
@@ -94,6 +103,7 @@ def simulate_muaps(owner, policy, n_jobs, verbose, use_gpu):
                 def compute(start, stop):
                     values = np.empty((stop - start, *shape))
                     for local, fibre in enumerate(range(start, stop)):
+                        L1, L2 = fiber_semi_lengths(zone, lengths[fibre])
                         values[local], _, _ = _simulate_fiber_v2_python(
                             Fs=float(owner._internal_sampling_frequency__Hz * 1e-3),
                             v=float(owner._mean_conduction_velocity__m_s),
@@ -101,8 +111,7 @@ def compute(start, stop):
                             r_bone=float(owner._radius_bone__mm),
                             th_fat=float(owner._fat_thickness__mm),
                             th_skin=float(owner._skin_thickness__mm),
-                            R=radial[fibre], L1=abs(zone + lengths[fibre] / 2),
-                            L2=abs(zone - lengths[fibre] / 2), zi=zone,
+                            R=radial[fibre], L1=L1, L2=L2, zi=zone,
                             electrode_array=electrode,
                             sig_muscle_rho=float(owner._muscle_conductivity_radial__S_m),
                             sig_muscle_z=float(owner._muscle_conductivity_longitudinal__S_m),
@@ -112,6 +121,9 @@ def compute(start, stop):
                             theta_offset=-angular[fibre], pos_z_precomputed=base_z,
                             pos_theta_precomputed=base_theta, rele_precomputed=radius,
                             _prepared=preparation,
+                            sig_intracellular=owner._intracellular_conductivity__S_m,
+                            fiber_diameter__mm=owner._fiber_diameter__mm,
+                            iap_lambda__per_mm=owner._iap_lambda__per_mm,
                         )
                         if not np.all(np.isfinite(values[local])):
                             raise FloatingPointError(f"Nonfinite surface fibre in MU {mu_index}")
diff --git a/myogen/simulator/core/emg/surface/fiber_dispersion.py b/myogen/simulator/core/emg/surface/fiber_dispersion.py
new file mode 100644
index 00000000..ec6d2f7e
--- /dev/null
+++ b/myogen/simulator/core/emg/surface/fiber_dispersion.py
@@ -0,0 +1,299 @@
+"""Per-fibre dispersion for surface EMG: end-plates, axon-branch delays, fibre CV.
+
+Every option defaults to off, which reproduces the undispersed model (one
+end-plate per motor unit, no nerve delays, every fibre at the mean conduction
+velocity). The options are independent so that each effect can be measured
+on its own.
+
+End-plates and nerve delays come from MyoGen's two-layer nerve model
+(:mod:`myogen.simulator.core.emg.nerve_branches`), the same one intramuscular
+EMG uses. Draws use generators seeded from ``seed`` only, never the global
+MyoGen generator, so switching an option on leaves every other draw intact.
+"""
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Literal, Optional, Sequence
+
+import numpy as np
+
+from ..nerve_branches import NMJ_SCHEDULE_COEFFICIENTS, nerve_delays__ms, nmj_branch_schedule, two_layer_nmj
+
+NMJ_MODELS = ("uniform_mu", "two_layer", "two_layer_intra")
+
+
+@dataclass(frozen=True)
+class SurfaceFiberDispersion:
+    """Configuration of per-fibre dispersion (all off by default).
+
+    Parameters
+    ----------
+    nmj_model : {"uniform_mu", "two_layer", "two_layer_intra"}
+        ``"uniform_mu"``: every fibre of a motor unit has the unit's end-plate
+        (the undispersed model). ``"two_layer"``: the two-layer nerve model as
+        intramuscular EMG uses it (branch points scattered about the end-plate
+        band centre, fibres scattered about their branch point).
+        ``"two_layer_intra"``: the two-layer scatter re-centred on each unit's
+        undispersed end-plate, isolating the spread within a motor unit.
+    nmj_scatter_scale : float
+        Multiplies both two-layer z spreads (1 = the coefficients as given).
+    nmj_coefficients : {"published", "reference_code"}
+        Two-layer z-spread coefficients: the values printed in Akhmadeev et al.
+        (2020), eq. 5-6 (default, as in intramuscular EMG), or those of
+        Akhmadeev's reference simulator code, 1.5-2 times wider.
+    nerve_delays : bool
+        Delay each fibre by its axon-branch conduction time (two-layer nerve
+        paths over ``nerve_cvs__m_per_s``). Independent of ``nmj_model``: with
+        ``"uniform_mu"`` only the timing changes, not the end-plate positions.
+    nerve_cvs__m_per_s : (float, float)
+        Conduction velocity of the first (axon to branch point) and second
+        (branch point to end-plate) layer. Default (5, 2) m/s as in
+        intramuscular EMG (Akhmadeev et al. 2020).
+    fiber_cv_inter_mu_spread : float
+        Spread of motor-unit mean fibre CV linear in recruitment order: the
+        first-recruited unit propagates at ``mean * (1 - spread / 2)``, the
+        last at ``mean * (1 + spread / 2)``.
+    fiber_cv_threshold_slope : float
+        Motor-unit mean fibre CV linear in recruitment threshold:
+        ``mean * (1 + slope * (rt - mean(rt)))`` with ``rt`` the threshold
+        relative to the largest. Del Vecchio et al. (2017) measured CV rising
+        linearly with recruitment threshold in tibialis anterior (406 units;
+        3.89 m/s at 0-30 % MVC, 5.12 m/s at 50-70 % MVC, overall mean 4.32),
+        about 0.63 of the mean per unit of threshold. Cannot be combined with
+        ``fiber_cv_inter_mu_spread``.
+    fiber_cv_within_mu_cov : float
+        Coefficient of variation of fibre CV within a motor unit (normal,
+        clipped at three standard deviations). No measurement of this spread
+        was found; Del Vecchio et al. (2017) call it unknown.
+    diameter_scales_source : bool
+        Scale each fibre's source by its cross-section, with the diameter read
+        from the CV line ``cv = cv_intercept + cv_per_diameter * d``
+        (Nandedkar & Stålberg 1983: 0.95 m/s + 0.05 m/s per µm), relative to
+        the diameter at the mean CV.
+    cv_per_diameter__m_s_per_mm, cv_intercept__m_s : float
+        Slope and intercept of that line.
+    tendon_end_band__mm : float
+        Width of the band over which each fibre end is placed, independently
+        at either end, uniform about ``±mean_fiber_length / 2``. Replaces the
+        fibre-length variation (which moves both ends together). 0 keeps it.
+    tendon_end_correlation__mm : float
+        Correlation length of the fibre-end position across the cross-section.
+        0 draws every end independently over the band. Above 0, each end
+        follows a smooth Gaussian random field (squared-exponential covariance,
+        one field per tendon) plus ``tendon_end_jitter__mm`` per fibre, with the
+        total SD of the uniform band, ``tendon_end_band__mm / sqrt(12)``.
+    tendon_end_jitter__mm : float
+        SD of each fibre's own offset from the smooth field.
+    seed : int
+        Seed of the dispersion draws.
+    """
+
+    nmj_model: Literal["uniform_mu", "two_layer", "two_layer_intra"] = "uniform_mu"
+    nmj_scatter_scale: float = 1.0
+    nmj_coefficients: str = "published"
+    nerve_delays: bool = False
+    nerve_cvs__m_per_s: tuple[float, float] = (5.0, 2.0)
+    fiber_cv_inter_mu_spread: float = 0.0
+    fiber_cv_threshold_slope: float = 0.0
+    fiber_cv_within_mu_cov: float = 0.0
+    diameter_scales_source: bool = False
+    cv_per_diameter__m_s_per_mm: float = 50.0
+    cv_intercept__m_s: float = 0.95
+    tendon_end_band__mm: float = 0.0
+    tendon_end_correlation__mm: float = 0.0
+    tendon_end_jitter__mm: float = 0.0
+    seed: int = 0
+
+    def __post_init__(self):
+        if self.nmj_model not in NMJ_MODELS:
+            raise ValueError(f"nmj_model must be one of {NMJ_MODELS}, got {self.nmj_model!r}")
+        if self.nmj_coefficients not in NMJ_SCHEDULE_COEFFICIENTS:
+            raise ValueError(f"nmj_coefficients must be one of {tuple(NMJ_SCHEDULE_COEFFICIENTS)}")
+        if self.nmj_scatter_scale < 0:
+            raise ValueError("nmj_scatter_scale must be non-negative")
+        if len(self.nerve_cvs__m_per_s) != 2 or min(self.nerve_cvs__m_per_s) <= 0:
+            raise ValueError("nerve_cvs__m_per_s must be two positive velocities")
+        if not 0 <= self.fiber_cv_inter_mu_spread < 2:
+            raise ValueError("fiber_cv_inter_mu_spread must be in [0, 2)")
+        if min(self.tendon_end_band__mm, self.tendon_end_correlation__mm, self.tendon_end_jitter__mm) < 0:
+            raise ValueError("tendon_end_band__mm, tendon_end_correlation__mm and tendon_end_jitter__mm "
+                             "must be non-negative")
+        if self.tendon_end_correlation__mm > 0:
+            if self.tendon_end_band__mm == 0:
+                raise ValueError("tendon_end_correlation__mm needs tendon_end_band__mm")
+            if self.tendon_end_jitter__mm >= self.tendon_end_band__mm / np.sqrt(12):
+                raise ValueError("tendon_end_jitter__mm must be below the band SD, tendon_end_band__mm / sqrt(12)")
+        if self.fiber_cv_threshold_slope < 0:
+            raise ValueError("fiber_cv_threshold_slope must be non-negative")
+        if self.fiber_cv_threshold_slope and self.fiber_cv_inter_mu_spread:
+            raise ValueError("use either fiber_cv_threshold_slope or fiber_cv_inter_mu_spread, not both")
+        if not 0 <= self.fiber_cv_within_mu_cov < 1 / 3:
+            raise ValueError("fiber_cv_within_mu_cov must be in [0, 1/3)")
+
+    @classmethod
+    def literature_candidate(cls, seed: int = 0) -> "SurfaceFiberDispersion":
+        """Dispersion with each value taken from the literature or marked as an assumption.
+
+        - End-plates: two-layer within each unit, coefficients of Akhmadeev et al.
+          (2020), eq. 5-6.
+        - Nerve branches: 5 / 2 m/s, the ``IntramuscularEMG`` default (Akhmadeev
+          et al. 2020). Within-unit delay SD is about 0.1-0.2 ms in the sweep
+          scenarios of ``benchmarks/semg_dispersion``.
+        - Unit conduction velocity: linear in recruitment threshold, slope 0.63
+          (Del Vecchio et al. 2017).
+        - Fibre velocity within a unit: CoV 5 %. A modelling assumption; no
+          measurement was found.
+        - Tendon ends: 5 mm band (Keenan et al. 2005), correlated over 5 mm with
+          0.3 mm per-fibre jitter (assumptions; no measurement of fibre-end stagger
+          was found).
+        - Diameter-scaled source: off, pending an amplitude check against published
+          ranges.
+        """
+        return cls(nmj_model="two_layer_intra", nmj_scatter_scale=1.0, nmj_coefficients="published",
+                   nerve_delays=True, nerve_cvs__m_per_s=(5.0, 2.0), fiber_cv_threshold_slope=0.63,
+                   fiber_cv_within_mu_cov=0.05, tendon_end_band__mm=5.0, tendon_end_correlation__mm=5.0,
+                   tendon_end_jitter__mm=0.3, seed=seed)
+
+    @property
+    def active(self) -> bool:
+        return (self.nmj_model != "uniform_mu" or self.nerve_delays
+                or self.fiber_cv_inter_mu_spread > 0 or self.fiber_cv_threshold_slope > 0
+                or self.fiber_cv_within_mu_cov > 0
+                or self.diameter_scales_source or self.tendon_end_band__mm > 0)
+
+
+@dataclass
+class FiberDispersionRealization:
+    """Per-motor-unit lists of per-fibre values, and a per-unit summary."""
+
+    zi__mm: list[np.ndarray]
+    cv__m_s: list[np.ndarray]
+    delay__ms: list[np.ndarray]
+    amplitude_scale: list[np.ndarray]
+    end_plus__mm: Optional[list[np.ndarray]] = None
+    end_minus__mm: Optional[list[np.ndarray]] = None
+    report: dict = field(default_factory=dict)
+
+
+def _smooth_field(rng: np.random.Generator, correlation__mm: float, sd__mm: float, n_features: int = 1000):
+    """Gaussian random field over the cross-section with covariance
+    ``sd² exp(-r² / (2 correlation²))``, by random Fourier features."""
+    k = rng.normal(0.0, 1.0 / correlation__mm, size=(n_features, 2))
+    phase = rng.uniform(0.0, 2 * np.pi, size=n_features)
+    weight = sd__mm * np.sqrt(2.0 / n_features)
+    return lambda xy: weight * np.cos(xy @ k.T + phase).sum(axis=1)
+
+
+def realize_fiber_dispersion(
+    config: SurfaceFiberDispersion,
+    fiber_positions__mm: Sequence[np.ndarray],
+    recruitment_thresholds: np.ndarray,
+    mu_zones__mm: np.ndarray,
+    mean_cv__m_s: float,
+    fiber_lengths__mm: Optional[Sequence[np.ndarray]] = None,
+    end_margin__mm: float = 1.0,
+    mean_fiber_length__mm: Optional[float] = None,
+) -> FiberDispersionRealization:
+    """Draw per-fibre end-plate, nerve delay, CV and source scale for every motor unit.
+
+    ``mu_zones__mm`` holds each unit's undispersed end-plate (relative to the
+    fibre centre). With ``fiber_lengths__mm`` given, each fibre's ends sit at
+    ``±length / 2`` (or are drawn in the tendon band, which needs
+    ``mean_fiber_length__mm``), and end-plates are clipped to
+    ``end_margin__mm`` inside the ends with the clipped count reported.
+    """
+    n_mu = len(fiber_positions__mm)
+    counts = np.array([len(p) for p in fiber_positions__mm])
+    nerve_rng = np.random.default_rng([config.seed, 0])
+    cv_rng = np.random.default_rng([config.seed, 1])
+    end_rng = np.random.default_rng([config.seed, 2])
+    band = config.tendon_end_band__mm
+    if band > 0 and (fiber_lengths__mm is None or mean_fiber_length__mm is None):
+        raise ValueError("tendon_end_band__mm needs fiber_lengths__mm and mean_fiber_length__mm")
+    end_fields = None
+    if band > 0 and config.tendon_end_correlation__mm > 0:
+        field_sd = np.sqrt(band**2 / 12 - config.tendon_end_jitter__mm**2)
+        end_fields = [_smooth_field(end_rng, config.tendon_end_correlation__mm, field_sd) for _ in range(2)]
+    needs_nerve = config.nmj_model != "uniform_mu" or config.nerve_delays
+    if needs_nerve:
+        n_branches, branch_sd, arbor_sd = nmj_branch_schedule(recruitment_thresholds, config.nmj_coefficients)
+
+    report = {key: np.full(n_mu, np.nan) for key in (
+        "zi_mean__mm", "zi_sd__mm", "cv_mean__m_s", "cv_cov", "delay_mean__ms", "delay_sd__ms",
+        "amplitude_scale_mean", "diameter_mean__um", "end_sd__mm")}
+    report["n_fibers"] = counts
+    report["n_branches"] = np.zeros(n_mu, dtype=int)
+    report["zi_clipped"] = np.zeros(n_mu, dtype=int)
+    zi_all, cv_all, delay_all, scale_all, plus_all, minus_all = [], [], [], [], [], []
+    rank = np.arange(n_mu) / max(n_mu - 1, 1)
+    rt = np.asarray(recruitment_thresholds, dtype=float)
+    rt = rt / rt.max()
+    threshold_factor = 1 + config.fiber_cv_threshold_slope * (rt - rt.mean())
+    if np.any(threshold_factor <= 0):
+        raise ValueError("fiber_cv_threshold_slope gives a non-positive CV for the first-recruited units")
+    d_mean__um = (mean_cv__m_s - config.cv_intercept__m_s) / config.cv_per_diameter__m_s_per_mm * 1e3
+    if config.diameter_scales_source and d_mean__um <= 0:
+        raise ValueError("the mean CV lies below the CV-diameter intercept")
+    for mu in range(n_mu):
+        n = int(counts[mu])
+        zi = np.full(n, float(mu_zones__mm[mu]))
+        delay = np.zeros(n)
+        if needs_nerve and n:
+            branches = int(min(n_branches[mu], n))
+            report["n_branches"][mu] = branches
+            nmj_z, paths = two_layer_nmj(
+                fiber_positions__mm[mu], branches, 0.0,
+                config.nmj_scatter_scale * branch_sd[mu], config.nmj_scatter_scale * arbor_sd[mu],
+                rng=nerve_rng, kmeans_seed=int(nerve_rng.integers(2**31)))
+            if config.nmj_model == "two_layer":
+                zi = nmj_z
+            elif config.nmj_model == "two_layer_intra":
+                zi = zi + (nmj_z - np.mean(nmj_z))
+            if config.nerve_delays:
+                delay = nerve_delays__ms(paths, config.nerve_cvs__m_per_s)
+        if fiber_lengths__mm is not None:
+            if end_fields is not None:
+                xy = np.asarray(fiber_positions__mm[mu], dtype=float)[:, :2]
+                jitter = config.tendon_end_jitter__mm
+                end_plus = mean_fiber_length__mm / 2 + end_fields[0](xy) + end_rng.normal(0, jitter, size=n)
+                end_minus = -mean_fiber_length__mm / 2 + end_fields[1](xy) + end_rng.normal(0, jitter, size=n)
+            elif band > 0:
+                end_plus = mean_fiber_length__mm / 2 + end_rng.uniform(-band / 2, band / 2, size=n)
+                end_minus = -mean_fiber_length__mm / 2 + end_rng.uniform(-band / 2, band / 2, size=n)
+            else:
+                end_plus = np.asarray(fiber_lengths__mm[mu]) / 2
+                end_minus = -np.asarray(fiber_lengths__mm[mu]) / 2
+            clipped = np.clip(zi, end_minus + end_margin__mm, end_plus - end_margin__mm)
+            report["zi_clipped"][mu] = int(np.count_nonzero(clipped != zi))
+            zi = clipped
+            plus_all.append(end_plus)
+            minus_all.append(end_minus)
+            if n:
+                report["end_sd__mm"][mu] = np.std(end_plus)
+
+        cv_mu = mean_cv__m_s * threshold_factor[mu] * (1 - config.fiber_cv_inter_mu_spread / 2
+                                                       + config.fiber_cv_inter_mu_spread * rank[mu])
+        cov = config.fiber_cv_within_mu_cov
+        if cov > 0:
+            cv = np.clip(cv_rng.normal(cv_mu, cov * cv_mu, size=n), cv_mu * (1 - 3 * cov), cv_mu * (1 + 3 * cov))
+        else:
+            cv = np.full(n, cv_mu)
+        diameter__um = (cv - config.cv_intercept__m_s) / config.cv_per_diameter__m_s_per_mm * 1e3
+        if config.diameter_scales_source:
+            scale = (diameter__um / d_mean__um) ** 2
+        else:
+            scale = np.ones(n)
+
+        zi_all.append(zi)
+        cv_all.append(cv)
+        delay_all.append(delay)
+        scale_all.append(scale)
+        if n:
+            report["zi_mean__mm"][mu], report["zi_sd__mm"][mu] = np.mean(zi), np.std(zi)
+            report["cv_mean__m_s"][mu], report["cv_cov"][mu] = np.mean(cv), np.std(cv) / np.mean(cv)
+            report["delay_mean__ms"][mu], report["delay_sd__ms"][mu] = np.mean(delay), np.std(delay)
+            report["amplitude_scale_mean"][mu] = np.mean(scale)
+            report["diameter_mean__um"][mu] = np.mean(diameter__um)
+    report["config"] = asdict(config)
+    ends = (plus_all, minus_all) if fiber_lengths__mm is not None else (None, None)
+    return FiberDispersionRealization(zi_all, cv_all, delay_all, scale_all, *ends, report=report)
diff --git a/myogen/simulator/core/emg/surface/simulate_fiber.py b/myogen/simulator/core/emg/surface/simulate_fiber.py
index 89a6f6b7..d0849cbb 100644
--- a/myogen/simulator/core/emg/surface/simulate_fiber.py
+++ b/myogen/simulator/core/emg/surface/simulate_fiber.py
@@ -101,6 +101,68 @@ def f_minus_t(y):
     return y[::-1].copy()
 
 
+def fiber_semi_lengths(innervation_zone__mm: float, fiber_length__mm: float) -> tuple[float, float]:
+    """Return ``(L1, L2)`` for a fibre centred on z = 0 with its end-plate at ``zi``.
+
+    In the source term (Farina et al. 2004, eq. 1) ``L1`` is the semi-length
+    towards +z and ``L2`` towards -z, so the fibre spans ``[zi - L2, zi + L1]``.
+    Keeping the tendons at ``±fiber_length / 2`` gives ``L1 = l/2 - zi`` and
+    ``L2 = l/2 + zi``.
+    """
+    L1 = fiber_length__mm / 2 - innervation_zone__mm
+    L2 = fiber_length__mm / 2 + innervation_zone__mm
+    if L1 <= 0 or L2 <= 0:
+        raise ValueError(
+            f"End-plate at {innervation_zone__mm} mm lies outside a fibre of length {fiber_length__mm} mm"
+        )
+    return L1, L2
+
+
+def _source_spectrum(psi: np.ndarray, dz: float, stretch: float) -> np.ndarray:
+    """IAP spectrum for a fibre at ``v = v_grid / stretch`` on the ``v_grid`` time grid.
+
+    ``psi`` is sampled on the symmetric grid ``z_n = (n - (N-1)/2) dz``. Column
+    ``m`` (wavenumber ``k_m`` of the centred FFT grid) needs the spectrum at
+    ``k_m * stretch``; the phase stays referred to the grid's first sample at
+    ``k_m`` so that, as on the fibre's own grid, the firing instant is the
+    window centre. ``stretch == 1`` gives ``fftshift(fft(psi)) * dz``.
+    """
+    n = len(psi)
+    k = 2 * math.pi * np.fft.fftshift(np.fft.fftfreq(n, d=dz))
+    support = np.nonzero(psi)[0]
+    z = (support - (n - 1) / 2) * dz
+    spectrum = (np.exp(-1j * np.outer(k * stretch, z)) @ psi[support]) * dz
+    return spectrum * np.exp(-1j * k * (n - 1) / 2 * dz)
+
+
+def delay_fibre_signal(phi: np.ndarray, delay__ms: float, fs__kHz: float) -> np.ndarray:
+    """Delay ``phi`` along its last (time) axis by ``delay__ms``, allowing fractions of a sample.
+
+    Applied as a linear phase in the frequency domain, i.e. a circular shift:
+    the window must leave room for the delayed signal. Zero delay returns
+    ``phi`` unchanged.
+    """
+    if delay__ms == 0:
+        return phi
+    n = phi.shape[-1]
+    f__kHz = np.fft.rfftfreq(n, d=1.0 / fs__kHz)
+    return np.fft.irfft(np.fft.rfft(phi, axis=-1) * np.exp(-2j * np.pi * f__kHz * delay__ms), n=n, axis=-1)
+
+
+def muap_sampling_rate__Hz(
+    conduction_velocity__m_s: float, internal_points: int, output_points: int, kernel_length__mm: float
+) -> float:
+    """Sampling rate of a fibre window resampled from ``internal_points`` to ``output_points``.
+
+    The internal window has ``internal_points`` samples at
+    ``Fs_eff = v * (N - 1) / kernel_length`` (see ``_simulate_fiber_v2_python``),
+    i.e. a period of ``N / Fs_eff``. Periodic (Fourier) resampling keeps that
+    period, so the output rate is ``output_points * Fs_eff / N``.
+    """
+    fs_effective__kHz = conduction_velocity__m_s * (internal_points - 1) / kernel_length__mm
+    return output_points * fs_effective__kHz / internal_points * 1e3
+
+
 # Numba-optimized helper functions for simulate_fiber_v3
 def _get_numba_functions():
     """Get Numba-optimized functions if available, otherwise return None."""
@@ -119,24 +181,32 @@ def _compute_B_kz_fast(
         len_kz,
         len_ktheta,
     ):
-        """Numba-optimized computation of B_kz matrix."""
-        B_kz = np.zeros((channels_0, channels_1, len_kz))
+        """Numba-optimized computation of the complex B_kz matrix (Farina 2004, eq. 5).
+
+        B_kz is complex in general: a longitudinal bipolar filter is purely
+        imaginary, so its whole signal lives in the imaginary part.
+        """
+        B_kz = np.zeros((channels_0, channels_1, len_kz), dtype=np.complex128)
 
         for channel_z in prange(channels_0):
             for channel_theta in prange(channels_1):
                 pos_theta_val = pos_theta[channel_z, channel_theta]
                 for i in range(len_kz):
                     sum_real = 0.0
+                    sum_imag = 0.0
                     for j in range(len_ktheta):
                         phase = pos_theta_val * ktheta_mesh_kzktheta[i, j]
                         cos_phase = math.cos(phase)
                         sin_phase = math.sin(phase)
 
                         # Complex multiplication: H_glo * exp(1j * phase)
-                        result_real = H_glo_real[i, j] * cos_phase - H_glo_imag[i, j] * sin_phase
-                        sum_real += result_real
+                        sum_real += H_glo_real[i, j] * cos_phase - H_glo_imag[i, j] * sin_phase
+                        sum_imag += H_glo_real[i, j] * sin_phase + H_glo_imag[i, j] * cos_phase
 
-                    B_kz[channel_z, channel_theta, i] = sum_real * k_theta_diff / (2 * math.pi)
+                    B_kz[channel_z, channel_theta, i] = complex(
+                        sum_real * k_theta_diff / (2 * math.pi),
+                        sum_imag * k_theta_diff / (2 * math.pi),
+                    )
 
         return B_kz
 
@@ -144,7 +214,8 @@ def _compute_B_kz_fast(
     def _compute_phi_fast(
         I_kzkt_real,
         I_kzkt_imag,
-        B_kz,
+        B_kz_real,
+        B_kz_imag,
         pos_z,
         kz_mesh_kzkt,
         channels_0,
@@ -166,9 +237,10 @@ def _compute_phi_fast(
 
                     for i in range(len_kz):
                         # I_kzkt[i, j] * B_kz[channel_z, channel_theta, i]
-                        B_val = B_kz[channel_z, channel_theta, i]
-                        arg_real = I_kzkt_real[i, j] * B_val
-                        arg_imag = I_kzkt_imag[i, j] * B_val
+                        B_re = B_kz_real[channel_z, channel_theta, i]
+                        B_im = B_kz_imag[channel_z, channel_theta, i]
+                        arg_real = I_kzkt_real[i, j] * B_re - I_kzkt_imag[i, j] * B_im
+                        arg_imag = I_kzkt_real[i, j] * B_im + I_kzkt_imag[i, j] * B_re
 
                         # arg * exp(1j * pos_z * kz_mesh_kzkt[i, j])
                         phase = pos_z_val * kz_mesh_kzkt[i, j]
@@ -225,6 +297,11 @@ def _simulate_fiber_v2_python(
     pos_theta_precomputed: np.ndarray | None = None,
     rele_precomputed: float | None = None,
     _prepared=None,
+    *,
+    sig_intracellular: float = 1.01,
+    fiber_diameter__mm: float = 0.05,
+    v_grid: float | None = None,
+    iap_lambda__per_mm: float = 1.0,
 ):
     """
     Simulate a single fiber (Python implementation).
@@ -284,10 +361,27 @@ def _simulate_fiber_v2_python(
         **Recommended**: Set this explicitly (e.g., 50-100 mm for typical motor units)
         to ensure MUAP duration is physically accurate and independent of N.
 
-        The actual MUAP duration will be approximately: fiber_length__mm / (2 * v) ms
-        (factor of 2 due to internal scaling for Rosenfalck model).
-
-        Example: fiber_length__mm=100 with v=4 m/s → ~12.5 ms MUAP duration.
+        The returned window spans fiber_length__mm / v ms (``N`` samples at
+        ``v * (N - 1) / fiber_length__mm`` kHz), with the fibre's firing
+        instant at sample ``N // 2``. See :func:`muap_sampling_rate__Hz`.
+
+        Example: fiber_length__mm=100 with v=4 m/s → 25 ms window.
+    sig_intracellular : float, optional
+        Intracellular conductivity (S/m), default 1.01.
+    fiber_diameter__mm : float, optional
+        Fibre diameter (mm), default 0.05. Together with ``sig_intracellular`` it
+        sets the line current density ``sig_i * pi * (d/2)**2 * d2Vm/dz2`` of the
+        source, so the output is the potential in mV.
+    v_grid : float, optional
+        Reference conduction velocity (m/s) that sets the time grid (``v`` above
+        in the window and sampling-rate formulas). Defaults to ``v``. Fibres
+        that propagate at different ``v`` but share ``v_grid`` return signals on
+        the same time axis and can be summed directly.
+    iap_lambda__per_mm : float, optional
+        Length scale of the Rosenfalck intracellular action potential,
+        ``Vm = 96 (lambda z)**3 exp(-lambda z) - 90`` mV with z in mm, default
+        1 / mm (Rosenfalck 1969). Values below 1 stretch the IAP along the fibre
+        and lower the spectral content of the MUAP; peak Vm is unchanged.
 
     Returns
     -------
@@ -298,6 +392,10 @@ def _simulate_fiber_v2_python(
     B_incomplete : np.ndarray
         B matrix for reuse in subsequent calls
     """
+    # The grid velocity fixes the (k_z, k_t) grids; the fibre velocity enters
+    # only the source term below.
+    if v_grid is None:
+        v_grid = v
     # Get electrode configuration from the array
     channels = [electrode_array.num_rows, electrode_array.num_cols]
 
@@ -316,8 +414,9 @@ def _simulate_fiber_v2_python(
     ## 1. Constants
 
     if _prepared is not None:
-        _prepared.bind((Fs, v, N, M, r, r_bone, th_fat, th_skin,
-                        sig_muscle_rho, sig_muscle_z, sig_fat, sig_skin, sig_bone, fiber_length__mm))
+        _prepared.bind((Fs, v_grid, N, M, r, r_bone, th_fat, th_skin,
+                        sig_muscle_rho, sig_muscle_z, sig_fat, sig_skin, sig_bone, fiber_length__mm,
+                        sig_intracellular, fiber_diameter__mm, iap_lambda__per_mm))
     if _prepared is None or _prepared.grid is None:
         ## Model angular frequencies
         # FFT-consistent bin centers (matches np.fft.fft + fftshift): spacing = 1, bins at
@@ -327,12 +426,9 @@ def _simulate_fiber_v2_python(
         # Calculate effective Fs based on grid spacing
         # When fiber_length__mm is specified, we must use the corresponding Fs for FFT consistency
         if fiber_length__mm is not None:
-            # z-grid spans fiber_length__mm with N points (before z /= 2 scaling)
-            # Grid spacing (before scaling): dz = fiber_length__mm / (N-1)
+            # z-grid spans fiber_length__mm with N points: dz = fiber_length__mm / (N-1)
             # For FFT: dz = v / Fs_eff → Fs_eff = v * (N-1) / fiber_length__mm
-            # Note: The z /= 2 scaling affects the IAP kernel evaluation but the FFT
-            # operates on the array structure, so we use the pre-scaling grid spacing
-            Fs_effective = v * (N - 1) / fiber_length__mm  # kHz
+            Fs_effective = v_grid * (N - 1) / fiber_length__mm  # kHz
         else:
             Fs_effective = Fs
 
@@ -350,7 +446,7 @@ def _simulate_fiber_v2_python(
         if N > 1:
             dk_t = 2 * math.pi * Fs_effective / N
             k_t = np.where(k_t == 0.0, 0.5 * dk_t, k_t)
-        k_z = k_t / v
+        k_z = k_t / v_grid
         (kt_mesh_kzkt, kz_mesh_kzkt) = np.meshgrid(k_t, k_z)
 
         ## Model radii -> (Farina, 2004), Figure 1 - b)
@@ -362,28 +458,32 @@ def _simulate_fiber_v2_python(
 
         ###################################################################################################
         ## 2. I(k_t, k_z)
-        # Rosenfalck (1969) intracellular action potential spatial distribution
-        # As used in Farina & Merletti (2001), equation 16
-        # IMPORTANT: This matches the original Farina implementation exactly (no normalization)
-        A = 96 / 10  # mV/mm^3 (amplitude parameter from Farina 2001, eq 16)
+        # Rosenfalck (1969) intracellular action potential, Vm = 96 (lz)^3 e^{-lz} - 90 mV
+        # with l = iap_lambda__per_mm (1 / mm as published; Farina & Merletti 2001,
+        # eq. 16); aux below is dVm/dz in mV/mm.
+        A = 96  # mV/mm^3
+        # Line current density i = sig_i * pi * (d/2)^2 * d2Vm/dz2 (core-conductor
+        # model). With conductivities in S/m and lengths in mm, phi comes out in mV.
+        source_scale = sig_intracellular * math.pi * (fiber_diameter__mm / 2) ** 2
 
         # Define spatial grid for IAP kernel evaluation
         if fiber_length__mm is None:
             # Legacy behavior: z-range depends on N (INCORRECT - causes MUAP duration to scale with N)
-            z = np.linspace(-(N - 1) * (v / Fs) / 2, (N - 1) * (v / Fs) / 2, N, dtype=np.longdouble)
+            z = np.linspace(-(N - 1) * (v_grid / Fs) / 2, (N - 1) * (v_grid / Fs) / 2, N, dtype=np.longdouble)
         else:
             # Correct behavior: z-range defined by physical fiber length (independent of N)
             # N controls only the resolution, not the physical extent
             z = np.linspace(-fiber_length__mm / 2, fiber_length__mm / 2, N, dtype=np.longdouble)
 
-        z /= 2  # mm - scaling for Rosenfalck model
-
-        # Rosenfalck action potential: A * exp(-z) * (3z² - z³) for z ≥ 0
-        # Uses raw z values in mm (NOT normalized) to match original implementation
+        # Rosenfalck action potential: A * l * exp(-lz) * (3(lz)² - (lz)³) for z ≥ 0, with
+        # z in mm on the same grid as k_z (l = 1 / mm as published). The source grid
+        # and the volume-conductor grid must share one z axis.
+        lam = iap_lambda__per_mm
         aux = np.zeros_like(z)
         for i in range(len(z)):
             if z[i] >= 0:
-                aux[i] = A * np.exp(-z[i]) * (3 * z[i] ** 2 - z[i] ** 3)
+                lz = lam * z[i]
+                aux[i] = source_scale * A * lam * np.exp(-lz) * (3 * lz ** 2 - lz ** 3)
 
         # print(f"DEBUG: z range = [{np.min(z):.2f}, {np.max(z):.2f}] mm")
         # print(f"DEBUG: aux range = [{np.min(aux):.6e}, {np.max(aux):.6e}]")
@@ -391,7 +491,9 @@ def _simulate_fiber_v2_python(
 
         psi = -f_minus_t(aux)
         # print(f"DEBUG: psi range = [{np.min(psi):.6e}, {np.max(psi):.6e}]")
-        PSI = np.fft.fftshift(np.fft.fft(psi)) / len(psi)
+        # Continuous Fourier transform: integral psi(z) e^{-ikz} dz ~ dz * FFT. The
+        # inverse transforms in step 6 carry the matching dk_t / 2pi = Fs / N.
+        PSI = np.fft.fftshift(np.fft.fft(psi)) * float(z[1] - z[0])
         PSI_conj = np.conj(PSI)
         PSI_conj = PSI_conj.reshape(-1, len(PSI_conj))
         ones = np.ones((len(PSI_conj[0, :]), 1))
@@ -400,11 +502,18 @@ def _simulate_fiber_v2_python(
             _prepared.freeze_grid((k_theta, k_t, k_z, kt_mesh_kzkt, kz_mesh_kzkt, a, b, c, d, psi, PSI_mesh_conj, Fs_effective))
     else:
         k_theta, k_t, k_z, kt_mesh_kzkt, kz_mesh_kzkt, a, b, c, d, psi, PSI_mesh_conj, Fs_effective = _prepared.grid
+    # The source term reads the IAP spectrum at k = k_t / v (one column per k_t).
+    # On the fibre's own grid that is the k_z grid; a fibre propagating at
+    # v != v_grid needs the spectrum at k_z * v_grid / v instead.
+    PSI_row_conj = PSI_mesh_conj[0]
+    if v != v_grid:
+        dz = (fiber_length__mm / (N - 1)) if fiber_length__mm is not None else v_grid / Fs
+        PSI_row_conj = np.conj(_source_spectrum(np.asarray(psi, dtype=np.float64), dz, v_grid / v))
     if _prepared is not None:
-        I_kzkt = _prepared.source_current(k_z, k_t, PSI_mesh_conj[0], v, zi, L1, L2)
+        I_kzkt = _prepared.source_current(k_z, k_t, PSI_row_conj, v, zi, L1, L2)
     else:
         I_kzkt = 1j * np.multiply(
-            kz_mesh_kzkt / v, np.multiply(PSI_mesh_conj, np.exp(-1j * kz_mesh_kzkt * zi))
+            kz_mesh_kzkt / v, np.multiply(PSI_row_conj[None, :], np.exp(-1j * kz_mesh_kzkt * zi))
         )
         k_eps = kz_mesh_kzkt + kt_mesh_kzkt / v
         k_beta = kz_mesh_kzkt - kt_mesh_kzkt / v
@@ -486,7 +595,7 @@ def _simulate_fiber_v2_python(
             channels[0], channels[1], len(k_z), len(k_theta),
         )
     else:
-        B_kz = np.zeros((channels[0], channels[1], len(k_z)))
+        B_kz = np.zeros((channels[0], channels[1], len(k_z)), dtype=np.complex128)
         for channel_z in range(channels[0]):
             for channel_theta in range(channels[1]):
                 arg = np.multiply(
@@ -505,7 +614,8 @@ def _simulate_fiber_v2_python(
                        if _prepared is not None else _numba_phi_func(
             np.ascontiguousarray(I_kzkt.real, dtype=np.float64),
             np.ascontiguousarray(I_kzkt.imag, dtype=np.float64),
-            np.ascontiguousarray(B_kz, dtype=np.float64),
+            np.ascontiguousarray(B_kz.real, dtype=np.float64),
+            np.ascontiguousarray(B_kz.imag, dtype=np.float64),
             np.ascontiguousarray(pos_z_mm, dtype=np.float64),
             np.ascontiguousarray(kz_mesh_kzkt, dtype=np.float64),
             channels[0], channels[1], len(k_z), len(k_t),
@@ -519,9 +629,10 @@ def _simulate_fiber_v2_python(
                 # applied when building the centered spectrum. They are
                 # equivalent for even N but differ by a one-sample phase ramp
                 # for odd N — ifftshift is the correct inverse here.
+                # (1/2pi) integral dk_t e^{i k_t t} = (Fs / N) * sum = Fs * ifft
                 phi[channel_z, channel_theta, :] = np.real(
                     np.fft.ifft(
-                        np.fft.ifftshift(PHI_complex[channel_z, channel_theta, :] * len(psi))
+                        np.fft.ifftshift(PHI_complex[channel_z, channel_theta, :] * Fs_effective)
                     )
                 )
     else:
@@ -545,28 +656,13 @@ def _simulate_fiber_v2_python(
                 # for odd N — ifftshift is the correct inverse here.
                 phi[channel_z, channel_theta, :] = np.real(
                     np.fft.ifft(
-                        np.fft.ifftshift(PHI / 2 / math.pi * len(psi))
+                        np.fft.ifftshift(PHI / 2 / math.pi * Fs_effective)
                     )
                 )
 
-    # Center the MUAP signal in the time window by finding the peak and shifting
-    # For each electrode channel, find the peak and center it
-    N_time = phi.shape[2]
-    center_idx = N_time // 2
-
-    # Find the peak location (use center electrode as reference)
-    center_electrode_row = phi.shape[0] // 2
-    center_electrode_col = phi.shape[1] // 2
-    center_signal = phi[center_electrode_row, center_electrode_col, :]
-
-    # Find peak (max absolute value)
-    peak_idx = np.argmax(np.abs(center_signal))
-
-    # Calculate shift needed to center the peak
-    shift = center_idx - peak_idx
-
-    # Apply circular shift to all channels
-    phi = np.roll(phi, shift, axis=2)
+    # No per-fibre re-centring: the fibre fires at sample N // 2 (the IAP grid is
+    # centred on z = 0), and every fibre of a motor unit must keep that common
+    # instant so that the summed MUAP preserves the fibres' relative timing.
 
     # print(f"DEBUG: Final phi range = [{np.min(phi):.6e}, {np.max(phi):.6e}]")
     # print(f"DEBUG: Final phi peak-to-peak = {np.ptp(phi):.6e}")
@@ -603,6 +699,10 @@ def simulate_fiber_v2(
     pos_z_precomputed: np.ndarray | None = None,
     pos_theta_precomputed: np.ndarray | None = None,
     rele_precomputed: float | None = None,
+    *,
+    sig_intracellular: float = 1.01,
+    fiber_diameter__mm: float = 0.05,
+    iap_lambda__per_mm: float = 1.0,
 ):
     """
     Simulate a single fiber in the layered-cylinder volume conductor.
@@ -668,10 +768,22 @@ def simulate_fiber_v2(
         **Recommended**: Set this explicitly (e.g., 50-100 mm for typical motor units)
         to ensure MUAP duration is physically accurate and independent of N.
 
-        The actual MUAP duration will be approximately: fiber_length__mm / (2 * v) ms
-        (factor of 2 due to internal scaling for Rosenfalck model).
-
-        Example: fiber_length__mm=100 with v=4 m/s → ~12.5 ms MUAP duration.
+        The returned window spans fiber_length__mm / v ms (``N`` samples at
+        ``v * (N - 1) / fiber_length__mm`` kHz), with the fibre's firing
+        instant at sample ``N // 2``. See :func:`muap_sampling_rate__Hz`.
+
+        Example: fiber_length__mm=100 with v=4 m/s → 25 ms window.
+    sig_intracellular : float, optional
+        Intracellular conductivity (S/m), default 1.01.
+    fiber_diameter__mm : float, optional
+        Fibre diameter (mm), default 0.05. Together with ``sig_intracellular`` it
+        sets the line current density ``sig_i * pi * (d/2)**2 * d2Vm/dz2`` of the
+        source, so the output is the potential in mV.
+    iap_lambda__per_mm : float, optional
+        Length scale of the Rosenfalck intracellular action potential,
+        ``Vm = 96 (lambda z)**3 exp(-lambda z) - 90`` mV with z in mm, default
+        1 / mm (Rosenfalck 1969). Values below 1 stretch the IAP along the fibre
+        and lower the spectral content of the MUAP; peak Vm is unchanged.
 
     Returns
     -------
@@ -727,4 +839,7 @@ def simulate_fiber_v2(
         pos_z_precomputed,
         pos_theta_precomputed,
         rele_precomputed,
+        sig_intracellular=sig_intracellular,
+        fiber_diameter__mm=fiber_diameter__mm,
+        iap_lambda__per_mm=iap_lambda__per_mm,
     )
diff --git a/myogen/simulator/core/emg/surface/surface_emg.py b/myogen/simulator/core/emg/surface/surface_emg.py
index 11153adc..d003c832 100644
--- a/myogen/simulator/core/emg/surface/surface_emg.py
+++ b/myogen/simulator/core/emg/surface/surface_emg.py
@@ -22,7 +22,17 @@
 
 from myogen import get_random_generator
 from myogen.simulator.core.emg.electrodes import SurfaceElectrodeArray
-from myogen.simulator.core.emg.surface.simulate_fiber import simulate_fiber_v2, _simulate_fiber_v2_python
+from myogen.simulator.core.emg.surface.simulate_fiber import (
+    _simulate_fiber_v2_python,
+    delay_fibre_signal,
+    fiber_semi_lengths,
+    muap_sampling_rate__Hz,
+    simulate_fiber_v2,
+)
+from myogen.simulator.core.emg.surface.fiber_dispersion import (
+    SurfaceFiberDispersion,
+    realize_fiber_dispersion,
+)
 from myogen.simulator.core.muscle import Muscle
 from myogen.utils.decorators import beartowertype
 from myogen.utils.types import (
@@ -72,18 +82,35 @@ class SurfaceEMG:
         If None, defaults to 10 kHz. Higher values provide better temporal resolution
         but increase computation time. Default is 10 kHz.
     iap_kernel_length__mm : float, optional
-        Physical spatial extent for intracellular action potential (IAP) kernel evaluation in mm.
-        If None (default), uses individual fiber lengths from muscle model, ensuring
-        MUAP duration is physiologically accurate and independent of sampling resolution.
-
-        **Recommended**: Leave as None to use fiber-specific lengths for most realistic MUAPs.
-
-        Alternatively, set to a fixed value (e.g., 80-100 mm) to use the same kernel
-        extent for all fibers, which can simplify analysis but may be less physiologically
-        accurate for muscles with variable fiber lengths.
-
-        This parameter controls the spatial extent over which the IAP waveform is computed,
-        directly affecting MUAP duration: duration ≈ iap_kernel_length__mm / (2 * v) ms.
+        Length ``K`` of the periodic z window (mm) on which each fibre is simulated.
+        If None (default), ``K = 2.5 × mean_fiber_length__mm``.
+
+        The MUAP template window spans ``K / v`` ms, with the firing instant at its
+        centre. ``K`` must hold the whole fibre plus the IAP, or the signal wraps
+        around; it does not change the physical MUAP, only the window and the
+        internal sampling step ``K / (v (N - 1))``.
+    fiber_diameter__um : float, optional
+        Muscle fibre diameter in µm, default 50. The source current scales with
+        the fibre cross-section (``d**2``).
+    intracellular_conductivity__S_m : float, optional
+        Intracellular conductivity in S/m, default 1.01. The source current
+        density is ``sigma_i * pi * (d/2)**2 * d2Vm/dz2`` (core-conductor model).
+    iap_lambda__per_mm : float, optional
+        Length scale of the Rosenfalck intracellular action potential,
+        ``Vm = 96 (lambda z)**3 exp(-lambda z) - 90`` mV with z in mm. Default
+        1 / mm, as published (Rosenfalck 1969). Values below 1 stretch the IAP
+        along the fibre and lower the MUAP's spectral content and raise its
+        amplitude. Botelho et al. (2019) used 0.5 to match the frequency content of
+        their FDI recordings; in this conductor 0.7 matched their Delsys median
+        frequency and adjacent-pin RMS at 25 % MVC. Any value other than 1 is a
+        fitted modelling assumption, not a measurement. ``iap_kernel_length__mm``
+        must hold the longer IAP (its tail scales with ``1 / lambda``).
+    fiber_dispersion : SurfaceFiberDispersion, optional
+        Per-fibre end-plate scatter, axon-branch delays and fibre conduction
+        velocities (see :class:`SurfaceFiberDispersion`). None (default) or an
+        inactive configuration keeps one end-plate per motor unit, no nerve
+        delays and the mean velocity for every fibre. Supported on the default
+        route only (``execution=None``, ``use_unified=False``).
 
     Attributes
     ----------
@@ -95,6 +122,10 @@ class SurfaceEMG:
         Noisy surface EMG signals for each electrode array as a neo.Block. Available after add_noise().
     spike_train__Block : SPIKE_TRAIN__Block
         Spike train block used for EMG generation signals. Available after simulate_surface_emg().
+    fiber_dispersion_report : dict or None
+        Per-motor-unit summary of the realised dispersion (end-plate mean and SD,
+        CV mean and coefficient of variation, nerve delay mean and SD, source
+        scale), or None when no dispersion is active. Available after simulate_muaps().
 
     References
     ----------
@@ -112,6 +143,10 @@ def __init__(
         internal_sampling_frequency__Hz: Quantity__Hz | None = None,
         iap_kernel_length__mm: float | None = None,
         use_unified: bool = False,
+        fiber_diameter__um: float = 50.0,
+        intracellular_conductivity__S_m: float = 1.01,
+        fiber_dispersion: SurfaceFiberDispersion | None = None,
+        iap_lambda__per_mm: float = 1.0,
     ):
         # Immutable public arguments - never modify these
         self.muscle_model = muscle_model
@@ -122,6 +157,12 @@ def __init__(
         self.MUs_to_simulate = MUs_to_simulate
         self.iap_kernel_length__mm = iap_kernel_length__mm
         self._use_unified = use_unified
+        self.fiber_diameter__um = fiber_diameter__um
+        self.intracellular_conductivity__S_m = intracellular_conductivity__S_m
+        self.iap_lambda__per_mm = iap_lambda__per_mm
+        self.fiber_dispersion = fiber_dispersion
+        self._fiber_dispersion = fiber_dispersion
+        self.fiber_dispersion_report = None
 
         # Internal sampling frequency for higher resolution MUAP computation
         # If not specified, defaults to 10 kHz for better MUAP resolution
@@ -149,6 +190,13 @@ def __init__(
         self._sampling_points_in_theta_domain = sampling_points_in_theta_domain
         self._MUs_to_simulate = MUs_to_simulate
         self._iap_kernel_length__mm = iap_kernel_length__mm
+        self._fiber_diameter__mm = float(fiber_diameter__um) * 1e-3
+        self._intracellular_conductivity__S_m = float(intracellular_conductivity__S_m)
+        if not iap_lambda__per_mm > 0:
+            raise ValueError(f"iap_lambda__per_mm must be positive, got {iap_lambda__per_mm}")
+        if use_unified and iap_lambda__per_mm != 1.0:
+            raise ValueError("iap_lambda__per_mm is not supported with use_unified=True")
+        self._iap_lambda__per_mm = float(iap_lambda__per_mm)
 
         # Derived properties from muscle model - immutable public access
         self.mean_conduction_velocity__m_s = self._muscle_model.mean_conduction_velocity__m_s
@@ -306,20 +354,39 @@ def simulate_muaps(
             for mu_idx in range(n_motor_units)
         ]
 
-        # Pre-allocate result shape at INTERNAL resolution (optimization: avoid repeated shape calculations)
-        # Will be downsampled to output resolution after simulation
-        internal_result_shape = (
-            self._electrode_arrays[0].num_rows,
-            self._electrode_arrays[0].num_cols,
-            len(t_internal),
-        )
+        # Per-fibre dispersion, drawn here from its own seeded generators (the
+        # global draws above are unchanged whether or not it is active).
+        dispersion = None
+        self.fiber_dispersion_report = None
+        if self._fiber_dispersion is not None and self._fiber_dispersion.active:
+            if self._use_unified:
+                raise ValueError("fiber_dispersion is not supported with use_unified=True")
+            fiber_positions = []
+            for mu_idx in range(n_motor_units):
+                positions = self._muscle_model.resulting_fiber_assignment(mu_idx)
+                fiber_positions.append(np.asarray(getattr(positions, "magnitude", positions))[:, :2])
+            dispersion = realize_fiber_dispersion(
+                self._fiber_dispersion,
+                fiber_positions,
+                np.asarray(self._muscle_model.recruitment_thresholds),
+                innervation_zones,
+                mean_cv__m_s=float(self._mean_conduction_velocity__m_s),
+                fiber_lengths__mm=[self._mean_fiber_length__mm + variation
+                                   for variation in fiber_length_variations_per_MU],
+                mean_fiber_length__mm=float(self._mean_fiber_length__mm),
+            )
+            self.fiber_dispersion_report = dispersion.report
 
-        # Final output shape after downsampling
-        output_result_shape = (
-            self._electrode_arrays[0].num_rows,
-            self._electrode_arrays[0].num_cols,
-            self._sampling_points_in_t_and_z_domains,
-        )
+        # Result shapes follow each electrode array's own grid (arrays may differ).
+        def internal_result_shape(electrode_array: SurfaceElectrodeArray) -> tuple[int, int, int]:
+            return electrode_array.num_rows, electrode_array.num_cols, len(t_internal)
+
+        def output_result_shape(electrode_array: SurfaceElectrodeArray) -> tuple[int, int, int]:
+            return (
+                electrode_array.num_rows,
+                electrode_array.num_cols,
+                self._sampling_points_in_t_and_z_domains,
+            )
 
         # Helper function to process a single motor unit
         def _process_single_mu(
@@ -351,13 +418,17 @@ def _process_single_mu(
                     electrode_array = electrode_array_original
 
                 # Pre-allocated result array at INTERNAL resolution (optimization: use pre-computed shape)
-                array_result_internal = np.zeros(internal_result_shape, dtype=np.float64)
+                array_result_internal = np.zeros(
+                    internal_result_shape(electrode_array), dtype=np.float64
+                )
 
                 number_of_fibers = number_of_fibers_per_MUs[MU_index]
 
                 if number_of_fibers == 0:
                     # Return empty signal (downsampled to output resolution)
-                    array_result_downsampled = np.zeros(output_result_shape, dtype=np.float64)
+                    array_result_downsampled = np.zeros(
+                        output_result_shape(electrode_array), dtype=np.float64
+                    )
                     return array_result_downsampled, f"MUAP_{MU_index}"
 
                 # Get fiber positions
@@ -414,6 +485,21 @@ def _process_single_mu(
                 else:
                     IAP_SCALE_FACTOR = 2.5
                     kernel_length = self._mean_fiber_length__mm * IAP_SCALE_FACTOR
+                Fs_grid = v_conduction * (N_internal - 1) / kernel_length  # kHz
+
+                if dispersion is not None:
+                    # The fibre must finish inside the second half of the window
+                    # (firing at its centre), or the circular grid wraps it.
+                    zone = dispersion.zi__mm[MU_index]
+                    reach = np.maximum(dispersion.end_plus__mm[MU_index] - zone,
+                                       zone - dispersion.end_minus__mm[MU_index]) + 10.0  # mm, plus the IAP tail
+                    finish = dispersion.delay__ms[MU_index] + reach / dispersion.cv__m_s[MU_index]
+                    if np.max(finish) >= kernel_length / v_conduction / 2:
+                        raise ValueError(
+                            f"MU {MU_index}: dispersed fibres need {np.max(finish):.1f} ms after firing, "
+                            f"the window holds {kernel_length / v_conduction / 2:.1f} ms; "
+                            "increase iap_kernel_length__mm"
+                        )
 
                 # Process each fiber (inner loop - must remain sequential)
                 fiber_iter = tqdm(
@@ -427,10 +513,18 @@ def _process_single_mu(
                     R = R_values[fiber_number]
                     theta = theta_values[fiber_number]
                     fiber_length__mm = fiber_lengths[fiber_number]
+                    if dispersion is not None:
+                        fiber_zone = float(dispersion.zi__mm[MU_index][fiber_number])
+                        fiber_cv = float(dispersion.cv__m_s[MU_index][fiber_number])
+                    else:
+                        fiber_zone, fiber_cv = innervation_zone, v_conduction
 
-                    # Calculate fiber end positions
-                    L1 = abs(innervation_zone + fiber_length__mm / 2)
-                    L2 = abs(innervation_zone - fiber_length__mm / 2)
+                    # Semi-lengths towards +z (L1) and -z (L2) from the end-plate
+                    if dispersion is not None:
+                        L1 = float(dispersion.end_plus__mm[MU_index][fiber_number]) - fiber_zone
+                        L2 = fiber_zone - float(dispersion.end_minus__mm[MU_index][fiber_number])
+                    else:
+                        L1, L2 = fiber_semi_lengths(fiber_zone, fiber_length__mm)
 
                     if self._use_unified:
                         from myogen.simulator.core.emg.fiber_simulation import (
@@ -474,7 +568,8 @@ def _process_single_mu(
                         # Existing frequency-domain path (unchanged)
                         phi_temp, A_matrix, B_incomplete = _simulate_fiber_v2_python(
                             Fs=Fs_internal,
-                            v=v_conduction,
+                            v=fiber_cv,
+                            v_grid=v_conduction,
                             N=N_internal,
                             M=M_theta,
                             r=r_total,
@@ -484,7 +579,7 @@ def _process_single_mu(
                             R=R,
                             L1=L1,
                             L2=L2,
-                            zi=innervation_zone,
+                            zi=fiber_zone,
                             electrode_array=electrode_array,
                             sig_muscle_rho=sig_rho,
                             sig_muscle_z=sig_z,
@@ -501,6 +596,15 @@ def _process_single_mu(
                             pos_z_precomputed=base_pos_z,
                             pos_theta_precomputed=base_pos_theta,
                             rele_precomputed=base_rele,
+                            sig_intracellular=self._intracellular_conductivity__S_m,
+                            fiber_diameter__mm=self._fiber_diameter__mm,
+                            iap_lambda__per_mm=self._iap_lambda__per_mm,
+                        )
+
+                    if dispersion is not None:
+                        phi_temp = phi_temp * dispersion.amplitude_scale[MU_index][fiber_number]
+                        phi_temp = delay_fibre_signal(
+                            phi_temp, float(dispersion.delay__ms[MU_index][fiber_number]), Fs_grid
                         )
 
                     array_result_internal += phi_temp
@@ -514,13 +618,9 @@ def _process_single_mu(
                 return array_result_downsampled, f"MUAP_{MU_index}"
 
             except Exception as e:
-                # Log error and return empty result to avoid crashing entire parallel job
-                logging.error(
-                    f"Failed to process MU {MU_index} for electrode array {array_idx}: {e}"
-                )
-                # Return empty signal with error marker at output resolution
-                empty_result = np.zeros(output_result_shape, dtype=np.float64)
-                return empty_result, f"MUAP_{MU_index}_FAILED"
+                # Fail loudly: an all-zero MUAP would pass for a valid, silent unit.
+                e.add_note(f"while simulating MU {MU_index} for electrode array {array_idx}")
+                raise
 
         block = Block()
         for array_idx, electrode_array in enumerate(self._electrode_arrays):
@@ -576,21 +676,13 @@ def _process_single_mu(
                 IAP_SCALE_FACTOR = 2.5
                 kernel_length_mm = self._mean_fiber_length__mm * IAP_SCALE_FACTOR
 
-            # Physical duration based on IAP kernel length (after /=2 scaling in simulate_fiber)
-            # Duration = (kernel_length_mm / 2) / velocity
-            muap_duration__s = (
-                kernel_length_mm / 2.0
-            ) / self._mean_conduction_velocity__m_s / 1000.0  # Convert ms to s
-
-            # Create custom time array for this duration
-            times__s = np.linspace(0, muap_duration__s, self._sampling_points_in_t_and_z_domains)
-
-            # Calculate effective sampling rate for these times
-            effective_sampling_rate__Hz = (
-                self._sampling_points_in_t_and_z_domains - 1
-            ) / muap_duration__s
-
-            use_custom_times = True
+            # The fibre window spans kernel_length / v (firing instant at its centre)
+            effective_sampling_rate__Hz = muap_sampling_rate__Hz(
+                self._mean_conduction_velocity__m_s,
+                self._internal_sampling_points,
+                self._sampling_points_in_t_and_z_domains,
+                kernel_length_mm,
+            )
 
             # Create segments for ALL MUs (maintaining index order)
             # Non-computed MUs get empty signals at output resolution
@@ -599,14 +691,13 @@ def _process_single_mu(
                     array_result, segment_name = results[MU_index]
                 else:
                     # Create empty MUAP for non-computed MUs at output resolution
-                    array_result = np.zeros(output_result_shape, dtype=np.float64)
+                    array_result = np.zeros(output_result_shape(electrode_array), dtype=np.float64)
                     segment_name = f"MUAP_{MU_index}"
 
                 segment = Segment(name=segment_name)
                 group.segments.append(segment)
 
-                # Use actual physical duration based on fiber lengths
-                grid_shape = (output_result_shape[0], output_result_shape[1])
+                grid_shape = (electrode_array.num_rows, electrode_array.num_cols)
                 segment.analogsignals.append(
                     create_grid_signal(
                         signal=np.transpose(array_result, (2, 0, 1)) * pq.mV,
diff --git a/myogen/simulator/core/emg/surface/volume_conductor.py b/myogen/simulator/core/emg/surface/volume_conductor.py
index fe9ae7f5..eee64ee7 100644
--- a/myogen/simulator/core/emg/surface/volume_conductor.py
+++ b/myogen/simulator/core/emg/surface/volume_conductor.py
@@ -56,6 +56,23 @@ def _log_tilde(log_fn, K_THETA, x):
     return np.logaddexp(log_fn(K_THETA + 1, x), log_fn(K_THETA - 1, x)) - np.log(2)
 
 
+def _solved_block(system, r_bone, columns=True):
+    """The rows (and columns) of ``system`` that the linear solve uses."""
+    if r_bone != 0:
+        return system
+    rows = system[..., 2:, :]
+    return rows[..., [1, 3, 4, 5, 6]] if columns else rows
+
+
+def _require_finite(block, name, K_THETA):
+    if not np.all(np.isfinite(block)):
+        raise ValueError(
+            f"The layered-cylinder {name} is not finite for angular orders up to "
+            f"|k_theta| = {int(np.max(np.abs(K_THETA)))}: the scaled modified Bessel "
+            "functions leave the float64 range (I_n underflows, K_n overflows). Reduce sampling_points_in_theta_domain (default 32)."
+        )
+
+
 def layered_cylinder_transfer(
     k_z: np.ndarray,
     k_theta: np.ndarray,
@@ -242,8 +259,12 @@ def layered_cylinder_transfer(
         A_mat[..., 6, 5] = sig_skin * np.exp(log_In_tilde_d - log_In_d)
         A_mat[..., 6, 6] = -sig_skin * np.exp(log_Kn_tilde_d - log_Kn_d)
 
-        A_mat[np.isinf(A_mat)] = 0
-        A_mat[np.isnan(A_mat)] = 0
+        # Without bone, rows 0-1 and columns 0/2 are dropped before the solve
+        # and hold harmless log(0) - log(0) = NaN entries.  Anything
+        # non-finite in the solved block means the Bessel functions left the
+        # float64 range; zeroing it gave a singular system or NaN MUAPs.
+        _require_finite(_solved_block(A_mat, r_bone), "system matrix", K_THETA)
+        A_mat[~np.isfinite(A_mat)] = 0
 
         A_matrix = A_mat.copy()
         B_incomplete = B.copy()
@@ -269,8 +290,8 @@ def _safe_exp(log_val):
     B[..., 2, 0] = -_safe_exp(log_Kn_bm + log_In_Rm) / sig_muscle_rho
     B[..., 3, 0] = anisotropy * _safe_exp(log_Kn_tilde_bm + log_In_Rm)
 
-    B[np.isinf(B)] = 0
-    B[np.isnan(B)] = 0
+    _require_finite(_solved_block(B, r_bone, columns=False), "source vector", K_THETA)
+    B[~np.isfinite(B)] = 0
 
     A_flat = A_mat.reshape(-1, 7, 7)
     B_flat = B.reshape(-1, 7, 1)
diff --git a/myogen/simulator/core/muscle/muscle.py b/myogen/simulator/core/muscle/muscle.py
index f7c5f507..50e432b9 100644
--- a/myogen/simulator/core/muscle/muscle.py
+++ b/myogen/simulator/core/muscle/muscle.py
@@ -88,7 +88,7 @@ def _perform_fast_marching(speed_map: np.ndarray, seed_points: np.ndarray) -> np
 @beartowertype
 class Muscle:
     """
-    A muscle model based on the cylindrical description of the volume conductor by Farina et al. 2004 [1] and the motor unit distribution by Konstantin et al. 2020 [2].
+    A muscle model based on the cylindrical description of the volume conductor by Farina et al. 2004 [1] and the motor unit distribution by Akhmadeev et al. 2020 [2].
 
     All default values are set to simulate the First Dorsal Interosseous (FDI) muscle.
     Values are pulled from the literature.
@@ -114,23 +114,44 @@ class Muscle:
         Mean conduction velocity in m/s. Default is set to 4.2 m/s as determined by Nishizono et al. 1990 [4].
         Experimental range determined by Nishizono et al. 1990 [4] is between 3.2 and 5.0 m/s.
     mean_fiber_length__mm : float, default=31.7
-        Mean fiber length in mm. Default is set to 31.7 mm as determined by Jacobson et al. 1992 [3] (Table 1).
+        Mean fiber length in mm. Default is the first dorsal interosseous (FDI) value of Jacobson et al. 1992 [3]
+        (Table 1).
     var_fiber_length__mm : float, default=2.8
-        Fiber length variance in mm. Default is set to 2.8 mm as determined by Jacobson et al. 1992 [3] (Table 1).
+        Half-width in mm of the uniform fibre-length variation: each fibre is ``mean_fiber_length__mm`` plus a
+        uniform draw in ``±var_fiber_length__mm``, with its ends at ``±length / 2``, so both ends move together
+        by up to half this value. Default 2.8 mm, the FDI fibre-length spread of Jacobson et al. 1992 [3]
+        (Table 1), which most likely describes variation between specimens rather than between fibres of one
+        muscle (not verified against the table).
     radius_bone__mm : float, default=1
         Bone radius in mm. Default is set to 1 mm.
-    fat_thickness__mm : float, default=0.3
-        Fat thickness in mm. Default is set to 0.3 mm as determined by Störchle et al. 2018 [5].
-    skin_thickness__mm : float, default=1.29
-        Skin thickness in mm. Default is set to the male skin thickness average of 1.29 mm as determined by Brodar 1960 [6].
+    fat_thickness__mm : float, default=1.3
+        Fat thickness in mm. Default 1.3 mm, derived rather than measured: no study measures fat alone over
+        the FDI, so it is the total depth to muscle of 2.5 mm, the low end of the FDI subcutaneous depth of
+        Nishikawa et al. 2024 [12] (group means 2.54-3.30 mm, ultrasound), minus the skin below. Fat averaged
+        over the whole hand is thinner, 0.3 mm (Störchle et al. 2018 [5]; the previous default).
+    skin_thickness__mm : float, default=1.2
+        Skin (epidermis and dermis) thickness in mm. Default 1.2 mm, the median over the hand dorsum in healthy
+        controls of Li et al. 2018 [11] (range 0.79-1.50 mm, high-frequency ultrasound). The previous default,
+        1.29 mm, was a male average from Brodar 1960 [6].
     muscle_conductivity_radial__S_per_m : float, default=0.09
         Muscle conductivity in radial direction. Default is set to 0.09 S/m as determined by Botelho et al. 2019 [7] (Table 1).
     muscle_conductivity_longitudinal__S_per_m : float, default=0.4
         Muscle conductivity in longitudinal direction. Default is set to 0.4 S/m as determined by Botelho et al. 2019 [7] (Table 1).
     fat_conductivity__S_per_m : float, default=4.07E-2
         Fat conductivity. Default is set to 4.07E-2 S/m as determined by Botelho et al. 2019 [7] (Table 1).
-    skin_conductivity__S_per_m : float, default=4.88E-4
-        Skin conductivity. Default is set to 4.88E-4 S/m as determined by Botelho et al. 2019 [7] (Table 1).
+    skin_conductivity__S_per_m : float, default=1.0
+        Skin conductivity. Default is 1 S/m, the value of Farina et al. 2004 [1], which they took
+        from the three-layer model of Roeleveld et al. 1997 [8] (also Blok et al. 2002 [9]). It is
+        an effective value chosen so that the model reproduces how biceps MUAPs fall off with
+        depth and around the arm, not a measured skin conductivity: Roeleveld et al. note that it
+        is not known whether skin conducts as well as 1 S/m, and Blok et al. that reference values
+        are scarce. Measured skin is far lower: 4.55E-4 to 4.88E-4 S/m for composite in-vivo skin
+        near 100-150 Hz (Gabriel et al. 1996, used by Lowery et al. 2002 [10] and Botelho et al.
+        2019 [7]); the IT'IS tissue database gives 0.148 +/- 0.042 S/m at low frequency (mean of
+        7 studies, 0.057-0.25 S/m, flagged for use with caution) [13]. A resistive skin layer
+        raises surface amplitudes (3.5-6x with 4.88E-4 S/m). MyoGen keeps 1 S/m as a
+        calibration: with the IT'IS value of 0.15 S/m the FDI plateau RMS is about 2.5-4x above
+        published ranges (``benchmarks/semg_dispersion``).
     grid_resolution : int, default=256
         Resolution of the computational grid used for innervation the muscle.
         Higher values provide more accurate spatial distribution but increase computational cost.
@@ -168,12 +189,18 @@ class Muscle:
     References
     ----------
     [1] Farina, D., Mesin, L., Martina, S., Merletti, R., 2004. A surface EMG generation model with multilayer cylindrical description of the volume conductor. IEEE Transactions on Biomedical Engineering 51, 415–426. https://doi.org/10.1109/TBME.2003.820998 <br>
-    [2] Konstantin, A., Yu, T., Le Carpentier, E., Aoustin, Y., Farina, D., 2020. Simulation of Motor Unit Action Potential Recordings From Intramuscular Multichannel Scanning Electrodes. IEEE Transactions on Biomedical Engineering 67, 2005–2014. https://doi.org/10.1109/TBME.2019.2953680 <br>
+    [2] Akhmadeev, K., Yu, T., Le Carpentier, E., Aoustin, Y., Farina, D., 2020. Simulation of Motor Unit Action Potential Recordings From Intramuscular Multichannel Scanning Electrodes. IEEE Transactions on Biomedical Engineering 67, 2005–2014. https://doi.org/10.1109/TBME.2019.2953680 <br>
     [3] Jacobson, M.D., Raab, R., Fazeli, B.M., Abrams, R.A., Botte, M.J., Lieber, R.L., 1992. Architectural design of the human intrinsic hand muscles. The Journal of Hand Surgery 17, 804–809. https://doi.org/10.1016/0363-5023(92)90446-V <br>
     [4] Nishizono, H., Fujimoto, T., Ohtake, H., Miyashita, M., 1990. Muscle fiber conduction velocity and contractile properties estimated from surface electrode arrays. Electroencephalography and Clinical Neurophysiology 75, 75–81. https://doi.org/10.1016/0013-4694(90)90154-C <br>
     [5] Störchle, P., Müller, W., Sengeis, M., Lackner, S., Holasek, S., Fürhapter-Rieger, A., 2018. Measurement of mean subcutaneous fat thickness: eight standardised ultrasound sites compared to 216 randomly selected sites. Sci Rep 8, 16268. https://doi.org/10.1038/s41598-018-34213-0 <br>
     [6] Brodar, V., 1960. Observations on skin thickness and subcutaneous tissue in man. Zeitschrift für Morphologie und Anthropologie 50, 386–395. <br>
-    [7] Botelho, D.P., Curran, K., Lowery, M.M., 2019. Anatomically accurate model of EMG during index finger flexion and abduction derived from diffusion tensor imaging. PLOS Computational Biology 15, e1007267. https://doi.org/10.1371/journal.pcbi.1007267
+    [7] Botelho, D.P., Curran, K., Lowery, M.M., 2019. Anatomically accurate model of EMG during index finger flexion and abduction derived from diffusion tensor imaging. PLOS Computational Biology 15, e1007267. https://doi.org/10.1371/journal.pcbi.1007267 <br>
+    [8] Roeleveld, K., Blok, J.H., Stegeman, D.F., van Oosterom, A., 1997. Volume conduction models for surface EMG; confrontation with measurements. Journal of Electromyography and Kinesiology 7, 221–232. https://doi.org/10.1016/S1050-6411(97)00009-6 <br>
+    [9] Blok, J.H., Stegeman, D.F., van Oosterom, A., 2002. Three-layer volume conductor model and software package for applications in surface electromyography. Annals of Biomedical Engineering 30, 566–577. https://doi.org/10.1114/1.1475345 <br>
+    [10] Lowery, M.M., Stoykov, N.S., Taflove, A., Kuiken, T.A., 2002. A multiple-layer finite-element model of the surface EMG signal. IEEE Transactions on Biomedical Engineering 49, 446–454. https://doi.org/10.1109/10.995683 <br>
+    [11] Li, H., Furst, D.E., Jin, H., Sun, C., Wang, X., Yang, L., He, J., Wang, Y., Liu, A., 2018. High-frequency ultrasound of the skin in systemic sclerosis: an exploratory study to examine correlation with disease activity and to define the minimally detectable difference. Arthritis Research & Therapy 20, 181. https://doi.org/10.1186/s13075-018-1686-9 <br>
+    [12] Nishikawa, Y., Watanabe, K., Holobar, A., Kitamura, R., Maeda, N., Hyngstrom, A.S., 2024. Sex differences in laterality of motor unit firing behavior of the first dorsal interosseous muscle in strength-matched healthy young males and females. European Journal of Applied Physiology 124, 1979–1990. https://doi.org/10.1007/s00421-024-05420-7 <br>
+    [13] Baumgartner, C., Hasgall, P.A., Di Gennaro, F., Neufeld, E., Lloyd, B., Gosselin, M.C., Payne, D., Klingenböck, A., Kuster, N., 2025. IT'IS Database for thermal and electromagnetic parameters of biological tissues, Version 5.0. https://doi.org/10.13099/VIP21000-05-0
     """
 
     def __init__(
@@ -187,12 +214,12 @@ def __init__(
         mean_fiber_length__mm: Quantity__mm = 31.7 * pq.mm,
         var_fiber_length__mm: Quantity__mm = 2.8 * pq.mm,
         radius_bone__mm: Quantity__mm = 0 * pq.mm,
-        fat_thickness__mm: Quantity__mm = 0.3 * pq.mm,
-        skin_thickness__mm: Quantity__mm = 1.29 * pq.mm,
+        fat_thickness__mm: Quantity__mm = 1.3 * pq.mm,
+        skin_thickness__mm: Quantity__mm = 1.2 * pq.mm,
         muscle_conductivity_radial__S_per_m: Quantity__S_per_m = 0.09 * pq.S / pq.m,
         muscle_conductivity_longitudinal__S_per_m: Quantity__S_per_m = 0.4 * pq.S / pq.m,
         fat_conductivity__S_per_m: Quantity__S_per_m = 4.07e-2 * pq.S / pq.m,
-        skin_conductivity__S_per_m: Quantity__S_per_m = 4.88e-4 * pq.S / pq.m,
+        skin_conductivity__S_per_m: Quantity__S_per_m = 1.0 * pq.S / pq.m,
         grid_resolution: int = 256,
         autorun: bool = False,
     ) -> None:
diff --git a/myogen/simulator/core/physiological_distribution.py b/myogen/simulator/core/physiological_distribution.py
index c51dd7bd..0afb6a19 100644
--- a/myogen/simulator/core/physiological_distribution.py
+++ b/myogen/simulator/core/physiological_distribution.py
@@ -34,7 +34,7 @@ def __init__(
         Following models are available:  
             - Fuglevand et al. (1993) [1]
             - De Luca & Contessa (2012) [2]
-            - Konstantin et al. (2020) [3]
+            - Akhmadeev et al. (2020) [3]
             - Combined model
 
         Parameters
@@ -72,7 +72,7 @@ def __init__(
         ----------
         [1] Fuglevand, A.J., Winter, D.A., Patla, A.E., 1993. Models of recruitment and rate coding organization in motor-unit pools. Journal of Neurophysiology 70, 2470-2488. https://doi.org/10.1152/jn.1993.70.6.2470 <br>
         [2] De Luca, C.J., Contessa, P., 2012. Hierarchical control of motor units in voluntary contractions. Journal of Neurophysiology 107, 178-195. https://doi.org/10.1152/jn.00961.2010 <br>
-        [3] Konstantin, A., Yu, T., Le Carpentier, E., Aoustin, Y., Farina, D., 2020. Simulation of Motor Unit Action Potential Recordings From Intramuscular Multichannel Scanning Electrodes. IEEE Transactions on Biomedical Engineering 67, 2005-2014. https://doi.org/10.1109/TBME.2019.2953680
+        [3] Akhmadeev, K., Yu, T., Le Carpentier, E., Aoustin, Y., Farina, D., 2020. Simulation of Motor Unit Action Potential Recordings From Intramuscular Multichannel Scanning Electrodes. IEEE Transactions on Biomedical Engineering 67, 2005-2014. https://doi.org/10.1109/TBME.2019.2953680
 
         Notes
         -----
@@ -88,7 +88,7 @@ def __init__(
 
         where $b$ = ``deluca__slope``, $i = 1, 2, \ldots, N$
 
-        **konstantin** : Konstantin et al. (2020) [3] model allowing explicit maximum threshold control
+        **konstantin** : Akhmadeev et al. (2020) [3] model (named after the first author's given name) allowing explicit maximum threshold control
 
         $$
         \begin{aligned}
@@ -116,7 +116,7 @@ def __init__(
         >>> rt = thresholds.rt
         >>> rtz = thresholds.rtz
         >>>
-        >>> # Generate thresholds using Konstantin model with explicit max threshold
+        >>> # Generate thresholds using the konstantin mode with explicit max threshold
         >>> thresholds = RecruitmentThresholds(
         ...     N=100, recruitment_range__ratio=50.0, konstantin__max_threshold__ratio=1.0, mode='konstantin'
         ... )
diff --git a/tests/test_fiber_simulation.py b/tests/test_fiber_simulation.py
index f16cfc30..aa917acf 100644
--- a/tests/test_fiber_simulation.py
+++ b/tests/test_fiber_simulation.py
@@ -351,7 +351,7 @@ def test_muap_structural_properties(self, electrode_array):
         # different mathematical approaches:
         #   - Old: frequency-domain convolution (FFT of source * H_vc, then IFFT)
         #   - New: spatial kernel IFFT + time-domain traveling-wave convolution
-        # They also differ in Rosenfalck parameterization (D1=9.6 + z/2 vs D1=96).
+        # They also differ in the Rosenfalck amplitude constant (D1=9.6 vs D1=96).
         # Strict waveform correlation is not expected; instead we verify that both
         # produce physically plausible signals with consistent structural properties.
 
@@ -392,12 +392,12 @@ def test_muap_structural_properties(self, electrode_array):
         )
 
         # 4. The amplitude order of magnitude should be within a reasonable factor
-        # (allowing for the 10x D1 difference and z/2 scaling)
+        # (allowing for the 10x D1 difference)
         old_max = np.max(np.abs(phi_old))
         new_max = np.max(np.abs(phi_new))
         ratio = new_max / old_max
         print(f"Amplitude ratio (new/old): {ratio:.2f}")
-        # The D1 difference alone gives ~10x, plus z-scaling effects.
+        # The D1 difference alone gives ~10x.
         # Allow a wide range (0.1 to 10000) to accommodate the different formulations.
         assert 0.1 < ratio < 10000, (
             f"Amplitude ratio {ratio:.1f} outside plausible range [0.1, 10000]"
diff --git a/tests/test_surface_amplitude.py b/tests/test_surface_amplitude.py
new file mode 100644
index 00000000..139e0fdd
--- /dev/null
+++ b/tests/test_surface_amplitude.py
@@ -0,0 +1,330 @@
+"""Absolute sEMG amplitude against an exact volume-conductor solution.
+
+For a homogeneous, isotropic cylinder with an insulating surface the potential
+of a point current has a closed Fourier-Bessel form (Jackson eq. 3.148 plus a
+Neumann correction; Wronskian I_n K_n' - I_n' K_n = -1/x):
+
+    phi(z, rho=r, theta) = sum_n int dk  I_n(|k| rho0) / (4 pi^2 sigma |k| r I_n'(|k| r))
+                                         * S(k) e^{ikz} e^{in theta}
+
+with S(k) the z-Fourier transform of the line current density. It is written
+here independently of MyoGen's layered-conductor code.
+"""
+import math
+
+import numpy as np
+import pytest
+import quantities as pq
+from scipy.special import ive
+
+from myogen.simulator.core.emg.electrodes import SurfaceElectrodeArray
+from myogen.simulator.core.emg.runtime.surface_preparation import SurfacePreparation
+from myogen.simulator.core.emg.surface import simulate_fiber
+
+SIGMA = 0.3       # S/m, every layer
+SIGMA_I = 1.01    # S/m, intracellular conductivity (default)
+DIAMETER = 0.05   # mm, fibre diameter (default)
+DU = 0.02         # mm
+
+
+def exact_surface_profile(i_line, du, rho0, r, sigma, n_max=200):
+    """Surface potential along z directly above a line source sampled at spacing du."""
+    n = len(i_line)
+    k = 2 * math.pi * np.fft.fftfreq(n, d=du)
+    S = np.fft.fft(i_line) * du
+    x0, x1 = np.abs(k[1:]) * rho0, np.abs(k[1:]) * r
+    total = np.zeros(n - 1)
+    for order in range(-n_max, n_max + 1):
+        m = abs(order)
+        dI = 0.5 * (ive(m - 1, x1) + ive(m + 1, x1))  # I_m'(x) e^{-x}
+        with np.errstate(divide="ignore", invalid="ignore"):
+            term = ive(m, x0) / dI * np.exp(x0 - x1)
+        total += np.where(np.isfinite(term), term, 0.0)  # high orders underflow; they vanish
+    g = np.concatenate([[0.0], total / (4 * math.pi**2 * sigma * x1)])
+    return np.real(np.fft.ifft(S * g)) * n * (2 * math.pi / (n * du))
+
+
+def rosenfalck_line_source(u, sigma_i=SIGMA_I, diameter=DIAMETER, lam=1.0):
+    """Line current density sigma_i * pi a^2 * d2Vm/dz2 of a front at u = 0 travelling towards +z.
+
+    Vm = 96 (lam z)^3 e^{-lam z} - 90 mV (Rosenfalck 1969 for lam = 1 / mm), z in mm behind the front.
+    """
+    s = -lam * u
+    dvm = np.where(s >= 0, 96 * lam * np.exp(-s) * (3 * s**2 - s**3), 0.0)
+    return sigma_i * math.pi * (diameter / 2) ** 2 * -np.gradient(dvm, u[1] - u[0])
+
+
+def _myogen_passing_wave(v, r, depth, prepared, z0=30.0, n=1024, kernel=300.0, th_fat=0.05, th_skin=0.05,
+                         r_bone=0.0, **fibre):
+    array = SurfaceElectrodeArray(1, 1, 5 * pq.mm, 0.01 * pq.mm, center_point__mm_deg=(z0 * pq.mm, 0 * pq.deg),
+                                  bending_radius__mm=r * pq.mm, differentiation_mode="monopolar")
+    phi, _, _ = simulate_fiber._simulate_fiber_v2_python(
+        Fs=10.0, v=v, N=n, M=64, r=r, r_bone=r_bone, th_fat=th_fat, th_skin=th_skin, R=r - depth, L1=140.0,
+        L2=140.0, zi=0.0, electrode_array=array, sig_muscle_rho=SIGMA, sig_muscle_z=SIGMA, sig_fat=SIGMA,
+        sig_skin=SIGMA, sig_bone=SIGMA,
+        fiber_length__mm=kernel, use_gpu=False, theta_offset=0.0,
+        _prepared=SurfacePreparation() if prepared else None, **fibre)
+    t = (np.arange(n) - n // 2) * kernel / (v * (n - 1))  # ms from the firing instant
+    window = (t > (z0 - 12) / v) & (t < (z0 + 12) / v)  # the wave passing the electrode only
+    return phi[0, 0][window]
+
+
+@pytest.mark.parametrize("prepared", [False, True], ids=["default", "prepared"])
+@pytest.mark.parametrize("v", [2.0, 4.0])
+@pytest.mark.parametrize("r, depth", [(10.0, 2.0), (20.0, 3.0)])
+def test_single_fibre_amplitude_matches_the_exact_cylinder_solution(r, depth, v, prepared):
+    u = np.arange(-60, 60, DU)
+    exact = exact_surface_profile(rosenfalck_line_source(u), DU, r - depth, r, SIGMA)
+    simulated = _myogen_passing_wave(v, r, depth, prepared)
+    # Amplitude must not depend on conduction velocity: the spatial wave is the same.
+    assert np.ptp(simulated) == pytest.approx(np.ptp(exact), rel=0.02)
+
+
+@pytest.mark.parametrize("prepared", [False, True], ids=["default", "prepared"])
+@pytest.mark.parametrize("layers", [dict(th_fat=1.5, th_skin=1.0), dict(r_bone=1.0),
+                                    dict(th_fat=1.5, th_skin=1.0, r_bone=1.0)],
+                         ids=["thick-fat-skin", "bone", "both"])
+def test_interfaces_between_equal_conductivities_are_transparent(layers, prepared):
+    # Production geometries use real layer thicknesses and a bone; with every
+    # conductivity equal they must reduce to the same exact homogeneous solution.
+    r, depth = 12.0, 5.0
+    u = np.arange(-60, 60, DU)
+    exact = exact_surface_profile(rosenfalck_line_source(u), DU, r - depth, r, SIGMA)
+    simulated = _myogen_passing_wave(4.0, r, depth, prepared, **layers)
+    assert np.ptp(simulated) == pytest.approx(np.ptp(exact), rel=0.02)
+
+
+@pytest.mark.parametrize("fibre, scale", [(dict(fiber_diameter__mm=0.08), (0.08 / DIAMETER) ** 2),
+                                          (dict(sig_intracellular=0.5), 0.5 / SIGMA_I)])
+def test_source_scales_with_fibre_cross_section_and_intracellular_conductivity(fibre, scale):
+    reference = np.ptp(_myogen_passing_wave(4.0, 10.0, 2.0, False))
+    assert np.ptp(_myogen_passing_wave(4.0, 10.0, 2.0, False, **fibre)) == pytest.approx(scale * reference, rel=1e-6)
+
+
+@pytest.mark.parametrize("prepared", [False, True], ids=["default", "prepared"])
+@pytest.mark.parametrize("lam", [0.7, 0.5])
+def test_iap_length_scale_matches_the_exact_cylinder_solution(lam, prepared):
+    # lam < 1 / mm stretches the Rosenfalck IAP along the fibre (Botelho et al. 2019 used 0.5).
+    r, depth = 10.0, 2.0
+    u = np.arange(-60, 60, DU)
+    exact = exact_surface_profile(rosenfalck_line_source(u, lam=lam), DU, r - depth, r, SIGMA)
+    simulated = _myogen_passing_wave(4.0, r, depth, prepared, iap_lambda__per_mm=lam)
+    assert np.ptp(simulated) == pytest.approx(np.ptp(exact), rel=0.02)
+
+
+@pytest.mark.parametrize("kwargs", [dict(iap_lambda__per_mm=0.0), dict(iap_lambda__per_mm=0.7, use_unified=True)],
+                         ids=["non-positive", "unified-route"])
+def test_unsupported_iap_length_scales_are_rejected(kwargs):
+    # The unified route has its own Rosenfalck source and would silently ignore lambda.
+    from myogen.simulator import Muscle, RecruitmentThresholds, SurfaceEMG
+
+    thresholds, _ = RecruitmentThresholds(N=5, recruitment_range__ratio=10, mode="konstantin")
+    array = SurfaceElectrodeArray(1, 1, 5 * pq.mm, 0.5 * pq.mm, center_point__mm_deg=(8 * pq.mm, 0 * pq.deg))
+    with pytest.raises(ValueError, match="iap_lambda__per_mm"):
+        SurfaceEMG(Muscle(thresholds), [array], **kwargs)
+
+
+@pytest.mark.parametrize("route", ["default", "execution"])
+@pytest.mark.usefixtures("ample_session_memory")
+def test_surface_emg_passes_fibre_properties_to_every_fibre(route, monkeypatch):
+    from myogen import set_random_seed
+    from myogen.simulator import ExecutionPolicy, Muscle, RecruitmentThresholds, SurfaceEMG
+    from myogen.simulator.core.emg.runtime import semg as runtime_semg
+    from myogen.simulator.core.emg.surface import surface_emg
+
+    set_random_seed(42)
+    thresholds, _ = RecruitmentThresholds(N=10, recruitment_range__ratio=20, mode="konstantin")
+    muscle = Muscle(thresholds, fiber_density__fibers_per_mm2=5 * pq.mm**-2)
+    muscle.distribute_innervation_centers()
+    muscle.generate_muscle_fiber_centers(verbose=False)
+    muscle.assign_mfs2mns(verbose=False, n_jobs=1)
+    calls = []
+
+    def spy(**kwargs):
+        calls.append((kwargs["fiber_diameter__mm"], kwargs["sig_intracellular"], kwargs["iap_lambda__per_mm"]))
+        array = kwargs["electrode_array"]
+        return np.zeros((array.num_rows, array.num_cols, kwargs["N"])), None, None
+
+    monkeypatch.setattr(surface_emg, "_simulate_fiber_v2_python", spy)
+    monkeypatch.setattr(runtime_semg, "_simulate_fiber_v2_python", spy)
+    array = SurfaceElectrodeArray(1, 1, 5 * pq.mm, 0.5 * pq.mm, center_point__mm_deg=(8 * pq.mm, 0 * pq.deg))
+    semg = SurfaceEMG(muscle, [array], MUs_to_simulate=[1, 2], fiber_diameter__um=60.0,
+                      intracellular_conductivity__S_m=0.9, iap_lambda__per_mm=0.7)
+    if route == "default":
+        semg.simulate_muaps(n_jobs=1, verbose=False, use_gpu=False)
+    else:
+        semg.simulate_muaps(n_jobs=1, verbose=False, execution=ExecutionPolicy())
+    assert calls and all(d == pytest.approx(0.06) and s == pytest.approx(0.9) and lam == pytest.approx(0.7)
+                         for d, s, lam in calls)
+
+
+def test_default_skin_conductivity_is_farina_value():
+    # 1 S/m as in Farina et al. (2004), from Roeleveld et al. (1997): an effective, fitted value.
+    # The previous default (4.88e-4 S/m, measured skin) raised surface amplitudes 3.5-6x.
+    from myogen.simulator import Muscle, RecruitmentThresholds
+
+    thresholds, _ = RecruitmentThresholds(N=5, recruitment_range__ratio=10, mode="konstantin")
+    muscle = Muscle(thresholds)
+    assert float(muscle.skin_conductivity__S_m.rescale(pq.S / pq.m).magnitude) == pytest.approx(1.0)
+
+
+def test_default_layers_are_fdi_literature_values():
+    # Skin 1.2 mm over the hand dorsum (Li et al. 2018, controls); fat 1.3 mm makes the total depth
+    # to muscle 2.5 mm, the low end of the FDI subcutaneous depth of Nishikawa et al. (2024).
+    from myogen.simulator import Muscle, RecruitmentThresholds
+
+    thresholds, _ = RecruitmentThresholds(N=5, recruitment_range__ratio=10, mode="konstantin")
+    muscle = Muscle(thresholds)
+    assert float(muscle.skin_thickness__mm.rescale(pq.mm).magnitude) == pytest.approx(1.2)
+    assert float(muscle.fat_thickness__mm.rescale(pq.mm).magnitude) == pytest.approx(1.3)
+
+
+@pytest.mark.parametrize("route", ["default", "execution"])
+@pytest.mark.usefixtures("ample_session_memory")
+def test_a_failing_motor_unit_raises_instead_of_returning_zeros(route, monkeypatch):
+    # A per-unit failure (e.g. a singular conductor system at high angular order) used to be logged and
+    # replaced by an all-zero MUAP, which looks like a valid, silent unit.
+    from myogen import set_random_seed
+    from myogen.simulator import ExecutionPolicy, Muscle, RecruitmentThresholds, SurfaceEMG
+    from myogen.simulator.core.emg.runtime import semg as runtime_semg
+    from myogen.simulator.core.emg.surface import surface_emg
+
+    set_random_seed(42)
+    thresholds, _ = RecruitmentThresholds(N=10, recruitment_range__ratio=20, mode="konstantin")
+    muscle = Muscle(thresholds, fiber_density__fibers_per_mm2=5 * pq.mm**-2)
+    muscle.distribute_innervation_centers()
+    muscle.generate_muscle_fiber_centers(verbose=False)
+    muscle.assign_mfs2mns(verbose=False, n_jobs=1)
+
+    def broken(**kwargs):
+        raise np.linalg.LinAlgError("Singular matrix")
+
+    monkeypatch.setattr(surface_emg, "_simulate_fiber_v2_python", broken)
+    monkeypatch.setattr(runtime_semg, "_simulate_fiber_v2_python", broken)
+    array = SurfaceElectrodeArray(1, 1, 5 * pq.mm, 0.5 * pq.mm, center_point__mm_deg=(8 * pq.mm, 0 * pq.deg))
+    semg = SurfaceEMG(muscle, [array], MUs_to_simulate=[1, 2])
+    with pytest.raises(np.linalg.LinAlgError):
+        if route == "default":
+            semg.simulate_muaps(n_jobs=1, verbose=False, use_gpu=False)
+        else:
+            semg.simulate_muaps(n_jobs=1, verbose=False, execution=ExecutionPolicy())
+
+
+def _bessel_ratios():
+    from scipy.special import kve
+
+    def ir(n, a, b):  # I_n(a) / I_n(b)
+        return ive(n, a) / ive(n, b) * np.exp(a - b)
+
+    def ipr(n, a, b):  # I_n'(a) / I_n(b)
+        return 0.5 * (ive(n - 1, a) + ive(n + 1, a)) / ive(n, b) * np.exp(a - b)
+
+    def kr(n, a, b):  # K_n(a) / K_n(b)
+        return kve(n, a) / kve(n, b) * np.exp(b - a)
+
+    def kpr(n, a, b):  # K_n'(a) / K_n(b)
+        return -0.5 * (kve(n - 1, a) + kve(n + 1, a)) / kve(n, b) * np.exp(b - a)
+
+    return ir, ipr, kr, kpr, kve
+
+
+def layered_surface_profile(i_line, du, rho0, rm, rf, rs, sr, sz, sf, ss, n_max=120, k_max=40.0):
+    """Surface potential above a line source in an insulated cylinder: anisotropic muscle (sr, sz) to rm,
+    isotropic fat (sf) to rf and skin (ss) to rs. Per angular order and k_z, the muscle field is the free-space
+    term I_n(q rho<) K_n(q rho>) / sr (q = |k| sqrt(sz / sr)) plus A I_n(q rho); each outer layer is
+    B I_n(|k| rho) + C K_n(|k| rho); potential and normal current are continuous and the surface is insulated."""
+    ir, ipr, kr, kpr, kve = _bessel_ratios()
+    n = len(i_line)
+    k = 2 * math.pi * np.fft.fftfreq(n, d=du)
+    S = np.fft.fft(i_line) * du
+    sel = (np.abs(k) > 0) & (np.abs(k) < k_max)
+    kk = np.abs(k[sel])
+    q = math.sqrt(sz / sr) * kk
+    total = np.zeros(kk.size)
+    for order in range(-n_max, n_max + 1):
+        m = abs(order)
+        with np.errstate(all="ignore"):
+            src = ive(m, q * rho0) * np.exp(q * rho0 - q * rm) / sr
+            A = np.zeros((kk.size, 5, 5))
+            b = np.zeros((kk.size, 5))
+            A[:, 0, 0], A[:, 0, 1], A[:, 0, 2] = 1, -ir(m, kk * rm, kk * rf), -1
+            b[:, 0] = -src * kve(m, q * rm)
+            A[:, 1, 0] = sr * q * ipr(m, q * rm, q * rm)
+            A[:, 1, 1], A[:, 1, 2] = -sf * kk * ipr(m, kk * rm, kk * rf), -sf * kk * kpr(m, kk * rm, kk * rm)
+            b[:, 1] = sr * q * src * 0.5 * (kve(m - 1, q * rm) + kve(m + 1, q * rm))
+            A[:, 2, 1], A[:, 2, 2] = 1, kr(m, kk * rf, kk * rm)
+            A[:, 2, 3], A[:, 2, 4] = -ir(m, kk * rf, kk * rs), -1
+            A[:, 3, 1], A[:, 3, 2] = sf * kk * ipr(m, kk * rf, kk * rf), sf * kk * kpr(m, kk * rf, kk * rm)
+            A[:, 3, 3], A[:, 3, 4] = -ss * kk * ipr(m, kk * rf, kk * rs), -ss * kk * kpr(m, kk * rf, kk * rf)
+            A[:, 4, 3], A[:, 4, 4] = ipr(m, kk * rs, kk * rs), kpr(m, kk * rs, kk * rf)
+            ok = np.all(np.isfinite(A), axis=(1, 2)) & np.all(np.isfinite(b), axis=1)
+            x = np.zeros((kk.size, 5))
+            if ok.any():
+                x[ok] = np.linalg.solve(A[ok], b[ok][..., None])[..., 0]
+            phi = x[:, 3] + x[:, 4] * kr(m, kk * rs, kk * rf)
+        total += np.where(np.isfinite(phi), phi, 0.0)
+    g = np.zeros(n)
+    g[sel] = total / (4 * math.pi**2)
+    return np.real(np.fft.ifft(S * g)) * n * (2 * math.pi / (n * du))
+
+
+def _myogen_layered(v, rm, depth, sr, sz, fat, skin, sf, ss, z0=30.0, n=1024, kernel=300.0, L=140.0,
+                    mode="monopolar", ied=5.0, window=True):
+    # The volume conductor's r is the outer (skin) radius; R is the fibre's radial position.
+    array = SurfaceElectrodeArray(1, 1, ied * pq.mm, 0.01 * pq.mm, center_point__mm_deg=(z0 * pq.mm, 0 * pq.deg),
+                                  bending_radius__mm=(rm + fat + skin) * pq.mm, differentiation_mode=mode)
+    phi, _, _ = simulate_fiber._simulate_fiber_v2_python(
+        Fs=10.0, v=v, N=n, M=64, r=rm + fat + skin, r_bone=0.0, th_fat=fat, th_skin=skin, R=rm - depth, L1=L, L2=L,
+        zi=0.0, electrode_array=array, sig_muscle_rho=sr, sig_muscle_z=sz, sig_fat=sf, sig_skin=ss, sig_bone=sr,
+        fiber_length__mm=kernel, use_gpu=False, theta_offset=0.0)
+    if not window:
+        return phi[0, 0]
+    t = (np.arange(n) - n // 2) * kernel / (v * (n - 1))
+    return phi[0, 0][(t > (z0 - 12) / v) & (t < (z0 + 12) / v)]
+
+
+def test_layered_solver_reduces_to_the_homogeneous_solution():
+    u = np.arange(-60, 60, DU)
+    src = rosenfalck_line_source(u)
+    layered = layered_surface_profile(src, DU, 8.0, 9.0, 9.5, 10.0, SIGMA, SIGMA, SIGMA, SIGMA)
+    assert np.ptp(layered) == pytest.approx(np.ptp(exact_surface_profile(src, DU, 8.0, 10.0, SIGMA)), rel=1e-3)
+
+
+@pytest.mark.parametrize("skin_sigma", [1.0, 0.15])
+@pytest.mark.parametrize("depth", [0.5, 2.0])
+def test_anisotropic_muscle_under_fat_and_skin_matches_independent_solution(depth, skin_sigma):
+    # FDI-like layers: muscle 0.1 / 0.5 S/m (radial / axial), fat 0.05 S/m 1.3 mm, skin 1.2 mm.
+    rm = 6.91
+    u = np.arange(-60, 60, DU)
+    ref = layered_surface_profile(rosenfalck_line_source(u), DU, rm - depth, rm, rm + 1.3, rm + 2.5,
+                                  0.1, 0.5, 0.05, skin_sigma)
+    simulated = _myogen_layered(4.0, rm, depth, 0.1, 0.5, 1.3, 1.2, 0.05, skin_sigma)
+    assert np.ptp(simulated) == pytest.approx(np.ptp(ref), rel=0.01)
+
+
+@pytest.mark.parametrize("ied", [5.0, 10.0])
+def test_finite_fibre_bipolar_matches_sealed_end_cable_source(ied):
+    # End-plate generation and tendon extinction: the transmembrane current of a sealed-end fibre
+    # (axial current -sigma_i pi a^2 dVm/dz, zero beyond the ends), convolved with the layered point-source
+    # potential, against MyoGen's finite-fibre source. Bipolar, so the far-field common mode cancels.
+    rm, fat, skin, depth, half, v, ze = 6.91, 1.3, 1.2, 2.0, 15.0, 4.0, 8.0
+    u = np.arange(-80, 80, DU)
+    delta = np.zeros_like(u)
+    delta[np.argmin(np.abs(u))] = 1.0 / DU
+    green = layered_surface_profile(delta, DU, rm - depth, rm, rm + fat, rm + fat + skin, 0.1, 0.5, 0.05, 1.0,
+                                    n_max=150)
+    zf = np.arange(-half, half + DU / 2, DU)
+    channels = []
+    for z in (ze + ied / 2, ze - ied / 2):
+        g = np.interp(z - zf, u, green)
+        phi = []
+        for t in np.arange(0, 14, 0.02):
+            s = v * t - np.abs(zf)
+            vm = np.where(s >= 0, 96 * s**3 * np.exp(-np.clip(s, 0, None)), 0.0)
+            axial = np.concatenate([[0.0], -SIGMA_I * math.pi * (DIAMETER / 2) ** 2 * np.diff(vm) / DU, [0.0]])
+            phi.append(np.sum(-np.diff(axial) * g))
+        channels.append(np.array(phi))
+    reference = channels[0] - channels[1]
+    simulated = _myogen_layered(v, rm, depth, 0.1, 0.5, fat, skin, 0.05, 1.0, z0=ze, n=4096, L=half,
+                                mode="bipolar_longitudinal", ied=ied, window=False)
+    assert np.ptp(simulated) == pytest.approx(np.ptp(reference), rel=0.01)
diff --git a/tests/test_surface_dispersion.py b/tests/test_surface_dispersion.py
new file mode 100644
index 00000000..5e246829
--- /dev/null
+++ b/tests/test_surface_dispersion.py
@@ -0,0 +1,386 @@
+"""Per-fibre dispersion in the surface-EMG model.
+
+Axon-branch delays and end-plate positions come from the two-layer nerve model
+that basic MyoGen already uses for intramuscular EMG (Akhmadeev et al. 2020);
+muscle-fibre conduction velocity may vary per fibre. Every option defaults to
+off, and off must reproduce the undispersed model exactly.
+"""
+import numpy as np
+import pytest
+import quantities as pq
+from scipy.signal import resample
+
+from myogen import derive_subseed, get_random_generator, set_random_seed
+from myogen.simulator import (
+    ExecutionPolicy,
+    Muscle,
+    RecruitmentThresholds,
+    SurfaceElectrodeArray,
+    SurfaceEMG,
+)
+from myogen.simulator.core.emg.intramuscular.motor_unit_sim import MotorUnitSim
+from myogen.simulator.core.emg.nerve_branches import (
+    nerve_delays__ms,
+    nmj_branch_schedule,
+    two_layer_nmj,
+)
+from myogen.simulator.core.emg.surface import simulate_fiber
+from myogen.simulator.core.emg.surface.fiber_dispersion import (
+    SurfaceFiberDispersion,
+    realize_fiber_dispersion,
+)
+from myogen.utils.neo import signal_to_grid
+
+GEOMETRY = dict(r=8.5, r_bone=0.0, th_fat=0.3, th_skin=1.29, sig_muscle_rho=0.09,
+                sig_muscle_z=0.4, sig_fat=4.07e-2, sig_skin=1.0)
+N = 512
+KERNEL = 100.0  # mm
+
+
+def _array(z0=10.0, mode="monopolar"):
+    return SurfaceElectrodeArray(1, 1, 10 * pq.mm, 0.5 * pq.mm,
+                                 center_point__mm_deg=(z0 * pq.mm, 0 * pq.deg),
+                                 bending_radius__mm=GEOMETRY["r"] * pq.mm,
+                                 differentiation_mode=mode)
+
+
+def _fibre(v, v_grid=None, n=N, zi=0.0):
+    kwargs = {} if v_grid is None else {"v_grid": v_grid}
+    phi, _, _ = simulate_fiber._simulate_fiber_v2_python(
+        Fs=10.0, v=v, N=n, M=32, R=6.5, L1=20.0 - zi, L2=20.0 + zi, zi=zi,
+        electrode_array=_array(), fiber_length__mm=KERNEL, use_gpu=False, **kwargs, **GEOMETRY)
+    return phi[0, 0]
+
+
+# ---- two-layer nerve model: one authority shared with intramuscular EMG ----------
+
+def test_two_layer_function_reproduces_motor_unit_sim():
+    set_random_seed(5)
+    xy = get_random_generator().uniform(-3, 3, size=(40, 2))
+    set_random_seed(11)
+    sim = MotorUnitSim(muscle_fiber_centers__mm=xy, muscle_length__mm=80.0,
+                       muscle_fiber_diameters__mm=np.full(40, 0.05),
+                       muscle_fiber_conduction_velocity__mm_per_s=np.full(40, 4000.0),
+                       nominal_center__mm=np.zeros(2))
+    sim.sim_nmj_branches_two_layers(3, 40.0, 2.0, 0.8)
+    set_random_seed(11)
+    nmj_z, paths = two_layer_nmj(xy, 3, 40.0, 2.0, 0.8, rng=get_random_generator(),
+                                 kmeans_seed=derive_subseed(3))
+    np.testing.assert_allclose(np.ravel(sim._neuromuscular_z_coordinates__mm), nmj_z, rtol=0, atol=1e-12)
+    np.testing.assert_allclose(sim.nerve_paths, paths, rtol=0, atol=1e-12)
+
+
+def test_branch_schedule_grows_with_motor_unit_size():
+    thresholds = np.array([1.0, np.e, np.e**2, np.e**3])
+    # Default: published coefficients (Akhmadeev et al. 2020, eq. 5-6): a_mu=1, b_mu=2.5, a_sigma=0.25, b_sigma=1 mm
+    n_branches, branch_sd, arbor_sd = nmj_branch_schedule(thresholds)
+    np.testing.assert_array_equal(n_branches, [1, 2, 3, 4])
+    spread = np.concatenate([[0], np.cumsum(thresholds)[:-1]]) / thresholds.sum()
+    np.testing.assert_allclose(branch_sd, 1.0 + 2.5 * spread)
+    np.testing.assert_allclose(arbor_sd, 0.25 + 1.0 * spread)
+    # Akhmadeev's reference simulator code
+    _, branch_sd, arbor_sd = nmj_branch_schedule(thresholds, coefficients="reference_code")
+    np.testing.assert_allclose(branch_sd, 1.5 + 4.0 * spread)
+    np.testing.assert_allclose(arbor_sd, 0.5 + 1.5 * spread)
+    with pytest.raises(ValueError):
+        nmj_branch_schedule(thresholds, coefficients="other")
+
+
+def test_surface_dispersion_can_use_the_published_coefficients(muscle):
+    zones = np.zeros(12)
+    script = _realize(muscle, SurfaceFiberDispersion(nmj_model="two_layer_intra", nmj_coefficients="reference_code"),
+                      zones)
+    paper = _realize(muscle, SurfaceFiberDispersion(nmj_model="two_layer_intra"), zones)
+    big = max(range(12), key=lambda i: len(paper.zi__mm[i]))
+    assert np.std(paper.zi__mm[big]) < np.std(script.zi__mm[big])
+    with pytest.raises(ValueError):
+        SurfaceFiberDispersion(nmj_coefficients="other")
+
+
+def test_nerve_delay_is_path_over_branch_velocity():
+    paths = np.array([[5.0, 2.0], [0.0, 4.0]])  # mm
+    np.testing.assert_allclose(nerve_delays__ms(paths, (5.0, 2.0)), [2.0, 2.0])
+
+
+# ---- fibre velocity is decoupled from the time grid -------------------------------
+
+def test_reference_grid_velocity_defaults_to_the_fibre_velocity():
+    np.testing.assert_array_equal(_fibre(4.2, v_grid=4.2), _fibre(4.2))
+
+
+@pytest.mark.parametrize("v", [3.4, 5.0])
+def test_fibre_on_a_shared_grid_matches_its_own_grid(v):
+    # Native run: dt = KERNEL / (v (N-1)). Shared run: dt = KERNEL / (4.2 (N-1)).
+    n = 1024
+    native = _fibre(v, n=n)
+    shared = _fibre(v, v_grid=4.2, n=n)
+    t_native = (np.arange(n) - n // 2) * KERNEL / (v * (n - 1))
+    t_shared = (np.arange(n) - n // 2) * KERNEL / (4.2 * (n - 1))
+    up = 16
+    fine = resample(native, n * up)
+    t_fine = (np.arange(n * up) - n // 2 * up) * KERNEL / (v * (n - 1)) / up
+    expected = np.interp(t_shared, t_fine, fine, left=0.0, right=0.0)
+    inside = np.abs(t_shared) < 0.45 * min(t_native.max(), t_shared.max())
+    err = np.max(np.abs(shared[inside] - expected[inside])) / np.ptp(expected)
+    assert err < 0.01
+
+
+# ---- fractional delay ---------------------------------------------------------------
+
+def test_delay_moves_the_signal_by_the_requested_time():
+    fs = 20.0  # kHz
+    t = np.arange(2048) / fs
+    x = np.exp(-((t - 40.0) / 0.8) ** 2)[None, None, :]
+    y = simulate_fiber.delay_fibre_signal(x, 1.37, fs)
+    up = resample(y[0, 0], 2048 * 50)
+    assert np.argmax(up) / 50 / fs == pytest.approx(41.37, abs=0.01)
+    np.testing.assert_array_equal(simulate_fiber.delay_fibre_signal(x, 0.0, fs), x)
+
+
+# ---- realisation --------------------------------------------------------------------
+
+def _muscle():
+    set_random_seed(42)
+    thresholds, _ = RecruitmentThresholds(N=12, recruitment_range__ratio=30, mode="fuglevand")
+    muscle = Muscle(thresholds, radius__mm=6 * pq.mm, length__mm=60 * pq.mm,
+                    fiber_density__fibers_per_mm2=6 * pq.mm**-2, mean_fiber_length__mm=50 * pq.mm,
+                    var_fiber_length__mm=2 * pq.mm, radius_bone__mm=0 * pq.mm,
+                    fat_thickness__mm=1 * pq.mm)
+    muscle.distribute_innervation_centers()
+    muscle.generate_muscle_fiber_centers(verbose=False)
+    muscle.assign_mfs2mns(verbose=False, n_jobs=1)
+    return muscle
+
+
+@pytest.fixture(scope="module")
+def muscle():
+    return _muscle()
+
+
+def _realize(muscle, config, zones=None):
+    counts = np.asarray(muscle.resulting_number_of_innervated_fibers)
+    zones = np.zeros(len(counts)) if zones is None else zones
+    positions = [np.asarray(muscle.resulting_fiber_assignment(i)) for i in range(len(counts))]
+    return realize_fiber_dispersion(config, positions, np.asarray(muscle.recruitment_thresholds),
+                                    zones, mean_cv__m_s=4.2)
+
+
+def test_default_config_is_the_undispersed_model(muscle):
+    zones = np.linspace(-2, 2, 12)
+    real = _realize(muscle, SurfaceFiberDispersion(), zones)
+    for mu, z in enumerate(zones):
+        n = len(real.cv__m_s[mu])
+        np.testing.assert_array_equal(real.zi__mm[mu], np.full(n, z))
+        np.testing.assert_array_equal(real.cv__m_s[mu], np.full(n, 4.2))
+        np.testing.assert_array_equal(real.delay__ms[mu], np.zeros(n))
+        np.testing.assert_array_equal(real.amplitude_scale[mu], np.ones(n))
+    assert not SurfaceFiberDispersion().active
+
+
+def test_fibre_cv_spreads_follow_the_configuration(muscle):
+    real = _realize(muscle, SurfaceFiberDispersion(fiber_cv_inter_mu_spread=0.3,
+                                                   fiber_cv_within_mu_cov=0.08))
+    means = np.array([np.mean(c) for c in real.cv__m_s if len(c)])
+    assert means[0] == pytest.approx(4.2 * 0.85, rel=0.05)
+    assert means[-1] == pytest.approx(4.2 * 1.15, rel=0.05)
+    big = max(range(12), key=lambda i: len(real.cv__m_s[i]))
+    c = real.cv__m_s[big]
+    assert np.std(c) / np.mean(c) == pytest.approx(0.08, rel=0.25)
+    assert np.all(real.amplitude_scale[big] == 1.0)  # amplitude coupling is a separate switch
+
+
+def test_fibre_cv_rises_linearly_with_recruitment_threshold(muscle):
+    real = _realize(muscle, SurfaceFiberDispersion(fiber_cv_threshold_slope=0.63))
+    rt = np.asarray(muscle.recruitment_thresholds, dtype=float)
+    rt = rt / rt.max()
+    for mu, cv in enumerate(real.cv__m_s):
+        np.testing.assert_allclose(cv, 4.2 * (1 + 0.63 * (rt[mu] - rt.mean())))
+    with pytest.raises(ValueError):
+        SurfaceFiberDispersion(fiber_cv_threshold_slope=0.6, fiber_cv_inter_mu_spread=0.3)
+
+
+def test_diameter_coupling_scales_source_with_cross_section(muscle):
+    cfg = SurfaceFiberDispersion(fiber_cv_within_mu_cov=0.08, diameter_scales_source=True)
+    real = _realize(muscle, cfg)
+    big = max(range(12), key=lambda i: len(real.cv__m_s[i]))
+    # Diameter from the CV line v = 0.95 m/s + 0.05 m/s/um * d (Nandedkar & Stalberg 1983)
+    diameter__um = (real.cv__m_s[big] - 0.95) / 0.05
+    np.testing.assert_allclose(real.amplitude_scale[big], (diameter__um / ((4.2 - 0.95) / 0.05)) ** 2)
+    assert real.report["diameter_mean__um"][big] == pytest.approx(np.mean(diameter__um))
+
+
+def test_intra_mu_scatter_keeps_each_motor_unit_anchor(muscle):
+    zones = np.linspace(-2, 2, 12)
+    real = _realize(muscle, SurfaceFiberDispersion(nmj_model="two_layer_intra"), zones)
+    for mu in range(12):
+        if len(real.zi__mm[mu]) > 1:
+            assert np.mean(real.zi__mm[mu]) == pytest.approx(zones[mu], abs=1e-9)
+            assert np.std(real.zi__mm[mu]) > 0.1
+
+
+def test_nerve_delays_switch_independently_of_end_plates(muscle):
+    real = _realize(muscle, SurfaceFiberDispersion(nerve_delays=True))
+    big = max(range(12), key=lambda i: len(real.cv__m_s[i]))
+    np.testing.assert_array_equal(real.zi__mm[big], np.zeros(len(real.zi__mm[big])))
+    assert np.std(real.delay__ms[big]) > 0
+    assert real.report["delay_sd__ms"][big] == pytest.approx(np.std(real.delay__ms[big]))
+
+
+def _realize_with_lengths(muscle, config, mean_length=70.0, var=2.8):
+    counts = np.asarray(muscle.resulting_number_of_innervated_fibers)
+    positions = [np.asarray(muscle.resulting_fiber_assignment(i)) for i in range(len(counts))]
+    lengths = [mean_length + np.random.default_rng(i).uniform(-var, var, size=n) for i, n in enumerate(counts)]
+    real = realize_fiber_dispersion(config, positions, np.asarray(muscle.recruitment_thresholds),
+                                    np.zeros(len(counts)), mean_cv__m_s=4.2, fiber_lengths__mm=lengths,
+                                    mean_fiber_length__mm=mean_length)
+    return real, lengths
+
+
+def test_fibre_ends_follow_the_fibre_length_by_default(muscle):
+    real, lengths = _realize_with_lengths(muscle, SurfaceFiberDispersion(nerve_delays=True))
+    for mu, length in enumerate(lengths):
+        np.testing.assert_array_equal(real.end_plus__mm[mu], length / 2)
+        np.testing.assert_array_equal(real.end_minus__mm[mu], -length / 2)
+
+
+def test_tendon_band_staggers_each_end_independently(muscle):
+    real, _ = _realize_with_lengths(muscle, SurfaceFiberDispersion(tendon_end_band__mm=8.0))
+    assert SurfaceFiberDispersion(tendon_end_band__mm=8.0).active
+    plus = np.concatenate(real.end_plus__mm)
+    minus = np.concatenate(real.end_minus__mm)
+    assert np.all(np.abs(plus - 35.0) <= 4.0) and np.all(np.abs(minus + 35.0) <= 4.0)
+    assert np.std(plus) == pytest.approx(8.0 / np.sqrt(12), rel=0.1)
+    assert abs(np.corrcoef(plus, minus)[0, 1]) < 4 / np.sqrt(len(plus))  # independent within sampling error
+    big = max(range(12), key=lambda i: len(real.end_plus__mm[i]))
+    assert real.report["end_sd__mm"][big] == pytest.approx(np.std(real.end_plus__mm[big]))
+
+
+def _end_variogram(muscle, real, near__mm, far__mm):
+    xy = np.concatenate([np.asarray(muscle.resulting_fiber_assignment(i))[:, :2] for i in range(12)])
+    plus = np.concatenate(real.end_plus__mm)
+    i, j = np.triu_indices(len(xy), k=1)
+    d = np.hypot(*(xy[i] - xy[j]).T)
+    sq = (plus[i] - plus[j]) ** 2
+    return np.mean(sq[d < near__mm]), np.mean(sq[d > far__mm])
+
+
+def test_correlated_tendon_ends_vary_smoothly_between_neighbours(muscle):
+    config = SurfaceFiberDispersion(tendon_end_band__mm=8.0, tendon_end_correlation__mm=2.0,
+                                    tendon_end_jitter__mm=0.3)
+    real, _ = _realize_with_lengths(muscle, config)
+    near, far = _end_variogram(muscle, real, 0.5, 8.0)
+    assert near < 0.2 * far
+    independent, _ = _realize_with_lengths(muscle, SurfaceFiberDispersion(tendon_end_band__mm=8.0))
+    near_independent, _ = _end_variogram(muscle, independent, 0.5, 8.0)
+    assert near < 0.2 * near_independent
+    sd = real.report["end_sd__mm"]
+    assert np.nanmedian(sd) < np.nanmedian(independent.report["end_sd__mm"])
+
+
+def test_tendon_end_correlation_needs_a_band_and_room_for_the_jitter():
+    with pytest.raises(ValueError, match="tendon_end_band"):
+        SurfaceFiberDispersion(tendon_end_correlation__mm=2.0)
+    with pytest.raises(ValueError, match="jitter"):
+        SurfaceFiberDispersion(tendon_end_band__mm=1.0, tendon_end_correlation__mm=2.0,
+                               tendon_end_jitter__mm=0.5)
+    with pytest.raises(ValueError, match="non-negative"):
+        SurfaceFiberDispersion(tendon_end_band__mm=5.0, tendon_end_correlation__mm=-1.0)
+
+
+def test_realisation_leaves_the_global_generator_untouched(muscle):
+    set_random_seed(3)
+    expected = get_random_generator().uniform(size=4)
+    set_random_seed(3)
+    _realize(muscle, SurfaceFiberDispersion(nmj_model="two_layer", nerve_delays=True,
+                                            fiber_cv_within_mu_cov=0.05))
+    np.testing.assert_array_equal(get_random_generator().uniform(size=4), expected)
+
+
+# ---- SurfaceEMG integration ---------------------------------------------------------
+
+def _semg(muscle, dispersion=None, mus=(4, 11)):
+    array = SurfaceElectrodeArray(1, 1, 10 * pq.mm, 2.5 * pq.mm,
+                                  center_point__mm_deg=(12 * pq.mm, 0 * pq.deg),
+                                  bending_radius__mm=8.3 * pq.mm,
+                                  differentiation_mode="bipolar_longitudinal")
+    set_random_seed(7)
+    return SurfaceEMG(muscle, [array], sampling_frequency__Hz=2048 * pq.Hz,
+                      internal_sampling_frequency__Hz=2048 * pq.Hz,
+                      MUs_to_simulate=list(mus), fiber_dispersion=dispersion)
+
+
+def _muaps(semg):
+    block = semg.simulate_muaps(n_jobs=1, verbose=False, use_gpu=False)
+    return np.array([np.asarray(signal_to_grid(s.analogsignals[0].rescale(pq.mV)))
+                     for s in block.groups[0].segments])
+
+
+def test_inactive_dispersion_is_bit_identical(muscle):
+    np.testing.assert_array_equal(_muaps(_semg(muscle)),
+                                  _muaps(_semg(muscle, SurfaceFiberDispersion())))
+
+
+def test_dispersion_changes_the_muap_and_is_reported(muscle):
+    base = _muaps(_semg(muscle))
+    semg = _semg(muscle, SurfaceFiberDispersion(nerve_delays=True, fiber_cv_within_mu_cov=0.08))
+    dispersed = _muaps(semg)
+    assert not np.allclose(base[11], dispersed[11])
+    report = semg.fiber_dispersion_report
+    assert report["delay_sd__ms"][11] > 0 and report["cv_cov"][11] > 0
+
+
+def test_tendon_band_changes_the_muap(muscle):
+    base = _muaps(_semg(muscle))
+    staggered = _muaps(_semg(muscle, SurfaceFiberDispersion(tendon_end_band__mm=10.0)))
+    assert not np.allclose(base[11], staggered[11])
+
+
+@pytest.mark.usefixtures("ample_session_memory")
+def test_other_routes_refuse_active_dispersion(muscle):
+    semg = _semg(muscle, SurfaceFiberDispersion(nerve_delays=True))
+    with pytest.raises(ValueError, match="dispersion"):
+        semg.simulate_muaps(n_jobs=1, verbose=False, execution=ExecutionPolicy())
+
+
+def test_literature_candidate_preset():
+    preset = SurfaceFiberDispersion.literature_candidate()
+    assert preset.active
+    assert (preset.nmj_model, preset.nmj_scatter_scale, preset.nmj_coefficients) == ("two_layer_intra", 1.0, "published")
+    assert preset.nerve_delays and preset.nerve_cvs__m_per_s == (5.0, 2.0)
+    assert (preset.fiber_cv_threshold_slope, preset.fiber_cv_within_mu_cov, preset.fiber_cv_inter_mu_spread) == (
+        0.63, 0.05, 0.0)
+    assert not preset.diameter_scales_source
+    assert (preset.tendon_end_band__mm, preset.tendon_end_correlation__mm, preset.tendon_end_jitter__mm) == (
+        5.0, 5.0, 0.3)
+    assert SurfaceFiberDispersion.literature_candidate(seed=4).seed == 4
+
+
+def test_intramuscular_emg_selects_the_end_plate_coefficients(monkeypatch):
+    from myogen.simulator import IntramuscularElectrodeArray, IntramuscularEMG
+    from myogen.simulator.core.emg.intramuscular.motor_unit_sim import MotorUnitSim
+
+    set_random_seed(5)
+    thresholds, _ = RecruitmentThresholds(N=4, recruitment_range__ratio=30)
+    muscle = Muscle(recruitment_thresholds=thresholds, radius__mm=2.0 * pq.mm, radius_bone__mm=0.5 * pq.mm,
+                    fiber_density__fibers_per_mm2=50 * pq.mm**-2, grid_resolution=32, autorun=True)
+    electrode = IntramuscularElectrodeArray(num_electrodes=2, inter_electrode_distance__mm=0.5 * pq.mm,
+                                            position__mm=(0.0 * pq.mm, 0.0 * pq.mm, 15.0 * pq.mm))
+    seen = []
+    original = MotorUnitSim.sim_nmj_branches_two_layers
+
+    def capture(self, **kwargs):
+        seen.append((kwargs["branches_z_std"], kwargs["arborization_z_std"]))
+        return original(self, **kwargs)
+
+    monkeypatch.setattr(MotorUnitSim, "sim_nmj_branches_two_layers", capture)
+    for coefficients in ("published", "reference_code"):
+        seen.clear()
+        kwargs = {} if coefficients == "published" else {"nmj_coefficients": coefficients}
+        iemg = IntramuscularEMG(muscle_model=muscle, electrode_array=electrode, **kwargs)
+        iemg._initialize_motor_units(verbose=False)
+        iemg._simulate_neuromuscular_junctions(verbose=False)
+        _, branch_sd, arbor_sd = nmj_branch_schedule(np.asarray(muscle.recruitment_thresholds), coefficients)
+        np.testing.assert_allclose([s[0] for s in seen], branch_sd)
+        np.testing.assert_allclose([s[1] for s in seen], arbor_sd)
+    with pytest.raises(ValueError, match="nmj_coefficients"):
+        IntramuscularEMG(muscle_model=muscle, electrode_array=electrode, nmj_coefficients="paper")
diff --git a/tests/test_surface_model_consistency.py b/tests/test_surface_model_consistency.py
new file mode 100644
index 00000000..df1019a5
--- /dev/null
+++ b/tests/test_surface_model_consistency.py
@@ -0,0 +1,214 @@
+"""Surface-EMG consistency with the Farina et al. (2004) model.
+
+Each test checks the analytical pipeline against an independent reference:
+linearity of the detection system, the conduction velocity that was set, an
+independent time-domain Rosenfalck path, or the documented source geometry.
+"""
+import numpy as np
+import pytest
+import quantities as pq
+from scipy.signal import correlate, resample
+
+from myogen import set_random_seed
+from myogen.simulator import (
+    ExecutionPolicy,
+    Muscle,
+    RecruitmentThresholds,
+    SurfaceElectrodeArray,
+    SurfaceEMG,
+)
+from myogen.simulator.core.emg import fiber_simulation
+from myogen.simulator.core.emg.runtime.surface_preparation import SurfacePreparation
+from myogen.simulator.core.emg.surface import simulate_fiber, volume_conductor
+from myogen.utils.neo import signal_to_grid
+
+GEOMETRY = dict(r=8.5, r_bone=0.0, th_fat=0.3, th_skin=1.29, sig_muscle_rho=0.09,
+                sig_muscle_z=0.4, sig_fat=4.07e-2, sig_skin=4.88e-4)
+V = 4.0          # mm/ms
+N = 512
+KERNEL = 79.25   # mm
+DT = KERNEL / (V * (N - 1))  # ms per internal sample
+
+
+def _array(rows, cols, ied, z0, mode="monopolar"):
+    return SurfaceElectrodeArray(rows, cols, ied * pq.mm, 0.5 * pq.mm,
+                                 center_point__mm_deg=(z0 * pq.mm, 0 * pq.deg),
+                                 bending_radius__mm=GEOMETRY["r"] * pq.mm,
+                                 differentiation_mode=mode)
+
+
+def _fibre(array, *, R=5.5, theta=0.15, L1=16.0, L2=16.0, zi=0.0, kernel=KERNEL, n=N,
+           prepared=False, hybrid=False, M=32, use_gpu=False):
+    if hybrid:
+        # use_unified=True route: time-domain Rosenfalck source, same conductor.
+        phi, _, _ = fiber_simulation.simulate_fiber_hybrid(
+            Fs=10.0, v=V, N=n, M=M, R=R, L1=L1, L2=L2, zi=zi, electrode_array=array,
+            fiber_length__mm=kernel, use_gpu=use_gpu, theta_offset=-theta, **GEOMETRY)
+        return phi
+    phi, _, _ = simulate_fiber._simulate_fiber_v2_python(
+        Fs=10.0, v=V, N=n, M=M, R=R, L1=L1, L2=L2, zi=zi, electrode_array=array,
+        fiber_length__mm=kernel, use_gpu=use_gpu, theta_offset=-theta,
+        _prepared=SurfacePreparation() if prepared else None, **GEOMETRY)
+    return phi
+
+
+def _upsampled_lag_ms(a, b, dt_ms, up=20):
+    a2, b2 = resample(a, len(a) * up), resample(b, len(b) * up)
+    return (np.argmax(correlate(b2, a2, "full")) - (len(a2) - 1)) * dt_ms / up
+
+
+@pytest.fixture(params=["numba", "numpy", "prepared", "hybrid"])
+def b_kz_backend(request, monkeypatch):
+    # "prepared" is the execution route's phi contraction (SurfacePreparation);
+    # "hybrid" is the use_unified=True route (simulate_fiber_hybrid).
+    if request.param == "numpy":
+        monkeypatch.setattr(simulate_fiber, "_numba_B_kz_func", None)
+        monkeypatch.setattr(simulate_fiber, "_numba_phi_func", None)
+    return dict(prepared=request.param == "prepared", hybrid=request.param == "hybrid")
+
+
+def test_longitudinal_bipolar_equals_difference_of_monopolar_pair(b_kz_backend):
+    bipolar = _fibre(_array(1, 1, 10, 8, "bipolar_longitudinal"), **b_kz_backend)[0, 0]
+    pair = _fibre(_array(2, 1, 10, 8), **b_kz_backend)
+    expected = pair[1, 0] - pair[0, 0]
+    np.testing.assert_allclose(bipolar, expected, atol=1e-9 * np.ptp(expected))
+
+
+def test_transversal_bipolar_equals_difference_of_monopolar_pair(b_kz_backend):
+    bipolar = _fibre(_array(1, 1, 3, 8, "bipolar_transversal"), **b_kz_backend)[0, 0]
+    pair = _fibre(_array(1, 2, 3, 8), **b_kz_backend)
+    expected = pair[0, 1] - pair[0, 0]
+    np.testing.assert_allclose(bipolar, expected, atol=1e-9 * np.ptp(expected))
+
+
+def test_separately_simulated_channels_keep_their_propagation_delay():
+    # One call per electrode: a per-call re-centring would erase the delay.
+    near = _fibre(_array(1, 1, 5, 6), R=6.5, theta=0.0)[0, 0]
+    far = _fibre(_array(1, 1, 5, 11), R=6.5, theta=0.0)[0, 0]
+    assert _upsampled_lag_ms(near, far, DT) == pytest.approx(5.0 / V, rel=0.03)
+
+
+def test_firing_instant_is_the_window_centre():
+    # Monopolar negative peaks along a long fibre fall on t = t0 + z/v; the
+    # intercept t0 is the IAP depolarisation peak (z = 3 mm for Rosenfalck)
+    # leaving the end-plate, measured from the window centre.
+    n, kernel = 1024, 300.0
+    dt = kernel / (V * (n - 1))
+    z_values = np.array([10.0, 20.0, 30.0, 40.0])
+    peaks = [np.argmin(_fibre(_array(1, 1, 5, z), R=6.7, theta=0.0, L1=60.0, L2=60.0,
+                              kernel=kernel, n=n)[0, 0]) for z in z_values]
+    slope, intercept = np.polyfit(z_values, peaks, 1)
+    assert slope * dt == pytest.approx(1.0 / V, rel=0.01)
+    assert (intercept - n // 2) * dt * V == pytest.approx(3.0, abs=0.5)
+
+
+def test_source_matches_independent_time_domain_rosenfalck():
+    # simulate_fiber_hybrid builds the published Rosenfalck IAP (lambda = 1 mm)
+    # in the time domain; only the amplitude constant differs.
+    array = _array(1, 1, 5, 8)
+    kwargs = dict(Fs=10.0, v=V, N=N, M=32, R=6.5, L1=15.85, L2=15.85, zi=0.0,
+                  electrode_array=array, fiber_length__mm=KERNEL, use_gpu=False, **GEOMETRY)
+    frequency = simulate_fiber._simulate_fiber_v2_python(**kwargs)[0][0, 0]
+    reference = fiber_simulation.simulate_fiber_hybrid(**kwargs, D1=96.0)[0][0, 0]
+    similarity = np.max(np.abs(correlate(frequency, reference, "full")))
+    similarity /= np.linalg.norm(frequency) * np.linalg.norm(reference)
+    assert similarity > 0.99
+
+
+def test_l1_is_the_positive_z_semi_length():
+    # Fibre spans [zi - L2, zi + L1]: pairs inside it see a travelling wave,
+    # pairs beyond its end see only a standing end-of-fibre component.
+    kernel = 100.0
+    dt = kernel / (V * (N - 1))
+    inside = _fibre(_array(2, 1, 5, 12.5), R=6.4, theta=0.0, L1=30.0, L2=8.0, kernel=kernel)
+    beyond = _fibre(_array(2, 1, 5, -12.5), R=6.4, theta=0.0, L1=30.0, L2=8.0, kernel=kernel)
+    assert _upsampled_lag_ms(inside[0, 0], inside[1, 0], dt) == pytest.approx(5.0 / V, rel=0.05)
+    assert abs(_upsampled_lag_ms(beyond[1, 0], beyond[0, 0], dt)) < 0.5 * 5.0 / V
+
+
+def _muscle(**kwargs):
+    set_random_seed(42)
+    thresholds, _ = RecruitmentThresholds(N=20, recruitment_range__ratio=50, mode="konstantin")
+    muscle = Muscle(thresholds, fiber_density__fibers_per_mm2=10 * pq.mm**-2, **kwargs)
+    muscle.distribute_innervation_centers()
+    muscle.generate_muscle_fiber_centers(verbose=False)
+    muscle.assign_mfs2mns(verbose=False, n_jobs=1)
+    return muscle
+
+
+@pytest.fixture(scope="module")
+def muscle():
+    return _muscle()
+
+
+@pytest.fixture(scope="module")
+def long_muscle():
+    return _muscle(mean_fiber_length__mm=120 * pq.mm)
+
+
+def _simulate(semg, route):
+    if route == "default":
+        return semg.simulate_muaps(n_jobs=1, verbose=False, use_gpu=False)
+    return semg.simulate_muaps(n_jobs=1, verbose=False, execution=ExecutionPolicy())
+
+
+@pytest.mark.parametrize("route", ["default", "execution"])
+@pytest.mark.usefixtures("ample_session_memory")
+def test_muap_sources_span_the_fibre_symmetrically(route, muscle, monkeypatch):
+    from myogen.simulator.core.emg.runtime import semg as runtime_semg
+    from myogen.simulator.core.emg.surface import surface_emg
+    calls = []
+
+    def spy(**kwargs):
+        calls.append((kwargs["L1"], kwargs["L2"], kwargs["zi"]))
+        array = kwargs["electrode_array"]
+        return np.zeros((array.num_rows, array.num_cols, kwargs["N"])), None, None
+
+    monkeypatch.setattr(surface_emg, "_simulate_fiber_v2_python", spy)
+    monkeypatch.setattr(runtime_semg, "_simulate_fiber_v2_python", spy)
+    _simulate(SurfaceEMG(muscle, [_array(1, 1, 5, 8)], MUs_to_simulate=[1, 2]), route)
+    L1, L2, zi = np.array(calls).T
+    assert np.all(zi != 0)
+    # Fibre of length L1 + L2 centred on z = 0 with its end-plate at zi.
+    np.testing.assert_allclose(zi + L1, (L1 + L2) / 2)
+    np.testing.assert_allclose(zi - L2, -(L1 + L2) / 2)
+
+
+@pytest.mark.parametrize("route", ["default", "execution"])
+@pytest.mark.usefixtures("ample_session_memory")
+def test_muap_time_axis_recovers_the_conduction_velocity(route, long_muscle):
+    muscle = long_muscle
+    mu = 1
+    centre = muscle.innervation_center_positions__mm.magnitude[mu]
+    column = SurfaceElectrodeArray(5, 1, 5 * pq.mm, 0.5 * pq.mm, center_point__mm_deg=(
+        30 * pq.mm, np.degrees(np.arctan2(centre[1], centre[0])) * pq.deg))
+    signal = _simulate(SurfaceEMG(muscle, [column], MUs_to_simulate=[mu]), route
+                       ).groups[0].segments[mu].analogsignals[0]
+    single_differential = np.diff(signal_to_grid(signal)[:, :, 0], axis=1)
+    dt_ms = 1e3 / float(signal.sampling_rate)
+    lags = [_upsampled_lag_ms(single_differential[:, i], single_differential[:, i + 1], dt_ms)
+            for i in range(single_differential.shape[1] - 1)]
+    velocity = float(muscle.mean_conduction_velocity__m_s.magnitude)
+    assert 5.0 / np.median(lags) == pytest.approx(velocity, rel=0.03)
+
+
+def test_mixed_electrode_array_shapes_keep_their_own_shape(muscle):
+    semg = SurfaceEMG(muscle, [_array(2, 1, 10, 8), _array(1, 1, 10, 8, "bipolar_longitudinal")],
+                      MUs_to_simulate=[1])
+    block = semg.simulate_muaps(n_jobs=1, verbose=False, use_gpu=False)
+    shapes = [signal_to_grid(group.segments[1].analogsignals[0]).shape[1:] for group in block.groups]
+    assert shapes == [(2, 1), (1, 1)]
+
+
+@pytest.mark.parametrize("hybrid", [False, True])
+def test_overflowing_angular_orders_raise_instead_of_a_singular_system(hybrid):
+    # Bessel overflow at high angular orders used to be zeroed, leaving a
+    # singular system on the CPU and NaN MUAPs on the GPU.
+    with pytest.raises(ValueError, match="sampling_points_in_theta_domain"):
+        _fibre(_array(1, 1, 10, 8), M=256, hybrid=hybrid)
+
+
+@pytest.mark.skipif(not volume_conductor.HAS_CUPY, reason="CuPy not available")
+def test_overflowing_angular_orders_raise_on_the_gpu_solve():
+    with pytest.raises(ValueError, match="sampling_points_in_theta_domain"):
+        _fibre(_array(1, 1, 10, 8), M=256, use_gpu=True)