@essrt/physics 23.3.3 → 24.0.0

package/src/model/cardinal-instants.js

@@ -0,0 +1,101 @@
+/**
+ * Cardinal instants — the apparent Sun (completed, aberrated, nutated) and the Newton crossings.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+
+/** @param {import('./published-periods.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleCardinalInstants(ctx) {
+  const {
+    C, F, currentAUDistance, eclipseFinders, j2000JD, jdTTFromUT, julianCenturyDays, moonArgs, sunEccentricityAt,
+    sunPlanetaryCompletionDeg, yearLengthsM,
+  } = ctx;
+  /** 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 - F.DT_ANCHOR.deltaTStartSeconds / 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 { cardinalCrossingJdUT, cardinalCrossingNearJdUT, cardinalTargetDeg, sunAberrationArcsecAt, sunApparentLonDegAtJdUT };
+}
+/** @typedef {import('./published-periods.js').Ctx & ReturnType<typeof assembleCardinalInstants>} Ctx */

package/src/model/context.js

@@ -0,0 +1,54 @@
+/**
+ * The model assembly's shared context — the types the slices of `assembleModel` (../model.js) pass along.
+ *
+ * Each slice takes the context the earlier slices built (`import('./<previous>.js').Ctx`, an intersection
+ * that grows slice by slice) and returns the bindings the later ones read; the composer merges them
+ * into ONE object, so every closure sees the same instance of every memo and sampler. The inputs
+ * below are the composer's parameters; `late` carries the handful of bindings a slice reads at CALL
+ * time that a later slice defines — the composer fills each one as the owning slice returns, so a
+ * reader finds every forward dependency of the assembly in these seven lines and in the composer.
+ */
+
+/**
+ * RESEARCH OVERRIDES for Earth's orbit laws (doc 109 §7): an alternative e(t), de/dt(t) and
+ * ϖ_of-date(t) flow through every consumer (the eclipse Sun, the Moon's E-factor, the cardinal
+ * points) exactly as the shipped laws do. `{}` = the shipped laws. Not a counterfactual in the §2d
+ * sense (no hash change) — callers must say when they used it; the generators refuse to --write
+ * under an override.
+ * @typedef {{ eccentricityAt?: (year: number) => number, eccentricityRateAt?: (year: number) => number, perihelionLongitudeDegAt?: (year: number) => number }} Laws
+ */
+
+/**
+ * `giaEllipticityOfDate: false` builds the one-source history WITHOUT the J₂(t)/J₂₀ factor of date
+ * (the ice-driven GIA channel, which rides the climate formula's own post-MPT layer): the orbital
+ * FORCING alone. The T1 exporter derives the climate lines' obliquity rate on it, so the lines
+ * cannot depend on their own fit (v23.0; measured 3e-5 of the rate, 2–3 yr of period). Default true =
+ * the shipped physics.
+ * @typedef {{ giaEllipticityOfDate?: boolean }} Options
+ */
+
+/**
+ * The forward bindings — what an early slice reads at call time from a later one. Typed by the
+ * members actually read, so the composer's assignment is checked against each owner's surface.
+ * @typedef {object} LateBindings
+ * @property {() => number} certifiedAxialPrecessionJ2000Years  owner: year-day-lengths — read by deep-time-chain
+ * @property {{ epsAt(year: number): number, eAt(year: number): number, periOfDateDegAt(year: number): number, precessionOfDateFactorsAt(year: number): { solarTorque: number, ellipticity: number }, axialPrecessionYearsLunisolarJ2000: number }} oneSourceM  owner: one-source-movement — read by deep-time-chain and earth-scalars
+ * @property {{ anomalisticYearSecondsAtYear(year: number): number }} yearLengthsM  owner: one-source-movement — read by year-day-lengths
+ * @property {(year: number) => number} sunMeanLongitudeDegAt  owner: sun-and-eclipses — read by lunar-theory (the arguments' Sun)
+ * @property {(year: number) => number} publishedAxialPrecessionYearsAtYear  owner: published-periods — read by lunar-theory (the dynamical rate of date)
+ * @property {(year: number) => number} publishedSiderealYearSecondsAtYear  owner: published-periods — read by year-day-lengths
+ * @property {(year: number) => number} sunAberrationArcsecAt  owner: cardinal-instants — read by sun-and-eclipses (the besselian's apparent Sun)
+ */
+
+/**
+ * The composer's inputs — the first slice's context.
+ * @typedef {object} ModelInputs
+ * @property {Readonly<Record<string, any>>} C  the frozen constants context
+ * @property {Readonly<Record<string, any>>} F  the fitted coefficients
+ * @property {Laws} laws
+ * @property {any} secularSeriesArtifact  the governed N-body secular series (the API/Node path; null for the bare package)
+ * @property {Options} options
+ * @property {LateBindings} late
+ */
+
+export {};

