@essrt/physics 7.0.0 → 9.1.0

package/src/model.js

@@ -21,11 +21,12 @@ import { deriveEpochParams } from './layer0/derive-params.js';
 import * as FL from './planets/fibonacci-laws.cjs';
 import * as planetOrientation from './planets/orientation.cjs';
 import { createPhaseMachinery } from './phase/index.cjs';
-import { createCardinalModel } from './cardinal/index.cjs';
 import { createYearLengths, ONE_FAMILY_WINDOW_YEARS } from './earth/year-lengths.cjs';
 import { createDeepOrbitalHistory } from './earth/deep-orbital-history.cjs';
 import { CHAIN_ARTIFACT } from './planets/chain-artifact.js';
 import { buildPlanetChainsFromArtifactData, computeApsidalSecularDegPerYr } from './planets/keplerian-chain.cjs';
+import { computeSecularShape } from './planets/secular-shape.cjs';
+import { createPlanetSpinChannelFromArtifacts, computeObliquityJ2000Deg } from './planets/spin-channel.cjs';
 import { createDeltaTCycles } from './deltat/cycles.cjs';
 import { createDeepTimeLod } from './deltat/deep-time.cjs';
 import { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
@@ -37,7 +38,6 @@ import { createChainCycleIntegrator } from './chain-cycles/index.cjs';
 import { createMoonArguments, jdToDecimalYear } from './moon/arguments.cjs';
 import { createMoonSeries } from './moon/series.cjs';
 import { createSunPlanetaryCompletion } from './eclipse/sun-planetary-completion.cjs';
-import { moonSeriesExtensionDeg } from './moon/series-extension.cjs';
 import { createEclipseFinders } from './eclipse/finders.cjs';
 import { createBesselian } from './eclipse/besselian.cjs';
 import { driver2PeriodSecondsAtAge } from './planets/orbit-chain.cjs';
@@ -102,7 +102,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // wobble-marker distance). It is the K calibration input ONLY — Earth's
   // eccentricity law does not use it; see eccentricityAt (base' derived) below.
   const eccentricityAmplitude = C.earth.eccentricityAmplitude;
-  const earthRAAngle = 2 * earthInclAmplitude - (earthInclAmplitude * earthInclAmplitude) / earthtiltMean;
   const earthInclMean = C.earthOrbital.earthInclinationJ2000_deg
     - earthInclAmplitude * Math.cos(((C.earthOrbital.earthPerihelionLongitudeJ2000
       - C.earthOrbital.earthInclinationCycleAnchor) * Math.PI) / 180);
@@ -426,7 +425,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   /** de/dyear of the Sun's e — the cardinal braid's equation-of-centre
    *  derivative rides it (±0.5-yr central difference; the constant offset
    *  cancels). @param {number} year @returns {number} */
-  const sunEccentricityRateAt = laws.eccentricityRateAt ?? ((year) => oneSourceM.eAt(year + 0.5) - oneSourceM.eAt(year - 0.5));
   /** @param {number} year @returns {number} */
   const inclinationDeg = (year) => earthInclMean
     - earthInclAmplitude * Math.cos(phaseRadians(balancedYear, year, 3));
@@ -502,39 +500,13 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     + RA_DAY_OFFSET_ECC_MS * Math.cos(phaseRadians(balancedYear, year, 16))
     + RA_DAY_OFFSET_OBLIQ_MS * Math.cos(phaseRadians(balancedYear, year, 8));
 
-  // ── Cardinal-point model ──────────────────────────────────────────────────
-  const cardinalM = createCardinalModel({
-    isDeepTime: () => true,
-    constants: {
-      anchors: F.CARDINAL_POINT_ANCHORS_ADJUSTED,
-      harmonics: F.CARDINAL_POINT_HARMONICS,
-      eccTerms: F.CARDINAL_POINT_ECC_TERMS,
-      jointTerms: F.CARDINAL_POINT_JOINT_TERMS,
-      derived: F.CARDINAL_POINT_DERIVED,
-      tropicalHarmonics: F.TROPICAL_YEAR_HARMONICS,
-      balancedYear,
-      meanSolarYearDays,
-      hJ2000: H,
-      tiltMeanDeg: earthtiltMean,
-      raAngleDeg: earthRAAngle,
-      inclAmplitudeDeg: earthInclAmplitude,
-    },
-    fns: {
-      cyclesBetween: (a, b, n) => phase().cyclesBetween(a, b, n),
-      // The frozen era clock's deps ride ITS convention H_era (plan 06 D8):
-      // drift integrand, dc/dY and the real-LOD convention were fitted on it.
-      analyticTropicalDays: (year) => {
-        const tMa = (startmodelYear - year) / 1e6;
-        const Ht = deepLod.eraClockHAtAge(tMa);
-        if (Ht === null) return null;
-        return (deepLod.siderealYearSecondsAtAge(tMa) / 86400) * (1 - 13 / Ht);
-      },
-      meanHAtAgeMa: (tMa) => deepLod.eraClockHAtAge(tMa),
-      meanYearRealLodDays: (tMa) => deepLod.eraClockYearInDaysAtAge(tMa),
-      eccentricityAt: sunEccentricityAt,
-      eccentricityRateAt: sunEccentricityRateAt,
-    },
-  });
+  // ── Cardinal points (the fitted model retired, R1)──────────────────────────────────────────────────
+  // Plan 06 R1: the fitted cardinal-point model (CARDINAL_POINT_* — the §10
+  // derived form on the frozen era clock, fitted to the retired K scene's
+  // events; measured 60–140 min from Meeus ch. 27 at 0..−1000 and 6–25 min
+  // in 1500–2900) left this package. The instants are the CROSSINGS of the
+  // one Sun the scene renders and the eclipse chain certifies — see
+  // `cardinalCrossingJdUT` below the finders.
   // ── One-source cardinal structure (D4b) ───────────────────────────────────
   // The EoC layer (year lengths, crossing offsets, the e(t)-proportional
   // spread) on the one-source movement's own e(t)/ϖ(t) — the MODE tier (the
@@ -646,9 +618,19 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     };
   })();
   const yearLengthsM = oneSourceM.yearLengths;
