@essrt/physics 12.0.0 → 14.0.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@essrt/physics",
-  "version": "12.0.0",
+  "version": "14.0.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": "v16.2",
+    "modelVersion": "v18.0",
     "_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",
@@ -50,10 +50,7 @@
     "./moon/series-extension": { "types": "./types/moon/series-extension.d.cts", "default": "./src/moon/series-extension.cjs" },
     "./moon/apparent": { "types": "./types/moon/apparent.d.cts", "default": "./src/moon/apparent.cjs" },
     "./planets/geometry": { "types": "./types/planets/geometry.d.cts", "default": "./src/planets/geometry.cjs" },
-    "./planets/fibonacci-laws": { "types": "./types/planets/fibonacci-laws.d.cts", "default": "./src/planets/fibonacci-laws.cjs" },
     "./planets/ecc-channel": { "types": "./types/planets/ecc-channel.d.cts", "default": "./src/planets/ecc-channel.cjs" },
-    "./planets/orientation": { "types": "./types/planets/orientation.d.cts", "default": "./src/planets/orientation.cjs" },
-    "./planets/asc-node-integrator": { "types": "./types/planets/asc-node-integrator.d.cts", "default": "./src/planets/asc-node-integrator.cjs" },
     "./planets/orbit-chain": { "types": "./types/planets/orbit-chain.d.cts", "default": "./src/planets/orbit-chain.cjs" },
     "./planets/keplerian-chain": { "types": "./types/planets/keplerian-chain.d.cts", "default": "./src/planets/keplerian-chain.cjs" },
     "./planets/spin-channel": { "types": "./types/planets/spin-channel.d.cts", "default": "./src/planets/spin-channel.cjs" },

package/src/constants/generated.js

@@ -36,7 +36,7 @@
 export const CONSTANTS_HASH = "726b10e23d8ace09";
 
 /** Model version label — single source: public/input/model-version.json (§10 two-axis scheme). */
-export const MODEL_VERSION = "v16.2";
+export const MODEL_VERSION = "v18.0";
 
 /** Canonical preprint DOI — single source: public/input/model-version.json. */
 export const PREPRINT_DOI = "10.21203/rs.3.rs-8758810/v4";

package/src/index.js

@@ -122,12 +122,13 @@ export { createMoonApparent } from './moon/apparent.cjs';
 // sample) and the offset-circle wheel-angle solver: the scene twins' one placement.
 export { computeEarthFrameOfDate, solveWheelAngleForLongitude } from './earth/frame-of-date.cjs';
 // Phase 8.3 — the planet machinery, extracted by LAW over body records
-// (survey order: geometry → Fibonacci laws → channels → chains).
+// (survey order: geometry → channels → chains). The ψ/K amplitude laws
+// (planets/fibonacci-laws), the record-based orientation forms
+// (planets/orientation) and the ascending-node integrator
+// (planets/asc-node-integrator) are DELETED at plan 07 R5/R6: the planets'
+// elements of date have one home, the N-body chain; docs/retired-record.md.
 export { derivePlanetGeometry } from './planets/geometry.cjs';
-export * as planetFibonacciLaws from './planets/fibonacci-laws.cjs';
 export { eccentricityFromCycles, computeEccentricityIntegrated } from './planets/ecc-channel.cjs';
-export * as planetOrientation from './planets/orientation.cjs';
-export { integrateAscendingNode } from './planets/asc-node-integrator.cjs';
 export * as planetOrbitChain from './planets/orbit-chain.cjs';
 // P5/K4.6c — the engine-D Keplerian chain (pure evaluator + the embedded
 // governed artifact; the browser flag path consumes exactly these).

package/src/model.js

@@ -18,7 +18,6 @@
  * which itself mirrors tools/lib/constants.js §9.
  */
 import { deriveEpochParams } from './layer0/derive-params.js';
-import * as FL from './planets/fibonacci-laws.cjs';
 import { buildPlanetChainsFromArtifactData, computePlanetElementsAtYear } from './planets/keplerian-chain.cjs';
 import { createSecularSeriesOverride } from './planets/secular-series.cjs';
 import { computeEquatorNodeOriginSFrameDeg, convertNodeSFrameToEquatorOriginDeg } from './planets/inv-plane-frame.cjs';
@@ -97,15 +96,12 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const meanAnomalisticYearDays = (meanSolarYearDays * (H / 16)) / (H / 16 - 1);
   const meanTropicalYearJ2000Seconds = meanSolarYearDays * meanLengthOfDay;
 
-  const earthtiltMean = C.earth.earthtiltMean;
-  const earthInclAmplitude = C.earth.earthInvPlaneInclinationAmplitude;
-  // eccentricityAmplitude: the Law-4 input A (the 1246 triangle closure; the
-  // wobble-marker distance). It is the K calibration input ONLY — Earth's
-  // eccentricity law does not use it; see eccentricityAt (base' derived) below.
-  const eccentricityAmplitude = C.earth.eccentricityAmplitude;
-  const earthInclMean = C.earthOrbital.earthInclinationJ2000_deg
-    - earthInclAmplitude * Math.cos(((C.earthOrbital.earthPerihelionLongitudeJ2000
-      - C.earthOrbital.earthInclinationCycleAnchor) * Math.PI) / 180);
+  // Plan 07 R5/R6/R9: `earthtiltMean`, `earthInvPlaneInclinationAmplitude`
+  // and `eccentricityAmplitude` were read here only to invert the K and ψ
+  // constants from Earth's calibration and to build the H/3 inclination
+  // 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;
 
   const G_CONSTANT = C.physicalConstants.G_CONSTANT;
@@ -430,14 +426,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   /** de/dyear of the Sun's e — the cardinal braid's equation-of-centre
    *  derivative rides it (±0.5-yr central difference; the constant offset
    *  cancels). @param {number} year @returns {number} */
