@math.gl/core 5.0.0-alpha.11 → 5.0.0-alpha.13

package/src/gl-matrix/quat.ts

@@ -1,3 +1,8 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 // @eslint-disable
 // @ts-nocheck
 

package/src/gl-matrix/vec2.ts

@@ -1,3 +1,8 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 // @eslint-disable
 // @ts-nocheck
 

package/src/gl-matrix/vec3.ts

@@ -1,3 +1,8 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 // @eslint-disable
 // @ts-nocheck
 

package/src/gl-matrix/vec4.ts

@@ -1,3 +1,8 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 // @eslint-disable
 // @ts-nocheck
 

package/src/gl-matrix/wip/index.js

@@ -1,6 +1,8 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 
 // @eslint-disable
 // @ts-nocheck

package/src/gl-matrix/wip/mat2.js

@@ -1,6 +1,8 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 
 // @ts-nocheck
 /* eslint-disable */

package/src/gl-matrix/wip/mat2d.js

@@ -1,6 +1,8 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 
 // @ts-nocheck
 /* eslint-disable */

package/src/gl-matrix/wip/quat2.ts

@@ -1,6 +1,8 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV. (gl-matrix)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Adapted from gl-matrix. See the repository LICENSE for upstream attribution and terms.
 
 // @ts-nocheck
 /* eslint-disable */

