dsh-cad 0.8.0 → 0.9.0

package/lib/modeling/modeling-worker.cjs

@@ -13,7 +13,8 @@ const path = require('node:path')
 const fs = require('node:fs')
 const { createRequire } = require('node:module')
 const { createAdapter } = require('./occt-adapter.cjs')
-const { createOcctBridge } = require('./occt-bridge.cjs')
+const { createOcctTsAdapter } = require('./occtts-adapter.cjs')
+const { createOcctBridge, loadSharedOcctModule } = require('./occt-bridge.cjs')
 
 const require3 = createRequire(__filename)
 // The ES6 emscripten build reads a global __dirname when its factory runs.
@@ -23,8 +24,12 @@ const loaderPath = require3.resolve('opencascade.js/dist/opencascade.wasm.js')
 const loaderModule = require3(loaderPath)
 const wasmBinary = fs.readFileSync(path.join(path.dirname(loaderPath), 'opencascade.wasm.wasm'))
 
+// Kernel selection: occt.ts is the PRIMARY backend (single-kernel modeling,
+// true B-splines, shell/draft native, direct HLR); opencascade.js stays as
+// the fallback when occt.ts cannot load. `adapter` carries whichever.
 let adapter = null
 let occt = null
+let kernelName = 'occt.ts'
 
 /**
  * Reject a degenerate result BEFORE registering it: the kernel cannot
@@ -156,26 +161,21 @@ async function applyOp(op) {
       return { bodyId, name: bodies.get(bodyId).name, mesh: meshOf(shape, bodies.get(bodyId).name) }
     }
     case 'shell': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
-      const stepIn = body.step ?? adapter.exportFile(body.shape, 'step')
-      const bridge = await getOcctBridge()
-      if (bridge === null) throw new Error('shell requires the occt.ts kernel (>= 0.3.0) — reinstall dsh-cad so the dependency pulls it')
-      const out = bridge.hostedSolidOp('shell', stepIn, { thickness: op.thickness, openNormals: op.openNormals, faces: op.faces, name: body.name })
-      body.step = out.step
-      body.shape = null
-      return { bodyId: op.target, name: body.name, volume: out.volume, mesh: out.mesh }
+      const body = requireShape(op.target, 'shell')
+      if (typeof adapter.shell !== 'function') throw new Error('shell requires the occt.ts kernel backend — it is unavailable, reinstall dsh-cad')
+      const faces = Array.isArray(op.faces) && op.faces.length > 0 ? op.faces : matchFacesByNormal(body.shape, op.openNormals)
+      const shape = adapter.shell(body.shape, op.thickness, faces)
+      assertUsable(shape, 'shell', '检查壁厚是否超出几何允许')
+      body.shape = shape
+      return { bodyId: op.target, name: body.name, volume: Math.abs(adapter.volume(shape)), mesh: meshOf(shape, body.name) }
     }
     case 'draft': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
-      const stepIn = body.step ?? adapter.exportFile(body.shape, 'step')
-      const bridge = await getOcctBridge()
-      if (bridge === null) throw new Error('draft requires the occt.ts kernel (>= 0.3.0) — reinstall dsh-cad so the dependency pulls it')
-      const out = bridge.hostedSolidOp('draft', stepIn, { angle: op.angle, direction: op.direction, faces: op.faces, name: body.name })
-      body.step = out.step
-      body.shape = null
-      return { bodyId: op.target, name: body.name, volume: out.volume, mesh: out.mesh }
+      const body = requireShape(op.target, 'draft')
+      if (typeof adapter.draft !== 'function') throw new Error('draft requires the occt.ts kernel backend — it is unavailable, reinstall dsh-cad')
+      const shape = adapter.draft(body.shape, op.angle, op.direction)
+      assertUsable(shape, 'draft', '检查拔模角度是否超出几何允许')
+      body.shape = shape
+      return { bodyId: op.target, name: body.name, volume: Math.abs(adapter.volume(shape)), mesh: meshOf(shape, body.name) }
     }
     case 'boolean': {
       const target = requireShape(op.target, 'boolean')
@@ -191,9 +191,10 @@ async function applyOp(op) {
     }
     case 'fillet': {
       const body = requireShape(op.target, 'fillet')
-      const { shape, edges } = adapter.filletAll(body.shape, op.radius ?? 1)
+      const shape = adapter.filletAll(body.shape, op.radius ?? 1)
+      assertUsable(shape, 'fillet', '半径可能超出相邻面')
       body.shape = shape
-      return { bodyId: op.target, name: body.name, edges, mesh: meshOf(shape, body.name) }
+      return { bodyId: op.target, name: body.name, mesh: meshOf(shape, body.name) }
     }
     case 'transform': {
       const body = requireShape(op.target, 'transform')
@@ -214,13 +215,7 @@ async function applyOp(op) {
       return { meshes }
     }
     case 'export': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
-      if (body.step !== undefined) {
-        // Hosted body: the STEP bytes ARE the parametric exchange form.
-        if (op.format !== 'step') throw new Error('stl export of a hosted body requires tessellation — export .step, or re-export before shelling')
-        return { bytes: body.step.buffer.slice(body.step.byteOffset, body.step.byteOffset + body.step.byteLength) }
-      }
+      const body = requireShape(op.target, 'export')
       const bytes = adapter.exportFile(body.shape, op.format)
       return { bytes: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) }
     }
@@ -261,17 +256,20 @@ async function applyOp(op) {
     }
     case 'export_assembly': {
       if (instances.size === 0) throw new Error('the assembly is empty')
-      const builder = new occt.BRep_Builder()
-      const compound = new occt.TopoDS_Compound()
-      builder.MakeCompound(compound)
+      // occt.ts has no compound binding — fuse the placed instances into one
+      // solid (the STEP carries the union; instance separation stays in the
+      // assembly scene/document). The legacy backend kept separate solids via
+      // a TopoDS_Compound; both exports open identically in CAD tools.
+      let compound = null
       let added = 0
       for (const instance of instances.values()) {
         const body = bodies.get(instance.bodyId)
         if (body === undefined) continue // stale instance of a consumed body
-        builder.Add(compound, adapter.transform(body.shape, {
+        const placed = adapter.transform(body.shape, {
           translate: instance.translate,
           rotate: instance.rotate,
-        }))
+        })
+        compound = compound === null ? placed : adapter.boolean('fuse', compound, [placed])
         added++
       }
       if (added === 0) throw new Error('no instance references a live body')
@@ -279,15 +277,12 @@ async function applyOp(op) {
       return { bytes: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength), instances: instancesList() }
     }
     case 'volume': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
-      if (body.step !== undefined) {
-        // Hosted body: ask the occt.ts kernel directly.
-        const bridge = await getOcctBridge()
-        if (bridge === null) throw new Error('volume on a hosted body requires the occt.ts kernel')
-        return { volume: bridge.volumeOf(body.step) }
+      const body = requireShape(op.target, 'volume')
+      const result = { volume: Math.abs(adapter.volume(body.shape)) }
+      if (typeof adapter.centroid === 'function') {
+        try { result.centroid = adapter.centroid(body.shape) } catch { /* centroid optional */ }
       }
