Terminus: shelves of the sky

Proposal section 3: how high do we build?

Hang a lamp low over a table, and it throws a small, bright circle. Raise it, and the circle grows, but the light spreads thin and arrives from far away. Every satellite constellation is a negotiation with that lamp, and before we commit a single spacecraft we owe the RFP a survey of every height the sky offers. Last time we learned we cannot steer our orbits to follow the twilight band; the fleet will fly fixed rings and hand duty from one to the next. What is still wide open is the altitude of those rings — and altitude, it turns out, is a three-way tug-of-war in which one beloved contestant never even makes it to the rope.

Three things every altitude must buy

A footprint. A satellite does not serve everyone who can technically see it. Near the horizon, its signal grazes through hills, forests, weather, and kilometers of thick atmosphere — and on this planet something worse lives at the horizon: the red star itself, sitting there forever, hissing radio noise exactly where a low satellite would appear. So we count a satellite as usable only when it stands at least 25 degrees above the horizon. That rule carves out the footprint: the patch of ground, directly under the satellite, close enough to see it that high in the sky.

The geometry is one triangle, and it is worth drawing carefully, because every number in this post falls out of it. Put the planet's center at O, the satellite at S, and a user at the very edge of coverage at U. Two sides are known before we launch anything: O→U is the planet's radius R, and O→S is R + h. What we want is the angle at O — the planet-central angle λ swept from the sub-satellite point out to that edge user — because the footprint is nothing more than that angle walked along the ground.

The third corner is where the elevation rule enters, and it is the step worth slowing down for. Stand at U and look flat along the horizon: that sight line is perpendicular to the vertical O→U, so a satellite sitting exactly on the horizon would make a right angle at U. Now lift it. Every degree of elevation swings the sight line further away from the direction back down to O, opening that angle by exactly as much. So the interior angle of the triangle at U is not 90° − ε but

∠OUS = 90° + ε

Obtuse — and that one fact is the whole reason a high mask is expensive. Now the triangle is determined. The law of sines relates the angle at S — the nadir angle η, how far off straight-down the satellite must look to see this user — to the side opposite it, and the angles have to close:

law of sines
  sin η / R = sin(90° + ε) / (R + h)
  sin η = (R / (R + h)) · cos ε
  η = arcsin( (R / (R + h)) · cos ε )

angles close
  λ + η + (90° + ε) = 180°
  λ = 90° − ε − η

The top block hands us η; the bottom one is waiting for it. Substitute, and notice that a 90° − sitting in front of an arcsin is exactly an arccos — so the whole derivation collapses to a single line:

λ = arccos( (R / (R + h)) · cos ε ) − ε

The triangle. Two sides are known before anything is launched: R and R + h. The angle at U is the one worth pausing on — the user's zenith runs along O→U extended and the satellite stands ε above the horizon, so the interior angle there is 90° + ε. Obtuse, which is precisely why the mask is expensive.

What ε costs. Drop the mask to the horizon and the same satellite reaches 7,461 km instead of 4,931. The violet arc is ground the red star's noise floor takes from us. The tax is not evenly spread: it shrinks the 300 km shelf by 3.41× and the 20,000 km shelf by only 1.45×.

Which is the toolkit, verbatim:

/// Planet-central angle (rad) from the sub-satellite point to the edge
/// of coverage, for a satellite at `altitude` seen at `min_elevation`.
fn coverage_half_angle(body: &CentralBody, altitude: f64, min_elevation: f64) -> f64 {
    let ratio = body.radius / (body.radius + altitude);
    (ratio * min_elevation.cos()).acos() - min_elevation
}

/// Great-circle radius (m) of the ground area a satellite serves.
pub fn footprint_radius(body: &CentralBody, altitude: f64, min_elevation: f64) -> f64 {
    body.radius * coverage_half_angle(body, altitude, min_elevation)
}

The footprint is then just arc length: the angle λ walked along the surface, R·λ — which is also why the angle has to arrive in radians for the multiplication to produce a distance at all.

Two limits are worth taking, because between them they bracket everything the survey is about to say. Set ε to zero, and the mask disappears: λ collapses to arccos(R / (R + h)), the schoolbook horizon, the farthest a satellite can be seen at all. Then let h run away to infinity. The ratio R / (R + h) goes to zero, its arccos saturates at a right angle, and

λ → 90° − ε

That is a wall, not a trend. No altitude, no budget, no launch vehicle buys a satellite that serves more than 65 degrees of arc out from beneath it — 7,228 km of ground radius on this planet and not a meter farther. Hold on to that number. The survey is about to walk straight up to it and stop.

