@essrt/physics 20.0.1 → 22.0.0

package/src/model.js

@@ -21,11 +21,11 @@ import { deriveEpochParams } from './layer0/derive-params.js';
 import { buildPlanetChainsFromArtifactData, computePlanetElementsAtYear } from './planets/keplerian-chain.cjs';
 import { createSecularSeriesOverride } from './planets/secular-series.cjs';
 import { computeEquatorNodeOriginSFrameDeg, convertNodeSFrameToEquatorOriginDeg } from './planets/inv-plane-frame.cjs';
-import { createPhaseMachinery } from './phase/index.cjs';
-import { createYearLengths, ONE_FAMILY_WINDOW_YEARS } from './earth/year-lengths.cjs';
+import { createYearLengths, computeMeanTropicalYearJ2000Days, ONE_FAMILY_WINDOW_YEARS } from './earth/year-lengths.cjs';
 import { createDeepOrbitalHistory } from './earth/deep-orbital-history.cjs';
 import { CHAIN_ARTIFACT } from './planets/chain-artifact.js';
 import { createPlanetSpinChannelFromArtifacts, computeObliquityJ2000Deg } from './planets/spin-channel.cjs';
+import { PLANET_DISPLAY_NAMES } from './planets/display-names.cjs';
 import { createDeltaTCycles } from './deltat/cycles.cjs';
 import { createDeepTimeLod } from './deltat/deep-time.cjs';
 import { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
@@ -47,9 +47,9 @@ import { driver2PeriodSecondsAtAge } from './planets/orbit-chain.cjs';
  * engine too — packaging them into FITTED_COEFFICIENTS is the remaining
  * §7a-step-1b move; until then this is their single packaged home.
  */
-// (Plan 07 R10: the RA day offset's two cosine amplitudes left here as
-// literals; they ride F.RA_DAY_OFFSET_MS now — [div, sin, cos] on the J2000
-// phase, ONE home for the three runtimes and the website.)
+// (Plan 07 R10 moved the RA day offset's two cosine amplitudes from literals
+// here into F.RA_DAY_OFFSET_MS; plan 09 step 5b deleted that family — it was
+// the equation of time's window term of an instrument, not a motion.)
 
 /**
  * Moon-channel eccentricity sensitivities (perigee/node), the [g/g₀]^s
@@ -86,24 +86,36 @@ const MOON_ECC_SENSITIVITY_NODE = 1.018;
  */
 export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type {any} */ (null), options = {}) {
   // ── Derived constants (constants.js §9 order) ─────────────────────────────
-  const H = C.foundational.holisticyearLength;
-  const meanSolarYearDays = Math.round(C.foundational.inputmeanlengthsolaryearindays * (H / 8)) / (H / 8);
-  const startmodelYear = C.foundational.startmodelYear;
-  const startmodelJD = C.foundational.startmodelJD;
-  const startModelYearWithCorrection = startmodelYear + C.foundational.correctionDays / meanSolarYearDays;
+  // (plan 09 step 7b: `foundational.holisticyearLength` — the unit H — is no
+  // longer read here; the unit function left the physics with it)
+  // Plan 09: 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); the Meeus & Savoie 1992 input
+  // 365.2421897 left the registry, the device's rounding onto 1/(H/8) before it.
+  const meanSolarYearDays = computeMeanTropicalYearJ2000Days(C.yearLengthRef.siderealYear, C.earthOrbital.generalPrecessionJ2000_arcsecPerYr);
+  // Plan 11 step 5: the scene epoch's ONE home — astro-reference
+  // timeReference.sceneEpochJD / sceneEpochYear (moved verbatim from the
+  // deleted foundational block); correctionDays is deleted, so the SI-year
+  // axis below anchors on the epoch itself.
+  const startmodelYear = C.timeReference.sceneEpochYear;
+  const startmodelJD = C.timeReference.sceneEpochJD;
   // Plan 07 R10: the correction combs measure their phase from J2000. The
   // former origin — perihelionalignmentYear − temperatureGraphMostLikely ×
   // H/16 = −302,635, the "balanced year" — was rotated out of every fitted
   // (sin, cos) pair exactly (tools/fit/reorigin-combs-j2000.mjs; measured
   // bit-identical on every surface over ±300 kyr); it is no longer an input.
-  const balancedYear = 2000;
+  // Plan 09 step 5b: the J2000 comb origin's last reader (the RA day offset
+  // comb) left with that device; no comb phase is evaluated here any more.
 
   const meanSiderealYearDays = C.yearLengthRef.siderealYear;
   const meanSiderealYearSeconds = meanSiderealYearDays * 86400;
-  const meanSiderealYearDaysKinematic = (meanSolarYearDays * H) / (H - 13);
-  const meanLengthOfDay = meanSiderealYearSeconds / meanSiderealYearDaysKinematic;
-  const meanAnomalisticYearDays = (meanSolarYearDays * (H / 16)) / (H / 16 - 1);
+  // Plan 09: the J2000 day length ω₀ is the SI day (an input); the device's
+  // H/13 kinematic-sidereal-days construction (86,399.99968 s) is deleted.
+  const meanLengthOfDay = C.yearLengthRef.solarDay;
   const meanTropicalYearJ2000Seconds = meanSolarYearDays * meanLengthOfDay;
+  // Plan 09: 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;
 
   // Plan 07 R5/R6/R9: `earthtiltMean`, `earthInvPlaneInclinationAmplitude`
   // and `eccentricityAmplitude` were read here only to invert the K and ψ
@@ -111,7 +123,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // device. With both laws retired nothing in this module reads them — they
   // remain on C.earth as the K device's J2000 pose inputs (the scene's wheel
   // geometry at the chain anchor epoch) and for the registry's record keys.
-  const solsticeObliquityMean = F.SOLSTICE_OBLIQUITY_MEAN_FITTED;
+  // (Plan 09: the 16-harmonic solstice-obliquity comb — SOLSTICE_OBLIQUITY_
+  // MEAN_FITTED / _HARMONICS, the frozen era record — is deleted; the model's
+  // ONE obliquity of date is the one-source hybrid, `oneSourceM.epsAt`.)
 
   const G_CONSTANT = C.physicalConstants.G_CONSTANT;
   const MASS_RATIO_EARTH_MOON = C.physicalConstants.MASS_RATIO_EARTH_MOON;
@@ -120,9 +134,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const moonDistanceKm = C.moonReference.moonDistance;
   const moonSiderealMonthInput = C.moonReference.moonSiderealMonthInput;
 
-  // 8H-lattice moon sidereal month (constants.js §"Moon derived months")
-  const totalDaysInH = H * meanSolarYearDays;
-  const moonSiderealMonth = totalDaysInH / (Math.round((8 * totalDaysInH) / moonSiderealMonthInput) / 8);
+  // Plan 09: the Moon's sidereal month is the IAU input itself (the device's
+  // eighth-integer-per-8H count read it back 7.8 ms long; deleted).
+  const moonSiderealMonth = moonSiderealMonthInput;
 
   // Mass chain: Moon Kepler → GM_EM → Earth/Moon split → Sun (§9 order)
   const moonOrbitalShift = moonDistanceKm * (1 / (MASS_RATIO_EARTH_MOON + 1)) * (moonSiderealMonth / meanSiderealYearDays);
@@ -160,15 +174,14 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     j2J2000: C.physicalConstants.earthJ2,
   });
 
