@math.gl/geometry 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/utils/interpolate-packed-attributes.ts

@@ -0,0 +1,284 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Scalar storage formats supported by packed attribute interpolation. */
+export type PackedAttributeType =
+  | 'int8'
+  | 'uint8'
+  | 'int16'
+  | 'uint16'
+  | 'int32'
+  | 'uint32'
+  | 'float32'
+  | 'float64';
+
+/** Interpolate numeric values, or require identical values at every contributing vertex. */
+export type PackedAttributeInterpolation = 'linear' | 'flat';
+
+/** One explicitly described attribute inside an interleaved vertex record. */
+export type PackedAttribute = {
+  /** Scalar storage format; values are interpolated in the encoded domain. */
+  type: PackedAttributeType;
+  /** Number of scalar components. */
+  size: number;
+  /** Byte offset within each record; unaligned offsets are supported. */
+  byteOffset: number;
+  /** Policy for the whole attribute, or one explicit policy per component. */
+  interpolation: PackedAttributeInterpolation | readonly PackedAttributeInterpolation[];
+};
+
+/** Three original source indices and corresponding weights per output vertex. */
+export type AttributeInterpolationProvenance = {
+  /** Indices into the original source records, matching polygon subdivision provenance. */
+  sourceVertexIndices: ArrayLike<number>;
+  /** Nonnegative finite weights summing to one per triplet; zero-weight indices are ignored. */
+  sourceVertexWeights: ArrayLike<number>;
+};
+
+/** Byte layout, interpolation policies and output allocation limit. */
+export type PackedAttributeInterpolationOptions = {
+  /** Positive byte length of a source and output vertex record. */
+  byteStride: number;
+  /** Nonoverlapping attribute ranges. Unlisted bytes are copied from the first contributor. */
+  attributes: readonly PackedAttribute[];
+  /** Byte order for multibyte components. Default true. */
+  littleEndian?: boolean;
+  /** Maximum allocated output byte length. Default 64 MiB; zero permits empty output only. */
+  maxOutputBytes?: number;
+};
+
+const BYTE_SIZES: Record<PackedAttributeType, number> = {
+  int8: 1,
+  uint8: 1,
+  int16: 2,
+  uint16: 2,
+  int32: 4,
+  uint32: 4,
+  float32: 4,
+  float64: 8
+};
+
+/** Reconstruct interleaved attributes from subdivision's original-vertex provenance.
+ * Inputs are never modified. Linear integer components use Math.round once at final output;
+ * this is deliberately not repeated midpoint quantization. Flat components reject differing
+ * contributing values instead of guessing categorical semantics. Padding and unlisted bytes
+ * come from the first positive-weight contributor. Normals are not renormalized, and normalized
+ * GPU formats are not decoded. Duplicate source records at attribute seams before subdivision.
+ * @throws RangeError For invalid layout, provenance, nonfinite values or allocation limits.
+ */
+export function interpolatePackedAttributes(
+  source: Uint8Array,
+  provenance: AttributeInterpolationProvenance,
+  options: PackedAttributeInterpolationOptions
+): Uint8Array {
+  const {byteStride, attributes, littleEndian = true, maxOutputBytes = 64 * 1024 * 1024} = options;
+  const {sourceVertexIndices, sourceVertexWeights} = provenance;
+  if (
+    !Number.isSafeInteger(byteStride) ||
+    byteStride <= 0 ||
+    source.byteLength % byteStride ||
+    !Array.isArray(options.attributes) ||
+    typeof littleEndian !== 'boolean' ||
+    !Number.isSafeInteger(maxOutputBytes) ||
+    maxOutputBytes < 0 ||
+    !Number.isSafeInteger(sourceVertexIndices.length) ||
+    sourceVertexIndices.length < 0 ||
+    sourceVertexIndices.length % 3 ||
+    sourceVertexIndices.length !== sourceVertexWeights.length
+  ) {
+    throw new RangeError('Invalid packed attribute layout or provenance lengths');
+  }
+  const outputCount = sourceVertexIndices.length / 3;
+  const outputBytes = outputCount * byteStride;
+  if (!Number.isSafeInteger(outputBytes) || outputBytes > maxOutputBytes) {
+    throw new RangeError('Packed attribute interpolation exceeded maxOutputBytes');
+  }
+  const ranges: [number, number][] = [];
+  for (const attribute of attributes) {
+    if (
+      !attribute ||
+      typeof attribute !== 'object' ||
+      !Object.prototype.hasOwnProperty.call(BYTE_SIZES, attribute.type) ||
+      !Number.isSafeInteger(attribute.size) ||
+      attribute.size <= 0 ||
+      !Number.isSafeInteger(attribute.byteOffset) ||
+      attribute.byteOffset < 0
+    ) {
+      throw new RangeError('Invalid packed attribute descriptor');
+    }
+    const end = attribute.byteOffset + attribute.size * BYTE_SIZES[attribute.type];
+    if (
+      !Number.isSafeInteger(end) ||
+      end > byteStride ||
+      ranges.some(([start, previousEnd]) => attribute.byteOffset < previousEnd && end > start)
+    ) {
+      throw new RangeError('Packed attribute ranges must fit the stride and not overlap');
+    }
+    ranges.push([attribute.byteOffset, end]);
+    if (typeof attribute.interpolation === 'string') {
+      validateInterpolation(attribute.interpolation);
+    } else {
+      if (
+        !Array.isArray(attribute.interpolation) ||
+        attribute.interpolation.length !== attribute.size
+      ) {
+        throw new RangeError('Expected one interpolation policy per component');
+      }
+      for (let component = 0; component < attribute.size; component++) {
+        validateInterpolation(attribute.interpolation[component]);
+      }
+    }
+  }
+  const sourceCount = source.byteLength / byteStride;
+  const input = new DataView(source.buffer, source.byteOffset, source.byteLength);
+  const output = new Uint8Array(outputBytes);
+  const result = new DataView(output.buffer);
+  for (let vertex = 0; vertex < outputCount; vertex++) {
+    let sum = 0;
+    let firstSource = -1;
+    let contributors = 0;
+    for (let slot = 0; slot < 3; slot++) {
+      const weight = sourceVertexWeights[vertex * 3 + slot];
+      const index = sourceVertexIndices[vertex * 3 + slot];
+      if (
+        !Number.isFinite(weight) ||
+        weight < 0 ||
+        weight > 1 ||
+        (weight > 0 && (!Number.isSafeInteger(index) || index < 0 || index >= sourceCount))
+      ) {
+        throw new RangeError('Invalid contributing source index or interpolation weight');
+      }
+      if (weight > 0) {
+        contributors++;
+        if (firstSource < 0) firstSource = index;
+      }
+      sum += weight;
+    }
+    if (firstSource < 0 || Math.abs(sum - 1) > 1e-10) {
+      throw new RangeError('Interpolation weights must sum to one');
+    }
+    output.set(
+      source.subarray(firstSource * byteStride, (firstSource + 1) * byteStride),
+      vertex * byteStride
+    );
+    for (const attribute of attributes) {
+      for (let component = 0; component < attribute.size; component++) {
+        const offset = attribute.byteOffset + component * BYTE_SIZES[attribute.type];
+        const policy =
+          typeof attribute.interpolation === 'string'
+            ? attribute.interpolation
+            : attribute.interpolation[component];
+        const firstValue = readComponent(
+          input,
+          firstSource * byteStride + offset,
+          attribute.type,
+          littleEndian
+        );
+        let value = 0;
+        for (let slot = 0; slot < 3; slot++) {
+          const weight = sourceVertexWeights[vertex * 3 + slot];
+          if (weight === 0) continue;
+          const sourceValue = readComponent(
+            input,
+            sourceVertexIndices[vertex * 3 + slot] * byteStride + offset,
+            attribute.type,
+            littleEndian
+          );
+          if (!Number.isFinite(sourceValue))
+            throw new RangeError('Packed attributes must be finite');
+          if (policy === 'flat' && sourceValue !== firstValue) {
+            throw new RangeError('Flat attribute contributors must agree');
+          }
+          value += sourceValue * weight;
+        }
+        if (policy === 'linear') {
+          if (!Number.isFinite(value))
+            throw new RangeError('Interpolated attributes must be finite');
+          // Identity provenance preserves every original encoded bit, including signed zero.
+          if (contributors !== 1 || sum !== 1) {
+            writeComponent(
+              result,
+              vertex * byteStride + offset,
+              attribute.type,
+              value,
+              littleEndian
+            );
+          }
+        }
+      }
+    }
+  }
+  return output;
+}
+
+/** Reject implicit or unknown interpolation semantics. */
+function validateInterpolation(interpolation: unknown): void {
+  if (interpolation !== 'linear' && interpolation !== 'flat') {
+    throw new RangeError('Expected linear or flat interpolation');
+  }
+}
+
+/** Read an encoded scalar relative to the source view, including its byte offset. */
+function readComponent(
+  view: DataView,
+  offset: number,
+  type: PackedAttributeType,
+  littleEndian: boolean
+): number {
+  switch (type) {
+    case 'int8':
+      return view.getInt8(offset);
+    case 'uint8':
+      return view.getUint8(offset);
+    case 'int16':
+      return view.getInt16(offset, littleEndian);
+    case 'uint16':
+      return view.getUint16(offset, littleEndian);
+    case 'int32':
+      return view.getInt32(offset, littleEndian);
+    case 'uint32':
+      return view.getUint32(offset, littleEndian);
+    case 'float32':
+      return view.getFloat32(offset, littleEndian);
+    case 'float64':
+      return view.getFloat64(offset, littleEndian);
+  }
+}
+
+/** Write one final interpolated scalar, rounding integer encodings consistently. */
+function writeComponent(
+  view: DataView,
+  offset: number,
+  type: PackedAttributeType,
+  value: number,
+  littleEndian: boolean
+): void {
+  const integer = Math.round(value);
+  switch (type) {
+    case 'int8':
+      view.setInt8(offset, integer);
+      break;
+    case 'uint8':
+      view.setUint8(offset, integer);
+      break;
+    case 'int16':
+      view.setInt16(offset, integer, littleEndian);
+      break;
+    case 'uint16':
+      view.setUint16(offset, integer, littleEndian);
+      break;
+    case 'int32':
+      view.setInt32(offset, integer, littleEndian);
+      break;
+    case 'uint32':
+      view.setUint32(offset, integer, littleEndian);
+      break;
+    case 'float32':
+      view.setFloat32(offset, value, littleEndian);
+      break;
+    case 'float64':
+      view.setFloat64(offset, value, littleEndian);
+      break;
+  }
+}

