@jscad/modeling 2.12.6 → 2.13.0

package/src/operations/extrusions/extrudeWalls.js

@@ -26,10 +26,11 @@ const repartitionEdges = (newlength, edges) => {
   }
 
   const divisor = vec3.fromValues(multiple, multiple, multiple)
+  const increment = vec3.create() // reuse across all edge iterations
 
   const newEdges = []
   edges.forEach((edge) => {
-    const increment = vec3.subtract(vec3.create(), edge[1], edge[0])
+    vec3.subtract(increment, edge[1], edge[0])
     vec3.divide(increment, increment, divisor)
 
     // repartition the edge

package/src/operations/extrusions/extrudeWalls.test.js

@@ -80,3 +80,75 @@ test('extrudeWalls (different shapes)', (t) => {
   walls = extrudeWalls(slice3, slice.transform(matrix, slice2))
   t.is(walls.length, 24)
 })
+
+// Test for vec3 reuse optimization in repartitionEdges
+// When shapes have different edge counts, edges are repartitioned using vec3 operations
+test('extrudeWalls (repartitionEdges vec3 reuse)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 5])
+
+  // Triangle (3 edges)
+  const triangle = [
+    [[0, 10], [-8.66, -5]],
+    [[-8.66, -5], [8.66, -5]],
+    [[8.66, -5], [0, 10]]
+  ]
+
+  // Hexagon (6 edges) - LCM with triangle is 6, so triangle edges get split
+  const hexagon = [
+    [[0, 10], [-8.66, 5]],
+    [[-8.66, 5], [-8.66, -5]],
+    [[-8.66, -5], [0, -10]],
+    [[0, -10], [8.66, -5]],
+    [[8.66, -5], [8.66, 5]],
+    [[8.66, 5], [0, 10]]
+  ]
+
+  const sliceTriangle = slice.fromSides(triangle)
+  const sliceHexagon = slice.fromSides(hexagon)
+
+  // Triangle to hexagon requires repartitioning (3 -> 6 edges)
+  // This exercises the vec3 reuse optimization in repartitionEdges
+  const walls = extrudeWalls(sliceTriangle, slice.transform(matrix, sliceHexagon))
+
+  // 6 edges * 2 triangles per edge = 12 wall polygons
+  t.is(walls.length, 12)
+
+  // Verify all walls are valid triangles
+  walls.forEach((wall) => {
+    t.is(wall.vertices.length, 3)
+  })
+})
+
+// Test for vec3 reuse with higher repartition multiple
+test('extrudeWalls (repartitionEdges with high multiple)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
+
+  // Square (4 edges)
+  const square = [
+    [[-5, 5], [-5, -5]],
+    [[-5, -5], [5, -5]],
+    [[5, -5], [5, 5]],
+    [[5, 5], [-5, 5]]
+  ]
+
+  // Octagon (8 edges) - LCM with square is 8, so square edges get doubled
+  const octagon = [
+    [[0, 5], [-3.54, 3.54]],
+    [[-3.54, 3.54], [-5, 0]],
+    [[-5, 0], [-3.54, -3.54]],
+    [[-3.54, -3.54], [0, -5]],
+    [[0, -5], [3.54, -3.54]],
+    [[3.54, -3.54], [5, 0]],
+    [[5, 0], [3.54, 3.54]],
+    [[3.54, 3.54], [0, 5]]
+  ]
+
+  const sliceSquare = slice.fromSides(square)
+  const sliceOctagon = slice.fromSides(octagon)
+
+  // Square to octagon requires repartitioning (4 -> 8 edges)
+  const walls = extrudeWalls(sliceSquare, slice.transform(matrix, sliceOctagon))
+
+  // 8 edges * 2 triangles per edge = 16 wall polygons
+  t.is(walls.length, 16)
+})

package/src/operations/minkowski/index.d.ts

@@ -0,0 +1 @@
+export { minkowskiSum } from './minkowskiSum'

package/src/operations/minkowski/index.js

