dsh-cad 0.7.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
@@ -37,7 +42,10 @@ function assertUsable(shape, what, hint) {
   }
 }
 
-/** bodyId → { shape, name } — the live document. */
+/** bodyId → { shape, name, step? } — the live document. A body whose solid
+ * was produced by an occt.ts-only op (shell/draft) is HOSTED: `step` carries
+ * the STEP bytes as the source of truth and `shape` is null, because
+ * opencascade.js in this build cannot read geometry back. */
 const bodies = new Map()
 let nextBodyNumber = 1
 
@@ -98,8 +106,7 @@ async function applyOp(op) {
       return { bodyId, name: bodies.get(bodyId).name, mesh: meshOf(shape, bodies.get(bodyId).name) }
     }
     case 'chamfer': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
+      const body = requireShape(op.target, 'chamfer')
       const shape = adapter.chamferAll(body.shape, op.distance)
       assertUsable(shape, 'chamfer', '距离可能超出相邻面')
       body.shape = shape
@@ -153,14 +160,26 @@ async function applyOp(op) {
       bodies.set(bodyId, { shape, name: op.name ?? bodyId })
       return { bodyId, name: bodies.get(bodyId).name, mesh: meshOf(shape, bodies.get(bodyId).name) }
     }
+    case 'shell': {
+      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 = 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 = bodies.get(op.target)
-      if (target === undefined) throw new Error(`unknown body: ${op.target}`)
-      const tools = op.tools.map((id) => {
-        const tool = bodies.get(id)
-        if (tool === undefined) throw new Error(`unknown body: ${id}`)
-        return tool.shape
-      })
+      const target = requireShape(op.target, 'boolean')
+      const tools = op.tools.map((id) => requireShape(id, 'boolean').shape)
       const shape = adapter.boolean(op.op, target.shape, tools)
       target.shape = shape
       // Consumed tool bodies are removed from the document (CAD convention).
@@ -171,15 +190,14 @@ async function applyOp(op) {
       return { bodyId: op.target, name: target.name, removed, mesh: meshOf(shape, target.name) }
     }
     case 'fillet': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
-      const { shape, edges } = adapter.filletAll(body.shape, op.radius ?? 1)
+      const body = requireShape(op.target, 'fillet')
+      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 = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
+      const body = requireShape(op.target, 'transform')
       const shape = adapter.transform(body.shape, {
         translate: op.translate,
         rotate: op.rotate,
@@ -191,13 +209,13 @@ async function applyOp(op) {
     case 'tessellate_all': {
       const meshes = []
       for (const [bodyId, body] of bodies) {
+        if (body.shape === null || body.shape === undefined) continue // hosted bodies re-mesh via their ops
         meshes.push({ bodyId, name: body.name, ...meshOf(body.shape, body.name) })
       }
       return { meshes }
     }
     case 'export': {
-      const body = bodies.get(op.target)
-      if (body === undefined) throw new Error(`unknown body: ${op.target}`)
+      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) }
     }
@@ -238,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')
@@ -256,9 +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}`)
-      return { volume: adapter.volume(body.shape) }
+      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 result
     }
     case 'delete': {
       if (!bodies.delete(op.target)) throw new Error(`unknown body: ${op.target}`)
@@ -306,6 +330,43 @@ async function getOcctBridge() {
   return occtBridge
 }
 
+/** 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 === null || body.shape === undefined) {
+    throw new Error(`${bodyId} has no live shape (${what})`)
+  }
+  return body
+}
+
 async function drawingViews(op) {
   const body = bodies.get(op.target)
   if (body === undefined) throw new Error(`unknown body: ${op.target}`)
@@ -319,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) {
@@ -343,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 {
@@ -143,22 +161,227 @@ async function hiddenLineViews(mod, stepBytes, views) {
   }
 }
 
+
+// ── occt.ts-hosted solid operations (shell / draft / boolean / transform) ────
+//
+// opencascade.js cannot read geometry BACK (STEPControl_Reader and BRepTools
+// readers are opaque no-method shells in that build), so a solid produced by
+// an occt.ts-only op cannot return to the opencascade.js modeling session.
+// Instead the result stays hosted as STEP bytes on the occt.ts side: every
+// hosted op re-reads the STEP, operates, and writes it back, while meshes for
+// display/volume come from the occt.ts tessellator. opencascade.js-exclusive
+// ops (fillet/chamfer/loft/sweep/revolve) refuse hosted bodies with a clear
+// error instead of silently operating on stale geometry.
+
+/** Read STEP bytes into an occt.ts shape (caller deletes). */
+function readShape(mod, stepBytes) {
+  const ptr = mod._malloc(stepBytes.length)
+  try {
+    mod.HEAPU8.set(stepBytes, ptr)
+    const shape = mod.readStep(ptr, stepBytes.length, 'mm')
+    if (shape.isNull()) throw new Error(`occt.ts readStep: ${mod.lastError()}`)
+    return shape
+  } finally {
+    mod._free(ptr)
+  }
+}
+
+/** Write an occt.ts shape to STEP bytes. */
+function toStepBytes(mod, shape) {
+  const text = mod.writeStep(shape, 'mm')
+  return Buffer.from(text, 'utf8')
+}
+
+/** Tessellate an occt.ts shape into the worker mesh format. */
+function tessellateMesh(mod, shape, name, linearDeflection = 0.3) {
+  const data = mod.tessellate(shape, linearDeflection, 20, false)
+  try {
+    const positions = new Float32Array(mod.HEAPU8.buffer, data.positionsPtr(), data.positionCount() * 3).slice()
+    const indices = new Uint32Array(mod.HEAPU8.buffer, data.indicesPtr(), data.indexCount()).slice()
+    const triangles = indices.length / 3
+    // Flat per-triangle normals (the mechanical-CAD look the viewer expects).
+    const normals = new Float32Array(positions.length)
+    for (let i = 0; i + 2 < indices.length; i += 3) {
+      const a = indices[i] * 3, b = indices[i + 1] * 3, c = indices[i + 2] * 3
+      const ux = positions[c] - positions[a], uy = positions[c + 1] - positions[a + 1], uz = positions[c + 2] - positions[a + 2]
+      const vx = positions[b] - positions[a], vy = positions[b + 1] - positions[a + 1], vz = positions[b + 2] - positions[a + 2]
+      let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx
+      const len = Math.hypot(nx, ny, nz) || 1
+      nx /= len; ny /= len; nz /= len
+      for (const corner of [a, b, c]) {
+        normals[corner] = nx; normals[corner + 1] = ny; normals[corner + 2] = nz
+      }
+    }
+    return { name, positions, normals, indices, vertexCount: positions.length / 3, triangleCount: triangles }
+  } finally {
+    data.delete()
+  }
+}
+
+/** Faces (1-based indices) whose outward plane-normal matches a target list. */
+function matchFaces(mod, shape, openNormals) {
+  if (!Array.isArray(openNormals) || openNormals.length === 0) return []
+  const desc = JSON.parse(mod.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 = 0.9
+    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]
+      // |dot| ≈ 1 means parallel; the OUTER face along ±target has the larger
+      // origin·target projection (a box carries both ±Z faces).
+      if (Math.abs(dot) < 0.9) continue
+      const outward = Math.sign(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
+}
+
+/** int32 face-index array into wasm memory; returns {ptr, count} or null. */
+function faceListPtr(mod, faces) {
+  if (!Array.isArray(faces) || faces.length === 0) return { ptr: 0, count: 0 }
+  const ptr = mod._malloc(faces.length * 4)
+  for (let i = 0; i < faces.length; i++) {
+    mod.HEAPU32[ptr / 4 + i] = faces[i]
+  }
+  return { ptr, count: faces.length }
+}
+
+/**
+ * Run one occt.ts-hosted solid operation on STEP bytes:
+ *   shell(stepBytes, thickness, openNormals) → { step, mesh, volume, faces }
+ *   draft(stepBytes, angleDegrees, direction, faces?) → { step, mesh, volume }
+ * The STEP bytes of the RESULT are the hosted body's new source of truth.
+ */
+function hostedSolidOp(mod, kind, stepBytes, params) {
+  const shape = readShape(mod, stepBytes)
+  try {
+    let result
+    if (kind === 'shell') {
+      const faces = Array.isArray(params.faces) && params.faces.length > 0
+        ? params.faces
+        : matchFaces(mod, shape, params.openNormals)
+      const list = faceListPtr(mod, faces)
+      try {
+        result = mod.shell(shape, Math.abs(params.thickness), list.ptr, list.count)
+      } finally {
+        if (list.ptr !== 0) mod._free(list.ptr)
+      }
+      if (result.isNull()) throw new Error(`shell failed: ${mod.lastError()}`)
+    } else if (kind === 'draft') {
+      const faces = Array.isArray(params.faces) && params.faces.length > 0 ? params.faces : []
+      const list = faceListPtr(mod, faces)
+      const d = params.direction ?? [0, 0, 1]
+      try {
+        result = mod.draft(shape, (params.angle * Math.PI) / 180, d[0], d[1], d[2], 0, 0, 1, list.ptr, list.count, faces.length === 0)
+      } finally {
+        if (list.ptr !== 0) mod._free(list.ptr)
+      }
+      if (result.isNull()) throw new Error(`draft failed: ${mod.lastError()}`)
+    } else {
+      throw new Error(`unknown hosted op: ${kind}`)
+    }
+    try {
+      return {
+        step: toStepBytes(mod, result),
+        mesh: tessellateMesh(mod, result, params.name ?? 'hosted'),
+        volume: Math.abs(result.volume()),
+      }
+    } finally {
+      result.delete()
+    }
+  } finally {
+    shape.delete()
+  }
+}
+
+/**
+ * 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`)
   }