-  let latticeAlphaPin = false;
   // Exact-argument memo (mirrors src/script.js + tools/lib/deep-time.js —
-  // the round-5 perf campaign): same tMa → bit-identical value; the pin
-  // branch bypasses the memo; bounded by wholesale clear.
+  // the round-5 perf campaign): same tMa → bit-identical value; bounded by
+  // wholesale clear. (Plan 09 step 7a: the lattice-α pin branch left with
+  // the ∫dt/H_era phase table, the one table this model built under it.)
   /** @type {Map<number, number>} */
   const alphaMemo = new Map();
   /** @param {number} tMa @returns {number} */
   const earthMoiFactorAtAge = (tMa) => {
-    if (latticeAlphaPin) return earthMoiFactorJ2000;
     let v = alphaMemo.get(tMa);
     if (v === undefined) {
       v = alphaGia.alphaAt(2000 - tMa * 1e6);
@@ -186,9 +199,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     alpha1PerMa: C.deepTime.alpha1PerMa,
     alpha3PerMa3: C.deepTime.alpha3PerMa3,
     alpha4PerMa4: C.deepTime.alpha4PerMa4,
-    holisticYearJ2000: H,
     meanSiderealYearSeconds,
-    meanSiderealYearDaysKinematic,
+    lodJ2000Seconds: meanLengthOfDay,   // plan 09: ω₀ = the SI day (was the H/13 kinematic day)
     sunMassKg: M_SUN,
     gmEarthAloneKm3S2: GM_EARTH_ALONE,
     gmMoonAloneKm3S2: GM_MOON_ALONE,
@@ -203,6 +215,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     astronomicalUnitKm: currentAUDistance,
     earthOrbitalEccentricityJ2000: C.earthOrbital.earthEccentricityJ2000,
     moonEclipticInclinationJ2000Deg: C.moonReference.moonEclipticInclinationJ2000,
+    // p₀'s period — the tropical year of date's equinox term (plan 09 step 5d)
+    axialPrecessionJ2000Years: certifiedAxialPrecessionJ2000Years(),
   });
 
   // ── Driver 1½: regime-aware recession history + the solar channels ────────
@@ -331,11 +345,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       alpha1PerMa: EPOCH_PARAMS.alpha1PerMa,
       alpha3PerMa3: EPOCH_PARAMS.alpha3PerMa3,
       alpha4PerMa4: EPOCH_PARAMS.alpha4PerMa4,
-      holisticYearJ2000: H,
       lodNowH13Seconds: EPOCH_PARAMS.lodNowH13Seconds,
       meanSiderealYearJ2000Seconds: meanSiderealYearSeconds,
       solarMassLossFracPerYear: EPOCH_PARAMS.solarMassLossFracPerYear,
-      siderealYearDaysKinematicJ2000: meanSiderealYearDaysKinematic,
       precessionSolarShareJ2000: EPOCH_PARAMS.precessionSolarShareJ2000,
     },
     moonDistanceMetresAtAge,
@@ -346,43 +358,18 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     // Plan 06 T2 item: the solar day's ecliptic missing-motion term rides the
     // nodal period 1,296,000/|s₃| (orbital), not the spin unit's H/5.
     nodalPeriodYearsFn: () => 1296000 / s3ArcsecPerYr,
-    siderealYearDaysFourierAt: (year) => evalSiderealYearFourierIAU(year),
     cycleLodSumAt: dtCycleLodCorrectionSum,
     swingLodAt: (year) => dtCycles.swingLodSecondsAt(year),
     swingLodRateAt: (year) => dtCycles.swingLodRateAt(year),
     lEmAtAgeKgm2S: solarBudget.lEmAtAgeKgm2S,
   });
 
