@essrt/physics 23.3.2 → 23.6.0

package/src/model/planet-elements-of-date.js

@@ -0,0 +1,61 @@
+/**
+ * The planets' elements of date — the chain with the series handover: ϖ, Ω (S&S origin), i, e.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { DEEP_MODES_ARTIFACT } from '../moon/deep-modes-artifact.cjs';
+import { CHAIN_ARTIFACT } from '../planets/chain-artifact.js';
+import { computeEquatorNodeOriginSFrameDeg, convertNodeSFrameToEquatorOriginDeg } from '../planets/inv-plane-frame.cjs';
+import { buildPlanetChainsFromArtifactData, computePlanetElementsAtYear } from '../planets/keplerian-chain.cjs';
+import { createSecularSeriesOverride } from '../planets/secular-series.cjs';
+
+/** @param {import('./planet-spin-channel.js').Ctx} ctx @returns the bindings the later slices read */
+export function assemblePlanetElementsOfDate(ctx) {
+  const { C, secularSeriesArtifact } = ctx;
+  // The planets' elements of date ride THE CHAIN — the only planet path the
+  // simulator renders — with the series handover beyond each planet's
+  // measured boundary when the series artifact is supplied: the mirror of the
+  // browser's _chainElementsOfDate → _chainSeriesSecularEl. The chain's
+  // argument is dynamical time; the API's decimal year is taken as that
+  // argument (ΔT on a secular element is far below its stated accuracy).
+  let planetChains = /** @type {any} */ (null);
+  let planetSeriesOverride = /** @type {any} */ (null);
+  let planetNodeOriginSSDeg = /** @type {number|null} */ (null);
+  /** @param {string} k @param {number} year */
+  const planetChainElementsAt = (k, year) => {
+    if (!planetChains) planetChains = buildPlanetChainsFromArtifactData(/** @type {any} */ (CHAIN_ARTIFACT));
+    const el = computePlanetElementsAtYear(year, planetChains[k], planetChains);
+    const seriesArt = /** @type {any} */ (secularSeriesArtifact);
+    if (!seriesArt) return el;
+    if (!planetSeriesOverride) {
+      planetSeriesOverride = createSecularSeriesOverride({
+        series: seriesArt,
+        anchorElements: /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements,
+        invariablePlane: /** @type {any} */ (CHAIN_ARTIFACT).invariablePlane,
+        planetZModes: /** @type {any} */ (DEEP_MODES_ARTIFACT).planetZ,
+        planetZetaModes: /** @type {any} */ (DEEP_MODES_ARTIFACT).planetZeta,
+      });
+    }
+    return planetSeriesOverride.applyToElements(k, year, el);
+  };
+  /** Ecliptic longitude of perihelion, J2000 ecliptic and equinox (the chain's ϖ). @param {string} k @param {number} year @returns {number} */
+  const planetPerihelionDeg = (k, year) => planetChainElementsAt(k, year).lonPeriEclipticDeg;
+  /** The S&S longitude origin as an s-frame longitude (J2000-fixed, derived). @returns {number} */
+  const nodeOriginSSDeg = () => {
+    if (planetNodeOriginSSDeg === null) {
+      planetNodeOriginSSDeg = computeEquatorNodeOriginSFrameDeg(/** @type {any} */ (CHAIN_ARTIFACT).invariablePlane, C.earthOrbital.obliquityJ2000_deg);
+    }
+    return planetNodeOriginSSDeg;
+  };
+  /** Ascending node on the model's invariable plane, from the plane's ascending node on the ICRF equator (the Souami & Souchay 2012 origin; derived conversion, inv-plane-frame). @param {string} k @param {number} year @returns {number} */
+  const planetAscNodeDeg = (k, year) => convertNodeSFrameToEquatorOriginDeg(planetChainElementsAt(k, year).ascNodeInvPlaneDeg, nodeOriginSSDeg());
+  /** Inclination to the model's invariable plane (exact orbit-normal rotation). @param {string} k @param {number} year @returns {number} */
+  const planetInclinationDeg = (k, year) => planetChainElementsAt(k, year).inclInvPlaneDeg;
+  /** Orbital eccentricity of date, from the same chain elements — the chain's
+   *  multi-mode e-vector has no single base + amplitude + phase triple, so the
+   *  value of date is the published form. @param {string} k @param {number} year @returns {number} */
+  const planetEccentricity = (k, year) => planetChainElementsAt(k, year).e;
+
+  return { nodeOriginSSDeg, planetAscNodeDeg, planetEccentricity, planetInclinationDeg, planetPerihelionDeg };
+}
+/** @typedef {import('./planet-spin-channel.js').Ctx & ReturnType<typeof assemblePlanetElementsOfDate>} Ctx */