+  /** THE one-family tropical year of date in SI seconds: route B inside the
+   *  one-family window, the tidal-chain year beyond (plan 06 R1 — the Sun's
+   *  mean longitude, the cardinal instants and the published year lengths
+   *  all ride this one function). @param {number} year @returns {number} */
+  const oneFamilyTropicalYearSeconds = (year) => (Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS
+    ? yearLengthsM.tropicalYearSecondsAtYear(year)
+    : (deepLod.tropicalYearSecondsAtAge(yearToTMa(year)) ?? meanSolarYearDays * 86400));
 
-  /** Tropical year: mean of the four cardinal intervals. @param {number} year @returns {number} */
-  const tropicalYearDays = (year) => cardinalM.computeTropicalYearLength(year);
+  /** Tropical year of date in DAYS OF THE EPOCH (the kinematic day below) —
+   *  the one-family SI year over the epoch's day length, so solarYearSeconds
+   *  ≡ the one-family year. Plan 06 R1: formerly the fitted cardinal model's
+   *  4-mean. @param {number} year @returns {number} */
+  const tropicalYearDays = (year) => oneFamilyTropicalYearSeconds(year) / dayLengthSeconds(year);
   /** @param {number} year @returns {number} */
   const tropicalYearDirectDays = (year) => evalYearFourier(year, tropicalYearDaysBase(year), F.TROPICAL_YEAR_HARMONICS);
 
@@ -737,10 +719,13 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     const mp = C.planets[k];
     const ar = C.planetOrbitalElements[k];
     const ecl = /** @type {number} */ (fractionToYears(mp.perihelionEclipticFraction));
