@essrt/physics 23.3.2 → 23.6.0

package/src/deltat/deep-time.cjs

@@ -1,11 +1,10 @@
 /**
  * Deep-time LOD / ΔT core — THE shared implementation (Phase 8.4, slice 3).
  *
- * The angular-momentum-conservation LOD (Layer 1/2), the H(t) identity, the
- * mass-loss year chain, the Simpson ΔT integrator with the H/5 ecliptic
- * "missing motion" integrand, the corrected-LOD composite, the Actual-LOD
- * Fourier ripple, and the dLOD/dt driver decomposition (tidal / GIA /
- * stack / resonator channels).
+ * The angular-momentum-conservation LOD (Layer 1/2), the composed precession
+ * rate, the mass-loss year chain, the Simpson ΔT integrator with the ecliptic
+ * "missing motion" integrand, the corrected-LOD composite, and the dLOD/dt
+ * driver decomposition (tidal / GIA / stack / resonator channels).
  *
  * INJECTED, by design:
  *  - moonDistanceMetresAtAge — the 8.2 moon month-chain (each engine's own
@@ -44,11 +43,11 @@ const { createComposedPrecession } = require('../earth/precession-composed.cjs')
  * @property {number} aLockMetres - tidal-lock distance (LOD denominator → 0)
  * @property {number} aMoonNowMetres - Farhat polynomial anchor
  * @property {number} alpha1PerMa - the LLR recession rate (the J2000 slope of the cited history)
- * @property {number} lodNowH13Seconds - ω₀, the J2000 day length (the SI day since plan 09; identifier kept)
+ * @property {number} lodNowH13Seconds - ω₀, the J2000 day length (the SI day; identifier kept)
  * @property {number} meanSiderealYearJ2000Seconds
  * @property {number} solarMassLossFracPerYear
  * @property {number} precessionSolarShareJ2000 - f_S, the solar fraction of the J2000
- *   precession torque (derive-params) — the unit H(t) = 13·T_p,composed needs it
+ *   precession torque (derive-params) — the composed precession rate needs it
  */
 
 /**
@@ -59,23 +58,20 @@ const { createComposedPrecession } = require('../earth/precession-composed.cjs')
  * @property {(year: number) => number} cycleLodSumAt - gated δLOD sum (incl. swing)
  * @property {(year: number) => number} swingLodAt - gated swing δLOD alone
  * @property {(year: number) => number} swingLodRateAt - gated analytic swing rate
- * @property {() => number} precessionPeriodJ2000YearsFn - the model's DERIVED
- *   J2000 axial precession period: the certified year-length laws' beat at
- *   2000, sid/(sid − trop) ≈ 25,771.4 yr (plan 06 S5 — one J2000 precession
- *   reading; the same anchor the hybrid obliquity self-anchors on). Read
+ * @property {() => number} precessionPeriodJ2000YearsFn - the model's J2000 axial
+ *   precession period, 1,296,000/p_A = 25,771.575 yr (the IAU 2006 general
+ *   precession; the same anchor the hybrid obliquity self-anchors on). Read
  *   LAZILY on the first composed-rate use, never at construction: every
  *   runtime's year laws read THIS factory's bases.
  * @property {() => number} nodalPeriodYearsFn - the period of Earth's orbit
  *   plane's nodal regression on the invariable plane, 1,296,000/|s₃| with s₃
  *   the dominant ζ mode of the banked deep secular modes (≈ 68,751 yr). An
  *   ORBITAL quantity (μ-tier: it does not follow Earth's spin), the reference
- *   the solar day's "ecliptic missing motion" term rides (plan 06 T2 item —
- *   formerly the spin unit's H/5, 67,063 yr, 2.5 % off and scaling with the
- *   spin at deep time). Lazy, like the precession anchor.
+ *   the solar day's "ecliptic missing motion" term rides. Lazy, like the
+ *   precession anchor.
  * @property {(tMa: number) => number} [lEmAtAgeKgm2S] - OPTIONAL time-dependent
  *   Earth-Moon angular momentum. Absent → the J2000 constant: conservation
- *   (plan 12 option A — the Driver-1½ solar-channel budget is deleted;
- *   measured: conservation on the cited history reproduces Farhat's own LOD
+ *   (measured: conservation on the cited history reproduces Farhat's own LOD
  *   to 0.01 h at 100 Ma, 0.14 h at 2.46 Ga).
  * @property {(tMa: number) => number|null} [moonDistanceSlopeMetresPerMaAtAge] -
  *   OPTIONAL analytic slope of the distance history (metres per Ma, positive
@@ -84,7 +80,7 @@ const { createComposedPrecession } = require('../earth/precession-composed.cjs')
  * @property {(tMa: number) => number|null} [meanObliquityCosRatioAtAge] -
  *   OPTIONAL cos ε̄(t)/cos ε̄(0) of the cited mean obliquity (earth/mean-
  *   obliquity-history) — the factor the precession RATE of date carries on the
- *   constant (plan 12 §8 option (a)); absent → 1, the constant alone, bit-identical.
+ *   constant; absent → 1, the constant alone, bit-identical.
  */
 
 /** @param {DeepTimeLodDeps} deps */
