@gridspace/raster-path 1.0.7 → 1.0.9

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(`QRSDOFON | 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(`QRSDOFON | 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) {
@@ -2339,59 +2862,109 @@ async function generateTracingToolpaths({
     usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
   });
   device.queue.writeBuffer(maxZBuffer, 0, maxZInitData);
-  const outputPaths = [];
+  debug.log("PHASE 1: Sampling all paths...");
+  const pathIndex = [];
+  const sampledSegments = [];
   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`);
+    debug.log(`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 numPoints = sampledPath.length / 2;
+    pathIndex.push({
+      startOffset: totalSampledPoints,
+      endOffset: totalSampledPoints + numPoints,
+      numPoints
+    });
+    sampledSegments.push(sampledPath);
+    totalSampledPoints += numPoints;
+    debug.log(`  Sampled to ${numPoints} points`);
+  }
+  const unifiedSampledXY = new Float32Array(totalSampledPoints * 2);
+  let writeOffset = 0;
+  for (let pathIdx = 0; pathIdx < sampledSegments.length; pathIdx++) {
+    const sampledPath = sampledSegments[pathIdx];
+    unifiedSampledXY.set(sampledPath, writeOffset * 2);
+    writeOffset += sampledPath.length / 2;
+  }
+  debug.log(`Unified buffer: ${totalSampledPoints} total points from ${paths.length} paths`);
+  if (totalSampledPoints > 0) {
+    const firstX = unifiedSampledXY[0];
+    const firstY = unifiedSampledXY[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) {
+    debug.log(`First point: world(${firstX.toFixed(2)}, ${firstY.toFixed(2)}) -> grid(${gridX.toFixed(2)}, ${gridY.toFixed(2)})`);
+  }
+  debug.log("PHASE 2: Calculating memory budget and chunking...");
+  const bytesPerPoint = 8 + 4;
+  const configuredLimit = config.maxGPUMemoryMB * 1024 * 1024;
+  const deviceLimit = deviceCapabilities.maxStorageBufferBindingSize;
+  const maxSafeSize = Math.min(configuredLimit, deviceLimit) * config.gpuMemorySafetyMargin;
+  const fixedOverhead = terrainPositions.byteLength + sparseToolData.count * 16 + paths.length * 4 + 48;
+  if (fixedOverhead > maxSafeSize) {
+    if (shouldCleanupBuffers) {
       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
+    throw new Error(
+      `Fixed buffers (terrain + tool) exceed GPU memory: ${(fixedOverhead / 1024 / 1024).toFixed(1)}MB > ${(maxSafeSize / 1024 / 1024).toFixed(1)}MB. Try reducing terrain resolution or tool density.`
+    );
+  }
+  const availableForPaths = maxSafeSize - fixedOverhead;
+  const maxPointsPerChunk = Math.floor(availableForPaths / bytesPerPoint);
+  debug.log(`Memory budget: ${(maxSafeSize / 1024 / 1024).toFixed(1)}MB safe, ${(availableForPaths / 1024 / 1024).toFixed(1)}MB available for paths`);
+  debug.log(`Max points per chunk: ${maxPointsPerChunk.toLocaleString()}`);
+  const chunks = [];
+  let currentStart = 0;
+  while (currentStart < totalSampledPoints) {
+    const currentEnd = Math.min(currentStart + maxPointsPerChunk, totalSampledPoints);
+    chunks.push({
+      startPoint: currentStart,
+      endPoint: currentEnd,
+      numPoints: currentEnd - currentStart
     });
+    currentStart = currentEnd;
+  }
+  debug.log(`Created ${chunks.length} chunk(s) for processing`);
+  debug.log("PHASE 3: Creating reusable GPU buffers...");
+  const inputBuffer = device.createBuffer({
+    size: maxPointsPerChunk * 8,
+    // 2 floats per point
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  const outputBuffer = device.createBuffer({
+    size: maxPointsPerChunk * 4,
+    // 1 float per point
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+  });
+  const uniformBuffer = device.createBuffer({
+    size: 48,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const stagingBuffer = device.createBuffer({
+    size: maxPointsPerChunk * 4,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
+  const unifiedOutputZ = new Float32Array(totalSampledPoints);
+  debug.log(`Buffers created for ${maxPointsPerChunk.toLocaleString()} points per chunk`);
+  debug.log("PHASE 4: Processing chunks...");
+  for (let chunkIdx = 0; chunkIdx < chunks.length; chunkIdx++) {
+    const chunk = chunks[chunkIdx];
+    const { startPoint, endPoint, numPoints } = chunk;
+    debug.log(`Processing chunk ${chunkIdx + 1}/${chunks.length}: points ${startPoint}-${endPoint} (${numPoints} points)`);
+    const chunkInputXY = unifiedSampledXY.subarray(startPoint * 2, endPoint * 2);
+    device.queue.writeBuffer(inputBuffer, 0, chunkInputXY);
     const uniformData = new Uint32Array(12);
     uniformData[0] = terrainData.width;
     uniformData[1] = terrainData.height;
     uniformData[2] = sparseToolData.count;
-    uniformData[3] = numSampledPoints;
-    uniformData[4] = pathIdx;
+    uniformData[3] = numPoints;
+    uniformData[4] = 0;
     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({
@@ -2402,6 +2975,7 @@ async function generateTracingToolpaths({
         { binding: 2, resource: { buffer: inputBuffer } },
         { binding: 3, resource: { buffer: outputBuffer } },
         { binding: 4, resource: { buffer: maxZBuffer } },
+        // Keep for shader compatibility
         { binding: 5, resource: { buffer: uniformBuffer } }
       ]
     });
@@ -2409,60 +2983,60 @@ async function generateTracingToolpaths({
     const passEncoder = commandEncoder.beginComputePass();
     passEncoder.setPipeline(cachedTracingPipeline);
     passEncoder.setBindGroup(0, bindGroup);
-    const workgroupsX = Math.ceil(numSampledPoints / 64);
+    const workgroupsX = Math.ceil(numPoints / 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);
+    commandEncoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, numPoints * 4);
     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);
+    const chunkOutputZ = new Float32Array(stagingBuffer.getMappedRange(), 0, numPoints);
+    unifiedOutputZ.set(chunkOutputZ, startPoint);
     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`);
+    debug.log(`  Chunk ${chunkIdx + 1} complete: ${numPoints} points processed`);
     if (onProgress) {
       onProgress({
         type: "tracing-progress",
         data: {
-          percent: Math.round((pathIdx + 1) / paths.length * 100),
-          current: pathIdx + 1,
-          total: paths.length,
-          pathIndex: pathIdx
+          percent: Math.round(endPoint / totalSampledPoints * 100),
+          current: endPoint,
+          total: totalSampledPoints,
+          chunkIndex: chunkIdx + 1,
+          totalChunks: chunks.length
         }
       });
     }
   }
-  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);
+  inputBuffer.destroy();
+  outputBuffer.destroy();
+  uniformBuffer.destroy();
+  stagingBuffer.destroy();
+  debug.log("All chunks processed");
+  debug.log("PHASE 5: Remapping to individual paths and computing maxZ...");
+  const outputPaths = [];
+  const maxZValues = new Array(paths.length).fill(zFloor);
+  for (let pathIdx = 0; pathIdx < pathIndex.length; pathIdx++) {
+    const { startOffset, numPoints } = pathIndex[pathIdx];
+    if (numPoints === 0) {
+      outputPaths.push(new Float32Array(0));
+      debug.log(`Path ${pathIdx + 1}: empty`);
+      continue;
+    }
+    const pathXYZ = new Float32Array(numPoints * 3);
+    for (let i = 0; i < numPoints; i++) {
+      const unifiedIdx = startOffset + i;
+      const x = unifiedSampledXY[unifiedIdx * 2 + 0];
+      const y = unifiedSampledXY[unifiedIdx * 2 + 1];
+      const z = unifiedOutputZ[unifiedIdx];
+      pathXYZ[i * 3 + 0] = x;
+      pathXYZ[i * 3 + 1] = y;
+      pathXYZ[i * 3 + 2] = z;
+      maxZValues[pathIdx] = Math.max(maxZValues[pathIdx], z);
+    }
+    outputPaths.push(pathXYZ);
+    debug.log(`Path ${pathIdx + 1}: ${numPoints} points, maxZ=${maxZValues[pathIdx].toFixed(2)}`);
+  }
   maxZBuffer.destroy();
-  maxZStagingBuffer.destroy();
   if (shouldCleanupBuffers) {
     terrainBuffer.destroy();
     toolBuffer.destroy();
@@ -2803,6 +3377,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,