-  // ── Integrated ∫1/H(t)dt phase (R2 α-pin honoured while building) ─────────
-  // The phase counter every FROZEN comb reads rides the frozen era clock's
-  // own convention H_era = H₀·LOD/LOD₀ (plan 06 D8: two named counters — the
-  // coefficients were fitted against this counter and ship with it), NOT the
-  // unit H(t) = 13·T_p,composed that the physics publishes.
-  const phaseM = createPhaseMachinery({
-    holisticHAtAgeMa: (tMa) => deepLod.eraClockHAtAge(tMa),
-    tableAnchorYear: startmodelYear,
-    driftRefYear: startModelYearWithCorrection,
-    hJ2000: H,
-    yearMin: -500e6,
-    yearMax: 500e6,
-    stepYears: 10000,
-  });
-  let phaseTableBuilt = false;
-  const phase = () => {
-    if (!phaseTableBuilt) {
-      latticeAlphaPin = true;
-      try { phaseM.ensureTable(); } finally { latticeAlphaPin = false; }
-      phaseTableBuilt = true;
-    }
-    return phaseM;
-  };
-  /** @param {number} yearA @param {number} yearB @param {number} divisorN @returns {number} */
-  const cyclesBetween = (yearA, yearB, divisorN) => {
-    const cyc = phase().cyclesBetween(yearA, yearB, divisorN);
-    return cyc === null ? (divisorN * (yearB - yearA)) / H : cyc;
-  };
-  /** @param {number} anchorYear @param {number} year @param {number} divisorN @returns {number} */
-  const phaseRadians = (anchorYear, year, divisorN) => 2 * Math.PI * cyclesBetween(anchorYear, year, divisorN);
+  // (Plan 09 step 7a: the integrated ∫dt/H_era phase table and its counter
+  // `cyclesBetween` — the frozen era clock's own convention H_era =
+  // H₀·LOD/LOD₀, plan 06 D8's second named counter, which every FROZEN comb
+  // read — are DELETED with the last comb; `epoch.cyclesBetween` left the
+  // surface with them, no reader remained. Step 5b: `phaseRadians` left with
+  // the RA day offset comb.)
 
   /** @param {number} year @returns {number} */
   const yearToTMa = (year) => (2000 - year) / 1e6;
@@ -404,15 +391,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const SUN_OFF = F.EARTH_OSCULATING_MEAN_OFFSET;
   /** The eclipse Sun's ϖ of date (mean elements). @param {number} year @returns {number} */
   const sunPerihelionDegAt = laws.perihelionLongitudeDegAt ?? ((year) => oneSourceM.periOfDateDegAt(year) + SUN_OFF.dPomArcsec / 3600);
+  // Plan 09: the obliquity of date is the one-source hybrid everywhere — the
+  // eclipse tier (besselian deps) read the retired 16-harmonic comb here.
   /** @param {number} year @returns {number} */
-  const obliquityDeg = (year) => {
-    let obliq = solsticeObliquityMean;
-    for (const [div, sinC, cosC] of F.SOLSTICE_OBLIQUITY_HARMONICS) {
-      const ph = phaseRadians(balancedYear, year, div);
-      obliq += sinC * Math.sin(ph) + cosC * Math.cos(ph);
-    }
-    return obliq;
-  };
+  const obliquityDeg = (year) => oneSourceM.epsAt(year);
   // ECCENTRICITY UNIFICATION — ONE law for the whole model (plan
   // IP-eccentricity-unification, decision D1 = form (e)). Earth's orbital
   // eccentricity is the magnitude of a vector sum, e = |v₁ + v₂|: v₁ of
@@ -430,9 +412,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // lattice periods; H/16 is the OF-DATE perihelion period (13 + 3 = 16 —
   // the H/3 rotation seen from the H/13 equinox) and belongs to ϖ_of-date;
   // measured, the H/16 law's present ė (−0.84e-5/cy) is 5× below the
-  // observed −4.20e-5 while this law reads −4.31e-5 (Phase-0 record:
-  // tools/explore/fq7s-h3-law-candidate.mjs; JPL Sun 1.49″, registry 0.80″,
-  // syzygy 3.72″). Consumers (engine-switch decision (ii) restatement,
+  // observed −4.20e-5 while this law reads −4.31e-5 (Phase-0 record: the
+  // H/3-law candidate instrument, deleted at plan 09 step 7e — docs/109 §22;
+  // JPL Sun 1.49″, registry 0.80″, syzygy 3.72″). Consumers (engine-switch decision (ii) restatement,
   // plan 02 §8): the eclipse Sun (equation of centre), the besselian Sun
   // distance and the cardinal-point braid — the CLOCK-side machinery. The
   // LUNAR chain (E-factor, perigee/node modulation/T², argument Δe² and
@@ -472,75 +454,51 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // one-source construction defined with the planets' chain evaluators below.)
 
   // ── Year/day lengths ──────────────────────────────────────────────────────
