@essrt/physics 20.0.1 → 22.0.0

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 };

package/src/planets/ecc-channel.cjs

@@ -1,59 +0,0 @@
-/**
- * Planet eccentricity channel — THE shared implementation (Phase 8.3, L3).
- * The law-of-cosines oscillation every body's runtime eccentricity rides
- * (Earth on H/16, each planet on its OWN wobble period — S-P1):
- *
- *   e(t) = √(base² + amp² − 2·base·amp·cos θ),  θ = 2π·N·∫1/H dt
- *
- * — the distance between two circular orbits (body orbits the wobble
- * centre at radius amp; the centre orbits the Sun at radius base).
- *
- * Extracted from src/script.js computeEccentricityEarth (the browser's
- * 5-arg generic form) and tools/lib/orbital-engine.js computeEccentricity
- * (identical law; R6 aligned its phase to integrated). The structural twin
- * of moon/ecc-channel — but a DIFFERENT law (H/16 orbit law vs the Moon
- * channel's H/3 line; doc 66 keeps the two deliberately distinct).
- *
- * Engine null/toggle semantics stay ENGINE-SIDE, deliberately:
- *  - the browser's cyclesBetween carries its DEEP_TIME_MODE toggle and maps
- *    null (past tidal lock) → the MEAN eccentricity;
- *  - the Node engine pre-computes its snapshot cycles and keeps them when
- *    the integrated phase is null (its documented R6 flag polarity).
- * Both call the same law; the dispatch difference is recorded here so
- * nobody "unifies" it without measuring.
- */
-
-'use strict';
-
-/**
- * The law of cosines over resolved cycles. null cycles → the MEAN
- * eccentricity √(base² + amp²) (past the tidal-lock asymptote).
- * @param {number | null} cycles @param {number} base @param {number} amplitude
- * @returns {number} */
-function eccentricityFromCycles(cycles, base, amplitude) {
-  if (cycles === null) {
-    return Math.sqrt(base * base + amplitude * amplitude);
-  }
-  const phase = cycles * 2 * Math.PI;
-  return Math.sqrt(
-    base * base + amplitude * amplitude - 2 * base * amplitude * Math.cos(phase)
-  );
-}
-
-/**
- * Browser-convention evaluator: J2000-FIXED anchor + cycle length, divisor
- * N = H_J2000/cycleLength, integrated phase via the injected engine
- * cyclesBetween (toggle semantics ride along), null → mean.
- * @param {number} currentYear @param {number} anchorYearJ2000
- * @param {number} cycleLengthYearsJ2000 @param {number} base
- * @param {number} amplitude
- * @param {{ holisticYearJ2000: number,
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null) }} env
- * @returns {number} */
-function computeEccentricityIntegrated(currentYear, anchorYearJ2000, cycleLengthYearsJ2000, base, amplitude, env) {
-  const divisorN = env.holisticYearJ2000 / cycleLengthYearsJ2000;
-  const cycles = env.cyclesBetween(anchorYearJ2000, currentYear, divisorN);
-  return eccentricityFromCycles(cycles, base, amplitude);
-}
-
-module.exports = { eccentricityFromCycles, computeEccentricityIntegrated };

package/src/sun/longitude-correction.cjs

