@gridspace/raster-path 1.0.2 → 1.0.4

package/src/test/lathe-cylinder-2-debug.cjs

@@ -0,0 +1,334 @@
+// lathe-cylinder-2-debug.cjs
+// Debug test for lathe-cylinder-2.stl with specific parameters
+// Run multiple times to check for non-deterministic behavior
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+const TEST_ITERATIONS = 5; // Run test 5 times to check consistency
+
+const TEST_CONFIG = {
+    model: '../benchmark/fixtures/lathe-cylinder-2.stl',
+    tool: '../benchmark/fixtures/tool.stl',
+    resolution: 0.05,
+    rotationStep: 1.0,
+    toolDiameter: 5.0, // Scale tool to 5mm
+    xStep: 1,
+    yStep: 1
+};
+
+console.log('=== Lathe Cylinder 2 Debug Test ===');
+console.log('Testing for non-deterministic behavior / missing toolpaths');
+console.log(`Model: lathe-cylinder-2.stl`);
+console.log(`Resolution: ${TEST_CONFIG.resolution}mm`);
+console.log(`Tool size: ${TEST_CONFIG.toolDiameter}mm`);
+console.log(`Rotation step: ${TEST_CONFIG.rotationStep}°`);
+console.log(`XY steps: ${TEST_CONFIG.xStep}`);
+console.log(`Iterations: ${TEST_ITERATIONS}`);
+console.log('');
+
+let win;
+let testResults = [];
+let currentIteration = 0;
+
+app.whenReady().then(async () => {
+    win = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true
+        }
+    });
+
+    // Capture console messages
+    win.webContents.on('console-message', (event, level, message) => {
+        console.log(message);
+    });
+
+    await win.loadFile(path.join(__dirname, '../../build/index.html'));
+    console.log('✓ Page loaded\n');
+
+    // Run test multiple times
+    await runNextIteration();
+});
+
+async function runNextIteration() {
+    if (currentIteration >= TEST_ITERATIONS) {
+        // All iterations complete - analyze results
+        analyzeResults();
+        app.quit();
+        return;
+    }
+
+    currentIteration++;
+    console.log('======================================================================');
+    console.log(`ITERATION ${currentIteration} of ${TEST_ITERATIONS}`);
+    console.log('======================================================================');
+
+    try {
+        const result = await runTest();
+        testResults.push(result);
+
+        // Wait a bit between iterations
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        // Run next iteration
+        await runNextIteration();
+    } catch (error) {
+        console.error(`✗ Iteration ${currentIteration} failed:`, error);
+        testResults.push({
+            iteration: currentIteration,
+            success: false,
+            error: error.message
+        });
+
+        // Continue with next iteration even on failure
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await runNextIteration();
+    }
+}
+
+async function runTest() {
+    const result = await win.webContents.executeJavaScript(`
+        (async () => {
+            const startTime = performance.now();
+
+            // Load model
+            const modelResponse = await fetch('${TEST_CONFIG.model}');
+            const modelBuffer = await modelResponse.arrayBuffer();
+
+            // Parse model triangles
+            function parseSTL(arrayBuffer) {
+                const view = new DataView(arrayBuffer);
+                const numTriangles = view.getUint32(80, true);
+                const triangles = new Float32Array(numTriangles * 9);
+
+                let offset = 84;
+                for (let i = 0; i < numTriangles; i++) {
+                    offset += 12; // Skip normal
+                    for (let v = 0; v < 3; v++) {
+                        triangles[i * 9 + v * 3 + 0] = view.getFloat32(offset + 0, true);
+                        triangles[i * 9 + v * 3 + 1] = view.getFloat32(offset + 4, true);
+                        triangles[i * 9 + v * 3 + 2] = view.getFloat32(offset + 8, true);
+                        offset += 12;
+                    }
+                    offset += 2; // Skip attribute
+                }
+
+                return triangles;
+            }
+
+            const modelTriangles = parseSTL(modelBuffer);
+
+            // Load and scale tool
+            const toolResponse = await fetch('${TEST_CONFIG.tool}');
+            const toolBuffer = await toolResponse.arrayBuffer();
+            const toolTriangles = parseSTL(toolBuffer);
+
+            // Scale tool to target diameter (${TEST_CONFIG.toolDiameter}mm)
+            function calculateToolDiameter(triangles) {
+                let minX = Infinity, maxX = -Infinity;
+                let minY = Infinity, maxY = -Infinity;
+                for (let i = 0; i < triangles.length; i += 3) {
+                    minX = Math.min(minX, triangles[i]);
+                    maxX = Math.max(maxX, triangles[i]);
+                    minY = Math.min(minY, triangles[i + 1]);
+                    maxY = Math.max(maxY, triangles[i + 1]);
+                }
+                return Math.max(maxX - minX, maxY - minY);
+            }
+
+            const originalDiameter = calculateToolDiameter(toolTriangles);
+            const scale = ${TEST_CONFIG.toolDiameter} / originalDiameter;
+            const scaledToolTriangles = new Float32Array(toolTriangles.length);
+            for (let i = 0; i < toolTriangles.length; i++) {
+                scaledToolTriangles[i] = toolTriangles[i] * scale;
+            }
+
+            // Import worker
+            const { RasterPath } = await import('./raster-path.js');
+            const rasterPath = new RasterPath({
+                mode: 'radial',
+                resolution: ${TEST_CONFIG.resolution},
+                rotationStep: ${TEST_CONFIG.rotationStep}
+            });
+
+            // Initialize
+            await rasterPath.init();
+
+            const toolStart = performance.now();
+            await rasterPath.loadTool({ triangles: scaledToolTriangles });
+            const toolTime = performance.now() - toolStart;
+
+            const terrainStart = performance.now();
+            await rasterPath.loadTerrain({
+                triangles: modelTriangles,
+                zFloor: 0
+            });
+            const terrainTime = performance.now() - terrainStart;
+
+            const toolpathStart = performance.now();
+            const toolpathResult = await rasterPath.generateToolpaths({
+                xStep: ${TEST_CONFIG.xStep},
+                yStep: ${TEST_CONFIG.yStep},
+                zFloor: 0,
+                radiusOffset: 20
+            });
+            const toolpathTime = performance.now() - toolpathStart;
+
+            const totalTime = performance.now() - startTime;
+
+            // Count strips and points
+            let numStrips = 0;
+            let totalPoints = 0;
+            let minPoints = Infinity;
+            let maxPoints = -Infinity;
+            let emptyStrips = 0;
+
+            if (toolpathResult) {
+                numStrips = toolpathResult.numStrips || 0;
+                totalPoints = toolpathResult.totalPoints || 0;
+
+                // If we have the raw strips data, analyze it
+                if (toolpathResult.strips) {
+                    for (const strip of toolpathResult.strips) {
+                        const pointCount = strip.length / 3;
+                        if (pointCount === 0) {
+                            emptyStrips++;
+                        }
+                        minPoints = Math.min(minPoints, pointCount);
+                        maxPoints = Math.max(maxPoints, pointCount);
+                    }
+                } else if (toolpathResult.result && toolpathResult.result.strips) {
+                    // Alternative format
+                    numStrips = toolpathResult.result.strips.length;
+                    for (const strip of toolpathResult.result.strips) {
+                        const pointCount = strip.length / 3;
+                        totalPoints += pointCount;
+                        if (pointCount === 0) {
+                            emptyStrips++;
+                        }
+                        minPoints = Math.min(minPoints, pointCount);
+                        maxPoints = Math.max(maxPoints, pointCount);
+                    }
+                }
+            }
+
+            return {
+                success: true,
+                triangleCount: modelTriangles.length / 9,
+                timing: {
+                    terrain: terrainTime,
+                    tool: toolTime,
+                    toolpath: toolpathTime,
+                    total: totalTime
+                },
+                result: {
+                    numStrips,
+                    totalPoints,
+                    minPoints: minPoints === Infinity ? 0 : minPoints,
+                    maxPoints: maxPoints === -Infinity ? 0 : maxPoints,
+                    emptyStrips,
+                    avgPointsPerStrip: numStrips > 0 ? (totalPoints / numStrips).toFixed(1) : 0
+                }
+            };
+        })()
+    `);
+
+    console.log(`\nResults (Iteration ${currentIteration}):`);
+    console.log(`  Triangle count:      ${result.triangleCount.toLocaleString()}`);
+    console.log(`  Terrain time:        ${result.timing.terrain.toFixed(1)}ms`);
+    console.log(`  Tool time:           ${result.timing.tool.toFixed(1)}ms`);
+    console.log(`  Toolpath time:       ${result.timing.toolpath.toFixed(1)}ms`);
+    console.log(`  Total time:          ${result.timing.total.toFixed(1)}ms`);
+    console.log('');
+    console.log('Toolpath Output:');
+    console.log(`  Strips:              ${result.result.numStrips}`);
+    console.log(`  Total points:        ${result.result.totalPoints.toLocaleString()}`);
+    console.log(`  Empty strips:        ${result.result.emptyStrips}`);
+    console.log(`  Min points/strip:    ${result.result.minPoints}`);
+    console.log(`  Max points/strip:    ${result.result.maxPoints}`);
+    console.log(`  Avg points/strip:    ${result.result.avgPointsPerStrip}`);
+    console.log('');
+
+    return {
+        iteration: currentIteration,
+        ...result
+    };
+}
+
+function analyzeResults() {
+    console.log('');
+    console.log('======================================================================');
+    console.log('CONSISTENCY ANALYSIS');
+    console.log('======================================================================');
+
+    const successful = testResults.filter(r => r.success);
+
+    if (successful.length === 0) {
+        console.log('✗ All iterations failed!');
+        return;
+    }
+
+    if (successful.length < TEST_ITERATIONS) {
+        console.log(`⚠️  Only ${successful.length} of ${TEST_ITERATIONS} iterations succeeded`);
+    }
+
+    // Check consistency of results
+    const totalPointsCounts = successful.map(r => r.result.totalPoints);
+    const uniqueTotalPoints = [...new Set(totalPointsCounts)];
+
+    const numStripsCounts = successful.map(r => r.result.numStrips);
+    const uniqueNumStrips = [...new Set(numStripsCounts)];
+
+    const emptyStripsCounts = successful.map(r => r.result.emptyStrips);
+    const uniqueEmptyStrips = [...new Set(emptyStripsCounts)];
+
+    console.log('\nTotal Points Consistency:');
+    if (uniqueTotalPoints.length === 1) {
+        console.log(`  ✓ All iterations produced ${totalPointsCounts[0].toLocaleString()} points`);
+    } else {
+        console.log(`  ✗ INCONSISTENT! Got ${uniqueTotalPoints.length} different values:`);
+        uniqueTotalPoints.forEach(val => {
+            const count = totalPointsCounts.filter(v => v === val).length;
+            console.log(`    ${val.toLocaleString()} points: ${count} times`);
+        });
+    }
+
+    console.log('\nEmpty Strips Consistency:');
+    if (uniqueEmptyStrips.length === 1) {
+        console.log(`  ${uniqueEmptyStrips[0] === 0 ? '✓' : '⚠️'}  All iterations had ${emptyStripsCounts[0]} empty strips`);
+    } else {
+        console.log(`  ✗ INCONSISTENT! Got ${uniqueEmptyStrips.length} different values:`);
+        uniqueEmptyStrips.forEach(val => {
+            const count = emptyStripsCounts.filter(v => v === val).length;
+            console.log(`    ${val} empty strips: ${count} times`);
+        });
+    }
+
+    // Timing statistics
+    const toolpathTimes = successful.map(r => r.timing.toolpath);
+    const avgTime = toolpathTimes.reduce((a, b) => a + b, 0) / toolpathTimes.length;
+    const minTime = Math.min(...toolpathTimes);
+    const maxTime = Math.max(...toolpathTimes);
+    const stdDev = Math.sqrt(
+        toolpathTimes.reduce((sum, t) => sum + Math.pow(t - avgTime, 2), 0) / toolpathTimes.length
+    );
+
+    console.log('\nToolpath Timing Statistics:');
+    console.log(`  Average: ${avgTime.toFixed(1)}ms`);
+    console.log(`  Min:     ${minTime.toFixed(1)}ms`);
+    console.log(`  Max:     ${maxTime.toFixed(1)}ms`);
+    console.log(`  StdDev:  ${stdDev.toFixed(1)}ms (${(stdDev / avgTime * 100).toFixed(1)}%)`);
+
+    // Overall verdict
+    console.log('');
+    if (uniqueTotalPoints.length === 1 && uniqueEmptyStrips[0] === 0) {
+        console.log('✅ RESULTS ARE CONSISTENT - No non-deterministic behavior detected');
+    } else {
+        console.log('🛑 RESULTS ARE INCONSISTENT - Non-deterministic behavior detected!');
+        console.log('   This suggests workgroups may be getting killed or timing out.');
+    }
+}