-  /** @param {number} year @param {number} base @param {Array<[number, number, number]>} harmonics @returns {number} */
-  const evalYearFourier = (year, base, harmonics) => {
-    let result = base;
-    const c1 = phase().cyclesBetween(balancedYear, year, 1);
-    if (c1 === null) return result;
-    for (const [div, sinC, cosC] of harmonics) {
-      const ph = div * c1 * 2 * Math.PI;
-      result += sinC * Math.sin(ph) + cosC * Math.cos(ph);
-    }
-    return result;
-  };
-  /** @param {number} year @returns {number} */
-  const evalSiderealYearFourierIAU = (year) => evalYearFourier(year, meanSiderealYearDays, F.SIDEREAL_YEAR_HARMONICS);
-  /** @param {number} year @returns {number} */
-  const siderealYearDaysBase = (year) => {
-    const tMa = yearToTMa(year);
-    const lod = deepLod.lodSecondsAtAge(tMa);
-    if (lod === null) return meanSiderealYearDays;
-    return deepLod.siderealYearSecondsAtAge(tMa) / lod;
-  };
-  // The comb family's bases are the FROZEN era clock's forms (H_era; plan 06
-  // D8) — the combs were fitted on them. The physical year lengths ride the
-  // unit through yearLengths (family B) and the tidal-chain mean.
-  /** @param {number} year @returns {number} */
-  const tropicalYearDaysBase = (year) => {
-    const days = deepLod.eraClockYearInDaysAtAge(yearToTMa(year));
-    return days === null ? meanSolarYearDays : days;
-  };
-  /** THE J2000 precession anchor (plan 06 S5 — one J2000 precession
-   * reading): the certified of-date year laws at 2000, sid/(sid − trop) =
-   * 25,771.4 yr = 50.2883 ″/yr (IAU 50.2879 to 8×10⁻⁶) — identical to the
-   * engine/browser Direct twins. ONE home: the composed clock's p₀, the
-   * hybrid's self-anchor and the lunisolar surface all read it. The former
-   * H/13 reading (25,793.6) is the fit anchor's, not a period. Memoized;
-   * hoisted so the deep-time factory's lazy dep can name it.
-   * @returns {number} */
+  // Plan 09: the three year-length combs (TROPICAL/SIDEREAL/ANOMALISTIC_
+  // YEAR_HARMONICS on the frozen era clock's bases) and their evaluators
+  // are deleted. The year lengths of date in DAYS are the published SI year
+  // lengths over the kinematic day of date; the kinematic day of date is the
+  // Layer-0 tidal mean LOD, exactly ω₀ (the SI day) at J2000 — the former
+  // "sidereal seconds over comb days" carried the λ̇ ripple of the sidereal
+  // year as a day-length ripple (≤ 0.1 ms in the era, 0.66 ms at ±26 kyr).
+  /** THE J2000 precession anchor p₀ (plan 09): the IAU 2006 general
+   * precession in longitude at J2000 (astro-reference.json
+   * earthOrbital.generalPrecessionJ2000_arcsecPerYr = 50.28796195 ″/yr),
+   * stated as the period 1,296,000/p_A = 25,771.575 Julian years. ONE home:
+   * the composed clock's p₀, the hybrid's self-anchor and the lunisolar
+   * surface all read it. Before plan 09 it was the retired year combs' beat
+   * at 2000 (plan 06 S5: 25,771.395 yr, 8 ppm faster); the H/13 reading
+   * (25,793.6) was the fit anchor's, not a period. The identifier keeps its
+   * name. @returns {number} */
   function certifiedAxialPrecessionJ2000Years() {
-    if (certifiedAxial0Memo === undefined) {
-      const sidLaw2000 = evalYearFourier(2000, siderealYearDaysBase(2000), F.SIDEREAL_YEAR_HARMONICS);
-      const solLaw2000 = evalYearFourier(2000, tropicalYearDaysBase(2000), F.TROPICAL_YEAR_HARMONICS);
-      certifiedAxial0Memo = sidLaw2000 / (sidLaw2000 - solLaw2000);
-    }
-    return certifiedAxial0Memo;
+    return 1296000 / C.earthOrbital.generalPrecessionJ2000_arcsecPerYr;
   }
