Add the chart conventions

1. Make the Earth chart entry

Imagine a pointer at 350° on a circle. Turning it halfway around adds 180°, reaching 530°. Subtracting one full turn leaves 170°, the same direction written within one circle. The engine makes the Earth chart longitude this way from the Sun longitude.

Earth longitude = wrap(Sun longitude + 180°)

Here wrap means retain the equivalent direction in [0°, 360°): include zero and exclude a full turn. Given a Sun entry with longitude 350°, speed 0.98°/day and declination −8°, earth_from_sun returns Earth longitude 170°, speed 0.98°/day and declination −8°. The fixed half-turn changes longitude without changing its daily rate.

That distinction matters downstream: a consumer receiving a name, longitude, speed and declination needs to know how each field was produced. An Earth label does not by itself establish that all fields describe a physical direction from one common origin.

const wrap = (x: number): number => { const r = x % 360; return r < 0 ? r + 360 : r; };
const earthFromSun = (sun: { longitude: number; speed: number; declination: number }) =>
  ({ name: "Earth", longitude: wrap(sun.longitude + 180), speed: sun.speed, declination: sun.declination });

2. Make the paired node entries

The Moon’s orbital plane crosses the ecliptic along a line. Its ascending crossing direction is already stored as the NodeOmega longitude series, prepared in the earlier lunar-node lesson. The runtime reads that direction and constructs the other end of the line with the same half-turn we just used.

For an invented north longitude Ω = 90°, the south longitude is 270°. To express the north direction relative to the equator, the engine uses the tilt between the ecliptic and equator, called obliquity ε. A point on the ecliptic has a north–south component sin ε × sin Ω in the equatorial frame. Taking inverse sine recovers its declination.

δ = asin(sin ε × sin Ω); south longitude = wrap(Ω + 180°)

Sine turns an angle into a component ratio; inverse sine, written asin, turns that ratio back into an angle between −90° and +90°. With the deliberately simplified ε = 30° and Ω = 90°, sin 30° = 0.5 and sin 90° = 1. The product is 0.5, so δ = 30°. Use radians inside TypeScript’s sine and inverse-sine functions: multiply degrees by π/180 before sine and multiply the inverse-sine result by 180/π.

Ephemeris::node_pair obtains speed from the centered difference of NodeOmega and true obliquity from the engine time model. With invented speed −0.05°/day, the north output is (90°, −0.05°/day, +30°) and the south output is (270°, −0.05°/day, +30°).

const nodeDeclination = (omegaDegrees: number, epsilonDegrees: number): number =>
  Math.asin(Math.sin(epsilonDegrees * Math.PI / 180) * Math.sin(omegaDegrees * Math.PI / 180)) * 180 / Math.PI;

3. Assemble the ordered body list

We now have two kinds of entries: evaluated places and derived chart points. A stable list keeps their names and fields together, so a caller can consume the same output contract for every chart. Start with twelve evaluated source bodies and add one Earth entry and two node entries: 12 + 1 + 2 = 15.

The actual order is Sun, Earth, Moon, NorthNode, SouthNode, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, Chiron, Ceres. chart_bodies inserts Earth immediately after the Sun and both nodes immediately after the Moon; chart_body copies each sampled place into named output fields. The twelve source bodies exclude NodeOmega; the node series is accessed separately to construct the pair.

12 sampled bodies + 1 derived Earth + 2 node entries = 15 body-list entries

For example, before processing Mercury the list already contains five entries: Sun, Earth, Moon and both nodes. Mercury becomes the sixth entry. This list is the input to the final chart assembly, which later appends four observer-dependent angles. Fifteen is the count at this boundary, not the final chart count.