VegasAfterglow test & validation report

Test details() with SSC enabled returns ssc_spectrum.

flux_density_grid with one frequency returns a (1, n_times) array.

flux_density_grid with one time returns an (n_frequencies, 1) array.

flux_density with a single time-frequency pair returns a length-1 finite array.

Very short exposure should match instantaneous flux.

Exposure-averaged flux has the same shape as the input times and is finite and positive.

flux_density_exposures raises an exception when the exposure array is shorter than the time and frequency arrays.

flux_density_exposures raises an exception when num_points is 1, too few samples to average over an exposure window.

Test creating FitResult.

Test FitResult with top-k parameters.

flux_density_grid raises an exception when the frequency array is empty even though the time array is non-empty.

flux raises an exception when the time array is empty despite a valid frequency integration range.

flux_density raises an exception when the time array is in descending order instead of ascending.

flux_density raises an exception when both the time and frequency arrays are empty.

flux_density_exposures raises an exception when the exposure array is shorter than the time and frequency arrays.

flux raises an exception when the time array is empty despite a valid frequency integration range.

flux raises an exception when the lower frequency bound of the integration band is negative.

flux raises an exception when the upper frequency bound of the integration band is below the lower bound.

flux raises an exception when only one frequency sample point is requested for the band integration.

Test that flux_density requires ascending time array.

Test that flux_density requires matching array shapes.

Test GaussianJet creation.

Test jet with spreading enabled.

Test PowerLawJet creation.

Test TophatJet creation.

Test TwoComponentJet creation.

Each parametrized jet structure yields finite, strictly positive total flux.

Each parametrized jet structure yields finite, strictly positive total flux.

SSC with Klein-Nishina suppression enabled yields finite, strictly positive total flux.

logscale_screen returns a non-empty proper subset of indices for log-spaced data.

logscale_screen on a single-element array returns exactly index 0.

A jet with magnetar spin-down energy injection produces finite, positive flux density.

repr() of a Magnetar instance contains the class name.

Test ISM medium creation.

Test Wind medium creation.

Test Wind with additional parameters.

Test details() method returns shock evolution data.

Test flux_density calculation.

Test flux_density_grid calculation.

Test jet profile methods.

Test basic model creation.

Test model with custom resolution.

Test setting ModelParams attributes.

Test creating ModelParams.

Model.axisymmetric is True for an on-axis tophat jet configuration.

Model.fwd_rad round-trips the eps_e and p microphysics parameters given at construction.

Model.observer round-trips the redshift and viewing angle given at construction.

repr() of a Model instance contains the class name.

Model.resolutions returns a length-3 tuple of grid resolutions.

Model.rtol exposes a positive solver relative tolerance.

Model.rvs_rad is None when no reverse-shock radiation is configured.

Test off-axis observer.

Test on-axis observer.

On-axis total flux exceeds off-axis (theta_obs=0.4) total flux at the earliest sampled time.

An observer at theta_obs=0.3 (outside the jet core) yields finite, strictly positive total flux.

Test creating a ParamDef with all parameters.

Test ParamDef default values.

Test fixed parameter definition.

Scale.fixed skips bound validation; lower==upper or even degenerate configurations work because the fitting layer uses `initial or lower`.

initial, when given, must lie within [lower, upper].

lower must be strictly less than upper for non-fixed scales.

Scale.log requires lower > 0; log10(<=0) is undefined.

Test basic synchrotron radiation settings.

Test radiation with SSC enabled.

Radiative losses drain blast-wave energy, so the adiabatic light curve must be brighter, increasingly so toward late times.

Omitting the flag must match radiative_fireball=True.

Gamma(r) local slope in the ultra-relativistic deceleration phase: adiabatic follows Blandford-McKee (-3/2); the fully radiative limit (eps_rad = eps_e = 1, forced via p < 2) is much steeper (toward -3).

Shock details for a reverse-shock model include a non-empty reverse-shock Lorentz factor array.

Reverse-shock synchrotron flux matches the time-grid shape, is nonzero at some epoch, and the total stays finite.

SSC model should produce both sync and ssc flux components.

Total flux should be >= sync-only flux.

Test Scale enum comparison.

Test that Scale enum has expected values.

All time-lattice construction paths return finite, strictly positive flux for degenerate observation windows (single epochs, narrow windows). A zero or NaN means a poisoned lattice node dropped ODE rows -- the failure mode of the v2.0.6 regression -- not faint emission.

All time-lattice construction paths return finite, strictly positive flux for degenerate observation windows (single epochs, narrow windows). A zero or NaN means a poisoned lattice node dropped ODE rows -- the failure mode of the v2.0.6 regression -- not faint emission.

All time-lattice construction paths return finite, strictly positive flux for degenerate observation windows (single epochs, narrow windows). A zero or NaN means a poisoned lattice node dropped ODE rows -- the failure mode of the v2.0.6 regression -- not faint emission.

