dsh-cad 0.2.0

package/lib/tools/cad-model.js

@@ -0,0 +1,816 @@
+import { writeFile } from 'node:fs/promises';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { runModelOp, workerResetEpoch } from '../modeling/client.js';
+import { ModelDocument } from '../modeling/document.js';
+import { composeAssemblyMeshes } from '../modeling/assembly.js';
+import { buildDrawingSheet, drawingToDxf, drawingToSvg } from '../modeling/drawing.js';
+import { resolveWorkspacePath } from './util.js';
+import { toDcPrtDocument } from '../feature_script/dc_prt.js';
+/** Mirror a worker mesh with its raw typed arrays (binary-transport ready). */
+function mirrorMesh(mesh, bodyId) {
+    return {
+        name: mesh.name === '' ? bodyId : mesh.name,
+        positions: mesh.positions,
+        normals: mesh.normals,
+        indices: mesh.indices,
+    };
+}
+/** Build the whole tool family over one document + worker + scene store. */
+export function createModelTools(deps) {
+    const document = new ModelDocument(deps.workspaceRoot);
+    /** bodyId → raw worker mesh mirror (binary scene source, zero encoding). */
+    const meshCache = new Map();
+    /** Reset epoch after the last sync — out-of-band replays (cad_view on a
+     *  .dcprt) bump the epoch and force a re-replay before the next op. */
+    let syncedEpoch = -1;
+    /** drawingId → rebuilt sheet (backing cad_export .svg/.dxf). */
+    const drawingSheets = new Map();
+    let lastDrawingId = null;
+    /**
+     * Standard drawing views (GB first-angle): 主视图 front, 俯视图 top,
+     * 左视图 left, 轴测 iso. Same constants as the worker's fallback.
+     */
+    const DRAWING_VIEWS = [
+        { name: 'front', dir: [0, -1, 0], xDir: [1, 0, 0] },
+        { name: 'top', dir: [0, 0, 1], xDir: [1, 0, 0] },
+        { name: 'left', dir: [-1, 0, 0], xDir: [0, 1, 0] },
+        { name: 'iso', dir: [1, -1, 1], xDir: [1, 1, 0] },
+    ];
+    /**
+     * A second stable UUID derived from the document id (hex reversed + salted
+     * version nibble): SceneStore's viewId regex demands UUID shape, while the
+     * drawing scene must keep one stable viewId across re-draws/replays.
+     */
+    const siblingUuid = (salt) => {
+        const hex = document.doc.docId.replace(/-/g, '').split('').reverse().join('');
+        const salted = (hex.slice(0, 12) + salt + hex.slice(13)).slice(0, 32);
+        return `${salted.slice(0, 8)}-${salted.slice(8, 12)}-${salted.slice(12, 16)}-${salted.slice(16, 20)}-${salted.slice(20, 32)}`;
+    };
+    async function restoreOnce() {
+        if (syncedEpoch === workerResetEpoch())
+            return;
+        await document.restore();
+        if (document.doc.ops.length > 0) {
+            await runModelOp({ kind: 'reset' });
+            for (const op of document.doc.ops) {
+                try {
+                    const result = await runModelOp(op);
+                    // A replayed drawing re-generates its sheet and re-publishes the
+                    // scene so the stable viewId keeps serving after restarts.
+                    if (op.kind === 'drawing' && op.sceneViewId !== undefined && result.views !== undefined) {
+                        const sheet = buildDrawingSheet({ partName: op.name ?? op.target, views: result.views, paper: op.paper });
+                        drawingSheets.set(op.sceneViewId, { sheet, partName: op.name ?? op.target });
+                        lastDrawingId = op.sceneViewId;
+                        await deps.sceneStore.putAt(op.sceneViewId, {
+                            kind: '2d',
+                            format: 'drawing',
+                            entities: sheet.entities,
+                            bounds: sheet.bounds,
+                            layers: sheet.layers,
+                        });
+                    }
+                }
+                catch {
+                    // A single stale op must not block recovery; later ops may be independent.
+                }
+            }
+            const all = await runModelOp({ kind: 'tessellate_all' });
+            meshCache.clear();
+            for (const mesh of all.meshes ?? []) {
+                meshCache.set(mesh.bodyId, mirrorMesh(mesh, mesh.bodyId));
+            }
+        }
+        syncedEpoch = workerResetEpoch();
+    }
+    async function syncScene(op, result, filePath) {
+        if (result.mesh !== undefined && result.bodyId !== undefined) {
+            meshCache.set(result.bodyId, mirrorMesh(result.mesh, result.bodyId));
+        }
+        for (const mesh of result.meshes ?? []) {
+            meshCache.set(mesh.bodyId, mirrorMesh(mesh, mesh.bodyId));
+        }
+        const removed = [...(result.removed ?? []), ...(result.deleted !== undefined ? [result.deleted] : [])];
+        for (const id of removed)
+            meshCache.delete(id);
+        const nameEntry = result.bodyId !== undefined && result.name !== undefined ? { bodyId: result.bodyId, name: result.name } : null;
+        await document.record(op, nameEntry);
+        const meshes = [...meshCache.values()];
+        const triangles = meshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0);
+        const sceneUrlBase = deps.ensureSceneRoute();
+        if (meshes.length > 0) {
+            // Direct worker→three.js transport: packed binary, in-memory, no file
+            // write per step (a debounced disk mirror keeps restart replay).
+            await deps.store.publish(document.doc.docId, meshes);
+        }
+        const value = {
+            triangles,
+            bodies: meshes.length,
+            version: document.doc.version,
+        };
+        if (result.bodyId !== undefined)
+            value.bodyId = result.bodyId;
+        if (result.name !== undefined)
+            value.name = result.name;
+        if (removed.length > 0)
+            value.removed = removed;
+        if (result.volume !== undefined)
+            value.volume = result.volume;
+        if (filePath !== undefined)
+            value.filePath = filePath;
+        if (sceneUrlBase !== null) {
+            value.sceneUrl = `${sceneUrlBase.replace('/scene', '/bin')}/${document.doc.docId}?v=${document.doc.version}`;
+        }
+        return value;
+    }
+    const nextBodyId = () => `b${document.doc.version + 1}`;
+    const nextInstanceId = () => `a${document.doc.version + 1}`;
+    /**
+     * Assembly sync: compose instance meshes from the body cache (pure
+     * transform math), publish the packed assembly scene under the stable
+     * `asm-<docId>` viewId, and record the op. Runs instead of syncScene —
+     * body geometry is untouched by assembly ops.
+     */
+    async function syncAssembly(op, result, filePath) {
+        const instances = result.instances ?? [];
+        const meshes = composeAssemblyMeshes(meshCache, instances);
+        await document.record(op, null);
+        const sceneUrlBase = deps.ensureSceneRoute();
+        if (sceneUrlBase !== null) {
+            // Publish even when empty — removing the last instance must refresh the tab.
+            await deps.store.publish(`asm-${document.doc.docId}`, meshes);
+        }
+        const triangles = meshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0);
+        const value = {
+            instances: instances.length,
+            triangles,
+            bodies: meshCache.size,
+            version: document.doc.version,
+            viewId: `asm-${document.doc.docId}`,
+        };
+        if (result.instanceId !== undefined)
+            value.instanceId = result.instanceId;
+        if (filePath !== undefined)
+            value.filePath = filePath;
+        if (sceneUrlBase !== null) {
+            value.sceneUrl = `${sceneUrlBase.replace('/scene', '/bin')}/asm-${document.doc.docId}?v=${document.doc.version}`;
+        }
+        return value;
+    }
+    /** Build + publish the drawing sheet for a replayed/executed drawing op. */
+    async function publishDrawing(sceneViewId, partName, views, paper) {
+        const sheet = buildDrawingSheet({
+            partName,
+            views: views ?? [],
+            paper,
+            drawingNo: `DSH-${String(document.doc.version).padStart(3, '0')}`,
+            date: new Date().toISOString().slice(0, 10),
+        });
+        drawingSheets.set(sceneViewId, { sheet, partName });
+        lastDrawingId = sceneViewId;
+        await deps.sceneStore.putAt(sceneViewId, {
+            kind: '2d',
+            format: 'drawing',
+            entities: sheet.entities,
+            bounds: sheet.bounds,
+            layers: sheet.layers,
+        });
+        return sheet;
+    }
+    /** Most recently created surviving body (default drawing/export target). */
+    const lastBodyId = () => {
+        const keys = [...meshCache.keys()];
+        return keys[keys.length - 1];
+    };
+    // The model-facing render text: bodyId visibility is the load-bearing part.
+    const renderModel = (value) => {
+        const lines = [
+            value.bodyId !== undefined
+                ? `${String(value.name ?? value.bodyId)} → ${String(value.bodyId)} (version ${String(value.version)}, document: ${String(value.bodies)} bodies, ${String(value.triangles)} triangles)`
+                : `document: ${String(value.bodies)} bodies, ${String(value.triangles)} triangles (version ${String(value.version)})`,
+        ];
+        if (Array.isArray(value.removed) && value.removed.length > 0)
+            lines.push(`consumed bodies: ${value.removed.join(', ')}`);
+        if (value.volume !== undefined)
+            lines.push(`volume: ${Number(value.volume).toFixed(2)} mm³`);
+        if (value.filePath !== undefined)
+            lines.push(`written: ${String(value.filePath)}`);
+        return lines.join('\n');
+    };
+    const metaOf = (value) => ({
+        viewId: document.doc.docId,
+        kind: '3d',
+        format: 'model',
+        file: 'modeling document',
+        doc: 'part',
+        ...(value.sceneUrl === undefined ? {} : { sceneUrl: String(value.sceneUrl) }),
+        title: `CAD model · ${String(value.bodies)} ${value.bodies === 1 ? 'body' : 'bodies'}`,
+        stats: {
+            meshes: Number(value.bodies),
+            triangles: Number(value.triangles),
+        },
+    });
+    /** Presentation meta for assembly ops (kind 3d, doc assembly). */
+    const assemblyMetaOf = (value) => ({
+        viewId: String(value.viewId),
+        kind: '3d',
+        format: 'assembly',
+        file: 'assembly',
+        doc: 'assembly',
+        ...(value.sceneUrl === undefined ? {} : { sceneUrl: String(value.sceneUrl) }),
+        title: `装配体 · ${String(value.instances)} 实例`,
+        stats: {
+            meshes: Number(value.instances),
+            triangles: Number(value.triangles),
+        },
+    });
+    /** Presentation meta for drawing ops (kind 2d, doc drawing). */
+    const drawingMetaOf = (value) => ({
+        viewId: String(value.drawingId),
+        kind: '2d',
+        format: 'drawing',
+        file: 'drawing',
+        doc: 'drawing',
+        ...(value.sceneUrl === undefined ? {} : { sceneUrl: String(value.sceneUrl) }),
+        title: `工程图 · ${String(value.name ?? value.target)}`,
+        stats: {
+            entities: Number(value.entities),
+        },
+    });
+    const renderAssembly = (value) => {
+        const lines = [
+            value.instanceId !== undefined
+                ? `instance ${String(value.instanceId)} placed (assembly: ${String(value.instances)} instances, ${String(value.triangles)} triangles)`
+                : `assembly: ${String(value.instances)} instances, ${String(value.triangles)} triangles`,
+        ];
+        if (value.filePath !== undefined)
+            lines.push(`written: ${String(value.filePath)}`);
+        return lines.join('\n');
+    };
+    const renderDrawing = (value) => {
+        const lines = [
+            `工程图 ${String(value.target)}: 主视图/俯视图/左视图/轴测 · 比例 ${String(value.scaleText ?? '')} · ${String(value.entities)} 实体 (version ${String(value.version)})`,
+        ];
+        if (value.filePath !== undefined)
+            lines.push(`written: ${String(value.filePath)}`);
+        return lines.join('\n');
+    };
+    const numberParam = (description) => ({ type: 'number', description });
+    const pointParam = (description) => ({ type: 'array', items: { type: 'number' }, description });
+    const bodyTarget = { type: 'string', required: true, description: 'BodyId to operate on.' };
+    /** Optional fields every tool's schema declares (syncScene emits any subset). */
+    const commonOptional = {
+        name: { type: 'string', description: 'Body display name.' },
+        removed: { type: 'array', items: { type: 'string' }, description: 'Bodies consumed by a boolean.' },
+        volume: { type: 'number', description: 'Body volume in mm³.' },
+        filePath: { type: 'string', description: 'Written file path (cad_export).' },
+        sceneUrl: { type: 'string', description: 'Versioned viewer URL (web compositions).' },
+    };
+    const requiredCounts = {
+        triangles: { type: 'number', required: true, description: 'Document triangle count.' },
+        bodies: { type: 'number', required: true, description: 'Bodies in the document.' },
+        version: { type: 'number', required: true, description: 'Document version (increments per op).' },
+    };
+    /** Schema shared by the assembly tool family. */
+    const assemblySchema = {
+        instances: { type: 'number', required: true, description: 'Instances in the assembly.' },
+        instanceId: { type: 'string', description: 'Affected instance id.' },
+        viewId: { type: 'string', description: 'Stable assembly scene viewId.' },
+        triangles: { type: 'number', required: true, description: 'Assembly triangle count.' },
+        bodies: { type: 'number', required: true, description: 'Bodies in the document.' },
+        version: { type: 'number', required: true, description: 'Document version.' },
+        filePath: { type: 'string', description: 'Written file path (cad_export).' },
+        sceneUrl: { type: 'string', description: 'Versioned assembly scene URL (web compositions).' },
+    };
+    /** Schema for the drawing tool output. */
+    const drawingSchema = {
+        target: { type: 'string', required: true, description: 'Drawn bodyId.' },
+        name: { type: 'string', description: 'Drawing/part display name.' },
+        drawingId: { type: 'string', description: 'Stable drawing scene viewId.' },
+        entities: { type: 'number', required: true, description: 'Sheet entity count.' },
+        scale: { type: 'number', required: true, description: 'Standard-view scale (1 = full size).' },
+        scaleText: { type: 'string', description: 'Scale as titled text (1:2 / 2:1).' },
+        bodies: { type: 'number', required: true, description: 'Bodies in the document.' },
+        triangles: { type: 'number', required: true, description: 'Document triangle count.' },
+        version: { type: 'number', required: true, description: 'Document version.' },
+        filePath: { type: 'string', description: 'Written file path (cad_export).' },
+        sceneUrl: { type: 'string', description: 'Versioned drawing scene URL (web compositions).' },
+    };
+    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.',
+        parameters: {
+            kind: { type: 'string', required: true, enum: ['box', 'cylinder', 'sphere', 'cone', 'torus'], description: 'Primitive kind.' },
+            dx: numberParam('box: size X (mm).'),
+            dy: numberParam('box: size Y (mm).'),
+            dz: numberParam('box: size Z (mm).'),
+            radius: numberParam('cylinder/sphere: radius (mm).'),
+            radius1: numberParam('cone: base radius (mm).'),
+            radius2: numberParam('cone: top radius (mm, 0 = pointed).'),
+            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).'),
+            axis: pointParam('axis direction [x,y,z] for cylinder/cone/torus.'),
+            name: { type: 'string', description: 'Optional display name.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    bodyId: { type: 'string', required: true, description: 'Stable body reference.' },
+                    ...requiredCounts,
+                    ...commonOptional,
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderModel(value) }],
+            presentationMeta: (_args, value) => metaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args) {
+            await restoreOnce();
+            const bodyId = nextBodyId();
+            const params = args;
+            const op = { kind: 'create_prim', bodyId, prim: args.kind, params, name: args.name };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD create ${String(args.kind)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD create' }),
+    });
+    const cadExtrude = defineTool({
+        name: 'cad_extrude_profile',
+        description: 'Create a solid by extruding a closed polygon profile in the XY plane along +Z (mm). `points` is a flat [x0,y0, x1,y1, …] loop (≥3 points, auto-closed). Use cad_boolean with cylinders for holes.',
+        parameters: {
+            points: { type: 'array', required: true, items: { type: 'number' }, description: 'Flat [x0,y0,x1,y1,…] loop (mm).' },
+            height: { type: 'number', description: 'Extrusion height (mm, default 10).' },
+            base: { type: 'number', description: 'Z of the profile plane (mm, default 0).' },
+            name: { type: 'string', description: 'Optional display name.' },
+        },
+        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) {
+            await restoreOnce();
+            if (args.points.length < 6 || args.points.length % 2 !== 0) {
+                throw new Error('points must be a flat array of ≥3 [x,y] pairs (≥6 numbers)');
+            }
+            const bodyId = nextBodyId();
+            const op = { kind: 'extrude_profile', bodyId, points: args.points, height: args.height, base: args.base, name: args.name };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: () => ({ card: 'generic', title: 'CAD extrude profile', kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD extrude' }),
+    });
+    const cadBoolean = defineTool({
+        name: 'cad_boolean',
+        description: 'Boolean-combine bodies: fuse (union), cut (subtract tools from target), common (intersection). Consumed tool bodies are removed; the result keeps the target bodyId. Classic pattern for holes: cut a cylinder from a plate.',
+        parameters: {
+            op: { type: 'string', required: true, enum: ['fuse', 'cut', 'common'], description: 'Boolean operation.' },
+            target: { type: 'string', required: true, description: 'BodyId kept as the result.' },
+            tools: { type: 'array', required: true, items: { type: 'string' }, description: 'BodyIds combined into the target.' },
+        },
+        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) {
+            await restoreOnce();
+            const op = { kind: 'boolean', op: args.op, target: args.target, tools: args.tools };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD ${String(args.op)} ${String(args.target)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD boolean' }),
+    });
+    const cadFillet = defineTool({
+        name: 'cad_fillet',
+        description: 'Round every sharp edge of a body with one radius (mm). Fails when the radius exceeds the adjacent faces.',
+        parameters: {
+            target: bodyTarget,
+            radius: { type: 'number', required: true, description: 'Fillet radius (mm).' },
+        },
+        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) {
+            await restoreOnce();
+            const op = { kind: 'fillet', target: args.target, radius: args.radius };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD fillet ${String(args.target)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD fillet' }),
+    });
+    const cadTransform = defineTool({
+        name: 'cad_transform',
+        description: 'Move/rotate/mirror a body (mm, degrees, Z-up). Applies in order: translate → rotate (XYZ Euler degrees) → mirror (plane through the origin by normal).',
+        parameters: {
+            target: bodyTarget,
+            translate: pointParam('translation [x,y,z] (mm).'),
+            rotate: pointParam('rotation [rx,ry,rz] (degrees, XYZ Euler).'),
+            mirror: pointParam('mirror plane normal [x,y,z] through the origin.'),
+        },
+        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) {
+            await restoreOnce();
+            const op = {
+                kind: 'transform',
+                target: args.target,
+                translate: args.translate,
+                rotate: args.rotate,
+                mirror: args.mirror,
+            };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD transform ${String(args.target)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD transform' }),
+    });
+    const cadExport = defineTool({
+        name: 'cad_export',
+        description: 'Export to a workspace path (extension selects format): .step / .stl of a body, or .dcprt (the native replayable part document). ' +
+            'target "assembly" exports the whole assembly (STEP assembly of transformed instances). ' +
+            'target "drawing" exports the latest drawing sheet (.svg vector / .dxf exchange).',
+        parameters: {
+            target: { type: 'string', description: 'BodyId; "assembly" for the whole assembly; "drawing" for the latest sheet (required for .step/.stl; unused for .dcprt).' },
+            path: { type: 'string', required: true, description: 'Destination file path (extension selects format).' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ...requiredCounts,
+                    ...commonOptional,
+                    instances: { type: 'number', description: 'Assembly instance count (assembly export).' },
+                    viewId: { type: 'string', description: 'Assembly scene viewId (assembly export).' },
+                    target: { type: 'string', description: 'Exported target: bodyId, "assembly", or "drawing".' },
+                    drawingId: { type: 'string', description: 'Drawing scene viewId (drawing export).' },
+                    entities: { type: 'number', description: 'Sheet entity count (drawing export).' },
+                    scale: { type: 'number', description: 'Standard-view scale (drawing export).' },
+                    scaleText: { type: 'string', description: 'Scale as titled text (drawing export).' },
+                    filePath: { type: 'string', required: true, description: 'Written file path.' },
+                },
+            },
+            render: (_args, value) => [{
+                    type: 'text',
+                    text: value.viewId !== undefined && String(value.viewId).startsWith('asm-')
+                        ? renderAssembly(value)
+                        : renderModel(value),
+                }],
+            presentationMeta: (_args, value) => {
+                const record = value;
+                if (typeof record.viewId === 'string' && record.viewId.startsWith('asm-'))
+                    return assemblyMetaOf(record);
+                return metaOf(record);
+            },
+        },
+        isConcurrencySafe: () => true,
+        async execute(args) {
+            await restoreOnce();
+            const resolved = resolveWorkspacePath(args.path, deps.workspaceRoot);
+            const lower = args.path.toLowerCase();
+            // Assembly export: compound of transformed instances via the worker.
+            if (args.target === 'assembly') {
+                const format = lower.endsWith('.stl') ? 'stl' : 'step';
+                const op = { kind: 'export_assembly', format };
+                const result = await runModelOp(op);
+                if (result.bytes === undefined)
+                    throw new Error('assembly export produced no data');
+                await writeFile(resolved, Buffer.from(result.bytes));
+                return syncAssembly(op, result, resolved);
+            }
+            // Drawing export: serialize the latest rebuilt sheet — no op recorded
+            // (pure export, same convention as .dcprt).
+            if (args.target === 'drawing') {
+                if (lastDrawingId === null)
+                    throw new Error('no drawing yet — call cad_drawing first');
+                const entry = drawingSheets.get(lastDrawingId);
+                if (entry === undefined)
+                    throw new Error('drawing sheet is unavailable');
+                if (lower.endsWith('.dxf'))
+                    await writeFile(resolved, drawingToDxf(entry.sheet), 'utf8');
+                else if (lower.endsWith('.svg'))
+                    await writeFile(resolved, drawingToSvg(entry.sheet), 'utf8');
+                else
+                    throw new Error('drawing export supports .svg and .dxf paths');
+                const meshes = [...meshCache.values()];
+                const sceneUrlBase = deps.ensureSceneRoute();
+                const value = {
+                    target: 'drawing',
+                    name: entry.partName,
+                    drawingId: lastDrawingId,
+                    entities: entry.sheet.entityCount,
+                    scale: entry.sheet.scale,
+                    scaleText: entry.sheet.scale >= 1 ? `${entry.sheet.scale}:1` : `1:${Math.round(1 / entry.sheet.scale * 100) / 100}`,
+                    bodies: meshes.length,
+                    triangles: meshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0),
+                    version: document.doc.version,
+                    filePath: resolved,
+                };
+                if (sceneUrlBase !== null)
+                    value.sceneUrl = `/dsh-cad/scene/${lastDrawingId}?v=${document.doc.version}`;
+                return value;
+            }
+            // .dcprt serializes the whole document on the main thread — no worker
+            // op (that path exports one body's geometry), no entry in the log.
+            if (lower.endsWith('.dcprt')) {
+                if (document.doc.ops.length === 0)
+                    throw new Error('nothing to export — the modeling document is empty');
+                await writeFile(resolved, JSON.stringify(toDcPrtDocument(document.doc)));
+                const meshes = [...meshCache.values()];
+                const value = {
+                    triangles: meshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0),
+                    bodies: meshes.length,
+                    version: document.doc.version,
+                    filePath: resolved,
+                };
+                const sceneUrlBase = deps.ensureSceneRoute();
+                if (sceneUrlBase !== null) {
+                    value.sceneUrl = `${sceneUrlBase.replace('/scene', '/bin')}/${document.doc.docId}?v=${document.doc.version}`;
+                }
+                return value;
+            }
+            if (args.target === undefined)
+                throw new Error('target is required for .step/.stl exports');
+            const format = lower.endsWith('.stl') ? 'stl' : 'step';
+            const op = { kind: 'export', target: args.target, format };
+            const result = await runModelOp(op);
+            if (result.bytes === undefined)
+                throw new Error('export produced no data');
+            await writeFile(resolved, Buffer.from(result.bytes));
+            return syncScene(op, result, resolved);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD export ${String(args.path)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD export' }),
+    });
+    const cadDelete = defineTool({
+        name: 'cad_delete',
+        description: 'Delete a body from the modeling document.',
+        parameters: {
+            target: bodyTarget,
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ...requiredCounts,
+                    ...commonOptional,
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderModel(value) }],
+            presentationMeta: (_args, value) => metaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args) {
+            await restoreOnce();
+            const op = { kind: 'delete', target: args.target };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD delete ${String(args.target)}`, kind: 'delete' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD delete' }),
+    });
+    const cadVolume = defineTool({
+        name: 'cad_volume',
+        description: "Report a body's exact BRep volume in mm³.",
+        parameters: {
+            target: bodyTarget,
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ...requiredCounts,
+                    ...commonOptional,
+                    volume: { type: 'number', required: true, description: 'Volume (mm³).' },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderModel(value) }],
+            presentationMeta: (_args, value) => metaOf(value),
+        },
+        isConcurrencySafe: () => true,
+        async execute(args) {
+            await restoreOnce();
+            const op = { kind: 'volume', target: args.target };
+            const result = await runModelOp(op);
+            return syncScene(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `CAD volume ${String(args.target)}`, kind: 'read' }),
+        presentResult: () => ({ card: 'generic', title: 'CAD volume' }),
+    });
+    const cadDrawing = defineTool({
+        name: 'cad_drawing',
+        description: 'Generate an engineering drawing (工程图) of a body: GB first-angle 主视图/俯视图/左视图 plus an isometric view on an A4/A3 sheet — ' +
+            'hidden lines dashed, frame, title block, overall dimensions, standard scale. Renders in the Drawing tab and exports via cad_export target "drawing" (.svg/.dxf).',
+        parameters: {
+            target: { type: 'string', description: 'BodyId to draw (default: the most recently created surviving body).' },
+            paper: { type: 'string', enum: ['A4', 'A3'], description: 'Sheet size (default A4 landscape).' },
+            name: { type: 'string', description: 'Part display name for the title block.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: drawingSchema,
+            },
+            render: (_args, value) => [{ type: 'text', text: renderDrawing(value) }],
+            presentationMeta: (_args, value) => drawingMetaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args) {
+            await restoreOnce();
+            const target = args.target ?? lastBodyId();
+            if (target === undefined)
+                throw new Error('nothing to draw — create a body first');
+            if (!meshCache.has(target))
+                throw new Error(`unknown body: ${target}`);
+            const partName = args.name ?? document.doc.bodyNames[target] ?? target;
+            const paper = args.paper === 'A3' ? 'A3' : 'A4';
+            const sceneViewId = siblingUuid('d');
+            const op = { kind: 'drawing', target, views: DRAWING_VIEWS, sceneViewId, name: partName, paper };
+            const result = await runModelOp(op);
+            const sheet = await publishDrawing(sceneViewId, partName, result.views, paper);
+            const meshes = [...meshCache.values()];
+            const sceneUrlBase = deps.ensureSceneRoute();
+            const value = {
+                target,
+                name: partName,
+                drawingId: sceneViewId,
+                entities: sheet.entityCount,
+                scale: sheet.scale,
+                scaleText: sheet.scale >= 1 ? `${sheet.scale}:1` : `1:${Math.round(1 / sheet.scale * 100) / 100}`,
+                bodies: meshes.length,
+                triangles: meshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0),
+                version: document.doc.version,
+            };
+            if (sceneUrlBase !== null)
+                value.sceneUrl = `/dsh-cad/scene/${sceneViewId}?v=${document.doc.version}`;
+            return value;
+        },
+        presentCall: (args) => ({ card: 'generic', title: `工程图 ${String(args.target ?? '')}`.trim(), kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: '工程图' }),
+    });
+    const cadAssemblyInsert = defineTool({
+        name: 'cad_assembly_insert',
+        description: 'Insert a body into the assembly as a placed instance (mm, degrees, Z-up). `at` positions the instance origin; `rotate` orients it (XYZ Euler). ' +
+            'Bodies stay untouched in the Part Studio; the Assembly tab renders every instance. Instances persist in the document op log.',
+        parameters: {
+            bodyId: { type: 'string', required: true, description: 'BodyId to insert.' },
+            at: pointParam('instance position [x,y,z] (mm).'),
+            rotate: pointParam('instance rotation [rx,ry,rz] (degrees, XYZ Euler).'),
+            name: { type: 'string', description: 'Instance display name (defaults to the body name).' },
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: assemblySchema },
+            render: (_args, value) => [{ type: 'text', text: renderAssembly(value) }],
+            presentationMeta: (_args, value) => assemblyMetaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args) {
+            await restoreOnce();
+            if (!meshCache.has(args.bodyId))
+                throw new Error(`unknown body: ${args.bodyId}`);
+            const instanceId = nextInstanceId();
+            const op = {
+                kind: 'assembly_insert',
+                instanceId,
+                bodyId: args.bodyId,
+                name: args.name ?? document.doc.bodyNames[args.bodyId] ?? args.bodyId,
+                translate: args.at,
+                rotate: args.rotate,
+            };
+            const result = await runModelOp(op);
+            return syncAssembly(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `装配 ${String(args.bodyId)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: '装配插入' }),
+    });
+    const cadAssemblyMove = defineTool({
+        name: 'cad_assembly_move',
+        description: 'Set an assembly instance placement (absolute, not incremental): `at` sets the position, `rotate` the orientation (mm, degrees).',
+        parameters: {
+            instanceId: { type: 'string', required: true, description: 'InstanceId to move.' },
+            at: pointParam('new position [x,y,z] (mm).'),
+            rotate: pointParam('new rotation [rx,ry,rz] (degrees, XYZ Euler).'),
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: assemblySchema },
+            render: (_args, value) => [{ type: 'text', text: renderAssembly(value) }],
+            presentationMeta: (_args, value) => assemblyMetaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args) {
+            await restoreOnce();
+            const op = {
+                kind: 'assembly_transform',
+                instanceId: args.instanceId,
+                translate: args.at,
+                rotate: args.rotate,
+            };
+            const result = await runModelOp(op);
+            return syncAssembly(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `移动 ${String(args.instanceId)}`, kind: 'other' }),
+        presentResult: () => ({ card: 'generic', title: '装配移动' }),
+    });
+    const cadAssemblyRemove = defineTool({
+        name: 'cad_assembly_remove',
+        description: 'Remove an instance from the assembly (the body itself stays in the Part Studio).',
+        parameters: {
+            instanceId: { type: 'string', required: true, description: 'InstanceId to remove.' },
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: assemblySchema },
+            render: (_args, value) => [{ type: 'text', text: renderAssembly(value) }],
+            presentationMeta: (_args, value) => assemblyMetaOf(value),
+        },
+        isConcurrencySafe: () => false,
+        async execute(args) {
+            await restoreOnce();
+            const op = { kind: 'assembly_remove', instanceId: args.instanceId };
+            const result = await runModelOp(op);
+            return syncAssembly(op, result);
+        },
+        presentCall: (args) => ({ card: 'generic', title: `移除 ${String(args.instanceId)}`, kind: 'delete' }),
+        presentResult: () => ({ card: 'generic', title: '装配移除' }),
+    });
+    return [
+        cadCreatePrim,
+        cadExtrude,
+        cadBoolean,
+        cadFillet,
+        cadTransform,
+        cadExport,
+        cadDelete,
+        cadVolume,
+        cadDrawing,
+        cadAssemblyInsert,
+        cadAssemblyMove,
+        cadAssemblyRemove,
+    ];
+}
+export const MODEL_TOOL_NAMES = [
+    'cad_create_prim',
+    'cad_extrude_profile',
+    'cad_boolean',
+    'cad_fillet',
+    'cad_transform',
+    'cad_export',
+    'cad_delete',
+    'cad_volume',
+    'cad_drawing',
+    'cad_assembly_insert',
+    'cad_assembly_move',
+    'cad_assembly_remove',
+];