@@ -0,0 +1,17 @@
+/**
+ * Minkowski sum operations for 3D geometries.
+ *
+ * The Minkowski sum of two shapes A and B is the set of all points that are
+ * the sum of a point in A and a point in B. This is useful for:
+ * - Offsetting/inflating shapes (using a sphere creates rounded edges)
+ * - Collision detection (shapes collide iff their Minkowski difference contains origin)
+ * - Motion planning and swept volumes
+ *
+ * @module modeling/minkowski
+ * @example
+ * const { minkowskiSum } = require('@jscad/modeling').minkowski
+ * const rounded = minkowskiSum(cube, sphere)
+ */
+module.exports = {
+  minkowskiSum: require('./minkowskiSum')
+}

package/src/operations/minkowski/minkowskiSum.d.ts

@@ -0,0 +1,4 @@
+import type { Geom3 } from '../../geometries/types'
+
+export function minkowskiSum(geometryA: Geom3, geometryB: Geom3): Geom3
+export function minkowskiSum(...geometries: Geom3[]): Geom3

package/src/operations/minkowski/minkowskiSum.js

@@ -0,0 +1,224 @@
+const flatten = require('../../utils/flatten')
+
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+const hullPoints3 = require('../hulls/hullPoints3')
+const unionGeom3 = require('../booleans/unionGeom3')
+
+/**
+ * Compute the Minkowski sum of two 3D geometries.
+ *
+ * The Minkowski sum A ⊕ B is the set of all points a + b where a ∈ A and b ∈ B.
+ * Geometrically, this "inflates" geometry A by the shape of geometry B.
+ *
+ * Common use cases:
+ * - Offset a solid by a sphere to round all edges and corners
+ * - Offset a solid by a cube to create chamfered edges
+ * - Collision detection (if Minkowski sum contains origin, shapes overlap)
+ *
+ * For best performance, use convex geometries. Non-convex geometries are supported
+ * when the second operand is convex, but require decomposition and are slower.
+ *
+ * @param {...Object} geometries - two geom3 geometries (second should be convex for non-convex first)
+ * @returns {geom3} new 3D geometry representing the Minkowski sum
+ * @alias module:modeling/minkowski.minkowskiSum
+ *
+ * @example
+ * const { primitives, minkowski } = require('@jscad/modeling')
+ * const cube = primitives.cuboid({ size: [10, 10, 10] })
+ * const sphere = primitives.sphere({ radius: 2, segments: 16 })
+ * const rounded = minkowski.minkowskiSum(cube, sphere)
+ */
+const minkowskiSum = (...geometries) => {
+  geometries = flatten(geometries)
+
+  if (geometries.length !== 2) {
+    throw new Error('minkowskiSum requires exactly two geometries')
+  }
+
+  const [geomA, geomB] = geometries
+
+  if (!geom3.isA(geomA) || !geom3.isA(geomB)) {
+    throw new Error('minkowskiSum requires geom3 geometries')
+  }
+
+  const aConvex = geom3.isConvex(geomA)
+  const bConvex = geom3.isConvex(geomB)
+
+  // Fast path: both convex
+  if (aConvex && bConvex) {
+    return minkowskiSumConvex(geomA, geomB)
+  }
+
+  // Non-convex A + convex B: decompose A into tetrahedra
+  if (!aConvex && bConvex) {
+    return minkowskiSumNonConvexConvex(geomA, geomB)
+  }
+
+  // Convex A + non-convex B: swap operands (Minkowski sum is commutative)
+  if (aConvex && !bConvex) {
+    return minkowskiSumNonConvexConvex(geomB, geomA)
+  }
+
+  // Both non-convex: not yet supported
+  throw new Error('minkowskiSum of two non-convex geometries is not yet supported')
+}
+
+/**
+ * Compute Minkowski sum of non-convex A with convex B.
+ *
+ * Decomposes A into tetrahedra, computes Minkowski sum of each with B,
+ * then unions all results.
+ */
+const minkowskiSumNonConvexConvex = (geomA, geomB) => {
+  const tetrahedra = decomposeIntoTetrahedra(geomA)
+
+  if (tetrahedra.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute Minkowski sum for each tetrahedron
+  const parts = tetrahedra.map((tet) => minkowskiSumConvex(tet, geomB))
+
+  // Union all parts using internal unionGeom3
+  if (parts.length === 1) {
+    return parts[0]
+  }
+
+  return unionGeom3(parts)
+}
+
+/**
+ * Decompose a geom3 into tetrahedra using face-local apex points.
+ * Each resulting tetrahedron is guaranteed to be convex.
+ *
+ * Unlike centroid-based decomposition, this approach works correctly for
+ * shapes where the centroid is outside the geometry (e.g., torus, U-shapes).
+ * Each polygon gets its own apex point, offset inward along its normal.
+ */
+const decomposeIntoTetrahedra = (geometry) => {
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return []
+  }
+
+  const tetrahedra = []
+
+  // For each polygon, compute a face-local apex and create tetrahedra
+  for (let i = 0; i < polygons.length; i++) {
+    const polygon = polygons[i]
+    const vertices = polygon.vertices
+
+    // Compute polygon center
+    let cx = 0, cy = 0, cz = 0
+    for (let k = 0; k < vertices.length; k++) {
+      cx += vertices[k][0]
+      cy += vertices[k][1]
+      cz += vertices[k][2]
+    }
+    cx /= vertices.length
+    cy /= vertices.length
+    cz /= vertices.length
+
+    // Get polygon plane (normal + offset)
+    const plane = poly3.plane(polygon)
+    const nx = plane[0], ny = plane[1], nz = plane[2]
+
+    // Offset inward along negative normal to create face-local apex
+    // The normal points outward, so we go in the negative direction
+    // Use a small offset - the actual distance doesn't matter much
+    // as long as the apex is on the interior side of the face
+    const offset = 0.1
+    const apex = [ // Vertex used as apex in tetrahedron polygons below
+      cx - nx * offset,
+      cy - ny * offset,
+      cz - nz * offset
+    ]
+
+    // Fan triangulate the polygon and create tetrahedra from apex
+    for (let j = 1; j < vertices.length - 1; j++) {
+      const v0 = vertices[0]
+      const v1 = vertices[j]
+      const v2 = vertices[j + 1]
+
+      // Create tetrahedron from apex and triangle
+      const tetPolygons = createTetrahedronPolygons(apex, v0, v1, v2)
+      tetrahedra.push(geom3.create(tetPolygons))
+    }
+  }
+
+  return tetrahedra
+}
+
+/**
+ * Create the 4 triangular faces of a tetrahedron.
+ */
+const createTetrahedronPolygons = (p0, p1, p2, p3) => {
+  // Tetrahedron has 4 faces, each a triangle
+  // We need to ensure consistent winding (outward-facing normals)
+  return [
+    poly3.create([p0, p2, p1]), // base seen from p3
+    poly3.create([p0, p1, p3]), // face opposite p2
+    poly3.create([p1, p2, p3]), // face opposite p0
+    poly3.create([p2, p0, p3])  // face opposite p1
+  ]
+}
+
+/**
+ * Compute Minkowski sum of two convex polyhedra.
+ *
+ * For convex polyhedra, the Minkowski sum equals the convex hull of
+ * all pairwise vertex sums. This is O(n*m) for n and m vertices,
+ * plus the cost of the convex hull algorithm.
+ */
+const minkowskiSumConvex = (geomA, geomB) => {
+  const pointsA = extractUniqueVertices(geomA)
+  const pointsB = extractUniqueVertices(geomB)
+
+  if (pointsA.length === 0 || pointsB.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute all pairwise sums
+  const summedPoints = []
+  for (let i = 0; i < pointsA.length; i++) {
+    const a = pointsA[i]
+    for (let j = 0; j < pointsB.length; j++) {
+      const b = pointsB[j]
+      summedPoints.push([a[0] + b[0], a[1] + b[1], a[2] + b[2]])
+    }
+  }
+
+  // Compute convex hull of the summed points
+  const hullPolygons = hullPoints3(summedPoints)
+
+  return geom3.create(hullPolygons)
+}
+
+/**
+ * Extract unique vertices from a geom3.
+ * Uses a Set with string keys for deduplication.
+ */
+const extractUniqueVertices = (geometry) => {
+  const found = new Set()
+  const unique = []
+
+  const polygons = geom3.toPolygons(geometry)
+  for (let i = 0; i < polygons.length; i++) {
+    const vertices = polygons[i].vertices
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        unique.push(v)
+      }
+    }
+  }
+
+  return unique
+}
+
+module.exports = minkowskiSum

