Kshana — Architektur

Kshana ist eine Engine, in Schichten über einem gemeinsamen Kern organisiert: die Sensorpakete (Uhr, inertial, Zeitübertragung, hybrid); eine astrodynamische / numerische Schicht (analytisches SGP4/SDP4 (SGP4: Simplified General Perturbations 4; SDP4: Simplified Deep-space Perturbations 4), ein numerischer Cowell-Propagator mit seinem Kraftmodell aus sieben Störungen, Manöverentwurf, Bahnbestimmung aus Bodenstations-Entfernungen und die Anpassung des Kraftmodells an präzise Ephemeriden von Agenturen); eine Schicht für Zeit & Bezugssysteme (IERS-Zeitskalen (International Earth Rotation and Reference Systems Service), IAU-Präzession–Nutation 2006/2000A (International Astronomical Union) und die CIO-Reduktion (Celestial Intermediate Origin) GCRS↔ITRS (GCRS: Geocentric Celestial Reference System; ITRS: International Terrestrial Reference System)); eine Fusionsschicht (die GNSS/INS-Schätzer (GNSS: globales Satellitennavigationssystem; INS: inertiales Navigationssystem)); und die Schichten für Integrität, Resilienz, alt-PNT (PNT: Positionierung, Navigation und Zeitgebung) und Mond (RAIM/ARAIM/SBAS (RAIM: Empfängerautonome Integritätsüberwachung; ARAIM: erweiterte empfängerautonome Integritätsüberwachung; SBAS: satellitengestütztes Erweiterungssystem), jamming und mehrschichtige spoofing-Erkennung, Karten-Abgleich mit Gravitation/Gelände/Magnetfeld und cislunare PNT); sowie die neueren Schichten LEO-PNT (PNT in niedriger Erdumlaufbahn), Spektrum, Sonnensystem und Konstellationsentwurf, Netzzeitgebung und Kampagnen, mit den Bericht-, Animations- und Interoperabilitäts-Schreibern, die jeder Lauf nutzen kann (§1d). In allen kennt die Engine nichts von „quantum“ gegenüber „classical“: Sie treibt Sensor-Fehlermodelle durch ein GNSS-Ausfallszenario, führt einen Schätzer aus und bewertet das Ergebnis. Ein Quanten- und ein klassisches Gerät werden daher im selben Szenario verglichen und unterscheiden sich nur in ihren (veröffentlichten, zitierten) Fehlerparametern und ihren unabhängigen Rauschseeds.

Dieses Dokument sammelt die strukturellen und verhaltensbezogenen Diagramme. §1 ist der Kern der Sensorpakete; §1a bildet die seither hinzugekommenen Schichten für Astrodynamik, Fusion und alt-PNT ab; §1b–§1d die Schichten für Studien, Anwendungsbereiche und Ausgaben. Zur Nutzung siehe die README; zu dem, was validiert ist und was nicht, siehe VALIDATION; für die Reifetabelle je Fähigkeit siehe CAPABILITY.

In den Diagrammen verwendete Abkürzungen, die dort nicht ausgeschrieben sind: ADEV, Allan-Abweichung; BW, Bandbreite; CAI, Kaltatom-Interferometer; CZML, die Cesium Language; Δ-DOR, Delta Differential One-way Ranging; DO-229E, der RTCA-Empfängerstandard (Radio Technical Commission for Aeronautics) für SBAS; EKF, erweitertes Kalman-Filter; FM, Frequenzmodulation; GSE, Bodenunterstützungsausrüstung; HPL/VPL, horizontales/vertikales Schutzniveau; IMU, inertiale Messeinheit; IOAG, Interagency Operations Advisory Group; IQ, Gleichphasen-/Quadratur-Abtastwerte; ISL, Intersatellitenverbindung; ITU-T, der Sektor für Telekommunikationsstandardisierung der Internationalen Fernmeldeunion; J2–J6, die zonalen Gravitationsharmonischen der Erde vom Grad 2 bis 6; KIF, das Kshana Interchange Format; KML, Keyhole Markup Language; KPI, Leistungskennzahl; L1/L5, GNSS-Trägerbänder (das L2 der CR3BP-Halo-Orbits ist stattdessen der Lagrange-Punkt 2 von Erde–Mond); LEO, niedrige Erdumlaufbahn; LOO, Leave-one-out; LTC, koordinierte Mondzeit; MEO, mittlere Erdumlaufbahn; MTIE, maximaler Zeitintervallfehler; N2, die Hill-Diversitätszahl der Ordnung 2; NED, Nord-Ost-Unten; NTN, nichtterrestrisches Netz; OD, Bahnbestimmung; OPS-SAT, der Satellit der Europäischen Weltraumorganisation als Software-Labor im Orbit; PPP, präzise Punktpositionierung; PSD, spektrale Leistungsdichte; PVT, Position, Geschwindigkeit und Zeit; RINEX, Receiver Independent Exchange Format; RK4 / RK5(4), Runge–Kutta-Integratoren vierter Ordnung und eingebettet fünfter (vierter) Ordnung; SH, Kugelflächenfunktion; SigMF, Signal Metadata Format; SIR, Sampling Importance Resampling; SRIF, Wurzel-Informationsfilter; SRP, Strahlungsdruck der Sonne; SSC, spektraler Trennungskoeffizient; STK, Systems Tool Kit; SVG, Scalable Vector Graphics; TDEV, Zeitabweichung; TDM, die Tracking Data Message des CCSDS (Consultative Committee for Space Data Systems); TLE, Two-Line-Element-Satz; TPL, Zeitgebungs-Schutzniveau; UBX, das binäre Protokoll von u-blox; UHF, Ultrahochfrequenz; VLBI, Interferometrie mit sehr langer Basislinie; VRW / ARW, Random Walk der Geschwindigkeit / des Winkels; WASM, WebAssembly.

---

1. Modulstruktur#

