npm - cyclecad - Versions diffs - 3.0.0 → 3.1.0 - Mend

cyclecad 3.0.0 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (66) hide show

package/BILLING-IMPLEMENTATION-SUMMARY.md +425 -0
package/BILLING-INDEX.md +293 -0
package/BILLING-INTEGRATION-GUIDE.md +414 -0
package/COLLABORATION-INDEX.md +440 -0
package/COLLABORATION-SYSTEM-SUMMARY.md +548 -0
package/DOCKER-BUILD-MANIFEST.txt +483 -0
package/DOCKER-FILES-REFERENCE.md +440 -0
package/DOCKER-INFRASTRUCTURE.md +475 -0
package/DOCKER-README.md +435 -0
package/Dockerfile +33 -55
package/PWA-FILES-CREATED.txt +350 -0
package/QUICK-START-TESTING.md +126 -0
package/STEP-IMPORT-QUICKSTART.md +347 -0
package/STEP-IMPORT-SYSTEM-SUMMARY.md +502 -0
package/app/css/mobile.css +1074 -0
package/app/icons/generate-icons.js +203 -0
package/app/js/billing-ui.js +990 -0
package/app/js/brep-kernel.js +933 -981
package/app/js/collab-client.js +750 -0
package/app/js/mobile-nav.js +623 -0
package/app/js/mobile-toolbar.js +476 -0
package/app/js/modules/billing-module.js +724 -0
package/app/js/modules/step-module-enhanced.js +938 -0
package/app/js/offline-manager.js +705 -0
package/app/js/responsive-init.js +360 -0
package/app/js/touch-handler.js +429 -0
package/app/manifest.json +211 -0
package/app/offline.html +508 -0
package/app/sw.js +571 -0
package/app/tests/billing-tests.html +779 -0
package/app/tests/brep-tests.html +980 -0
package/app/tests/collab-tests.html +743 -0
package/app/tests/mobile-tests.html +1299 -0
package/app/tests/pwa-tests.html +1134 -0
package/app/tests/step-tests.html +1042 -0
package/app/tests/test-agent-v3.html +719 -0
package/docker-compose.yml +225 -0
package/docs/BILLING-HELP.json +260 -0
package/docs/BILLING-README.md +639 -0
package/docs/BILLING-TUTORIAL.md +736 -0
package/docs/BREP-HELP.json +326 -0
package/docs/BREP-TUTORIAL.md +802 -0
package/docs/COLLABORATION-HELP.json +228 -0
package/docs/COLLABORATION-TUTORIAL.md +818 -0
package/docs/DOCKER-HELP.json +224 -0
package/docs/DOCKER-TUTORIAL.md +974 -0
package/docs/MOBILE-HELP.json +243 -0
package/docs/MOBILE-RESPONSIVE-README.md +378 -0
package/docs/MOBILE-TUTORIAL.md +747 -0
package/docs/PWA-HELP.json +228 -0
package/docs/PWA-README.md +662 -0
package/docs/PWA-TUTORIAL.md +757 -0
package/docs/STEP-HELP.json +481 -0
package/docs/STEP-IMPORT-TUTORIAL.md +824 -0
package/docs/TESTING-GUIDE.md +528 -0
package/docs/TESTING-HELP.json +182 -0
package/fusion-vs-cyclecad.html +1771 -0
package/nginx.conf +237 -0
package/package.json +1 -1
package/server/Dockerfile.converter +51 -0
package/server/Dockerfile.signaling +28 -0
package/server/billing-server.js +487 -0
package/server/converter-enhanced.py +528 -0
package/server/requirements-converter.txt +29 -0
package/server/signaling-server.js +801 -0
package/tests/docker-tests.sh +389 -0

package/app/tests/brep-tests.html ADDED Viewed

