@essrt/physics 6.0.1 → 8.0.0

package/src/model.js

@@ -21,7 +21,6 @@ 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';
@@ -30,7 +29,6 @@ import { createDeltaTCycles } from './deltat/cycles.cjs';
 import { createDeepTimeLod } from './deltat/deep-time.cjs';
 import { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
 import { evalClimateL1OrbitalPermil, createAlphaGiaChannel } from './climate/l1-orbital.cjs';
-import { createMoonEccChannel } from './moon/ecc-channel.cjs';
 import { createDeepEccChannel } from './moon/deep-ecc-channel.cjs';
 import { DEEP_MODES_ARTIFACT } from './moon/deep-modes-artifact.cjs';
 import { createMoonMonthChain } from './moon/month-chain.cjs';
@@ -38,7 +36,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';
@@ -103,7 +100,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);
@@ -232,26 +228,29 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
 
   const DT = F.DT_STACK;
   const RES = F.DT_RESONATOR;
+  // Periods STATED IN YEARS (the fit files' period_yr / T0_yr): plan 06 T5
+  // measured the former 8H/n labels chance-level; layer B item 3 removed the
+  // divisor from every runtime. Twins: tools/lib/deep-time.js, src/script.js,
+  // the website's essrt.ts.
   const dtCycles = createDeltaTCycles({
-    eightHYears: 8 * H,
     taperFullHalfwidthYears: C.deepTime.dtStackTaperFullHalfwidthYr,
     taperTotalHalfwidthYears: C.deepTime.dtStackTaperTotalHalfwidthYr,
     tropicalYearSecondsJ2000: meanTropicalYearJ2000Seconds,
     cycles: {
-      bond: { latticeN: DT.bond.lattice_n, cosCoeffSeconds: DT.bond.cos_coeff_s, sinCoeffSeconds: DT.bond.sin_coeff_s },
-      hallstatt: { latticeN: DT.hallstatt.lattice_n, cosCoeffSeconds: DT.hallstatt.cos_coeff_s, sinCoeffSeconds: DT.hallstatt.sin_coeff_s },
-      jose5: { latticeN: DT.jose5.lattice_n, cosCoeffSeconds: DT.jose5.cos_coeff_s, sinCoeffSeconds: DT.jose5.sin_coeff_s },
-      jose4: { latticeN: DT.jose4.lattice_n, cosCoeffSeconds: DT.jose4.cos_coeff_s, sinCoeffSeconds: DT.jose4.sin_coeff_s },
+      bond: { periodYears: DT.bond.period_yr, cosCoeffSeconds: DT.bond.cos_coeff_s, sinCoeffSeconds: DT.bond.sin_coeff_s },
+      hallstatt: { periodYears: DT.hallstatt.period_yr, cosCoeffSeconds: DT.hallstatt.cos_coeff_s, sinCoeffSeconds: DT.hallstatt.sin_coeff_s },
+      jose5: { periodYears: DT.jose5.period_yr, cosCoeffSeconds: DT.jose5.cos_coeff_s, sinCoeffSeconds: DT.jose5.sin_coeff_s },
+      jose4: { periodYears: DT.jose4.period_yr, cosCoeffSeconds: DT.jose4.cos_coeff_s, sinCoeffSeconds: DT.jose4.sin_coeff_s },
     },
     resonator: {
-      t0LatticeN: RES.T0_lattice_n,
+      t0Years: RES.T0_yr,
       q: RES.Q,
       kicks: RES.kick_epochs_year.map(/** @param {number} t @param {number} i */ (t, i) => ({
         tYear: t,
         cosSeconds: RES.kick_coefficients_s[i].cos,
         sinSeconds: RES.kick_coefficients_s[i].sin,
       })),
-      tones: RES.drive_tones.map(/** @param {{dn: number, phi_locked_rad: number, amp_s: number}} t */ (t) => ({ dn: t.dn, phiLockedRad: t.phi_locked_rad, ampSeconds: t.amp_s })),
+      tones: RES.drive_tones.map(/** @param {{period_yr: number, phi_locked_rad: number, amp_s: number}} t */ (t) => ({ periodYears: t.period_yr, phiLockedRad: t.phi_locked_rad, ampSeconds: t.amp_s })),
     },
   });
 
@@ -346,14 +345,21 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
 
   // ── Earth scalars (integrated-phase display semantics) ────────────────────
   /** @param {number} year @returns {number} */