-    const axial = /** @type {number} */ (fractionToYears(mp.axialPrecessionFraction));
-    const obliquityCycle = fractionToYears(mp.obliquityCycleFraction)
-      ?? Math.abs(1 / (1 / ecl - 1 / (H / 13)));
-    const wobble = FL.computeWobblePeriodYears(ecl, axial, H);
+    // Plan 06 Phase 7 commit 2: the K device's integer axial and obliquity
+    // fractions are retired. The eccentricity law's cycle period is the
+    // chain's OWN g-mode beat (the dominant mode × largest companion of the
+    // planet's eccentricity vector), its obliquity input the DERIVED J2000
+    // obliquity of the spin channel (the IAU pole against the chain's J2000
+    // plane, acute form) — both from the governed artifacts, no fractions.
+    const wobble = computeSecularShape(/** @type {any} */ (CHAIN_ARTIFACT), k).beatYears;
     const il = FL.computeInclinationLaw({
       fibonacciD: mp.fibonacciD,
       massFrac: massFraction[k],
@@ -749,11 +734,13 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       inclinationCycleAnchor: mp.inclinationCycleAnchor,
       antiPhase: mp.antiPhase || false,
     }, PSI);
-    const obliquityMean = FL.computeObliquityMeanSnapshot({
-      axialTiltJ2000: ar.axialTiltJ2000,
-      invPlaneInclinationAmplitude: il.amplitude,
-      perihelionEclipticYears: ecl,
-    }, obliquityCycle, { H, t2000 });
+    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: the K law reads sin|ε|
     const el = FL.computeEccentricityLaw({
       fibonacciD: mp.fibonacciD,
       massFrac: massFraction[k],
@@ -773,8 +760,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       longitudePerihelion: ar.longitudePerihelion,
       ascendingNodeCyclesIn8H: mp.ascendingNodeCyclesIn8H,
       ascendingNodePeriod: -(8 * H) / mp.ascendingNodeCyclesIn8H,
-      axialPrecessionYears: axial,
-      obliquityCycle,
       wobblePeriod: wobble,
       fibonacciD: mp.fibonacciD,
       antiPhase: mp.antiPhase || false,
@@ -793,6 +778,32 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     });
   }
 