@@ -117,26 +113,12 @@ function createDeepTimeLod(deps) {
     return (s === null) ? null : s / 3600;
   }
 
-  // (Plan 09 step 7a deleted the FROZEN ERA CLOCK's public counter
-  // `eraClockHAtAge` — H_era(t) = H₀·LOD(t)/LOD₀, plan 06 D8's second named
-  // counter — with its year twins; step 7b deleted the unit itself, `hAtAge`
-  // = H_era/[f_S + (1 − f_S)(a₀/a_M)³] — H(t) was 13.011 composed precession
-  // periods, a fit constant's multiple of T_p(t), never a period of anything
-  // the model computes. The physics it scaled is the composed precession
-  // below: ψ̇(t) and T_p(t) = 1,296,000/ψ̇ are the published quantities.)
-  // The `…FromLod` twins take an ALREADY-COMPUTED LOD(t): the Simpson ΔT
-  // integrand below evaluated the LOD four times and the tropical year twice
-  // per node through these helpers (measured 8.8 → 4.8 ms per cardinal panel
-  // year with the model's ΔT memo). Same operations, same inputs — every
-  // value bit-identical (11,958-value sweep, 0 differences).
-
-  // The composed lunisolar precession (plan 06 D6 → Phase 3 → S5; plan 12 §8):
-  // the CONSTANT's scaling [ω(t)/ω₀]·p₀·[f_S + (1 − f_S)(a₀/a_M(t))³] and the
-  // RATE of date, that × cos ε̄(t)/cos ε̄(0) on the cited mean obliquity; p₀ the
-  // model's J2000 rate 1,296,000/axial0 (the IAU 2006 general precession since
-  // plan 09). ONE formula home: earth/precession-composed, built here on this
-  // factory's own LOD, recession and obliquity histories; the anchor resolves
-  // lazily on the first rate use.
+  // The composed lunisolar precession: the CONSTANT's scaling
+  // [ω(t)/ω₀]·p₀·[f_S + (1 − f_S)(a₀/a_M(t))³] and the RATE of date, that ×
+  // cos ε̄(t)/cos ε̄(0) on the cited mean obliquity; p₀ the model's J2000 rate
+  // 1,296,000/axial0 (the IAU 2006 general precession). ONE formula home:
+  // earth/precession-composed, built here on this factory's own LOD, recession
+  // and obliquity histories; the anchor resolves lazily on the first rate use.
   const composed = createComposedPrecession({
     p0ArcsecPerYr: () => 1296000 / deps.precessionPeriodJ2000YearsFn(),
     solarShare: K.precessionSolarShareJ2000,
@@ -148,11 +130,10 @@ function createDeepTimeLod(deps) {
     meanObliquityCosRatioAtAge: deps.meanObliquityCosRatioAtAge,
   });
 
-
   /** THE PRECESSION RATE OF DATE ψ̇(t), ″/yr — the constant's scaling
    * p₀·[ω/ω₀]·[f_S + (1 − f_S)(a₀/a_M)³] × cos ε̄(t)/cos ε̄(0), ε̄ the cited mean
-   * obliquity (plan 12 §8 option (a); the chain held cos ε̄ at J2000 before —
-   * 2.5 % of rate at 2.46 Ga, 2e-7 at 10 kyr). p₀ the J2000 anchor (S5).
+   * obliquity (its factor is 2.5 % of the rate at 2.46 Ga, 2e-7 at 10 kyr);
+   * p₀ the J2000 anchor.
    * @param {number} t_Ma @returns {number|null} */
   function lunisolarPrecessionRateArcsecPerYrAtAge(t_Ma) {
     return composed.composedRateArcsecPerYrAtAge(t_Ma);
@@ -192,23 +173,18 @@ function createDeepTimeLod(deps) {
     // a(t) = a₀·(1−Δm)): T ∝ M⁻² ⇒ T(t) = T₀·(1−Δm)² — the SAME Driver-2
     // law the planet chains use (orbit-chain driver2PeriodSecondsAtAge).
     // The previous (1 − 2Δm) was this law's first-order Taylor — the one
-    // form in the model inconsistent with it (measured on the retired day-count
-    // identity of the era counter: with the product form the counter's
-    // H_era·(days/yr)·(AU₀/AU)² held exactly — a tautology of spin scaling ∘
-    // Kepler, deleted with the counter and the unit at plan 09 steps 7a/7b).
+    // form in the model inconsistent with it.
     return K.meanSiderealYearJ2000Seconds * (1 - mass_loss_fraction) * (1 - mass_loss_fraction);
   }
 
   /** Tropical year of date, seconds — the sidereal year less the equinox's
    * own motion over one year: one turn per the composed lunisolar precession
    * period T_p(t), 1/T_trop = 1/T_sid + ψ̇(t)/(1,296,000″ · Julian-year s),
-   * ψ̇(t) the RATE of date (with the cited mean obliquity's cosine, plan 12 §8).
-   * Plan 09 step 5d: it was the unit's calendar convention sid·(1 − 13/H(t))
-   * — plan 06 D2 had kept it as a named device — 0.086 % slow on the equinox
-   * term (1.0 s of year at J2000), and the deep JD↔year calendar integrates
-   * THIS. The SAME operations as layer0's tropicalYearSecondsCore (the
-   * layer0 gate holds the twins bit-identical). Past the tidal chain's domain
-   * the J2000 rate stands in. @param {number} t_Ma @returns {number} */
+   * ψ̇(t) the RATE of date (with the cited mean obliquity's cosine). The deep
+   * JD↔year calendar integrates THIS. The SAME operations as layer0's
+   * tropicalYearSecondsCore (the layer0 gate holds the twins bit-identical).
+   * Past the tidal chain's domain the J2000 rate stands in.
+   * @param {number} t_Ma @returns {number} */
   function tropicalYearSecondsAtAge(t_Ma) {
     return tropicalYearSecondsFromLod(t_Ma, lodSecondsAtAge(t_Ma));
   }
@@ -235,10 +211,6 @@ function createDeepTimeLod(deps) {
     return tropicalYearSecondsAtAge(t_Ma) / LOD_s;
   }
 
-  // (Plan 09 step 7a: the frozen era clock's year twins on H_era —
-  // T_sid·(1 − 13/H_era) and its day count, the bases the deleted cardinal
-  // record and year-length combs were fitted against — are deleted.)
-
   /**
    * The solar day's "ecliptic missing motion" correction, seconds: the mean
    * solar day is counted against the Sun on the ECLIPTIC, whose plane turns
@@ -247,8 +219,7 @@ function createDeepTimeLod(deps) {
    * (≈ 3.44 ms at J2000). T_s₃ is an orbital quantity: constant at every
    * epoch (μ-tier), so the term rides only LOD_mean and the year length at
    * deep time. ONE home for the three runtimes' `h5Correction` twins (the
-   * identifier keeps its name; the divisor is the nodal period since the
-   * plan 06 T2 restatement, formerly the spin unit's H/5).
+   * identifier keeps its historical name; the divisor is the nodal period).
    * @param {number} t_Ma @returns {number|null} seconds (null past tidal lock)
    */
   function eclipticLodCorrectionSecondsAtAge(t_Ma) {
@@ -305,10 +276,6 @@ function createDeepTimeLod(deps) {
     return tidal + deps.cycleLodSumAt(year);
   }
 
-  // (Plan 09: the "Actual LOD" — the tidal mean × the retired sidereal-year
-  // comb's ripple — is deleted with the comb; the ripple was the sidereal
-  // year's λ̇ variation misattributed to the day length.)
-
   /**
    * dLOD/dt driver decomposition, ms/century per channel.
    * tidal: Moon-recession (Farhat da/dt, LLR-anchored) · gia: α(t) numeric
@@ -331,12 +298,11 @@ function createDeepTimeLod(deps) {
     const I_E = alpha * K.mEarthAloneKg * K.rEarthMetres * K.rEarthMetres;
     const year = 2000 - t_Ma * 1e6;
 
-    // The cited history's slope (plan 12 option A): the engine's
-    // moonDistanceSlopeMetresPerMaAtAge when it provides one (the Hermite's
-    // analytic derivative — C1, smooth), else a ±1-kyr central difference on
-    // the distance itself. t_Ma > 0 = past; forward-time sign flip. At J2000
-    // the slope IS the LLR observation (the history's boundary condition):
-    // +3.82 cm/yr ✓
+    // The cited history's slope: the engine's moonDistanceSlopeMetresPerMaAtAge
+    // when it provides one (the Hermite's analytic derivative — C1, smooth),
+    // else a ±1-kyr central difference on the distance itself. t_Ma > 0 =
+    // past; forward-time sign flip. At J2000 the slope IS the LLR observation
+    // (the history's boundary condition): +3.82 cm/yr ✓
     let slopePerMa = deps.moonDistanceSlopeMetresPerMaAtAge ? deps.moonDistanceSlopeMetresPerMaAtAge(t_Ma) : null;
     if (slopePerMa === null || slopePerMa === undefined) {
       const H_MA = 1e-3;
@@ -387,19 +353,18 @@ function createDeepTimeLod(deps) {
   return {
     lodSecondsAtAge, lodSecondsAtAgeWithAlpha, lodHoursAtAge,
     lunisolarPrecessionRateArcsecPerYrAtAge, lunisolarPrecessionPeriodYearsAtAge,
-    // the constant's scaling alone (the hybrid's integrand) and the rate's obliquity factor (plan 12 §8)
+    // the constant's scaling alone (the hybrid's integrand) and the rate's obliquity factor
     lunisolarTorqueRateArcsecPerYrAtAge, lunisolarTorquePeriodYearsAtAge, precessionObliquityFactorAtAge,
-    // the composition's terms (plan 06 Phase 3 S3, the lunisolar surface): (a₀/a_M)³ and f_S + (1 − f_S)(a₀/a_M)³
+    // the composition's terms (the lunisolar surface): (a₀/a_M)³ and f_S + (1 − f_S)(a₀/a_M)³
     lunarTorqueFactorAtAge: composed.lunarTorqueFactorAtAge,
     precessionTorqueTermAtAge: composed.torqueTermAtAge,
     siderealYearSecondsAtAge, tropicalYearSecondsAtAge, tropicalYearDaysAtAge,
-    // the same law on a caller-supplied LOD (the browser's L1-α sensitivity sweep; plan 09 step 7c)
+    // the same law on a caller-supplied LOD (the browser's L1-α sensitivity sweep)
     tropicalYearSecondsFromLod,
-    // the solar day's ecliptic missing-motion term on the nodal period (plan 06 T2 item; one home)
+    // the solar day's ecliptic missing-motion term on the nodal period (one home)
     eclipticLodCorrectionSecondsAtAge,
     yearInDaysAtAge, deltaTRawSecondsAtAge, lodSecondsWithCorrectionsAtAge,
     dLodDtDecompositionAtAge,
-    // (plan 09 step 7a: the frozen era clock's counter and bases left with the last comb)
   };
 }
 

package/src/index.js

@@ -61,7 +61,7 @@ const NEVER_INJECTABLE = Object.keys(REFERENCE_DATA);
 
 /**
  * Generated at build time from `public/input/astro-reference.json` (plus the
- * deep-time block the generator assembles; model-parameters.json is deleted, plan 11)
+ * deep-time block the generator assembles)
  * (§2g) by `tools/constants/generate.mjs`. 324 values across 15 blocks.
  *
  * Free parameters and measured anchors only. Validation targets are excluded by
@@ -95,29 +95,21 @@ export { FITTED_COEFFICIENTS, COEFFICIENTS_HASH } from './constants/index.js';
 export { createEpochPrimitives } from './layer0/index.js';
 export { deriveEpochParams } from './layer0/derive-params.js';
 export { createDerivedViews } from './layer1/index.js';
-// (Plan 09 step 7a: the Phase 7 integrated-phase machinery `createPhaseMachinery`
-// — the ∫dt/H_era table and the cycle counters every comb read — and the
-// frozen cardinal record evaluator `createCardinalModel` (the §10 derived
-// form on the deleted CARDINAL_POINT_* coefficients) are DELETED; the
-// cardinal instants are createModel().cardinal, the one Sun's crossings.)
 // The deep-time calendar (year ↔ JD under the drifting year length) — ONE
-// implementation for both engines since the year/day collapse (formerly the
-// PHASE-B-DUPLICATE family). CJS on purpose: tools/lib requires the same
+// implementation for both engines. CJS on purpose: tools/lib requires the same
 // file via the exports-map subpath; re-exported here so bundled ESM
 // consumers need only the package root.
 export { createDeepCalendar } from './phase/deep-calendar.cjs';
-// Plan 13 B1: the civil calendar ↔ JD (Meeus ch. 7 with the 1582-10-15
-// reform) and the angle constants/wraps — ONE home; the browser's eighteen
-// calendar copies and 27 local D2R constants import these.
+// The civil calendar ↔ JD (Meeus ch. 7 with the 1582-10-15 reform) and the
+// angle constants/wraps — ONE home for every runtime.
 export { GREGORIAN_START, GREGORIAN_START_JD, calendarToJD, jdToCalendar, jdToDecimalYear, dayFractionToHMS, julianCalendarToJD, jdToJulianCalendar } from './time/calendar.cjs';
 export { DEG2RAD, RAD2DEG, ARCSEC_PER_TURN, ARCSEC_PER_RAD, wrap360, wrap180, wrap180Closed, wrap2pi, wrapPi } from './math/angles.cjs';
-// Plan 13 B2: THE deep-time chain assembly — the GIA α channel, the Layer-0
-// bundle, the cited Moon-distance history, the ΔT cycle stack, |s₃|, the
-// LOD/ΔT core, the lunar month chain and the mean*AtAge family, assembled
-// ONCE from the generated constants; the Node twin and the browser destructure it.
+// THE deep-time chain assembly — the GIA α channel, the Layer-0 bundle, the
+// cited Moon-distance history, the ΔT cycle stack, |s₃|, the LOD/ΔT core, the
+// lunar month chain and the mean*AtAge family, assembled ONCE from the
+// generated constants; the Node twin and the browser destructure it.
 export { createDeepTimeChain, MOON_ECC_SENSITIVITY_PERIGEE, MOON_ECC_SENSITIVITY_NODE } from './deltat/deep-time-chain.js';
-// Plan 13 B3: the J2000 mass chain and the Moon's J2000 periods (one home for
-// three copies each) and the unit constants.
+// The J2000 mass chain, the Moon's J2000 periods and the unit constants — ONE home.
 export { computeMassChainJ2000, computeMoonPeriodsJ2000 } from './earth/mass-chain.cjs';
 export { SECONDS_PER_DAY, DAYS_PER_JULIAN_YEAR, JULIAN_CENTURY_DAYS, SECONDS_PER_JULIAN_YEAR } from './constants/units.cjs';
 // D4b: the one-source cardinal structure — the EoC layer (year lengths,
@@ -127,7 +119,6 @@ export { createCardinalStructure } from './cardinal/one-source-structure.cjs';
 // Phase 8.2 — the lunar machinery, extracted layer by layer (survey order:
 // eccentricity channel → month chain → cycle tables → arguments → series →
 // apparent). Same CJS + root re-export convention.
-// (plan 09 step 6: createMoonEccChannel — the H/3 eccentricity law — is deleted; Earth's e of date is the N-body series on every path)
 export { createMoonMonthChain } from './moon/month-chain.cjs';
 export { createChainCycleIntegrator } from './chain-cycles/index.cjs';
 export { createMoonArguments } from './moon/arguments.cjs';
@@ -137,26 +128,26 @@ export { createMoonApparent } from './moon/apparent.cjs';
 // sample) and the offset-circle wheel-angle solver: the scene twins' one placement.
 export { computeEarthFrameOfDate, solveWheelAngleForLongitude, computeSceneWorldFrameJ2000, SCENE_EQUINOX_VIEW_AZIMUTH_DEG } from './earth/frame-of-date.cjs';
 // Phase 8.3 — the planet machinery, extracted by LAW over body records
-// (survey order: geometry → channels → chains). The ψ/K amplitude laws
-// (planets/fibonacci-laws), the record-based orientation forms
-// (planets/orientation) and the ascending-node integrator
-// (planets/asc-node-integrator) are DELETED at plan 07 R5/R6: the planets'
-// elements of date have one home, the N-body chain.
+// (survey order: geometry → channels → chains). The planets' elements of date
+// have one home, the N-body chain.
 export { derivePlanetGeometry, scaffoldOrbitInputs } from './planets/geometry.cjs';
 // (plan 09 step 6: eccentricityFromCycles / computeEccentricityIntegrated — the H/16 law-of-cosines eccentricity — are deleted; no runtime read them)
 export * as planetOrbitChain from './planets/orbit-chain.cjs';
 // P5/K4.6c — the engine-D Keplerian chain (pure evaluator + the embedded
 // governed artifact; the browser flag path consumes exactly these).
 export { computeSecularShape } from './planets/secular-shape.cjs';
-export { buildPlanetChainsFromArtifactData, computePlanetElementsAtYear, computeHeliocentricEclipticFromElements, computePoissonArgRad, computeOsculatingElements, solveKeplerRad, computeApsidalSecularDegPerYr, ANCHOR_EPOCH_YEAR, ANCHOR_EPOCH_JD } from './planets/keplerian-chain.cjs';
+// `computeApsidalTangentDegPerYr` is the chain's ±150-yr central tangent of the perihelion
+// longitude (the panels' "Prec." cell — osculating, NOT the ±1-kyr secular stencil of the
+// "Secular" cell); `computeApsidalSecularDegPerYr` is its former name, kept as a deprecated
+// alias on the API axis.
+export { buildPlanetChainsFromArtifactData, computePlanetElementsAtYear, computeHeliocentricEclipticFromElements, computePoissonArgRad, computeOsculatingElements, solveKeplerRad, computeApsidalSecularDegPerYr, computeApsidalSecularDegPerYr as computeApsidalTangentDegPerYr, ANCHOR_EPOCH_YEAR, ANCHOR_EPOCH_JD } from './planets/keplerian-chain.cjs';
 export { computeEquatorNodeOriginSFrameDeg, convertNodeSFrameToEquatorOriginDeg } from './planets/inv-plane-frame.cjs';
 export { createSecularSeriesOverride } from './planets/secular-series.cjs';
-// Plan 06 Phase 7 — the planets' spin channel (the precession constant from
-// each planet's own torques, the spin integrated on its own ζ plane history).
+// The planets' spin channel (the precession constant from each planet's own
+// torques, the spin integrated on its own ζ plane history).
 export { computePlanetPrecessionConstant, createPlanetSpinChannel, createPlanetSpinChannelFromArtifacts, computeObliquityJ2000Deg } from './planets/spin-channel.cjs';
 export { CHAIN_ARTIFACT, CHAIN_ARTIFACT_HASH } from './planets/chain-artifact.js';
-// Engine-switch Stage B, T5d-(d): the deep-time Earth-z channel (the deep
-// lunar-chain modulation rides it; era consumers stay on the H/3 channel).
+// The deep-time Earth-z channel (the deep lunar-chain modulation rides it).
 export { createDeepEccChannel } from './moon/deep-ecc-channel.cjs';
 export { DEEP_MODES_ARTIFACT, DEEP_MODES_ARTIFACT_HASH } from './moon/deep-modes-artifact.cjs';
 // Stage C-3: the ONE home of the obliquity-hybrid / deep-orbital-history
@@ -166,28 +157,25 @@ export { createDeepOrbitalHistory } from './earth/deep-orbital-history.cjs';
 export { createSiderealYearChannel } from './earth/sidereal-year-channel.cjs';
 // S2: THE ONE of-date year-length family (years + precession beats, SI seconds)
 export { createYearLengths, computeMeanTropicalYearJ2000Days, ONE_FAMILY_WINDOW_YEARS } from './earth/year-lengths.cjs';
-// Plan 06 D6: THE ONE home of the composed lunisolar precession rate ψ̇(t)
-// (spin ω(t) × [solar torque + lunar torque on the recession history]) —
-// leg-1's physical rate; the structural H(t)/13 clock is its named diagnostic.
+// THE ONE home of the composed lunisolar precession rate ψ̇(t) (spin ω(t) ×
+// [solar torque + lunar torque on the recession history]) — falsification
+// leg 1's physical rate.
 export { computeSolarTorqueShare, createComposedPrecession } from './earth/precession-composed.cjs';
-// Plan 12 §8 option (a): the cited mean obliquity of date — the second column read from the
-// Earth–Moon history; the precession RATE of date carries its cos ε̄(t)/cos ε̄(0) on the constant.
+// The cited mean obliquity of date — the second column read from the Earth–Moon
+// history; the precession RATE of date carries its cos ε̄(t)/cos ε̄(0) on the constant.
 export { createMeanObliquityHistory } from './earth/mean-obliquity-history.cjs';
 // (planets/predict.cjs — the planet predictive-precession feature basis — was
 // retired at plan 06 R8 with PREDICT_COEFFS_PHYSICAL.)
 // L10 — the composition front door: one law set, N body records. Thin by
 // design; engines keep their direct call sites (see planets/model.cjs).
 export { createPlanetModel } from './planets/model.cjs';
-// plan 11 step 6 — the planets' presentation names, the last leaf of the
-// deleted model-parameters.json (code, not an input: not injectable, not hashed).
+// the planets' presentation names (code, not an input: not injectable, not hashed).
 export { PLANET_DISPLAY_NAMES } from './planets/display-names.cjs';
 // Phase 8.4 — the climate/ΔT machinery, extracted layer by layer.
 export { createDeltaTCycles } from './deltat/cycles.cjs';
 export { createDeepTimeLod } from './deltat/deep-time.cjs';
-// plan 12 (option A): the Earth–Moon distance history is a CITED PHYSICAL
-// INPUT (Farhat et al. 2022, the AstroGeo22 ephemeris) read as a shape on the
-// model's J2000 anchor; the fitted quartic, the rock-fitted regime spline and
-// the solar-channel budget are deleted.
+// The Earth–Moon distance history is a CITED PHYSICAL INPUT (Farhat et al.
+// 2022, the AstroGeo22 ephemeris) read as a shape on the model's J2000 anchor.
 export { createMoonDistanceHistory } from './deltat/moon-distance-history.cjs';
 export { MOON_DISTANCE_ARTIFACT, MOON_DISTANCE_ARTIFACT_HASH } from './deltat/moon-distance-artifact.cjs';
 export { deltaTEspenakMeeusCanonSeconds } from './deltat/historical.cjs';
@@ -199,9 +187,6 @@ export { createEclipseFinders } from './eclipse/finders.cjs';
 // (reference/published-curves MIGRATED to @essrt/reference at the 4.0.0
 // major — the published model package carries no comparison references;
 // the K2 one-way wall is package-structural.)
-// Phase 9 — S-P8: the fitted sun-longitude harmonic stack (three copies → one).
-// (plan 09 step 5a: createSunLongitudeCorrection — the Step-0 Sun comb's evaluator,
-//  retired from the Sun node at plan 06 R4 — is deleted with the comb and its fitter.)
 
 /**
  * Build a model bound to a set of constants.
@@ -270,15 +255,12 @@ export const createModel = (constants = GENERATED, opts = {}) => {
     constants: ctx,
     hash,
 
-    // Plan 09: the fit-era lattice identities H/13, H/3, H/16
-    // (`computeLatticePeriodsYears`, DEVICE tier) left this surface — the
-    // published periods are `epoch.axialPrecessionYearsAtYear` and the
+    // The published periods are `epoch.axialPrecessionYearsAtYear` and the
     // lunisolar surface's apsidal and perihelion-of-date periods; the
-    // counterfactual gate now reads the obliquity anchor through the assembly.
+    // counterfactual gate reads the obliquity anchor through the assembly.
 
     /**
-     * Earth eccentricity at a year — the Phase-6 promise, fulfilled by the
-     * §7a assembly (law-of-cosines on the integrated H/16 phase).
+     * Earth eccentricity at a year — the one-source series through the §7a assembly.
      * @param {number} year
      * @returns {number}
      */
@@ -294,6 +276,11 @@ export const createModel = (constants = GENERATED, opts = {}) => {
       coefficientsHash: COEFF_HASH,
       counterfactual: hash !== CONSTANTS_HASH,
       preprintDoi: PREPRINT_DOI,
+      // Which evaluator serves Earth's orbit elements away from J2000: the banked
+      // N-body series (every published surface passes it) or the embedded 18-term
+      // mode table (the bare package — exact at J2000, e RMS 3.6e-3 vs La2010a
+      // over 500 kyr where the series reads 2.5e-5). A stored result names it.
+      earthElements: opts.secularSeriesArtifact ? 'secular-series' : 'mode-table',
     }),
 
     // The assembled surfaces (§7a step 1): epoch, earth, lengths, cardinal, moon.

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