flowchart TD
    main["main.rs<br/>CLI (thin wrapper)"]
    py["python.rs<br/>PyO3 (feature)"]
    wasm["wasm.rs<br/>wasm-bindgen (feature)"]
    api["api.rs<br/>run_toml: parse · dispatch by kind · json+svg+summary"]

    subgraph shared["Shared core"]
      types["types.rs<br/>Seconds · TimeGrid · ModelSpec"]
      scenario["scenario.rs<br/>GnssState · GnssTimeline · ClockCfg · Scenario"]
      allan["allan.rs<br/>overlapping Allan deviation"]
    end

    subgraph pack1["Pack 1 · Clock holdover"]
      models["models.rs<br/>ErrorModel · ClockModel (incl. flicker FM)"]
      estimator["estimator.rs<br/>HoldoverEstimator"]
      kalman["kalman.rs<br/>KalmanClock → Integrity bound"]
      security["security.rs<br/>clock-aided spoof detection → Security"]
      fom["fom.rs<br/>Sample · FoMScores · score · worst_case_holdover"]
      report["report.rs<br/>RunResult · hash · to_svg"]
      run["run.rs<br/>run / run_clock / run_orbit_clock"]
    end

    inertial["inertial/<br/>Pack 2 · AccelModel (accel + gyro + bias instability/RW) · run_inertial · quantum_imu CAI + QuantumNavBudget dead-reckoning-over-holdover"]
    timetransfer["timetransfer.rs<br/>Pack 3 · TimeTransferLink · run_timetransfer"]
    hybrid["hybrid.rs<br/>Pack 4 · run_suite · score_hybrid · run_hybrid (+ integrity/security)"]
    fusion["fusion/<br/>joint Kalman PNT estimator · run_fusion"]
    orbit["orbit.rs<br/>Propagator (Kepler | SGP4) · Walker / TLE / multi-constellation · visibility · DOP"]
    tle["tle.rs<br/>two-line element parsing (line 2 → Kepler, full TLE → SGP4)"]
    sgp4mod["sgp4.rs<br/>SGP4 / SDP4 propagator (deep-space + resonance)"]
    ensemble["ensemble.rs<br/>Monte Carlo confidence bands"]
    sweep["sweep.rs<br/>trade-study parameter sweeps"]
    spoof["spoof.rs<br/>active spoofing-attack demonstrator"]
    jamming["jamming.rs<br/>link-budget anti-jam C/N₀ (J/S · processing gain · Q)"]
    navsignal["navsignal.rs<br/>signal level: BPSK-R / BOC PSD · SSC κ · Gabor BW · DLL jitter · multipath · ranging-code (m-seq/Gold) design-trade"]
    holdover["holdover.rs<br/>GNSS-denied clock holdover: van-Loan coast → holdover-to-threshold · quantum-clock classes"]
    verification["verification.rs<br/>machine-checked requirement→module→test→oracle→status matrix"]

    main --> api
    py --> api
    wasm --> api
    api --> run
    api --> inertial
    api --> timetransfer
    api --> hybrid
    api --> ensemble
    api --> sweep
    api --> fusion
    api --> spoof
    spoof --> security
    api --> jamming
    api --> holdover
    api --> verification
    navsignal -. derives anti-jam Q (κ → Q=1/(R_c·κ)) .-> jamming
    jamming -. uses PSD / SSC .-> navsignal
    holdover -. coast-variance vs van-Loan recursion .-> kalman
    ensemble --> run
    sweep --> run
    orbit --> tle
    tle --> sgp4mod
    orbit -. SGP4 propagator .-> sgp4mod
    fusion -. composes .-> models
    fusion -. composes .-> inertial
    fusion --> kalman

    run --> models
    run --> estimator
    run --> kalman
    run --> security
    run --> fom
    run --> report
    run --> orbit
    models --> types
    scenario --> types
    inertial --> scenario
    timetransfer --> types
    orbit --> scenario
    hybrid -. composes .-> models
    hybrid -. composes .-> estimator
    hybrid -. composes .-> inertial
    hybrid -. composes .-> timetransfer
    pack1 --> shared
    inertial --> allan

Die CLI (Befehlszeilenschnittstelle) und beide Bindings laufen über einen einzigen Einstiegspunkt api::run_toml, sodass sie nie auseinanderlaufen. Die Pakete verwenden den gemeinsamen Kern wieder (types, scenario, allan); Paket 4 (hybrid) setzt die Modelle und Schätzer der Pakete 1–3 zusammen, statt sie neu zu implementieren; orbit leitet aus der Geometrie eine GNSS-Zeitleiste ab, die dann den Lauf von Paket 1 speist. Das Modul navsignal sitzt auf Signalebene zwischen dem Link-Budget und dem Messungsbereich: Es leitet den spektralen Trennungskoeffizienten κ aus den tatsächlichen Leistungsspektren von Signal und Störer ab, woraus jamming nun sein Anti-Jam-Q = 1/(R_c·κ) berechnet, statt eine repräsentative Konstante zu nehmen (in der CI (Continuous Integration) gegengeprüft); es trägt außerdem den Entwurfskompromiss der Entfernungsmesscodes (m-Folge/Gold).

Drei weitere Module bilden das Rückgrat der GNSS-verweigerten Resilienz. holdover beantwortet die operative Frage unmittelbar — wie lange kann diese Uhr frei laufen, bevor ihr Zeitfehler das Budget überschreitet? —, indem es die geschlossene van-Loan-Form des Auslauffehlers als Inversion von holdover zu Schwelle bereitstellt, gegengeprüft gegen die mehrstufige Kovarianzrekursion von clock_state. Sein inertialer Zwilling lebt in inertial::quantum_imu (QuantumNavBudget), das die Weißrauschdrift des Kaltatom-Interferometers mit Bias- und Skalenfaktorfehler zu einem Budget der Positionsdrift über holdover zusammensetzt (der Bias-Term ist gegen den unabhängigen Integrator AccelModel gegengeprüft). verification stellt die Matrix der gesamten Engine von Anforderung zu Modul zu Test zu unabhängiger Referenz zu Status dar, mit unit-getesteten Invarianten, die ein Label validiert ohne unabhängige externe Referenz verbieten — damit sich die Zusicherung nicht vom Code entfernen kann.

1a. Schichten für Astrodynamik, Fusion und alt-PNT#

Über den Kern der Sensorpakete hinaus teilen sich drei Subsysteme denselben gemeinsamen Kern und speisen orbit (oder werden davon gespeist). Die astrodynamische / numerische Schicht fügt neben dem analytischen SGP4/SDP4-Pfad einen nichtanalytischen Cowell-Propagator hinzu; die Fusionsschicht trägt die GNSS/INS-Schätzer; und die alt-PNT-Schicht ist GPS-verweigerter (GPS: Global Positioning System) Gravitationskarten-Abgleich. Dies sind Bibliotheks-/Szenariofähigkeiten (siehe CAPABILITY, welche an eine Szenarioart kind angebunden sind und welche als Rust-API (Programmierschnittstelle) erreichbar sind).

