@essrt/physics 23.3.3 → 23.6.0

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 */

package/src/model/lunar-theory.js

@@ -0,0 +1,216 @@
+/**
+ * Lunar theory — the shared-chain assembly: the derived months, the chain-cycle counters, the arguments, UT→TT, the Meeus series.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { createChainCycleIntegrator } from '../chain-cycles/index.cjs';
+import { J2000_JD, JULIAN_CENTURY_DAYS } from '../constants/units.cjs';
+import { createMoonArguments, jdToDecimalYear } from '../moon/arguments.cjs';
+import { createMoonSeries } from '../moon/series.cjs';
+import { driver2PeriodSecondsAtAge } from '../planets/orbit-chain.cjs';
+
+/** @param {import('./time-axis.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleLunarTheory(ctx) {
+  const {
+    C, F, late, EPOCH_PARAMS, axialPrecessionJ2000Days, chain, deepEcc, deepLod, meanDeltaTSecondsAtAge,
+    meanSiderealYearDays, meanSolarYearDays, meanTropicalYearJ2000Seconds, moonChain, moonDistanceKm,
+    moonDistanceMetresAtAge, moonSiderealMonth, oneSourceM, startmodelJD, startmodelYear, sunPerihelionDegAt,
+    yearFromJD,
+  } = ctx;
+  // Wiring mirrors the engine call sites exactly — tools/lib/deep-time.js
+  // (ecc channel, month chain, J2000 precession anchors),
+  // tools/lib/scene-graph.js (chain-cycles, arguments, series) and
+  // tools/verify/eclipse-audit.js (finders). Deep-time and framework-native
+  // are hardwired ON here: they are the shipped defaults; the A/B env
+  // toggles (SG_DEEP_TIME/MOON_ARGS_PURE_MEEUS) stay an engine concern.
+  const j2000JD = J2000_JD;                       // ONE home: constants/units (plan 14 step 2)
+  const julianCenturyDays = JULIAN_CENTURY_DAYS;
+
+  // J2000 Moon precession anchors (the IAU inputs themselves). The
+  // legacy-'ICRF'-named inputs hold the EQUINOX-OF-DATE observables (Meeus/
+  // IERS 3231.50 d / 6798.38 d); the star-referenced (inertial) periods
+  // follow by removing the equinox's own precession, 1/T_E = 1/T_I ∓ 1/T_p
+  // (perigee advances, node regresses), T_p the J2000 precession anchor.
+  const { moonApsidalJ2000Seconds } = chain;
+  // (The of-date perigee/node are the chain's count compositions —
+  // mcApsidalOfDate / mcNodalOfDate below.)
+
+  // Derived months on the IAU inputs (constants.js §Moon derived months)
+  const moonTropicalMonthDays = 1 / (1 / moonSiderealMonth + 1 / axialPrecessionJ2000Days);
+  const moonAnomalisticMonthDays = 1 / (1 / moonSiderealMonth - 86400 / moonApsidalJ2000Seconds);
+  const moonSynodicMonthDays = moonSiderealMonth * meanSiderealYearDays / (meanSiderealYearDays - moonSiderealMonth);
+
+  // The Layer-2 month/precession chain (Brouwer-Clemence m² scaling × the
+  // e_E-line modulation on the ONE deep e — decision (ii), plan 02 §8) is
+  // the deep-time chain's `moonChain` (deep-time-chain.js).
+
+  // Chain-cycle integrator. S5/S12 conventions: age anchor = startmodelYear
+  // (the scene's t_Ma convention), grid anchor C(2000) = 0 — grid anchor ≠
+  // age anchor, deliberately. One stable period fn per chain so the shared
+  // Float64Array tables key correctly and persist.
+  const chainCycles = createChainCycleIntegrator({
+    ageAnchorYear: startmodelYear,
+    tropicalYearJ2000Seconds: meanTropicalYearJ2000Seconds,   // the SI tick (plan 09 step 7c′)
+    isDeepTime: () => true,
+  });
+  /** @param {number} tMa @returns {number|null} */
+  const nodalMonthPeriodFn = (tMa) => moonChain.nodalMonthSecondsAtAge(tMa);
+  /** @param {number} tMa @returns {number|null} */
+  const tropicalMonthPeriodFn = (tMa) => moonChain.tropicalMonthSecondsAtAge(tMa);
+  /** @param {number} tMa @returns {number|null} */
+  const anomalisticMonthPeriodFn = (tMa) => moonChain.anomalisticMonthSecondsAtAge(tMa);
+  /** @param {number} tMa @returns {number|null} */
+  const siderealMonthPeriodFn = (tMa) => moonChain.siderealMonthSecondsAtAge(tMa);
+  const jupiterT0Seconds = C.planetOrbitalElements.jupiter.solarYearInput * 86400;
+  /** @param {number} tMa @returns {number} */
+  const jupiterPeriodFn = (tMa) => driver2PeriodSecondsAtAge(tMa, jupiterT0Seconds, EPOCH_PARAMS.solarMassLossFracPerYear);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcDraconic = (a, b) => chainCycles.cyclesBetween(nodalMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcTropical = (a, b) => chainCycles.cyclesBetween(tropicalMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcAnomalistic = (a, b) => chainCycles.cyclesBetween(anomalisticMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcJupiter = (a, b) => chainCycles.cyclesBetween(jupiterPeriodFn, a, b);
+  /** The Moon's sidereal (star-referenced) orbits — the series' A3 argument (plan 09 step 5c). @param {number} a @param {number} b @returns {number|null} */
+  const mcSidereal = (a, b) => chainCycles.cyclesBetween(siderealMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcApsidalOfDate = (a, b) => {
+    const t = mcTropical(a, b), n = mcAnomalistic(a, b);
+    return (t === null || n === null) ? null : t - n;
+  };
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcNodalOfDate = (a, b) => {
+    const dr = mcDraconic(a, b), t = mcTropical(a, b);
+    return (dr === null || t === null) ? null : dr - t;
+  };
+
+  // The argument skeleton (the _FW_MOON bundle; Sun secular deviations on
+  // the CALENDAR year coordinate — S3)
+  const moonArgs = createMoonArguments({
+    constants: {
+      j2000JD,
+      julianCenturyDays,
+      eccentricityJ2000: C.earthOrbital.earthEccentricityJ2000,
+      eccentricityDotJ2000: C.earthOrbital.earthEccentricityDotJ2000,
+      eccentricityDotDotJ2000: C.earthOrbital.earthEccentricityDotDotJ2000,
+      elpEarthFigureJ2ArcsecPerCy2: C.moonMeeus.elpW1T2Decomposition_arcsecPerCy2.earthFigureJ2,
+      elpGeneralPrecessionPA_T2ArcsecPerCy2: C.moonMeeus.elpW1T2Decomposition_arcsecPerCy2.generalPrecessionPA_T2_Lieske1976,
+      // Decision (ii): the lunar chain reads ONE deep e end to end
+      eccE0: deepEcc.e0,
+    },
+    fns: {
+      eccAt: /** @param {number} tYr */ (tYr) => deepEcc.eccAt(tYr),
+      channelIntegral: /** @param {number} T @param {number} s */ (T, s) => deepEcc.channelIntegral(T, s),
+      // The arguments' obliquity carrier reads the PUBLISHED ε (the one-source
+      // hybrid) — one ε everywhere. Twins: script.js (_sceneEpsTargetDeg), scene-graph.js.
+      computeObliquityEarth: /** @param {number} year @returns {number} */ (year) => oneSourceM.epsAt(year),
+      // The arguments' Sun IS the one certified Sun — the mean longitude that
+      // integrates the one-family tropical year (the eclipse finder's Sun,
+      // sun-and-eclipses.js) and the series' mean perihelion of date
+      // (unwrapped), both on the TT Julian-year axis. Twins: scene-graph.js,
+      // script.js.
+      sunMeanLonDegAtJdTT: /** @param {number} jdTT @returns {number} */ (jdTT) => late.sunMeanLongitudeDegAt(2000 + (jdTT - j2000JD) / 365.25),
+      sunPerihelionLonDegAtJdTT: /** @param {number} jdTT @returns {number} */ (jdTT) => sunPerihelionDegAt(2000 + (jdTT - j2000JD) / 365.25),
+      jdToSIyear: yearFromJD,
+      tropicalOrbitsBetween: mcTropical,
+      apsidalOfDateCyclesBetween: mcApsidalOfDate,
+      nodalOfDateCyclesBetween: mcNodalOfDate,
+      isDeepTime: () => true,
+      isFrameworkNative: () => true,
+      // (d′) of-date rate completion: the DYNAMICAL axial precession and the
+      // KINEMATIC pair's beat the chains embed. MATCHED TRIPLE with the
+      // tools-lib and browser wirings. The dynamical rate of date is the
+      // published precession period's (the one-family beat inside its window,
+      // the composed clock beyond — published-periods.js). Degrees per Julian year.
+      pDynDegPerYearAt: /** @param {number} year */ (year) => 360 / late.publishedAxialPrecessionYearsAtYear(year),
+      pKinDegPerYearAt: /** @param {number} year */ (year) => {
+        // MODEL-START-anchored age, matching the tools-lib/browser wirings
+        // bit-exactly — NOT yearToTMa's 2000.0 convention (the recorded
+        // 0.4977-yr parity trap, same class as getMoonDistanceKm in the series wiring below).
+        const t = (startmodelYear - year) / 1e6;
+        const sid = deepLod.siderealYearSecondsAtAge(t);
+        const trop = deepLod.tropicalYearSecondsAtAge(t);
+        return (sid === null || trop === null) ? 0 : 360 * (sid - trop) / sid;
+      },
+    },
+  });
+
+  // UT→TT on the CALENDAR decimal-year coordinate (script.js Phase 9.16 —
+  // a linear-year approximation here once cost ~5–6 s of ΔT and ~1e-3° of
+  // Moon longitude at the Babylonian epochs)
+  /** @param {number} jd @returns {number} */
+  const jdTTFromUT = (jd) => {
+    const tMa = (startmodelYear - jdToDecimalYear(jd)) / 1e6;
+    const dT = meanDeltaTSecondsAtAge(tMa);
+    return Number.isFinite(dT) ? jd + dT / 86400 : jd;
+  };
+  // ΔT at a JD on the CALENDAR-year axis (mirrors deep-time frameworkDeltaT;
+  // NOT deltaTSeconds of delta-t.js, which adds the deltaTStart anchor)
+  /** @param {number} jd @returns {number} */
+  const frameworkDeltaTSecondsAtJD = (jd) => {
+    const decYear = startmodelYear + (jd - startmodelJD) / meanSolarYearDays;
+    const dT = meanDeltaTSecondsAtAge((startmodelYear - decYear) / 1e6);
+    return Number.isFinite(dT) ? dT : 0;
+  };
+
+  // Bounded Meeus E-factor from the ONE deep e (decision (ii); the
+  // pure-Meeus polynomial A/B branch stays engine-local)
+  /** @param {number} dDays @returns {number} */
+  // (on the channel's Julian-year axis — the N-body series' time)
+  const fwEFactor = (dDays) => deepEcc.eFactorAt(dDays / 365.25);
+
+  // D2 derived additional-argument rates (deg/cy, from the J2000 month inputs —
+  // docs/109 §22 for the derivation)
+  const fwA2RateDegPerCy = 2 * ((360 * 36525) / moonTropicalMonthDays)
+    - (360 * 36525) / moonAnomalisticMonthDays
+    - 2 * ((360 * 36525) / C.planetOrbitalElements.jupiter.solarYearInput);
+  const fwA3RateDegPerCy = (360 * 36525) / moonSiderealMonth;
+
+  // Meeus Ch. 47 truncated series (framework-native arguments + E-factor)
+  const moonSeries = createMoonSeries({
+    constants: {
+      moonL: F.MEEUS_LONGITUDE_TERMS,
+      moonB: F.MEEUS_LATITUDE_TERMS,
+      moonR: F.MEEUS_DISTANCE_TERMS.terms,
+      moonRMeanKm: F.MEEUS_DISTANCE_TERMS.meanKm,
+      moonDistanceJ2000Km: C.moonReference.moonDistance,
+      j2000JD,
+      julianCenturyDays,
+      fwA2RateDegPerCy,
+      fwA3RateDegPerCy,
+    },
+    fns: {
+      argsAt: /** @param {number} jdTT */ (jdTT) => moonArgs.argsAt(jdTT),
+      eFactorForD: fwEFactor,
+      eFactorAtJdTT: /** @param {number} jdTT */ (jdTT) => fwEFactor(jdTT - j2000JD),
+      // 20.3d(i): the Driver-1 ratio at the EVALUATED epoch (per-jd pure
+      // evaluator). MATCHED TRIPLE with the tools-lib and browser getters:
+      // identical age arithmetic — the SI-linear year (yearFromJD, never
+      // the calendar year: the recorded linear-vs-calendar mirror trap)
+      // against the MODEL-START anchor (startmodelYear, the browser's
+      // J2000_CALENDAR_YEAR — NOT this model's 2000.0 yearToTMa convention:
+      // the 0.5-yr difference is 4.95e-11 of distance and failed the
+      // bit-exact parity gate; plan 11 step 5 dropped the −0.83-d correction
+      // from the anchor, both twins alike). Falls back to the J2000 constant
+      // without a jd (legacy call shape) or past the domain.
+      getMoonDistanceKm: /** @param {number} [jdTT] */ (jdTT) => {
+        if (jdTT === undefined) return moonDistanceKm;
+        const d = moonDistanceMetresAtAge((startmodelYear - yearFromJD(jdTT)) / 1e6);
+        return d === null ? moonDistanceKm : d / 1000;
+      },
+      getEccentricityBase: () => C.moonReference.moonOrbitalEccentricityBase,
+      deltaTSeconds: /** @param {number} jd */ (jd) => (jdTTFromUT(jd) - jd) * 86400,
+      jdToSIyear: yearFromJD,
+      tropicalOrbitsBetween: mcTropical,
+      apsidalOfDateCyclesBetween: mcApsidalOfDate,
+      siderealOrbitsBetween: mcSidereal,
+      jupiterOrbitsBetween: mcJupiter,
+      isDeepTime: () => true,
+      isFrameworkNative: () => true,
+    },
+  });
+
+  return { frameworkDeltaTSecondsAtJD, j2000JD, jdTTFromUT, julianCenturyDays, moonArgs, moonSeries, moonSynodicMonthDays };
+}
+/** @typedef {import('./time-axis.js').Ctx & ReturnType<typeof assembleLunarTheory>} Ctx */

package/src/model/moon-epoch.js

@@ -0,0 +1,28 @@
+/**
+ * The Moon at epoch — the solar-Δa-corrected Kepler month.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+
+/** @param {import('./one-source-movement.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleMoonEpoch(ctx) {
+  const {
+    EPOCH_PARAMS, MASS_RATIO_EARTH_MOON, deepLod, moonDistanceMetresAtAge, moonSiderealMonthInput, yearToTMa,
+  } = ctx;
+  /** Solar-Δa-corrected Kepler month. @param {number} year @returns {number} */
+  const moonSiderealMonthDaysAt = (year) => {
+    const tMa = yearToTMa(year);
+    const lod = deepLod.lodSecondsAtAge(tMa);
+    const aAppM = moonDistanceMetresAtAge(tMa);
+    if (lod === null || aAppM === null) return NaN;
+    const aAppKm = aAppM / 1000;
+    const sidYrDays = deepLod.siderealYearSecondsAtAge(tMa) / lod;
+    const deltaA = aAppKm * (1 / (MASS_RATIO_EARTH_MOON + 1)) * (moonSiderealMonthInput / sidYrDays);
+    const aCorrM = (aAppKm + deltaA) * 1000;
+    const monthSeconds = 2 * Math.PI * Math.sqrt(Math.pow(aCorrM, 3) / EPOCH_PARAMS.gmEarthMoonM3S2);
+    return monthSeconds / lod;
+  };
+
+  return { moonSiderealMonthDaysAt };
+}
+/** @typedef {import('./one-source-movement.js').Ctx & ReturnType<typeof assembleMoonEpoch>} Ctx */

package/src/model/one-source-movement.js

@@ -0,0 +1,192 @@
+/**
+ * The one-source movement — the hybrid's ε(t), e(t), ϖ(t) on the per-tier sampler, the ONE year-length family, and the days of date on them.
+ *
+ * One slice of `assembleModel` (../model.js): receives the context the earlier slices built, returns the bindings the later ones read.
+ */
+import { createDeepOrbitalHistory } from '../earth/deep-orbital-history.cjs';
+import { ONE_FAMILY_WINDOW_YEARS, createYearLengths } from '../earth/year-lengths.cjs';
+import { DEEP_MODES_ARTIFACT } from '../moon/deep-modes-artifact.cjs';
+import { CHAIN_ARTIFACT } from '../planets/chain-artifact.js';
+
+/** @param {import('./year-day-lengths.js').Ctx} ctx @returns the bindings the later slices read */
+export function assembleOneSourceMovement(ctx) {
+  const {
+    C, options, secularSeriesArtifact, EPOCH_PARAMS, alphaGia, certifiedAxialPrecessionJ2000Years, dayLengthSeconds,
+    deepLod, dtCycleLodCorrectionSum, meanSolarYearDays, startmodelYear, yearToTMa,
+  } = ctx;
+  // The cardinal INSTANTS are the crossings of the one Sun the scene renders
+  // and the eclipse chain certifies (cardinal-instants.js); the cardinal
+  // STRUCTURE here is 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 package's embedded deep-modes artifact; the series
+  // tier when the governed artifact is injected). Absolute dates deliberately
+  // absent — see cardinal/one-source-structure.cjs. The mean year is SI
+  // SECONDS: the sidereal year of date reduced by the SECULAR equinox
+  // precession on the composed T_p(t).
+  // THE ONE of-date year-length family — createYearLengths owns tropical
+  // (equinox-rate mean, wobble included), sidereal (the λ̇ channel),
+  // anomalistic (the cardinal structure on the SAME mean), all λ̇-corrected
+  // coherently, SI seconds, and the beats of that pair.
+  // S3 tier unification: when the caller injects the governed secular-
+  // series artifact (createModel opts.secularSeriesArtifact — the API/Node
+  // path; the npm package alone has no 8 MB series), the movement runs the
+  // SERIES tier exactly like the browser — killing the mode-vs-series
+  // value split (measured: 6 s on the anomalistic year at J2000).
+  // The ONE-SOURCE movement: the hybrid's ε(t) (plan 06 Phase 3 S3b — THE
+  // published obliquity) and the one-family year lengths, on the same
+  // per-tier sampler.
+  const oneSourceM = (() => {
+    const AEarth = /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements.earth;
+    // The ψ̇ anchor: the IAU 2006 general precession p_A (25,771.575 yr — the
+    // ONE home certifiedAxialPrecessionJ2000Years, twins in tools-lib and the
+    // browser).
+    const axial0 = certifiedAxialPrecessionJ2000Years();   // the ONE home
+    // The deep-time ψ̇(t) the hybrid precesses on is the COMPOSED lunisolar
+    // rate — its period of date T_p(t) read directly; the composition carries
+    // the lunar 1/a³ growth (104.5 ″/yr at 2.46 Ga against Lantink 2022's
+    // 108.6 ± 8.5).
+    const seriesArt = /** @type {any} */ (secularSeriesArtifact);
+    const sb = seriesArt && seriesArt.bodies && seriesArt.bodies.earth;
+    // Plan 12 §8.5 (owner): the hybrid's own domain is the banked ζ series' span (years; null
+    // without a series). Beyond it the ζ-mode tail carries the Quaternary mean with no tidal
+    // evolution — the API refuses the obliquity there and serves the cited mean beside it.
+    const obliquityHybridDomainYears = sb
+      ? /** @type {[number, number]} */ ([2000 + seriesArt.t0Yr, 2000 + seriesArt.t0Yr + (sb.zetaQ.length - 1) * sb.stepYr])
+      : null;
+    const hist = createDeepOrbitalHistory({
+      zModes: DEEP_MODES_ARTIFACT.earthZ,
+      zetaModes: DEEP_MODES_ARTIFACT.earthZeta,
+      ...(sb ? {
+        zetaSeries: { t0Yr: seriesArt.t0Yr, stepYr: sb.stepYr, q: sb.zetaQ, p: sb.zetaP },
+        zSeries: { t0Yr: seriesArt.t0Yr, stepYr: sb.stepYr, q: sb.zQ, p: sb.zP },
+      } : {}),
+      anchorE: AEarth.e,
+      anchorPeriEclipticDeg: AEarth.lonPeriEclipticDeg,
+      anchorInclEclipticDeg: AEarth.inclEclipticDeg,
+      anchorAscNodeEclipticDeg: AEarth.ascNodeEclipticDeg,
+      axialPrecessionYearsJ2000: axial0,
+      // The hybrid's initial condition is the OBSERVED J2000 mean obliquity —
+      // the IAU 2006 input constant (84381.406″), the same anchor the
+      // browser's _deepHistSeries and the Node one-source movement use.
+      obliquityJ2000Deg: C.earthOrbital.obliquityJ2000_deg,
+      // The CONSTANT's scaling (the torque period), not the published rate of date: the
+      // integration's own ŝ·n̂ carries the obliquity's cosine, so the cited mean obliquity's
+      // factor (plan 12 §8 option (a)) must not enter twice. Bit-identical to the pre-§8 form.
+      axialPrecessionYearsAtYearFn: (yr) => deepLod.lunisolarTorquePeriodYearsAtAge((startmodelYear - yr) / 1e6) ?? axial0,
+      // THE PRECESSION OF DATE: on top of the secular law above, the solar
+      // torque at the eccentricity of date and the oblateness of date from
+      // the GIA channel — both exactly 1 at J2000, so the J2000 anchor is
+      // untouched. The channel is
+      // read PURE (alphaGia, not the lattice-pin-aware earthMoiFactorAtAge):
+      // the samplers are cached, their values must be pure in year.
+      solarTorqueShareJ2000: EPOCH_PARAMS.precessionSolarShareJ2000,
+      // options.giaEllipticityOfDate === false: the orbital forcing alone (the T1 line derivation).
+      dynamicalEllipticityRatioAtYearFn: options.giaEllipticityOfDate === false ? undefined : alphaGia.j2RatioAt,
+    });
+    // PER-TIER ROUTING (the anomalistic-contamination fix): one sampler PER
+    // grid tier, built on first entry and KEPT — a query always reads the
+    // tier its own span selects. The former single grown sampler replaced
+    // the 100-yr grid with the 1000/5000-yr one after any deep-time probe,
+    // and the year-length rates (±0.5-yr central differences through the
+    // grid) then returned grid-segment averages instead of local rates
+    // (anomalistic of date +2.63 s / +19 s, visit-order dependent).
+    const samplers = /** @type {Map<number, any>} */ (new Map());
+    const gridStep = (/** @type {number} */ n) => (n <= 50000 ? 100 : n <= 2000000 ? 1000 : 5000);
+    const tierSpan = (/** @type {number} */ n) => (n <= 50000 ? 50000 : 2000000);
+    const sampleAt = (/** @type {number} */ year) => {
+      const t = year - 2000, need = Math.max(20000, Math.abs(t) * 1.25);
+      if (need > 2000000) {
+        // The deep tier (5000-yr grid): walked in the queried DIRECTION only,
+        // to two nodes past the query, and EXTENDED by the factory's shared
+        // walk when a deeper epoch arrives (plan 13 A1). It was built to
+        // ±1.25·|t| in both directions and rebuilt from J2000 on every deeper
+        // probe — bit-identical values, 4× the RK4 steps of one walk.
+        const span = Math.ceil((Math.abs(t) + 2 * 5000) / 5000) * 5000;
+        return hist.build(t < 0 ? -span : span, 0, 5000).at(t);
+      }
+      const span = tierSpan(need);
+      if (!samplers.has(span)) samplers.set(span, hist.build(span, -span, gridStep(span)));
+      return samplers.get(span).at(t);
+    };
+    // The anomalistic year rides THIS movement's own apsidal line (the
+    // scene's perihelion) — the factory owns the construction; the planet
+    // chain's secular tangent is no longer a member (year-lengths.cjs).
+    const yearLengths = createYearLengths({
+      sampleAt,
+      massLossSiderealSecondsAtYearFn: (year) => deepLod.siderealYearSecondsAtAge(yearToTMa(year)),
+    });
+    return {
+      yearLengths,
+      /** The one-source sample at a decimal year (the engine year) — ε, e, ϖ of date, the Earth-orbit normal (the fields the frame of date and the invariable-plane elements read). @param {number} year */
+      sampleAt,
+      /** 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,
+      /** The hybrid's own domain, [yearFrom, yearTo] — the banked ζ series' span (plan 12 §8.5); null without a series. */
+      obliquityHybridDomainYears,
+      /** The precession of date's two factors at a decimal year (the factory's own — ONE home). @param {number} year @returns {{solarTorque: number, ellipticity: number}} */
+      precessionOfDateFactorsAt: (year) => hist.precessionOfDateFactorsAt(year - 2000),
+      /** The spin axis's INERTIAL precession period at J2000, years — the self-anchored
+       *  lunisolar rate the hybrid integrates ŝ on (deep-orbital-history D4e): the general
+       *  precession anchor plus the planetary mean the ecliptic's own motion carries. */
+      axialPrecessionYearsLunisolarJ2000: hist.axialPrecessionYearsLunisolarJ2000,
+    };
+  })();
+  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 of date in DAYS OF THE EPOCH (the kinematic day,
+   *  year-day-lengths.js) — the one-family SI year over the epoch's day
+   *  length, so solarYearSeconds ≡ the one-family year. @param {number} year @returns {number} */
+  const tropicalYearDays = (year) => oneFamilyTropicalYearSeconds(year) / dayLengthSeconds(year);
+
+  /** Layer-4 solar day of date in SI seconds — LOD_real, the shipped
+   *  observable (the tweakpane Solar Day row, the registry's lodRealPhysical,
+   *  the Framework Verification panel's day): the kinematic day of date + the
+   *  ecliptic missing-motion term on the nodal period + the calibrated ΔT
+   *  cycle stack incl. the core-mantle swing. Twin of tools/lib
+   *  computeLodRealSecondsAtEpoch and the browser's _vfpSolarDaySecondsOfDate
+   *  (86,400.001780 s at 2000). @param {number} year @returns {number} */
+  const lodRealSeconds = (year) =>
+    dayLengthSeconds(year)
+    + (deepLod.eclipticLodCorrectionSecondsAtAge(yearToTMa(year)) ?? 0)
+    + dtCycleLodCorrectionSum(year);
+  /** Mean sidereal day of date in SI seconds — on LOD_real (plan 08 storyline
+   *  sweep, 2026-10-09: the published day bases are the SI day of exactly
+   *  86,400 s, the IAU constants, and LOD_real; this rode the KINEMATIC day
+   *  before, 1.7 ms below the simulator's readout at J2000). One rotation
+   *  more against the equinox than there are solar days in a year.
+   *  @param {number} year @returns {number} */
+  const siderealDaySeconds = (year) => {
+    const Y = tropicalYearDays(year);
+    return (lodRealSeconds(year) * Y) / (Y + 1);
+  };
+  /** Mean stellar day of date in SI seconds — the sidereal day plus the
+   *  equinox's daily regression projected onto the equator (on LOD_real, like
+   *  the sidereal day). @param {number} year @returns {number} */
+  const stellarDaySeconds = (year) => {
+    const tMa = yearToTMa(year);
+    // One equinox turn per T_p(t) — the composed lunisolar period (its
+    // certified J2000 anchor past the chain's domain).
+    const TpRaw = deepLod.lunisolarPrecessionPeriodYearsAtAge(tMa);
+    const Tp = TpRaw === null ? certifiedAxialPrecessionJ2000Years() : TpRaw;
+    const syD = tropicalYearDays(year);
+    const sidDay = siderealDaySeconds(year);
+    // The RA projection reads the published ε (the one-source hybrid) — the
+    // browser's _sceneEpsTargetDeg twin; 1e-8 s.
+    const raProjection = Math.cos((oneSourceM.epsAt(year) * Math.PI) / 180);
+    return (sidDay / Tp / (syD + 1)) * raProjection + sidDay;
+  };
+
+  return { lodRealSeconds, oneFamilyTropicalYearSeconds, oneSourceM, siderealDaySeconds, stellarDaySeconds, tropicalYearDays, yearLengthsM };
+}
+/** @typedef {import('./year-day-lengths.js').Ctx & ReturnType<typeof assembleOneSourceMovement>} Ctx */