@essrt/physics 20.0.1 → 21.0.0

package/src/cardinal/index.cjs

@@ -1,324 +0,0 @@
-/**
- * Cardinal-point model — THE shared implementation (Phase 7.2).
- *
- * The §10 derived form and everything on it, extracted verbatim from
- * tools/lib/orbital-engine.js (which the browser mirrored function-for-
- * function — this file replaces both copies):
- *
- *   JD_X(Y)  = anchor_X + ΣT_trop(Y) + δ_X(Y) − δ_X(2000)
- *   ΣT_trop  = lincoef·(Y−2000) + driftTerm(Y) + Ih(Y)
- *   δ_X      = sinusoids + equation-of-centre orders (e(t)ⁿ·sin(nM), e(t)
- *              the LAW OF COSINES) + §10g quadrature-locked joint sidebands
- *   T_X(Y)   = the EXACT term-by-term derivative of JD_X
- *
- * LOAD-BEARING, do not "improve":
- *  - lincoef/h0/h1 come from the fit and are used VERBATIM — recomputing
- *    lincoef from the 1-year anchor injects a −12,276 s ramp; holding H
- *    constant inside Ih costs up to 5.2 s (§10c/§10e-quinquies).
- *  - The drift term is Simpson on 2000-yr NODE SPACING (not a fixed node
- *    count: that was exact in-window and −33,758 s at −380 Ma) plus the
- *    Euler–Maclaurin endpoint term (omitting it costs 6–13 s).
- *  - The equation-of-centre terms are {order,sin,cos}, NOT sinusoids — read
- *    as H/16+H/32 harmonics they are wrong by the whole ~1.78 d braid.
- *  - §10g joint sidebands are SHARED across the four points with phase
- *    order·λ_X − 2π·div·c — COUNTER-rotating. The minus sign is load-bearing:
- *    the co-rotating sense captures NOTHING (measured — the sign experiment,
- *    doc 99 "the braid law").
- *  - The year-length derivative keeps ONE deliberate divergence from the
- *    exact derivative: its drift part uses the real-LOD convention
- *    (`meanYearRealLodDays`) — the tweakpane's epoch-local days ("~400 days
- *    at the Devonian") — where the JD form integrates the SI form. Equal at
- *    J2000 up to the known 118 ms fit-basis gap.
- *
- * The `cyclesBetween` the caller injects is the ENGINE'S OWN function, so
- * each engine's deep-time/snapshot toggle semantics are preserved exactly;
- * under deep time both engines now route it through @essrt/physics/phase.
- */
-
-'use strict';
-
-/** @type {Record<string, number>} */
-const JOINT_LAMBDA = { SS: 0, AE: Math.PI / 2, WS: Math.PI, VE: 1.5 * Math.PI };
-
-const DRIFT_NODE_SPACING_YEARS = 2000;
-const DRIFT_SIMPSON_N_MIN = 64;
-
-/** @typedef {{ lincoef: number, h0: number, h1: number }} DerivedCoefs */
-/** @typedef {{ order: number, sin: number, cos: number }} EccTerm */
-/** @typedef {{ order: number, div: number, sin: number, cos: number }} JointTerm */
-
-/**
- * @param {{
- *   isDeepTime: () => boolean,
- *   constants: {
- *     anchors: Record<string, number>,
- *     harmonics: Record<string, Array<[number, number, number]>>,
- *     eccTerms: (Record<string, EccTerm[]> | null),
- *     jointTerms: ({ terms: JointTerm[] } | null),
- *     derived: (DerivedCoefs | null),
- *     tropicalHarmonics: Array<[number, number, number]>,
- *     balancedYear: number,
- *     meanSolarYearDays: number,
- *     hJ2000: number,
- *     tiltMeanDeg: number,
- *     raAngleDeg: number,
- *     inclAmplitudeDeg: number,
- *   },
- *   fns: {
- *     cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null),
- *     analyticTropicalDays: (year: number) => (number | null),
- *     meanHAtAgeMa: (tMa: number) => (number | null),
- *     meanYearRealLodDays: (tMa: number) => (number | null),
- *     eccentricityAt: (year: number) => number,
- *     eccentricityRateAt: (year: number) => number,
- *   },
- * }} deps
- */
-function createCardinalModel({ isDeepTime, constants, fns }) {
-  const {
-    anchors,               // { SS, WS, VE, AE } — J2000 event JDs
-    harmonics,             // { type: [[div, sin, cos], …] } — δ sinusoids
-    eccTerms,              // { type: [{order, sin, cos}, …] } | null
-    jointTerms,            // { terms: [{order, div, sin, cos}, …] } | null
-    derived,               // { lincoef, h0, h1 } — fit-calibrated, VERBATIM
-    tropicalHarmonics,     // TROPICAL_YEAR_HARMONICS [[div, sin, cos], …]
-    balancedYear,
-    meanSolarYearDays,
-    hJ2000,
-    tiltMeanDeg,           // for RA
-    raAngleDeg,
-    inclAmplitudeDeg,
-  } = constants;
-  const {
-    cyclesBetween,         // (yearA, yearB, divisorN) => cycles | null
-    analyticTropicalDays,  // (year) => SI days | null — the drift integrand base
-    meanHAtAgeMa,          // (t_Ma) => H | null — the derivative's dc/dY
-    meanYearRealLodDays,   // (t_Ma) => days | null — real-LOD drift convention
-    eccentricityAt,        // (year) => e(t) — the model's ONE eccentricity law (H/3 vector sum, plan IP-eccentricity-unification)
-    eccentricityRateAt,    // (year) => de/dyear of the same law — the braid's EoC derivative rides it
-  } = fns;
-
-  /** @param {number} year */
-  const cycleOf = (year) => {
-    const c = cyclesBetween(balancedYear, year, 1);
-    return c === null ? 0 : c;
-  };
-
-  /** @param {number} year */
-  const driftIntegrand = (year) => {
-    const a = analyticTropicalDays(year);
-    return a === null ? 0 : (a - meanSolarYearDays);
-  };
-
-  /** @param {number} year */
-  function driftTerm(year) {
-    const span = year - 2000;
-    if (span === 0) return 0;
-    let n = Math.ceil(Math.abs(span) / DRIFT_NODE_SPACING_YEARS);
-    if (n % 2) n++;
-    if (n < DRIFT_SIMPSON_N_MIN) n = DRIFT_SIMPSON_N_MIN;
-    const h = span / n;
-    const f0 = driftIntegrand(2000), fN = driftIntegrand(year);
-    let acc = f0 + fN;
-    for (let i = 1; i < n; i++) acc += driftIntegrand(2000 + i * h) * ((i % 2) ? 4 : 2);
-    return acc * h / 3 - (fN - f0) / 2;
-  }
-
-  /** Step 6d's self-corrected tropical harmonic series, as a length deviation.
-   *  @param {number} year */
-  function tropHarmonicsAt(year) {
-    const c = cycleOf(year), c0 = cycleOf(2000);
-    let s = 0;
-    for (const [div, sinC, cosC] of tropicalHarmonics) {
-      const th = 2 * Math.PI * div * c, th0 = 2 * Math.PI * div * c0;
-      s += sinC * (Math.sin(th) - Math.sin(th0)) + cosC * (Math.cos(th) - Math.cos(th0));
-    }
-    return s;
-  }
-
-  // Ih(Y) = Σ_{2000→Y} of the tropical harmonics, closed form. H stays INSIDE
-  // the integral (h0 + h1·c) — it moves 27.5 yr across the window and
-  // multiplies the amplitude. Deep-time only, so `derived` is present here.
-  /** @param {number} year */
-  function integratedTropHarmonics(year) {
-    const D = /** @type {DerivedCoefs} */ (derived);
-    const cY = cycleOf(year), c0 = cycleOf(2000);
-    let tot = 0, k0 = 0;
-    for (const [div, sinC, cosC] of tropicalHarmonics) {
-      const k = 2 * Math.PI * div;
-      /** @param {number} c */
-      const F = (c) => {
-        const sn = Math.sin(k * c), cs = Math.cos(k * c), Hc = D.h0 + D.h1 * c;
-        return [-Hc * cs / k + D.h1 * sn / (k * k), Hc * sn / k + D.h1 * cs / (k * k)];
-      };
-      const a = F(c0), b = F(cY);
-      tot += sinC * (b[0] - a[0]) + cosC * (b[1] - a[1]);
-      k0 += sinC * Math.sin(k * c0) + cosC * Math.cos(k * c0);
-    }
-    return tot - k0 * (year - 2000)
-         - (tropHarmonicsAt(year) - tropHarmonicsAt(2000)) / 2;
-  }
-
-  /** @param {number} year */
-  function sigmaTropical(year) {
-    const D = /** @type {DerivedCoefs} */ (derived);
-    return D.lincoef * (year - 2000) + driftTerm(year) + integratedTropHarmonics(year);
-  }
-
-  // δ_X(2000) — the self-correction that pins JD(2000) to the anchor exactly
-  // (sinusoids + ecc orders; the §10g joint terms self-correct inline).
-  // Computed lazily so the phase table builds on the caller's schedule.
-  /** @type {Record<string, number> | null} */
-  let _selfCorr = null;
-  function selfCorr() {
-    if (_selfCorr !== null) return _selfCorr;
-    _selfCorr = {};
-    const c2000 = cycleOf(2000);
-    for (const type of ['SS', 'WS', 'VE', 'AE']) {
-      let h2000 = 0;
-      for (const [div, sinC, cosC] of harmonics[type]) {
-        const th0 = 2 * Math.PI * div * c2000;
-        h2000 += sinC * Math.sin(th0) + cosC * Math.cos(th0);
-      }
-      const ecc = eccTerms && eccTerms[type];
-      if (ecc) {
-        const e0 = eccentricityAt(2000);
-        const th0 = 2 * Math.PI * 16 * c2000;
-        for (const t of ecc) {
-          const eN0 = Math.pow(e0, t.order);
-          h2000 += t.sin * eN0 * Math.sin(t.order * th0) + t.cos * eN0 * Math.cos(t.order * th0);
-        }
-      }
-      _selfCorr[type] = h2000;
-    }
-    return _selfCorr;
-  }
-
-  /** @param {number} year @param {string} [type] */
-  function computeSolsticeJD(year, type) {
-    const cp = type || 'SS';
-    const anchor = anchors[cp];
-    const deep = isDeepTime();
-
-    let jd = deep
-      ? anchor + sigmaTropical(year)
-      : anchor + meanSolarYearDays * (year - 2000);
-
-    const cY = cycleOf(year);
-    for (const [div, sinC, cosC] of harmonics[cp]) {
-      jd += sinC * Math.sin(2 * Math.PI * div * cY) + cosC * Math.cos(2 * Math.PI * div * cY);
-    }
-    const ecc = eccTerms && eccTerms[cp];
-    if (ecc) {
-      const e = eccentricityAt(year);
-      const th = 2 * Math.PI * 16 * cY;
-      for (const t of ecc) {
-        const eN = Math.pow(e, t.order);
-        jd += t.sin * eN * Math.sin(t.order * th) + t.cos * eN * Math.cos(t.order * th);
-      }
-    }
-    if (jointTerms) {
-      const lam = JOINT_LAMBDA[cp];
-      const c2000 = cycleOf(2000);
-      for (const t of jointTerms.terms) {
-        const th  = t.order * lam - 2 * Math.PI * t.div * cY;
-        const th0 = t.order * lam - 2 * Math.PI * t.div * c2000;
-        jd += t.sin * (Math.sin(th) - Math.sin(th0)) + t.cos * (Math.cos(th) - Math.cos(th0));
-      }
-    }
-    jd -= selfCorr()[cp];
-    return jd;
-  }
-
-  /** The EXACT term-by-term derivative of computeSolsticeJD — except the
-   *  drift part, which deliberately stays in the real-LOD convention (see
-   *  the file header). Neglected: the drift Euler–Maclaurin half-sample
-   *  term's own derivative (f′/2, sub-µs).
-   *  @param {number} year @param {string} [type] */
-  function computeSolsticeYearLength(year, type) {
-    const cp = type || 'SS';
-    const deep = isDeepTime();
-    const t_Ma = (2000 - year) / 1e6;
-
-    const H_at = deep ? (meanHAtAgeMa(t_Ma) ?? hJ2000) : hJ2000;
-    const dcdY = 1 / H_at;
-    const cY = cycleOf(year);
-
-    let length;
-    if (deep && derived) {
-      length = derived.lincoef;
-      const mSY_at = meanYearRealLodDays(t_Ma);
-      if (mSY_at !== null) length += (mSY_at - meanSolarYearDays);
-      length += tropHarmonicsAt(year);
-      let dTrop = 0;
-      for (const [div, sinC, cosC] of tropicalHarmonics) {
-        const k = 2 * Math.PI * div, th = k * cY;
-        dTrop += k * dcdY * (sinC * Math.cos(th) - cosC * Math.sin(th));
-      }
-      length -= dTrop / 2;
-    } else {
-      length = meanSolarYearDays;
-    }
-
-    for (const [div, sinC, cosC] of harmonics[cp]) {
-      const k = 2 * Math.PI * div, th = k * cY;
-      length += k * dcdY * (sinC * Math.cos(th) - cosC * Math.sin(th));
-    }
-
-    const ecc = eccTerms && eccTerms[cp];
-    if (ecc) {
-      const th16 = 2 * Math.PI * 16 * cY;
-      const thp = 2 * Math.PI * 16 * dcdY;
-      const e = eccentricityAt(year);
-      // de/dyear from the one law (formerly the H/16 law-of-cosines derivative).
-      // The braid's own phase θ16 stays: it is the perihelion-OF-DATE phase the
-      // equation of centre is seen through — an H/16 quantity by nature.
-      const de = eccentricityRateAt(year);
-      for (const t of ecc) {
-        const n = t.order, nth = n * th16;
-        const eN = Math.pow(e, n), eN1 = Math.pow(e, n - 1);
-        length += t.sin * (n * eN1 * de * Math.sin(nth) + eN * n * thp * Math.cos(nth))
-                + t.cos * (n * eN1 * de * Math.cos(nth) - eN * n * thp * Math.sin(nth));
-      }
-    }
-
-    if (jointTerms) {
-      const lam = JOINT_LAMBDA[cp];
-      for (const t of jointTerms.terms) {
-        const k = 2 * Math.PI * t.div;
-        const th = t.order * lam - k * cY;
-        length += k * dcdY * (-t.sin * Math.cos(th) + t.cos * Math.sin(th));
-      }
-    }
-    return length;
-  }
-
-  /** RA where a cardinal point occurs — fully derived, zero fitted constants.
-   *  INTEGRATED phase: the formula describes where the SCENE puts the point,
-   *  and the scene's H/3 and H/8 objects rotate on integrated phase.
-   *  @param {number} year @param {string} [type] */
-  function computeSolsticeRA(year, type) {
-    const sinE = Math.sin(tiltMeanDeg * Math.PI / 180);
-    const baseRA = /** @type {Record<string, number>} */ ({ SS: 90, WS: 270, VE: 0, AE: 180 })[type || 'SS'];
-    const raMean = baseRA - raAngleDeg / sinE;
-    const amp = inclAmplitudeDeg / sinE;
-    const cY = cycleOf(year);
-    const phase3 = 2 * Math.PI * 3 * cY;
-    const phase8 = 2 * Math.PI * 8 * cY;
-    return raMean + amp * (-Math.sin(phase3) + Math.sin(phase8));
-  }
-
-  /** Tropical year as the mean of the four cardinal intervals — the
-   *  physically correct definition (Σδ_X ≡ 0 makes the braid cancel).
-   *  @param {number} year */
-  function computeTropicalYearLength(year) {
-    return (computeSolsticeYearLength(year, 'SS') +
-            computeSolsticeYearLength(year, 'WS') +
-            computeSolsticeYearLength(year, 'VE') +
-            computeSolsticeYearLength(year, 'AE')) / 4;
-  }
-
-  return { computeSolsticeJD, computeSolsticeYearLength, computeSolsticeRA, computeTropicalYearLength };
-}
-
-module.exports = { createCardinalModel, JOINT_LAMBDA };

