@gridspace/raster-path 1.0.6 → 1.0.7

package/build/raster-worker.js

@@ -9,6 +9,8 @@ var cachedToolpathPipeline = null;
 var cachedToolpathShaderModule = null;
 var cachedRadialBatchPipeline = null;
 var cachedRadialBatchShaderModule = null;
+var cachedTracingPipeline = null;
+var cachedTracingShaderModule = null;
 var EMPTY_CELL = -1e10;
 var log_pre = "[Worker]";
 var diagnostic = false;
@@ -535,6 +537,102 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     }
 }
 `;
+var tracingShaderCode = `// Tracing toolpath generation
+// Follows input polylines and calculates Z-depth at each sampled point
+// Sentinel value for empty terrain cells (must match rasterize shader)
+const EMPTY_CELL: f32 = -1e10;
+const MAX_F32: f32 = 3.402823466e+38;
+
+struct SparseToolPoint {
+    x_offset: i32,
+    y_offset: i32,
+    z_value: f32,
+    padding: f32,
+}
+
+struct Uniforms {
+    terrain_width: u32,
+    terrain_height: u32,
+    tool_count: u32,
+    point_count: u32,        // Number of sampled points to process
+    path_index: u32,         // Index of current path being processed
+    terrain_min_x: f32,      // Terrain bounding box (world coordinates)
+    terrain_min_y: f32,
+    grid_step: f32,          // Resolution of terrain rasterization
+    oob_z: f32,              // Z value for out-of-bounds points (zFloor)
+}
+
+@group(0) @binding(0) var<storage, read> terrain_map: array<f32>;
+@group(0) @binding(1) var<storage, read> sparse_tool: array<SparseToolPoint>;
+@group(0) @binding(2) var<storage, read> input_points: array<f32>;  // XY pairs
+@group(0) @binding(3) var<storage, read_write> output_depths: array<f32>;  // Z values
+@group(0) @binding(4) var<storage, read_write> max_z_buffer: array<atomic<i32>>;  // Max Z per path (as bits)
+@group(0) @binding(5) var<uniform> uniforms: Uniforms;
+
+@compute @workgroup_size(64, 1, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let point_idx = global_id.x;
+
+    if (point_idx >= uniforms.point_count) {
+        return;
+    }
+
+    // Read input X,Y world coordinates
+    let world_x = input_points[point_idx * 2u + 0u];
+    let world_y = input_points[point_idx * 2u + 1u];
+
+    // Convert world coordinates to grid coordinates
+    let grid_x_f32 = (world_x - uniforms.terrain_min_x) / uniforms.grid_step;
+    let grid_y_f32 = (world_y - uniforms.terrain_min_y) / uniforms.grid_step;
+    let tool_center_x = i32(grid_x_f32);
+    let tool_center_y = i32(grid_y_f32);
+
+    // Check if tool center is outside terrain bounds
+    let center_oob = tool_center_x < 0 || tool_center_x >= i32(uniforms.terrain_width) ||
+                     tool_center_y < 0 || tool_center_y >= i32(uniforms.terrain_height);
+
+    var max_collision_z = uniforms.oob_z;
+    var found_collision = false;
+
+    // Test each tool point for collision with terrain
+    for (var i = 0u; i < uniforms.tool_count; i++) {
+        let tool_point = sparse_tool[i];
+        let terrain_x = tool_center_x + tool_point.x_offset;
+        let terrain_y = tool_center_y + tool_point.y_offset;
+
+        // Bounds check: terrain sample must be within terrain grid
+        if (terrain_x < 0 || terrain_x >= i32(uniforms.terrain_width) ||
+            terrain_y < 0 || terrain_y >= i32(uniforms.terrain_height)) {
+            continue;
+        }
+
+        let terrain_idx = u32(terrain_y) * uniforms.terrain_width + u32(terrain_x);
+        let terrain_z = terrain_map[terrain_idx];
+
+        // Check if terrain cell has geometry (not empty sentinel value)
+        if (terrain_z > EMPTY_CELL + 1.0) {
+            // Tool z_value is positive offset from tip (tip=0, shaft=+50)
+            // Add to terrain height to find where tool center needs to be
+            let collision_z = terrain_z + tool_point.z_value;
+            max_collision_z = max(max_collision_z, collision_z);
+            found_collision = true;
+        }
+    }
+
+    // If no collision found and center was in-bounds, use oob_z
+    var output_z = uniforms.oob_z;
+    if (found_collision) {
+        output_z = max_collision_z;
+    }
+
+    output_depths[point_idx] = output_z;
+
+    // Update max Z for this path using atomic operation
+    // Convert float to int bits for atomic comparison
+    let z_bits = bitcast<i32>(output_z);
+    atomicMax(&max_z_buffer[uniforms.path_index], z_bits);
+}
+`;
 async function initWebGPU() {
   if (isInitialized)
     return true;
@@ -549,10 +647,7 @@ async function initWebGPU() {
       return false;
     }
     const adapterLimits = adapter.limits;
-    debug.log("Adapter limits:", {
-      maxStorageBufferBindingSize: adapterLimits.maxStorageBufferBindingSize,
-      maxBufferSize: adapterLimits.maxBufferSize
-    });
+    debug.log("Adapter limits:", adapterLimits);
     device = await adapter.requestDevice({
       requiredLimits: {
         maxStorageBufferBindingSize: Math.min(
@@ -582,6 +677,11 @@ async function initWebGPU() {
       layout: "auto",
       compute: { module: cachedRadialBatchShaderModule, entryPoint: "main" }
     });
+    cachedTracingShaderModule = device.createShaderModule({ code: tracingShaderCode });
+    cachedTracingPipeline = device.createComputePipeline({
+      layout: "auto",
+      compute: { module: cachedTracingShaderModule, entryPoint: "main" }
+    });
     deviceCapabilities = {
       maxStorageBufferBindingSize: device.limits.maxStorageBufferBindingSize,
       maxBufferSize: device.limits.maxBufferSize,
@@ -2037,7 +2137,7 @@ async function generateRadialToolpaths({
       if (!strip.positions || strip.positions.length === 0)
         continue;
       if (diagnostic && (globalStripIdx === 0 || globalStripIdx === 360)) {
-        debug.log(`GLY1HF51 | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}\xB0) INPUT terrain first 5 Z values: ${strip.positions.slice(0, 5).map((v) => v.toFixed(3)).join(",")}`);
+        debug.log(`YGWIPII2 | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}\xB0) INPUT terrain first 5 Z values: ${strip.positions.slice(0, 5).map((v) => v.toFixed(3)).join(",")}`);
       }
       const stripToolpathResult = await runToolpathComputeWithBuffers(
         strip.positions,
@@ -2050,7 +2150,7 @@ async function generateRadialToolpaths({
         pipelineStartTime
       );
       if (diagnostic && (globalStripIdx === 0 || globalStripIdx === 360)) {
-        debug.log(`GLY1HF51 | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}\xB0) OUTPUT toolpath first 5 Z values: ${stripToolpathResult.pathData.slice(0, 5).map((v) => v.toFixed(3)).join(",")}`);
+        debug.log(`YGWIPII2 | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}\xB0) OUTPUT toolpath first 5 Z values: ${stripToolpathResult.pathData.slice(0, 5).map((v) => v.toFixed(3)).join(",")}`);
       }
       allStripToolpaths.push({
         angle: strip.angle,
@@ -2069,7 +2169,6 @@ async function generateRadialToolpaths({
     const batchTotalTime = performance.now() - batchStartTime;
     Object.assign(batchInfo, {
       "prep": batchInfo.prep || 0,
-      "gpu": batchInfo.gpu || 0,
       "stitch": batchInfo.stitch || 0,
       "raster": batchInfo.raster || 0,
       "paths": toolpathTime | 0,
@@ -2101,6 +2200,284 @@ async function generateRadialToolpaths({
   };
 }
 
+// src/core/path-tracing.js
+var cachedTracingBuffers = null;
+function createReusableTracingBuffers(terrainPositions, toolPositions) {
+  if (!isInitialized) {
+    throw new Error("WebGPU not initialized");
+  }
+  if (cachedTracingBuffers) {
+    destroyReusableTracingBuffers();
+  }
+  const sparseToolData = createSparseToolFromPoints(toolPositions);
+  debug.log(`Created reusable tracing buffers: terrain ${terrainPositions.length} floats, tool ${sparseToolData.count} points`);
+  const terrainBuffer = device.createBuffer({
+    size: terrainPositions.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(terrainBuffer, 0, terrainPositions);
+  const toolBufferData = new ArrayBuffer(sparseToolData.count * 16);
+  const toolBufferI32 = new Int32Array(toolBufferData);
+  const toolBufferF32 = new Float32Array(toolBufferData);
+  for (let i = 0; i < sparseToolData.count; i++) {
+    toolBufferI32[i * 4 + 0] = sparseToolData.xOffsets[i];
+    toolBufferI32[i * 4 + 1] = sparseToolData.yOffsets[i];
+    toolBufferF32[i * 4 + 2] = sparseToolData.zValues[i];
+    toolBufferF32[i * 4 + 3] = 0;
+  }
+  const toolBuffer = device.createBuffer({
+    size: toolBufferData.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(toolBuffer, 0, toolBufferData);
+  cachedTracingBuffers = {
+    terrainBuffer,
+    toolBuffer,
+    sparseToolData
+  };
+  return cachedTracingBuffers;
+}
+function destroyReusableTracingBuffers() {
+  if (cachedTracingBuffers) {
+    cachedTracingBuffers.terrainBuffer.destroy();
+    cachedTracingBuffers.toolBuffer.destroy();
+    cachedTracingBuffers = null;
+    debug.log("Destroyed reusable tracing buffers");
+  }
+}
+function samplePath(pathXY, step) {
+  if (pathXY.length < 2) {
+    return new Float32Array(pathXY);
+  }
+  const numVertices = pathXY.length / 2;
+  const sampledPoints = [];
+  sampledPoints.push(pathXY[0], pathXY[1]);
+  for (let i = 0; i < numVertices - 1; i++) {
+    const x1 = pathXY[i * 2];
+    const y1 = pathXY[i * 2 + 1];
+    const x2 = pathXY[(i + 1) * 2];
+    const y2 = pathXY[(i + 1) * 2 + 1];
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const segmentLength = Math.sqrt(dx * dx + dy * dy);
+    if (segmentLength > step) {
+      const numSubdivisions = Math.ceil(segmentLength / step);
+      const subdivisionStep = 1 / numSubdivisions;
+      for (let j = 1; j < numSubdivisions; j++) {
+        const t = j * subdivisionStep;
+        const x = x1 + t * dx;
+        const y = y1 + t * dy;
+        sampledPoints.push(x, y);
+      }
+    }
+    if (i < numVertices - 1) {
+      sampledPoints.push(x2, y2);
+    }
+  }
+  return new Float32Array(sampledPoints);
+}
+async function generateTracingToolpaths({
+  paths,
+  terrainPositions,
+  terrainData,
+  toolPositions,
+  step,
+  gridStep,
+  terrainBounds,
+  zFloor,
+  onProgress
+}) {
+  const startTime = performance.now();
+  debug.log("Generating tracing toolpaths...");
+  debug.log(`Input: ${paths.length} paths, step=${step}, gridStep=${gridStep}, zFloor=${zFloor}`);
+  debug.log(`Terrain: ${terrainData.width}\xD7${terrainData.height}, bounds: min(${terrainBounds.min.x.toFixed(2)}, ${terrainBounds.min.y.toFixed(2)}) max(${terrainBounds.max.x.toFixed(2)}, ${terrainBounds.max.y.toFixed(2)})`);
+  if (!isInitialized) {
+    const success = await initWebGPU();
+    if (!success) {
+      throw new Error("WebGPU not available");
+    }
+  }
+  let terrainBuffer, toolBuffer, sparseToolData;
+  let shouldCleanupBuffers = false;
+  if (cachedTracingBuffers) {
+    debug.log("Using cached tracing buffers");
+    terrainBuffer = cachedTracingBuffers.terrainBuffer;
+    toolBuffer = cachedTracingBuffers.toolBuffer;
+    sparseToolData = cachedTracingBuffers.sparseToolData;
+  } else {
+    debug.log("Creating temporary tracing buffers");
+    sparseToolData = createSparseToolFromPoints(toolPositions);
+    debug.log(`Created sparse tool: ${sparseToolData.count} points`);
+    terrainBuffer = device.createBuffer({
+      size: terrainPositions.byteLength,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(terrainBuffer, 0, terrainPositions);
+    const toolBufferData = new ArrayBuffer(sparseToolData.count * 16);
+    const toolBufferI32 = new Int32Array(toolBufferData);
+    const toolBufferF32 = new Float32Array(toolBufferData);
+    for (let i = 0; i < sparseToolData.count; i++) {
+      toolBufferI32[i * 4 + 0] = sparseToolData.xOffsets[i];
+      toolBufferI32[i * 4 + 1] = sparseToolData.yOffsets[i];
+      toolBufferF32[i * 4 + 2] = sparseToolData.zValues[i];
+      toolBufferF32[i * 4 + 3] = 0;
+    }
+    toolBuffer = device.createBuffer({
+      size: toolBufferData.byteLength,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(toolBuffer, 0, toolBufferData);
+    await device.queue.onSubmittedWorkDone();
+    shouldCleanupBuffers = true;
+  }
+  const SENTINEL_Z = -1e30;
+  const sentinelBits = new Float32Array([SENTINEL_Z]);
+  const sentinelI32 = new Int32Array(sentinelBits.buffer)[0];
+  const maxZInitData = new Int32Array(paths.length).fill(sentinelI32);
+  const maxZBuffer = device.createBuffer({
+    size: maxZInitData.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+  });
+  device.queue.writeBuffer(maxZBuffer, 0, maxZInitData);
+  const outputPaths = [];
+  let totalSampledPoints = 0;
+  for (let pathIdx = 0; pathIdx < paths.length; pathIdx++) {
+    const pathStartTime = performance.now();
+    const inputPath = paths[pathIdx];
+    debug.log(`Processing path ${pathIdx + 1}/${paths.length}: ${inputPath.length / 2} input vertices`);
+    const sampledPath = samplePath(inputPath, step);
+    const numSampledPoints = sampledPath.length / 2;
+    totalSampledPoints += numSampledPoints;
+    debug.log(`  Sampled to ${numSampledPoints} points`);
+    const firstX = sampledPath[0];
+    const firstY = sampledPath[1];
+    const gridX = (firstX - terrainBounds.min.x) / gridStep;
+    const gridY = (firstY - terrainBounds.min.y) / gridStep;
+    debug.log(`  First point: world(${firstX.toFixed(2)}, ${firstY.toFixed(2)}) -> grid(${gridX.toFixed(2)}, ${gridY.toFixed(2)})`);
+    debug.log(`  Terrain: ${terrainData.width}x${terrainData.height}, bounds: (${terrainBounds.min.x.toFixed(2)}, ${terrainBounds.min.y.toFixed(2)}) to (${terrainBounds.max.x.toFixed(2)}, ${terrainBounds.max.y.toFixed(2)})`);
+    const inputBufferSize = sampledPath.byteLength;
+    const outputBufferSize = numSampledPoints * 4;
+    const estimatedMemory = inputBufferSize + outputBufferSize;
+    const configuredLimit = config.maxGPUMemoryMB * 1024 * 1024;
+    const deviceLimit = deviceCapabilities.maxStorageBufferBindingSize;
+    const maxSafeSize = Math.min(configuredLimit, deviceLimit) * config.gpuMemorySafetyMargin;
+    if (estimatedMemory > maxSafeSize) {
+      terrainBuffer.destroy();
+      toolBuffer.destroy();
+      throw new Error(
+        `Path ${pathIdx + 1} exceeds GPU memory limits: ${(estimatedMemory / 1024 / 1024).toFixed(1)}MB > ${(maxSafeSize / 1024 / 1024).toFixed(1)}MB safe limit. Consider reducing step parameter or splitting path.`
+      );
+    }
+    const inputBuffer = device.createBuffer({
+      size: sampledPath.byteLength,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(inputBuffer, 0, sampledPath);
+    const outputBuffer = device.createBuffer({
+      size: outputBufferSize,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    });
+    const uniformData = new Uint32Array(12);
+    uniformData[0] = terrainData.width;
+    uniformData[1] = terrainData.height;
+    uniformData[2] = sparseToolData.count;
+    uniformData[3] = numSampledPoints;
+    uniformData[4] = pathIdx;
+    const uniformDataFloat = new Float32Array(uniformData.buffer);
+    uniformDataFloat[5] = terrainBounds.min.x;
+    uniformDataFloat[6] = terrainBounds.min.y;
+    uniformDataFloat[7] = gridStep;
+    uniformDataFloat[8] = zFloor;
+    const uniformBuffer = device.createBuffer({
+      size: uniformData.byteLength,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(uniformBuffer, 0, uniformData);
+    await device.queue.onSubmittedWorkDone();
+    const bindGroup = device.createBindGroup({
+      layout: cachedTracingPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: terrainBuffer } },
+        { binding: 1, resource: { buffer: toolBuffer } },
+        { binding: 2, resource: { buffer: inputBuffer } },
+        { binding: 3, resource: { buffer: outputBuffer } },
+        { binding: 4, resource: { buffer: maxZBuffer } },
+        { binding: 5, resource: { buffer: uniformBuffer } }
+      ]
+    });
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(cachedTracingPipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+    const workgroupsX = Math.ceil(numSampledPoints / 64);
+    passEncoder.dispatchWorkgroups(workgroupsX);
+    passEncoder.end();
+    const stagingBuffer = device.createBuffer({
+      size: outputBufferSize,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    commandEncoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, outputBufferSize);
+    device.queue.submit([commandEncoder.finish()]);
+    await device.queue.onSubmittedWorkDone();
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+    const outputDepths = new Float32Array(stagingBuffer.getMappedRange());
+    const depthsCopy = new Float32Array(outputDepths);
+    stagingBuffer.unmap();
+    const outputXYZ = new Float32Array(numSampledPoints * 3);
+    for (let i = 0; i < numSampledPoints; i++) {
+      outputXYZ[i * 3 + 0] = sampledPath[i * 2 + 0];
+      outputXYZ[i * 3 + 1] = sampledPath[i * 2 + 1];
+      outputXYZ[i * 3 + 2] = depthsCopy[i];
+    }
+    outputPaths.push(outputXYZ);
+    inputBuffer.destroy();
+    outputBuffer.destroy();
+    uniformBuffer.destroy();
+    stagingBuffer.destroy();
+    const pathTime = performance.now() - pathStartTime;
+    debug.log(`  Path ${pathIdx + 1} complete: ${numSampledPoints} points in ${pathTime.toFixed(1)}ms`);
+    if (onProgress) {
+      onProgress({
+        type: "tracing-progress",
+        data: {
+          percent: Math.round((pathIdx + 1) / paths.length * 100),
+          current: pathIdx + 1,
+          total: paths.length,
+          pathIndex: pathIdx
+        }
+      });
+    }
+  }
+  const maxZStagingBuffer = device.createBuffer({
+    size: maxZInitData.byteLength,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
+  const maxZCommandEncoder = device.createCommandEncoder();
+  maxZCommandEncoder.copyBufferToBuffer(maxZBuffer, 0, maxZStagingBuffer, 0, maxZInitData.byteLength);
+  device.queue.submit([maxZCommandEncoder.finish()]);
+  await device.queue.onSubmittedWorkDone();
+  await maxZStagingBuffer.mapAsync(GPUMapMode.READ);
+  const maxZBitsI32 = new Int32Array(maxZStagingBuffer.getMappedRange());
+  const maxZBitsCopy = new Int32Array(maxZBitsI32);
+  maxZStagingBuffer.unmap();
+  const maxZValues = new Float32Array(maxZBitsCopy.buffer);
+  maxZBuffer.destroy();
+  maxZStagingBuffer.destroy();
+  if (shouldCleanupBuffers) {
+    terrainBuffer.destroy();
+    toolBuffer.destroy();
+    debug.log("Cleaned up temporary tracing buffers");
+  }
+  const endTime = performance.now();
+  debug.log(`Tracing complete: ${paths.length} paths, ${totalSampledPoints} total points in ${(endTime - startTime).toFixed(1)}ms`);
+  debug.log(`Max Z values: [${Array.from(maxZValues).map((z) => z.toFixed(2)).join(", ")}]`);
+  return {
+    paths: outputPaths,
+    maxZ: Array.from(maxZValues),
+    generationTime: endTime - startTime
+  };
+}
+
 // src/core/workload-calibrate.js
 var calibrateShaderCode = `// Workload Calibration Shader
 // Tests GPU watchdog limits by doing configurable amount of work per thread
