@gridspace/raster-path 1.0.2

package/src/web/webgpu-worker.js

@@ -0,0 +1,2520 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * WebGPU Worker - GPU Compute Operations
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * Offloads all WebGPU compute operations to a worker thread to prevent UI blocking.
+ * Handles both planar (XY grid) and radial (cylindrical) rasterization modes.
+ *
+ * MESSAGE PROTOCOL:
+ * ─────────────────
+ * Main Thread → Worker:
+ *   'init'                     - Initialize WebGPU device
+ *   'rasterize-planar'         - Rasterize geometry to XY grid
+ *   'generate-toolpath-planar' - Generate planar toolpath from rasters
+ *   'radial-generate-toolpaths'- Generate radial toolpaths (does rasterization + toolpath)
+ *
+ * Worker → Main Thread:
+ *   'webgpu-ready'            - Initialization complete
+ *   'rasterize-complete'      - Planar rasterization complete
+ *   'rasterize-progress'      - Progress update (0-1)
+ *   'toolpath-complete'       - Planar toolpath complete
+ *   'toolpath-progress'       - Progress update (0-1)
+ *   'radial-toolpaths-complete' - Radial toolpaths complete
+ *
+ * ARCHITECTURE:
+ * ─────────────
+ * 1. PLANAR MODE:
+ *    - Rasterize terrain: XY grid, keep max Z per cell
+ *    - Rasterize tool: XY grid, keep min Z per cell
+ *    - Generate toolpath: Scan tool over terrain, compute Z-heights
+ *
+ * 2. RADIAL MODE:
+ *    - Batched processing: 360 angles per batch
+ *    - X-bucketing: Spatial partitioning to reduce triangle tests
+ *    - For each angle:
+ *        * Cast ray from origin
+ *        * Rasterize terrain triangles along ray
+ *        * Calculate tool-terrain collision
+ *        * Output Z-heights along X-axis
+ *
+ * MEMORY MANAGEMENT:
+ * ──────────────────
+ * - All GPU buffers are preallocated to known maximum sizes
+ * - Triangle data transferred once per operation
+ * - Output buffers mapped asynchronously to avoid blocking
+ * - Worker maintains pipeline cache to avoid recompilation
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+let device = null;
+let isInitialized = false;
+let cachedRasterizePipeline = null;
+let cachedRasterizeShaderModule = null;
+let cachedToolpathPipeline = null;
+let cachedToolpathShaderModule = null;
+let config = null;
+let deviceCapabilities = null;
+
+const EMPTY_CELL = -1e10;
+const log_pre = '[Raster Worker]';
+
+// url params to control logging
+let { search } = self.location;
+let verbose = search.indexOf('debug') >= 0;
+let quiet = search.indexOf('quiet') >= 0;
+
+const debug = {
+    error: function() { console.error(log_pre, ...arguments) },
+    warn: function() { console.warn(log_pre, ...arguments) },
+    log: function() { !quiet && console.log(log_pre, ...arguments) },
+    ok: function() { console.log(log_pre, '✅', ...arguments) },
+};
+
+function round(v, d = 1) {
+    return parseFloat(v.toFixed(d));
+}
+
+// Global error handler for uncaught errors in worker
+self.addEventListener('error', (event) => {
+    debug.error('Uncaught error:', event.error || event.message);
+    debug.error('Stack:', event.error?.stack);
+});
+
+self.addEventListener('unhandledrejection', (event) => {
+    debug.error('Unhandled promise rejection:', event.reason);
+});
+
+// Initialize WebGPU device in worker context
+async function initWebGPU() {
+    if (isInitialized) return true;
+
+    if (!navigator.gpu) {
+        debug.warn('WebGPU not supported');
+        return false;
+    }
+
+    try {
+        const adapter = await navigator.gpu.requestAdapter();
+        if (!adapter) {
+            debug.warn('WebGPU adapter not available');
+            return false;
+        }
+
+        // Request device with higher limits for large meshes
+        const adapterLimits = adapter.limits;
+        debug.log('Adapter limits:', {
+            maxStorageBufferBindingSize: adapterLimits.maxStorageBufferBindingSize,
+            maxBufferSize: adapterLimits.maxBufferSize
+        });
+
+        device = await adapter.requestDevice({
+            requiredLimits: {
+                maxStorageBufferBindingSize: Math.min(
+                    adapterLimits.maxStorageBufferBindingSize,
+                    1024 * 1024 * 1024 // Request up to 1GB
+                ),
+                maxBufferSize: Math.min(
+                    adapterLimits.maxBufferSize,
+                    1024 * 1024 * 1024 // Request up to 1GB
+                )
+            }
+        });
+
+        // Pre-compile rasterize shader module (expensive operation)
+        cachedRasterizeShaderModule = device.createShaderModule({ code: rasterizeShaderCode });
+
+        // Pre-create rasterize pipeline (very expensive operation)
+        cachedRasterizePipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: cachedRasterizeShaderModule, entryPoint: 'main' },
+        });
+
+        // Pre-compile toolpath shader module
+        cachedToolpathShaderModule = device.createShaderModule({ code: toolpathShaderCode });
+
+        // Pre-create toolpath pipeline
+        cachedToolpathPipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: cachedToolpathShaderModule, entryPoint: 'main' },
+        });
+
+        // Store device capabilities
+        deviceCapabilities = {
+            maxStorageBufferBindingSize: device.limits.maxStorageBufferBindingSize,
+            maxBufferSize: device.limits.maxBufferSize,
+            maxComputeWorkgroupSizeX: device.limits.maxComputeWorkgroupSizeX,
+            maxComputeWorkgroupSizeY: device.limits.maxComputeWorkgroupSizeY,
+        };
+
+        isInitialized = true;
+        debug.log('Initialized (pipelines cached)');
+        return true;
+    } catch (error) {
+        debug.error('Failed to initialize:', error);
+        return false;
+    }
+}
+
+// Planar rasterization with spatial partitioning
+const rasterizeShaderCode = /*SHADER:planar-rasterize*/;
+
+// Planar toolpath generation
+const toolpathShaderCode = /*SHADER:planar-toolpath*/;
+
+// Radial V2: Rasterization with rotating ray planes and X-bucketing
+const radialRasterizeV2ShaderCode = /*SHADER:radial-raster-v2*/;
+
+// Calculate bounding box from triangle vertices
+function calculateBounds(triangles) {
+    let min_x = Infinity, min_y = Infinity, min_z = Infinity;
+    let max_x = -Infinity, max_y = -Infinity, max_z = -Infinity;
+
+    for (let i = 0; i < triangles.length; i += 3) {
+        const x = triangles[i];
+        const y = triangles[i + 1];
+        const z = triangles[i + 2];
+
+        if (x < min_x) min_x = x;
+        if (y < min_y) min_y = y;
+        if (z < min_z) min_z = z;
+        if (x > max_x) max_x = x;
+        if (y > max_y) max_y = y;
+        if (z > max_z) max_z = z;
+    }
+
+    return {
+        min: { x: min_x, y: min_y, z: min_z },
+        max: { x: max_x, y: max_y, z: max_z }
+    };
+}
+
+// Build spatial grid for efficient triangle culling
+function buildSpatialGrid(triangles, bounds, cellSize = 5.0) {
+    const gridWidth = Math.max(1, Math.ceil((bounds.max.x - bounds.min.x) / cellSize));
+    const gridHeight = Math.max(1, Math.ceil((bounds.max.y - bounds.min.y) / cellSize));
+    const totalCells = gridWidth * gridHeight;
+
+    // debug.log(`Building spatial grid ${gridWidth}x${gridHeight} (${cellSize}mm cells)`);
+
+    const grid = new Array(totalCells);
+    for (let i = 0; i < totalCells; i++) {
+        grid[i] = [];
+    }
+
+    const triangleCount = triangles.length / 9;
+    for (let t = 0; t < triangleCount; t++) {
+        const base = t * 9;
+
+        const v0x = triangles[base], v0y = triangles[base + 1];
+        const v1x = triangles[base + 3], v1y = triangles[base + 4];
+        const v2x = triangles[base + 6], v2y = triangles[base + 7];
+
+        // Add small epsilon to catch triangles near cell boundaries
+        const epsilon = cellSize * 0.01;  // 1% of cell size
+        const minX = Math.min(v0x, v1x, v2x) - epsilon;
+        const maxX = Math.max(v0x, v1x, v2x) + epsilon;
+        const minY = Math.min(v0y, v1y, v2y) - epsilon;
+        const maxY = Math.max(v0y, v1y, v2y) + epsilon;
+
+        let minCellX = Math.floor((minX - bounds.min.x) / cellSize);
+        let maxCellX = Math.floor((maxX - bounds.min.x) / cellSize);
+        let minCellY = Math.floor((minY - bounds.min.y) / cellSize);
+        let maxCellY = Math.floor((maxY - bounds.min.y) / cellSize);
+
+        minCellX = Math.max(0, Math.min(gridWidth - 1, minCellX));
+        maxCellX = Math.max(0, Math.min(gridWidth - 1, maxCellX));
+        minCellY = Math.max(0, Math.min(gridHeight - 1, minCellY));
+        maxCellY = Math.max(0, Math.min(gridHeight - 1, maxCellY));
+
+        for (let cy = minCellY; cy <= maxCellY; cy++) {
+            for (let cx = minCellX; cx <= maxCellX; cx++) {
+                const cellIdx = cy * gridWidth + cx;
+                grid[cellIdx].push(t);
+            }
+        }
+    }
+
+    let totalTriangleRefs = 0;
+    for (let i = 0; i < totalCells; i++) {
+        totalTriangleRefs += grid[i].length;
+    }
+
+    const cellOffsets = new Uint32Array(totalCells + 1);
+    const triangleIndices = new Uint32Array(totalTriangleRefs);
+
+    let currentOffset = 0;
+    for (let i = 0; i < totalCells; i++) {
+        cellOffsets[i] = currentOffset;
+        for (let j = 0; j < grid[i].length; j++) {
+            triangleIndices[currentOffset++] = grid[i][j];
+        }
+    }
+    cellOffsets[totalCells] = currentOffset;
+
+    const avgPerCell = totalTriangleRefs / totalCells;
+    // debug.log(`Spatial grid: ${totalTriangleRefs} refs (avg ${avgPerCell.toFixed(1)} per cell)`);
+
+    return {
+        gridWidth,
+        gridHeight,
+        cellSize,
+        cellOffsets,
+        triangleIndices,
+        avgTrianglesPerCell: avgPerCell
+    };
+}
+
+// Create reusable GPU buffers for multiple rasterization passes (e.g., radial rotations)
+
+// Rasterize mesh to point cloud
+// Internal function - rasterize without tiling (do not modify this function!)
+async function rasterizeMeshSingle(triangles, stepSize, filterMode, options = {}) {
+    const startTime = performance.now();
+
+    if (!isInitialized) {
+        const initStart = performance.now();
+        const success = await initWebGPU();
+        if (!success) {
+            throw new Error('WebGPU not available');
+        }
+        const initEnd = performance.now();
+        debug.log(`First-time init: ${(initEnd - initStart).toFixed(1)}ms`);
+    }
+
+    // debug.log(`Rasterizing ${triangles.length / 9} triangles (step ${stepSize}mm, mode ${filterMode})...`);
+
+    // Extract options
+    // boundsOverride: Optional manual bounds to avoid recalculating from triangles
+    // Useful when bounds are already known (e.g., from tiling operations)
+    const boundsOverride = options.bounds || options.min ? options : null;
+
+    // Use bounds override if provided, otherwise calculate from triangles
+    const bounds = boundsOverride || calculateBounds(triangles);
+
+    if (boundsOverride) {
+        // debug.log(`Using bounds override: min(${bounds.min.x.toFixed(2)}, ${bounds.min.y.toFixed(2)}, ${bounds.min.z.toFixed(2)}) max(${bounds.max.x.toFixed(2)}, ${bounds.max.y.toFixed(2)}, ${bounds.max.z.toFixed(2)})`);
+
+        // Validate bounds
+        if (bounds.min.x >= bounds.max.x || bounds.min.y >= bounds.max.y || bounds.min.z >= bounds.max.z) {
+            throw new Error(`Invalid bounds: min must be less than max. Got min(${bounds.min.x}, ${bounds.min.y}, ${bounds.min.z}) max(${bounds.max.x}, ${bounds.max.y}, ${bounds.max.z})`);
+        }
+    }
+
+    const gridWidth = Math.ceil((bounds.max.x - bounds.min.x) / stepSize) + 1;
+    const gridHeight = Math.ceil((bounds.max.y - bounds.min.y) / stepSize) + 1;
+    const totalGridPoints = gridWidth * gridHeight;
+
+    // debug.log(`Grid: ${gridWidth}x${gridHeight} = ${totalGridPoints.toLocaleString()} points`);
+
+    // Calculate buffer size based on filter mode
+    // filterMode 0 (terrain): Dense Z-only output (1 float per grid cell)
+    // filterMode 1 (tool): Sparse X,Y,Z output (3 floats per grid cell)
+    const floatsPerPoint = filterMode === 0 ? 1 : 3;
+    const outputSize = totalGridPoints * floatsPerPoint * 4;
+    const maxBufferSize = device.limits.maxBufferSize || 268435456; // 256MB default
+    const modeStr = filterMode === 0 ? 'terrain (dense Z-only)' : 'tool (sparse XYZ)';
+    // debug.log(`Output buffer size: ${(outputSize / 1024 / 1024).toFixed(2)} MB for ${modeStr} (max: ${(maxBufferSize / 1024 / 1024).toFixed(2)} MB)`);
+
+    if (outputSize > maxBufferSize) {
+        throw new Error(`Output buffer too large: ${(outputSize / 1024 / 1024).toFixed(2)} MB exceeds device limit of ${(maxBufferSize / 1024 / 1024).toFixed(2)} MB. Try a larger step size.`);
+    }
+
+    const spatialGrid = buildSpatialGrid(triangles, bounds);
+
+    // Create buffers
+    const triangleBuffer = device.createBuffer({
+        size: triangles.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(triangleBuffer, 0, triangles);
+
+    // Create and INITIALIZE output buffer (GPU buffers contain garbage by default!)
+    const outputBuffer = device.createBuffer({
+        size: outputSize,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+    });
+
+    // Initialize output buffer with sentinel value for terrain, zeros for tool
+    if (filterMode === 0) {
+        // Terrain: initialize with EMPTY_CELL sentinel value
+        const initData = new Float32Array(totalGridPoints);
+        initData.fill(EMPTY_CELL);
+        device.queue.writeBuffer(outputBuffer, 0, initData);
+    }
+    // Tool mode: zeros are fine (will check valid mask)
+
+    const validMaskBuffer = device.createBuffer({
+        size: totalGridPoints * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const spatialCellOffsetsBuffer = device.createBuffer({
+        size: spatialGrid.cellOffsets.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(spatialCellOffsetsBuffer, 0, spatialGrid.cellOffsets);
+
+    const spatialTriangleIndicesBuffer = device.createBuffer({
+        size: spatialGrid.triangleIndices.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(spatialTriangleIndicesBuffer, 0, spatialGrid.triangleIndices);
+
+    // Uniforms
+    const uniformData = new Float32Array([
+        bounds.min.x, bounds.min.y, bounds.min.z,
+        bounds.max.x, bounds.max.y, bounds.max.z,
+        stepSize,
+        0, 0, 0, 0, 0, 0, 0  // Padding for alignment
+    ]);
+    const uniformDataU32 = new Uint32Array(uniformData.buffer);
+    uniformDataU32[7] = gridWidth;
+    uniformDataU32[8] = gridHeight;
+    uniformDataU32[9] = triangles.length / 9;
+    uniformDataU32[10] = filterMode;
+    uniformDataU32[11] = spatialGrid.gridWidth;
+    uniformDataU32[12] = spatialGrid.gridHeight;
+    const uniformDataF32 = new Float32Array(uniformData.buffer);
+    uniformDataF32[13] = spatialGrid.cellSize;
+
+    // Check for u32 overflow
+    const maxU32 = 4294967295;
+    if (gridWidth > maxU32 || gridHeight > maxU32) {
+        throw new Error(`Grid dimensions exceed u32 max: ${gridWidth}x${gridHeight}`);
+    }
+
+    // debug.log(`Uniforms: gridWidth=${gridWidth}, gridHeight=${gridHeight}, triangles=${triangles.length / 9}`);
+
+    const uniformBuffer = device.createBuffer({
+        size: uniformData.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(uniformBuffer, 0, uniformData);
+
+    // CRITICAL: Wait for all writeBuffer operations to complete before compute dispatch
+    await device.queue.onSubmittedWorkDone();
+
+    // Use cached pipeline
+    const bindGroup = device.createBindGroup({
+        layout: cachedRasterizePipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: triangleBuffer } },
+            { binding: 1, resource: { buffer: outputBuffer } },
+            { binding: 2, resource: { buffer: validMaskBuffer } },
+            { binding: 3, resource: { buffer: uniformBuffer } },
+            { binding: 4, resource: { buffer: spatialCellOffsetsBuffer } },
+            { binding: 5, resource: { buffer: spatialTriangleIndicesBuffer } },
+        ],
+    });
+
+    // Dispatch compute shader
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(cachedRasterizePipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+
+    const workgroupsX = Math.ceil(gridWidth / 16);
+    const workgroupsY = Math.ceil(gridHeight / 16);
+
+    // Check dispatch limits
+    const maxWorkgroupsPerDim = device.limits.maxComputeWorkgroupsPerDimension || 65535;
+
+    if (workgroupsX > maxWorkgroupsPerDim || workgroupsY > maxWorkgroupsPerDim) {
+        throw new Error(`Workgroup dispatch too large: ${workgroupsX}x${workgroupsY} exceeds limit of ${maxWorkgroupsPerDim}. Try a larger step size.`);
+    }
+
+    passEncoder.dispatchWorkgroups(workgroupsX, workgroupsY);
+    passEncoder.end();
+
+    // Create staging buffers for readback
+    const stagingOutputBuffer = device.createBuffer({
+        size: outputSize,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+
+    const stagingValidMaskBuffer = device.createBuffer({
+        size: totalGridPoints * 4,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+
+    commandEncoder.copyBufferToBuffer(outputBuffer, 0, stagingOutputBuffer, 0, outputSize);
+    commandEncoder.copyBufferToBuffer(validMaskBuffer, 0, stagingValidMaskBuffer, 0, totalGridPoints * 4);
+
+    device.queue.submit([commandEncoder.finish()]);
+
+    // Wait for GPU to finish
+    await device.queue.onSubmittedWorkDone();
+
+    // Read back results
+    await stagingOutputBuffer.mapAsync(GPUMapMode.READ);
+    await stagingValidMaskBuffer.mapAsync(GPUMapMode.READ);
+
+    const outputData = new Float32Array(stagingOutputBuffer.getMappedRange());
+    const validMaskData = new Uint32Array(stagingValidMaskBuffer.getMappedRange());
+
+    let result, pointCount;
+
+    if (filterMode === 0) {
+        // Terrain: Dense output (Z-only), no compaction needed
+        // Copy the full array (already has NaN for empty cells)
+        result = new Float32Array(outputData);
+        pointCount = totalGridPoints;
+
+        if (verbose) {
+            // Count valid points for logging (sentinel value = -1e10)
+            let zeroCount = 0;
+            let validCount = 0;
+            for (let i = 0; i < totalGridPoints; i++) {
+                if (result[i] > EMPTY_CELL + 1) validCount++;  // Any value significantly above sentinel
+                if (result[i] === 0) zeroCount++;
+            }
+
+            let percentHit = validCount/totalGridPoints;
+            if (zeroCount > 0 || percentHit < 0.5 ) {
+                debug.log(totalGridPoints, 'cells,', round(percentHit*100), '% coverage,', zeroCount, 'zeros');
+            }
+        }
+    } else {
+        // Tool: Sparse output (X,Y,Z triplets), compact to remove invalid points
+        const validPoints = [];
+        for (let i = 0; i < totalGridPoints; i++) {
+            if (validMaskData[i] === 1) {
+                validPoints.push(
+                    outputData[i * 3],
+                    outputData[i * 3 + 1],
+                    outputData[i * 3 + 2]
+                );
+            }
+        }
+        result = new Float32Array(validPoints);
+        pointCount = validPoints.length / 3;
+    }
+
+    stagingOutputBuffer.unmap();
+    stagingValidMaskBuffer.unmap();
+
+    // Cleanup
+    triangleBuffer.destroy();
+    outputBuffer.destroy();
+    validMaskBuffer.destroy();
+    uniformBuffer.destroy();
+    spatialCellOffsetsBuffer.destroy();
+    spatialTriangleIndicesBuffer.destroy();
+    stagingOutputBuffer.destroy();
+    stagingValidMaskBuffer.destroy();
+
+    const endTime = performance.now();
+    const conversionTime = endTime - startTime;
+    // debug.log(`Rasterize complete: ${pointCount} points in ${conversionTime.toFixed(1)}ms`);
+    // debug.log(`Bounds: min(${bounds.min.x.toFixed(2)}, ${bounds.min.y.toFixed(2)}, ${bounds.min.z.toFixed(2)}) max(${bounds.max.x.toFixed(2)}, ${bounds.max.y.toFixed(2)}, ${bounds.max.z.toFixed(2)})`);
+
+    // Verify result data integrity
+    if (filterMode === 0) {
+        // Terrain: Dense Z-only format
+        if (result.length > 0) {
+            const firstZ = result[0] <= EMPTY_CELL + 1 ? 'EMPTY' : result[0].toFixed(3);
+            const lastZ = result[result.length-1] <= EMPTY_CELL + 1 ? 'EMPTY' : result[result.length-1].toFixed(3);
+            // debug.log(`First Z: ${firstZ}, Last Z: ${lastZ}`);
+        }
+    } else {
+        // Tool: Sparse X,Y,Z format
+        if (result.length > 0) {
+            const firstPoint = `(${result[0].toFixed(3)}, ${result[1].toFixed(3)}, ${result[2].toFixed(3)})`;
+            const lastIdx = result.length - 3;
+            const lastPoint = `(${result[lastIdx].toFixed(3)}, ${result[lastIdx+1].toFixed(3)}, ${result[lastIdx+2].toFixed(3)})`;
+            // debug.log(`First point: ${firstPoint}, Last point: ${lastPoint}`);
+        }
+    }
+
+    return {
+        positions: result,
+        pointCount: pointCount,
+        bounds: bounds,
+        conversionTime: conversionTime,
+        gridWidth: gridWidth,
+        gridHeight: gridHeight,
+        isDense: filterMode === 0  // True for terrain (dense), false for tool (sparse)
+    };
+}
+
+// Create tiles for tiled rasterization
+function createTiles(bounds, stepSize, maxMemoryBytes) {
+    const width = bounds.max.x - bounds.min.x;
+    const height = bounds.max.y - bounds.min.y;
+    const aspectRatio = width / height;
+
+    // Calculate how many grid points we can fit in one tile
+    // Terrain uses dense Z-only format: (gridW * gridH * 1 * 4) for output
+    // This is 4x more efficient than the old sparse format (16 bytes → 4 bytes per point)
+    const bytesPerPoint = 1 * 4; // 4 bytes per grid point (Z-only)
+    const maxPointsPerTile = Math.floor(maxMemoryBytes / bytesPerPoint);
+    debug.log(`Dense terrain format: ${bytesPerPoint} bytes/point (was 16), can fit ${(maxPointsPerTile/1e6).toFixed(1)}M points per tile`);
+
+    // Calculate optimal tile grid dimensions while respecting aspect ratio
+    // We want: tileGridW * tileGridH <= maxPointsPerTile
+    // And: tileGridW / tileGridH ≈ aspectRatio
+
+    let tileGridW, tileGridH;
+    if (aspectRatio >= 1) {
+        // Width >= Height
+        tileGridH = Math.floor(Math.sqrt(maxPointsPerTile / aspectRatio));
+        tileGridW = Math.floor(tileGridH * aspectRatio);
+    } else {
+        // Height > Width
+        tileGridW = Math.floor(Math.sqrt(maxPointsPerTile * aspectRatio));
+        tileGridH = Math.floor(tileGridW / aspectRatio);
+    }
+
+    // Ensure we don't exceed limits
+    while (tileGridW * tileGridH * bytesPerPoint > maxMemoryBytes) {
+        if (tileGridW > tileGridH) {
+            tileGridW--;
+        } else {
+            tileGridH--;
+        }
+    }
+
+    // Convert grid dimensions to world dimensions
+    const tileWidth = tileGridW * stepSize;
+    const tileHeight = tileGridH * stepSize;
+
+    // Calculate number of tiles needed
+    const tilesX = Math.ceil(width / tileWidth);
+    const tilesY = Math.ceil(height / tileHeight);
+
+    // Calculate actual tile dimensions (distribute evenly)
+    const actualTileWidth = width / tilesX;
+    const actualTileHeight = height / tilesY;
+
+    debug.log(`Creating ${tilesX}x${tilesY} = ${tilesX * tilesY} tiles (${actualTileWidth.toFixed(2)}mm × ${actualTileHeight.toFixed(2)}mm each)`);
+    debug.log(`Tile grid: ${Math.ceil(actualTileWidth / stepSize)}x${Math.ceil(actualTileHeight / stepSize)} points per tile`);
+
+    const tiles = [];
+    const overlap = stepSize * 2; // Overlap by 2 grid cells to ensure no gaps
+
+    for (let ty = 0; ty < tilesY; ty++) {
+        for (let tx = 0; tx < tilesX; tx++) {
+            // Calculate base tile bounds (no overlap)
+            let tileMinX = bounds.min.x + (tx * actualTileWidth);
+            let tileMinY = bounds.min.y + (ty * actualTileHeight);
+            let tileMaxX = Math.min(bounds.max.x, tileMinX + actualTileWidth);
+            let tileMaxY = Math.min(bounds.max.y, tileMinY + actualTileHeight);
+
+            // Add overlap (except at outer edges) - but DON'T extend beyond global bounds
+            if (tx > 0) tileMinX = Math.max(bounds.min.x, tileMinX - overlap);
+            if (ty > 0) tileMinY = Math.max(bounds.min.y, tileMinY - overlap);
+            if (tx < tilesX - 1) tileMaxX = Math.min(bounds.max.x, tileMaxX + overlap);
+            if (ty < tilesY - 1) tileMaxY = Math.min(bounds.max.y, tileMaxY + overlap);
+
+            tiles.push({
+                id: `tile_${tx}_${ty}`,
+                bounds: {
+                    min: { x: tileMinX, y: tileMinY, z: bounds.min.z },
+                    max: { x: tileMaxX, y: tileMaxY, z: bounds.max.z }
+                }
+            });
+        }
+    }
+
+    return { tiles, tilesX, tilesY };
+}
+
+// Stitch tiles from multiple rasterization passes
+function stitchTiles(tileResults, fullBounds, stepSize) {
+    if (tileResults.length === 0) {
+        throw new Error('No tile results to stitch');
+    }
+
+    // Check if results are dense (terrain) or sparse (tool)
+    const isDense = tileResults[0].isDense;
+
+    if (isDense) {
+        // DENSE TERRAIN STITCHING: Simple array copying (Z-only format)
+        debug.log(`Stitching ${tileResults.length} dense terrain tiles...`);
+
+        // Calculate global grid dimensions
+        const globalWidth = Math.ceil((fullBounds.max.x - fullBounds.min.x) / stepSize) + 1;
+        const globalHeight = Math.ceil((fullBounds.max.y - fullBounds.min.y) / stepSize) + 1;
+        const totalGridCells = globalWidth * globalHeight;
+
+        // Allocate global dense grid (Z-only), initialize to sentinel value
+        const globalGrid = new Float32Array(totalGridCells);
+        globalGrid.fill(EMPTY_CELL);
+
+        debug.log(`Global grid: ${globalWidth}x${globalHeight} = ${totalGridCells.toLocaleString()} cells`);
+
+        // Copy each tile's Z-values to the correct position in global grid
+        for (const tile of tileResults) {
+            // Calculate tile's position in global grid
+            const tileOffsetX = Math.round((tile.tileBounds.min.x - fullBounds.min.x) / stepSize);
+            const tileOffsetY = Math.round((tile.tileBounds.min.y - fullBounds.min.y) / stepSize);
+
+            const tileWidth = tile.gridWidth;
+            const tileHeight = tile.gridHeight;
+
+            // Copy Z-values row by row
+            for (let ty = 0; ty < tileHeight; ty++) {
+                const globalY = tileOffsetY + ty;
+                if (globalY >= globalHeight) continue;
+
+                for (let tx = 0; tx < tileWidth; tx++) {
+                    const globalX = tileOffsetX + tx;
+                    if (globalX >= globalWidth) continue;
+
+                    const tileIdx = ty * tileWidth + tx;
+                    const globalIdx = globalY * globalWidth + globalX;
+                    const tileZ = tile.positions[tileIdx];
+
+                    // For overlapping cells, keep max Z (terrain surface)
+                    // Skip empty cells (sentinel value)
+                    if (tileZ > EMPTY_CELL + 1) {
+                        const existingZ = globalGrid[globalIdx];
+                        if (existingZ <= EMPTY_CELL + 1 || tileZ > existingZ) {
+                            globalGrid[globalIdx] = tileZ;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Count valid cells (above sentinel value)
+        let validCount = 0;
+        for (let i = 0; i < totalGridCells; i++) {
+            if (globalGrid[i] > EMPTY_CELL + 1) validCount++;
+        }
+
+        debug.log(`Stitched: ${totalGridCells} total cells, ${validCount} with geometry (${(validCount/totalGridCells*100).toFixed(1)}% coverage)`);
+
+        return {
+            positions: globalGrid,
+            pointCount: totalGridCells,
+            bounds: fullBounds,
+            gridWidth: globalWidth,
+            gridHeight: globalHeight,
+            isDense: true,
+            conversionTime: tileResults.reduce((sum, r) => sum + (r.conversionTime || 0), 0),
+            tileCount: tileResults.length
+        };
+
+    } else {
+        // SPARSE TOOL STITCHING: Keep existing deduplication logic (X,Y,Z triplets)
+        debug.log(`Stitching ${tileResults.length} sparse tool tiles...`);
+
+        const pointMap = new Map();
+
+        for (const result of tileResults) {
+            const positions = result.positions;
+
+            // Calculate offset from tile origin to global origin (in grid cells)
+            const tileOffsetX = Math.round((result.tileBounds.min.x - fullBounds.min.x) / stepSize);
+            const tileOffsetY = Math.round((result.tileBounds.min.y - fullBounds.min.y) / stepSize);
+
+            // Convert each point from tile-local to global grid coordinates
+            for (let i = 0; i < positions.length; i += 3) {
+                const localGridX = positions[i];
+                const localGridY = positions[i + 1];
+                const z = positions[i + 2];
+
+                // Convert local grid indices to global grid indices
+                const globalGridX = localGridX + tileOffsetX;
+                const globalGridY = localGridY + tileOffsetY;
+
+                const key = `${globalGridX},${globalGridY}`;
+                const existing = pointMap.get(key);
+
+                // Keep lowest Z value (for tool)
+                if (!existing || z < existing.z) {
+                    pointMap.set(key, { x: globalGridX, y: globalGridY, z });
+                }
+            }
+        }
+
+        // Convert Map to flat array
+        const finalPointCount = pointMap.size;
+        const allPositions = new Float32Array(finalPointCount * 3);
+        let writeOffset = 0;
+
+        for (const point of pointMap.values()) {
+            allPositions[writeOffset++] = point.x;
+            allPositions[writeOffset++] = point.y;
+            allPositions[writeOffset++] = point.z;
+        }
+
+        debug.log(`Stitched: ${finalPointCount} unique sparse points`);
+
+        return {
+            positions: allPositions,
+            pointCount: finalPointCount,
+            bounds: fullBounds,
+            isDense: false,
+            conversionTime: tileResults.reduce((sum, r) => sum + (r.conversionTime || 0), 0),
+            tileCount: tileResults.length
+        };
+    }
+}
+
+// Check if tiling is needed (only called for terrain, which uses dense format)
+function shouldUseTiling(bounds, stepSize) {
+    if (!config || !config.autoTiling) return false;
+    if (!deviceCapabilities) return false;
+
+    const gridWidth = Math.ceil((bounds.max.x - bounds.min.x) / stepSize) + 1;
+    const gridHeight = Math.ceil((bounds.max.y - bounds.min.y) / stepSize) + 1;
+    const totalPoints = gridWidth * gridHeight;
+
+    // Terrain uses dense Z-only format: 1 float (4 bytes) per grid cell
+    const gpuOutputBuffer = totalPoints * 1 * 4;
+    const totalGPUMemory = gpuOutputBuffer;  // No mask needed for dense output
+
+    // Use the smaller of configured limit or device capability
+    const configuredLimit = config.maxGPUMemoryMB * 1024 * 1024;
+    const deviceLimit = deviceCapabilities.maxStorageBufferBindingSize;
+    const maxSafeSize = Math.min(configuredLimit, deviceLimit) * config.gpuMemorySafetyMargin;
+
+    return totalGPUMemory > maxSafeSize;
+}
+
+// Rasterize mesh - wrapper that handles automatic tiling if needed
+async function rasterizeMesh(triangles, stepSize, filterMode, options = {}) {
+    const boundsOverride = options.bounds || options.min ? options : null;  // Support old and new format
+    const bounds = boundsOverride || calculateBounds(triangles);
+
+    // Check if tiling is needed
+    if (shouldUseTiling(bounds, stepSize)) {
+        debug.log('Tiling required - switching to tiled rasterization');
+
+        // Calculate max safe size per tile
+        const configuredLimit = config.maxGPUMemoryMB * 1024 * 1024;
+        const deviceLimit = deviceCapabilities.maxStorageBufferBindingSize;
+        const maxSafeSize = Math.min(configuredLimit, deviceLimit) * config.gpuMemorySafetyMargin;
+
+        // Create tiles
+        const { tiles } = createTiles(bounds, stepSize, maxSafeSize);
+
+        // Rasterize each tile
+        const tileResults = [];
+        for (let i = 0; i < tiles.length; i++) {
+            const tileStart = performance.now();
+            debug.log(`Processing tile ${i + 1}/${tiles.length}: ${tiles[i].id}`);
+            debug.log(`  Tile bounds: min(${tiles[i].bounds.min.x.toFixed(2)}, ${tiles[i].bounds.min.y.toFixed(2)}) max(${tiles[i].bounds.max.x.toFixed(2)}, ${tiles[i].bounds.max.y.toFixed(2)})`);
+
+            const tileResult = await rasterizeMeshSingle(triangles, stepSize, filterMode, {
+                ...tiles[i].bounds,
+                rotationAngleDeg: options.rotationAngleDeg
+            });
+
+            const tileTime = performance.now() - tileStart;
+            debug.log(`  Tile ${i + 1} complete: ${tileResult.pointCount} points in ${tileTime.toFixed(1)}ms`);
+
+            // Store tile bounds with result for coordinate conversion during stitching
+            tileResult.tileBounds = tiles[i].bounds;
+            tileResults.push(tileResult);
+        }
+
+        // Stitch tiles together (pass full bounds and step size for coordinate conversion)
+        return stitchTiles(tileResults, bounds, stepSize);
+    } else {
+        // Single-pass rasterization
+        return await rasterizeMeshSingle(triangles, stepSize, filterMode, options);
+    }
+}
+
+// Helper: Create height map from dense terrain points (Z-only array)
+// Terrain is ALWAYS dense (Z-only), never sparse
+function createHeightMapFromPoints(points, gridStep, bounds = null) {
+    if (!points || points.length === 0) {
+        throw new Error('No points provided');
+    }
+
+    // Calculate dimensions from bounds
+    if (!bounds) {
+        throw new Error('Bounds required for height map creation');
+    }
+
+    const minX = bounds.min.x;
+    const minY = bounds.min.y;
+    const minZ = bounds.min.z;
+    const maxX = bounds.max.x;
+    const maxY = bounds.max.y;
+    const maxZ = bounds.max.z;
+    const width = Math.ceil((maxX - minX) / gridStep) + 1;
+    const height = Math.ceil((maxY - minY) / gridStep) + 1;
+
+    // Terrain is ALWAYS dense (Z-only format from GPU rasterizer)
+    // debug.log(`Terrain dense format: ${width}x${height} = ${points.length} cells`);
+
+    return {
+        grid: points,  // Dense Z-only array
+        width,
+        height,
+        minX,
+        minY,
+        minZ,
+        maxX,
+        maxY,
+        maxZ
+    };
+}
+
+// Helper: Create sparse tool representation
+// Points come from GPU as [gridX, gridY, Z] - pure integer grid coordinates for X/Y
+function createSparseToolFromPoints(points) {
+    if (!points || points.length === 0) {
+        throw new Error('No tool points provided');
+    }
+
+    // Points are [gridX, gridY, Z] where gridX/gridY are grid indices (floats but integer values)
+    // Find bounds in grid space and tool tip Z
+    let minGridX = Infinity, minGridY = Infinity, minZ = Infinity;
+    let maxGridX = -Infinity, maxGridY = -Infinity;
+
+    for (let i = 0; i < points.length; i += 3) {
+        const gridX = points[i];      // Already a grid index
+        const gridY = points[i + 1];  // Already a grid index
+        const z = points[i + 2];
+
+        minGridX = Math.min(minGridX, gridX);
+        maxGridX = Math.max(maxGridX, gridX);
+        minGridY = Math.min(minGridY, gridY);
+        maxGridY = Math.max(maxGridY, gridY);
+        minZ = Math.min(minZ, z);
+    }
+
+    // Calculate tool center in grid coordinates (pure integer)
+    const width = Math.floor(maxGridX - minGridX) + 1;
+    const height = Math.floor(maxGridY - minGridY) + 1;
+    const centerX = Math.floor(minGridX) + Math.floor(width / 2);
+    const centerY = Math.floor(minGridY) + Math.floor(height / 2);
+
+    // Convert each point to offset from center (integer arithmetic only)
+    const xOffsets = [];
+    const yOffsets = [];
+    const zValues = [];
+
+    for (let i = 0; i < points.length; i += 3) {
+        const gridX = Math.floor(points[i]);      // Grid index (ensure integer)
+        const gridY = Math.floor(points[i + 1]);  // Grid index (ensure integer)
+        const z = points[i + 2];
+
+        // Calculate offset from tool center (pure integer arithmetic)
+        const xOffset = gridX - centerX;
+        const yOffset = gridY - centerY;
+        // Z relative to tool tip: tip=0, points above tip are positive
+        // minZ is the lowest Z (tip), so z - minZ gives positive offsets upward
+        const zValue = z;// - minZ;
+
+        xOffsets.push(xOffset);
+        yOffsets.push(yOffset);
+        zValues.push(zValue);
+    }
+
+    return {
+        count: xOffsets.length,
+        xOffsets: new Int32Array(xOffsets),
+        yOffsets: new Int32Array(yOffsets),
+        zValues: new Float32Array(zValues),
+        referenceZ: minZ
+    };
+}
+
+// Generate toolpath with pre-created sparse tool (for batch operations)
+async function generateToolpathWithSparseTools(terrainPoints, sparseToolData, xStep, yStep, oobZ, gridStep, terrainBounds = null, singleScanline = false) {
+    const startTime = performance.now();
+
+    try {
+        // Create height map from terrain points (use terrain bounds if provided)
+        const terrainMapData = createHeightMapFromPoints(terrainPoints, gridStep, terrainBounds);
+
+        // Run WebGPU compute with pre-created sparse tool
+        const result = await runToolpathCompute(
+            terrainMapData, sparseToolData, xStep, yStep, oobZ, startTime
+        );
+
+        return result;
+    } catch (error) {
+        debug.error('Error generating toolpath:', error);
+        throw error;
+    }
+}
+
+// Generate toolpath for a single region (internal)
+async function generateToolpathSingle(terrainPoints, toolPoints, xStep, yStep, oobZ, gridStep, terrainBounds = null) {
+    const startTime = performance.now();
+    debug.log('Generating toolpath...');
+    debug.log(`Input: terrain ${terrainPoints.length/3} points, tool ${toolPoints.length/3} points, steps (${xStep}, ${yStep}), oobZ ${oobZ}, gridStep ${gridStep}`);
+
+    if (terrainBounds) {
+        debug.log(`Using terrain bounds: min(${terrainBounds.min.x.toFixed(2)}, ${terrainBounds.min.y.toFixed(2)}, ${terrainBounds.min.z.toFixed(2)}) max(${terrainBounds.max.x.toFixed(2)}, ${terrainBounds.max.y.toFixed(2)}, ${terrainBounds.max.z.toFixed(2)})`);
+    }
+
+    try {
+        // Create height map from terrain points (use terrain bounds if provided)
+        const terrainMapData = createHeightMapFromPoints(terrainPoints, gridStep, terrainBounds);
+        debug.log(`Created terrain map: ${terrainMapData.width}x${terrainMapData.height}`);
+
+        // Create sparse tool representation
+        const sparseToolData = createSparseToolFromPoints(toolPoints);
+        debug.log(`Created sparse tool: ${sparseToolData.count} points`);
+
+        // Run WebGPU compute
+        const result = await runToolpathCompute(
+            terrainMapData, sparseToolData, xStep, yStep, oobZ, startTime
+        );
+
+        return result;
+    } catch (error) {
+        debug.error('Error generating toolpath:', error);
+        throw error;
+    }
+}
+
+async function runToolpathCompute(terrainMapData, sparseToolData, xStep, yStep, oobZ, startTime) {
+    if (!isInitialized) {
+        const success = await initWebGPU();
+        if (!success) {
+            throw new Error('WebGPU not available');
+        }
+    }
+
+    // Use WASM-generated terrain grid
+    const terrainBuffer = device.createBuffer({
+        size: terrainMapData.grid.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(terrainBuffer, 0, terrainMapData.grid);
+
+    // Use WASM-generated sparse tool
+    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);
+
+    // Calculate output dimensions
+    const pointsPerLine = Math.ceil(terrainMapData.width / xStep);
+    const numScanlines = Math.ceil(terrainMapData.height / yStep);
+    const outputSize = pointsPerLine * numScanlines;
+
+    const outputBuffer = device.createBuffer({
+        size: outputSize * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const uniformData = new Uint32Array([
+        terrainMapData.width,
+        terrainMapData.height,
+        sparseToolData.count,
+        xStep,
+        yStep,
+        0,
+        pointsPerLine,
+        numScanlines,
+        0,  // y_offset (default 0 for planar mode)
+    ]);
+    const uniformDataFloat = new Float32Array(uniformData.buffer);
+    uniformDataFloat[5] = oobZ;
+
+    const uniformBuffer = device.createBuffer({
+        size: uniformData.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(uniformBuffer, 0, uniformData);
+
+    // CRITICAL: Wait for all writeBuffer operations to complete before compute dispatch
+    await device.queue.onSubmittedWorkDone();
+
+    // Use cached pipeline
+    const bindGroup = device.createBindGroup({
+        layout: cachedToolpathPipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: terrainBuffer } },
+            { binding: 1, resource: { buffer: toolBuffer } },
+            { binding: 2, resource: { buffer: outputBuffer } },
+            { binding: 3, resource: { buffer: uniformBuffer } },
+        ],
+    });
+
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(cachedToolpathPipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+
+    const workgroupsX = Math.ceil(pointsPerLine / 16);
+    const workgroupsY = Math.ceil(numScanlines / 16);
+    passEncoder.dispatchWorkgroups(workgroupsX, workgroupsY);
+    passEncoder.end();
+
+    const stagingBuffer = device.createBuffer({
+        size: outputSize * 4,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+
+    commandEncoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, outputSize * 4);
+
+    device.queue.submit([commandEncoder.finish()]);
+
+    // CRITICAL: Wait for GPU to finish before reading results
+    await device.queue.onSubmittedWorkDone();
+
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+
+    const outputData = new Float32Array(stagingBuffer.getMappedRange());
+    const result = new Float32Array(outputData);
+    stagingBuffer.unmap();
+
+    terrainBuffer.destroy();
+    toolBuffer.destroy();
+    outputBuffer.destroy();
+    uniformBuffer.destroy();
+    stagingBuffer.destroy();
+
+    const endTime = performance.now();
+
+    return {
+        pathData: result,
+        numScanlines,
+        pointsPerLine,
+        generationTime: endTime - startTime
+    };
+}
+
+// Create reusable GPU buffers for tiled toolpath generation
+function createReusableToolpathBuffers(terrainWidth, terrainHeight, sparseToolData, xStep, yStep) {
+    const pointsPerLine = Math.ceil(terrainWidth / xStep);
+    const numScanlines = Math.ceil(terrainHeight / yStep);
+    const outputSize = pointsPerLine * numScanlines;
+
+    // Create terrain buffer (will be updated for each tile)
+    const terrainBuffer = device.createBuffer({
+        size: terrainWidth * terrainHeight * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+
+    // Create tool buffer (STATIC - same for all tiles!)
+    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);  // Write once!
+
+    // Create output buffer (will be read for each tile)
+    const outputBuffer = device.createBuffer({
+        size: outputSize * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    // Create uniform buffer (will be updated for each tile)
+    const uniformBuffer = device.createBuffer({
+        size: 36,  // 9 fields × 4 bytes (added y_offset field)
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+
+    // Create staging buffer (will be reused for readback)
+    const stagingBuffer = device.createBuffer({
+        size: outputSize * 4,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+
+    return {
+        terrainBuffer,
+        toolBuffer,
+        outputBuffer,
+        uniformBuffer,
+        stagingBuffer,
+        maxOutputSize: outputSize,
+        maxTerrainWidth: terrainWidth,
+        maxTerrainHeight: terrainHeight,
+        sparseToolData
+    };
+}
+
+// Destroy reusable GPU buffers
+function destroyReusableToolpathBuffers(buffers) {
+    buffers.terrainBuffer.destroy();
+    buffers.toolBuffer.destroy();
+    buffers.outputBuffer.destroy();
+    buffers.uniformBuffer.destroy();
+    buffers.stagingBuffer.destroy();
+}
+
+// Run toolpath compute using pre-created reusable buffers
+async function runToolpathComputeWithBuffers(terrainData, terrainWidth, terrainHeight, xStep, yStep, oobZ, buffers, startTime) {
+    // Update terrain buffer with new tile data
+    device.queue.writeBuffer(buffers.terrainBuffer, 0, terrainData);
+
+    // Calculate output dimensions
+    const pointsPerLine = Math.ceil(terrainWidth / xStep);
+    const numScanlines = Math.ceil(terrainHeight / yStep);
+    const outputSize = pointsPerLine * numScanlines;
+
+    // Calculate Y offset for single-scanline radial mode
+    // When numScanlines=1 and terrainHeight > 1, center the tool at the midline
+    const yOffset = (numScanlines === 1 && terrainHeight > 1) ? Math.floor(terrainHeight / 2) : 0;
+
+    // Update uniforms for this tile
+    const uniformData = new Uint32Array([
+        terrainWidth,
+        terrainHeight,
+        buffers.sparseToolData.count,
+        xStep,
+        yStep,
+        0,
+        pointsPerLine,
+        numScanlines,
+        yOffset,  // y_offset for radial single-scanline mode
+    ]);
+    const uniformDataFloat = new Float32Array(uniformData.buffer);
+    uniformDataFloat[5] = oobZ;
+    device.queue.writeBuffer(buffers.uniformBuffer, 0, uniformData);
+
+    // CRITICAL: Wait for all writeBuffer operations to complete before compute dispatch
+    // Without this, compute shader may read stale/incomplete buffer data
+    await device.queue.onSubmittedWorkDone();
+
+    // Create bind group (reusing cached pipeline)
+    const bindGroup = device.createBindGroup({
+        layout: cachedToolpathPipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: buffers.terrainBuffer } },
+            { binding: 1, resource: { buffer: buffers.toolBuffer } },
+            { binding: 2, resource: { buffer: buffers.outputBuffer } },
+            { binding: 3, resource: { buffer: buffers.uniformBuffer } },
+        ],
+    });
+
+    // Dispatch compute shader
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(cachedToolpathPipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+
+    const workgroupsX = Math.ceil(pointsPerLine / 16);
+    const workgroupsY = Math.ceil(numScanlines / 16);
+    passEncoder.dispatchWorkgroups(workgroupsX, workgroupsY);
+    passEncoder.end();
+
+    // Copy to staging buffer
+    commandEncoder.copyBufferToBuffer(buffers.outputBuffer, 0, buffers.stagingBuffer, 0, outputSize * 4);
+
+    device.queue.submit([commandEncoder.finish()]);
+
+    // CRITICAL: Wait for GPU to finish before reading results
+    await device.queue.onSubmittedWorkDone();
+
+    await buffers.stagingBuffer.mapAsync(GPUMapMode.READ);
+
+    // Create a true copy using slice() - new Float32Array(typedArray) only creates a view!
+    const outputData = new Float32Array(buffers.stagingBuffer.getMappedRange(), 0, outputSize);
+    const result = outputData.slice();  // slice() creates a new ArrayBuffer with copied data
+    buffers.stagingBuffer.unmap();
+
+    const endTime = performance.now();
+
+    // Debug: Log first few Z values to detect non-determinism
+    if (result.length > 0) {
+        const samples = [];
+        for (let i = 0; i < Math.min(10, result.length); i++) {
+            samples.push(result[i].toFixed(3));
+        }
+        // debug.log(`[Toolpath] Output samples (${result.length} total): ${samples.join(', ')}`);
+    }
+
+    return {
+        pathData: result,
+        numScanlines,
+        pointsPerLine,
+        generationTime: endTime - startTime
+    };
+}
+
+// Generate toolpath with tiling support (public API)
+async function generateToolpath(terrainPoints, toolPoints, xStep, yStep, oobZ, gridStep, terrainBounds = null, singleScanline = false) {
+    // Calculate bounds if not provided
+    if (!terrainBounds) {
+        let minX = Infinity, minY = Infinity, minZ = Infinity;
+        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+        for (let i = 0; i < terrainPoints.length; i += 3) {
+            minX = Math.min(minX, terrainPoints[i]);
+            maxX = Math.max(maxX, terrainPoints[i]);
+            minY = Math.min(minY, terrainPoints[i + 1]);
+            maxY = Math.max(maxY, terrainPoints[i + 1]);
+            minZ = Math.min(minZ, terrainPoints[i + 2]);
+            maxZ = Math.max(maxZ, terrainPoints[i + 2]);
+        }
+        terrainBounds = {
+            min: { x: minX, y: minY, z: minZ },
+            max: { x: maxX, y: maxY, z: maxZ }
+        };
+    }
+
+    // Note: singleScanline mode means OUTPUT only centerline, but terrain bounds stay full
+    // This ensures all terrain Y values contribute to tool interference at the centerline
+
+    // Debug tool bounds and center
+    for (let i=0; i<toolPoints.length; i += 3) {
+        if (toolPoints[i] === 0 && toolPoints[i+1] === 0) {
+            debug.log('[WebGPU Worker]', { TOOL_CENTER: toolPoints[i+2] });
+        }
+    }
+    debug.log('[WebGPU Worker]',
+        'toolZMin:', ([...toolPoints].filter((_,i) => i % 3 === 2).reduce((a,b) => Math.min(a,b), Infinity)),
+        'toolZMax:', ([...toolPoints].filter((_,i) => i % 3 === 2).reduce((a,b) => Math.max(a,b), -Infinity))
+    );
+
+    // Calculate tool dimensions for overlap
+    // Tool points are [gridX, gridY, Z] where X/Y are grid indices (not mm)
+    let toolMinX = Infinity, toolMaxX = -Infinity;
+    let toolMinY = Infinity, toolMaxY = -Infinity;
+    for (let i = 0; i < toolPoints.length; i += 3) {
+        toolMinX = Math.min(toolMinX, toolPoints[i]);
+        toolMaxX = Math.max(toolMaxX, toolPoints[i]);
+        toolMinY = Math.min(toolMinY, toolPoints[i + 1]);
+        toolMaxY = Math.max(toolMaxY, toolPoints[i + 1]);
+    }
+    // Tool dimensions in grid cells
+    const toolWidthCells = toolMaxX - toolMinX;
+    const toolHeightCells = toolMaxY - toolMinY;
+    // Convert to mm for logging
+    const toolWidthMm = toolWidthCells * gridStep;
+    const toolHeightMm = toolHeightCells * gridStep;
+
+    // Check if tiling is needed based on output grid size
+    const outputWidth = Math.ceil((terrainBounds.max.x - terrainBounds.min.x) / gridStep) + 1;
+    const outputHeight = Math.ceil((terrainBounds.max.y - terrainBounds.min.y) / gridStep) + 1;
+    const outputPoints = Math.ceil(outputWidth / xStep) * Math.ceil(outputHeight / yStep);
+    const outputMemory = outputPoints * 4; // 4 bytes per float
+
+    const configuredLimit = config.maxGPUMemoryMB * 1024 * 1024;
+    const deviceLimit = deviceCapabilities.maxStorageBufferBindingSize;
+    const maxSafeSize = Math.min(configuredLimit, deviceLimit) * config.gpuMemorySafetyMargin;
+
+    if (outputMemory <= maxSafeSize) {
+        // No tiling needed
+        return await generateToolpathSingle(terrainPoints, toolPoints, xStep, yStep, oobZ, gridStep, terrainBounds);
+    }
+
+    // Tiling needed (terrain is ALWAYS dense)
+    const tilingStartTime = performance.now();
+    debug.log('Using tiled toolpath generation');
+    debug.log(`Terrain: DENSE (${terrainPoints.length} cells = ${outputWidth}x${outputHeight})`);
+    debug.log(`Tool dimensions: ${toolWidthMm.toFixed(2)}mm × ${toolHeightMm.toFixed(2)}mm (${toolWidthCells}×${toolHeightCells} cells)`);
+
+    // Create tiles with tool-size overlap (pass dimensions in grid cells)
+    const { tiles, maxTileGridWidth, maxTileGridHeight } = createToolpathTiles(terrainBounds, gridStep, xStep, yStep, toolWidthCells, toolHeightCells, maxSafeSize);
+    debug.log(`Created ${tiles.length} tiles`);
+
+    // Pre-generate all tile terrain point arrays
+    const pregenStartTime = performance.now();
+    debug.log(`Pre-generating ${tiles.length} tile terrain arrays...`);
+    const allTileTerrainPoints = [];
+
+    for (let i = 0; i < tiles.length; i++) {
+        const tile = tiles[i];
+
+        // Extract terrain sub-grid for this tile (terrain is ALWAYS dense)
+        const tileMinGridX = Math.floor((tile.bounds.min.x - terrainBounds.min.x) / gridStep);
+        const tileMaxGridX = Math.ceil((tile.bounds.max.x - terrainBounds.min.x) / gridStep);
+        const tileMinGridY = Math.floor((tile.bounds.min.y - terrainBounds.min.y) / gridStep);
+        const tileMaxGridY = Math.ceil((tile.bounds.max.y - terrainBounds.min.y) / gridStep);
+
+        const tileWidth = tileMaxGridX - tileMinGridX + 1;
+        const tileHeight = tileMaxGridY - tileMinGridY + 1;
+
+        // Pad to max dimensions for consistent buffer sizing
+        const paddedTileTerrainPoints = new Float32Array(maxTileGridWidth * maxTileGridHeight);
+        paddedTileTerrainPoints.fill(EMPTY_CELL);
+
+        // Copy relevant sub-grid from full terrain into top-left of padded array
+        for (let ty = 0; ty < tileHeight; ty++) {
+            const globalY = tileMinGridY + ty;
+            if (globalY < 0 || globalY >= outputHeight) continue;
+
+            for (let tx = 0; tx < tileWidth; tx++) {
+                const globalX = tileMinGridX + tx;
+                if (globalX < 0 || globalX >= outputWidth) continue;
+
+                const globalIdx = globalY * outputWidth + globalX;
+                const tileIdx = ty * maxTileGridWidth + tx;  // Use maxTileGridWidth for stride
+                paddedTileTerrainPoints[tileIdx] = terrainPoints[globalIdx];
+            }
+        }
+
+        allTileTerrainPoints.push({
+            data: paddedTileTerrainPoints,
+            actualWidth: tileWidth,
+            actualHeight: tileHeight
+        });
+    }
+
+    const pregenTime = performance.now() - pregenStartTime;
+    debug.log(`Pre-generation complete in ${pregenTime.toFixed(1)}ms`);
+
+    // Create reusable GPU buffers (sized for maximum tile)
+    if (!isInitialized) {
+        const success = await initWebGPU();
+        if (!success) {
+            throw new Error('WebGPU not available');
+        }
+    }
+
+    const sparseToolData = createSparseToolFromPoints(toolPoints);
+    const reusableBuffers = createReusableToolpathBuffers(maxTileGridWidth, maxTileGridHeight, sparseToolData, xStep, yStep);
+    debug.log(`Created reusable GPU buffers for ${maxTileGridWidth}x${maxTileGridHeight} tiles`);
+
+    // Process each tile with reusable buffers
+    const tileResults = [];
+    let totalTileTime = 0;
+    for (let i = 0; i < tiles.length; i++) {
+        const tile = tiles[i];
+        const tileStartTime = performance.now();
+        debug.log(`Processing tile ${i + 1}/${tiles.length}...`);
+
+        // Report progress
+        const percent = Math.round(((i + 1) / tiles.length) * 100);
+        self.postMessage({
+            type: 'toolpath-progress',
+            data: {
+                percent,
+                current: i + 1,
+                total: tiles.length,
+                layer: i + 1  // Using tile index as "layer" for consistency
+            }
+        });
+
+        debug.log(`Tile ${i+1} using pre-generated terrain: ${allTileTerrainPoints[i].actualWidth}x${allTileTerrainPoints[i].actualHeight} (padded to ${maxTileGridWidth}x${maxTileGridHeight})`);
+
+        // Generate toolpath for this tile using reusable buffers
+        const tileToolpathResult = await runToolpathComputeWithBuffers(
+            allTileTerrainPoints[i].data,
+            maxTileGridWidth,
+            maxTileGridHeight,
+            xStep,
+            yStep,
+            oobZ,
+            reusableBuffers,
+            tileStartTime
+        );
+
+        const tileTime = performance.now() - tileStartTime;
+        totalTileTime += tileTime;
+
+        tileResults.push({
+            pathData: tileToolpathResult.pathData,
+            numScanlines: tileToolpathResult.numScanlines,
+            pointsPerLine: tileToolpathResult.pointsPerLine,
+            tile: tile
+        });
+
+        debug.log(`Tile ${i + 1}/${tiles.length} complete: ${tileToolpathResult.numScanlines}×${tileToolpathResult.pointsPerLine} in ${tileTime.toFixed(1)}ms`);
+    }
+
+    // Cleanup reusable buffers
+    destroyReusableToolpathBuffers(reusableBuffers);
+
+    debug.log(`All tiles processed in ${totalTileTime.toFixed(1)}ms (avg ${(totalTileTime/tiles.length).toFixed(1)}ms per tile)`);
+
+    // Stitch tiles together, dropping overlap regions
+    const stitchStartTime = performance.now();
+    const stitchedResult = stitchToolpathTiles(tileResults, terrainBounds, gridStep, xStep, yStep);
+    const stitchTime = performance.now() - stitchStartTime;
+
+    const totalTime = performance.now() - tilingStartTime;
+    debug.log(`Stitching took ${stitchTime.toFixed(1)}ms`);
+    debug.log(`Tiled toolpath complete: ${stitchedResult.numScanlines}×${stitchedResult.pointsPerLine} in ${totalTime.toFixed(1)}ms total`);
+
+    // Update generation time to reflect total tiled time
+    stitchedResult.generationTime = totalTime;
+
+    return stitchedResult;
+}
+
+// Create tiles for toolpath generation with overlap (using integer grid coordinates)
+// toolWidth and toolHeight are in grid cells (not mm)
+function createToolpathTiles(bounds, gridStep, xStep, yStep, toolWidthCells, toolHeightCells, maxMemoryBytes) {
+    // Calculate global grid dimensions
+    const globalGridWidth = Math.ceil((bounds.max.x - bounds.min.x) / gridStep) + 1;
+    const globalGridHeight = Math.ceil((bounds.max.y - bounds.min.y) / gridStep) + 1;
+
+    // Calculate tool overlap in grid cells (use radius = half diameter)
+    // Tool centered at tile boundary needs terrain extending half tool width beyond boundary
+    const toolOverlapX = Math.ceil(toolWidthCells / 2);
+    const toolOverlapY = Math.ceil(toolHeightCells / 2);
+
+    // Binary search for optimal tile size in grid cells
+    let low = Math.max(toolOverlapX, toolOverlapY) * 2; // At least 2x tool size
+    let high = Math.max(globalGridWidth, globalGridHeight);
+    let bestTileGridSize = high;
+
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const outputW = Math.ceil(mid / xStep);
+        const outputH = Math.ceil(mid / yStep);
+        const memoryNeeded = outputW * outputH * 4;
+
+        if (memoryNeeded <= maxMemoryBytes) {
+            bestTileGridSize = mid;
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+    }
+
+    const tilesX = Math.ceil(globalGridWidth / bestTileGridSize);
+    const tilesY = Math.ceil(globalGridHeight / bestTileGridSize);
+    const coreGridWidth = Math.ceil(globalGridWidth / tilesX);
+    const coreGridHeight = Math.ceil(globalGridHeight / tilesY);
+
+    // Calculate maximum tile dimensions (for buffer sizing)
+    const maxTileGridWidth = coreGridWidth + 2 * toolOverlapX;
+    const maxTileGridHeight = coreGridHeight + 2 * toolOverlapY;
+
+    debug.log(`Creating ${tilesX}×${tilesY} tiles (${coreGridWidth}×${coreGridHeight} cells core + ${toolOverlapX}×${toolOverlapY} cells overlap)`);
+    debug.log(`Max tile dimensions: ${maxTileGridWidth}×${maxTileGridHeight} cells (for buffer sizing)`);
+
+    const tiles = [];
+    for (let ty = 0; ty < tilesY; ty++) {
+        for (let tx = 0; tx < tilesX; tx++) {
+            // Core tile in grid coordinates
+            const coreGridStartX = tx * coreGridWidth;
+            const coreGridStartY = ty * coreGridHeight;
+            const coreGridEndX = Math.min((tx + 1) * coreGridWidth, globalGridWidth) - 1;
+            const coreGridEndY = Math.min((ty + 1) * coreGridHeight, globalGridHeight) - 1;
+
+            // Extended tile with overlap in grid coordinates
+            let extGridStartX = coreGridStartX;
+            let extGridStartY = coreGridStartY;
+            let extGridEndX = coreGridEndX;
+            let extGridEndY = coreGridEndY;
+
+            // Add overlap on sides that aren't at global boundary
+            if (tx > 0) extGridStartX -= toolOverlapX;
+            if (ty > 0) extGridStartY -= toolOverlapY;
+            if (tx < tilesX - 1) extGridEndX += toolOverlapX;
+            if (ty < tilesY - 1) extGridEndY += toolOverlapY;
+
+            // Clamp to global bounds
+            extGridStartX = Math.max(0, extGridStartX);
+            extGridStartY = Math.max(0, extGridStartY);
+            extGridEndX = Math.min(globalGridWidth - 1, extGridEndX);
+            extGridEndY = Math.min(globalGridHeight - 1, extGridEndY);
+
+            // Calculate actual dimensions for this tile
+            const tileGridWidth = extGridEndX - extGridStartX + 1;
+            const tileGridHeight = extGridEndY - extGridStartY + 1;
+
+            // Convert grid coordinates to world coordinates
+            const extMinX = bounds.min.x + extGridStartX * gridStep;
+            const extMinY = bounds.min.y + extGridStartY * gridStep;
+            const extMaxX = bounds.min.x + extGridEndX * gridStep;
+            const extMaxY = bounds.min.y + extGridEndY * gridStep;
+
+            const coreMinX = bounds.min.x + coreGridStartX * gridStep;
+            const coreMinY = bounds.min.y + coreGridStartY * gridStep;
+            const coreMaxX = bounds.min.x + coreGridEndX * gridStep;
+            const coreMaxY = bounds.min.y + coreGridEndY * gridStep;
+
+            tiles.push({
+                id: `tile_${tx}_${ty}`,
+                tx, ty,
+                tilesX, tilesY,
+                gridWidth: tileGridWidth,
+                gridHeight: tileGridHeight,
+                bounds: {
+                    min: { x: extMinX, y: extMinY, z: bounds.min.z },
+                    max: { x: extMaxX, y: extMaxY, z: bounds.max.z }
+                },
+                core: {
+                    gridStart: { x: coreGridStartX, y: coreGridStartY },
+                    gridEnd: { x: coreGridEndX, y: coreGridEndY },
+                    min: { x: coreMinX, y: coreMinY },
+                    max: { x: coreMaxX, y: coreMaxY }
+                }
+            });
+        }
+    }
+
+    return { tiles, maxTileGridWidth, maxTileGridHeight };
+}
+
+// Stitch toolpath tiles together, dropping overlap regions (using integer grid coordinates)
+function stitchToolpathTiles(tileResults, globalBounds, gridStep, xStep, yStep) {
+    // Calculate global output dimensions
+    const globalWidth = Math.ceil((globalBounds.max.x - globalBounds.min.x) / gridStep) + 1;
+    const globalHeight = Math.ceil((globalBounds.max.y - globalBounds.min.y) / gridStep) + 1;
+    const globalPointsPerLine = Math.ceil(globalWidth / xStep);
+    const globalNumScanlines = Math.ceil(globalHeight / yStep);
+
+    debug.log(`Stitching toolpath: global grid ${globalWidth}x${globalHeight}, output ${globalPointsPerLine}x${globalNumScanlines}`);
+
+    const result = new Float32Array(globalPointsPerLine * globalNumScanlines);
+    result.fill(NaN);
+
+    // Fast path for 1x1 stepping: use bulk row copying
+    const use1x1FastPath = (xStep === 1 && yStep === 1);
+
+    for (const tileResult of tileResults) {
+        const tile = tileResult.tile;
+        const tileData = tileResult.pathData;
+
+        // Use the pre-calculated integer grid coordinates from tile.core
+        const coreGridStartX = tile.core.gridStart.x;
+        const coreGridStartY = tile.core.gridStart.y;
+        const coreGridEndX = tile.core.gridEnd.x;
+        const coreGridEndY = tile.core.gridEnd.y;
+
+        // Calculate tile's extended grid coordinates
+        const extGridStartX = Math.round((tile.bounds.min.x - globalBounds.min.x) / gridStep);
+        const extGridStartY = Math.round((tile.bounds.min.y - globalBounds.min.y) / gridStep);
+
+        let copiedCount = 0;
+
+        // Calculate output coordinate ranges for this tile's core
+        // Core region in grid coordinates
+        const coreGridWidth = coreGridEndX - coreGridStartX + 1;
+        const coreGridHeight = coreGridEndY - coreGridStartY + 1;
+
+        // Core region in output coordinates (sampled by xStep/yStep)
+        const coreOutStartX = Math.floor(coreGridStartX / xStep);
+        const coreOutStartY = Math.floor(coreGridStartY / yStep);
+        const coreOutEndX = Math.floor(coreGridEndX / xStep);
+        const coreOutEndY = Math.floor(coreGridEndY / yStep);
+        const coreOutWidth = coreOutEndX - coreOutStartX + 1;
+        const coreOutHeight = coreOutEndY - coreOutStartY + 1;
+
+        // Tile's extended region start in grid coordinates
+        const extOutStartX = Math.floor(extGridStartX / xStep);
+        const extOutStartY = Math.floor(extGridStartY / yStep);
+
+        // Copy entire rows at once (works for all stepping values)
+        for (let outY = 0; outY < coreOutHeight; outY++) {
+            const globalOutY = coreOutStartY + outY;
+            const tileOutY = globalOutY - extOutStartY;
+
+            if (globalOutY >= 0 && globalOutY < globalNumScanlines &&
+                tileOutY >= 0 && tileOutY < tileResult.numScanlines) {
+
+                const globalRowStart = globalOutY * globalPointsPerLine + coreOutStartX;
+                const tileRowStart = tileOutY * tileResult.pointsPerLine + (coreOutStartX - extOutStartX);
+
+                // Bulk copy entire row of output values
+                result.set(tileData.subarray(tileRowStart, tileRowStart + coreOutWidth), globalRowStart);
+                copiedCount += coreOutWidth;
+            }
+        }
+
+        debug.log(`  Tile ${tile.id}: copied ${copiedCount} values`);
+    }
+
+    // Count how many output values are still NaN (gaps)
+    let nanCount = 0;
+    for (let i = 0; i < result.length; i++) {
+        if (isNaN(result[i])) nanCount++;
+    }
+    debug.log(`Stitching complete: ${result.length} total values, ${nanCount} still NaN`);
+
+    return {
+        pathData: result,
+        numScanlines: globalNumScanlines,
+        pointsPerLine: globalPointsPerLine,
+        generationTime: 0 // Sum from tiles if needed
+    };
+}
+
+// Radial rasterization - two-pass tiled with bit-attention
+// Workload budget: triangles × scanlines should stay under this to avoid timeouts
+const MAX_WORKLOAD_PER_TILE = 10_000_000; // triangles × gridHeight budget per tile
+
+let cachedRadialCullPipeline = null;
+let cachedRadialRasterizePipeline = null;
+
+async function radialRasterize(triangles, stepSize, rotationStepDegrees, zFloor = 0, boundsOverride = null, params = {}) {
+    const startTime = performance.now();
+
+    if (!isInitialized) {
+        await initWebGPU();
+    }
+
+    // Check if SharedArrayBuffer is available and triangle data is large (>1M triangles = 9M floats = 36MB)
+    const numTriangles = triangles.length / 9;
+    const useSharedBuffer = typeof SharedArrayBuffer !== 'undefined' &&
+                           numTriangles > 1000000 &&
+                           !(triangles.buffer instanceof SharedArrayBuffer);
+
+    if (useSharedBuffer) {
+        debug.log(`Large dataset (${numTriangles.toLocaleString()} triangles), converting to SharedArrayBuffer`);
+        const sab = new SharedArrayBuffer(triangles.byteLength);
+        const sharedTriangles = new Float32Array(sab);
+        sharedTriangles.set(triangles);
+        triangles = sharedTriangles;
+    }
+
+    const bounds = boundsOverride || calculateBounds(triangles);
+
+    // Calculate max radius (distance from X-axis)
+    let maxRadius = 0;
+    for (let i = 0; i < triangles.length; i += 3) {
+        const y = triangles[i + 1];
+        const z = triangles[i + 2];
+        const radius = Math.sqrt(y * y + z * z);
+        maxRadius = Math.max(maxRadius, radius);
+    }
+
+    // Add margin for ray origins to start outside mesh
+    maxRadius *= 1.2;
+
+    const circumference = 2 * Math.PI * maxRadius;
+    const xRange = bounds.max.x - bounds.min.x;
+    const rotationStepRadians = rotationStepDegrees * (Math.PI / 180);
+
+    // Calculate grid height (number of angular scanlines)
+    const gridHeight = Math.ceil(360 / rotationStepDegrees) + 1;
+
+    // Calculate number of tiles based on user config or auto-calculation
+    let numTiles, trianglesPerTileTarget;
+
+    if (params.trianglesPerTile) {
+        // User specified explicit triangles per tile
+        trianglesPerTileTarget = params.trianglesPerTile;
+        numTiles = Math.max(1, Math.ceil(numTriangles / trianglesPerTileTarget));
+        debug.log(`Radial: ${numTriangles} triangles, ${gridHeight} scanlines, ${numTiles} X-tiles (${trianglesPerTileTarget} target tri/tile)`);
+    } else {
+        // Auto-calculate based on workload budget
+        // Total work = numTriangles × gridHeight × culling_efficiency
+        // More tiles = smaller X-slices = better culling = less work per tile
+        const totalWorkload = numTriangles * gridHeight * 0.5; // 0.5 = expected culling efficiency
+        numTiles = Math.max(1, Math.ceil(totalWorkload / MAX_WORKLOAD_PER_TILE));
+        trianglesPerTileTarget = Math.ceil(numTriangles / numTiles);
+        debug.log(`Radial: ${numTriangles} triangles, ${gridHeight} scanlines, ${numTiles} X-tiles (${trianglesPerTileTarget} avg tri/tile, auto-calculated)`);
+    }
+
+    const tileWidth = xRange / numTiles;
+
+    // Create pipelines on first use
+    if (!cachedRadialCullPipeline) {
+        const cullShaderModule = device.createShaderModule({ code: radialCullShaderCode });
+        cachedRadialCullPipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: cullShaderModule, entryPoint: 'main' }
+        });
+        debug.log('Created radial cull pipeline');
+    }
+
+    if (!cachedRadialRasterizePipeline) {
+        const rasterShaderModule = device.createShaderModule({ code: radialRasterizeShaderCode });
+        cachedRadialRasterizePipeline = device.createComputePipeline({
+            layout: 'auto',
+            compute: { module: rasterShaderModule, entryPoint: 'main' }
+        });
+        debug.log('Created radial rasterize pipeline');
+    }
+
+    // Create shared triangle buffer
+    const triangleBuffer = device.createBuffer({
+        size: triangles.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(triangleBuffer, 0, triangles);
+
+    // Calculate attention bit array size
+    const numWords = Math.ceil(numTriangles / 32);
+    debug.log(`Attention array: ${numWords} words (${numWords * 4} bytes)`);
+
+    // Helper function to process a single tile
+    async function processTile(tileIdx) {
+        const prefix = `Tile ${tileIdx + 1}/${numTiles}:`;
+        try {
+            const tile_min_x = bounds.min.x + tileIdx * tileWidth;
+            const tile_max_x = bounds.min.x + (tileIdx + 1) * tileWidth;
+
+            debug.log(`${prefix} X=[${tile_min_x.toFixed(2)}, ${tile_max_x.toFixed(2)}]`);
+
+        // Pass 1: Cull triangles for this X-tile
+        const tileStartTime = performance.now();
+
+        const attentionBuffer = device.createBuffer({
+            size: numWords * 4,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+        });
+
+        // Clear attention buffer
+        const zeros = new Uint32Array(numWords);
+        device.queue.writeBuffer(attentionBuffer, 0, zeros);
+
+        const cullUniformData = new Float32Array(4);
+        cullUniformData[0] = tile_min_x;
+        cullUniformData[1] = tile_max_x;
+        const cullUniformU32 = new Uint32Array(cullUniformData.buffer);
+        cullUniformU32[2] = numTriangles;
+
+        const cullUniformBuffer = device.createBuffer({
+            size: 16,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(cullUniformBuffer, 0, cullUniformData);
+
+        // CRITICAL: Wait for writeBuffer operations before compute dispatch
+        await device.queue.onSubmittedWorkDone();
+
+        const cullBindGroup = device.createBindGroup({
+            layout: cachedRadialCullPipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: triangleBuffer } },
+                { binding: 1, resource: { buffer: attentionBuffer } },
+                { binding: 2, resource: { buffer: cullUniformBuffer } },
+            ],
+        });
+
+        const cullEncoder = device.createCommandEncoder();
+        const cullPass = cullEncoder.beginComputePass();
+        cullPass.setPipeline(cachedRadialCullPipeline);
+        cullPass.setBindGroup(0, cullBindGroup);
+        cullPass.dispatchWorkgroups(Math.ceil(numTriangles / 256));
+        cullPass.end();
+        device.queue.submit([cullEncoder.finish()]);
+        await device.queue.onSubmittedWorkDone();
+
+        const cullTime = performance.now() - tileStartTime;
+        // debug.log(`  Culling: ${cullTime.toFixed(1)}ms`);
+
+        // Pass 1.5: Read back attention bits and compact to triangle index list
+        const compactStartTime = performance.now();
+
+        // Create staging buffer to read attention bits
+        const attentionStagingBuffer = device.createBuffer({
+            size: numWords * 4,
+            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+        });
+
+        const copyEncoder = device.createCommandEncoder();
+        copyEncoder.copyBufferToBuffer(attentionBuffer, 0, attentionStagingBuffer, 0, numWords * 4);
+        device.queue.submit([copyEncoder.finish()]);
+        await device.queue.onSubmittedWorkDone();
+
+        await attentionStagingBuffer.mapAsync(GPUMapMode.READ);
+        const attentionBits = new Uint32Array(attentionStagingBuffer.getMappedRange());
+
+        // CPU compaction: build list of marked triangle indices
+        const compactIndices = [];
+        for (let triIdx = 0; triIdx < numTriangles; triIdx++) {
+            const wordIdx = Math.floor(triIdx / 32);
+            const bitIdx = triIdx % 32;
+            const isMarked = (attentionBits[wordIdx] & (1 << bitIdx)) !== 0;
+            if (isMarked) {
+                compactIndices.push(triIdx);
+            }
+        }
+
+        attentionStagingBuffer.unmap();
+        attentionStagingBuffer.destroy();
+
+        const compactTime = performance.now() - compactStartTime;
+        const cullingEfficiency = ((numTriangles - compactIndices.length) / numTriangles * 100).toFixed(1);
+        debug.log(`${prefix} Compacted ${numTriangles} → ${compactIndices.length} triangles (${cullingEfficiency}% culled) in ${compactTime.toFixed(1)}ms`);
+
+        // Create compact triangle index buffer
+        const compactIndexBuffer = device.createBuffer({
+            size: Math.max(4, compactIndices.length * 4), // At least 4 bytes
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+        if (compactIndices.length > 0) {
+            device.queue.writeBuffer(compactIndexBuffer, 0, new Uint32Array(compactIndices));
+        }
+
+        // Pass 2: Rasterize this X-tile
+        const rasterStartTime = performance.now();
+
+        const gridWidth = Math.ceil(tileWidth / stepSize) + 1;
+        const gridHeight = Math.ceil(360 / rotationStepDegrees) + 1; // Number of angular samples
+        const totalCells = gridWidth * gridHeight;
+
+        debug.log(`${prefix} Grid: ${gridWidth}×${gridHeight} = ${totalCells} cells (rotationStep=${rotationStepDegrees}°)`);
+
+        const outputBuffer = device.createBuffer({
+            size: totalCells * 4,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+        });
+
+        // Initialize with EMPTY_CELL
+        const initData = new Float32Array(totalCells);
+        initData.fill(EMPTY_CELL);
+        device.queue.writeBuffer(outputBuffer, 0, initData);
+
+        const rotationOffsetRadians = (params.radialRotationOffset ?? 0) * (Math.PI / 180);
+
+        const rasterUniformData = new Float32Array(16);
+        rasterUniformData[0] = tile_min_x;
+        rasterUniformData[1] = tile_max_x;
+        rasterUniformData[2] = maxRadius;
+        rasterUniformData[3] = rotationStepRadians;
+        rasterUniformData[4] = stepSize;
+        rasterUniformData[5] = zFloor;
+        rasterUniformData[6] = rotationOffsetRadians;
+        rasterUniformData[7] = 0; // padding
+        const rasterUniformU32 = new Uint32Array(rasterUniformData.buffer);
+        rasterUniformU32[8] = gridWidth;
+        rasterUniformU32[9] = gridHeight;
+        rasterUniformU32[10] = compactIndices.length; // Use compact count instead of numTriangles
+        rasterUniformU32[11] = 0; // No longer using attention words
+
+        const rasterUniformBuffer = device.createBuffer({
+            size: 64,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(rasterUniformBuffer, 0, rasterUniformData);
+
+        // CRITICAL: Wait for writeBuffer operations before compute dispatch
+        await device.queue.onSubmittedWorkDone();
+
+        const rasterBindGroup = device.createBindGroup({
+            layout: cachedRadialRasterizePipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: triangleBuffer } },
+                { binding: 1, resource: { buffer: compactIndexBuffer } }, // Use compact indices instead of attention bits
+                { binding: 2, resource: { buffer: outputBuffer } },
+                { binding: 3, resource: { buffer: rasterUniformBuffer } },
+            ],
+        });
+
+        const rasterEncoder = device.createCommandEncoder();
+        const rasterPass = rasterEncoder.beginComputePass();
+        rasterPass.setPipeline(cachedRadialRasterizePipeline);
+        rasterPass.setBindGroup(0, rasterBindGroup);
+        const workgroupsX = Math.ceil(gridWidth / 16);
+        const workgroupsY = Math.ceil(gridHeight / 16);
+        rasterPass.dispatchWorkgroups(workgroupsX, workgroupsY);
+        rasterPass.end();
+
+        const stagingBuffer = device.createBuffer({
+            size: totalCells * 4,
+            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+        });
+
+        rasterEncoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, totalCells * 4);
+        device.queue.submit([rasterEncoder.finish()]);
+        await device.queue.onSubmittedWorkDone();
+
+        await stagingBuffer.mapAsync(GPUMapMode.READ);
+        const outputData = new Float32Array(stagingBuffer.getMappedRange());
+        const tileResult = new Float32Array(outputData);
+        stagingBuffer.unmap();
+
+        const rasterTime = performance.now() - rasterStartTime;
+        debug.log(`${prefix} Rasterization: ${rasterTime.toFixed(1)}ms`);
+
+        // Cleanup tile buffers
+        attentionBuffer.destroy();
+        cullUniformBuffer.destroy();
+        compactIndexBuffer.destroy();
+        outputBuffer.destroy();
+        rasterUniformBuffer.destroy();
+        stagingBuffer.destroy();
+
+            return {
+                tileIdx,
+                data: tileResult,
+                gridWidth,
+                gridHeight,
+                minX: tile_min_x,
+                maxX: tile_max_x
+            };
+        } catch (error) {
+            debug.error(`Error processing tile ${tileIdx + 1}/${numTiles}:`, error);
+            throw new Error(`Tile ${tileIdx + 1} failed: ${error.message}`);
+        }
+    }
+
+    // Process tiles with rolling window to maintain constant concurrency
+    // This keeps GPU busy while preventing browser from allocating too many buffers at once
+    const maxConcurrentTiles = params.maxConcurrentTiles ?? 50;
+    debug.log(`Processing ${numTiles} tiles (max ${maxConcurrentTiles} concurrent)...`);
+
+    let completedTiles = 0;
+    let nextTileIdx = 0;
+    const activeTiles = new Map(); // promise -> tileIdx
+    const tileResults = new Array(numTiles);
+
+    // Helper to start a tile and track it
+    const startTile = (tileIdx) => {
+        const promise = processTile(tileIdx).then(result => {
+            completedTiles++;
+            const percent = Math.round((completedTiles / numTiles) * 100);
+
+            // Report progress
+            self.postMessage({
+                type: 'rasterize-progress',
+                data: {
+                    percent,
+                    current: completedTiles,
+                    total: numTiles
+                }
+            });
+
+            tileResults[tileIdx] = result;
+            activeTiles.delete(promise);
+            return result;
+        });
+        activeTiles.set(promise, tileIdx);
+        return promise;
+    };
+
+    // Start initial window of tiles
+    while (nextTileIdx < numTiles && activeTiles.size < maxConcurrentTiles) {
+        startTile(nextTileIdx++);
+    }
+
+    // As tiles complete, start new ones to maintain window size
+    while (activeTiles.size > 0) {
+        // Wait for at least one tile to complete
+        await Promise.race(activeTiles.keys());
+
+        // Start as many new tiles as needed to fill window
+        while (nextTileIdx < numTiles && activeTiles.size < maxConcurrentTiles) {
+            startTile(nextTileIdx++);
+        }
+    }
+
+    triangleBuffer.destroy();
+
+    const totalTime = performance.now() - startTime;
+    debug.log(`Radial complete in ${totalTime.toFixed(1)}ms`);
+
+    // Stitch tiles together into a single dense array
+    const fullGridHeight = Math.ceil(360 / rotationStepDegrees) + 1; // Number of angular samples
+    const fullGridWidth = Math.ceil(xRange / stepSize) + 1;
+    const stitchedData = new Float32Array(fullGridWidth * fullGridHeight);
+    stitchedData.fill(EMPTY_CELL);
+
+    for (const tile of tileResults) {
+        const tileXOffset = Math.round((tile.minX - bounds.min.x) / stepSize);
+
+        for (let ty = 0; ty < tile.gridHeight; ty++) {
+            for (let tx = 0; tx < tile.gridWidth; tx++) {
+                const tileIdx = ty * tile.gridWidth + tx;
+                const fullX = tileXOffset + tx;
+                const fullY = ty;
+
+                if (fullX >= 0 && fullX < fullGridWidth && fullY >= 0 && fullY < fullGridHeight) {
+                    const fullIdx = fullY * fullGridWidth + fullX;
+                    stitchedData[fullIdx] = tile.data[tileIdx];
+                }
+            }
+        }
+    }
+
+    // For toolpath generation, bounds.max.y must match the actual grid dimensions
+    // so that createHeightMapFromPoints calculates the correct height:
+    // height = ceil((max.y - min.y) / stepSize) + 1 = gridHeight
+    // Therefore: max.y = (gridHeight - 1) * stepSize
+    const boundsMaxY = (fullGridHeight - 1) * stepSize;
+
+    return {
+        positions: stitchedData,
+        pointCount: stitchedData.length,
+        bounds: {
+            min: { x: bounds.min.x, y: 0, z: 0 },
+            max: { x: bounds.max.x, y: boundsMaxY, z: maxRadius }
+        },
+        conversionTime: totalTime,
+        gridWidth: fullGridWidth,
+        gridHeight: fullGridHeight,
+        isDense: true,
+        maxRadius,
+        circumference,
+        rotationStepDegrees  // NEW: needed for wrapping and toolpath generation
+    };
+}
+
+// Radial V2: Rasterize model with rotating ray planes and X-bucketing
+async function radialRasterizeV2(triangles, bucketData, resolution, angleStep, numAngles, maxRadius, toolWidth, zFloor, bounds, startAngle = 0) {
+    if (!device) {
+        throw new Error('WebGPU not initialized');
+    }
+
+    const timings = {
+        start: performance.now(),
+        prep: 0,
+        gpu: 0,
+        stitch: 0
+    };
+
+    // Calculate grid dimensions based on BUCKET range (not model bounds)
+    // Buckets may extend slightly beyond model bounds due to rounding
+    const bucketMinX = bucketData.buckets[0].minX;
+    const bucketMaxX = bucketData.buckets[bucketData.numBuckets - 1].maxX;
+    const gridWidth = Math.ceil((bucketMaxX - bucketMinX) / resolution);
+    const gridYHeight = Math.ceil(toolWidth / resolution);
+    const bucketGridWidth = Math.ceil((bucketData.buckets[0].maxX - bucketData.buckets[0].minX) / resolution);
+
+    // Calculate workgroup load distribution for timeout analysis
+    const bucketTriangleCounts = bucketData.buckets.map(b => b.count);
+    const minTriangles = Math.min(...bucketTriangleCounts);
+    const maxTriangles = Math.max(...bucketTriangleCounts);
+    const avgTriangles = bucketTriangleCounts.reduce((a, b) => a + b, 0) / bucketTriangleCounts.length;
+    const workPerWorkgroup = maxTriangles * numAngles * bucketGridWidth * gridYHeight;
+
+    debug.log(`[Worker] Radial V2: ${gridWidth}x${gridYHeight} grid, ${numAngles} angles, ${bucketData.buckets.length} buckets`);
+    debug.log(`[Worker] Load: min=${minTriangles} max=${maxTriangles} avg=${avgTriangles.toFixed(0)} (${(maxTriangles/avgTriangles).toFixed(2)}x imbalance, worst=${(workPerWorkgroup/1e6).toFixed(1)}M tests)`);
+
+    // Create GPU buffers
+    const triangleBuffer = device.createBuffer({
+        size: triangles.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+    new Float32Array(triangleBuffer.getMappedRange()).set(triangles);
+    triangleBuffer.unmap();
+
+    // Create bucket info buffer (f32, f32, u32, u32 per bucket)
+    const bucketInfoSize = bucketData.buckets.length * 16; // 4 fields * 4 bytes
+    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 < bucketData.buckets.length; i++) {
+        const bucket = bucketData.buckets[i];
+        const offset = i * 4;
+        bucketFloatView[offset] = bucket.minX;           // f32
+        bucketFloatView[offset + 1] = bucket.maxX;       // f32
+        bucketUintView[offset + 2] = bucket.startIndex;  // u32
+        bucketUintView[offset + 3] = bucket.count;       // u32
+    }
+
+    new Uint8Array(bucketInfoBuffer.getMappedRange()).set(new Uint8Array(bucketView));
+    bucketInfoBuffer.unmap();
+
+    // Create triangle indices buffer
+    const triangleIndicesBuffer = device.createBuffer({
+        size: bucketData.triangleIndices.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+    new Uint32Array(triangleIndicesBuffer.getMappedRange()).set(bucketData.triangleIndices);
+    triangleIndicesBuffer.unmap();
+
+    // Create output buffer (all angles, all buckets)
+    const outputSize = numAngles * bucketData.numBuckets * bucketGridWidth * gridYHeight * 4;
+    const outputBuffer = device.createBuffer({
+        size: outputSize,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    });
+
+    // CRITICAL: Initialize output buffer with zFloor to avoid reading garbage data
+    // Use mappedAtCreation for deterministic initialization (not writeBuffer!)
+    const initEncoder = device.createCommandEncoder();
+    const initData = new Float32Array(outputSize / 4);
+    initData.fill(zFloor);
+    device.queue.writeBuffer(outputBuffer, 0, initData);
+    // Force initialization to complete
+    device.queue.submit([initEncoder.finish()]);
+    await device.queue.onSubmittedWorkDone();
+
+    // Create uniforms with proper alignment (f32 and u32 mixed)
+    // Struct layout: f32, f32, u32, f32, f32, u32, f32, u32, f32, f32, u32, u32, f32
+    const uniformBuffer = device.createBuffer({
+        size: 52,  // 13 fields * 4 bytes
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: true
+    });
+
+    const uniformView = new ArrayBuffer(52);
+    const floatView = new Float32Array(uniformView);
+    const uintView = new Uint32Array(uniformView);
+
+    floatView[0] = resolution;                                          // f32
+    floatView[1] = angleStep * (Math.PI / 180);                        // f32
+    uintView[2] = numAngles;                                            // u32
+    floatView[3] = maxRadius;                                           // f32
+    floatView[4] = toolWidth;                                           // f32
+    uintView[5] = gridYHeight;                                          // u32
+    floatView[6] = bucketData.buckets[0].maxX - bucketData.buckets[0].minX;  // f32 bucketWidth
+    uintView[7] = bucketGridWidth;                                      // u32
+    floatView[8] = bucketMinX;                                          // f32 global_min_x (use bucket range)
+    floatView[9] = zFloor;                                              // f32
+    uintView[10] = 0;                                                   // u32 filterMode
+    uintView[11] = bucketData.numBuckets;                               // u32
+    floatView[12] = startAngle * (Math.PI / 180);                       // f32 start_angle (radians)
+
+    new Uint8Array(uniformBuffer.getMappedRange()).set(new Uint8Array(uniformView));
+    uniformBuffer.unmap();
+
+    // Create shader and pipeline
+    const shaderModule = device.createShaderModule({ code: radialRasterizeV2ShaderCode });
+    const pipeline = device.createComputePipeline({
+        layout: 'auto',
+        compute: {
+            module: shaderModule,
+            entryPoint: 'main'
+        }
+    });
+
+    // Create bind group
+    const bindGroup = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: triangleBuffer } },
+            { binding: 1, resource: { buffer: outputBuffer } },
+            { binding: 2, resource: { buffer: uniformBuffer } },
+            { binding: 3, resource: { buffer: bucketInfoBuffer } },
+            { binding: 4, resource: { buffer: triangleIndicesBuffer } }
+        ]
+    });
+
+    console.time('RADIAL COMPUTE');
+    // Dispatch
+    const commandEncoder = device.createCommandEncoder();
+    const passEncoder = commandEncoder.beginComputePass();
+    passEncoder.setPipeline(pipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+
+    // Prep complete, GPU starting
+    timings.prep = performance.now() - timings.start;
+    const gpuStart = performance.now();
+
+    // Dispatch: (numAngles/8, gridYHeight/8, numBuckets)
+    const dispatchX = Math.ceil(numAngles / 8);
+    const dispatchY = Math.ceil(gridYHeight / 8);
+    const dispatchZ = bucketData.numBuckets;
+    debug.log(`[Worker] Dispatch: (${dispatchX}, ${dispatchY}, ${dispatchZ}) = ${dispatchX * 8} angles, ${dispatchY * 8} Y cells, ${dispatchZ} buckets`);
+
+    passEncoder.dispatchWorkgroups(dispatchX, dispatchY, dispatchZ);
+    passEncoder.end();
+
+    // Read back
+    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()]);
+
+    // CRITICAL: Wait for GPU to finish before reading results
+    await device.queue.onSubmittedWorkDone();
+    console.timeEnd('RADIAL COMPUTE');
+
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+    const outputData = new Float32Array(stagingBuffer.getMappedRange());
+    const outputCopy = new Float32Array(outputData);
+    stagingBuffer.unmap();
+
+    // Cleanup
+    triangleBuffer.destroy();
+    bucketInfoBuffer.destroy();
+    triangleIndicesBuffer.destroy();
+    outputBuffer.destroy();
+    uniformBuffer.destroy();
+    stagingBuffer.destroy();
+
+    timings.gpu = performance.now() - gpuStart;
+
+    // Stitch strips
+    const stitchStart = performance.now();
+    const strips = [];
+
+    for (let angleIdx = 0; angleIdx < numAngles; angleIdx++) {
+        const stripData = new Float32Array(gridWidth * gridYHeight);
+        stripData.fill(zFloor);  // Initialize with zFloor, not zeros!
+
+        // Gather from each bucket
+        for (let bucketIdx = 0; bucketIdx < bucketData.numBuckets; bucketIdx++) {
+            const bucket = bucketData.buckets[bucketIdx];
+            const bucketMinGridX = Math.floor((bucket.minX - bucketMinX) / resolution);
+
+            for (let localX = 0; localX < bucketGridWidth; localX++) {
+                const gridX = bucketMinGridX + localX;
+                if (gridX >= gridWidth) continue;
+
+                for (let gridY = 0; gridY < gridYHeight; gridY++) {
+                    const srcIdx = bucketIdx * numAngles * bucketGridWidth * gridYHeight
+                                 + angleIdx * bucketGridWidth * gridYHeight
+                                 + gridY * bucketGridWidth
+                                 + localX;
+                    const dstIdx = gridY * gridWidth + gridX;
+                    stripData[dstIdx] = outputCopy[srcIdx];
+                }
+            }
+        }
+
+        // Keep as DENSE Z-only format (toolpath generator expects this!)
+        // Count valid points
+        let validCount = 0;
+        for (let i = 0; i < stripData.length; i++) {
+            if (stripData[i] !== zFloor) validCount++;
+        }
+
+        strips.push({
+            angle: startAngle + (angleIdx * angleStep),
+            positions: stripData,  // DENSE Z-only format!
+            gridWidth,
+            gridHeight: gridYHeight,
+            pointCount: validCount,  // Number of non-floor cells
+            bounds: {
+                min: { x: bucketMinX, y: 0, z: zFloor },
+                max: { x: bucketMaxX, y: toolWidth, z: bounds.max.z }
+            }
+        });
+    }
+
+    timings.stitch = performance.now() - stitchStart;
+    const totalTime = performance.now() - timings.start;
+
+    debug.log(`[Worker] Radial V2 complete: ${totalTime.toFixed(0)}ms`);
+    debug.log(`[Worker]   Prep: ${timings.prep.toFixed(0)}ms (${(timings.prep/totalTime*100).toFixed(0)}%)`);
+    debug.log(`[Worker]   GPU:  ${timings.gpu.toFixed(0)}ms (${(timings.gpu/totalTime*100).toFixed(0)}%)`);
+    debug.log(`[Worker]   Stitch: ${timings.stitch.toFixed(0)}ms (${(timings.stitch/totalTime*100).toFixed(0)}%)`);
+
+    return { strips, timings };
+}
+
+// Handle messages from main thread
+self.onmessage = async function(e) {
+    const { type, data } = e.data;
+
+    try {
+        switch (type) {
+            case 'init':
+                // Store config
+                config = data?.config || {
+                    maxGPUMemoryMB: 256,
+                    gpuMemorySafetyMargin: 0.8,
+                    tileOverlapMM: 10,
+                    autoTiling: true,
+                    minTileSize: 50
+                };
+                const success = await initWebGPU();
+                self.postMessage({
+                    type: 'webgpu-ready',
+                    data: {
+                        success,
+                        capabilities: deviceCapabilities
+                    }
+                });
+                break;
+
+            case 'update-config':
+                config = data.config;
+                debug.log('Config updated:', config);
+                break;
+
+            case 'rasterize':
+                const { triangles, stepSize, filterMode, boundsOverride } = data;
+                const rasterOptions = boundsOverride || {};
+                const rasterResult = await rasterizeMesh(triangles, stepSize, filterMode, rasterOptions);
+                self.postMessage({
+                    type: 'rasterize-complete',
+                    data: rasterResult,
+                }, [rasterResult.positions.buffer]);
+                break;
+
+            case 'generate-toolpath':
+                const { terrainPositions, toolPositions, xStep, yStep, zFloor, gridStep, terrainBounds, singleScanline } = data;
+                const toolpathResult = await generateToolpath(
+                    terrainPositions, toolPositions, xStep, yStep, zFloor, gridStep, terrainBounds, singleScanline
+                );
+                self.postMessage({
+                    type: 'toolpath-complete',
+                    data: toolpathResult
+                }, [toolpathResult.pathData.buffer]);
+                break;
+
+            case 'radial-rasterize':
+                const { triangles: radialTriangles, stepSize: radialStep, rotationStep: radialRotationStep, zFloor: radialZFloor = 0, boundsOverride: radialBounds, maxConcurrentTiles, trianglesPerTile, radialRotationOffset } = data;
+                const radialResult = await radialRasterize(radialTriangles, radialStep, radialRotationStep, radialZFloor, radialBounds, { maxConcurrentTiles, trianglesPerTile, radialRotationOffset });
+                self.postMessage({
+                    type: 'radial-rasterize-complete',
+                    data: radialResult
+                }, [radialResult.positions.buffer]);
+                break;
+
+            case 'radial-generate-toolpaths':
+                // Complete radial pipeline: rasterize model + generate toolpaths for all strips
+                const {
+                    triangles: radialModelTriangles,
+                    bucketData: radialBucketData,
+                    toolData: radialToolData,
+                    resolution: radialResolution,
+                    angleStep: radialAngleStep,
+                    numAngles: radialNumAngles,
+                    maxRadius: radialMaxRadius,
+                    toolWidth: radialToolWidth,
+                    zFloor: radialToolpathZFloor,
+                    bounds: radialToolpathBounds,
+                    xStep: radialXStep,
+                    yStep: radialYStep,
+                    gridStep: radialGridStep
+                } = data;
+
+                debug.log('[Worker] Starting complete radial toolpath pipeline...');
+
+                // Batch processing: rasterize angle ranges to avoid memory allocation failure
+                const ANGLES_PER_BATCH = 360;  // Process 360 angles at a time
+                const numBatches = Math.ceil(radialNumAngles / ANGLES_PER_BATCH);
+
+                debug.log(`[Worker] Processing ${radialNumAngles} angles in ${numBatches} batch(es) of up to ${ANGLES_PER_BATCH} angles`);
+
+                const allStripToolpaths = [];
+                let totalToolpathPoints = 0;
+                const pipelineStartTime = performance.now();
+
+                // Prepare sparse tool once
+                const sparseToolData = createSparseToolFromPoints(radialToolData.positions);
+                debug.log(`[Worker] Created sparse tool: ${sparseToolData.count} points (reusing for all strips)`);
+
+                for (let batchIdx = 0; batchIdx < numBatches; batchIdx++) {
+                    const startAngleIdx = batchIdx * ANGLES_PER_BATCH;
+                    const endAngleIdx = Math.min(startAngleIdx + ANGLES_PER_BATCH, radialNumAngles);
+                    const batchNumAngles = endAngleIdx - startAngleIdx;
+                    const batchStartAngle = startAngleIdx * radialAngleStep;
+
+                    debug.log(`[Worker] Batch ${batchIdx + 1}/${numBatches}: angles ${startAngleIdx}-${endAngleIdx - 1} (${batchNumAngles} angles), startAngle=${batchStartAngle.toFixed(1)}°`);
+
+                    // Rasterize this batch of strips
+                    const batchModelResult = await radialRasterizeV2(
+                        radialModelTriangles,
+                        radialBucketData,
+                        radialResolution,
+                        radialAngleStep,
+                        batchNumAngles,
+                        radialMaxRadius,
+                        radialToolWidth,
+                        radialToolpathZFloor,
+                        radialToolpathBounds,
+                        batchStartAngle  // Start angle for this batch
+                    );
+
+                    debug.log(`[Worker] Batch ${batchIdx + 1}: Rasterized ${batchModelResult.strips.length} strips, first angle=${batchModelResult.strips[0]?.angle.toFixed(1)}°, last angle=${batchModelResult.strips[batchModelResult.strips.length - 1]?.angle.toFixed(1)}°`);
+
+                    // Find max dimensions for this batch
+                    let maxStripWidth = 0;
+                    let maxStripHeight = 0;
+                    for (const strip of batchModelResult.strips) {
+                        maxStripWidth = Math.max(maxStripWidth, strip.gridWidth);
+                        maxStripHeight = Math.max(maxStripHeight, strip.gridHeight);
+                    }
+
+                    // Create reusable buffers for this batch
+                    const reusableBuffers = createReusableToolpathBuffers(maxStripWidth, maxStripHeight, sparseToolData, radialXStep, maxStripHeight);
+
+                    // Generate toolpaths for this batch
+                    debug.log(`[Worker] Batch ${batchIdx + 1}: Generating toolpaths for ${batchModelResult.strips.length} strips...`);
+                    for (let i = 0; i < batchModelResult.strips.length; i++) {
+                        const strip = batchModelResult.strips[i];
+                        const globalStripIdx = startAngleIdx + i;
+
+                        if (globalStripIdx % 10 === 0 || globalStripIdx === radialNumAngles - 1) {
+                            self.postMessage({
+                                type: 'toolpath-progress',
+                                data: {
+                                    percent: Math.round(((globalStripIdx + 1) / radialNumAngles) * 100),
+                                    current: globalStripIdx + 1,
+                                    total: radialNumAngles,
+                                    layer: globalStripIdx + 1
+                                }
+                            });
+                        }
+
+                        if (!strip.positions || strip.positions.length === 0) continue;
+
+                        // DEBUG: Diagnostic logging (BUILD_ID gets injected during build)
+                        // Used to trace data flow through radial toolpath pipeline
+                        if (globalStripIdx === 0 || globalStripIdx === 360) {
+                            debug.log(`[Worker] BUILD_ID_PLACEHOLDER | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}°) INPUT terrain first 5 Z values: ${strip.positions.slice(0, 5).map(v => v.toFixed(3)).join(',')}`);
+                        }
+
+                        const stripToolpathResult = await runToolpathComputeWithBuffers(
+                            strip.positions,
+                            strip.gridWidth,
+                            strip.gridHeight,
+                            radialXStep,
+                            strip.gridHeight,
+                            radialToolpathZFloor,
+                            reusableBuffers,
+                            pipelineStartTime
+                        );
+
+                        // DEBUG: Verify toolpath generation output
+                        if (globalStripIdx === 0 || globalStripIdx === 360) {
+                            debug.log(`[Worker] BUILD_ID_PLACEHOLDER | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}°) OUTPUT toolpath first 5 Z values: ${stripToolpathResult.pathData.slice(0, 5).map(v => v.toFixed(3)).join(',')}`);
+                        }
+
+                        allStripToolpaths.push({
+                            angle: strip.angle,
+                            pathData: stripToolpathResult.pathData,
+                            numScanlines: stripToolpathResult.numScanlines,
+                            pointsPerLine: stripToolpathResult.pointsPerLine,
+                            terrainBounds: strip.bounds  // Include terrain bounds for display
+                        });
+
+                        totalToolpathPoints += stripToolpathResult.pathData.length;
+                    }
+
+                    destroyReusableToolpathBuffers(reusableBuffers);
+
+                    debug.log(`[Worker] Batch ${batchIdx + 1}: Completed, allStripToolpaths now has ${allStripToolpaths.length} strips total`);
+
+                    // Free batch terrain data
+                    for (const strip of batchModelResult.strips) {
+                        strip.positions = null;
+                    }
+                }
+
+                const pipelineTotalTime = performance.now() - pipelineStartTime;
+                debug.log(`[Worker] Complete radial toolpath: ${allStripToolpaths.length} strips, ${totalToolpathPoints} total points in ${pipelineTotalTime.toFixed(0)}ms`);
+
+                const toolpathTransferBuffers = allStripToolpaths.map(strip => strip.pathData.buffer);
+
+                self.postMessage({
+                    type: 'radial-toolpaths-complete',
+                    data: {
+                        strips: allStripToolpaths,
+                        totalPoints: totalToolpathPoints,
+                        numStrips: allStripToolpaths.length
+                    }
+                }, toolpathTransferBuffers);
+                break;
+
+            default:
+                self.postMessage({
+                    type: 'error',
+                    message: 'Unknown message type: ' + type
+                });
+        }
+    } catch (error) {
+        debug.error('Error:', error);
+        self.postMessage({
+            type: 'error',
+            message: error.message,
+            stack: error.stack
+        });
+    }
+};