+  // ── The planets' spin channel (plan 06 Phase 7): 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;
+  };
+
   /** Perihelion longitude (linear lattice rate). @param {string} k @param {number} year @returns {number} */
   const planetPerihelionDeg = (k, year) => {
     const p = PLANET_RECORDS[k];
@@ -858,6 +869,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const nNodalEJ2000 = nNodalIJ2000 + 13;
   const moonApsidalJ2000Seconds = (totalDaysInH / nApsidalEJ2000) * meanLengthOfDay;
   const moonNodalJ2000Seconds = (totalDaysInH / nNodalEJ2000) * meanLengthOfDay;
+  // the OF-DATE anchors (the H² counter's J2000 period — the Meeus/IERS
+  // observables 3231.49 d / 6798.38 d)
+  const moonApsidalOfDateJ2000Seconds = (totalDaysInH / nApsidalIJ2000) * meanLengthOfDay;
+  const moonNodalOfDateJ2000Seconds = (totalDaysInH / nNodalIJ2000) * meanLengthOfDay;
   const moonSiderealMonthJ2000Seconds = moonSiderealMonth * meanLengthOfDay;
 
   // 8H-lattice derived months (constants.js §Moon derived months)
@@ -887,6 +902,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       nNodalOfDateJ2000: nNodalIJ2000,
       moonApsidalJ2000Seconds,
       moonNodalJ2000Seconds,
+      moonApsidalOfDateJ2000Seconds,
+      moonNodalOfDateJ2000Seconds,
       moonSiderealMonthJ2000Seconds,
       sPerigee: MOON_ECC_SENSITIVITY_PERIGEE,
       sNode: MOON_ECC_SENSITIVITY_NODE,
@@ -1113,65 +1130,73 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // same movement and is retired by the unification (measured identical on
   // every modern gate).
   const sunMeanLongitudeDegAt = (() => {
-    // SW PHASE B — the CLOSED FORM on the integrated lattice phase
-    // (supersedes the E5 ±3,000-yr trapezoid table; valid at EVERY epoch,
-    // no table, no domain window). drift = D_smooth + Σₖ D_k + D_torque:
-    //  · D_smooth — the deep chain's smooth SI tropical-year physics
-    //    (tropicalYearDaysBase × LOD), two-point trapezoid: the same
-    //    structure the scene twin uses, so the scene δ stays bounded.
-    //  · Each oscillatory term integrates ANALYTICALLY: the antiderivative
-    //    of cos/sin on the integrated phase is (H/2πk)·[sin/−cos] — the H
-    //    drift lives in the phase itself; the amplitude factor uses H_J2000
-    //    (ppm-class difference, negligible).
-    //  · THE REBASE (E5's corpus-preferred J2000 rate anchor) is applied
-    //    PER HARMONIC as a SIN-SATURATED ramp, (H/2πk)·sin(Δφₖ): equal to
-    //    the linear rebase for |Δφₖ| ≪ 1 (the corpus era) and bounded by
-    //    the harmonic's own period beyond — extending a linearized local
-    //    slope to deep time would be the fitted-linear-slope trap. Every
-    //    quantity is derived; zero new constants; each component and its
-    //    slope vanish at year 2000 by construction (the drift-only
-    //    property is exact, not tabulated).
-    const RATE_LIN = sunTropicalRateDegPerCy / 100;              // deg / SI yr
-    const precessionP0DegPerYr = 13 * 360 / H;
-    const tanEps = Math.tan(earthtiltMean * Math.PI / 180);
-    const A_RAD = earthInclAmplitude * Math.PI / 180;
-    /** @param {number} year @returns {number} */
-    const rateSmooth = (year) => 360 * (365.25 * 86400)
-      / (tropicalYearDaysBase(year)
-        * (deepLod.lodSecondsAtAge(yearToTMa(year)) ?? meanLengthOfDay));
-    /** @type {{rateSm0: number, ph0: Map<number, number>}|null} */
-    let anchor = null;
-    return /** @param {number} year @returns {number} */ (year) => {
-      if (anchor === null) {
-        const ph0 = new Map();
-        for (const [k] of F.TROPICAL_YEAR_HARMONICS) ph0.set(k, phaseRadians(balancedYear, 2000, k));
-        for (const k of [3, 8]) if (!ph0.has(k)) ph0.set(k, phaseRadians(balancedYear, 2000, k));
-        anchor = { rateSm0: rateSmooth(2000), ph0 };
-      }
+    // Plan 06 R1 — 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 route-B tropical year of date in SI seconds (the ONE
+    // year-length family; the frozen era clock's tropicalYearDaysBase × LOD
+    // and its comb ripple + torque term left here). MEASURED before the
+    // move (tools/explore r1 probes, plan 06 record): the route-B tropical
+    // year equals the IAU/Laskar drift expression to 0.1 s over −1000..+3000
+    // while the era-clock year carried NO secular drift (+1.09 s flat), so
+    // the former mean longitude wandered +12 min around 500 AD and diverged
+    // −3.3 min/cy after 2100 against both Meeus ch. 27 and the one-source
+    // integral — outside every eclipse and JPL gate. MODERN-WINDOW COST,
+    // stated (plan 06 I1 corrected an earlier misreading of the cache's
+    // clock): against the JPL Sun cache (UT instants, verified; the registry
+    // instrument's bridge) the one-source Sun read 1.29″ sd in 1970–2049
+    // where the era-clock Sun read 0.80″ — both carried ~0.02–0.03″/yr
+    // trends against JPL over 1900–2100; accepted because over millennia
+    // the era-clock Sun is minutes off. Plan 06 I2 located the trend: the
+    // Earth–Mars–Jupiter long inequality (1783 yr, 6.3″) the smooth year
+    // cannot carry — derived on the model's own N-body and shipped in the
+    // planetary completion, the instrument reads 1.03″ (Horizons ±3000 yr:
+    // modern-window mean +8.4 → +0.8″, per-millennium sd roughly halved).
+    // 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;
-      // smooth deep physics (two-point trapezoid; exact 0 at 2000)
-      let drift = 0.5 * (rateSmooth(year) - anchor.rateSm0) * dy;
-      // year-harmonic ripple: rate ≈ −(RATE_LIN/T̄)·h(y); antiderivative +
-      // sin-saturated per-harmonic rebase
-      const HK = H / (2 * Math.PI);
-      for (const [k, sK, cK] of F.TROPICAL_YEAR_HARMONICS) {
-        const ph = phaseRadians(balancedYear, year, k);
-        const ph0 = /** @type {number} */ (anchor.ph0.get(k));
-        const scale = -(RATE_LIN / meanSolarYearDays) * (HK / k);
-        const anti = (-sK) * (Math.cos(ph) - Math.cos(ph0)) + cK * (Math.sin(ph) - Math.sin(ph0));
-        const h0 = sK * Math.sin(ph0) + cK * Math.cos(ph0);
-        drift += scale * (anti - h0 * Math.sin(ph - ph0));
+      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]);
       }
-      // torque (E5): rate = −p₀·tanε·δε, δε = A(−cos φ₃ + cos φ₈); same
-      // antiderivative + per-component sin-saturated rebase
-      for (const [k, sgn] of [[3, -1], [8, 1]]) {
-        const ph = phaseRadians(balancedYear, year, k);
-        const ph0 = /** @type {number} */ (anchor.ph0.get(k));
-        const scale = -precessionP0DegPerYr * tanEps * A_RAD * sgn * (HK / k);
-        drift += scale * ((Math.sin(ph) - Math.sin(ph0)) - Math.cos(ph0) * Math.sin(ph - ph0));
-      }
-      return sunL0Deg + sunTropicalRateDegPerCy * dy / 100 + drift;
+      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);
   })();
 
   // Eclipse finders — wired like the engine probe (tools/verify/
