Eve library

Nyx Domain Feature Inventory

Guide

Revision 1

On this page

Generated on May 8, 2026. This document captures domain feature scope from the Oshun repository and the phase checklist in TODOS.md.

Overview#

Nyx is a Cosmic Observatory Platform that combines interactive star mapping, high-precision celestial calculations, VR planetarium experiences, AR sky identification, telescope control, astrophotography tools, and educational features into a complete astronomy ecosystem. This document describes every user-facing feature from the perspective of stargazers, educators, astrophotographers, and telescope operators.

Coverage Summary#

  • Domain slug: nyx
  • TODO phase coverage: 21
  • Checklist-derived feature items: 249
  • Repository status: Repository implementation exists under apps/libs/services.
  • Oshun integration status: Dedicated Oshun domain adapter library present.
  • Source confidence: Implementation-backed and documentation-backed

Source Hierarchy#

  1. Actual implementation footprints in apps/, libs/, services/, and openapi/
  2. TODO-derived capability scope from the mapped phase sections
  3. Existing standalone domain docs in docs/domains/nyx/

Capability Pillars#

Capability Pillar Primary Source Status
Platform Access docs/domains/nyx/features.md implementation-backed
Interactive Star Map docs/domains/nyx/features.md implementation-backed
Celestial Object Database docs/domains/nyx/features.md implementation-backed
Ephemeris and Position Calculations docs/domains/nyx/features.md implementation-backed
Astronomical Events docs/domains/nyx/features.md implementation-backed
Observation Planning docs/domains/nyx/features.md implementation-backed
Telescope Control docs/domains/nyx/features.md implementation-backed
Astrophotography docs/domains/nyx/features.md implementation-backed
VR Planetarium docs/domains/nyx/features.md implementation-backed
AR Sky Identification docs/domains/nyx/features.md implementation-backed
Educational Features docs/domains/nyx/features.md implementation-backed
Constellation Mythology docs/domains/nyx/features.md implementation-backed
Solar System Explorer docs/domains/nyx/features.md implementation-backed
Satellite Tracking docs/domains/nyx/features.md implementation-backed
Time Travel docs/domains/nyx/features.md implementation-backed
Social and Community docs/domains/nyx/features.md implementation-backed
Gamification docs/domains/nyx/features.md implementation-backed
Search and Discovery docs/domains/nyx/features.md implementation-backed
Audio and Narration docs/domains/nyx/features.md implementation-backed
Offline and Cross-Platform docs/domains/nyx/features.md implementation-backed
Data Catalogs and Sources docs/domains/nyx/features.md implementation-backed
Developer and API Access docs/domains/nyx/features.md implementation-backed
Lilith Integration docs/domains/nyx/features.md implementation-backed
Domain Setup TODOS.md phase 21 planned-or-partially-implemented
Database Schema Design TODOS.md phase 21 planned-or-partially-implemented
Core Services Architecture TODOS.md phase 21 planned-or-partially-implemented
Star Catalog Integration TODOS.md phase 21 planned-or-partially-implemented
Exoplanet Database TODOS.md phase 21 planned-or-partially-implemented
Galaxy Catalogs TODOS.md phase 21 planned-or-partially-implemented
Solar System Data TODOS.md phase 21 planned-or-partially-implemented
Deep Sky Objects TODOS.md phase 21 planned-or-partially-implemented
Exotic Objects Database TODOS.md phase 21 planned-or-partially-implemented
Coordinate Transformations TODOS.md phase 21 planned-or-partially-implemented
Time Systems TODOS.md phase 21 planned-or-partially-implemented
Positional Astronomy TODOS.md phase 21 planned-or-partially-implemented
Kepler Solver TODOS.md phase 21 planned-or-partially-implemented
N-Body Simulation TODOS.md phase 21 planned-or-partially-implemented
Eclipse & Event Prediction TODOS.md phase 21 planned-or-partially-implemented
Ephemeris Generation TODOS.md phase 21 planned-or-partially-implemented
WebGPU/WebGL Renderer TODOS.md phase 21 planned-or-partially-implemented
Star Rendering TODOS.md phase 21 planned-or-partially-implemented
Planet Rendering TODOS.md phase 21 planned-or-partially-implemented
Galaxy Rendering TODOS.md phase 21 planned-or-partially-implemented
Nebulae & Deep Sky Rendering TODOS.md phase 21 planned-or-partially-implemented
Special Relativistic Effects TODOS.md phase 21 planned-or-partially-implemented
Background & Skybox TODOS.md phase 21 planned-or-partially-implemented
Core Navigation TODOS.md phase 21 planned-or-partially-implemented
Object Interaction TODOS.md phase 21 planned-or-partially-implemented
Search & Discovery TODOS.md phase 21 planned-or-partially-implemented
Bookmarks & Collections TODOS.md phase 21 planned-or-partially-implemented
Visual Overlays TODOS.md phase 21 planned-or-partially-implemented
Time Controls TODOS.md phase 21 planned-or-partially-implemented
Interactive Orrery TODOS.md phase 21 planned-or-partially-implemented
Spacecraft Tracking TODOS.md phase 21 planned-or-partially-implemented
Eclipse & Transit Visualization TODOS.md phase 21 planned-or-partially-implemented
Historical Sky View TODOS.md phase 21 planned-or-partially-implemented
Future Predictions TODOS.md phase 21 planned-or-partially-implemented
Supernova & Transient Events TODOS.md phase 21 planned-or-partially-implemented
Interactive Lessons TODOS.md phase 21 planned-or-partially-implemented
Interactive Demonstrations TODOS.md phase 21 planned-or-partially-implemented
Quizzes & Assessments TODOS.md phase 21 planned-or-partially-implemented
Solar Activity Monitoring TODOS.md phase 21 planned-or-partially-implemented
Near-Earth Object Monitoring TODOS.md phase 21 planned-or-partially-implemented
Astronomical Event Alerts TODOS.md phase 21 planned-or-partially-implemented
Overview Effect Experience TODOS.md phase 21 planned-or-partially-implemented
Sacred Geometry & Patterns TODOS.md phase 21 planned-or-partially-implemented
Cosmic Soundscapes TODOS.md phase 21 planned-or-partially-implemented
WebXR Planetarium TODOS.md phase 21 planned-or-partially-implemented
Mobile Experiences TODOS.md phase 21 planned-or-partially-implemented
Multi-Cultural Constellations TODOS.md phase 21 planned-or-partially-implemented
Star Lore & Mythology TODOS.md phase 21 planned-or-partially-implemented
Historical Navigation TODOS.md phase 21 planned-or-partially-implemented
Astrophotography Tools TODOS.md phase 21 planned-or-partially-implemented
Scientific Analysis Tools TODOS.md phase 21 planned-or-partially-implemented
REST API TODOS.md phase 21 planned-or-partially-implemented
WebSocket Real-Time TODOS.md phase 21 planned-or-partially-implemented
Embeddable Widgets TODOS.md phase 21 planned-or-partially-implemented
Third-Party Integrations TODOS.md phase 21 planned-or-partially-implemented
Unit Testing TODOS.md phase 21 planned-or-partially-implemented
Integration Testing TODOS.md phase 21 planned-or-partially-implemented
Visual Regression Testing TODOS.md phase 21 planned-or-partially-implemented
Performance Testing TODOS.md phase 21 planned-or-partially-implemented
Documentation TODOS.md phase 21 planned-or-partially-implemented
Deployment TODOS.md phase 21 planned-or-partially-implemented

