Eve library

phase-21.md

Tracker

Revision 1

On this page

Historical task source. The Eve task board holds current task state.

Phase 21: Nyx Cosmic Observatory & Astronomy Exploration Platform#

Domain: Nyx (Greek primordial goddess of night, mother of cosmic forces) Purpose: Industry-leading, state-of-the-art platform for exploring and learning about the cosmos through immersive 3D visualizations, scientific accuracy, and consciousness-expanding experiences.

Core Philosophy: Bridging scientific astronomy with the mystical wonder of the cosmos. Nyx complements Lilith's consciousness exploration by extending awareness from inner consciousness to the outer universe - the macrocosm reflecting the microcosm.

Key Features:

  • Interactive 3D star map with multi-scale universe exploration
  • Accurate orbital mechanics and orrery simulation
  • Comprehensive celestial object database with real astronomical data
  • Time travel to view historical and future sky states
  • VR/AR immersive planetarium experiences
  • Consciousness-expanding meditation and overview effect experiences
  • Real-time satellite tracking and astronomical events
  • Educational platform for astronomy and cosmology

21.1 Nyx Domain Infrastructure & Architecture#

21.1.1 Domain Setup#

  • 21.1.1.1 [Critical/M] Create Nyx domain directory structure ✅ COMPLETED

    • Directory: libs/nyx/ domain root
    • Directory: apps/nyx/ applications root
    • File: libs/nyx/README.md domain documentation
    • Acceptance: Domain structure created
    • Completed: Created domain directories and comprehensive README with architecture overview, library catalog (44+ planned libraries), and usage examples
  • 21.1.1.2 [Critical/M] Configure Nx workspace for Nyx ✅ COMPLETED

    • File: tsconfig.base.json add @nyx/* path mappings
    • File: nx.json add Nyx project patterns
    • Config: Domain tags scope:nyx, type:lib, layer:domain
    • Acceptance: Nx recognizes Nyx projects
    • Completed: Added @nyx/* path mapping, scope:nyx to ESLint module boundaries, and nyx scope to commitlint
  • 21.1.1.3 [High/M] Create Nyx shared types library ✅ COMPLETED

    • File: libs/nyx/types/ comprehensive type definitions
    • Types: Celestial objects, coordinates, time systems
    • Types: Visualization, rendering, interaction
    • Types: Orbital mechanics, ephemeris
    • Acceptance: All domain types defined
    • Completed: Created @nyx/types with 150+ type definitions:
      • coordinates.ts - Equatorial, horizontal, galactic, ecliptic systems
      • celestial.ts - Stars, planets, galaxies, nebulae, clusters
      • time.ts - Julian dates, sidereal time, epochs, time scales
      • observer.ts - Location, equipment, visibility, weather
      • orbital.ts - Keplerian elements, ephemeris, TLE, events
      • visualization.ts - Sky charts, 3D rendering, interactivity
  • 21.1.1.4 [High/M] Create Nyx constants library ✅

    • File: libs/nyx/constants/
    • Constants: Astronomical constants (AU, parsec, c, G)
    • Constants: Coordinate system parameters
    • Constants: Physical constants for calculations
    • Constants: Catalog identifiers and references
    • Acceptance: All astronomical constants defined
  • 21.1.1.5 [High/S] Create Nyx utilities library ✅

    • File: libs/nyx/utils/
    • Implement: Unit conversion utilities
    • Implement: Formatting utilities (RA/Dec, magnitudes)
    • Implement: Validation utilities
    • Acceptance: Common utilities available

21.1.2 Database Schema Design#

  • 21.1.2.1 [Critical/L] Design celestial objects schema ✅

    • File: libs/nyx/database/schema/celestial-objects.ts
    • Table: stars (id, catalog_ids, coordinates, properties)
    • Table: planets (exoplanets and solar system)
    • Table: galaxies (types, distances, properties)
    • Table: nebulae (types, coordinates, properties)
    • Table: deep_sky_objects (clusters, etc.)
    • Acceptance: Comprehensive object schema
  • 21.1.2.2 [High/L] Design orbital mechanics schema ✅

    • File: libs/nyx/database/schema/orbital-mechanics.ts
    • Table: orbital_elements (Keplerian elements)
    • Table: ephemeris_data (computed positions)
    • Table: perturbations (gravitational influences)
    • Table: eclipse_data (solar/lunar eclipses)
    • Acceptance: Orbital data schema complete
  • 21.1.2.3 [High/M] Design user data schema ✅

    • File: libs/nyx/database/schema/user-data.ts
    • Table: observation_logs (user observations)
    • Table: saved_views (bookmarked locations)
    • Table: custom_annotations (user labels)
    • Table: tour_progress (educational progress)
    • Acceptance: User data schema complete
  • 21.1.2.4 [High/M] Design catalog cross-reference schema ✅

    • File: libs/nyx/database/schema/catalogs.ts
    • Table: catalog_cross_references (HD, HIP, Gaia, etc.)
    • Table: name_aliases (common names, Bayer, Flamsteed)
    • Table: catalog_metadata (source, accuracy, epoch)
    • Acceptance: Multi-catalog linking enabled
  • 21.1.2.5 [Medium/M] Create database migrations ✅

    • File: libs/nyx/database/migrations/
    • Implement: Initial schema migration
    • Implement: Seed data migration
    • Implement: Index creation migration
    • Acceptance: Database deployable via migrations

21.1.3 Core Services Architecture#

  • 21.1.3.1 [High/L] Design Nyx microservices architecture ✅

    • Document: Service boundaries and responsibilities
    • Service: nyx-catalog-service (data access)
    • Service: nyx-compute-service (calculations)
    • Service: nyx-render-service (tile generation)
    • Service: nyx-realtime-service (live data)
    • Acceptance: Architecture documented
  • 21.1.3.2 [High/M] Create service communication contracts

    • File: libs/contracts/src/events/nyx.ts
    • Contract: Catalog query protocol (observation logging, view saving, lists)
    • Contract: Computation request protocol (ephemeris, eclipses, conjunctions)
    • Contract: Real-time event protocol (satellite tracking, ISS passes, alerts)
    • Acceptance: Service contracts defined
  • 21.1.3.3 [Medium/M] Design caching strategy

    • Document: libs/nyx/docs/caching-strategy.md
    • Cache: Star field tiles (CDN with CloudFront, versioned URLs)
    • Cache: Ephemeris calculations (Redis L2 with distributed locks)
    • Cache: Catalog queries (Memory L1 with LRU eviction)
    • Acceptance: Caching strategy documented

21.2 Astronomical Data Infrastructure#

21.2.1 Star Catalog Integration#

  • 21.2.1.1 [Critical/XL] Integrate Gaia DR3 catalog

    • File: libs/nyx/catalogs/gaia/
    • Data: ~1.8 billion sources
    • Implement: Efficient binary data format
    • Implement: Spatial indexing (HEALPix)
    • Implement: Query by region, magnitude, type
    • Fields: Position, parallax, proper motion, photometry
    • Acceptance: Gaia DR3 queryable
  • 21.2.1.2 [High/L] Integrate Hipparcos catalog

    • File: libs/nyx/catalogs/hipparcos/
    • Data: ~118,000 stars with high precision
    • Implement: Cross-reference with Gaia
    • Fields: Astrometry, variability, multiplicity
    • Acceptance: Hipparcos integrated
  • 21.2.1.3 [High/L] Integrate Tycho-2 catalog

    • File: libs/nyx/catalogs/tycho/
    • Data: ~2.5 million stars
    • Implement: Position, proper motion, photometry
    • Implement: Cross-reference with other catalogs
    • Acceptance: Tycho-2 integrated
    • Completed: @nyx/tycho library with TYC identifier handling, TAP/ADQL client, multi-endpoint support (VizieR, ESA, NOIRLAB), cone/box/region searches, proper motion filtering, Hipparcos cross-matching, position propagation, Johnson-Tycho magnitude conversions, caching support
  • 21.2.1.4 [High/M] Integrate Yale Bright Star Catalogue

    • File: libs/nyx/catalogs/bright-stars/
    • Data: ~9,110 stars visible to naked eye
    • Implement: Common names, constellations
    • Implement: Detailed spectral data
    • Acceptance: Bright stars searchable by name
    • Completed: @nyx/bright-stars library with TAP/ADQL client for VizieR V/50, spectral type parsing (MK classification), common star names database, Bayer/Flamsteed designation handling, cross-references (HD, SAO, HIP), variable/multiple star identification, high-level query service with caching
  • 21.2.1.5 [Medium/M] Integrate SIMBAD astronomical database

    • File: libs/nyx/catalogs/simbad/
    • Implement: API client for SIMBAD queries
    • Implement: Object type classification
    • Implement: Bibliography cross-references
    • Acceptance: SIMBAD lookup available
    • Completed: Comprehensive SIMBAD TAP client with hierarchical object type classification (200+ types), name resolution (Sesame-style), rate-limited queries, cone/box/catalog searches, cross-references to major catalogs (HD, HIP, NGC, etc.), bibliographic reference handling, coordinate systems (ICRS, Galactic), astrometric data, photometry, spectral classification, and galaxy morphological types
  • 21.2.1.6 [High/L] Create unified star query interface

    • Library: @nyx/star-query in libs/nyx/catalogs/star-query/
    • Implemented: UnifiedStarQueryService with query across all catalogs (Gaia, Hipparcos, Tycho-2, Yale BSC, SIMBAD)
    • Implemented: Intelligent catalog selection based on magnitude range and data requirements
    • Implemented: CatalogAdapter interface and CatalogRegistry for managing adapters
    • Implemented: Result deduplication with duplicate detection and intelligent merging
    • Implemented: Cross-reference resolution using identifiers and position matching
    • Implemented: Confidence scoring based on source count, source agreement, astrometric quality, data completeness, catalog reliability, and cross-reference validation
    • Implemented: Name resolution with multi-catalog fallback
    • Implemented: Cone and box search capabilities
    • Implemented: Comprehensive type system with Zod schemas for validation
    • Acceptance: Single API for all star data ✓

21.2.2 Exoplanet Database#

  • 21.2.2.1 [High/L] Integrate NASA Exoplanet Archive

    • Library: @nyx/nasa-exoplanets in libs/nyx/catalogs/nasa-exoplanets/
    • Implemented: TAP/ADQL client for NASA Exoplanet Archive (5,500+ planets)
    • Implemented: Comprehensive types for orbital parameters, physical parameters, host star properties, discovery information
    • Implemented: Cone and box searches by position
    • Implemented: Property-based filtering (mass, radius, temperature, period)
    • Implemented: Discovery method and year searches
    • Implemented: Habitable zone and Earth-like planet searches
    • Implemented: Planet type classification (terrestrial, super-earth, mini-neptune, neptune-like, gas-giant, hot-jupiter)
    • Implemented: Earth Similarity Index (ESI) calculation
    • Implemented: Result caching for performance
    • Implemented: System queries (multi-planet systems)
    • Acceptance: Exoplanet data queryable ✓
  • 21.2.2.2 [High/M] Integrate Open Exoplanet Catalogue ✅

    • Library: @nyx/open-exoplanets at libs/nyx/catalogs/open-exoplanets/
    • Implemented: Custom XML parser for OEC format
    • Implemented: System hierarchy (system → binary → star → planet → moon)
    • Implemented: Gzipped catalogue download support
    • Implemented: Hierarchical data flattening to FlatPlanet view
    • Implemented: Multi-parameter planet search (mass, radius, period, temperature)
    • Implemented: Discovery method filtering
    • Implemented: Circumbinary and rogue planet support
    • Implemented: Host star properties integration
    • Implemented: Unit conversion utilities
    • Implemented: Habitable zone calculation functions
    • Peer dependency: @nyx/nasa-exoplanets for cross-reference
    • Acceptance: Multiple exoplanet sources merged ✓
  • 21.2.2.3 [Medium/M] Create exoplanet habitability analysis ✅

    • Library: @nyx/habitability at libs/nyx/analysis/habitability/
    • Implemented: Habitable zone calculation (Kopparapu et al. 2013)
    • Implemented: Conservative and optimistic HZ boundaries
    • Implemented: Earth Similarity Index (ESI) with four components
    • Implemented: Atmospheric potential analysis with Jeans escape
    • Implemented: XUV-driven mass loss estimation
    • Implemented: Tidal locking timescale calculation
    • Implemented: Tidal heating for eccentric orbits
    • Implemented: Planet type classification from mass-radius
    • Implemented: Magnetic field protection assessment
    • Implemented: Comprehensive habitability scoring
    • Implemented: Stellar luminosity and flux calculations
    • Acceptance: Habitability metrics computed ✓
  • 21.2.2.4 [Medium/M] Create exoplanet visualization data ✅

    • Library: @nyx/visualization (libs/nyx/analysis/visualization/)
    • Implemented: Visual planet type classification from physical parameters
    • Implemented: Atmosphere visuals (color, clouds, banding, storms, scattering)
    • Implemented: Surface visuals with textures, features, and color palettes
    • Implemented: Terrain parameters with noise-based height maps
    • Implemented: Star illumination from stellar properties
    • Implemented: Night side visuals (aurora, lava glow, city lights)
    • Implemented: Ring system generation for gas giants
    • Implemented: Temperature-to-color conversion (blackbody radiation)
    • Implemented: Color utilities (HSL/RGB, blending, desaturation)
    • Implemented: Solar System reference visualizations
    • Implemented: Deterministic procedural generation with seeded RNG
    • Acceptance: Visual data for rendering ✓

21.2.3 Galaxy Catalogs#

  • 21.2.3.1 [High/L] Integrate NGC/IC catalogs ✅

    • Library: @nyx/ngc-ic (libs/nyx/catalogs/ngc-ic/)
    • Implemented: Type definitions for deep sky objects (galaxies, nebulae, clusters)
    • Implemented: Galaxy morphological classification (Hubble types)
    • Implemented: Equatorial and galactic coordinate support
    • Implemented: Notable NGC objects with Messier catalog cross-references
    • Implemented: Notable IC objects (Horsehead, Pelican, Cocoon, etc.)
    • Implemented: Caldwell catalog cross-references
    • Implemented: Comprehensive query system with filtering
    • Implemented: Cone search functionality
    • Implemented: Constellation and magnitude filtering
    • Implemented: Coordinate utilities (RA/Dec conversion, angular distance)
    • Implemented: Object lookup by designation or common name
    • Implemented: Recommended observing targets by location/season
    • Acceptance: NGC/IC objects queryable ✓
  • 21.2.3.2 [High/L] Integrate NASA/IPAC Extragalactic Database (NED) ✅

    • Library: @nyx/ned (libs/nyx/catalogs/ned/)
    • Implemented: Type definitions for galaxies, QSOs, AGN, clusters, nebulae
    • Implemented: Object search by name with alias support
    • Implemented: Cone search by position with radius filter
    • Implemented: Redshift range queries
    • Implemented: Coordinate parsing and conversion utilities
    • Implemented: Position and distance calculations
    • Implemented: Photometry data with multiple bands
    • Implemented: Galaxy morphology classification
    • Implemented: Angular and physical size support
    • Implemented: Hubble flow distance estimation
    • Implemented: Lookback time calculation
    • Implemented: API client with configurable timeout
    • Acceptance: NED data accessible ✓
  • 21.2.3.3 [High/M] Integrate Sloan Digital Sky Survey data ✅

    • Library: @nyx/sdss (libs/nyx/catalogs/sdss/)
    • Implemented: Type definitions for SDSS objects (galaxies, stars, QSOs)
    • Implemented: Photometric data in 5 bands (ugriz)
    • Implemented: PSF, model, Petrosian, and cmodel magnitudes
    • Implemented: Spectroscopic redshifts and classifications
    • Implemented: Galaxy morphology and shape parameters
    • Implemented: Stellar mass estimates from photometry
    • Implemented: Emission line measurements
    • Implemented: SQL query interface for custom queries
    • Implemented: Cone and rectangular search functionality
    • Implemented: Image cutout service integration
    • Implemented: Color index and concentration calculations
    • Implemented: Absolute magnitude estimation
    • Acceptance: SDSS galaxy data integrated ✓
  • 21.2.3.4 [Medium/M] Create galaxy classification system ✅

    • Library: @nyx/galaxy-classification
    • Implemented: Hubble sequence (E, S0, Sa-Sd, Irr) and T-type (-6 to +10)
    • Implemented: De Vaucouleurs extended classification with bar/ring notation
    • Implemented: CAS morphological parameters (Concentration, Asymmetry, Smoothness)
    • Implemented: Sérsic profile analysis and bulge-to-total decomposition
    • Implemented: BPT diagram classification for AGN/LINER/Seyfert detection
    • Implemented: Star formation state classification (passive to starburst)
    • Implemented: Environment and interaction state tracking
    • Acceptance: Galaxies classified by type ✓
  • 21.2.3.5 [Medium/L] Create 3D galaxy distribution map ✅

    • Library: @nyx/galaxy-distribution
    • Implemented: Comoving coordinate transformations with Planck 2018 cosmology
    • Implemented: Density field estimation with Gaussian smoothing
    • Implemented: Void finding using connected component analysis
    • Implemented: Friends-of-Friends cluster finding with group/cluster classification
    • Implemented: Minimum spanning tree filament detection
    • Implemented: Supercluster identification from cluster linkages
    • Implemented: 3D visualization data generation (point clouds, lines, spheres)
    • Implemented: Density isosurface extraction
    • Implemented: Slice and cone extraction utilities
    • Implemented: Known structures database (Laniakea, Shapley, Bootes Void)
    • Acceptance: Universe structure visualizable ✓

21.2.4 Solar System Data#

  • 21.2.4.1 [High/L] Integrate JPL Horizons ephemeris system ✓

    • File: libs/nyx/catalogs/solar-system/horizons/src/
    • Implemented: Full TypeScript API client for JPL Horizons REST API
    • Data: All planets, moons, dwarf planets, asteroids, comets
    • Fields: Position, velocity, orbital elements, observer ephemeris
    • Implemented: High-precision ephemeris queries with type-safe parameters
    • Features: State vectors, orbital elements, close approaches, observer coordinates
    • Tests: 82 comprehensive tests covering all functionality
    • Acceptance: JPL data accessible ✓
  • 21.2.4.2 [High/L] Create comprehensive planet database ✓

    • File: libs/nyx/catalogs/solar-system/planets/src/
    • Implemented: Full TypeScript library with Zod validation schemas
    • Data: All 8 major planets (Mercury-Neptune) + 5 dwarf planets (Pluto, Ceres, Eris, Makemake, Haumea)
    • Fields: Physical properties (mass, radius, density, gravity, escape velocity)
    • Fields: Orbital parameters (semi-major axis, eccentricity, inclination, period)
    • Fields: Rotational properties (period, axial tilt, retrograde status)
    • Fields: Atmosphere composition and characteristics
    • Fields: Magnetic field properties (dipole moment, field strength, magnetosphere)
    • Fields: Ring systems with individual ring data
    • Fields: Interior structure models (core, mantle, crust)
    • Fields: Moon summaries
    • Fields: Discovery and exploration history with missions
    • Fields: Texture references for visualization
    • Functions: 40+ utility functions for lookups, sorting, filtering, comparisons
    • Calculations: Orbital velocity, synodic period, equilibrium temperature, Hill sphere, Roche limit
    • Tests: 120 comprehensive tests covering all functionality
    • Acceptance: Planet data complete ✓
  • 21.2.4.3 [High/L] Create moon database ✓

    • File: libs/nyx/catalogs/solar-system/moons/src/
    • Implemented: Full TypeScript library with Zod validation schemas
    • Data: 45+ major moons with complete data + 117 compact moon entries
    • Coverage: Earth, Mars, Jupiter, Saturn, Uranus, Neptune moons
    • Coverage: Pluto system (Charon + 4 small moons)
    • Coverage: Dwarf planet moons (Eris, Haumea, Makemake)
    • Fields: Physical properties (mass, radius, density, gravity, albedo)
    • Fields: Orbital elements (semi-major axis, period, eccentricity, inclination)
    • Fields: Rotational properties (period, tidal locking, axial tilt)
    • Fields: Atmospheres (composition, pressure)
    • Fields: Surface features (composition, geological activity, craters)
    • Fields: Interior structure (differentiation, subsurface oceans)
    • Fields: Discovery history and exploration missions
    • Fields: Ring interactions for shepherd moons
    • Implemented: Parent body relationships via parentBody/parentBodyId
    • Functions: 40+ utility functions for lookups, filtering, sorting, calculations
    • Tests: 79 comprehensive tests
    • Acceptance: Moon data complete ✓
  • 21.2.4.4 [High/M] Integrate Minor Planet Center data ✅

    • Library: @nyx/mpc at libs/nyx/catalogs/solar-system/mpc/
    • MPC Web Service client with authentication
    • Asteroid and Comet schemas with full orbital elements
    • NEO classification (Atira, Aten, Apollo, Amor)
    • Asteroid group classification (main belt, Trojans, TNOs, etc.)
    • Kepler equation solvers (elliptic, parabolic, hyperbolic)
    • Orbital propagation and ephemeris generation
    • Query service with caching
    • Notable asteroids/comets reference data
    • Tests: 71 comprehensive tests
    • Acceptance: Minor bodies queryable ✓
  • 21.2.4.5 [Medium/M] Create near-Earth object database ✅

    • Library: @nyx/neo (libs/nyx/catalogs/solar-system/neo/)
    • CNEOS Close Approach Data API client
    • JPL Sentry Impact Monitoring System client
    • Palermo Scale and Torino Scale calculations
    • NEO classification (Atira, Aten, Apollo, Amor)
    • Virtual impactor tracking
    • Risk assessment functions
    • Unified NEOService combining CAD and Sentry
    • Diameter estimation, impact energy, damage potential utilities
    • Notable NEOs reference data (Apophis, Bennu, Ryugu, etc.)
    • Tests: 101 comprehensive tests
    • Acceptance: NEO tracking available ✓
  • 21.2.4.6 [Medium/M] Create comet database ✅

    • Library: @nyx/comets at libs/nyx/catalogs/solar-system/comets/
    • Comprehensive type definitions with Zod schemas for validation
    • Database of 19 notable comets (Halley, Encke, Hale-Bopp, NEOWISE, etc.)
    • Keplerian orbital mechanics (elliptic, parabolic, hyperbolic orbits)
    • Kepler equation solvers using Newton-Raphson iteration
    • Julian Date conversions and ephemeris generation
    • Visibility predictions with magnitude estimation
    • CometService class for querying and analysis
    • Tests: 94 comprehensive tests
    • Acceptance: Comet data complete ✓

21.2.5 Deep Sky Objects#

  • 21.2.5.1 [High/L] Create nebulae catalog ✅

    • Library: @nyx/nebulae at libs/nyx/catalogs/deep-sky/nebulae/
    • Comprehensive type definitions with Zod schemas
    • Database of 23 notable nebulae covering all major types:
      • Emission nebulae (Orion, Lagoon, Eagle, Carina, etc.)
      • Planetary nebulae (Ring, Dumbbell, Helix, Cat's Eye, etc.)
      • Dark nebulae (Horsehead, Coal Sack, Pipe, Snake)
      • Supernova remnants (Crab, Veil, Cassiopeia A)
      • Reflection nebulae (Pleiades, Witch Head, Iris)
    • Coordinate utilities (equatorial/galactic conversions)
    • NebulaeService class with filtering, searching, and statistics
    • Tests: 121 comprehensive tests
    • Acceptance: Nebulae data complete ✓
  • 21.2.5.2 [High/M] Create star cluster catalog ✅

    • Library: @nyx/clusters at libs/nyx/catalogs/deep-sky/clusters/
    • Data: 17 notable clusters (9 open, 8 globular)
    • Open: Pleiades, Hyades, Beehive, Double Cluster, Wild Duck, Jewel Box, M35, M37
    • Globular: M13, Omega Centauri, 47 Tucanae, M3, M22, M5, M15, M4
    • Features: Trumpler classification, Shapley-Sawyer concentration class
    • Fields: Member stars, age, distance, metallicity, radial velocity
    • Service: ClusterService with query, filter, visibility methods
    • Tests: 150 comprehensive tests
    • Acceptance: Cluster data complete ✓
  • 21.2.5.3 [Medium/M] Integrate Messier catalog with rich data ✅

    • File: libs/nyx/catalogs/deep-sky/messier/
    • Data: All 110 Messier objects
    • Fields: Historical descriptions
    • Fields: Observation notes, visibility
    • Fields: High-quality imagery references
    • Implementation: @nyx/messier library with MessierService
    • Tests: 71 comprehensive tests, all passing
    • Acceptance: Messier catalog enhanced ✓
  • 21.2.5.4 [Medium/M] Create supernova remnant catalog ✅

    • File: libs/nyx/catalogs/deep-sky/snr/ (@nyx/snr library)
    • Data: 40+ well-characterized SNRs from Green's catalog
    • Types: Shell, plerion (filled-center), composite, mixed-morphology
    • SNe: Type Ia, II (IIP, IIL, IIb, IIn), electron-capture
    • Compact remnants: Pulsars, magnetars, CCOs, black holes
    • Historical: Crab (1054), Cas A, Tycho (1572), Kepler (1604), SN 1006, SN 1987A
    • Multi-wavelength: Radio, optical, X-ray, gamma-ray (GeV/TeV) properties
    • Coordinates: Galactic (l,b) and equatorial (RA/Dec J2000.0)
    • Distance, age, evolution phase, expansion velocity
    • Implementation: @nyx/snr library with SNRService
    • Tests: 114 comprehensive tests, all passing
    • Acceptance: SNR catalog complete ✓

21.2.6 Exotic Objects Database#

  • 21.2.6.1 [High/L] Create black hole catalog

    • File: libs/nyx/catalogs/deep-sky/black-holes/
    • Data: Stellar black holes, supermassive black holes, IMBHs, GW events
    • Fields: Mass, spin, accretion rate
    • Fields: Event horizon radius, location
    • Implement: AGN classification, XRB types, GW mergers
    • Implementation: @nyx/black-holes library with BlackHoleService
    • Tests: 92 comprehensive tests, all passing
    • Acceptance: Black holes cataloged ✓
  • 21.2.6.2 [High/M] Create pulsar catalog (ATNF) ✅

    • File: libs/nyx/catalogs/deep-sky/pulsars/
    • Implementation: @nyx/pulsars library with PulsarService
    • Data: 27 pulsars (11 famous, 8 millisecond, 8 magnetars)
    • Fields: Period, period derivative, timing, DM, binary parameters
    • Derived: Characteristic age, surface B-field, spindown luminosity
    • Tests: 83 comprehensive tests, all passing
    • Acceptance: Pulsar data complete ✓
  • 21.2.6.3 [Medium/M] Create neutron star catalog ✅

    • File: libs/nyx/catalogs/deep-sky/neutron-stars/
    • Implementation: @nyx/neutron-stars library with NeutronStarService
    • Data: 14 objects (7 Magnificent Seven XDINSs, 7 CCOs)
    • Fields: X-ray spectrum, timing, distances, proper motion
    • Types: XDINS, CCO with full category system
    • Tests: 83 comprehensive tests, all passing
    • Acceptance: Neutron stars cataloged ✓
  • 21.2.6.4 [Medium/M] Create quasar catalog ✅

    • File: libs/nyx/catalogs/deep-sky/quasars/
    • Data: 20 curated quasars (famous quasars, blazars, high-redshift)
    • Fields: Redshift, luminosity, black hole mass, jets, host galaxy
    • Features: QuasarService with 30+ query methods
    • Cosmological utilities: luminosity distance, light travel time, etc.
    • Acceptance: Quasars queryable ✓
  • 21.2.6.5 [Medium/M] Create gravitational wave source catalog ✅

    • File: libs/nyx/catalogs/deep-sky/gravitational-waves/
    • Data: 15 curated GWTC events (GWTC-1, GWTC-2, GWTC-3)
    • Source types: BBH, BNS, NSBH with full mass/spin/distance parameters
    • Notable events: GW150914, GW170817, GW190521, GW190814, GW200105
    • Features: GWEventService with 25+ query methods
    • Tests: 78 comprehensive tests, all passing
    • Acceptance: GW sources cataloged ✓

21.3 Coordinate Systems & Astronomical Calculations#

21.3.1 Coordinate Transformations#

  • 21.3.1.1 [Critical/L] Implement celestial coordinate systems ✅

    • File: libs/nyx/coordinates/celestial.ts
    • System: Equatorial (RA/Dec, J2000, current epoch)
    • System: Horizontal (Alt/Az)
    • System: Ecliptic (heliocentric, geocentric)
    • System: Galactic (l, b)
    • System: Supergalactic
    • Acceptance: All coordinate systems implemented
  • 21.3.1.2 [Critical/L] Implement coordinate transformations ✅

    • File: libs/nyx/coordinates/transformations.ts
    • Transform: Equatorial ↔ Horizontal
    • Transform: Equatorial ↔ Ecliptic
    • Transform: Equatorial ↔ Galactic
    • Transform: Precession between epochs
    • Implement: High-precision IAU standards
    • Acceptance: Accurate transformations
  • 21.3.1.3 [High/M] Implement proper motion calculations ✅

    • File: libs/nyx/coordinates/proper-motion.ts
    • Implement: Proper motion propagation
    • Implement: Radial velocity effects
    • Implement: Parallax corrections
    • Implement: Historical/future positions
    • Acceptance: Star positions time-accurate
  • 21.3.1.4 [High/M] Implement atmospheric refraction ✅

    • File: libs/nyx/coordinates/refraction.ts
    • Implement: Refraction correction models
    • Implement: Temperature/pressure effects
    • Implement: Wavelength dependence
    • Acceptance: Apparent positions accurate
  • 21.3.1.5 [Medium/M] Implement aberration corrections

    • File: libs/nyx/coordinates/aberration.ts
    • Implement: Stellar aberration
    • Implement: Annual aberration
    • Implement: Diurnal aberration
    • Acceptance: Aberration-corrected positions

21.3.2 Time Systems#

  • 21.3.2.1 [Critical/L] Implement astronomical time systems

    • File: libs/nyx/time/systems.ts
    • System: UTC (Coordinated Universal Time)
    • System: TAI (International Atomic Time)
    • System: TT (Terrestrial Time)
    • System: TDB (Barycentric Dynamical Time)
    • System: UT1 (Universal Time)
    • Implement: Leap second handling
    • Acceptance: All time systems accurate
  • 21.3.2.2 [High/L] Implement Julian Date conversions

    • File: libs/nyx/time/julian.ts
    • Implement: JD (Julian Date)
    • Implement: MJD (Modified Julian Date)
    • Implement: Calendar date conversions
    • Implement: Decimal year conversions
    • Acceptance: JD conversions accurate
  • 21.3.2.3 [High/M] Implement sidereal time calculations

    • File: libs/nyx/time/sidereal.ts
    • Implement: GMST (Greenwich Mean Sidereal Time)
    • Implement: GAST (Greenwich Apparent Sidereal Time)
    • Implement: Local sidereal time
    • Implement: Hour angle calculations
    • Acceptance: Sidereal time accurate
  • 21.3.2.4 [High/M] Implement Earth rotation parameters

    • File: libs/nyx/time/earth-rotation.ts
    • Implement: Delta-T calculations
    • Implement: UT1-UTC difference
    • Implement: Polar motion (x, y)
    • Implement: IERS data integration
    • Acceptance: ERP data integrated
  • 21.3.2.5 [Medium/M] Create historical time handling

    • File: libs/nyx/time/historical.ts
    • Implement: Proleptic calendars
    • Implement: Julian/Gregorian transition
    • Implement: Ancient date handling
    • Acceptance: Historical dates handled

21.3.3 Positional Astronomy#

  • 21.3.3.1 [High/L] Implement precession-nutation model

    • File: libs/nyx/positional/precession-nutation.ts
    • Implement: IAU 2006 precession
    • Implement: IAU 2000A nutation
    • Implement: Frame bias
    • Implement: CIO-based transformation
    • Acceptance: P-N model accurate
  • 21.3.3.2 [High/M] Implement rise/set/transit calculations

    • File: libs/nyx/positional/rise-set-transit.ts
    • Implement: Rise time calculation
    • Implement: Set time calculation
    • Implement: Transit (meridian crossing)
    • Implement: Twilight calculations
    • Implement: Golden/blue hour
    • Acceptance: Event times accurate
  • 21.3.3.3 [High/M] Implement angular separation calculations

    • File: libs/nyx/positional/angular-separation.ts
    • Implement: Great circle distance
    • Implement: Position angle
    • Implement: Conjunction detection
    • Implement: Occultation prediction
    • Acceptance: Separations calculated
  • 21.3.3.4 [Medium/M] Implement parallax calculations

    • File: libs/nyx/positional/parallax.ts
    • Implement: Geocentric parallax
    • Implement: Topocentric parallax
    • Implement: Annual parallax
    • Implement: Distance from parallax
    • Acceptance: Parallax effects computed

21.4 Orbital Mechanics Engine#

21.4.1 Kepler Solver#

  • 21.4.1.1 [Critical/L] Implement Keplerian orbital elements

    • File: libs/nyx/orbital/elements.ts
    • Elements: Semi-major axis (a)
    • Elements: Eccentricity (e)
    • Elements: Inclination (i)
    • Elements: Longitude of ascending node (Ω)
    • Elements: Argument of perihelion (ω)
    • Elements: Mean anomaly (M) or true anomaly (ν)
    • Implement: Epoch handling
    • Acceptance: Orbital elements defined
  • 21.4.1.2 [Critical/L] Implement Kepler's equation solver

    • File: libs/nyx/orbital/kepler-solver.ts
    • Implement: Mean anomaly → Eccentric anomaly
    • Implement: Eccentric anomaly → True anomaly
    • Implement: Newton-Raphson iteration
    • Implement: Hyperbolic orbits (sinh/cosh)
    • Implement: Parabolic orbits
    • Acceptance: Kepler equation solved accurately
  • 21.4.1.3 [High/L] Implement orbital state vectors

    • File: libs/nyx/orbital/state-vectors.ts
    • Implement: Position vector (r)
    • Implement: Velocity vector (v)
    • Implement: Elements ↔ State vectors conversion
    • Implement: Orbital energy, angular momentum
    • Acceptance: State vectors computed
  • 21.4.1.4 [High/M] Implement orbital propagation

    • File: libs/nyx/orbital/propagation.ts
    • Implement: Two-body propagation
    • Implement: Time of flight calculations
    • Implement: Universal variables formulation
    • Implement: Stumpff functions
    • Acceptance: Orbits propagated accurately
  • 21.4.1.5 [Medium/M] Implement orbital visualization helpers

    • File: libs/nyx/orbital/visualization.ts
    • Implement: Orbit path generation
    • Implement: Perihelion/aphelion markers
    • Implement: Ascending/descending nodes
    • Implement: Orbit plane normal
    • Acceptance: Orbits renderable

21.4.2 N-Body Simulation#

  • 21.4.2.1 [High/L] Implement N-body gravitational simulation ✅

    • File: libs/nyx/orbital/src/n-body.ts
    • Implement: Gravitational force calculation (direct N² method)
    • Implement: Symplectic integrators (Leapfrog KDK/DKD, Yoshida 4th order)
    • Implement: Runge-Kutta integrators (RK4, RK8/DOP853)
    • Implement: Barnes-Hut octree for O(N log N) force calculation
    • Implement: Conservation monitoring (energy, momentum, angular momentum)
    • Implement: Collision detection
    • Implement: Predefined systems (Sun-Earth-Moon, Figure-8, Pythagorean)
    • Acceptance: N-body simulation runs with 103 tests passing
  • 21.4.2.2 [High/M] Implement solar system integration

    • File: libs/nyx/orbital/solar-system-integration.ts
    • Implement: Sun + all planets
    • Implement: Major moons
    • Implement: Relativistic corrections
    • Implement: JPL DE ephemeris validation
    • Acceptance: Solar system accurate to arcseconds
  • 21.4.2.3 [Medium/M] Implement perturbation analysis

    • File: libs/nyx/orbital/perturbations.ts
    • Implement: J2 oblateness perturbation
    • Implement: Solar radiation pressure
    • Implement: Third-body perturbations
    • Implement: Atmospheric drag (LEO)
    • Acceptance: Perturbations modeled
  • 21.4.2.4 [Medium/M] Implement Lagrange point calculations ✅

    • File: libs/nyx/orbital/src/lagrange-points.ts
    • Implemented: L1-L5 point position calculations using Newton-Raphson
    • Implemented: Stability analysis with characteristic exponents
    • Implemented: Jacobi integral and zero-velocity curves
    • Implemented: Synodic/inertial frame conversions
    • Acceptance: Lagrange points computed

21.4.3 Eclipse & Event Prediction#

  • 21.4.3.1 [High/L] Implement solar eclipse prediction ✅

    • File: libs/nyx/events/solar-eclipses.ts
    • Implemented: Besselian elements method for eclipse prediction
    • Implemented: Eclipse path calculation with central line and limit curves
    • Implemented: Totality/annularity/hybrid/partiality determination
    • Implemented: Contact times (C1-C4) with Newton-Raphson iteration
    • Implemented: Magnitude and obscuration calculations
    • Implemented: Saros cycle tracking with series information
    • Implemented: SolarEclipseService class for comprehensive API
    • Acceptance: Solar eclipses predicted (74 tests passing)
  • 21.4.3.2 [High/L] Implement lunar eclipse prediction ✅

    • File: libs/nyx/events/lunar-eclipses.ts
    • Implemented: Earth shadow cone geometry (umbral/penumbral)
    • Implemented: Eclipse type determination (total/partial/penumbral)
    • Implemented: Eclipse magnitude and obscuration calculations
    • Implemented: Contact times (P1, U1, U2, MAX, U3, U4, P4)
    • Implemented: Danjon scale brightness estimation (L0-L4)
    • Implemented: Saros cycle tracking for lunar eclipses
    • Implemented: Visibility calculations for observer locations
    • Implemented: LunarEclipseService class for comprehensive API
    • Acceptance: Lunar eclipses predicted (79 tests passing)
  • 21.4.3.3 [High/M] Implement planetary conjunction prediction ✅

    • File: libs/nyx/events/src/conjunctions.ts
    • Implemented: Planet position calculations using Keplerian orbital elements
    • Implemented: Planet-planet conjunction detection with Newton-Raphson refinement
    • Implemented: Planet-star conjunctions with proper motion correction
    • Implemented: Superior planet opposition detection (Mars, Jupiter, Saturn, Uranus, Neptune)
    • Implemented: Greatest elongation for Mercury and Venus
    • Implemented: Triple conjunction detection for rare events
    • Implemented: ConjunctionService class for high-level API
    • Implemented: Notable zodiacal stars (Regulus, Spica, Antares, Aldebaran, Pollux)
    • Acceptance: Planetary conjunctions predicted (93 tests passing)
  • 21.4.3.4 [Medium/M] Implement occultation prediction ✅

    • File: libs/nyx/events/src/occultations.ts
    • Implemented: Lunar occultation prediction (Moon occulting stars)
    • Implemented: Planetary occultation prediction (planets occulting stars)
    • Implemented: Contact time calculations (ingress, egress, maximum)
    • Implemented: Topocentric parallax corrections for observer locations
    • Implemented: Visibility calculations with quality scoring
    • Implemented: Grazing occultation path calculations (simplified)
    • Implemented: OccultationService class for high-level API
    • Implemented: Notable zodiacal occultation stars catalog
    • Acceptance: Occultations predicted (76 tests passing)
  • 21.4.3.5 [Medium/M] Implement transit prediction

    • File: libs/nyx/events/src/transits.ts
    • Implemented: Mercury transit prediction with contact times
    • Implemented: Venus transit prediction with contact times
    • Implemented: Galilean moon transits (Io, Europa, Ganymede, Callisto)
    • Implemented: Galilean moon shadow transits, occultations, eclipses
    • Implemented: ISS transit prediction (with SGP4 propagation)
    • Implemented: TLE parsing and validation
    • Implemented: Geodetic/ECI coordinate conversions
    • Implemented: Simplified Keplerian orbital elements for planets
    • Implemented: TransitService class for high-level API
    • Acceptance: Transits predicted (114 tests passing, 436 total in @nyx/events)

21.4.4 Ephemeris Generation#

  • 21.4.4.1 [High/L] Create ephemeris generation engine

    • File: libs/nyx/ephemeris/src/generator.ts
    • Implemented: Position ephemeris for Sun, Moon, and all planets
    • Implemented: Velocity ephemeris (angular and radial)
    • Implemented: Distance, elongation, phase calculations
    • Implemented: Configurable time resolution (uniform and adaptive)
    • Implemented: Coordinate frames (equatorial, ecliptic, horizontal)
    • Implemented: Interpolation (linear and Lagrange)
    • Implemented: EphemerisService class with caching
    • Implemented: Rise/set/transit calculations
    • Acceptance: Ephemerides generated (153 tests passing)
  • 21.4.4.2 [High/M] Implement planet visibility calculations

    • File: libs/nyx/ephemeris/visibility.ts
    • Implemented: Apparent magnitude and observability scoring
    • Implemented: Phase angle, airmass, atmospheric extinction
    • Implemented: Angular diameter and elongation calculations
    • Implemented: Best viewing times and visibility windows
    • Implemented: Moon interference calculations
    • Implemented: Opposition/conjunction/quadrature detection
    • Implemented: VisibilityService class with comprehensive API
    • Acceptance: Visibility computed (126 tests passing, 279 total)
  • 21.4.4.3 [Medium/M] Implement asteroid/comet ephemeris

    • File: libs/nyx/ephemeris/minor-bodies.ts
    • Implemented: Osculating elements propagation with Kepler solvers
    • Implemented: Non-gravitational forces (Marsden/Sekanina models, A1/A2/A3)
    • Implemented: Light-time correction
    • Implemented: Asteroid H-G magnitude system, comet m1+k system
    • Implemented: Close approach detection with refinement
    • Implemented: NEO classification (Atira, Aten, Apollo, Amor)
    • Implemented: MinorBodyEphemerisService class
    • Acceptance: Minor body positions accurate (82 tests passing, 361 total)
  • 21.4.4.4 [Medium/M] Create ephemeris caching system

    • File: libs/nyx/ephemeris/src/cache.ts
    • Implemented: High-performance EphemerisCache class
    • Implemented: LRU, LFU, FIFO, and TTL cache eviction policies
    • Implemented: Pre-computed ephemeris storage for planets and minor bodies
    • Implemented: Cubic spline and Lagrange interpolation between cached points
    • Implemented: Cache key generation with orbital element versioning
    • Implemented: Cache invalidation (pattern/regex, per-target, full clear)
    • Implemented: Cache statistics and monitoring (hit ratio, query times)
    • Implemented: Automatic garbage collection for expired entries
    • Implemented: Convenience functions (getDefaultCache, precomputePlanetEphemeris, etc.)
    • Acceptance: Ephemeris queries fast (65 tests passing, 426 total)

21.5 3D Visualization Engine#

21.5.1 WebGPU/WebGL Renderer#

  • 21.5.1.1 [Critical/XL] Create core 3D rendering engine

    • File: libs/nyx/renderer/core/
    • Implement: WebGPU primary renderer
    • Implement: WebGL 2.0 fallback
    • Implement: Scene graph management
    • Implement: Camera system (free, orbit, flythrough)
    • Implement: Frame scheduling and performance
    • Acceptance: Core renderer functional
  • 21.5.1.2 [Critical/L] Implement multi-scale rendering system

    • File: libs/nyx/renderer/scale/
    • Scale: Solar system (AU units)
    • Scale: Stellar neighborhood (parsecs)
    • Scale: Galaxy (kiloparsecs)
    • Scale: Universe (megaparsecs)
    • Implement: Seamless scale transitions
    • Implement: Floating-point precision handling
    • Acceptance: Scales transition smoothly
  • 21.5.1.3 [High/L] Implement level-of-detail system

    • File: libs/nyx/renderer/lod/
    • Implement: Distance-based LOD
    • Implement: Screen-space error metric
    • Implement: Streaming LOD tiles
    • Implement: Memory budget management
    • Acceptance: LOD maintains performance
  • 21.5.1.4 [High/M] Implement HDR rendering pipeline

    • File: libs/nyx/renderer/hdr/
    • Implement: HDR framebuffer
    • Implement: Tone mapping operators
    • Implement: Bloom effects
    • Implement: Exposure adaptation
    • Acceptance: HDR rendering works
  • 21.5.1.5 [Medium/M] Implement post-processing effects

    • File: libs/nyx/renderer/post-processing/
    • Effect: Anti-aliasing (FXAA, SMAA)
    • Effect: Motion blur
    • Effect: Depth of field
    • Effect: Vignette
    • Acceptance: Post-processing enhances visuals

21.5.2 Star Rendering#

  • 21.5.2.1 [Critical/L] Implement star point rendering ✅

    • File: libs/nyx/renderer/stars/src/point-stars.ts
    • Implemented: GPU point sprite rendering with efficient vertex buffers
    • Implemented: Billboard sizing by apparent magnitude with logarithmic scaling
    • Implemented: Accurate color from spectral type/temperature via blackbody
    • Implemented: Realistic twinkling/scintillation with altitude dependency
    • Implemented: LOD system for efficient rendering of millions of stars
    • Implemented: GLSL and WGSL shader generation for GPU rendering
    • Implemented: PointStarRenderer class for complete star field management
    • Tests: 65+ comprehensive tests covering all functionality
    • Acceptance: Stars render beautifully ✓
  • 21.5.2.2 [High/L] Implement star color calculations ✅

    • File: libs/nyx/renderer/stars/src/star-colors.ts
    • Implemented: B-V color index to RGB (via Ballesteros formula)
    • Implemented: Blackbody temperature to color (Planck's law approximation)
    • Implemented: Spectral type color lookup with subtype interpolation
    • Implemented: Luminosity class support (Ia, Ib, II, III, IV, V, VI, VII)
    • Implemented: sRGB gamma correction and linear RGB operations
    • Implemented: Color utilities (blend, brightness, desaturate, luminance)
    • Implemented: Bidirectional B-V ↔ temperature conversion
    • Tests: 78 comprehensive tests, all passing
    • Acceptance: Star colors accurate ✓
  • 21.5.2.3 [High/M] Implement star brightness calculations

    • File: libs/nyx/renderer/stars/src/brightness.ts
    • Implemented: Magnitude ↔ intensity conversion (Pogson's formula)
    • Implemented: Distance-based dimming (distance modulus, absolute/apparent magnitude)
    • Implemented: Atmospheric extinction (Kasten & Young airmass, elevation correction)
    • Implemented: Apparent magnitude to screen size (logarithmic/linear scaling)
    • Implemented: Limiting magnitude selection (equipment-based, telescope aperture formula)
    • Implemented: Combined star visibility with extinction
    • Implemented: Distance unit conversion (pc, ly, au)
    • Tests: 108 comprehensive tests, all passing
    • Acceptance: Brightness scales correctly ✓
  • 21.5.2.4 [High/M] Implement star streaming system

    • File: libs/nyx/renderer/stars/src/streaming.ts
    • Implemented: HEALPix-based tile organization
    • Implemented: View frustum culling via queryDisc
    • Implemented: Priority-based loading (visibility, distance from center, brightness)
    • Implemented: LRU memory management with configurable limits
    • Implemented: Progressive loading with adaptive level-of-detail
    • Implemented: Prefetch system for smoother navigation
    • Implemented: Tile cache with metadata tracking
    • Implemented: Load queue with concurrent load limits
    • Tests: 65 comprehensive tests, all passing
    • Acceptance: Billions of stars streamable ✓
  • 21.5.2.5 [Medium/M] Implement variable star visualization ✅

    • File: libs/nyx/renderer/stars/src/variable-stars.ts
    • Implemented: Variable star type enums (Cepheid, RR Lyrae, Mira, Algol, etc.)
    • Implemented: Variable category classification (pulsating, eclipsing, eruptive, etc.)
    • Implemented: Light curve generation for all variable types
    • Implemented: Asymmetric pulsation curves (Cepheids, RR Lyrae)
    • Implemented: Long-period Mira curves with irregularity
    • Implemented: Eclipsing binary curves (Algol, Beta Lyrae, W UMa)
    • Implemented: Phase calculations with epoch support
    • Implemented: Current brightness state computation
    • Implemented: Animation frame generation for visualization
    • Implemented: Multi-periodic variable support
    • Implemented: Eclipse detection for eclipsing binaries
    • Tests: 95 comprehensive tests, all passing
    • Acceptance: Variable stars animated ✓

21.5.3 Planet Rendering#

  • 21.5.3.1 [High/L] Implement planet sphere rendering

    • File: libs/nyx/renderer/planets/sphere.ts
    • Implemented: High-detail sphere geometry with configurable segments
    • Implemented: Adaptive tessellation based on distance
    • Implemented: Texture mapping (diffuse, normal, specular, emissive)
    • Implemented: WebGPU buffer management
    • Tests: 52 comprehensive tests, all passing
    • Acceptance: Planets render realistically ✓
  • 21.5.3.2 [High/L] Implement planetary texture system

    • File: libs/nyx/renderer/planets/textures.ts
    • Implemented: Planetary texture manager with caching
    • Implemented: Multiple texture types (diffuse, normal, specular, emissive, cloud, height)
    • Implemented: Procedural texture generation with FBM noise
    • Implemented: Cloud layer generation and animation support
    • Implemented: Night-side city lights (emissive layer)
    • Implemented: Bump/height map generation
    • Tests: 65 comprehensive tests, all passing
    • Acceptance: Planet surfaces detailed ✓
  • 21.5.3.3 [High/M] Implement ring system rendering

    • File: libs/nyx/renderer/planets/rings.ts
    • Implemented: Ring system with configurable divisions (A, B, C rings, Cassini Division)
    • Implemented: Ring opacity and color per division
    • Implemented: Ring shadows on planet surface
    • Implemented: Ring particle density simulation
    • Implemented: Ring geometry and WebGPU buffer management
    • Implemented: GLSL and WGSL shader generation
    • Tests: 56 comprehensive tests, all passing
    • Acceptance: Rings render correctly ✓
  • 21.5.3.4 [High/M] Implement atmosphere scattering

    • File: libs/nyx/renderer/planets/atmosphere.ts
    • Implemented: Rayleigh scattering with wavelength-dependent coefficients
    • Implemented: Mie scattering with configurable anisotropy (g parameter)
    • Implemented: Atmospheric rim glow with proper limb darkening
    • Implemented: Sunset/sunrise color calculation via optical depth integration
    • Implemented: Single and multiple scattering approximation
    • Implemented: Ray-sphere intersection for atmosphere boundaries
    • Implemented: GLSL and WGSL shader generation
    • Tests: 69 comprehensive tests, all passing
    • Acceptance: Atmospheres realistic ✓
  • 21.5.3.5 [Medium/M] Implement exoplanet artistic rendering

    • File: libs/nyx/renderer/planets/exoplanets.ts
    • Implemented: Procedural surface generation with FBM noise
    • Implemented: Type-based appearance (Hot Jupiter, Super-Earth, Water World, Ice Giant, Lava World, Desert, Ocean, Terrestrial)
    • Implemented: Host star illumination with temperature-based coloring
    • Implemented: Tidally locked visualization (hot/cold hemispheres)
    • Implemented: Habitable zone calculation and visualization
    • Implemented: Atmospheric glow based on planet type
    • Implemented: GLSL and WGSL shader generation
    • Tests: 109 comprehensive tests, all passing
    • Acceptance: Exoplanets visualized artistically ✓

21.5.4 Galaxy Rendering#

  • 21.5.4.1 [High/L] Implement Milky Way rendering

    • File: libs/nyx/renderer/galaxies/milky-way.ts
    • Implemented: Panoramic Milky Way texture generation
    • Implemented: 3D dust lane modeling with extinction
    • Implemented: Galactic bulge with Sersic profile
    • Implemented: Logarithmic spiral arm structure (Perseus, Sagittarius, Scutum-Centaurus, Norma, Orion Spur)
    • Implemented: Galactic center (Sgr A*) visualization with glow
    • Implemented: Star particle generation for point rendering
    • Implemented: Galactic coordinate system utilities
    • Implemented: GLSL and WGSL shader generation
    • Tests: 72 comprehensive tests, all passing
    • Acceptance: Milky Way renders beautifully ✓
  • 21.5.4.2 [High/L] Implement external galaxy rendering

    • File: libs/nyx/renderer/galaxies/external.ts
    • Implemented: Galaxy type classification (spiral, elliptical, barred, irregular, lenticular, ring, peculiar)
    • Implemented: Hubble morphology sequence (E0-E7, S0, Sa-Sd, SBa-SBd, Irr)
    • Implemented: Galaxy position and orientation (inclination, position angle)
    • Implemented: Distance-based LOD (Point, Blob, LowDetail, MediumDetail, HighDetail, Full3D)
    • Implemented: NGC/Messier catalog with 10 famous galaxies (M31, M33, M51, M87, M101, M104, LMC, SMC, NGC1300, Cartwheel)
    • Implemented: Procedural sprite generation for all galaxy types
    • Implemented: GLSL and WGSL shader generation
    • Tests: 74 comprehensive tests (58 passing, 16 skipped for slow sprite generation)
    • Acceptance: External galaxies visible ✓
  • 21.5.4.3 [Medium/L] Implement procedural galaxy generation

    • File: libs/nyx/renderer/galaxies/procedural.ts
    • Implement: Spiral arm generation
    • Implement: Bar structure
    • Implement: Star population distribution
    • Implement: Dust lane placement
    • Acceptance: Galaxies procedurally generated
  • 21.5.4.4 [Medium/M] Implement galaxy cluster visualization

    • File: libs/nyx/renderer/galaxies/clusters.ts
    • Implement: Cluster member distribution
    • Implement: Intracluster medium hint
    • Implement: Gravitational lensing hint
    • Acceptance: Galaxy clusters visualized

21.5.5 Nebulae & Deep Sky Rendering#

  • 21.5.5.1 [High/L] Implement nebula rendering

    • File: libs/nyx/renderer/nebulae/nebula-renderer.ts
    • Implement: Volumetric gas rendering
    • Implement: Emission nebula glow
    • Implement: Reflection nebula illumination
    • Implement: Dark nebula silhouettes
    • Implement: High-quality texture integration
    • Acceptance: Nebulae render beautifully
  • 21.5.5.2 [High/M] Implement planetary nebula rendering

    • File: libs/nyx/renderer/nebulae/planetary.ts
    • Implement: Shell/ring structure
    • Implement: Central white dwarf
    • Implement: Bipolar jet visualization
    • Acceptance: Planetary nebulae modeled
  • 21.5.5.3 [Medium/M] Implement supernova remnant rendering

    • File: libs/nyx/renderer/nebulae/supernova-remnant.ts
    • Implement: Expanding shell visualization
    • Implement: Shockwave structure
    • Implement: Central pulsar (if present)
    • Acceptance: SNRs visualized
  • 21.5.5.4 [Medium/M] Implement star cluster rendering

    • File: libs/nyx/renderer/clusters/star-clusters.ts
    • Implement: Open cluster point clouds
    • Implement: Globular cluster density
    • Implement: Member star colors
    • Acceptance: Clusters render distinctly

21.5.6 Special Relativistic Effects#

  • 21.5.6.1 [High/L] Implement black hole visualization

    • File: libs/nyx/renderer/exotic/black-hole.ts
    • Implement: Event horizon sphere
    • Implement: Gravitational lensing effect
    • Implement: Photon sphere
    • Implement: Accretion disk
    • Implement: Relativistic jet visualization
    • Acceptance: Black holes visually stunning
  • 21.5.6.2 [Medium/M] Implement gravitational lensing

    • File: libs/nyx/renderer/exotic/gravitational-lensing.ts
    • Implement: Background distortion
    • Implement: Einstein ring effect
    • Implement: Multiple image creation
    • Implement: Galaxy cluster lensing
    • Acceptance: Lensing effects visible
  • 21.5.6.3 [Medium/M] Implement relativistic doppler effects

    • File: libs/nyx/renderer/exotic/doppler.ts
    • Implement: Blueshift visualization
    • Implement: Redshift visualization
    • Implement: High-velocity star coloring
    • Acceptance: Doppler effects shown
  • 21.5.6.4 [Low/M] Implement pulsar visualization

    • File: libs/nyx/renderer/exotic/pulsar.ts
    • Implement: Rotating beam animation
    • Implement: Lighthouse effect
    • Implement: Pulse timing visualization
    • Acceptance: Pulsars animated

21.5.7 Background & Skybox#

  • 21.5.7.1 [High/M] Implement cosmic microwave background

    • File: libs/nyx/renderer/background/cmb.ts
    • Implement: Planck CMB map integration
    • Implement: Temperature anisotropy coloring
    • Implement: Toggle between visible/CMB
    • Acceptance: CMB visualizable
  • 21.5.7.2 [High/M] Implement dark sky background

    • File: libs/nyx/renderer/background/dark-sky.ts
    • Implement: Proper black level
    • Implement: Zodiacal light (optional)
    • Implement: Gegenschein (optional)
    • Implement: Airglow (optional)
    • Acceptance: Background realistic
  • 21.5.7.3 [Medium/M] Implement cosmic web visualization

    • File: libs/nyx/renderer/background/cosmic-web.ts
    • Implement: Large-scale filaments
    • Implement: Void regions
    • Implement: Dark matter distribution hint
    • Acceptance: Universe structure visible

21.6 Interactive Star Map Application#

21.6.1 Core Navigation#

  • 21.6.1.1 [Critical/L] Create main star map application

    • File: apps/nyx/star-map/
    • Framework: React + Three.js/WebGPU
    • Implement: Main scene setup
    • Implement: Responsive canvas
    • Implement: Loading and splash screen
    • Acceptance: App launches and renders
  • 21.6.1.2 [Critical/L] Implement camera controls

    • File: apps/nyx/star-map/src/controls/camera-controls.ts
    • Control: Mouse orbit (drag to rotate)
    • Control: Scroll to zoom
    • Control: Touch gestures (pinch, pan)
    • Control: Keyboard navigation (WASD, arrows)
    • Control: Gamepad support
    • Acceptance: Intuitive navigation
  • 21.6.1.3 [High/L] Implement multi-scale navigation

    • File: apps/nyx/star-map/src/navigation/scale-navigation.ts
    • Implement: Smooth zoom between scales
    • Implement: Context indicators at each scale
    • Implement: Breadcrumb trail (Universe > Galaxy > System)
    • Implement: Quick jump to scales
    • Acceptance: Scales seamlessly connected
  • 21.6.1.4 [High/M] Implement fly-to navigation

    • File: apps/nyx/star-map/src/navigation/fly-to.ts
    • Implement: Smooth camera animation
    • Implement: Path optimization
    • Implement: Scale adjustment during flight
    • Implement: Arrival at object
    • Acceptance: Flying to objects feels natural
  • 21.6.1.5 [High/M] Implement view presets

    • File: apps/nyx/star-map/src/navigation/view-presets.ts
    • Preset: Earth surface view
    • Preset: Solar system overview
    • Preset: Milky Way face-on
    • Preset: Local Group
    • Preset: Observable universe
    • Acceptance: Quick view switches

21.6.2 Object Interaction#

  • 21.6.2.1 [High/L] Implement object selection system

    • File: apps/nyx/star-map/src/interaction/selection.ts
    • Implement: Click to select
    • Implement: Hover highlighting
    • Implement: Selection outline/glow
    • Implement: Multi-select (shift+click)
    • Acceptance: Objects selectable
  • 21.6.2.2 [High/L] Create object info panel

    • File: apps/nyx/star-map/src/ui/info-panel/
    • Display: Object name and designations
    • Display: Physical properties
    • Display: Orbital properties
    • Display: Observational data
    • Display: Links to external resources
    • Acceptance: Info panel comprehensive
  • 21.6.2.3 [High/M] Implement context menu

    • File: apps/nyx/star-map/src/ui/context-menu.ts
    • Action: Fly to object
    • Action: Center view
    • Action: Add to bookmarks
    • Action: Compare with...
    • Action: Show orbit
    • Action: Wikipedia link
    • Acceptance: Context actions available
  • 21.6.2.4 [Medium/M] Implement measurement tools

    • File: apps/nyx/star-map/src/tools/measurements.ts
    • Tool: Angular distance measurement
    • Tool: Linear distance measurement
    • Tool: Light travel time display
    • Tool: Comparison overlays
    • Acceptance: Distances measurable

21.6.3 Search & Discovery#

  • 21.6.3.1 [Critical/L] Implement search functionality

    • File: apps/nyx/star-map/src/search/
    • Search: By name (common, catalog)
    • Search: By coordinates
    • Search: By type/classification
    • Search: Fuzzy matching
    • Implement: Search suggestions
    • Implement: Recent searches
    • Acceptance: Find any object quickly
  • 21.6.3.2 [High/M] Implement filter system

    • File: apps/nyx/star-map/src/filters/
    • Filter: Object type (star, planet, galaxy, etc.)
    • Filter: Magnitude range
    • Filter: Distance range
    • Filter: Spectral type
    • Filter: Constellation
    • Acceptance: View customizable
  • 21.6.3.3 [High/M] Create discovery mode

    • File: apps/nyx/star-map/src/modes/discovery.ts
    • Feature: Random interesting object
    • Feature: "Similar to this" suggestions
    • Feature: Nearby objects of interest
    • Feature: Today's sky highlights
    • Acceptance: Exploration encouraged
  • 21.6.3.4 [Medium/M] Implement advanced query builder

    • File: apps/nyx/star-map/src/search/query-builder.ts
    • Query: Boolean operators (AND, OR, NOT)
    • Query: Range queries (magnitude < 3)
    • Query: Spatial queries (within X of Y)
    • Query: Save custom queries
    • Acceptance: Complex searches possible

21.6.4 Bookmarks & Collections#

  • 21.6.4.1 [High/M] Implement bookmarks system

    • File: apps/nyx/star-map/src/bookmarks/
    • Feature: Save object as bookmark
    • Feature: Save view (location + orientation)
    • Feature: Organize in folders
    • Feature: Import/export bookmarks
    • Acceptance: Favorites saved
  • 21.6.4.2 [Medium/M] Create curated collections

    • File: apps/nyx/star-map/src/collections/
    • Collection: Messier objects
    • Collection: Brightest stars
    • Collection: Notable exoplanets
    • Collection: Famous nebulae
    • Collection: Nearby stars
    • Acceptance: Curated lists available
  • 21.6.4.3 [Medium/M] Implement observation planning

    • File: apps/nyx/star-map/src/planning/observation-planner.ts
    • Feature: Create observation list
    • Feature: Sort by visibility
    • Feature: Best viewing time
    • Feature: Export to format (AstroPlanner, etc.)
    • Acceptance: Observation lists creatable

21.6.5 Visual Overlays#

  • 21.6.5.1 [High/M] Implement constellation lines overlay

    • File: apps/nyx/star-map/src/overlays/constellations.ts
    • Implement: IAU constellation boundaries
    • Implement: Traditional asterism lines
    • Implement: Constellation names
    • Implement: Multiple culture overlays
    • Acceptance: Constellations visible
  • 21.6.5.2 [High/M] Implement coordinate grid overlays

    • File: apps/nyx/star-map/src/overlays/grids.ts
    • Grid: Equatorial (RA/Dec)
    • Grid: Alt-azimuth
    • Grid: Ecliptic
    • Grid: Galactic
    • Implement: Toggle each grid
    • Acceptance: Coordinate reference available
  • 21.6.5.3 [Medium/M] Implement celestial markers

    • File: apps/nyx/star-map/src/overlays/markers.ts
    • Marker: Celestial poles
    • Marker: Ecliptic
    • Marker: Celestial equator
    • Marker: Galactic plane
    • Marker: Zenith/nadir
    • Acceptance: Reference points visible
  • 21.6.5.4 [Medium/M] Implement orbit path visualization

    • File: apps/nyx/star-map/src/overlays/orbits.ts
    • Display: Planet orbit paths
    • Display: Moon orbits
    • Display: Comet/asteroid orbits
    • Display: Spacecraft trajectories
    • Implement: Toggle individual orbits
    • Acceptance: Orbits visualized

21.6.6 Time Controls#

  • 21.6.6.1 [High/L] Implement time control system

    • File: apps/nyx/star-map/src/time/time-controls.ts
    • Control: Current time (real-time)
    • Control: Manual date/time selection
    • Control: Play/pause time flow
    • Control: Time speed (1x to 10000x)
    • Control: Reverse time
    • Acceptance: Time fully controllable
  • 21.6.6.2 [High/M] Implement time slider

    • File: apps/nyx/star-map/src/ui/time-slider.ts
    • Feature: Drag to change time
    • Feature: Keyframe markers (events)
    • Feature: Zoom timeline (hours/days/years)
    • Feature: Jump to date
    • Acceptance: Time navigation intuitive
  • 21.6.6.3 [Medium/M] Implement astronomical event timeline

    • File: apps/nyx/star-map/src/time/event-timeline.ts
    • Events: Eclipses
    • Events: Conjunctions
    • Events: Meteor showers
    • Events: Planetary oppositions
    • Feature: Jump to event
    • Acceptance: Events accessible from timeline

21.7 Orrery & Solar System Explorer#

21.7.1 Interactive Orrery#

  • 21.7.1.1 [High/L] Create orrery application mode

    • File: apps/nyx/star-map/src/modes/orrery/
    • Implement: Solar system focused view
    • Implement: Accurate orbital positions
    • Implement: Real-time or accelerated time
    • Implement: Scale options (true/exaggerated)
    • Acceptance: Orrery mode functional
  • 21.7.1.2 [High/M] Implement planet detail view

    • File: apps/nyx/star-map/src/modes/orrery/planet-detail.ts
    • Display: High-res planet render
    • Display: Moon system
    • Display: Ring system (if applicable)
    • Display: Physical data sidebar
    • Feature: Rotate/examine planet
    • Acceptance: Planets examinable in detail
  • 21.7.1.3 [High/M] Implement moon system view

    • File: apps/nyx/star-map/src/modes/orrery/moon-system.ts
    • Display: All moons of selected planet
    • Display: Orbital paths
    • Display: Resonance indicators
    • Feature: Time lapse moon dance
    • Acceptance: Moon systems explorable
  • 21.7.1.4 [Medium/M] Implement Lagrange point visualization

    • File: apps/nyx/star-map/src/modes/orrery/lagrange-points.ts
    • Display: L1-L5 for Sun-Earth
    • Display: L1-L5 for Earth-Moon
    • Display: Spacecraft at Lagrange points
    • Feature: Stability visualization
    • Acceptance: Lagrange points shown
  • 21.7.1.5 [Medium/M] Implement asteroid belt visualization

    • File: apps/nyx/star-map/src/modes/orrery/asteroid-belt.ts
    • Display: Main belt distribution
    • Display: Trojan asteroids
    • Display: Kirkwood gaps
    • Display: Notable asteroids (Ceres, Vesta)
    • Acceptance: Asteroid belt visualized

21.7.2 Spacecraft Tracking#

  • 21.7.2.1 [High/M] Implement spacecraft database

    • File: libs/nyx/catalogs/spacecraft/
    • Data: Active missions (Voyager, New Horizons, etc.)
    • Data: Historical missions
    • Data: Trajectory data
    • Data: Mission status
    • Acceptance: Spacecraft cataloged
  • 21.7.2.2 [High/M] Implement spacecraft visualization

    • File: apps/nyx/star-map/src/spacecraft/visualization.ts
    • Display: Current position
    • Display: Trajectory path
    • Display: Mission milestones
    • Display: Communication range
    • Acceptance: Spacecraft visible in solar system
  • 21.7.2.3 [Medium/M] Implement mission timeline view

    • File: apps/nyx/star-map/src/spacecraft/mission-timeline.ts
    • Display: Launch, flybys, arrival
    • Display: Key events
    • Feature: Jump to event
    • Feature: Replay mission
    • Acceptance: Missions reviewable

21.7.3 Eclipse & Transit Visualization#

  • 21.7.3.1 [High/L] Implement eclipse visualization mode

    • File: apps/nyx/star-map/src/modes/eclipse/
    • Display: Eclipse shadow cone
    • Display: Path of totality on Earth
    • Display: Moon position during lunar eclipse
    • Display: Contact times
    • Feature: View from different locations
    • Acceptance: Eclipses visualized
  • 21.7.3.2 [Medium/M] Implement ISS transit visualization

    • File: apps/nyx/star-map/src/modes/transits/iss.ts
    • Display: ISS position
    • Display: Transit path across Sun/Moon
    • Display: Transit duration and times
    • Feature: Location-based alerts
    • Acceptance: ISS transits predictable
  • 21.7.3.3 [Medium/M] Implement planetary transit visualization

    • File: apps/nyx/star-map/src/modes/transits/planetary.ts
    • Display: Mercury/Venus transit across Sun
    • Display: Transit timing
    • Display: Historical transits
    • Acceptance: Planetary transits shown

21.8 Time Travel & Historical Astronomy#

21.8.1 Historical Sky View#

  • 21.8.1.1 [High/L] Implement historical sky calculation

    • File: libs/nyx/time-travel/historical-sky.ts
    • Implement: Precession back thousands of years
    • Implement: Proper motion integration
    • Implement: Star position extrapolation
    • Implement: Constellation changes over time
    • Acceptance: Historical positions accurate
  • 21.8.1.2 [High/M] Create historical event presets

    • File: apps/nyx/star-map/src/time-travel/presets.ts
    • Event: Building of Pyramids (~2500 BCE)
    • Event: Supernova 1054 (Crab Nebula)
    • Event: Tycho's supernova (1572)
    • Event: Newton's Principia (1687)
    • Event: Moon landing (1969)
    • Acceptance: Quick jumps to famous dates
  • 21.8.1.3 [Medium/M] Implement pole star visualization

    • File: apps/nyx/star-map/src/time-travel/pole-star.ts
    • Display: Precession circle
    • Display: Current pole star
    • Display: Future pole stars
    • Display: Historical pole stars
    • Acceptance: Precession visualized
  • 21.8.1.4 [Medium/M] Implement ancient navigation view

    • File: apps/nyx/star-map/src/time-travel/navigation.ts
    • Display: Stars used for navigation
    • Display: Latitude determination
    • Display: Season indicators
    • Feature: Egyptian, Greek, Polynesian views
    • Acceptance: Historical navigation shown

21.8.2 Future Predictions#

  • 21.8.2.1 [High/M] Implement future sky projection

    • File: libs/nyx/time-travel/future-sky.ts
    • Implement: Proper motion extrapolation
    • Implement: Constellation dissolution
    • Implement: Stellar encounters
    • Implement: Sun's galactic orbit
    • Acceptance: Future sky viewable
  • 21.8.2.2 [Medium/M] Implement stellar evolution timeline

    • File: apps/nyx/star-map/src/time-travel/stellar-evolution.ts
    • Display: Star life stages
    • Display: Predicted supernovae
    • Display: Red giant phase timing
    • Display: White dwarf cooling
    • Acceptance: Stellar futures shown
  • 21.8.2.3 [Medium/M] Implement cosmic timeline view

    • File: apps/nyx/star-map/src/time-travel/cosmic-timeline.ts
    • Display: Big Bang to present
    • Display: Era of stars
    • Display: Heat death projection
    • Display: Major cosmic events
    • Acceptance: Cosmic history visualized

21.8.3 Supernova & Transient Events#

  • 21.8.3.1 [Medium/M] Implement historical supernova database

    • File: libs/nyx/catalogs/supernovae/historical.ts
    • Data: SN 185, SN 1006, SN 1054, etc.
    • Data: Chinese, Arabic, European records
    • Data: Remnant correlations
    • Acceptance: Historical SNe cataloged
  • 21.8.3.2 [Medium/M] Implement supernova visualization

    • File: apps/nyx/star-map/src/time-travel/supernova.ts
    • Display: Explosion visualization
    • Display: Light curve animation
    • Display: Expanding remnant
    • Display: Contemporary records
    • Acceptance: Supernovae shown dramatically

21.9 Educational Platform#

21.9.1 Interactive Lessons#

  • 21.9.1.1 [High/L] Create lesson framework

    • File: libs/nyx/education/lesson-framework/
    • Implement: Lesson structure (intro, content, quiz)
    • Implement: Progress tracking
    • Implement: Achievement system
    • Implement: Adaptive difficulty
    • Acceptance: Lesson system functional
  • 21.9.1.2 [High/L] Create astronomy fundamentals course

    • File: apps/nyx/education/courses/fundamentals/
    • Lesson: Celestial sphere concept
    • Lesson: Coordinate systems
    • Lesson: Magnitude and brightness
    • Lesson: Stellar spectral types
    • Lesson: The electromagnetic spectrum
    • Acceptance: Fundamentals course complete
  • 21.9.1.3 [High/L] Create solar system course

    • File: apps/nyx/education/courses/solar-system/
    • Lesson: Formation of the solar system
    • Lesson: The Sun
    • Lesson: Terrestrial planets
    • Lesson: Gas giants
    • Lesson: Dwarf planets and small bodies
    • Acceptance: Solar system course complete
  • 21.9.1.4 [High/L] Create stellar astronomy course

    • File: apps/nyx/education/courses/stellar/
    • Lesson: Star formation
    • Lesson: Main sequence
    • Lesson: Stellar evolution
    • Lesson: Variable stars
    • Lesson: Binary and multiple stars
    • Lesson: Stellar death (SN, WD, NS, BH)
    • Acceptance: Stellar course complete
  • 21.9.1.5 [High/L] Create galactic astronomy course

    • File: apps/nyx/education/courses/galactic/
    • Lesson: Milky Way structure
    • Lesson: Galaxy types
    • Lesson: Galaxy formation and evolution
    • Lesson: Active galactic nuclei
    • Lesson: Galaxy clusters
    • Acceptance: Galactic course complete
  • 21.9.1.6 [High/L] Create cosmology course

    • File: apps/nyx/education/courses/cosmology/
    • Lesson: Big Bang theory
    • Lesson: Cosmic expansion
    • Lesson: Dark matter
    • Lesson: Dark energy
    • Lesson: Cosmic microwave background
    • Lesson: Fate of the universe
    • Acceptance: Cosmology course complete

21.9.2 Interactive Demonstrations#

  • 21.9.2.1 [High/L] Create HR diagram interactive

    • File: apps/nyx/education/demos/hr-diagram/
    • Feature: Plot real stars on diagram
    • Feature: Animate stellar evolution path
    • Feature: Explain main sequence, giants, white dwarfs
    • Feature: Click stars to see their position
    • Acceptance: HR diagram interactive
  • 21.9.2.2 [High/M] Create distance ladder demonstration

    • File: apps/nyx/education/demos/distance-ladder/
    • Step: Parallax (nearby stars)
    • Step: Cepheid variables
    • Step: Type Ia supernovae
    • Step: Hubble's law
    • Feature: Interactive measurements
    • Acceptance: Distance methods demonstrated
  • 21.9.2.3 [High/M] Create spectroscopy demonstration

    • File: apps/nyx/education/demos/spectroscopy/
    • Feature: Absorption/emission spectra
    • Feature: Element identification
    • Feature: Doppler shift measurement
    • Feature: Temperature determination
    • Acceptance: Spectroscopy explained
  • 21.9.2.4 [Medium/M] Create gravity well demonstration

    • File: apps/nyx/education/demos/gravity-well/
    • Feature: 2D rubber sheet analogy
    • Feature: Orbital mechanics demo
    • Feature: Escape velocity visual
    • Feature: Black hole well
    • Acceptance: Gravity visualized
  • 21.9.2.5 [Medium/M] Create light speed demonstration

    • File: apps/nyx/education/demos/light-speed/
    • Feature: Earth-Moon light travel
    • Feature: Sun-Earth (8 minutes)
    • Feature: Light-year visualization
    • Feature: Lookback time concept
    • Acceptance: Speed of light intuitive

21.9.3 Quizzes & Assessments#

  • 21.9.3.1 [Medium/M] Create quiz system

    • File: libs/nyx/education/quiz-system/
    • Question types: Multiple choice
    • Question types: Image identification
    • Question types: Drag and drop
    • Question types: Interactive challenges
    • Implement: Scoring and feedback
    • Acceptance: Quiz system functional
  • 21.9.3.2 [Medium/M] Create star identification challenge

    • File: apps/nyx/education/challenges/star-identification.ts
    • Challenge: Name the constellation
    • Challenge: Identify the star
    • Challenge: Point to coordinates
    • Challenge: Timed challenges
    • Acceptance: Star ID challenge works
  • 21.9.3.3 [Medium/M] Create orbital mechanics challenge ✅

    • File: apps/nyx/education/challenges/orbital-mechanics/src/index.ts
    • Challenge: Plot orbit from elements
    • Challenge: Predict conjunction
    • Challenge: Calculate escape velocity
    • Acceptance: Orbital challenges work

21.10 Real-Time Astronomical Data#

21.10.1 Satellite Tracking#

  • 21.10.1.1 [High/L] Integrate TLE/NORAD satellite data ✅

    • File: libs/nyx/realtime/satellites/tle.ts
    • Data: Celestrak TLE feeds
    • Data: Space-track.org API
    • Implement: TLE parsing (SGP4/SDP4)
    • Implement: Position propagation
    • Acceptance: Satellite positions accurate
    • Completed: Created @nyx/realtime-satellites library with:
      • Full TLE parsing with checksum validation
      • SGP4/SDP4 orbit propagation for near/deep space satellites
      • Coordinate transformations (TEME→ECI→ECEF→geodetic→topocentric)
      • Celestrak and Space-Track.org API clients
      • Pass prediction and ground track calculation
      • Comprehensive test suite (40 tests passing)
  • 21.10.1.2 [High/M] Create satellite tracking interface ✅

    • File: apps/nyx/star-map/src/satellites/tracker.ts
    • Display: Real-time satellite positions
    • Display: Orbital paths
    • Display: Ground tracks
    • Feature: Filter by type (ISS, Starlink, etc.)
    • Feature: Pass predictions
    • Acceptance: Satellites trackable
    • Implementation Complete:
      • tracker.ts: Core SatelliteTracker class (~1900 lines)
        • TLE parsing and simplified SGP4-like orbit propagation
        • Coordinate transformations (ECI→ECEF→geodetic→topocentric)
        • Multi-source TLE loading (Celestrak API integration)
        • Real-time position updates with configurable intervals
        • Pass prediction with visibility calculations (sunrise/sunset)
        • Ground track generation with segment handling
        • Event-driven architecture for UI updates
        • Category-based styling system (ISS, Starlink, weather, etc.)
      • index.ts: Module exports
      • useSatelliteTracker.ts: React hook for tracker state management
      • useSatellitePositions.ts: Optimized positions hook for Three.js
      • SatellitePoints.tsx: Instanced point rendering with custom shaders
      • SatelliteOrbitPath.tsx: 3D orbital path visualization
      • SatelliteGroundTrack.tsx: Ground track with footprint and nadir marker
      • All files pass lint (0 errors) and TypeScript type check
  • 21.10.1.3 [High/M] Implement ISS tracking ✅

    • File: apps/nyx/star-map/src/satellites/iss.ts
    • Display: Real-time ISS position
    • Display: Next pass for location
    • Display: Crew information
    • Display: Live video feed link
    • Acceptance: ISS fully tracked
    • Implementation Complete:
      • iss.ts: Comprehensive ISSTracker class (~1050 lines)
        • Real-time ISS position tracking via satellite tracker
        • Pass prediction for any observer location
        • Crew roster fetching from Open Notify API
        • NASA video feed links (HDEV, NASA TV, ESA Columbus)
        • Orbital information (altitude, velocity, period, orbit count)
        • Visibility calculations (elevation, azimuth, magnitude)
        • Pass start/end event alerts
        • Human-readable location descriptions
        • Integration with existing satellite tracking system
      • useISSTracker.ts: React hooks for ISS tracking
        • useISSTracker: Main hook with full status management
        • useISSVisibility: Observer visibility information
        • useISSCrew: Crew roster with refresh capability
        • useISSPasses: Pass predictions for location
        • useISSOrbital: Orbital parameters and position
      • ISS constants: Dimensions, NORAD ID, orbital parameters
      • Video feed metadata: URLs, embed links, descriptions
      • All files pass lint (0 errors) and TypeScript type check
  • 21.10.1.4 [Medium/M] Implement Starlink constellation view ✅

    • File: apps/nyx/star-map/src/satellites/starlink.ts
    • Display: All Starlink satellites
    • Display: Train visualization
    • Display: Coverage map
    • Display: Launch batches
    • Acceptance: Starlink visualized
    • Implementation Complete:
      • starlink.ts: Comprehensive StarlinkTracker class (~1100 lines)
        • All Starlink satellite loading from Celestrak
        • Train formation identification (recently launched satellites)
        • Orbital shell assignment (Shell 1-5)
        • Launch batch grouping and tracking
        • Coverage map generation with configurable grid
        • Satellite status detection (operational/raising/deorbiting)
        • Version identification (v1.0, v1.5, v2 Mini)
        • Train visibility alerts
        • Shell statistics and completion tracking
      • useStarlinkTracker.ts: React hooks
        • useStarlinkTracker: Main constellation status
        • useStarlinkTrains: Train tracking and alerts
        • useStarlinkBatches: Launch batch history
        • useStarlinkShells: Orbital shell statistics
        • useStarlinkCoverage: Coverage map generation
        • useStarlinkVisibility: Visible satellite/train tracking
      • Constants: Shell parameters, dimensions, magnitudes
      • All files pass lint (0 errors) and TypeScript type check

21.10.2 Solar Activity Monitoring#

  • 21.10.2.1 [High/M] Integrate solar monitoring data

    • File: libs/nyx/realtime/solar/
    • Data: NOAA Space Weather
    • Data: SDO imagery
    • Data: SOHO data
    • Fields: Sunspot number, Kp index
    • Fields: Solar flare alerts
    • Acceptance: Solar data integrated
    • COMPLETED: @nyx/realtime-solar library created with:
      • types.ts: Comprehensive type definitions with Zod schemas
        • Solar constants (SOLAR_CONSTANTS, ALERT_LEVELS, KP_STORM_LEVELS, FLARE_CLASSES)
        • SDO AIA wavelengths and SOHO instruments
        • Schemas: KpIndex, SolarFlare, CME, SolarWind, ActiveRegion, AuroraForecast
        • Configuration types for NOAA client, imagery client, monitoring service
      • noaa-client.ts: NOAA SWPC API client (~600 lines)
        • Endpoints for Kp, Ap, Dst, F10.7, sunspots, solar wind, flares, CMEs
        • Active regions, alerts, geomagnetic forecast
        • Built-in caching with configurable TTL
        • Retry logic with exponential backoff
      • imagery-client.ts: SDO/SOHO imagery client (~450 lines)
        • SDO AIA images at 10 wavelengths (94-4500 Angstroms)
        • SDO HMI magnetograms and intensitygrams
        • SOHO EIT and LASCO coronagraph images
        • Temperature-based image filtering
      • aurora-forecast.ts: Aurora forecasting (~500 lines)
        • Geomagnetic latitude calculations
        • Kp visibility thresholds by latitude
        • Aurora oval position based on Kp
        • Probability calculations with time-of-day adjustments
        • 16 aurora hotspot locations
      • solar-monitoring-service.ts: Main service (~600 lines)
        • Event-driven architecture with listeners
        • Auto-refresh with configurable interval
        • Alert generation (Kp threshold, flares, aurora)
        • Integration of all clients and forecaster
      • 97 passing tests covering all functionality
      • All files pass lint (0 errors) and TypeScript type check
  • 21.10.2.2 [High/M] Create solar activity dashboard

    • File: apps/nyx/star-map/src/solar/dashboard.ts
    • Display: Current solar imagery
    • Display: Sunspot locations
    • Display: Solar wind speed
    • Display: Aurora forecast
    • Display: CME alerts
    • Acceptance: Solar activity visible
    • COMPLETED: Solar activity dashboard module created with:
      • types.ts: Dashboard-specific type definitions
        • Display modes, settings, and state interfaces
        • Widget display data types (Kp, solar wind, aurora, flares, CMEs)
        • Imagery gallery types
        • Event system types
      • dashboard.ts: Main SolarDashboard class (~900 lines)
        • Integrates with @nyx/realtime-solar library
        • Event-driven architecture with listeners
        • Auto-refresh with configurable interval
        • Display data methods for all widgets:
          • Kp index with history and trend
          • Solar wind speed and Bz direction
          • Aurora probability and viewing recommendations
          • Flare tracking with severity colors
          • CME tracking with arrival predictions
          • Active region risk assessment
          • Alert management with severity levels
        • Imagery gallery with temperature and feature info
        • Observer location for aurora forecasts
        • Aurora hotspots for quick location selection
      • index.ts: Barrel exports with re-exports from @nyx/realtime-solar
      • 48 passing tests covering all functionality
      • All files pass lint (0 errors)
  • 21.10.2.3 [Medium/M] Implement aurora forecast

    • File: apps/nyx/star-map/src/solar/aurora.ts
    • Display: Aurora oval projection
    • Display: Kp index requirements
    • Display: Viewing probability by location
    • Display: Alert system
    • Acceptance: Aurora predictable

21.10.3 Near-Earth Object Monitoring#

  • 21.10.3.1 [High/M] Integrate NASA NEO API

    • File: libs/nyx/realtime/neo/
    • Data: Close approach data
    • Data: Potentially hazardous asteroids
    • Data: Size and velocity
    • Implement: Alert thresholds
    • Acceptance: NEO data live
  • 21.10.3.2 [High/M] Create NEO visualization ✅

    • File: apps/nyx/star-map/src/neo/visualization.ts
    • Display: Approaching NEOs
    • Display: Close approach distances
    • Display: Orbit visualizations
    • Display: Risk indicators
    • Acceptance: NEOs visualized
  • 21.10.3.3 [Medium/M] Implement impact probability display ✅

    • File: apps/nyx/star-map/src/neo/impact.ts
    • Display: Palermo scale rating
    • Display: Torino scale rating
    • Display: Impact energy estimates
    • Display: Historical impacts
    • Acceptance: Risk communicated clearly

21.10.4 Astronomical Event Alerts#

  • 21.10.4.1 [High/M] Create event alert system ✅

    • File: libs/nyx/realtime/events/alerts.ts
    • Alert: Meteor shower peaks
    • Alert: Eclipse visibility
    • Alert: Planetary conjunctions
    • Alert: Comet visibility
    • Alert: ISS passes
    • Acceptance: Alerts triggered
  • 21.10.4.2 [Medium/M] Implement notification system ✅

    • File: apps/nyx/star-map/src/notifications/
    • Channel: In-app notifications
    • Channel: Email alerts
    • Channel: Push notifications
    • Feature: Customizable preferences
    • Acceptance: Users notified
  • 21.10.4.3 [Medium/M] Create tonight's sky feature ✅

    • File: apps/nyx/star-map/src/tonight/
    • Feature: Visible planets
    • Feature: Notable objects up
    • Feature: Meteor shower activity
    • Feature: Moon phase
    • Feature: Best objects to view
    • Acceptance: Tonight's sky summarized

21.11 Consciousness & Mystical Layer#

21.11.1 Overview Effect Experience#

  • 21.11.1.1 [High/L] Create overview effect mode ✅

    • File: apps/nyx/star-map/src/modes/overview-effect/
    • Implement: Earth from space view
    • Implement: Slow rotation
    • Implement: Ambient audio
    • Implement: Inspirational quotes
    • Implement: Breathing guidance integration
    • Acceptance: Overview effect immersive
  • 21.11.1.2 [High/M] Implement cosmic zoom meditation ✅

    • File: apps/nyx/star-map/src/modes/cosmic-zoom/
    • Feature: Zoom from Earth to universe edge
    • Feature: Scale narration
    • Feature: Ambient soundscape
    • Feature: Contemplation pauses
    • Acceptance: Cosmic zoom meditative
  • 21.11.1.3 [Medium/M] Create pale blue dot experience ✅

    • File: apps/nyx/star-map/src/modes/pale-blue-dot/
    • Feature: View Earth from various distances
    • Feature: Carl Sagan's words (complete reflection in 11 segments)
    • Feature: Perspective on cosmic significance
    • Feature: 12 distance waypoints from Earth to Voyager 1 position
    • Feature: 12 cosmic context facts across 6 categories
    • Feature: 5 ambient soundscape themes
    • Feature: 4 experience modes (guided, silent, exploration, educational)
    • Acceptance: Pale blue dot experience moving (106 tests passing)
  • 21.11.1.4 [Medium/M] Implement "you are here" markers ✅

    • File: apps/nyx/star-map/src/overlays/you-are-here.ts
    • Display: Position in solar system
    • Display: Position in Milky Way
    • Display: Position in Local Group
    • Display: Position in observable universe
    • Feature: 8 cosmic scale levels from Earth to Observable Universe
    • Feature: Interactive scale navigation with zoom in/out
    • Feature: Facts display with auto-rotation at each scale
    • Feature: Multiple address display formats (full, compact, hierarchical)
    • Feature: YouAreHereManager class with full event system
    • Acceptance: Cosmic address shown (134 tests passing)

21.11.2 Lilith Integration#

  • 21.11.2.1 [High/M] Create Lilith consciousness bridge ✅

    • File: libs/nyx/lilith-integration/
    • Implement: Shared meditation experiences (8 cosmic visualizations)
    • Implement: Cosmic awareness exercises (6 expansion exercises)
    • Implement: Inner/outer space parallels (8 parallels)
    • Implement: Consciousness expansion sessions (5 breath patterns)
    • Feature: LilithBridgeManager class for guiding sessions
    • Acceptance: Lilith integration seamless (79 tests passing)
  • 21.11.2.2 [Medium/M] Implement guided cosmic meditation

    • File: apps/nyx/star-map/src/meditation/guided.ts
    • Session: Stellar contemplation
    • Session: Galaxy breathing
    • Session: Cosmic oneness
    • Session: Time and eternity
    • Integration: Lilith voice guidance
    • Acceptance: Meditations available (66 tests passing)
  • 21.11.2.3 [Medium/M] Create consciousness journaling

    • File: apps/nyx/star-map/src/journal/
    • Feature: Log cosmic experiences
    • Feature: Connect sky events to inner states
    • Feature: Track contemplation sessions
    • Feature: Share insights (optional)
    • Acceptance: Journaling functional (110 tests passing)

21.11.3 Sacred Geometry & Patterns#

  • 21.11.3.1 [Medium/M] Implement sacred geometry overlays

    • File: apps/nyx/star-map/src/overlays/sacred-geometry.ts
    • Pattern: Fibonacci spirals in galaxies
    • Pattern: Golden ratio in planetary spacing
    • Pattern: Platonic solids in orbits
    • Pattern: Flower of life overlay
    • Acceptance: Sacred geometry visible (108 tests passing)
  • 21.11.3.2 [Medium/M] Create cosmic synchronicity view

    • File: apps/nyx/star-map/src/modes/synchronicity/
    • Feature: Planetary alignments
    • Feature: Astrological transits (optional)
    • Feature: Eclipse patterns
    • Feature: Saros cycles visualization
    • Acceptance: Cycles and patterns shown
  • 21.11.3.3 [Low/M] Implement astrological overlay (optional) ✅

    • File: apps/nyx/star-map/src/overlays/astrology.ts
    • Display: Zodiac constellations ✅
    • Display: Planet positions in signs ✅
    • Display: Aspects and angles ✅
    • Note: Toggle on/off, clearly labeled as cultural ✅
    • Acceptance: Astrology overlay available ✅
    • Implemented: AstrologyOverlayManager with tropical/sidereal systems, zodiac boundaries, planet positions, aspect calculations, event system, and comprehensive styling options

21.11.4 Cosmic Soundscapes#

  • 21.11.4.1 [High/M] Create cosmic ambient audio system

    • File: libs/nyx/audio/ambient/
    • Implement: Spatial audio engine
    • Implement: Distance-based volume
    • Implement: Direction-based panning
    • Implement: Layered soundscapes
    • Acceptance: Audio system functional
  • 21.11.4.2 [High/M] Implement stellar sonification

    • File: libs/nyx/audio/sonification/
    • Implement: Star brightness to pitch
    • Implement: Spectral type to timbre
    • Implement: Distance to reverb
    • Implement: Variable star rhythms
    • Acceptance: Stars audible
  • 21.11.4.3 [Medium/M] Create cosmic soundscape presets

    • File: apps/nyx/star-map/src/audio/presets.ts
    • Preset: Deep space ambient
    • Preset: Solar system orchestral
    • Preset: Nebula drones
    • Preset: Pulsar rhythms
    • Preset: Black hole bass
    • Acceptance: Soundscapes selectable
  • 21.11.4.4 [Medium/M] Integrate meditation music

    • File: apps/nyx/star-map/src/audio/meditation.ts
    • Track: Cosmic binaural beats
    • Track: Space ambient compositions
    • Track: Guided meditation backgrounds
    • Integration: Lilith audio system
    • Acceptance: Meditation audio available

21.12 VR/AR Immersive Experiences#

21.12.1 WebXR Planetarium#

  • 21.12.1.1 [High/L] Create WebXR planetarium mode

    • File: apps/nyx/vr-planetarium/
    • Implement: WebXR session management
    • Implement: 360° star dome rendering
    • Implement: VR controller navigation
    • Implement: Seated/standing modes
    • Acceptance: VR planetarium functional
  • 21.12.1.2 [High/M] Implement VR star selection ✅

    • File: apps/nyx/vr-planetarium/src/interaction/selection.ts
    • Implement: Gaze-based selection ✅
    • Implement: Controller pointer ✅
    • Implement: Info panel in VR space ✅
    • Implement: Object highlighting ✅
    • Acceptance: VR selection works ✅
  • 21.12.1.3 [High/M] Implement VR scale navigation ✅

    • File: apps/nyx/vr-planetarium/src/navigation/scale.ts ✅
    • Implement: Shrink to solar system scale ✅
    • Implement: Grow to walk on planets ✅
    • Implement: Teleportation locomotion ✅
    • Implement: Smooth transitions ✅
    • Acceptance: VR scale navigation works ✅
  • 21.12.1.4 [Medium/M] Create VR tours ✅

    • File: apps/nyx/vr-planetarium/src/tours/ ✅
    • Tour: Grand tour of solar system ✅
    • Tour: Journey to the stars ✅
    • Tour: Milky Way overview ✅
    • Tour: Edge of observable universe ✅
    • Feature: Narration and guidance ✅
    • Acceptance: VR tours available ✅

21.12.2 AR Sky Identification#

  • 21.12.2.1 [High/L] Create AR sky map app

    • File: apps/nyx/ar-sky/
    • Implement: Camera feed integration ✅
    • Implement: Device orientation tracking ✅
    • Implement: Star overlay rendering ✅
    • Implement: Object identification ✅
    • Acceptance: AR sky map works ✅
  • 21.12.2.2 [High/M] Implement AR object labels

    • File: apps/nyx/ar-sky/src/labels/
    • Display: Star names ✅
    • Display: Planet names ✅
    • Display: Constellation outlines ✅
    • Display: Deep sky object markers ✅
    • Acceptance: Objects labeled in AR ✅
  • 21.12.2.3 [Medium/M] Implement AR compass and grids

    • File: apps/nyx/ar-sky/src/overlays/
    • Display: Cardinal directions ✅
    • Display: Altitude/azimuth grid ✅
    • Display: Celestial equator ✅
    • Display: Ecliptic ✅
    • Acceptance: AR reference overlays work ✅
  • 21.12.2.4 [Medium/M] Create AR observation assistant

    • File: apps/nyx/ar-sky/src/assistant/
    • Feature: Point to object ✅
    • Feature: Voice commands ("Show me Mars") ✅
    • Feature: Tonight's highlights ✅
    • Feature: Telescope alignment helper ✅
    • Acceptance: AR assistant helpful ✅

21.12.3 Mobile Experiences#

  • 21.12.3.1 [High/L] Create mobile star map app

    • File: apps/nyx/mobile/
    • Platform: React Native or PWA
    • Feature: Gyroscope-based sky pointing
    • Feature: Offline star catalog
    • Feature: Notifications for events
    • Acceptance: Mobile app functional
    • COMPLETED: PWA with canvas renderer, device orientation/compass APIs, embedded star catalog, React/Zustand, service worker
  • 21.12.3.2 [High/M] Implement offline capabilities

    • File: apps/nyx/mobile/src/offline/
    • Cache: Bright star catalog
    • Cache: Solar system data
    • Cache: User bookmarks
    • Feature: Sync when online
    • Acceptance: Works without internet
    • COMPLETED: IndexedDB storage, comprehensive solar system catalog (planets, moons, orbital elements), sync manager
  • 21.12.3.3 [Medium/M] Implement mobile widget

    • File: apps/nyx/mobile/src/widget/
    • Widget: Moon phase
    • Widget: Tonight's planets
    • Widget: ISS pass countdown
    • Widget: Event alerts
    • Acceptance: Widget displays on home screen
    • COMPLETED: MoonPhaseWidget, PlanetsTonightWidget, ISSPassWidget, EventAlertsWidget, WidgetPage

21.13 Constellation & Mythology#

21.13.1 Multi-Cultural Constellations#

  • 21.13.1.1 [High/L] Create constellation database ✅

    • File: libs/nyx/constellations/database.ts
    • Culture: IAU official (88 constellations)
    • Culture: Chinese (Three Enclosures, 28 Mansions)
    • Culture: Egyptian
    • Culture: Polynesian
    • Culture: Norse
    • Culture: Indigenous American
    • Acceptance: Multi-cultural constellations stored
  • 21.13.1.2 [High/M] Implement constellation artwork ✅

    • File: libs/nyx/constellations/artwork/
    • Art: Classical constellation illustrations
    • Art: Modern minimalist line art
    • Art: Historical star atlas images
    • Implement: Overlay on star field
    • Acceptance: Constellation art displayable
  • 21.13.1.3 [High/M] Create constellation selector ✅

    • File: apps/nyx/star-map/src/constellations/selector.ts
    • Feature: Culture toggle
    • Feature: Show/hide boundaries
    • Feature: Show/hide lines
    • Feature: Show/hide art
    • Feature: Highlight selected
    • Acceptance: Constellation display customizable
  • 21.13.1.4 [Medium/M] Implement constellation finder ✅

    • File: apps/nyx/star-map/src/constellations/finder.ts
    • Feature: Search by name
    • Feature: Currently visible filter
    • Feature: Season-based suggestions
    • Feature: Difficulty rating
    • Acceptance: Constellations findable

21.13.2 Star Lore & Mythology#

  • 21.13.2.1 [High/L] Create mythology content database

    • File: libs/nyx/mythology/database.ts
    • Content: Greek/Roman myths
    • Content: Egyptian myths
    • Content: Chinese astronomy lore
    • Content: Indigenous star stories
    • Content: Modern cultural references
    • Acceptance: Rich mythology content stored
  • 21.13.2.2 [High/M] Implement myth viewer

    • File: apps/nyx/star-map/src/mythology/viewer.ts
    • Display: Story text
    • Display: Related constellation
    • Display: Cultural context
    • Display: Illustrations
    • Feature: Audio narration
    • Acceptance: Myths viewable
  • 21.13.2.3 [Medium/M] Create myth-guided tours

    • File: apps/nyx/star-map/src/mythology/tours.ts
    • Tour: Greek hero journey (Perseus, Orion, etc.)
    • Tour: Chinese Four Symbols
    • Tour: Egyptian sky goddess Nut
    • Tour: Polynesian navigation stars
    • Acceptance: Mythological tours available
  • 21.13.2.4 [Medium/M] Implement star name etymology

    • File: apps/nyx/star-map/src/mythology/etymology.ts
    • Display: Origin of star names
    • Display: Multiple cultural names
    • Display: Historical designations
    • Display: Pronunciation guide
    • Acceptance: Name origins shown

21.13.3 Historical Navigation#

  • 21.13.3.1 [Medium/M] Create celestial navigation mode

    • File: apps/nyx/star-map/src/modes/navigation/
    • Feature: Navigation star catalog
    • Feature: Sextant simulation
    • Feature: Latitude determination
    • Feature: Star sight calculation
    • Acceptance: Navigation mode educational
  • 21.13.3.2 [Medium/M] Implement historical voyage recreations

    • File: apps/nyx/star-map/src/modes/navigation/voyages.ts
    • Voyage: Polynesian Pacific navigation (Hawaii to Tahiti)
    • Voyage: Columbus 1492 Atlantic crossing
    • Voyage: Viking Atlantic crossings (Leif Erikson, Erik the Red)
    • Voyage: Zheng He treasure fleet
    • Feature: 5 historical eras with date ranges
    • Feature: 11+ navigation techniques by culture
    • Feature: Era-specific star positions via precession calculation
    • Feature: VoyageManager for simulation playback
    • Tests: 85 comprehensive tests
    • Acceptance: Historical voyages visualized

21.14 Scientific Tools & Analysis#

21.14.1 Observation Planning#

  • 21.14.1.1 [High/L] Create observation planner tool

    • File: apps/nyx/tools/observation-planner/
    • Feature: Object visibility windows with altitude constraints
    • Feature: Moon interference calculation (illumination and separation)
    • Feature: Weather integration interface (WeatherProvider)
    • Feature: Twilight times (civil, nautical, astronomical)
    • Feature: Export to AstroPlanner XML and CSV formats
    • Feature: Air mass calculations (Kasten-Young formula)
    • Feature: Session planning for multiple objects with suggested order
    • Feature: ObservationPlannerManager class with event system
    • Tests: 78 comprehensive tests
    • Acceptance: Observation planning works
  • 21.14.1.2 [High/M] Implement telescope FOV overlay

    • File: apps/nyx/tools/observation-planner/src/fov.ts
    • Feature: Custom FOV settings (telescope aperture, focal length, focal ratio)
    • Feature: Eyepiece simulation (magnification, TFOV from AFOV, exit pupil, field stop calc)
    • Feature: CCD/CMOS frame overlay (horizontal/vertical/diagonal FOV, image scale, pixel scale)
    • Feature: Scale indicator (automatic scale bar sizing in arcsec/arcmin/degrees)
    • Feature: Barlow lens and focal reducer support
    • Feature: Sampling status assessment (optimal, oversampled, undersampled)
    • Feature: Equipment compatibility analysis with recommendations
    • Feature: Common sensor format presets (full-frame, APS-C, M4/3, ASI294MC, QHY268C, etc.)
    • Feature: Common eyepiece type presets (Plössl, Nagler, Ethos, etc.)
    • Feature: FOV comparison utility for different equipment combinations
    • Feature: Target object recommendations by FOV
    • Tests: 90 comprehensive tests covering all calculations and edge cases
    • Acceptance: FOV visualized accurately ✓
  • 21.14.1.3 [Medium/M] Implement finder chart generator

    • File: apps/nyx/tools/observation-planner/src/finder-charts.ts
    • Feature: Generate printable charts with SVG export
    • Feature: Customizable scale (arcsec/arcmin/degrees per cm)
    • Feature: Star magnitude limits with configurable filtering
    • Feature: DSS (Digitized Sky Survey) image background with STScI API integration
    • Feature: Three projection types (gnomonic, stereographic, orthographic)
    • Feature: RA/Dec grid lines with automatic spacing
    • Feature: Celestial equator and ecliptic overlays
    • Feature: Constellation line rendering
    • Feature: Deep sky object rendering (galaxies, nebulae, clusters)
    • Feature: FOV circle and rectangle overlays for eyepiece/CCD visualization
    • Feature: Automatic scale bar generation
    • Feature: Chart rotation and mirroring (for Newtonian views)
    • Feature: Inverted colors option (white on black)
    • Feature: Export to SVG, CSV, and JSON metadata
    • Feature: Preset configurations (overview, finder, detail, astrophotography)
    • Tests: 81 comprehensive tests covering projections, rendering, and exports
    • Acceptance: Finder charts exportable ✓

21.14.2 Astrophotography Tools#

  • 21.14.2.1 [Medium/M] Create astrophotography planner ✅

    • File: apps/nyx/tools/astrophotography/
    • Feature: Object altitude charts - generateAltitudeChart() with configurable intervals
    • Feature: Moon phase calendar - generateMoonPhaseCalendar() with imaging recommendations
    • Feature: Imaging window calculator - calculateImagingWindow() with moon interference
    • Feature: Bortle scale by location - complete BORTLE_SCALE definitions (1-9)
    • Feature: getLightPollutionInfo() and estimateBortleFromSQM() utilities
    • Feature: Julian Date/sidereal time calculations for precise timing
    • Feature: Sun/Moon position calculations with altitude/azimuth
    • Feature: Twilight times (civil, nautical, astronomical)
    • Feature: Air mass calculations using Kasten & Young formula
    • Feature: Equipment FOV and exposure calculations
    • Feature: Complete session planning with createImagingSessionPlan()
    • Tests: 72 comprehensive tests
    • Acceptance: Astrophotography planning works ✓
  • 21.14.2.2 [Medium/M] Implement imaging calculator ✅

    • File: apps/nyx/tools/astrophotography/src/calculator.ts
    • Calculate: Field of view from sensor + focal length - calculateFOV()
    • Calculate: Image scale (arcsec/pixel) - calculateImageScale()
    • Calculate: Required exposure - calculateExposure() (from planner)
    • Calculate: Tracking limits - comprehensive tracking analysis:
      • 500 Rule: calculate500RuleExposure()
      • NPF Rule: calculateNPFRuleExposure() (accounts for sensor, optics, declination)
      • Polar drift: calculatePolarDriftRate(), calculateUnguidedExposure()
      • Guiding limits: calculateGuidedExposure()
      • Complete analysis: calculateTrackingLimits()
    • Bonus: Sampling assessment with assessSampling() (under/well/oversampled)
    • Bonus: Resolution calculations (Dawes limit, Rayleigh, Airy disk)
    • Bonus: Complete system analysis with analyzeImagingSystem()
    • Bonus: Framing utilities for target planning
    • Tests: 71 comprehensive tests
    • Acceptance: Imaging calculations accurate ✓
  • 21.14.2.3 [Medium/M] Create target suggestion engine

    • File: apps/nyx/tools/astrophotography/src/targets.ts
    • Feature: 45+ curated astrophotography targets covering all seasons
    • Feature: Best targets for season with getCurrentSeason() and scoring
    • Feature: Filter by object type with getTargetsByType()
    • Feature: Difficulty rating (5 levels: Beginner to Expert)
    • Feature: Sample image URLs and notable features for each target
    • Bonus: Intelligent scoring system based on season, Bortle class, equipment FOV, altitude
    • Bonus: Visibility calculations with calculateMidnightAltitude() and calculateImagingWindowHours()
    • Bonus: Search by name/constellation with searchTargets()
    • Bonus: Equipment matching with getTargetsForEquipment()
    • Bonus: Beginner-friendly suggestions with getBeginnerTargets()
    • Bonus: Recommendation reasons and warnings for each target
    • Tests: 56 comprehensive tests
    • Acceptance: Target suggestions helpful ✓

21.14.3 Scientific Analysis Tools#

  • 21.14.3.1 [Medium/L] Create spectral analysis tool

    • File: apps/nyx/education/demos/spectroscopy/ (implemented as @nyx/spectroscopy)
    • Feature: Display star spectra - example spectra (sun-like, hot star, cool star, nebula)
    • Feature: Element identification - spectral lines with element lookups, H/He/Na/Ca/Mg/Fe/O/N
    • Feature: Radial velocity calculation - measureDoppler(), velocityFromShift(), binary star velocities
    • Feature: Compare spectra - state management for comparison spectra overlays
    • Bonus: Blackbody radiation (Planck function, Wien's law, temperature fitting)
    • Bonus: Spectral classification (OBAFGKM classes with characteristics)
    • Bonus: Rotational broadening calculations
    • Bonus: Wavelength/frequency/energy conversions
    • Tests: Comprehensive test suite
    • Acceptance: Spectral analysis functional ✓
  • 21.14.3.2 [Medium/M] Create light curve viewer

    • File: apps/nyx/tools/light-curves/
    • Feature: Plot variable star data (observations with stats)
    • Feature: Period determination (Lomb-Scargle, PDM, String-Length methods)
    • Feature: Phase folding with foldLightCurve() and binning
    • Feature: AAVSO data integration (parse Extended/Visual formats, export)
    • Bonus: Fourier series fitting for light curve modeling
    • Bonus: Statistical analysis (mean, median, std dev, outlier removal)
    • Bonus: Nyquist frequency calculation
    • Bonus: Period refinement and secondary peak detection
    • Bonus: JD/date conversion utilities
    • Tests: 50 comprehensive tests
    • Acceptance: Light curves viewable ✓
  • 21.14.3.3 [Medium/M] Create orbit determination tool ✓

    • File: apps/nyx/tools/orbit-determination/
    • Feature: Input observations ✓ (MPC 80-column format parser, RA/Dec input helpers)
    • Feature: Calculate orbital elements ✓ (Gauss, Laplace, Double-r, Gooding, Herrick-Gibbs methods)
    • Feature: Uncertainty estimation ✓ (Monte Carlo, covariance analysis, differential correction)
    • Feature: JPL comparison ✓ (Reference orbits for Ceres, Vesta, Pallas, Halley, Eros)
    • Implementation: ~2300 lines comprehensive IOD library
    • Tests: 72 comprehensive tests
    • Acceptance: Orbits determinable ✓

21.15 API & Integration#

21.15.1 REST API#

  • 21.15.1.1 [High/L] Create Nyx REST API

    • File: apps/nyx/api/
    • Endpoint: GET /objects/:id
    • Endpoint: GET /search
    • Endpoint: GET /ephemeris
    • Endpoint: GET /events
    • Endpoint: GET /satellites
    • Implement: Rate limiting
    • Implement: API key authentication
    • Acceptance: REST API functional
  • 21.15.1.2 [High/M] Create API documentation

    • File: libs/openapi/nyx/
    • Document: All endpoints
    • Document: Request/response schemas
    • Document: Authentication
    • Document: Rate limits
    • Generate: OpenAPI spec
    • Acceptance: API documented
  • 21.15.1.3 [Medium/M] Create API client library

    • File: libs/nyx/client/
    • Implement: TypeScript client
    • Implement: Python client
    • Implement: Request helpers
    • Implement: Type-safe responses
    • Acceptance: Client libraries available

21.15.2 WebSocket Real-Time#

  • 21.15.2.1 [High/M] Create WebSocket API

    • File: apps/nyx/api/src/websocket/
    • Event: Object position updates
    • Event: Satellite positions
    • Event: Alert notifications
    • Event: Time synchronization
    • Acceptance: WebSocket API functional
  • 21.15.2.2 [Medium/M] Implement subscription system

    • File: apps/nyx/api/src/websocket/subscriptions.ts
    • Subscribe: Object tracking
    • Subscribe: Event alerts
    • Subscribe: Satellite passes
    • Feature: Customizable update frequency
    • Acceptance: Subscriptions work

21.15.3 Embeddable Widgets#

  • 21.15.3.1 [Medium/M] Create embeddable star map widget

    • File: libs/nyx/widgets/star-map/
    • Feature: Configurable view
    • Feature: Object highlighting
    • Feature: Interactive or static
    • Feature: Responsive sizing
    • Acceptance: Widget embeddable
  • 21.15.3.2 [Medium/M] Create moon phase widget

    • File: libs/nyx/widgets/moon-phase/
    • Display: Current moon phase
    • Display: Phase name
    • Display: Illumination percentage
    • Feature: Size variants
    • Acceptance: Moon widget embeddable
  • 21.15.3.3 [Medium/M] Create ISS tracker widget

    • File: libs/nyx/widgets/iss-tracker/
    • Display: Current ISS position
    • Display: Next pass for location
    • Display: Mini map view
    • Acceptance: ISS widget embeddable

21.15.4 Third-Party Integrations#

  • 21.15.4.1 [Medium/M] Create Stellarium export ✅

    • File: libs/nyx/integrations/stellarium/ ✅
    • Feature: Export bookmarks ✅
    • Feature: Export custom catalogs ✅
    • Feature: Export observation lists ✅
    • Acceptance: Stellarium integration works ✅
    • Implemented: Full export/import with bookmarks, observing lists, DSO catalogs, textures, coordinate utilities, and Zod validation schemas
  • 21.15.4.2 [Medium/M] Create telescope control interface ✅

    • File: libs/nyx/integrations/telescope/ ✅
    • Protocol: ASCOM Alpaca ✅
    • Protocol: INDI ✅
    • Feature: GoTo commands ✅
    • Feature: Object sync ✅
    • Acceptance: Telescope control possible ✅
    • Implemented: AlpacaTelescopeController, INDITelescopeController with slewToCoordinates, tracking control, park/unpark, pulse guiding
  • 21.15.4.3 [Low/M] Create planetarium software bridge ✅

    • File: libs/nyx/integrations/planetarium/ ✅
    • Support: Cartes du Ciel ✅
    • Support: TheSkyX ✅
    • Support: SkySafari ✅
    • Feature: Position sync ✅
    • Acceptance: Planetarium bridge works ✅
    • Implemented: WebSocket bridges for all three platforms with position push/pull, FOV control, and event callbacks

21.16 Testing & Quality Assurance#

21.16.1 Unit Testing#

  • 21.16.1.1 [High/L] Create coordinate system tests

    • File: libs/nyx/coordinates/*.test.ts
    • Test: All coordinate transformations
    • Test: Edge cases (poles, wrap-around)
    • Test: Precision requirements
    • Validate: Against SOFA/ERFA
    • Acceptance: Coordinate tests pass
  • 21.16.1.2 [High/L] Create orbital mechanics tests

    • File: libs/nyx/orbital/*.test.ts
    • Test: Kepler solver accuracy
    • Test: Propagation precision
    • Test: Eclipse prediction
    • Validate: Against JPL Horizons
    • Acceptance: Orbital tests pass
  • 21.16.1.3 [High/M] Create ephemeris tests

    • File: libs/nyx/ephemeris/*.test.ts
    • Test: Planet positions
    • Test: Moon positions
    • Test: Rise/set times
    • Validate: Against USNO data
    • Acceptance: Ephemeris tests pass
  • 21.16.1.4 [Medium/M] Create visualization tests

    • File: libs/nyx/renderer/*.test.ts
    • Test: Color calculations
    • Test: Magnitude to size
    • Test: Coordinate rendering
    • Acceptance: Visual tests pass

21.16.2 Integration Testing#

  • 21.16.2.1 [High/M] Create catalog integration tests

    • File: libs/nyx/catalogs/*.integration.test.ts
    • Test: Gaia DR3 queries
    • Test: Exoplanet queries
    • Test: Cross-catalog matching
    • Test: Performance benchmarks
    • Acceptance: Catalog tests pass
  • 21.16.2.2 [High/M] Create API integration tests

    • File: apps/nyx/api/*.integration.test.ts
    • Test: All REST endpoints
    • Test: WebSocket connections
    • Test: Authentication
    • Test: Rate limiting
    • Acceptance: API tests pass
  • 21.16.2.3 [Medium/M] Create real-time data tests

    • File: libs/nyx/realtime/*.integration.test.ts
    • Test: TLE parsing
    • Test: Solar data fetch
    • Test: NEO data fetch
    • Test: Data freshness
    • Acceptance: Real-time tests pass

21.16.3 Visual Regression Testing#

  • 21.16.3.1 [High/M] Create visual regression suite

    • File: apps/nyx/star-map/*.visual.test.ts
    • Test: Star field rendering
    • Test: Planet rendering
    • Test: UI components
    • Tool: Percy or Chromatic
    • Acceptance: Visual regression catches changes
  • 21.16.3.2 [Medium/M] Create cross-browser tests

    • File: apps/nyx/star-map/*.browser.test.ts
    • Browser: Chrome
    • Browser: Firefox
    • Browser: Safari
    • Browser: Mobile browsers
    • Acceptance: Cross-browser compatibility

21.16.4 Performance Testing#

  • 21.16.4.1 [High/M] Create rendering performance tests

    • File: apps/nyx/star-map/*.perf.test.ts
    • Metric: FPS with 1M stars
    • Metric: Load time
    • Metric: Memory usage
    • Metric: GPU utilization
    • Acceptance: Performance meets targets
  • 21.16.4.2 [Medium/M] Create API performance tests

    • File: apps/nyx/api/*.perf.test.ts
    • Metric: Response time
    • Metric: Throughput
    • Metric: Concurrent connections
    • Acceptance: API performs under load

21.17 Documentation & Deployment#

21.17.1 Documentation#

  • 21.17.1.1 [High/M] Create Nyx domain documentation

    • File: docs/domains/nyx/README.md
    • Content: Architecture overview
    • Content: Getting started guide
    • Content: Development setup
    • Acceptance: Domain documented
  • 21.17.1.2 [High/M] Create astronomical accuracy documentation

    • File: docs/domains/nyx/accuracy.md
    • Content: Precision standards
    • Content: Data sources
    • Content: Validation methodology
    • Content: Known limitations
    • Acceptance: Accuracy documented
  • 21.17.1.3 [High/M] Create user guide

    • File: docs/domains/nyx/user-guide/
    • Guide: Star map navigation
    • Guide: Search and discovery
    • Guide: Educational features
    • Guide: VR/AR usage
    • Acceptance: User guide complete
  • 21.17.1.4 [Medium/M] Create API guide

    • File: docs/domains/nyx/api/
    • Guide: REST API usage
    • Guide: WebSocket integration
    • Guide: Widget embedding
    • Guide: Authentication
    • Acceptance: API guide complete

21.17.2 Deployment#

  • 21.17.2.1 [High/M] Create deployment configuration

    • File: apps/nyx/*/Dockerfile
    • Config: Docker images
    • Config: Kubernetes manifests
    • Config: Environment variables
    • Acceptance: Deployment configs ready
  • 21.17.2.2 [High/M] Configure CDN for static assets

    • Config: Star texture tiles
    • Config: Planet textures
    • Config: Nebula images
    • Config: Cache policies
    • Acceptance: CDN configured
  • 21.17.2.3 [Medium/M] Create data pipeline deployment

    • Config: Catalog ingestion jobs
    • Config: Real-time data feeds
    • Config: Data update schedules
    • Acceptance: Data pipelines deployed
  • 21.17.2.4 [Medium/M] Update RESPONSIBILITY_SPLIT_RECOMMENDATION.md

    • Add: Nyx domain responsibilities
    • Add: Integration with Lilith
    • Add: Data ownership
    • Acceptance: Recommendation doc updated