All time-lattice construction paths return finite, strictly positive flux for degenerate observation windows (single epochs, narrow windows). A zero or NaN means a poisoned lattice node dropped ODE rows -- the failure mode of the v2.0.6 regression -- not faint emission.

All time-lattice construction paths return finite, strictly positive flux for degenerate observation windows (single epochs, narrow windows). A zero or NaN means a poisoned lattice node dropped ODE rows -- the failure mode of the v2.0.6 regression -- not faint emission.

The equal-arrival-time node grid itself contains no NaN/inf: a single poisoned node silently disables a whole (phi, theta) row even when other windows would mask it in the flux.

A single early epoch whose window ends inside the deceleration refinement band produced a NaN time node, silently skipping every ODE row and returning identically zero flux (v2.0.6 regression).

Single-epoch requests across the light curve never hit a degenerate lattice (any zero would mean a dropped ODE row, not faint emission).

A stellar-wind (A_star) medium yields finite, strictly positive total flux.

A wind medium with an ISM density floor (n_ism) yields finite, strictly positive total flux.

An unparseable --nu value aborts with SystemExit or ArgumentTypeError rather than running the model.

CSV output has a column header plus exactly num_t data rows, and the first data row has at least two columns with positive time and flux values.

JSON output parses to a dict containing light-curve content (numeric values, a flux field, or a time key).

A named band ("XRT") is accepted for --nu and the run still writes the output file.

Every emission component at the (mode-specific) default resolution stays within both validation gates (mean error < 5%, max error < 15%) against a phi+theta+time-converged reference, on the families that pin the calibrated defaults of each mode.

Every emission component at the (mode-specific) default resolution stays within both validation gates (mean error < 5%, max error < 15%) against a phi+theta+time-converged reference, on the families that pin the calibrated defaults of each mode.

Every emission component at the (mode-specific) default resolution stays within both validation gates (mean error < 5%, max error < 15%) against a phi+theta+time-converged reference, on the families that pin the calibrated defaults of each mode.

Every emission component at the (mode-specific) default resolution stays within both validation gates (mean error < 5%, max error < 15%) against a phi+theta+time-converged reference, on the families that pin the calibrated defaults of each mode.

Band-only path -> 2 axes (top + bottom), single y-axis on top.

With a realistic posterior and n_samples>0, draw_fit renders at least one credible-band fill (PolyCollection) on the top axis.

Passing best_params explicitly should bypass the result-requirement.

Light-curve-only path -> 2 axes (top + bottom), no twin axis.

LC + band-integrated -> 3 axes (left, twin, bottom) and equal decade span on the dual y-axes.

Fitter with no observation data -> ValueError.

show_nu_panel=False -> single panel, ax_bot is None.

Unknown obs_noise string surfaces a clear ValueError listing the valid set.

All three obs_noise modes render a fill_between band without error.

All three obs_noise modes render a fill_between band without error.

All three obs_noise modes render a fill_between band without error.

BUILTIN_LAWS registry contains exactly smc/lmc/mw, each mapping to a callable positive at the V band.

Each Pei92 law (SMC/LMC/MW) normalizes to k(λ)=1 at the V-band wavelength to 1e-12 relative precision.

Each Pei92 law (SMC/LMC/MW) normalizes to k(λ)=1 at the V-band wavelength to 1e-12 relative precision.

Each Pei92 law (SMC/LMC/MW) normalizes to k(λ)=1 at the V-band wavelength to 1e-12 relative precision.

Each Pei92 law rises toward the UV: k(2000 Å) exceeds k(7000 Å), and both are positive.

Each Pei92 law rises toward the UV: k(2000 Å) exceeds k(7000 Å), and both are positive.

Each Pei92 law rises toward the UV: k(2000 Å) exceeds k(7000 Å), and both are positive.

pei92 on a 2-D wavelength array preserves the input shape and returns only finite, non-negative values.

The smc/lmc/mw convenience wrappers return values identical to pei92 called with the matching law name.

Each Pei92 law returns exactly zero extinction for wavelengths below the Lyman limit (912 Å).

Each Pei92 law returns exactly zero extinction for wavelengths below the Lyman limit (912 Å).

Each Pei92 law returns exactly zero extinction for wavelengths below the Lyman limit (912 Å).

A bilby Result file with no VegasAfterglow snapshot makes Fitter.load raise a ValueError stating the file does not include a Fitter snapshot.

HDF5 save/load restores samples, log_probs, top-k arrays, labels, and the Fitter snapshot (jet/medium/z/lumi_dist/data), populates bilby_result, keeps summary() text identical, and leaves unset fit-quality fields None.

JSON save/load restores samples, top_k_params, and labels, with unset fit-quality fields staying None.

samples is (N, n_walkers, ndim); shape must survive the bilby flatten.

When the FitResult has n_data / n_free_params populated (as it does after a real fit() call), both fields must survive HDF5 and JSON round-trip and the summary() header must remain identical.

Fitter.save before .fit() raises a clear error -- no silent empty file.

File written by Fitter.save() should be a valid bilby Result file.

summary() on a FitResult without top_k_params reports "no top_k_params stored" instead of a table.