package/src/index.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 // types
 export type {
@@ -68,3 +68,5 @@ export {
   lerp,
   withEpsilon
 } from './lib/common';
+
+export type {SpheroidParameters} from '@math.gl/types';

package/src/lib/assert.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export function assert(condition: unknown, message?: string): void {
   if (!condition) {

package/src/lib/common.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 /* eslint-disable no-shadow */ // radians and degrees are common variable names
 

package/src/lib/gl-matrix-extras.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 /* eslint-disable camelcase */
 import {NumericArray} from '@math.gl/types';

package/src/lib/gl-matrix.d.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 // Float16Array is declared in a separate TypeScript library. This reference affects types only.
 // eslint-disable-next-line spaced-comment

package/src/lib/math-utils.ts

@@ -1,6 +1,7 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original compatibility helpers for Cesium-derived tests.
 
 // NOTE: Added to make Cesium-derived test cases work
 // TODO: Determine if/how to keep

package/src/lib/validators.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 import {NumericArray} from '@math.gl/types';
 import {config} from './common';

package/src/local-frame.ts

@@ -0,0 +1,253 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original factored ENU/NED basis, rotations and matrix commits. No CesiumJS or PROJ source is copied.
+import type {NumericArray} from '@math.gl/types';
+
+export type LocalFramePoint = {x: number; y: number; z: number};
+export type LocalFrameAxis = 'east' | 'north' | 'up' | 'west' | 'south' | 'down';
+/** East has zero Z. North is up × east; northZ is its horizontal radial factor. */
+export type LocalFrameBasis = {
+  eastX: number;
+  eastY: number;
+  northZ: number;
+  upX: number;
+  upY: number;
+  upZ: number;
+};
+
+/** Setup-time scratch, initially the ENU basis at longitude/latitude zero. */
+export function createLocalFrameBasis(): LocalFrameBasis {
+  return {eastX: 0, eastY: 1, northZ: 1, upX: 1, upY: 0, upZ: 0};
+}
+
+/** Angles in radians. Longitude is periodic; latitude must be within ±π/2. */
+export function eastNorthUpBasis(
+  longitude: number,
+  latitude: number,
+  result: LocalFrameBasis
+): boolean {
+  if (!Number.isFinite(longitude) || !Number.isFinite(latitude) || Math.abs(latitude) > Math.PI / 2)
+    return false;
+  const sl = Math.sin(longitude),
+    cl = Math.cos(longitude);
+  const sp = Math.sin(latitude),
+    cp = Math.cos(latitude);
+  return commitBasis(result, -sl, cl, cp, cp * cl, cp * sl, sp);
+}
+
+/**
+ * Caller supplies finite unit east/up directions, east.z=0, mutually perpendicular,
+ * and an up direction whose horizontal component points radially outward.
+ * This form preserves supplied up components rather than inferring a geodetic footpoint.
+ * Finiteness is checked; orthonormality is a caller precondition, not certified here.
+ */
+export function eastNorthUpBasisFromDirections(
+  east: LocalFramePoint,
+  up: LocalFramePoint,
+  result: LocalFrameBasis
+): boolean {
+  const ex = east.x,
+    ey = east.y,
+    ez = east.z;
+  const ux = up.x,
+    uy = up.y,
+    uz = up.z;
+  if (ez !== 0) return false;
+  return commitBasis(result, ex, ey, ux * ey - uy * ex, ux, uy, uz);
+}
+
+/** Rotate ENU offsets/velocities to fixed XYZ. Distances retain the input unit. */
+export function localToFixed(
+  point: LocalFramePoint,
+  basis: LocalFrameBasis,
+  result: LocalFramePoint = point
+): boolean {
+  const sl = -basis.eastX,
+    cl = basis.eastY,
+    sp = basis.upZ,
+    cp = basis.northZ;
+  const east = point.x,
+    north = point.y,
+    up = point.z;
+  // Retain the factored rotation order used by deformation; no intermediate vector.
+  const radial = up * cp - north * sp;
+  return commitPoint(
+    result,
+    radial * cl - east * sl,
+    radial * sl + east * cl,
+    up * sp + north * cp
+  );
+}
+
+/** Transpose rotation, valid for the orthonormal ENU basis precondition. */
+export function fixedToLocal(
+  point: LocalFramePoint,
+  basis: LocalFrameBasis,
+  result: LocalFramePoint = point
+): boolean {
+  const ex = basis.eastX,
+    ey = basis.eastY,
+    nz = basis.northZ;
+  const ux = basis.upX,
+    uy = basis.upY,
+    uz = basis.upZ;
+  const x = point.x,
+    y = point.y,
+    z = point.z;
+  return commitPoint(
+    result,
+    x * ex + y * ey,
+    -x * uz * ey + y * uz * ex + z * nz,
+    x * ux + y * uy + z * uz
+  );
+}
+
+/**
+ * Column-major affine matrix, with explicit signed local axes and fixed-space origin.
+ * Axis triples must be right handed (e.g. east/north/up or north/east/down).
+ * Translation uses the origin's distance unit. The basis itself has no origin.
+ * A failure leaves output unchanged; caller owns writable storage (a growable number array or a typed array of length ≥16).
+ */
+export function localFrameToMatrix(
+  basis: LocalFrameBasis,
+  origin: LocalFramePoint,
+  firstAxis: LocalFrameAxis,
+  secondAxis: LocalFrameAxis,
+  thirdAxis: LocalFrameAxis,
+  result: NumericArray
+): boolean {
+  const first = axisCode(firstAxis),
+    second = axisCode(secondAxis),
+    third = axisCode(thirdAxis);
+  const a = Math.abs(first),
+    b = Math.abs(second),
+    c = Math.abs(third);
+  if (!a || !b || !c || a === b || a === c || b === c) return false;
+  const parity = (a % 3) + 1 === b ? 1 : -1;
+  if (
+    parity * Math.sign(first * second * third) !== 1 ||
+    (!Array.isArray(result) && result.length < 16)
+  )
+    return false;
+  const ex = basis.eastX,
+    ey = basis.eastY,
+    nz = basis.northZ;
+  const ux = basis.upX,
+    uy = basis.upY,
+    uz = basis.upZ;
+  const nx = -uz * ey,
+    ny = uz * ex;
+  const x = origin.x,
+    y = origin.y,
+    z = origin.z;
+  const ax = (a === 1 ? ex : a === 2 ? nx : ux) * Math.sign(first);
+  const ay = (a === 1 ? ey : a === 2 ? ny : uy) * Math.sign(first);
+  const az = (a === 1 ? 0 : a === 2 ? nz : uz) * Math.sign(first);
+  const bx = (b === 1 ? ex : b === 2 ? nx : ux) * Math.sign(second);
+  const by = (b === 1 ? ey : b === 2 ? ny : uy) * Math.sign(second);
+  const bz = (b === 1 ? 0 : b === 2 ? nz : uz) * Math.sign(second);
+  const cx = (c === 1 ? ex : c === 2 ? nx : ux) * Math.sign(third);
+  const cy = (c === 1 ? ey : c === 2 ? ny : uy) * Math.sign(third);
+  const cz = (c === 1 ? 0 : c === 2 ? nz : uz) * Math.sign(third);
+  if (
+    !Number.isFinite(ax) ||
+    !Number.isFinite(ay) ||
+    !Number.isFinite(az) ||
+    !Number.isFinite(bx) ||
+    !Number.isFinite(by) ||
+    !Number.isFinite(bz) ||
+    !Number.isFinite(cx) ||
+    !Number.isFinite(cy) ||
+    !Number.isFinite(cz) ||
+    !Number.isFinite(x) ||
+    !Number.isFinite(y) ||
+    !Number.isFinite(z)
+  )
+    return false;
+  if (
+    result instanceof Float32Array &&
+    (!Number.isFinite(Math.fround(ax)) ||
+      !Number.isFinite(Math.fround(ay)) ||
+      !Number.isFinite(Math.fround(az)) ||
+      !Number.isFinite(Math.fround(bx)) ||
+      !Number.isFinite(Math.fround(by)) ||
+      !Number.isFinite(Math.fround(bz)) ||
+      !Number.isFinite(Math.fround(cx)) ||
+      !Number.isFinite(Math.fround(cy)) ||
+      !Number.isFinite(Math.fround(cz)) ||
+      !Number.isFinite(Math.fround(x)) ||
+      !Number.isFinite(Math.fround(y)) ||
+      !Number.isFinite(Math.fround(z)))
+  )
+    return false;
+  // Snapshot every component before application setters can recursively change scratch.
+  result[0] = ax;
+  result[1] = ay;
+  result[2] = az;
+  result[3] = 0;
+  result[4] = bx;
+  result[5] = by;
+  result[6] = bz;
+  result[7] = 0;
+  result[8] = cx;
+  result[9] = cy;
+  result[10] = cz;
+  result[11] = 0;
+  result[12] = x;
+  result[13] = y;
+  result[14] = z;
+  result[15] = 1;
+  return true;
+}
+function axisCode(axis: LocalFrameAxis): number {
+  switch (axis) {
+    case 'east':
+      return 1;
+    case 'west':
+      return -1;
+    case 'north':
+      return 2;
+    case 'south':
+      return -2;
+    case 'up':
+      return 3;
+    case 'down':
+      return -3;
+    default:
+      return 0;
+  }
+}
+function commitBasis(
+  result: LocalFrameBasis,
+  ex: number,
+  ey: number,
+  nz: number,
+  ux: number,
+  uy: number,
+  uz: number
+): boolean {
+  if (
+    !Number.isFinite(ex) ||
+    !Number.isFinite(ey) ||
+    !Number.isFinite(nz) ||
+    !Number.isFinite(ux) ||
+    !Number.isFinite(uy) ||
+    !Number.isFinite(uz)
+  )
+    return false;
+  result.eastX = ex;
+  result.eastY = ey;
+  result.northZ = nz;
+  result.upX = ux;
+  result.upY = uy;
+  result.upZ = uz;
+  return true;
+}
+function commitPoint(result: LocalFramePoint, x: number, y: number, z: number): boolean {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return false;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return true;
+}

package/src/mat3.ts

@@ -1,5 +1,5 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export * from './gl-matrix/mat3';

package/src/mat4.ts

@@ -1,5 +1,5 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export * from './gl-matrix/mat4';

package/src/quat.ts

@@ -1,5 +1,5 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export * from './gl-matrix/quat';

package/src/spheroid.ts

@@ -0,0 +1,253 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Forward geocentric equations and Hannover inverse moved/adapted from math.gl projection's proj4js 2.22.0 datumUtils.js port. See ../PROJ4-LICENSE.md. Safeguarded nearest-footpoint inverse and numeric output commit are original math.gl code.
+
+/** Numeric leaf: angles in radians, distances in axis units; no CRS, global config or scratch. */
+import type {SpheroidParameters} from '@math.gl/types';
+export type SpheroidGeometry = SpheroidParameters & {readonly eccentricitySquared: number};
+export type SpheroidPoint = {x: number; y: number; z: number};
+
+/** Caller supplies validated positive finite axes and eccentricity. No latitude wrapping. */
+export function spheroidToCartesian(
+  point: SpheroidPoint,
+  geometry: SpheroidGeometry,
+  result: SpheroidPoint = point
+): boolean {
+  const longitude = point.x,
+    latitude = point.y,
+    height = point.z;
+  const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = geometry;
+  const sin = Math.sin(latitude),
+    cos = Math.cos(latitude);
+  // Use the axis ratio for very flat shapes: 1 - es*sin² loses polar precision.
+  const ratio = b / a;
+  const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio * sin);
+  const x = (radius + height) * cos * Math.cos(longitude);
+  const y = (radius + height) * cos * Math.sin(longitude);
+  const z = (radius * (es < 0.9 ? 1 - es : ratio * ratio) + height) * sin;
+  return commit(result, x, y, z);
+}
+
+/**
+ * Bounded inverse. Sphere is analytic; ordinary spheroids use the retained Hannover
+ * iteration on exterior points. Interiors use a safeguarded nearest-footpoint solve.
+ * Equatorial interiors below the evolute cusp have two nearest normals: reject.
+ * false leaves output untouched, including the center and unresolved binary64 cases.
+ * Only exact poles canonicalize longitude; adapters may retain other conventions.
+ */
+export function cartesianToSpheroid(
+  point: SpheroidPoint,
+  geometry: SpheroidGeometry,
+  result: SpheroidPoint = point
+): boolean {
+  const x = point.x,
+    y = point.y,
+    z = point.z;
+  const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = geometry;
+  const p = Math.hypot(x, y),
+    rr = Math.hypot(x, y, z);
+  if (!(rr > 0) || !Number.isFinite(rr)) return false;
+  if (es === 0) return commit(result, p === 0 ? 0 : Math.atan2(y, x), Math.atan2(z, p), rr - a);
+  if (p === 0) return commit(result, 0, (Math.sign(z) * Math.PI) / 2, Math.abs(z) - b);
+  const horizontal = p / a,
+    vertical = z / b;
+  if (horizontal * horizontal + vertical * vertical < 1 - 16 * Number.EPSILON)
+    return interiorInverse(x, y, z, p, a, b, result);
+  if (es >= 0.9) return exteriorInverse(x, y, z, p, a, b, result);
+  const ct = z / rr,
+    st = p / rr;
+  let rx = 1 / Math.sqrt(1 - es * (2 - es) * st * st);
+  let cos = st * (1 - es) * rx,
+    sin = ct * rx;
+  for (let i = 0; i < 30; i++) {
+    const rn = a / Math.sqrt(1 - es * sin * sin);
+    const height = p * cos + z * sin - rn * (1 - es * sin * sin);
+    const rk = (es * rn) / (rn + height);
+    rx = 1 / Math.sqrt(1 - rk * (2 - rk) * st * st);
+    const nextCos = st * (1 - rk) * rx,
+      nextSin = ct * rx;
+    if (Math.abs(nextSin * cos - nextCos * sin) <= 1e-12) {
+      if (!Number.isFinite(height) || !Number.isFinite(nextSin) || !Number.isFinite(nextCos)) break;
+      return commit(result, Math.atan2(y, x), Math.atan2(nextSin, Math.abs(nextCos)), height);
+    }
+    cos = nextCos;
+    sin = nextSin;
+  }
+  return exteriorInverse(x, y, z, p, a, b, result);
+}
+
+/** Original nearest-normal solve in t = (lambda + b²)/a², avoiding interior cancellation.
+ * The positive interval selects the globally nearest branch, rather than a stationary normal.
+ */
+function interiorInverse(
+  x: number,
+  y: number,
+  z: number,
+  p: number,
+  a: number,
+  b: number,
+  result: SpheroidPoint
+): boolean {
+  const ratio = b / a,
+    ratio2 = ratio * ratio;
+  const horizontal = p / a,
+    vertical = z / a,
+    delta = 1 - ratio2;
+  if (!(ratio2 > 0) || ratio > 1) return false;
+  if (z === 0) {
+    if (horizontal < delta) return false;
+    return commit(result, Math.atan2(y, x), 0, p - a);
+  }
+  const aa = a * a,
+    bb = b * b;
+  const ratioError =
+    Number.isFinite(aa) && aa > 0
+      ? (bb -
+          ratio2 * aa +
+          productError(b, b, bb) -
+          ratio2 * productError(a, a, aa) -
+          productError(ratio2, aa, ratio2 * aa)) /
+        aa
+      : 0;
+  const pp = p * p,
+    xx = x * x,
+    yy = y * y,
+    sum = xx + yy;
+  const radiusError =
+    Number.isFinite(pp) && pp > 0
+      ? (sum -
+          pp +
+          sumError(xx, yy, sum) +
+          productError(x, x, xx) +
+          productError(y, y, yy) -
+          productError(p, p, pp)) /
+        (2 * p)
+      : 0;
+  const shift = a * ratio2,
+    base = p - a + shift;
+  const correction =
+    radiusError + sumError(p - a, shift, base) + productError(a, ratio2, shift) + a * ratioError;
+  const weighted = Math.abs(vertical) * ratio;
+  if (!(weighted > 0)) return false;
+  let lower = 0,
+    upper = ratio2;
+  // A lower bound near the short-axis singularity prevents thousands of bisections
+  // for deep, nearly equatorial interiors. No subtraction of lambda and -b².
+  let t = Math.max(weighted, horizontal - delta);
+  if (!(t > lower && t < upper)) t = upper / 2;
+  for (let i = 0; i < 128; i++) {
+    const equatorial = delta + t;
+    const u = horizontal / equatorial,
+      v = weighted / t;
+    const at = a * t,
+      difference = base - at;
+    const offset =
+      (difference + (sumError(base, -at, difference) + correction - productError(a, t, at))) /
+      (a * equatorial);
+    const term = offset * (u + 1);
+    const residual = term + v * v;
+    if (
+      Math.abs(residual) <= 4 * Number.EPSILON * (Math.abs(term) + v * v) ||
+      upper - lower <= 4 * Number.EPSILON * t
+    ) {
+      const latitude = Math.atan2(vertical / t, horizontal / equatorial);
+      const sin = Math.sin(latitude),
+        cos = Math.cos(latitude);
+      return commit(
+        result,
+        Math.atan2(y, x),
+        latitude,
+        p * cos + z * sin - a * Math.hypot(cos, ratio * sin)
+      );
+    }
+    if (residual > 0) lower = t;
+    else upper = t;
+    const derivative = -2 * ((u * u) / equatorial + (v * v) / t);
+    const next = t - residual / derivative;
+    const candidate =
+      Number.isFinite(next) && next > lower && next < upper ? next : lower + (upper - lower) / 2;
+    if (candidate === t) {
+      const latitude = Math.atan2(vertical / t, horizontal / equatorial);
+      return commit(
+        result,
+        Math.atan2(y, x),
+        latitude,
+        p * Math.cos(latitude) +
+          z * Math.sin(latitude) -
+          a * Math.hypot(Math.cos(latitude), ratio * Math.sin(latitude))
+      );
+    }
+    t = candidate;
+  }
+  return false;
+}
+
+/** Error-free transforms on the finite squared-axis domain used by geometry adapters. */
+function sumError(x: number, y: number, sum: number): number {
+  const part = sum - x;
+  return x - (sum - part) + (y - part);
+}
+function productError(x: number, y: number, product: number): number {
+  const sx = 134217729 * x,
+    sy = 134217729 * y;
+  if (!Number.isFinite(sx) || !Number.isFinite(sy)) return 0;
+  const hx = sx - (sx - x),
+    hy = sy - (sy - y),
+    lx = x - hx,
+    ly = y - hy;
+  return hx * hy - product + hx * ly + lx * hy + lx * ly;
+}
+
+/** Original dimensionless Lagrange-multiplier solve, restricted to surface/exterior. */
+function exteriorInverse(
+  x: number,
+  y: number,
+  z: number,
+  p: number,
+  a: number,
+  b: number,
+  result: SpheroidPoint
+): boolean {
+  const ratio = b / a,
+    ratio2 = ratio * ratio,
+    horizontal = p / a,
+    vertical = z / a;
+  const norm = Math.hypot(horizontal, z / b);
+  if (!Number.isFinite(norm) || norm < 1 - 8 * Number.EPSILON || !(ratio2 > 0)) return false;
+  let lower = 0,
+    upper = Math.hypot(horizontal, vertical * ratio);
+  if (!Number.isFinite(upper)) return false;
+  let multiplier = norm <= 1 + 8 * Number.EPSILON ? 0 : upper / 2;
+  for (let i = 0; i < 96; i++) {
+    const equatorial = 1 + multiplier,
+      polar = ratio2 + multiplier;
+    const u = horizontal / equatorial,
+      v = (vertical * ratio) / polar;
+    const length = Math.hypot(u, v);
+    const residual = length - 1;
+    if (Math.abs(residual) <= 4 * Number.EPSILON) {
+      const latitude = Math.atan2(vertical / polar, horizontal / equatorial);
+      const sin = Math.sin(latitude),
+        cos = Math.cos(latitude);
+      const height = p * cos + z * sin - a * Math.hypot(cos, ratio * sin);
+      return commit(result, Math.atan2(y, x), latitude, height);
+    }
+    if (residual > 0) lower = multiplier;
+    else upper = multiplier;
+    const derivative = -((u * u) / equatorial + (v * v) / polar) / length;
+    const next = multiplier - residual / derivative;
+    multiplier = Number.isFinite(next) && next > lower && next < upper ? next : (lower + upper) / 2;
+  }
+  return false;
+}
+
+/** Values are captured before invoking application setters; recursive writes are safe. */
+function commit(result: SpheroidPoint, x: number, y: number, z: number): boolean {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return false;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return true;
+}