@@ -1,68 +0,0 @@
-/**
- * Sun longitude correction — the fitted H-lattice harmonic stack
- * (Phase 9, S-P8). THE shared evaluator behind what were THREE verbatim
- * copies: the browser's sunLongitudeCorrection and two inline blocks in
- * tools/lib/scene-graph (moveModel and the fast animator).
- *
- * The ~200″→~7″ RMS Sun-only correction (Phase Z-B): a fitted harmonic
- * table on H-lattice divisors, with the H-LATTICE FILTER applied at
- * evaluation — a divisor is structurally on-lattice iff EITHER
- *   (a) it is a year-multiple of H (integer year period), OR
- *   (b) it is a small precession divisor (1..20 — Earth's Fibonacci
- *       named cycles H/3, H/5, H/8, H/13, H/16, …), OR
- *   (c) it is one of the two lunar precession divisors (auto-tracked
- *       from the Meeus anchors).
- * Divisors failing all three are design-rule violating and silently
- * skipped. (Clause (d) "sharesFactorWithH" was removed 2026-07-15 — it
- * admitted mid-range fit artifacts, divisors 84/92/115/122, that are
- * not physically motivated. See tools/fit/sun-longitude-harmonics.js.)
- *
- * MATCHED PAIR: every dep is the J2000-FIXED value — the table was
- * fitted against J2000 H and mSY (the Node engines' documented
- * convention). The browser copy historically read the MUTABLE
- * holisticyearLength/balancedYear globals; measured divergence under
- * epoch shift was 8.2e-10 deg (~3 µas) — aligned onto the fitted
- * convention at extraction (9-1), zero fixture drift.
- *
- * The engines own the application (θ −= corr·d2r on the Sun node only)
- * and their enable flags.
- */
-
-'use strict';
-
-/**
- * @typedef {Object} SunLongitudeCorrectionDeps
- * @property {number} hYears - H, J2000-fixed (the fitted axis)
- * @property {number} balancedYear - J2000-fixed
- * @property {number} j2000JD
- * @property {number} meanDeg - the fitted mean offset
- * @property {Array<[number, number, number]>} harmonics - [divisor, sinC, cosC]
- * @property {number} nNodalJ2000 - lunar nodal divisor (per 8H convention)
- * @property {number} nApsidalJ2000 - lunar apsidal divisor
- */
-
-/** @param {SunLongitudeCorrectionDeps} deps */
-function createSunLongitudeCorrection(deps) {
-  /** Correction in DEGREES at JD (subtract from the raw Sun longitude).
-   * @param {number} jd @returns {number} */
-  function correctionDegAt(jd) {
-    const year = 2000 + (jd - deps.j2000JD) / 365.25;
-    const t = year - deps.balancedYear;
-    let corr = deps.meanDeg;
-    const H_round = Math.round(deps.hYears);
-    for (const h of deps.harmonics) {
-      const divisor = h[0];
-      const isYearMultiple = divisor >= H_round && divisor % H_round === 0;
-      const isPrecessionDivisor = divisor > 0 && divisor <= 20;
-      const isLunarPrecession = divisor === deps.nNodalJ2000 || divisor === deps.nApsidalJ2000;
-      if (!isYearMultiple && !isPrecessionDivisor && !isLunarPrecession) continue;
-      const phase = 2 * Math.PI * t / (deps.hYears / divisor);
-      corr += h[1] * Math.sin(phase) + h[2] * Math.cos(phase);
-    }
-    return corr;
-  }
-
-  return { correctionDegAt };
-}
-
-module.exports = { createSunLongitudeCorrection };

package/types/cardinal/index.d.cts

@@ -1,80 +0,0 @@
-export type DerivedCoefs = {
-    lincoef: number;
-    h0: number;
-    h1: number;
-};
-export type EccTerm = {
-    order: number;
-    sin: number;
-    cos: number;
-};
-export type JointTerm = {
-    order: number;
-    div: number;
-    sin: number;
-    cos: number;
-};
-/** @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
- */
-export function createCardinalModel({ isDeepTime, constants, fns }: {
-    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;
-    };
-}): {
-    computeSolsticeJD: (year: number, type?: string) => number;
-    computeSolsticeYearLength: (year: number, type?: string) => number;
-    computeSolsticeRA: (year: number, type?: string) => number;
-    computeTropicalYearLength: (year: number) => number;
-};
-/** @type {Record<string, number>} */
-export const JOINT_LAMBDA: Record<string, number>;

package/types/moon/ecc-channel.d.cts

@@ -1,30 +0,0 @@
-/**
- * @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°).
- */
-export function createMoonEccChannel({ cyclesBetween, eccentricityBase, perihelionLongitudeJ2000Deg, inclinationCycleAnchorDeg, eccentricityJ2000, }: {
-    cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null);
-    eccentricityBase: number;
-    eccentricityJ2000?: number;
-    perihelionLongitudeJ2000Deg: number;
-    inclinationCycleAnchorDeg: number;
-}): {
-    eccAt: (tYr: number) => number;
-    eccRateAt: (tYr: number) => number;
-    modulation: (tMa: number, s: number) => number;
-    channelIntegral: (T: number, s: number) => number;
-    eFactorAt: (tYr: number) => number;
-    th0: number;
-    amplitude: number;
-    mean: number;
-    e0: number;
-    g0: number;
-};

