@gridspace/raster-path 1.0.7 → 1.0.8

package/build/raster-worker.js

@@ -11,6 +11,10 @@ var cachedRadialBatchPipeline = null;
 var cachedRadialBatchShaderModule = null;
 var cachedTracingPipeline = null;
 var cachedTracingShaderModule = null;
+var cachedRadialV3RotatePipeline = null;
+var cachedRadialV3RotateShaderModule = null;
+var cachedRadialV3BatchedRasterizePipeline = null;
+var cachedRadialV3BatchedRasterizeShaderModule = null;
 var EMPTY_CELL = -1e10;
 var log_pre = "[Worker]";
 var diagnostic = false;
@@ -633,6 +637,242 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     atomicMax(&max_z_buffer[uniforms.path_index], z_bits);
 }
 `;
+var radialV3RotateShaderCode = `// Triangle rotation shader for radial rasterization V3
+// Rotates all triangles in a bucket by a single angle and computes Y-bounds
+
+struct Uniforms {
+    angle: f32,              // Rotation angle in radians
+    num_triangles: u32,      // Number of triangles to rotate
+}
+
+struct RotatedTriangle {
+    v0: vec3<f32>,          // Rotated vertex 0
+    v1: vec3<f32>,          // Rotated vertex 1
+    v2: vec3<f32>,          // Rotated vertex 2
+    y_min: f32,             // Minimum Y coordinate (for filtering)
+    y_max: f32,             // Maximum Y coordinate (for filtering)
+}
+
+@group(0) @binding(0) var<storage, read> triangles: array<f32>;           // Input: original triangles (flat array)
+@group(0) @binding(1) var<storage, read_write> rotated: array<f32>;       // Output: rotated triangles + bounds
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+
+// Rotate a point around X-axis
+fn rotate_around_x(p: vec3<f32>, angle: f32) -> vec3<f32> {
+    let cos_a = cos(angle);
+    let sin_a = sin(angle);
+
+    return vec3<f32>(
+        p.x,
+        p.y * cos_a - p.z * sin_a,
+        p.y * sin_a + p.z * cos_a
+    );
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let tri_idx = global_id.x;
+
+    if (tri_idx >= uniforms.num_triangles) {
+        return;
+    }
+
+    // Read original triangle vertices
+    let base = tri_idx * 9u;
+    let v0 = vec3<f32>(triangles[base], triangles[base + 1u], triangles[base + 2u]);
+    let v1 = vec3<f32>(triangles[base + 3u], triangles[base + 4u], triangles[base + 5u]);
+    let v2 = vec3<f32>(triangles[base + 6u], triangles[base + 7u], triangles[base + 8u]);
+
+    // Rotate vertices around X-axis
+    let v0_rot = rotate_around_x(v0, uniforms.angle);
+    let v1_rot = rotate_around_x(v1, uniforms.angle);
+    let v2_rot = rotate_around_x(v2, uniforms.angle);
+
+    // Compute Y bounds for fast filtering during rasterization
+    let y_min = min(v0_rot.y, min(v1_rot.y, v2_rot.y));
+    let y_max = max(v0_rot.y, max(v1_rot.y, v2_rot.y));
+
+    // Write rotated triangle + bounds
+    // Layout: 11 floats per triangle: v0(3), v1(3), v2(3), y_min(1), y_max(1)
+    let out_base = tri_idx * 11u;
+    rotated[out_base] = v0_rot.x;
+    rotated[out_base + 1u] = v0_rot.y;
+    rotated[out_base + 2u] = v0_rot.z;
+    rotated[out_base + 3u] = v1_rot.x;
+    rotated[out_base + 4u] = v1_rot.y;
+    rotated[out_base + 5u] = v1_rot.z;
+    rotated[out_base + 6u] = v2_rot.x;
+    rotated[out_base + 7u] = v2_rot.y;
+    rotated[out_base + 8u] = v2_rot.z;
+    rotated[out_base + 9u] = y_min;
+    rotated[out_base + 10u] = y_max;
+}
+`;
+var radialV3BatchedRasterizeShaderCode = `// Radial V3 batched bucket rasterization
+// Processes ALL buckets in one dispatch - GPU threads find their bucket
+
+const EPSILON: f32 = 0.0001;
+
+struct Uniforms {
+    resolution: f32,         // Grid step size (mm)
+    tool_radius: f32,        // Tool radius for Y-filtering
+    full_grid_width: u32,    // Full grid width (all buckets)
+    grid_height: u32,        // Number of Y cells
+    global_min_x: f32,       // Global minimum X coordinate
+    bucket_min_y: f32,       // Y-axis start (typically -tool_width/2)
+    z_floor: f32,            // Z value for empty cells
+    num_buckets: u32,        // Number of buckets
+}
+
+struct BucketInfo {
+    min_x: f32,              // Bucket X range start
+    max_x: f32,              // Bucket X range end
+    start_index: u32,        // Index into triangle_indices array
+    count: u32,              // Number of triangles in this bucket
+}
+
+@group(0) @binding(0) var<storage, read> rotated_triangles: array<f32>;   // ALL rotated triangles + bounds
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;        // Full-width output grid
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+@group(0) @binding(3) var<storage, read> all_buckets: array<BucketInfo>;  // All bucket descriptors
+@group(0) @binding(4) var<storage, read> triangle_indices: array<u32>;    // All triangle indices
+
+// Simplified ray-triangle intersection for downward rays
+fn ray_triangle_intersect_downward(
+    ray_origin: vec3<f32>,
+    v0: vec3<f32>,
+    v1: vec3<f32>,
+    v2: vec3<f32>
+) -> vec2<f32> {  // Returns (hit: 0.0 or 1.0, t: distance along ray)
+    let ray_dir = vec3<f32>(0.0, 0.0, -1.0);
+
+    let edge1 = v1 - v0;
+    let edge2 = v2 - v0;
+    let h = cross(ray_dir, edge2);
+    let a = dot(edge1, h);
+
+    if (a > -EPSILON && a < EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let f = 1.0 / a;
+    let s = ray_origin - v0;
+    let u = f * dot(s, h);
+
+    if (u < -EPSILON || u > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let q = cross(s, edge1);
+    let v = f * dot(ray_dir, q);
+
+    if (v < -EPSILON || u + v > 1.0 + EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let t = f * dot(edge2, q);
+
+    if (t > EPSILON) {
+        return vec2<f32>(1.0, t);
+    }
+
+    return vec2<f32>(0.0, 0.0);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let grid_x = global_id.x;
+    let grid_y = global_id.y;
+
+    // Bounds check
+    if (grid_x >= uniforms.full_grid_width || grid_y >= uniforms.grid_height) {
+        return;
+    }
+
+    // Calculate world position
+    let world_x = uniforms.global_min_x + f32(grid_x) * uniforms.resolution;
+    let world_y = uniforms.bucket_min_y + f32(grid_y) * uniforms.resolution;
+
+    // FIND WHICH BUCKET THIS X POSITION BELONGS TO
+    // Simple linear search (could be binary search for many buckets)
+    var bucket_idx = 0u;
+    var found_bucket = false;
+    for (var i = 0u; i < uniforms.num_buckets; i++) {
+        if (world_x >= all_buckets[i].min_x && world_x < all_buckets[i].max_x) {
+            bucket_idx = i;
+            found_bucket = true;
+            break;
+        }
+    }
+
+    // If not in any bucket, write floor and return
+    if (!found_bucket) {
+        let output_idx = grid_y * uniforms.full_grid_width + grid_x;
+        output[output_idx] = uniforms.z_floor;
+        return;
+    }
+
+    let bucket = all_buckets[bucket_idx];
+
+    // Fixed downward ray from high above
+    let ray_origin = vec3<f32>(world_x, world_y, 1000.0);
+
+    // Track best (closest) hit
+    var best_z = uniforms.z_floor;
+
+    // Test triangles in this bucket with Y-bounds filtering
+    for (var i = 0u; i < bucket.count; i++) {
+        // Get triangle index from bucket's index array
+        let tri_idx = triangle_indices[bucket.start_index + i];
+
+        // Read Y-bounds first (cheaper than reading all vertices)
+        let base = tri_idx * 11u;
+        let y_min = rotated_triangles[base + 9u];
+        let y_max = rotated_triangles[base + 10u];
+
+        // Y-bounds check: skip triangles that don't overlap this ray's Y position
+        if (y_max < world_y - uniforms.tool_radius ||
+            y_min > world_y + uniforms.tool_radius) {
+            continue;
+        }
+
+        // Read rotated vertices
+        let v0 = vec3<f32>(
+            rotated_triangles[base],
+            rotated_triangles[base + 1u],
+            rotated_triangles[base + 2u]
+        );
+        let v1 = vec3<f32>(
+            rotated_triangles[base + 3u],
+            rotated_triangles[base + 4u],
+            rotated_triangles[base + 5u]
+        );
+        let v2 = vec3<f32>(
+            rotated_triangles[base + 6u],
+            rotated_triangles[base + 7u],
+            rotated_triangles[base + 8u]
+        );
+
+        let result = ray_triangle_intersect_downward(ray_origin, v0, v1, v2);
+        let hit = result.x;
+        let t = result.y;
+
+        if (hit > 0.5) {
+            // Calculate Z position of intersection
+            let hit_z = ray_origin.z - t;
+
+            // Keep highest (max Z) hit
+            if (hit_z > best_z) {
+                best_z = hit_z;
+            }
+        }
+    }
+
+    // Write to FULL-WIDTH output (no stitching needed!)
+    let output_idx = grid_y * uniforms.full_grid_width + grid_x;
+    output[output_idx] = best_z;
+}
+`;
 async function initWebGPU() {
   if (isInitialized)
     return true;
@@ -682,6 +922,16 @@ async function initWebGPU() {
       layout: "auto",
       compute: { module: cachedTracingShaderModule, entryPoint: "main" }
     });
+    cachedRadialV3RotateShaderModule = device.createShaderModule({ code: radialV3RotateShaderCode });
+    cachedRadialV3RotatePipeline = device.createComputePipeline({
+      layout: "auto",
+      compute: { module: cachedRadialV3RotateShaderModule, entryPoint: "main" }
+    });
+    cachedRadialV3BatchedRasterizeShaderModule = device.createShaderModule({ code: radialV3BatchedRasterizeShaderCode });
+    cachedRadialV3BatchedRasterizePipeline = device.createComputePipeline({
+      layout: "auto",
+      compute: { module: cachedRadialV3BatchedRasterizeShaderModule, entryPoint: "main" }
+    });
     deviceCapabilities = {
       maxStorageBufferBindingSize: device.limits.maxStorageBufferBindingSize,
       maxBufferSize: device.limits.maxBufferSize,
@@ -2137,7 +2387,7 @@ async function generateRadialToolpaths({
       if (!strip.positions || strip.positions.length === 0)
         continue;
       if (diagnostic && (globalStripIdx === 0 || globalStripIdx === 360)) {
-        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(",")}`);
+        debug.log(`JRZ5FG9R | 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,
@@ -2150,7 +2400,7 @@ async function generateRadialToolpaths({
         pipelineStartTime
       );
       if (diagnostic && (globalStripIdx === 0 || globalStripIdx === 360)) {
-        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(",")}`);
+        debug.log(`JRZ5FG9R | 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,
@@ -2200,6 +2450,279 @@ async function generateRadialToolpaths({
   };
 }
 
+// src/core/path-radial-v3.js
+async function rotateTriangles({
+  triangleBuffer,
+  // GPU buffer with original triangles
+  numTriangles,
+  angle
+  // Radians
+}) {
+  const rotatePipeline = cachedRadialV3RotatePipeline;
+  if (!rotatePipeline) {
+    throw new Error("Radial V3 pipelines not initialized");
+  }
+  const outputSize = numTriangles * 11 * 4;
+  const rotatedBuffer = device.createBuffer({
+    size: outputSize,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+  });
+  const uniformBuffer = device.createBuffer({
+    size: 8,
+    // f32 angle + u32 num_triangles
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    mappedAtCreation: true
+  });
+  const uniformView = new ArrayBuffer(8);
+  const floatView = new Float32Array(uniformView);
+  const uintView = new Uint32Array(uniformView);
+  floatView[0] = angle;
+  uintView[1] = numTriangles;
+  new Uint8Array(uniformBuffer.getMappedRange()).set(new Uint8Array(uniformView));
+  uniformBuffer.unmap();
+  const bindGroup = device.createBindGroup({
+    layout: rotatePipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: triangleBuffer } },
+      { binding: 1, resource: { buffer: rotatedBuffer } },
+      { binding: 2, resource: { buffer: uniformBuffer } }
+    ]
+  });
+  const commandEncoder = device.createCommandEncoder();
+  const passEncoder = commandEncoder.beginComputePass();
+  passEncoder.setPipeline(rotatePipeline);
+  passEncoder.setBindGroup(0, bindGroup);
+  passEncoder.dispatchWorkgroups(Math.ceil(numTriangles / 64));
+  passEncoder.end();
+  device.queue.submit([commandEncoder.finish()]);
+  uniformBuffer.destroy();
+  return rotatedBuffer;
+}
+async function rasterizeAllBuckets({
+  rotatedTrianglesBuffer,
+  buckets,
+  triangleIndices,
+  resolution,
+  toolRadius,
+  fullGridWidth,
+  gridHeight,
+  globalMinX,
+  bucketMinY,
+  zFloor
+}) {
+  const rasterizePipeline = cachedRadialV3BatchedRasterizePipeline;
+  if (!rasterizePipeline) {
+    throw new Error("Radial V3 batched pipeline not initialized");
+  }
+  const bucketInfoSize = buckets.length * 16;
+  const bucketInfoBuffer = device.createBuffer({
+    size: bucketInfoSize,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    mappedAtCreation: true
+  });
+  const bucketView = new ArrayBuffer(bucketInfoSize);
+  const bucketFloatView = new Float32Array(bucketView);
+  const bucketUintView = new Uint32Array(bucketView);
+  for (let i = 0; i < buckets.length; i++) {
+    const bucket = buckets[i];
+    const offset = i * 4;
+    bucketFloatView[offset] = bucket.minX;
+    bucketFloatView[offset + 1] = bucket.maxX;
+    bucketUintView[offset + 2] = bucket.startIndex;
+    bucketUintView[offset + 3] = bucket.count;
+  }
+  new Uint8Array(bucketInfoBuffer.getMappedRange()).set(new Uint8Array(bucketView));
+  bucketInfoBuffer.unmap();
+  const indicesBuffer = device.createBuffer({
+    size: triangleIndices.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    mappedAtCreation: true
+  });
+  new Uint32Array(indicesBuffer.getMappedRange()).set(triangleIndices);
+  indicesBuffer.unmap();
+  const outputSize = fullGridWidth * gridHeight * 4;
+  const outputBuffer = device.createBuffer({
+    size: outputSize,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+  });
+  const initData = new Float32Array(fullGridWidth * gridHeight);
+  initData.fill(zFloor);
+  device.queue.writeBuffer(outputBuffer, 0, initData);
+  const uniformBuffer = device.createBuffer({
+    size: 32,
+    // 8 fields × 4 bytes
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    mappedAtCreation: true
+  });
+  const uniformView = new ArrayBuffer(32);
+  const floatView = new Float32Array(uniformView);
+  const uintView = new Uint32Array(uniformView);
+  floatView[0] = resolution;
+  floatView[1] = toolRadius;
+  uintView[2] = fullGridWidth;
+  uintView[3] = gridHeight;
+  floatView[4] = globalMinX;
+  floatView[5] = bucketMinY;
+  floatView[6] = zFloor;
+  uintView[7] = buckets.length;
+  new Uint8Array(uniformBuffer.getMappedRange()).set(new Uint8Array(uniformView));
+  uniformBuffer.unmap();
+  const bindGroup = device.createBindGroup({
+    layout: rasterizePipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: rotatedTrianglesBuffer } },
+      { binding: 1, resource: { buffer: outputBuffer } },
+      { binding: 2, resource: { buffer: uniformBuffer } },
+      { binding: 3, resource: { buffer: bucketInfoBuffer } },
+      { binding: 4, resource: { buffer: indicesBuffer } }
+    ]
+  });
+  const commandEncoder = device.createCommandEncoder();
+  const passEncoder = commandEncoder.beginComputePass();
+  passEncoder.setPipeline(rasterizePipeline);
+  passEncoder.setBindGroup(0, bindGroup);
+  const dispatchX = Math.ceil(fullGridWidth / 8);
+  const dispatchY = Math.ceil(gridHeight / 8);
+  passEncoder.dispatchWorkgroups(dispatchX, dispatchY);
+  passEncoder.end();
+  const stagingBuffer = device.createBuffer({
+    size: outputSize,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
+  commandEncoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, outputSize);
+  device.queue.submit([commandEncoder.finish()]);
+  await device.queue.onSubmittedWorkDone();
+  await stagingBuffer.mapAsync(GPUMapMode.READ);
+  const terrainData = new Float32Array(stagingBuffer.getMappedRange().slice());
+  stagingBuffer.unmap();
+  outputBuffer.destroy();
+  stagingBuffer.destroy();
+  uniformBuffer.destroy();
+  bucketInfoBuffer.destroy();
+  indicesBuffer.destroy();
+  return terrainData;
+}
+async function generateRadialToolpathsV3({
+  triangles,
+  bucketData,
+  toolData,
+  resolution,
+  angleStep,
+  numAngles,
+  maxRadius,
+  toolWidth,
+  zFloor,
+  bounds,
+  xStep,
+  yStep
+}) {
+  debug.log("radial-v3-generate-toolpaths", { triangles: triangles.length / 9, numAngles, resolution });
+  const pipelineStartTime = performance.now();
+  const allStripToolpaths = [];
+  let totalToolpathPoints = 0;
+  const sparseToolData = createSparseToolFromPoints(toolData.positions);
+  debug.log(`Created sparse tool: ${sparseToolData.count} points (reusing for all strips)`);
+  const toolRadius = toolWidth / 2;
+  const bucketMinX = bucketData.buckets[0].minX;
+  const bucketMaxX = bucketData.buckets[bucketData.numBuckets - 1].maxX;
+  const fullWidth = bucketMaxX - bucketMinX;
+  const fullGridWidth = Math.ceil(fullWidth / resolution);
+  const gridHeight = Math.ceil(toolWidth / resolution);
+  debug.log(`Uploading ${triangles.length / 9} triangles to GPU (reused across all angles)...`);
+  const allTrianglesBuffer = device.createBuffer({
+    size: triangles.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    mappedAtCreation: true
+  });
+  new Float32Array(allTrianglesBuffer.getMappedRange()).set(triangles);
+  allTrianglesBuffer.unmap();
+  for (let angleIdx = 0; angleIdx < numAngles; angleIdx++) {
+    const angle = -(angleIdx * angleStep * (Math.PI / 180));
+    const angleDegrees = angleIdx * angleStep;
+    if (diagnostic) {
+      debug.log(`Angle ${angleIdx + 1}/${numAngles}: ${angleDegrees.toFixed(1)}\xB0`);
+    }
+    if (angleIdx % 10 === 0 || angleIdx === numAngles - 1) {
+      const stripProgress = (angleIdx + 1) / numAngles * 98;
+      self.postMessage({
+        type: "toolpath-progress",
+        data: {
+          percent: Math.round(stripProgress),
+          current: angleIdx + 1,
+          total: numAngles,
+          layer: angleIdx + 1
+        }
+      });
+    }
+    const numTotalTriangles = triangles.length / 9;
+    const allRotatedTrianglesBuffer = await rotateTriangles({
+      triangleBuffer: allTrianglesBuffer,
+      numTriangles: numTotalTriangles,
+      angle
+    });
+    const fullTerrainStrip = await rasterizeAllBuckets({
+      rotatedTrianglesBuffer: allRotatedTrianglesBuffer,
+      buckets: bucketData.buckets,
+      triangleIndices: bucketData.triangleIndices,
+      resolution,
+      toolRadius,
+      fullGridWidth,
+      gridHeight,
+      globalMinX: bucketMinX,
+      bucketMinY: -toolWidth / 2,
+      zFloor
+    });
+    allRotatedTrianglesBuffer.destroy();
+    const reusableToolpathBuffers = createReusableToolpathBuffers(
+      fullGridWidth,
+      gridHeight,
+      sparseToolData,
+      xStep,
+      gridHeight
+    );
+    const stripToolpathResult = await runToolpathComputeWithBuffers(
+      fullTerrainStrip,
+      fullGridWidth,
+      gridHeight,
+      xStep,
+      gridHeight,
+      zFloor,
+      reusableToolpathBuffers,
+      pipelineStartTime
+    );
+    destroyReusableToolpathBuffers(reusableToolpathBuffers);
+    allStripToolpaths.push({
+      angle: angleDegrees,
+      pathData: stripToolpathResult.pathData,
+      numScanlines: stripToolpathResult.numScanlines,
+      pointsPerLine: stripToolpathResult.pointsPerLine,
+      terrainBounds: {
+        min: { x: bucketMinX, y: -toolWidth / 2, z: zFloor },
+        max: { x: bucketMaxX, y: toolWidth / 2, z: bounds.max.z }
+      }
+    });
+    totalToolpathPoints += stripToolpathResult.pathData.length;
+  }
+  allTrianglesBuffer.destroy();
+  debug.log(`Destroyed reusable triangle buffer`);
+  const pipelineTotalTime = performance.now() - pipelineStartTime;
+  debug.log(`Complete radial V3 toolpath: ${allStripToolpaths.length} strips, ${totalToolpathPoints} total points in ${pipelineTotalTime.toFixed(0)}ms`);
+  self.postMessage({
+    type: "toolpath-progress",
+    data: {
+      percent: 100,
+      current: bucketData.numBuckets * numAngles,
+      total: bucketData.numBuckets * numAngles,
+      layer: numAngles
+    }
+  });
+  return {
+    strips: allStripToolpaths,
+    totalPoints: totalToolpathPoints,
+    numStrips: allStripToolpaths.length
+  };
+}
+
 // src/core/path-tracing.js
 var cachedTracingBuffers = null;
 function createReusableTracingBuffers(terrainPositions, toolPositions) {
@@ -2803,6 +3326,14 @@ self.onmessage = async function(e) {
           data: radialToolpathResult
         }, toolpathTransferBuffers);
         break;
+      case "radial-generate-toolpaths-v3":
+        const radialV3ToolpathResult = await generateRadialToolpathsV3(data);
+        const v3ToolpathTransferBuffers = radialV3ToolpathResult.strips.map((strip) => strip.pathData.buffer);
+        self.postMessage({
+          type: "radial-toolpaths-complete",
+          data: radialV3ToolpathResult
+        }, v3ToolpathTransferBuffers);
+        break;
       case "tracing-generate-toolpaths":
         const tracingResult = await generateTracingToolpaths({
           paths: data.paths,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gridspace/raster-path",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "private": false,
   "description": "Terrain and Tool Raster Path Finder using WebGPU",
   "type": "module",
@@ -32,7 +32,7 @@
     "build:web": "mkdir -p build && cp src/web/*.html src/web/*.css src/web/*.js build/ && cp src/core/raster-path.js build/raster-path.js && cp src/etc/serve.json build/",
     "clean": "rm -rf build/",
     "dev": "npm run build && npm run serve",
-    "serve": "npx serve build --config serve.json --listen 9090",
+    "serve": "npm run build && npx serve build --config serve.json --listen 9090",
     "publish:public": "npm publish --access public",
     "test": "npm run test:planar && npm run test:radial",
     "test:planar": "npm run build && npx electron src/test/planar-test.cjs",
@@ -45,6 +45,7 @@
     "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-v3": "npm run build && npx electron src/test/radial-v3-benchmark.cjs",
     "test:tracing": "npm run build && npx electron src/test/tracing-test.cjs"
   },
   "keywords": [