package/src/test/lathe-cylinder-2-test.cjs

@@ -0,0 +1,157 @@
+// lathe-cylinder-2-test.cjs
+// Test for lathe-cylinder-2.stl (201 buckets) with bucket batching
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+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('=== Lathe Cylinder 2 Test (201 buckets) ===');
+
+                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 lathe-cylinder-2.stl...');
+                const terrainResponse = await fetch('../benchmark/fixtures/lathe-cylinder-2.stl');
+                const terrainBuffer = await terrainResponse.arrayBuffer();
+
+                const toolResponse = await fetch('../benchmark/fixtures/tool.stl');
+                const toolBuffer = await toolResponse.arrayBuffer();
+
+                console.log('✓ Loaded lathe-cylinder-2.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.5;
+                const rotationStep = 5.0;
+                const xStep = 1;
+                const yStep = 1;
+                const zFloor = -50;
+
+                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');
+
+                // Create RasterPath instance for radial mode
+                console.log('\\nInitializing RasterPath (radial mode with diagnostic=true)...');
+                const raster = new RasterPath({
+                    mode: 'radial',
+                    resolution: resolution,
+                    rotationStep: rotationStep,
+                    diagnostic: true
+                });
+                await raster.init();
+                console.log('✓ RasterPath initialized');
+
+                // Load tool
+                console.log('\\nLoading 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
+                console.log('\\nLoading terrain...');
+                const t1 = performance.now();
+                await raster.loadTerrain({ triangles: terrainTriangles });
+                const terrainTime = performance.now() - t1;
+                console.log('✓ Terrain loaded in', terrainTime.toFixed(1), 'ms');
+
+                // Generate toolpaths (this should trigger bucket batching)
+                console.log('\\n*** Generating toolpaths (watch for bucket batching messages) ***');
+                const t2 = performance.now();
+                const toolpaths = await raster.generateToolpaths({
+                    xStep,
+                    yStep,
+                    zFloor
+                });
+                const toolpathTime = performance.now() - t2;
+
+                console.log('\\n✓ Generated', toolpaths.length, 'toolpaths in', (toolpathTime / 1000).toFixed(2), 's');
+                if (toolpaths.length > 0) {
+                    console.log('  First toolpath:', toolpaths[0].numScanlines, 'scanlines ×', toolpaths[0].pointsPerLine, 'points');
+                }
+
+                console.log('\\n✅ TEST PASSED - No GPU timeout!');
+
+                return { success: true };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result && result.error) {
+                console.error('❌ Test failed:', result.error);
+                app.exit(1);
+            } else {
+                console.log('\n✅ Test completed successfully');
+                app.exit(0);
+            }
+        } catch (error) {
+            console.error('❌ Test execution failed:', error);
+            app.exit(1);
+        }
+    });
+
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        console.log(message);
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    app.quit();
+});