@@ -2426,6 +2803,43 @@ self.onmessage = async function(e) {
           data: radialToolpathResult
         }, toolpathTransferBuffers);
         break;
+      case "tracing-generate-toolpaths":
+        const tracingResult = await generateTracingToolpaths({
+          paths: data.paths,
+          terrainPositions: data.terrainPositions,
+          terrainData: data.terrainData,
+          toolPositions: data.toolPositions,
+          step: data.step,
+          gridStep: data.gridStep,
+          terrainBounds: data.terrainBounds,
+          zFloor: data.zFloor,
+          onProgress: (progressData) => {
+            self.postMessage({
+              type: "tracing-progress",
+              data: progressData.data
+            });
+          }
+        });
+        const tracingTransferBuffers = tracingResult.paths.map((p) => p.buffer);
+        self.postMessage({
+          type: "tracing-toolpaths-complete",
+          data: tracingResult
+        }, tracingTransferBuffers);
+        break;
+      case "create-tracing-buffers":
+        createReusableTracingBuffers(data.terrainPositions, data.toolPositions);
+        self.postMessage({
+          type: "tracing-buffers-created",
+          data: { success: true }
+        });
+        break;
+      case "destroy-tracing-buffers":
+        destroyReusableTracingBuffers();
+        self.postMessage({
+          type: "tracing-buffers-destroyed",
+          data: { success: true }
+        });
+        break;
       case "calibrate":
         const calibrationResult = await calibrateGPU(device, data?.options || {});
         self.postMessage({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gridspace/raster-path",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "private": false,
   "description": "Terrain and Tool Raster Path Finder using WebGPU",
   "type": "module",
@@ -44,7 +44,8 @@
     "test:workload-calibration": "npm run build && npx electron src/test/workload-calibration.cjs",
     "test:lathe-cylinder-2-debug": "npm run build && npx electron src/test/lathe-cylinder-2-debug.cjs",
     "test:extreme-work": "npm run build && npx electron src/test/extreme-work-test.cjs",
-    "test:radial-thread-limit": "npm run build && npx electron src/test/radial-thread-limit-test.cjs"
+    "test:radial-thread-limit": "npm run build && npx electron src/test/radial-thread-limit-test.cjs",
+    "test:tracing": "npm run build && npx electron src/test/tracing-test.cjs"
   },
   "keywords": [
     "cnc",
@@ -60,6 +61,7 @@
   "license": "MIT",
   "devDependencies": {
     "electron": "^28.0.0",
+    "esbuild": "^0.27.0",
     "serve": "^14.2.1"
   }
 }

package/src/core/path-radial.js

@@ -610,7 +610,6 @@ export async function generateRadialToolpaths({
 
         Object.assign(batchInfo, {
             'prep': batchInfo.prep || 0,
-            'gpu': batchInfo.gpu || 0,
             'stitch': batchInfo.stitch || 0,
             'raster': batchInfo.raster || 0,
             'paths': (toolpathTime | 0),