n_data + n_free_params populated -> header line with χ²/DOF, BIC, AIC.

latex_labels set => single LaTeX block (posterior median, asymmetric 1σ).

latex=False forces the block off even when latex_labels are set.

Auto mode is silent without latex_labels (no LaTeX block, no note). Explicit latex=True surfaces a note explaining how to enable the block.

Suppress header silently if n_data <= n_free_params (over-parametrized).

Older saved files have n_data=None; header suppressed.

summary() table has Rank and chi^2 columns, every parameter label, magnitude-aware decimal formatting per column, and chi^2 = -2 * log_prob.

The _SummaryTable wrapper's __repr__ returns the text directly so Jupyter last-line auto-display renders cleanly (no escaped \n).

summary() title reports displayed rows versus total stored top-k rows ("top 2 of 2").

summary(top_k=1) keeps only the first rank's row and the title reflects the slice ("top 1 of 2").

add_flux raises ValueError naming band for each argument that is not a two-element (nu_min, nu_max) pair (None, bare scalar, 1-tuple, 3-tuple).

add_flux raises ValueError naming band for each argument that is not a two-element (nu_min, nu_max) pair (None, bare scalar, 1-tuple, 3-tuple).

add_flux raises ValueError naming band for each argument that is not a two-element (nu_min, nu_max) pair (None, bare scalar, 1-tuple, 3-tuple).

add_flux raises ValueError naming band for each argument that is not a two-element (nu_min, nu_max) pair (None, bare scalar, 1-tuple, 3-tuple).

add_flux raises ValueError naming band for each frequency pair that is not a strictly increasing positive finite range (reversed, negative, zero, equal edges, NaN, Inf).

add_flux raises ValueError naming band for each frequency pair that is not a strictly increasing positive finite range (reversed, negative, zero, equal edges, NaN, Inf).

add_flux raises ValueError naming band for each frequency pair that is not a strictly increasing positive finite range (reversed, negative, zero, equal edges, NaN, Inf).

add_flux raises ValueError naming band for each frequency pair that is not a strictly increasing positive finite range (reversed, negative, zero, equal edges, NaN, Inf).

add_flux raises ValueError naming band for each frequency pair that is not a strictly increasing positive finite range (reversed, negative, zero, equal edges, NaN, Inf).

add_flux raises ValueError naming band for each frequency pair that is not a strictly increasing positive finite range (reversed, negative, zero, equal edges, NaN, Inf).

add_flux raises ValueError naming num_points when only one in-band integration frequency is requested.

add_flux_density raises ValueError naming err for each measurement uncertainty that is zero, negative, NaN, or Inf.

add_flux_density raises ValueError naming err for each measurement uncertainty that is zero, negative, NaN, or Inf.

add_flux_density raises ValueError naming err for each measurement uncertainty that is zero, negative, NaN, or Inf.

add_flux_density raises ValueError naming err for each measurement uncertainty that is zero, negative, NaN, or Inf.

add_flux_density raises ValueError naming nu for each non-positive or non-finite frequency (zero, negative, NaN, Inf).

add_flux_density raises ValueError naming nu for each non-positive or non-finite frequency (zero, negative, NaN, Inf).

add_flux_density raises ValueError naming nu for each non-positive or non-finite frequency (zero, negative, NaN, Inf).

add_flux_density raises ValueError naming nu for each non-positive or non-finite frequency (zero, negative, NaN, Inf).

add_flux_density raises ValueError naming weights when the weights array is longer than the data arrays.

add_flux_density raises ValueError mentioning 'empty' when the t, f_nu, and err arrays contain no points.

add_flux_density accepts a positive scalar frequency with matching finite t, f_nu, and err arrays without raising.

add_flux_density raises ValueError mentioning 'non-finite' when the f_nu array contains a NaN entry.

add_flux_density raises ValueError naming weights when the weights array contains a negative entry.

add_flux_density raises ValueError mentioning 'same shape' when f_nu is shorter than the t and err arrays.

add_flux_density accepts an optional positive weights array of the same shape as the data without raising.

add_flux accepts a named instrument band (XRT) resolved to a frequency range with matching t, flux, and err arrays without raising.

add_flux raises ValueError naming err when the error array contains a negative entry.

add_flux raises ValueError mentioning 'same shape' when flux is shorter than the t and err arrays.

add_spectrum raises ValueError naming nu when the frequency array contains a negative value.

add_spectrum raises a ValueError whose message starts with 'add_spectrum: t' for each non-positive or non-finite observation time (zero, negative, NaN, Inf).

add_spectrum raises a ValueError whose message starts with 'add_spectrum: t' for each non-positive or non-finite observation time (zero, negative, NaN, Inf).

add_spectrum raises a ValueError whose message starts with 'add_spectrum: t' for each non-positive or non-finite observation time (zero, negative, NaN, Inf).

add_spectrum raises a ValueError whose message starts with 'add_spectrum: t' for each non-positive or non-finite observation time (zero, negative, NaN, Inf).

