@essrt/physics 1.0.0

package/src/planets/ecc-channel.cjs

@@ -0,0 +1,59 @@
+/**
+ * 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/planets/fibonacci-laws.cjs

@@ -0,0 +1,136 @@
+/**
+ * The Fibonacci Laws — THE shared implementation (Phase 8.3, layer L2).
+ *
+ * The scientific heart of the model: the closed derivation loop
+ *   ψ → inclination amplitude/mean → wobble period → obliquity mean →
+ *   K → eccentricity amplitude → phase → base
+ * that turns per-body Fibonacci divisors and mass fractions into every
+ * planet's inclination and eccentricity structure (docs/37, doc 99).
+ *
+ * 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 25) — 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 };
+}
+
+/**
+ * Wobble period: beat of axial precession and perihelion ICRF precession.
+ * @param {number} periEclYr @param {number} axialYr @param {number} H
+ * @returns {number} years */
+function computeWobblePeriodYears(periEclYr, axialYr, H) {
+  const H13 = H / 13;
+  const inclICRF = (periEclYr * H13) / (H13 - periEclYr);
+  if (Math.abs(axialYr) > 8 * H) return Math.abs(inclICRF);
+  const wobbleRate = Math.abs(1 / Math.abs(axialYr) - 1 / Math.abs(inclICRF));
+  return 1 / wobbleRate;
+}
+
+/**
+ * Obliquity cycle with the Venus/Neptune fallback: the record's cycle if
+ * present, else |ICRF| (tidally damped — the two-component obliquity
+ * formula cancels exactly, constant tilt).
+ * @param {number | null | undefined} obliquityCycleYears
+ * @param {number} periEclYr @param {number} H @returns {number} */
+function resolveObliquityCycleYears(obliquityCycleYears, periEclYr, H) {
+  if (obliquityCycleYears !== undefined && obliquityCycleYears !== null) return obliquityCycleYears;
+  return Math.abs(1 / (1 / periEclYr - 13 / H));
+}
+
+/**
+ * Mean obliquity, SNAPSHOT form (the load-time law both engines ship):
+ * mean = tiltJ2000 + amp·cos(ωᵢ·t₂₀₀₀) − amp·cos(ωₒ·t₂₀₀₀).
+ * @param {{ axialTiltJ2000: number, invPlaneInclinationAmplitude: number,
+ *   perihelionEclipticYears: number }} b
+ * @param {number | null | undefined} obliqCycleYears — falsy ⇒ static tilt
+ * @param {{ H: number, t2000: number }} env — t2000 = 2000 − eccentricity
+ *   anchor (balancedYear − systemResetN·H)
+ * @returns {number} degrees */
+function computeObliquityMeanSnapshot(b, obliqCycleYears, env) {
+  if (!obliqCycleYears) return b.axialTiltJ2000;
+  const amp = b.invPlaneInclinationAmplitude;
+  const genPrecRate = 1 / (env.H / 13);
+  const icrfPeriod = 1 / (1 / b.perihelionEclipticYears - genPrecRate);
+  return b.axialTiltJ2000 + amp * Math.cos(2 * Math.PI * env.t2000 / icrfPeriod)
+                          - amp * Math.cos(2 * Math.PI * env.t2000 / obliqCycleYears);
+}
+
+/**
+ * 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, computeWobblePeriodYears,
+  resolveObliquityCycleYears, computeObliquityMeanSnapshot,
+  computeKConstant, computeEccentricityLaw,
+};

package/src/planets/geometry.cjs

@@ -0,0 +1,145 @@
+/**
+ * Planet orbital geometry — THE shared implementation (Phase 8.3, layer L1).
+ *
+ * ONE law set, N body records: the derivation the browser hand-unrolled per
+ * planet (mercurySolarYearCount … halleysRotationPeriod, src/script.js
+ * ~2145–2237) and Node kept as computePlanetDerived/computeAdditionalDerived
+ * (tools/lib/constants.js). This file replaces all three copies with one
+ * type-branched function over a body record — the shape the model's claim
+ * has always had (six laws, per-body parameters).
+ *
+ * EXPRESSION FORMS ARE THE BROWSER'S (the certified engine) — e.g.
+ * `Math.round((H·mSY)/input)`, `((H/N)**2)**(1/3)` — so browser bit-identity
+ * holds by construction; Node's last-ulp variants dissolve here (the
+ * cardinal-extraction pattern).
+ *
+ * Type classification (the survey's measured taxonomy):
+ *  - Type I  (mercury, venus): peri = a·e_real·100, elip = peri/2
+ *  - Type II (mars, eros):     elip first, peri = a·e_base·100 + elip
+ *  - Type III (jupiter…neptune): elip = geocentric 2·e_E·100·sin(ϖ_E − ϖ_p)
+ *    — the only formula that reads Earth's elements; peri = e_real·a·100
+ *  - pluto:   peri = e_BASE·a·100 (raw base, no e_real), elip = peri/2
+ *  - halleys: elip = (e_base·a − e_real·a)·100, peri = e_real·a·2·100
+ *  - ceres:   orbitDistanceOverride, geometry-only (no ellipse family)
+ *  - mercury rotation: the 3:2 spin-orbit lock (period from N, not a
+ *    rotation input)
+ *
+ * Saturn's scene-side negation of elipticOrbit (antiPhase) is a SCENE
+ * convention and stays engine-side.
+ *
+ * MINOR-BODY TYPES ARE PLACEHOLDERS (model-parameters.json _typeNote): the
+ * small bodies borrow the planet taxonomy geometrically but are more
+ * susceptible to planetary gravity disturbances; a perturbation-aware
+ * type is expected from the Phase 18 refit. It lands as ONE new branch
+ * here + a JSON type flip per body — both engines pick it up automatically.
+ */
+
+'use strict';
+
+/**
+ * @typedef {{
+ *   key: string,
+ *   type?: string,
+ *   solarYearInput: number,
+ *   orbitalEccentricityBase?: number,
+ *   longitudePerihelion?: number,
+ *   ascendingNode?: number,
+ *   rotationPeriodDays?: number,
+ *   orbitDistanceOverride?: number,
+ * }} PlanetGeometryBody
+ */
+
+/**
+ * @param {PlanetGeometryBody} body
+ * @param {{
+ *   holisticYears: number,
+ *   meanSolarYearDays: number,
+ *   currentAUDistanceKm: number,
+ *   earthEccentricityJ2000: number,
+ *   earthPerihelionLongitudeJ2000Deg: number,
+ * }} env — the engine's J2000 values (browser passes its live globals at
+ *   load time, preserving its original initial-derivation semantics; the
+ *   epoch machinery that later mutates the browser's `let` aliases is
+ *   untouched by this layer).
+ * @returns {{
+ *   solarYearCount: number, orbitDistance: number, periodYears: number,
+ *   realOrbitalEccentricity: (number | undefined),
+ *   elipticOrbit: (number | undefined), perihelionDistance: (number | undefined),
+ *   speedKmh: number, rotationPeriodHours: (number | undefined),
+ *   eccentricityPerihelion: (number | undefined), lowestPoint: (number | undefined),
+ * }}
+ */
+function derivePlanetGeometry(body, env) {
+  const { key, type, solarYearInput, orbitalEccentricityBase: base,
+          longitudePerihelion, ascendingNode, rotationPeriodDays, orbitDistanceOverride } = body;
+  const { holisticYears: H, meanSolarYearDays: mSY, currentAUDistanceKm: AU,
+          earthEccentricityJ2000, earthPerihelionLongitudeJ2000Deg } = env;
+
+  const solarYearCount = Math.round((H * mSY) / solarYearInput);
+  const orbitDistance = orbitDistanceOverride !== undefined
+    ? orbitDistanceOverride
+    : ((H / solarYearCount) ** 2) ** (1 / 3);
+  const periodYears = H / solarYearCount;
+  const speedKmh = (orbitDistance * AU * Math.PI * 2) / (mSY * (H / solarYearCount)) / 24;
+
+  /** @type {number | undefined} */
+  let realOrbitalEccentricity;
+  /** @type {number | undefined} */
+  let elipticOrbit;
+  /** @type {number | undefined} */
+  let perihelionDistance;
+  /** @type {number | undefined} */
+  let eccentricityPerihelion;
+
+  if (key === 'ceres') {
+    // Geometry-only body — no ellipse family in either engine.
+  } else if (key === 'pluto') {
+    realOrbitalEccentricity = undefined;   // deliberately absent (raw base used)
+    perihelionDistance = /** @type {number} */ (base) * orbitDistance * 100;
+    elipticOrbit = perihelionDistance / 2;
+  } else if (key === 'halleys') {
+    const b = /** @type {number} */ (base);
+    realOrbitalEccentricity = b / (1 + b);
+    elipticOrbit = ((b * orbitDistance) - (realOrbitalEccentricity * orbitDistance)) * 100;
+    perihelionDistance = realOrbitalEccentricity * orbitDistance * 2 * 100;
+  } else if (type === 'I') {
+    const b = /** @type {number} */ (base);
+    realOrbitalEccentricity = b / (1 + b);
+    perihelionDistance = orbitDistance * realOrbitalEccentricity * 100;
+    elipticOrbit = perihelionDistance / 2;
+    eccentricityPerihelion = (perihelionDistance / 2) * b;
+  } else if (type === 'II') {
+    const b = /** @type {number} */ (base);
+    realOrbitalEccentricity = b / (1 + b);
+    elipticOrbit = ((realOrbitalEccentricity * orbitDistance) / 2) * 100
+                 + ((b * orbitDistance) - (realOrbitalEccentricity * orbitDistance)) * 100;
+    perihelionDistance = (orbitDistance * b * 100) + elipticOrbit;
+  } else if (type === 'III') {
+    const b = /** @type {number} */ (base);
+    realOrbitalEccentricity = b / (1 + b);
+    // Geocentric correction: Earth's eccentricity creates annual parallax
+    // variation ∝ sin(ϖ_Earth − ϖ_planet); factor 2 from off-centre geometry.
+    const dw = (earthPerihelionLongitudeJ2000Deg - /** @type {number} */ (longitudePerihelion)) * Math.PI / 180;
+    elipticOrbit = 2 * earthEccentricityJ2000 * 100 * Math.sin(dw);
+    perihelionDistance = realOrbitalEccentricity * orbitDistance * 100;
+  }
+
+  /** @type {number | undefined} */
+  let rotationPeriodHours;
+  if (key === 'mercury') {
+    // 3:2 spin-orbit lock — period from the orbit count itself.
+    rotationPeriodHours = 24 * (mSY * H) / (solarYearCount * 3 / 2);
+  } else if (rotationPeriodDays !== undefined) {
+    rotationPeriodHours = 24 * (mSY * H) / Math.round((mSY * H) / rotationPeriodDays);
+  }
+
+  const lowestPoint = ascendingNode !== undefined ? 180 - ascendingNode : undefined;
+
+  return {
+    solarYearCount, orbitDistance, periodYears, realOrbitalEccentricity,
+    elipticOrbit, perihelionDistance, speedKmh, rotationPeriodHours,
+    eccentricityPerihelion, lowestPoint,
+  };
+}
+
+module.exports = { derivePlanetGeometry };

