@gridspace/raster-path 1.0.2 → 1.0.3

package/build/webgpu-worker.js

@@ -2939,7 +2939,7 @@ self.onmessage = async function(e) {
                         // 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] 4XFJ410L | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}°) INPUT terrain first 5 Z values: ${strip.positions.slice(0, 5).map(v => v.toFixed(3)).join(',')}`);
+                            debug.log(`[Worker] 9P5WQ2V3 | 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(
@@ -2955,7 +2955,7 @@ self.onmessage = async function(e) {
 
                         // DEBUG: Verify toolpath generation output
                         if (globalStripIdx === 0 || globalStripIdx === 360) {
-                            debug.log(`[Worker] 4XFJ410L | Strip ${globalStripIdx} (${strip.angle.toFixed(1)}°) OUTPUT toolpath first 5 Z values: ${stripToolpathResult.pathData.slice(0, 5).map(v => v.toFixed(3)).join(',')}`);
+                            debug.log(`[Worker] 9P5WQ2V3 | 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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gridspace/raster-path",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "private": false,
   "description": "Terrain and Tool Raster Path Finder using WebGPU",
   "type": "module",
@@ -11,8 +11,7 @@
   },
   "files": [
     "build/**/*",
-    "src/**/*.js",
-    "src/**/*.wgsl",
+    "src/**/*",
     "scripts/**/*",
     "README.md",
     "LICENSE"

package/src/etc/serve.json

@@ -0,0 +1,12 @@
+{
+  "headers": [
+    {
+      "source": "**/*",
+      "headers": [
+        { "key": "Cache-Control", "value": "no-store, no-cache, must-revalidate, proxy-revalidate" },
+        { "key": "Pragma",       "value": "no-cache" },
+        { "key": "Expires",      "value": "0" }
+      ]
+    }
+  ]
+}

package/src/test/planar-test.cjs

@@ -0,0 +1,253 @@
+// planar-test.cjs
+// Regression test for planar mode using new RasterPath API
+// Tests: loadTool() + loadTerrain() + generateToolpaths()
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '../../test-output');
+const BASELINE_FILE = path.join(OUTPUT_DIR, 'planar-baseline.json');
+const CURRENT_FILE = path.join(OUTPUT_DIR, 'planar-current.json');
+
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== Planar Mode Regression Test ===');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+                console.log('✓ WebGPU available');
+
+                // Import RasterPath
+                const { RasterPath } = await import('./raster-path.js');
+
+                // Load STL files
+                console.log('\\nLoading STL files...');
+                const terrainResponse = await fetch('../benchmark/fixtures/terrain.stl');
+                const terrainBuffer = await terrainResponse.arrayBuffer();
+
+                const toolResponse = await fetch('../benchmark/fixtures/tool.stl');
+                const toolBuffer = await toolResponse.arrayBuffer();
+
+                console.log('✓ Loaded terrain.stl:', terrainBuffer.byteLength, 'bytes');
+                console.log('✓ Loaded tool.stl:', toolBuffer.byteLength, 'bytes');
+
+                // Parse STL files
+                function parseBinarySTL(buffer) {
+                    const dataView = new DataView(buffer);
+                    const numTriangles = dataView.getUint32(80, true);
+                    const positions = new Float32Array(numTriangles * 9);
+                    let offset = 84;
+
+                    for (let i = 0; i < numTriangles; i++) {
+                        offset += 12; // Skip normal
+                        for (let j = 0; j < 9; j++) {
+                            positions[i * 9 + j] = dataView.getFloat32(offset, true);
+                            offset += 4;
+                        }
+                        offset += 2; // Skip attribute byte count
+                    }
+                    return positions;
+                }
+
+                const terrainTriangles = parseBinarySTL(terrainBuffer);
+                const toolTriangles = parseBinarySTL(toolBuffer);
+                console.log('✓ Parsed terrain:', terrainTriangles.length / 9, 'triangles');
+                console.log('✓ Parsed tool:', toolTriangles.length / 9, 'triangles');
+
+                // Test parameters
+                const resolution = 0.05; // 0.05mm high resolution
+                const xStep = 1;
+                const yStep = 1;
+                const zFloor = -100;
+
+                console.log('\\nTest parameters:');
+                console.log('  Resolution:', resolution, 'mm');
+                console.log('  XY step:', xStep + 'x' + yStep, 'points');
+                console.log('  Z floor:', zFloor, 'mm');
+
+                // Create RasterPath instance for planar mode
+                console.log('\\nInitializing RasterPath (planar mode)...');
+                const raster = new RasterPath({
+                    mode: 'planar',
+                    resolution: resolution
+                });
+                await raster.init();
+                console.log('✓ RasterPath initialized');
+
+                // Load tool (NEW API)
+                console.log('\\n1. Loading tool...');
+                const t0 = performance.now();
+                const toolData = await raster.loadTool({
+                    triangles: toolTriangles
+                });
+                const toolTime = performance.now() - t0;
+                console.log('✓ Tool:', toolData.pointCount, 'points in', toolTime.toFixed(1), 'ms');
+
+                // Load terrain (NEW API)
+                console.log('\\n2. Loading terrain...');
+                const t1 = performance.now();
+                const terrainData = await raster.loadTerrain({
+                    triangles: terrainTriangles,
+                    zFloor: zFloor
+                });
+                const terrainTime = performance.now() - t1;
+                console.log('✓ Terrain:', terrainData.pointCount, 'points in', terrainTime.toFixed(1), 'ms');
+
+                // Generate toolpaths (NEW API - no need to pass terrainData/toolData)
+                console.log('\\n3. Generating toolpaths...');
+                const t2 = performance.now();
+                const toolpathData = await raster.generateToolpaths({
+                    xStep: xStep,
+                    yStep: yStep,
+                    zFloor: zFloor
+                });
+                const toolpathTime = performance.now() - t2;
+                console.log('✓ Toolpath:', toolpathData.numScanlines + 'x' + toolpathData.pointsPerLine, '=', toolpathData.pathData.length, 'Z-values');
+                console.log('  Generation time:', toolpathTime.toFixed(1), 'ms');
+
+                // Cleanup
+                raster.terminate();
+
+                // Calculate checksum for regression detection
+                let checksum = 0;
+                for (let i = 0; i < toolpathData.pathData.length; i++) {
+                    checksum = (checksum + toolpathData.pathData[i] * (i + 1)) | 0;
+                }
+
+                // Sample first 30 Z-values for debugging
+                const sampleSize = Math.min(30, toolpathData.pathData.length);
+                const sampleValues = [];
+                for (let i = 0; i < sampleSize; i++) {
+                    sampleValues.push(toolpathData.pathData[i].toFixed(2));
+                }
+
+                return {
+                    success: true,
+                    output: {
+                        parameters: {
+                            mode: 'planar',
+                            resolution: resolution,
+                            xStep,
+                            yStep,
+                            zFloor,
+                            terrainTriangles: terrainTriangles.length / 9,
+                            toolTriangles: toolTriangles.length / 9
+                        },
+                        result: {
+                            terrainPoints: terrainData.pointCount,
+                            toolPoints: toolData.pointCount,
+                            toolpathSize: toolpathData.pathData.length,
+                            numScanlines: toolpathData.numScanlines,
+                            pointsPerLine: toolpathData.pointsPerLine,
+                            checksum: checksum,
+                            sampleValues: sampleValues
+                        },
+                        timing: {
+                            terrain: terrainTime,
+                            tool: toolTime,
+                            toolpath: toolpathTime,
+                            total: terrainTime + toolTime + toolpathTime
+                        }
+                    }
+                };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('❌ Test failed:', result.error);
+                app.exit(1);
+                return;
+            }
+
+            // Save current output
+            const currentData = {
+                parameters: result.output.parameters,
+                result: result.output.result,
+                timing: result.output.timing
+            };
+
+            fs.writeFileSync(CURRENT_FILE, JSON.stringify(currentData, null, 2));
+            console.log('\n✓ Saved current output to', CURRENT_FILE);
+            console.log(`  Toolpath size: ${result.output.result.toolpathSize} Z-values`);
+            console.log(`  Checksum: ${result.output.result.checksum}`);
+            console.log(`  Total time: ${result.output.timing.total.toFixed(1)}ms`);
+
+            // Check if baseline exists
+            if (!fs.existsSync(BASELINE_FILE)) {
+                console.log('\n📝 No baseline found - saving current as baseline');
+                fs.writeFileSync(BASELINE_FILE, JSON.stringify(currentData, null, 2));
+                console.log('✅ Baseline created');
+                app.exit(0);
+                return;
+            }
+
+            // Compare with baseline
+            const baseline = JSON.parse(fs.readFileSync(BASELINE_FILE, 'utf8'));
+
+            console.log('\n=== Comparison ===');
+            console.log('Baseline checksum:', baseline.result.checksum);
+            console.log('Current checksum:', result.output.result.checksum);
+
+            let passed = true;
+
+            if (baseline.result.toolpathSize !== result.output.result.toolpathSize) {
+                console.error('❌ Toolpath size mismatch!');
+                console.error(`  Expected: ${baseline.result.toolpathSize}, Got: ${result.output.result.toolpathSize}`);
+                passed = false;
+            }
+
+            if (baseline.result.checksum !== result.output.result.checksum) {
+                console.error('❌ Checksum mismatch!');
+                console.error(`  Expected: ${baseline.result.checksum}, Got: ${result.output.result.checksum}`);
+                passed = false;
+            } else {
+                console.log('✓ Checksum matches');
+            }
+
+            if (passed) {
+                console.log('\n✅ All checks passed - output matches baseline');
+                app.exit(0);
+            } else {
+                console.log('\n❌ Regression detected - output differs from baseline');
+                console.log('To update baseline: cp', CURRENT_FILE, BASELINE_FILE);
+                app.exit(1);
+            }
+
+        } catch (error) {
+            console.error('Error running test:', error);
+            app.exit(1);
+        }
+    });
+}
+
+app.whenReady().then(createWindow);
+app.on('window-all-closed', () => app.quit());

