@jbroll/jscad-modeling 2.12.8 → 2.13.1

package/.claude/settings.local.json

@@ -3,28 +3,24 @@
     "allow": [
       "Bash(wc:*)",
       "Bash(git add:*)",
-      "Bash(git commit -m \"$\\(cat <<''EOF''\ndocs\\(modeling\\): add CLAUDE.md for AI assistant guidance\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
+      "Bash(git commit:*)",
+      "Bash(git checkout:*)",
+      "Bash(git push:*)",
       "Bash(gh auth:*)",
-      "Bash(gh issue create --title \"perf\\(modeling\\): O\\(n²\\) array concatenation in extrudeFromSlices.js\" --body \"$\\(cat <<''EOF''\n## Summary\n`extrudeFromSlices.js` uses `Array.concat\\(\\)` inside a loop, causing O\\(n²\\) memory operations.\n\n## Usage Frequency: VERY HIGH\nThis function is the core of all extrusion operations:\n- `extrudeLinearGeom2.js`\n- `extrudeRotate.js`  \n- `extrudeHelical.js`\n\nEvery extrusion operation goes through this code path.\n\n## Problem\n**File:** `packages/modeling/src/operations/extrusions/extrudeFromSlices.js`\n**Lines:** 84, 98, 102-103, 108\n\n```javascript\nfor \\(let s = 0; s < numberOfSlices; s++\\) {\n  // ...\n  if \\(prevSlice\\) {\n    polygons = polygons.concat\\(extrudeWalls\\(prevSlice, currentSlice\\)\\)  // Creates new array each iteration\n  }\n}\n// ...\npolygons = polygons.concat\\(endPolygons\\)\npolygons = polygons.concat\\(startPolygons\\)\n```\n\nEach `concat\\(\\)` creates a new array and copies all existing elements. For N slices, this performs O\\(n²\\) copy operations.\n\n## Suggested Fix\nUse `push\\(\\)` with spread operator:\n\n```javascript\nfor \\(let s = 0; s < numberOfSlices; s++\\) {\n  if \\(prevSlice\\) {\n    polygons.push\\(...extrudeWalls\\(prevSlice, currentSlice\\)\\)\n  }\n}\npolygons.push\\(...endPolygons\\)\npolygons.push\\(...startPolygons\\)\n```\n\n## Impact\nHigh - affects performance of all extrusion operations, especially with many slices.\nEOF\n\\)\")",
-      "Bash(gh issue create --repo jscad/OpenJSCAD.org --title \"perf\\(modeling\\): O\\(n²\\) array concatenation in extrudeFromSlices.js\" --body \"$\\(cat <<''EOF''\n## Summary\n`extrudeFromSlices.js` uses `Array.concat\\(\\)` inside a loop, causing O\\(n²\\) memory operations.\n\n## Usage Frequency: VERY HIGH\nThis function is the core of all extrusion operations:\n- `extrudeLinearGeom2.js`\n- `extrudeRotate.js`  \n- `extrudeHelical.js`\n\nEvery extrusion operation goes through this code path.\n\n## Problem\n**File:** `packages/modeling/src/operations/extrusions/extrudeFromSlices.js`  \n**Lines:** 84, 98, 102-103, 108\n\n```javascript\nfor \\(let s = 0; s < numberOfSlices; s++\\) {\n  // ...\n  if \\(prevSlice\\) {\n    polygons = polygons.concat\\(extrudeWalls\\(prevSlice, currentSlice\\)\\)  // Creates new array each iteration\n  }\n}\n// ...\npolygons = polygons.concat\\(endPolygons\\)\npolygons = polygons.concat\\(startPolygons\\)\n```\n\nEach `concat\\(\\)` creates a new array and copies all existing elements. For N slices, this performs O\\(n²\\) copy operations.\n\n## Suggested Fix\nUse `push\\(\\)` with spread operator:\n\n```javascript\nfor \\(let s = 0; s < numberOfSlices; s++\\) {\n  if \\(prevSlice\\) {\n    polygons.push\\(...extrudeWalls\\(prevSlice, currentSlice\\)\\)\n  }\n}\npolygons.push\\(...endPolygons\\)\npolygons.push\\(...startPolygons\\)\n```\n\n## Impact\nHigh - affects performance of all extrusion operations, especially with many slices.\nEOF\n\\)\")",
-      "Bash(gh issue create --repo jscad/OpenJSCAD.org --title \"perf\\(modeling\\): O\\(n²\\) array concatenation in scissionGeom3.js\" --body \"$\\(cat <<''EOF''\n## Summary\n`scissionGeom3.js` uses `Array.concat\\(\\)` inside nested loops, causing O\\(n²\\) memory operations.\n\n## Usage Frequency: LOW\nUsed only by `scission\\(\\)` operation which splits a geometry into disconnected pieces. Most typical models don''t use scission - it''s a specialized operation for:\n- Separating imported models that contain multiple parts\n- Post-processing boolean results that created separate islands\n\n**Typical model usage:** Rare - maybe 1% of models\n\n## Problem\n**File:** `packages/modeling/src/operations/booleans/scissionGeom3.js`  \n**Lines:** 40-42\n\n```javascript\nconst indexesPerPolygon = polygons.map\\(\\(polygon\\) => {\n  let indexes = []\n  polygon.vertices.forEach\\(\\(point\\) => {\n    indexes = indexes.concat\\(findMapping\\(indexesPerPoint, vec3.snap\\(temp, point, eps\\)\\)\\)\n  }\\)\n  return { e: 1, d: sortNb\\(indexes\\) }\n}\\)\n```\n\nFor each vertex of each polygon, `concat\\(\\)` creates a new array. With N polygons averaging V vertices, this is O\\(N*V\\) array allocations.\n\n## Suggested Fix\nUse `push\\(\\)` with spread:\n\n```javascript\nconst indexesPerPolygon = polygons.map\\(\\(polygon\\) => {\n  const indexes = []\n  polygon.vertices.forEach\\(\\(point\\) => {\n    indexes.push\\(...findMapping\\(indexesPerPoint, vec3.snap\\(temp, point, eps\\)\\)\\)\n  }\\)\n  return { e: 1, d: sortNb\\(indexes\\) }\n}\\)\n```\n\n## Impact\nLow overall \\(rare operation\\), but when used on complex geometry it can be slow.\nEOF\n\\)\")",
       "Bash(gh issue create:*)",
-      "Bash(npm run bench:*)",
       "Bash(gh issue view:*)",
-      "Bash(git commit -m \"$\\(cat <<''EOF''\nperf\\(modeling\\): add benchmark suite for performance testing\n\nAdds benchmarks for:\n- Booleans \\(union, subtract, intersect at varying complexity\\)\n- Extrusions \\(extrudeLinear, extrudeRotate with varying slices\\)\n- Measurements \\(boundingBox, volume, area\\)\n- Transforms \\(translate, rotate, scale, center\\)\n- Utils \\(flatten with varying array sizes\\)\n\nRun with: npm run bench\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
       "Bash(gh issue comment:*)",
+      "Bash(gh pr create:*)",
+      "Bash(npm run bench:*)",
       "Bash(npm test:*)",
+      "Bash(npm install)",
+      "Bash(npm whoami:*)",
       "Bash(npx ava:*)",
       "Bash(node -e:*)",
-      "Bash(git commit:*)",
       "Bash(ls:*)",
       "Bash(grep:*)",
-      "Bash(npm install)",
-      "Bash(git checkout:*)",
-      "Bash(git push:*)",
-      "Bash(gh pr create:*)",
       "Bash(cat:*)",
-      "Bash(npm whoami:*)"
+      "Bash(npm run test:tsd:*)"
     ]
   }
 }