package/src/test/lathe-cylinder-test.cjs

@@ -0,0 +1,198 @@
+const { app, BrowserWindow } = require('electron');
+const fs = require('fs');
+const path = require('path');
+
+let testPassed = false;
+
+app.on('ready', async () => {
+    const win = new BrowserWindow({
+        width: 800,
+        height: 600,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true
+        }
+    });
+
+    // Load test page
+    await win.loadFile(path.join(__dirname, '../../build/index.html'));
+
+    // Inject test script
+    await win.webContents.executeJavaScript(`
+        (async () => {
+            console.log('=== Lathe Cylinder Radial Test (0.025mm resolution) ===');
+
+            // Load STL
+            const stlPath = '${path.join(__dirname, '../../benchmark/fixtures/lathe-cylinder.stl')}';
+            const stlBuffer = await (await fetch('file://' + stlPath)).arrayBuffer();
+
+            console.log('STL Size:', (stlBuffer.byteLength / 1024 / 1024).toFixed(2), 'MB');
+
+            // Parse STL
+            function parseSTL(arrayBuffer) {
+                const view = new DataView(arrayBuffer);
+                const triangleCount = view.getUint32(80, true);
+                console.log('Triangle count:', triangleCount);
+
+                const triangles = new Float32Array(triangleCount * 9);
+                let offset = 84;
+
+                for (let i = 0; i < triangleCount; i++) {
+                    offset += 12; // Skip normal
+                    for (let j = 0; j < 9; j++) {
+                        triangles[i * 9 + j] = view.getFloat32(offset, true);
+                        offset += 4;
+                    }
+                    offset += 2; // Skip attribute byte count
+                }
+
+                return triangles;
+            }
+
+            const triangles = parseSTL(stlBuffer);
+
+            // Calculate bounds
+            let minX = Infinity, maxX = -Infinity;
+            let minY = Infinity, maxY = -Infinity;
+            let minZ = Infinity, maxZ = -Infinity;
+
+            for (let i = 0; i < triangles.length; i += 3) {
+                const x = triangles[i];
+                const y = triangles[i + 1];
+                const z = triangles[i + 2];
+                minX = Math.min(minX, x); maxX = Math.max(maxX, x);
+                minY = Math.min(minY, y); maxY = Math.max(maxY, y);
+                minZ = Math.min(minZ, z); maxZ = Math.max(maxZ, z);
+            }
+
+            console.log('Bounds:');
+            console.log('  X:', minX.toFixed(2), 'to', maxX.toFixed(2), '(size:', (maxX - minX).toFixed(2), 'mm)');
+            console.log('  Y:', minY.toFixed(2), 'to', maxY.toFixed(2), '(size:', (maxY - minY).toFixed(2), 'mm)');
+            console.log('  Z:', minZ.toFixed(2), 'to', maxZ.toFixed(2), '(size:', (maxZ - minZ).toFixed(2), 'mm)');
+
+            const resolution = 0.025;
+            const rotationStep = 1.0;
+
+            console.log('\\nTest parameters:');
+            console.log('  Resolution:', resolution, 'mm');
+            console.log('  Rotation step:', rotationStep, 'degrees');
+
+            // Calculate expected dimensions
+            const xSize = maxX - minX;
+            const ySize = maxY - minY;
+            const zSize = maxZ - minZ;
+            const maxRadius = Math.sqrt(ySize * ySize + zSize * zSize) / 2;
+
+            const gridXSize = Math.ceil(xSize / resolution);
+            const gridYHeight = Math.ceil(ySize / resolution);
+            const numAngles = Math.ceil(360 / rotationStep);
+
+            console.log('\\nExpected grid dimensions:');
+            console.log('  X grid size:', gridXSize, 'cells');
+            console.log('  Y grid height:', gridYHeight, 'cells');
+            console.log('  Number of angles:', numAngles);
+            console.log('  Max radius:', maxRadius.toFixed(2), 'mm');
+
+            // Calculate memory requirements
+            const bytesPerCell = 4; // f32
+            const totalCells = gridXSize * gridYHeight * numAngles;
+            const totalMemoryMB = (totalCells * bytesPerCell / 1024 / 1024).toFixed(2);
+
+            console.log('\\nMemory requirements:');
+            console.log('  Total cells:', totalCells.toLocaleString());
+            console.log('  Total memory:', totalMemoryMB, 'MB');
+
+            // Test with RasterPath
+            console.log('\\n=== Starting RasterPath test ===');
+
+            const { RasterPath } = await import('./raster-path.js');
+            const raster = new RasterPath({
+                mode: 'radial',
+                resolution: resolution,
+                rotationStep: rotationStep
+            });
+
+            await raster.init();
+            console.log('RasterPath initialized');
+
+            try {
+                // Load terrain
+                console.log('Loading terrain...');
+                const startLoad = Date.now();
+                await raster.loadTerrain({ triangles, zFloor: 0 });
+                const loadTime = Date.now() - startLoad;
+                console.log('Terrain loaded in', loadTime, 'ms');
+
+                // Generate toolpaths with a dummy tool
+                console.log('Generating toolpaths...');
+                const startToolpath = Date.now();
+
+                // Create a simple cylindrical tool (10mm diameter, 10mm height)
+                const toolRadius = 5;
+                const toolHeight = 10;
+                const toolSegments = 16;
+                const toolTriangles = new Float32Array(toolSegments * 2 * 9);
+
+                for (let i = 0; i < toolSegments; i++) {
+                    const angle1 = (i / toolSegments) * Math.PI * 2;
+                    const angle2 = ((i + 1) / toolSegments) * Math.PI * 2;
+
+                    const x1 = Math.cos(angle1) * toolRadius;
+                    const y1 = Math.sin(angle1) * toolRadius;
+                    const x2 = Math.cos(angle2) * toolRadius;
+                    const y2 = Math.sin(angle2) * toolRadius;
+
+                    // Bottom triangle
+                    const idx = i * 18;
+                    toolTriangles[idx] = 0; toolTriangles[idx + 1] = 0; toolTriangles[idx + 2] = 0;
+                    toolTriangles[idx + 3] = x1; toolTriangles[idx + 4] = y1; toolTriangles[idx + 5] = 0;
+                    toolTriangles[idx + 6] = x2; toolTriangles[idx + 7] = y2; toolTriangles[idx + 8] = 0;
+
+                    // Side rectangle (as 2 triangles) - just one for simplicity
+                    toolTriangles[idx + 9] = x1; toolTriangles[idx + 10] = y1; toolTriangles[idx + 11] = 0;
+                    toolTriangles[idx + 12] = x1; toolTriangles[idx + 13] = y1; toolTriangles[idx + 14] = toolHeight;
+                    toolTriangles[idx + 15] = x2; toolTriangles[idx + 16] = y2; toolTriangles[idx + 17] = 0;
+                }
+
+                await raster.loadTool({ triangles: toolTriangles });
+
+                const toolpathData = await raster.generateToolpaths({
+                    xStep: 10,
+                    yStep: 10,
+                    zFloor: 0,
+                    radiusOffset: 20
+                });
+
+                const toolpathTime = Date.now() - startToolpath;
+
+                console.log('\\n=== Test Results ===');
+                console.log('Toolpath generation time:', toolpathTime, 'ms');
+                console.log('Number of strips:', toolpathData.numStrips);
+                console.log('Total points:', toolpathData.totalPoints);
+                console.log('Average points per strip:', (toolpathData.totalPoints / toolpathData.numStrips).toFixed(0));
+                console.log('\\nTEST PASSED');
+
+                return { success: true };
+
+            } catch (error) {
+                console.error('\\n=== TEST FAILED ===');
+                console.error('Error:', error.message);
+                console.error('Stack:', error.stack);
+                return { success: false, error: error.message };
+            } finally {
+                raster.terminate();
+            }
+        })();
+    `).then((result) => {
+        testPassed = result.success === true;
+        app.quit();
+    }).catch((error) => {
+        console.error('Test execution error:', error);
+        app.quit();
+    });
+});
+
+app.on('window-all-closed', () => {
+    process.exit(testPassed ? 0 : 1);
+});