-  /** @type {number|undefined} */
-  let certifiedAxial0Memo;
-  /** @param {number} year @returns {number} */
-  const anomalisticYearDaysBase = (year) => {
-    const tMa = yearToTMa(year);
-    const Ht = deepLod.eraClockHAtAge(tMa);
-    const tropD = deepLod.eraClockYearInDaysAtAge(tMa);
-    if (Ht === null || tropD === null) return meanAnomalisticYearDays;
-    return (tropD * (Ht / 16)) / (Ht / 16 - 1);
-  };
-  /** @param {number} year @returns {number} */
-  const siderealYearDays = (year) => evalYearFourier(year, siderealYearDaysBase(year), F.SIDEREAL_YEAR_HARMONICS);
-  /** @param {number} year @returns {number} */
-  const anomalisticYearDays = (year) => evalYearFourier(year, anomalisticYearDaysBase(year), F.ANOMALISTIC_YEAR_HARMONICS);
-  /** Kinematic LOD (Layer 0). @param {number} year @returns {number} */
-  const dayLengthSeconds = (year) => deepLod.siderealYearSecondsAtAge(yearToTMa(year)) / siderealYearDays(year);
-  /** @param {number} year @returns {number} */
-  const raDayOffsetMs = (year) => {
-    let ms = F.RA_DAY_OFFSET_MS.mean;
-    for (const [div, sinC, cosC] of F.RA_DAY_OFFSET_MS.terms) {
-      const ph = phaseRadians(balancedYear, year, div);
-      ms += sinC * Math.sin(ph) + cosC * Math.cos(ph);
-    }
-    return ms;
+  /** Kinematic day of date (Layer 0 tidal mean LOD; ω₀ at J2000). Past the
+   *  tidal-lock asymptote the chain is null — the J2000 day stands in, as
+   *  the retired comb base did. @param {number} year @returns {number} */
+  const dayLengthSeconds = (year) => deepLod.lodSecondsAtAge(yearToTMa(year)) ?? meanLengthOfDay;
+  /** Sidereal year of date in days of the epoch — the published SI sidereal
+   *  year (the λ̇ channel inside the one-family window, the mass-loss law
+   *  beyond) over the kinematic day of date. @param {number} year @returns {number} */
+  const siderealYearDays = (year) => publishedSiderealYearSecondsAtYear(year) / dayLengthSeconds(year);
+  /** Anomalistic year of date in days of the epoch — the published SI
+   *  anomalistic year (one-family inside its window; NaN beyond, where the
+   *  movement's apsidal line is not resolved). @param {number} year @returns {number} */
+  const anomalisticYearDays = (year) => {
+    const s = Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS ? yearLengthsM.anomalisticYearSecondsAtYear(year) : NaN;
+    return s / dayLengthSeconds(year);
   };
+  // (Plan 09 step 5b: raDayOffsetMs — the fitted RA_DAY_OFFSET_MS comb, a −14.194 ms
+  // mean + lines on H/16 and H/8 — and measuredSolarDaySeconds = dayLength + that
+  // offset are deleted. The quantity was the equation of time's window term of the
+  // Framework-Verification instrument: 365 solar noons counted from the June
+  // solstice end 0.2422 d short of the tropical year, so the mean noon-to-noon
+  // interval differs from the mean solar day by −(0.2422/365)·dEoT/dt at the
+  // solstice — the e·cos(90° − ϖ) term on the perihelion-of-date cycle (the comb's
+  // "H/16" line, 5.6 ms vs 5.2 first-order) and the tan²(ε/2) term on the obliquity
+  // cycle (the "H/8" line, 1.7 vs 1.4). A property of the window, not of the sky:
+  // the physical day of date is dayLengthSeconds; the equation of time is the
+  // certified Sun's. docs/11 § "The retired RA day offset".)
 
   // ── Cardinal points (the fitted model retired, R1)──────────────────────────────────────────────────
   // Plan 06 R1: the fitted cardinal-point model (CARDINAL_POINT_* — the §10
@@ -576,21 +534,21 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // per-tier sampler.
   const oneSourceM = (() => {
     const AEarth = /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements.earth;
-    // The ψ̇ anchor: the CERTIFIED of-date laws at 2000 — identical to the
-    // engine/browser (computeSiderealYearDaysDirect / computeSolarYearDays
-    // Direct twins → 25,771.4). The FOUNDATIONAL mean pair used before
-    // (meanSiderealYearDays/meanSolarYearDays → 25,796) anchored this
-    // movement's realized precession 25 yr off the certified value — the
-    // hidden split behind the API's 365.242204 tropical mean (found in the
-    // owner's one-implementation drive).
+    // The ψ̇ anchor: the IAU 2006 general precession p_A (plan 09; 25,771.575
+    // yr — the ONE home certifiedAxialPrecessionJ2000Years, twins in
+    // tools-lib and the browser). History: plan 06 S5 anchored it on the
+    // certified year combs' beat at 2000 (25,771.4); before that the device's
+    // mean pair (meanSiderealYearDays/meanSolarYearDays → 25,796) anchored
+    // this movement's realized precession 25 yr off — the hidden split behind
+    // the API's 365.242204 tropical mean (found in the owner's
+    // one-implementation drive).
     const axial0 = certifiedAxialPrecessionJ2000Years();   // S5: the ONE home
     // D6 → Phase 3 (plan 06): the deep-time ψ̇(t) the hybrid precesses on is
-    // the COMPOSED lunisolar rate, and since Phase 3 the unit H(t) IS
-    // 13 × that period (deltat/deep-time.cjs hAtAge), so the injection is
-    // the plain period₀·H(t)/H₀ again — on the unit, not on the frozen
-    // era clock's H_era (which misses the lunar 1/a³ growth: 70.9 vs
-    // Lantink 2022's 108.6 ± 8.5 ″/yr at 2.46 Ga; the unit reads 104.5).
-    const H0 = /** @type {number} */ (deepLod.hAtAge(0));
+    // the COMPOSED lunisolar rate — its period of date T_p(t) read directly
+    // (plan 09 step 5c; it was period₀·H(t)/H₀ on the unit, the same number
+    // to 2e-16 since the unit scales with T_p). Not the frozen era clock's
+    // H_era (which misses the lunar 1/a³ growth: 70.9 vs Lantink 2022's
+    // 108.6 ± 8.5 ″/yr at 2.46 Ga; the composed rate reads 104.5).
     const seriesArt = /** @type {any} */ (secularSeriesArtifact);
     const sb = seriesArt && seriesArt.bodies && seriesArt.bodies.earth;
     const hist = createDeepOrbitalHistory({
@@ -612,10 +570,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // rendering-device residual imported as the initial condition of the
       // physics (found when the package began publishing the hybrid).
       obliquityJ2000Deg: C.earthOrbital.obliquityJ2000_deg,
-      axialPrecessionYearsAtYearFn: (yr) => {
-        const h = deepLod.hAtAge((startmodelYear - yr) / 1e6);
-        return axial0 * (h === null ? 1 : h / H0);
-      },
+      axialPrecessionYearsAtYearFn: (yr) => deepLod.lunisolarPrecessionPeriodYearsAtAge((startmodelYear - yr) / 1e6) ?? axial0,
       // THE PRECESSION OF DATE (plan 06 §9 item 10): 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,
@@ -686,8 +641,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
    *  ≡ the one-family year. Plan 06 R1: formerly the fitted cardinal model's
    *  4-mean. @param {number} year @returns {number} */
   const tropicalYearDays = (year) => oneFamilyTropicalYearSeconds(year) / dayLengthSeconds(year);
-  /** @param {number} year @returns {number} */
-  const tropicalYearDirectDays = (year) => evalYearFourier(year, tropicalYearDaysBase(year), F.TROPICAL_YEAR_HARMONICS);
 
   /** Layer-4 solar day of date in SI seconds — LOD_real, the shipped
    *  observable (the tweakpane Solar Day row, the registry's lodRealPhysical,
@@ -727,8 +680,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     const raProjection = Math.cos((oneSourceM.epsAt(year) * Math.PI) / 180);
     return (sidDay / Tp / (syD + 1)) * raProjection + sidDay;
   };
-  /** @param {number} year @returns {number} */
-  const measuredSolarDaySeconds = (year) => dayLengthSeconds(year) + raDayOffsetMs(year) / 1000;
 
   // ── Moon at epoch ─────────────────────────────────────────────────────────
   /** Solar-Δa-corrected Kepler month. @param {number} year @returns {number} */
@@ -793,7 +744,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   /** @type {Record<string, Record<string, any>>} */
   const PUBLISHED_PLANET_RECORDS = {};    // what model.planets.record() serves (R8)
   for (const k of PLANET_KEYS) {
-    const mp = C.planets[k];
     const ar = C.planetOrbitalElements[k];
     // Plan 06 Phase 7 commit 2: the K device's integer axial and obliquity
     // fractions are retired; the obliquity is the DERIVED J2000 obliquity of
@@ -834,10 +784,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     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: mp.name,
+      name: PLANET_DISPLAY_NAMES[k],   // presentation — planets/display-names, the deleted JSON's last leaf (plan 11 step 6)
       solarYearInput: ar.solarYearInput,
       longitudePerihelion: ar.longitudePerihelion,
-      ascendingNodeInvPlane: mp.ascendingNodeInvPlane,
+      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,
@@ -979,9 +929,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // put the eclipse umbra twin 8 km off (§12h; ≤1 m once unified).
   const siTropicalYearDays = meanTropicalYearJ2000Seconds / 86400;
   /** Model year (SI axis) at a JD(TT). @param {number} jd @returns {number} */
-  const yearFromJD = (jd) => startModelYearWithCorrection + (jd - startmodelJD) / siTropicalYearDays;
+  const yearFromJD = (jd) => startmodelYear + (jd - startmodelJD) / siTropicalYearDays;
   /** JD(TT) at a model year (SI axis). @param {number} year @returns {number} */
-  const jdFromYear = (year) => startmodelJD + (year - startModelYearWithCorrection) * siTropicalYearDays;
+  const jdFromYear = (year) => startmodelJD + (year - startmodelYear) * siTropicalYearDays;
 
   // ── Lunar theory: the shared-chain assembly (§7a slice-2b) ────────────────
   // Wiring mirrors the engine call sites exactly — tools/lib/deep-time.js
@@ -993,25 +943,26 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const j2000JD = 2451545.0;
   const julianCenturyDays = 36525;
 
-  // J2000 Moon precession anchors (Option C+ — of-date observational anchors
-  // in the legacy-'ICRF'-named inputs; the E values are star-referenced ∓13)
-  const nApsidalIJ2000 = Math.round((8 * totalDaysInH) / C.moonReference.moonApsidalPrecessionDaysInputICRF) / 8;
-  const nNodalIJ2000 = Math.round((8 * totalDaysInH) / C.moonReference.moonNodalPrecessionDaysInputICRF) / 8;
-  const nApsidalEJ2000 = nApsidalIJ2000 - 13;
-  const nNodalEJ2000 = nNodalIJ2000 + 13;
-  const moonApsidalJ2000Seconds = (totalDaysInH / nApsidalEJ2000) * meanLengthOfDay;
-  const moonNodalJ2000Seconds = (totalDaysInH / nNodalEJ2000) * meanLengthOfDay;
-  // the OF-DATE anchors (the H² counter's J2000 period — the Meeus/IERS
-  // observables 3231.49 d / 6798.38 d)
-  const moonApsidalOfDateJ2000Seconds = (totalDaysInH / nApsidalIJ2000) * meanLengthOfDay;
-  const moonNodalOfDateJ2000Seconds = (totalDaysInH / nNodalIJ2000) * meanLengthOfDay;
-  const moonSiderealMonthJ2000Seconds = moonSiderealMonth * meanLengthOfDay;
+  // J2000 Moon precession anchors (plan 09: 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.
+  // The retired era device counted these as eighth-integers per 8H and read
+  // the periods back as totalDaysInH/N (the ∓13 was H/13 cycles per H).
+  const moonApsidalOfDateJ2000Seconds = C.moonReference.moonApsidalPrecessionDaysInputICRF * 86400;
+  const moonNodalOfDateJ2000Seconds = C.moonReference.moonNodalPrecessionDaysInputICRF * 86400;
+  const moonApsidalJ2000Seconds = 1 / (1 / moonApsidalOfDateJ2000Seconds - 1 / (axialPrecessionJ2000Days * 86400));
+  const moonNodalJ2000Seconds = 1 / (1 / moonNodalOfDateJ2000Seconds + 1 / (axialPrecessionJ2000Days * 86400));
+  const moonSiderealMonthJ2000Seconds = moonSiderealMonth * 86400;
+  // (Plan 09 step 5c: the per-H of-date cycle counts and the month chain's H²
+  // scaling of the of-date periods are deleted; the of-date perigee/node are
+  // the chain's count compositions.)
 
-  // 8H-lattice derived months (constants.js §Moon derived months)
-  const nSid = Math.round((8 * totalDaysInH) / moonSiderealMonthInput) / 8;
-  const moonTropicalMonthDays = totalDaysInH / (nSid + 13);
-  const moonAnomalisticMonthDays = totalDaysInH / (nSid - nApsidalEJ2000);
-  const moonSynodicMonthDays = totalDaysInH / (nSid + 13 - H);
+  // 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);
 
   // moonEcc — the model's ONE eccentricity law — is created above (with
   // eccentricityAt); the Moon channel's E-factor e(t)/e(J2000) and its
@@ -1028,14 +979,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       gmEarthMoonM3PerS2: EPOCH_PARAMS.gmEarthMoonM3S2,
       massRatioEarthMoon: MASS_RATIO_EARTH_MOON,
       moonSiderealMonthInputDays: moonSiderealMonthInput,
-      holisticYearJ2000: H,
       meanSiderealYearJ2000Seconds: meanSiderealYearSeconds,
-      nApsidalOfDateJ2000: nApsidalIJ2000,
-      nNodalOfDateJ2000: nNodalIJ2000,
       moonApsidalJ2000Seconds,
       moonNodalJ2000Seconds,
-      moonApsidalOfDateJ2000Seconds,
-      moonNodalOfDateJ2000Seconds,
       moonSiderealMonthJ2000Seconds,
       sPerigee: MOON_ECC_SENSITIVITY_PERIGEE,
       sNode: MOON_ECC_SENSITIVITY_NODE,
@@ -1043,7 +989,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     fns: {
       meanLodSecondsAtAge: /** @param {number} tMa */ (tMa) => deepLod.lodSecondsAtAge(tMa),
       meanSiderealYearSecondsAtAge: /** @param {number} tMa */ (tMa) => deepLod.siderealYearSecondsAtAge(tMa),
-      meanHAtAge: /** @param {number} tMa */ (tMa) => deepLod.hAtAge(tMa),
+      // plan 09 step 5c: the tropical month's equinox turn is one per T_p(t)
+      precessionPeriodYearsAtAge: /** @param {number} tMa */ (tMa) => deepLod.lunisolarPrecessionPeriodYearsAtAge(tMa),
       // Decision (ii) (owner-approved MODEL CHANGE, plan 02 §8): the whole
       // lunar chain — this modulation, the integrated cycle counts it
       // drives, the arguments' eccAt/channelIntegral and the E-factor —
@@ -1061,8 +1008,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // Float64Array tables key correctly and persist.
   const chainCycles = createChainCycleIntegrator({
     ageAnchorYear: startmodelYear,
-    tropicalYearSecondsAtAge: /** @param {number} tMa */ (tMa) => deepLod.tropicalYearSecondsAtAge(tMa),
-    tropicalYearJ2000Seconds: meanTropicalYearJ2000Seconds,
+    tropicalYearJ2000Seconds: meanTropicalYearJ2000Seconds,   // the SI tick (plan 09 step 7c′)
     isDeepTime: () => true,
   });
   /** @param {number} tMa @returns {number|null} */
@@ -1071,6 +1017,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   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);
@@ -1082,6 +1030,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   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);
@@ -1102,12 +1052,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     constants: {
       j2000JD,
       julianCenturyDays,
-      holisticYearJ2000: H,
-      balancedYearJ2000: balancedYear,
-      meanSolarYearDays,
-      meanAnomalisticYearDays,
-      tropicalYearHarmonics: F.TROPICAL_YEAR_HARMONICS,
-      anomalisticYearHarmonics: F.ANOMALISTIC_YEAR_HARMONICS,
       eccentricityJ2000: C.earthOrbital.earthEccentricityJ2000,
       eccentricityDotJ2000: C.earthOrbital.earthEccentricityDotJ2000,
       eccentricityDotDotJ2000: C.earthOrbital.earthEccentricityDotDotJ2000,
@@ -1123,22 +1067,31 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // PUBLISHED ε (the one-source hybrid), not the K snapshot comb — one ε
       // everywhere. Twins: script.js (_sceneEpsTargetDeg), scene-graph.js.
       computeObliquityEarth: /** @param {number} year @returns {number} */ (year) => oneSourceM.epsAt(year),
+      // Plan 09: the arguments' Sun IS the one certified Sun — the mean
+      // longitude that integrates the one-family tropical year (the eclipse
+      // finder's Sun) and the series' mean perihelion of date (unwrapped),
+      // both on the TT Julian-year axis. The former "model timeline" Sun
+      // (360° per mean solar year plus the integral of the retired year
+      // combs) sat 0.2° behind the IAU mean Sun at −2000 — the combs could
+      // not carry the tropical year's secular drift. Twins: scene-graph.js,
+      // script.js.
+      sunMeanLonDegAtJdTT: /** @param {number} jdTT @returns {number} */ (jdTT) => 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,
-      cyclesBetween,
       isDeepTime: () => true,
       isFrameworkNative: () => true,
       // (d′) of-date rate completion: the DYNAMICAL axial precession (the
       // tweakpane day-form identity — real at J2000, epoch-valid) and the
       // KINEMATIC pair's beat the chains embed. MATCHED TRIPLE with the
       // tools-lib and browser wirings.
-      pDynDegPerYearAt: /** @param {number} year */ (year) => {
-        const sid = siderealYearDays(year);
-        const sol = tropicalYearDirectDays(year);
-        return 360 * (sid - sol) / sid;
-      },
+      // Plan 09: the dynamical rate of date is the published precession
+      // period's (the one-family beat inside its window, the composed clock
+      // beyond) — the retired year combs' day-form beat read 60 % of the
+      // secular drift. Degrees per Julian year.
+      pDynDegPerYearAt: /** @param {number} year */ (year) => 360 / 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
@@ -1172,10 +1125,12 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   // 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} */
-  const fwEFactor = (dDays) => deepEcc.eFactorAt(dDays / C.foundational.inputmeanlengthsolaryearindays);
+  // (plan 09 step 7c: on the channel's Julian-year axis — the N-body series'
+  // time; the device's rounded tropical-year input read the axis 2e-5 short)
+  const fwEFactor = (dDays) => deepEcc.eFactorAt(dDays / 365.25);
 
-  // D2 derived additional-argument rates (deg/cy, J2000 8H-lattice months;
-  // record: tools/explore/derive-a1a2a3.js)
+  // D2 derived additional-argument rates (deg/cy, from the J2000 month inputs;
+  // the derivation record derive-a1a2a3.js was deleted at plan 09 step 7e — docs/109 §22)
   const fwA2RateDegPerCy = 2 * ((360 * 36525) / moonTropicalMonthDays)
     - (360 * 36525) / moonAnomalisticMonthDays
     - 2 * ((360 * 36525) / C.planetOrbitalElements.jupiter.solarYearInput);
@@ -1191,7 +1146,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       moonDistanceJ2000Km: C.moonReference.moonDistance,
       j2000JD,
       julianCenturyDays,
-      moonMeeusLpCorrectionDeg: C.moon.moonMeeusLpCorrection,
       fwA2RateDegPerCy,
       fwA3RateDegPerCy,
     },
@@ -1203,14 +1157,15 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // 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 (startModelYearWithCorrection, the
-      // browser's J2000_CALENDAR_YEAR — NOT this model's 2000.0 yearToTMa
-      // convention: the 0.4977-yr difference is 4.95e-11 of distance and
-      // failed the bit-exact parity gate). Falls back to the J2000
-      // constant without a jd (legacy call shape) or past the domain.
+      // 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((startModelYearWithCorrection - yearFromJD(jdTT)) / 1e6);
+        const d = moonDistanceMetresAtAge((startmodelYear - yearFromJD(jdTT)) / 1e6);
         return d === null ? moonDistanceKm : d / 1000;
       },
       getEccentricityBase: () => C.moonReference.moonOrbitalEccentricityBase,
@@ -1218,7 +1173,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       jdToSIyear: yearFromJD,
       tropicalOrbitsBetween: mcTropical,
       apsidalOfDateCyclesBetween: mcApsidalOfDate,
-      cyclesBetween,
+      siderealOrbitsBetween: mcSidereal,
       jupiterOrbitsBetween: mcJupiter,
       isDeepTime: () => true,
       isFrameworkNative: () => true,
@@ -1330,6 +1285,14 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     };
     return /** @param {number} year @returns {number} */ (year) => sunL0Deg + 360 * cyclesTo(year);
   })();
+  // Plan 09: the lunar arguments' Sun perihelion of date is the eclipse
+  // Sun's mean perihelion (`sunPerihelionDegAt`) read DIRECTLY, wrapped.
+  // Every consumer wraps the argument it enters (M = Lsun − ϖ − 180) or
+  // differences it over ±25 days (the rate anchors, wrapped to ±180°), so
+  // no continuous angle is needed. MEASURED: a 100-yr unwrapping ladder
+  // (two series reads per rung, 53,400 rungs at −5.34 Myr) cost the cold
+  // deep jump 1,062 s — 343× the in-table jump against the perf gate's 8× —
+  // for a value the consumers reduced mod 360 anyway.
 
   // Eclipse finders — wired like the engine probe (tools/verify/
   // eclipse-audit.js). The finder axis is JD(UT): the series wrapper applies
@@ -1453,6 +1416,13 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     if (Math.abs(year - 2000) <= ONE_FAMILY_WINDOW_YEARS) return yearLengthsM.tropicalYearSecondsAtYear(year);
     return deepLod.tropicalYearSecondsAtAge(yearToTMa(year));
   };