add_spectrum accepts a positive scalar time with matching finite nu, f_nu, and err arrays without raising.

add_spectrum raises ValueError mentioning 'same shape' when f_nu is shorter than the nu and err arrays.

Each jet type's required and forbidden parameter sets derived from its JetSpec equal the historical hand-maintained JET_RULES entry verbatim.

Each jet type's required and forbidden parameter sets derived from its JetSpec equal the historical hand-maintained JET_RULES entry verbatim.

Each jet type's required and forbidden parameter sets derived from its JetSpec equal the historical hand-maintained JET_RULES entry verbatim.

Each jet type's required and forbidden parameter sets derived from its JetSpec equal the historical hand-maintained JET_RULES entry verbatim.

Each jet type's required and forbidden parameter sets derived from its JetSpec equal the historical hand-maintained JET_RULES entry verbatim.

Each jet type's required and forbidden parameter sets derived from its JetSpec equal the historical hand-maintained JET_RULES entry verbatim.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered jet type constructs a non-None jet object from ModelParams defaults combined with its spec's fixed_kwargs.

Each registered medium type constructs a non-None medium object from ModelParams once its density normalization (n_ism or A_star) is set nonzero to pass validation.

Each registered medium type constructs a non-None medium object from ModelParams once its density normalization (n_ism or A_star) is set nonzero to pass validation.

Each medium type's required and forbidden parameter sets derived from its spec equal the historical hand-maintained MEDIUM_RULES entry verbatim.

Each medium type's required and forbidden parameter sets derived from its spec equal the historical hand-maintained MEDIUM_RULES entry verbatim.

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

For each jet spec, the required and forbidden sets are disjoint and no constructor argument is both sampled (params) and fixed (fixed_kwargs).

The uniform jet, historically unvalidated, now derives required {E_iso, Gamma0}, forbidden wing/power-law-index params, and a fixed theta_c of pi/2.

gil_free-compiled top-hat E_iso and Gamma0 profiles fed to Ejecta yield a flux_density light curve at 1e14 Hz that is finite and strictly positive everywhere.

could not import 'numba': No module named 'numba'

Calling a NativeFunc through the pure-Python fallback appends the bound params after the runtime args, reproducing the profile value E_iso*(1 - theta/theta_c).

Binding trailing kwargs splits the cfunc signature so params holds the bound values in signature order while n_args still counts all four arguments.

A signature where an unbound runtime argument follows a bound parameter is rejected with a ValueError saying it cannot appear after the bound one.

Binding a kwarg that is not in the cfunc signature raises a TypeError naming it an unexpected keyword.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Each validity-boundary extreme (trans-relativistic to Gamma0=5000, needle to spherical jets, IGM to dense media, hard to steep p, magnetized shell, ultralong reverse shock) yields finite, strictly positive flux from 1 s through the deep-Newtonian phase.

Raising the grid resolutions above their defaults and loosening the solver rtol to 1e-4 still yields a finite, strictly positive light curve.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

Each jet variant (tophat, spreading, thick-shell, magnetar, Gaussian, power-law, two-component, step power-law, wing, custom Ejecta) produces a light curve matching the input time shape that is finite and strictly positive.

jet_E_iso and jet_Gamma0 on a Gaussian jet return arrays matching the theta grid with E_iso > 0 and Gamma0 > 1 everywhere.

Regression for the sigma>0 + rvs_rad runaway (fixed 2026-07-02): at early times Gamma ~= Gamma4 makes the magnetized jump ratio -> 1, and the reverse-shock crossing rate divided by (Gamma*comp_ratio/Gamma4 - 1) -> 0/0; the NaN then silently froze dGamma/dt at zero (eternal coasting). Fixed by the shock-penetration gate in FRShockEqn::compute_dx3_dt.

Regression for the sigma>0 + rvs_rad runaway (fixed 2026-07-02): at early times Gamma ~= Gamma4 makes the magnetized jump ratio -> 1, and the reverse-shock crossing rate divided by (Gamma*comp_ratio/Gamma4 - 1) -> 0/0; the NaN then silently froze dGamma/dt at zero (eternal coasting). Fixed by the shock-penetration gate in FRShockEqn::compute_dx3_dt.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Regression for the penetration->0+ knife edge (fixed 2026-07-02): for magnetized shells the Zhang-Kobayashi crossing rate diverges as the penetration factor (Gamma*comp_ratio/Gamma4 - 1) -> 0+, and whether a run hit the singularity depended on the time grid's t0 (sigma=0.999 passed while sigma=1.0 failed). Fixed by capping the comoving consumption rate at the fast magnetosonic speed of the magnetized upstream in FRShockEqn::compute_dx3_dt (unreachable for sigma=0, where the penetration factor is algebraically >= 1). Parametrized over time grids because the original failure was grid-t0 sensitive.

Each ambient-medium variant (ISM, thin ISM, stellar wind, hybrid wind, custom density profile) produces a finite, strictly positive light curve.