flowchart TD
    subgraph astro["Astrodynamics & numerical"]
      orbit2["orbit · sgp4 · tle · walker<br/>analytic SGP4/SDP4 · Walker design"]
      prop["propagator<br/>Cowell driver (accel_at / accel_rv)"]
      forces["forces<br/>two-body · J2–J6 · EGM2008 d/o-70 · 3rd-body · SRP · drag · Schwarzschild + Lense–Thirring · tides"]
      integ["integrator<br/>RK4 step-doubling · Dormand–Prince RK5(4)"]
      ephem["ephem<br/>low-precision Sun & Moon"]
      man["maneuver<br/>impulsive/finite burns · Izzo Lambert · porkchop"]
      od["orbit_determination<br/>Gauss–Newton batch (batch_ls) · sequential UKF"]
    end
    subgraph fusion["Fusion (GNSS/INS)"]
      ekf["fusion/gnss_ins_ekf · closed_loop · pack<br/>15-state loosely-coupled EKF"]
      tc["fusion/tightly_coupled (8-state)<br/>fusion/tightly_coupled17 (17-state, quantum-CAI)"]
      ukf["fusion/ukf — sigma-point core"]
      coup["fusion/coupled — clock+position cross-covariance"]
    end
    subgraph alt["Alt-PNT (GPS-denied)"]
      grav["gravimeter<br/>cold-atom model + SH anomaly field + mascons"]
      pf["particle_filter — SIR"]
      mm["mapmatch — field-match likelihood"]
    end
    prop --> forces
    prop --> integ
    forces --> ephem
    man --> integ
    od --> forces
    od --> integ
    od --> ukf
    tc --> ukf
    tc -. coasts on .-> forces
    grav --> pf
    mm --> pf
    grav --> mm
    ekf -. drives .-> strap["inertial/ strapdown (quaternion · NED · IMU errors)"]
    tc -. drives .-> strap
    grav -. CAI floor .-> strap

Die Kraftterme des numerischen Propagators sind standardmäßig aus, sodass ihr Einschalten die freigegebenen Goldens nie verändert. Das eng gekoppelte UKF (Unscented Kalman Filter) mit 17 Zuständen überbrückt einen GNSS-Ausfall mit dem abgeleiteten Geschwindigkeits-Random-Walk des Quanten-CAI-Beschleunigungsmessers; die Bahnbestimmung verwendet dieselben forces/integrator wieder, um einen Kandidatenzustand über den Verfolgungsbogen zu propagieren.

Derselbe gemeinsame Kern trägt außerdem vier weitere Subsysteme, die oben nicht gezeichnet sind (ihre Pakete erscheinen im Dispatch von §4): eine Schicht für Zeit & Bezugssysteme (timescales, jd2, precession, nutation, cio, frames, eop), die TEME↔GCRS↔ITRS reduziert (TEME: true equator, mean equinox) und das Paket ephemeris/Bodenspur speist; eine Integritätsschicht (raim, sbas) für RAIM/ARAIM/SBAS; eine Resilienzschicht (jamming, spoof, spoof_detect, spoof_monitors, detection) für jamming und mehrschichtige spoofing-Erkennung, mit einer Navigationssignalschicht (navsignal) auf Signalebene — spektrale Leistungsdichten von BPSK-R (BPSK: binäre Phasenumtastung) / Sinus-BOC (BOC: binärer Offsetträger), der spektrale Trennungskoeffizient κ, der nun das Anti-Jam-Q von jamming ableitet, die RMS-Entfernungsbandbreite (Gabor), der Jitter der kohärenten Early–Late-Codeverfolgung des DLL (Delay-Locked Loop) und die Mehrwege-Fehlerhüllkurve (Signalleistungsanalyse, nicht Entwurf von RF-Nutzlast- (RF: Hochfrequenz) / Antennenhardware — die Rolle eines Nutzlastpartners); und eine Mond-/cislunare Schicht (lunar, lunar_frame, lunar_od, cr3bp) für CR3BP-Dynamik (eingeschränktes kreisförmiges Dreikörperproblem) — einschließlich der Zustandsübergangsmatrix 6×6 und eines Differenzialkorrektors mit Einzelschießverfahren (cr3bp_jacobian, propagate_state_stm, differential_correct_halo), der echte periodische Halo-/NRHO-Bahnen (NRHO: nahezu geradlinige Halo-Bahn) erzeugt und die veröffentlichte südliche L2-NRHO 9:2 (die Gateway-Bahn) bei Periode ≈ 6,57 d / Perilun ≈ 3.250 km reproduziert (veröffentlicht ≈ 6,56 d / ≈ 3.370 km); die selenozentrische MCI/MCMF-Transformation (MCI: mondzentriert inertial; MCMF: mondzentriert, mondfest) einer korrigierten Bahn und die Familienfortsetzung bleiben Folgearbeiten, und die NRHO ist eine CR3BP-Lösung (kreisförmig, ohne Sonne), nicht gegen eine reale LANS/Gateway-Ephemeride (LANS: Lunar Augmented Navigation Service) validiert — und die LunaNet-Integrität. Die Anpassung des Kraftmodells an Ephemeriden von Agenturen (precise_od, lunar_od, tides, gravity_sh) und der volle Satz an alt-PNT-Feldern (igrf, altpnt/terrain, gravimeter) runden die Modulliste ab; zur Reife je Modul siehe CAPABILITY.

1b. Resilienzstudien, Auswertung von maschinellem Lernen und reproduzierbare Artefakte#

Fünf weitere Modulgruppen bilden die offene, reproduzierbare Studien-Schicht hinter den Forschungsarbeiten des Projekts. Anders als die Szenarioarten kind werden diese als Generatoren cargo run --example / --bin erreicht, die byte-deterministische Artefakte schreiben (feste Seeds, festgehaltene Engine-Version + Konfigurations-Hash). Alle sind MODELLED (synthetische oder öffentliche Datensatz-Kalibrierung) und tragen ehrliche Validierungskennzeichnungen — keine ist eine Zertifizierung.

flowchart TD
    gen["study generators<br/>examples/ · bin/ (cargo run) → byte-deterministic artifacts"]

    subgraph timing["Timing integrity"]
      tplm["tpl<br/>conditional Timing Protection Level: k-σ floor · van-Loan coast · CUSUM"]
    end
    subgraph resilm["Resilience scoring & decision-instability"]
      arch["resilience/arch · score<br/>architecture model + RPCF-aligned scoring"]
      stats["resilience/stats<br/>Dirichlet · Kendall-τ · flip-rate · bootstrap"]
      div["resilience/diversity · timeline<br/>Hill-N2 common-mode collapse · KPIs"]
      study["resilience/study · report · panel<br/>instability study + integrity-hashed assurance report"]
    end
    subgraph aiml["RF-impairment optimism-gap (Machine learning)"]
      ie["impairment_eval<br/>labelled synthetic corpus · ROC/AUC harness"]
      is["impairment_study<br/>13-detector panel · scaling laws · LOO predictor"]
      ml["impairment_ml<br/>logistic-regression + one-hidden-layer MLP"]
      es["eval_stats<br/>bootstrap CI · DeLong · Spearman · ridge"]
      sdrm["sdr · realdata<br/>IQ/IF → E/P/L taps → SQM + ingest adapters"]
    end
    subgraph trade["Quantum-vs-classical"]
      cross["crossover<br/>resilience crossover map under parameter uncertainty"]
      qt["quantum_trade<br/>measured-ADEV holdover benefit vs classical"]
    end

    gen --> timing
    gen --> resilm
    gen --> aiml
    gen --> trade
    tplm -. cross-checked vs .-> recursion["holdover · clock_state · allan"]
    is --> ie
    is --> ml
    is --> es
    ie -. real recordings via .-> sdrm
    cross -. composes .-> packs2["clock · inertial packs"]