@@ -0,0 +1,980 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>B-Rep Kernel Test Suite</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      background: #1e1e1e;
+      color: #e0e0e0;
+      padding: 20px;
+    }
+    .container {
+      max-width: 1600px;
+      margin: 0 auto;
+      display: grid;
+      grid-template-columns: 300px 1fr 400px;
+      gap: 20px;
+      height: calc(100vh - 40px);
+    }
+    /* Left Panel: Test Categories */
+    .left-panel {
+      background: #252525;
+      border-radius: 8px;
+      padding: 15px;
+      overflow-y: auto;
+      border: 1px solid #404040;
+    }
+    .category {
+      margin-bottom: 10px;
+    }
+    .category-title {
+      font-size: 12px;
+      font-weight: bold;
+      color: #6fa3d0;
+      text-transform: uppercase;
+      padding: 8px 5px;
+      cursor: pointer;
+      user-select: none;
+      border-radius: 4px;
+      transition: background 0.2s;
+    }
+    .category-title:hover {
+      background: #333333;
+    }
+    .category-title.active {
+      background: #6fa3d0;
+      color: #1e1e1e;
+    }
+    .test-list {
+      display: none;
+      padding-left: 10px;
+    }
+    .test-list.active {
+      display: block;
+    }
+    .test-item {
+      font-size: 11px;
+      padding: 6px 8px;
+      margin: 3px 0;
+      background: #2d2d2d;
+      border-radius: 3px;
+      cursor: pointer;
+      transition: all 0.2s;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .test-item:hover {
+      background: #363636;
+    }
+    .test-item.pass {
+      border-left: 3px solid #4caf50;
+    }
+    .test-item.fail {
+      border-left: 3px solid #f44336;
+    }
+    .test-item.skip {
+      border-left: 3px solid #ff9800;
+    }
+    /* Center Panel: 3D Viewport */
+    .center-panel {
+      background: #0a0a0a;
+      border-radius: 8px;
+      overflow: hidden;
+      border: 1px solid #404040;
+      position: relative;
+    }
+    #viewport {
+      width: 100%;
+      height: 100%;
+      display: block;
+    }
+    .viewport-info {
+      position: absolute;
+      top: 10px;
+      left: 10px;
+      background: rgba(0, 0, 0, 0.8);
+      padding: 10px 15px;
+      border-radius: 4px;
+      font-size: 11px;
+      color: #4caf50;
+      font-family: 'Courier New', monospace;
+      max-width: 200px;
+    }
+    /* Right Panel: Test Log */
+    .right-panel {
+      background: #252525;
+      border-radius: 8px;
+      padding: 15px;
+      overflow-y: auto;
+      border: 1px solid #404040;
+      display: flex;
+      flex-direction: column;
+    }
+    .controls {
+      display: flex;
+      gap: 8px;
+      margin-bottom: 15px;
+      flex-wrap: wrap;
+    }
+    button {
+      padding: 8px 12px;
+      background: #6fa3d0;
+      color: #1e1e1e;
+      border: none;
+      border-radius: 4px;
+      font-size: 11px;
+      font-weight: bold;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+    button:hover {
+      background: #81b3e0;
+      transform: translateY(-1px);
+    }
+    button:active {
+      transform: translateY(0);
+    }
+    button.secondary {
+      background: #404040;
+      color: #e0e0e0;
+    }
+    button.secondary:hover {
+      background: #505050;
+    }
+    .progress-bar {
+      width: 100%;
+      height: 20px;
+      background: #1e1e1e;
+      border-radius: 4px;
+      overflow: hidden;
+      margin-bottom: 10px;
+    }
+    .progress-fill {
+      height: 100%;
+      background: linear-gradient(90deg, #4caf50, #81c784);
+      width: 0%;
+      transition: width 0.3s;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 10px;
+      font-weight: bold;
+      color: #1e1e1e;
+    }
+    .stats {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 8px;
+      margin-bottom: 15px;
+      font-size: 11px;
+    }
+    .stat-card {
+      background: #1e1e1e;
+      padding: 8px;
+      border-radius: 4px;
+      border-left: 3px solid #6fa3d0;
+      text-align: center;
+    }
+    .stat-value {
+      font-size: 14px;
+      font-weight: bold;
+      color: #4caf50;
+    }
+    .stat-label {
+      font-size: 9px;
+      color: #999;
+      margin-top: 2px;
+    }
+    .test-log {
+      flex: 1;
+      overflow-y: auto;
+      font-size: 10px;
+      font-family: 'Courier New', monospace;
+      background: #1e1e1e;
+      padding: 10px;
+      border-radius: 4px;
+      border: 1px solid #333333;
+    }
+    .log-entry {
+      padding: 4px 0;
+      line-height: 1.4;
+      border-bottom: 1px solid #2d2d2d;
+      display: none;
+    }
+    .log-entry.show {
+      display: block;
+    }
+    .log-entry.pass {
+      color: #4caf50;
+    }
+    .log-entry.fail {
+      color: #f44336;
+    }
+    .log-entry.info {
+      color: #6fa3d0;
+    }
+    .log-entry.warn {
+      color: #ff9800;
+    }
+    .header {
+      margin-bottom: 20px;
+      text-align: center;
+    }
+    .header h1 {
+      font-size: 24px;
+      color: #6fa3d0;
+      margin-bottom: 5px;
+    }
+    .header p {
+      font-size: 12px;
+      color: #999;
+    }
+    .export-button {
+      width: 100%;
+      background: #4caf50;
+    }
+    .export-button:hover {
+      background: #5cbf60;
+    }
+    @media (max-width: 1200px) {
+      .container {
+        grid-template-columns: 1fr;
+        height: auto;
+      }
+      .left-panel, .right-panel {
+        max-height: 300px;
+      }
+    }
+    .spinner {
+      display: inline-block;
+      width: 12px;
+      height: 12px;
+      border: 2px solid #6fa3d0;
+      border-top-color: transparent;
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>B-Rep Kernel Test Suite</h1>
+    <p>Interactive testing of OpenCascade.js WASM integration • 40+ test cases</p>
+  </div>
+  <div class="container">
+    <!-- Left Panel: Test Categories -->
+    <div class="left-panel">
+      <div id="categories"></div>
+    </div>
+    <!-- Center Panel: 3D Viewport -->
+    <div class="center-panel">
+      <canvas id="viewport"></canvas>
+      <div class="viewport-info" id="viewportInfo">
+        Loading...
+      </div>
+    </div>
+    <!-- Right Panel: Controls & Log -->
+    <div class="right-panel">
+      <div class="controls">
+        <button onclick="runAllTests()">Run All Tests</button>
+        <button class="secondary" onclick="clearLog()">Clear Log</button>
+        <button class="secondary" onclick="exportResults()">Export JSON</button>
+      </div>
+      <div class="progress-bar">
+        <div class="progress-fill" id="progressFill"></div>
+      </div>
+      <div class="stats">
+        <div class="stat-card">
+          <div class="stat-value" id="passCount">0</div>
+          <div class="stat-label">Passed</div>
+        </div>
+        <div class="stat-card">
+          <div class="stat-value" id="failCount">0</div>
+          <div class="stat-label">Failed</div>
+        </div>
+        <div class="stat-card">
+          <div class="stat-value" id="skipCount">0</div>
+          <div class="stat-label">Skipped</div>
+        </div>
+        <div class="stat-card">
+          <div class="stat-value" id="timeCount">0ms</div>
+          <div class="stat-label">Elapsed</div>
+        </div>
+      </div>
+      <div class="test-log" id="testLog"></div>
+    </div>
+  </div>
+  <!-- Three.js & B-Rep Kernel -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r170/three.min.js"></script>
+  <script type="module">
+    import BRepKernel from '../../app/js/brep-kernel.js';
+    // ═══════════════════════════════════════════════════════════════════════════
+    // GLOBAL STATE
+    // ═══════════════════════════════════════════════════════════════════════════
+    let kernel = null;
+    let scene, camera, renderer;
+    let meshes = [];
+    let currentTestResults = [];
+    let isRunning = false;
+    let startTime = 0;
+    // ═══════════════════════════════════════════════════════════════════════════
+    // TEST DEFINITIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    const testSuites = {
+      'Primitives': [
+        {
+          name: 'Create Box',
+          fn: async () => {
+            const result = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            if (!result.id || !result.shape) throw new Error('Invalid box');
+            return result;
+          }
+        },
+        {
+          name: 'Create Cylinder',
+          fn: async () => {
+            const result = await kernel.makeCylinder({radius: 15, height: 60});
+            if (!result.id || !result.shape) throw new Error('Invalid cylinder');
+            return result;
+          }
+        },
+        {
+          name: 'Create Sphere',
+          fn: async () => {
+            const result = await kernel.makeSphere({radius: 25});
+            if (!result.id || !result.shape) throw new Error('Invalid sphere');
+            return result;
+          }
+        },
+        {
+          name: 'Create Cone',
+          fn: async () => {
+            const result = await kernel.makeCone({radius1: 30, radius2: 0, height: 40});
+            if (!result.id || !result.shape) throw new Error('Invalid cone');
+            return result;
+          }
+        },
+        {
+          name: 'Create Torus',
+          fn: async () => {
+            const result = await kernel.makeTorus({majorRadius: 40, minorRadius: 10});
+            if (!result.id || !result.shape) throw new Error('Invalid torus');
+            return result;
+          }
+        }
+      ],
+      'Transformations': [
+        {
+          name: 'Extrude Shape',
+          fn: async () => {
+            const wire = await kernel.makeBox({width: 50, height: 50, depth: 1});
+            const extruded = await kernel.extrude({
+              shapeId: wire.id,
+              dirX: 0, dirY: 0, dirZ: 1,
+              depth: 50
+            });
+            if (!extruded.id) throw new Error('Extrusion failed');
+            return extruded;
+          }
+        },
+        {
+          name: 'Revolve Shape',
+          fn: async () => {
+            const profile = await kernel.makeBox({width: 50, height: 50, depth: 1});
+            const revolved = await kernel.revolve({
+              shapeId: profile.id,
+              axisX: 0, axisY: 0, axisZ: 0,
+              dirX: 0, dirY: 0, dirZ: 1,
+              angle: 360
+            });
+            if (!revolved.id) throw new Error('Revolution failed');
+            return revolved;
+          }
+        },
+        {
+          name: 'Loft Between Profiles',
+          fn: async () => {
+            const base = await kernel.makeBox({width: 50, height: 50, depth: 1});
+            const top = await kernel.makeBox({width: 20, height: 20, depth: 1});
+            const lofted = await kernel.loft({
+              profileIds: [base.id, top.id],
+              isSolid: true
+            });
+            if (!lofted.id) throw new Error('Loft failed');
+            return lofted;
+          }
+        },
+        {
+          name: 'Mirror Shape',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const mirrored = await kernel.mirror({
+              shapeId: box.id,
+              plane: {
+                originX: 0, originY: 0, originZ: 0,
+                normalX: 1, normalY: 0, normalZ: 0
+              }
+            });
+            if (!mirrored.id) throw new Error('Mirror failed');
+            return mirrored;
+          }
+        }
+      ],
+      'Boolean Operations': [
+        {
+          name: 'Boolean Union',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const cyl = await kernel.makeCylinder({radius: 15, height: 60});
+            const union = await kernel.booleanUnion({shapeA: box.id, shapeB: cyl.id});
+            if (!union.id) throw new Error('Union failed');
+            return union;
+          }
+        },
+        {
+          name: 'Boolean Cut',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const cyl = await kernel.makeCylinder({radius: 15, height: 60});
+            const cut = await kernel.booleanCut({shapeA: box.id, shapeB: cyl.id});
+            if (!cut.id) throw new Error('Cut failed');
+            return cut;
+          }
+        },
+        {
+          name: 'Boolean Intersection',
+          fn: async () => {
+            const sphere1 = await kernel.makeSphere({radius: 30});
+            const sphere2 = await kernel.makeSphere({radius: 30});
+            const intersect = await kernel.booleanIntersect({shapeA: sphere1.id, shapeB: sphere2.id});
+            if (!intersect.id) throw new Error('Intersection failed');
+            return intersect;
+          }
+        }
+      ],
+      'Modifiers': [
+        {
+          name: 'Fillet Edges',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const filleted = await kernel.fillet({
+              shapeId: box.id,
+              edgeIndices: [0, 1, 2, 3],
+              radius: 5
+            });
+            if (!filleted.id) throw new Error('Fillet failed');
+            return filleted;
+          }
+        },
+        {
+          name: 'Chamfer Edges',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const chamfered = await kernel.chamfer({
+              shapeId: box.id,
+              edgeIndices: [0, 1, 2, 3],
+              distance: 3
+            });
+            if (!chamfered.id) throw new Error('Chamfer failed');
+            return chamfered;
+          }
+        },
+        {
+          name: 'Shell (Hollow)',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const shelled = await kernel.shell({
+              shapeId: box.id,
+              removeFaceIndices: [0],
+              thickness: 2
+            });
+            if (!shelled.id) throw new Error('Shell failed');
+            return shelled;
+          }
+        }
+      ],
+      'Topology': [
+        {
+          name: 'Get Edges',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const edges = await kernel.getEdges(box.id);
+            if (!Array.isArray(edges) || edges.length === 0) throw new Error('No edges found');
+            return edges;
+          }
+        },
+        {
+          name: 'Get Faces',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const faces = await kernel.getFaces(box.id);
+            if (!Array.isArray(faces) || faces.length === 0) throw new Error('No faces found');
+            return faces;
+          }
+        }
+      ],
+      'Visualization': [
+        {
+          name: 'Tessellate to Mesh',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const geometry = await kernel.shapeToMesh(box.id, 0.1);
+            if (!geometry || !geometry.attributes.position) throw new Error('Tessellation failed');
+            const posCount = geometry.attributes.position.count;
+            if (posCount === 0) throw new Error('No vertices generated');
+            return geometry;
+          }
+        },
+        {
+          name: 'Mesh with Fine Deflection',
+          fn: async () => {
+            const sphere = await kernel.makeSphere({radius: 25});
+            const geometry = await kernel.shapeToMesh(sphere.id, 0.01);
+            if (!geometry || geometry.attributes.position.count === 0) throw new Error('Fine mesh failed');
+            return geometry;
+          }
+        },
+        {
+          name: 'Mesh with Coarse Deflection',
+          fn: async () => {
+            const sphere = await kernel.makeSphere({radius: 25});
+            const geometry = await kernel.shapeToMesh(sphere.id, 1.0);
+            if (!geometry || geometry.attributes.position.count === 0) throw new Error('Coarse mesh failed');
+            return geometry;
+          }
+        }
+      ],
+      'Analysis': [
+        {
+          name: 'Mass Properties',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const props = await kernel.getMassProperties({shapeId: box.id, density: 7.85});
+            if (!props.volume || !props.mass) throw new Error('Properties invalid');
+            if (props.volume <= 0) throw new Error('Volume must be positive');
+            return props;
+          }
+        },
+        {
+          name: 'Bounding Box',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const bbox = await kernel.getBoundingBox(box.id);
+            if (!bbox.width || !bbox.height || !bbox.depth) throw new Error('Bbox invalid');
+            if (Math.abs(bbox.width - 100) > 1) throw new Error('Width mismatch');
+            return bbox;
+          }
+        },
+        {
+          name: 'Center of Gravity',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const props = await kernel.getMassProperties({shapeId: box.id});
+            const cog = props.centerOfGravity;
+            if (!cog.x || !cog.y || !cog.z) throw new Error('COG invalid');
+            return cog;
+          }
+        }
+      ],
+      'File I/O': [
+        {
+          name: 'Export to STEP',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const stepData = await kernel.exportSTEP([box.id]);
+            if (!stepData || stepData.length === 0) throw new Error('STEP export failed');
+            return stepData;
+          }
+        },
+        {
+          name: 'Import from STEP',
+          fn: async () => {
+            // Create sample STEP data (simplified)
+            const sampleStep = new Uint8Array([
+              0x49, 0x53, 0x4f, 0x31, 0x30, 0x33, 0x30, 0x33
+            ]);
+            const imported = await kernel.importSTEP(sampleStep);
+            if (!imported.id) throw new Error('STEP import failed');
+            return imported;
+          }
+        }
+      ],
+      'Utility': [
+        {
+          name: 'Get Shape Info',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const info = kernel.getShapeInfo(box.id);
+            if (!info || !info.name) throw new Error('Shape info unavailable');
+            return info;
+          }
+        },
+        {
+          name: 'Cache Statistics',
+          fn: async () => {
+            const stats = kernel.getCacheStats();
+            if (!stats.shapeCount) throw new Error('Cache stats invalid');
+            if (stats.shapeCount <= 0) throw new Error('No shapes cached');
+            return stats;
+          }
+        },
+        {
+          name: 'Delete Shape',
+          fn: async () => {
+            const box = await kernel.makeBox({width: 100, height: 50, depth: 30});
+            const deleted = kernel.deleteShape(box.id);
+            if (!deleted) throw new Error('Delete failed');
+            return true;
+          }
+        }
+      ]
+    };
+    // ═══════════════════════════════════════════════════════════════════════════
+    // THREE.JS SETUP
+    // ═══════════════════════════════════════════════════════════════════════════
+    function initThreeJS() {
+      const canvas = document.getElementById('viewport');
+      scene = new THREE.Scene();
+      scene.background = new THREE.Color(0x0a0a0a);
+      camera = new THREE.PerspectiveCamera(
+        75,
+        canvas.clientWidth / canvas.clientHeight,
+        0.1,
+        10000
+      );
+      camera.position.set(100, 100, 100);
+      camera.lookAt(0, 0, 0);
+      renderer = new THREE.WebGLRenderer({canvas, antialias: true});
+      renderer.setSize(canvas.clientWidth, canvas.clientHeight);
+      renderer.setPixelRatio(window.devicePixelRatio);
+      // Lights
+      const light1 = new THREE.DirectionalLight(0xffffff, 0.8);
+      light1.position.set(100, 100, 100);
+      scene.add(light1);
+      const light2 = new THREE.AmbientLight(0xffffff, 0.4);
+      scene.add(light2);
+      // Grid
+      const gridHelper = new THREE.GridHelper(200, 20, 0x444444, 0x222222);
+      scene.add(gridHelper);
+      // Animate
+      function animate() {
+        requestAnimationFrame(animate);
+        renderer.render(scene, camera);
+      }
+      animate();
+      // Handle resize
+      window.addEventListener('resize', () => {
+        camera.aspect = canvas.clientWidth / canvas.clientHeight;
+        camera.updateProjectionMatrix();
+        renderer.setSize(canvas.clientWidth, canvas.clientHeight);
+      });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // TEST RUNNER
+    // ═══════════════════════════════════════════════════════════════════════════
+    async function runAllTests() {
+      if (isRunning) return;
+      isRunning = true;
+      startTime = Date.now();
+      currentTestResults = [];
+      clearLog();
+      clearMeshes();
+      updateStats();
+      addLog('Starting test suite...', 'info');
+      let totalTests = 0;
+      let passCount = 0;
+      let failCount = 0;
+      let skipCount = 0;
+      for (const [category, tests] of Object.entries(testSuites)) {
+        addLog(`\n[${category}]`, 'info');
+        for (const test of tests) {
+          totalTests++;
+          const index = totalTests;
+          const progress = (index / Object.values(testSuites).flat().length) * 100;
+          updateProgress(progress);
+          try {
+            const startTest = performance.now();
+            const result = await test.fn();
+            const elapsed = (performance.now() - startTest).toFixed(2);
+            addLog(`✓ ${test.name} (${elapsed}ms)`, 'pass');
+            currentTestResults.push({
+              category,
+              name: test.name,
+              status: 'pass',
+              elapsed
+            });
+            passCount++;
+            // Visualize result
+            if (result && result.shape && result.id) {
+              visualizeShape(result.shape, test.name);
+            }
+          } catch (err) {
+            addLog(`✗ ${test.name}: ${err.message}`, 'fail');
+            currentTestResults.push({
+              category,
+              name: test.name,
+              status: 'fail',
+              error: err.message
+            });
+            failCount++;
+          }
+          updateStats();
+        }
+      }
+      const totalTime = (Date.now() - startTime).toFixed(0);
+      addLog(`\n=== SUMMARY ===`, 'info');
+      addLog(`Passed: ${passCount}/${totalTests}`, passCount === totalTests ? 'pass' : 'warn');
+      addLog(`Failed: ${failCount}/${totalTests}`, failCount === 0 ? 'pass' : 'fail');
+      addLog(`Time: ${totalTime}ms`, 'info');
+      updateProgress(100);
+      isRunning = false;
+    }
+    function visualizeShape(shape, label) {
+      if (!window.THREE) return;
+      try {
+        // Create simple visualization (actual implementation would tessellate the shape)
+        const geometry = new THREE.BoxGeometry(Math.random() * 50 + 25, Math.random() * 50 + 25, Math.random() * 50 + 25);
+        const material = new THREE.MeshStandardMaterial({
+          color: Math.random() * 0xffffff,
+          metalness: 0.3,
+          roughness: 0.7
+        });
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.position.set(
+          (Math.random() - 0.5) * 300,
+          (Math.random() - 0.5) * 300,
+          (Math.random() - 0.5) * 300
+        );
+        scene.add(mesh);
+        meshes.push(mesh);
+        if (meshes.length > 10) {
+          const old = meshes.shift();
+          scene.remove(old);
+        }
+      } catch (err) {
+        console.error('Visualization error:', err);
+      }
+    }
+    function clearMeshes() {
+      for (const mesh of meshes) {
+        scene.remove(mesh);
+      }
+      meshes = [];
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // UI FUNCTIONS
+    // ═══════════════════════════════════════════════════════════════════════════
+    function addLog(message, type = 'info') {
+      const log = document.getElementById('testLog');
+      const entry = document.createElement('div');
+      entry.className = `log-entry ${type} show`;
+      entry.textContent = message;
+      log.appendChild(entry);
+      log.scrollTop = log.scrollHeight;
+    }
+    function clearLog() {
+      document.getElementById('testLog').innerHTML = '';
+    }
+    function updateProgress(percent) {
+      const fill = document.getElementById('progressFill');
+      fill.style.width = percent + '%';
+      fill.textContent = Math.round(percent) + '%';
+    }
+    function updateStats() {
+      const results = currentTestResults;
+      const pass = results.filter(r => r.status === 'pass').length;
+      const fail = results.filter(r => r.status === 'fail').length;
+      const skip = results.filter(r => r.status === 'skip').length;
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      document.getElementById('passCount').textContent = pass;
+      document.getElementById('failCount').textContent = fail;
+      document.getElementById('skipCount').textContent = skip;
+      document.getElementById('timeCount').textContent = elapsed + 's';
+    }
+    function exportResults() {
+      const json = JSON.stringify(currentTestResults, null, 2);
+      const blob = new Blob([json], {type: 'application/json'});
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement('a');
+      link.href = url;
+      link.download = `brep-test-results-${Date.now()}.json`;
+      link.click();
+      URL.revokeObjectURL(url);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // INITIALIZATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    async function init() {
+      addLog('Initializing B-Rep Kernel...', 'info');
+      kernel = new BRepKernel();
+      try {
+        await kernel.init((loaded, total, percent) => {
+          document.getElementById('viewportInfo').textContent = `Downloading WASM: ${percent}%`;
+        });
+        addLog('B-Rep Kernel initialized successfully', 'pass');
+        document.getElementById('viewportInfo').textContent = 'Ready to test';
+        // Build category UI
+        buildCategoryUI();
+      } catch (err) {
+        addLog(`Failed to initialize: ${err.message}`, 'fail');
+      }
+    }
+    function buildCategoryUI() {
+      const container = document.getElementById('categories');
+      for (const [category, tests] of Object.entries(testSuites)) {
+        const categoryDiv = document.createElement('div');
+        categoryDiv.className = 'category';
+        const title = document.createElement('div');
+        title.className = 'category-title';
+        title.textContent = category + ` (${tests.length})`;
+        title.onclick = () => {
+          title.classList.toggle('active');
+          testList.classList.toggle('active');
+        };
+        const testList = document.createElement('div');
+        testList.className = 'test-list';
+        for (const test of tests) {
+          const item = document.createElement('div');
+          item.className = 'test-item';
+          item.textContent = test.name;
+          testList.appendChild(item);
+        }
+        categoryDiv.appendChild(title);
+        categoryDiv.appendChild(testList);
+        container.appendChild(categoryDiv);
+      }
+    }
+    // Global functions for HTML
+    window.runAllTests = runAllTests;
+    window.clearLog = clearLog;
+    window.exportResults = exportResults;
+    // Start
+    initThreeJS();
+    init();
+  </script>
+</body>
+</html>