ephemvis 0.1.0__tar.gz

ephemvis-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+
+# Secrets / local env / OS cruft
+.env
+*.local
+.DS_Store
+Thumbs.db

ephemvis-0.1.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to **ephemvis** are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/) and the project uses
+[Semantic Versioning](https://semver.org/).
+
+## [0.1.0] — 2026-07-24
+
+Initial public release — themeable SVG rendering for openephem chart data.
+
+### Rendering
+- `render_svg` — the natal chart wheel: zodiac ring, house cusps & numbers, planet
+  glyphs with radial de-collision + dotted leader lines, and aspect lines.
+- `render_aspect_grid_svg` — the triangular aspectarian: a clean square grid with a
+  themed gradient on the frame and separators.
+- 12 selectable themes, including the **infrared / ultraviolet** spectral pair, each
+  with a per-theme prism-halo sweep.
+- Hover tooltips via SVG `<title>`: body name / sign / degree, aspect significance,
+  sign → house (rising-aware), and Asc / MC.
+
+### Design & quality
+- **Zero runtime dependencies**; engine-agnostic — renders any dict with the
+  openephem `ChartResult` shape. The optional `[compute]` extra pulls openephem so
+  you can compute and render in one line.
+- MIT-licensed.
+- CI gates: pytest + **SVG snapshot tests** (byte-stable across Linux/Windows) +
+  ruff + mypy, on Python 3.10–3.13.
+
+[0.1.0]: https://github.com/NoahChristian/ephemvis/releases/tag/v0.1.0

ephemvis-0.1.0/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2026 Elizabeth Huston, Ph.D. and Noah Christian, Ph.D.
+Contact: elpisastrology@gmail.com · elpisastrology.com and noahchristian@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------------------------------------------------------------------
+This MIT license covers the source code authored in this project. It does NOT
+cover third-party libraries or data the code depends on, which retain their own
+licenses (Skyfield MIT, spiceypy/CSPICE, Moshier public domain, JPL/NASA public
+domain, ESA Hipparcos, OpenStreetMap ODbL, IANA tzdata public domain, etc.).
+See ephemeris-migration/oracle/references.txt for the full third-party notices.
+
+Swiss Ephemeris (pyswisseph, AGPL) is NOT included or distributed in this repo;
+it is used only by the optional offline validation tools, which require the user
+to install it separately. No AGPL code or data is redistributed here.

ephemvis-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: ephemvis
+Version: 0.1.0
+Summary: Themeable SVG chart-wheel & aspect-grid rendering for openephem chart data
+Project-URL: Homepage, https://github.com/NoahChristian/ephemvis
+Project-URL: Repository, https://github.com/NoahChristian/ephemvis
+Project-URL: Changelog, https://github.com/NoahChristian/ephemvis/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/NoahChristian/ephemvis/issues
+Author: Elizabeth Huston, Noah Christian
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aspectarian,astrology,chart wheel,natal chart,openephem,svg,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: >=3.10
+Provides-Extra: compute
+Requires-Dist: openephem>=0.1.0; extra == 'compute'
+Provides-Extra: test
+Requires-Dist: mypy>=1.10; extra == 'test'
+Requires-Dist: pytest>=7; extra == 'test'
+Requires-Dist: ruff>=0.6; extra == 'test'
+Description-Content-Type: text/markdown
+
+# ephemvis
+
+[![CI](https://github.com/NoahChristian/ephemvis/actions/workflows/ci.yml/badge.svg)](https://github.com/NoahChristian/ephemvis/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/ephemvis.svg)](https://pypi.org/project/ephemvis/)
+[![Python](https://img.shields.io/pypi/pyversions/ephemvis.svg)](https://pypi.org/project/ephemvis/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Themeable **SVG rendering** for astrological chart data — the display layer that
+pairs with [openephem](https://github.com/NoahChristian/openephem) (the calculation
+core). ephemvis turns a chart dict into a self-contained chart **wheel** and a
+triangular **aspect grid**.
+
+The split is deliberate: **openephem computes, ephemvis draws.** The math core
+stays small and auditable; the visuals can be forked and restyled freely without
+touching (or destabilising) the calculations.
+
+## Install
+
+```bash
+pip install ephemvis            # pure renderer, zero runtime deps
+pip install ephemvis[compute]   # also pulls openephem to compute charts
+```
+
+## Use
+
+```python
+from openephem import resolve, assemble          # needs ephemvis[compute]
+from ephemvis import render_svg, render_aspect_grid_svg
+
+chart = assemble(resolve(date=(1990, 5, 15), time=(14, 30),
+                         place="New York, NY"))
+open("wheel.svg", "w", encoding="utf-8").write(render_svg(chart, theme="prism"))
+open("grid.svg",  "w", encoding="utf-8").write(render_aspect_grid_svg(chart, theme="prism"))
+```
+
+`render_svg` and `render_aspect_grid_svg` accept any dict with the openephem
+`ChartResult` shape (`angles`, `cusps`, `bodies`, `aspects`), so **any engine that
+emits that shape can be rendered** — ephemvis has no dependency on how the chart
+was computed.
+
+## Themes
+
+`light`, `dark`, `auto`, and eight pastel "pretty" modes with a prism-halo ring:
+`prism`, `twilight`, `aurora`, `opal`, `seafoam`, `meadow`, `dawn`, `blossom`.
+See `ephemvis.PALETTES`.
+
+## The data contract
+
+ephemvis reads the chart dict openephem's `assemble()` returns:
+
+```python
+{
+  "angles": {"asc": float, "mc": float, ...} | None,   # ecliptic longitude, degrees
+  "cusps":  [float] (12) | None,                        # house cusp longitudes
+  "bodies": {name: {"lon": float, "retro": bool}},      # ecliptic longitude, degrees
+  "aspects": [{"a": name, "b": name, "aspect": str, "orb": float}],
+  "warnings": [str],
+}
+```
+
+MIT © 2026 Elizabeth Huston, Ph.D. and Noah Christian, Ph.D.  
+Contact: elpisastrology@gmail.com · elpisastrology.com and noahchristian@gmail.com

ephemvis-0.1.0/README.md

@@ -0,0 +1,62 @@
+# ephemvis
+
+[![CI](https://github.com/NoahChristian/ephemvis/actions/workflows/ci.yml/badge.svg)](https://github.com/NoahChristian/ephemvis/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/ephemvis.svg)](https://pypi.org/project/ephemvis/)
+[![Python](https://img.shields.io/pypi/pyversions/ephemvis.svg)](https://pypi.org/project/ephemvis/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Themeable **SVG rendering** for astrological chart data — the display layer that
+pairs with [openephem](https://github.com/NoahChristian/openephem) (the calculation
+core). ephemvis turns a chart dict into a self-contained chart **wheel** and a
+triangular **aspect grid**.
+
+The split is deliberate: **openephem computes, ephemvis draws.** The math core
+stays small and auditable; the visuals can be forked and restyled freely without
+touching (or destabilising) the calculations.
+
+## Install
+
+```bash
+pip install ephemvis            # pure renderer, zero runtime deps
+pip install ephemvis[compute]   # also pulls openephem to compute charts
+```
+
+## Use
+
+```python
+from openephem import resolve, assemble          # needs ephemvis[compute]
+from ephemvis import render_svg, render_aspect_grid_svg
+
+chart = assemble(resolve(date=(1990, 5, 15), time=(14, 30),
+                         place="New York, NY"))
+open("wheel.svg", "w", encoding="utf-8").write(render_svg(chart, theme="prism"))
+open("grid.svg",  "w", encoding="utf-8").write(render_aspect_grid_svg(chart, theme="prism"))
+```
+
+`render_svg` and `render_aspect_grid_svg` accept any dict with the openephem
+`ChartResult` shape (`angles`, `cusps`, `bodies`, `aspects`), so **any engine that
+emits that shape can be rendered** — ephemvis has no dependency on how the chart
+was computed.
+
+## Themes
+
+`light`, `dark`, `auto`, and eight pastel "pretty" modes with a prism-halo ring:
+`prism`, `twilight`, `aurora`, `opal`, `seafoam`, `meadow`, `dawn`, `blossom`.
+See `ephemvis.PALETTES`.
+
+## The data contract
+
+ephemvis reads the chart dict openephem's `assemble()` returns:
+
+```python
+{
+  "angles": {"asc": float, "mc": float, ...} | None,   # ecliptic longitude, degrees
+  "cusps":  [float] (12) | None,                        # house cusp longitudes
+  "bodies": {name: {"lon": float, "retro": bool}},      # ecliptic longitude, degrees
+  "aspects": [{"a": name, "b": name, "aspect": str, "orb": float}],
+  "warnings": [str],
+}
+```
+
+MIT © 2026 Elizabeth Huston, Ph.D. and Noah Christian, Ph.D.  
+Contact: elpisastrology@gmail.com · elpisastrology.com and noahchristian@gmail.com

ephemvis-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ephemvis"
+version = "0.1.0"
+description = "Themeable SVG chart-wheel & aspect-grid rendering for openephem chart data"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Elizabeth Huston" },
+    { name = "Noah Christian" },
+]
+keywords = [
+    "astrology", "chart wheel", "aspectarian", "svg", "visualization",
+    "openephem", "natal chart",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Multimedia :: Graphics",
+    "Topic :: Scientific/Engineering :: Astronomy",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+]
+# The renderers take a plain chart dict and have NO runtime dependencies — this is
+# a pure, engine-agnostic SVG layer. Install [compute] to also pull the openephem
+# calculation core for the one-liner (compute + render together).
+dependencies = []
+
+[project.optional-dependencies]
+compute = ["openephem>=0.1.0"]
+test = ["pytest>=7", "ruff>=0.6", "mypy>=1.10"]
+
+[project.urls]
+Homepage = "https://github.com/NoahChristian/ephemvis"
+Repository = "https://github.com/NoahChristian/ephemvis"
+Changelog = "https://github.com/NoahChristian/ephemvis/blob/main/CHANGELOG.md"
+Issues = "https://github.com/NoahChristian/ephemvis/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ephemvis"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/ephemvis", "README.md", "CHANGELOG.md", "LICENSE"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+# E501: dense SVG output lines. UP031: %-formatting is deliberate here — the tight,
+# many-argument SVG string assembly reads better as % than as f-strings.
+ignore = ["E501", "UP031"]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src/ephemvis"]
+ignore_missing_imports = true
+disallow_untyped_defs = false
+warn_unused_ignores = false

ephemvis-0.1.0/src/ephemvis/__init__.py

@@ -0,0 +1,28 @@
+"""ephemvis — SVG chart rendering for openephem chart data.
+
+Turns a chart dict (the shape openephem's ``assemble()`` returns — ``angles``,
+``cusps``, ``bodies``, ``aspects``) into self-contained, themeable SVG: a chart
+wheel and a triangular aspect grid. The renderers take a plain dict and have no
+runtime dependencies, so any engine that emits the same shape can be rendered.
+
+Quick start:
+    from openephem import resolve, assemble   # optional: `pip install ephemvis[compute]`
+    from ephemvis import render_svg, render_aspect_grid_svg
+    chart = assemble(resolve(date=(1990, 5, 15), time=(14, 30), place="New York, NY"))
+    wheel_svg = render_svg(chart, theme="prism")
+    grid_svg  = render_aspect_grid_svg(chart, theme="prism")
+
+Themes: 'light', 'dark', 'auto', and the pastel modes 'prism', 'twilight',
+'aurora', 'opal', 'seafoam', 'meadow', 'dawn', 'blossom' (see PALETTES).
+"""
+
+__version__ = "0.1.0"
+
+from . import aspectgrid, wheel  # noqa: F401
+from .aspectgrid import render_aspect_grid_svg  # noqa: F401
+from .wheel import PALETTES, render_svg  # noqa: F401
+
+__all__ = [
+    "__version__", "render_svg", "render_aspect_grid_svg", "PALETTES",
+    "wheel", "aspectgrid",
+]

ephemvis-0.1.0/src/ephemvis/aspectgrid.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+aspectgrid.py — render the aspectarian (triangular aspect grid) as a self-contained SVG.
+
+Takes an openephem chart dict (needs ``bodies`` and ``aspects``) and returns an SVG
+string: bodies run down the diagonal as glyphs; each lower-left cell shows the aspect
+between its row and column body, coloured by nature (hard / soft / neutral). Themed
+via the same PALETTES as the wheel. Uses inline presentation attributes (no <style>),
+so it is safe to embed in the same page as other inline SVGs.
+"""
+
+from __future__ import annotations
+
+from typing import cast
+
+from .wheel import _L, PALETTES, PLANET_GLYPHS, _esc, _lerp_hex, body_label
+
+ASP_SYM = {"conjunction": "☌", "opposition": "☍", "square": "□", "trine": "△",
+           "sextile": "⚹", "quincunx": "⚻", "semisextile": "⚺",
+           "semisquare": "∠", "sesquiquadrate": "⚼", "quintile": "Q"}
+ASP_CAT = {"conjunction": "aNeutral", "opposition": "aHard", "square": "aHard",
+           "semisquare": "aHard", "sesquiquadrate": "aHard", "trine": "aSoft",
+           "sextile": "aSoft", "quincunx": "aSoft", "semisextile": "aSoft", "quintile": "aSoft"}
+ASP_LABEL = {"conjunction": "Conjunction", "opposition": "Opposition", "square": "Square",
+             "trine": "Trine", "sextile": "Sextile", "quincunx": "Quincunx",
+             "semisextile": "Semi-sextile", "semisquare": "Semi-square",
+             "sesquiquadrate": "Sesquiquadrate", "quintile": "Quintile"}
+# relational verb for the hover significance ("Sun conjunct Mercury ...")
+ASP_REL = {"conjunction": "conjunct", "opposition": "opposite", "square": "square",
+           "trine": "trine", "sextile": "sextile", "quincunx": "quincunx",
+           "semisextile": "semi-sextile", "semisquare": "semi-square",
+           "sesquiquadrate": "sesquiquadrate", "quintile": "quintile"}
+_NICE = {"TrueNode": "North Node", "MeanNode": "North Node",
+         "MeanLilith": "Lilith", "OscuLilith": "Lilith", "SouthNode": "South Node"}
+DEFAULT_ORDER = ["Sun", "Moon", "Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus",
+                 "Neptune", "Pluto", "TrueNode", "MeanNode", "MeanLilith", "OscuLilith",
+                 "Chiron", "Ceres", "Pallas", "Juno", "Vesta",
+                 "Astraea", "Hygeia", "Eros", "Eris", "Sedna", "AsteroidLilith"]
+SYM = '"Segoe UI Symbol","Noto Sans Symbols2","Apple Symbols",system-ui,sans-serif'
+# Themes whose two grid-gradient colours read better swapped (perceptual). The
+# direction/anchoring is unchanged — only which colour sits at the bottom-left nexus.
+_GRID_GRAD_REVERSE = {"infrared"}
+
+
+def render_aspect_grid_svg(chart: dict, theme: str = "light", order=None,
+                           cell: float = 30.0, legend: bool = True) -> str:
+    """Return an SVG string for the triangular aspect grid.
+
+    Only bodies that appear in `order` AND in the chart's `bodies` are shown, in that
+    order. Aspects are matched from `chart['aspects']` (undirected).
+    """
+    bodies = chart.get("bodies") or {}
+    aspects = chart.get("aspects") or []
+    pal = _L if theme == "auto" else PALETTES.get(theme, _L)
+    gorder = [b for b in (order or DEFAULT_ORDER) if b in bodies]
+    n = len(gorder)
+    amap = {frozenset((a.get("a"), a.get("b"))): a for a in aspects}
+    C, pad = float(cell), 8.0
+    bg0 = cast("tuple[str, str]", pal["bg"])[0]
+    diagbg = _lerp_hex(bg0, pal["planet"], 0.10)       # subtle diagonal-cell tint over bg
+    accent = pal["anglelab"]                           # diagonal glyph colour
+    muted = pal["deg"]
+    # grid gradient: two theme colours, nexus at the bottom-left corner
+    gwarm, gcool = pal["aHard"], pal["aSoft"]
+    if theme in _GRID_GRAD_REVERSE:                    # perceptual per-theme swap
+        gwarm, gcool = gcool, gwarm
+    gid = "aspgrid_%s_%d_%d" % (theme, int(round(C)), n)
+
+    present = [k for k in ASP_SYM if any(a.get("aspect") == k for a in aspects)]
+    leg_h = 26.0 if (legend and present) else 0.0
+    gridW = n * C
+    legW = sum(20.0 + len(ASP_LABEL[k]) * 7.2 + 22.0 for k in present) if leg_h else 0.0
+    W = max(gridW, legW) + pad * 2
+    H = gridW + pad * 2 + leg_h
+
+    def X(j): return pad + j * C
+    def Y(i): return pad + i * C
+
+    P = ['<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 %.0f %.0f" '
+         'width="%.0f" height="%.0f" style="cursor:default" role="img" '
+         'aria-label="aspect grid">' % (W, H, W, H)]
+
+    # gradient DIRECTION (pass one): warm nexus pinned at the bottom-left corner,
+    # radiating perpendicular to the symbol diagonal toward the top-right. The axis
+    # runs along (1,-1), so iso-colour bands are straight lines PARALLEL to the symbol
+    # diagonal; the cool 100% stop-band lands exactly on the line through the symbols'
+    # top-right corners (x - y == one cell). End point (X((n+1)/2), Y((n-1)/2)) has
+    # x - y == C and BL->end is along (1,-1).
+    P.append('<defs><linearGradient id="%s" gradientUnits="userSpaceOnUse" '
+             'x1="%.1f" y1="%.1f" x2="%.1f" y2="%.1f">'
+             '<stop offset="0%%" stop-color="%s"/><stop offset="100%%" stop-color="%s"/>'
+             '</linearGradient></defs>'
+             % (gid, X(0), Y(n), X((n + 1) / 2.0), Y((n - 1) / 2.0), gwarm, gcool))
+
+    # --- cell fills, glyphs & aspect symbols ---
+    for i, bi in enumerate(gorder):
+        for j in range(i + 1):
+            x, y = X(j), Y(i)
+            if j == i:
+                # hover the body's diagonal cell -> its name, sign & degree
+                P.append('<g><title>%s</title>' % _esc(body_label(bi, bodies.get(bi, {}))))
+                P.append('<rect x="%.1f" y="%.1f" width="%.1f" height="%.1f" fill="%s"/>'
+                         % (x, y, C, C, diagbg))
+                P.append('<text x="%.1f" y="%.1f" fill="%s" font-family=\'%s\' font-size="%.1f" '
+                         'text-anchor="middle" dominant-baseline="central">%s︎</text></g>'
+                         % (x + C / 2, y + C / 2, accent, SYM, C * 0.52,
+                            _esc(PLANET_GLYPHS.get(bi) or
+                                 ("✦" if bodies.get(bi, {}).get("kind") == "star" else bi[:2]))))
+            else:
+                a = amap.get(frozenset((bi, gorder[j])))
+                if not a:
+                    continue
+                col = pal[ASP_CAT.get(a.get("aspect"), "aSoft")]
+                asp = a.get("aspect")
+                tip = "%s %s %s · %.1f° orb" % (
+                    _NICE.get(bi, bi), ASP_REL.get(asp, asp),
+                    _NICE.get(gorder[j], gorder[j]), abs(float(a.get("orb", 0.0))))
+                P.append('<g><title>%s</title>'
+                         '<rect x="%.1f" y="%.1f" width="%.1f" height="%.1f" fill="%s" fill-opacity="0.13"/>'
+                         '<text x="%.1f" y="%.1f" fill="%s" font-family=\'%s\' font-size="%.1f" '
+                         'font-weight="600" text-anchor="middle" dominant-baseline="central">%s︎</text></g>'
+                         % (_esc(tip), x, y, C, C, col, x + C / 2, y + C / 2, col, SYM, C * 0.46,
+                            _esc(ASP_SYM.get(a.get("aspect"), "·"))))
+
+    # --- interior gridlines: same gradient as the frame (pass two) ---
+    for i in range(1, n):                        # row separators (span columns 0..i)
+        P.append('<line x1="%.1f" y1="%.1f" x2="%.1f" y2="%.1f" stroke="url(#%s)" stroke-width="1.5" '
+                 'shape-rendering="crispEdges"/>' % (X(0), Y(i), X(i), Y(i), gid))
+    for j in range(1, n):                        # column separators (span rows j..n)
+        P.append('<line x1="%.1f" y1="%.1f" x2="%.1f" y2="%.1f" stroke="url(#%s)" stroke-width="1.5" '
+                 'shape-rendering="crispEdges"/>' % (X(j), Y(j), X(j), Y(n), gid))
+
+    # --- outer edge of the triangle (staircase frame, themed gradient stroke) ---
+    if n:
+        pts = [(X(0), Y(0)), (X(0), Y(n)), (X(n), Y(n))]
+        for i in range(n - 1, -1, -1):
+            pts.append((X(i + 1), Y(i)))
+            pts.append((X(i), Y(i)))
+        P.append('<polygon points="%s" fill="none" stroke="url(#%s)" stroke-width="4" '
+                 'stroke-linejoin="miter" shape-rendering="crispEdges"/>'
+                 % (" ".join("%.1f,%.1f" % p for p in pts), gid))
+
+    # --- legend ---
+    if leg_h:
+        ly, lx = pad + gridW + 17.0, pad
+        for k in present:
+            P.append('<text x="%.1f" y="%.1f" fill="%s" font-family=\'%s\' font-size="14" '
+                     'dominant-baseline="central">%s︎</text>' % (lx, ly, pal[ASP_CAT[k]], SYM, _esc(ASP_SYM[k])))
+            lx += 20.0
+            P.append('<text x="%.1f" y="%.1f" fill="%s" font-family="system-ui,sans-serif" '
+                     'font-size="12.5" dominant-baseline="central">%s</text>' % (lx, ly, muted, ASP_LABEL[k]))
+            lx += len(ASP_LABEL[k]) * 7.2 + 22.0
+
+    P.append('</svg>')
+    return "\n".join(P)

ephemvis-0.1.0/src/ephemvis/wheel.py

@@ -0,0 +1,489 @@
+#!/usr/bin/env python3
+"""
+wheel.py — render a natal chart as a self-contained SVG wheel.  [SHIP]
+
+Pure Python, zero dependencies. Takes the dict from chart.assemble() (or any dict
+with the same shape) and returns an SVG string. Ascendant is placed at the left
+(9 o'clock) with the zodiac increasing counter-clockwise — the standard chart
+convention. Theme-aware (light/dark) via a CSS block.
+
+Glyphs are standard Unicode astrological symbols (no font-licensing issue); if a
+viewer's font lacks them, pass text_labels=True for 2-3 letter abbreviations.
+"""
+
+from __future__ import annotations
+
+import math
+
+SIGN_GLYPHS = ["♈", "♉", "♊", "♋", "♌", "♍",
+               "♎", "♏", "♐", "♑", "♒", "♓"]
+SIGN_ABBR = ["Ar", "Ta", "Ge", "Cn", "Le", "Vi", "Li", "Sc", "Sg", "Cp", "Aq", "Pi"]
+
+PLANET_GLYPHS = {
+    "Sun": "☉", "Moon": "☽", "Mercury": "☿", "Venus": "♀",
+    "Mars": "♂", "Jupiter": "♃", "Saturn": "♄", "Uranus": "♅",
+    "Neptune": "♆", "Pluto": "♇", "TrueNode": "☊", "MeanNode": "☊", "SouthNode": "☋",
+    "MeanLilith": "⚸", "OscuLilith": "⚸", "Chiron": "⚷",
+    "Ceres": "⚳", "Pallas": "⚴", "Juno": "⚵", "Vesta": "⚶",
+    "Eros": "♡", "Eris": "⯰", "AsteroidLilith": "☾",   # no standard Unicode glyphs
+    "Hygeia": "⚕", "Astraea": "As", "Sedna": "⯲",
+    "PartOfFortune": "⊗", "Vertex": "Vx", "EastPoint": "Ep",
+    "Descendant": "Dc", "ImumCoeli": "Ic", "AriesPoint": "♈", "LibraPoint": "♎",
+    "CoAscendant": "Co",
+    # Uranian / hypothetical bodies — no standard Unicode glyphs, so 2-letter marks
+    "Cupido": "Cu", "Hades": "Ha", "Zeus": "Ze", "Kronos": "Kr", "Apollon": "Ap",
+    "Admetos": "Ad", "Vulcanus": "Vl", "Poseidon": "Po", "TransPluto": "TP",
+    "Vulcan": "Vu", "WhiteMoon": "Se",   # Weston's Vulcan; Selena / White Moon
+}
+PLANET_ABBR = {k: (k[:2] if k not in ("Sun", "Moon") else k[:2]) for k in PLANET_GLYPHS}
+
+_SIGNS = ("Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo", "Libra", "Scorpio",
+          "Sagittarius", "Capricorn", "Aquarius", "Pisces")
+_NICE_NAMES = {"TrueNode": "North Node", "MeanNode": "North Node", "SouthNode": "South Node",
+               "MeanLilith": "Black Moon Lilith", "OscuLilith": "Black Moon Lilith",
+               "AsteroidLilith": "Asteroid Lilith", "PartOfFortune": "Part of Fortune",
+               "EastPoint": "East Point", "ImumCoeli": "Imum Coeli", "CoAscendant": "Co-Ascendant",
+               "AriesPoint": "Aries Point", "LibraPoint": "Libra Point",
+               "WhiteMoon": "White Moon (Selena)", "TransPluto": "Trans-Pluto"}
+
+
+def body_label(name, body):
+    """Hover text for a body: 'Moon in Pisces at 5.00°' (+ ' ℞' when retrograde)."""
+    lon = float(body.get("lon", 0.0)) % 360.0
+    sign = body.get("sign") or _SIGNS[int(lon // 30) % 12]
+    deg = body.get("deg_in_sign")
+    if deg is None:
+        deg = lon % 30.0
+    s = "%s in %s at %.2f°" % (_NICE_NAMES.get(name, name), sign, float(deg))
+    return s + " ℞" if body.get("retro") else s
+
+
+_ORDINALS = ("1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th",
+             "9th", "10th", "11th", "12th")
+
+
+def _house_of_lon(lon, cusps):
+    for i in range(12):
+        span = (cusps[(i + 1) % 12] - cusps[i]) % 360.0
+        if span == 0.0 or (lon - cusps[i]) % 360.0 < span:
+            return i + 1
+    return 12
+
+
+def sign_label(i, angles, cusps):
+    """Hover text for a zodiac sign: 'Virgo · 2nd house' (+ ' (Rising)' on the Asc sign)."""
+    name = _SIGNS[i % 12]
+    asc = (angles or {}).get("asc")
+    rising = asc is not None and int(asc // 30) % 12 == i % 12
+    if cusps and len(cusps) >= 12:
+        s = "%s · %s house" % (name, _ORDINALS[_house_of_lon(i * 30.0 + 15.0, cusps) - 1])
+    else:
+        s = name
+    return s + " (Rising)" if rising else s
+
+
+def angle_label(key, lon):
+    """Hover text for the Asc/MC: 'Leo Ascendant at 12.34°'."""
+    lon %= 360.0
+    nm = {"asc": "Ascendant", "mc": "Midheaven"}.get(key, key)
+    return "%s %s at %.2f°" % (_SIGNS[int(lon // 30) % 12], nm, lon % 30.0)
+
+# Aspect line styling (color, dash). Class names keyed for the CSS block.
+ASPECT_STYLE = {
+    "conjunction": ("#8a8a8a", ""),
+    "opposition": ("#d7263d", ""),
+    "square": ("#d7263d", ""),
+    "trine": ("#1f7a8c", ""),
+    "sextile": ("#1f7a8c", "4 3"),
+    "quincunx": ("#3f8f3f", "2 3"),
+    "semisextile": ("#3f8f3f", "2 3"),
+    "semisquare": ("#c08a2e", "2 3"),
+    "sesquiquadrate": ("#c08a2e", "2 3"),
+    "quintile": ("#7a4fb0", "2 3"),
+}
+
+# Which aspects read as hard / soft / neutral (for per-theme aspect colouring).
+ASPECT_CAT = {
+    "conjunction": "neutral",
+    "opposition": "hard", "square": "hard",
+    "semisquare": "hard", "sesquiquadrate": "hard",
+    "trine": "soft", "sextile": "soft",
+    "quincunx": "soft", "semisextile": "soft", "quintile": "soft",
+}
+
+# ---- colour palettes -> selectable "modes" ---------------------------------
+# Each palette: bg (radial gradient in/out), ring (3 linear-gradient stops), then
+# per-element colours. light/dark are functional; the rest are pastel "pretty"
+# modes with a prism-like ring sweep. All are valid `theme=` values.
+_L = dict(bg=("#ffffff", "#ffffff"), ring=("#b0b0b0", "#b0b0b0", "#b0b0b0"),
+          tick="#b0b0b0", sign="#3a3a3a", cusp="#7f9fd4", cuspA="#3f5f9c",
+          hdiv="#a3aab8", leader="#c3c7cf", housenum="#3a3a3a", anglelab="#1c1c1c",
+          pmark="#b6b6b6", planet="#111111", deg="#5f5f5f", degRx="#c0392b",
+          title="#222222", aHard="#d7263d", aSoft="#1f7a8c", aNeutral="#8a8a8a", halo=False)
+_D = dict(bg=("#14161a", "#0f1114"), ring=("#3a3f47", "#3a3f47", "#3a3f47"),
+          tick="#3a3f47", sign="#c9cdd4", cusp="#6a84ad", cuspA="#a6c1ec",
+          hdiv="#5b6474", leader="#4c525e", housenum="#7a828c", anglelab="#d5d9df",
+          pmark="#454b54", planet="#f2f4f7", deg="#9aa1ab", degRx="#ff6f6f",
+          title="#e6e9ee", aHard="#e06c78", aSoft="#5fb0c0", aNeutral="#7a828c", halo=False)
+
+
+def _pretty(bg, bg2, ring, ink, mid, line, lineA, accent, hard, soft):
+    return dict(bg=(bg, bg2), ring=ring, tick=line, sign=ink, cusp=line, cuspA=lineA,
+                hdiv=mid, leader=line, housenum=ink, anglelab=accent, pmark=mid,
+                planet=ink, deg=mid, degRx=hard, title=ink,
+                aHard=hard, aSoft=soft, aNeutral=mid, halo=True)
+
+
+def _lerp_hex(c1, c2, t):
+    a = tuple(int(c1[i:i + 2], 16) for i in (1, 3, 5))
+    b = tuple(int(c2[i:i + 2], 16) for i in (1, 3, 5))
+    return "#%02x%02x%02x" % tuple(round(a[k] + (b[k] - a[k]) * t) for k in range(3))
+
+
+def _conic(p, stops):
+    """Colour at fraction p in [0,1) sweeping the three ring stops around a loop."""
+    seg = (p % 1.0) * 3.0
+    i = int(seg) % 3
+    return _lerp_hex(stops[i], stops[(i + 1) % 3], seg - int(seg))
+
+
+# Rotation applied to the halo sweep so the brightest/warmest ring stop (stops[2],
+# naturally at screen 240° = ~7 o'clock) lands at the TOP of the wheel (screen 90°).
+# colour = _conic(mid/360 + _HALO_TURN); stops[2] shows where the arg == 2/3, so
+# 90/360 + _HALO_TURN == 2/3  ->  _HALO_TURN = 2/3 - 1/4 = 150/360.
+_HALO_TURN = 150.0 / 360.0
+
+# Per-theme perceptual nudge of the halo nexus, in degrees CCW from the top (the
+# nexus screen angle = 240 - 360*turn, and CCW = increasing screen angle, so the
+# effective turn is (_HALO_TURN - deg/360)). Tuned by eye per palette; 0 = at top.
+_HALO_ROT_DEG = {
+    "twilight": 30, "aurora": 30, "opal": 30, "seafoam": 30,
+    "meadow": 45, "dawn": 90, "blossom": 60, "infrared": 30,
+    # prism, ultraviolet (and the halo-less light/dark): 0
+}
+
+
+PALETTES = {
+    "light": _L, "dark": _D,
+    "aurora": _pretty("#f4f7fd", "#e8eef8", ("#8fb3e6", "#b9c9ee", "#d9b8e6"),
+                      "#2a3550", "#5f6a86", "#a9bfe4", "#5f79b8", "#bf8f4a", "#cf7a8a", "#5f96b0"),
+    "seafoam": _pretty("#eef8f4", "#ddf0ea", ("#6fc2c9", "#a5dcd2", "#cfe6b0"),
+                       "#22403c", "#567a74", "#9fd0cb", "#4f9a92", "#a98a45", "#d07a6e", "#3f9a90"),
+    "twilight": _pretty("#f2eef8", "#e6e0f0", ("#6a7fd0", "#9a8fd8", "#d29ac0"),
+                        "#2e2846", "#6a6484", "#b3a6dd", "#6a5fb0", "#b98a4e", "#cf6a8a", "#6a7fc8"),
+    "dawn": _pretty("#fcf5ee", "#f7e9dc", ("#8fbce6", "#f0c69a", "#f0a48f"),
+                    "#40342a", "#7a6a58", "#e3c3a3", "#c98f6f", "#bf7f3a", "#d0705a", "#5f96b8"),
+    "prism": _pretty("#f4f7fb", "#e8f0f8", ("#6aa0e0", "#7fd0c0", "#e8d98f"),
+                     "#263242", "#5f6f80", "#a7c4e6", "#4f86c8", "#b98a3e", "#cf6f6a", "#3f9aa0"),
+    "opal": _pretty("#f6f5fb", "#edeef6", ("#a9c4ea", "#cdc2ec", "#ecd6b0"),
+                    "#33324a", "#6a6a82", "#bfcbe8", "#7a86bf", "#b28a4a", "#cf7a90", "#6f96b8"),
+    "meadow": _pretty("#f2f7ee", "#e7f0de", ("#7fb0d8", "#a8cfa8", "#d8d68f"),
+                      "#2c3a2a", "#5f6f56", "#aecbb0", "#6a9a72", "#a98a40", "#d0705a", "#4f9a86"),
+    "blossom": _pretty("#fbf3f6", "#f6e7ee", ("#8fb3e6", "#dab0d8", "#f0aab8"),
+                       "#402a38", "#7a5f6e", "#e0bcd2", "#b06a92", "#bf7f5a", "#d06a86", "#6f96b8"),
+    # spectral "beyond visible" pair — dark grounds with a thermal / black-light glow
+    "infrared": _pretty("#1a0a0a", "#0d0404", ("#7a0d0d", "#e0431f", "#f2b705"),
+                        "#f6e3d8", "#a06a52", "#5a2f28", "#ff7a3c", "#ff5a2e", "#ff3b2f", "#ffd25e"),
+    "ultraviolet": _pretty("#120a24", "#080413", ("#7a3cff", "#b03cff", "#3c9cff"),
+                           "#ece4ff", "#7a68b0", "#3a2a5e", "#a06cff", "#b57bff", "#ff5ad0", "#6ab8ff"),
+}
+
+
+def _defs(pal):
+    b0, b1 = pal["bg"]
+    r0, r1, r2 = pal["ring"]
+    return ('<defs>'
+            '<radialGradient id="bggrad" cx="50%" cy="40%" r="82%">'
+            '<stop id="bs0" offset="0%" stop-color="' + b0 + '"/>'
+            '<stop id="bs1" offset="100%" stop-color="' + b1 + '"/>'
+            '</radialGradient>'
+            '<linearGradient id="ringgrad" x1="0.05" y1="0.05" x2="0.95" y2="0.95">'
+            '<stop id="rs0" offset="0%" stop-color="' + r0 + '"/>'
+            '<stop id="rs1" offset="50%" stop-color="' + r1 + '"/>'
+            '<stop id="rs2" offset="100%" stop-color="' + r2 + '"/>'
+            '</linearGradient></defs>')
+
+
+def _style(pal):
+    sym = '"Segoe UI Symbol","Noto Sans Symbols2","Apple Symbols",system-ui,sans-serif'
+    rules = [
+        (".ring", "fill:none;stroke:url(#ringgrad);stroke-width:3.4"),
+        (".tick", "stroke:%s;stroke-width:3.4" % pal["tick"]),
+        (".sign", "fill:%s;font:600 28px %s" % (pal["sign"], sym)),
+        (".cusp", "stroke:%s;stroke-width:2" % pal["cusp"]),
+        (".cusp-angle", "stroke:%s;stroke-width:2.4" % pal["cuspA"]),
+        (".hdiv", "stroke:%s;stroke-width:1.3" % pal["hdiv"]),
+        (".leader", "stroke:%s;stroke-width:2;stroke-dasharray:1 5;stroke-linecap:round" % pal["leader"]),
+        (".housenum", "fill:%s;font:600 19px system-ui,sans-serif" % pal["housenum"]),
+        (".anglelab", "fill:%s;font:800 28px system-ui,sans-serif" % pal["anglelab"]),
+        (".ac-sm", "font-size:0.5em"),
+        (".pmark", "stroke:%s;stroke-width:1.6" % pal["pmark"]),
+        (".planet", "fill:%s;font:600 33px %s" % (pal["planet"], sym)),
+        (".deg", "fill:%s;font:600 18px system-ui,sans-serif" % pal["deg"]),
+        (".deg-rx", "fill:%s" % pal["degRx"]),
+        (".aspect", "stroke-width:1.1;fill:none;opacity:.85"),
+        (".title", "fill:%s;font:600 15px system-ui,sans-serif" % pal["title"]),
+    ]
+    return "<style>" + "".join("%s{%s}" % (s, p) for s, p in rules) + "</style>"
+
+
+def _dark_media():
+    d = _D
+    return ('<style>@media (prefers-color-scheme: dark){'
+            '#bs0{stop-color:' + d["bg"][0] + '}#bs1{stop-color:' + d["bg"][1] + '}'
+            '#rs0,#rs1,#rs2{stop-color:' + d["ring"][0] + '}'
+            '.tick{stroke:' + d["tick"] + '}.sign{fill:' + d["sign"] + '}'
+            '.cusp{stroke:' + d["cusp"] + '}.cusp-angle{stroke:' + d["cuspA"] + '}'
+            '.hdiv{stroke:' + d["hdiv"] + '}.leader{stroke:' + d["leader"] + '}'
+            '.housenum{fill:' + d["housenum"] + '}.anglelab{fill:' + d["anglelab"] + '}'
+            '.pmark{stroke:' + d["pmark"] + '}.planet{fill:' + d["planet"] + '}'
+            '.deg{fill:' + d["deg"] + '}.deg-rx{fill:' + d["degRx"] + '}'
+            '.title{fill:' + d["title"] + '}}</style>')
+
+
+def _theme_markup(theme):
+    """Return the <defs> gradients + <style> for a theme (auto = light + dark media)."""
+    if theme == "auto":
+        return _defs(_L) + _style(_L) + _dark_media()
+    pal = PALETTES.get(theme, _L)
+    return _defs(pal) + _style(pal)
+
+
+def _esc(s: str) -> str:
+    return (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+
+
+def render_svg(chart: dict, size: int = 760, theme: str = "auto",
+               text_labels: bool = False, title: str | None = None) -> str:
+    cx = cy = size / 2.0
+    r_out = size * 0.45              # outer edge (leaves a margin for AC/MC outside)
+    r_zod_in = r_out * 0.862         # inner edge of the zodiac band (signs live here)
+    r_house = r_zod_in               # house-cusp lines reach the zodiac inner edge
+    r_tick_in = r_zod_in * 0.905     # inner end of the planet pointer ticks
+    r_glyph = r_zod_in * 0.845       # planet-glyph ring (pushed out for more room)
+    r_hnum_out = r_zod_in * 0.43     # house-ring outer = former aspect-circle radius
+    r_hub = r_zod_in * 0.33          # aspect circle == house-ring inner edge (they meet)
+    r_hnum = r_zod_in * 0.38         # house numbers, centred in the (wider) ring band
+    glyphs = None if not text_labels else True
+    apal = _L if theme == "auto" else PALETTES.get(theme, _L)  # aspect colours
+
+    angles = chart.get("angles") or {}
+    asc = angles.get("asc", 0.0)     # unknown-time -> 0 Aries at left
+    cusps = chart.get("cusps")
+
+    def pol(r, lon):
+        """Ecliptic longitude -> (x, y). Asc at left, zodiac CCW."""
+        a = math.radians(180.0 + (lon - asc))
+        return cx + r * math.cos(a), cy - r * math.sin(a)
+
+    def sp(r, deg):
+        """Screen-space polar (independent of the chart's rotation) for halo bands."""
+        a = math.radians(deg)
+        return cx + r * math.cos(a), cy - r * math.sin(a)
+
+    P = []  # svg fragments
+    P.append(f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {size} {size}" '
+             f'width="{size}" height="{size}" style="cursor:default" role="img" '
+             f'aria-label="{_esc(title or "natal chart")}">')
+    P.append(_theme_markup(theme))
+    P.append(f'<rect x="0" y="0" width="{size}" height="{size}" class="bg" fill="url(#bggrad)"/>')
+
+    # --- rings / prism-halo bands ---
+    if apal.get("halo"):
+        # fill the zodiac band and the house-number band with an angular sweep of
+        # the ring stops (a true "halo" around the wheel), then outline the edges.
+        stops = apal["ring"]
+        turn = _HALO_TURN - _HALO_ROT_DEG.get(theme, 0) / 360.0   # per-theme CCW nudge
+        N = 120
+        for rin, rout in ((r_zod_in, r_out), (r_hub, r_hnum_out)):
+            for sgi in range(N):
+                a0, a1 = 360.0 * sgi / N, 360.0 * (sgi + 1) / N
+                col = _conic((a0 + a1) / 720.0 + turn, stops)
+                x1, y1 = sp(rout, a0)
+                x2, y2 = sp(rout, a1)
+                x3, y3 = sp(rin, a1)
+                x4, y4 = sp(rin, a0)
+                P.append(f'<polygon points="{x1:.1f},{y1:.1f} {x2:.1f},{y2:.1f} '
+                         f'{x3:.1f},{y3:.1f} {x4:.1f},{y4:.1f}" fill="{col}"/>')
+        for r in (r_out, r_zod_in, r_hnum_out, r_hub):
+            P.append(f'<circle cx="{cx:.1f}" cy="{cy:.1f}" r="{r:.1f}" '
+                     f'fill="none" stroke="rgba(38,44,60,.28)" stroke-width="1.4"/>')
+    else:
+        for r in (r_out, r_zod_in, r_hnum_out, r_hub):
+            P.append(f'<circle cx="{cx:.1f}" cy="{cy:.1f}" r="{r:.1f}" class="ring"/>')
+
+    # --- zodiac: 12 sectors (fixed to longitude) ---
+    for i in range(12):
+        lon0 = i * 30.0
+        x1, y1 = pol(r_zod_in, lon0)
+        x2, y2 = pol(r_out, lon0)
+        P.append(f'<line x1="{x1:.1f}" y1="{y1:.1f}" x2="{x2:.1f}" y2="{y2:.1f}" class="tick"/>')
+        gx, gy = pol((r_zod_in + r_out) / 2.0, lon0 + 15.0)
+        label = SIGN_ABBR[i] if glyphs else SIGN_GLYPHS[i] + "︎"  # text, not emoji
+        P.append(f'<text x="{gx:.1f}" y="{gy:.1f}" class="sign" '
+                 f'dominant-baseline="central" text-anchor="middle">'
+                 f'<title>{_esc(sign_label(i, angles, cusps))}</title>{label}</text>')
+
+    # --- houses (cusp lines here; numbers collected and drawn last, on top) ---
+    house_labels = []
+    if cusps and len(cusps) >= 12:
+        # emphasise the four angle cusps only when they ARE the angles (quadrant
+        # systems like Placidus); in whole-sign/equal the cusps are sign boundaries,
+        # so every division stays uniform.
+        _asc, _mc = angles.get("asc"), angles.get("mc")
+        quad = (_asc is not None and _mc is not None
+                and abs((cusps[0] - _asc + 180.0) % 360.0 - 180.0) < 0.5
+                and abs((cusps[9] - _mc + 180.0) % 360.0 - 180.0) < 0.5)
+        for i, c in enumerate(cusps):
+            cls = "cusp-angle" if (quad and i in (0, 3, 6, 9)) else "cusp"
+            # solid divider between house numbers, within the number ring
+            hx1, hy1 = pol(r_hub, c)
+            hx2, hy2 = pol(r_hnum_out, c)
+            P.append(f'<line x1="{hx1:.1f}" y1="{hy1:.1f}" x2="{hx2:.1f}" y2="{hy2:.1f}" class="hdiv"/>')
+            # dotted cusp continues from the number ring out to the zodiac
+            dx1, dy1 = pol(r_hnum_out, c)
+            dx2, dy2 = pol(r_house, c)
+            P.append(f'<line x1="{dx1:.1f}" y1="{dy1:.1f}" x2="{dx2:.1f}" y2="{dy2:.1f}" class="{cls}"/>')
+            mid = c + (((cusps[(i + 1) % 12] - c) % 360.0) / 2.0)
+            nx, ny = pol(r_hnum, mid)
+            house_labels.append(f'<text x="{nx:.1f}" y="{ny:.1f}" class="housenum" '
+                                f'dominant-baseline="central" text-anchor="middle">{i + 1}</text>')
+        # Asc / MC labels, OUTSIDE the ring (so the halo bands don't clobber them);
+        # the trailing "C" is half-height, baseline-aligned (not descending).
+        r_ang = r_out + size * 0.03
+        for key, first in (("asc", "A"), ("mc", "M")):
+            if key in angles:
+                lx, ly = pol(r_ang, angles[key])
+                P.append(f'<text x="{lx:.1f}" y="{ly + size*0.008:.1f}" class="anglelab" '
+                         f'text-anchor="middle"><title>{_esc(angle_label(key, angles[key]))}</title>'
+                         f'{first}<tspan class="ac-sm">C</tspan></text>')
+
+    # --- planets (with simple angular de-collision on the display ring) ---
+    bodies = chart.get("bodies") or {}
+    # Combined de-collision: a gentle angular (circumferential) spread PLUS radial
+    # tiers where bodies pile up. Glyphs stay near their true longitude; a dotted
+    # leader ties any displaced glyph back to its true mark, so nothing is lost.
+    ANG = 6.0                        # angular min-gap (deg) — gentle circumferential fan
+    RAD_TH = 12.0                    # within this angular gap, stack radially instead
+    STEP = r_zod_in * 0.173          # radial gap between tiers
+    DOFF = r_zod_in * 0.086          # degree label offset below its glyph
+    placed = _spread([(n, bodies[n]["lon"]) for n in bodies], min_gap=ANG)
+    order = sorted(range(len(placed)), key=lambda k: placed[k][2])
+    last: list[float] = []
+    tier = [0] * len(placed)
+    for k in order:
+        d = placed[k][2]
+        t = 0
+        while t < len(last) and (d - last[t]) % 360.0 < RAD_TH:
+            t += 1
+        if t == len(last):
+            last.append(d)
+        else:
+            last[t] = d
+        tier[k] = t
+    hub_pts = {}
+    for k, (name, lon, disp) in enumerate(placed):
+        rg = r_glyph - tier[k] * STEP
+        # true-position mark: a short spoke just inside the zodiac
+        tx1, ty1 = pol(r_tick_in, lon)
+        tx2, ty2 = pol(r_house, lon)
+        P.append(f'<line x1="{tx1:.1f}" y1="{ty1:.1f}" x2="{tx2:.1f}" y2="{ty2:.1f}" class="pmark"/>')
+        # displaced glyph: dotted leader back to its true mark (keeps the link)
+        drift = abs((disp - lon + 180.0) % 360.0 - 180.0)
+        if tier[k] > 0 or drift > 2.5:
+            gx0, gy0 = pol(rg + r_zod_in * 0.045, disp)
+            P.append(f'<line x1="{gx0:.1f}" y1="{gy0:.1f}" x2="{tx1:.1f}" y2="{ty1:.1f}" class="leader"/>')
+        gx, gy = pol(rg, disp)
+        if glyphs:
+            g = PLANET_ABBR.get(name, name[:2])
+        else:  # fixed stars share one ✦ marker; the name identifies them in the key
+            base = PLANET_GLYPHS.get(name) or ("✦" if bodies[name].get("kind") == "star" else name[:2])
+            g = base + "︎"  # text, not emoji
+        retro = bodies[name].get("retro")
+        lbl = _esc(body_label(name, bodies[name]))          # hover: name in sign at deg
+        P.append(f'<text x="{gx:.1f}" y="{gy:.1f}" class="planet" '
+                 f'dominant-baseline="central" text-anchor="middle">'
+                 f'<title>{lbl}</title>{_esc(g)}</text>')
+        dxp, dyp = pol(rg - DOFF, disp)
+        deg = f'{int(lon % 30)}°' + ("℞" if retro else "")
+        dcls = "deg deg-rx" if retro else "deg"
+        P.append(f'<text x="{dxp:.1f}" y="{dyp:.1f}" class="{dcls}" '
+                 f'dominant-baseline="central" text-anchor="middle">'
+                 f'<title>{lbl}</title>{deg}</text>')
+        hub_pts[name] = pol(r_hub, lon)
+
+    # --- aspects (lines across the hub) ---
+    for asp in chart.get("aspects") or []:
+        a, b = asp.get("a"), asp.get("b")
+        if a in hub_pts and b in hub_pts:
+            cat = ASPECT_CAT.get(asp.get("aspect"), "soft")
+            color = apal["a" + cat.capitalize()]
+            _, dash = ASPECT_STYLE.get(asp.get("aspect"), ("", "2 3"))
+            (x1, y1), (x2, y2) = hub_pts[a], hub_pts[b]
+            da = f' stroke-dasharray="{dash}"' if dash else ""
+            P.append(f'<line x1="{x1:.1f}" y1="{y1:.1f}" x2="{x2:.1f}" y2="{y2:.1f}" '
+                     f'stroke="{color}" class="aspect"{da}/>')
+
+    # house numbers last, so they sit in front of the cusp lines and ticks
+    P.extend(house_labels)
+
+    if title:
+        P.append(f'<text x="{cx:.1f}" y="{size*0.04:.1f}" class="title" '
+                 f'text-anchor="middle">{_esc(title)}</text>')
+    P.append('</svg>')
+    return "\n".join(P)
+
+
+def _spread(items, min_gap=7.0):
+    """De-collide glyph display angles while preserving zodiacal order. Cut the
+    circle at its widest gap so a cluster can open into free space, enforce the
+    minimum gap in one forward sweep (no crossovers), then recentre on the true
+    centroid to keep drift minimal and symmetric. Returns (name, true_lon, disp)."""
+    items = sorted(items, key=lambda t: t[1])
+    n = len(items)
+    if n < 2:
+        return [(nm, lo, lo) for nm, lo in items]
+    lons = [lo for _, lo in items]
+    gaps = [(lons[(i + 1) % n] - lons[i]) % 360.0 for i in range(n)]
+    s = max(range(n), key=lambda i: gaps[i])          # widest gap -> seam
+    order = [(s + 1 + k) % n for k in range(n)]        # chain order from the seam
+    u, prev = [], lons[order[0]]                       # unwrap along the chain
+    for idx in order:
+        v = lons[idx]
+        while v < prev - 1e-9:
+            v += 360.0
+        u.append(v)
+        prev = v
+    tgt = u[:]
+    for k in range(1, n):                              # forward sweep: enforce gap
+        if u[k] < u[k - 1] + min_gap:
+            u[k] = u[k - 1] + min_gap
+    shift = sum(tgt[k] - u[k] for k in range(n)) / n   # recentre on true centroid
+    disp = [0.0] * n
+    for k, idx in enumerate(order):
+        disp[idx] = (u[k] + shift) % 360.0
+    return [(items[i][0], items[i][1], disp[i]) for i in range(n)]
+
+
+if __name__ == "__main__":
+    from openephem import houses
+    # Real analytic houses (no skyfield) + a few mock planets, to a file.
+    h = houses.houses_from_jd(2448027.270833, 40.7128, -74.0060, "Placidus")
+    demo = {
+        "angles": {"asc": h.asc, "mc": h.mc, "vertex": h.vertex, "east_point": h.east_point},
+        "cusps": h.cusps,
+        "bodies": {
+            "Sun": {"lon": 54.6, "retro": False}, "Moon": {"lon": 300.2, "retro": False},
+            "Mercury": {"lon": 47.1, "retro": True}, "Venus": {"lon": 78.0, "retro": False},
+            "Mars": {"lon": 300.9, "retro": False}, "Saturn": {"lon": 293.4, "retro": False},
+        },
+        "aspects": [
+            {"a": "Sun", "b": "Mercury", "aspect": "conjunction", "orb": 7.5},
+            {"a": "Moon", "b": "Saturn", "aspect": "conjunction", "orb": 6.8},
+            {"a": "Sun", "b": "Moon", "aspect": "trine", "orb": -5.6},
+        ],
+    }
+    svg = render_svg(demo, title="Demo Chart")
+    with open("demo_chart.svg", "w", encoding="utf-8") as fh:
+        fh.write(svg)
+    print(f"wrote demo_chart.svg ({len(svg)} bytes); asc={h.asc:.2f} mc={h.mc:.2f}")