dsh-cad 0.2.0 → 0.7.0

package/lib/types/modeling/ansatz-bridge.d.ts

@@ -0,0 +1,24 @@
+/** The solver's solve report (outcome + solved entities + diagnostics). */
+export interface AnsatzSolveReport {
+    outcome: string;
+    entities: Array<{
+        id: number;
+        geometry?: Record<string, unknown>;
+    }>;
+    diagnostics?: Record<string, unknown>;
+}
+/**
+ * Resolve the wasm solver package directory, or null when none is present.
+ * The npm dependency wins, so `npm install ansatz-wasm@latest` takes effect.
+ */
+export declare function resolveAnsatzWasmDir(explicit?: string): string | null;
+/** Whether the solver is available (diagnostics/tests). */
+export declare function ansatzAvailable(): boolean;
+/** Solve one model with the wasm solver. */
+export declare function solveModel(model: unknown, options?: {
+    wasmDir?: string;
+}): Promise<AnsatzSolveReport>;
+/** Solver version string, or null when the solver is unavailable. */
+export declare function ansatzVersion(options?: {
+    wasmDir?: string;
+}): string | null;

package/lib/types/modeling/bin-store.d.ts

@@ -14,6 +14,8 @@ export declare class BinarySceneStore {
     publish(viewId: string, meshes: BinMeshData[]): Promise<number>;
     /** Fetch for serving: memory first, disk mirror as the restart fallback. */
     get(viewId: string): Promise<Entry | null>;
+    /** Existence check without loading the buffer into memory. */
+    has(viewId: string): Promise<boolean>;
     /** Debounced disk mirror: one write after modeling quiesces, not per step. */
     private scheduleDiskMirror;
 }

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