@@ -1213,20 +1238,34 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // μ = 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: one
-  // revolution per the model's own tropical period records (Earth from
-  // the framework mean solar year; the Moon-elongation rate from the
-  // sidereal month/year identity). The v3 table's amplitudes were
-  // re-extracted on exactly these rates (the carrier↔table matched pair).
+  // 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).
   const degPerCyOf = /** @param {number} cyclesPerDay */ (cyclesPerDay) => 360 * 36525 * cyclesPerDay;
+  const carrierPrecessionDegPerCy = degPerCyOf(1 / meanSolarYearDays) - degPerCyOf(1 / meanSiderealYearDays);
   const carrierRatesDegPerCy = {
     planets: [
-      degPerCyOf(1 / C.planetOrbitalElements.mercury.solarYearInput),
-      degPerCyOf(1 / C.planetOrbitalElements.venus.solarYearInput),
-      degPerCyOf(1 / meanSolarYearDays),
-      degPerCyOf(1 / C.planetOrbitalElements.mars.solarYearInput),
-      degPerCyOf(1 / C.planetOrbitalElements.jupiter.solarYearInput),
-      degPerCyOf(1 / C.planetOrbitalElements.saturn.solarYearInput),
+      degPerCyOf(1 / C.planetOrbitalElements.mercury.solarYearInput) - carrierPrecessionDegPerCy,
+      degPerCyOf(1 / C.planetOrbitalElements.venus.solarYearInput) - carrierPrecessionDegPerCy,
+      degPerCyOf(1 / meanSiderealYearDays),
+      degPerCyOf(1 / C.planetOrbitalElements.mars.solarYearInput) - carrierPrecessionDegPerCy,
+      degPerCyOf(1 / C.planetOrbitalElements.jupiter.solarYearInput) - carrierPrecessionDegPerCy,
+      degPerCyOf(1 / C.planetOrbitalElements.saturn.solarYearInput) - carrierPrecessionDegPerCy,
     ],
     moonElongation: degPerCyOf(1 / moonSiderealMonthInput - 1 / meanSiderealYearDays),
   };