package/bench/splitPolygon.bench.js

@@ -0,0 +1,143 @@
+/**
+ * Direct benchmark for splitPolygonByPlane - the hot path in boolean operations
+ *
+ * Run with: node --expose-gc bench/splitPolygon.bench.js
+ */
+
+const { sphere, torus } = require('../src/primitives')
+const splitPolygonByPlane = require('../src/operations/booleans/trees/splitPolygonByPlane')
+const poly3 = require('../src/geometries/poly3')
+const plane = require('../src/maths/plane')
+
+// Benchmark helper
+const benchmark = (name, setup, fn, iterations = 1000) => {
+  const data = setup()
+
+  // Force GC if available
+  if (global.gc) global.gc()
+
+  // Warmup
+  for (let i = 0; i < 100; i++) fn(data)
+
+  if (global.gc) global.gc()
+  const heapBefore = process.memoryUsage().heapUsed
+
+  const start = process.hrtime.bigint()
+  for (let i = 0; i < iterations; i++) {
+    fn(data)
+  }
+  const end = process.hrtime.bigint()
+
+  if (global.gc) global.gc()
+  const heapAfter = process.memoryUsage().heapUsed
+
+  const totalNs = Number(end - start)
+  const avgNs = totalNs / iterations
+  const avgUs = avgNs / 1000
+  const heapDelta = (heapAfter - heapBefore) / 1024
+
+  console.log(`${name.padEnd(50)} ${avgUs.toFixed(2).padStart(8)} µs/op  heap: ${heapDelta > 0 ? '+' : ''}${heapDelta.toFixed(0)} KB`)
+  return avgUs
+}
+
+console.log('='.repeat(80))
+console.log('splitPolygonByPlane Direct Benchmark')
+console.log('='.repeat(80))
+console.log()
+
+// Get polygons from a sphere
+const testSphere = sphere({ radius: 5, segments: 32 })
+const polygons = testSphere.polygons
+
+console.log(`Test geometry: sphere(32) with ${polygons.length} polygons`)
+console.log(`Average vertices per polygon: ${(polygons.reduce((sum, p) => sum + p.vertices.length, 0) / polygons.length).toFixed(1)}`)
+console.log()
+
+// Test 1: Coplanar case (fast path - type 0 or 1)
+console.log('--- Coplanar Cases (fast path) ---')
+benchmark('coplanar-front (type 0)', () => {
+  const polygon = polygons[0]
+  const pplane = poly3.plane(polygon)
+  return { polygon, splane: pplane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+// Test 2: Entirely front (type 2)
+console.log()
+console.log('--- One-side Cases (no split needed) ---')
+benchmark('entirely front (type 2)', () => {
+  const polygon = polygons[0]
+  // Create a plane far behind the polygon
+  const splane = [0, 0, 1, -100]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+benchmark('entirely back (type 3)', () => {
+  const polygon = polygons[0]
+  // Create a plane far in front of the polygon
+  const splane = [0, 0, 1, 100]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+// Test 3: Spanning case (type 4) - this is where allocations hurt
+console.log()
+console.log('--- Spanning Cases (allocations happen here) ---')
+benchmark('spanning split (type 4) - triangle', () => {
+  // A triangle that will be split
+  const polygon = poly3.create([[0, 0, 0], [10, 0, 0], [5, 10, 0]])
+  const splane = [1, 0, 0, 5] // Split down the middle
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+benchmark('spanning split (type 4) - quad', () => {
+  const polygon = poly3.create([[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]])
+  const splane = [1, 0, 0, 5]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+benchmark('spanning split (type 4) - hexagon', () => {
+  const polygon = poly3.create([
+    [0, 0, 0], [5, 0, 0], [7.5, 4, 0],
+    [5, 8, 0], [0, 8, 0], [-2.5, 4, 0]
+  ])
+  const splane = [1, 0, 0, 2.5]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+// Test 4: Realistic mix from actual boolean operation
+console.log()
+console.log('--- Realistic Mix (simulating boolean op) ---')
+benchmark('mixed types from sphere polygons', () => {
+  // Use multiple polygons with a plane that hits various cases
+  const splane = [0.577, 0.577, 0.577, 0] // Diagonal plane through origin
+  return { polygons: polygons.slice(0, 50), splane }
+}, (data) => {
+  let spanning = 0
+  for (const polygon of data.polygons) {
+    const result = splitPolygonByPlane(data.splane, polygon)
+    if (result.type === 4) spanning++
+  }
+  return spanning
+}, 1000)
+
+// Measure allocation overhead specifically
+console.log()
+console.log('--- Allocation Stress Test ---')
+benchmark('10k spanning splits (allocation heavy)', () => {
+  const polygon = poly3.create([[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]])
+  const splane = [1, 0, 0, 5]
+  return { polygon, splane }
+}, (data) => {
+  for (let i = 0; i < 100; i++) {
+    splitPolygonByPlane(data.splane, data.polygon)
+  }
+}, 100)
+
+console.log()
+console.log('='.repeat(80))
+console.log('Benchmark complete')
+console.log()
+console.log('Note: "spanning split" cases allocate the most:')
+console.log('  - result object { type, front, back }')
+console.log('  - vertexIsBack[] array')
+console.log('  - frontvertices[] and backvertices[] arrays')
+console.log('  - Two new poly3 objects (front and back)')