package/src/moon/ecc-channel.cjs

@@ -1,141 +0,0 @@
-/**
- * The Moon-channel eccentricity line — THE shared implementation (Phase 8.2-2).
- *
- * ONE movement, FULLY DERIVED, zero solved values (doc 66 §"Framework-native
- * e_E"): e(t) = eccentricityBase · (1 + cos θ(t) / 2), where θ rides the H/3
- * wobble cycle that drives Earth's inclination. Mean = base (Law 5),
- * amplitude = base/2, phase anchor θ₀ = ϖ_ICRF(J2000) − 21.77° = 81.18° past
- * max. The observed J2000 e (−0.86%), ė (+1.7%) and the sign of ë are
- * PREDICTIONS of this line, not inputs.
- *
- * DOMAIN (engine-switch decision (ii) restatement, plan 02 §8): this H/3
- * line is the CLOCK-side e — the eclipse Sun's equation of centre (FQ-7-Sun
- * option C-small, doc 66 §5), the besselian Sun distance, the cardinal
- * braid and the scene machinery ride it. The LUNAR chain (E-factor,
- * modulation, channelIntegral, argument Δe²) rides the ONE deep e
- * (deep-ecc-channel.cjs — the engine's own ±10-Myr z-vector); the two
- * agree within 4.2e-5 across the historical era, and this line keeps its
- * E18 role as the epoch-local tangent. Eccentricity remains
- * frame-invariant (fixed-frame periods only); the H/16 perihelion cycle
- * (the H/3 rotation seen from the H/13 equinox, 13 + 3 = 16) belongs to
- * ϖ, not e (doc 108).
- *
- * Extracted VERBATIM from src/script.js (_FW_ECC, _fwEarthEcc,
- * _eCompModulation, _fwChannelIntegral, the framework branch of _fwEFactor),
- * which tools/lib mirrored; this file replaces both copies. The 8.2-1
- * alignment made the two engines bit-exact first, so this move is provably
- * behaviour-preserving against the lunar golden masters.
- *
- * LOAD-BEARING conventions:
- *  - The injected `cyclesBetween` is the ENGINE'S OWN integrated-phase
- *    function (divisor 3 on the H lattice). Each engine's deep-time/snapshot
- *    toggle semantics ride along with it.
- *  - `e0`/`g0` are ANCHOR CONSTS by construction, never eccAt(0): under
- *    integrated phase, cycles(2000→2000) carries the R3 drift correction and
- *    is not exactly zero. The tools mirror once recomputed g0 from
- *    _fwEarthEcc(0) — unified here to the const.
- *  - channelIntegral uses composite Simpson with step ≤ ~4,000 yr (N ≥ 2,
- *    even) — the discretization the certified numbers were produced with.
- *  - Past the tidal-lock asymptote (cyclesBetween → null) eccAt returns the
- *    mean — the bounded continuation, not an error.
- */
-
-'use strict';
-
-/**
- * @param {{
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null),
- *   eccentricityBase: number,
- *   eccentricityJ2000?: number,
- *   perihelionLongitudeJ2000Deg: number,
- *   inclinationCycleAnchorDeg: number,
- * }} deps — cyclesBetween MUST be the engine's own H-lattice phase counter
- *   (integrated under deep time); perihelionLongitudeJ2000Deg is ϖ_ICRF at
- *   J2000 (102.94719°, the FULL value — a truncated copy once cost 0.684″);
- *   inclinationCycleAnchorDeg is the H/3 inclination anchor (21.77°).
- */
-function createMoonEccChannel({
-  cyclesBetween,
-  eccentricityBase,
-  perihelionLongitudeJ2000Deg,
-  inclinationCycleAnchorDeg,
-  eccentricityJ2000,
-}) {
-  const th0 = (perihelionLongitudeJ2000Deg - inclinationCycleAnchorDeg) * Math.PI / 180;
-  // ECCENTRICITY UNIFICATION (plan IP-eccentricity-unification, D1 = form
-  // (e)): this line is the model's ONE eccentricity law for every consumer
-  // (eclipse Sun, Sun distance, Moon E-factor and T² channel, cardinal
-  // braid, scene). When the observed J2000 eccentricity is supplied the
-  // mean is DERIVED from it and the shared anchor — base' = e0 / (1 +
-  // cos θ₀ / 2) = 0.015520 — so e(J2000) is exact by construction; the
-  // legacy form (mean = the Law-5 base, e(J2000) a −0.86% prediction) is
-  // kept for callers that do not supply it.
-  const mean = eccentricityJ2000 !== undefined
-    ? eccentricityJ2000 / (1 + Math.cos(th0) / 2)
-    : eccentricityBase;
-  const amplitude = mean / 2;
-  const e0 = mean + amplitude * Math.cos(th0);        // J2000 anchor, exact by construction
-  const g0 = Math.pow(1 - e0 * e0, -1.5);             // (1−e²)^(−3/2) at the anchor
-
-  /** e_E on the H/3 line at tYr years from J2000 (negative = past).
-   *  Returns the mean past the tidal-lock asymptote.
-   *  @param {number} tYr @returns {number} */
-  function eccAt(tYr) {
-    const cycles = cyclesBetween(2000, 2000 + tYr, 3);
-    if (cycles === null) return mean;
-    return mean + amplitude * Math.cos(th0 + 2 * Math.PI * cycles);
-  }
-
-  /** [g(e(t))/g₀]^s — the perigee/node rate modulation, ≡ 1 at J2000.
-   *  tMa is age in Myr (positive = past, the deep-time chain convention).
-   *  @param {number} tMa @param {number} s @returns {number} */
-  function modulation(tMa, s) {
-    if (tMa === 0) return 1;
-    const e = eccAt(-tMa * 1e6);
-    return Math.pow(Math.pow(1 - e * e, -1.5) / g0, s);
-  }
-
-  /** ∫₀ᵀ [(g(e(t′))/g₀)^s − 1] dt′ in Julian centuries — the phase-aware
-   *  channel-rate integral (the old frozen-κ T²/T³ Taylor coefficients were
-   *  this integral's J2000 truncation). Composite Simpson, step ≤ ~4 kyr.
-   *  @param {number} T @param {number} s @returns {number} */
-  function channelIntegral(T, s) {
-    if (T === 0) return 0;
-    /** @param {number} t */
-    const f = (t) => {
-      const e = eccAt(t * 100);   // t in cy → years
-      return Math.pow(Math.pow(1 - e * e, -1.5) / g0, s) - 1;
-    };
-    const N = Math.max(2, 2 * Math.ceil(Math.abs(T) * 100 / 8000));
-    const h = T / N;
-    let sum = f(0) + f(T);
-    for (let i = 1; i < N; i++) sum += f(i * h) * (i % 2 ? 4 : 2);
-    return sum * h / 3;
-  }
-
-  /** Bounded Meeus E-factor: E ≡ e_E(t)/e_E(J2000), value 1 at J2000 by
-   *  construction. The caller supplies tYr = days-from-J2000 / mean solar
-   *  year; the pure-Meeus A/B polynomial branch stays ENGINE-LOCAL with its
-   *  mode toggle. @param {number} tYr @returns {number} */
-  function eFactorAt(tYr) {
-    return eccAt(tYr) / e0;
-  }
-
-  /** de/dyear of the line at tYr years from J2000 (the cardinal braid's
-   *  equation-of-centre derivative): −amplitude·sin(θ)·dθ/dt, with dθ/dt
-   *  from the phase counter's two-point difference over ±1 yr (exact for a
-   *  linear phase, ppm-class under the integrated one). Returns 0 past the
-   *  tidal-lock asymptote, where eccAt returns the mean.
-   *  @param {number} tYr @returns {number} */
-  function eccRateAt(tYr) {
-    const c = cyclesBetween(2000, 2000 + tYr, 3);
-    if (c === null) return 0;
-    const cp = cyclesBetween(2000, 2000 + tYr + 1, 3), cm = cyclesBetween(2000, 2000 + tYr - 1, 3);
-    const dth = 2 * Math.PI * ((cp === null || cm === null) ? 0 : (cp - cm) / 2);
-    return -amplitude * Math.sin(th0 + 2 * Math.PI * c) * dth;
-  }
-
-  return { eccAt, eccRateAt, modulation, channelIntegral, eFactorAt, th0, amplitude, mean, e0, g0 };
-}
-
-module.exports = { createMoonEccChannel };

