@essrt/physics 24.0.0 → 24.1.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@essrt/physics",
-  "version": "24.0.0",
+  "version": "24.1.0",
   "description": "ESSRT (Expanding Solar System Resonance Theory) physics core — pure, injectable-constants, no I/O, no globals, no DOM. The complete model incl. fitted coefficients; every published version immutably ships one recorded model identity.",
   "essrt": {
-    "modelVersion": "v26.6",
+    "modelVersion": "v26.7",
     "_note": "The model identity this package version ships (IP-unified-architecture §10: package semver tracks the API axis; the model version + CONSTANTS_HASH/COEFFICIENTS_HASH in src/constants/ carry the scientific identity). The version-pinning gate enforces this pairing against public/input/model-version.json."
   },
   "type": "module",

package/src/chain-cycles/index.cjs

@@ -26,11 +26,18 @@
  *    tableAnchorYear vs driftRefYear pair).
  *
  * NUMERICS ARE LOAD-BEARING: fixed 10-yr grid over ±250 kyr, per-cell
- * 3-point Simpson at build, LINEAR interpolation on read; adaptive Simpson
- * (~1 sample/kyr, n ∈ [32, 1024], even) as the out-of-range fallback. The
- * table replaced the per-call Simpson for in-range spans (the L-4
- * 92 s/century full-canon regression); an "analytically better" integrator
- * here would detach the runtime from the certified numbers.
+ * 3-point Simpson at build, LINEAR interpolation on read; beyond the dense
+ * grid a COARSE cumulative table (1-kyr cells, the same per-cell Simpson,
+ * anchored at the dense edge) grown lazily in 250-kyr chunks in the direction
+ * asked for — the owner's playback at 1,000 yr/s past year 250,000 had fallen
+ * to 190 ms of JS per frame: the former fallback, an adaptive Simpson of up to
+ * 1,024 samples per call cached by exact year pair, re-integrated every one
+ * of the four Moon chains from the grid edge on every frame, each sample a
+ * deep-time LOD/α evaluation. The adaptive Simpson remains only for a chain
+ * undefined somewhere in range (null) or beyond the coarse limit (±600 Myr,
+ * past the model's domain). An "analytically better" integrator here would
+ * detach the runtime from the certified numbers: the in-range path is
+ * byte-identical to before.
  */
 
 'use strict';
@@ -125,6 +132,62 @@ function createChainCycleIntegrator({
     return tab[i] + (idxF - i) * (tab[i + 1] - tab[i]);
   }
 
+  // ── The coarse extension beyond the dense grid ─────────────────────────────
+  // Per chain and per direction, a cumulative table in COARSE_STEP cells that
+  // starts at the dense edge with the edge's own value and grows by COARSE_CHUNK
+  // years whenever a year beyond its reach is asked for. The cells are built
+  // with the same 3-point Simpson as the dense grid; the read is the same
+  // linear interpolation. The period laws vary on Myr scales at deep time, so
+  // 1-kyr cells hold the count to far below a cycle — the old fallback sampled
+  // ~1 per kyr too, but re-did the whole span on every call.
+  const COARSE_STEP = 1000, COARSE_CHUNK = 250000, COARSE_LIMIT_YEARS = 600e6;
+  /** @typedef {{ cum: number[], ok: boolean }} CoarseSide */
+  /** @type {WeakMap<PeriodSecondsAtAge, { fwd: CoarseSide, bwd: CoarseSide }>} */
+  const coarse = new WeakMap();
+  /** @param {PeriodSecondsAtAge} periodFnSeconds @param {number} y @returns {number | null} cycles per tick */
+  const integrandAt = (periodFnSeconds, y) => {
+    const tPeriodS = periodFnSeconds((ageAnchorYear - y) / 1e6);
+    return tPeriodS === null ? null : tropicalYearJ2000Seconds / tPeriodS;
+  };
+  /** Grow one side until it covers `distance` years from the dense edge (or fails on a null chain).
+   *  @param {PeriodSecondsAtAge} periodFnSeconds @param {CoarseSide} side @param {number} edgeYear
+   *  @param {1|-1} dir @param {number} distance */
+  function growCoarse(periodFnSeconds, side, edgeYear, dir, distance) {
+    const need = Math.ceil(distance / COARSE_STEP) + 1;
+    let target = side.cum.length;
+    while (target < need) target += COARSE_CHUNK / COARSE_STEP;
+    for (let i = side.cum.length; i < target && side.ok; i++) {
+      const y0 = edgeYear + dir * (i - 1) * COARSE_STEP, y1 = y0 + dir * COARSE_STEP;
+      const f0 = integrandAt(periodFnSeconds, y0), fm = integrandAt(periodFnSeconds, (y0 + y1) / 2), f1 = integrandAt(periodFnSeconds, y1);
+      if (f0 === null || fm === null || f1 === null) { side.ok = false; break; }
+      side.cum.push(side.cum[i - 1] + dir * (f0 + 4 * fm + f1) * (COARSE_STEP / 6));
+    }
+  }
+  /** C(y) beyond the dense grid, or null when the chain is undefined on the way there.
+   *  @param {PeriodSecondsAtAge} periodFnSeconds @param {Float64Array} tab @param {number} y @returns {number | null} */
+  function coarseAt(periodFnSeconds, tab, y) {
+    let c = coarse.get(periodFnSeconds);
+    if (!c) {
+      c = { fwd: { cum: [tab[tab.length - 1]], ok: true }, bwd: { cum: [tab[0]], ok: true } };
+      coarse.set(periodFnSeconds, c);
+    }
+    const dir = y >= gridMaxYear ? 1 : -1;
+    const side = dir === 1 ? c.fwd : c.bwd;
+    const edgeYear = dir === 1 ? gridMaxYear : gridMinYear;
+    const distance = Math.abs(y - edgeYear);
+    if (distance > COARSE_LIMIT_YEARS) return null;
+    if (side.cum.length < Math.ceil(distance / COARSE_STEP) + 1) growCoarse(periodFnSeconds, side, edgeYear, dir, distance);
+    if (!side.ok || side.cum.length < Math.ceil(distance / COARSE_STEP) + 1) return null;
+    const idxF = distance / COARSE_STEP;
+    const i = Math.floor(idxF);
+    return side.cum[i] + (idxF - i) * (side.cum[i + 1] - side.cum[i]);
+  }
+  /** C(y) anywhere the tables reach: dense inside the grid, coarse beyond.
+   *  @param {PeriodSecondsAtAge} periodFnSeconds @param {Float64Array} tab @param {number} y @returns {number | null} */
+  function cumulativeAt(periodFnSeconds, tab, y) {
+    return (y > gridMinYear && y < gridMaxYear) ? tableAt(tab, y) : coarseAt(periodFnSeconds, tab, y);
+  }
+
   /** Cycles of the chain between two calendar years. Snapshot mode: linear
    *  at the J2000 rate. Deep time: table lookup in ±range, adaptive Simpson
    *  beyond. null past the tidal-lock asymptote.
@@ -147,10 +210,16 @@ function createChainCycleIntegrator({
       return dy * tropicalYearJ2000Seconds / tJ2000;
     }
 
-    // Cumulative-table fast path (deterministic, call-order independent)
-    if (yearA > gridMinYear && yearA < gridMaxYear && yearB > gridMinYear && yearB < gridMaxYear) {
-      const tab = table(periodFnSeconds);
-      if (tab !== null) return tableAt(tab, yearB) - tableAt(tab, yearA);
+    // Cumulative-table fast path (deterministic, call-order independent): the
+    // dense grid inside ±250 kyr — byte-identical to before — and the lazily
+    // grown coarse extension beyond it.
+    const tab = table(periodFnSeconds);
+    if (tab !== null) {
+      if (yearA > gridMinYear && yearA < gridMaxYear && yearB > gridMinYear && yearB < gridMaxYear) {
+        return tableAt(tab, yearB) - tableAt(tab, yearA);
+      }
+      const cA = cumulativeAt(periodFnSeconds, tab, yearA), cB = cumulativeAt(periodFnSeconds, tab, yearB);
+      if (cA !== null && cB !== null) return cB - cA;
     }
 
     let cache = caches.get(periodFnSeconds);
@@ -162,7 +231,8 @@ function createChainCycleIntegrator({
     const hit = cache.get(cacheKey);
     if (hit !== undefined) return hit;
 
-    // Adaptive Simpson: ~1 sample per 1 kyr, capped at 1024 to bound per-call cost.
+    // Adaptive Simpson (a chain undefined in range, or beyond the coarse limit):
+    // ~1 sample per 1 kyr, capped at 1024 to bound per-call cost.
     let n = Math.max(32, Math.ceil(Math.abs(dy) / 1000));
     if (n > 1024) n = 1024;
     if (n % 2 === 1) n++;

package/src/constants/generated.js

@@ -39,7 +39,7 @@
 export const CONSTANTS_HASH = "da713fc2d846767d";
 
 /** Model version label — single source: public/input/model-version.json (§10 two-axis scheme). */
-export const MODEL_VERSION = "v26.6";
+export const MODEL_VERSION = "v26.7";
 
 /** Canonical preprint DOI — single source: public/input/model-version.json. */
 export const PREPRINT_DOI = "10.21203/rs.3.rs-8758810/v4";

package/src/moon/arguments.cjs

@@ -145,8 +145,46 @@ function createMoonArguments({ constants, fns }) {
     }
     return kPl;
   }
+  // ── Deep-time carrier tables ────────────────────────────────────────────────
+  // In the era (|T| ≤ CARRIER_DENSE_CY = 250 kyr) each carrier is the Simpson
+  // sum below, untouched — the certified numbers. Beyond, the integral
+  // continues from the dense edge on a cumulative table of CARRIER_CELL_CY
+  // cells (1 kyr; per-cell 3-point Simpson, a 3-point Simpson over the
+  // partial last cell), grown in CARRIER_CHUNK cells in the direction asked
+  // for. The former form re-integrated the whole span from J2000 on EVERY
+  // call with N ∝ |T| nodes — 77 evaluations of the e channel at 300 kyr,
+  // 2,500 at 10 Myr, per lunar argument set and frame — the deep-time
+  // playback cost the owner measured (the loop's JS at 190 ms a frame).
+  const CARRIER_DENSE_CY = 2500, CARRIER_CELL_CY = 10, CARRIER_CHUNK = 2500;
+  /** @param {(t: number) => number} f the SCALED integrand per century
+   *  @param {(T: number) => number} dense the in-era Simpson (its value at ±CARRIER_DENSE_CY seeds the table)
+   *  @returns {(T: number) => number} */
+  function makeDeepCarrier(f, dense) {
+    /** @type {{ fwd: number[] | null, bwd: number[] | null }} */
+    const sides = { fwd: null, bwd: null };
+    return (T) => {
+      if (Math.abs(T) <= CARRIER_DENSE_CY) return dense(T);
+      const dir = T > 0 ? 1 : -1;
+      let cum = dir === 1 ? sides.fwd : sides.bwd;
+      if (!cum) { cum = [dense(dir * CARRIER_DENSE_CY)]; if (dir === 1) sides.fwd = cum; else sides.bwd = cum; }
+      const dist = Math.abs(T) - CARRIER_DENSE_CY;
+      const k = Math.floor(dist / CARRIER_CELL_CY);
+      let target = cum.length;
+      while (target < k + 2) target += CARRIER_CHUNK;
+      for (let i = cum.length; i < target; i++) {
+        const t0 = dir * (CARRIER_DENSE_CY + (i - 1) * CARRIER_CELL_CY), t1 = t0 + dir * CARRIER_CELL_CY;
+        cum.push(cum[i - 1] + dir * (f(t0) + 4 * f((t0 + t1) / 2) + f(t1)) * (CARRIER_CELL_CY / 6));
+      }
+      const ta = dir * (CARRIER_DENSE_CY + k * CARRIER_CELL_CY);
+      const hp = T - ta;
+      return cum[k] + (f(ta) + 4 * f(ta + hp / 2) + f(T)) * (hp / 6);
+    };
+  }
+
+  /** The planetary carrier's SCALED integrand, k_PL · (e² − e0²), per century. @param {number} t */
+  const planetaryIntegrand = (t) => { const e = eccAt(t * 100); return kPlValue() * (e * e - eccE0 * eccE0); };
   /** @param {number} T @returns {number} */
-  function planetaryCarrier(T) {
+  function planetaryCarrierDense(T) {
     if (T === 0) return 0;
     const k = kPlValue();
     // The channel's e0 anchor CONST — not eccAt(0), which under integrated
@@ -160,12 +198,12 @@ function createMoonArguments({ constants, fns }) {
     for (let i = 1; i < N; i++) sum += f(i * h) * (i % 2 ? 4 : 2);
     return k * sum * h / 3;
   }
+  const planetaryCarrier = makeDeepCarrier(planetaryIntegrand, planetaryCarrierDense);
 
   /** @type {{eps0: number, C: number} | null} */
   let obl = null;
-  /** @param {number} T @returns {number} */
-  function obliquityCarrier(T) {
-    if (T === 0) return 0;
+  /** The obliquity carrier's normalization, once. @returns {{eps0: number, C: number}} */
+  function oblInit() {
     if (obl === null) {
       // (d′): when the of-date rate completion is live, its ∫(p_dyn − p_kin)
       // carries the model-native share of the precession ACCELERATION
@@ -179,14 +217,23 @@ function createMoonArguments({ constants, fns }) {
       const epsDot = computeObliquityEarth(2050) - computeObliquityEarth(1950);
       obl = { eps0, C: 2 * T2_OBL / epsDot };
     }
+    return obl;
+  }
+  /** The obliquity carrier's SCALED integrand, C · (ε − ε0), per century. @param {number} t */
+  const obliquityIntegrand = (t) => { const O = oblInit(); return O.C * (computeObliquityEarth(2000 + t * 100) - O.eps0); };
+  /** @param {number} T @returns {number} */
+  function obliquityCarrierDense(T) {
+    if (T === 0) return 0;
+    const O = oblInit();
     /** @param {number} t */
-    const f = (t) => computeObliquityEarth(2000 + t * 100) - /** @type {{eps0: number, C: number}} */ (obl).eps0;
+    const f = (t) => computeObliquityEarth(2000 + t * 100) - O.eps0;
     const N = Math.max(2, 2 * Math.ceil(Math.abs(T) * 100 / 2000));
     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 /** @type {{eps0: number, C: number}} */ (obl).C * sum * h / 3;
+    return O.C * sum * h / 3;
   }
+  const obliquityCarrier = makeDeepCarrier(obliquityIntegrand, obliquityCarrierDense);
 
   // ── Secular-ë completion carrier (ṅ campaign, plan §12i item 0 (c)) ──────
   // The certified snapshot's Lp T³/T⁴ tail is DERIVED physics (v4 D3,
@@ -234,6 +281,10 @@ function createMoonArguments({ constants, fns }) {
       const env = Math.cos(Math.PI / 2 * q) ** 2;
       return (0.5 * S.dd2 * t * t + S.d3Sec * t * t * t / 6) * env;
     };
+    // Beyond the era the envelope has long closed (|t| ≥ Tq ≈ 279 cy → 0): the
+    // integral is the constant to ±Tq, so integrate exactly that span instead of
+    // N ∝ |T| nodes of zeros (in-era calls untouched).
+    if (Math.abs(T) > CARRIER_DENSE_CY) T = Math.sign(T) * S.Tq;
     const N = Math.max(2, 2 * Math.ceil(Math.abs(T) * 100 / 2000));
     const h = T / N;
     let sum = f(0) + f(T);
@@ -374,7 +425,18 @@ function createMoonArguments({ constants, fns }) {
    *  (the anchors are measured against exactly this).
    *  @param {number} jd
    *  @returns {{Lp: number, w: number, om: number, Lsun: number, ws: number, dy: number} | null} */
+  /** @type {number} */ let _partsJd = NaN;
+  /** @type {ReturnType<typeof fwArgsDeepPartsAt>} */ let _partsLast = null;
+  /** The parts at a JD — memoized on the exact JD: a frame asks the same instant for
+   *  the Moon, the umbra disc and the element rows. @param {number} jd */
   function fwArgsDeepParts(jd) {
+    if (jd === _partsJd && _partsLast !== null) return _partsLast;
+    const P = fwArgsDeepPartsAt(jd);
+    _partsJd = jd; _partsLast = P;
+    return P;
+  }
+  /** @param {number} jd */
+  function fwArgsDeepPartsAt(jd) {
     const A = bundle;
     if (argsY0 === null) argsY0 = jdToSIyear(j2000JD);
     const y = jdToSIyear(jd);