package/src/operations/minkowski/minkowskiSum.test.js

@@ -0,0 +1,195 @@
+const test = require('ava')
+
+const { geometries, primitives, measurements, booleans, minkowski } = require('../../index')
+const { geom3 } = geometries
+
+test('minkowskiSum: throws for non-geom3 inputs', (t) => {
+  t.throws(() => minkowski.minkowskiSum('invalid', primitives.cuboid()), { message: /requires geom3/ })
+  t.throws(() => minkowski.minkowskiSum(primitives.cuboid(), 'invalid'), { message: /requires geom3/ })
+})
+
+test('minkowskiSum: throws for wrong number of geometries', (t) => {
+  t.throws(() => minkowski.minkowskiSum(), { message: /exactly two/ })
+  t.throws(() => minkowski.minkowskiSum(primitives.cuboid()), { message: /exactly two/ })
+  t.throws(() => minkowski.minkowskiSum(primitives.cuboid(), primitives.cuboid(), primitives.cuboid()), { message: /exactly two/ })
+})
+
+test('minkowskiSum: cube + cube produces correct bounds', (t) => {
+  // Cube1: size 10 (±5 from origin)
+  // Cube2: size 4 (±2 from origin)
+  // Minkowski sum should be size 14 (±7 from origin)
+  const cube1 = primitives.cuboid({ size: [10, 10, 10] })
+  const cube2 = primitives.cuboid({ size: [4, 4, 4] })
+
+  const result = minkowski.minkowskiSum(cube1, cube2)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+  // Allow small tolerance for floating point
+  t.true(Math.abs(bounds[0][0] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[0][1] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[0][2] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[1][0] - 7) < 0.001)
+  t.true(Math.abs(bounds[1][1] - 7) < 0.001)
+  t.true(Math.abs(bounds[1][2] - 7) < 0.001)
+})
+
+test('minkowskiSum: cube + sphere produces correct bounds', (t) => {
+  // Cube: size 10 (±5 from origin)
+  // Sphere: radius 2
+  // Minkowski sum should be ±7 from origin
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const sph = primitives.sphere({ radius: 2, segments: 16 })
+
+  const result = minkowski.minkowskiSum(cube, sph)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+  // Allow small tolerance
+  t.true(Math.abs(bounds[0][0] - (-7)) < 0.1)
+  t.true(Math.abs(bounds[1][0] - 7) < 0.1)
+})
+
+test('minkowskiSum: sphere + sphere produces correct bounds', (t) => {
+  // Sphere1: radius 3
+  // Sphere2: radius 2
+  // Minkowski sum should be a sphere-like shape with radius ~5
+  const sph1 = primitives.sphere({ radius: 3, segments: 16 })
+  const sph2 = primitives.sphere({ radius: 2, segments: 16 })
+
+  const result = minkowski.minkowskiSum(sph1, sph2)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+  // Should be approximately ±5
+  t.true(Math.abs(bounds[0][0] - (-5)) < 0.2)
+  t.true(Math.abs(bounds[1][0] - 5) < 0.2)
+})
+
+test('minkowskiSum: empty geometry returns empty', (t) => {
+  const empty = geom3.create()
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+
+  const result = minkowski.minkowskiSum(empty, cube)
+
+  t.notThrows(() => geom3.validate(result))
+  t.is(geom3.toPolygons(result).length, 0)
+})
+
+test('minkowskiSum: result is convex', (t) => {
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const sph = primitives.sphere({ radius: 2, segments: 12 })
+
+  const result = minkowski.minkowskiSum(cube, sph)
+
+  t.notThrows(() => geom3.validate(result))
+  t.true(geom3.isConvex(result))
+})
+
+// Non-convex tests
+
+test('minkowskiSum: non-convex + convex produces valid geometry', (t) => {
+  // Create L-shaped non-convex geometry
+  const big = primitives.cuboid({ size: [10, 10, 10] })
+  const corner = primitives.cuboid({ size: [6, 6, 12], center: [3, 3, 0] })
+  const lShape = booleans.subtract(big, corner)
+
+  t.false(geom3.isConvex(lShape))
+
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+
+  const result = minkowski.minkowskiSum(lShape, sph)
+
+  t.true(geom3.toPolygons(result).length > 0)
+  t.true(geom3.isA(result))
+})
+
+test('minkowskiSum: non-convex + convex produces correct bounds', (t) => {
+  // Cube with hole through it
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const hole = primitives.cuboid({ size: [4, 4, 20] })
+  const cubeWithHole = booleans.subtract(cube, hole)
+
+  t.false(geom3.isConvex(cubeWithHole))
+
+  // Offset by sphere of radius 1
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+  const result = minkowski.minkowskiSum(cubeWithHole, sph)
+
+  t.true(geom3.isA(result))
+
+  const bounds = measurements.measureBoundingBox(result)
+
+  // Original cube is ±5, plus sphere radius 1 = ±6
+  t.true(Math.abs(bounds[0][0] - (-6)) < 0.2)
+  t.true(Math.abs(bounds[1][0] - 6) < 0.2)
+})
+
+test('minkowskiSum: convex + non-convex swaps operands', (t) => {
+  // Minkowski sum is commutative, so A⊕B = B⊕A
+  const cube = primitives.cuboid({ size: [10, 10, 10] })
+  const hole = primitives.cuboid({ size: [4, 4, 20] })
+  const cubeWithHole = booleans.subtract(cube, hole)
+
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+
+  // convex + non-convex should work (swaps internally)
+  const result = minkowski.minkowskiSum(sph, cubeWithHole)
+
+  t.true(geom3.isA(result))
+  t.true(geom3.toPolygons(result).length > 0)
+})
+
+test('minkowskiSum: throws for two non-convex geometries', (t) => {
+  const cube1 = primitives.cuboid({ size: [10, 10, 10] })
+  const hole1 = primitives.cuboid({ size: [4, 4, 20] })
+  const nonConvex1 = booleans.subtract(cube1, hole1)
+
+  const cube2 = primitives.cuboid({ size: [8, 8, 8] })
+  const hole2 = primitives.cuboid({ size: [3, 3, 16] })
+  const nonConvex2 = booleans.subtract(cube2, hole2)
+
+  t.throws(() => minkowski.minkowskiSum(nonConvex1, nonConvex2), { message: /two non-convex/ })
+})
+
+test('minkowskiSum: torus + sphere preserves hole (face-local apex)', (t) => {
+  // Torus with innerRadius=3 (tube radius) and outerRadius=8 (distance to tube center)
+  // At z=0, the torus extends from radius 5 to 11 (8-3 to 8+3)
+  // Adding sphere of radius 1 should give 4 to 12
+  const torusShape = primitives.torus({
+    innerRadius: 3,
+    outerRadius: 8,
+    innerSegments: 16,
+    outerSegments: 24
+  })
+
+  const sph = primitives.sphere({ radius: 1, segments: 8 })
+
+  t.false(geom3.isConvex(torusShape))
+
+  const result = minkowski.minkowskiSum(torusShape, sph)
+
+  t.true(geom3.isA(result))
+  t.true(geom3.toPolygons(result).length > 0)
+
+  // Check that the hole is preserved by examining vertices at z≈0
+  const polygons = geom3.toPolygons(result)
+  let minRadius = Infinity
+
+  for (const poly of polygons) {
+    for (const v of poly.vertices) {
+      if (Math.abs(v[2]) < 0.5) {
+        const r = Math.sqrt(v[0] * v[0] + v[1] * v[1])
+        if (r < minRadius) minRadius = r
+      }
+    }
+  }
+
+  // With face-local apex, hole should be preserved
+  // Inner radius should be around 4 (8-3-1 = 4)
+  // If centroid-based (buggy), hole would be filled and minRadius would be ~0
+  t.true(minRadius > 3, `hole should be preserved, got minRadius=${minRadius}`)
+})

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -120,6 +120,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
     //   at the the left and right side of the polygon
     // Iterate over all polygons that have a corner at this y coordinate:
     const polygonindexeswithcorner = ycoordinatetopolygonindexes.get(ycoordinate)