• tpl — das bedingte Zeitgebungs-Schutzniveau: eine durch holdover begrenzte Schranke für den unentdeckten Zeitfehler unter spoofing, zusammengesetzt aus einer k-σ-Monitor-Untergrenze, der van-Loan-Auslaufvarianz über die Erkennungslatenz und einer CUSUM-Zeit-bis-Alarm (kumulative Summe); kalibriert an einem real aufgezeichneten Spoofing (JammerTest 2024). Es gibt keine endliche unbedingte Schranke — das TPL ist daran gebunden, dass eine unabhängige Gegenprüfung den Angriff erkennt.
• resilience/ — eine am Rahmenwerk ausgerichtete Bewertungs-Engine für PNT-Resilienz (Kategorien des DHS (Department of Homeland Security) RPCF (Resilient PNT Conformance Framework)) plus eine Studie zur Entscheidungsinstabilität: ein Dirichlet-Gewichtungssimplex, Kendall-τ-Ranginstabilität, Top-1-Gewinner-Wechselrate und Diversitätskollaps durch gemeinsame Ursachen (Hill-N2), mit einem integritätsgehashten Zusicherungsbericht und 35 von Hand abgeleiteten Referenztests. Siehe RESILIENCE-CROSSWALK. Synthetische Architekturen, ausgerichtet an RPCF v2.0 — eine Selbstbewertung, keine Zertifizierung.
• impairment_eval / impairment_study / impairment_ml / eval_stats — die Studie zur Optimismuslücke bei RF-Beeinträchtigungen: ein beschrifteter synthetischer Korpus und ein detektorunabhängiges ROC/AUC-Harness (ROC: Receiver Operating Characteristic; AUC: Fläche unter der Kurve), ein Panel aus 13 Detektoren (Energie/AGC/SQM/Parität (AGC: automatische Verstärkungsregelung; SQM: Signalqualitätsüberwachung) plus Detektoren mit festem Seed aus logistischer Regression und einem MLP mit einer verborgenen Schicht (MLP: mehrschichtiges Perzeptron)), Skalierungsgesetze innerhalb gegenüber außerhalb der Verteilung mit einer Permutations-Nullverteilung und ein Leave-one-out-Prädiktor der Degradation außerhalb der Verteilung. Die Auswertungsmetriken sind bitgenau gegen scikit-learn validiert.
• sdr / realdata — ein Front-End eines softwaredefinierten Empfängers (rohe IQ/IF (IQ: Gleichphasen/Quadratur; IF: Zwischenfrequenz) → Korrelator-Early/Prompt/Late-Abgriffe → SQM) und Einlese-Adapter (RINEX, u-blox UBX, GnssLogger, JammerTest, Yunnan, SatGrid), mit denen dieselben Detektoren über lokal bereitgestellte Aufzeichnungen laufen; es werden keine Datensätze im Repository eingecheckt.
• crossover / quantum_trade — die Karte des Resilienz-Übergangs zwischen Quanten und klassisch unter Parameterunsicherheit und der Kompromiss beim Nutzen von holdover aus gemessener ADEV; die numerischen Kerne des Kompromisses sind gegen scipy validiert.

1c. Schichten für Integrität, GNSS, Weltraum, Mond und Missionen#

Die übrigen Bereiche schließen an denselben Dispatch api an und verwenden den gemeinsamen Kern, die Bezugssysteme und die Geometrie wieder. Alles hier ist MODELLED, sofern keine Zeile der Matrix verification eine externe unabhängige Referenz nennt (RAIM-Kern gegen SciPy, SBAS gegen den Fork von RTKLIB (eine quelloffene Bibliothek für kinematische Echtzeit-Positionierung), der DOP-Kern (Dilution of Precision) von gnss_lib_py, die OPS-SAT-Auswertung, der ARAIM-Schutzniveau-Kern für den Mond, die anbieterübergreifende Konsistenz der Mond-Ephemeriden) — der Rest der Mond-Suite und der Quanten-Demonstrator sind modelliert, illustrativ, aus öffentlichen Quellen und tragen keine Aussage zu TRL (Technologiereifegrad) / Heritage / Agenturbefürwortung.

flowchart TD
    api["api.rs — run_toml / run_scenario · 92 kinds"]

    subgraph gnss["Integrity & GNSS measurement"]
      raim["raim — RAIM/ARAIM · HPL/VPL (kernel vs SciPy)"]
      sbas["sbas — DO-229E PL · L1/L5 (vs RTKLIB fork)"]
      meas["gnss_sim · ionex · pvt · glonass — pseudorange · iono maps · single-point PVT"]
      imp["integrity_impact · frugal — miss→integrity · cost-per-coverage"]
    end

    subgraph deep["Deep-space & Mars"]
      core2["body · ephem_provider · clock_state — multi-body · ephemeris seam · onboard clock"]
      radio["radiometric · ccsds_tdm — light-time · Doppler/range · Δ-DOR · TDM"]
      mars["deepspace_od · mars_frame · mars_atmos · mars_pnt · linkbudget · gse_sim — SRIF OD · Mars frame · relay-PNT · GSE sim"]
    end

    subgraph lunar["Lunar PNT suite (evidence tier per piece in the matrix · illustrative public-source)"]
      cis["cr3bp · lunar · lunar_frame · lunar_od — CR3BP · halo/NRHO · cislunar ARAIM · MCI↔MCMF"]
      suite["lunar_time · lunar_vlbi · lunar_combination · lunar_frame_realise — LTC time · VLBI · joint OD+clock · frame realisation"]
      suite2["lunar_service · lunar_dpnt · lunar_interop — Moonlight service-volume · differential PNT · LunaNet/IOAG interop"]
    end

    subgraph quantum["Quantum-Enabled PNT demonstrator (MODELLED)"]
      qd["quantum_devices · quantum_faults · quantum_nav_od — device error models · fault catalogue · GNSS-free OD"]
      qt["qtrade · timetransfer_chain · representativeness — unified trade · time-transfer chain · gaps-to-flight ledger"]
    end

    subgraph mission["Mission analysis, environment & interop"]
      ma["launch · reentry · eo_payload · attitude_budget · passes · linkbudget — first-order budgets"]
      env["space_weather — Jacchia-71 density"]
      iop["rinex · rinex_obs · sp3 · oem · omm · ccsds_tdm · space_packet · interchange · permalink — interop formats + KIF"]
      ver["verification — requirement→module→test→oracle→status matrix"]
    end

    api --> gnss & deep & lunar & quantum & mission
    raim -. reuses .-> meas
    suite -. reuses validated DOP / SBAS kernels .-> gnss
    qt -. rides validated kernels (scipy / sklearn) .-> quantum