Each ambient-medium variant (ISM, thin ISM, stellar wind, hybrid wind, custom density profile) produces a finite, strictly positive light curve.

Each ambient-medium variant (ISM, thin ISM, stellar wind, hybrid wind, custom density profile) produces a finite, strictly positive light curve.

Each ambient-medium variant (ISM, thin ISM, stellar wind, hybrid wind, custom density profile) produces a finite, strictly positive light curve.

Each ambient-medium variant (ISM, thin ISM, stellar wind, hybrid wind, custom density profile) produces a finite, strictly positive light curve.

details returns forward-shock dynamics with finite Lorentz factor Gamma >= 1, strictly positive radius, and finite observer times.

Band-integrated flux over 1e17-1e19 Hz matches the input time shape and is finite and strictly positive.

flux_density on the baseline model returns a total-flux array matching the input time shape that is finite and strictly positive.

Exposure-averaged flux over finite 10 s exposures returns one finite, strictly positive value per epoch.

flux_density_grid returns a (n_nu, n_t) total-flux grid that is finite and strictly positive.

A custom Ejecta jet solved with axisymmetric=False and an off-axis observer produces a finite, strictly positive light curve.

For an observer at theta_obs=0.4 outside each jet's core (tophat, Gaussian, two-component), both the light curve and the (n_nu, n_t) flux grid are finite and strictly positive with the expected shapes.

For an observer at theta_obs=0.4 outside each jet's core (tophat, Gaussian, two-component), both the light curve and the (n_nu, n_t) flux grid are finite and strictly positive with the expected shapes.

For an observer at theta_obs=0.4 outside each jet's core (tophat, Gaussian, two-component), both the light curve and the (n_nu, n_t) flux grid are finite and strictly positive with the expected shapes.

Each forward-shock radiation configuration (synchrotron only, SSC, SSC with Klein-Nishina, p near 2, steep p, reduced xi_e) produces a finite, strictly positive light curve.

Each forward-shock radiation configuration (synchrotron only, SSC, SSC with Klein-Nishina, p near 2, steep p, reduced xi_e) produces a finite, strictly positive light curve.

Each forward-shock radiation configuration (synchrotron only, SSC, SSC with Klein-Nishina, p near 2, steep p, reduced xi_e) produces a finite, strictly positive light curve.

Each forward-shock radiation configuration (synchrotron only, SSC, SSC with Klein-Nishina, p near 2, steep p, reduced xi_e) produces a finite, strictly positive light curve.

Each forward-shock radiation configuration (synchrotron only, SSC, SSC with Klein-Nishina, p near 2, steep p, reduced xi_e) produces a finite, strictly positive light curve.

Each forward-shock radiation configuration (synchrotron only, SSC, SSC with Klein-Nishina, p near 2, steep p, reduced xi_e) produces a finite, strictly positive light curve.

A thick-shell jet with each reverse-shock radiation configuration keeps the total flux finite and positive while the reverse-shock synchrotron component is finite, non-negative, and shaped like the input times.

A thick-shell jet with each reverse-shock radiation configuration keeps the total flux finite and positive while the reverse-shock synchrotron component is finite, non-negative, and shaped like the input times.

A thick-shell jet with each reverse-shock radiation configuration keeps the total flux finite and positive while the reverse-shock synchrotron component is finite, non-negative, and shaped like the input times.

A thick-shell jet with each reverse-shock radiation configuration keeps the total flux finite and positive while the reverse-shock synchrotron component is finite, non-negative, and shaped like the input times.

A thick-shell jet with each reverse-shock radiation configuration keeps the total flux finite and positive while the reverse-shock synchrotron component is finite, non-negative, and shaped like the input times.

A thick-shell jet with each reverse-shock radiation configuration keeps the total flux finite and positive while the reverse-shock synchrotron component is finite, non-negative, and shaped like the input times.

sky_image for an off-axis observer returns a finite intensity map with at least one lit pixel, the requested pixel dimension, a positive pixel solid angle, and at least four extent entries.

Ejecta raises ValueError naming duration for each non-positive or non-finite ejection duration.

Ejecta raises ValueError naming duration for each non-positive or non-finite ejection duration.

Ejecta raises ValueError naming duration for each non-positive or non-finite ejection duration.

Ejecta raises ValueError naming duration for each non-positive or non-finite ejection duration.

Ejecta constructs from callable E_iso and Gamma0 angular profiles without raising.

Ejecta raises ValueError naming E_iso when the energy profile callable returns NaN, Inf, or a negative value.

Ejecta raises ValueError naming E_iso when the energy profile callable returns NaN, Inf, or a negative value.

Ejecta raises ValueError naming E_iso when the energy profile callable returns NaN, Inf, or a negative value.

Ejecta raises ValueError naming Gamma0 when the Lorentz-factor profile callable returns a non-finite value or one that does not exceed 1.

Ejecta raises ValueError naming Gamma0 when the Lorentz-factor profile callable returns a non-finite value or one that does not exceed 1.

Ejecta raises ValueError naming Gamma0 when the Lorentz-factor profile callable returns a non-finite value or one that does not exceed 1.