-  const earthPerihelionDeg = laws.perihelionLongitudeDegAt ?? ((year) => {
-    let longitude = 270.0 + 360.0 * cyclesBetween(balancedYear, year, 16);
-    for (const [div, sinC, cosC] of F.PERI_HARMONICS_RAW) {
-      const ph = phaseRadians(balancedYear, year, div);
-      longitude += sinC * Math.sin(ph) + cosC * Math.cos(ph);
-    }
-    return (((longitude + F.PERI_OFFSET) % 360) + 360) % 360;
-  });
+  // Plan 06 layer B — the eclipse Sun onto the series. The PUBLISHED Earth
+  // ϖ of date is the one-source series (the secular orbit; its J2000 element
+  // ≡ La2004's — the same field the D4c apsidal wheel renders). The SUN's
+  // equation of centre needs the MEAN elements of the era: the series plus the
+  // derived mean offset of the osculating channel (F.EARTH_OSCULATING_MEAN_
+  // OFFSET, tools/verify/earth-osculating-offset.js — the 1890–2110 mean of
+  // osculating − secular from the Horizons-seeded nine-body run). Measured:
+  // the fast osculating wobble is carried by the completion's direct terms and
+  // double-counts if added; the window mean is what the Sun residual holds
+  // (all-phase JPL sd 3.23″ → 1.59″; the former K law's Standish anchor
+  // 1.58″). The former K perihelion Fourier law (H divisors) is retired here.
+  const earthPerihelionDeg = (year) => oneSourceM.periOfDateDegAt(year);
+  const SUN_OFF = F.EARTH_OSCULATING_MEAN_OFFSET;
+  /** The eclipse Sun's ϖ of date (mean elements). @param {number} year @returns {number} */
+  const sunPerihelionDegAt = laws.perihelionLongitudeDegAt ?? ((year) => oneSourceM.periOfDateDegAt(year) + SUN_OFF.dPomArcsec / 3600);
   /** @param {number} year @returns {number} */
   const obliquityDeg = (year) => {
     let obliq = solsticeObliquityMean;
@@ -395,13 +401,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // (θ₀ = ϖ_ICRF(J2000) − 21.77° = 81.178°, the System-Reset anchor in
   // anchor form — doc 66 §1); base' is derived inside from the observed
   // J2000 eccentricity.
-  const moonEcc = createMoonEccChannel({
-    cyclesBetween,
-    eccentricityBase: C.earth.eccentricityBase,
-    perihelionLongitudeJ2000Deg: C.earthOrbital.earthPerihelionLongitudeJ2000,
-    inclinationCycleAnchorDeg: C.earthOrbital.earthInclinationCycleAnchor,
-    eccentricityJ2000: C.earthOrbital.earthEccentricityJ2000,
-  });
+  // (The H/3 eccentricity-law channel — createMoonEccChannel — left this
+  // package with plan 06 layer B: the Sun's e is the one-source series plus
+  // the derived mean offset above; the browser's scene Sun still reads the
+  // law through its own _moonEcc until the cardinal points move.)
   // Engine-switch decision (ii) (plan 02 §8): the ONE deep e — the engine's
   // own ±10-Myr mode table, anchored form — feeds the ENTIRE lunar chain
   // (modulation, cycle counts, arguments eccAt/channelIntegral, E-factor).
@@ -411,10 +414,15 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // laws hook deliberately does NOT reach this channel.
   const deepEcc = createDeepEccChannel(DEEP_MODES_ARTIFACT);
   /** @param {number} year @returns {number} */
-  const eccentricityAt = laws.eccentricityAt ?? ((year) => moonEcc.eccAt(year - 2000));
-  /** de/dyear of the one law — the cardinal braid's equation-of-centre
-   *  derivative rides it. @param {number} year @returns {number} */
-  const eccentricityRateAt = laws.eccentricityRateAt ?? ((year) => moonEcc.eccRateAt(year - 2000));
+  // Plan 06 layer B: the PUBLISHED Earth eccentricity is the one-source series
+  // (|z|, the secular orbit); the SUN's e adds the derived mean offset (see
+  // sunPerihelionDegAt). The former H/3 eccentricity law is retired here.
+  const eccentricityAt = (year) => oneSourceM.eAt(year);
+  /** The eclipse Sun's e (mean elements). @param {number} year @returns {number} */
+  const sunEccentricityAt = laws.eccentricityAt ?? ((year) => oneSourceM.eAt(year) + SUN_OFF.dE);
+  /** 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} */
   /** @param {number} year @returns {number} */
   const inclinationDeg = (year) => earthInclMean
     - earthInclAmplitude * Math.cos(phaseRadians(balancedYear, year, 3));
@@ -490,39 +498,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,
-      eccentricityRateAt,
-    },
-  });
+  // ── 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
@@ -625,14 +607,28 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     });
     return {
       yearLengths,
+      /** EXPERIMENT accessors: the series' e and equinox-referenced ϖ of date. @param {number} year @returns {number} */
+      eAt: (year) => sampleAt(year).e,
+      /** @param {number} year @returns {number} */
+      periOfDateDegAt: (year) => sampleAt(year).periOfDateDeg,
       /** The hybrid's obliquity at a decimal year, degrees — the banked series inside its span, the α(t)-coupled ζ-tail integration beyond (the deep sampler grows ~0.1 s/Myr). @param {number} year @returns {number} */
       epsAt: (year) => sampleAt(year).epsDeg,
     };
   })();
   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);
 