@@ -1238,7 +1277,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     },
     sunLonDegAt: /** @param {number} jdUT */ (jdUT) => eclipseFinders.sunLonDegAt(jdUT),
     sunCompletionDeg: sunPlanetaryCompletionDeg,
-    moonExtensionAt: moonSeriesExtensionDeg,
+    // 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) => sunAberrationArcsecAt(year) / 3600,
     deltaTSecondsAt: /** @param {number} jd */ (jd) => (jdTTFromUT(jd) - jd) * 86400,
     obliquityDegAt: obliquityDeg,
     eccentricityAt: sunEccentricityAt,
@@ -1256,6 +1298,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       gmstMeanSiderealT0Deg: C.physicalConstants.gmstMeanSiderealT0Deg,
       gmstMeanSiderealRateDegPerDay: C.physicalConstants.gmstMeanSiderealRateDegPerDay,
       gmstMeanSiderealT2Deg: C.physicalConstants.gmstMeanSiderealT2Deg,
+      speedOfLightKmS: C.physicalConstants.speedOfLight,
     },
   });
 
@@ -1277,6 +1320,93 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     if (Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS) return yearLengthsM.tropicalYearSecondsAtYear(year);
     return deepLod.tropicalYearSecondsAtAge(yearToTMa(year));
   };