package/src/model/deep-time-chain.js

@@ -0,0 +1,79 @@
+/**
+ * The deep-time chain — ONE assembly (createDeepTimeChain destructured), the climate L1 layer and the realized pole rate over a window.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { evalClimateL1OrbitalPermil } from '../climate/l1-orbital.cjs';
+import { createDeepTimeChain } from '../deltat/deep-time-chain.js';
+import { MOON_DISTANCE_ARTIFACT } from '../deltat/moon-distance-artifact.cjs';
+import { DEEP_MODES_ARTIFACT } from '../moon/deep-modes-artifact.cjs';
+
+/** @param {import('./derived-constants.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleDeepTimeChain(ctx) {
+  const { C, F, late, startmodelYear } = ctx;
+  // The GIA α channel (the lagged response to the L1 ice history, with the R2
+  // lattice pin and the exact-argument memo), the Layer-0 bundle, the cited
+  // Earth–Moon distance history (plan 12 option A), the ΔT cycle stack (all
+  // channels ON here), |s₃|, the LOD/ΔT core and the lunar month chain are
+  // assembled once in deltat/deep-time-chain.js from this context's constants
+  // and fitted coefficients (so a counterfactual context flows through them);
+  // the Node twin and the browser destructure the same module.
+  const chain = createDeepTimeChain({
+    constants: C, fitted: F, deepModes: DEEP_MODES_ARTIFACT, moonDistanceArtifact: MOON_DISTANCE_ARTIFACT,
+    ageAnchorYear: startmodelYear,
+  });
+  const { alphaGia, earthMoiFactorAtAge, EPOCH_PARAMS, recession, dtCycles, dtCycleLodCorrectionSum, s3ArcsecPerYr, deepLod, deepEcc, moonChain } = chain;
+  const CLIMATE_REGIME = F.CLIMATE_FORMULA_COEFFS.regimes['lr04-post-mpt'];
+  /** The climate formula's L1 (unlagged) — the orbital δ¹⁸O layer itself. @param {number} year @returns {number} */
+  const evalClimateL1 = (year) => evalClimateL1OrbitalPermil(year, {
+    l1Terms: CLIMATE_REGIME.L1,
+    yStdDenormalization: CLIMATE_REGIME.denormalization.y_std,
+  });
+  const moonDistanceMetresAtAge = recession.distanceMetresAtAge;
+  /** The published surfaces' km reading — NaN beyond the cited history's span (the API's
+   *  validity span lies inside it; the deep charts stop where the input stops).
+   *  @param {number} year @returns {number} */
+  const moonDistanceKmAtYearOrNaN = (year) => { const m = moonDistanceMetresAtAge(yearToTMa(year)); return m === null ? NaN : m / 1000; };
+
+  /** THE REALIZED POLE RATE OVER A WINDOW, ″/yr — the mean over [yearFrom, yearTo] of the rate the spin
+   *  integration actually turns the pole at: the inertial secular rate of date × the solar-torque factor at
+   *  e(t) × J₂(t)/J₂₀ × cos ε(t)/cos ε₀ (ds/dt = α (ŝ·n̂)(ŝ×n̂): the azimuthal rate about n̂ is α cos ε).
+   *  The secular rate here is the CONSTANT's scaling (lunisolarTorqueRate…), not the published rate of
+   *  date: the hybrid's own ε(t) carries the ONE cosine, so the cited mean obliquity's factor (plan 12 §8)
+   *  does not enter twice — inside the ζ-series span the hybrid IS the model's obliquity of date.
+   *  Measured (2026-10): the dominant obliquity line of the model's own ε(t) over the last 5 Myr sits at
+   *  this mean minus |s₃| (40,938 fitted vs 40,936 predicted), NOT at the J2000 beat (41,098) — the pole
+   *  turned faster in the past (spin +0.06 ″/yr over 5 Myr, lower mean obliquity +0.05, higher mean
+   *  eccentricity +0.015); La2004's own series reads the same (40,917). The climate records' preferred
+   *  "+0.12…+0.20 ″/yr on the obliquity lines" is this window mean (50.515 over the LR04 record).
+   *  Reads the one-source history and p₀ through `late` (one-source-movement.js, year-day-lengths.js —
+   *  evaluated at call time) and the deep-time LOD.
+   *  `ellipticity: false` leaves the J₂(t)/J₂₀ factor out: that factor is the ice-driven GIA channel, which
+   *  rides the climate formula's own post-MPT layer — the one piece that would make the climate LINES
+   *  depend on their own fit (measured: its LR04-window mean moved 1 − 3e-5 → 1 across one refit,
+   *  1.4e-3 ″/yr, 1 yr of period). The line derivation (the T1 exporter) excludes it; the published
+   *  realized period and the hybrid verdict's gate keep the full rate.
+   *  @param {number} yearFrom @param {number} yearTo @param {number} [stepYears=500]
+   *  @param {{ellipticity?: boolean}} [opts] @returns {number} */
+  const spinAxisInertialRateMeanArcsecPerYr = (yearFrom, yearTo, stepYears = 500, opts = {}) => {
+    const useEllipticity = opts.ellipticity !== false;
+    const lo = Math.min(yearFrom, yearTo), hi = Math.max(yearFrom, yearTo);
+    const cosEps0 = Math.cos(late.oneSourceM.epsAt(2000) * Math.PI / 180);
+    const kInertial = late.certifiedAxialPrecessionJ2000Years() / late.oneSourceM.axialPrecessionYearsLunisolarJ2000;
+    let sum = 0, n = 0;
+    for (let y = lo; y <= hi; y += stepYears) {
+      const r = deepLod.lunisolarTorqueRateArcsecPerYrAtAge(yearToTMa(y));
+      const psiDot = (r === null ? 1296000 / late.certifiedAxialPrecessionJ2000Years() : r) * kInertial;
+      const f = late.oneSourceM.precessionOfDateFactorsAt(y);
+      sum += psiDot * f.solarTorque * (useEllipticity ? f.ellipticity : 1) * Math.cos(late.oneSourceM.epsAt(y) * Math.PI / 180) / cosEps0;
+      n++;
+    }
+    return sum / n;
+  };
+
+  /** @param {number} year @returns {number} */
+  const yearToTMa = (year) => (2000 - year) / 1e6;
+
+  return { EPOCH_PARAMS, alphaGia, chain, deepEcc, deepLod, dtCycleLodCorrectionSum, dtCycles, earthMoiFactorAtAge, evalClimateL1, moonChain, moonDistanceKmAtYearOrNaN, moonDistanceMetresAtAge, s3ArcsecPerYr, spinAxisInertialRateMeanArcsecPerYr, yearToTMa };
+}
+/** @typedef {import('./derived-constants.js').Ctx & ReturnType<typeof assembleDeepTimeChain>} Ctx */