Ejecta raises ValueError naming Gamma0 when the Lorentz-factor profile callable returns a non-finite value or one that does not exceed 1.

Ejecta raises ValueError naming sigma0 when the magnetization profile callable returns NaN.

Ejecta raises ValueError saying 'must be callable' when E_iso or Gamma0 is passed as a scalar instead of a profile function.

flux_density_exposures raises ValueError naming the offending element expo_time[1] when one exposure time is negative.

flux_density_exposures raises ValueError naming the offending element expo_time[1] when one exposure time is NaN.

GaussianJet constructs with positive theta_c, positive E_iso, and Gamma0 > 1 without raising.

GaussianJet raises ValueError naming E_iso when the isotropic-equivalent energy is NaN.

ISM raises ValueError naming n_ism for each negative, NaN, or Inf number density.

ISM raises ValueError naming n_ism for each negative, NaN, or Inf number density.

ISM raises ValueError naming n_ism for each negative, NaN, or Inf number density.

ISM constructs with a positive ambient number density n_ism without raising.

ISM accepts n_ism = 0 (no ambient density floor) without raising.

Magnetar constructs with positive spin-down luminosity L0, timescale t0, and decay index q without raising.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Magnetar raises ValueError naming the offending parameter for each case that passes a NaN, negative, or zero value for L0, t0, or q.

Medium constructs from a callable mass-density profile rho(phi, theta, r) without raising.

Medium raises ValueError naming rho when the density profile callable returns NaN, Inf, or a negative value.

Medium raises ValueError naming rho when the density profile callable returns NaN, Inf, or a negative value.

Medium raises ValueError naming rho when the density profile callable returns NaN, Inf, or a negative value.

Medium raises ValueError saying 'rho must be callable' when the density profile is passed as a scalar.

Model raises ValueError matching 'resol' for each resolutions triple containing a negative, zero, NaN, or Inf entry.

Model raises ValueError matching 'resol' for each resolutions triple containing a negative, zero, NaN, or Inf entry.

Model raises ValueError matching 'resol' for each resolutions triple containing a negative, zero, NaN, or Inf entry.

Model raises ValueError matching 'resol' for each resolutions triple containing a negative, zero, NaN, or Inf entry.

Model raises ValueError naming rtol for each relative tolerance that is zero, negative, >= 1, or non-finite.

Model raises ValueError naming rtol for each relative tolerance that is zero, negative, >= 1, or non-finite.

Model raises ValueError naming rtol for each relative tolerance that is zero, negative, >= 1, or non-finite.

Model raises ValueError naming rtol for each relative tolerance that is zero, negative, >= 1, or non-finite.

Model raises ValueError naming rtol for each relative tolerance that is zero, negative, >= 1, or non-finite.

Model raises ValueError naming rtol for each relative tolerance that is zero, negative, >= 1, or non-finite.

Model constructs from valid jet, medium, observer, and radiation components without raising.

Observer raises ValueError naming lumi_dist for each non-positive or non-finite luminosity distance.

Observer raises ValueError naming lumi_dist for each non-positive or non-finite luminosity distance.

Observer raises ValueError naming lumi_dist for each non-positive or non-finite luminosity distance.

Observer raises ValueError naming lumi_dist for each non-positive or non-finite luminosity distance.

Observer raises ValueError naming theta_obs for each viewing angle that is negative, greater than pi, or non-finite.

Observer raises ValueError naming theta_obs for each viewing angle that is negative, greater than pi, or non-finite.

Observer raises ValueError naming theta_obs for each viewing angle that is negative, greater than pi, or non-finite.

Observer raises ValueError naming theta_obs for each viewing angle that is negative, greater than pi, or non-finite.

Observer raises ValueError naming z for each negative, NaN, or Inf redshift.

Observer raises ValueError naming z for each negative, NaN, or Inf redshift.

Observer raises ValueError naming z for each negative, NaN, or Inf redshift.

Observer constructs with positive lumi_dist, non-negative z, and theta_obs inside [0, pi] without raising.

Observer accepts the inclusive viewing-angle bounds theta_obs = 0 and theta_obs = pi without raising.

Observer accepts redshift z = 0 without raising.

PowerLawJet raises ValueError naming k_e for each non-positive or non-finite energy power-law index.

PowerLawJet raises ValueError naming k_e for each non-positive or non-finite energy power-law index.

PowerLawJet raises ValueError naming k_e for each non-positive or non-finite energy power-law index.

PowerLawJet raises ValueError naming k_e for each non-positive or non-finite energy power-law index.

PowerLawJet raises ValueError naming k_g when the Lorentz-factor power-law index is NaN.

PowerLawJet constructs with valid core parameters and positive power-law indices k_e and k_g without raising.

PowerLawWing constructs with positive theta_c, E_iso_w, Gamma0_w > 1, and indices k_e and k_g without raising.

