Fix Vercel deployment, address PR review comments, and add new bindings

- Add vercel.json to run build and serve from build/ directory
- Add .nvmrc (Node 20) for Vercel compatibility
- Fix TypeScript intellisense: match ofType() docs to actual enum values
- Remove dead golden-layout code from postinstall.js
- Add zero-vector validation in Section() and _normalize()
- Add backward compat for loading old GoldenLayout project files
- Rewrite selector helpers to use proper OCCT API (BRepAdaptor, GeomAbs enums)
- Update tests for new binding-based implementations

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: zalo

.nvmrc

@@ -0,0 +1 @@
+20

js/CADWorker/CascadeStudioStandardLibrary.js

@@ -952,74 +952,24 @@ function _edgeLength(edge) {
 }
 
 function _edgeCurveType(edge) {
-  // Sample 3 points along the edge to determine curve type geometrically
-  // (GetType() is unavailable — GeomAbs_CurveType enum is unbound)
   let curve = new self.oc.BRepAdaptor_Curve_2(edge);
-  let u0 = curve.FirstParameter(), u1 = curve.LastParameter();
-  let p0 = new self.oc.gp_Pnt_1(), p1 = new self.oc.gp_Pnt_1(), p2 = new self.oc.gp_Pnt_1();
-  curve.D0(u0, p0); curve.D0((u0 + u1) / 2, p1); curve.D0(u1, p2);
-  let a = [p0.X(), p0.Y(), p0.Z()];
-  let b = [p1.X(), p1.Y(), p1.Z()];
-  let c = [p2.X(), p2.Y(), p2.Z()];
-
-  // Check collinearity: if cross product of (b-a) and (c-a) is ~zero → Line
-  let ab = [b[0]-a[0], b[1]-a[1], b[2]-a[2]];
-  let ac = [c[0]-a[0], c[1]-a[1], c[2]-a[2]];
-  let cross = [
-    ab[1]*ac[2] - ab[2]*ac[1],
-    ab[2]*ac[0] - ab[0]*ac[2],
-    ab[0]*ac[1] - ab[1]*ac[0]
-  ];
-  let crossMag = Math.sqrt(cross[0]*cross[0] + cross[1]*cross[1] + cross[2]*cross[2]);
-  let abMag = Math.sqrt(ab[0]*ab[0] + ab[1]*ab[1] + ab[2]*ab[2]);
-  if (abMag < 1e-10 || crossMag / abMag < 1e-6) { return "Line"; }
-
-  // Check if it's a circle: sample more points and check equal distance from center
-  let nSamples = 8;
-  let pts = [];
-  for (let i = 0; i <= nSamples; i++) {
-    let u = u0 + (u1 - u0) * i / nSamples;
-    let p = new self.oc.gp_Pnt_1();
-    curve.D0(u, p);
-    pts.push([p.X(), p.Y(), p.Z()]);
-  }
-  // Approximate center as average of all points
-  let cx = 0, cy = 0, cz = 0;
-  for (let p of pts) { cx += p[0]; cy += p[1]; cz += p[2]; }
-  cx /= pts.length; cy /= pts.length; cz /= pts.length;
-  // Check if all distances from center are approximately equal
-  let dists = pts.map(p => Math.sqrt((p[0]-cx)**2 + (p[1]-cy)**2 + (p[2]-cz)**2));
-  let avgDist = dists.reduce((s,d) => s+d, 0) / dists.length;
-  let maxDeviation = Math.max(...dists.map(d => Math.abs(d - avgDist)));
-  if (avgDist > 1e-10 && maxDeviation / avgDist < 0.01) { return "Circle"; }
-
+  let type = curve.GetType();
+  let CT = self.oc.GeomAbs_CurveType;
+  if (type === CT.GeomAbs_Line)        return "Line";
+  if (type === CT.GeomAbs_Circle)      return "Circle";
+  if (type === CT.GeomAbs_Ellipse)     return "Ellipse";
+  if (type === CT.GeomAbs_Hyperbola)   return "Hyperbola";
+  if (type === CT.GeomAbs_Parabola)    return "Parabola";
+  if (type === CT.GeomAbs_BezierCurve) return "BezierCurve";
+  if (type === CT.GeomAbs_BSplineCurve) return "BSplineCurve";
   return "Other";
 }
 
 function _edgeDirection(edge) {
-  // Compute direction from start and end points (no GetType() needed)
   let curve = new self.oc.BRepAdaptor_Curve_2(edge);
-  let u0 = curve.FirstParameter(), u1 = curve.LastParameter();
-  let p0 = new self.oc.gp_Pnt_1(), p1 = new self.oc.gp_Pnt_1(), p2 = new self.oc.gp_Pnt_1();
-  curve.D0(u0, p0); curve.D0((u0 + u1) / 2, p1); curve.D0(u1, p2);
-
-  // Check if the edge is a line (collinear points)
-  let a = [p0.X(), p0.Y(), p0.Z()];
-  let b = [p1.X(), p1.Y(), p1.Z()];
-  let c = [p2.X(), p2.Y(), p2.Z()];
-  let ab = [b[0]-a[0], b[1]-a[1], b[2]-a[2]];
-  let ac = [c[0]-a[0], c[1]-a[1], c[2]-a[2]];
-  let cross = [
-    ab[1]*ac[2] - ab[2]*ac[1],
-    ab[2]*ac[0] - ab[0]*ac[2],
-    ab[0]*ac[1] - ab[1]*ac[0]
-  ];
-  let crossMag = Math.sqrt(cross[0]*cross[0] + cross[1]*cross[1] + cross[2]*cross[2]);
-  let abMag = Math.sqrt(ab[0]*ab[0] + ab[1]*ab[1] + ab[2]*ab[2]);
-  if (abMag < 1e-10) { return null; }
-  if (crossMag / abMag > 1e-6) { return null; } // Not a line
-
-  return _normalize(ac);
+  if (curve.GetType() !== self.oc.GeomAbs_CurveType.GeomAbs_Line) return null;
+  let dir = curve.Line().Direction();
+  return [dir.X(), dir.Y(), dir.Z()];
 }
 
 function _faceCentroid(face) {
@@ -1036,81 +986,17 @@ function _faceArea(face) {
 }
 
 function _faceNormal(face) {
-  // Compute face normal from edge geometry (BRepAdaptor_Surface not available)
-  // Sample 3 non-collinear points from the face's edges to determine normal
-  try {
-    let points = [];
-    let explorer = new self.oc.TopExp_Explorer_2(
-      face, self.oc.TopAbs_ShapeEnum.TopAbs_EDGE, self.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    while (explorer.More() && points.length < 10) {
-      let edge = self.oc.TopoDS.Edge_1(explorer.Current());
-      let curve = new self.oc.BRepAdaptor_Curve_2(edge);
-      let u0 = curve.FirstParameter(), u1 = curve.LastParameter();
-      for (let t of [0, 0.5, 1]) {
-        let p = new self.oc.gp_Pnt_1();
-        curve.D0(u0 + (u1 - u0) * t, p);
-        points.push([p.X(), p.Y(), p.Z()]);
-      }
-      explorer.Next();
-    }
-    // Find 3 non-collinear points
-    if (points.length < 3) { return [0, 0, 1]; }
-    let a = points[0];
-    for (let i = 1; i < points.length; i++) {
-      let ab = [points[i][0]-a[0], points[i][1]-a[1], points[i][2]-a[2]];
-      let abLen = _vecLength(ab);
-      if (abLen < 1e-10) continue;
-      for (let j = i + 1; j < points.length; j++) {
-        let ac = [points[j][0]-a[0], points[j][1]-a[1], points[j][2]-a[2]];
-        let cross = [
-          ab[1]*ac[2] - ab[2]*ac[1],
-          ab[2]*ac[0] - ab[0]*ac[2],
-          ab[0]*ac[1] - ab[1]*ac[0]
-        ];
-        let crossMag = _vecLength(cross);
-        if (crossMag > 1e-8) {
-          return _normalize(cross);
-        }
-      }
-    }
-    return [0, 0, 1]; // Fallback (degenerate face)
-  } catch (e) {
-    return [0, 0, 1]; // Fallback
-  }
-}
-
-function _isFacePlanar(face) {
-  // Check if all sampled points on the face lie on a plane
-  try {
-    let points = [];
-    let explorer = new self.oc.TopExp_Explorer_2(
-      face, self.oc.TopAbs_ShapeEnum.TopAbs_EDGE, self.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    while (explorer.More()) {
-      let edge = self.oc.TopoDS.Edge_1(explorer.Current());
-      let curve = new self.oc.BRepAdaptor_Curve_2(edge);
-      let u0 = curve.FirstParameter(), u1 = curve.LastParameter();
-      for (let t = 0; t <= 1; t += 0.25) {
-        let p = new self.oc.gp_Pnt_1();
-        curve.D0(u0 + (u1 - u0) * t, p);
-        points.push([p.X(), p.Y(), p.Z()]);
-      }
-      explorer.Next();
-    }
-    if (points.length < 3) { return true; }
-    // Get the normal from first 3 non-collinear points
-    let normal = _faceNormal(face);
-    if (_vecLength(normal) < 1e-10) { return true; }
-    // Check all points lie on the plane defined by points[0] and normal
-    let d = _dot(points[0], normal);
-    for (let p of points) {
-      if (Math.abs(_dot(p, normal) - d) > 1e-4) { return false; }
-    }
-    return true;
-  } catch (e) {
-    return false;
-  }
+  let surf = new self.oc.BRepAdaptor_Surface_2(face, true);
+  let uMid = (surf.FirstUParameter() + surf.LastUParameter()) / 2;
+  let vMid = (surf.FirstVParameter() + surf.LastVParameter()) / 2;
+  let pnt = new self.oc.gp_Pnt_1();
+  let du = new self.oc.gp_Vec_1();
+  let dv = new self.oc.gp_Vec_1();
+  surf.D1(uMid, vMid, pnt, du, dv);
+  let normal = du.Crossed(dv);
+  let mag = normal.Magnitude();
+  if (mag < 1e-10) return [0, 0, 1];
+  return [normal.X() / mag, normal.Y() / mag, normal.Z() / mag];
 }
 
 function _dot(a, b) {
@@ -1123,7 +1009,7 @@ function _vecLength(v) {
 
 function _normalize(v) {
   let len = _vecLength(v);
-  if (len < 1e-10) { return [0, 0, 0]; }
+  if (len < 1e-10) { throw new Error("Cannot normalize a zero-length vector; check your axis parameter"); }
   return [v[0] / len, v[1] / len, v[2] / len];
 }
 
@@ -1324,16 +1210,21 @@ class FaceSelector {
   // --- Filtering ---
 
   ofType(type) {
-    // BRepAdaptor_Surface not available in bindings — use geometry heuristics
+    let ST = self.oc.GeomAbs_SurfaceType;
+    let typeMap = {
+      "Plane": ST.GeomAbs_Plane,
+      "Cylinder": ST.GeomAbs_Cylinder,
+      "Cone": ST.GeomAbs_Cone,
+      "Sphere": ST.GeomAbs_Sphere,
+      "Torus": ST.GeomAbs_Torus,
+      "BSplineSurface": ST.GeomAbs_BSplineSurface,
+      "BezierSurface": ST.GeomAbs_BezierSurface,
+    };
+    let target = typeMap[type];
     let sel = this._clone();
     sel._entries = sel._entries.filter(e => {
-      let normal = _faceNormal(e.face);
-      if (type === "Plane") {
-        // A planar face has consistent normals at all edge points
-        return _isFacePlanar(e.face);
-      }
-      // Other types not reliably detectable without BRepAdaptor_Surface
-      return false;
+      let surf = new self.oc.BRepAdaptor_Surface_2(e.face, true);
+      return surf.GetType() === target;
     });
     return sel;
   }
@@ -1505,59 +1396,14 @@ function Wedge(dx, dy, dz, ltx) {
 function Section(shape, planeOrigin, planeNormal) {
   if (!planeNormal) { planeNormal = [0, 0, 1]; }
   if (!planeOrigin) { planeOrigin = [0, 0, 0]; }
+  if (_vecLength(planeNormal) < 1e-10) { throw new Error("Section: planeNormal must be a non-zero vector"); }
   let curSection = self.CacheOp(arguments, "Section", () => {
-    // Create a very thin slab at the cutting plane and intersect with shape.
-    // (gp_Pln and BRepAlgoAPI_Section are not available in the bindings.)
-    let n = _normalize(planeNormal);
-    let thickness = 1e-3;
-    // Create a large box centered at origin
-    let slab = new self.oc.BRepPrimAPI_MakeBox_4(
-      new self.oc.gp_Pnt_3(-1e4, -1e4, -thickness / 2),
-      new self.oc.gp_Pnt_3( 1e4,  1e4,  thickness / 2)
-    ).Shape();
-    // Rotate slab to align Z-axis with planeNormal
-    if (Math.abs(n[2] - 1.0) > 1e-8) {
-      // Need to rotate: find rotation axis (cross product of Z and normal)
-      let zAxis = [0, 0, 1];
-      let rotAxis = [
-        zAxis[1]*n[2] - zAxis[2]*n[1],
-        zAxis[2]*n[0] - zAxis[0]*n[2],
-        zAxis[0]*n[1] - zAxis[1]*n[0]
-      ];
-      let rotAxisLen = _vecLength(rotAxis);
-      if (rotAxisLen > 1e-10) {
-        let angle = Math.acos(Math.max(-1, Math.min(1, _dot(zAxis, n))));
-        rotAxis = _normalize(rotAxis);
-        let ax1 = new self.oc.gp_Ax1_2(
-          new self.oc.gp_Pnt_3(0, 0, 0),
-          new self.oc.gp_Dir_4(rotAxis[0], rotAxis[1], rotAxis[2])
-        );
-        let trsf = new self.oc.gp_Trsf_1();
-        trsf.SetRotation_1(ax1, angle);
-        let brep = new self.oc.BRepBuilderAPI_Transform_2(slab, trsf, true);
-        slab = brep.Shape();
-      } else if (n[2] < 0) {
-        // Normal is [0,0,-1], rotate 180 degrees around X
-        let ax1 = new self.oc.gp_Ax1_2(
-          new self.oc.gp_Pnt_3(0, 0, 0),
-          new self.oc.gp_Dir_4(1, 0, 0)
-        );
-        let trsf = new self.oc.gp_Trsf_1();
-        trsf.SetRotation_1(ax1, Math.PI);
-        let brep = new self.oc.BRepBuilderAPI_Transform_2(slab, trsf, true);
-        slab = brep.Shape();
-      }
-    }
-    // Translate slab to planeOrigin
-    if (planeOrigin[0] !== 0 || planeOrigin[1] !== 0 || planeOrigin[2] !== 0) {
-      let trsf = new self.oc.gp_Trsf_1();
-      trsf.SetTranslation_1(new self.oc.gp_Vec_4(planeOrigin[0], planeOrigin[1], planeOrigin[2]));
-      let brep = new self.oc.BRepBuilderAPI_Transform_2(slab, trsf, true);
-      slab = brep.Shape();
-    }
-    // Intersect
-    let common = new self.oc.BRepAlgoAPI_Common_3(shape, slab, new self.oc.Message_ProgressRange_1());
-    return common.Shape();
+    let origin = new self.oc.gp_Pnt_3(planeOrigin[0], planeOrigin[1], planeOrigin[2]);
+    let normal = new self.oc.gp_Dir_4(planeNormal[0], planeNormal[1], planeNormal[2]);
+    let plane = new self.oc.gp_Pln_3(origin, normal);
+    let section = new self.oc.BRepAlgoAPI_Section_5(shape, plane, false);
+    section.Build(new self.oc.Message_ProgressRange_1());
+    return section.Shape();
   });
   self.sceneShapes.push(curSection);
   return curSection;

js/MainPage/CascadeMain.js

@@ -127,8 +127,13 @@ class CascadeStudioApp {
       try {
         let parsed = JSON.parse(projectContent);
         if (parsed._cascadeState) {
+          // New Dockview project format
           codeStr = parsed._cascadeState.code || codeStr;
           this.gui.state = parsed._cascadeState.guiState || {};
+        } else if (parsed.content || parsed.root) {
+          // Legacy GoldenLayout project format — extract code from componentState
+          let code = this._extractLegacyCode(parsed);
+          if (code) { codeStr = code; }
         }
       } catch (e) {
         console.error("Failed to parse project:", e);
@@ -326,6 +331,25 @@ class CascadeStudioApp {
     this.console.goldenContainer.setState({});
   }
 
+  /** Extract code from a legacy GoldenLayout project file. */
+  _extractLegacyCode(parsed) {
+    // Recursively search for componentState.code in GoldenLayout config
+    function findCode(obj) {
+      if (!obj || typeof obj !== 'object') return null;
+      if (obj.componentState && obj.componentState.code) return obj.componentState.code;
+      for (let key of ['content', 'root', 'children']) {
+        if (Array.isArray(obj[key])) {
+          for (let child of obj[key]) {
+            let result = findCode(child);
+            if (result) return result;
+          }
+        }
+      }
+      return null;
+    }
+    return findCode(parsed);
+  }
+
   // --- Static utility methods ---
 
   /** Get a new file handle via the File System Access API. */

js/StandardLibraryIntellisense.ts

@@ -238,7 +238,7 @@ function ChamferEdges(shape: oc.TopoDS_Shape, distance: number, edgeList: number
  * and call `.indices()` to get edge indices for FilletEdges/ChamferEdges.
  * @example```FilletEdges(box, 3, Edges(box).max([0,0,1]).indices());``` */
 class EdgeSelector {
-    /** Filter to edges of a specific curve type: "Line", "Circle", "Ellipse", "BSpline", "Bezier" */
+    /** Filter to edges of a specific curve type: "Line", "Circle", "Ellipse", "Hyperbola", "Parabola", "BezierCurve", "BSplineCurve" */
     ofType(type: string): EdgeSelector;
     /** Filter to edges whose direction is parallel to the given axis vector */
     parallel(axis: number[], tolerance?: number): EdgeSelector;
@@ -281,7 +281,7 @@ class EdgeSelector {
  * Use `Faces(shape)` to create a FaceSelector, then chain filtering methods.
  * @example```let topFace = Faces(box).max([0,0,1]).faces()[0];``` */
 class FaceSelector {
-    /** Filter to faces of a specific surface type: "Plane", "Cylinder", "Cone", "Sphere", "Torus", "BSpline" */
+    /** Filter to faces of a specific surface type: "Plane", "Cylinder", "Cone", "Sphere", "Torus", "BSplineSurface", "BezierSurface" */
     ofType(type: string): FaceSelector;
     /** Filter to faces whose normal is parallel to the given axis */
     parallel(axis: number[], tolerance?: number): FaceSelector;

scripts/postinstall.js

@@ -1,39 +1,13 @@
 /**
  * Postinstall script for CascadeStudio.
- * Bundles golden-layout ESM (which has extensionless imports) into a single browser-ready file.
+ * Bundles library ESM modules into single browser-ready files.
  */
 const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
 const root = path.join(__dirname, '..');
 const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-const glInput = path.join(root, 'node_modules', 'golden-layout', 'dist', 'esm', 'index.js');
-const glOutput = path.join(root, 'lib', 'golden-layout', 'golden-layout.js');
-
-// Bundle golden-layout ESM into a single file for buildless browser use
-if (fs.existsSync(glInput)) {
-  const glDir = path.dirname(glOutput);
-  if (!fs.existsSync(glDir)) { fs.mkdirSync(glDir, { recursive: true }); }
-
-  execFileSync(npx, [
-    'esbuild', glInput,
-    '--bundle', '--format=esm',
-    '--outfile=' + glOutput, '--sourcemap'
-  ], { cwd: root, stdio: 'inherit' });
-  console.log('  Bundled golden-layout ESM to', glOutput);
-
-  // Copy CSS files
-  const cssBase = path.join(root, 'node_modules', 'golden-layout', 'dist', 'css', 'goldenlayout-base.css');
-  const cssTheme = path.join(root, 'node_modules', 'golden-layout', 'dist', 'css', 'themes', 'goldenlayout-dark-theme.css');
-  if (fs.existsSync(cssBase)) {
-    fs.copyFileSync(cssBase, path.join(glDir, 'goldenlayout-base.css'));
-  }
-  if (fs.existsSync(cssTheme)) {
-    fs.copyFileSync(cssTheme, path.join(glDir, 'goldenlayout-dark-theme.css'));
-  }
-  console.log('  Copied golden-layout CSS files');
-}
 
 // Bundle dockview-core ESM into a single file for buildless browser use
 const dvInput = path.join(root, 'node_modules', 'dockview-core', 'dist', 'esm', 'index.js');