feat(tahuantinsuyu): fase 3 — engine real contra eternal + rueda pintada en GPUI

Bridge a eternal-astrology prendido por default. `engine::compute(chart)`
abre una EphemerisSession VSOP2013 (cacheada vía OnceLock global),
traduce los Stored* del modelo a BirthData/ChartConfig de eternal,
corre NatalChart::compute + find_aspects(modern_western) y devuelve un
RenderModel con cuatro capas: SignDial, Houses, Bodies, Aspects.

- tahuantinsuyu-engine: bridge.rs nuevo con map_house_system,
  map_zodiac (incl. 8 ayanamshas), map_body_set, body_symbol,
  aspect_kind_id. compute_mock se mantiene como fallback sin feature.
  Errores tipados (EngineError::Eternal). Test real verde con datos
  natales de demo.
- tahuantinsuyu-canvas: rewrite con gpui::canvas() + PathBuilder.
  Pinta: sectores zodiacales coloreados por elemento (Fire/Earth/Air/
  Water), anillos de sign-dial/houses/aspects, cusps zodiacales,
  cusps de casas (con énfasis para Asc/MC/Desc/IC), líneas radiales
  hasta el centro para los ejes, líneas de aspectos coloreadas por
  kind con opacidad por orb, dots de cuerpos.
  Glifos unicode (- signos, ☉-♇ planetas, ☊☋⚷⚸ puntos) como divs
  absolutos sobre el canvas. Marcador ᴿ cuando retrógrado.
  Rotación canónica: Asc a las 9, casas crecen contrarreloj.
- shell: ahora llama engine::compute() real y reporta errores por
  stderr sin caer la app.

Datos sintetizados: ascendente, MC, descendente, IC; 12 cusps de
casa según el sistema configurado; placements de los cuerpos del
BodySet con sus longitudes zodiacales, casa y flag retrógrado;
aspectos mayores con opacidad proporcional al orb.