package/src/model/delta-t.js

@@ -0,0 +1,38 @@
+/**
+ * ΔT (TT − UT1) — the raw integral plus the cycle stack, memoized on the exact argument.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+
+/** @param {import('./moon-epoch.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleDeltaT(ctx) {
+  const { F, deepLod, dtCycles, yearToTMa } = ctx;
+  /** @param {number} tMa @returns {number} */
+  // Exact-argument memo (the alphaMemo pattern of deltat/deep-time-chain.js): the cardinal Newton
+  // solve asks for ΔT at the SAME jd twice per step (jdTTFromUT in the
+  // apparent Sun and again under the planetary completion) — measured 8.8 →
+  // 5.6 ms per panel year (8 solves) at modern epochs, values bit-identical.
+  /** @type {Map<number, number>} */
+  const dtMemo = new Map();
+  /** @param {number} tMa @returns {number} */
+  const meanDeltaTSecondsAtAge = (tMa) => {
+    if (tMa === 0) return 0;
+    const hit = dtMemo.get(tMa);
+    if (hit !== undefined) return hit;
+    let result = deepLod.deltaTRawSecondsAtAge(tMa);
+    const yearY = 2000 - tMa * 1e6;
+    result += dtCycles.cycleDeltaTSecondsAt('bond', yearY);
+    result += dtCycles.cycleDeltaTSecondsAt('hallstatt', yearY);
+    result += dtCycles.cycleDeltaTSecondsAt('jose5', yearY);
+    result += dtCycles.cycleDeltaTSecondsAt('jose4', yearY);
+    result += dtCycles.swingDeltaTSecondsAt(yearY);
+    if (dtMemo.size >= 8192) dtMemo.clear();
+    dtMemo.set(tMa, result);
+    return result;
+  };
+  /** @param {number} year @returns {number} */
+  const deltaTSeconds = (year) => F.DT_ANCHOR.deltaTStartSeconds + meanDeltaTSecondsAtAge(yearToTMa(year));   // the joint fit's anchor (plan 14: its own artifact)
+
+  return { deltaTSeconds, meanDeltaTSecondsAtAge };
+}
+/** @typedef {import('./moon-epoch.js').Ctx & ReturnType<typeof assembleDeltaT>} Ctx */