package/src/planets/model.cjs

@@ -0,0 +1,185 @@
+/**
+ * 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):
+ *
+ *   ψ 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)
+ *
+ * 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).
+ *
+ * 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
+ * (test/planet-model-identity.test.mjs) holds this factory bit-exact
+ * against the shipped Node derivation.
+ */
+
+'use strict';
+
+const { derivePlanetGeometry } = require('./geometry.cjs');
+const FL = require('./fibonacci-laws.cjs');
+
+/**
+ * @typedef {Object} PlanetModelBody
+ * @property {string} [type] - geometry type branch ('I' | 'II' | 'III')
+ * @property {number} solarYearInput
+ * @property {number} [fibonacciD]
+ * @property {number} [invPlaneInclinationJ2000]
+ * @property {number} [longitudePerihelion]
+ * @property {number} [inclinationCycleAnchor]
+ * @property {boolean} [antiPhase]
+ * @property {number} [perihelionEclipticYears]
+ * @property {number} [axialPrecessionYears]
+ * @property {number|null} [obliquityCycle]
+ * @property {number} [axialTiltJ2000]
+ * @property {number} [orbitalEccentricityJ2000]
+ * @property {number} [ascendingNode]
+ * @property {number} [rotationPeriodDays]
+ * @property {number} [orbitalEccentricityBase] - minor bodies: JSON input;
+ *   carriers: ignored (the K law derives it)
+ * @property {number} [orbitDistanceOverride]
+ */
+
+/**
+ * @typedef {Object} PlanetModelEnv
+ * @property {number} holisticYears
+ * @property {number} meanSolarYearDays
+ * @property {number} balancedYear
+ * @property {number} systemResetN
+ * @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
+ */
+
+/**
+ * Run the full derivation chain over a set of body records.
+ *
+ * @param {PlanetModelEnv} env
+ * @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> }}
+ */
+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;
+
+  const geomEnv = {
+    holisticYears: env.holisticYears,
+    meanSolarYearDays: env.meanSolarYearDays,
+    currentAUDistanceKm: env.currentAUDistanceKm,
+    earthEccentricityJ2000: env.earthEccentricityJ2000,
+    earthPerihelionLongitudeJ2000Deg: env.earthPerihelionLongitudeJ2000Deg,
+  };
+
+  /** @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;
+    }
+
+    if (b.perihelionEclipticYears && b.axialPrecessionYears) {
+      rec.wobblePeriodYears = FL.computeWobblePeriodYears(
+        b.perihelionEclipticYears, b.axialPrecessionYears, env.holisticYears,
+      );
+    }
+
+    if (b.fibonacciD && massFrac) {
+      rec.obliquityMeanDeg = FL.computeObliquityMeanSnapshot({
+        axialTiltJ2000: /** @type {number} */ (b.axialTiltJ2000),
+        invPlaneInclinationAmplitude: /** @type {number} */ (rec.invPlaneInclinationAmplitude),
+        perihelionEclipticYears: /** @type {number} */ (b.perihelionEclipticYears),
+      }, b.obliquityCycle, { H: env.holisticYears, t2000 });
+      const el = FL.computeEccentricityLaw({
+        fibonacciD: b.fibonacciD, massFrac,
+        solarYearInput: b.solarYearInput,
+        orbitalEccentricityJ2000: /** @type {number} */ (b.orbitalEccentricityJ2000),
+        antiPhase: /** @type {boolean} */ (b.antiPhase),
+      }, {
+        kConstant, obliquityMeanDeg: rec.obliquityMeanDeg,
+        wobblePeriodYears: /** @type {number} */ (rec.wobblePeriodYears), t2000,
+        meanSolarYearDays: env.meanSolarYearDays,
+      });
+      rec.eccentricityAmplitude = el.amplitude;
+      rec.eccentricityBase = el.base;
+      rec.eccentricityPhaseJ2000Deg = el.phaseJ2000;
+    }
+
+    rec.geometry = derivePlanetGeometry({
+      key, type: b.type,
+      solarYearInput: b.solarYearInput,
+      orbitalEccentricityBase: rec.eccentricityBase !== undefined
+        ? rec.eccentricityBase : b.orbitalEccentricityBase,
+      longitudePerihelion: b.longitudePerihelion,
+      ascendingNode: b.ascendingNode,
+      rotationPeriodDays: b.rotationPeriodDays,
+      orbitDistanceOverride: b.orbitDistanceOverride,
+    }, geomEnv);
+
+    out[key] = rec;
+  }
+
+  return { psiConstant, kConstant, eccentricityAnchor, t2000, bodies: out };
+}
+
+module.exports = { createPlanetModel };