Phase 21 Summary Statistics#

Section Task Count
21.1 Nyx Domain Infrastructure & Architecture 13
21.2 Astronomical Data Infrastructure 30
21.3 Coordinate Systems & Calculations 14
21.4 Orbital Mechanics Engine 18
21.5 3D Visualization Engine 30
21.6 Interactive Star Map Application 23
21.7 Orrery & Solar System Explorer 11
21.8 Time Travel & Historical Astronomy 9
21.9 Educational Platform 14
21.10 Real-Time Astronomical Data 13
21.11 Consciousness & Mystical Layer 14
21.12 VR/AR Immersive Experiences 11
21.13 Constellation & Mythology 10
21.14 Scientific Tools & Analysis 9
21.15 API & Integration 11
21.16 Testing & Quality Assurance 11
21.17 Documentation & Deployment 8
TOTAL Phase 21 249

Updated Grand Total#

Phase Task Count
Phase 0-14 (Original) 796
Phase 15: Physical Wellness & Fitness 503
Phase 16: Video-to-Animation Pipeline 346
Phase 17: State-of-the-Art AI Integration 424
Phase 18: Production Readiness Remediation 847
Phase 19: AWS ECS + RunPod Infrastructure 126
Phase 20: Eve/Aphrodite Platform 145
Phase 21: Nyx Cosmic Observatory 249
GRAND TOTAL 3,436