package/src/test/planar-tiling-test.cjs

@@ -0,0 +1,230 @@
+// planar-tiling-test.cjs
+// Test for planar tiling with very high resolution (0.01mm)
+// This should trigger automatic tiling to avoid GPU memory allocation failures
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '../../test-output');
+const OUTPUT_FILE = path.join(OUTPUT_DIR, 'planar-tiling-test.json');
+
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== Planar Tiling Test (0.01mm resolution) ===');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+                console.log('✓ WebGPU available');
+
+                const { RasterPath } = await import('./raster-path.js');
+
+                console.log('\\nLoading STL files...');
+                const terrainResponse = await fetch('../benchmark/fixtures/terrain.stl');
+                const terrainBuffer = await terrainResponse.arrayBuffer();
+
+                const toolResponse = await fetch('../benchmark/fixtures/tool.stl');
+                const toolBuffer = await toolResponse.arrayBuffer();
+
+                console.log('✓ Loaded terrain.stl:', terrainBuffer.byteLength, 'bytes');
+                console.log('✓ Loaded tool.stl:', toolBuffer.byteLength, 'bytes');
+
+                function parseBinarySTL(buffer) {
+                    const dataView = new DataView(buffer);
+                    const numTriangles = dataView.getUint32(80, true);
+                    const positions = new Float32Array(numTriangles * 9);
+                    let offset = 84;
+
+                    for (let i = 0; i < numTriangles; i++) {
+                        offset += 12;
+                        for (let j = 0; j < 9; j++) {
+                            positions[i * 9 + j] = dataView.getFloat32(offset, true);
+                            offset += 4;
+                        }
+                        offset += 2;
+                    }
+                    return positions;
+                }
+
+                const terrainTriangles = parseBinarySTL(terrainBuffer);
+                const toolTriangles = parseBinarySTL(toolBuffer);
+                console.log('✓ Parsed terrain:', terrainTriangles.length / 9, 'triangles');
+                console.log('✓ Parsed tool:', toolTriangles.length / 9, 'triangles');
+
+                // HIGH RESOLUTION - should trigger tiling
+                const resolution = 0.01;
+                const xStep = 1;
+                const yStep = 1;
+                const zFloor = -100;
+
+                console.log('\\nTest parameters:');
+                console.log('  Resolution:', resolution, 'mm (VERY HIGH - should trigger tiling)');
+                console.log('  XY step:', xStep + 'x' + yStep, 'points');
+                console.log('  Z floor:', zFloor, 'mm');
+
+                // Calculate expected grid size
+                // Terrain is roughly 1000x1000mm, so at 0.01mm = 100,000 x 100,000 grid
+                // = 10 billion points * 4 bytes = 40GB (way over GPU limit!)
+                const terrainSize = 1000; // approximate
+                const expectedGridSize = Math.ceil(terrainSize / resolution);
+                const expectedPoints = expectedGridSize * expectedGridSize;
+                const expectedMemoryMB = (expectedPoints * 4) / (1024 * 1024);
+                console.log('\\nExpected memory usage:');
+                console.log('  Grid size:', expectedGridSize + 'x' + expectedGridSize);
+                console.log('  Total points:', (expectedPoints / 1e6).toFixed(1) + 'M');
+                console.log('  Memory needed:', expectedMemoryMB.toFixed(0) + 'MB');
+                console.log('  GPU limit: ~512MB (should trigger tiling)');
+
+                console.log('\\nInitializing RasterPath (planar mode)...');
+                const raster = new RasterPath({
+                    mode: 'planar',
+                    resolution: resolution
+                });
+                await raster.init();
+                console.log('✓ RasterPath initialized');
+
+                console.log('\\n1. Loading tool (NEW API)...');
+                const t0 = performance.now();
+                const toolData = await raster.loadTool({
+                    triangles: toolTriangles
+                });
+                const toolTime = performance.now() - t0;
+                console.log('✓ Tool:', toolData.pointCount, 'points in', toolTime.toFixed(1), 'ms');
+
+                console.log('\\n2. Loading terrain (NEW API - should use tiling)...');
+                const t1 = performance.now();
+                let terrainData;
+                let terrainTime;
+                try {
+                    terrainData = await raster.loadTerrain({
+                        triangles: terrainTriangles,
+                        zFloor: zFloor
+                    });
+                    terrainTime = performance.now() - t1;
+                    console.log('✓ Terrain:', terrainData.pointCount, 'points in', terrainTime.toFixed(1), 'ms');
+                } catch (error) {
+                    console.error('❌ Terrain loading FAILED:', error.message);
+                    return {
+                        error: 'Terrain loading failed: ' + error.message,
+                        expectedTiling: true,
+                        resolution: resolution
+                    };
+                }
+
+                console.log('\\n3. Generating toolpaths (NEW API)...');
+                const t2 = performance.now();
+                const toolpathData = await raster.generateToolpaths({
+                    xStep: xStep,
+                    yStep: yStep,
+                    zFloor: zFloor
+                });
+                const toolpathTime = performance.now() - t2;
+                console.log('✓ Toolpath:', toolpathData.numScanlines + 'x' + toolpathData.pointsPerLine, '=', toolpathData.pathData.length, 'Z-values');
+                console.log('  Generation time:', toolpathTime.toFixed(1), 'ms');
+
+                raster.terminate();
+
+                // Calculate checksum
+                let checksum = 0;
+                for (let i = 0; i < Math.min(1000, toolpathData.pathData.length); i++) {
+                    checksum = (checksum + toolpathData.pathData[i] * (i + 1)) | 0;
+                }
+
+                return {
+                    success: true,
+                    tilingWorked: true,
+                    output: {
+                        parameters: {
+                            resolution: resolution,
+                            expectedMemoryMB: Math.round(expectedMemoryMB)
+                        },
+                        result: {
+                            terrainPoints: terrainData.pointCount,
+                            toolPoints: toolData.pointCount,
+                            toolpathSize: toolpathData.pathData.length,
+                            checksum: checksum
+                        },
+                        timing: {
+                            terrain: terrainTime,
+                            tool: toolTime,
+                            toolpath: toolpathTime,
+                            total: terrainTime + toolTime + toolpathTime
+                        }
+                    }
+                };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('\n❌ TEST FAILED - Tiling did not work!');
+                console.error('Error:', result.error);
+                console.error('Resolution:', result.resolution);
+                console.error('Expected tiling:', result.expectedTiling);
+
+                fs.writeFileSync(OUTPUT_FILE, JSON.stringify({
+                    failed: true,
+                    error: result.error,
+                    resolution: result.resolution
+                }, null, 2));
+
+                app.exit(1);
+                return;
+            }
+
+            console.log('\n=== Test Complete ===');
+            console.log('✅ Tiling worked correctly!');
+            console.log('Terrain points:', result.output.result.terrainPoints);
+            console.log('Tool points:', result.output.result.toolPoints);
+            console.log('Toolpath size:', result.output.result.toolpathSize);
+            console.log('Total time:', result.output.timing.total.toFixed(1), 'ms');
+
+            fs.writeFileSync(OUTPUT_FILE, JSON.stringify(result.output, null, 2));
+            console.log('\n✓ Results written to:', OUTPUT_FILE);
+
+            app.exit(0);
+        } catch (error) {
+            console.error('❌ Test execution error:', error);
+            app.exit(1);
+        }
+    });
+
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        if (message.includes('[Raster') || message.includes('[Worker') || message.includes('Tiling')) {
+            console.log('[Browser]', message);
+        }
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    app.quit();
+});