+  // ── Cardinal instants (plan 06 R1) ─────────────────────────────────────
+  /** The completed certified Sun (finder Sun − the derived planetary
+   *  completion) at a UT model-JD — the same longitude the scene renders
+   *  inside the overlay window; MEAN GEOMETRIC, mean equinox of date.
+   *  @param {number} jdUT @returns {number} */
+  const sunLonCompletedDegAtJdUT = (jdUT) => eclipseFinders.sunLonDegAt(jdUT)
+    - sunPlanetaryCompletionDeg((jdTTFromUT(jdUT) - j2000JD) / julianCenturyDays);
+  /** The APPARENT Sun the cardinal instants are defined on (an equinox is
+   *  the apparent Sun crossing the equator — the USNO/Meeus instants are
+   *  apparent): the completed geometric Sun minus the aberration constant,
+   *  plus the nutation in longitude. Both derived, zero new constants —
+   *  κ = 2π·a/(c·T_sid·√(1−e²)) from the AU, c, the one-family sidereal year
+   *  and the Sun's e (20.50″ at J2000); Δψ from the four IAU 1980 leading
+   *  terms on the model's OWN lunar node, mean Sun and mean Moon (the
+   *  framework arguments), the same family the registry's JPL Sun
+   *  instrument bridges with. @param {number} jdUT @returns {number} */
+  /** The Sun's derived aberration constant of date, arcsec — κ = 2π·a/(c·T_sid·√(1−e²))
+   *  from the AU, c, the one-family sidereal year and the Sun's e (20.50″ at
+   *  J2000); ONE home for the cardinal instants and the eclipse location tier.
+   *  @param {number} year @returns {number} */
+  const sunAberrationArcsecAt = (year) => {
+    const e = sunEccentricityAt(year);
+    return (2 * Math.PI * currentAUDistance
+      / (C.physicalConstants.speedOfLight * yearLengthsM.siderealYearSecondsAtYear(year) * Math.sqrt(1 - e * e)))
+      * (648000 / Math.PI);
+  };
+  /** @param {number} jdUT @returns {number} */
+  const sunApparentLonDegAtJdUT = (jdUT) => {
+    const jdTT = jdTTFromUT(jdUT);
+    const year = 2000 + (jdTT - j2000JD) / 365.25;
+    const kappaArcsec = sunAberrationArcsecAt(year);
+    const a = moonArgs.argsAt(jdTT);
+    const d2r = Math.PI / 180;
+    const Om = (a.Lp - a.F) * d2r, Ls = (a.Lp - a.D) * d2r, Lm = a.Lp * d2r;
+    const NU = C.physicalConstants.nutationLeadingTermsArcsec;
+    const dPsiArcsec = NU.psiOmega * Math.sin(Om) + NU.psi2Ls * Math.sin(2 * Ls)
+      + NU.psi2Lm * Math.sin(2 * Lm) + NU.psi2Omega * Math.sin(2 * Om);
+    return sunLonCompletedDegAtJdUT(jdUT) + (dPsiArcsec - kappaArcsec) / 3600;
+  };
+  /** @param {string} type @returns {number} */
+  const cardinalTargetDeg = (type) => {
+    const t = { VE: 0, SS: 90, AE: 180, WS: 270 }[type];
+    if (t === undefined) throw new RangeError(`cardinal type must be VE|SS|AE|WS, got ${type}`);
+    return t;
+  };
+  const CARDINAL_SI_YEAR_D = 365.2422;
+  /** The crossing NEAREST a seed instant — the unique root within ±½ tropical
+   *  year of the seed (the wrapped longitude difference is the Newton residual).
+   *  Plan 06 R4c: the seed is a JD because the caller's year may live on a
+   *  different axis than the model year — the simulator's cardinal panel
+   *  labels its year with the displayed CALENDAR date (the Julian calendar
+   *  before 1582, 365.25-d years) while `year` below is the model year (the SI
+   *  axis, 365.2422-d count from J2000); the two part by 0.0078 d/yr, 114 yr at
+   *  −5.34 Myr, where the panel showed the events of −5341772 for a date in
+   *  −5341886 (owner). Seeding at the calendar year's midpoint returns that
+   *  year's own events at every epoch. @param {number} jdSeedUT @param {string} type @returns {number} */
+  const cardinalCrossingNearJdUT = (jdSeedUT, type) => {
+    const target = cardinalTargetDeg(type);
+    const RATE = 360 / CARDINAL_SI_YEAR_D;
+    let jd = jdSeedUT;
+    for (let i = 0; i < 20; i++) {
+      const d = ((((sunApparentLonDegAtJdUT(jd) - target) + 540) % 360 + 360) % 360) - 180;
+      jd -= d / RATE;
+      if (Math.abs(d) < 1e-10) break;
+    }
+    return jd - C.earthOrbital.deltaTStart / 86400;
+  };
+  /** The TRUE-UT JD at which the APPARENT Sun's longitude of date equals
+   *  the cardinal target in the given year — Newton on the crossing (the
+   *  Sun's rate 360°/tropical year; a handful of steps from the tropical-year
+   *  seed). Replaces the fitted cardinal model's instants (R1). Plan 06 R3
+   *  item 2: the Newton root lives on the FINDER axis (the curve-only ΔT the
+   *  eclipse finders certify), and the returned instant is that root minus the
+   *  deltaTStart bridge — true UT = TT − (deltaTStart + curve), the same
+   *  bridge the besselian and the registry instruments apply. Before this the
+   *  published instants were 54.55 s (0.9 min) late. Against Horizons over
+   *  ±3000 yr the remaining offset is the Sun's (plan 06 I2 measured).
+   *  `year` is the MODEL year (the SI axis) — see cardinalCrossingNearJdUT.
+   *  @param {number} year @param {string} type @returns {number} */
+  const cardinalCrossingJdUT = (year, type) => {
+    const target = cardinalTargetDeg(type);
+    // seed: Jan 1.5 of the year (J2000 = 2000 Jan 1.5) + the mean date of the
+    // March equinox (day 79.3) + the quarter-turns to the target
+    const seed = j2000JD + (year - 2000) * CARDINAL_SI_YEAR_D + 79.3 + (target / 360) * CARDINAL_SI_YEAR_D;
+    return cardinalCrossingNearJdUT(seed, type);
+  };
+
   return Object.freeze({
     time: Object.freeze({
       yearFromJD,
@@ -1399,13 +1529,18 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       measuredSolarDaySeconds,
       raDayOffsetMs,
     }),
+    // Plan 06 R1: the instants are the crossings of the ONE Sun (the
+    // certified completed Sun the scene renders), UT model-JD; the RA at a
+    // crossing is the target longitude by construction (λ = 0/90/180/270 ⇒
+    // RA = 0/90/180/270, any obliquity); the per-type year length is the
+    // interval between successive crossings (SI days).
     cardinal: Object.freeze({
-      jd: /** @param {number} year @param {string} type @returns {number} */ (year, type) => cardinalM.computeSolsticeJD(year, type),
-      raDeg: /** @param {number} year @param {string} type @returns {number} */ (year, type) => {
-        const ra = cardinalM.computeSolsticeRA(year, type);
-        return ((ra % 360) + 360) % 360;
-      },
-      yearLengthDays: /** @param {number} year @param {string} type @returns {number} */ (year, type) => cardinalM.computeSolsticeYearLength(year, type),
+      jd: /** @param {number} year @param {string} type @returns {number} */ (year, type) => cardinalCrossingJdUT(year, type),
+      // R4c: the crossing nearest a UT instant (a JD seed — for callers whose
+      // year coordinate is not the model year, e.g. a calendar year's midpoint).
+      jdNearUT: /** @param {number} jdUT @param {string} type @returns {number} */ (jdUT, type) => cardinalCrossingNearJdUT(jdUT, type),
+      raDeg: /** @param {number} year @param {string} type @returns {number} */ (year, type) => { void year; return cardinalTargetDeg(type); },
+      yearLengthDays: /** @param {number} year @param {string} type @returns {number} */ (year, type) => cardinalCrossingJdUT(year + 1, type) - cardinalCrossingJdUT(year, type),
     }),
     // D4b: the one-source cardinal STRUCTURE — the EoC layer on the
     // movement's own e(t)/ϖ(t), valid at every epoch (mode tier). Absolute
@@ -1449,6 +1584,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       sunLonCompletedDegAtJD: /** @param {number} jd @returns {number} */ (jd) =>
         eclipseFinders.sunLonDegAt(jd)
         - sunPlanetaryCompletionDeg((jdTTFromUT(jd) - j2000JD) / julianCenturyDays),
+      /** The APPARENT Sun (completed geometric − the derived aberration constant + the leading nutation terms on the model's own arguments) — the quantity Horizons' observer ecliptic longitude is; the cardinal instants are its crossings (plan 06 R1/I1). @param {number} jdUT @returns {number} */
+      sunApparentLonDegAtJD: /** @param {number} jdUT @returns {number} */ (jdUT) => sunApparentLonDegAtJdUT(jdUT),
       findLunarInRange: /** @param {number} jdStart @param {number} jdEnd */ (jdStart, jdEnd) => eclipseFinders.findLunarEclipsesInRange(jdStart, jdEnd),
       findSolarInRange: /** @param {number} jdStart @param {number} jdEnd */ (jdStart, jdEnd) => eclipseFinders.findSolarEclipsesInRange(jdStart, jdEnd),
       deltaTSecondsAtJD: frameworkDeltaTSecondsAtJD,
@@ -1477,6 +1614,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       perihelionLongitudeDeg: planetPerihelionDeg,
       ascendingNodeInvPlaneDeg: planetAscNodeDeg,
       invPlaneInclinationDeg: planetInclinationDeg,
+      spin: planetSpin,
     }),
   });
 }