Implementation-Derived Capability Surfaces#

Category Path Inferred Capability Surface
Application apps/nyx/api/ Api
Application apps/nyx/ar-sky/ Ar Sky
Application apps/nyx/education/ Education
Application apps/nyx/mobile/ Mobile
Application apps/nyx/pipelines/ Pipelines
Application apps/nyx/star-map/ Star Map
Application apps/nyx/tools/ Tools
Application apps/nyx/vr-planetarium/ Vr Planetarium
Library libs/nyx/analysis/ Analysis
Library libs/nyx/api-client/ Api Client
Library libs/nyx/audio/ Audio
Library libs/nyx/catalogs/ Catalogs
Library libs/nyx/client/ Client
Library libs/nyx/client-python/ Client Python
Library libs/nyx/constants/ Constants
Library libs/nyx/constellations/ Constellations
Library libs/nyx/coordinates/ Coordinates
Library libs/nyx/database/ Database
Library libs/nyx/docs/ Docs
Library libs/nyx/education/ Education
Library libs/nyx/ephemeris/ Ephemeris
Library libs/nyx/events/ Events
Library libs/nyx/integrations/ Integrations
Library libs/nyx/lilith-integration/ Lilith Integration
Library libs/nyx/mythology/ Mythology
Library libs/nyx/orbital/ Orbital
Library libs/nyx/positional/ Positional
Library libs/nyx/README.md README.md
Library libs/nyx/realtime/ Realtime
Library libs/nyx/renderer/ Renderer
Library libs/nyx/time/ Time
Library libs/nyx/time-travel/ Time Travel
Library libs/nyx/types/ Types
Library libs/nyx/utils/ Utils
Library libs/nyx/visualization/ Visualization
Library libs/nyx/widgets/ Widgets