package/src/test/radial-test.cjs

@@ -0,0 +1,269 @@
+// radial-test.cjs
+// Regression test for radial mode using new RasterPath API
+// Tests: loadTool() + loadTerrain() + generateToolpaths() with radial projection
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '../../test-output');
+const BASELINE_FILE = path.join(OUTPUT_DIR, 'radial-baseline.json');
+const CURRENT_FILE = path.join(OUTPUT_DIR, 'radial-current.json');
+
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== Radial Mode Regression Test ===');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+                console.log('✓ WebGPU available');
+
+                // Import RasterPath
+                const { RasterPath } = await import('./raster-path.js');
+
+                // Load STL files
+                console.log('\\nLoading STL files...');
+                const terrainResponse = await fetch('../benchmark/fixtures/terrain.stl');
+                const terrainBuffer = await terrainResponse.arrayBuffer();
+
+                const toolResponse = await fetch('../benchmark/fixtures/tool.stl');
+                const toolBuffer = await toolResponse.arrayBuffer();
+
+                console.log('✓ Loaded terrain.stl:', terrainBuffer.byteLength, 'bytes');
+                console.log('✓ Loaded tool.stl:', toolBuffer.byteLength, 'bytes');
+
+                // Parse STL files
+                function parseBinarySTL(buffer) {
+                    const dataView = new DataView(buffer);
+                    const numTriangles = dataView.getUint32(80, true);
+                    const positions = new Float32Array(numTriangles * 9);
+                    let offset = 84;
+
+                    for (let i = 0; i < numTriangles; i++) {
+                        offset += 12; // Skip normal
+                        for (let j = 0; j < 9; j++) {
+                            positions[i * 9 + j] = dataView.getFloat32(offset, true);
+                            offset += 4;
+                        }
+                        offset += 2; // Skip attribute byte count
+                    }
+                    return positions;
+                }
+
+                const terrainTriangles = parseBinarySTL(terrainBuffer);
+                const toolTriangles = parseBinarySTL(toolBuffer);
+                console.log('✓ Parsed terrain:', terrainTriangles.length / 9, 'triangles');
+                console.log('✓ Parsed tool:', toolTriangles.length / 9, 'triangles');
+
+                // Test parameters
+                const resolution = 0.1; // 0.1mm for radial (coarser than planar)
+                const rotationStep = 1.0; // 1 degree between rays
+                const xStep = 5; // Sample every 5th point
+                const yStep = 5;
+                const zFloor = 0;
+                const radiusOffset = 20; // Tool offset above terrain surface
+
+                console.log('\\nTest parameters:');
+                console.log('  Resolution:', resolution, 'mm');
+                console.log('  Rotation step:', rotationStep, '°');
+                console.log('  XY step:', xStep + 'x' + yStep, 'points');
+                console.log('  Z floor:', zFloor, 'mm');
+                console.log('  Radius offset:', radiusOffset, 'mm');
+
+                // Create RasterPath instance for radial mode
+                console.log('\\nInitializing RasterPath (radial mode)...');
+                const raster = new RasterPath({
+                    mode: 'radial',
+                    resolution: resolution,
+                    rotationStep: rotationStep
+                });
+                await raster.init();
+                console.log('✓ RasterPath initialized');
+
+                // Load tool (NEW API)
+                console.log('\\n1. Loading tool (NEW API)...');
+                const t0 = performance.now();
+                const toolData = await raster.loadTool({
+                    triangles: toolTriangles
+                });
+                const toolTime = performance.now() - t0;
+                console.log('✓ Tool:', toolData.pointCount, 'points in', toolTime.toFixed(1), 'ms');
+
+                // Load terrain (NEW API - stores triangles for later)
+                console.log('\\n2. Loading terrain (NEW API - radial mode)...');
+                const t1 = performance.now();
+                await raster.loadTerrain({
+                    triangles: terrainTriangles,
+                    zFloor: zFloor
+                });
+                const terrainTime = performance.now() - t1;
+                console.log('✓ Terrain loaded (triangles stored, will rasterize during toolpath generation)');
+                console.log('  Time:', terrainTime.toFixed(1), 'ms');
+
+                // Generate toolpaths (NEW API - does rasterization + toolpath generation)
+                console.log('\\n3. Generating toolpaths (NEW API - radial)...');
+                const t2 = performance.now();
+                const toolpathData = await raster.generateToolpaths({
+                    xStep: xStep,
+                    yStep: yStep,
+                    zFloor: zFloor,
+                    radiusOffset: radiusOffset
+                });
+                const toolpathTime = performance.now() - t2;
+                console.log('✓ Toolpath generated');
+                console.log('  Strips:', toolpathData.numStrips);
+                console.log('  Total points:', toolpathData.totalPoints);
+                console.log('  Generation time:', toolpathTime.toFixed(1), 'ms');
+
+                // Cleanup
+                raster.terminate();
+
+                // Calculate checksum for regression detection (NEW API - radial mode uses strips)
+                let checksum = 0;
+                let totalValues = 0;
+                for (const strip of toolpathData.strips) {
+                    for (let i = 0; i < strip.pathData.length; i++) {
+                        checksum = (checksum + strip.pathData[i] * (totalValues + i + 1)) | 0;
+                    }
+                    totalValues += strip.pathData.length;
+                }
+
+                // Sample first 30 Z-values for debugging (from first strip)
+                const firstStrip = toolpathData.strips[0];
+                const sampleSize = Math.min(30, firstStrip ? firstStrip.pathData.length : 0);
+                const sampleValues = [];
+                if (firstStrip) {
+                    for (let i = 0; i < sampleSize; i++) {
+                        sampleValues.push(firstStrip.pathData[i].toFixed(2));
+                    }
+                }
+
+                return {
+                    success: true,
+                    output: {
+                        parameters: {
+                            mode: 'radial',
+                            resolution: resolution,
+                            rotationStep: rotationStep,
+                            xStep,
+                            yStep,
+                            zFloor,
+                            radiusOffset,
+                            terrainTriangles: terrainTriangles.length / 9,
+                            toolTriangles: toolTriangles.length / 9
+                        },
+                        result: {
+                            toolPoints: toolData.pointCount,
+                            numStrips: toolpathData.numStrips,
+                            totalPoints: toolpathData.totalPoints,
+                            checksum: checksum,
+                            sampleValues: sampleValues
+                        },
+                        timing: {
+                            terrain: terrainTime,
+                            tool: toolTime,
+                            toolpath: toolpathTime,
+                            total: terrainTime + toolTime + toolpathTime
+                        }
+                    }
+                };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('❌ Test failed:', result.error);
+                app.exit(1);
+                return;
+            }
+
+            // Save current output
+            const currentData = {
+                parameters: result.output.parameters,
+                result: result.output.result,
+                timing: result.output.timing
+            };
+
+            fs.writeFileSync(CURRENT_FILE, JSON.stringify(currentData, null, 2));
+            console.log('\n✓ Saved current output to', CURRENT_FILE);
+            console.log(`  Toolpath size: ${result.output.result.toolpathSize} Z-values`);
+            console.log(`  Checksum: ${result.output.result.checksum}`);
+            console.log(`  Total time: ${result.output.timing.total.toFixed(1)}ms`);
+
+            // Check if baseline exists
+            if (!fs.existsSync(BASELINE_FILE)) {
+                console.log('\n📝 No baseline found - saving current as baseline');
+                fs.writeFileSync(BASELINE_FILE, JSON.stringify(currentData, null, 2));
+                console.log('✅ Baseline created');
+                app.exit(0);
+                return;
+            }
+
+            // Compare with baseline
+            const baseline = JSON.parse(fs.readFileSync(BASELINE_FILE, 'utf8'));
+
+            console.log('\n=== Comparison ===');
+            console.log('Baseline checksum:', baseline.result.checksum);
+            console.log('Current checksum:', result.output.result.checksum);
+
+            let passed = true;
+
+            if (baseline.result.toolpathSize !== result.output.result.toolpathSize) {
+                console.error('❌ Toolpath size mismatch!');
+                console.error(`  Expected: ${baseline.result.toolpathSize}, Got: ${result.output.result.toolpathSize}`);
+                passed = false;
+            }
+
+            if (baseline.result.checksum !== result.output.result.checksum) {
+                console.error('❌ Checksum mismatch!');
+                console.error(`  Expected: ${baseline.result.checksum}, Got: ${result.output.result.checksum}`);
+                passed = false;
+            } else {
+                console.log('✓ Checksum matches');
+            }
+
+            if (passed) {
+                console.log('\n✅ All checks passed - output matches baseline');
+                app.exit(0);
+            } else {
+                console.log('\n❌ Regression detected - output differs from baseline');
+                console.log('To update baseline: cp', CURRENT_FILE, BASELINE_FILE);
+                app.exit(1);
+            }
+
+        } catch (error) {
+            console.error('Error running test:', error);
+            app.exit(1);
+        }
+    });
+}
+
+app.whenReady().then(createWindow);
+app.on('window-all-closed', () => app.quit());