@@ -36,6 +36,12 @@ export interface OpResult {
     views?: DrawingView[];
     instanceId?: string;
     instances?: AssemblyInstance[];
+    /** Pattern op: the newly created copy bodies with their meshes. */
+    created?: Array<{
+        bodyId: string;
+        name?: string;
+        mesh?: WorkerMesh;
+    }>;
 }
 export interface DrawingViewSpec {
     name: string;
@@ -51,10 +57,45 @@ export type ModelOp = {
 } | {
     kind: 'extrude_profile';
     bodyId: string;
-    points: number[];
+    points?: number[];
+    profile?: unknown;
     height?: number;
     base?: number;
     name?: string;
+} | {
+    kind: 'loft';
+    bodyId: string;
+    sections: number[][];
+    solid?: boolean;
+    ruled?: boolean;
+    name?: string;
+} | {
+    kind: 'revolve';
+    bodyId: string;
+    profile: unknown;
+    angle?: number;
+    axis?: [number, number, number];
+    at?: [number, number, number];
+    name?: string;
+} | {
+    kind: 'chamfer';
+    target: string;
+    distance: number;
+} | {
+    kind: 'pattern';
+    target: string;
+    mode: 'linear' | 'circular';
+    count: number;
+    delta?: [number, number, number];
+    axis?: [number, number, number];
+    at?: [number, number, number];
+    angle?: number;
+} | {
+    kind: 'sweep';
+    bodyId: string;
+    profile: unknown;
+    path: number[];
+    name?: string;
 } | {
     kind: 'boolean';
     op: 'fuse' | 'cut' | 'common';
@@ -106,6 +147,14 @@ export type ModelOp = {
 } | {
     kind: 'assembly_remove';
     instanceId: string;
+} | {
+    kind: 'assembly_list';
+} | {
+    kind: 'constraints';
+    model: {
+        entities: unknown[];
+        constraints: unknown[];
+    };
 } | {
     kind: 'export_assembly';
     format: 'step' | 'stl';

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

@@ -0,0 +1,63 @@
+/**
+ * Constraint-model helpers: map dsh-cad assembly instances (translate + XYZ
+ * Euler degrees, matching cad_transform / assembly.ts) to and from the
+ * Ansatz solver's `rigid3` pose (translation + rotation as an exponential-map
+ * vector — direction = axis, magnitude = radians), plus the persisted
+ * constraint-model types shared by the cad_constraint / cad_solve /
+ * cad_motion tools.
+ */
+import type { AssemblyInstance } from './client.js';
+export interface SolverVec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Ansatz rigid3 pose: translation + exponential-map rotation vector. */
+export interface Rigid3Pose {
+    translation: SolverVec3;
+    rotation: {
+        vector: [number, number, number];
+    };
+}
+/** One entity of the persisted constraint model. */
+export interface ConstraintEntity {
+    id: number;
+    /** Assembly instance this entity tracks (geometry stays in sync on solve). */
+    instance?: string;
+    /** Literal geometry (point2 …) or a rigid3 snapshot; omitted for instance-bound entities until solve time. */
+    geometry?: Record<string, unknown>;
+}
+/** One constraint, pass-through to the solver's schema (type + refs + params). */
+export interface ConstraintEntry {
+    id: number;
+    kind: Record<string, unknown>;
+    label?: string;
+}
+/** The persisted constraint model (op log entry; the worker stores it as a no-op). */
+export interface ConstraintModel {
+    entities: ConstraintEntity[];
+    constraints: ConstraintEntry[];
+}
+/** Instance placement → solver rigid3 pose. */
+export declare function instanceToRigid3(instance: AssemblyInstance): Rigid3Pose;
+/** Solver rigid3 pose → instance placement (translate tuple + Euler degrees). */
+export declare function rigid3ToInstance(pose: Rigid3Pose): {
+    translate: [number, number, number];
+    rotate: [number, number, number];
+};
+/** Build the solver-input model: instance-bound entities get live rigid3 poses. */
+export declare function buildSolverModel(model: ConstraintModel, instances: AssemblyInstance[]): {
+    entities: Array<{
+        id: number;
+        geometry: Record<string, unknown>;
+    }>;
+    constraints: ConstraintEntry[];
+};
+/** Extract solved rigid3 poses keyed by entity id (absent for 2D geometry). */
+export declare function solvedRigid3s(reportEntities: Array<{
+    id: number;
+    geometry?: {
+        type?: string;
+        pose?: Rigid3Pose;
+    };
+}>): Map<number, Rigid3Pose>;

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

@@ -11,7 +11,15 @@ export interface ModelDoc {
 export declare class ModelDocument {
     readonly root: string;
     doc: ModelDoc;
-    constructor(root: string);
+    /**
+     * @param docId Registry-assigned document id. With an id the document lives
+     *   at `<root>/.dsh-cad/docs/<docId>.json`; without one it keeps the legacy
+     *   single-document path `<root>/.dsh-cad/model.json` (tests, migration).
+     */
+    constructor(root: string, docId?: string);
+    /** True when this instance owns the legacy single-document path. */
+    private readonly legacy;
+    private get base();
     private get directory();
     private get file();
     /** Load the persisted document if one exists. */
@@ -21,6 +29,8 @@ export declare class ModelDocument {
         bodyId: string;
         name: string;
     } | null): Promise<void>;
+    /** Persist the current state without appending an op (registry creation). */
+    save(): Promise<void>;
     /** Clear the document (cad_new / tests). */
     clear(): Promise<void>;
 }

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

@@ -0,0 +1,61 @@
+import { ModelDocument } from './document.js';
+export interface DocMeta {
+    id: string;
+    name: string;
+    /** ISO timestamps; updatedAt drives the file-list ordering. */
+    createdAt: string;
+    updatedAt: string;
+    opCount: number;
+    bodyCount: number;
+}
+export declare class DocumentRegistry {
+    readonly root: string;
+    private state;
+    private loaded;
+    constructor(root: string);
+    private get base();
+    private get docsDir();
+    private get file();
+    private docFile;
+    /** Load the manifest once; migrates the legacy single document on first run. */
+    private ensureLoaded;
+    /**
+     * Adopt the pre-registry single document (`.dsh-cad/model.json`) as a named
+     * document so existing work stays openable from the file list.
+     */
+    private migrateLegacy;
+    private persist;
+    /** All document metas, most recently updated first. */
+    list(): Promise<DocMeta[]>;
+    /** Create a named document (empty op log, persisted immediately). */
+    create(name?: string): Promise<ModelDocument>;
+    private nextUntitledName;
+    /** Open a document by id (null when the manifest has no such entry). */
+    open(id: string): Promise<ModelDocument | null>;
+    /** Resolve by document id or (case-insensitive) exact name. */
+    resolve(ref: string): Promise<DocMeta | null>;
+    /** Bind a session to its active document. */
+    bind(sessionId: string, docId: string): Promise<void>;
+    /** The session's active document id (null: unbound — create on first use). */
+    bindingOf(sessionId: string): Promise<string | null>;
+    /**
+     * One-shot upgrade continuity: hand the migrated legacy document to the
+     * first unbound session (so continuing an old conversation keeps its
+     * bodies) and clear the marker. Returns null once claimed or absent.
+     */
+    claimLegacyFor(sessionId: string): Promise<string | null>;
+    /** Update a document's meta after recorded ops (write-through). */
+    touch(docId: string, patch: {
+        opCount?: number;
+        bodyCount?: number;
+        name?: string;
+    }): Promise<void>;
+    /** Rename a document. */
+    rename(id: string, name: string): Promise<DocMeta | null>;
+    /**
+     * Delete a document: remove its op log, drop every session binding to it.
+     * Scene caches (bin mirrors) are inert without the manifest entry and are
+     * left for the store's own lifecycle.
+     */
+    remove(id: string): Promise<boolean>;
+}

package/lib/types/routes.d.ts

@@ -1,9 +1,12 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { SceneStore } from './store.js';
 import type { BinarySceneStore } from './modeling/bin-store.js';
+import type { DocumentRegistry } from './modeling/registry.js';
 export declare const SCENE_ROUTE_PATH = "/dsh-cad/scene";
 export declare const BIN_ROUTE_PATH = "/dsh-cad/bin";
 export declare const DEMO_SCENE_ROUTE_PATH = "/dsh-cad/demo-scene";
+export declare const DOCS_ROUTE_PATH = "/dsh-cad/docs";
+export declare const DOCS_DELETE_ROUTE_PATH = "/dsh-cad/docs/delete";
 /** The built-in demo examples (packaged as lib/demo-<part>.brep). */
 export declare const DEMO_PARTS: readonly ["bracket", "flange", "shaft"];
 export type DemoPart = (typeof DEMO_PARTS)[number];
@@ -24,4 +27,12 @@ export declare function registerBinRoute(server: {
 export declare function registerDemoRoute(server: {
     register: (route: SceneRoute) => () => void;
 }): () => void;
+/** Register the docs file-space route: GET /dsh-cad/docs (list documents). */
+export declare function registerDocsRoute(server: {
+    register: (route: SceneRoute) => () => void;
+}, registry: DocumentRegistry, binStore: BinarySceneStore): () => void;
+/** Register the docs delete route: POST /dsh-cad/docs/delete?id=<docId>. */
+export declare function registerDocsDeleteRoute(server: {
+    register: (route: SceneRoute) => () => void;
+}, registry: DocumentRegistry): () => void;
 export type { SceneRoute };

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

@@ -0,0 +1,25 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { ModelOp, OpResult } from '../modeling/client.js';
+import type { ConstraintModel } from '../modeling/constraints.js';
+import type { ModelDocument } from '../modeling/document.js';
+import type { BinMeshData } from '../modeling/bin-format.js';
+import type { ModelToolDeps } from './cad-model.js';
+/**
+ * State shared with createModelTools. The active document is read through
+ * `getDocument()` (multi-document sessions swap it per call), and
+ * `resolveDoc(exec)` binds the calling session's document + replays it —
+ * the multi-document successor of the old restoreOnce.
+ */
+export interface ConstraintToolCtx {
+    deps: ModelToolDeps;
+    getDocument(): ModelDocument;
+    meshCache: Map<string, BinMeshData>;
+    constraintState: {
+        model: ConstraintModel | null;
+        lastSuggestions: string[];
+    };
+    resolveDoc(exec: unknown): Promise<void>;
+    syncAssembly(op: ModelOp, result: OpResult, filePath?: string): Promise<Record<string, unknown>>;
+    assemblyMetaOf(value: Record<string, unknown>): Record<string, unknown>;
+}
+export declare function createConstraintTools(ctx: ConstraintToolCtx): ToolDefinition[];

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

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import { DocumentRegistry } from '../modeling/registry.js';
 import type { BinarySceneStore } from '../modeling/bin-store.js';
 import type { SceneStore } from '../store.js';
 export interface ModelToolDeps {
@@ -7,7 +8,9 @@ export interface ModelToolDeps {
     sceneStore: SceneStore;
     workspaceRoot: string;
     ensureSceneRoute: () => string | null;
+    /** The workspace document registry (file space + session bindings). */
+    registry: DocumentRegistry;
 }
-/** Build the whole tool family over one document + worker + scene store. */
+/** 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_boolean", "cad_fillet", "cad_transform", "cad_export", "cad_delete", "cad_volume", "cad_drawing", "cad_assembly_insert", "cad_assembly_move", "cad_assembly_remove"];
+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"];

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.2.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "MIT",
   "author": "LAU-MARS",
@@ -58,18 +58,19 @@
   },
   "files": [
     "lib",
-    "cordis.patch.yml",
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node esbuild.client.mjs && node -e \"const fs=require('fs'); fs.copyFileSync('src/convert/step-worker.mjs','lib/convert/step-worker.mjs'); fs.mkdirSync('lib/modeling',{recursive:true}); fs.copyFileSync('src/modeling/occt-adapter.cjs','lib/modeling/occt-adapter.cjs'); fs.copyFileSync('src/modeling/modeling-worker.cjs','lib/modeling/modeling-worker.cjs'); fs.copyFileSync('src/modeling/hlr.cjs','lib/modeling/hlr.cjs'); for (const part of ['bracket','flange','shaft']) fs.copyFileSync('assets/demo-'+part+'.brep','lib/demo-'+part+'.brep')\"",
+    "build": "tsc -p tsconfig.json && node esbuild.client.mjs && node -e \"const fs=require('fs'); fs.copyFileSync('src/convert/step-worker.mjs','lib/convert/step-worker.mjs'); fs.mkdirSync('lib/modeling',{recursive:true}); fs.copyFileSync('src/modeling/occt-adapter.cjs','lib/modeling/occt-adapter.cjs'); fs.copyFileSync('src/modeling/modeling-worker.cjs','lib/modeling/modeling-worker.cjs'); fs.copyFileSync('src/modeling/occt-bridge.cjs','lib/modeling/occt-bridge.cjs'); for (const part of ['bracket','flange','shaft']) fs.copyFileSync('assets/demo-'+part+'.brep','lib/demo-'+part+'.brep')\"",
     "watch": "tsc -p tsconfig.json --watch & node esbuild.client.mjs --watch",
     "test": "vitest run --no-file-parallelism",
     "test:watch": "vitest"
   },
   "dependencies": {
+    "ansatz-wasm": "^0.2.0",
     "dxf-parser": "^1.1.2",
     "occt-import-js": "^0.0.23",
+    "occt.ts": "^0.1.0",
     "opencascade.js": "^1.1.1",
     "three": "^0.185.1"
   },

package/cordis.patch.yml

@@ -1,3 +0,0 @@
-- insert:
-    - id: dsh-cad
-      name: 'dsh-cad'