package/src/planets/orbit-chain.cjs

@@ -0,0 +1,46 @@
+/**
+ * Deep-time planet orbit chain — THE shared implementation (Phase 8.3, L6).
+ * Driver 2: solar mass loss. Three pure laws:
+ *
+ *  - massLossScaledLinearAtAge — adiabatic a·M = const ⇒ a(t) scales
+ *    LINEARLY with (1 − Δm). Serves Earth's AU (km) and every planet's
+ *    semi-major axis (units are the caller's — S-P11 resolved: the two
+ *    engines shared this driver all along, differing only in km vs
+ *    AU-ratio normalization).
+ *  - driver2PeriodSecondsAtAge — Kepler under mass loss, dT/T = −2·dM/M ⇒
+ *    T(t) = T₀·(1 − Δm)². The integrand of the planet cycle chains
+ *    (chain-cycles) and the scene integrators (S-P2).
+ *  - synodicPeriodSeconds — the Earth–planet beat Tp·Ty/|Tp − Ty|.
+ *
+ * t_Ma is AGE in Myr (positive = past); Δm = massLossFracPerYear·t_Ma·1e6.
+ * The t_Ma === 0 fast paths return the J2000 values EXACTLY.
+ */
+
+'use strict';
+
+/**
+ * @param {number} tMa @param {number} valueJ2000
+ * @param {number} massLossFracPerYear @returns {number} */
+function massLossScaledLinearAtAge(tMa, valueJ2000, massLossFracPerYear) {
+  if (tMa === 0) return valueJ2000;
+  const massLossFraction = massLossFracPerYear * tMa * 1e6;
+  return valueJ2000 * (1 - massLossFraction);
+}
+
+/**
+ * @param {number} tMa @param {number} periodJ2000Seconds
+ * @param {number} massLossFracPerYear @returns {number} */
+function driver2PeriodSecondsAtAge(tMa, periodJ2000Seconds, massLossFracPerYear) {
+  if (tMa === 0) return periodJ2000Seconds;
+  const massLossFraction = massLossFracPerYear * tMa * 1e6;
+  return periodJ2000Seconds * Math.pow(1 - massLossFraction, 2);
+}
+
+/**
+ * @param {number} planetPeriodSeconds @param {number} yearSeconds
+ * @returns {number} */
+function synodicPeriodSeconds(planetPeriodSeconds, yearSeconds) {
+  return planetPeriodSeconds * yearSeconds / Math.abs(planetPeriodSeconds - yearSeconds);
+}
+
+module.exports = { massLossScaledLinearAtAge, driver2PeriodSecondsAtAge, synodicPeriodSeconds };