Speed of light. Radio waves travel at light speed — fast, but not instant, and the RFP's latency budget (TER-REQ-003) is written in milliseconds. Every kilometer of altitude is a kilometer the signal must climb and descend, and the worst case is a user at the footprint's edge, where the slant path is longest.

How long is that path? It is the third side of the triangle we just drew. Stand at U again and walk out along the sight line a distance d: you rise d sin ε straight up and travel d cos ε along the ground, so the satellite's distance from the planet's center must satisfy:

(R + d sin ε)² + (d cos ε)² = (R + h)²

Which is a quadratic in d. Its positive root is the slant range:

d = R · [ √( ((R + h)/R)² − cos²ε ) − sin ε ]

/// Slant range (m) from a ground user at exactly the minimum elevation
/// angle to the satellite — the longest, highest-loss path in the footprint.
pub fn edge_slant_range(body: &CentralBody, altitude: f64, min_elevation: f64) -> f64 {
    let ratio = (body.radius + altitude) / body.radius;
    body.radius * ((ratio * ratio - min_elevation.cos().powi(2)).sqrt() - min_elevation.sin())
}

Latency is then that distance over c, and the two limits behave: point the user straight up (ε = 90°), and d collapses to h, the altitude and nothing more; drop the mask to the horizon, and d becomes √((R+h)² − R²), the tangent line grazing the planet.

The edge user pays for this twice over, and again it is the low shelves that suffer. At 300 km, the edge path is 648 km — 2.16 times the altitude, because the satellite is far off to the side rather than overhead. At 50,000 km, it is only 1.07 times: from that height nearly everyone in the footprint is, near enough, straight up.

Dwell. The satellites move — post 2's lesson made sure of that — so a user's satellite eventually slides below the acceptable sky, and another must take over the conversation mid-sentence. That handover machinery gets its own posts later; for now the survey only asks how often we would invoke it: how long does one satellite stay usably overhead on its best pass?

λ answers this one too, because it is the same cone read from the other end. The satellite clears the mask exactly while the angle between it and the user — measured at the planet's center — is less than λ. That window is an arc of 2λ out of the whole 2π lap:

pass fraction = 2λ / 2π = λ / π
max pass      = (λ / π) · T

/// Duration (s) of the best-case pass, straight through the zenith, for a
/// ground user on a slowly rotating body: the satellite is visible while it
/// crosses `2 × coverage_half_angle` of its orbit.
pub fn max_pass_duration(body: &CentralBody, altitude: f64, min_elevation: f64) -> f64 {
    let lambda = coverage_half_angle(body, altitude, min_elevation);
    lambda / std::f64::consts::PI * orbital_period(body, altitude)
}

A pass is a fraction of a lap

The satellite clears the mask over the arc 2λ — the same λ the footprint used, because it is the same cone seen from the other end. Out of a full 2π lap that is the fraction λ/π, and the pass lasts that fraction of the orbital period. At this shelf the window is 24.6% of a lap: 85.6 minutes out of 5.79 hours.

Two honest caveats. This is the best pass — one straight through the user's zenith; a satellite that clips the edge of the footprint is overhead for far less. And it ignores the ground turning underneath, which is a fair simplification on a planet whose day is 11.2 of ours, though not a free one: a 37-hour pass at 50,000 km spans about a seventh of a rotation.

What makes dwell the table's most violent column is that altitude buys it twice. Climbing from 300 km to 50,000 km stretches the period 24.6× — and widens λ another 11.7× on top of that. The product is 287×, which is how two and a half minutes becomes twelve hours.

The survey

One command prices every shelf:

cargo run -p terminus-orbits --example regime_survey

  alt (km)   period (h)   footprint (km)  edge latency (ms)   max pass (min)
       300         1.51              562                2.2              2.5
      1200         1.82             1701                7.4              9.3
      1800         2.04             2228               10.3             13.6
     10000         5.79             4931               42.1             85.6
     20000        11.84             5821               76.8            206.6
     50000        37.00             6574              178.1            729.1

Read it as a menu of personalities. The bottom shelf, 300 km, is the sprinter: two milliseconds up, a signal so short and strong the terminals could be simple — and a footprint barely 560 km in radius that drags out from under you in two and a half minutes. Serving the whole twilight band with sprinters means swarms of them and a handover every few minutes for every terminal on the planet. The middle shelves, 1,200–1,800 km, are the honest laborers: ten milliseconds, footprints a couple of thousand kilometers across, a quarter hour per pass. The high shelves, 10,000 km and up, are the slow giants: one satellite shades nearly a third of the planet and lingers for hours — an afternoon-long conversation instead of a corridor of quick introductions — but every word now pays a 40-to-180-millisecond toll, and a signal spread over that distance demands bigger antennas, more power, more satellite.