package/src/model/planet-records.js

@@ -0,0 +1,63 @@
+/**
+ * The planets' structural records — keys, mass fractions, the published J2000 record.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { CHAIN_ARTIFACT } from '../planets/chain-artifact.js';
+import { PLANET_DISPLAY_NAMES } from '../planets/display-names.cjs';
+import { computeObliquityJ2000Deg } from '../planets/spin-channel.cjs';
+
+/** @param {import('./delta-t.js').Ctx} ctx @returns the bindings the later slices read */
+export function assemblePlanetRecords(ctx) {
+  const { C, GM_EARTH_ALONE, G_CONSTANT, M_SUN } = ctx;
+  const PLANET_KEYS = ['mercury', 'venus', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune'];
+  const massEarthAlone = GM_EARTH_ALONE / G_CONSTANT;
+  /** @type {Record<string, number>} */
+  const massFraction = {};
+  for (const k of PLANET_KEYS) massFraction[k] = 1 / C.physicalConstants.massRatioDE440[k];
+  massFraction.earth = massEarthAlone / M_SUN;
+
+  /** @type {Record<string, Record<string, any>>} */
+  const PUBLISHED_PLANET_RECORDS = {};    // what model.planets.record() serves
+  for (const k of PLANET_KEYS) {
+    const ar = C.planetOrbitalElements[k];
+    // The obliquity is the DERIVED J2000 obliquity of the spin channel (the
+    // IAU pole against the chain's J2000 plane, acute form) — from the
+    // governed artifacts.
+    const obliquityDerived = computeObliquityJ2000Deg({
+      spin: C.planetSpinPhysical[k],
+      anchorInclEclipticDeg: /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements[k].inclEclipticDeg,
+      anchorAscNodeEclipticDeg: /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements[k].ascNodeEclipticDeg,
+      obliquityJ2000Deg: C.earthOrbital.obliquityJ2000_deg,
+    });
+    const obliquityMean = Math.min(obliquityDerived, 180 - obliquityDerived);   // acute form of the derived J2000 obliquity
+    // What `model.planets.record()` PUBLISHES is the structural record: the
+    // REFERENCE inputs (IAU J2000 ϖ, the Souami & Souchay node and
+    // inclination, DE440 e, the period input, the axial tilt), the DERIVED
+    // `obliquityMean` (the spin channel against the chain's J2000 plane), and
+    // the two PERIODS that are chain eigenmodes — 1,296,000/g and 1,296,000/s
+    // (apsidal prograde positive, nodal regression negative). Quantities that
+    // vary with the epoch (e, i, Ω, ϖ of date) are served AT AN EPOCH by
+    // planet-elements-of-date.js and `/v1/bodies`' `at[]` rows, never as a
+    // single oscillation's mean + amplitude + phase — the chain's multi-mode
+    // vectors have none.
+    const chainModes = /** @type {any} */ (CHAIN_ARTIFACT);
+    const gArc = chainModes.g[k] && chainModes.g[k].arcsecPerYr;
+    const sArc = chainModes.s[k] && chainModes.s[k].arcsecPerYr;
+    PUBLISHED_PLANET_RECORDS[k] = Object.freeze({
+      name: PLANET_DISPLAY_NAMES[k],   // presentation — planets/display-names, the deleted JSON's last leaf (plan 11 step 6)
+      solarYearInput: ar.solarYearInput,
+      longitudePerihelion: ar.longitudePerihelion,
+      ascendingNodeInvPlane: ar.ascendingNodeInvPlaneClosedForm,   // the closed-form verified J2000 node — astro-reference since plan 11 step 2
+      invPlaneInclinationJ2000: ar.invPlaneInclinationJ2000,
+      orbitalEccentricityJ2000: ar.orbitalEccentricityJ2000,
+      axialTiltJ2000: ar.axialTiltJ2000,
+      obliquityMean,
+      perihelionEclipticYears: gArc ? 1296000 / gArc : undefined,
+      ascendingNodePeriod: sArc ? 1296000 / sArc : undefined,
+    });
+  }
+
+  return { PLANET_KEYS, PUBLISHED_PLANET_RECORDS, massFraction };
+}
+/** @typedef {import('./delta-t.js').Ctx & ReturnType<typeof assemblePlanetRecords>} Ctx */

package/src/model/planet-spin-channel.js

@@ -0,0 +1,41 @@
+/**
+ * The planets' spin channel — each planet's precession constant from its own torques on the chain's orbit.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { DEEP_MODES_ARTIFACT } from '../moon/deep-modes-artifact.cjs';
+import { CHAIN_ARTIFACT } from '../planets/chain-artifact.js';
+import { createPlanetSpinChannelFromArtifacts } from '../planets/spin-channel.cjs';
+
+/** @param {import('./planet-records.js').Ctx} ctx @returns the bindings the later slices read */
+export function assemblePlanetSpinChannel(ctx) {
+  const { C, GM_SUN, PLANET_KEYS, massFraction } = ctx;
+  // The planets' spin channel: the precession constant
+  // from each planet's OWN torques (astro-reference planetSpinPhysical) on the
+  // model's OWN orbit — the chain's J2000 a/e/plane and the deep ζ table —
+  // integrated as dŝ/dt = α(ŝ·n̂)(ŝ×n̂) from the IAU J2000 pole. ONE home:
+  // planets/spin-channel.cjs; built lazily per planet, pure in `year`.
+  /** @type {Map<string, ReturnType<typeof createPlanetSpinChannelFromArtifacts>>} */
+  const spinChannels = new Map();
+  /** @param {string} k */
+  const planetSpin = (k) => {
+    if (!PLANET_KEYS.includes(k)) throw new Error(`planets.spin: unknown planet '${k}'`);
+    let ch = spinChannels.get(k);
+    if (!ch) {
+      ch = createPlanetSpinChannelFromArtifacts({
+        key: k,
+        planetSpinPhysical: C.planetSpinPhysical,
+        chainAnchorElements: /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements,
+        planetZeta: /** @type {any} */ (DEEP_MODES_ARTIFACT).planetZeta,
+        massFractionOfSun: massFraction[k],
+        gmSunKm3S2: GM_SUN,
+        obliquityJ2000Deg: C.earthOrbital.obliquityJ2000_deg,
+      });
+      spinChannels.set(k, ch);
+    }
+    return ch;
+  };
+
+  return { planetSpin };
+}
+/** @typedef {import('./planet-records.js').Ctx & ReturnType<typeof assemblePlanetSpinChannel>} Ctx */

package/src/model/published-periods.js

@@ -0,0 +1,38 @@
+/**
+ * The published periods of date — the seamed precession period, tropical year and sidereal year (one-family inside the window, the deep chain beyond).
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { ONE_FAMILY_WINDOW_YEARS } from '../earth/year-lengths.cjs';
+
+/** @param {import('./sun-and-eclipses.js').Ctx} ctx @returns the bindings the later slices read */
+export function assemblePublishedPeriods(ctx) {
+  const { certifiedAxialPrecessionJ2000Years, deepLod, yearLengthsM, yearToTMa } = ctx;
+  // Plan 06 Phase 3 S2 — THE published of-date precession period and mean
+  // tropical year: the one-family route (B) inside the banked tiers
+  // (|Δyear| ≤ ONE_FAMILY_WINDOW_YEARS), the composed lunisolar period
+  // beyond (S5: on the derived J2000 anchor, so the two faces agree at
+  // 25,771.4 at J2000 and the deep tail is the same clock scaled; the
+  // tidal-chain year). Shared by `epoch` and `lunisolar`.
+  /** @param {number} year @returns {number} */
+  const publishedAxialPrecessionYearsAtYear = (year) => {
+    if (Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS) return yearLengthsM.axialPrecessionYearsAtYear(year);
+    const p = deepLod.lunisolarPrecessionPeriodYearsAtAge(yearToTMa(year));
+    return p === null ? certifiedAxialPrecessionJ2000Years() : p;
+  };
+  /** @param {number} year @returns {number} */
+  const publishedTropicalYearSecondsAtYear = (year) => {
+    if (Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS) return yearLengthsM.tropicalYearSecondsAtYear(year);
+    return deepLod.tropicalYearSecondsAtAge(yearToTMa(year));
+  };
+  /** The published sidereal year of date, SI seconds — the one-family λ̇
+   *  channel inside the window, the mass-loss law beyond (plan 09: the
+   *  `lengths` surface's days ride it). @param {number} year @returns {number} */
+  const publishedSiderealYearSecondsAtYear = (year) => {
+    if (Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS) return yearLengthsM.siderealYearSecondsAtYear(year);
+    return deepLod.siderealYearSecondsAtAge(yearToTMa(year));
+  };
+
+  return { publishedAxialPrecessionYearsAtYear, publishedSiderealYearSecondsAtYear, publishedTropicalYearSecondsAtYear };
+}
+/** @typedef {import('./sun-and-eclipses.js').Ctx & ReturnType<typeof assemblePublishedPeriods>} Ctx */

package/src/model/sun-and-eclipses.js

@@ -0,0 +1,199 @@
+/**
+ * The certified Sun and the eclipse tier — the mean longitude of date, the finders, the planetary completion, the besselian location tier.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { ONE_FAMILY_WINDOW_YEARS } from '../earth/year-lengths.cjs';
+import { createBesselian } from '../eclipse/besselian.cjs';
+import { createEclipseFinders } from '../eclipse/finders.cjs';
+import { computeCarrierRatesDegPerCy, createSunPlanetaryCompletion } from '../eclipse/sun-planetary-completion.cjs';
+
+/** @param {import('./lunar-theory.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleSunAndEclipses(ctx) {
+  const {
+    C, F, late, MASS_RATIO_EARTH_MOON, currentAUDistance, frameworkDeltaTSecondsAtJD, j2000JD, jdTTFromUT,
+    julianCenturyDays, meanSiderealYearDays, meanSolarYearDays, moonArgs, moonDistanceKm, moonSeries,
+    moonSiderealMonthInput, moonSynodicMonthDays, obliquityDeg, oneFamilyTropicalYearSeconds, sunEccentricityAt,
+    sunPerihelionDegAt, yearFromJD,
+  } = ctx;
+  // The certified Sun — assembled from the model's own laws, ZERO fitted Sun
+  // constants: e(t) and ϖ(t) are the eclipse Sun's mean elements of date
+  // (earth-scalars.js: the one-source series plus the derived mean offset);
+  // L(t) is the integral of the one-family tropical year (below). The
+  // finders, the derived planetary completion and the besselian location
+  // tier are wired on it; the sun-vs-horizons gate banks its modern-window
+  // residual, the eclipse audit the finders' canon statistics.
+  const sunL0Deg = C.earthOrbital.sunMeanLongitudeJ2000_deg;
+  const sunTropicalRateDegPerCy = 360 * julianCenturyDays / meanSolarYearDays;
+  const sunMeanLongitudeDegAt = (() => {
+    // The Sun's mean longitude of date is the INTEGRAL of the one-source
+    // tropical year: L(t) = L0 + 360·∫_{2000}^{t} dt′/T_trop(t′), T_trop the
+    // one-family tropical year of date in SI seconds (one-source-movement.js).
+    // MEASURED: it equals the IAU/Laskar drift expression to 0.1 s over
+    // −1000..+3000. The smooth year cannot carry the Earth–Mars–Jupiter long
+    // inequality (1783 yr, 6.3″); derived on the model's own N-body and
+    // shipped in the planetary completion, the JPL instrument reads 1.03″
+    // all-phase sd (Horizons ±3000 yr: modern-window mean +0.8″).
+    // NUMERICS (rate vs point value): a cumulative trapezoid table of
+    // cycles, yearly inside ±20,000 yr and per century beyond, grown on
+    // demand from 2000 in both directions and interpolated inside a cell —
+    // never a rate multiplied by a span. Beyond the one-family window the
+    // tidal-chain year continues the integrand (the scene overlay ends at
+    // 20,000 yr; the finders refuse out-of-domain epochs upstream).
+    const JULIAN_YEAR_S = 365.25 * 86400;
+    const tropSec = oneFamilyTropicalYearSeconds;
+    const FINE_SPAN = 20000, COARSE_STEP = 100;
+    /** cycles from 2000 to 2000 ± i·step (fwd/bwd tiers) */
+    /** @type {number[]} */ const fwdFine = [0];
+    /** @type {number[]} */ const bwdFine = [0];
+    /** @type {number[]} */ const fwdCoarse = [];
+    /** @type {number[]} */ const bwdCoarse = [];
+    /** UNSIGNED trapezoid cycles over the span between two years (Julian
+     *  years → SI seconds over the one-family year); the caller applies the
+     *  direction sign. @param {number} ya @param {number} yb @returns {number} */
+    const segAbs = (ya, yb) => 0.5 * (Math.abs(yb - ya) * JULIAN_YEAR_S) * (1 / tropSec(ya) + 1 / tropSec(yb));
+    /** signed cycles from 2000 to `year` @param {number} year @returns {number} */
+    const cyclesTo = (year) => {
+      const dy = year - 2000;
+      const s = dy >= 0 ? 1 : -1, a = Math.abs(dy);
+      // WARM THE SAMPLER TO THE TARGET FIRST (plan 06 R4, measured): the
+      // table below grows outward in 1-yr / 100-yr steps, and every step
+      // beyond ~1.6 Myr enlarged the one-family sampler's >2-Myr tier just
+      // past its span, rebuilding the whole deep integration about every 32
+      // steps — ~125 rebuilds and 22 s for the first deep-epoch call (the
+      // scene's first jump to −5 Myr), 0.4 ms once built. One read at the
+      // clamped target builds the tier at its final span; the grid stores
+      // are endpoint-independent, so every value is bit-identical.
+      tropSec(2000 + s * Math.min(a, ONE_FAMILY_WINDOW_YEARS));
+      const fine = s > 0 ? fwdFine : bwdFine;
+      const growFine = (/** @type {number} */ upto) => { while (fine.length <= upto) { const k = fine.length; fine.push(fine[k - 1] + s * segAbs(2000 + s * (k - 1), 2000 + s * k)); } };
+      if (a <= FINE_SPAN) {
+        const i = Math.floor(a), f = a - i;
+        growFine(i + 1);
+        return fine[i] + f * (fine[i + 1] - fine[i]);
+      }
+      growFine(FINE_SPAN);
+      const coarse = s > 0 ? fwdCoarse : bwdCoarse;
+      if (coarse.length === 0) coarse.push(fine[FINE_SPAN]);
+      const c = (a - FINE_SPAN) / COARSE_STEP, ci = Math.floor(c), cf = c - ci;
+      while (coarse.length <= ci + 1) { const k = coarse.length; const y0 = 2000 + s * (FINE_SPAN + (k - 1) * COARSE_STEP); coarse.push(coarse[k - 1] + s * segAbs(y0, y0 + s * COARSE_STEP)); }
+      return coarse[ci] + cf * (coarse[ci + 1] - coarse[ci]);
+    };
+    return /** @param {number} year @returns {number} */ (year) => sunL0Deg + 360 * cyclesTo(year);
+  })();
+  // The lunar arguments' Sun perihelion of date is the eclipse Sun's mean
+  // perihelion (`sunPerihelionDegAt`) read DIRECTLY, wrapped.
+  // Every consumer wraps the argument it enters (M = Lsun − ϖ − 180) or
+  // differences it over ±25 days (the rate anchors, wrapped to ±180°), so
+  // no continuous angle is needed. MEASURED: a 100-yr unwrapping ladder
+  // (two series reads per rung, 53,400 rungs at −5.34 Myr) cost the cold
+  // deep jump 1,062 s — 343× the in-table jump against the perf gate's 8× —
+  // for a value the consumers reduced mod 360 anyway.
+
+  // Eclipse finders — wired like the engine probe (tools/verify/
+  // eclipse-audit.js). The finder axis is JD(UT): the series wrapper applies
+  // UT→TT internally. Ground-track/umbra paths deliberately absent: the
+  // scene-umbra projection navigates the Tychosium-derived scaffold, which
+  // never enters this package (§2h).
+  const eclipseFinders = createEclipseFinders({
+    moonLonDegAt: /** @param {number} jd */ (jd) => moonSeries.truncatedLonDeg(jd),
+    moonBetaDegAt: /** @param {number} jd */ (jd) => moonSeries.truncatedBetaDeg(jd),
+    moonDistanceKmAt: /** @param {number} jd */ (jd) => moonSeries.truncatedDistanceKm(jd),
+    deltaTSecondsAt: frameworkDeltaTSecondsAtJD,
+    getSynodicMonthDays: () => moonSynodicMonthDays,
+    getSunDistanceKm: () => currentAUDistance,
+    frameworkSun: {
+      sunMeanLongitudeJ2000Deg: sunL0Deg,
+      tropicalRateDegPerCy: sunTropicalRateDegPerCy,
+      eccentricityAt: sunEccentricityAt,
+      perihelionLongitudeDegAt: sunPerihelionDegAt,
+      meanLongitudeDegAt: sunMeanLongitudeDegAt,
+    },
+    constants: {
+      rEarthMetres: (C.bodyDiametersKm.earth / 2) * 1000,
+      moonDiameterKm: C.bodyDiametersKm.moon,
+      sunDiameterKm: C.bodyDiametersKm.sun,
+      j2000JD,
+      julianCenturyDays,
+    },
+  });
+
+  // 20.3g — the solar-eclipse LOCATION tier: shadow geometry on the FULL
+  // series (sceneEvalAt — the truncated finder forms omit the fitted Lp
+  // anchor and the −2235·sin(Lp) β family, deliberate for finder
+  // statistics, required here) at the model's ABSOLUTE TT (deltaTStart +
+  // curve, the same convention every other ΔT consumer reads). Both axis
+  // conventions are measured against the NASA path-table centerlines —
+  // see eclipse/besselian.cjs.
+  // Derived Earth-around-EMB wobble for the Sun completion: a_M·μ/AU,
+  // μ = 1/(1+M_E/M_M) — 6.4399″ at current constants, tracks them live.
+  const embWobbleArcsec = (moonDistanceKm / (MASS_RATIO_EARTH_MOON + 1) / currentAUDistance)
+    * (648000 / Math.PI);
+  // FQ-5 N3 — the completion's carriers are FRAMEWORK-derived from the
+  // model's own planet period records (the Moon-elongation rate from the
+  // sidereal month/year identity). Plan 06 I2 — the carriers are SIDEREAL
+  // (measured): the records' solarYearInput are OF-DATE periods (their
+  // rates sit +1.39..1.62°/cy above the VSOP sidereal mean motions — the
+  // framework precession plus input rounding), and a perturbation argument
+  // is inertial (D'Alembert: only Σk = 0 arguments are frame-free), so on
+  // of-date carriers every Σk ≠ 0 argument drifted by Σk·ψ(t) — 42..52° at
+  // −3000 for the table's Σk = −1 terms (their ancient scatter against
+  // Horizons 6.4 → 4.4″ on sidereal carriers), and 6 % of frequency for the
+  // 1783-yr long inequality (1683 yr on the of-date carriers). Constant-free:
+  // the record rate minus the model's own J2000 precession p₀ =
+  // 360·36525·(1/T_trop − 1/T_sid) for the planets, the framework sidereal
+  // year for Earth; identical to the N3 carriers at J2000 (same phase
+  // anchors), ≤ 1.4°·|Σk| apart at the 200-yr extraction window's edges
+  // (the composed table reproduces the N3 one there: JPL 1900–2100
+  // all-phase sd unchanged to 0.01″). The parity gate's fingerprint mirrors
+  // this arithmetic (test/create-model-parity.test.mjs).
+  // PLAN 06 I3 — the carriers are the model's own banked J2000 sidereal mean
+  // motions (the embedded sun-completion artifact; ONE home,
+  // computeCarrierRatesDegPerCy — the former record-based arithmetic sat
+  // 4.1″/yr off for Venus, 1.7″/yr for Jupiter: 83° of the Venus–Earth
+  // argument at ±9000 yr), Earth the framework sidereal year, the Moon
+  // elongation from the sidereal month/year identity. The long-period rows
+  // ride the embedded e-vectors of date, and the lunar equation rides the
+  // framework's own Moon elongation of date (ṅ included) — the constant-rate
+  // carrier ran ~29° off it at ±9000 yr.
+  const carrierRatesDegPerCy = computeCarrierRatesDegPerCy({ meanSiderealYearDays, moonSiderealMonthDays: moonSiderealMonthInput });
+  const { sunPlanetaryCompletionDeg } = createSunPlanetaryCompletion({
+    embWobbleArcsec,
+    carrierRatesDegPerCy,
+    moonElongationDegAtT: /** @param {number} T */ (T) => moonArgs.argsAt(j2000JD + T * julianCenturyDays).D,
+  });
+  const besselian = createBesselian({
+    moonFullAtDaysTT: /** @param {number} dDaysTT */ (dDaysTT) => {
+      const ev = moonSeries.sceneEvalAt(dDaysTT);
+      return { lonDeg: ev.lonDeg, latDeg: ev.latDeg, distKm: ev.distKm };
+    },
+    sunLonDegAt: /** @param {number} jdUT */ (jdUT) => eclipseFinders.sunLonDegAt(jdUT),
+    sunCompletionDeg: sunPlanetaryCompletionDeg,
+    // plan 06 R3 item 1: the location tier on APPARENT places — the Sun's derived κ
+    // (the same helper the cardinal instants use), the Moon's relative light-time
+    // inside the besselian; the series-extension tail now lives in sceneEvalAt.
+    sunAberrationDegAt: /** @param {number} year */ (year) => late.sunAberrationArcsecAt(year) / 3600,
+    deltaTSecondsAt: /** @param {number} jd */ (jd) => (jdTTFromUT(jd) - jd) * 86400,
+    obliquityDegAt: obliquityDeg,
+    eccentricityAt: sunEccentricityAt,
+    perihelionLongitudeDegAt: sunPerihelionDegAt,
+    yearFromJD,
+    constants: {
+      j2000JD,
+      julianCenturyDays,
+      earthDiameterKm: C.bodyDiametersKm.earth,
+      moonDiameterKm: C.bodyDiametersKm.moon,
+      sunDiameterKm: C.bodyDiametersKm.sun,
+      sunDistanceKm: currentAUDistance,
+      earthFlatteningInverse: C.physicalConstants.earthFlatteningInverseWGS84,
+      ttBridgeSeconds: F.DT_ANCHOR.deltaTStartSeconds,
+      gmstMeanSiderealT0Deg: C.physicalConstants.gmstMeanSiderealT0Deg,
+      gmstMeanSiderealRateDegPerDay: C.physicalConstants.gmstMeanSiderealRateDegPerDay,
+      gmstMeanSiderealT2Deg: C.physicalConstants.gmstMeanSiderealT2Deg,
+      speedOfLightKmS: C.physicalConstants.speedOfLight,
+    },
+  });
+
+  return { besselian, eclipseFinders, sunL0Deg, sunMeanLongitudeDegAt, sunPlanetaryCompletionDeg, sunTropicalRateDegPerCy };
+}
+/** @typedef {import('./lunar-theory.js').Ctx & ReturnType<typeof assembleSunAndEclipses>} Ctx */