perf(modeling): Inefficient recursive flatten utility uses O(n²) concat

[jbroll]

Summary

The flatten() utility uses recursive concat() which creates a new array for every element processed.

Usage Frequency: EXTREMELY HIGH

Used by 48 files across the entire codebase:

• All transform operations (translate, rotate, scale, mirror, align, center)
• All boolean operations (union, subtract, intersect, scission)
• All hull operations
• All measurement functions
• Color operations

Typical model usage: Called on virtually every operation that accepts multiple geometries. A model with 10 operations might call flatten 50+ times.

Problem

File: packages/modeling/src/utils/flatten.js
Line: 8

const flatten = (arr) => arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])

This creates a new array for every single element via concat(). For an array of N elements (including nested), this performs N array allocations and O(n²) total copying.

Suggested Fix

Use modern Array.flat() or an iterative approach:

// Modern JS (Node 11+):
const flatten = (arr) => arr.flat(Infinity)

// Or iterative for older environments:
const flatten = (arr) => {
  const result = []
  const stack = [...arr]
  while (stack.length) {
    const item = stack.pop()
    if (Array.isArray(item)) {
      stack.push(...item)
    } else {
      result.push(item)
    }
  }
  return result.reverse()
}

Impact

HIGH - this is called constantly. Every union([a, b, c]) or translate([1,0,0], a, b) uses flatten.

[jbroll]

Note on spread operator limits: The iterative fix I suggested uses stack.push(...item) which has stack limits (65k-500k elements). A safer version:

const flatten = (arr) => {
  const result = []
  const stack = arr.slice()
  while (stack.length) {
    const item = stack.pop()
    if (Array.isArray(item)) {
      for (let i = 0; i < item.length; i++) {
        stack.push(item[i])
      }
    } else {
      result.push(item)
    }
  }
  return result.reverse()
}

Or simply use Array.flat(Infinity) if the Node.js version supports it (11+).

Benchmark baseline showing O(n²) behavior:

Items	Time	Scaling
10	2 µs	baseline
100	38 µs	19x (should be 10x)
1000	2130 µs	56x (should be 10x)

This is one of the highest-impact fixes since flatten is used by 48 files.