-  /** @param {number} year @returns {number} */
-  const inclinationDeg = (year) => earthInclMean
-    - earthInclAmplitude * Math.cos(phaseRadians(balancedYear, year, 3));
-  /** @param {number} year @returns {number} */
-  const ascendingNodeDeg = (year) => {
-    const period = -H / 5;
-    return (((C.earthOrbital.earthAscendingNodeInvPlane + (360.0 * (year - 2000)) / period) % 360) + 360) % 360;
-  };
+  // (Plan 07 R5/R9: Earth's H/3 inclination cosine and −H/5 linear node — the
+  // K device — stood here; `inclinationDeg`/`ascendingNodeDeg` are now the
+  // 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} */
@@ -618,6 +609,8 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     });
     return {
       yearLengths,
+      /** The one-source sample at a decimal year (the engine year) — ε, e, ϖ of date, the Earth-orbit normal (the fields the frame of date and the invariable-plane elements read). @param {number} year */
+      sampleAt,
       /** EXPERIMENT accessors: the series' e and equinox-referenced ϖ of date. @param {number} year @returns {number} */
       eAt: (year) => sampleAt(year).e,
       /** @param {number} year @returns {number} */
@@ -717,19 +710,11 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   for (const k of PLANET_KEYS) massFraction[k] = 1 / C.physicalConstants.massRatioDE440[k];
   massFraction.earth = massEarthAlone / M_SUN;
 
-  const PSI = FL.computePsiConstant({
-    earthInvPlaneInclinationAmplitude: earthInclAmplitude,
-    massEarthAlone,
-    massSun: M_SUN,
-  });
-  const eccentricityAmplitudeK = FL.computeKConstant({
-    eccentricityAmplitude,
-    massEarthAlone,
-    massSun: M_SUN,
-    earthTiltMeanDeg: earthtiltMean,
-  });
-  const systemResetN = C.foundational.systemResetN;
-  const t2000 = 2000 - (balancedYear - systemResetN * H);
+  // (plan 07 R6: eccentricityAmplitudeK — the K constant inverted from
+  // Earth's calibration — and the t2000 phase offset it fed went with the
+  // eccentricity law; plan 07 R5: PSI — ψ = 3·A_earth·√(m_E/m_☉) — and the
+  // inclination law it fed went the same way. systemResetN is kept where
+  // other consumers read it.)
 
   /** @param {[number, number]|null} frac @returns {number|null} */
   const fractionToYears = (frac) => (frac === null ? null : (H * frac[0]) / frac[1]);
@@ -749,34 +734,13 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     // obliquity of the spin channel (the IAU pole against the chain's J2000
     // plane, acute form) — both from the governed artifacts, no fractions.
     const wobble = computeSecularShape(/** @type {any} */ (CHAIN_ARTIFACT), k).beatYears;
-    const il = FL.computeInclinationLaw({
-      fibonacciD: mp.fibonacciD,
-      massFrac: massFraction[k],
-      invPlaneInclinationJ2000: ar.invPlaneInclinationJ2000,
-      longitudePerihelion: ar.longitudePerihelion,
-      inclinationCycleAnchor: mp.inclinationCycleAnchor,
-      antiPhase: mp.antiPhase || false,
-    }, PSI);
     const obliquityDerived = computeObliquityJ2000Deg({
       spin: C.planetSpinPhysical[k],
       anchorInclEclipticDeg: /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements[k].inclEclipticDeg,
       anchorAscNodeEclipticDeg: /** @type {any} */ (CHAIN_ARTIFACT).j2000AnchorElements[k].ascNodeEclipticDeg,
       obliquityJ2000Deg: C.earthOrbital.obliquityJ2000_deg,
     });
-    const obliquityMean = Math.min(obliquityDerived, 180 - obliquityDerived);   // acute: the K law reads sin|ε|
-    const el = FL.computeEccentricityLaw({
-      fibonacciD: mp.fibonacciD,
-      massFrac: massFraction[k],
-      solarYearInput: ar.solarYearInput,
-      orbitalEccentricityJ2000: ar.orbitalEccentricityJ2000,
-      antiPhase: mp.antiPhase || false,
-    }, {
-      kConstant: eccentricityAmplitudeK,
-      obliquityMeanDeg: obliquityMean,
-      wobblePeriodYears: wobble,
-      t2000,
-      meanSolarYearDays,
-    });
+    const obliquityMean = Math.min(obliquityDerived, 180 - obliquityDerived);   // acute form of the derived J2000 obliquity
     PLANET_RECORDS[k] = Object.freeze({
       name: mp.name,
       perihelionEclipticYears: ecl,
@@ -789,19 +753,17 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       ascendingNodeInvPlane: mp.ascendingNodeInvPlane,
       inclinationCycleAnchor: mp.inclinationCycleAnchor,
       invPlaneInclinationJ2000: ar.invPlaneInclinationJ2000,
-      invPlaneInclinationAmplitude: il.amplitude,
-      invPlaneInclinationMean: il.mean,
       obliquityMean,
       orbitalEccentricityJ2000: ar.orbitalEccentricityJ2000,
-      orbitalEccentricityAmplitude: el.amplitude,
-      orbitalEccentricityBase: el.base,
-      eccentricityPhaseJ2000: el.phaseJ2000,
       solarYearInput: ar.solarYearInput,
       axialTiltJ2000: ar.axialTiltJ2000,
     });
     // R8 (plan 07): what `model.planets.record()` PUBLISHES is not the record
-    // above. The record keeps the ψ/K law outputs because the fitting pipeline
-    // reads them (step 7a derive-eccentricity-amplitudes, the EoC fractions) —
+    // above. The internal record kept the ψ/K law outputs for the fitting
+    // pipeline; at R6 the K half and both fitter steps that read it went, at
+    // R5 the ψ half (invPlaneInclinationAmplitude/Mean) — what remains above
+    // is the structural inputs and the derived J2000 obliquity.
+    // The separation stands for the same reason it was made —
     // but nothing outside needs the device, and serving it made /v1/bodies
     // contradict the model's own chain on the SAME quantities: Mercury's node
     // cycle 298,060 yr against the chain's 232,001, Jupiter's perihelion period
@@ -898,13 +860,15 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   };
   /** Ecliptic longitude of perihelion, J2000 ecliptic and equinox (the chain's ϖ). @param {string} k @param {number} year @returns {number} */
   const planetPerihelionDeg = (k, year) => planetChainElementsAt(k, year).lonPeriEclipticDeg;