Plot the two against altitude, and the asymmetry is the whole story. The footprint runs into the wall we derived above; the latency has no wall to run into.

Footprint radius — saturates

Every kilometer of altitude buys less ground than the one below it. The arc a satellite can serve is capped at R·(90° − ε) whatever you spend, and the 50,000 km shelf already holds 91% of that. There is no altitude where the lamp gets meaningfully wider.

Edge latency — does not

The bill has no such courtesy. Slant range grows roughly with altitude forever, so the same climb that stops widening the footprint keeps lengthening every word spoken through it — 82× the latency between the two ends of the survey, for 12× the footprint.

That is the lamp, and the survey has now priced it. No shelf wins all three currencies. But an engineer raised under a fast yellow sun knows there is supposed to be one more shelf — the magic one.

The fixed star that isn't there

Every spacefaring civilization discovers the same trick early. There is always one altitude where a satellite's orbital period exactly matches the planet's rotation, so the satellite circles in lockstep with the ground and hangs, from the ground's point of view, at a fixed point in the sky forever. Around Earth, that shelf sits at about 36,000 km, and whole industries bolted their dishes to walls, aimed once, and never moved them again. A fixed point in the sky is infrastructure's dearest dream — no tracking, no handover, ever.

Notice what that shelf really is. It is the one place in the sky where the two frames from the last section stop disagreeing — where the hoop's loyalty to the distant stars and the ground's loyalty to its own rotation happen to ask for the same thing. A satellite there is not fighting the planet's turn; it is matching it, and matching it for free. Every degree of alignment we priced at 3.9 km/s a day comes included.

That shelf has an address, and finding it takes one idea: what fixes an orbit's period.

A circular orbit is a standing compromise. Gravity pulls the satellite straight at the planet's center, and the satellite is traveling at right angles to that pull. Because the pull is always sideways to the motion, it never speeds the satellite up and never slows it down — it only bends the path. Get the speed exactly right, and the bend closes into a circle instead of a crash or an escape.

How hard gravity pulls is set by a single number: the planet's mass rolled together with Newton's constant, μ = GM, the standard gravitational parameter. That is what body.mu means everywhere in this toolkit — for an Earth-mass planet, 3.986 × 10¹⁴ m³/s². What gravity supplies and what a circle demands then have to agree:

gravity supplies    μ / r²
a circle demands    v² / r
set equal           v = √( μ / r )

Each radius permits exactly one speed, and higher orbits are slower — not intuition, arithmetic. The period is one lap at that speed:

T = 2πr / v = 2π √( r³ / μ )

That is Kepler's third law, T² ∝ r³, and it is the whole of the toolkit's period function:

/// Circular orbital period at the given altitude, s.
pub fn orbital_period(body: &CentralBody, altitude: f64) -> f64 {
    let r = body.radius + altitude;
    2.0 * PI * (r.powi(3) / body.mu).sqrt()
}

The stationary shelf is that same equation run backward. We are handed T — the planet's rotation period, 11.2 days — and we want the radius that produces it:

r_sync = ∛( μ T_rot² / 4π² )

/// Radius (from body center) of the orbit whose period equals the
/// body's rotation period — the stationary orbit, m.
pub fn synchronous_radius(body: &CentralBody) -> f64 {
    let t = body.rotation_period;
    (body.mu * t * t / (4.0 * PI * PI)).cbrt()
}

One radius, one speed

Gravity pulls straight at the center while the satellite moves at right angles to it, so it never speeds the satellite up or slows it down — it only bends the path. Setting the pull equal to what a circle demands leaves exactly one speed per radius, and the lap time follows.

Kepler, and where 11.2 days lands

On log axes T² ∝ r³ is a straight line of slope 3/2. Come across at the planet's rotation period, drop down where you meet the line, and you have the stationary shelf. The whole survey is the huddle at bottom left; the shelf is off past the far right.

Now watch what that cube root does to a slow planet. Radius grows only as T^(2/3), so a much longer day buys a surprisingly modest amount of extra distance — modest, at least, until you remember how far out the shelf already starts. Earth turns once in 23.93 hours, and its shelf sits 42,164 km from the center, which puts it at the ~36,000 km overhead quoted above. This planet's day is 11.23 times longer, and 11.23 to the two-thirds is 5.01:

Stationary shelf, scaled from Earth's:
  Earth synchronous radius:      42164 km (altitude 35793 km)
  this planet spins              11.23x slower
  radius grows as T^(2/3):        5.01x  =>  211453 km