Radiation raises ValueError naming eps_B for each magnetic energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_B for each magnetic energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_B for each magnetic energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_B for each magnetic energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_B for each magnetic energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_e for each electron energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_e for each electron energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_e for each electron energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_e for each electron energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming eps_e for each electron energy fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming p for each electron spectral index that is non-finite or violates the strict p > 1 bound, including p = 1 exactly.

Radiation raises ValueError naming p for each electron spectral index that is non-finite or violates the strict p > 1 bound, including p = 1 exactly.

Radiation raises ValueError naming p for each electron spectral index that is non-finite or violates the strict p > 1 bound, including p = 1 exactly.

Radiation raises ValueError naming p for each electron spectral index that is non-finite or violates the strict p > 1 bound, including p = 1 exactly.

Radiation raises ValueError naming p for each electron spectral index that is non-finite or violates the strict p > 1 bound, including p = 1 exactly.

Radiation raises ValueError naming xi_e for each accelerated-electron fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming xi_e for each accelerated-electron fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming xi_e for each accelerated-electron fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming xi_e for each accelerated-electron fraction that is zero, negative, above 1, or non-finite.

Radiation raises ValueError naming xi_e for each accelerated-electron fraction that is zero, negative, above 1, or non-finite.

Radiation constructs with eps_e and eps_B in (0, 1] and electron spectral index p > 1 without raising.

Radiation accepts p = 1.5, confirming hard electron spectral indices in 1 < p < 2 are not rejected.

Radiation accepts the inclusive upper bound xi_e = 1 without raising.

StepPowerLawJet constructs with valid core and wing parameters and positive indices k_e and k_g without raising.

StepPowerLawJet raises ValueError naming Gamma0_w when the wing bulk Lorentz factor equals 1.

TophatJet raises ValueError naming E_iso for each non-positive or non-finite isotropic-equivalent energy.

TophatJet raises ValueError naming E_iso for each non-positive or non-finite isotropic-equivalent energy.

TophatJet raises ValueError naming E_iso for each non-positive or non-finite isotropic-equivalent energy.

TophatJet raises ValueError naming E_iso for each non-positive or non-finite isotropic-equivalent energy.

TophatJet raises ValueError naming Gamma0 for each initial bulk Lorentz factor that is <= 1, negative, or non-finite.

TophatJet raises ValueError naming Gamma0 for each initial bulk Lorentz factor that is <= 1, negative, or non-finite.

TophatJet raises ValueError naming Gamma0 for each initial bulk Lorentz factor that is <= 1, negative, or non-finite.

TophatJet raises ValueError naming Gamma0 for each initial bulk Lorentz factor that is <= 1, negative, or non-finite.

TophatJet raises ValueError naming Gamma0 for each initial bulk Lorentz factor that is <= 1, negative, or non-finite.

TophatJet raises ValueError naming Gamma0 for each initial bulk Lorentz factor that is <= 1, negative, or non-finite.

TophatJet raises ValueError naming theta_c for each half-opening angle that is negative, zero, NaN, Inf, or as large as pi.

TophatJet raises ValueError naming theta_c for each half-opening angle that is negative, zero, NaN, Inf, or as large as pi.

TophatJet raises ValueError naming theta_c for each half-opening angle that is negative, zero, NaN, Inf, or as large as pi.

TophatJet raises ValueError naming theta_c for each half-opening angle that is negative, zero, NaN, Inf, or as large as pi.

TophatJet raises ValueError naming theta_c for each half-opening angle that is negative, zero, NaN, Inf, or as large as pi.

TophatJet constructs with positive theta_c, positive E_iso, and Gamma0 > 1 without raising.

TwoComponentJet constructs when the wing angle theta_w exceeds the core angle theta_c and all core/wing parameters are valid, without raising.

TwoComponentJet raises ValueError naming E_iso_w when the wing isotropic-equivalent energy is NaN.

TwoComponentJet raises ValueError naming theta_w when the wing angle does not exceed the core angle theta_c.

Wind raises ValueError naming A_star for each non-positive or non-finite wind parameter.

Wind raises ValueError naming A_star for each non-positive or non-finite wind parameter.

Wind raises ValueError naming A_star for each non-positive or non-finite wind parameter.

Wind raises ValueError naming A_star for each non-positive or non-finite wind parameter.

Wind raises ValueError naming k_m when the density power-law slope is negative.

Wind constructs with a positive stellar-wind parameter A_star without raising.

Wind accepts n0 = +inf as the no-density-floor sentinel without raising.

Wind raises ValueError naming n0 when the density floor is negative.

Wind raises ValueError naming n0 when the density floor is zero.

A 5-magnitude difference in AB magnitude corresponds to exactly a factor of 100 in flux density.

AB magnitude to flux density round-trip recovers a numpy array of magnitudes elementwise to within relative tolerance 1e-7 (atol 1e-12 mag).

cgs_to_ABmag inverts ABmag_to_cgs to within 1e-12 mag for scalar magnitudes from -5 to 30.

AB magnitude 0 converts to the AB zero-point flux density of 3631 Jy (3.631e-20 erg/cm^2/s/Hz).