`cargo check` y `cargo test --features eternal-bridge` verdes.
La fase 4 traerá el panel interactivo (jog-dial, toggles, sliders,
atajos teclado).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
2026-05-16 01:43:11 +00:00
parent bcb92b537e
commit 82fa370877
5 changed files with 1152 additions and 150 deletions
@@ -17,11 +17,10 @@
//!
//! ## Feature `eternal-bridge`
//!
//! - **off** (default): la engine sólo expone los tipos `RenderModel`,
//! `Layer`, `Glyph`, etc. y un `compute_mock()` con un disco de
//! prueba. Útil para la UI antes de que `eternal-astrology` compile.
//! - **on**: agrega `compute(chart) -> RenderModel` con la pipeline
//! real.
//! - **on** (default): [`compute`] abre una `EphemerisSession` VSOP2013
//! compartida y corre la pipeline real.
//! - **off**: [`compute`] cae a [`compute_mock`] — útil para tests +
//! builds sin eternal checked out.
#![forbid(unsafe_code)]
#![warn(rust_2018_idioms)]
@@ -31,41 +30,45 @@ use thiserror::Error;
pub use tahuantinsuyu_model::{Chart, ChartId, ChartKind};
#[cfg(feature = "eternal-bridge")]
mod bridge;
// =====================================================================
// RenderModel — lo que el canvas necesita pintar una capa
// RenderModel — lo que el canvas necesita pintar
// =====================================================================
/// Resultado agnóstico de un cómputo astrológico, listo para renderizar.
/// Cada `Layer` es independiente — el canvas las apila por z-order.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenderModel {
/// Identidad estable de la carta a la que pertenece este render.
pub chart_id: ChartId,
/// Kind original — el canvas lo usa para títulos y ornamentos.
pub chart_kind: ChartKind,
pub title: String,
#[serde(default)]
pub subtitle: Option<String>,
pub compute_ms: u64,
// ─── Ángulos del chart (grados eclípticos, 0..360) ───────────────
/// Ascendente — punto fijo de rotación del lienzo. La rueda se gira
/// de modo que el Asc cae a las 9 (lado izquierdo).
pub ascendant_deg: f32,
pub midheaven_deg: f32,
pub descendant_deg: f32,
pub imum_coeli_deg: f32,
/// Capas a pintar. Orden = z-order ascendente.
pub layers: Vec<Layer>,
/// Texto humano-legible breve. Ej. "Sergio · 14 mar 1987 · Caracas".
pub title: String,
/// Tiempo de cómputo en ms — métrica para diagnóstico.
pub compute_ms: u64,
}
/// Una capa visual. Cada módulo de astrología publica una o varias.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Layer {
/// Identidad estable del módulo emisor ("natal", "transit", "uranian").
pub module_id: String,
/// Tipo de capa — controla cómo se compone con vecinas.
pub kind: LayerKind,
/// Radio normalizado [0, 1] sobre el lienzo. Permite stack de anillos.
/// Radio normalizado [0, 1] sobre el lienzo — el canvas lo convierte
/// a píxeles. Permite stack de anillos.
pub ring: f32,
/// Z-order absoluto (más alto = encima). Default 0.
#[serde(default)]
pub z: i32,
/// Geometría: puntos, arcos, líneas.
pub geometry: Geometry,
/// Glifos simbólicos sobre la geometría (planetas, signos, casas).
#[serde(default)]
pub glyphs: Vec<Glyph>,
}
@@ -73,51 +76,36 @@ pub struct Layer {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LayerKind {
/// El anillo zodiacal de fondo (12 signos).
SignDial,
/// Las 12 cusps de casas + cuadrantes.
Houses,
/// Los planetas / cuerpos en sus posiciones.
Bodies,
/// Líneas de aspecto entre cuerpos.
Aspects,
/// Puntos arábigos / lots.
Lots,
/// Estrellas fijas como overlay.
FixedStars,
/// Puntos medios y simetría Uraniana.
Midpoints,
/// Anillo externo de tránsitos / progresiones / direcciones.
Outer,
/// Geometría libre — usa cuando una capa no encaja en las otras.
Custom,
}
/// Geometría primitiva, agnóstica del renderer.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Geometry {
/// Sólo glifos posicionados — sin trazo de fondo.
GlyphsOnly,
/// Anillo dividido en sectores (zodíaco, casas).
Ring {
/// Divisiones en grados zodiacales [0, 360). El canvas pinta
/// líneas radiales en cada uno.
cusps_deg: Vec<f32>,
},
/// Conjunto de líneas (aspectos). Cada par = `(from_deg, to_deg)`.
/// Anillo dividido en sectores. `cusps_deg` son los grados
/// zodiacales donde van las divisiones radiales.
Ring { cusps_deg: Vec<f32> },
Lines(Vec<LineSeg>),
/// Puntos sueltos con marcadores (lots, fixed stars).
Points(Vec<PointMark>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LineSeg {
/// Grados zodiacales del extremo "a".
pub from_deg: f32,
/// Grados zodiacales del extremo "b".
pub to_deg: f32,
/// Categoría simbólica (conjunction, trine, square…) — el theme
/// resuelve el color.
/// Categoría simbólica (`"conjunction"`, `"trine"`, …) — el theme la
/// resuelve a color.
pub kind: String,
/// Opacidad sugerida [0, 1].
pub opacity: f32,
}
@@ -125,25 +113,20 @@ pub struct LineSeg {
pub struct PointMark {
pub deg: f32,
pub label: String,
/// Tag simbólico para que el theme elija color/glifo.
pub tag: String,
}
/// Glifo dibujable sobre una capa.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Glyph {
/// Posición zodiacal en grados [0, 360).
/// Grado eclíptico [0, 360).
pub deg: f32,
/// Glyph simbólico ("sun","moon","aries",…). El theme lo mapea a
/// imagen o codepoint.
/// Glyph simbólico — el theme/canvas lo mapea a unicode o imagen.
/// Ej: `"sun"`, `"moon"`, `"aries"`, `"asc"`, `"mc"`.
pub symbol: String,
/// Texto secundario (ej. el grado dentro del signo).
#[serde(default)]
pub annotation: Option<String>,
/// `true` si el cuerpo está retrógrado.
#[serde(default)]
pub retrograde: bool,
/// Casa en la que cae (1..=12), si aplica.
#[serde(default)]
pub house: Option<u8>,
}
@@ -158,29 +141,30 @@ pub enum EngineError {
BridgeDisabled,
#[error("model: {0}")]
Model(#[from] tahuantinsuyu_model::ModelError),
#[cfg(feature = "eternal-bridge")]
#[error("eternal: {0}")]
Eternal(String),
#[error("kind {0:?} todavía no implementado")]
UnsupportedKind(ChartKind),
}
// =====================================================================
// API pública
// =====================================================================
/// Computa el RenderModel real contra `eternal-astrology`. Requiere
/// el feature `eternal-bridge`.
#[cfg(feature = "eternal-bridge")]
pub fn compute(_chart: &Chart) -> Result<RenderModel, EngineError> {
// TODO: pipeline real — abrir `EphemerisSession`, traducir
// `StoredBirthData → BirthData`, `StoredChartConfig → ChartConfig`,
// correr `NatalChart::compute`, mapear a `Layer`s. Se cablea en la
// fase 3 del plan.
Err(EngineError::Eternal("pendiente fase 3".into()))
/// Computa el RenderModel real contra eternal-astrology si el feature
/// está prendido; sino cae al mock.
pub fn compute(chart: &Chart) -> Result<RenderModel, EngineError> {
#[cfg(feature = "eternal-bridge")]
{
bridge::compute(chart)
}
#[cfg(not(feature = "eternal-bridge"))]
{
Ok(compute_mock(chart))
}
}
/// Stub que devuelve un disco vacío de placeholder — sirve a la UI
/// mientras la pipeline real no esté cableada. Usar en demos y
/// desarrollo.
/// Stub determinista — útil para tests + para la UI sin eternal.
pub fn compute_mock(chart: &Chart) -> RenderModel {
use std::time::Instant;
let t0 = Instant::now();
@@ -188,7 +172,7 @@ pub fn compute_mock(chart: &Chart) -> RenderModel {
let sign_dial = Layer {
module_id: "natal".into(),
kind: LayerKind::SignDial,
ring: 0.95,
ring: 1.0,
z: 0,
geometry: Geometry::Ring {
cusps_deg: (0..12).map(|i| (i as f32) * 30.0).collect(),
@@ -207,9 +191,14 @@ pub fn compute_mock(chart: &Chart) -> RenderModel {
RenderModel {
chart_id: chart.id,
chart_kind: chart.kind,
layers: vec![sign_dial],
title: chart.label.clone(),
subtitle: chart.birth_data.birthplace_label.clone(),
compute_ms: t0.elapsed().as_millis() as u64,
ascendant_deg: 0.0,
midheaven_deg: 270.0,
descendant_deg: 180.0,
imum_coeli_deg: 90.0,
layers: vec![sign_dial],
}
}
@@ -228,6 +217,10 @@ const ZODIAC_GLYPHS: [&str; 12] = [
"pisces",
];
// =====================================================================
// Tests
// =====================================================================
#[cfg(test)]
mod tests {
use super::*;
@@ -269,4 +262,16 @@ mod tests {
assert!(matches!(model.layers[0].kind, LayerKind::SignDial));
assert_eq!(model.layers[0].glyphs.len(), 12);
}
#[cfg(feature = "eternal-bridge")]
#[test]
fn real_compute_natal_demo() {
let model = compute(&sample_chart()).expect("compute con eternal");
assert!(model.layers.iter().any(|l| matches!(l.kind, LayerKind::SignDial)));
assert!(model.layers.iter().any(|l| matches!(l.kind, LayerKind::Houses)));
assert!(model.layers.iter().any(|l| matches!(l.kind, LayerKind::Bodies)));
// El Asc debe ser un grado válido.
assert!(model.ascendant_deg.is_finite());
assert!((0.0..360.0).contains(&model.ascendant_deg));
}
}