orbix 1.2.0__tar.gz → 2.0.0__tar.gz

{orbix-1.2.0 → orbix-2.0.0}/.github/workflows/docs.yml

@@ -12,7 +12,7 @@ jobs:
     name: Build docs
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7
 
     - name: Install uv
       uses: astral-sh/setup-uv@v7

{orbix-1.2.0 → orbix-2.0.0}/.gitignore

@@ -70,6 +70,7 @@ instance/
 
 # Sphinx documentation
 docs/_build/
+docs/.build/
 
 # PyBuilder
 .pybuilder/

{orbix-1.2.0 → orbix-2.0.0}/.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
         args: [--pytest-test-first]
       - id: end-of-file-fixer
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.16.4
+    rev: v0.16.10
     hooks:
       - id: ruff-check
         args: [--fix]

{orbix-1.2.0 → orbix-2.0.0}/.zenodo.json

@@ -3,7 +3,7 @@
   "creators": [
     {
       "orcid": "0000-0002-3138-0240",
-      "affiliation": "NASA Goddard Space Flight Center, Greenbelt, MD",
+      "affiliation": "University of Maryland, Baltimore County; NASA Goddard Space Flight Center; CRESST II",
       "name": "Spohn, Corey"
     }
   ],

{orbix-1.2.0 → orbix-2.0.0}/CHANGELOG.md

@@ -11,6 +11,31 @@
 * The broken predict/pdet functions and the `discrete_e` factory were removed
   (they did not work correctly and had no working callers).
 