package/src/phase/index.cjs

@@ -1,186 +0,0 @@
-/**
- * Integrated-phase machinery — THE shared implementation (Phase 7.1).
- *
- * The cumulative ∫1/H(t)dt table and everything derived from it: cycle counts,
- * the J2000 drift correction, and the inverse lookup. Extracted VERBATIM from
- * tools/lib/deep-time.js, which was itself the port of src/script.js — this
- * file replaces both copies (and is the reference the website's deepTime.ts
- * must match; Phase E measured what happens when it doesn't).
- *
- * CommonJS on purpose: `tools/lib` is CJS and cannot require an ESM module
- * synchronously; ESM (`src/script.js`, bundlers) imports CJS natively. One
- * file, every engine.
- *
- * THE CONVENTIONS ARE LOAD-BEARING — the fitted coefficients were produced
- * against THIS discretization, so the numerics ship with the coefficients:
- *
- *  - TRAPEZOID rule on 10-kyr cells with LINEAR interpolation between cells.
- *    An analytically better integrator is WRONG here: the website's adaptive
- *    Simpson disagreed by ~1e-6 cycles at −280 kyr = ~18 s of cardinal-point
- *    JD through the ×16 braid phase (Gate E measured 24.7 s before the fix).
- *  - R2: the table must be built under the LATTICE α — the CONSTANT moment of
- *    inertia, not the climate-modulated α(t). The `holisticHAtAgeMa` the
- *    caller injects must already be pinned (see each engine's construction
- *    site). The always-on climate modulation integrates into a linear phase
- *    drift (the same ~18 s class — the dominant Phase E bug).
- *  - R3: the drift-correction anchor is identified by CALL SHAPE, never by
- *    distance from J2000 — the old distance heuristic put a 2·drift
- *    = 6.80e-5-cycle STEP DISCONTINUITY at yearB == yearA, worth 0.393 d of
- *    apsis displacement and 100% of 6d's anomalistic residual.
- *  - The table zero sits at the cell nearest `tableAnchorYear` (2000.5,
- *    startmodelYear); the drift reference is `driftRefYear`
- *    (startModelYearWithCorrection ≈ 2000.4977) — TWO different constants,
- *    half a day apart. Do not "unify" them.
- */
-
-'use strict';
-
-/**
- * @param {{
- *   holisticHAtAgeMa: (tMa: number) => (number | null),
- *   tableAnchorYear: number,
- *   driftRefYear: number,
- *   hJ2000: number,
- *   yearMin?: number,
- *   yearMax?: number,
- *   stepYears?: number,
- * }} cfg — holisticHAtAgeMa MUST be the lattice-α form; tableAnchorYear is
- *   startmodelYear (2000.5, table zero + t_Ma convention); driftRefYear is
- *   startModelYearWithCorrection (the R3 drift anchor); hJ2000 the snapshot
- *   rate the drift compares against; 10-kyr cells match both engines'
- *   historic tables.
- */
-function createPhaseMachinery({
-  holisticHAtAgeMa,
-  tableAnchorYear,
-  driftRefYear,
-  hJ2000,
-  yearMin = -500e6,
-  yearMax = 500e6,
-  stepYears = 10000,
-}) {
-  /** @type {Float64Array | null} */
-  let table = null;
-  let j2000Idx = -1;
-
-  function ensureTable() {
-    if (table !== null) return;
-    const N = Math.ceil((yearMax - yearMin) / stepYears) + 1;
-    const t = new Float64Array(N);
-    j2000Idx = Math.round((tableAnchorYear - yearMin) / stepYears);
-
-    /** @param {number} year */
-    const invH = (year) => {
-      const t_Ma = (tableAnchorYear - year) / 1e6;
-      const H = holisticHAtAgeMa(t_Ma);
-      return H === null ? null : 1 / H;
-    };
-
-    t[j2000Idx] = 0;
-    let prev = invH(yearMin + j2000Idx * stepYears);
-    for (let i = j2000Idx + 1; i < N; i++) {
-      const year_i = yearMin + i * stepYears;
-      const curr = invH(year_i);
-      t[i] = (prev !== null && curr !== null)
-        ? t[i - 1] + 0.5 * (prev + curr) * stepYears
-        : NaN;
-      prev = curr;
-    }
-    prev = invH(yearMin + j2000Idx * stepYears);
-    for (let i = j2000Idx - 1; i >= 0; i--) {
-      const year_i = yearMin + i * stepYears;
-      const curr = invH(year_i);
-      t[i] = (prev !== null && curr !== null)
-        ? t[i + 1] - 0.5 * (prev + curr) * stepYears
-        : NaN;
-      prev = curr;
-    }
-    table = t;
-  }
-
-  /** Cumulative ∫1/H at a year (linear interpolation). null outside the range
-   *  or where the physics is undefined (past the tidal-lock asymptote).
-   *  @param {number} year @returns {number | null} */
-  function cumulAtYear(year) {
-    ensureTable();
-    if (year < yearMin || year > yearMax) return null;
-    const t = /** @type {Float64Array} */ (table);
-    const idx_f = (year - yearMin) / stepYears;
-    const idx_lo = Math.floor(idx_f);
-    const idx_hi = Math.min(idx_lo + 1, t.length - 1);
-    const v_lo = t[idx_lo];
-    const v_hi = t[idx_hi];
-    if (Number.isNaN(v_lo) || Number.isNaN(v_hi)) return null;
-    return v_lo + (idx_f - idx_lo) * (v_hi - v_lo);
-  }
-
-  /** ∫_{yearA}^{yearB} 1/H(t') dt'. null if either endpoint is out of domain.
-   *  @param {number} yearA @param {number} yearB @returns {number | null} */
-  function integralBetween(yearA, yearB) {
-    if (yearA === yearB) return 0;
-    const cA = cumulAtYear(yearA);
-    const cB = cumulAtYear(yearB);
-    if (cA === null || cB === null) return null;
-    return cB - cA;
-  }
-
-  /** How far the integrated form has drifted from the J2000-snapshot form over
-   *  (yearA → driftRefYear). Subtracting it at the anchor restores the
-   *  snapshot-fitted harmonic calibration at J2000 without changing the
-   *  integrated form's shape at deep time.
-   *  @param {number} yearA @returns {number} */
-  function j2000Drift(yearA) {
-    const integral = integralBetween(yearA, driftRefYear);
-    if (integral === null) return 0;
-    const snapshot = (driftRefYear - yearA) / hJ2000;
-    return integral - snapshot;
-  }
-
-  /** Total cycles between two years for a cycle of period H/divisorN.
-   *  R3: the anchor is identified from the CALL SHAPE — two shapes exist,
-   *  (anchor, movingYear, N) and (J2000, anchor, N) where yearA IS the J2000
-   *  reference itself. The correction depends only on a FIXED endpoint, so it
-   *  is constant across any scan. Returns null past the tidal-lock asymptote.
-   *  @param {number} yearA @param {number} yearB @param {number} divisorN
-   *  @returns {number | null} */
-  function cyclesBetween(yearA, yearB, divisorN) {
-    const integral = integralBetween(yearA, yearB);
-    if (integral === null) return null;
-    const anchorIsA = (yearA !== driftRefYear);
-    const correction = anchorIsA ? j2000Drift(yearA) : -j2000Drift(yearB);
-    return divisorN * (integral - correction);
-  }
-
-  /** Inverse of cumulAtYear — the year at a given cumulative ∫1/H (binary
-   *  search over the monotone table). null outside the table domain.
-   *  @param {number} targetCumul @returns {number | null} */
-  function yearAtCumul(targetCumul) {
-    ensureTable();
-    const t = /** @type {Float64Array} */ (table);
-    const N = t.length;
-    let lo = 0, hi = N - 1;
-    while (lo < N && Number.isNaN(t[lo])) lo++;
-    while (hi >= 0 && Number.isNaN(t[hi])) hi--;
-    if (lo >= hi) return null;
-    if (targetCumul < t[lo] || targetCumul > t[hi]) return null;
-    while (lo < hi - 1) {
-      const mid = (lo + hi) >> 1;
-      if (t[mid] <= targetCumul) lo = mid; else hi = mid;
-    }
-    const v_lo = t[lo], v_hi = t[hi];
-    const frac = (v_lo === v_hi) ? 0 : (targetCumul - v_lo) / (v_hi - v_lo);
-    return yearMin + (lo + frac) * stepYears;
-  }
-
-  /** Grid geometry — consumed by the engines' days/pos tables, which share
-   *  this grid but keep their own integrands (they move at Phase 8). */
-  function grid() {
-    ensureTable();
-    const t = /** @type {Float64Array} */ (table);
-    return { yearMin, yearMax, stepYears, j2000Idx, length: t.length };
-  }
-
-  return { ensureTable, cumulAtYear, integralBetween, j2000Drift, cyclesBetween, yearAtCumul, grid };
-}
-
-module.exports = { createPhaseMachinery };