Canonical Standalone Feature Coverage#

Heading Level Feature Family
H2 Platform Access
H3 Applications
H3 System Requirements
H2 Interactive Star Map
H3 Navigation
H3 View Modes
H3 Map Projections
H3 Display Layers
H3 Object Interaction
H2 Celestial Object Database
H3 Star Catalogs
H3 Star Data
H3 Deep Sky Object Catalogs
H3 Deep Sky Object Data
H3 Planet and Moon Data
H3 Asteroid and Comet Data
H2 Ephemeris and Position Calculations
H3 Position Calculation
H3 Precision Levels
H3 Coordinate Systems
H3 Time Systems
H2 Astronomical Events
H3 Eclipse Prediction
H3 Planetary Events
H3 Other Events
H2 Observation Planning
H3 Visibility Calculator
H3 Session Planner
H3 Weather Integration
H3 Light Pollution
H2 Telescope Control
H3 Supported Protocols
H3 Mount Control
H3 Autoguiding
H3 Camera Control
H3 Plate Solving
H2 Astrophotography
H3 Imaging Workflow
H3 Image Management
H2 VR Planetarium
H3 VR Features
H3 VR Experiences
H3 Multiplayer VR
H3 Supported VR Headsets
H2 AR Sky Identification
H3 AR Features
H3 AR Supported Devices
H2 Educational Features
H3 Learning Modes
H3 Guided Tours
H3 Interactive Lessons
H2 Constellation Mythology
H3 Mythology Features
H2 Solar System Explorer
H3 3D Solar System
H3 Scale Modes
H3 Planet Information
H2 Satellite Tracking
H3 Satellite Features
H2 Time Travel
H3 Time Control
H2 Social and Community
H3 Community Features
H3 Equipment Management
H2 Gamification
H3 Achievements
H3 Observation Logging
H2 Search and Discovery
H3 Search Features
H2 Audio and Narration
H3 Audio Features
H2 Offline and Cross-Platform
H3 Offline Features
H3 Cross-Platform Sync
H2 Data Catalogs and Sources
H3 Data Provenance
H2 Developer and API Access
H3 REST API
H3 SDK and Client Libraries
H3 Embeddable Widgets
H2 Lilith Integration
H3 Cross-Domain Features

Detailed TODO Phase Coverage#

Phase 21: Nyx Cosmic Observatory & Astronomy Exploration Platform#

  • Checklist items captured: 249
  • Source: TODOS.md

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 33
21.3 Coordinate Systems & Calculations 14
21.4 Orbital Mechanics Engine 17
21.5 3D Visualization Engine 31
21.6 Interactive Star Map Application 24
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 12
21.11 Consciousness & Mystical Layer 13
21.12 VR/AR Immersive Experiences 11
21.13 Constellation & Mythology 10
21.14 Scientific Tools & Analysis 9
21.15 API & Integration 12
21.16 Testing & Quality Assurance 10
21.17 Documentation & Deployment 8
TOTAL Phase 21 251

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 251
GRAND TOTAL 3,438