dsh-cad 0.2.0 → 0.7.0

package/lib/index.js

@@ -1,6 +1,7 @@
 import { SceneStore } from './store.js';
 import { BinarySceneStore } from './modeling/bin-store.js';
-import { registerSceneRoute, registerBinRoute, registerDemoRoute } from './routes.js';
+import { DocumentRegistry } from './modeling/registry.js';
+import { registerSceneRoute, registerBinRoute, registerDemoRoute, registerDocsRoute, registerDocsDeleteRoute } from './routes.js';
 import { createCadViewTool } from './tools/cad-view.js';
 import { createCadInfoTool } from './tools/cad-info.js';
 import { createModelTools } from './tools/cad-model.js';
@@ -14,6 +15,7 @@ export function apply(ctx, config = {}) {
     const root = config.root ?? process.cwd();
     const store = new SceneStore(root);
     const binStore = new BinarySceneStore(root);
+    const registry = new DocumentRegistry(process.cwd());
     const workspaceRoot = process.cwd();
     let routeRegistered = false;
     /** Idempotently register the scene routes; returns the JSON base or null. */
@@ -27,6 +29,8 @@ export function apply(ctx, config = {}) {
         registerSceneRoute(server, store);
         registerBinRoute(server, binStore);
         registerDemoRoute(server);
+        registerDocsRoute(server, registry, binStore);
+        registerDocsDeleteRoute(server, registry);
         routeRegistered = true;
         return '/dsh-cad/scene';
     };
@@ -55,7 +59,7 @@ export function apply(ctx, config = {}) {
     }
     const cadView = createCadViewTool({ store, workspaceRoot, ensureSceneRoute });
     const cadInfo = createCadInfoTool({ workspaceRoot });
-    const modelTools = createModelTools({ store: binStore, sceneStore: store, workspaceRoot, ensureSceneRoute });
+    const modelTools = createModelTools({ store: binStore, sceneStore: store, workspaceRoot, ensureSceneRoute, registry });
     const cadFreeCad = createFreeCadTool({ store: binStore, workspaceRoot, ensureSceneRoute });
     const cadFusion = createFusionTool({ store: binStore, workspaceRoot, ensureSceneRoute });
     const cadImage = createCadImageTool({ store, workspaceRoot, ensureSceneRoute });

package/lib/modeling/ansatz-bridge.js

@@ -0,0 +1,108 @@
+/**
+ * Bridge to the Ansatz geometric constraint solver — the `ansatz-wasm` npm
+ * dependency (a wasm-bindgen build: no Rust toolchain, no native binary,
+ * platform independent, synchronous once loaded).
+ *
+ * Resolution for the wasm package directory, first hit wins:
+ *   1. an explicit `wasmDir` option
+ *   2. `DSH_ANSATZ_WASM` (any built pkg-node / package directory)
+ *   3. the `ansatz-wasm` npm dependency in node_modules
+ *   4. a sibling Ansatz checkout's wasm-pack output (solver development)
+ *   5. Node's own resolution (hoisted/nested installs)
+ *
+ * The solver answers through a JSON envelope
+ * `{ok:true,result} | {ok:false,error:{kind,message}}`. A tool-layer error
+ * (e.g. `unsupported_constraint`) is thrown as an Error carrying the solver's
+ * own message, so the LLM sees its "never just says failed" diagnostics
+ * verbatim.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const require_ = createRequire(import.meta.url);
+/** Repo root, derived from this module's URL (__dirname is absent in ESM). */
+function repoRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+}
+/** A directory holding the built wasm package (ansatz_wasm.js + _bg.wasm). */
+function isWasmDir(dir) {
+    if (!dir)
+        return false;
+    return fs.existsSync(path.join(dir, 'ansatz_wasm.js')) && fs.existsSync(path.join(dir, 'ansatz_wasm_bg.wasm'));
+}
+/**
+ * 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 function resolveAnsatzWasmDir(explicit) {
+    const root = repoRoot();
+    const candidates = [
+        explicit,
+        process.env.DSH_ANSATZ_WASM,
+        // The declared npm dependency — the primary, version-respecting path.
+        path.join(root, 'node_modules', 'ansatz-wasm'),
+        // Solver development: a sibling checkout's wasm-pack output.
+        path.join(root, '..', 'Ansatz', 'crates', 'ansatz-wasm', 'pkg-node'),
+    ];
+    for (const dir of candidates) {
+        if (dir !== undefined && isWasmDir(dir))
+            return dir;
+    }
+    // Fall back to Node's own resolution (hoisted/nested installs).
+    try {
+        return path.dirname(require_.resolve('ansatz-wasm/package.json'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether the solver is available (diagnostics/tests). */
+export function ansatzAvailable() {
+    return resolveAnsatzWasmDir() !== null;
+}
+let cachedWasm = null;
+function loadWasm(dir) {
+    if (cachedWasm !== null && cachedWasm.dir === dir)
+        return cachedWasm.module;
+    // The wasm-pack nodejs target is CJS and reads its .wasm sibling from
+    // __dirname, so it must be required (not imported) with the dir intact.
+    const module = require_(path.join(dir, 'ansatz_wasm.js'));
+    cachedWasm = { dir, module };
+    return module;
+}
+/** Unwrap the envelope: report on ok, Error carrying the solver text otherwise. */
+function unwrapEnvelope(envelopeJson) {
+    let envelope;
+    try {
+        envelope = JSON.parse(envelopeJson);
+    }
+    catch {
+        throw new Error(`ansatz returned a non-JSON envelope: ${envelopeJson.slice(0, 200)}`);
+    }
+    if (envelope.ok === true && envelope.result !== undefined)
+        return envelope.result;
+    const kind = envelope.error?.kind ?? 'solver_error';
+    const message = envelope.error?.message ?? 'the solver returned an unspecified error';
+    throw new Error(`ansatz ${kind}: ${message}`);
+}
+/** Solve one model with the wasm solver. */
+export async function solveModel(model, options = {}) {
+    const wasmDir = options.wasmDir ?? resolveAnsatzWasmDir();
+    if (wasmDir === null) {
+        throw new Error('the Ansatz solver is unavailable — install it (npm install ansatz-wasm) or point DSH_ANSATZ_WASM at a built wasm package');
+    }
+    return unwrapEnvelope(loadWasm(wasmDir).solveJson(JSON.stringify(model)));
+}
+/** Solver version string, or null when the solver is unavailable. */
+export function ansatzVersion(options = {}) {
+    const wasmDir = options.wasmDir ?? resolveAnsatzWasmDir();
+    if (wasmDir === null)
+        return null;
+    try {
+        return loadWasm(wasmDir).version();
+    }
+    catch {
+        return null;
+    }
+}