+## [2.0.0](https://github.com/CoreySpohn/orbix/compare/v1.2.0...v2.0.0) (2026-10-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* **viz:** prepare sky tracks for shared renderers
+
+### Features
+
+* **kepler:** add a table-free Markley solver with implicit derivatives ([886bec0](https://github.com/CoreySpohn/orbix/commit/886bec02b6dfda444cf78a84710e1aadc2a2f150))
+* **viz:** prepare sky tracks for shared renderers ([84fd1ef](https://github.com/CoreySpohn/orbix/commit/84fd1ef7dd7fdb51fd0751cef4afd7f75f80dabd))
+
+
+### Bug Fixes
+
+* **viz:** accept a quarter-step clock rounding when no precision is exact ([67a3822](https://github.com/CoreySpohn/orbix/commit/67a3822eee0ed7b8474768a7b3b91acf3d048861))
+* **viz:** keep per-track colors on sky tracks ([693e5da](https://github.com/CoreySpohn/orbix/commit/693e5da6be5b55372bd7ae8b7a4d0b63733ee3af))
+* **viz:** print exact clock offsets, take clock_fmt, and weight heads ([022f04a](https://github.com/CoreySpohn/orbix/commit/022f04ac45b6d121f95a42a309b250fd44f94674))
+* **viz:** weight the star and observations at the top track weight so heads fade with their paths ([b190d40](https://github.com/CoreySpohn/orbix/commit/b190d40e2ec876ca5fafd3975485c3268e294cd7))
+
+
+### Performance Improvements
+
+* **kepler:** select the reduced angle before the trig polynomial and gather RPP coefficients once ([02d71da](https://github.com/CoreySpohn/orbix/commit/02d71dae0984e3e36f58ae70d502ab7703257362))
+
 ## [1.2.0](https://github.com/CoreySpohn/orbix/compare/v1.1.0...v1.2.0) (2026-08-28)
 
 

{orbix-1.2.0 → orbix-2.0.0}/CITATION.cff

@@ -7,7 +7,7 @@ authors:
   - family-names: Spohn
     given-names: Corey
     orcid: "https://orcid.org/0000-0002-3138-0240"
-    affiliation: "NASA Goddard Space Flight Center"
+    affiliation: "University of Maryland, Baltimore County; NASA Goddard Space Flight Center; CRESST II"
 repository-code: "https://github.com/CoreySpohn/orbix"
 license: MIT
 doi: "10.5281/zenodo.20819376"

{orbix-1.2.0 → orbix-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: orbix
-Version: 1.2.0
+Version: 2.0.0
 Summary: A JAX library of functions useful for exoplanet simulations
 Project-URL: Homepage, https://github.com/CoreySpohn/orbix
 Project-URL: Issues, https://github.com/CoreySpohn/orbix/issues
@@ -44,6 +44,7 @@ Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
 Requires-Dist: sphinx-book-theme; extra == 'docs'
 Provides-Extra: test
 Requires-Dist: eyepiece>=0.4.0; extra == 'test'
+Requires-Dist: mpmath>=1.3; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
 Provides-Extra: viz
 Requires-Dist: eyepiece>=0.4.0; extra == 'viz'
@@ -71,7 +72,13 @@ from orbix.orbit import KeplerianOrbit
 from orbix.kepler.shortcuts.grid import get_grid_solver
 
 orbit = KeplerianOrbit(
-    a_AU=1.0, e=0.0167, W_rad=0.0, i_rad=0.0, w_rad=0.0, M0_rad=0.0, t0_d=0.0,
+    a_AU=1.0,
+    e=0.0167,
+    W_rad=0.0,
+    i_rad=0.0,
+    w_rad=0.0,
+    M0_rad=0.0,
+    t0_d=0.0,
 )
 trig_solver = get_grid_solver(level="scalar", E=False, trig=True)
 t_jd = jnp.linspace(2451545.0, 2451545.0 + 365.25, 5)
@@ -84,6 +91,13 @@ contract `trig_solver(M, e) -> (sinE, cosE)`; `KeplerianOrbit.propagate` uses
 it to convert orbital elements and times into position vectors, phase angle,
 and star-planet distance.
 
+For an alternative without interpolation tables, use
+`from orbix.kepler import markley_solve_trig` and pass `markley_solve_trig` as the
+orbit's `trig_solver`. This Markley-based solver supports scalar inputs,
+broadcasting, and both forward and reverse derivatives. Enable
+`jax.config.update("jax_enable_x64", True)` for double-precision accuracy.
+The RPP/orvara solver remains available in `orbix.kepler.core`.
+
 ## Scope
 
 orbix provides Keplerian orbit geometry and Kepler-equation solvers; scene

{orbix-1.2.0 → orbix-2.0.0}/README.md

@@ -20,7 +20,13 @@ from orbix.orbit import KeplerianOrbit
 from orbix.kepler.shortcuts.grid import get_grid_solver
 
 orbit = KeplerianOrbit(
-    a_AU=1.0, e=0.0167, W_rad=0.0, i_rad=0.0, w_rad=0.0, M0_rad=0.0, t0_d=0.0,
+    a_AU=1.0,
+    e=0.0167,
+    W_rad=0.0,
+    i_rad=0.0,
+    w_rad=0.0,
+    M0_rad=0.0,
+    t0_d=0.0,
 )
 trig_solver = get_grid_solver(level="scalar", E=False, trig=True)
 t_jd = jnp.linspace(2451545.0, 2451545.0 + 365.25, 5)
@@ -33,6 +39,13 @@ contract `trig_solver(M, e) -> (sinE, cosE)`; `KeplerianOrbit.propagate` uses
 it to convert orbital elements and times into position vectors, phase angle,
 and star-planet distance.
 
+For an alternative without interpolation tables, use
+`from orbix.kepler import markley_solve_trig` and pass `markley_solve_trig` as the
+orbit's `trig_solver`. This Markley-based solver supports scalar inputs,
+broadcasting, and both forward and reverse derivatives. Enable
+`jax.config.update("jax_enable_x64", True)` for double-precision accuracy.
+The RPP/orvara solver remains available in `orbix.kepler.core`.
+
 ## Scope
 
 orbix provides Keplerian orbit geometry and Kepler-equation solvers; scene

{orbix-1.2.0 → orbix-2.0.0}/docs/conf.py

@@ -31,7 +31,7 @@ intersphinx_mapping = {
     "jax": ("https://docs.jax.dev/en/latest/", None),
 }
 
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+exclude_patterns = ["_build", ".build", "Thumbs.db", ".DS_Store"]
 
 autoapi_dirs = ["../src"]
 autoapi_ignore = ["**/_version.py"]

{orbix-1.2.0 → orbix-2.0.0}/docs/examples/orbits.md

@@ -14,8 +14,9 @@ kernelspec:
 `orbix.viz` turns an orbit into a figure in one call. It is installed with
 the `viz` extra (`pip install 'orbix[viz]'`) and is built on eyepiece, so
 every figure here follows the same conventions as any other figure in the
-eyepiece fleet: stateless ax-first functions, a `PlotResult` back, and
-style resolved from hwostyle at call time.
+eyepiece fleet: stateless functions that draw into a given axes or a new
+figure, a result back that holds every artist drawn, and style resolved from
+hwostyle at call time.
 
 Every page starts the same way: activate a style mode, import the plotting
 module, and declare the document's cast.
@@ -50,7 +51,10 @@ styles = ep.SourceStyles(["planet b", "planet c", "planet d"])
 `plot_sky_track` propagates an orbit and draws its sky-plane track in
 arcseconds: RA offset on the x axis (increasing to the left, per the
 astronomical convention), Dec offset on the y axis, the star at the
-origin, and an equal aspect so the ellipse is not distorted.
+origin, and an equal aspect so the ellipse is not distorted. The sky-plane
+functions share one preparation step that propagates the orbit once; the
+{doc}`prepared` page uses it directly for a still, a strip, and a movie from
+one set of tracks.
 
 ```{code-cell} ipython3
 MSUN_KG = 1.988409870698051e30
@@ -108,7 +112,7 @@ t_system = jnp.linspace(T0_D, T0_D + OUTER_PERIOD_D, 240)
 
 result = viz.plot_sky_track(
     orbit, t_jd, Ms_kg=MSUN_KG, dist_pc=10.0,
-    style=styles["planet b"], iwa=0.06,
+    style=styles["planet b"], iwa_arcsec=0.06,
 )
 ```
 
@@ -132,9 +136,14 @@ t_obs = T0_D + np.array([70.0, 250.0, 430.0])
 ra_true, dec_true = orbit.position_arcsec(
     t_jd=jnp.asarray(t_obs), Ms_kg=MSUN_KG, dist_pc=10.0
 )
+# Observations are (xy, xerr, yerr): positions shaped (P, 2) and one-sigma
+# errors along RA and Dec.
 epochs = (
-    np.asarray(ra_true)[0] + SIGMA_ARCSEC * rng.standard_normal(3),
-    np.asarray(dec_true)[0] + SIGMA_ARCSEC * rng.standard_normal(3),
+    np.column_stack([
+        np.asarray(ra_true)[0] + SIGMA_ARCSEC * rng.standard_normal(3),
+        np.asarray(dec_true)[0] + SIGMA_ARCSEC * rng.standard_normal(3),
+    ]),
+    np.full(3, SIGMA_ARCSEC),
     np.full(3, SIGMA_ARCSEC),
 )
 
@@ -151,7 +160,7 @@ draws = dict(
 fan = KeplerianOrbit.from_period(**draws, Ms_kg=MSUN_KG)
 result = viz.plot_sky_track(
     fan, t_jd, Ms_kg=MSUN_KG, dist_pc=10.0,
-    style=styles["planet b"], iwa=0.06, data=epochs,
+    style=styles["planet b"], iwa_arcsec=0.06, observations=epochs,
 )
 ```
 
@@ -213,7 +222,7 @@ ax3d.set_title("plot_orbit -- star-centric, AU")
 
 viz.plot_sky_track(
     system, t_system, Ms_kg=MSUN_KG, dist_pc=10.0, ax=axsky,
-    colors=[styles[name]["color"] for name in PLANETS], iwa=0.06,
+    colors=[styles[name]["color"] for name in PLANETS], iwa_arcsec=0.06,
     fan_kw={"lw": 1.8},
 )
 axsky.set_title("plot_sky_track -- as seen from Earth")
@@ -250,7 +259,8 @@ keeps a trailing window, `"none"` moves the head markers alone. The base
 marker size is the anchor the depth cue swells around, so it is where
 physical meaning lives: `size_by_radius` maps planet radii onto marker
 diameters. The same call with `kind="sky"` animates the sky-plane track
-instead.
+instead, played in physical time from the prepared sequence described in
+{doc}`prepared`.
 
 ```{code-cell} ipython3
 from IPython.display import HTML

orbix-2.0.0/docs/examples/prepared.md

@@ -0,0 +1,304 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+kernelspec:
+  display_name: Python 3
+  language: python
+  name: python3
+---
+
+# Sky tracks, prepared once
+
+A sky-plane figure of a planet's orbit is needed in several forms: a paper
+still of a posterior fan, a strip of chosen epochs, a movie, and a clip in a
+talk. Each form needs the same science: the orbits propagated over the time
+grid, projected to arcseconds, and moved from the device to the host. The
+preparation functions in `orbix.viz` do that work once and return
+[eyepiece](https://eyepiece.readthedocs.io) prepared records, which
+eyepiece's renderers draw. None of the outputs below propagates an orbit
+again, so they cannot disagree about where the planet is.
+
+- `prepare_sky_view` returns a static `TrackView` of full tracks, with no
+  time axis.
+- `prepare_sky_track` returns a `Sequence` whose samples are the propagated
+  epochs, with a head per track, an optional trail, and a clock.
+
+Their module imports NumPy, JAX, the orbit types, and `eyepiece.prepared`,
+and no renderer. Drawing belongs to
+`eyepiece.mpl` for figures and movies and `eyepiece.manim` for native Manim
+clips. The records, scales, and sample-and-hold time rules are described in
+eyepiece's
+[prepared views guide](https://eyepiece.readthedocs.io/en/latest/prepared-views.html).
+
+```{code-cell} ipython3
+import jax
+
+# Julian days near 2.46 million need double precision to resolve a fraction
+# of a day, and the clock below prints the sampled times.
+jax.config.update("jax_enable_x64", True)
+
+import hwostyle
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from hwoutils.constants import Msun2kg
+from IPython.display import HTML
+
+import eyepiece.mpl as mpl
+from eyepiece.prepared import find_element
+from eyepiece.style import SourceCast, snapshot_profile
+from orbix import KeplerianOrbit
+from orbix.viz import prepare_sky_track, prepare_sky_view
+
+hwostyle.use("dark")
+
+# Docs-builder concerns, not lines to copy into your own scripts: a fallback
+# face for builders without the style's fonts, and small page images.
+matplotlib.rcParams["font.sans-serif"] = list(
+    matplotlib.rcParams["font.sans-serif"]
+) + ["DejaVu Sans"]
+matplotlib.rcParams["savefig.dpi"] = 120
+
+# One cast and one profile for every output on this page, sized from the
+# active style's rc settings.
+CAST = SourceCast(["planet b"])
+PROFILE = snapshot_profile(
+    text_size_pt=plt.rcParams["font.size"],
+    stroke_width_pt=plt.rcParams["lines.linewidth"],
+)
+```
+
+## A posterior and its data
+
+The planet below is synthetic: an eccentric, inclined orbit around a solar
+mass star at 10 pc, three measured positions drawn from it with 8 mas
+errors, and forty posterior draws scattered around it, each with a weight.
+
+```{code-cell} ipython3
+DIST_PC = 10.0
+A_AU, ECC, INC_RAD = 1.3, 0.31, 1.05
+BIG_OMEGA_RAD, SMALL_OMEGA_RAD, M0_RAD = 2.3, -0.7, 0.4
+T0_D = 2460000.0
+PERIOD_D = A_AU**1.5 * 365.25
+PERIAPSIS_D = T0_D - M0_RAD * PERIOD_D / (2.0 * np.pi)
+
+orbit = KeplerianOrbit(
+    a_AU=A_AU, e=ECC, W_rad=BIG_OMEGA_RAD, i_rad=INC_RAD,
+    w_rad=SMALL_OMEGA_RAD, M0_rad=M0_RAD, t0_d=T0_D,
+)
+rng = np.random.default_rng(0)
+
+# Observed positions: the true orbit at three epochs, perturbed by the error.
+SIGMA_ARCSEC = 0.008
+t_obs = T0_D + np.array([70.0, 250.0, 430.0])
+ra, dec = orbit.position_arcsec(t_jd=t_obs, Ms_kg=Msun2kg, dist_pc=DIST_PC)
+xy_obs = np.column_stack([np.asarray(ra)[0], np.asarray(dec)[0]])
+xy_obs = xy_obs + SIGMA_ARCSEC * rng.standard_normal(xy_obs.shape)
+sigma = np.full(len(t_obs), SIGMA_ARCSEC)
+observations = (xy_obs, sigma, sigma)
+
+# Forty posterior draws around the same orbit, and a weight for each.
+K = 40
+fan = KeplerianOrbit.from_period(
+    T_d=PERIOD_D * (1.0 + 0.04 * rng.standard_normal(K)),
+    e=np.clip(ECC + 0.04 * rng.standard_normal(K), 0.0, 0.9),
+    cos_i=np.clip(np.cos(INC_RAD) + 0.06 * rng.standard_normal(K), -1.0, 1.0),
+    W_rad=BIG_OMEGA_RAD + 0.08 * rng.standard_normal(K),
+    cos_w=np.cos(SMALL_OMEGA_RAD + 0.15 * rng.standard_normal(K)),
+    sin_w=np.sin(SMALL_OMEGA_RAD + 0.15 * rng.standard_normal(K)),
+    tp_d=PERIAPSIS_D + 12.0 * rng.standard_normal(K),
+    Ms_kg=Msun2kg,
+)
+weights = rng.dirichlet(np.full(K, 3.0))
+
+# One orbital period in 180 steps of about three days.
+t_jd = np.linspace(T0_D, T0_D + PERIOD_D, 181)
+```
+
+## A still of the fan
+
+`prepare_sky_view` propagates every draw over `t_jd` and returns one
+`TrackView`. Each draw is its own `Path` (`path/0` to `path/39`), so every
+draw stays addressable, while `source_ids="planet b"` names the one planet
+they all describe, so they share one color from the cast. The weights become
+relative opacity. The observations carry their error bars, and
+`iwa_arcsec` adds the inner working angle as a shaded disk about the star.
+RA offset increases to the left and the two axes share one scale; both are
+part of the view, not options.
+
+```{code-cell} ipython3
+view = prepare_sky_view(
+    fan,
+    t_jd=t_jd,
+    Ms_kg=Msun2kg,
+    dist_pc=DIST_PC,
+    source_ids="planet b",
+    weights=weights,
+    observations=observations,
+    iwa_arcsec=0.06,
+)
+fig, ax = plt.subplots(figsize=(4.2, 4.0), layout="constrained")
+fan_still = mpl.render(view, ax=ax, cast=CAST, profile=PROFILE)
+print(len(fan_still.parts), "parts, including", sorted(fan_still.parts)[:4])
+```
+
+`fan_still.parts` maps each element ID to its Matplotlib artist, so one
+draw, the star, or the IWA disk is adjusted through its handle. The
+Matplotlib convenience `plot_sky_track` makes this same view and render in
+one call.
+
+## A sequence of epochs
+
+`prepare_sky_track` takes the same arguments and returns a `Sequence` over
+the propagated epochs. Its template adds a head per draw (`head/<k>`), which
+holds the propagated position at the current sample, and a clock. `history`
+adds a trail per draw: `"all"` grows from the first sample, and an integer
+keeps a sliding window of that many samples, here about ninety days.
+
+```{code-cell} ipython3
+sequence = prepare_sky_track(
+    fan,
+    t_jd=t_jd,
+    Ms_kg=Msun2kg,
+    dist_pc=DIST_PC,
+    source_ids="planet b",
+    weights=weights,
+    observations=observations,
+    iwa_arcsec=0.06,
+    history=30,
+)
+print(f"{len(sequence.times)} samples in {sequence.time_unit!r} after JD {sequence.epoch}")
+```
+
+Times are days since the first sample, and the first sample's Julian day is
+the sequence `epoch`. A head never moves along the chord between two
+samples. Asked for a time between samples, the sequence holds the earlier
+one, so a head is always a propagated position. On a sparsely sampled orbit
+an interpolated head could cut across the inner working angle while the
+orbit itself never enters it; a held head cannot.
+
+```{code-cell} ipython3
+between = 0.5 * (sequence.times[60] + sequence.times[61])
+sample = sequence.at(between)
+held = find_element(sample.view, "head/0").xy[0]
+propagated = find_element(sequence.template, "path/0").xy[60]
+print(f"t = {between:.1f} d holds sample {sample.index}:", np.array_equal(held, propagated))
+```
+
+## A still and a strip
+
+`sequence.frame(i)` is the complete state at sample `i`, and
+`sequence.strip(indices)` lays chosen samples side by side. Each strip slot's
+IDs are prefixed with its position, and each slot's clock is its time label,
+restamped with that slot's time. The heads show where the planet could be at each epoch: the spread of
+the forty heads is the posterior uncertainty in its position at that time.
+
+```{code-cell} ipython3
+picks = [0, 60, 120]
+fig, axes = plt.subplots(1, 3, figsize=(10.0, 3.6), layout="constrained")
+strip = mpl.render(sequence.strip(picks), axes=axes, cast=CAST, profile=PROFILE)
+```
+
+## A movie
+
+`eyepiece.mpl.animate` plays the sequence in physical time: three seconds at
+ten frames per second is thirty output frames, spaced evenly from the first
+sample to the last. Each output frame holds the latest sample acquired at or
+before its time, so the heads move at their projected speed on the sky:
+quickly near periapsis and slowly near apoapsis.
+
+```{code-cell} ipython3
+fig, ax = plt.subplots(figsize=(3.6, 3.4), layout="constrained")
+movie = mpl.animate(
+    sequence, run_time=3.0, fps=10, ax=ax, cast=CAST, profile=PROFILE
+)
+html = movie.jshtml(dpi=100)
+plt.close(fig)
+print("output frames:", movie.n_frames)
+HTML(html)
+```
+
+`animate_orbit(..., kind="sky")` wraps preparation and this call in one step,
+for a movie that needs no other output.
+
+## Bare tracks
+
+Tracks that were propagated elsewhere, or loaded from a file, enter through
+the same functions: an array of arcsecond offsets shaped `(K, T, 2)`, or an
+`(ra, dec)` pair of `(T,)` or `(K, T)` arrays. A bare array is borrowed as
+given, without a copy. `prepare_sky_view` draws bare tracks with no times at
+all, and `prepare_sky_track` takes the times they were sampled at. A row with
+a nonfinite coordinate is a gap in the track.
+
+```{code-cell} ipython3
+tracks = np.stack(
+    [find_element(view, f"path/{k}").xy for k in range(K)]
+)  # (K, T, 2) arcsec
+bare = prepare_sky_view(tracks, source_ids="planet b", iwa_arcsec=0.06)
+print(np.shares_memory(find_element(bare, "path/0").xy, tracks))
+```
+
+## In a talk
+
+The same sequence plays as a native Manim clip through `eyepiece.manim`,
+with a profile sized for slides and the same cast, so the planet keeps its
+color from paper to talk. The code below is shown rather than run, because
+rendering Manim media needs system libraries a documentation builder does
+not have.
+
+```python
+import manim
+import eyepiece.manim as em
+from matplotlib.colors import to_hex
+
+TALK = snapshot_profile()  # 24 pt text and 1.5 pt strokes
+
+
+class Orbit(manim.Scene):
+    def construct(self):
+        self.camera.background_color = manim.ManimColor(to_hex(TALK.background_color))
+        clip = em.animate(sequence, cast=CAST, profile=TALK)
+        self.add(clip.mobject)
+        self.play(clip.playback(run_time=8))
+```
+
+Render it with Manim's caching disabled (`manim --disable_caching`). The
+playback follows the same physical-time schedule as the Matplotlib movie.
+Eyepiece's [Manim guide](https://eyepiece.readthedocs.io/en/latest/manim.html)
+covers the parts, reveals, and Manim Slides.
+
+## Migrating from the earlier sky-track functions
+
+Earlier releases drew sky tracks directly through `eyepiece.sky_fan`.
+`plot_sky_track` and `animate_orbit(kind="sky")` now prepare the tracks
+first and render them through eyepiece, which changes the following
+behavior.
+
+- Bare tracks are shaped `(K, T, 2)`, (RA, Dec) last, or given as an
+  `(ra, dec)` pair of `(T,)` or `(K, T)` arrays. The earlier `(2, T)` and
+  `(K, 2, T)` arrays are no longer read: pass a `(2, T)` array as the pair
+  `tuple(tracks)`, and a `(K, 2, T)` array as `np.moveaxis(tracks, 1, 2)`.
+- `invert_ra=` is removed. RA always increases to the left.
+- `plot_sky_track` returns an `eyepiece.mpl.MplResult`, not a `PlotResult`.
+  Track `k`'s line is `result.parts["path/k"]`, and the IWA disk and the
+  observations are `result.parts["iwa"]` and `result.parts["observations"]`.
+- Bare tracks are in arcsec and get the same RA and Dec offset axis labels
+  as propagated orbits.
+- A lone track is drawn at opacity 0.80, the top of the shared weight
+  mapping, rather than 0.75. Heads carry their track's weight and fade with
+  it; the star and the observations carry the top track weight, so they
+  stay at full opacity.
+- An `"alpha"` in `fan_kw=` is set last, so it replaces the weight-derived
+  opacity instead of scaling it.
+- `plot_sky_track` still accepts `data=(ra, dec, err)` and `iwa=` and
+  converts them to `observations=` and `iwa_arcsec=`. `animate_orbit` with
+  `kind="sky"` takes only `observations=(xy, xerr, yerr)` and `iwa_arcsec=`,
+  so convert there by hand: `observations=(np.column_stack([ra, dec]), err,
+  err)`.
+- `animate_orbit(kind="sky")` refuses `style=`, `base_ms=`, and `marks=`,
+  which apply to `kind="3d"` only; sky colors come from the cast. It needs
+  `t_jd=` for bare tracks too, because the sample times drive its clock and
+  its physical-time playback.