@essrt/physics 23.3.3 → 24.0.0

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.orbitalPeriodInputDays * 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.orbitalPeriodInputDays);
+  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 */

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

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

package/src/model/planet-records.js

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

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

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

package/src/model/published-periods.js

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