package/types/phase/index.d.cts

@@ -1,38 +0,0 @@
-/**
- * @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.
- */
-export function createPhaseMachinery({ holisticHAtAgeMa, tableAnchorYear, driftRefYear, hJ2000, yearMin, yearMax, stepYears, }: {
-    holisticHAtAgeMa: (tMa: number) => (number | null);
-    tableAnchorYear: number;
-    driftRefYear: number;
-    hJ2000: number;
-    yearMin?: number;
-    yearMax?: number;
-    stepYears?: number;
-}): {
-    ensureTable: () => void;
-    cumulAtYear: (year: number) => number | null;
-    integralBetween: (yearA: number, yearB: number) => number | null;
-    j2000Drift: (yearA: number) => number;
-    cyclesBetween: (yearA: number, yearB: number, divisorN: number) => number | null;
-    yearAtCumul: (targetCumul: number) => number | null;
-    grid: () => {
-        yearMin: number;
-        yearMax: number;
-        stepYears: number;
-        j2000Idx: number;
-        length: number;
-    };
-};

package/types/planets/ecc-channel.d.cts

@@ -1,20 +0,0 @@
-/**
- * The law of cosines over resolved cycles. null cycles → the MEAN
- * eccentricity √(base² + amp²) (past the tidal-lock asymptote).
- * @param {number | null} cycles @param {number} base @param {number} amplitude
- * @returns {number} */
-export function eccentricityFromCycles(cycles: number | null, base: number, amplitude: number): number;
-/**
- * Browser-convention evaluator: J2000-FIXED anchor + cycle length, divisor
- * N = H_J2000/cycleLength, integrated phase via the injected engine
- * cyclesBetween (toggle semantics ride along), null → mean.
- * @param {number} currentYear @param {number} anchorYearJ2000
- * @param {number} cycleLengthYearsJ2000 @param {number} base
- * @param {number} amplitude
- * @param {{ holisticYearJ2000: number,
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null) }} env
- * @returns {number} */
-export function computeEccentricityIntegrated(currentYear: number, anchorYearJ2000: number, cycleLengthYearsJ2000: number, base: number, amplitude: number, env: {
-    holisticYearJ2000: number;
-    cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null);
-}): number;

package/types/sun/longitude-correction.d.cts

@@ -1,41 +0,0 @@
-export type SunLongitudeCorrectionDeps = {
-    /**
-     * - H, J2000-fixed (the fitted axis)
-     */
-    hYears: number;
-    /**
-     * - J2000-fixed
-     */
-    balancedYear: number;
-    j2000JD: number;
-    /**
-     * - the fitted mean offset
-     */
-    meanDeg: number;
-    /**
-     * - [divisor, sinC, cosC]
-     */
-    harmonics: Array<[number, number, number]>;
-    /**
-     * - lunar nodal divisor (per 8H convention)
-     */
-    nNodalJ2000: number;
-    /**
-     * - lunar apsidal divisor
-     */
-    nApsidalJ2000: number;
-};
-/**
- * @typedef {Object} SunLongitudeCorrectionDeps
- * @property {number} hYears - H, J2000-fixed (the fitted axis)
- * @property {number} balancedYear - J2000-fixed
- * @property {number} j2000JD
- * @property {number} meanDeg - the fitted mean offset
- * @property {Array<[number, number, number]>} harmonics - [divisor, sinC, cosC]
- * @property {number} nNodalJ2000 - lunar nodal divisor (per 8H convention)
- * @property {number} nApsidalJ2000 - lunar apsidal divisor
- */
-/** @param {SunLongitudeCorrectionDeps} deps */
-export function createSunLongitudeCorrection(deps: SunLongitudeCorrectionDeps): {
-    correctionDegAt: (jd: number) => number;
-};