1d. LEO-PNT, Spektrum, Sonnensystem, Netzzeitgebung, Kampagnen und Ausgaben#

Die neuesten Schichten folgen demselben Muster: Jede ist eine oder mehrere Szenarioarten kind, aus api dispatcht, auf dem gemeinsamen Kern gebaut und MODELLED, sofern keine Zeile der Matrix eine externe unabhängige Referenz nennt.

flowchart TD
    api["api.rs — run_toml / run_scenario"]

    subgraph leo["LEO PNT (low Earth orbit positioning, navigation and timing)"]
      lsig["leo_signal — signal design: acquisition, code tracking, GNSS compatibility, band trade"]
      lpass["leo_pass · leo_link (geometry · antenna · itu · iono · energy · spoof · presets) — pass and per-band link budget"]
      lnav["leo_navmsg (elements · fit · codec · sisre · services · text) — broadcast ephemeris and clock message"]
      lfus["leo_fusion (doppler · joint_pvt · ppp · ntn · timing · polar · presets) — fused MEO+LEO PVT · PPP · 5G NTN"]
      lchain["leo_pnt_chain — one system end to end, each stage handing its output to the next"]
    end

    subgraph rf["Spectrum"]
      spec["spectrum · navsignal — L-band (and UHF/S/C) PSD waterfall under a jammer timeline"]
      sig["sigmf — SigMF recording read/write · Welch PSD of complex IQ"]
    end

    subgraph sky["Solar system & constellations"]
      ss["solar_system · body · ephem · ephem_provider — bodies, constants, light time at one epoch"]
      bp["body_pnt — positioning around any body with a local constellation"]
      cd["constellation · walker — Walker delta/star, multi-shell, published GNSS slots, coverage/DOP maps"]
    end

    subgraph net["Network timing"]
      tel["telecom_timing — time error, MTIE, TDEV vs ITU-T masks"]
      slot["slot_timing — seconds until a free-running clock leaves a slot guard"]
    end

    subgraph comp["Composition & outputs"]
      camp["campaign · study · suite — chained phases, sweeps, Monte Carlo, shared conditions"]
      rep["advanced_report — report.html + report.json with a reproducibility record"]
      anim["animation — SVG / HTML / frame animations"]
      iop["interop (czml · kml · geojson · stk) · sigmf — exchange files for --export"]
    end

    api --> leo & rf & sky & net & comp
    lchain -. composes .-> lsig & lpass & lnav & lfus
    lsig -. SSC chain .-> spec
    lfus -. GNSS presets .-> cd
    bp -. reuses .-> ss
    camp -. runs other kinds through .-> api

Die Einzelheiten je Art stehen in LEO-PNT, LEO-SIGNAL, LEO-PASS, LEO-NAVMSG, LEO-PNT-FUSION, SPECTRUM, CONSTELLATION-DESIGN, TELECOM-TIMING, SLOT-TIMING, CAMPAIGNS, REPORTS, ANIMATION und INTEROP.

1e. Schichten für Empfängervertrauen, Nachweise, Telemetrie, Ausbildung und compliance (0,35)#

Diese Schichten lesen das eigene Protokoll eines Empfängers oder schreiben Dateien für andere Werkzeuge; keine von ihnen synthetisiert oder sendet ein Hochfrequenzsignal. Sie sitzen neben api statt unter den Szenarioarten, mit Ausnahme von receiver-trust selbst, das eine Szenarioart ist. Alle sind MODELLED, sofern keine Zeile der Matrix eine externe unabhängige Referenz nennt, und die maritimen Ausgaben sind beratend, keine typzugelassene Navigationsausrüstung.

Integrationen für Boote (das Signal-K-Plugin, der OpenCPN-Gate-Modus und der Referenzaufbau) rufen das Kommandozeilenwerkzeug auf; siehe MARINE-INTEGRATIONS.

2. Engine-Pipeline (je Lauf)#

Jeder Lauf schreitet mit einem einzelnen Sensormodell das Zeitraster ab: Es wird nachgeführt, solange GNSS nominal ist, und läuft während des Ausfalls frei (holdover / Koppelnavigation).

flowchart TD
    A["for each time step t"] --> B{"i > 0 ?"}
    B -- yes --> C["model.step(dt, rng)<br/>evolve noise state"]
    B -- no --> D
    C --> D{"GNSS state at t ?"}
    D -- "Nominal" --> E["discipline to truth<br/>(estimator sync / dead-reckoning reset)<br/>error = 0"]
    D -- "Denied/Degraded" --> F["estimator predicts;<br/>error = truth − prediction"]
    E --> G["record Sample(t, error, gnss)"]
    F --> G
    G --> A
    A -. after loop .-> H["score(series, spec)<br/>→ figures of merit"]
    H --> I["assemble Result<br/>(specs · series · FoM · scenario hash)"]

Ein Szenario durchläuft diese Pipeline zweimal, einmal für den Quantensensor und einmal für den klassischen Sensor, mit unabhängigen Startwerten (classical_seed = seed + 0x9e3779b97f4a7c15), sodass die beiden Rauschrealisierungen unkorreliert sind.

3. Die Fehlermodell-Schnittstelle (der Erweiterungspunkt)#

Jeder Sensor setzt dieselbe Idee um: ein zustandsbehaftetes Objekt, dessen step() seinen internen stochastischen Fehler fortschreibt und dessen aufgelaufener Zustand in jedem Takt ausgelesen wird. Uhren liefern die aufgelaufene Phase, Beschleunigungsmesser die zweifach integrierte Position, Verbindungen den Jitter je Messung.