So the shelf lies at 211,453 km from the planet's center — 205,000 km overhead. The survey already frowns: from that height, the edge user's signal takes 0.7 seconds one way, which by itself wrecks any conversation held to the RFP's latency budget. But the real objection is more fundamental. It is not that this orbit would be slow. It is that this orbit does not exist.

An orbit is a courtship between a satellite and a planet — but the star is always in the room. Near the planet, the planet's gravity rules, and orbits behave. Far enough out, the star's pull dominates, and a "satellite of the planet" quietly becomes a satellite of the star. The boundary bubble is called the Hill sphere, and its size follows from a custody arithmetic — how heavy the planet is, how heavy the star is, and above all how close they live to each other:

r_Hill ≈ a · ∛( m_planet / 3 M_star )

Three things live in that expression. The distance to the star, a, enters plainly: move a planet twice as close, and its authority halves. The masses enter only as a ratio — and that ratio is then buried under a cube root, which flattens it almost out of existence. This planet is one part in 40,619 of its star; the cube root turns that crushing deficit into roughly one part in thirty-four, and the 3 underneath brings it to about one part in fifty. Mass barely matters here. Distance decides.

/// Hill radius (m): the region where the planet's gravity dominates
/// the star's.
pub fn hill_radius(body: &CentralBody, star_mu: f64, orbital_distance: f64) -> f64 {
    orbital_distance * (body.mu / (3.0 * star_mu)).cbrt()
}

/// Conservative outer limit for long-lived prograde satellite orbits:
/// roughly half the Hill radius.
pub fn prograde_stability_limit(body: &CentralBody, star_mu: f64, orbital_distance: f64) -> f64 {
    0.5 * hill_radius(body, star_mu, orbital_distance)
}

That second function is caution rather than physics. Orbits near the rim of the Hill sphere are not forbidden so much as unreliable: the star keeps tugging, the orbit keeps stretching, and eventually it wanders off. How much margin you need depends, oddly enough, on which way you go around. Numerical work puts the survival radius near nine-tenths of the Hill radius for retrograde orbits — satellites circling against the planet's motion around the star — but only about half for prograde ones, which is why the function carries that word in its name. Half is the generous reading of a generous case, and we are about to fail the test anyway.

Our planet is Earth's mass, but it huddles just 0.0485 AU from its 0.122-solar-mass star — twenty times closer than Earth to the Sun. Its bubble of authority is correspondingly small:

Stationary orbit check:
  synchronous radius:           211453 km (altitude 205082 km)
  planet / star mass ratio:   2.462e-5 (1 : 40619)
  Hill radius:                  146347 km (2.02% of the way to the star)
  prograde stability limit:      73173 km
  verdict: synchronous radius is 2.9x the stability limit —
           no stationary orbit exists around this planet.

Whose satellite is it?

Near the planet, the planet wins and orbits behave. Far enough out the star wins, and a "satellite of the planet" quietly becomes a satellite of the star. The boundary is the Hill sphere, and the Lagrange points L1 and L2 sit on its rim, on the line to the star.

To scale, and the verdict

Everything the survey priced fits in the first quarter of this bar. The shelf we actually want sits past the stability limit, past the Hill radius, out where the planet has no say at all — not slow, not expensive, simply not available.

The lockstep shelf lies nearly three times beyond the distance where the planet can keep a satellite at all. Park anything there, and the red star takes it — another small cold thing lost to the tide. Civilizations under yellow suns get to hang their unblinking artificial stars over the equator and build cathedrals of fixed antennas beneath them. This sky refuses. Whatever we build for this world will move across its heavens, and every antenna, protocol, and session will be designed around that motion. We record the exclusion formally as ADR-0002.

One consolation: the same custody arithmetic hands us two fixed addresses for free. Where the star's pull and the planet's pull strike a truce, the star-planet line carries two of the five Lagrange points — L1 between the planet and the star, L2 directly behind the planet — and they sit on the rim of the bubble, about 146,000 km out. That is no coincidence: the Hill radius is essentially defined as the distance to those two points, which is why the number matches. Both are unstable equilibria, so a spacecraft at either one needs an occasional nudge to stay put — quasi-fixed rather than fixed. And nothing there can serve a conversation at 0.5 seconds one way. But remember those addresses; they will matter when this proposal asks where to keep things that are precious and patient.

What survives the survey

The menu is now honest. The sprinters and laborers of the low shelves will carry the users; the slow giants of the high shelves offer hours-long dwell that is about to become unexpectedly valuable; the magic shelf is a fiction of kinder suns. Next time we finally place hardware: how many rings, how many satellites on each, and what it takes to keep every town in the twilight band under at least one usable satellite, every second, forever. The number will be larger than the AI's accountants might hope — and the reasons why are where arithmetic hands over to simulation.