@essrt/physics 12.0.0 → 13.0.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@essrt/physics",
-  "version": "12.0.0",
+  "version": "13.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": "v17.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",

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 = "v17.0";
 
 /** Canonical preprint DOI — single source: public/input/model-version.json. */
 export const PREPRINT_DOI = "10.21203/rs.3.rs-8758810/v4";

package/src/model.js

@@ -97,12 +97,11 @@ 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;
+  // Plan 07 R6: `earthtiltMean` and `eccentricityAmplitude` were read here
+  // ONLY to invert the K constant from Earth's calibration. With the K law
+  // retired nothing in this module reads either — they remain on C.earth for
+  // the Earth-side devices (R9) and the registry.
   const earthInclMean = C.earthOrbital.earthInclinationJ2000_deg
     - earthInclAmplitude * Math.cos(((C.earthOrbital.earthPerihelionLongitudeJ2000
       - C.earthOrbital.earthInclinationCycleAnchor) * Math.PI) / 180);
@@ -722,14 +721,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     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. 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]);
@@ -763,20 +757,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       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,
@@ -793,15 +774,14 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       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 are gone,
+    // so what remains above is the ψ half (until R5) and the structural inputs.
+    // 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

package/src/planets/fibonacci-laws.cjs

@@ -72,37 +72,24 @@ function computeInclinationLaw(b, psiConstant) {
 // 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 };
-}
+// Plan 07 R6: computeKConstant and computeEccentricityLaw stood here — the
+// K relation (K = e_amp·√m·a^1.5 / (sin(tilt)·√d), inverted per planet) and
+// the System-Reset eccentricity construction it fed
+// (base = A·cosθ + √(e_J2000² − A²sin²θ) at the J2000 phase, θ measured on
+// the wobble beat with a 90°/270° anti-phase offset).
+//
+// They are DELETED, not reclassified. Measured first (plan 07 §9e): scaling
+// their outputs by 1.10 moved no scene position and no published record
+// field — both twins place planets from the N-body chain, which overwrites
+// the construction entirely — and the registry keys built on them had no
+// consumer in the docs, on the website or in the paper. The nine balance and
+// Fibonacci-law instruments that computed from them are retired with them;
+// docs/retired-record.md is the record.
+//
+// A planet's eccentricity of date now has one home: the chain
+// (`model.planets.eccentricity(k, year)`), and its long-term shape is the
+// chain's own g-mode structure.
 
 module.exports = {
   computePsiConstant, computeInclinationLaw,
-  computeKConstant, computeEccentricityLaw,
 };

package/src/planets/model.cjs

@@ -67,8 +67,7 @@ const FL = require('./fibonacci-laws.cjs');
  * @property {number} earthEccentricityJ2000
  * @property {number} earthPerihelionLongitudeJ2000Deg
  * @property {{ earthInvPlaneInclinationAmplitude: number,
- *   massEarthAlone: number, massSun: number,
- *   eccentricityAmplitude: number, earthTiltMeanDeg: number }} calibration
+ *   massEarthAlone: number, massSun: number }} calibration
  * @property {Record<string, number>} massFractions
  */
 
@@ -78,9 +77,6 @@ const FL = require('./fibonacci-laws.cjs');
  * @property {number} [invPlaneInclinationMean]
  * @property {number} [wobblePeriodYears]
  * @property {number} [obliquityMeanDeg]
- * @property {number} [eccentricityAmplitude]
- * @property {number} [eccentricityBase]
- * @property {number} [eccentricityPhaseJ2000Deg]
  * @property {ReturnType<typeof derivePlanetGeometry>} geometry
  */
 
@@ -91,8 +87,7 @@ 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,
+ * @returns {{ psiConstant: number,
  *   bodies: Record<string, PlanetModelRecord> }}
  */
 function createPlanetModel(env, bodies) {
@@ -101,15 +96,9 @@ function createPlanetModel(env, bodies) {
     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.
 
   const geomEnv = {
     holisticYears: env.holisticYears,
@@ -146,27 +135,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 +156,7 @@ function createPlanetModel(env, bodies) {
     out[key] = rec;
   }
 
-  return { psiConstant, kConstant, eccentricityAnchor, t2000, bodies: out };
+  return { psiConstant, bodies: out };
 }
 
 module.exports = { createPlanetModel };

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

@@ -25,37 +25,3 @@ export function computeInclinationLaw(b: {
     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/model.d.cts

@@ -41,8 +41,6 @@ export type PlanetModelEnv = {
         earthInvPlaneInclinationAmplitude: number;
         massEarthAlone: number;
         massSun: number;
-        eccentricityAmplitude: number;
-        earthTiltMeanDeg: number;
     };
     massFractions: Record<string, number>;
 };
@@ -51,9 +49,6 @@ export type PlanetModelRecord = {
     invPlaneInclinationMean?: number | undefined;
     wobblePeriodYears?: number | undefined;
     obliquityMeanDeg?: number | undefined;
-    eccentricityAmplitude?: number | undefined;
-    eccentricityBase?: number | undefined;
-    eccentricityPhaseJ2000Deg?: number | undefined;
     geometry: ReturnType<typeof derivePlanetGeometry>;
 };
 /**
@@ -86,8 +81,7 @@ export type PlanetModelRecord = {
  * @property {number} earthEccentricityJ2000
  * @property {number} earthPerihelionLongitudeJ2000Deg
  * @property {{ earthInvPlaneInclinationAmplitude: number,
- *   massEarthAlone: number, massSun: number,
- *   eccentricityAmplitude: number, earthTiltMeanDeg: number }} calibration
+ *   massEarthAlone: number, massSun: number }} calibration
  * @property {Record<string, number>} massFractions
  */
 /**
@@ -96,9 +90,6 @@ export type PlanetModelRecord = {
  * @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 +99,11 @@ 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,
+ * @returns {{ psiConstant: number,
  *   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";