package/src/utils/mesh-processing.ts

@@ -0,0 +1,377 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {Matrix4} from '@math.gl/core';
+import type {TypedArray, TypedArrayConstructor} from '@math.gl/core/types';
+import {GL} from './constants';
+import {getAttributeValues, type Geometry, type GeometryAttribute} from './geometry';
+
+type MeshData = {
+  attributes: Record<string, {value: TypedArray; size: number}>;
+  position: string;
+  count: number;
+  indices: Uint32Array;
+};
+
+/** Fresh, indexed triangle-list geometry. No input buffers are changed. */
+export function transformGeometry(
+  geometry: Geometry,
+  matrix: Readonly<ArrayLike<number>>
+): Geometry {
+  const mesh = readMesh(geometry);
+  if (
+    matrix.length !== 16 ||
+    Array.from(matrix).some(v => !Number.isFinite(v)) ||
+    matrix[3] !== 0 ||
+    matrix[7] !== 0 ||
+    matrix[11] !== 0 ||
+    matrix[15] !== 1
+  ) {
+    throw new RangeError('Transform must be a finite affine column-major matrix');
+  }
+  const transform = new Matrix4(Array.from(matrix));
+  // Factor out independent column scales before testing orientation/invertibility.
+  // A raw determinant can underflow or overflow for finite invertible matrices.
+  const columns = [0, 4, 8].map(offset => Array.from(matrix).slice(offset, offset + 3));
+  const scales = columns.map(column => Math.max(...column.map(Math.abs)));
+  const basis = columns.map((column, i) => column.map(v => (scales[i] ? v / scales[i] : 0)));
+  const cofactors = [
+    cross(basis[1], basis[2]),
+    cross(basis[2], basis[0]),
+    cross(basis[0], basis[1])
+  ];
+  const determinant = basis[0].reduce((sum, v, i) => sum + v * cofactors[0][i], 0);
+  const attributes = copyAttributes(mesh.attributes);
+  const normalName = attributes['NORMAL'] ? 'NORMAL' : attributes['normals'] ? 'normals' : null;
+  const tangentName = attributes['TANGENT'] ? 'TANGENT' : null;
+  if ((normalName || tangentName) && (!Number.isFinite(determinant) || determinant === 0))
+    throw new RangeError('Normals and tangents require an invertible transform');
+  const positions = new Float64Array(mesh.count * 3);
+  const source = mesh.attributes[mesh.position].value;
+  for (let i = 0; i < mesh.count; i++) {
+    const point = transform.transformAsPoint([source[i * 3], source[i * 3 + 1], source[i * 3 + 2]]);
+    positions.set(point, i * 3);
+  }
+  attributes[mesh.position] = {size: 3, value: positions};
+  if (normalName) {
+    const input = mesh.attributes[normalName];
+    if (input.size !== 3) throw new RangeError('Normals must have size 3');
+    const output = new Float64Array(mesh.count * 3);
+    for (let i = 0; i < mesh.count; i++) {
+      const value = normalizedLinearCombination(
+        cofactors,
+        Array.from(input.value.slice(i * 3, i * 3 + 3)),
+        scales.map(v => -Math.log(v))
+      );
+      output.set(
+        value.map(v => (determinant < 0 ? -v : v)),
+        i * 3
+      );
+    }
+    attributes[normalName] = {size: 3, value: output};
+  }
+  if (tangentName) {
+    const input = mesh.attributes[tangentName];
+    if (input.size !== 4) throw new RangeError('Tangents must have size 4');
+    const output = new Float64Array(mesh.count * 4);
+    for (let i = 0; i < mesh.count; i++) {
+      const value = normalizedLinearCombination(
+        basis,
+        Array.from(input.value.slice(i * 4, i * 4 + 3)),
+        scales.map(Math.log)
+      );
+      if (normalName) {
+        const n = attributes[normalName].value.slice(i * 3, i * 3 + 3);
+        const projection = value[0] * n[0] + value[1] * n[1] + value[2] * n[2];
+        for (let axis = 0; axis < 3; axis++) value[axis] -= projection * n[axis];
+      }
+      const length = Math.hypot(...value);
+      output.set(
+        value.map(v => (length ? v / length : 0)),
+        i * 4
+      );
+      output[i * 4 + 3] = input.value[i * 4 + 3] * (determinant < 0 ? -1 : 1);
+    }
+    attributes[tangentName] = {size: 4, value: output};
+  }
+  const indices = mesh.indices.slice();
+  if (determinant < 0)
+    for (let i = 0; i < indices.length; i += 3)
+      [indices[i + 1], indices[i + 2]] = [indices[i + 2], indices[i + 1]];
+  return {mode: GL.TRIANGLES, attributes, indices};
+}
+
+/** Concatenates compatible triangle meshes and offsets vertex indices. */
+export function mergeGeometries(geometries: readonly Geometry[]): Geometry {
+  if (!geometries.length) throw new RangeError('At least one geometry is required');
+  const meshes = geometries.map(readMesh),
+    first = meshes[0],
+    names = Object.keys(first.attributes).sort();
+  let count = 0,
+    indexCount = 0;
+  for (const mesh of meshes) {
+    if (
+      mesh.position !== first.position ||
+      Object.keys(mesh.attributes).length !== names.length ||
+      names.some(name => !Object.prototype.hasOwnProperty.call(mesh.attributes, name))
+    )
+      throw new RangeError('Attribute names must match');
+    for (const name of names) {
+      if (
+        mesh.attributes[name].size !== first.attributes[name].size ||
+        mesh.attributes[name].value.constructor !== first.attributes[name].value.constructor
+      ) {
+        throw new RangeError('Attribute sizes and storage types must match');
+      }
+    }
+    count += mesh.count;
+    indexCount += mesh.indices.length;
+  }
+  if (count > 0xffffffff) throw new RangeError('Geometry exceeds 32-bit indexing');
+  const attributes: Record<string, GeometryAttribute> = {};
+  for (const name of names) {
+    const attribute = first.attributes[name],
+      Constructor = attribute.value.constructor as TypedArrayConstructor;
+    const value = new Constructor(count * attribute.size);
+    let offset = 0;
+    for (const mesh of meshes) {
+      value.set(mesh.attributes[name].value, offset);
+      offset += mesh.attributes[name].value.length;
+    }
+    attributes[name] = {size: attribute.size, value};
+  }
+  const indices = new Uint32Array(indexCount);
+  let vertexOffset = 0,
+    indexOffset = 0;
+  for (const mesh of meshes) {
+    for (const index of mesh.indices) indices[indexOffset++] = index + vertexOffset;
+    vertexOffset += mesh.count;
+  }
+  return {mode: GL.TRIANGLES, attributes, indices};
+}
+
+export type WeldGeometryOptions = {
+  /** Position quantization step; zero means exact matching. */ positionGridSize?: number;
+};
+export type WeldGeometryResult = {
+  geometry: Geometry;
+  vertexMap: Uint32Array;
+  removedVertices: number;
+};
+
+/** Welds full attribute tuples, preserving UV seams and hard normal edges. */
+export function weldGeometry(
+  geometry: Geometry,
+  options: WeldGeometryOptions = {}
+): WeldGeometryResult {
+  const mesh = readMesh(geometry),
+    grid = options.positionGridSize ?? 0;
+  if (!Number.isFinite(grid) || grid < 0)
+    throw new RangeError('positionGridSize must be finite and nonnegative');
+  const names = Object.keys(mesh.attributes).sort(),
+    keys = new Map<string, number>(),
+    rows: number[] = [],
+    vertexMap = new Uint32Array(mesh.count);
+  for (let i = 0; i < mesh.count; i++) {
+    const tuple: number[] = [];
+    for (const name of names) {
+      const attribute = mesh.attributes[name];
+      for (let component = 0; component < attribute.size; component++) {
+        const value = attribute.value[i * attribute.size + component];
+        const quantized = name === mesh.position && grid ? Math.round(value / grid) : value;
+        if (!Number.isFinite(quantized)) throw new RangeError('Position quantization overflow');
+        tuple.push(quantized);
+      }
+    }
+    const key = tuple.join(',');
+    let row = keys.get(key);
+    if (row === undefined) {
+      row = rows.length;
+      keys.set(key, row);
+      rows.push(i);
+    }
+    vertexMap[i] = row;
+  }
+  const attributes: Record<string, GeometryAttribute> = {};
+  for (const name of names) {
+    const attribute = mesh.attributes[name],
+      Constructor = attribute.value.constructor as TypedArrayConstructor;
+    const value = new Constructor(rows.length * attribute.size);
+    rows.forEach((row, i) =>
+      value.set(
+        attribute.value.subarray(row * attribute.size, (row + 1) * attribute.size),
+        i * attribute.size
+      )
+    );
+    attributes[name] = {size: attribute.size, value};
+  }
+  return {
+    geometry: {
+      mode: GL.TRIANGLES,
+      attributes,
+      indices: Uint32Array.from(mesh.indices, index => vertexMap[index])
+    },
+    vertexMap,
+    removedVertices: mesh.count - rows.length
+  };
+}
+
+/** Returns triangle numbers with area <= areaEpsilon, in original draw order. */
+export function getDegenerateTriangles(geometry: Geometry, areaEpsilon = 0): Uint32Array {
+  if (!Number.isFinite(areaEpsilon) || areaEpsilon < 0)
+    throw new RangeError('Area epsilon must be finite and nonnegative');
+  const mesh = readMesh(geometry),
+    positions = mesh.attributes[mesh.position].value,
+    result: number[] = [];
+  for (let i = 0; i < mesh.indices.length; i += 3) {
+    const [a, b, c] = Array.from(mesh.indices.subarray(i, i + 3), index => index * 3);
+    const ab = [
+      positions[b] - positions[a],
+      positions[b + 1] - positions[a + 1],
+      positions[b + 2] - positions[a + 2]
+    ];
+    const ac = [
+      positions[c] - positions[a],
+      positions[c + 1] - positions[a + 1],
+      positions[c + 2] - positions[a + 2]
+    ];
+    // Keep the common path in floating point, but use exact dyadic arithmetic
+    // when normalization loses a component or cannot distinguish collinearity.
+    const scaleAB = Math.max(...ab.map(Math.abs));
+    const scaleAC = Math.max(...ac.map(Math.abs));
+    const normalizedAB = ab.map(v => (scaleAB ? v / scaleAB : 0));
+    const normalizedAC = ac.map(v => (scaleAC ? v / scaleAC : 0));
+    const crossLength = Math.hypot(...cross(normalizedAB, normalizedAC));
+    const lostComponent = [ab, ac].some((edge, i) =>
+      edge.some((v, axis) => v !== 0 && (i ? normalizedAC : normalizedAB)[axis] === 0)
+    );
+    if (!Number.isFinite(crossLength) || crossLength === 0 || lostComponent) {
+      if (exactAreaAtMost(positions, a, b, c, areaEpsilon)) result.push(i / 3);
+    } else {
+      const logArea = Math.log(crossLength) + Math.log(scaleAB) + Math.log(scaleAC) - Math.log(2);
+      if (areaEpsilon > 0 && logArea <= Math.log(areaEpsilon)) result.push(i / 3);
+    }
+  }
+  return Uint32Array.from(result);
+}
+
+function readMesh(geometry: Geometry): MeshData {
+  if (geometry.mode !== GL.TRIANGLES)
+    throw new RangeError('Packed triangle-list geometry is required');
+  const position = geometry.attributes['POSITION']
+    ? 'POSITION'
+    : geometry.attributes['positions']
+      ? 'positions'
+      : null;
+  if (!position) throw new RangeError('POSITION or positions is required');
+  const attributes: MeshData['attributes'] = {};
+  let count: number;
+  for (const [name, attribute] of Object.entries(geometry.attributes)) {
+    const value = getAttributeValues(attribute),
+      size = attribute.size ?? (name === position ? 3 : undefined);
+    if (!Number.isSafeInteger(size) || size < 1 || value.length % size)
+      throw new RangeError('Attributes need explicit packed sizes');
+    const length = value.length / size;
+    if (name === position) {
+      if (size !== 3) throw new RangeError('Positions must have size 3');
+      count = length;
+    }
+    for (const component of value)
+      if (!Number.isFinite(component)) throw new RangeError('Attributes must be finite');
+    attributes[name] = {value, size};
+  }
+  for (const attribute of Object.values(attributes))
+    if (attribute.value.length / attribute.size !== count)
+      throw new RangeError('Attribute vertex counts must match');
+  if (count > 0xffffffff) throw new RangeError('Geometry exceeds 32-bit indexing');
+  const input = geometry.indices
+    ? getAttributeValues(geometry.indices)
+    : Uint32Array.from({length: count}, (_, i) => i);
+  if (input.length % 3) throw new RangeError('Indices must form triangles');
+  for (const index of input)
+    if (!Number.isSafeInteger(index) || index < 0 || index >= count)
+      throw new RangeError('Vertex index is out of bounds');
+  return {attributes, position, count, indices: Uint32Array.from(input)};
+}
+function copyAttributes(attributes: MeshData['attributes']): Record<string, GeometryAttribute> {
+  return Object.fromEntries(
+    Object.entries(attributes).map(([name, attribute]) => [
+      name,
+      {size: attribute.size, value: attribute.value.slice()}
+    ])
+  );
+}
+
+function cross(a: number[], b: number[]): number[] {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+/** Direction-only multiplication, avoiding overflow in scale-weighted components. */
+function normalizedLinearCombination(
+  columns: number[][],
+  vector: number[],
+  logScales: number[]
+): number[] {
+  const logs = vector.map((v, i) => (v ? Math.log(Math.abs(v)) + logScales[i] : -Infinity));
+  const largest = Math.max(...logs);
+  if (largest === -Infinity) return [0, 0, 0];
+  const weights = logs.map((v, i) => Math.sign(vector[i]) * Math.exp(v - largest));
+  const result = [0, 1, 2].map(axis =>
+    columns.reduce((sum, column, i) => sum + column[axis] * weights[i], 0)
+  );
+  const length = Math.hypot(...result);
+  return result.map(v => (length ? v / length : 0));
+}
+
+// Every finite binary64 value is an integer times a power of two. The fallback
+// compares squared cross lengths to 4*epsilon² without floating-point products.
+type Dyadic = {n: bigint; exponent: number};
+function exactAreaAtMost(
+  positions: TypedArray,
+  a: number,
+  b: number,
+  c: number,
+  epsilon: number
+): boolean {
+  const edge = (end: number) =>
+    [0, 1, 2].map(axis =>
+      subtractDyadic(toDyadic(positions[end + axis]), toDyadic(positions[a + axis]))
+    );
+  const ab = edge(b),
+    ac = edge(c);
+  const components = [0, 1, 2].map(axis => {
+    const j = (axis + 1) % 3,
+      k = (axis + 2) % 3;
+    return subtractDyadic(multiplyDyadic(ab[j], ac[k]), multiplyDyadic(ab[k], ac[j]));
+  });
+  if (epsilon === 0) return components.every(v => v.n === 0n);
+  const squared = components.map(v => multiplyDyadic(v, v));
+  const sum = squared.reduce((total, v) => subtractDyadic(total, {...v, n: -v.n}), {
+    n: 0n,
+    exponent: 0
+  });
+  const threshold = multiplyDyadic(toDyadic(epsilon), toDyadic(epsilon));
+  threshold.exponent += 2;
+  return subtractDyadic(sum, threshold).n <= 0n;
+}
+function toDyadic(value: number): Dyadic {
+  const bits = new DataView(new ArrayBuffer(8));
+  bits.setFloat64(0, value);
+  const high = bits.getUint32(0),
+    low = bits.getUint32(4);
+  const exponentBits = (high >>> 20) & 0x7ff;
+  const fraction = (BigInt(high & 0xfffff) << 32n) | BigInt(low);
+  const n = exponentBits ? (1n << 52n) | fraction : fraction;
+  return {n: high >>> 31 ? -n : n, exponent: exponentBits ? exponentBits - 1075 : -1074};
+}
+function subtractDyadic(a: Dyadic, b: Dyadic): Dyadic {
+  const exponent = Math.min(a.exponent, b.exponent);
+  return {
+    n: (a.n << BigInt(a.exponent - exponent)) - (b.n << BigInt(b.exponent - exponent)),
+    exponent
+  };
+}
+function multiplyDyadic(a: Dyadic, b: Dyadic): Dyadic {
+  return {n: a.n * b.n, exponent: a.exponent + b.exponent};
+}