package/src/web/index.html

@@ -0,0 +1,92 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Raster Path</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div id="container">
+        <!-- Controls Panel -->
+        <div class="controls">
+            <div class="section">
+                <h3>Mode</h3>
+                <div class="mode-toggle">
+                    <label><input type="radio" name="mode" value="planar" checked> Planar</label>
+                    <label><input type="radio" name="mode" value="radial"> Radial</label>
+                </div>
+            </div>
+
+            <div class="section">
+                <h3>Load STL</h3>
+                <button id="load-model" class="btn">Load Model</button>
+                <div id="model-status" class="status">No model loaded</div>
+                <button id="load-tool" class="btn">Load Tool</button>
+                <div id="tool-status" class="status">No tool loaded</div>
+            </div>
+
+            <div class="section">
+                <h3>Resolution</h3>
+                <select id="resolution">
+                    <option value="0.100" selected>0.100mm</option>
+                    <option value="0.050">0.050mm</option>
+                    <option value="0.025">0.025mm</option>
+                    <option value="0.010">0.010mm</option>
+                </select>
+            </div>
+
+            <div class="section">
+                <h3>Parameters</h3>
+                <label>
+                    Z Floor: <input type="number" id="z-floor" value="-100" step="10" style="width: 70px;">
+                </label>
+                <label>
+                    X Step: <input type="number" id="x-step" value="5" min="1" max="50" style="width: 60px;">
+                </label>
+                <label>
+                    Y Step: <input type="number" id="y-step" value="5" min="1" max="50" style="width: 60px;">
+                </label>
+                <label id="angle-step-container" class="hide">
+                    Angle Step (deg): <input type="number" id="angle-step" value="1" min="0.1" max="10" step="0.1" style="width: 60px;">
+                </label>
+            </div>
+
+            <div class="section">
+                <h3>Process</h3>
+                <button id="rasterize" class="btn" disabled>Rasterize</button>
+                <button id="generate-toolpath" class="btn" disabled>Generate Toolpath</button>
+            </div>
+
+            <div class="section">
+                <h3>View</h3>
+                <label><input type="checkbox" id="show-model" checked> Model</label>
+                <label><input type="checkbox" id="show-raster"> Raster</label>
+                <label><input type="checkbox" id="show-paths"> Toolpaths</label>
+                <label id="wrapped-container" class="hide">
+                    <input type="checkbox" id="show-wrapped"> Wrapped
+                </label>
+            </div>
+
+            <div class="section">
+                <h3>Info</h3>
+                <div id="info" class="info-text">Ready</div>
+            </div>
+        </div>
+
+        <!-- 3D Canvas -->
+        <canvas id="canvas"></canvas>
+    </div>
+
+    <script type="importmap">
+    {
+        "imports": {
+            "three": "https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js",
+            "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/"
+        }
+    }
+    </script>
+    <script type="module" src="app.js"></script>
+    <!-- <script type="module" src="webgpu-worker.js"></script> -->
+</body>
+</html>

