@gridspace/raster-path 1.0.6 → 1.0.8

package/build/raster-worker.js

@@ -9,6 +9,12 @@ var cachedToolpathPipeline = null;
 var cachedToolpathShaderModule = null;
 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;
@@ -535,6 +541,338 @@ 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);
+}
+`;
+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;
@@ -549,10 +887,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 +917,21 @@ 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" }
+    });
+    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,
@@ -2037,7 +2387,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(`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,
@@ -2050,7 +2400,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(`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,
@@ -2069,7 +2419,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 +2450,557 @@ 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) {
+  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 +3326,51 @@ 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,
+          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({