cgs_to_STmag inverts STmag_to_cgs to within 1e-10 mag for a registered ST-system filter.

cgs_to_Vegamag inverts Vegamag_to_cgs to within 1e-10 mag for a registered Vega-system filter.

band('XRT') returns a strictly ordered positive frequency range with 0 < nu_min < nu_max.

band raises ValueError with an 'Unknown band' message for an unrecognized band name.

filter returns a strictly positive effective frequency in Hz for a registered Vega filter.

Vegamag_to_cgs raises KeyError or ValueError when given an unrecognized filter name.

ISM light curve above nu_c decays with alpha = (3p-2)/4 = 1.375 within a calibrated 0.15 that absorbs smooth-spectrum curvature.

ISM light curve at nu_m < nu < nu_c decays with the Granot & Sari slope alpha = 3(p-1)/4 = 1.125 within a calibrated 0.08.

Changing the electron index to p=2.2 shifts the ISM mid-band decay to alpha = 3(p-1)/4 = 0.9, so the closure relation tracks p.

A narrow jet's post-jet-break temporal decay index exceeds the pre-break index by more than 0.7.

Magnetar spin-down energy injection flattens the optical decay index by at least 0.1 relative to the no-injection model.

Relativistic beaming makes the off-axis (theta_obs > theta_c) flux strictly lower than on-axis at every sampled early time.

Spectral slope above nu_c matches beta = p/2 = 1.25 within 0.1.

Spectral slope between nu_m and nu_c matches beta = (p-1)/2 = 0.75 within a calibrated 0.08.

The maximum local spectral slope in the nu_a-to-past-nu_m window must lie between +0.15 and +0.45 (rising segment near the nu^{1/3} asymptote; measured ~+0.34), and the local slope at the low-frequency end of the window must exceed that at the high-frequency end as the rise flattens across nu_m.

Lowering eps_B from 1e-2 to 1e-4 raises the SSC-to-synchrotron flux ratio more than tenfold (Compton Y ~ sqrt(eps_e/eps_B)), with SSC dominating at 1e24 Hz in both cases.

In the thick-shell regime the reverse-shock synchrotron light curve peaks within a factor of ~3 of the shell-crossing time T*(1+z).

Stellar-wind-medium light curve at nu_m < nu < nu_c decays with alpha = (3p-1)/4 = 1.625 within a calibrated 0.08.

The top-ranked sample's log10(E_iso) lands within 1 dex of the injected truth, i.e. the short MCMC run recovers the isotropic energy to the right order of magnitude.

FitResult has consistent shapes: samples' last axis equals the 2 free parameters, log-probs are all finite, and top_k_params/n_free_params/n_data match the fit setup.

FitResult.summary() renders without raising and its repr contains ranking or chi-square content.

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each config's stored baseline time and frequency grids match the current regeneration grids to 1e-12 relative (logspace differs by one ulp across platform libms).

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

Each recomputed flux component matches its golden baseline within the calibrated rtol=2e-3, and identically-zero baseline components stay zero. Bins below 1e-2 of the component peak float (the atol term): for structured-jet reverse shocks their values are only reproducible to ~1% against ANY perturbation — codegen, platform libm, math-kernel choice — because the wing-row ODE solves amplify bit-level differences to that saturated level. Real regressions move bright bins far beyond rtol, so nothing observable is unguarded.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

The shock solver must not abandon any grid row ("giving up" on stderr): an abandoned row leaves its stored state at initialization values and silently corrupts the light curve.

For an on-axis observer (theta_obs=0) the axisymmetric fast path and the full 3D integration yield the same flux to 1e-9 relative.

Band-integrated flux from flux() agrees with the trapezoidal frequency integral of flux_density_grid over 1e14-1e15 Hz within 1% (measured 1.7e-4), pinning the quadrature contract.

With SSC and the reverse shock disabled, the fwd.ssc, rvs.sync, and rvs.ssc components are exactly zero while fwd.sync remains strictly positive.

With SSC and reverse shock enabled, the total flux density is finite and strictly positive at every sampled time.

Doubling the luminosity distance reduces the total flux density by exactly a factor of 4 (F proportional to 1/D_L^2) to 1e-9 relative.

F(nu, t; z2) == F(nu (1+z2)/(1+z1), t (1+z1)/(1+z2); z1) * (1+z2)/(1+z1) at fixed luminosity distance -- the exact cosmological transformation.

flux_density evaluated along a (t, nu) series matches the corresponding row of flux_density_grid at the same frequency to 1e-12 relative.

With SSC and reverse shock enabled, the total flux equals the sum of forward and reverse synchrotron plus SSC components to 1e-12 relative.

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).

For each medium (ISM/wind) and forward-shock quantity (four-velocity u, radius r, comoving B, swept-up proton number N_p), the power-law slope fitted over the Blandford-McKee phase time range matches the analytic self-similar exponent from the shared SHOCK_SCALINGS table within SLOPE_TOLERANCE (0.1 in the slope).