+  /** 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));
+  };
   // ── Cardinal instants (plan 06 R1) ─────────────────────────────────────
   /** The completed certified Sun (finder Sun − the derived planetary
    *  completion) at a UT model-JD — the same longitude the scene renders
@@ -1546,9 +1516,20 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       jdFromYear,
       siTropicalYearDays,
     }),
+    // Plan 09: the ONE certified Sun's mean elements of date — the lunar
+    // arguments of every runtime build their Sun from these two (the Node
+    // scene twin and the browser read them here; the "model timeline" Sun on
+    // the retired year combs is gone).
+    sun: Object.freeze({
+      /** Mean longitude of date, degrees, unwrapped — L0 + 360·∫dt/T_trop (the one-family tropical year). @param {number} year @returns {number} */
+      meanLongitudeDegAt: sunMeanLongitudeDegAt,
+      /** The Sun's mean perihelion longitude of date (Earth's ϖ, mean elements), degrees, wrapped to [0, 360). @param {number} year @returns {number} */
+      perihelionLongitudeDegAt: sunPerihelionDegAt,
+    }),
     epoch: Object.freeze({
       yearToTMa,
-      hAtYear: /** @param {number} year @returns {number|null} */ (year) => deepLod.hAtAge(yearToTMa(year)),
+      // (plan 09 step 7b: `hAtYear` — the unit H(t) on a published surface, the
+      // API's `epoch.h` — is deleted; the deep-time clock is axialPrecessionYearsAtYear)
       // The Layer-2 mean day of date — the tidal + GIA base the deep-time law
       // gives at any age (86,399.9997 s at J2000): the day the paleo anchors
       // and the ΔT integrand ride. NOT the observable solar day of date —
@@ -1564,18 +1545,17 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // (identical at J2000 where the ratio ≡ 1 by construction)
       siderealYearSecondsAtYear: /** @param {number} year @returns {number} */ (year) => yearLengthsM.siderealYearSecondsAtYear(year),
       deltaTSecondsAtYear: deltaTSeconds,
-      cyclesBetween,
       // Plan 06 Phase 3 S2 — THE published of-date precession period is the
       // one-family route (B): the hybrid's own equinox regression against
       // the λ̇-corrected sidereal year (~25,771 yr at J2000 ≈ IAU), inside
       // the banked tiers (|Δyear| ≤ ONE_FAMILY_WINDOW_YEARS); beyond, the
       // composed lunisolar period on the same J2000 anchor (S5; the
-      // of-date wobble is unresolved there). The comb family's beat
-      // sid/(sid − tropicalYearDirectDays) — the frozen era clock's
-      // kinematic-day device — is no longer published here; it still
-      // anchors the lunar chain's (d′) rate completion (pDynDegPerYearAt,
-      // a MATCHED TRIPLE with the eclipse gates: M0(a) measured a 3–15 min
-      // lunar-timing shift if it moved).
+      // of-date wobble is unresolved there). The comb family's beat (the
+      // frozen era clock's kinematic-day device) is deleted at plan 09; the
+      // lunar chain's (d′) rate completion (pDynDegPerYearAt) rides THIS
+      // published period — a MATCHED TRIPLE with the eclipse gates (M0(a)
+      // measured a 3–15 min lunar-timing shift when it moved; the records
+      // were re-baselined on the plan 09 move).
       axialPrecessionYearsAtYear: publishedAxialPrecessionYearsAtYear,
       // The same publication rule for the mean tropical year of date (SI s):
       // one-family inside the window, the tidal-chain mean beyond.
@@ -1686,12 +1666,10 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // Plan 06 Phase 3 S3b: THE published obliquity is the hybrid — one
       // torque law integrated on the dynamical orbit plane of the N-body
       // chain, zero fitted constants (≡ La2004 to ≤ 4″ over ±50 kyr). The
-      // fitted 16-harmonic K comb, a device fitted to the scene's own
-      // wheel geometry (0.005″ to it, 1.27° off La2004 at −20 kyr), keeps
-      // its name below as the frozen era clock's device: it anchors the
-      // hybrid at J2000, the kinematic-day stack and the lunar arguments.
+      // fitted 16-harmonic K comb that sat beside it as `obliquityCombDeg`
+      // (a device fitted to the scene's own wheel geometry, 1.27° off
+      // La2004 at −20 kyr) is deleted with the frozen era device (plan 09).
       obliquityDeg: /** @param {number} year @returns {number} */ (year) => oneSourceM.epsAt(year),
-      obliquityCombDeg: obliquityDeg,
       eccentricity: eccentricityAt,
       inclinationDeg,
       ascendingNodeDeg,
@@ -1703,15 +1681,12 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     // route) and the seamed `epoch.*AtYear` surfaces above.
     lengths: Object.freeze({
       tropicalYearDays,
-      tropicalYearDirectDays,
       siderealYearDays,
       anomalisticYearDays,
       dayLengthSeconds,
       lodRealSeconds,
       siderealDaySeconds,
       stellarDaySeconds,
-      measuredSolarDaySeconds,
-      raDayOffsetMs,
     }),
     // Plan 06 R1: the instants are the crossings of the ONE Sun (the
     // certified completed Sun the scene renders), UT model-JD; the RA at a