dsh-cad 0.7.0 → 0.8.0

package/lib/modeling/modeling-worker.cjs

@@ -37,7 +37,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 +101,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 +155,31 @@ 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 = 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 }
+    }
+    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 }
+    }
     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,13 @@ 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 body = requireShape(op.target, 'fillet')
       const { shape, edges } = adapter.filletAll(body.shape, op.radius ?? 1)
       body.shape = shape
       return { bodyId: op.target, name: body.name, edges, 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,6 +208,7 @@ 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 }
@@ -198,6 +216,11 @@ async function applyOp(op) {
     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 bytes = adapter.exportFile(body.shape, op.format)
       return { bytes: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) }
     }
@@ -258,7 +281,13 @@ async function applyOp(op) {
     case 'volume': {
       const body = bodies.get(op.target)
       if (body === undefined) throw new Error(`unknown body: ${op.target}`)
-      return { volume: adapter.volume(body.shape) }
+      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) }
+      }
+      return { volume: Math.abs(adapter.volume(body.shape)) }
     }
     case 'delete': {
       if (!bodies.delete(op.target)) throw new Error(`unknown body: ${op.target}`)
@@ -306,6 +335,16 @@ async function getOcctBridge() {
   return occtBridge
 }
 
+/** Reject ops that need an opencascade.js BRep on a hosted body. */
+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`)
+  }
+  return body
+}
+
 async function drawingViews(op) {
   const body = bodies.get(op.target)
   if (body === undefined) throw new Error(`unknown body: ${op.target}`)

package/lib/modeling/occt-bridge.cjs

@@ -143,6 +143,149 @@ 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()
+  }
+}
+
 /**
  * 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.
@@ -154,11 +297,25 @@ async function createOcctBridge(options = {}) {
   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),
+    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()
+      }
+    },
   }
 }
 

package/lib/tools/cad-model.js

@@ -597,6 +597,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 +1367,8 @@ export function createModelTools(deps) {
         cadExtrude,
         cadRevolve,
         cadChamfer,
+        cadShell,
+        cadDraft,
         cadPattern,
         cadLoft,
         cadSweep,
@@ -1329,6 +1395,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"];

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.7.0",
+  "version": "0.8.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.1.0",
+    "occt.ts": "^0.3.0",
     "opencascade.js": "^1.1.1",
     "three": "^0.185.1"
   },