package/src/web/style.css

@@ -0,0 +1,158 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: #1a1a1a;
+    color: #ffffff;
+    overflow: hidden;
+}
+
+#container {
+    width: 100vw;
+    height: 100vh;
+    position: relative;
+}
+
+#canvas {
+    display: block;
+    width: 100%;
+    height: 100%;
+}
+
+.controls {
+    position: absolute;
+    top: 20px;
+    right: 20px;
+    background: rgba(0, 0, 0, 0.85);
+    backdrop-filter: blur(10px);
+    border: 1px solid #333;
+    border-radius: 8px;
+    padding: 20px;
+    min-width: 220px;
+    max-width: 280px;
+    z-index: 100;
+}
+
+.section {
+    margin-bottom: 20px;
+    padding-bottom: 15px;
+    border-bottom: 1px solid #333;
+}
+
+.section:last-child {
+    border-bottom: none;
+    margin-bottom: 0;
+}
+
+.section h3 {
+    font-size: 13px;
+    color: #00ffff;
+    margin-bottom: 10px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.mode-toggle {
+    display: flex;
+    gap: 12px;
+}
+
+.mode-toggle label {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 13px;
+    cursor: pointer;
+}
+
+.mode-toggle input[type="radio"] {
+    cursor: pointer;
+    accent-color: #00ffff;
+}
+
+.btn {
+    width: 100%;
+    padding: 10px;
+    margin-bottom: 8px;
+    font-size: 13px;
+    font-weight: 600;
+    background: rgba(0, 255, 255, 0.1);
+    border: 1px solid #00ffff;
+    border-radius: 6px;
+    color: #00ffff;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.btn:hover:not(:disabled) {
+    background: rgba(0, 255, 255, 0.2);
+    box-shadow: 0 0 8px rgba(0, 255, 255, 0.3);
+}
+
+.btn:active:not(:disabled) {
+    background: rgba(0, 255, 255, 0.3);
+    transform: translateY(1px);
+}
+
+.btn:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+    border-color: #666;
+    color: #666;
+}
+
+.status {
+    font-size: 11px;
+    color: #888;
+    margin-bottom: 12px;
+    font-style: italic;
+}
+
+select {
+    width: 100%;
+    padding: 8px;
+    font-size: 13px;
+    background: rgba(0, 0, 0, 0.6);
+    border: 1px solid #00ffff;
+    border-radius: 6px;
+    color: #ffffff;
+    cursor: pointer;
+}
+
+select:focus {
+    outline: none;
+    border-color: #00cccc;
+    box-shadow: 0 0 8px rgba(0, 255, 255, 0.3);
+}
+
+label {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+    margin-bottom: 8px;
+    cursor: pointer;
+}
+
+input[type="checkbox"] {
+    cursor: pointer;
+    width: 16px;
+    height: 16px;
+    accent-color: #00ffff;
+}
+
+.info-text {
+    font-size: 12px;
+    color: #aaa;
+    line-height: 1.5;
+    white-space: pre-wrap;
+}
+
+.hide {
+    display: none;
+}