-  /** Ascending node on the model's invariable plane, from the plane's ascending node on the ICRF equator (the Souami & Souchay 2012 origin; derived conversion, inv-plane-frame). @param {string} k @param {number} year @returns {number} */
-  const planetAscNodeDeg = (k, year) => {
+  /** The S&S longitude origin as an s-frame longitude (J2000-fixed, derived). @returns {number} */
+  const nodeOriginSSDeg = () => {
     if (planetNodeOriginSSDeg === null) {
       planetNodeOriginSSDeg = computeEquatorNodeOriginSFrameDeg(/** @type {any} */ (CHAIN_ARTIFACT).invariablePlane, C.earthOrbital.obliquityJ2000_deg);
     }
-    return convertNodeSFrameToEquatorOriginDeg(planetChainElementsAt(k, year).ascNodeInvPlaneDeg, planetNodeOriginSSDeg);
+    return planetNodeOriginSSDeg;
   };
+  /** Ascending node on the model's invariable plane, from the plane's ascending node on the ICRF equator (the Souami & Souchay 2012 origin; derived conversion, inv-plane-frame). @param {string} k @param {number} year @returns {number} */
+  const planetAscNodeDeg = (k, year) => convertNodeSFrameToEquatorOriginDeg(planetChainElementsAt(k, year).ascNodeInvPlaneDeg, nodeOriginSSDeg());
   /** Inclination to the model's invariable plane (exact orbit-normal rotation). @param {string} k @param {number} year @returns {number} */
   const planetInclinationDeg = (k, year) => planetChainElementsAt(k, year).inclInvPlaneDeg;
   /** Orbital eccentricity of date, from the same chain elements (R8): the
@@ -913,6 +877,52 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
    *  e-vector does not have. @param {string} k @param {number} year @returns {number} */
   const planetEccentricity = (k, year) => planetChainElementsAt(k, year).e;
 
+  // ── Earth's invariable-plane elements of date (plan 07 R5/R9) ─────────────
+  // ONE published i_inv / Ω_inv everywhere — the mirror of the browser's
+  // inclInvPlaneModel / ascNodeInvPlaneModel (identical ops): the engine's
+  // own Earth-orbit normal of date (the one-source sampler — the banked
+  // secular series inside ±10 Myr, the mode tail beyond) against the
+  // artifact's invariable plane, the node expressed in the Souami & Souchay
+  // longitude origin through the same derived conversion the planets' node
+  // takes. The H/3 cosine on the fixed apsidal carrier and the −H/5 linear
+  // node that served here until R5 were the K device: 1.578677° against
+  // 1.578422° at J2000, 1.24° against 1.91° at −100 kyr, and 112° against
+  // 94° of node there. Doc 05 banks the one-source reading at rms 0.003°
+  // vs La2010 over −500 kyr. Argument: the engine year (dynamical time,
+  // Julian from J2000 TT — the sampler's own coordinate, as the chain's).
+  const invPlaneGeometry = (() => {
+    const ip = /** @type {{ inclEclipticDeg: number, ascNodeEclipticDeg: number }} */ (/** @type {any} */ (CHAIN_ARTIFACT).invariablePlane);
+    const D2R = Math.PI / 180;
+    const si = Math.sin(ip.inclEclipticDeg * D2R), ci = Math.cos(ip.inclEclipticDeg * D2R);
+    const nInv = [si * Math.sin(ip.ascNodeEclipticDeg * D2R), -si * Math.cos(ip.ascNodeEclipticDeg * D2R), ci];
+    const xIp = [Math.cos(ip.ascNodeEclipticDeg * D2R), Math.sin(ip.ascNodeEclipticDeg * D2R), 0];
+    const yIp = [nInv[1] * xIp[2] - nInv[2] * xIp[1], nInv[2] * xIp[0] - nInv[0] * xIp[2], nInv[0] * xIp[1] - nInv[1] * xIp[0]];
+    return { ascNodeEclipticDeg: ip.ascNodeEclipticDeg, nInv, xIp, yIp };
+  })();
+  /** The engine Earth-orbit normal of date, J2000 ecliptic frame. @param {number} year @returns {number[]} */
+  const earthOrbitNormalJ2000At = (year) => {
+    const s = oneSourceM.sampleAt(year);
+    return [s.orbitNormalX, s.orbitNormalY, Math.sqrt(Math.max(0, 1 - s.orbitNormalX * s.orbitNormalX - s.orbitNormalY * s.orbitNormalY))];
+  };
+  /** Earth's inclination of date to the model's invariable plane, degrees. @param {number} year @returns {number} */
+  const inclinationDeg = (year) => {
+    const nE = earthOrbitNormalJ2000At(year), nInv = invPlaneGeometry.nInv;
+    const d = nE[0] * nInv[0] + nE[1] * nInv[1] + nE[2] * nInv[2];
+    return Math.acos(Math.min(1, Math.max(-1, d))) / (Math.PI / 180);
+  };
+  /** Earth's ascending node of date on the invariable plane, S&S origin, degrees in [0, 360). @param {number} year @returns {number} */
+  const ascendingNodeDeg = (year) => {
+    const D2R = Math.PI / 180;
+    const { ascNodeEclipticDeg, nInv, xIp, yIp } = invPlaneGeometry;
+    const nE = earthOrbitNormalJ2000At(year);
+    let N = [nInv[1] * nE[2] - nInv[2] * nE[1], nInv[2] * nE[0] - nInv[0] * nE[2], nInv[0] * nE[1] - nInv[1] * nE[0]];
+    const L = Math.hypot(N[0], N[1], N[2]);
+    N = [N[0] / L, N[1] / L, N[2] / L];
+    const sFrameDeg = ((Math.atan2(N[0] * yIp[0] + N[1] * yIp[1] + N[2] * yIp[2],
+      N[0] * xIp[0] + N[1] * xIp[1] + N[2] * xIp[2]) / D2R + ascNodeEclipticDeg) % 360 + 360) % 360;
+    return convertNodeSFrameToEquatorOriginDeg(sFrameDeg, nodeOriginSSDeg());
+  };
+
   // ── Time axis: exact JD ↔ model-year conversion ───────────────────────────
   // The model's `year` inputs live on the SI axis (the axis the fits were
   // anchored on — tools/lib `_jdToSIyear`): linear in SI 86400-s days from the

package/src/planets/model.cjs

@@ -2,31 +2,29 @@
  * createPlanetModel — the planet composition front door (Phase 8.3, L10).
  *
  * ONE law set, N body records: this factory binds an environment once and
- * runs the certified derivation chain over every body record, in the order
- * the chain requires (each step feeds the next):
+ * runs the certified derivation chain over every body record:
  *
- *   ψ constant → inclination law (amplitude, mean)
- *             → wobble period (beat of |axial| and |ICRF|)
- *   K constant → obliquity mean (snapshot form) → eccentricity law
- *             (amplitude, base, J2000 phase)
- *   geometry   (the type-branched ellipse family — the law-derived
- *              eccentricity base feeds geometry for the seven carriers;
- *              minor bodies use their record's base)
+ *   inputs     the chain's g-mode beat (wobble) and the spin channel's
+ *              derived J2000 obliquity, carried on the record since plan 06
+ *              Phase 7 commit 2
+ *   geometry   (the type-branched ellipse family on the OBSERVED J2000
+ *              eccentricity; minor bodies use their record's base)
+ *
+ * The ψ and K amplitude laws that opened this chain (ψ constant →
+ * inclination amplitude/mean; K constant → eccentricity amplitude/base/
+ * phase) are DELETED — K at plan 07 R6, ψ at plan 07 R5. A planet's
+ * inclination and eccentricity of date have one home, the N-body chain
+ * (model.js planetChainElementsAt); docs/retired-record.md is the record.
  *
  * THIN BY DESIGN. This is the composition surface, not a rewiring: both
- * engines keep their existing direct call sites into the law modules, and
- * the runtime channels (eccentricity-at-year, orientation, the ascending-
- * node integrator, predictive precession) stay direct module calls because
- * they consume engine-owned state (scene JD, epoch machinery, fitted
- * tables). What this factory adds is the seam future bodies plug into:
- * a new body is a record + (at most) one new geometry branch — see the
- * minor-body placeholder note in geometry.cjs (Phase 18 perturbation
- * types land the same way).
+ * engines keep their existing direct call sites, and the runtime channels
+ * stay direct module calls because they consume engine-owned state (scene
+ * JD, epoch machinery, fitted tables). What this factory adds is the seam
+ * future bodies plug into: a new body is a record + (at most) one new
+ * geometry branch — see the minor-body placeholder note in geometry.cjs
+ * (Phase 18 perturbation types land the same way).
  *
- * Guard semantics mirror tools/lib/constants.js verbatim: the law steps
- * run only where the record carries the required fields (fibonacciD +
- * mass fraction for the ψ/K families, perihelion + axial periods for
- * wobble); geometry runs for every body. The identity gate
+ * Geometry runs for every body. The identity gate
  * (test/planet-model-identity.test.mjs) holds this factory bit-exact
  * against the shipped Node derivation.
  */
@@ -34,7 +32,6 @@
 'use strict';
 
 const { derivePlanetGeometry } = require('./geometry.cjs');
-const FL = require('./fibonacci-laws.cjs');
 
 /**
  * @typedef {Object} PlanetModelBody
@@ -66,21 +63,12 @@ const FL = require('./fibonacci-laws.cjs');
  * @property {number} currentAUDistanceKm
  * @property {number} earthEccentricityJ2000
  * @property {number} earthPerihelionLongitudeJ2000Deg
- * @property {{ earthInvPlaneInclinationAmplitude: number,
- *   massEarthAlone: number, massSun: number,
- *   eccentricityAmplitude: number, earthTiltMeanDeg: number }} calibration
- * @property {Record<string, number>} massFractions
  */
 
 /**
  * @typedef {Object} PlanetModelRecord
- * @property {number} [invPlaneInclinationAmplitude]
- * @property {number} [invPlaneInclinationMean]
  * @property {number} [wobblePeriodYears]
  * @property {number} [obliquityMeanDeg]
- * @property {number} [eccentricityAmplitude]
- * @property {number} [eccentricityBase]
- * @property {number} [eccentricityPhaseJ2000Deg]
  * @property {ReturnType<typeof derivePlanetGeometry>} geometry
  */
 
@@ -91,25 +79,13 @@ const FL = require('./fibonacci-laws.cjs');
  * @param {Record<string, PlanetModelBody>} bodies - keyed by body name
  *   (the key selects the body-unique geometry branches: mercury, pluto,
  *   halleys, ceres)
- * @returns {{ psiConstant: number, kConstant: number,
- *   eccentricityAnchor: number, t2000: number,
- *   bodies: Record<string, PlanetModelRecord> }}
+ * @returns {{ bodies: Record<string, PlanetModelRecord> }}
  */
 function createPlanetModel(env, bodies) {
-  const psiConstant = FL.computePsiConstant({
-    earthInvPlaneInclinationAmplitude: env.calibration.earthInvPlaneInclinationAmplitude,
-    massEarthAlone: env.calibration.massEarthAlone,
-    massSun: env.calibration.massSun,
-  });
-  const kConstant = FL.computeKConstant({
-    eccentricityAmplitude: env.calibration.eccentricityAmplitude,
-    massEarthAlone: env.calibration.massEarthAlone,
-    massSun: env.calibration.massSun,
-    earthTiltMeanDeg: env.calibration.earthTiltMeanDeg,
-  });
-  // Anchor = balancedYear − systemResetN·H (n=7: the System Reset state).
-  const eccentricityAnchor = env.balancedYear - env.systemResetN * env.holisticYears;
-  const t2000 = 2000 - eccentricityAnchor;
+  // Plan 07 R6: kConstant, the System-Reset eccentricityAnchor
+  // (balancedYear − systemResetN·H) and the t2000 phase it fed went with the
+  // eccentricity law; plan 07 R5: psiConstant (ψ = 3·A_earth·√(m_E/m_☉),
+  // from env.calibration) went with the inclination law.
 
   const geomEnv = {
     holisticYears: env.holisticYears,
@@ -122,22 +98,9 @@ function createPlanetModel(env, bodies) {
   /** @type {Record<string, PlanetModelRecord>} */
   const out = {};
   for (const [key, b] of Object.entries(bodies)) {
-    const massFrac = env.massFractions[key];
     /** @type {PlanetModelRecord} */
     const rec = /** @type {PlanetModelRecord} */ ({});
 
-    if (b.fibonacciD && massFrac && b.invPlaneInclinationJ2000 !== undefined) {
-      const il = FL.computeInclinationLaw({
-        fibonacciD: b.fibonacciD, massFrac,
-        invPlaneInclinationJ2000: b.invPlaneInclinationJ2000,
-        longitudePerihelion: /** @type {number} */ (b.longitudePerihelion),
-        inclinationCycleAnchor: /** @type {number} */ (b.inclinationCycleAnchor),
-        antiPhase: /** @type {boolean} */ (b.antiPhase),
-      }, psiConstant);
-      rec.invPlaneInclinationAmplitude = il.amplitude;
-      rec.invPlaneInclinationMean = il.mean;
-    }
-
     // Plan 06 Phase 7 commit 2: the K law's cycle period and obliquity input
     // are INPUTS of the record now — the chain's own g-mode beat
     // (keplerian-chain computeSecularShape) and the derived J2000 obliquity
@@ -146,27 +109,18 @@ function createPlanetModel(env, bodies) {
     if (b.wobblePeriodYears !== undefined) rec.wobblePeriodYears = b.wobblePeriodYears;
     if (b.obliquityMeanDeg !== undefined) rec.obliquityMeanDeg = b.obliquityMeanDeg;
 
-    if (b.fibonacciD && massFrac) {
-      const el = FL.computeEccentricityLaw({
-        fibonacciD: b.fibonacciD, massFrac,
-        solarYearInput: b.solarYearInput,
-        orbitalEccentricityJ2000: /** @type {number} */ (b.orbitalEccentricityJ2000),
-        antiPhase: /** @type {boolean} */ (b.antiPhase),
-      }, {
-        kConstant, obliquityMeanDeg: /** @type {number} */ (rec.obliquityMeanDeg),
-        wobblePeriodYears: /** @type {number} */ (rec.wobblePeriodYears), t2000,
-        meanSolarYearDays: env.meanSolarYearDays,
-      });
-      rec.eccentricityAmplitude = el.amplitude;
-      rec.eccentricityBase = el.base;
-      rec.eccentricityPhaseJ2000Deg = el.phaseJ2000;
-    }
+    // Plan 07 R6: the K law's eccentricityAmplitude / eccentricityBase /
+    // eccentricityPhaseJ2000Deg stood here. With the law gone, the ellipse
+    // geometry below reads the OBSERVED J2000 eccentricity where it used to
+    // read the law's System-Reset base — the observation the chain is
+    // anchored on, not a construction. The stored base survives only for the
+    // additional bodies, which carry theirs in model-parameters.json.
 
     rec.geometry = derivePlanetGeometry({
       key, type: b.type,
       solarYearInput: b.solarYearInput,
-      orbitalEccentricityBase: rec.eccentricityBase !== undefined
-        ? rec.eccentricityBase : b.orbitalEccentricityBase,
+      orbitalEccentricityBase: b.orbitalEccentricityBase !== undefined
+        ? b.orbitalEccentricityBase : b.orbitalEccentricityJ2000,
       longitudePerihelion: b.longitudePerihelion,
       ascendingNode: b.ascendingNode,
       rotationPeriodDays: b.rotationPeriodDays,
@@ -176,7 +130,7 @@ function createPlanetModel(env, bodies) {
     out[key] = rec;
   }
 
-  return { psiConstant, kConstant, eccentricityAnchor, t2000, bodies: out };
+  return { bodies: out };
 }
 
 module.exports = { createPlanetModel };

package/types/index.d.ts

@@ -12,9 +12,6 @@ export { createMoonArguments } from "./moon/arguments.cjs";
 export { createMoonSeries } from "./moon/series.cjs";
 export { createMoonApparent } from "./moon/apparent.cjs";
 export { derivePlanetGeometry } from "./planets/geometry.cjs";
-export * as planetFibonacciLaws from "./planets/fibonacci-laws.cjs";
-export * as planetOrientation from "./planets/orientation.cjs";
-export { integrateAscendingNode } from "./planets/asc-node-integrator.cjs";
 export * as planetOrbitChain from "./planets/orbit-chain.cjs";
 export { computeSecularShape } from "./planets/secular-shape.cjs";
 export { createSecularSeriesOverride } from "./planets/secular-series.cjs";

package/types/planets/model.d.cts

@@ -37,23 +37,10 @@ export type PlanetModelEnv = {
     currentAUDistanceKm: number;
     earthEccentricityJ2000: number;
     earthPerihelionLongitudeJ2000Deg: number;
-    calibration: {
-        earthInvPlaneInclinationAmplitude: number;
-        massEarthAlone: number;
-        massSun: number;
-        eccentricityAmplitude: number;
-        earthTiltMeanDeg: number;
-    };
-    massFractions: Record<string, number>;
 };
 export type PlanetModelRecord = {
-    invPlaneInclinationAmplitude?: number | undefined;
-    invPlaneInclinationMean?: number | undefined;
     wobblePeriodYears?: number | undefined;
     obliquityMeanDeg?: number | undefined;
-    eccentricityAmplitude?: number | undefined;
-    eccentricityBase?: number | undefined;
-    eccentricityPhaseJ2000Deg?: number | undefined;
     geometry: ReturnType<typeof derivePlanetGeometry>;
 };
 /**
@@ -85,20 +72,11 @@ export type PlanetModelRecord = {
  * @property {number} currentAUDistanceKm
  * @property {number} earthEccentricityJ2000
  * @property {number} earthPerihelionLongitudeJ2000Deg
- * @property {{ earthInvPlaneInclinationAmplitude: number,
- *   massEarthAlone: number, massSun: number,
- *   eccentricityAmplitude: number, earthTiltMeanDeg: number }} calibration
- * @property {Record<string, number>} massFractions
  */
 /**
  * @typedef {Object} PlanetModelRecord
- * @property {number} [invPlaneInclinationAmplitude]
- * @property {number} [invPlaneInclinationMean]
  * @property {number} [wobblePeriodYears]
  * @property {number} [obliquityMeanDeg]
- * @property {number} [eccentricityAmplitude]
- * @property {number} [eccentricityBase]
- * @property {number} [eccentricityPhaseJ2000Deg]
  * @property {ReturnType<typeof derivePlanetGeometry>} geometry
  */
 /**
@@ -108,15 +86,9 @@ export type PlanetModelRecord = {
  * @param {Record<string, PlanetModelBody>} bodies - keyed by body name
  *   (the key selects the body-unique geometry branches: mercury, pluto,
  *   halleys, ceres)
- * @returns {{ psiConstant: number, kConstant: number,
- *   eccentricityAnchor: number, t2000: number,
- *   bodies: Record<string, PlanetModelRecord> }}
+ * @returns {{ bodies: Record<string, PlanetModelRecord> }}
  */
 export function createPlanetModel(env: PlanetModelEnv, bodies: Record<string, PlanetModelBody>): {
-    psiConstant: number;
-    kConstant: number;
-    eccentricityAnchor: number;
-    t2000: number;
     bodies: Record<string, PlanetModelRecord>;
 };
 import { derivePlanetGeometry } from "./geometry.cjs";

package/src/planets/asc-node-integrator.cjs

@@ -1,120 +0,0 @@
-/**
- * Dynamic ascending node — rate-based segment integration (Phase 8.3, L5).
- *
- * dΩ/dε = −sin(Ω)/tan(i), integrated over obliquity change with segment
- * handling at obliquity extrema and Earth-inclination crossovers (the
- * inclination DIRECTION flips the sign of the effect per segment).
- *
- * Extracted from tools/lib/orbital-engine.js
- * calculateDynamicAscendingNodeFromTilts (itself the mirror of the
- * browser's 6-arg variant — S-P5). The BROWSER variant remains engine-side
- * this slice: neither copy is fixture-pinned, so the signature unification
- * is deferred to the factory pass, WITH probes first (recorded follow-up).
- *
- * §2h BOUNDARY: this module takes {ascendingNodeDeg, inclinationDeg} — the
- * Tychosium `orbitTilta/orbitTiltb` scheme names never enter the package;
- * the engines own the atan2/hypot decomposition at their edge.
- *
- * All time-dependent inputs are INJECTED per call: the engine's obliquity
- * and Earth-inclination evaluators, the precomputed obliquity-extrema
- * lookup, the inclination-crossing finder, and (optionally) the per-planet
- * dynamic ecliptic inclination.
- */
-
-'use strict';
-
-/**
- * @param {{ ascendingNodeDeg: number, inclinationDeg: number }} tilt —
- *   static node and inclination (engine-decomposed from its scene scheme)
- * @param {number} currentYear
- * @param {{
- *   obliquityAt: (year: number) => number,
- *   earthInclinationAt: (year: number) => number,
- *   obliquityExtremaInRange: (yearMin: number, yearMax: number) => number[],
- *   inclinationCrossingsInRange: (inclinationDeg: number, yearMin: number, yearMax: number) => number[],
- *   eclipticInclinationAt: ((year: number) => number) | null,
- *   earthInclinationMeanDeg: number,
- *   earthInclinationAmplitudeDeg: number,
- *   epochYear?: number,
- * }} deps — eclipticInclinationAt non-null enables the dynamic-inclination
- *   crossover search and per-segment rates (the planetName path).
- * @returns {number} dynamic ascending node longitude, degrees 0–360
- */
-function integrateAscendingNode(tilt, currentYear, deps) {
-  const DEG2RAD = Math.PI / 180;
-  const RAD2DEG = 180 / Math.PI;
-
-  const staticOmega = ((tilt.ascendingNodeDeg % 360) + 360) % 360;
-  const planetInclination = tilt.inclinationDeg;
-
-  if (planetInclination < 1e-6) return staticOmega;
-
-  const i = planetInclination * DEG2RAD;
-  const OmegaRad = staticOmega * DEG2RAD;
-  const tanI = Math.tan(i);
-  if (Math.abs(tanI) < 1e-10) return staticOmega;
-
-  const sinOmega = Math.sin(OmegaRad);
-  const EPOCH_YEAR = deps.epochYear !== undefined ? deps.epochYear : 2000;
-
-  /** @param {number} fromYear @param {number} toYear @returns {number} */
-  const integrateEffect = (fromYear, toYear) => {
-    if (Math.abs(toYear - fromYear) < 0.1) return 0;
-
-    const yearMin = Math.min(fromYear, toYear);
-    const yearMax = Math.max(fromYear, toYear);
-    const dir = toYear >= fromYear ? 1 : -1;   // integration direction — signs the total
-
-    /** @type {number[]} */
-    let criticalYears = [yearMin, yearMax];
-
-    criticalYears.push(...deps.obliquityExtremaInRange(yearMin, yearMax));
-
-    // Find ALL inclination crossings
-    const minEarthIncl = deps.earthInclinationMeanDeg - deps.earthInclinationAmplitudeDeg;
-    const maxEarthIncl = deps.earthInclinationMeanDeg + deps.earthInclinationAmplitudeDeg;
-
-    // With a dynamic ecliptic inclination the planet can enter Earth's range
-    // even if the static value is outside — always search for crossovers.
-    if (deps.eclipticInclinationAt || (planetInclination >= minEarthIncl && planetInclination <= maxEarthIncl)) {
-      const crossIncl = deps.eclipticInclinationAt
-        ? deps.eclipticInclinationAt((yearMin + yearMax) / 2)
-        : planetInclination;
-      criticalYears.push(...deps.inclinationCrossingsInRange(crossIncl, yearMin, yearMax));
-    }
-
-    criticalYears = [...new Set(criticalYears)].sort((a, b) => a - b);
-
-    // Integrate over segments
-    let effect = 0;
-    for (let idx = 0; idx < criticalYears.length - 1; idx++) {
-      const segStart = criticalYears[idx];
-      const segEnd = criticalYears[idx + 1];
-
-      const oblStart = deps.obliquityAt(segStart);
-      const oblEnd = deps.obliquityAt(segEnd);
-      const deltaObl = (oblEnd - oblStart) * DEG2RAD;
-
-      const midYear = (segStart + segEnd) / 2;
-      const earthInclAtMid = deps.earthInclinationAt(midYear);
-
-      const dynIncl = deps.eclipticInclinationAt
-        ? deps.eclipticInclinationAt(midYear)
-        : planetInclination;
-      const inclDirection = earthInclAtMid > dynIncl ? 1 : -1;
-      const dynTanI = Math.tan(dynIncl * DEG2RAD);
-      if (Math.abs(dynTanI) < 1e-10) continue; // skip near-zero inclination
-      const segRate = -sinOmega / dynTanI;
-
-      effect += segRate * inclDirection * deltaObl * RAD2DEG;
-    }
-    return effect * dir;
-  };
-
-  const effectFromEpoch = integrateEffect(EPOCH_YEAR, currentYear);
-
-  const newOmega = staticOmega + effectFromEpoch;
-  return ((newOmega % 360) + 360) % 360;
-}
-
-module.exports = { integrateAscendingNode };

package/src/planets/fibonacci-laws.cjs

@@ -1,108 +0,0 @@
-/**
- * The ψ/K amplitude relations + the retired law-loop constructions —
- * THE shared implementation (Phase 8.3, layer L2). Status per relation
- * (doc 10 "The Six Fibonacci Relations"; the restatement: the N-body
- * chain is the planet path):
- *  - ψ (computePsiConstant/computeInclinationLaw) and K (computeKConstant/
- *    computeEccentricityLaw's amplitude) are OPEN PREDICTIONS — untested
- *    empirical amplitude laws, derived from Earth alone, kept as stated.
- *  - The wobble beat (computeWobblePeriodYears) is kinematic frame
- *    arithmetic — the permanent class.
- *  - The obliquity-mean snapshot and the eccentricity base/phase
- *    (System-Reset construction) belong to the RETIRED law framework —
- *    today serving the legacy scene scaffolding, the no-chain bodies
- *    (Pluto/Halley/Eros) and the o.fib* diagnostics (doc 72 — the closed
- *    loop; docs/37 is archived, see docs/retired-record.md).
- *
- * Extracted VERBATIM in the BROWSER's expression forms from src/script.js
- * (the ψ loop, calcWobblePeriod, the obliquity-cycle aliases,
- * calcObliquityMean's load-time snapshot branch, the K loop), which
- * tools/lib/constants.js + constants/utils.js hand-mirrored with last-ulp
- * operation-order variants (measured: 32/42 law outputs bit-exact, 10 at
- * the 1e-11..1e-15 relative class) — those variants dissolve here.
- *
- * LOAD-BEARING conventions:
- *  - ψ = 3·A_earth·√(M_EARTH_ALONE/M_SUN): the ALONE/SYSTEM mass asymmetry
- *    is calibration convention (doc 24) — switching Earth to SYSTEM shifts
- *    ψ by 0.612% and would require re-calibrating A_earth.
- *  - Wobble = beat of |axial| and |ICRF| RATES (sign-free — Venus's
- *    prograde-axial/retrograde-ICRF case); |axial| > 8H ⇒ frozen ⇒
- *    wobble = |ICRF| exactly.
- *  - The obliquity-mean law here is the SNAPSHOT form (the browser's
- *    module-load TDZ fallback — the value both engines actually ship at
- *    load); the browser's runtime integrated path stays engine-side with
- *    its Phase-8 anchors. Note it uses 1/(H/13), where the runtime
- *    integrated form uses 13/H — historical operation orders, preserved.
- *  - K-law phase offset: 90° in-phase, 270° anti-phase (Saturn) — the n=7
- *    System Reset state (all planets at mean e, Saturn falling).
- *  - The Node mirror carried an `else` branch for bodies without a wobble
- *    period — DEAD code (the loop is fibonacciD-guarded and all seven
- *    carriers have wobble periods); dropped here, recorded in the commit.
- */
-
-'use strict';
-
-/**
- * ψ constant from Earth's calibration. @param {{
- *   earthInvPlaneInclinationAmplitude: number,
- *   massEarthAlone: number, massSun: number }} c @returns {number} */
-function computePsiConstant(c) {
-  return 3 * c.earthInvPlaneInclinationAmplitude * Math.sqrt(c.massEarthAlone / c.massSun);
-}
-
-/**
- * ψ law: invariable-plane inclination amplitude and mean.
- * @param {{ fibonacciD: number, massFrac: number,
- *   invPlaneInclinationJ2000: number, longitudePerihelion: number,
- *   inclinationCycleAnchor: number, antiPhase: boolean }} b
- * @param {number} psiConstant
- * @returns {{ amplitude: number, mean: number }} */
-function computeInclinationLaw(b, psiConstant) {
-  const amplitude = psiConstant / (b.fibonacciD * Math.sqrt(b.massFrac));
-  const antiPhase = b.antiPhase ? -1 : 1;
-  const mean = b.invPlaneInclinationJ2000
-    - antiPhase * amplitude * Math.cos((b.longitudePerihelion - b.inclinationCycleAnchor) * Math.PI / 180);
-  return { amplitude, mean };
-}
-
-// (The device's wobble beat of integer axial and obliquity fractions, the
-// Venus/Neptune |ICRF| obliquity-cycle fallback and the snapshot "mean
-// obliquity" left with plan 06 Phase 7 commit 2: the K law's cycle period is
-// the chain's own g-mode beat (keplerian-chain computeSecularShape) and its
-// obliquity input the derived J2000 obliquity (spin-channel
-// computeObliquityJ2000Deg). docs/retired-record.md carries the record.)
-
-/**
- * K constant from Earth's calibration. @param {{
- *   eccentricityAmplitude: number, massEarthAlone: number, massSun: number,
- *   earthTiltMeanDeg: number }} c @returns {number} */
-function computeKConstant(c) {
-  return c.eccentricityAmplitude * Math.sqrt(c.massEarthAlone / c.massSun)
-    / (Math.sin(c.earthTiltMeanDeg * Math.PI / 180) * Math.sqrt(3));
-}
-
-/**
- * K law: eccentricity amplitude, base and J2000 phase.
- * @param {{ fibonacciD: number, massFrac: number, solarYearInput: number,
- *   orbitalEccentricityJ2000: number, antiPhase: boolean }} b
- * @param {{ kConstant: number, obliquityMeanDeg: number,
- *   wobblePeriodYears: number, t2000: number, meanSolarYearDays: number }} env
- * @returns {{ amplitude: number, base: number, phaseJ2000: number }} */
-function computeEccentricityLaw(b, env) {
-  const a = Math.pow(b.solarYearInput / env.meanSolarYearDays, 2 / 3);
-  const amplitude = env.kConstant * Math.sin(Math.abs(env.obliquityMeanDeg) * Math.PI / 180) * Math.sqrt(b.fibonacciD)
-    / (Math.sqrt(b.massFrac) * Math.pow(a, 1.5));
-  const eJ2000 = b.orbitalEccentricityJ2000;
-  const phaseOffset = b.antiPhase ? 270 : 90;
-  const phaseDeg = (env.t2000 / env.wobblePeriodYears) * 360 + phaseOffset;
-  const cosTheta = Math.cos(phaseDeg * Math.PI / 180);
-  const sinTheta = Math.sin(phaseDeg * Math.PI / 180);
-  const disc = eJ2000 * eJ2000 - amplitude * amplitude * sinTheta * sinTheta;
-  const base = amplitude * cosTheta + Math.sqrt(Math.max(0, disc));
-  return { amplitude, base, phaseJ2000: ((phaseDeg % 360) + 360) % 360 };
-}
-
-module.exports = {
-  computePsiConstant, computeInclinationLaw,
-  computeKConstant, computeEccentricityLaw,
-};

package/src/planets/orientation.cjs

@@ -1,142 +0,0 @@
-/**
- * Planet orientation channel — THE shared implementation (Phase 8.3, L4):
- * invariable-plane inclination, ascending nodes, and the scene ecliptic
- * inclination (the balanced-year dot-product form canonicalized at S-P4).
- *
- * Time is EXPLICIT here (yearsSinceBalanced / calendar year). A finding
- * from extraction, preserved not fixed: the browser's
- * computePlanetInvPlaneInclinationDynamic(planet, currentYear) IGNORED its
- * currentYear parameter and read the live scene JD — the 8.3-0 fixtures
- * recorded identical values at every probed epoch. The browser wrapper
- * keeps that scene-coupling (visibly, at the wrapper); the Node engine
- * honors the year as before. Unifying them is a measured decision for the
- * factory layer, not a silent side effect.
- *
- * Two ascending-node conventions exist and BOTH are quantities (the S-P4
- * lesson): the year-2000-anchored linear node here
- * (ascendingNodeInvPlaneLinearAt — the node-integrator mirror)
- * and the balanced-year −8H/N node inside the scene tilt
- * (eclipticInclinationFromBalanced). Do not merge them.
- *
- * SCOPE SINCE v16.2 (owner-found audit): these record-based forms — the
- * planet record's linear lattice rates, the −8H/N node period, the
- * balanced-year inclination oscillation — are the RETIRED device. They serve
- * the structural record and the browser's no-chain bodies (Pluto, Halley,
- * Eros) only. The seven planets' elements of date on every published surface
- * (the simulator, the API's /v1/bodies, the MCP essrt_bodies) ride the N-body
- * Keplerian chain with the series handover (model.js planetChainElementsAt;
- * src/script.js _kcElementsOfDate).
- */
-
-'use strict';
-
-/**
- * Invariable-plane inclination at explicit time (browser form): the ICRF
- * perihelion-linked oscillation i(t) = mean + s·A·cos(ϖ_ICRF(t) − anchor).
- * @param {{ key?: string, isEarth?: boolean,
- *   invPlaneInclinationJ2000: number, invPlaneInclinationMean: number,
- *   invPlaneInclinationAmplitude: number, inclinationCycleAnchor: number,
- *   longitudePerihelion: number, perihelionEclipticYears: number,
- *   antiPhase?: boolean }} body
- * @param {number} yearsSinceBalanced
- * @param {{ H: number, yearsFromBalancedToJ2000: number }} env
- * @returns {number} degrees */
-function invPlaneInclinationAt(body, yearsSinceBalanced, env) {
-  const iJ2000 = body.invPlaneInclinationJ2000;
-  const amplitude = body.invPlaneInclinationAmplitude;
-  if (iJ2000 === undefined || amplitude === undefined) return iJ2000 || 0;
-  if (amplitude === 0) return iJ2000;
-
-  // ICRF period: Earth = H/3 directly; others = 1/(1/eclP − 1/(H/13)).
-  const genPrecRate = 1 / (env.H / 13);
-  const icrfPeriod = body.isEarth
-    ? env.H / 3
-    : 1 / (1 / body.perihelionEclipticYears - genPrecRate);
-  const icrfRate = 360 / icrfPeriod;
-
-  const periAtBalanced = body.longitudePerihelion - icrfRate * env.yearsFromBalancedToJ2000;
-  const periCurrent = periAtBalanced + icrfRate * yearsSinceBalanced;
-  const currentPhaseRad = (periCurrent - body.inclinationCycleAnchor) * Math.PI / 180;
-  const antiPhaseSign = body.antiPhase ? -1 : 1;
-  return body.invPlaneInclinationMean + antiPhaseSign * amplitude * Math.cos(currentPhaseRad);
-}
-
-/**
- * Ascending node on the invariable plane — the LINEAR year-2000-anchored
- * convention (node-integrator; see the header).
- * @param {{ ascendingNodeInvPlane?: number, ascendingNodePeriod?: number,
- *   perihelionEclipticYears: number }} body
- * @param {number} year @returns {number} degrees 0–360 */
-function ascendingNodeInvPlaneLinearAt(body, year) {
-  if (!body.ascendingNodeInvPlane) return 0;
-  const period = body.ascendingNodePeriod || body.perihelionEclipticYears;
-  const rate = 360 / period;
-  return ((body.ascendingNodeInvPlane + rate * (year - 2000)) % 360 + 360) % 360;
-}
-
-/**
- * Scene ecliptic inclination — normal-vector dot product, balanced-year
- * anchoring, planet Ω on the −8H/N assignment (canonicalized at S-P4; the
- * mirror of src/script.js updateDynamicInclinations).
- * @param {{ perihelionEclipticYears: number, longitudePerihelion: number,
- *   inclinationCycleAnchor: number, antiPhase?: boolean,
- *   invPlaneInclinationMean: number, invPlaneInclinationAmplitude: number,
- *   ascendingNodeInvPlane: number, ascendingNodeCyclesIn8H?: number }} body
- * @param {{ invPlanePrecessionYears: number, inclinationMean: number,
- *   inclinationAmplitude: number, ascendingNodeInvPlane: number }} earth
- * @param {number} yearsSinceBalanced
- * @param {{ H: number, yearsFromBalancedToJ2000: number }} env
- * @returns {number} degrees */
-function eclipticInclinationFromBalanced(body, earth, yearsSinceBalanced, env) {
-  const d2r = Math.PI / 180;
-  const genPrecRate = 1 / (env.H / 13);
-
-  // --- Earth's orbital plane ---
-  const earthPhaseRad = (yearsSinceBalanced / earth.invPlanePrecessionYears) * 2 * Math.PI;
-  const earthI = (earth.inclinationMean
-    - earth.inclinationAmplitude * Math.cos(earthPhaseRad)) * d2r;
-
-  // Earth Ω regresses at -H/5 (ecliptic precession rate), NOT at H/3.
-  const earthAscNodePeriod = -env.H / 5;
-  const earthOmegaRate = 360 / earthAscNodePeriod;
-  const earthOmega = (earth.ascendingNodeInvPlane
-    - earthOmegaRate * env.yearsFromBalancedToJ2000
-    + earthOmegaRate * yearsSinceBalanced) * d2r;
-
-  // --- Planet's orbital plane ---
-  const eclRate = 1 / body.perihelionEclipticYears;
-  const icrfRate = (eclRate - genPrecRate) * 360;  // deg/yr
-  const periICRFDeg = body.longitudePerihelion
-    - icrfRate * env.yearsFromBalancedToJ2000
-    + icrfRate * yearsSinceBalanced;
-
-  const planetPhaseDeg = periICRFDeg - body.inclinationCycleAnchor;
-  const antiPhaseSign = body.antiPhase ? -1 : 1;
-  const planetI = (body.invPlaneInclinationMean
-    + antiPhaseSign * body.invPlaneInclinationAmplitude * Math.cos(planetPhaseDeg * d2r)) * d2r;
-
-  // Planet Ω advances at the asc-node period (-8H/N), NOT the ecliptic
-  // perihelion period — they are different angles.
-  const planetAscNodePeriod = body.ascendingNodeCyclesIn8H
-    ? -(8 * env.H) / body.ascendingNodeCyclesIn8H
-    : body.perihelionEclipticYears;
-  const planetOmegaRate = 360 / planetAscNodePeriod;
-  const planetOmegaDeg = body.ascendingNodeInvPlane
-    - planetOmegaRate * env.yearsFromBalancedToJ2000
-    + planetOmegaRate * yearsSinceBalanced;
-  const planetOmega = planetOmegaDeg * d2r;
-
-  // --- Dot product of normal vectors → angle between orbital planes ---
-  const eNx = Math.sin(earthI) * Math.sin(earthOmega);
-  const eNy = Math.sin(earthI) * Math.cos(earthOmega);
-  const eNz = Math.cos(earthI);
-
-  const pNx = Math.sin(planetI) * Math.sin(planetOmega);
-  const pNy = Math.sin(planetI) * Math.cos(planetOmega);
-  const pNz = Math.cos(planetI);
-
-  const cosAngle = eNx * pNx + eNy * pNy + eNz * pNz;
-  return Math.acos(Math.max(-1, Math.min(1, cosAngle))) * (180 / Math.PI);
-}
-
-module.exports = { invPlaneInclinationAt, ascendingNodeInvPlaneLinearAt, eclipticInclinationFromBalanced };

package/types/planets/asc-node-integrator.d.cts

@@ -1,30 +0,0 @@
-/**
- * @param {{ ascendingNodeDeg: number, inclinationDeg: number }} tilt —
- *   static node and inclination (engine-decomposed from its scene scheme)
- * @param {number} currentYear
- * @param {{
- *   obliquityAt: (year: number) => number,
- *   earthInclinationAt: (year: number) => number,
- *   obliquityExtremaInRange: (yearMin: number, yearMax: number) => number[],
- *   inclinationCrossingsInRange: (inclinationDeg: number, yearMin: number, yearMax: number) => number[],
- *   eclipticInclinationAt: ((year: number) => number) | null,
- *   earthInclinationMeanDeg: number,
- *   earthInclinationAmplitudeDeg: number,
- *   epochYear?: number,
- * }} deps — eclipticInclinationAt non-null enables the dynamic-inclination
- *   crossover search and per-segment rates (the planetName path).
- * @returns {number} dynamic ascending node longitude, degrees 0–360
- */
-export function integrateAscendingNode(tilt: {
-    ascendingNodeDeg: number;
-    inclinationDeg: number;
-}, currentYear: number, deps: {
-    obliquityAt: (year: number) => number;
-    earthInclinationAt: (year: number) => number;
-    obliquityExtremaInRange: (yearMin: number, yearMax: number) => number[];
-    inclinationCrossingsInRange: (inclinationDeg: number, yearMin: number, yearMax: number) => number[];
-    eclipticInclinationAt: ((year: number) => number) | null;
-    earthInclinationMeanDeg: number;
-    earthInclinationAmplitudeDeg: number;
-    epochYear?: number;
-}): number;

package/types/planets/fibonacci-laws.d.cts

@@ -1,61 +0,0 @@
-/**
- * ψ constant from Earth's calibration. @param {{
- *   earthInvPlaneInclinationAmplitude: number,
- *   massEarthAlone: number, massSun: number }} c @returns {number} */
-export function computePsiConstant(c: {
-    earthInvPlaneInclinationAmplitude: number;
-    massEarthAlone: number;
-    massSun: number;
-}): number;
-/**
- * ψ law: invariable-plane inclination amplitude and mean.
- * @param {{ fibonacciD: number, massFrac: number,
- *   invPlaneInclinationJ2000: number, longitudePerihelion: number,
- *   inclinationCycleAnchor: number, antiPhase: boolean }} b
- * @param {number} psiConstant
- * @returns {{ amplitude: number, mean: number }} */
-export function computeInclinationLaw(b: {
-    fibonacciD: number;
-    massFrac: number;
-    invPlaneInclinationJ2000: number;
-    longitudePerihelion: number;
-    inclinationCycleAnchor: number;
-    antiPhase: boolean;
-}, psiConstant: number): {
-    amplitude: number;
-    mean: number;
-};
-/**
- * K constant from Earth's calibration. @param {{
- *   eccentricityAmplitude: number, massEarthAlone: number, massSun: number,
- *   earthTiltMeanDeg: number }} c @returns {number} */
-export function computeKConstant(c: {
-    eccentricityAmplitude: number;
-    massEarthAlone: number;
-    massSun: number;
-    earthTiltMeanDeg: number;
-}): number;
-/**
- * K law: eccentricity amplitude, base and J2000 phase.
- * @param {{ fibonacciD: number, massFrac: number, solarYearInput: number,
- *   orbitalEccentricityJ2000: number, antiPhase: boolean }} b
- * @param {{ kConstant: number, obliquityMeanDeg: number,
- *   wobblePeriodYears: number, t2000: number, meanSolarYearDays: number }} env
- * @returns {{ amplitude: number, base: number, phaseJ2000: number }} */
-export function computeEccentricityLaw(b: {
-    fibonacciD: number;
-    massFrac: number;
-    solarYearInput: number;
-    orbitalEccentricityJ2000: number;
-    antiPhase: boolean;
-}, env: {
-    kConstant: number;
-    obliquityMeanDeg: number;
-    wobblePeriodYears: number;
-    t2000: number;
-    meanSolarYearDays: number;
-}): {
-    amplitude: number;
-    base: number;
-    phaseJ2000: number;
-};

package/types/planets/orientation.d.cts

@@ -1,67 +0,0 @@
-/**
- * Invariable-plane inclination at explicit time (browser form): the ICRF
- * perihelion-linked oscillation i(t) = mean + s·A·cos(ϖ_ICRF(t) − anchor).
- * @param {{ key?: string, isEarth?: boolean,
- *   invPlaneInclinationJ2000: number, invPlaneInclinationMean: number,
- *   invPlaneInclinationAmplitude: number, inclinationCycleAnchor: number,
- *   longitudePerihelion: number, perihelionEclipticYears: number,
- *   antiPhase?: boolean }} body
- * @param {number} yearsSinceBalanced
- * @param {{ H: number, yearsFromBalancedToJ2000: number }} env
- * @returns {number} degrees */
-export function invPlaneInclinationAt(body: {
-    key?: string;
-    isEarth?: boolean;
-    invPlaneInclinationJ2000: number;
-    invPlaneInclinationMean: number;
-    invPlaneInclinationAmplitude: number;
-    inclinationCycleAnchor: number;
-    longitudePerihelion: number;
-    perihelionEclipticYears: number;
-    antiPhase?: boolean;
-}, yearsSinceBalanced: number, env: {
-    H: number;
-    yearsFromBalancedToJ2000: number;
-}): number;
-/**
- * Ascending node on the invariable plane — the LINEAR year-2000-anchored
- * convention (node-integrator; see the header).
- * @param {{ ascendingNodeInvPlane?: number, ascendingNodePeriod?: number,
- *   perihelionEclipticYears: number }} body
- * @param {number} year @returns {number} degrees 0–360 */
-export function ascendingNodeInvPlaneLinearAt(body: {
-    ascendingNodeInvPlane?: number;
-    ascendingNodePeriod?: number;
-    perihelionEclipticYears: number;
-}, year: number): number;
-/**
- * Scene ecliptic inclination — normal-vector dot product, balanced-year
- * anchoring, planet Ω on the −8H/N assignment (canonicalized at S-P4; the
- * mirror of src/script.js updateDynamicInclinations).
- * @param {{ perihelionEclipticYears: number, longitudePerihelion: number,
- *   inclinationCycleAnchor: number, antiPhase?: boolean,
- *   invPlaneInclinationMean: number, invPlaneInclinationAmplitude: number,
- *   ascendingNodeInvPlane: number, ascendingNodeCyclesIn8H?: number }} body
- * @param {{ invPlanePrecessionYears: number, inclinationMean: number,
- *   inclinationAmplitude: number, ascendingNodeInvPlane: number }} earth
- * @param {number} yearsSinceBalanced
- * @param {{ H: number, yearsFromBalancedToJ2000: number }} env
- * @returns {number} degrees */
-export function eclipticInclinationFromBalanced(body: {
-    perihelionEclipticYears: number;
-    longitudePerihelion: number;
-    inclinationCycleAnchor: number;
-    antiPhase?: boolean;
-    invPlaneInclinationMean: number;
-    invPlaneInclinationAmplitude: number;
-    ascendingNodeInvPlane: number;
-    ascendingNodeCyclesIn8H?: number;
-}, earth: {
-    invPlanePrecessionYears: number;
-    inclinationMean: number;
-    inclinationAmplitude: number;
-    ascendingNodeInvPlane: number;
-}, yearsSinceBalanced: number, env: {
-    H: number;
-    yearsFromBalancedToJ2000: number;
-}): number;