package/src/model/derived-constants.js

@@ -0,0 +1,58 @@
+/**
+ * Derived constants — the §9-order scalars from the constants context and the J2000 mass chain.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { computeMassChainJ2000 } from '../earth/mass-chain.cjs';
+import { computeMeanTropicalYearJ2000Days } from '../earth/year-lengths.cjs';
+
+/** @param {import('./context.js').ModelInputs} ctx @returns the bindings the later slices read */
+export function assembleDerivedConstants(ctx) {
+  const { C } = ctx;
+  // The mean solar year in days (the calendar's year axis) is the J2000 mean
+  // tropical year DERIVED in one home from the IAU sidereal year and p_A per
+  // Julian year (year-lengths.cjs).
+  const meanSolarYearDays = computeMeanTropicalYearJ2000Days(C.yearLengthRef.siderealYear, C.earthOrbital.generalPrecessionJ2000_arcsecPerYr);
+  // The scene epoch's ONE home — astro-reference timeReference.sceneEpochJD /
+  // sceneEpochYear; the SI-year axis (time-axis.js) anchors on the epoch itself.
+  const startmodelYear = C.timeReference.sceneEpochYear;
+  const startmodelJD = C.timeReference.sceneEpochJD;
+
+  const meanSiderealYearDays = C.yearLengthRef.siderealYear;
+  // (the sidereal year in SI seconds is the mass chain's own, below)
+  // The J2000 day length ω₀ is the SI day (an input).
+  const meanLengthOfDay = C.yearLengthRef.solarDay;
+  const meanTropicalYearJ2000Seconds = meanSolarYearDays * meanLengthOfDay;
+  // THE J2000 precession anchor p₀ in days (Julian years) — the IAU 2006
+  // general precession; the Moon's star-referenced periods read it.
+  const axialPrecessionJ2000Days = (1296000 / C.earthOrbital.generalPrecessionJ2000_arcsecPerYr) * 365.25;
+
+  const G_CONSTANT = C.physicalConstants.G_CONSTANT;
+  const MASS_RATIO_EARTH_MOON = C.physicalConstants.MASS_RATIO_EARTH_MOON;
+  const currentAUDistance = C.physicalConstants.currentAUDistance;
+  const moonDistanceKm = C.moonReference.moonDistance;
+  const moonSiderealMonthInput = C.moonReference.moonSiderealMonthInput;
+
+  // The Moon's sidereal month is the IAU input itself.
+  const moonSiderealMonth = moonSiderealMonthInput;
+
+  // The mass chain (Moon Kepler → GM_EM → the Earth/Moon split → the Sun, §9
+  // order) — ONE home: earth/mass-chain.cjs (the deep-time chain,
+  // deep-time-chain.js, computes the same scalars from the same context).
+  const mass = computeMassChainJ2000({
+    moonDistanceKm, moonSiderealMonthDays: moonSiderealMonth, meanSiderealYearDays,
+    meanLengthOfDaySeconds: meanLengthOfDay, massRatioEarthMoon: MASS_RATIO_EARTH_MOON,
+    currentAUDistanceKm: currentAUDistance, gravitationalConstantKm3KgS2: G_CONSTANT,
+  });
+  const moonOrbitalShift = mass.moonOrbitalShiftKm;
+  const moonDistanceCorrected = mass.moonDistanceCorrectedKm;
+  const GM_EARTH_MOON_SYSTEM = mass.gmEarthMoonSystemKm3S2;
+  const GM_EARTH_ALONE = mass.gmEarthAloneKm3S2;
+  const GM_MOON_ALONE = mass.gmMoonAloneKm3S2;
+  const GM_SUN_PLUS_EARTH = mass.gmSunPlusEarthKm3S2;
+  const GM_SUN = mass.gmSunKm3S2;
+  const M_SUN = mass.sunMassKg;
+
+  return { GM_EARTH_ALONE, GM_EARTH_MOON_SYSTEM, GM_MOON_ALONE, GM_SUN, GM_SUN_PLUS_EARTH, G_CONSTANT, MASS_RATIO_EARTH_MOON, M_SUN, axialPrecessionJ2000Days, currentAUDistance, meanLengthOfDay, meanSiderealYearDays, meanSolarYearDays, meanTropicalYearJ2000Seconds, moonDistanceCorrected, moonDistanceKm, moonOrbitalShift, moonSiderealMonth, moonSiderealMonthInput, startmodelJD, startmodelYear };
+}
+/** @typedef {import('./context.js').ModelInputs & ReturnType<typeof assembleDerivedConstants>} Ctx */