+    let removeCount = 0 // track removals to filter at end (avoids O(n²) splice)
     for (let activepolygonindex = 0; activepolygonindex < activepolygons.length; ++activepolygonindex) {
       const activepolygon = activepolygons[activepolygonindex]
       const polygonindex = activepolygon.polygonindex
@@ -143,9 +144,9 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         }
         if ((newleftvertexindex !== activepolygon.leftvertexindex) && (newleftvertexindex === newrightvertexindex)) {
           // We have increased leftvertexindex or decreased rightvertexindex, and now they point to the same vertex
-          // This means that this is the bottom point of the polygon. We'll remove it:
-          activepolygons.splice(activepolygonindex, 1)
-          --activepolygonindex
+          // This means that this is the bottom point of the polygon. Mark it for removal:
+          activepolygon._remove = true
+          removeCount++
         } else {
           activepolygon.leftvertexindex = newleftvertexindex
           activepolygon.rightvertexindex = newrightvertexindex
@@ -160,6 +161,10 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         }
       } // if polygon has corner here
     } // for activepolygonindex
+    // Filter out marked polygons in single pass (O(n) instead of O(n²) splice)
+    if (removeCount > 0) {
+      activepolygons = activepolygons.filter((p) => !p._remove)
+    }
     let nextycoordinate
     if (yindex >= ycoordinates.length - 1) {
       // last row, all polygons must be finished here:

package/src/operations/modifiers/reTesselateCoplanarPolygons.test.js

@@ -16,7 +16,7 @@ const rotatePoly3 = (angles, polygon) => {
   return poly3.transform(matrix, polygon)
 }
 
-test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
+test('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
   const polyA = poly3.create([[-5, -5, 0], [5, -5, 0], [5, 5, 0], [-5, 5, 0]])
   const polyB = poly3.create([[5, -5, 0], [8, 0, 0], [5, 5, 0]])
   const polyC = poly3.create([[-5, 5, 0], [-8, 0, 0], [-5, -5, 0]])
@@ -68,3 +68,38 @@ test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) =>
   obs = reTesselateCoplanarPolygons([polyH, polyI, polyJ, polyK, polyL])
   t.is(obs.length, 1)
 })