@@ -651,7 +647,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     const syS = solarYearSeconds(year);
     const syD = tropicalYearDays(year);
     const sidDay = siderealDaySeconds(year);
-    const raProjection = Math.cos((obliquityDeg(year) * Math.PI) / 180);
+    // Layer A (plan 06): the RA projection reads the published ε (the one-source
+    // hybrid), not the K comb — the browser's _sceneEpsTargetDeg twin; 1e-8 s.
+    const raProjection = Math.cos((oneSourceM.epsAt(year) * Math.PI) / 180);
     return (syS / (syD + 1) / Tp / (syD + 1)) * raProjection + sidDay;
   };
   /** @param {number} year @returns {number} */
@@ -926,20 +924,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     return (dr === null || t === null) ? null : dr - t;
   };
 
-  // Snapshot-phase obliquity — the engine's computeObliquityEarth convention
-  // for the lunar chain (linear H-lattice phase; orbital-engine.js). NOT the
-  // integrated-phase display obliquity above — the chain was certified
-  // against this form.
-  /** @param {number} year @returns {number} */
-  const obliquitySnapshotDeg = (year) => {
-    const t = year - balancedYear;
-    let obliq = solsticeObliquityMean;
-    for (const [div, sinC, cosC] of F.SOLSTICE_OBLIQUITY_HARMONICS) {
-      const ph = (2 * Math.PI * t) / (H / div);
-      obliq += sinC * Math.sin(ph) + cosC * Math.cos(ph);
-    }
-    return obliq;
-  };
+  // (The K snapshot-phase obliquity the lunar chain was certified against left
+  // with layer A / item 3c: the arguments' carrier reads the published ε.)
 
   // The argument skeleton (the _FW_MOON bundle; Sun secular deviations on
   // the CALENDAR year coordinate — S3)
@@ -964,7 +950,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     fns: {
       eccAt: /** @param {number} tYr */ (tYr) => deepEcc.eccAt(tYr),
       channelIntegral: /** @param {number} T @param {number} s */ (T, s) => deepEcc.channelIntegral(T, s),
-      computeObliquityEarth: obliquitySnapshotDeg,
+      // Layer A / item 3c (plan 06): the arguments' obliquity carrier reads the
+      // PUBLISHED ε (the one-source hybrid), not the K snapshot comb — one ε
+      // everywhere. Twins: script.js (_sceneEpsTargetDeg), scene-graph.js.
+      computeObliquityEarth: /** @param {number} year @returns {number} */ (year) => oneSourceM.epsAt(year),
       jdToSIyear: yearFromJD,
       tropicalOrbitsBetween: mcTropical,
       apsidalOfDateCyclesBetween: mcApsidalOfDate,
@@ -1104,65 +1093,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));
-      }
-      // 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));
+      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]);
       }
-      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/
@@ -1180,8 +1177,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     frameworkSun: {
       sunMeanLongitudeJ2000Deg: sunL0Deg,
       tropicalRateDegPerCy: sunTropicalRateDegPerCy,
-      eccentricityAt,
-      perihelionLongitudeDegAt: earthPerihelionDeg,
+      eccentricityAt: sunEccentricityAt,
+      perihelionLongitudeDegAt: sunPerihelionDegAt,
       meanLongitudeDegAt: sunMeanLongitudeDegAt,
     },
     constants: {
@@ -1204,20 +1201,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),
   };
@@ -1229,11 +1240,14 @@ 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,
-    perihelionLongitudeDegAt: earthPerihelionDeg,
+    eccentricityAt: sunEccentricityAt,
+    perihelionLongitudeDegAt: sunPerihelionDegAt,
     yearFromJD,
     constants: {
       j2000JD,
@@ -1247,6 +1261,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,
     },
   });
 
@@ -1268,6 +1283,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,
@@ -1390,13 +1492,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
@@ -1440,6 +1547,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,
@@ -1451,8 +1560,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       frameworkSunDeps: Object.freeze({
         sunMeanLongitudeJ2000Deg: sunL0Deg,
         tropicalRateDegPerCy: sunTropicalRateDegPerCy,
-        eccentricityAt,
-        perihelionLongitudeDegAt: earthPerihelionDeg,
+        eccentricityAt: sunEccentricityAt,
+        perihelionLongitudeDegAt: sunPerihelionDegAt,
         meanLongitudeDegAt: sunMeanLongitudeDegAt,
       }),
       // 20.3g location tier (see eclipse/besselian.cjs):