universal-physics-tensor 10.0.0 → 11.0.0

package/dist/numerical/null-ray-integrator.js.map

@@ -1 +1 @@
-{"version":3,"file":"null-ray-integrator.js","sourceRoot":"","sources":["../../src/numerical/null-ray-integrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAOpD,SAAS,WAAW,CAAC,CAAwB,EAAE,QAAgB;IAC7D,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,IAAI,qBAAqB,CAC7B,8DAA8D,CAAC,CAAC,MAAM,cAAc,QAAQ,EAAE,CAC/F,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,MAAiB,EACjB,EAAyB,EACzB,OAAe,EACf,OAAe,EACf,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,qBAAqB,CAAC,4DAA4D,KAAK,EAAE,CAAC,CAAC;IACvG,CAAC;IACD,MAAM,CAAC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,KAAK,CAAC;IACtC,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;IACvB,MAAM,GAAG,GAAG,cAAc,CACxB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACZ,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC5B,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,CAAC,CAAC;IACX,CAAC,EACD,MAAM,EACN,CAAC,OAAO,EAAE,OAAO,CAAC,EAClB,EAAE,EAAE,EAAE,CAAC,EAAE,CACV,CAAC;IACF,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC;AAClD,CAAC","sourcesContent":["/**\n * Fixed-step classical RK4 integrator for affine-parameterized null\n * geodesics. No module under `src/` calls it: the covariant-eikonal path\n * (`src/numerical/covariant-eikonal.ts`) uses the symplectic\n * `integrateGeodesicGL4`, and the tests keep this one as the RK4 oracle\n * the atlas ODE helper is compared against. The fixed steps are MathTS\n * `solveODESystem` with `dt` set. Operates on plain `number[]` state\n * vectors, no TensorEngine dependency.\n *\n * @module numerical/null-ray-integrator\n */\nimport { solveODESystem } from '@danielsimonjr/mathts-functions';\nimport { NumericalBackendError } from './errors.js';\n\n/** A first-order ODE system: dy/dλ = f(λ, y). `y` and the return are\n *  state vectors of equal length.\n *  v0.6.1: dropped export — was @internal-tagged with no external consumer. */\ntype ODESystem = (lambda: number, y: ReadonlyArray<number>) => number[];\n\nfunction checkLength(k: ReadonlyArray<number>, expected: number): void {\n  if (k.length !== expected) {\n    throw new NumericalBackendError(\n      `integrateRK4: ODE system returned a state vector of length ${k.length}, expected ${expected}`,\n    );\n  }\n}\n\n/**\n * Integrate `system` from affine parameter `lambda0` to `lambda1` in\n * `steps` fixed RK4 steps, starting from state `y0`. Returns the final\n * state vector. Classical 4th-order Runge-Kutta — global error O(h⁴).\n *\n * @internal — cross-module/test use only; not part of the consumer surface.\n */\nexport function integrateRK4(\n  system: ODESystem,\n  y0: ReadonlyArray<number>,\n  lambda0: number,\n  lambda1: number,\n  steps: number,\n): number[] {\n  if (!Number.isInteger(steps) || steps <= 0) {\n    throw new NumericalBackendError(`integrateRK4: step count must be a positive integer, got ${steps}`);\n  }\n  const h = (lambda1 - lambda0) / steps;\n  const yStart = [...y0];\n  const sol = solveODESystem(\n    (lambda, y) => {\n      const k = system(lambda, y);\n      checkLength(k, yStart.length);\n      return k;\n    },\n    yStart,\n    [lambda0, lambda1],\n    { dt: h },\n  );\n  return [...(sol.y[sol.y.length - 1] ?? yStart)];\n}\n"]}
+{"version":3,"file":"null-ray-integrator.js","sourceRoot":"","sources":["../../src/numerical/null-ray-integrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAOpD,SAAS,WAAW,CAAC,CAAwB,EAAE,QAAgB;IAC7D,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,IAAI,qBAAqB,CAC7B,8DAA8D,CAAC,CAAC,MAAM,cAAc,QAAQ,EAAE,CAC/F,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,MAAiB,EACjB,EAAyB,EACzB,OAAe,EACf,OAAe,EACf,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,qBAAqB,CAAC,4DAA4D,KAAK,EAAE,CAAC,CAAC;IACvG,CAAC;IACD,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;IACvB,MAAM,MAAM,GAAG,aAAa,CAC1B,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACZ,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC5B,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,CAAC,CAAC;IACX,CAAC,EACD,MAAM,EACN,OAAO,EACP,OAAO,EACP,KAAK,CACN,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC;AAC7C,CAAC","sourcesContent":["/**\n * Fixed-step classical RK4 integrator for affine-parameterized null\n * geodesics, and the one-step RK4 the atlas and case modules call. The\n * covariant-eikonal path (`src/numerical/covariant-eikonal.ts`) uses the\n * symplectic `integrateGeodesicGL4` instead. The fixed steps are\n * `rk4Trajectory` (`rk4-trajectory.ts`, MathTS `solveODESystem` with `dt`),\n * the one owner of the step count; this module returns its last state.\n * Operates on plain `number[]` state vectors, no TensorEngine dependency.\n *\n * @module numerical/null-ray-integrator\n */\nimport { NumericalBackendError } from './errors.js';\nimport { rk4Trajectory } from './rk4-trajectory.js';\n\n/** A first-order ODE system: dy/dλ = f(λ, y). `y` and the return are\n *  state vectors of equal length.\n *  v0.6.1: dropped export — was @internal-tagged with no external consumer. */\ntype ODESystem = (lambda: number, y: ReadonlyArray<number>) => number[];\n\nfunction checkLength(k: ReadonlyArray<number>, expected: number): void {\n  if (k.length !== expected) {\n    throw new NumericalBackendError(\n      `integrateRK4: ODE system returned a state vector of length ${k.length}, expected ${expected}`,\n    );\n  }\n}\n\n/**\n * Integrate `system` from affine parameter `lambda0` to `lambda1` in\n * `steps` fixed RK4 steps, starting from state `y0`. Returns the final\n * state vector. Classical 4th-order Runge-Kutta — global error O(h⁴). It takes\n * exactly `steps` steps of (lambda1 − lambda0)/steps (`rk4Trajectory`).\n *\n * @internal — cross-module/test use only; not part of the consumer surface.\n */\nexport function integrateRK4(\n  system: ODESystem,\n  y0: ReadonlyArray<number>,\n  lambda0: number,\n  lambda1: number,\n  steps: number,\n): number[] {\n  if (!Number.isInteger(steps) || steps <= 0) {\n    throw new NumericalBackendError(`integrateRK4: step count must be a positive integer, got ${steps}`);\n  }\n  const yStart = [...y0];\n  const states = rk4Trajectory(\n    (lambda, y) => {\n      const k = system(lambda, y);\n      checkLength(k, yStart.length);\n      return k;\n    },\n    yStart,\n    lambda0,\n    lambda1,\n    steps,\n  );\n  return states[states.length - 1] ?? yStart;\n}\n"]}

package/dist/numerical/painleve-gullstrand-metric.js

@@ -50,7 +50,7 @@
  *
  * @module numerical/painleve-gullstrand-metric
  */
-import { C_SI, G_SI } from '../core/constants.js';
+import { schwarzschildRadius } from './schwarzschild.js';
 /**
  * Schwarzschild radius `r_s = 2 G M / c²` for a body of mass `M`.
  * Inlined here to avoid an out-of-rootDir import on the test
@@ -59,7 +59,7 @@ import { C_SI, G_SI } from '../core/constants.js';
  * @internal
  */
 function schwarzschildRs(M_kg) {
-    return (2 * G_SI * M_kg) / (C_SI * C_SI);
+    return schwarzschildRadius(M_kg);
 }
 /**
  * Builds a Painlevé-Gullstrand metric function `g_μν(T, r, θ, φ)`

package/dist/numerical/painleve-gullstrand-metric.js.map

@@ -1 +1 @@
-{"version":3,"file":"painleve-gullstrand-metric.js","sourceRoot":"","sources":["../../src/numerical/painleve-gullstrand-metric.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Painlevé-Gullstrand (PG) metric for Schwarzschild spacetime —\n * regular at the event horizon.\n *\n * Per `docs/architecture/archive/v0.7-near-horizon-kretschmann-design-note.md`\n * (v0.7 follow-up to v0.6.0's deferred \"Near-horizon Kretschmann\"\n * item). Schwarzschild coordinates have a coordinate singularity at\n * `r = r_s` (the event horizon); `g_rr = 1/(1−r_s/r) → ∞`. The\n * Painlevé-Gullstrand coordinate system is regular at the horizon\n * (and everywhere outside the curvature singularity at `r=0`).\n *\n * Coordinate transform (closed-form, no implicit-function solve):\n *\n *     T = t + 2√(r·r_s) + r_s·ln|(√r − √r_s)/(√r + √r_s)|\n *\n * In PG coordinates (T, r, θ, φ):\n *\n *     ds² = -(1 − r_s/r) dT² + 2√(r_s/r) dT dr + dr² + r² dΩ²\n *\n * Matrix form:\n *\n *     g_μν = [[-(1−r_s/r),  √(r_s/r),  0,       0          ],\n *             [ √(r_s/r),    1,         0,       0          ],\n *             [ 0,           0,         r²,      0          ],\n *             [ 0,           0,         0,       r² sin²θ   ]]\n *\n * Inverse (closed-form via 2x2 block inverse on the (T,r) block,\n * det = -1):\n *\n *     g^μν = [[-1,           √(r_s/r),  0,       0           ],\n *             [ √(r_s/r),    (1−r_s/r), 0,       0           ],\n *             [ 0,           0,         1/r²,    0           ],\n *             [ 0,           0,         0,       1/(r² sin²θ)]]\n *\n * Verification at the horizon:\n *\n *     r → r_s:  g_TT → 0, g_Tr → 1, g_rr → 1 (all finite)\n *               g^rr → 0, g^Tr → 1, g^TT → -1 (all finite)\n *\n * Compare to Schwarzschild where g_rr → ∞. The Kretschmann\n * scalar K = R_μνρσ R^μνρσ is computed via the existing\n * `numerical/kretschmann.ts` (coordinate-agnostic — takes raw\n * arrays) fed by Riemann assembled from these closed-form metric\n * functions via the existing FD pipeline. At r=r_s the analytic\n * value `K = 48 G²M²/(c⁴ r_s⁶) = 12/r_s⁴` (in c=G=1 units) is\n * recovered numerically without coordinate-singularity blowup.\n *\n * Reference: MTW §31.4 (\"Lemaître coordinates\" + the\n * Painlevé-Gullstrand variant); Carroll §5.7.\n *\n * @module numerical/painleve-gullstrand-metric\n */\n\nimport { C_SI, G_SI } from '../core/constants.js';\nimport type { MetricFnFlat } from './curvature-lowering-helpers.js';\n\n/**\n * Schwarzschild radius `r_s = 2 G M / c²` for a body of mass `M`.\n * Inlined here to avoid an out-of-rootDir import on the test\n * fixture's `schwarzschildRs` helper. Same formula.\n *\n * @internal\n */\nfunction schwarzschildRs(M_kg: number): number {\n  return (2 * G_SI * M_kg) / (C_SI * C_SI);\n}\n\n/**\n * Builds a Painlevé-Gullstrand metric function `g_μν(T, r, θ, φ)`\n * for a Schwarzschild black hole of mass `M_kg`.\n *\n * The returned function maps a 4-tuple coordinate point to the\n * 4×4 lower-lower metric as a row-major `Float64Array(16)` —\n * `flat[mu*4 + nu] = g_{μν}` (v0.9.0 O-6 migration, mirroring the\n * v0.6.0 BR-2 christoffelFn convention). Closed-form; no FD;\n * regular at r=r_s.\n *\n * BREAKING (v0.9.0) for subpath-import consumers: previously\n * returned `number[][]`.\n *\n * @public\n */\nexport function painleveGullstrandGFn(M_kg: number): MetricFnFlat {\n  const r_s = schwarzschildRs(M_kg);\n  return function pgG(x: ReadonlyArray<number>): Float64Array {\n    const r = x[1];\n    const theta = x[2];\n    if (!(r > 0)) {\n      throw new RangeError(`painleveGullstrandGFn: r must be > 0, got ${r}`);\n    }\n    const rho = r_s / r;\n    const sqrtRho = Math.sqrt(rho);\n    const sinTheta = Math.sin(theta);\n    const out = new Float64Array(16);\n    out[0 * 4 + 0] = -(1 - rho);\n    out[0 * 4 + 1] = sqrtRho;\n    out[1 * 4 + 0] = sqrtRho;\n    out[1 * 4 + 1] = 1;\n    out[2 * 4 + 2] = r * r;\n    out[3 * 4 + 3] = r * r * sinTheta * sinTheta;\n    return out;\n  };\n}\n\n/**\n * Builds a Painlevé-Gullstrand inverse-metric function `g^μν(T, r,\n * θ, φ)`. Closed-form (2×2 block inverse on the (T, r) block,\n * det = -1; angular block is trivially diagonal).\n *\n * Returns a row-major `Float64Array(16)` — `flat[mu*4 + nu] = g^{μν}`\n * (v0.9.0 O-6 migration). At r=r_s, g^rr=0 (the horizon's\n * coordinate-regularity signature in PG: NO divergence). At r→∞,\n * g^rr → 1 (asymptotic flatness).\n *\n * BREAKING (v0.9.0) for subpath-import consumers: previously\n * returned `number[][]`.\n *\n * @public\n */\nexport function painleveGullstrandGInverseFn(M_kg: number): MetricFnFlat {\n  const r_s = schwarzschildRs(M_kg);\n  return function pgGInv(x: ReadonlyArray<number>): Float64Array {\n    const r = x[1];\n    const theta = x[2];\n    if (!(r > 0)) {\n      throw new RangeError(`painleveGullstrandGInverseFn: r must be > 0, got ${r}`);\n    }\n    const rho = r_s / r;\n    const sqrtRho = Math.sqrt(rho);\n    const sinTheta = Math.sin(theta);\n    const out = new Float64Array(16);\n    out[0 * 4 + 0] = -1;\n    out[0 * 4 + 1] = sqrtRho;\n    out[1 * 4 + 0] = sqrtRho;\n    out[1 * 4 + 1] = 1 - rho;\n    out[2 * 4 + 2] = 1 / (r * r);\n    out[3 * 4 + 3] = 1 / (r * r * sinTheta * sinTheta);\n    return out;\n  };\n}\n"]}
+{"version":3,"file":"painleve-gullstrand-metric.js","sourceRoot":"","sources":["../../src/numerical/painleve-gullstrand-metric.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Painlevé-Gullstrand (PG) metric for Schwarzschild spacetime —\n * regular at the event horizon.\n *\n * Per `docs/architecture/archive/v0.7-near-horizon-kretschmann-design-note.md`\n * (v0.7 follow-up to v0.6.0's deferred \"Near-horizon Kretschmann\"\n * item). Schwarzschild coordinates have a coordinate singularity at\n * `r = r_s` (the event horizon); `g_rr = 1/(1−r_s/r) → ∞`. The\n * Painlevé-Gullstrand coordinate system is regular at the horizon\n * (and everywhere outside the curvature singularity at `r=0`).\n *\n * Coordinate transform (closed-form, no implicit-function solve):\n *\n *     T = t + 2√(r·r_s) + r_s·ln|(√r − √r_s)/(√r + √r_s)|\n *\n * In PG coordinates (T, r, θ, φ):\n *\n *     ds² = -(1 − r_s/r) dT² + 2√(r_s/r) dT dr + dr² + r² dΩ²\n *\n * Matrix form:\n *\n *     g_μν = [[-(1−r_s/r),  √(r_s/r),  0,       0          ],\n *             [ √(r_s/r),    1,         0,       0          ],\n *             [ 0,           0,         r²,      0          ],\n *             [ 0,           0,         0,       r² sin²θ   ]]\n *\n * Inverse (closed-form via 2x2 block inverse on the (T,r) block,\n * det = -1):\n *\n *     g^μν = [[-1,           √(r_s/r),  0,       0           ],\n *             [ √(r_s/r),    (1−r_s/r), 0,       0           ],\n *             [ 0,           0,         1/r²,    0           ],\n *             [ 0,           0,         0,       1/(r² sin²θ)]]\n *\n * Verification at the horizon:\n *\n *     r → r_s:  g_TT → 0, g_Tr → 1, g_rr → 1 (all finite)\n *               g^rr → 0, g^Tr → 1, g^TT → -1 (all finite)\n *\n * Compare to Schwarzschild where g_rr → ∞. The Kretschmann\n * scalar K = R_μνρσ R^μνρσ is computed via the existing\n * `numerical/kretschmann.ts` (coordinate-agnostic — takes raw\n * arrays) fed by Riemann assembled from these closed-form metric\n * functions via the existing FD pipeline. At r=r_s the analytic\n * value `K = 48 G²M²/(c⁴ r_s⁶) = 12/r_s⁴` (in c=G=1 units) is\n * recovered numerically without coordinate-singularity blowup.\n *\n * Reference: MTW §31.4 (\"Lemaître coordinates\" + the\n * Painlevé-Gullstrand variant); Carroll §5.7.\n *\n * @module numerical/painleve-gullstrand-metric\n */\n\nimport { schwarzschildRadius } from './schwarzschild.js';\nimport type { MetricFnFlat } from './curvature-lowering-helpers.js';\n\n/**\n * Schwarzschild radius `r_s = 2 G M / c²` for a body of mass `M`.\n * Inlined here to avoid an out-of-rootDir import on the test\n * fixture's `schwarzschildRs` helper. Same formula.\n *\n * @internal\n */\nfunction schwarzschildRs(M_kg: number): number {\n  return schwarzschildRadius(M_kg);\n}\n\n/**\n * Builds a Painlevé-Gullstrand metric function `g_μν(T, r, θ, φ)`\n * for a Schwarzschild black hole of mass `M_kg`.\n *\n * The returned function maps a 4-tuple coordinate point to the\n * 4×4 lower-lower metric as a row-major `Float64Array(16)` —\n * `flat[mu*4 + nu] = g_{μν}` (v0.9.0 O-6 migration, mirroring the\n * v0.6.0 BR-2 christoffelFn convention). Closed-form; no FD;\n * regular at r=r_s.\n *\n * BREAKING (v0.9.0) for subpath-import consumers: previously\n * returned `number[][]`.\n *\n * @public\n */\nexport function painleveGullstrandGFn(M_kg: number): MetricFnFlat {\n  const r_s = schwarzschildRs(M_kg);\n  return function pgG(x: ReadonlyArray<number>): Float64Array {\n    const r = x[1];\n    const theta = x[2];\n    if (!(r > 0)) {\n      throw new RangeError(`painleveGullstrandGFn: r must be > 0, got ${r}`);\n    }\n    const rho = r_s / r;\n    const sqrtRho = Math.sqrt(rho);\n    const sinTheta = Math.sin(theta);\n    const out = new Float64Array(16);\n    out[0 * 4 + 0] = -(1 - rho);\n    out[0 * 4 + 1] = sqrtRho;\n    out[1 * 4 + 0] = sqrtRho;\n    out[1 * 4 + 1] = 1;\n    out[2 * 4 + 2] = r * r;\n    out[3 * 4 + 3] = r * r * sinTheta * sinTheta;\n    return out;\n  };\n}\n\n/**\n * Builds a Painlevé-Gullstrand inverse-metric function `g^μν(T, r,\n * θ, φ)`. Closed-form (2×2 block inverse on the (T, r) block,\n * det = -1; angular block is trivially diagonal).\n *\n * Returns a row-major `Float64Array(16)` — `flat[mu*4 + nu] = g^{μν}`\n * (v0.9.0 O-6 migration). At r=r_s, g^rr=0 (the horizon's\n * coordinate-regularity signature in PG: NO divergence). At r→∞,\n * g^rr → 1 (asymptotic flatness).\n *\n * BREAKING (v0.9.0) for subpath-import consumers: previously\n * returned `number[][]`.\n *\n * @public\n */\nexport function painleveGullstrandGInverseFn(M_kg: number): MetricFnFlat {\n  const r_s = schwarzschildRs(M_kg);\n  return function pgGInv(x: ReadonlyArray<number>): Float64Array {\n    const r = x[1];\n    const theta = x[2];\n    if (!(r > 0)) {\n      throw new RangeError(`painleveGullstrandGInverseFn: r must be > 0, got ${r}`);\n    }\n    const rho = r_s / r;\n    const sqrtRho = Math.sqrt(rho);\n    const sinTheta = Math.sin(theta);\n    const out = new Float64Array(16);\n    out[0 * 4 + 0] = -1;\n    out[0 * 4 + 1] = sqrtRho;\n    out[1 * 4 + 0] = sqrtRho;\n    out[1 * 4 + 1] = 1 - rho;\n    out[2 * 4 + 2] = 1 / (r * r);\n    out[3 * 4 + 3] = 1 / (r * r * sinTheta * sinTheta);\n    return out;\n  };\n}\n"]}

package/dist/numerical/perihelion-finder.d.ts

@@ -1,39 +1,3 @@
-/**
- * Bisection perihelion finder via cubic-Hermite interpolation on cached
- * GL4 snapshots (v0.5.0 Task 4, Phase 1b).
- *
- * Algorithm (Design §3 Task 1b):
- *   1. Walk snapshots, extract `dr/dτ_i = g^{rν}(x_i) · p_{i,ν}` at each
- *      snapshot. Index `r` is the radial coordinate slot (index 1 by
- *      convention in (t, r, θ, φ)).
- *   2. Locate consecutive indices `(i, i+1)` where `dr/dτ` sign-changes
- *      from `−` to `+` — that is the perihelion (inner radial turning
- *      point). Sign-change `+ → −` is apoapsis and is intentionally
- *      skipped.
- *   3. **M3 bracket-width check:** if `|τ_{i+1} − τ_i| < 2 · h_snap`
- *      where `h_snap` is the median Δτ across all snapshots, emit a
- *      non-throwing `PerihelionBracketWidthWarning` via
- *      `process.emitWarning`. This indicates the GL4 step is too coarse
- *      to resolve the turning point — the caller should re-integrate
- *      with finer steps.
- *   4. Fit a **cubic Hermite polynomial** through `(τ_i, dr/dτ_i)` and
- *      `(τ_{i+1}, dr/dτ_{i+1})`, with endpoint derivatives estimated
- *      from neighboring snapshots (4 values total: f and f' at both
- *      endpoints). Find an analytic root of the cubic on [τ_i, τ_{i+1}].
- *   5. If `|P(τ_root)| > tauTolerance`, refine with **bisection on the
- *      polynomial** (not re-integration — Adam+Eve I6/F11 — that would
- *      cost a full GL4 sweep per bisection step, which defeats the
- *      cached-snapshot approach). Precision floor: 1e-9 × T_orbit
- *      (Adam+Eve I1 — 1e-12 needs ~40 cubic bisections and is wasted
- *      effort given the integrator's per-step error is already > 1e-12).
- *   6. Return `{ tau, x, phi }` where `x` is the cubic-Hermite-interpolated
- *      4-coordinate at the root and `phi = x[3]`.
- *
- * **Throws** `Error("no perihelion bracket")` if no `−→+` sign-change is
- * found in the snapshot range.
- *
- * @module numerical/perihelion-finder
- */
 /**
  * Result of `findPerihelion`: the τ at the radial turning point, the
  * interpolated 4-coordinate, and the orbital phase `phi = x[3]`.

package/dist/numerical/perihelion-finder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perihelion-finder.d.ts","sourceRoot":"","sources":["../../src/numerical/perihelion-finder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC;wEACoE;IACpE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;QAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC9B,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KAC/B,CAAC,CAAC;IACH;;4DAEwD;IACxD,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,KAAK,YAAY,CAAC;IAC5D;;iEAE6D;IAC7D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;qCACiC;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAoJD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,gBAAgB,CAwG/E"}
+{"version":3,"file":"perihelion-finder.d.ts","sourceRoot":"","sources":["../../src/numerical/perihelion-finder.ts"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC;wEACoE;IACpE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;QAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC9B,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KAC/B,CAAC,CAAC;IACH;;4DAEwD;IACxD,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,KAAK,YAAY,CAAC;IAC5D;;iEAE6D;IAC7D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;qCACiC;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAkGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,gBAAgB,CAwG/E"}

package/dist/numerical/perihelion-finder.js

@@ -20,11 +20,14 @@
  *      `(τ_{i+1}, dr/dτ_{i+1})`, with endpoint derivatives estimated
  *      from neighboring snapshots (4 values total: f and f' at both
  *      endpoints). Find an analytic root of the cubic on [τ_i, τ_{i+1}].
- *   5. If `|P(τ_root)| > tauTolerance`, refine with **bisection on the
- *      polynomial** (not re-integration — Adam+Eve I6/F11 — that would
- *      cost a full GL4 sweep per bisection step, which defeats the
- *      cached-snapshot approach). Precision floor: 1e-9 × T_orbit
- *      (Adam+Eve I1 — 1e-12 needs ~40 cubic bisections and is wasted
+ *   5. If `|P(τ_root)| > tauTolerance`, refine with **Brent's method on the
+ *      polynomial** (MathTS `findRoot`, not re-integration — Adam+Eve
+ *      I6/F11 — that would cost a full GL4 sweep per step, which defeats
+ *      the cached-snapshot approach). `tauTolerance` is a RESIDUAL tolerance
+ *      in the units of dr/dτ, so the search is run with `xtol: 0`
+ *      (`@danielsimonjr/mathts-functions` ≥ 0.68.3): the solver stops on
+ *      `|P| ≤ tauTolerance` alone, never on the bracket width in `s`.
+ *      Precision floor: 1e-9 × T_orbit (Adam+Eve I1 — 1e-12 is wasted
  *      effort given the integrator's per-step error is already > 1e-12).
  *   6. Return `{ tau, x, phi }` where `x` is the cubic-Hermite-interpolated
  *      4-coordinate at the root and `phi = x[3]`.
@@ -34,6 +37,8 @@
  *
  * @module numerical/perihelion-finder
  */
+import { findRoot, hermiteInterp, median } from '@danielsimonjr/mathts-functions';
+import { numberFrom } from '../core/mathts-read.js';
 /** Compute `dr/dτ = g^{rν}(x) p_ν` at a single snapshot. */
 function radialVelocity(x, p, gInverseFn, r) {
     const gInv = gInverseFn(x);
@@ -44,41 +49,25 @@ function radialVelocity(x, p, gInverseFn, r) {
     }
     return v;
 }
-/** Median of a numeric array (does not mutate input). */
-function median(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const n = sorted.length;
-    if (n === 0)
+/** Median of the snapshot steps, MathTS `median` (0 for no steps, as before). */
+function medianStep(values) {
+    if (values.length === 0)
         return 0;
-    if (n % 2 === 1)
-        return sorted[(n - 1) / 2];
-    return 0.5 * (sorted[n / 2 - 1] + sorted[n / 2]);
+    return numberFrom('median', median([...values]));
 }
 /**
- * Hermite basis on the unit interval, evaluated at `s ∈ [0,1]`.
- *
- * Cubic Hermite interpolant of a scalar `f(τ)` over `[τ0, τ1]` with
+ * The cubic Hermite interpolant of a scalar `f(τ)` over `[τ0, τ1]` with
  * endpoint values `f0, f1` and endpoint derivatives `m0, m1` (in `f` per
- * `τ`):
- *
- *     P(τ) = h00(s) f0 + h10(s) (τ1−τ0) m0 + h01(s) f1 + h11(s) (τ1−τ0) m1
+ * `τ`), at `s = (τ − τ0)/(τ1 − τ0)`: MathTS `hermiteInterp` on the two
+ * nodes `0` and `1` of the unit interval, where the derivatives are
+ * `(τ1 − τ0) m`. With two nodes that interpolant IS the cubic
  *
- * where `s = (τ − τ0)/(τ1 − τ0)` and
- *     h00 =  2s³ − 3s² + 1
- *     h10 =      s³ − 2s² + s
- *     h01 = −2s³ + 3s²
- *     h11 =      s³ −  s²
+ *     P = h00(s) f0 + h10(s) (τ1−τ0) m0 + h01(s) f1 + h11(s) (τ1−τ0) m1
  *
  * (Numerical Recipes §3.4; Hairer/Lubich/Wanner §III.5.)
  */
 function hermiteEval(f0, f1, m0, m1, dt, s) {
-    const s2 = s * s;
-    const s3 = s2 * s;
-    const h00 = 2 * s3 - 3 * s2 + 1;
-    const h10 = s3 - 2 * s2 + s;
-    const h01 = -2 * s3 + 3 * s2;
-    const h11 = s3 - s2;
-    return h00 * f0 + h10 * dt * m0 + h01 * f1 + h11 * dt * m1;
+    return hermiteInterp([0, 1], [f0, f1], [dt * m0, dt * m1], s);
 }
 /**
  * Vector cubic-Hermite interpolation of a 4-coordinate `x^μ` at `τ`
@@ -95,61 +84,26 @@ function hermiteInterpVector(x0, x1, m0, m1, dt, s) {
     return out;
 }
 /**
- * Bisection on the cubic-Hermite polynomial for the scalar `dr/dτ` root.
- * Operates on `s ∈ [0,1]` — the normalised bracket coordinate. Returns
- * the converged `s` and the corresponding polynomial value.
+ * The root of the cubic-Hermite polynomial for the scalar `dr/dτ`, on the
+ * normalised bracket coordinate `s ∈ [0,1]`, by MathTS `findRoot` (Brent).
+ * Returns the converged `s` and the polynomial value there.
  *
- * Precision: the loop terminates when `|P(s_mid)| ≤ tauTolerance` (scaled
- * to whatever units `dr/dτ` is in — the caller passes `tauTolerance`
- * matched to the integrator scale). A hard iteration cap of 60 prevents
- * runaway on pathological inputs (60 bisections halve `s` to ≈1e-18 — well
- * below floating-point resolution).
+ * Precision: `tol` is a residual tolerance in the units of `dr/dτ` (the
+ * caller passes `tauTolerance`, matched to the integrator scale), so the
+ * solver runs with `xtol: 0` and stops on `|P(s)| ≤ tol` alone, never on
+ * the bracket width in `s`. `sInitial` (the linear estimate) is tried first
+ * and returned when it already meets `tol`. A hard iteration cap of 100
+ * bounds a tolerance the polynomial cannot meet in floating point; the
+ * solver then returns its best point.
  */
-function bisectCubic(f0, f1, m0, m1, dt, sInitial, tol) {
-    // Establish a bracket around sInitial. The sign-change is at the
-    // f(τ0)=f0 → f(τ1)=f1 endpoints (by construction f0 < 0, f1 > 0).
-    let sLo = 0;
-    let sHi = 1;
-    let fLo = f0;
-    let fHi = f1;
-    let s = sInitial;
-    let fs = hermiteEval(f0, f1, m0, m1, dt, s);
-    // If sInitial already satisfies tol, return it.
-    let absFs = fs < 0 ? -fs : fs;
-    if (absFs <= tol)
-        return { s, residual: fs };
-    // Warm start: the sInitial evaluation above is otherwise discarded. Use its
-    // sign to tighten the GUARANTEED bracket before bisecting. This preserves the
-    // sign-bracket invariant (fLo < 0 < fHi) — so convergence is unaffected — and
-    // a good linear estimate yields a smaller starting interval (fewer iters).
-    if (sInitial > sLo && sInitial < sHi) {
-        if ((fs < 0) === (fLo < 0)) {
-            sLo = s;
-            fLo = fs;
-        }
-        else {
-            sHi = s;
-            fHi = fs;
-        }
-    }
-    for (let iter = 0; iter < 60; iter++) {
-        // Bisect the (warm-started) bracket — robust regardless of the estimate.
-        s = 0.5 * (sLo + sHi);
-        fs = hermiteEval(f0, f1, m0, m1, dt, s);
-        absFs = fs < 0 ? -fs : fs;
-        if (absFs <= tol)
-            return { s, residual: fs };
-        // Maintain sign-bracket: fLo < 0 < fHi.
-        if ((fs < 0) === (fLo < 0)) {
-            sLo = s;
-            fLo = fs;
-        }
-        else {
-            sHi = s;
-            fHi = fs;
-        }
-    }
-    return { s, residual: fs };
+function rootOnCubic(f0, f1, m0, m1, dt, sInitial, tol) {
+    const P = (s) => hermiteEval(f0, f1, m0, m1, dt, s);
+    const atStart = P(sInitial);
+    if (Math.abs(atStart) <= tol)
+        return { s: sInitial, residual: atStart };
+    // By construction f(0) = f0 ≤ 0 < f1 = f(1) (or f0 < 0 ≤ f1), the sign change `findRoot` requires.
+    const s = findRoot(P, 0, 1, { tol, xtol: 0, maxIter: 100 });
+    return { s, residual: P(s) };
 }
 /**
  * Find the perihelion (inner radial turning point) on a snapshot stream.
@@ -267,7 +221,7 @@ export function findPerihelion(options) {
     for (let i = 0; i < snapshots.length - 1; i++) {
         deltas.push(snapshots[i + 1].tau - snapshots[i].tau);
     }
-    const hSnap = median(deltas);
+    const hSnap = medianStep(deltas);
     if (dt < hSnap) {
         process.emitWarning(`findPerihelion: bracket width Δτ=${dt} < h_snap=${hSnap} `
             + `(median snapshot step) — GL4 snapshot density is too coarse to `
@@ -284,8 +238,8 @@ export function findPerihelion(options) {
     // Initial guess: linear interpolation root, s = f0 / (f0 − f1).
     // For a linear sign-change this is exact; for cubic it's a warm start.
     const sLinear = f0 / (f0 - f1);
-    // Step 5: bisect the cubic-Hermite polynomial until residual ≤ tolerance.
-    const { s: sRoot } = bisectCubic(f0, f1, m0, m1, dt, sLinear, tauTolerance);
+    // Step 5: solve the cubic-Hermite polynomial until residual ≤ tolerance.
+    const { s: sRoot } = rootOnCubic(f0, f1, m0, m1, dt, sLinear, tauTolerance);
     const tauRoot = tau0 + sRoot * dt;
     // Step 6: interpolate x^μ at τ_root via cubic Hermite using the same
     // endpoint-derivative scheme. dx^μ/dτ at endpoints comes from

package/dist/numerical/perihelion-finder.js.map

@@ -1 +1 @@
-{"version":3,"file":"perihelion-finder.js","sourceRoot":"","sources":["../../src/numerical/perihelion-finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bisection perihelion finder via cubic-Hermite interpolation on cached\n * GL4 snapshots (v0.5.0 Task 4, Phase 1b).\n *\n * Algorithm (Design §3 Task 1b):\n *   1. Walk snapshots, extract `dr/dτ_i = g^{rν}(x_i) · p_{i,ν}` at each\n *      snapshot. Index `r` is the radial coordinate slot (index 1 by\n *      convention in (t, r, θ, φ)).\n *   2. Locate consecutive indices `(i, i+1)` where `dr/dτ` sign-changes\n *      from `−` to `+` — that is the perihelion (inner radial turning\n *      point). Sign-change `+ → −` is apoapsis and is intentionally\n *      skipped.\n *   3. **M3 bracket-width check:** if `|τ_{i+1} − τ_i| < 2 · h_snap`\n *      where `h_snap` is the median Δτ across all snapshots, emit a\n *      non-throwing `PerihelionBracketWidthWarning` via\n *      `process.emitWarning`. This indicates the GL4 step is too coarse\n *      to resolve the turning point — the caller should re-integrate\n *      with finer steps.\n *   4. Fit a **cubic Hermite polynomial** through `(τ_i, dr/dτ_i)` and\n *      `(τ_{i+1}, dr/dτ_{i+1})`, with endpoint derivatives estimated\n *      from neighboring snapshots (4 values total: f and f' at both\n *      endpoints). Find an analytic root of the cubic on [τ_i, τ_{i+1}].\n *   5. If `|P(τ_root)| > tauTolerance`, refine with **bisection on the\n *      polynomial** (not re-integration — Adam+Eve I6/F11 — that would\n *      cost a full GL4 sweep per bisection step, which defeats the\n *      cached-snapshot approach). Precision floor: 1e-9 × T_orbit\n *      (Adam+Eve I1 — 1e-12 needs ~40 cubic bisections and is wasted\n *      effort given the integrator's per-step error is already > 1e-12).\n *   6. Return `{ tau, x, phi }` where `x` is the cubic-Hermite-interpolated\n *      4-coordinate at the root and `phi = x[3]`.\n *\n * **Throws** `Error(\"no perihelion bracket\")` if no `−→+` sign-change is\n * found in the snapshot range.\n *\n * @module numerical/perihelion-finder\n */\n\n/**\n * Result of `findPerihelion`: the τ at the radial turning point, the\n * interpolated 4-coordinate, and the orbital phase `phi = x[3]`.\n *\n * @public\n */\nexport interface PerihelionResult {\n  /** Proper time at the perihelion. */\n  readonly tau: number;\n  /** Interpolated 4-coordinate x^μ at τ_perihelion. */\n  readonly x: readonly number[];\n  /** Orbital phase φ = x[3] at τ_perihelion. */\n  readonly phi: number;\n}\n\n/**\n * Options for {@link findPerihelion}.\n *\n * @public\n */\nexport interface FindPerihelionOptions {\n  /** Snapshots produced by `integrateGeodesicGL4` (or any compatible\n   *  `(τ, x, p)` snapshot stream — only `tau`, `x`, `p` are read). */\n  readonly snapshots: ReadonlyArray<{\n    readonly tau: number;\n    readonly x: readonly number[];\n    readonly p: readonly number[];\n  }>;\n  /** Inverse-metric closure (v0.9.0 O-1 flat layout):\n   *  `gInverseFn(x)[μ*dim + ν] = g^{μν}(x)`, Float64Array(dim²). Used to\n   *  compute `dr/dτ = g^{rν}(x) p_ν` at each snapshot. */\n  readonly gInverseFn: (x: readonly number[]) => Float64Array;\n  /** Polynomial-bisection target tolerance on the cubic-Hermite root —\n   *  measured as `|P(τ_root)|`, not `|τ − τ_true|`. Precision floor 1e-9\n   *  per Adam+Eve I1; tighter values just waste bisections. */\n  readonly tauTolerance: number;\n  /** Coordinate index used as the \"radial\" slot. Defaults to 1\n   *  ((t, r, θ, φ) convention). */\n  readonly radialIndex?: number;\n}\n\n/** Compute `dr/dτ = g^{rν}(x) p_ν` at a single snapshot. */\nfunction radialVelocity(\n  x: readonly number[],\n  p: readonly number[],\n  gInverseFn: (x: readonly number[]) => Float64Array,\n  r: number,\n): number {\n  const gInv = gInverseFn(x);\n  const dim = p.length;\n  let v = 0;\n  for (let nu = 0; nu < dim; nu++) {\n    v += gInv[r * dim + nu] * p[nu];\n  }\n  return v;\n}\n\n/** Median of a numeric array (does not mutate input). */\nfunction median(values: readonly number[]): number {\n  const sorted = [...values].sort((a, b) => a - b);\n  const n = sorted.length;\n  if (n === 0) return 0;\n  if (n % 2 === 1) return sorted[(n - 1) / 2];\n  return 0.5 * (sorted[n / 2 - 1] + sorted[n / 2]);\n}\n\n/**\n * Hermite basis on the unit interval, evaluated at `s ∈ [0,1]`.\n *\n * Cubic Hermite interpolant of a scalar `f(τ)` over `[τ0, τ1]` with\n * endpoint values `f0, f1` and endpoint derivatives `m0, m1` (in `f` per\n * `τ`):\n *\n *     P(τ) = h00(s) f0 + h10(s) (τ1−τ0) m0 + h01(s) f1 + h11(s) (τ1−τ0) m1\n *\n * where `s = (τ − τ0)/(τ1 − τ0)` and\n *     h00 =  2s³ − 3s² + 1\n *     h10 =      s³ − 2s² + s\n *     h01 = −2s³ + 3s²\n *     h11 =      s³ −  s²\n *\n * (Numerical Recipes §3.4; Hairer/Lubich/Wanner §III.5.)\n */\nfunction hermiteEval(\n  f0: number,\n  f1: number,\n  m0: number,\n  m1: number,\n  dt: number,\n  s: number,\n): number {\n  const s2 = s * s;\n  const s3 = s2 * s;\n  const h00 =  2 * s3 - 3 * s2 + 1;\n  const h10 =      s3 - 2 * s2 + s;\n  const h01 = -2 * s3 + 3 * s2;\n  const h11 =      s3 -     s2;\n  return h00 * f0 + h10 * dt * m0 + h01 * f1 + h11 * dt * m1;\n}\n\n/**\n * Vector cubic-Hermite interpolation of a 4-coordinate `x^μ` at `τ`\n * given the two bracket endpoints and their snapshot derivatives in `τ`\n * (here: the `x` arrays, with derivative `dx/dτ` approximated by central\n * differences on neighbor snapshots — passed in by the caller).\n */\nfunction hermiteInterpVector(\n  x0: readonly number[],\n  x1: readonly number[],\n  m0: readonly number[],\n  m1: readonly number[],\n  dt: number,\n  s: number,\n): number[] {\n  const dim = x0.length;\n  const out = new Array<number>(dim);\n  for (let mu = 0; mu < dim; mu++) {\n    out[mu] = hermiteEval(x0[mu], x1[mu], m0[mu], m1[mu], dt, s);\n  }\n  return out;\n}\n\n/**\n * Bisection on the cubic-Hermite polynomial for the scalar `dr/dτ` root.\n * Operates on `s ∈ [0,1]` — the normalised bracket coordinate. Returns\n * the converged `s` and the corresponding polynomial value.\n *\n * Precision: the loop terminates when `|P(s_mid)| ≤ tauTolerance` (scaled\n * to whatever units `dr/dτ` is in — the caller passes `tauTolerance`\n * matched to the integrator scale). A hard iteration cap of 60 prevents\n * runaway on pathological inputs (60 bisections halve `s` to ≈1e-18 — well\n * below floating-point resolution).\n */\nfunction bisectCubic(\n  f0: number,\n  f1: number,\n  m0: number,\n  m1: number,\n  dt: number,\n  sInitial: number,\n  tol: number,\n): { s: number; residual: number } {\n  // Establish a bracket around sInitial. The sign-change is at the\n  // f(τ0)=f0 → f(τ1)=f1 endpoints (by construction f0 < 0, f1 > 0).\n  let sLo = 0;\n  let sHi = 1;\n  let fLo = f0;\n  let fHi = f1;\n  let s = sInitial;\n  let fs = hermiteEval(f0, f1, m0, m1, dt, s);\n\n  // If sInitial already satisfies tol, return it.\n  let absFs = fs < 0 ? -fs : fs;\n  if (absFs <= tol) return { s, residual: fs };\n\n  // Warm start: the sInitial evaluation above is otherwise discarded. Use its\n  // sign to tighten the GUARANTEED bracket before bisecting. This preserves the\n  // sign-bracket invariant (fLo < 0 < fHi) — so convergence is unaffected — and\n  // a good linear estimate yields a smaller starting interval (fewer iters).\n  if (sInitial > sLo && sInitial < sHi) {\n    if ((fs < 0) === (fLo < 0)) {\n      sLo = s;\n      fLo = fs;\n    } else {\n      sHi = s;\n      fHi = fs;\n    }\n  }\n\n  for (let iter = 0; iter < 60; iter++) {\n    // Bisect the (warm-started) bracket — robust regardless of the estimate.\n    s = 0.5 * (sLo + sHi);\n    fs = hermiteEval(f0, f1, m0, m1, dt, s);\n    absFs = fs < 0 ? -fs : fs;\n    if (absFs <= tol) return { s, residual: fs };\n    // Maintain sign-bracket: fLo < 0 < fHi.\n    if ((fs < 0) === (fLo < 0)) {\n      sLo = s;\n      fLo = fs;\n    } else {\n      sHi = s;\n      fHi = fs;\n    }\n  }\n  return { s, residual: fs };\n}\n\n/**\n * Find the perihelion (inner radial turning point) on a snapshot stream.\n *\n * See module-level docstring for the algorithm. Throws if no `−→+` sign\n * change in `dr/dτ` is found.\n *\n * **Units.** Inherited from the supplied snapshots and `gInverseFn` — the\n * finder is metric-agnostic. For the perihelion method used by catalog\n * relation be-52 on Schwarzschild:\n *   - `snapshots[i].tau` — affine parameter in **seconds** (SI, the\n *     covariant-eikonal method's null normalization, used by catalog\n *     relation be-37) or **proper-time seconds** (timelike geodesics).\n *   - `snapshots[i].x` — 4-coordinate `(t, r, θ, φ)` in\n *     **(s, m, rad, rad)** (SI).\n *   - `snapshots[i].p` — covariant momentum (units depend on the\n *     normalization; see `integrateGeodesicGL4` JSDoc).\n *   - `tauTolerance` — polynomial-residual tolerance on `dr/dτ`,\n *     therefore in **m/s** for SI Schwarzschild. Floor `1e-9` ⇒ tighter\n *     values are quietly clamped (see implementation).\n *\n * @param options — see {@link FindPerihelionOptions}:\n *   - `snapshots` — `(τ, x, p)` stream from `integrateGeodesicGL4` (units\n *     as above).\n *   - `gInverseFn(x)[μ*dim+ν]` — inverse metric `g^{μν}(x)` (flat). Same units as\n *     the matching integrator call.\n *   - `tauTolerance` — bisection target on `|P(s_root)|` measured in the\n *     units of `dr/dτ` (m/s for SI Schwarzschild).\n *   - `radialIndex` — index of `r` within `x` (default `1` — standard\n *     `(t, r, θ, φ)` ordering).\n * @returns `{ tau, x, phi }` — affine parameter, interpolated 4-coordinate,\n *   and orbital phase `φ = x[3]` at the perihelion. Units of `tau` and `x`\n *   match the inputs; `phi` is in **radians**.\n * @throws Error if `snapshots.length < 2` or no `−→+` sign change in `dr/dτ`.\n *\n * @example\n * ```typescript\n * import { findPerihelion, integrateGeodesicGL4 } from 'universal-physics-tensor';\n * import {\n *   schwarzschildDgInverseFn,\n *   schwarzschildGInverseFn,\n *   schwarzschildRs,\n * } from '../tests/fixtures/schwarzschild.js';\n *\n * const M = 1.989e30;\n * const r0 = 20 * schwarzschildRs(M); // starting radius\n * // Canonical (x, p) state: covariant momentum p = [-E, 0, 0, L] from the\n * // orbit's conserved energy E and angular momentum L (see\n * // tests/bridges/perihelion-precession.test.ts for a full setup).\n * const snapshots = integrateGeodesicGL4(\n *   { x: [0, r0, Math.PI / 2, 0], p: [-E, 0, 0, L] },\n *   {\n *     steps: 2000,\n *     tauMax: 1e6,\n *     gInverseFn: schwarzschildGInverseFn(M),\n *     dgInverseFn: schwarzschildDgInverseFn(M),\n *   },\n * );\n *\n * const perihelion = findPerihelion({\n *   snapshots,\n *   gInverseFn: schwarzschildGInverseFn(M),\n *   tauTolerance: 1e-9,\n * });\n * // perihelion.phi — azimuthal angle at closest approach (radians)\n * ```\n *\n * @public\n */\nexport function findPerihelion(options: FindPerihelionOptions): PerihelionResult {\n  const { snapshots, gInverseFn, tauTolerance, radialIndex = 1 } = options;\n  if (snapshots.length < 2) {\n    throw new Error('no perihelion bracket: need at least 2 snapshots');\n  }\n\n  // Step 1: extract dr/dτ at every snapshot.\n  const drDtau = new Array<number>(snapshots.length);\n  for (let i = 0; i < snapshots.length; i++) {\n    drDtau[i] = radialVelocity(\n      snapshots[i].x,\n      snapshots[i].p,\n      gInverseFn,\n      radialIndex,\n    );\n  }\n\n  // Step 2: locate the first `− → +` sign change.\n  // Tolerant against snapshot landing exactly at the turning point\n  // (drDtau ≈ 0): treat `≤ 0 → > 0` as a valid bracket. A snapshot with\n  // f == 0 exactly is itself the perihelion — but we still return through\n  // the Hermite path so the {x, phi} interpolation is uniform.\n  let iBracket = -1;\n  for (let i = 0; i < snapshots.length - 1; i++) {\n    if (drDtau[i] <= 0 && drDtau[i + 1] > 0) {\n      iBracket = i;\n      break;\n    }\n    if (drDtau[i] < 0 && drDtau[i + 1] >= 0) {\n      iBracket = i;\n      break;\n    }\n  }\n  if (iBracket < 0) {\n    throw new Error('no perihelion bracket: dr/dτ does not change sign − → +');\n  }\n\n  const i0 = iBracket;\n  const i1 = iBracket + 1;\n  const tau0 = snapshots[i0].tau;\n  const tau1 = snapshots[i1].tau;\n  const dt = tau1 - tau0;\n\n  // Step 3: M3 bracket-width check vs median Δτ.\n  //\n  // Plan spec literally says `< 2·h_snap`, but on a uniform-step grid\n  // every bracket equals h_snap exactly (ratio 1.0), so `< 2·h_snap` would\n  // fire on every successful call — useless as a diagnostic. The intent\n  // of M3 is to flag brackets compressed below the nominal integrator\n  // step (i.e., adaptive step-halving has run near perihelion, leaving a\n  // suspicious cluster). We compare against `h_snap` directly: the\n  // warning fires when the bracket is **narrower than the typical step**.\n  // Documented deviation; honest framing maintained — see CHANGELOG.\n  const deltas: number[] = [];\n  for (let i = 0; i < snapshots.length - 1; i++) {\n    deltas.push(snapshots[i + 1].tau - snapshots[i].tau);\n  }\n  const hSnap = median(deltas);\n  if (dt < hSnap) {\n    process.emitWarning(\n      `findPerihelion: bracket width Δτ=${dt} < h_snap=${hSnap} `\n      + `(median snapshot step) — GL4 snapshot density is too coarse to `\n      + `resolve this turning point reliably; consider re-integrating `\n      + `with finer steps.`,\n      'PerihelionBracketWidthWarning',\n    );\n  }\n\n  // Step 4: build cubic-Hermite interpolant for dr/dτ on [τ_i0, τ_i1].\n  // Endpoint derivatives (d/dτ of dr/dτ) approximated via central\n  // differences on neighboring snapshots (one-sided at boundaries).\n  const f0 = drDtau[i0];\n  const f1 = drDtau[i1];\n  const m0 = derivAt(drDtau, snapshots, i0);\n  const m1 = derivAt(drDtau, snapshots, i1);\n\n  // Initial guess: linear interpolation root, s = f0 / (f0 − f1).\n  // For a linear sign-change this is exact; for cubic it's a warm start.\n  const sLinear = f0 / (f0 - f1);\n\n  // Step 5: bisect the cubic-Hermite polynomial until residual ≤ tolerance.\n  const { s: sRoot } = bisectCubic(f0, f1, m0, m1, dt, sLinear, tauTolerance);\n\n  const tauRoot = tau0 + sRoot * dt;\n\n  // Step 6: interpolate x^μ at τ_root via cubic Hermite using the same\n  // endpoint-derivative scheme. dx^μ/dτ at endpoints comes from\n  // central-differencing neighboring snapshots' x arrays.\n  const xMomentum0 = velocityAt(snapshots, i0, gInverseFn);\n  const xMomentum1 = velocityAt(snapshots, i1, gInverseFn);\n  const xInterp = hermiteInterpVector(\n    snapshots[i0].x,\n    snapshots[i1].x,\n    xMomentum0,\n    xMomentum1,\n    dt,\n    sRoot,\n  );\n\n  return {\n    tau: tauRoot,\n    x: xInterp,\n    phi: xInterp[3] ?? 0,\n  };\n}\n\n/**\n * Central-difference estimate of `d(dr/dτ)/dτ` at snapshot index `i`.\n * One-sided at i=0 and i=N−1. Used as the Hermite endpoint slope.\n */\nfunction derivAt(\n  drDtau: readonly number[],\n  snapshots: ReadonlyArray<{ readonly tau: number }>,\n  i: number,\n): number {\n  const N = snapshots.length;\n  if (i === 0) {\n    return (drDtau[1] - drDtau[0]) / (snapshots[1].tau - snapshots[0].tau);\n  }\n  if (i === N - 1) {\n    return (drDtau[N - 1] - drDtau[N - 2])\n      / (snapshots[N - 1].tau - snapshots[N - 2].tau);\n  }\n  return (drDtau[i + 1] - drDtau[i - 1])\n    / (snapshots[i + 1].tau - snapshots[i - 1].tau);\n}\n\n/**\n * 4-velocity `v^μ = g^{μν}(x_i) p_{i,ν}` at snapshot `i`. Used as the\n * Hermite endpoint slope for the `x^μ` interpolation (since by definition\n * `dx^μ/dτ = g^{μν} p_ν` along a geodesic).\n */\nfunction velocityAt(\n  snapshots: ReadonlyArray<{ readonly x: readonly number[]; readonly p: readonly number[] }>,\n  i: number,\n  gInverseFn: (x: readonly number[]) => Float64Array,\n): number[] {\n  const x = snapshots[i].x;\n  const p = snapshots[i].p;\n  const gInv = gInverseFn(x);\n  const dim = x.length;\n  const v = new Array<number>(dim);\n  for (let mu = 0; mu < dim; mu++) {\n    let acc = 0;\n    for (let nu = 0; nu < dim; nu++) {\n      acc += gInv[mu * dim + nu] * p[nu];\n    }\n    v[mu] = acc;\n  }\n  return v;\n}\n"]}
+{"version":3,"file":"perihelion-finder.js","sourceRoot":"","sources":["../../src/numerical/perihelion-finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bisection perihelion finder via cubic-Hermite interpolation on cached\n * GL4 snapshots (v0.5.0 Task 4, Phase 1b).\n *\n * Algorithm (Design §3 Task 1b):\n *   1. Walk snapshots, extract `dr/dτ_i = g^{rν}(x_i) · p_{i,ν}` at each\n *      snapshot. Index `r` is the radial coordinate slot (index 1 by\n *      convention in (t, r, θ, φ)).\n *   2. Locate consecutive indices `(i, i+1)` where `dr/dτ` sign-changes\n *      from `−` to `+` — that is the perihelion (inner radial turning\n *      point). Sign-change `+ → −` is apoapsis and is intentionally\n *      skipped.\n *   3. **M3 bracket-width check:** if `|τ_{i+1} − τ_i| < 2 · h_snap`\n *      where `h_snap` is the median Δτ across all snapshots, emit a\n *      non-throwing `PerihelionBracketWidthWarning` via\n *      `process.emitWarning`. This indicates the GL4 step is too coarse\n *      to resolve the turning point — the caller should re-integrate\n *      with finer steps.\n *   4. Fit a **cubic Hermite polynomial** through `(τ_i, dr/dτ_i)` and\n *      `(τ_{i+1}, dr/dτ_{i+1})`, with endpoint derivatives estimated\n *      from neighboring snapshots (4 values total: f and f' at both\n *      endpoints). Find an analytic root of the cubic on [τ_i, τ_{i+1}].\n *   5. If `|P(τ_root)| > tauTolerance`, refine with **Brent's method on the\n *      polynomial** (MathTS `findRoot`, not re-integration — Adam+Eve\n *      I6/F11 — that would cost a full GL4 sweep per step, which defeats\n *      the cached-snapshot approach). `tauTolerance` is a RESIDUAL tolerance\n *      in the units of dr/dτ, so the search is run with `xtol: 0`\n *      (`@danielsimonjr/mathts-functions` ≥ 0.68.3): the solver stops on\n *      `|P| ≤ tauTolerance` alone, never on the bracket width in `s`.\n *      Precision floor: 1e-9 × T_orbit (Adam+Eve I1 — 1e-12 is wasted\n *      effort given the integrator's per-step error is already > 1e-12).\n *   6. Return `{ tau, x, phi }` where `x` is the cubic-Hermite-interpolated\n *      4-coordinate at the root and `phi = x[3]`.\n *\n * **Throws** `Error(\"no perihelion bracket\")` if no `−→+` sign-change is\n * found in the snapshot range.\n *\n * @module numerical/perihelion-finder\n */\nimport { findRoot, hermiteInterp, median } from '@danielsimonjr/mathts-functions';\nimport { numberFrom } from '../core/mathts-read.js';\n\n/**\n * Result of `findPerihelion`: the τ at the radial turning point, the\n * interpolated 4-coordinate, and the orbital phase `phi = x[3]`.\n *\n * @public\n */\nexport interface PerihelionResult {\n  /** Proper time at the perihelion. */\n  readonly tau: number;\n  /** Interpolated 4-coordinate x^μ at τ_perihelion. */\n  readonly x: readonly number[];\n  /** Orbital phase φ = x[3] at τ_perihelion. */\n  readonly phi: number;\n}\n\n/**\n * Options for {@link findPerihelion}.\n *\n * @public\n */\nexport interface FindPerihelionOptions {\n  /** Snapshots produced by `integrateGeodesicGL4` (or any compatible\n   *  `(τ, x, p)` snapshot stream — only `tau`, `x`, `p` are read). */\n  readonly snapshots: ReadonlyArray<{\n    readonly tau: number;\n    readonly x: readonly number[];\n    readonly p: readonly number[];\n  }>;\n  /** Inverse-metric closure (v0.9.0 O-1 flat layout):\n   *  `gInverseFn(x)[μ*dim + ν] = g^{μν}(x)`, Float64Array(dim²). Used to\n   *  compute `dr/dτ = g^{rν}(x) p_ν` at each snapshot. */\n  readonly gInverseFn: (x: readonly number[]) => Float64Array;\n  /** Polynomial-bisection target tolerance on the cubic-Hermite root —\n   *  measured as `|P(τ_root)|`, not `|τ − τ_true|`. Precision floor 1e-9\n   *  per Adam+Eve I1; tighter values just waste bisections. */\n  readonly tauTolerance: number;\n  /** Coordinate index used as the \"radial\" slot. Defaults to 1\n   *  ((t, r, θ, φ) convention). */\n  readonly radialIndex?: number;\n}\n\n/** Compute `dr/dτ = g^{rν}(x) p_ν` at a single snapshot. */\nfunction radialVelocity(\n  x: readonly number[],\n  p: readonly number[],\n  gInverseFn: (x: readonly number[]) => Float64Array,\n  r: number,\n): number {\n  const gInv = gInverseFn(x);\n  const dim = p.length;\n  let v = 0;\n  for (let nu = 0; nu < dim; nu++) {\n    v += gInv[r * dim + nu] * p[nu];\n  }\n  return v;\n}\n\n/** Median of the snapshot steps, MathTS `median` (0 for no steps, as before). */\nfunction medianStep(values: readonly number[]): number {\n  if (values.length === 0) return 0;\n  return numberFrom('median', median([...values]));\n}\n\n/**\n * The cubic Hermite interpolant of a scalar `f(τ)` over `[τ0, τ1]` with\n * endpoint values `f0, f1` and endpoint derivatives `m0, m1` (in `f` per\n * `τ`), at `s = (τ − τ0)/(τ1 − τ0)`: MathTS `hermiteInterp` on the two\n * nodes `0` and `1` of the unit interval, where the derivatives are\n * `(τ1 − τ0) m`. With two nodes that interpolant IS the cubic\n *\n *     P = h00(s) f0 + h10(s) (τ1−τ0) m0 + h01(s) f1 + h11(s) (τ1−τ0) m1\n *\n * (Numerical Recipes §3.4; Hairer/Lubich/Wanner §III.5.)\n */\nfunction hermiteEval(\n  f0: number,\n  f1: number,\n  m0: number,\n  m1: number,\n  dt: number,\n  s: number,\n): number {\n  return hermiteInterp([0, 1], [f0, f1], [dt * m0, dt * m1], s);\n}\n\n/**\n * Vector cubic-Hermite interpolation of a 4-coordinate `x^μ` at `τ`\n * given the two bracket endpoints and their snapshot derivatives in `τ`\n * (here: the `x` arrays, with derivative `dx/dτ` approximated by central\n * differences on neighbor snapshots — passed in by the caller).\n */\nfunction hermiteInterpVector(\n  x0: readonly number[],\n  x1: readonly number[],\n  m0: readonly number[],\n  m1: readonly number[],\n  dt: number,\n  s: number,\n): number[] {\n  const dim = x0.length;\n  const out = new Array<number>(dim);\n  for (let mu = 0; mu < dim; mu++) {\n    out[mu] = hermiteEval(x0[mu], x1[mu], m0[mu], m1[mu], dt, s);\n  }\n  return out;\n}\n\n/**\n * The root of the cubic-Hermite polynomial for the scalar `dr/dτ`, on the\n * normalised bracket coordinate `s ∈ [0,1]`, by MathTS `findRoot` (Brent).\n * Returns the converged `s` and the polynomial value there.\n *\n * Precision: `tol` is a residual tolerance in the units of `dr/dτ` (the\n * caller passes `tauTolerance`, matched to the integrator scale), so the\n * solver runs with `xtol: 0` and stops on `|P(s)| ≤ tol` alone, never on\n * the bracket width in `s`. `sInitial` (the linear estimate) is tried first\n * and returned when it already meets `tol`. A hard iteration cap of 100\n * bounds a tolerance the polynomial cannot meet in floating point; the\n * solver then returns its best point.\n */\nfunction rootOnCubic(\n  f0: number,\n  f1: number,\n  m0: number,\n  m1: number,\n  dt: number,\n  sInitial: number,\n  tol: number,\n): { s: number; residual: number } {\n  const P = (s: number): number => hermiteEval(f0, f1, m0, m1, dt, s);\n  const atStart = P(sInitial);\n  if (Math.abs(atStart) <= tol) return { s: sInitial, residual: atStart };\n  // By construction f(0) = f0 ≤ 0 < f1 = f(1) (or f0 < 0 ≤ f1), the sign change `findRoot` requires.\n  const s = findRoot(P, 0, 1, { tol, xtol: 0, maxIter: 100 });\n  return { s, residual: P(s) };\n}\n\n/**\n * Find the perihelion (inner radial turning point) on a snapshot stream.\n *\n * See module-level docstring for the algorithm. Throws if no `−→+` sign\n * change in `dr/dτ` is found.\n *\n * **Units.** Inherited from the supplied snapshots and `gInverseFn` — the\n * finder is metric-agnostic. For the perihelion method used by catalog\n * relation be-52 on Schwarzschild:\n *   - `snapshots[i].tau` — affine parameter in **seconds** (SI, the\n *     covariant-eikonal method's null normalization, used by catalog\n *     relation be-37) or **proper-time seconds** (timelike geodesics).\n *   - `snapshots[i].x` — 4-coordinate `(t, r, θ, φ)` in\n *     **(s, m, rad, rad)** (SI).\n *   - `snapshots[i].p` — covariant momentum (units depend on the\n *     normalization; see `integrateGeodesicGL4` JSDoc).\n *   - `tauTolerance` — polynomial-residual tolerance on `dr/dτ`,\n *     therefore in **m/s** for SI Schwarzschild. Floor `1e-9` ⇒ tighter\n *     values are quietly clamped (see implementation).\n *\n * @param options — see {@link FindPerihelionOptions}:\n *   - `snapshots` — `(τ, x, p)` stream from `integrateGeodesicGL4` (units\n *     as above).\n *   - `gInverseFn(x)[μ*dim+ν]` — inverse metric `g^{μν}(x)` (flat). Same units as\n *     the matching integrator call.\n *   - `tauTolerance` — bisection target on `|P(s_root)|` measured in the\n *     units of `dr/dτ` (m/s for SI Schwarzschild).\n *   - `radialIndex` — index of `r` within `x` (default `1` — standard\n *     `(t, r, θ, φ)` ordering).\n * @returns `{ tau, x, phi }` — affine parameter, interpolated 4-coordinate,\n *   and orbital phase `φ = x[3]` at the perihelion. Units of `tau` and `x`\n *   match the inputs; `phi` is in **radians**.\n * @throws Error if `snapshots.length < 2` or no `−→+` sign change in `dr/dτ`.\n *\n * @example\n * ```typescript\n * import { findPerihelion, integrateGeodesicGL4 } from 'universal-physics-tensor';\n * import {\n *   schwarzschildDgInverseFn,\n *   schwarzschildGInverseFn,\n *   schwarzschildRs,\n * } from '../tests/fixtures/schwarzschild.js';\n *\n * const M = 1.989e30;\n * const r0 = 20 * schwarzschildRs(M); // starting radius\n * // Canonical (x, p) state: covariant momentum p = [-E, 0, 0, L] from the\n * // orbit's conserved energy E and angular momentum L (see\n * // tests/bridges/perihelion-precession.test.ts for a full setup).\n * const snapshots = integrateGeodesicGL4(\n *   { x: [0, r0, Math.PI / 2, 0], p: [-E, 0, 0, L] },\n *   {\n *     steps: 2000,\n *     tauMax: 1e6,\n *     gInverseFn: schwarzschildGInverseFn(M),\n *     dgInverseFn: schwarzschildDgInverseFn(M),\n *   },\n * );\n *\n * const perihelion = findPerihelion({\n *   snapshots,\n *   gInverseFn: schwarzschildGInverseFn(M),\n *   tauTolerance: 1e-9,\n * });\n * // perihelion.phi — azimuthal angle at closest approach (radians)\n * ```\n *\n * @public\n */\nexport function findPerihelion(options: FindPerihelionOptions): PerihelionResult {\n  const { snapshots, gInverseFn, tauTolerance, radialIndex = 1 } = options;\n  if (snapshots.length < 2) {\n    throw new Error('no perihelion bracket: need at least 2 snapshots');\n  }\n\n  // Step 1: extract dr/dτ at every snapshot.\n  const drDtau = new Array<number>(snapshots.length);\n  for (let i = 0; i < snapshots.length; i++) {\n    drDtau[i] = radialVelocity(\n      snapshots[i].x,\n      snapshots[i].p,\n      gInverseFn,\n      radialIndex,\n    );\n  }\n\n  // Step 2: locate the first `− → +` sign change.\n  // Tolerant against snapshot landing exactly at the turning point\n  // (drDtau ≈ 0): treat `≤ 0 → > 0` as a valid bracket. A snapshot with\n  // f == 0 exactly is itself the perihelion — but we still return through\n  // the Hermite path so the {x, phi} interpolation is uniform.\n  let iBracket = -1;\n  for (let i = 0; i < snapshots.length - 1; i++) {\n    if (drDtau[i] <= 0 && drDtau[i + 1] > 0) {\n      iBracket = i;\n      break;\n    }\n    if (drDtau[i] < 0 && drDtau[i + 1] >= 0) {\n      iBracket = i;\n      break;\n    }\n  }\n  if (iBracket < 0) {\n    throw new Error('no perihelion bracket: dr/dτ does not change sign − → +');\n  }\n\n  const i0 = iBracket;\n  const i1 = iBracket + 1;\n  const tau0 = snapshots[i0].tau;\n  const tau1 = snapshots[i1].tau;\n  const dt = tau1 - tau0;\n\n  // Step 3: M3 bracket-width check vs median Δτ.\n  //\n  // Plan spec literally says `< 2·h_snap`, but on a uniform-step grid\n  // every bracket equals h_snap exactly (ratio 1.0), so `< 2·h_snap` would\n  // fire on every successful call — useless as a diagnostic. The intent\n  // of M3 is to flag brackets compressed below the nominal integrator\n  // step (i.e., adaptive step-halving has run near perihelion, leaving a\n  // suspicious cluster). We compare against `h_snap` directly: the\n  // warning fires when the bracket is **narrower than the typical step**.\n  // Documented deviation; honest framing maintained — see CHANGELOG.\n  const deltas: number[] = [];\n  for (let i = 0; i < snapshots.length - 1; i++) {\n    deltas.push(snapshots[i + 1].tau - snapshots[i].tau);\n  }\n  const hSnap = medianStep(deltas);\n  if (dt < hSnap) {\n    process.emitWarning(\n      `findPerihelion: bracket width Δτ=${dt} < h_snap=${hSnap} `\n      + `(median snapshot step) — GL4 snapshot density is too coarse to `\n      + `resolve this turning point reliably; consider re-integrating `\n      + `with finer steps.`,\n      'PerihelionBracketWidthWarning',\n    );\n  }\n\n  // Step 4: build cubic-Hermite interpolant for dr/dτ on [τ_i0, τ_i1].\n  // Endpoint derivatives (d/dτ of dr/dτ) approximated via central\n  // differences on neighboring snapshots (one-sided at boundaries).\n  const f0 = drDtau[i0];\n  const f1 = drDtau[i1];\n  const m0 = derivAt(drDtau, snapshots, i0);\n  const m1 = derivAt(drDtau, snapshots, i1);\n\n  // Initial guess: linear interpolation root, s = f0 / (f0 − f1).\n  // For a linear sign-change this is exact; for cubic it's a warm start.\n  const sLinear = f0 / (f0 - f1);\n\n  // Step 5: solve the cubic-Hermite polynomial until residual ≤ tolerance.\n  const { s: sRoot } = rootOnCubic(f0, f1, m0, m1, dt, sLinear, tauTolerance);\n\n  const tauRoot = tau0 + sRoot * dt;\n\n  // Step 6: interpolate x^μ at τ_root via cubic Hermite using the same\n  // endpoint-derivative scheme. dx^μ/dτ at endpoints comes from\n  // central-differencing neighboring snapshots' x arrays.\n  const xMomentum0 = velocityAt(snapshots, i0, gInverseFn);\n  const xMomentum1 = velocityAt(snapshots, i1, gInverseFn);\n  const xInterp = hermiteInterpVector(\n    snapshots[i0].x,\n    snapshots[i1].x,\n    xMomentum0,\n    xMomentum1,\n    dt,\n    sRoot,\n  );\n\n  return {\n    tau: tauRoot,\n    x: xInterp,\n    phi: xInterp[3] ?? 0,\n  };\n}\n\n/**\n * Central-difference estimate of `d(dr/dτ)/dτ` at snapshot index `i`.\n * One-sided at i=0 and i=N−1. Used as the Hermite endpoint slope.\n */\nfunction derivAt(\n  drDtau: readonly number[],\n  snapshots: ReadonlyArray<{ readonly tau: number }>,\n  i: number,\n): number {\n  const N = snapshots.length;\n  if (i === 0) {\n    return (drDtau[1] - drDtau[0]) / (snapshots[1].tau - snapshots[0].tau);\n  }\n  if (i === N - 1) {\n    return (drDtau[N - 1] - drDtau[N - 2])\n      / (snapshots[N - 1].tau - snapshots[N - 2].tau);\n  }\n  return (drDtau[i + 1] - drDtau[i - 1])\n    / (snapshots[i + 1].tau - snapshots[i - 1].tau);\n}\n\n/**\n * 4-velocity `v^μ = g^{μν}(x_i) p_{i,ν}` at snapshot `i`. Used as the\n * Hermite endpoint slope for the `x^μ` interpolation (since by definition\n * `dx^μ/dτ = g^{μν} p_ν` along a geodesic).\n */\nfunction velocityAt(\n  snapshots: ReadonlyArray<{ readonly x: readonly number[]; readonly p: readonly number[] }>,\n  i: number,\n  gInverseFn: (x: readonly number[]) => Float64Array,\n): number[] {\n  const x = snapshots[i].x;\n  const p = snapshots[i].p;\n  const gInv = gInverseFn(x);\n  const dim = x.length;\n  const v = new Array<number>(dim);\n  for (let mu = 0; mu < dim; mu++) {\n    let acc = 0;\n    for (let nu = 0; nu < dim; nu++) {\n      acc += gInv[mu * dim + nu] * p[nu];\n    }\n    v[mu] = acc;\n  }\n  return v;\n}\n"]}

package/dist/numerical/quadrature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quadrature.d.ts","sourceRoot":"","sources":["../../src/numerical/quadrature.ts"],"names":[],"mappings":"AAqBA,yFAAyF;AACzF,UAAU,iBAAiB;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAgBD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,iBAAiB,CAG7D,CAAC;AAEH;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAmBR"}
+{"version":3,"file":"quadrature.d.ts","sourceRoot":"","sources":["../../src/numerical/quadrature.ts"],"names":[],"mappings":"AAsBA,yFAAyF;AACzF,UAAU,iBAAiB;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAcD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,iBAAiB,CAG7D,CAAC;AAEH;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAmBR"}

package/dist/numerical/quadrature.js

@@ -17,18 +17,16 @@
  *
  * @module numerical/quadrature
  */
-import { rootsLegendre } from '@danielsimonjr/mathts-functions';
+import { legendreP, rootsLegendre } from '@danielsimonjr/mathts-functions';
+import { numberFrom } from '../core/mathts-read.js';
 const legendre16 = rootsLegendre(16);
-/** P₁₆'(x) by the three-term recurrence, for the weight formula. */
+/** `Pₙ(x)`, MathTS `legendreP`, read back as the number it is for a number. */
+function legendre(n, x) {
+    return numberFrom('legendreP', legendreP(n, x));
+}
+/** P₁₆'(x) = 16 (x P₁₆(x) − P₁₅(x)) / (x² − 1), the derivative identity on MathTS `legendreP`. */
 function legendre16Derivative(x) {
-    let p0 = 1;
-    let p1 = x;
-    for (let k = 2; k <= 16; k++) {
-        const p2 = ((2 * k - 1) * x * p1 - (k - 1) * p0) / k;
-        p0 = p1;
-        p1 = p2;
-    }
-    return (16 * (x * p1 - p0)) / (x * x - 1);
+    return (16 * (x * legendre(16, x) - legendre(15, x))) / (x * x - 1);
 }
 /**
  * 16-point Gauss–Legendre nodes and weights on [−1, 1] (Σ weights = 2). The

package/dist/numerical/quadrature.js.map

@@ -1 +1 @@
-{"version":3,"file":"quadrature.js","sourceRoot":"","sources":["../../src/numerical/quadrature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAQhE,MAAM,UAAU,GAAG,aAAa,CAAC,EAAE,CAAC,CAAC;AAErC,oEAAoE;AACpE,SAAS,oBAAoB,CAAC,CAAS;IACrC,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7B,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QACrD,EAAE,GAAG,EAAE,CAAC;QACR,EAAE,GAAG,EAAE,CAAC;IACV,CAAC;IACD,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAqC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;IAC/F,MAAM,EAAE,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;AAC7D,CAAC,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,CAAwB,EACxB,CAAS,EACT,CAAS;IAET,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,UAAU,CAClB,mEAAmE,CAAC,KAAK,CAAC,IAAI,CAC/E,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACzB,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;QACjD,GAAG,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC;IACvC,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,GAAG,GAAG,CAAC;IAC1B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAClB,mEAAmE,MAAM,SAAS,CAAC,KAAK,CAAC,IAAI,CAC9F,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * Gauss–Legendre quadrature — shared between the numerical AST lowering and the\n * traced reverse-mode-AD lowering of definite `integral` nodes.\n *\n * 16-point Gauss–Legendre on [−1, 1]: exact for polynomials of degree ≤ 31, and\n * highly accurate for smooth integrands (√, exp, trig away from singularities).\n * It is NOT reliable for highly oscillatory integrands or singularities at/near\n * the bounds — those are out of scope for the differentiable-integral feature.\n *\n * The affine map from [−1, 1] to [a, b] is x = (b−a)/2·ξ + (a+b)/2 with Jacobian\n * (b−a)/2, so ∫ₐᵇ f dx ≈ (b−a)/2 · Σᵢ wᵢ·f(xᵢ). For b < a the (b−a)/2 factor is\n * negative, giving the correct signed integral (∫ₐᵇ = −∫ᵦᵃ).\n *\n * The nodes are MathTS `rootsLegendre(16)`. `gaussQuad` is not this rule: its\n * single-interval order is only 2–5, and a larger `n` is that many panels of\n * order 5. `quad` is adaptive Gauss–Kronrod, not a fixed degree.\n *\n * @module numerical/quadrature\n */\nimport { rootsLegendre } from '@danielsimonjr/mathts-functions';\n\n/** A Gauss–Legendre abscissa/weight pair on the reference interval [−1, 1]. @internal */\ninterface GaussLegendreNode {\n  readonly node: number;\n  readonly weight: number;\n}\n\nconst legendre16 = rootsLegendre(16);\n\n/** P₁₆'(x) by the three-term recurrence, for the weight formula. */\nfunction legendre16Derivative(x: number): number {\n  let p0 = 1;\n  let p1 = x;\n  for (let k = 2; k <= 16; k++) {\n    const p2 = ((2 * k - 1) * x * p1 - (k - 1) * p0) / k;\n    p0 = p1;\n    p1 = p2;\n  }\n  return (16 * (x * p1 - p0)) / (x * x - 1);\n}\n\n/**\n * 16-point Gauss–Legendre nodes and weights on [−1, 1] (Σ weights = 2). The\n * nodes are MathTS `rootsLegendre(16)`'s. The weights are the closed form\n * `2 / ((1 − x²) P₁₆'(x)²)` on those nodes: MathTS's tabulated weights carried a\n * relative error of 8e-14 (Σ = 1.9999999999999956), 400 times the double\n * precision the degree-31 exactness claim rests on (Tom's second round).\n */\nexport const GAUSS_LEGENDRE_16: ReadonlyArray<GaussLegendreNode> = legendre16.nodes.map((node) => {\n  const dp = legendre16Derivative(node);\n  return { node, weight: 2 / ((1 - node * node) * dp * dp) };\n});\n\n/**\n * Evaluate the definite integral ∫ₐᵇ f(x) dx by 16-point Gauss–Legendre\n * quadrature. `f` is sampled at the 16 mapped abscissae.\n */\nexport function integrateGaussLegendre(\n  f: (x: number) => number,\n  a: number,\n  b: number,\n): number {\n  if (!Number.isFinite(a) || !Number.isFinite(b)) {\n    throw new RangeError(\n      `integrateGaussLegendre: integration bounds must be finite, got [${a}, ${b}].`,\n    );\n  }\n  const half = (b - a) / 2;\n  const mid = (a + b) / 2;\n  let sum = 0;\n  for (const { node, weight } of GAUSS_LEGENDRE_16) {\n    sum += weight * f(half * node + mid);\n  }\n  const result = half * sum;\n  if (!Number.isFinite(result)) {\n    throw new RangeError(\n      `integrateGaussLegendre: integrand produced a non-finite result (${result}) on [${a}, ${b}].`,\n    );\n  }\n  return result;\n}\n"]}
+{"version":3,"file":"quadrature.js","sourceRoot":"","sources":["../../src/numerical/quadrature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAQpD,MAAM,UAAU,GAAG,aAAa,CAAC,EAAE,CAAC,CAAC;AAErC,+EAA+E;AAC/E,SAAS,QAAQ,CAAC,CAAS,EAAE,CAAS;IACpC,OAAO,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC;AAED,kGAAkG;AAClG,SAAS,oBAAoB,CAAC,CAAS;IACrC,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAqC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;IAC/F,MAAM,EAAE,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;AAC7D,CAAC,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,CAAwB,EACxB,CAAS,EACT,CAAS;IAET,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,UAAU,CAClB,mEAAmE,CAAC,KAAK,CAAC,IAAI,CAC/E,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACzB,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;QACjD,GAAG,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC;IACvC,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,GAAG,GAAG,CAAC;IAC1B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAClB,mEAAmE,MAAM,SAAS,CAAC,KAAK,CAAC,IAAI,CAC9F,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * Gauss–Legendre quadrature — shared between the numerical AST lowering and the\n * traced reverse-mode-AD lowering of definite `integral` nodes.\n *\n * 16-point Gauss–Legendre on [−1, 1]: exact for polynomials of degree ≤ 31, and\n * highly accurate for smooth integrands (√, exp, trig away from singularities).\n * It is NOT reliable for highly oscillatory integrands or singularities at/near\n * the bounds — those are out of scope for the differentiable-integral feature.\n *\n * The affine map from [−1, 1] to [a, b] is x = (b−a)/2·ξ + (a+b)/2 with Jacobian\n * (b−a)/2, so ∫ₐᵇ f dx ≈ (b−a)/2 · Σᵢ wᵢ·f(xᵢ). For b < a the (b−a)/2 factor is\n * negative, giving the correct signed integral (∫ₐᵇ = −∫ᵦᵃ).\n *\n * The nodes are MathTS `rootsLegendre(16)`. `gaussQuad` is not this rule: its\n * single-interval order is only 2–5, and a larger `n` is that many panels of\n * order 5. `quad` is adaptive Gauss–Kronrod, not a fixed degree.\n *\n * @module numerical/quadrature\n */\nimport { legendreP, rootsLegendre } from '@danielsimonjr/mathts-functions';\nimport { numberFrom } from '../core/mathts-read.js';\n\n/** A Gauss–Legendre abscissa/weight pair on the reference interval [−1, 1]. @internal */\ninterface GaussLegendreNode {\n  readonly node: number;\n  readonly weight: number;\n}\n\nconst legendre16 = rootsLegendre(16);\n\n/** `Pₙ(x)`, MathTS `legendreP`, read back as the number it is for a number. */\nfunction legendre(n: number, x: number): number {\n  return numberFrom('legendreP', legendreP(n, x));\n}\n\n/** P₁₆'(x) = 16 (x P₁₆(x) − P₁₅(x)) / (x² − 1), the derivative identity on MathTS `legendreP`. */\nfunction legendre16Derivative(x: number): number {\n  return (16 * (x * legendre(16, x) - legendre(15, x))) / (x * x - 1);\n}\n\n/**\n * 16-point Gauss–Legendre nodes and weights on [−1, 1] (Σ weights = 2). The\n * nodes are MathTS `rootsLegendre(16)`'s. The weights are the closed form\n * `2 / ((1 − x²) P₁₆'(x)²)` on those nodes: MathTS's tabulated weights carried a\n * relative error of 8e-14 (Σ = 1.9999999999999956), 400 times the double\n * precision the degree-31 exactness claim rests on (Tom's second round).\n */\nexport const GAUSS_LEGENDRE_16: ReadonlyArray<GaussLegendreNode> = legendre16.nodes.map((node) => {\n  const dp = legendre16Derivative(node);\n  return { node, weight: 2 / ((1 - node * node) * dp * dp) };\n});\n\n/**\n * Evaluate the definite integral ∫ₐᵇ f(x) dx by 16-point Gauss–Legendre\n * quadrature. `f` is sampled at the 16 mapped abscissae.\n */\nexport function integrateGaussLegendre(\n  f: (x: number) => number,\n  a: number,\n  b: number,\n): number {\n  if (!Number.isFinite(a) || !Number.isFinite(b)) {\n    throw new RangeError(\n      `integrateGaussLegendre: integration bounds must be finite, got [${a}, ${b}].`,\n    );\n  }\n  const half = (b - a) / 2;\n  const mid = (a + b) / 2;\n  let sum = 0;\n  for (const { node, weight } of GAUSS_LEGENDRE_16) {\n    sum += weight * f(half * node + mid);\n  }\n  const result = half * sum;\n  if (!Number.isFinite(result)) {\n    throw new RangeError(\n      `integrateGaussLegendre: integrand produced a non-finite result (${result}) on [${a}, ${b}].`,\n    );\n  }\n  return result;\n}\n"]}

package/dist/numerical/rk4-trajectory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Integrate `dy/dt = system(t, y)` from `t0` to `t1` in `steps` fixed RK4
+ * steps and return the `steps + 1` states, the first being `y0`.
+ *
+ * @throws NumericalBackendError if `steps` is not a positive integer, or the
+ *   run did not produce exactly `steps + 1` states.
+ * @internal
+ */
+export declare function rk4Trajectory(system: (t: number, y: ReadonlyArray<number>) => number[], y0: ReadonlyArray<number>, t0: number, t1: number, steps: number): number[][];
+//# sourceMappingURL=rk4-trajectory.d.ts.map

package/dist/numerical/rk4-trajectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rk4-trajectory.d.ts","sourceRoot":"","sources":["../../src/numerical/rk4-trajectory.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,EAAE,EACzD,EAAE,EAAE,aAAa,CAAC,MAAM,CAAC,EACzB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,EAAE,CAcZ"}

package/dist/numerical/rk4-trajectory.js

@@ -0,0 +1,37 @@
+/**
+ * Fixed-step classical RK4 that keeps EVERY state of the run: the one owner of
+ * the fixed-step count. `integrateRK4` (`null-ray-integrator.ts`) returns its
+ * last state and `integrateGeodesic` (`geodesic-integrator.ts`) samples its
+ * states; callers that read a quantity off the whole motion (a supremum over a
+ * window, a zero crossing) call it directly. A caller that re-entered a
+ * one-step integrator once per sample would not reproduce one continuous
+ * fixed-step run (`tests/numerical/rk4-trajectory.test.ts`).
+ *
+ * @module numerical/rk4-trajectory
+ */
+import { solveODESystem } from '@danielsimonjr/mathts-functions';
+import { NumericalBackendError } from './errors.js';
+/**
+ * Integrate `dy/dt = system(t, y)` from `t0` to `t1` in `steps` fixed RK4
+ * steps and return the `steps + 1` states, the first being `y0`.
+ *
+ * @throws NumericalBackendError if `steps` is not a positive integer, or the
+ *   run did not produce exactly `steps + 1` states.
+ * @internal
+ */
+export function rk4Trajectory(system, y0, t0, t1, steps) {
+    if (!Number.isInteger(steps) || steps <= 0) {
+        throw new NumericalBackendError(`rk4Trajectory: step count must be a positive integer, got ${steps}`);
+    }
+    // From @danielsimonjr/mathts-functions 0.68.5 (MathTS #371) a `span/dt` that is a whole number
+    // up to rounding takes exactly that many steps of span/n and ends on t1; before it, `ceil`
+    // could add one smaller step, and this module nudged `dt` by 4ε to avoid it. The count is
+    // still checked, so a regression in MathTS is refused here, not integrated.
+    const h = (t1 - t0) / steps;
+    const sol = solveODESystem(system, [...y0], [t0, t1], { dt: h });
+    if (sol.y.length !== steps + 1) {
+        throw new NumericalBackendError(`rk4Trajectory: expected ${steps + 1} states, got ${sol.y.length}`);
+    }
+    return sol.y.map((state) => [...state]);
+}
+//# sourceMappingURL=rk4-trajectory.js.map

package/dist/numerical/rk4-trajectory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rk4-trajectory.js","sourceRoot":"","sources":["../../src/numerical/rk4-trajectory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAyD,EACzD,EAAyB,EACzB,EAAU,EACV,EAAU,EACV,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,qBAAqB,CAAC,6DAA6D,KAAK,EAAE,CAAC,CAAC;IACxG,CAAC;IACD,+FAA+F;IAC/F,2FAA2F;IAC3F,0FAA0F;IAC1F,4EAA4E;IAC5E,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC;IAC5B,MAAM,GAAG,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;IACjE,IAAI,GAAG,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,qBAAqB,CAAC,2BAA2B,KAAK,GAAG,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IACtG,CAAC;IACD,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["/**\n * Fixed-step classical RK4 that keeps EVERY state of the run: the one owner of\n * the fixed-step count. `integrateRK4` (`null-ray-integrator.ts`) returns its\n * last state and `integrateGeodesic` (`geodesic-integrator.ts`) samples its\n * states; callers that read a quantity off the whole motion (a supremum over a\n * window, a zero crossing) call it directly. A caller that re-entered a\n * one-step integrator once per sample would not reproduce one continuous\n * fixed-step run (`tests/numerical/rk4-trajectory.test.ts`).\n *\n * @module numerical/rk4-trajectory\n */\nimport { solveODESystem } from '@danielsimonjr/mathts-functions';\nimport { NumericalBackendError } from './errors.js';\n\n/**\n * Integrate `dy/dt = system(t, y)` from `t0` to `t1` in `steps` fixed RK4\n * steps and return the `steps + 1` states, the first being `y0`.\n *\n * @throws NumericalBackendError if `steps` is not a positive integer, or the\n *   run did not produce exactly `steps + 1` states.\n * @internal\n */\nexport function rk4Trajectory(\n  system: (t: number, y: ReadonlyArray<number>) => number[],\n  y0: ReadonlyArray<number>,\n  t0: number,\n  t1: number,\n  steps: number,\n): number[][] {\n  if (!Number.isInteger(steps) || steps <= 0) {\n    throw new NumericalBackendError(`rk4Trajectory: step count must be a positive integer, got ${steps}`);\n  }\n  // From @danielsimonjr/mathts-functions 0.68.5 (MathTS #371) a `span/dt` that is a whole number\n  // up to rounding takes exactly that many steps of span/n and ends on t1; before it, `ceil`\n  // could add one smaller step, and this module nudged `dt` by 4ε to avoid it. The count is\n  // still checked, so a regression in MathTS is refused here, not integrated.\n  const h = (t1 - t0) / steps;\n  const sol = solveODESystem(system, [...y0], [t0, t1], { dt: h });\n  if (sol.y.length !== steps + 1) {\n    throw new NumericalBackendError(`rk4Trajectory: expected ${steps + 1} states, got ${sol.y.length}`);\n  }\n  return sol.y.map((state) => [...state]);\n}\n"]}

package/dist/numerical/schwarzschild.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The Schwarzschild radius, once.
+ *
+ * `r_s = 2GM/c²` was written at five sites (the covariant eikonal, the
+ * Painlevé–Gullstrand metric, the flat Christoffel closure and the metric
+ * library twice), each with its own constants. One function holds the
+ * formula; the constants default to the SI values and a caller that works
+ * in other units passes its own.
+ *
+ * @module numerical/schwarzschild
+ */
+/** `r_s = 2GM/c²` for a mass `M` (kg), with `G` and `c` in SI unless a caller passes its own. @internal */
+export declare function schwarzschildRadius(M: number, G?: number, c?: number): number;
+//# sourceMappingURL=schwarzschild.d.ts.map

package/dist/numerical/schwarzschild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schwarzschild.d.ts","sourceRoot":"","sources":["../../src/numerical/schwarzschild.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,2GAA2G;AAC3G,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,MAAa,EAAE,CAAC,GAAE,MAAa,GAAG,MAAM,CAEzF"}

package/dist/numerical/schwarzschild.js

@@ -0,0 +1,17 @@
+/**
+ * The Schwarzschild radius, once.
+ *
+ * `r_s = 2GM/c²` was written at five sites (the covariant eikonal, the
+ * Painlevé–Gullstrand metric, the flat Christoffel closure and the metric
+ * library twice), each with its own constants. One function holds the
+ * formula; the constants default to the SI values and a caller that works
+ * in other units passes its own.
+ *
+ * @module numerical/schwarzschild
+ */
+import { C_SI, G_SI } from '../core/constants.js';
+/** `r_s = 2GM/c²` for a mass `M` (kg), with `G` and `c` in SI unless a caller passes its own. @internal */
+export function schwarzschildRadius(M, G = G_SI, c = C_SI) {
+    return (2 * G * M) / (c * c);
+}
+//# sourceMappingURL=schwarzschild.js.map

package/dist/numerical/schwarzschild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schwarzschild.js","sourceRoot":"","sources":["../../src/numerical/schwarzschild.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAElD,2GAA2G;AAC3G,MAAM,UAAU,mBAAmB,CAAC,CAAS,EAAE,CAAC,GAAW,IAAI,EAAE,CAAC,GAAW,IAAI;IAC/E,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/B,CAAC","sourcesContent":["/**\n * The Schwarzschild radius, once.\n *\n * `r_s = 2GM/c²` was written at five sites (the covariant eikonal, the\n * Painlevé–Gullstrand metric, the flat Christoffel closure and the metric\n * library twice), each with its own constants. One function holds the\n * formula; the constants default to the SI values and a caller that works\n * in other units passes its own.\n *\n * @module numerical/schwarzschild\n */\n\nimport { C_SI, G_SI } from '../core/constants.js';\n\n/** `r_s = 2GM/c²` for a mass `M` (kg), with `G` and `c` in SI unless a caller passes its own. @internal */\nexport function schwarzschildRadius(M: number, G: number = G_SI, c: number = C_SI): number {\n  return (2 * G * M) / (c * c);\n}\n"]}