+
+// Test for mark-and-filter optimization: multiple polygons that reach their
+// bottom point at the same y-coordinate (triggering the removal code path)
+test('retessellateCoplanarPolygons: should correctly handle multiple polygon removals', (t) => {
+  // Create multiple triangular polygons that all end at the same y-coordinate
+  // This exercises the mark-and-filter removal optimization
+  const poly1 = poly3.create([[0, 0, 0], [2, 0, 0], [1, 3, 0]]) // triangle pointing up
+  const poly2 = poly3.create([[3, 0, 0], [5, 0, 0], [4, 3, 0]]) // triangle pointing up
+  const poly3a = poly3.create([[6, 0, 0], [8, 0, 0], [7, 3, 0]]) // triangle pointing up
+
+  // These polygons share the same plane and have vertices at y=0 and y=3
+  // During retessellation, all three will be active and then removed at y=3
+  const obs = reTesselateCoplanarPolygons([poly1, poly2, poly3a])
+
+  // Each triangle should be preserved (they don't overlap)
+  t.is(obs.length, 3)
+
+  // Verify each polygon has 3 vertices (triangles)
+  obs.forEach((polygon) => {
+    t.is(polygon.vertices.length, 3)
+  })
+})
+
+// Test for mark-and-filter with overlapping polygons that get merged
+test('retessellateCoplanarPolygons: should merge adjacent polygons with shared edges', (t) => {
+  // Two adjacent squares sharing an edge at x=5
+  const poly1 = poly3.create([[0, 0, 0], [5, 0, 0], [5, 5, 0], [0, 5, 0]])
+  const poly2 = poly3.create([[5, 0, 0], [10, 0, 0], [10, 5, 0], [5, 5, 0]])
+
+  const obs = reTesselateCoplanarPolygons([poly1, poly2])
+
+  // Should merge into a single rectangle
+  t.is(obs.length, 1)
+  t.is(obs[0].vertices.length, 4) // rectangle has 4 vertices
+})

