dsh-cad 0.13.2 → 0.14.0

package/lib/modeling/modeling-worker.cjs

@@ -166,8 +166,8 @@ async function applyOp(op) {
     }
     case 'loft': {
       const bodyId = op.bodyId
-      const shape = adapter.makeLoft(op.sections, { solid: op.solid, ruled: op.ruled })
-      assertUsable(shape, 'loft', '检查各截面是否闭合、点数是否合理')
+      const shape = adapter.makeLoft(op.sections, { solid: op.solid, ruled: op.ruled, smooth: op.smooth })
+      assertUsable(shape, 'loft', '检查各截面是否闭合、点数是否合理；平滑截面要求截面点共面且不重复')
       bodies.set(bodyId, { shape, name: op.name ?? bodyId })
       return { bodyId, name: bodies.get(bodyId).name, mesh: meshOf(shape, bodies.get(bodyId).name) }
     }

package/lib/modeling/occt-adapter.cjs

@@ -319,18 +319,105 @@ function createAdapter(occt) {
     return face
   }
 
+  /**
+   * Closed Catmull-Rom polyline through the given flat [x,y,z, …] points,
+   * sampled at `samples` chords per span. This build has no curve→edge
+   * binding, so the occt.ts backend's periodic B-spline section is carried
+   * here as a dense closed polyline (the same approximation the bspline
+   * profile segment uses) — the loft still smooths across sections.
+   */
+  function smoothLoop(points, samples = 16) {
+    if (!Array.isArray(points) || points.length < 9 || points.length % 3 !== 0) {
+      throw new Error('a section needs at least 3 [x,y,z] triplets (≥9 numbers)')
+    }
+    const n = points.length / 3
+    const at = (i) => {
+      const k = ((i % n) + n) % n
+      return [points[k * 3], points[k * 3 + 1], points[k * 3 + 2]]
+    }
+    const out = []
+    for (let i = 0; i < n; i++) {
+      const p0 = at(i - 1)
+      const p1 = at(i)
+      const p2 = at(i + 1)
+      const p3 = at(i + 2)
+      for (let s = 0; s < samples; s++) {
+        const t = s / samples
+        const t2 = t * t
+        const t3 = t2 * t
+        for (let axis = 0; axis < 3; axis++) {
+          out.push(0.5 * (
+            2 * p1[axis]
+            + (-p0[axis] + p2[axis]) * t
+            + (2 * p0[axis] - 5 * p1[axis] + 4 * p2[axis] - p3[axis]) * t2
+            + (-p0[axis] + 3 * p1[axis] - 3 * p2[axis] + p3[axis]) * t3
+          ))
+        }
+      }
+    }
+    return closedWire(out)
+  }
+
+  const sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
+  const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+  const cross3 = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
+  const norm3 = (a) => {
+    const len = Math.hypot(a[0], a[1], a[2]) || 1
+    return [a[0] / len, a[1] / len, a[2] / len]
+  }
+
+  /** Plane frame (origin, in-plane X, in-plane Y) for a planar curve section. */
+  function sectionFrame(section) {
+    const at = section.at ?? [0, 0, 0]
+    if (!Array.isArray(at) || at.length !== 3) throw new Error('section.at must be [x,y,z]')
+    const n = norm3(Array.isArray(section.normal) ? section.normal : [0, 0, 1])
+    const seed = Array.isArray(section.xAxis) ? section.xAxis : [1, 0, 0]
+    let u = sub3(seed, n.map((c) => c * dot3(seed, n)))
+    if (Math.hypot(u[0], u[1], u[2]) < 1e-9) {
+      const alt = Math.abs(n[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]
+      u = sub3(alt, n.map((c) => c * dot3(alt, n)))
+    }
+    u = norm3(u)
+    return [at, u, cross3(n, u)]
+  }
+
+  /**
+   * One loft section → a closed wire.
+   *   [x,y,z, …]                     flat point loop (polygon, or smooth spline)
+   *   { points: […], smooth?: bool } same, with a per-section override
+   *   { through: [x,y,z, …] }        smooth curve through the points
+   *   { profile, at?, normal?, xAxis? }  2D curve profile placed in a plane
+   */
+  function sectionWire(section, smoothDefault) {
+    if (Array.isArray(section)) return smoothDefault ? smoothLoop(section) : closedWire(section)
+    if (section === null || typeof section !== 'object') {
+      throw new Error('a loft section must be a flat [x,y,z,…] loop or a {points|through|profile, …} object')
+    }
+    if (section.profile !== undefined) {
+      const [o3, u3, v3] = sectionFrame(section)
+      return profileWire(section.profile, o3, u3, v3)
+    }
+    if (section.through !== undefined) return smoothLoop(section.through)
+    if (section.points !== undefined) {
+      return (section.smooth ?? smoothDefault) ? smoothLoop(section.points) : closedWire(section.points)
+    }
+    throw new Error('a section object needs `points`, `through` or `profile`')
+  }
+
   /**
    * Loft: skin a solid through successive closed sections (OCCT ThruSections).
-   * `sections` is a list of flat [x,y,z, …] loops, in order along the loft.
-   * `solid` caps the ends, `ruled` keeps the sides straight (no smoothing).
+   * Sections are flat [x,y,z, …] loops or section objects (see sectionWire);
+   * `smooth` fits a periodic B-spline through plain point loops on the occt.ts
+   * backend, `solid` caps the ends, `ruled` keeps the sides straight.
    */
   function makeLoft(sections, options = {}) {
     if (!Array.isArray(sections) || sections.length < 2) throw new Error('a loft needs at least 2 sections')
     const solid = options.solid ?? true
     const ruled = options.ruled ?? false
+    const smooth = options.smooth === true
     // Verified spelling: this build binds only the 3-argument constructor.
     const thru = new occt.BRepOffsetAPI_ThruSections(solid, ruled, 1e-6)
-    for (const section of sections) thru.AddWire(closedWire(section))
+    for (const section of sections) thru.AddWire(sectionWire(section, smooth))
     thru.Build()
     if (!thru.IsDone()) throw new Error('loft failed (check that the sections are closed and non-degenerate)')
     return thru.Shape()

package/lib/modeling/occtts-adapter.cjs

@@ -174,9 +174,11 @@ function createOcctTsAdapter(mod) {
     const parts = new mod.VectorShape()
     try {
       let cur = [profile.start[0], profile.start[1]]
+      const pushed = []
       const push = (shape) => {
         if (shape.isNull()) throw wrapError('segment edge', new Error('null edge'))
         parts.push_back(shape)
+        pushed.push(shape)
       }
       for (const seg of segs) {
         if (seg === null || typeof seg !== 'object') throw new Error('each profile segment must be an object')
@@ -222,6 +224,12 @@ function createOcctTsAdapter(mod) {
       if (Math.hypot(cur[0] - profile.start[0], cur[1] - profile.start[1]) > 1e-9) {
         push(mod.makeLine(cur[0], cur[1], 0, profile.start[0], profile.start[1], 0))
       }
+      if (pushed.length === 1) {
+        // A single closed B-spline already IS a wire; makeWire needs ≥2 parts.
+        // (A lone edge cannot close a profile — say so instead of a kernel error.)
+        if (typeof pushed[0].shapeType === 'function' && pushed[0].shapeType() === 'Wire') return pushed[0]
+        throw new Error('a segment profile needs at least 2 segments (a single open edge cannot close a loop)')
+      }
       const wire = mod.makeWire(parts)
       if (wire.isNull()) throw wrapError('makeWire', new Error('null wire'))
       return wire
@@ -241,17 +249,82 @@ function createOcctTsAdapter(mod) {
     return solid
   }
 
-  /** Loft through closed 3D section wires. */
+  // ── loft sections: point loops, smooth curves, planar profiles ─────────────
+  /**
+   * Closed wire through a flat [x,y,z, …] loop: a polygon (the historical
+   * section) or — with `smooth` — a PERIODIC B-spline interpolating every
+   * point. The periodic spline has no start/end vertex, so a loft skinned over
+   * it carries no crease lines: the lateral face is a single smooth B-spline
+   * surface instead of one planar strip per polygon edge.
+   */
+  function loopWire(xyz, smooth) {
+    if (!Array.isArray(xyz) || xyz.length < 9 || xyz.length % 3 !== 0) {
+      throw new Error('a section needs at least 3 [x,y,z] triplets (≥9 numbers)')
+    }
+    if (!smooth) return polygonWireXY(xyz)
+    const { ptr, free } = mallocF64(xyz)
+    try {
+      const wire = mod.makeBsplineThrough(ptr, xyz.length / 3, true, 1e-6)
+      if (wire.isNull()) throw wrapError('smooth section', new Error('periodic B-spline construction failed'))
+      return wire
+    } finally {
+      free()
+    }
+  }
+
+  /** Plane frame (origin, in-plane X, in-plane Y) for a planar curve section. */
+  function sectionFrame(section) {
+    const at = section.at ?? [0, 0, 0]
+    if (!Array.isArray(at) || at.length !== 3) throw new Error('section.at must be [x,y,z]')
+    const n = vec3.norm(Array.isArray(section.normal) ? section.normal : [0, 0, 1])
+    const seed = Array.isArray(section.xAxis) ? section.xAxis : [1, 0, 0]
+    const d = vec3.dot(seed, n)
+    let u = [seed[0] - n[0] * d, seed[1] - n[1] * d, seed[2] - n[2] * d]
+    if (Math.hypot(u[0], u[1], u[2]) < 1e-9) {
+      // xAxis parallel to the normal — fall back to a stable perpendicular.
+      const alt = Math.abs(n[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]
+      const d2 = vec3.dot(alt, n)
+      u = [alt[0] - n[0] * d2, alt[1] - n[1] * d2, alt[2] - n[2] * d2]
+    }
+    u = vec3.norm(u)
+    // v = n × u so that u × v = n — profileWire's (u,v) → plane mapping stays
+    // right-handed and profile +Y points along the plane normal cross X.
+    return [at, u, vec3.cross(n, u)]
+  }
+
+  /**
+   * One loft section → a closed wire.
+   *   [x,y,z, …]                     flat point loop (polygon, or smooth B-spline)
+   *   { points: […], smooth?: bool } same, with a per-section override
+   *   { through: [x,y,z, …] }        periodic B-spline through the points
+   *   { profile, at?, normal?, xAxis? }  2D curve profile placed in a plane
+   */
+  function sectionWire(section, smoothDefault) {
+    if (Array.isArray(section)) return loopWire(section, smoothDefault)
+    if (section === null || typeof section !== 'object') {
+      throw new Error('a loft section must be a flat [x,y,z,…] loop or a {points|through|profile, …} object')
+    }
+    if (section.profile !== undefined) {
+      const [o3, u3, v3] = sectionFrame(section)
+      return profileWire(section.profile, o3, u3, v3)
+    }
+    if (section.through !== undefined) return loopWire(section.through, true)
+    if (section.points !== undefined) return loopWire(section.points, section.smooth ?? smoothDefault)
+    throw new Error('a section object needs `points`, `through` or `profile`')
+  }
+
+  /**
+   * Loft through closed 3D sections. `smooth: true` turns plain point loops
+   * into periodic B-splines, which is what makes a crease-free skin: OCCT
+   * skins a B-spline surface through continuous sections, while polygon
+   * sections leave a G0 crease along every polygon edge.
+   */
   function makeLoft(sections, options = {}) {
     if (!Array.isArray(sections) || sections.length < 2) throw new Error('a loft needs at least 2 sections')
+    const smooth = options.smooth === true
     const v = new mod.VectorShape()
     try {
-      for (const section of sections) {
-        if (!Array.isArray(section) || section.length < 9 || section.length % 3 !== 0) {
-          throw new Error('each section must be a flat [x,y,z,…] loop (≥9 numbers)')
-        }
-        v.push_back(polygonWireXY(section))
-      }
+      for (const section of sections) v.push_back(sectionWire(section, smooth))
       const solid = mod.loft(v, options.ruled ?? false, options.solid ?? true)
       if (solid.isNull()) throw wrapError('loft', new Error('null shape'))
       if (Math.abs(volume(solid)) < 1e-9) {

package/lib/routes.js

@@ -166,6 +166,11 @@ export function registerDocsRoute(server, registry, binStore) {
                     name: doc.name,
                     bodies: doc.bodyCount,
                     updatedAt: doc.updatedAt,
+                    // Op count: the panel's liveness signal. It polls this list and
+                    // re-fetches the scene when the tracked document's version moves,
+                    // so the viewport follows modeling ops even when the conversation
+                    // meta pipeline is stale (host UI drift).
+                    version: doc.opCount,
                     // Preview URL only when a published scene exists (memory or mirror).
                     ...(await binStore.has(doc.id) ? { sceneUrl: `${BIN_ROUTE_PATH}/${doc.id}` } : {}),
                 })));

package/lib/tools/cad-model.js

@@ -792,16 +792,18 @@ export function createModelTools(deps) {
     });
     const cadLoft = defineTool({
         name: 'cad_loft',
-        description: 'Loft (放样): skin a solid through successive closed sections. `sections` is a list of ≥2 loops, each a flat [x0,y0,z0, x1,y1,z1, …] triplet list in its own plane (≥3 points, auto-closed), ordered along the loft. ' +
-            'Sections may differ in shape and point count (e.g. a square lofted to a hexagon). `ruled` keeps the sides straight instead of smoothing. ' +
+        description: 'Loft (放样): skin a solid through successive closed sections (≥2), ordered along the loft. Each section is either a flat [x0,y0,z0, x1,y1,z1, …] point loop, or an object: {points:[…], smooth?:true}, {through:[…]} (closed B-spline interpolating the points), or {profile, at?, normal?, xAxis?} — a 2D curve profile (flat [x,y], {start,segments:[line|arc|bspline]}, or {circle:{center,radius}}) laid in its own plane. ' +
+            'For a CREASE-FREE surface pass `smooth: true` (or a curve section): a polygon-section loft is planar strips meeting at G0 creases, while a periodic B-spline / NURBS section skims ONE continuous B-spline lateral face. ' +
+            'Sections may differ in shape and point count (e.g. a square lofted to a hexagon); `ruled` keeps the sides straight instead of smoothing. ' +
             'Each result passes a BRepCheck validity gate: a self-intersecting or degenerate loft is rejected with a clear message instead of storing an unusable body.',
         parameters: {
             sections: {
                 type: 'array',
                 required: true,
-                description: 'Ordered sections, each a flat [x,y,z,…] loop (≥9 numbers).',
-                items: { type: 'array', items: { type: 'number' }, description: 'One closed section loop.' },
+                description: 'Ordered sections (≥2): each a flat [x,y,z,…] loop (≥9 numbers) or a section object {points|through|profile, at?, normal?, xAxis?, smooth?}.',
+                items: { type: 'json', description: 'One closed section loop or section object.' },
             },
+            smooth: { type: 'boolean', description: 'Fit a periodic B-spline through each plain point loop — the crease-free "NURBS section" loft (default false).' },
             ruled: { type: 'boolean', description: 'Straight (ruled) sides instead of a smoothed surface (default false).' },
             solid: { type: 'boolean', description: 'Cap the ends into a solid (default true).' },
             name: { type: 'string', description: 'Optional display name.' },
@@ -824,8 +826,17 @@ export function createModelTools(deps) {
             await resolveDoc(exec);
             if (!Array.isArray(args.sections) || args.sections.length < 2)
                 throw new Error('sections must list at least 2 closed loops');
+            for (const section of args.sections) {
+                if (Array.isArray(section)) {
+                    if (section.length < 9 || section.length % 3 !== 0)
+                        throw new Error('a point loop section needs ≥3 [x,y,z] triplets (≥9 numbers)');
+                }
+                else if (section === null || typeof section !== 'object') {
+                    throw new Error('each section must be a flat [x,y,z,…] loop or a {points|through|profile, …} object');
+                }
+            }
             const bodyId = nextBodyId();
-            const op = { kind: 'loft', bodyId, sections: args.sections, solid: args.solid, ruled: args.ruled, name: args.name };
+            const op = { kind: 'loft', bodyId, sections: args.sections, solid: args.solid, ruled: args.ruled, smooth: args.smooth, name: args.name };
             const result = await runModelOp(op);
             return syncScene(op, result);
         },

package/lib/types/modeling/client.d.ts

@@ -61,6 +61,23 @@ export interface DrawingViewSpec {
     dir: [number, number, number];
     xDir: [number, number, number];
 }
+/** One loft section: a flat world-space loop, or a curve/profile section. */
+export type LoftSection = number[] | {
+    /** Flat [x,y,z, …] loop (polygon, or a smooth B-spline when `smooth`). */
+    points?: number[];
+    /** Flat [x,y,z, …] points interpolated by a closed B-spline. */
+    through?: number[];
+    /** 2D profile (flat [x,y,…], {start,segments}, or {circle}) in the section plane. */
+    profile?: unknown;
+    /** Plane origin for `profile` (default world origin). */
+    at?: [number, number, number];
+    /** Plane normal for `profile` (default +Z). */
+    normal?: [number, number, number];
+    /** In-plane X axis for `profile` (default world +X projected). */
+    xAxis?: [number, number, number];
+    /** Override the loft-level `smooth` flag for this section. */
+    smooth?: boolean;
+};
 export type ModelOp = {
     kind: 'create_prim';
     bodyId: string;
@@ -79,9 +96,10 @@ export type ModelOp = {
 } | {
     kind: 'loft';
     bodyId: string;
-    sections: number[][];
+    sections: LoftSection[];
     solid?: boolean;
     ruled?: boolean;
+    smooth?: boolean;
     name?: string;
 } | {
     kind: 'revolve';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-cad",
   "description": "CAD visualization plugin for DeepSeek Harness: cad_view / cad_info tools with an embedded 3D (STL/OBJ/STEP/IGES) and 2D (DXF/SVG) viewer card in the Web UI",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "type": "module",
   "license": "MIT",
   "author": "LAU-MARS",