package/src/model/earth-scalars.js

@@ -0,0 +1,47 @@
+/**
+ * Earth scalars of date — e, ϖ, ε read from the one-source movement; the eclipse Sun's mean elements (the research `laws` hook).
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+
+/** @param {import('./deep-time-chain.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleEarthScalars(ctx) {
+  const { F, laws, late } = ctx;
+  /** @param {number} year @returns {number} */
+  // 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″).
+  const earthPerihelionDeg = (year) => late.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) => late.oneSourceM.periOfDateDegAt(year) + SUN_OFF.dPomArcsec / 3600);
+  // The obliquity of date is the one-source hybrid everywhere (the eclipse
+  // tier's besselian reads it here).
+  /** @param {number} year @returns {number} */
+  const obliquityDeg = (year) => late.oneSourceM.epsAt(year);
+  // ONE eccentricity for the whole model, two readers. The PUBLISHED Earth
+  // eccentricity is the one-source series (|z|, the secular orbit) and the
+  // SUN's e adds the derived mean offset (see sunPerihelionDegAt) — the
+  // clock-side machinery reads these: the eclipse Sun's equation of centre,
+  // the besselian Sun distance, the cardinal braid. The LUNAR chain
+  // (E-factor, perigee/node modulation, argument Δe² and the of-date rates)
+  // rides the ONE deep e — the engine's own ±10-Myr z-vector, `deepEcc` of
+  // the deep-time chain (deep-time-chain.js); the two agree within 4.2e-5
+  // in-era. The laws hook deliberately does NOT reach the deep e channel.
+  /** @param {number} year @returns {number} */
+  const eccentricityAt = (year) => late.oneSourceM.eAt(year);
+  /** The eclipse Sun's e (mean elements). @param {number} year @returns {number} */
+  const sunEccentricityAt = laws.eccentricityAt ?? ((year) => late.oneSourceM.eAt(year) + SUN_OFF.dE);
+  // (Earth's inclination and node of date — `inclinationDeg` /
+  // `ascendingNodeDeg` — are the one-source construction in inv-plane-elements.js.)
+
+  return { earthPerihelionDeg, eccentricityAt, obliquityDeg, sunEccentricityAt, sunPerihelionDegAt };
+}
+/** @typedef {import('./deep-time-chain.js').Ctx & ReturnType<typeof assembleEarthScalars>} Ctx */

package/src/model/inv-plane-elements.js