classDiagram
    class ErrorModel {
      <<trait>>
      +step(dt, rng)
      +spec() ModelSpec
    }
    class ClockModel {
      +y0, q_wf, q_rw, drift, flicker
      +phase() s
      +det_freq()  +drift_rate()
    }
    class AccelModel {
      +bias, q_va, gyro_bias, q_arw
      +pos() m  +theta() rad
      +reset()
    }
    class TimeTransferLink {
      +sigma_j
      +sample(rng) s
    }
    ErrorModel <|.. ClockModel
    ClockModel : white FM + random-walk FM + flicker FM + aging
    AccelModel : accel bias + VRW + gyro bias + ARW (gravity-tilt)
    TimeTransferLink : white timing jitter

ModelSpec { id, kind, provenance, params } wandert ins Ergebnis, sodass jede Zahl der Ausgabe auf die in provenance genannte veröffentlichte Quelle zurückführbar ist.

Neben dem analytischen HoldoverEstimator führt das Uhrenpaket ein Kalman-Filter mit zwei Zuständen (Phase, Frequenz) aus (KalmanClock), dessen Prozessrauschen dem wahren Modell entspricht. Im Auslauf durch einen Ausfall wächst seine Phasenfehlervarianz genau auf q_wf·T + q_rw·T³/3, die analytische holdover-Beziehung, und seine Online-1-σ-Schranke dient dazu, die Gütegröße Integrität zu bestimmen (Anteil der Ausfallproben, deren Fehler innerhalb der k-σ-Schranke bleibt).

4. Dispatch (CLI und Bindings)#

api::run_toml(src) ist der einzige Einstiegspunkt: Sie liest das kind der obersten Ebene vorab, deserialisiert das passende Szenario, führt das Paket aus und gibt { json, svg, summary, csv } zurück (csv ist nur bei den Arten vorhanden, die eine Reproduzierbarkeitstabelle veröffentlichen). Die CLI schreibt diese in Dateien, dazu den Bericht (report.html, report.json) und jede Ausgabe von --export / --animate; die Python- und WebAssembly-Bindings geben sie an den Host zurück. Ein Dispatch, keine Abweichung.

flowchart TD
    F["api::run_toml(src) · run_scenario(src)"] --> K{"ScenarioKind::classify<br/>typed · exhaustive · 92 kinds<br/>(absent kind → clock; unknown kind → InvalidInput)"}
    K --> G1["Timing<br/>clock · timetransfer · quantum-time-transfer · telecom-timing · slot-timing"]
    K --> G2["Inertial & fusion<br/>inertial · hybrid · hybrid-ukf · fusion · gnss-ins · quantum-gnss-free-nav · ins-trn-coast · hybrid-optical-rf"]
    K --> G3["Orbit, geometry & positioning<br/>orbit · ephemeris · constellation-design · gnss-sim · pvt"]
    K --> G4["Integrity<br/>integrity · lunar-integrity · araim-reference-check"]
    K --> G5["Resilience & spectrum<br/>jamming · spoof · spoof-detect · quantum-anomaly-detect · tracking-loop · spectrum · conflict-resilience"]
    K --> G6["Alt-PNT (GPS-denied)<br/>gravity-map · terrain-nav · terrain-slam · combined-altpnt"]
    K --> G7["LEO PNT<br/>leo-signal · leo-pass · leo-navmsg · leo-pvt · leo-ppp · ntn-positioning · leo-pnt-chain"]
    K --> G8["Lunar / cislunar suite (MODELLED)<br/>lunar-time-offset · lunar-time-budget · lunar-vlbi · lunar-vlbi-fim · lunar-joint-od-clock<br/>lunar-frame-realisation · lunar-frame-campaign · lunar-llr-datum · realtime-frame-eop<br/>moonlight-service-volume · lunar-differential-pnt · lunar-interop-export · lunar-beacon<br/>lunar-jamming · lunar-attack-surface · earth-gnss-lunar · cislunar-observability · cislunar-arc-recovery"]
    K --> G9["Deep space & solar system<br/>mars-pnt · solar-system · body-pnt"]
    K --> G10["Machine learning & trade<br/>impairment-eval · quantum-trade"]
    K --> G11["Mission analysis & environment<br/>launch-window · reentry · eo-coverage · attitude-budget · aperture-duty-cycle<br/>passes · link-budget · space-packet · space-weather"]
    K --> G12["Trade studies, campaigns & interop<br/>sweep · sweep-nd · campaign · oem-interop"]
    G1 & G2 & G3 & G4 & G5 & G6 & G7 & G8 & G9 & G10 & G11 & G12 --> W["RunOutput { json, svg, summary, csv }<br/>+ SHA-256 scenario_hash"]

Der Dispatch erfolgt über eine typisierte Enum ScenarioKind, die erschöpfend abgeglichen wird (siehe nächster Unterabschnitt); das Hinzufügen eines Pakets ist daher eine vom Compiler geprüfte Änderung. Ein fehlendes kind fällt auf das Paket clock zurück, sodass bestehende Szenarien einer einzigen Art unverändert deserialisiert werden (serde ignoriert das Feld kind in jeder Szenario-Struktur). Eine unbekannte kind wird mit KshanaError::InvalidInput zurückgewiesen, der bei einem wahrscheinlichen Tippfehler die nächstliegende eingebaute Art nennt.

Typisierter Dispatch und die strukturierte API#

Der Dispatch erfolgt über eine typisierte Enum ScenarioKind, nicht über einen rohen Zeichenkettenvergleich: ScenarioKind::classify(src) löst das Feld kind zu einer Variante auf, und der Dispatcher gleicht sie erschöpfend ab; das Hinzufügen eines Pakets ist eine vom Compiler geprüfte Änderung, kein Zeichenketten-Tippfehler. Neben dem zeichenkettenliefernden run_toml (für die CLI und bestehende Bindings beibehalten) gibt es zwei typisierte Oberflächen:

• run_scenario(src) -> Result<RunOutput, KshanaError>: der typisierte Einstieg mit einer strukturierten Fehlertaxonomie (InvalidInput, NonConvergence, Unsupported, IoError). Jeder Fehler trägt ein stabiles kind_tag(), damit ein Aufrufer nach Fehlerkategorie verzweigen kann, statt die Meldung zu parsen. Die Bindings stellen dies als error_kind(toml) bereit.
• list_scenario_kinds() -> Vec<ScenarioMeta> (und list_scenario_kinds_json(), in den Bindings als list_kinds() bereitgestellt): programmatische Introspektion, also Name, Beschreibung sowie Pflicht- und optionale Felder jeder Art, für die automatische Vervollständigung in Benutzeroberflächen (UI) und Notebooks.

Kshana mit einem externen Paket erweitern#

Ein Paket eines Drittanbieters implementiert zwei kleine, semver-stabile Traits aus api:

use kshana::api::{ExternalPack, KshanaError, RunOutput, Scenario, ScenarioMeta};

struct MyPack {
    threshold: f64, // the deserialized scenario fields
}

impl Scenario for MyPack {
    fn run(&self) -> Result<RunOutput, KshanaError> {
        // Run the model, then build the unified output envelope.
        Ok(RunOutput {
            json: format!("{{\"threshold\": {}}}", self.threshold),
            svg: String::from("<svg xmlns=\"http://www.w3.org/2000/svg\"/>"),
            summary: format!("my-pack | threshold {}", self.threshold),
            csv: None,
        })
    }
}

impl ExternalPack for MyPack {
    fn kind_name(&self) -> &'static str {
        "my-pack"
    }
    fn meta(&self) -> ScenarioMeta {
        ScenarioMeta {
            name: "my-pack",
            description: "An out-of-tree example pack.",
            required_fields: &["threshold"],
            optional_fields: &[],
        }
    }
}

ExternalPack hat außerdem eine Standardmethode register_into(&mut PackRegistry), die nichts tut, sofern ein Paket sich nicht für die Registry-Dispatch-Schnittstelle in src/registry.rs entscheidet. Das eingebaute Paket jamming ist über Scenario als durchgespieltes Beispiel angebunden; Pakete außerhalb des Repositorys folgen demselben Vertrag, ohne den Kern zu forken (entsprechend dem Erweiterungspunkt ErrorModel in §3, den das private Resilienz-Overlay nutzt).

Kshana hat daher zwei stabile Erweiterungsschnittstellen: einen Sensor hinzufügen, indem man ErrorModel implementiert (§3), oder eine ganze Szenarioart, indem man Scenario + ExternalPack implementiert; beide sind semver-stabil, keine verlangt einen Fork des Kerns:

classDiagram
    class ErrorModel {
      <<trait — sensor seam>>
      +step(dt, rng)
      +spec() ModelSpec
    }
    class Scenario {
      <<trait — pack seam>>
      +run() RunOutput
    }
    class ExternalPack {
      <<trait : Scenario>>
      +kind_name() str
      +meta() ScenarioMeta
    }
    ErrorModel <|.. ClockModel
    ErrorModel <|.. AccelModel
    ErrorModel <|.. TimeTransferLink
    Scenario <|.. ExternalPack
    Scenario <|.. JammingPack : worked example
    ExternalPack <|.. ThirdPartyPack : out-of-tree, no core fork

5. Das hybride Schlussstück#

Das Hybridpaket führt eine Suite aus (eine Uhr plus ein Inertialsensor) und verlangt, dass sowohl Zeitgebung als auch Position innerhalb der Spezifikation bleiben; pnt_holdover ist die Zeit, bis eines von beiden sie verletzt. Optional synchronisiert eine optische Inter-Satelliten-Verbindung die Uhr während des Ausfalls neu, ausschließlich als Zeitstützung; die Position wird nicht neu synchronisiert, weil Zeitübertragung Zeit liefert, keine Position. Dadurch wird der Inertialsensor als begrenzender Faktor isoliert.

flowchart LR
    subgraph suite["PNT suite (per technology)"]
      clk["clock → timing error"]
      acc["inertial sensor → position error"]
      isl["optical ISL<br/>re-sync clock at interval"] -. aids .-> clk
    end
    clk --> J["both within spec ?"]
    acc --> J
    J --> P["pnt_holdover = first breach<br/>(timing OR position)"]

6. Aus der Geometrie abgeleitete GNSS-Verfügbarkeit#

orbit.rs ist eine deterministische, abhängigkeitsfreie Geometrieschicht. Ein Propagator ist entweder die analytische Keplersche Orbit (Zweikörperproblem, optional mit säkularem J2) oder ein vollständiger Sgp4-Propagator, der aus einem vollständigen Zweizeilen-Elementesatz aufgebaut wird; ein Walker-Delta-Generator erzeugt synthetische Konstellationen, und die Sichtlinien-Sichtbarkeit = Erdverdeckung + Elevationsmaske. Die Zahl sichtbarer Satelliten wird auf einen GNSS-Zustand abgebildet (≥4 = nominal, 1–3 = degradiert, 0 = verweigert), und build_timeline macht daraus die Verfügbarkeitszeitleiste, die den üblichen Uhren-holdover-Lauf antreibt. Die Verfügbarkeit ist somit aus der Geometrie abgeleitet statt von Hand vorgegeben, während Lauf, Schätzer und Bewertung unverändert bleiben.

Eine als vollständige TLEs gelieferte Konstellation wird mit dem SGP4/SDP4-Modell in sgp4.rs propagiert (gegen die Vektoren AIAA (American Institute of Aeronautics and Astronautics) 2006-6753 validiert); Elemente, die nur aus Zeile 2 bestehen, behalten den analytischen Zweikörperpfad. Beide lassen sich innerhalb eines Konstellationsblocks mischen.

flowchart LR
    U["user orbit"] --> V
    C["Walker constellation"] --> V["visible_count(t)<br/>occultation + mask"]
    V --> S["gnss_state: ≥4 / 1–3 / 0"]
    S --> T["build_timeline → GnssTimeline"]
    T --> R["run_orbit_clock → clock holdover"]

7. Bindings#

Der Kern lässt sich unverändert nativ, als Python-Erweiterung und als WebAssembly kompilieren. Die Python- (python.rs, PyO3 abi3) und WebAssembly-Module (wasm.rs, wasm-bindgen) sind optionale, per Feature zugeschaltete Abhängigkeiten (--features python / --features wasm): Der Standard-Build und die Testsuite kompilieren sie nie, während das Abhängigkeitsaudit (cargo deny --all-features) ihre Abhängigkeitsbäume sehr wohl prüft, weil diese Crates im Wheel und im npm-Paket ausgeliefert werden. Beide rufen api::run_toml auf, sodass jede Oberfläche identische Ergebnisse liefert. Das WebAssembly-Modul trägt den Browser-Playground in web/ und exportiert dreizehn Funktionen: run, run_all (ein Engine-Lauf, der Ergebnis, Diagramm, Zusammenfassung und Tabelle zusammen liefert), chart_svg, summary, table_csv, list_kinds, error_kind, version, den Codec encode_permalink / decode_permalink für teilbare URLs (URL: Webadresse) und die drei Exporter export_sp3 / export_omm / export_oem, die das Exportmenü des Playgrounds tragen. Zwei weitere Zugänge erreichen dieselbe api: der MCP-Server (Model Context Protocol) (mcp/kshana-mcp, ein vom Workspace ausgeschlossenes Crate rmcp mit fünfzehn Werkzeugen: run_scenario, list_scenario_kinds, validate_scenario, list_example_scenarios, get_example_scenario, report_scenario, animate_scenario, list_export_formats, export_interop, import_route, export_sp3, export_omm, export_oem, export_table_csv, assess_receiver_log; die beiden Beispielwerkzeuge lesen die mitgelieferten Szenarien über die standardmäßig abgeschaltete Funktion bundled-scenarios der Bibliothek, die nur dieser Server einschaltet) und das JetBrains-IDE-Plugin (integrierte Entwicklungsumgebung) (ide/jetbrains, ein Kotlin-Projekt, das die CLI kshana aufruft, statt die Bibliothek einzubinden).