+  for (const required of ['shell', 'draft', 'describe', 'writeStep', 'tessellate']) {
+    if (typeof mod[required] !== 'function') {
+      throw new Error(`occt.ts dist at ${distDir} lacks ${required} (need occt.ts >= 0.3.0)`)
+    }
+  }
   return {
     kernel: 'occt.ts',
     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)
+      try {
+        return Math.abs(shape.volume())
+      } finally {
+        shape.delete()
+      }
+    },
   }
 }
 
@@ -247,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.' },
         },
@@ -597,6 +598,70 @@ export function createModelTools(deps) {
         presentCall: (args) => ({ card: 'generic', title: `CAD chamfer ${String(args.target)}`, kind: 'other' }),
         presentResult: () => ({ card: 'generic', title: 'CAD chamfer' }),
     });
+    const cadShell = defineTool({
+        name: 'cad_shell',
+        description: 'Shell (抽壳): hollow a solid into a wall of `thickness` mm (the wall grows inward, the outer skin is preserved). `open` lists outward NORMALS [x,y,z] whose faces become openings (e.g. [[0,0,1]] opens the top of a box; empty = sealed hollow). ' +
+            'Runs on the occt.ts kernel (>= 0.3.0): the result becomes a HOSTED body — volume/export(.step)/display keep working, but opencascade.js-only edits (fillet/chamfer/loft/sweep/revolve/boolean) on it are refused, so do those before shelling.',
+        parameters: {
+            target: bodyTarget,
+            thickness: { type: 'number', required: true, description: 'Wall thickness (mm, positive).' },
+            open: { type: 'array', items: { type: 'array', items: { type: 'number' } }, description: 'Outward normals of the faces to open, e.g. [[0,0,1]].' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    bodyId: { type: 'string', required: true },
+                    ...requiredCounts,
+                    ...commonOptional,
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderModel(value) }],
+            presentationMeta: (_args, value) => metaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args, exec) {
+            await resolveDoc(exec);
+            const op = { kind: 'shell', target: args.target, thickness: args.thickness, ...(Array.isArray(args.open) ? { openNormals: args.open } : {}) };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD shell ${String(args.target)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD shell' }),
+    });
+    const cadDraft = defineTool({
+        name: 'cad_draft',
+        description: 'Draft (拔模): tilt the walls of a solid by `angle` degrees for mold release — faces pivot about a neutral plane, dimensions there unchanged. `direction` is the pull direction (default +Z); by default the faces parallel to it (the walls) are drafted. ' +
+            'Runs on the occt.ts kernel (>= 0.3.0): the result becomes a HOSTED body (same caveats as cad_shell).',
+        parameters: {
+            target: bodyTarget,
+            angle: { type: 'number', required: true, description: 'Draft angle in degrees (positive opens the walls toward the pull direction).' },
+            direction: { type: 'array', items: { type: 'number' }, description: 'Pull direction [x,y,z] (default +Z).' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    bodyId: { type: 'string', required: true },
+                    ...requiredCounts,
+                    ...commonOptional,
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderModel(value) }],
+            presentationMeta: (_args, value) => metaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args, exec) {
+            await resolveDoc(exec);
+            const op = { kind: 'draft', target: args.target, angle: args.angle, ...(Array.isArray(args.direction) ? { direction: args.direction } : {}) };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD draft ${String(args.target)} ${String(args.angle ?? '')}°`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD draft' }),
+    });
     const cadPattern = defineTool({
         name: 'cad_pattern',
         description: 'Pattern (阵列): replicate a body into `count` total placements. Linear: `delta` [dx,dy,dz] spacing per copy. Circular: rotate copies around a principal axis (+X/+Y/+Z) through `at` over `angle` degrees (default 360). Creates new bodies (target·1 … target·(count−1)); fuse afterwards for a single body.',
@@ -1303,6 +1368,8 @@ export function createModelTools(deps) {
         cadExtrude,
         cadRevolve,
         cadChamfer,
+        cadShell,
+        cadDraft,
         cadPattern,
         cadLoft,
         cadSweep,
@@ -1329,6 +1396,8 @@ export const MODEL_TOOL_NAMES = [
     'cad_extrude_profile',
     'cad_revolve',
     'cad_chamfer',
+    'cad_shell',
+    'cad_draft',
     'cad_pattern',
     'cad_loft',
     'cad_sweep',

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

@@ -81,6 +81,18 @@ export type ModelOp = {
     kind: 'chamfer';
     target: string;
     distance: number;
+} | {
+    kind: 'shell';
+    target: string;
+    thickness: number;
+    openNormals?: Array<[number, number, number]>;
+    faces?: number[];
+} | {
+    kind: 'draft';
+    target: string;
+    angle: number;
+    direction?: [number, number, number];
+    faces?: number[];
 } | {
     kind: 'pattern';
     target: string;

package/lib/types/tools/cad-model.d.ts

@@ -13,4 +13,4 @@ export interface ModelToolDeps {
 }
 /** Build the whole tool family over the document registry + worker + stores. */
 export declare function createModelTools(deps: ModelToolDeps): ToolDefinition[];
-export declare const MODEL_TOOL_NAMES: readonly ["cad_create_prim", "cad_extrude_profile", "cad_revolve", "cad_chamfer", "cad_pattern", "cad_loft", "cad_sweep", "cad_boolean", "cad_fillet", "cad_transform", "cad_export", "cad_delete", "cad_volume", "cad_drawing", "cad_assembly_insert", "cad_assembly_move", "cad_assembly_remove", "cad_docs", "cad_doc_new", "cad_doc_open", "cad_doc_rename", "cad_doc_delete", "cad_constraint", "cad_solve", "cad_motion"];
+export declare const MODEL_TOOL_NAMES: readonly ["cad_create_prim", "cad_extrude_profile", "cad_revolve", "cad_chamfer", "cad_shell", "cad_draft", "cad_pattern", "cad_loft", "cad_sweep", "cad_boolean", "cad_fillet", "cad_transform", "cad_export", "cad_delete", "cad_volume", "cad_drawing", "cad_assembly_insert", "cad_assembly_move", "cad_assembly_remove", "cad_docs", "cad_doc_new", "cad_doc_open", "cad_doc_rename", "cad_doc_delete", "cad_constraint", "cad_solve", "cad_motion"];