-      return { volume: Math.abs(adapter.volume(body.shape)) }
+      return result
     }
     case 'delete': {
       if (!bodies.delete(op.target)) throw new Error(`unknown body: ${op.target}`)
@@ -335,12 +330,39 @@ async function getOcctBridge() {
   return occtBridge
 }
 
-/** Reject ops that need an opencascade.js BRep on a hosted body. */
+/** Faces (1-based) whose outward plane-normal matches the target normals. */
+function matchFacesByNormal(shape, openNormals) {
+  if (!Array.isArray(openNormals) || openNormals.length === 0) return []
+  if (typeof adapter.describe !== 'function') throw new Error('face matching by normal requires the occt.ts kernel backend')
+  const desc = adapter.describe(shape)
+  const faces = Array.isArray(desc.faces) ? desc.faces : []
+  const picked = []
+  for (const target of openNormals) {
+    const tlen = Math.hypot(target[0], target[1], target[2])
+    if (tlen < 1e-12) continue
+    const tn = [target[0] / tlen, target[1] / tlen, target[2] / tlen]
+    let best = null
+    let bestScore = -Infinity
+    for (const face of faces) {
+      if (face.surface !== 'plane' || !Array.isArray(face.normal)) continue
+      const dot = face.normal[0] * tn[0] + face.normal[1] * tn[1] + face.normal[2] * tn[2]
+      if (Math.abs(dot) < 0.9) continue
+      const outward = dot >= 0 ? 1 : -1
+      const proj = (face.origin[0] * tn[0] + face.origin[1] * tn[1] + face.origin[2] * tn[2]) * outward
+      const score = Math.abs(dot) + proj * 1e-3
+      if (score > bestScore) { bestScore = score; best = face.index }
+    }
+    if (best !== null) picked.push(best)
+  }
+  return picked
+}
+
+/** Resolve a body's live shape (single-kernel: always present). */
 function requireShape(bodyId, what) {
   const body = bodies.get(bodyId)
   if (body === undefined) throw new Error(`unknown body: ${bodyId}`)
-  if (body.shape === undefined || body.shape === null) {
-    throw new Error(`${bodyId} is hosted on the occt.ts kernel (created by shell/draft); ${what} needs the opencascade.js BRep and cannot read hosted geometry back — model the feature before shelling, or reconstruct the body`)
+  if (body.shape === null || body.shape === undefined) {
+    throw new Error(`${bodyId} has no live shape (${what})`)
   }
   return body
 }
@@ -358,21 +380,34 @@ async function drawingViews(op) {
   return { views: projected.views }
 }
 
-const initOpenCascade = loaderModule.default ?? loaderModule
-initOpenCascade({ wasmBinary }).then((instance) => {
-  occt = instance
-  adapter = createAdapter(occt)
-  parentPort.on('message', async (message) => {
+async function boot() {
+  const mod = await loadSharedOcctModule()
+  if (mod !== null) {
+    adapter = createOcctTsAdapter(mod)
+    kernelName = 'occt.ts'
+  } else {
+    console.warn('[dsh-cad] occt.ts unavailable — falling back to the opencascade.js backend')
+    const initOpenCascade = loaderModule.default ?? loaderModule
+    occt = await initOpenCascade({ wasmBinary })
+    adapter = createAdapter(occt)
+    kernelName = 'opencascade.js'
+  }
+  parentPort.postMessage({ jobId: 0, ok: true, result: { ready: true, kernel: kernelName } })
+  parentPort.on('message', runMessage)
+}
+
+async function runMessage(message) {
+  {
     const transfers = []
     try {
       const result = await applyOp(message.op)
-      // Collect transferable mesh buffers.
       const collect = (mesh) => {
         if (mesh === undefined) return
         transfers.push(mesh.positions.buffer, mesh.indices.buffer, mesh.normals.buffer)
       }
       if (result.mesh !== undefined) collect(result.mesh)
       for (const mesh of result.meshes ?? []) collect(mesh)
+      if (result.created !== undefined) for (const entry of result.created) if (entry.mesh !== undefined) collect(entry.mesh)
       if (result.bytes !== undefined) transfers.push(result.bytes)
       parentPort.postMessage({ jobId: message.jobId, ok: true, result }, transfers)
     } catch (error) {
@@ -382,8 +417,10 @@ initOpenCascade({ wasmBinary }).then((instance) => {
         error: error instanceof Error ? error.message : String(error),
       })
     }
-  })
-  parentPort.postMessage({ jobId: 0, ok: true, result: { ready: true } })
-}).catch((error) => {
-  parentPort.postMessage({ jobId: 0, ok: false, error: `modeling kernel init failed: ${error.message}` })
+  }
+}
+
+boot().catch((error) => {
+  parentPort.postMessage({ jobId: 0, ok: false, error: `modeling kernel init failed: ${error instanceof Error ? error.message : String(error)}` })
 })
+

package/lib/modeling/occt-adapter.cjs

@@ -127,7 +127,7 @@ function createAdapter(occt) {
     if (edges === 0) throw new Error('no edges to fillet')
     algo.Build()
     if (!algo.IsDone()) throw new Error('fillet failed (radius may exceed the adjacent faces)')
-    return { shape: algo.Shape(), edges }
+    return algo.Shape()
   }
 
   function castEdge(shape) {

package/lib/modeling/occt-bridge.cjs

@@ -54,6 +54,24 @@ function resolveDistDir(explicit) {
   return null
 }
 
+/** Shared wasm-module singleton: the worker's modeling adapter, the HLR path
+ * and the hosted ops all reuse ONE occt.ts instance per process. */
+let sharedModule = null
+
+/** Load (once) and return the shared occt.ts raw module, or null when absent. */
+async function loadSharedOcctModule() {
+  if (sharedModule !== null && sharedModule !== undefined) return sharedModule
+  const distDir = resolveDistDir()
+  if (distDir === null) return null
+  try {
+    sharedModule = await loadModule(distDir)
+  } catch (error) {
+    console.warn(`[dsh-cad] occt.ts kernel failed to load: ${error instanceof Error ? error.message : error}`)
+    sharedModule = null
+  }
+  return sharedModule
+}
+
 async function loadModule(distDir) {
   const imported = await import(pathToFileURL(path.join(distDir, 'wasm', 'occtjs.js')).href)
   const factory = imported.default
@@ -81,7 +99,7 @@ async function hiddenLineViews(mod, stepBytes, views) {
   const ptr = mod._malloc(stepBytes.length)
   try {
     mod.HEAPU8.set(stepBytes, ptr)
-    const shape = mod.readStep(ptr, stepBytes.length)
+    const shape = mod.readStep(ptr, stepBytes.length, 'mm')
     if (shape.isNull()) throw new Error(`occt.ts readStep: ${mod.lastError()}`)
     try {
       return {
@@ -286,14 +304,61 @@ function hostedSolidOp(mod, kind, stepBytes, params) {
   }
 }
 
+/**
+ * Hidden-line views of a shape that ALREADY lives in this occt.ts instance
+ * (the single-kernel path — no STEP hop). Same frame/remap contract as
+ * hiddenLineViews.
+ */
+function hiddenLineViewsOfShape(mod, shape, views) {
+  return {
+    views: views.map((view) => {
+      const w = norm(view.dir)
+      const u = norm(view.xDir)
+      const v = norm(cross(w, u))
+      const dv = dot(w, v)
+      let x = [v[0] - w[0] * dv, v[1] - w[1] * dv, v[2] - w[2] * dv]
+      if (Math.hypot(x[0], x[1], x[2]) < 1e-9) x = Math.abs(w[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0]
+      x = norm(x)
+      const y = norm(cross(w, x))
+      const raw = mod.hiddenLines(shape, w[0], w[1], w[2], x[0], x[1], x[2], 0.1)
+      const read = (ptr2, count) => new Float32Array(mod.HEAPU8.buffer, ptr2, count * 3).slice()
+      let visible
+      let hidden
+      try {
+        visible = read(raw.visiblePtr(), raw.visiblePointCount())
+        hidden = read(raw.hiddenPtr(), raw.hiddenPointCount())
+      } finally {
+        raw.delete()
+      }
+      const a = dot(x, u)
+      const b = dot(y, u)
+      const c = dot(x, v)
+      const d = dot(y, v)
+      const remap = (arr) => {
+        const xyz = []
+        for (let i = 0; i + 2 < arr.length; i += 3) xyz.push(arr[i] * a + arr[i + 1] * b, arr[i] * c + arr[i + 1] * d, 0)
+        return xyz
+      }
+      const toPolylines = (xyz) =>
+        chainSegments(
+          Array.from({ length: xyz.length / 6 }, (_, si) => [xyz[si * 6], xyz[si * 6 + 1], xyz[si * 6 + 3], xyz[si * 6 + 4]]),
+        ).map((chain) => simplify(chain, 0.02)).filter((chain) => chain.length >= 4)
+      const visiblePolylines = toPolylines(remap(visible))
+      const visibleKeys = new Set(visiblePolylines.map(polylineKey))
+      const hiddenPolylines = toPolylines(remap(hidden)).filter((chain) => !visibleKeys.has(polylineKey(chain)))
+      return { name: view.name, visible: visiblePolylines, hidden: hiddenPolylines }
+    }),
+  }
+}
+
 /**
  * Create the bridge, or null when the dist is absent/unloadable (the caller
  * falls back to the mesh HLR). The heavy wasm load is lazy and cached.
  */
 async function createOcctBridge(options = {}) {
+  const mod = options.mod ?? await loadSharedOcctModule()
+  if (mod === null) return null
   const distDir = resolveDistDir(options.distDir)
-  if (distDir === null) return null
-  const mod = await loadModule(distDir)
   if (typeof mod.hiddenLines !== 'function' || typeof mod.readStep !== 'function') {
     throw new Error(`occt.ts dist at ${distDir} lacks hiddenLines/readStep`)
   }
@@ -307,6 +372,7 @@ async function createOcctBridge(options = {}) {
     distDir,
     occtVersion: mod.occtVersion(),
     hiddenLineViews: (stepBytes, views) => hiddenLineViews(mod, stepBytes, views),
+    hiddenLineViewsOf: (shape, views) => hiddenLineViewsOfShape(mod, shape, views),
     hostedSolidOp: (kind, stepBytes, params) => hostedSolidOp(mod, kind, stepBytes, params),
     volumeOf: (stepBytes) => {
       const shape = readShape(mod, stepBytes)
@@ -404,4 +470,4 @@ function simplify(points, epsilon) {
   return out
 }
 
-module.exports = { createOcctBridge, resolveDistDir }
+module.exports = { createOcctBridge, resolveDistDir, loadSharedOcctModule }

package/lib/tools/cad-model.js

@@ -372,7 +372,8 @@ export function createModelTools(deps) {
     const cadCreatePrim = defineTool({
         name: 'cad_create_prim',
         description: 'Create a parametric primitive in the shared modeling document (mm, Z-up). Kinds: box (dx,dy,dz), cylinder (radius,height), sphere (radius), cone (radius1,radius2,height), torus (majorRadius,minorRadius). ' +
-            '`at` places the origin; `axis` orients cylinder/cone/torus (default +Z). Returns the bodyId other CAD tools reference. The viewer card updates after every call.',
+            '`at` is the anchor point with per-kind semantics: box → min corner (the solid spans at .. at+[dx,dy,dz] along +X/+Y/+Z); cylinder/cone → base-circle center (the solid extends `height` from it along `axis`); sphere/torus → geometric center. ' +
+            '`axis` orients cylinder/cone/torus (default +Z). Returns the bodyId other CAD tools reference. The viewer card updates after every call.',
         parameters: {
             kind: { type: 'string', required: true, enum: ['box', 'cylinder', 'sphere', 'cone', 'torus'], description: 'Primitive kind.' },
             dx: numberParam('box: size X (mm).'),
@@ -384,7 +385,7 @@ export function createModelTools(deps) {
             height: numberParam('cylinder/cone: height (mm).'),
             majorRadius: numberParam('torus: center radius (mm).'),
             minorRadius: numberParam('torus: tube radius (mm).'),
-            at: pointParam('origin [x,y,z] (mm).'),
+            at: pointParam('anchor [x,y,z] (mm): box = min corner, cylinder/cone = base-circle center, sphere/torus = geometric center.'),
             axis: pointParam('axis direction [x,y,z] for cylinder/cone/torus.'),
             name: { type: 'string', description: 'Optional display name.' },
         },

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.8.0",
+  "version": "0.9.0",
   "type": "module",
   "license": "MIT",
   "author": "LAU-MARS",
@@ -70,7 +70,7 @@
     "ansatz-wasm": "^0.2.0",
     "dxf-parser": "^1.1.2",
     "occt-import-js": "^0.0.23",
-    "occt.ts": "^0.3.0",
+    "occt.ts": "^0.5.0",
     "opencascade.js": "^1.1.1",
     "three": "^0.185.1"
   },