flowchart LR
    cli["CLI · main.rs<br/>native binary"] --> api
    py["Python · python.rs (PyO3 abi3)<br/>RunOutput class + run · run_full · run_typed · scenario_kinds · list_kinds · validate_toml · error_kind · version"] --> api
    wasm["WebAssembly · wasm.rs (wasm-bindgen)<br/>run · run_all · chart_svg · summary · table_csv · list_kinds · error_kind · version · encode/decode_permalink<br/>export_sp3 · export_omm · export_oem"] --> api
    mcp["MCP server · mcp/kshana-mcp (rmcp)<br/>tools: run_scenario · list_scenario_kinds · validate_scenario<br/>list_example_scenarios · get_example_scenario<br/>report_scenario · animate_scenario<br/>list_export_formats · export_interop · import_route<br/>export_sp3 · export_omm · export_oem · export_table_csv"] --> api
    ide["JetBrains plugin · ide/jetbrains (Kotlin)"] -- spawns process --> cli
    api["api::run_toml / run_scenario / list_scenario_kinds"] --> out["identical { json, svg, summary } on every surface"]

Feature-Gating: Python und WASM sind --features python / --features wasm; die Tabelle der mitgelieferten Szenarien ist --features bundled-scenarios (die einzige Nutzung durch den MCP-Server); der MCP-Server und die Gegenprüfungen xval/* sind vom Workspace AUSGESCHLOSSENE Crates; das IDE-Plugin bindet nichts ein, es führt die CLI aus.

8. Determinismus und Reproduzierbarkeit#

• Sämtliche Zufälligkeit läuft pro Lauf durch einen einzigen mit einem Startwert versehenen ChaCha8Rng; die Schrittreihenfolge ist fest, daher gilt (scenario, seed, engine version) → identical bits.
• Das Ergebnis trägt einen SHA-256-scenario_hash (SHA: Secure Hash Algorithm); scripts/check-reproducible.sh führt ein Referenzszenario zweimal aus und prüft, dass die Ausgabe byteidentisch ist.
• Dieselbe Engine lässt sich nativ, als Python-Erweiterung und nach wasm32-unknown-unknown für Läufe im Browser kompilieren und liefert dieselben Zahlen.

9. Zurückgestellte / künftige Struktur#

Die Astrodynamik-, Fusions- und Alt-PNT-Schichten in §1a (der vollständige SGP4/SDP4-Propagator, der numerische Cowell-Propagator mit seinem Kraftmodell aus sieben Störungen und zwei adaptiven Integratoren, Manöver-/Trajektorienentwurf, Bahnbestimmung, die GNSS/INS-Schätzer mit 15, 8 und 17 Zuständen, das gekoppelte Uhren-plus-Positions-Filter und der Schwerekarten-Abgleich) sind alle ausgeliefert, ebenso die Security-Gütegröße mit aktivem Spoofing-Demonstrator, echte TLE-/Mehrkonstellationsgeometrie, Monte-Carlo-Bänder, Trade-Study-Sweeps, der druckbare HTML-Bericht (HyperText Markup Language) mit seinem maschinenlesbaren Zwilling sowie die Workflows für Release, Publish, Wheels und Pages.

Mehrere Fähigkeiten, die hier einst als künftige Arbeit aufgeführt waren, sind inzwischen ausgeliefert und weiter oben oder in VALIDATION behandelt: die vollständige IAU-2000A-Nutation und die äquinoxfreie CIO-Reduktion GCRS↔ITRS / ITRF (International Terrestrial Reference Frame), bitgenau gegen SOFA/ERFA geprüft (SOFA: Standards of Fundamental Astronomy; ERFA: Essential Routines for Fundamental Astronomy), das Geopotenzial EGM2008 (Earth Gravitational Model 2008) bis Grad/Ordnung 70, der Lense-Thirring-Term der Rahmenmitführung, Fest-, Ozean- und atmosphärische Gezeiten, eine Ephemeriden-Kreuzvalidierung auf DE-Niveau (DE440/ANISE (DE440: Development Ephemeris 440; ANISE: Attitude, Navigation, Instrument, Spacecraft, Ephemeris, ein reines Rust-Werkzeug für Planetengeometrie)), die externe Orekit-12,2-Kreuzvalidierung des numerischen Cowell-Propagators (0,08 m über 24 h) und der Batch- und sequenziellen Bahnbestimmung sowie der eng gekoppelte Navigator mit 17 Zuständen, der als Szenarioart hybrid-ukf bereitsteht.

Die verbleibenden Folgearbeiten werden in CHANGELOG [Unreleased] und in der Roadmap je Fähigkeit in CAPABILITY verfolgt: ein externer Wert einer unabhängigen Referenz für den EGM-Auswerter (Earth Gravitational Model) hohen Grades genau auf der Polachse und ein pyshtools-sauberer Vergleich nahe dem Pol (der Auswerter bis Grad 2190 und sein Laufzeit-Lader für .gfc sind ausgeliefert, MODELLED; siehe xval/high-degree-gravity/), ein zeitvarianter Weltraumwetter-Treiber für die optionale Luftwiderstandsdichte-Stufe NRLMSISE-00 (NRLMSISE: Naval Research Laboratory Mass Spectrometer and Incoherent Scatter Radar Extended atmosphere model) (die Standarddichte ist das statische Exponentialmodell, und die Jacchia-71-Dichte der Art space-weather wird gegen NRLMSISE-00 charakterisiert, aber nicht durch es ersetzt), eine externe Prüfung des optionalen Sonnenrand-Verdunkelungsschattens, enge Kopplung von Trägerphasen-GNSS/INS und eine echte EGM2008-/EIGEN-Schwerekarte (EIGEN: European Improved Gravity model of the Earth by New techniques) für den Alt-PNT-Abgleicher.

Ein privates Overlay-Repository enthält exportsensible Resilienztiefe; es wird über dieselbe Schnittstelle ErrorModel (und den Vertrag ExternalPack in §4) eingebunden, ohne die öffentliche Engine zu verändern.