@@ -0,0 +1,56 @@
+/**
+ * Earth's invariable-plane elements of date — the ONE published i_inv / Ω_inv.
+ *
+ * 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 { convertNodeSFrameToEquatorOriginDeg } from '../planets/inv-plane-frame.cjs';
+
+/** @param {import('./planet-elements-of-date.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleInvPlaneElements(ctx) {
+  const { nodeOriginSSDeg, oneSourceM } = ctx;
+  // ONE published i_inv / Ω_inv everywhere — the mirror of the browser's
+  // inclInvPlaneModel / ascNodeInvPlaneModel (identical ops): the engine's
+  // own Earth-orbit normal of date (the one-source sampler — the banked
+  // secular series inside ±10 Myr, the mode tail beyond) against the
+  // artifact's invariable plane, the node expressed in the Souami & Souchay
+  // longitude origin through the same derived conversion the planets' node
+  // takes. Doc 05 banks the one-source reading at rms 0.003° vs La2010 over
+  // −500 kyr. Argument: the engine year (dynamical time,
+  // Julian from J2000 TT — the sampler's own coordinate, as the chain's).
+  const invPlaneGeometry = (() => {
+    const ip = /** @type {{ inclEclipticDeg: number, ascNodeEclipticDeg: number }} */ (/** @type {any} */ (CHAIN_ARTIFACT).invariablePlane);
+    const D2R = Math.PI / 180;
+    const si = Math.sin(ip.inclEclipticDeg * D2R), ci = Math.cos(ip.inclEclipticDeg * D2R);
+    const nInv = [si * Math.sin(ip.ascNodeEclipticDeg * D2R), -si * Math.cos(ip.ascNodeEclipticDeg * D2R), ci];
+    const xIp = [Math.cos(ip.ascNodeEclipticDeg * D2R), Math.sin(ip.ascNodeEclipticDeg * D2R), 0];
+    const yIp = [nInv[1] * xIp[2] - nInv[2] * xIp[1], nInv[2] * xIp[0] - nInv[0] * xIp[2], nInv[0] * xIp[1] - nInv[1] * xIp[0]];
+    return { ascNodeEclipticDeg: ip.ascNodeEclipticDeg, nInv, xIp, yIp };
+  })();
+  /** The engine Earth-orbit normal of date, J2000 ecliptic frame. @param {number} year @returns {number[]} */
+  const earthOrbitNormalJ2000At = (year) => {
+    const s = oneSourceM.sampleAt(year);
+    return [s.orbitNormalX, s.orbitNormalY, Math.sqrt(Math.max(0, 1 - s.orbitNormalX * s.orbitNormalX - s.orbitNormalY * s.orbitNormalY))];
+  };
+  /** Earth's inclination of date to the model's invariable plane, degrees. @param {number} year @returns {number} */
+  const inclinationDeg = (year) => {
+    const nE = earthOrbitNormalJ2000At(year), nInv = invPlaneGeometry.nInv;
+    const d = nE[0] * nInv[0] + nE[1] * nInv[1] + nE[2] * nInv[2];
+    return Math.acos(Math.min(1, Math.max(-1, d))) / (Math.PI / 180);
+  };
+  /** Earth's ascending node of date on the invariable plane, S&S origin, degrees in [0, 360). @param {number} year @returns {number} */
+  const ascendingNodeDeg = (year) => {
+    const D2R = Math.PI / 180;
+    const { ascNodeEclipticDeg, nInv, xIp, yIp } = invPlaneGeometry;
+    const nE = earthOrbitNormalJ2000At(year);
+    let N = [nInv[1] * nE[2] - nInv[2] * nE[1], nInv[2] * nE[0] - nInv[0] * nE[2], nInv[0] * nE[1] - nInv[1] * nE[0]];
+    const L = Math.hypot(N[0], N[1], N[2]);
+    N = [N[0] / L, N[1] / L, N[2] / L];
+    const sFrameDeg = ((Math.atan2(N[0] * yIp[0] + N[1] * yIp[1] + N[2] * yIp[2],
+      N[0] * xIp[0] + N[1] * xIp[1] + N[2] * xIp[2]) / D2R + ascNodeEclipticDeg) % 360 + 360) % 360;
+    return convertNodeSFrameToEquatorOriginDeg(sFrameDeg, nodeOriginSSDeg());
+  };
+
+  return { ascendingNodeDeg, inclinationDeg };
+}
+/** @typedef {import('./planet-elements-of-date.js').Ctx & ReturnType<typeof assembleInvPlaneElements>} Ctx */