dsh-cad 0.13.0 → 0.13.2

package/lib/modeling/assembly.js

@@ -106,8 +106,36 @@ export function foldAssemblyState(ops, bodyNames) {
     const instances = [];
     let entities = [];
     let constraints = [];
+    const liveBodyIds = new Set();
     for (const op of ops) {
         switch (op.kind) {
+            case 'create_prim':
+            case 'extrude_profile':
+            case 'loft':
+            case 'revolve':
+            case 'sweep':
+                liveBodyIds.add(op.bodyId);
+                break;
+            case 'pattern': {
+                // Mirror the worker's unique-copy rule so replay-derived ids match
+                // (repeat patterns of the same target uniquify against live ids).
+                const count = Math.max(1, Math.trunc(op.count));
+                for (let i = 1; i < count; i++) {
+                    let seq = i;
+                    let id = `${op.target}p${seq}`;
+                    while (liveBodyIds.has(id))
+                        id = `${op.target}p${++seq}`;
+                    liveBodyIds.add(id);
+                }
+                break;
+            }
+            case 'delete':
+                liveBodyIds.delete(op.target);
+                break;
+            case 'boolean':
+                for (const tool of op.tools)
+                    liveBodyIds.delete(tool);
+                break;
             case 'assembly_insert':
                 instances.push({
                     instanceId: op.instanceId,
@@ -142,11 +170,11 @@ export function foldAssemblyState(ops, bodyNames) {
                 break;
         }
     }
-    return { instances, entities, constraints };
+    return { instances, entities, constraints, liveBodyIds };
 }
 /** Build the assembly-tree payload from a restored document. */
 export function assemblyTreePayload(doc) {
-    const { instances, entities, constraints } = foldAssemblyState(doc.ops, doc.bodyNames);
+    const { instances, entities, constraints, liveBodyIds } = foldAssemblyState(doc.ops, doc.bodyNames);
     const names = assemblyDisplayNames(instances);
     const nameByInstanceId = new Map(instances.map((instance, index) => [instance.instanceId, names[index]]));
     const entityName = (id) => {
@@ -165,8 +193,11 @@ export function assemblyTreePayload(doc) {
             bodyId: instance.bodyId,
             name: names[index],
             color: instanceColor(index),
-            // bodyNames tracks every live body (unnamed bodies record their id).
-            missing: doc.bodyNames[instance.bodyId] === undefined,
+            // Missing only when BOTH witnesses lack the body: liveBodyIds (folded
+            // from the op log — covers pattern copies in documents written before
+            // copy names were recorded, issue #6) and bodyNames (the recorded name
+            // manifest).
+            missing: !liveBodyIds.has(instance.bodyId) && doc.bodyNames[instance.bodyId] === undefined,
         })),
         constraints: constraints.map((constraint) => {
             const entry = { id: constraint.id, type: String(constraint.kind.type ?? 'constraint') };

package/lib/modeling/document.js

@@ -44,12 +44,14 @@ export class ModelDocument {
             // No document yet — a fresh one stays in memory until the first op.
         }
     }
-    /** Append an applied operation and persist. */
+    /** Append an applied operation and persist. Multi-create ops (pattern)
+     *  pass an array so every copy's display name lands in bodyNames. */
     async record(op, bodyName) {
         this.doc.ops.push(op);
         this.doc.version += 1;
-        if (bodyName !== null)
-            this.doc.bodyNames[bodyName.bodyId] = bodyName.name;
+        const entries = Array.isArray(bodyName) ? bodyName : bodyName === null ? [] : [bodyName];
+        for (const entry of entries)
+            this.doc.bodyNames[entry.bodyId] = entry.name;
         if (op.kind === 'delete' || op.kind === 'boolean') {
             const removed = op.kind === 'delete' ? [op.target] : op.tools;
             for (const id of removed)

package/lib/modeling/modeling-worker.cjs

@@ -12,6 +12,7 @@ const { parentPort } = require('node:worker_threads')
 const path = require('node:path')
 const fs = require('node:fs')
 const { createRequire } = require('node:module')
+const { pathToFileURL } = require('node:url')
 const { createAdapter } = require('./occt-adapter.cjs')
 const { createOcctTsAdapter } = require('./occtts-adapter.cjs')
 const { createOcctBridge, loadSharedOcctModule } = require('./occt-bridge.cjs')
@@ -20,10 +21,6 @@ const require3 = createRequire(__filename)
 // The ES6 emscripten build reads a global __dirname when its factory runs.
 if (typeof globalThis.__dirname === 'undefined') globalThis.__dirname = __dirname
 
-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.
@@ -133,7 +130,13 @@ async function applyOp(op) {
       const count = Math.max(1, Math.trunc(op.count))
       const created = []
       for (let i = 1; i < count; i++) {
-        const id = `${op.target}p${i}`
+        // Unique copy ids even when the same target is patterned repeatedly:
+        // the naive `<target>p<i>` collides with the previous pattern's
+        // copies and silently overwrites them (issue #6). The rule is
+        // deterministic, so replaying the op log reproduces the same ids.
+        let seq = i
+        let id = `${op.target}p${seq}`
+        while (bodies.has(id)) id = `${op.target}p${++seq}`
         let shape
         if (op.mode === 'circular') {
           // Rotation about a principal axis through `at`: translate in, rotate,
@@ -155,7 +158,7 @@ async function applyOp(op) {
             translate: [op.delta[0] * i, op.delta[1] * i, op.delta[2] * i],
           })
         }
-        const name = `${body.name}·${i}`
+        const name = `${body.name}·${seq}`
         bodies.set(id, { shape, name })
         created.push({ bodyId: id, name, mesh: meshOf(shape, name) })
       }
@@ -455,6 +458,15 @@ async function boot() {
     kernelName = 'occt.ts'
   } else {
     console.warn('[dsh-cad] occt.ts unavailable — falling back to the opencascade.js backend')
+    // Load the fallback kernel lazily: a top-level require() of the
+    // emscripten loader crashes the whole worker at module scope when the
+    // resolved opencascade.js build is ESM (ERR_REQUIRE_ESM) — boot() never
+    // runs and the main thread hangs waiting for ready. Dynamic import()
+    // accepts both module formats and confines a broken fallback build to
+    // this branch (surfaced as a clean init error via boot().catch).
+    const loaderPath = require3.resolve('opencascade.js/dist/opencascade.wasm.js')
+    const loaderModule = await import(pathToFileURL(loaderPath).href)
+    const wasmBinary = fs.readFileSync(path.join(path.dirname(loaderPath), 'opencascade.wasm.wasm'))
     const initOpenCascade = loaderModule.default ?? loaderModule
     occt = await initOpenCascade({ wasmBinary })
     adapter = createAdapter(occt)

package/lib/modeling/occt-bridge.cjs

@@ -78,6 +78,9 @@ 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
+  // DSH_CAD_KERNEL=opencascade.js forces the fallback backend (diagnostics
+  // and regression tests — compare kernel behavior on a real model).
+  if (process.env.DSH_CAD_KERNEL === 'opencascade.js') return null
   const distDir = resolveDistDir()
   if (distDir === null) return null
   try {

package/lib/modeling/occtts-adapter.cjs

@@ -349,6 +349,12 @@ function createOcctTsAdapter(mod) {
       }
       const next = mod.shell(shape, Math.abs(thickness), ptr, faces.length)
       if (next.isNull()) throw wrapError('shell', new Error('null shape'))
+      // The kernel can return the input unchanged on chamfered/tangent faces
+      // (issue #6) — an unchanged volume means the shell silently no-op'd;
+      // fail loudly with an actionable hint instead of reporting success.
+      if (Math.abs(next.volume() - shape.volume()) < 1e-6) {
+        throw wrapError('shell', new Error('kernel returned an unchanged solid — shell 未生效（倒角/相切面是已知诱因），请减小壁厚或先抽壳后倒角'))
+      }
       return next
     } finally {
       if (ptr !== 0) mod._free(ptr)
@@ -360,6 +366,10 @@ function createOcctTsAdapter(mod) {
     const d = direction ?? [0, 0, 1]
     const next = mod.draft(shape, (angleDegrees * Math.PI) / 180, d[0], d[1], d[2], 0, 0, 1, 0, 0, true)
     if (next.isNull()) throw wrapError('draft', new Error('null shape'))
+    // Same silent no-op guard as shell: unchanged volume = nothing happened.
+    if (Math.abs(next.volume() - shape.volume()) < 1e-6) {
+      throw wrapError('draft', new Error('kernel returned an unchanged solid — draft 未生效（没有可倾斜的壁面？），请检查拔模方向或改用显式面选择'))
+    }
     return next
   }
 

package/lib/tools/cad-freecad.js

@@ -8,7 +8,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { resolveWorkspacePath } from './util.js';
+import { resolveSessionPath } from './util.js';
 import { findFreeCad, runFreeCadProgram } from '../cad_connector/freecad-executor.js';
 import { isKnownOpKind, normalizeOps } from '../cad_connector/executor.js';
 // Shared executor-contract normalization; historical alias for callers/tests.
@@ -84,7 +84,7 @@ export function createFreeCadTool(deps) {
         },
         timeoutMs: 300_000,
         isConcurrencySafe: () => false,
-        async execute(args) {
+        async execute(args, exec) {
             const executable = findFreeCad();
             if (executable === null) {
                 throw new Error('FreeCAD was not found — install FreeCAD or point FREECAD_BIN at its console binary (freecadcmd)');
@@ -105,14 +105,14 @@ export function createFreeCadTool(deps) {
             }
             const program = { ops: steps, names };
             if (args.input !== undefined) {
-                const resolved = resolveWorkspacePath(args.input, deps.workspaceRoot);
+                const resolved = resolveSessionPath(args.input, exec, deps.workspaceRoot);
                 const extension = resolved.toLowerCase().split('.').pop() ?? '';
                 if (!INPUT_EXTENSIONS.has(extension))
                     throw new Error(`input must be one of .step .stp .brep .stl (got .${extension})`);
                 program.input = { format: extension, path: resolved, bodyId: 'input' };
             }
             if (args.exportPath !== undefined) {
-                const resolved = resolveWorkspacePath(args.exportPath, deps.workspaceRoot);
+                const resolved = resolveSessionPath(args.exportPath, exec, deps.workspaceRoot);
                 const extension = resolved.toLowerCase().split('.').pop() ?? '';
                 if (!EXPORT_EXTENSIONS.has(extension))
                     throw new Error(`exportPath must be .step or .stl (got .${extension})`);

package/lib/tools/cad-fusion.js

@@ -7,7 +7,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { resolveWorkspacePath } from './util.js';
+import { resolveSessionPath } from './util.js';
 import { isKnownOpKind, normalizeOps } from '../cad_connector/executor.js';
 import { FUSION360_EXECUTOR } from '../cad_connector/fusion360-executor.js';
 export function createFusionTool(deps) {
@@ -73,7 +73,7 @@ export function createFusionTool(deps) {
         },
         timeoutMs: 300_000,
         isConcurrencySafe: () => false,
-        async execute(args) {
+        async execute(args, exec) {
             if (!FUSION360_EXECUTOR.available()) {
                 throw new Error(FUSION360_EXECUTOR.unavailableReason?.() ?? 'Fusion 360 is not available on this machine');
             }
@@ -93,7 +93,7 @@ export function createFusionTool(deps) {
             }
             const program = { ops: steps, names, display: true };
             if (args.exportPath !== undefined) {
-                const resolved = resolveWorkspacePath(args.exportPath, deps.workspaceRoot);
+                const resolved = resolveSessionPath(args.exportPath, exec, deps.workspaceRoot);
                 const extension = resolved.toLowerCase().split('.').pop() ?? '';
                 if (extension !== 'step' && extension !== 'stp' && extension !== 'stl') {
                     throw new Error(`exportPath must be .step or .stl (got .${extension})`);

package/lib/tools/cad-image.js

@@ -8,7 +8,7 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { decodePng } from '../convert/png.js';
 import { extractProfiles } from '../image/profile.js';
-import { loadCadFile, resolveWorkspacePath } from './util.js';
+import { loadCadFile, resolveSessionPath } from './util.js';
 export function createCadImageTool(deps) {
     return defineTool({
         name: 'cad_image_profile',
@@ -56,8 +56,8 @@ export function createCadImageTool(deps) {
         },
         timeoutMs: 120_000,
         isConcurrencySafe: () => true,
-        async execute(args) {
-            const resolved = resolveWorkspacePath(args.path, deps.workspaceRoot);
+        async execute(args, exec) {
+            const resolved = resolveSessionPath(args.path, exec, deps.workspaceRoot);
             const buffer = await loadCadFile(resolved);
             const image = decodePng(buffer);
             const profiles = extractProfiles(image, {

package/lib/tools/cad-info.js

@@ -6,7 +6,7 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { detectFormat } from '../convert/detect.js';
 import { convert } from '../convert/index.js';
 import { sceneStats } from '../types.js';
-import { loadCadFile, resolveWorkspacePath } from './util.js';
+import { loadCadFile, resolveSessionPath } from './util.js';
 /** Build the cad_info tool definition. */
 export function createCadInfoTool(deps) {
     return defineTool({
@@ -58,8 +58,8 @@ export function createCadInfoTool(deps) {
         },
         timeoutMs: 180_000,
         isConcurrencySafe: () => true,
-        async execute(args) {
-            const resolved = resolveWorkspacePath(args.path, deps.workspaceRoot);
+        async execute(args, exec) {
+            const resolved = resolveSessionPath(args.path, exec, deps.workspaceRoot);
             const name = resolved.split('/').pop() ?? resolved;
             const format = detectFormat(name);
             if (format === null) {

package/lib/tools/cad-model.js

@@ -1,10 +1,11 @@
-import { writeFile } from 'node:fs/promises';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
 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 { resolveSessionPath } from './util.js';
 import { toDcPrtDocument } from '../feature_script/dc_prt.js';
 import { createConstraintTools } from './cad-constraint.js';
 /** Mirror a worker mesh with its raw typed arrays (binary-transport ready). */
@@ -359,6 +360,24 @@ export function createModelTools(deps) {
         ];
         if (Array.isArray(value.removed) && value.removed.length > 0)
             lines.push(`consumed bodies: ${value.removed.join(', ')}`);
+        // cad_sketch_list: the sketches are the payload — render them, or the
+        // result reads as just a body count (issue #6).
+        if (Array.isArray(value.sketches)) {
+            const sketches = value.sketches;
+            if (sketches.length === 0) {
+                lines.push('sketches: (none — create one with cad_sketch_new)');
+            }
+            else {
+                for (const sketch of sketches) {
+                    const size = sketch.type === 'circle'
+                        ? `R${String(sketch.radius)}`
+                        : sketch.type === 'segments'
+                            ? `${String(sketch.segments)} segments`
+                            : `${String(sketch.points)} points`;
+                    lines.push(`sketch ${String(sketch.name)}: ${String(sketch.type)} (${size})`);
+                }
+            }
+        }
         if (value.volume !== undefined)
             lines.push(`volume: ${Number(value.volume).toFixed(2)} mm³`);
         if (value.filePath !== undefined)
@@ -381,6 +400,8 @@ export function createModelTools(deps) {
     /** Presentation meta for assembly ops (kind 3d, doc assembly). */
     const assemblyMetaOf = (value) => ({
         viewId: String(value.viewId),
+        // viewId 是装配场景 id（asm-<docId>）；docId 供客户端查文档级数据（特征树等）。
+        docId: document.doc.docId,
         kind: '3d',
         format: 'assembly',
         file: 'assembly',
@@ -395,6 +416,8 @@ export function createModelTools(deps) {
     /** Presentation meta for drawing ops (kind 2d, doc drawing). */
     const drawingMetaOf = (value) => ({
         viewId: String(value.drawingId),
+        // viewId 是图纸场景 id；docId 供客户端查文档级数据（特征树等）。
+        docId: document.doc.docId,
         kind: '2d',
         format: 'drawing',
         file: 'drawing',
@@ -1023,12 +1046,16 @@ export function createModelTools(deps) {
                 ...(args.angle !== undefined ? { angle: args.angle } : {}),
             };
             const result = await runModelOp(op);
-            const created = (result.created ?? []).map((entry) => {
+            const createdEntries = result.created ?? [];
+            const created = createdEntries.map((entry) => {
                 if (entry.mesh !== undefined)
                     meshCache.set(entry.bodyId, mirrorMesh(entry.mesh, entry.bodyId));
                 return entry.bodyId;
             });
-            await document.record(op, null);
+            // Record every copy's name: bodyNames is the manifest the assembly
+            // tree reads, and skipping copies marked pattern-derived instances as
+            // missing (issue #6).
+            await document.record(op, createdEntries.map((entry) => ({ bodyId: entry.bodyId, name: entry.name ?? entry.bodyId })));
             const meshes = [...meshCache.values()];
             const sceneUrlBase = deps.ensureSceneRoute();
             if (sceneUrlBase !== null && meshes.length > 0) {
@@ -1188,7 +1215,10 @@ export function createModelTools(deps) {
         isConcurrencySafe: () => true,
         async execute(args, exec) {
             await resolveDoc(exec);
-            const resolved = resolveWorkspacePath(args.path, deps.workspaceRoot);
+            const resolved = resolveSessionPath(args.path, exec, deps.workspaceRoot);
+            // Auto-create the parent directory — the session workspace is the base,
+            // and nested export paths should just work (issue #6).
+            await mkdir(path.dirname(resolved), { recursive: true });
             const lower = args.path.toLowerCase();
             // Assembly export: compound of transformed instances via the worker.
             if (args.target === 'assembly') {

package/lib/tools/cad-onshape.js

@@ -9,7 +9,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { resolveWorkspacePath } from './util.js';
+import { resolveSessionPath } from './util.js';
 import { onshapeAvailable, onshapeUnavailableReason, runOnshapeProgram } from '../cad_connector/onshape-executor.js';
 import { isKnownOpKind, normalizeOps } from '../cad_connector/executor.js';
 const EXPORT_EXTENSIONS = new Set(['stl', 'step', 'stp', 'x_t', 'x_b']);
@@ -90,7 +90,7 @@ export function createOnshapeTool(deps) {
         },
         timeoutMs: 300_000,
         isConcurrencySafe: () => false,
-        async execute(args) {
+        async execute(args, exec) {
             if (!onshapeAvailable())
                 throw new Error(onshapeUnavailableReason());
             if (!Array.isArray(args.steps) || args.steps.length === 0) {
@@ -121,7 +121,7 @@ export function createOnshapeTool(deps) {
                     : {}),
             };
             if (args.exportPath !== undefined) {
-                const resolved = resolveWorkspacePath(args.exportPath, deps.workspaceRoot);
+                const resolved = resolveSessionPath(args.exportPath, exec, deps.workspaceRoot);
                 const extension = resolved.toLowerCase().split('.').pop() ?? '';
                 if (!EXPORT_EXTENSIONS.has(extension)) {
                     throw new Error(`exportPath must be one of ${[...EXPORT_EXTENSIONS].map((ext) => `.${ext}`).join(' ')} (got .${extension})`);

package/lib/tools/cad-view.js

@@ -7,7 +7,7 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { detectFormat, is3DFormat } from '../convert/detect.js';
 import { convert } from '../convert/index.js';
 import { sceneStats } from '../types.js';
-import { loadCadFile, resolveWorkspacePath } from './util.js';
+import { loadCadFile, resolveSessionPath } from './util.js';
 function formatBounds(stats) {
     if (stats.boundsMin === undefined || stats.boundsMax === undefined)
         return '';
@@ -71,8 +71,8 @@ export function createCadViewTool(deps) {
         },
         timeoutMs: 180_000,
         isConcurrencySafe: () => true,
-        async execute(args) {
-            const resolved = resolveWorkspacePath(args.path, deps.workspaceRoot);
+        async execute(args, exec) {
+            const resolved = resolveSessionPath(args.path, exec, deps.workspaceRoot);
             const name = basename(resolved);
             const format = detectFormat(name);
             if (format === null) {

package/lib/tools/util.js

@@ -10,6 +10,26 @@ import path from 'node:path';
 export function resolveWorkspacePath(input, workspaceRoot) {
     return path.isAbsolute(input) ? input : path.join(workspaceRoot, input);
 }
+/**
+ * The calling session's workspace cwd, when the host's agent runtime exposes
+ * it (`exec.agent.session.header.cwd`). dsh web/desktop launch the host with
+ * cwd = workspace, but a host started from another directory (e.g. a dsh
+ * source checkout) breaks that assumption — issue #6: exports landed in the
+ * launch directory instead of the session's workspace.
+ */
+export function sessionCwdOf(exec) {
+    const cwd = exec?.agent?.session?.header?.cwd;
+    return typeof cwd === 'string' && path.isAbsolute(cwd) ? cwd : null;
+}
+/**
+ * Resolve a model-supplied path against the SESSION workspace first, falling
+ * back to the process-cwd workspace root on hosts without session metadata.
+ */
+export function resolveSessionPath(input, exec, fallbackRoot) {
+    if (path.isAbsolute(input))
+        return input;
+    return path.join(sessionCwdOf(exec) ?? fallbackRoot, input);
+}
 /** Load a CAD file buffer, failing with model-friendly errors. */
 export async function loadCadFile(resolvedPath) {
     let info;

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

@@ -38,6 +38,10 @@ export interface FoldedAssembly {
     instances: AssemblyInstance[];
     entities: ConstraintEntity[];
     constraints: ConstraintEntry[];
+    /** Body ids alive at the end of the log — the ground truth for "missing".
+     *  Folded from ops rather than read off bodyNames because documents written
+     *  before pattern copies were recorded have incomplete name maps. */
+    liveBodyIds: Set<string>;
 }
 /**
  * Rebuild the assembly state purely from the persisted op log — the worker

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

@@ -24,11 +24,15 @@ export declare class ModelDocument {
     private get file();
     /** Load the persisted document if one exists. */
     restore(): Promise<void>;
-    /** Append an applied operation and persist. */
+    /** Append an applied operation and persist. Multi-create ops (pattern)
+     *  pass an array so every copy's display name lands in bodyNames. */
     record(op: ModelOp, bodyName: {
         bodyId: string;
         name: string;
-    } | null): Promise<void>;
+    } | Array<{
+        bodyId: string;
+        name: string;
+    }> | null): Promise<void>;
     /** Persist the current state without appending an op (registry creation). */
     save(): Promise<void>;
     /**

package/lib/types/tools/util.d.ts

@@ -1,4 +1,17 @@
 /** Resolve a model-supplied path against the workspace root. */
 export declare function resolveWorkspacePath(input: string, workspaceRoot: string): string;
+/**
+ * The calling session's workspace cwd, when the host's agent runtime exposes
+ * it (`exec.agent.session.header.cwd`). dsh web/desktop launch the host with
+ * cwd = workspace, but a host started from another directory (e.g. a dsh
+ * source checkout) breaks that assumption — issue #6: exports landed in the
+ * launch directory instead of the session's workspace.
+ */
+export declare function sessionCwdOf(exec: unknown): string | null;
+/**
+ * Resolve a model-supplied path against the SESSION workspace first, falling
+ * back to the process-cwd workspace root on hosts without session metadata.
+ */
+export declare function resolveSessionPath(input: string, exec: unknown, fallbackRoot: string): string;
 /** Load a CAD file buffer, failing with model-friendly errors. */
 export declare function loadCadFile(resolvedPath: string): Promise<Buffer>;

package/lib/types.js

@@ -5,13 +5,16 @@
  */
 /** Flatten a converted scene into the model/card-facing summary. */
 export function sceneStats(scene) {
+    // Tool output must round-trip lossless JSON: NaN/Infinity in source geometry
+    // (or a converter edge case) would make the registry reject the whole result
+    // — drop bounds containing non-finite numbers instead (issue #6).
+    const bounds = (min, max) => [...min, ...max].every((value) => Number.isFinite(value)) ? { boundsMin: min, boundsMax: max } : {};
     if (scene.kind === '3d') {
         return {
             format: scene.format,
             meshes: scene.meshes.length,
             triangles: scene.meshes.reduce((sum, mesh) => sum + mesh.triangleCount, 0),
-            boundsMin: [scene.bounds.min.x, scene.bounds.min.y, scene.bounds.min.z],
-            boundsMax: [scene.bounds.max.x, scene.bounds.max.y, scene.bounds.max.z],
+            ...bounds([scene.bounds.min.x, scene.bounds.min.y, scene.bounds.min.z], [scene.bounds.max.x, scene.bounds.max.y, scene.bounds.max.z]),
             units: scene.units,
         };
     }
@@ -19,7 +22,6 @@ export function sceneStats(scene) {
         format: scene.format,
         entities: scene.entities.length,
         layers: scene.layers,
-        boundsMin: [scene.bounds.min.x, scene.bounds.min.y],
-        boundsMax: [scene.bounds.max.x, scene.bounds.max.y],
+        ...bounds([scene.bounds.min.x, scene.bounds.min.y], [scene.bounds.max.x, scene.bounds.max.y]),
     };
 }