package/src/operations/modifiers/retessellate.js

@@ -22,8 +22,11 @@ const retessellate = (geometry) => {
   const destPolygons = []
   classified.forEach((group) => {
     if (Array.isArray(group)) {
-      const reTessellateCoplanarPolygons = reTesselateCoplanarPolygons(group)
-      destPolygons.push(...reTessellateCoplanarPolygons)
+      const coplanarPolygons = reTesselateCoplanarPolygons(group)
+      // Use loop instead of spread to avoid stack overflow with large arrays
+      for (let i = 0; i < coplanarPolygons.length; i++) {
+        destPolygons.push(coplanarPolygons[i])
+      }
     } else {
       destPolygons.push(group)
     }

package/src/operations/modifiers/snap.test.js

@@ -25,31 +25,40 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
 
   pts = path2.toPoints(results[1])
   exp = [
-    [0.5, 0], [0.383022221559489, 0.3213938048432696],
-    [0.08682408883346521, 0.492403876506104], [-0.2499999999999999, 0.43301270189221935],
-    [-0.46984631039295416, 0.17101007166283444], [-0.4698463103929542, -0.17101007166283433],
-    [-0.2500000000000002, -0.43301270189221924], [0.08682408883346499, -0.49240387650610407],
-    [0.3830222215594889, -0.3213938048432698]
+    [ 0.5, 0 ],
+    [ 0.35355000000000003, 0.35355000000000003 ],
+    [ 0, 0.5 ],
+    [ -0.35355000000000003, 0.35355000000000003 ],
+    [ -0.5, 0 ],
+    [ -0.35355000000000003, -0.35355000000000003 ],
+    [ 0, -0.5 ],
+    [ 0.35355000000000003, -0.35355000000000003 ]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = path2.toPoints(results[2])
   exp = [
-    [0.6666666666666666, 0], [0.5106962954126519, 0.4285250731243595],
-    [0.11576545177795361, 0.6565385020081387], [-0.33333333333333315, 0.5773502691896257],
-    [-0.6264617471906055, 0.22801342888377923], [-0.6264617471906055, -0.2280134288837791],
-    [-0.3333333333333336, -0.5773502691896256], [0.1157654517779533, -0.6565385020081387],
-    [0.5106962954126518, -0.4285250731243597]
+    [ 0.6666666666666666, 0 ],
+    [ 0.4714, 0.4714 ],
+    [ 0, 0.6666666666666666 ],
+    [ -0.4714, 0.4714 ],
+    [ -0.6666666666666666, 0 ],
+    [ -0.4714, -0.4714 ],
+    [ 0, -0.6666666666666666 ],
+    [ 0.4714, -0.4714 ]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = path2.toPoints(results[3])
   exp = [
-    [1570.7979271820118, 0], [1203.3061290889411, 1009.6890116376164],
-    [272.7710864950155, 1546.9412033856784], [-785.3989635910059, 1360.3552181729126],
-    [-1476.0772155839566, 537.2521917480618], [-1476.0772155839566, -537.2521917480618],
-    [-785.3989635910059, -1360.3552181729126], [272.7710864950155, -1546.9412033856784],
-    [1203.3061290889411, -1009.6890116376164]
+    [ 1570.7963267948967, 0 ],
+    [ 1110.7100826766714, 1110.7100826766714 ],
+    [ 0, 1570.7963267948967 ],
+    [ -1110.7100826766714, 1110.7100826766714 ],
+    [ -1570.7963267948967, 0 ],
+    [ -1110.7100826766714, -1110.7100826766714 ],
+    [ 0, -1570.7963267948967 ],
+    [ 1110.7100826766714, -1110.7100826766714 ]
   ]
   t.true(comparePoints(pts, exp))
 })