package/lib/modeling/bin-store.js

@@ -3,7 +3,7 @@
  * route serves straight from memory; a debounced disk mirror keeps restart
  * replay working without paying a file write on every modeling step.
  */
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { packBinaryScene } from './bin-format.js';
 const DISK_MIRROR_DELAY_MS = 1500;
@@ -45,6 +45,20 @@ export class BinarySceneStore {
             return null;
         }
     }
+    /** Existence check without loading the buffer into memory. */
+    async has(viewId) {
+        if (!/^[0-9a-zA-Z_-]{1,64}$/.test(viewId))
+            return false;
+        if (this.memory.has(viewId))
+            return true;
+        try {
+            await access(path.join(this.directory, `${viewId}.bin`));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /** Debounced disk mirror: one write after modeling quiesces, not per step. */
     scheduleDiskMirror(viewId, buffer) {
         const existing = this.diskTimers.get(viewId);

package/lib/modeling/constraints.js

@@ -0,0 +1,85 @@
+// ── Euler degrees ↔ axis-angle radians (via quaternion, XYZ order) ───────────
+const DEG = Math.PI / 180;
+function eulerToQuaternion(rx, ry, rz) {
+    const cx = Math.cos((rx * DEG) / 2), sx = Math.sin((rx * DEG) / 2);
+    const cy = Math.cos((ry * DEG) / 2), sy = Math.sin((ry * DEG) / 2);
+    const cz = Math.cos((rz * DEG) / 2), sz = Math.sin((rz * DEG) / 2);
+    // Rx·Ry·Rz composition — the same convention as cad_transform / assembly.ts
+    // (coefficient signs matrix-verified; see the round-trip tests).
+    return [
+        sx * cy * cz + cx * sy * sz,
+        cx * sy * cz - sx * cy * sz,
+        cx * cy * sz + sx * sy * cz,
+        cx * cy * cz - sx * sy * sz,
+    ];
+}
+function quaternionToEuler(qw, qx, qy, qz) {
+    // Exact inverse of eulerToQuaternion, extracted from the Rx·Ry·Rz rotation
+    // matrix written in quaternion terms: ry = asin(m02), rx = atan2(−m12, m22),
+    // rz = atan2(−m01, m00). ry is gimbal-limited to ±90°; rx/rz span ±180°.
+    const rx = Math.atan2(2 * (qw * qx - qy * qz), 1 - 2 * (qx * qx + qy * qy)) / DEG;
+    const s2 = Math.min(1, Math.max(-1, 2 * (qw * qy + qx * qz)));
+    const ry = Math.asin(s2) / DEG;
+    const rz = Math.atan2(2 * (qw * qz - qx * qy), 1 - 2 * (qy * qy + qz * qz)) / DEG;
+    return [rx, ry, rz];
+}
+/** Instance placement → solver rigid3 pose. */
+export function instanceToRigid3(instance) {
+    const [rx, ry, rz] = instance.rotate;
+    const [qx, qy, qz, qw] = eulerToQuaternion(rx, ry, rz);
+    const angle = 2 * Math.acos(Math.min(1, Math.max(-1, qw)));
+    let vector = [0, 0, 0];
+    if (angle > 1e-9) {
+        const s = Math.sin(angle / 2);
+        vector = [(qx / s) * angle, (qy / s) * angle, (qz / s) * angle];
+    }
+    return {
+        translation: { x: instance.translate[0], y: instance.translate[1], z: instance.translate[2] },
+        rotation: { vector },
+    };
+}
+/** Solver rigid3 pose → instance placement (translate tuple + Euler degrees). */
+export function rigid3ToInstance(pose) {
+    const [ax, ay, az] = pose.rotation.vector;
+    const angle = Math.hypot(ax, ay, az);
+    let qx = 0, qy = 0, qz = 0, qw = 1;
+    if (angle > 1e-12) {
+        const h = angle / 2;
+        const s = Math.sin(h) / angle;
+        qx = ax * s;
+        qy = ay * s;
+        qz = az * s;
+        qw = Math.cos(h);
+    }
+    const [rx, ry, rz] = quaternionToEuler(qw, qx, qy, qz);
+    return {
+        translate: [pose.translation.x, pose.translation.y, pose.translation.z],
+        rotate: [rx, ry, rz],
+    };
+}
+/** Build the solver-input model: instance-bound entities get live rigid3 poses. */
+export function buildSolverModel(model, instances) {
+    const byInstance = new Map(instances.map((instance) => [instance.instanceId, instance]));
+    const entities = model.entities.map((entity) => {
+        if (entity.instance !== undefined) {
+            const live = byInstance.get(entity.instance);
+            if (live === undefined)
+                throw new Error(`constraint entity ${entity.id} references unknown assembly instance: ${entity.instance}`);
+            return { id: entity.id, geometry: { type: 'rigid3', pose: instanceToRigid3(live) } };
+        }
+        if (entity.geometry === undefined)
+            throw new Error(`constraint entity ${entity.id} has neither an instance binding nor literal geometry`);
+        return { id: entity.id, geometry: entity.geometry };
+    });
+    return { entities, constraints: model.constraints };
+}
+/** Extract solved rigid3 poses keyed by entity id (absent for 2D geometry). */
+export function solvedRigid3s(reportEntities) {
+    const out = new Map();
+    for (const entity of reportEntities) {
+        if (entity.geometry?.type === 'rigid3' && entity.geometry.pose !== undefined) {
+            out.set(entity.id, entity.geometry.pose);
+        }
+    }
+    return out;
+}

package/lib/modeling/document.js

@@ -1,5 +1,5 @@
 /**
- * Modeling document: an operation log (JSON) per workspace that both persists
+ * Modeling document: an operation log (JSON) that both persists
  * across restarts and is the unit of replay — restart recovery re-applies the
  * log to a fresh worker, which is what makes the worker's in-memory shapes
  * disposable.
@@ -9,15 +9,27 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 export class ModelDocument {
     root;
-    doc = { docId: randomUUID(), version: 0, ops: [], bodyNames: {} };
-    constructor(root) {
+    doc;
+    /**
+     * @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, docId) {
         this.root = root;
+        this.legacy = docId === undefined;
+        this.doc = { docId: docId ?? randomUUID(), version: 0, ops: [], bodyNames: {} };
     }
-    get directory() {
+    /** True when this instance owns the legacy single-document path. */
+    legacy;
+    get base() {
         return path.join(this.root, '.dsh-cad');
     }
+    get directory() {
+        return this.legacy ? this.base : path.join(this.base, 'docs');
+    }
     get file() {
-        return path.join(this.directory, 'model.json');
+        return this.legacy ? path.join(this.base, 'model.json') : path.join(this.base, 'docs', `${this.doc.docId}.json`);
     }
     /** Load the persisted document if one exists. */
     async restore() {
@@ -46,6 +58,11 @@ export class ModelDocument {
         await mkdir(this.directory, { recursive: true });
         await writeFile(this.file, JSON.stringify(this.doc));
     }
+    /** Persist the current state without appending an op (registry creation). */
+    async save() {
+        await mkdir(this.directory, { recursive: true });
+        await writeFile(this.file, JSON.stringify(this.doc));
+    }
     /** Clear the document (cad_new / tests). */
     async clear() {
         this.doc = { docId: randomUUID(), version: 0, ops: [], bodyNames: {} };