dsh-cad 0.2.0

package/lib/tools/cad-view.js

@@ -0,0 +1,112 @@
+/**
+ * The `cad_view` tool: load a CAD file, convert it to a renderable scene, and
+ * project presentation metadata the Web UI card renders as a 3D/2D viewer.
+ */
+import { basename } from 'node:path';
+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';
+function formatBounds(stats) {
+    if (stats.boundsMin === undefined || stats.boundsMax === undefined)
+        return '';
+    const min = stats.boundsMin;
+    const max = stats.boundsMax;
+    return `bounds [${min.map((v) => v.toFixed(2)).join(', ')}] → [${max.map((v) => v.toFixed(2)).join(', ')}]`;
+}
+/** Build the cad_view tool definition over the scene store. */
+export function createCadViewTool(deps) {
+    return defineTool({
+        name: 'cad_view',
+        description: 'Open a CAD file in the interactive viewer embedded in the chat UI. ' +
+            '3D: STL, OBJ, STEP (.step/.stp), IGES (.iges/.igs), BREP, DCPRT (.dcprt native part document). 2D: DXF, SVG. ' +
+            'The card shows the geometry (orbit/zoom for 3D, pan/zoom for 2D) plus a geometry summary. ' +
+            'Use it whenever the user wants to see, inspect, or verify CAD geometry; the returned summary carries bounds and counts.',
+        parameters: {
+            path: {
+                type: 'string',
+                required: true,
+                description: 'Path to the CAD file, absolute or relative to the workspace root.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    viewId: { type: 'string', required: true, description: 'Viewer scene id.' },
+                    kind: { type: 'string', enum: ['3d', '2d'], required: true, description: 'Viewer kind.' },
+                    format: { type: 'string', required: true, description: 'Detected source format.' },
+                    file: { type: 'string', required: true, description: 'Resolved file path.' },
+                    sceneUrl: { type: 'string', description: 'Same-origin JSON scene URL (web compositions only).' },
+                    triangles: { type: 'number', description: 'Total triangle count (3D).' },
+                    meshes: { type: 'number', description: 'Part count (3D).' },
+                    entities: { type: 'number', description: 'Drawing entity count (2D).' },
+                },
+            },
+            render: (_args, value) => {
+                const lines = [`CAD viewer: ${value.file} (${value.format.toUpperCase()}, ${value.kind.toUpperCase()})`];
+                if (value.kind === '3d') {
+                    lines.push(`${value.meshes ?? 0} part(s), ${value.triangles ?? 0} triangles`);
+                }
+                else {
+                    lines.push(`${value.entities ?? 0} entities`);
+                }
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+            presentationMeta: (_args, value) => ({
+                viewId: value.viewId,
+                kind: value.kind,
+                format: value.format,
+                file: basename(value.file),
+                ...(value.sceneUrl === undefined ? {} : { sceneUrl: value.sceneUrl }),
+                title: `${basename(value.file)} · ${value.format.toUpperCase()}`,
+                stats: {
+                    ...(value.meshes === undefined ? {} : { meshes: value.meshes }),
+                    ...(value.triangles === undefined ? {} : { triangles: value.triangles }),
+                    ...(value.entities === undefined ? {} : { entities: value.entities }),
+                },
+            }),
+        },
+        timeoutMs: 180_000,
+        isConcurrencySafe: () => true,
+        async execute(args) {
+            const resolved = resolveWorkspacePath(args.path, deps.workspaceRoot);
+            const name = basename(resolved);
+            const format = detectFormat(name);
+            if (format === null) {
+                throw new Error(`unsupported CAD format: ${name} — supported extensions are .stl .obj .step .stp .iges .igs .brep .dcprt .dxf .svg`);
+            }
+            const buffer = await loadCadFile(resolved);
+            const scene = await convert(buffer, format, name);
+            const stats = sceneStats(scene);
+            const viewId = await deps.store.put(scene);
+            const kind = is3DFormat(format) ? '3d' : '2d';
+            const sceneUrlBase = deps.ensureSceneRoute();
+            // Optional fields spread conditionally: an explicit undefined value
+            // would fail the registry's lossless-JSON output validation.
+            return {
+                viewId,
+                kind,
+                format,
+                file: resolved,
+                ...(sceneUrlBase === null ? {} : { sceneUrl: `${sceneUrlBase}/${viewId}` }),
+                ...(stats.triangles === undefined ? {} : { triangles: stats.triangles }),
+                ...(stats.meshes === undefined ? {} : { meshes: stats.meshes }),
+                ...(stats.entities === undefined ? {} : { entities: stats.entities }),
+            };
+        },
+        presentCall: (args) => ({
+            card: 'generic',
+            title: `CAD view ${args.path}`,
+            kind: 'other',
+        }),
+        presentResult: (args, result) => ({
+            card: 'generic',
+            title: result.isError
+                ? `CAD view ${args.path} failed`
+                : `CAD viewer: ${args.path}`,
+        }),
+    });
+}

package/lib/tools/util.js

@@ -0,0 +1,25 @@
+/**
+ * Shared tool helpers: path resolution and file loading. CAD payloads are
+ * binary, so reads go through node:fs (the platform fs service exposes only
+ * UTF-8 text reads); relative paths resolve against the workspace root like
+ * every other model-facing path.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+/** Resolve a model-supplied path against the workspace root. */
+export function resolveWorkspacePath(input, workspaceRoot) {
+    return path.isAbsolute(input) ? input : path.join(workspaceRoot, input);
+}
+/** Load a CAD file buffer, failing with model-friendly errors. */
+export async function loadCadFile(resolvedPath) {
+    let info;
+    try {
+        info = await stat(resolvedPath);
+    }
+    catch {
+        throw new Error(`CAD file not found: ${resolvedPath}`);
+    }
+    if (!info.isFile())
+        throw new Error(`not a file: ${resolvedPath}`);
+    return readFile(resolvedPath);
+}

package/lib/types/b64.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Base64 codecs for typed arrays. Node (host) encodes; the browser card
+ * decodes. Kept dependency-free on both sides.
+ */
+/** Encode a Float32Array's buffer as base64 (Node, host side). */
+export declare function encodeF32B64(array: Float32Array): string;
+/** Encode a Uint32Array's buffer as base64 (Node, host side). */
+export declare function encodeU32B64(array: Uint32Array): string;

package/lib/types/cad/builtin.d.ts

@@ -0,0 +1,3 @@
+/** The built-in modeling kernel: opencascade.js (WASM) in a worker, rendered with WebGL/three.js. */
+import type { CadConnector } from './types.js';
+export declare const BUILTIN_CONNECTOR: CadConnector;

package/lib/types/cad/freecad.d.ts

@@ -0,0 +1,3 @@
+/** FreeCAD — first external executor planned. */
+import type { CadConnector } from './types.js';
+export declare const FREECAD_CONNECTOR: CadConnector;

package/lib/types/cad/fusion360.d.ts

@@ -0,0 +1,3 @@
+/** Fusion 360 — planned external executor. */
+import type { CadConnector } from './types.js';
+export declare const FUSION360_CONNECTOR: CadConnector;

package/lib/types/cad/gstarcad3d.d.ts

@@ -0,0 +1,3 @@
+/** GstarCAD 3D / 浩辰3D — planned external executor. */
+import type { CadConnector } from './types.js';
+export declare const GSTARCAD3D_CONNECTOR: CadConnector;

package/lib/types/cad/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Connector registry, ordered like the README table: the built-in kernel
+ * first, then external CAD executors by support status.
+ */
+import type { CadConnector } from './types.js';
+export declare const CONNECTORS: readonly CadConnector[];
+export declare function connectorById(id: string): CadConnector | undefined;
+export * from './types.js';

package/lib/types/cad/onshape.d.ts

@@ -0,0 +1,3 @@
+/** Onshape — planned external executor, cloud-native. */
+import type { CadConnector } from './types.js';
+export declare const ONSHAPE_CONNECTOR: CadConnector;

package/lib/types/cad/solidworks.d.ts

@@ -0,0 +1,3 @@
+/** SolidWorks — planned external executor. */
+import type { CadConnector } from './types.js';
+export declare const SOLIDWORKS_CONNECTOR: CadConnector;

package/lib/types/cad/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Connector contracts: how dsh-cad describes the CAD engines it can drive.
+ * The built-in WebGL/OCCT kernel is one entry; external engines (FreeCAD,
+ * SolidWorks, …) are executors reached through the language declared here.
+ */
+export type ConnectorStatus = 'built-in' | 'coming-soon' | 'planned';
+/**
+ * The language/binding a connector speaks. `sdk` marks vendor
+ * secondary-development kits whose surface is not a single language.
+ */
+export type ExecutorLanguage = 'webgl' | 'python' | 'csharp' | 'cpp' | 'javascript' | 'rest' | 'sdk';
+export interface CadConnector {
+    id: string;
+    label: string;
+    vendor: string;
+    /** The external language this engine is driven through. */
+    language: ExecutorLanguage;
+    status: ConnectorStatus;
+    /** Short note on the binding path. */
+    binding?: string;
+}

package/lib/types/cad/zw3d.d.ts

@@ -0,0 +1,3 @@
+/** ZW3D / 中望3D — planned external executor. */
+import type { CadConnector } from './types.js';
+export declare const ZW3D_CONNECTOR: CadConnector;

package/lib/types/cad_connector/builtin-executor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The built-in kernel as a GeometryExecutor: runs a one-shot op program on an
+ * ISOLATED OCCT worker (never the shared modeling-session worker), so
+ * executor-driven runs can't clobber live session state. This is the same
+ * primitive .dcprt replay uses.
+ */
+import type { GeometryExecutor } from './executor.js';
+/** The shared WASM kernel always exists in this build. */
+export declare const BUILTIN_EXECUTOR: GeometryExecutor;

package/lib/types/cad_connector/builtin.d.ts

@@ -0,0 +1,3 @@
+/** The built-in modeling kernel: opencascade.js (WASM) in a worker, rendered with WebGL/three.js. */
+import type { CadConnector } from './types.js';
+export declare const BUILTIN_CONNECTOR: CadConnector;

package/lib/types/cad_connector/executor.d.ts

@@ -0,0 +1,69 @@
+/**
+ * GeometryExecutor — the unified backend access contract.
+ *
+ * The display layer is one WebGL pipeline and never changes; what varies is
+ * HOW geometry is produced. Every backend (the built-in OCCT/WASM kernel,
+ * FreeCAD, Fusion 360, a future SolidWorks bridge…) implements this one
+ * interface over the same op program shape, so swapping executors changes
+ * only the quality of the produced geometry — never the frontend.
+ */
+/** The mesh currency shared by every executor and the binary scene store. */
+export interface ExecutorMesh {
+    bodyId: string;
+    name: string;
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    vertexCount: number;
+    triangleCount: number;
+}
+/** A CAD file loaded as the initial body before the ops run. */
+export interface ExecutorInput {
+    format: 'step' | 'stp' | 'brep' | 'stl';
+    path: string;
+    bodyId?: string;
+}
+export interface ExecutorExport {
+    format: 'step' | 'stp' | 'stl';
+    path: string;
+}
+/** The canonical op program every executor understands. */
+export interface GeometryProgram {
+    ops: Array<Record<string, unknown>>;
+    /** bodyId → display name (from create ops). */
+    names?: Record<string, string>;
+    input?: ExecutorInput;
+    export?: ExecutorExport;
+    /** Keep the result on screen in the engine's own window, when supported. */
+    display?: boolean;
+}
+export interface GeometryResult {
+    meshes: ExecutorMesh[];
+    volumes: Record<string, number>;
+    exported?: string;
+}
+export interface RunOptions {
+    timeoutMs?: number;
+}
+export interface GeometryExecutor {
+    id: string;
+    label: string;
+    /** Whether this executor is usable on the current machine right now. */
+    available(): boolean;
+    /** Human-readable reason when unavailable (install guidance). */
+    unavailableReason?(): string;
+    /** Run one op program; rejects on any executor failure. */
+    run(program: GeometryProgram, options?: RunOptions): Promise<GeometryResult>;
+}
+/**
+ * LLM callers emit op shapes liberally. Normalize the common variants onto
+ * the canonical op shape before validation/execution:
+ *  - {op:"cut", target, tools}              → {kind:"boolean", op:"cut", ...}
+ *  - {op:"create_prim", kind:"box", dx:...} → {kind:"create_prim", prim:"box", params:{dx:...}}
+ *  - {kind:"create_prim", prim, dx:...}     → params folded in
+ */
+export declare function normalizeOps(raw: unknown[]): Array<Record<string, unknown>>;
+/** Op discriminators the canonical program accepts. */
+export declare function isKnownOpKind(kind: unknown): boolean;
+export declare const EXECUTORS: readonly GeometryExecutor[];
+export declare function executorById(id: string): GeometryExecutor | undefined;

package/lib/types/cad_connector/freecad-executor.d.ts

@@ -0,0 +1,55 @@
+import type { GeometryExecutor } from './executor.js';
+/** Mesh shape shared with the WASM worker pipeline. */
+export interface FreeCadMesh {
+    bodyId: string;
+    name: string;
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    vertexCount: number;
+    triangleCount: number;
+}
+export interface FreeCadProgram {
+    ops: Array<Record<string, unknown>>;
+    /** bodyId → display name (from create ops). */
+    names?: Record<string, string>;
+    input?: {
+        format: 'step' | 'stp' | 'brep' | 'stl';
+        path: string;
+        bodyId?: string;
+    };
+    export?: {
+        format: 'step' | 'stp' | 'stl';
+        path: string;
+    };
+    /** Put the final bodies into a FreeCAD document so the GUI shows them. */
+    display?: boolean;
+}
+export interface FreeCadResult {
+    meshes: FreeCadMesh[];
+    volumes: Record<string, number>;
+    exported?: string;
+}
+/**
+ * Locate a FreeCAD console executable: FREECAD_BIN env → PATH candidates →
+ * common install directories. Cached after the first probe. Pass
+ * `{ gui: true }` for the GUI binary (windowed) variant.
+ */
+export declare function findFreeCad(options?: {
+    gui?: boolean;
+}): string | null;
+/** Whether an external FreeCAD executor is usable on this machine. */
+export declare function freecadAvailable(): boolean;
+export interface RunFreeCadOptions {
+    timeoutMs?: number;
+    /** Run in the FreeCAD GUI (detached window that stays open, showing the bodies). */
+    gui?: boolean;
+}
+/**
+ * Run a feature program in an external FreeCAD process and return tessellated
+ * meshes + volumes (+ exported file path). Console mode waits for exit; GUI
+ * mode detaches the windowed process and polls for the result file.
+ */
+export declare function runFreeCadProgram(program: FreeCadProgram, options?: RunFreeCadOptions): Promise<FreeCadResult>;
+/** The GeometryExecutor contract over the FreeCAD console/GUI bridge. */
+export declare const FREECAD_EXECUTOR: GeometryExecutor;

package/lib/types/cad_connector/freecad.d.ts

@@ -0,0 +1,3 @@
+/** FreeCAD — external executor, live via the local console binary. */
+import type { CadConnector } from './types.js';
+export declare const FREECAD_CONNECTOR: CadConnector;

package/lib/types/cad_connector/fusion360-executor.d.ts

@@ -0,0 +1,11 @@
+import type { GeometryExecutor, GeometryProgram, GeometryResult, RunOptions } from './executor.js';
+/** Locate a Fusion 360 application bundle/binary, or null when absent. */
+export declare function findFusion360(): string | null;
+/** Whether the Fusion executor is usable on this machine. */
+export declare function fusion360Available(): boolean;
+/** Idempotently install the resident bridge add-in next to its manifest. */
+export declare function installFusionBridge(): Promise<string>;
+/** Write a job, make sure Fusion is running, poll for the bridge result. */
+export declare function runFusionProgram(program: GeometryProgram, options?: RunOptions): Promise<GeometryResult>;
+/** The GeometryExecutor contract over the Fusion GUI bridge. */
+export declare const FUSION360_EXECUTOR: GeometryExecutor;

package/lib/types/cad_connector/fusion360.d.ts

@@ -0,0 +1,3 @@
+/** Fusion 360 — external executor via the resident-add-in GUI bridge. */
+import type { CadConnector } from './types.js';
+export declare const FUSION360_CONNECTOR: CadConnector;

package/lib/types/cad_connector/gstarcad3d.d.ts

@@ -0,0 +1,3 @@
+/** GstarCAD 3D / 浩辰3D — planned external executor. */
+import type { CadConnector } from './types.js';
+export declare const GSTARCAD3D_CONNECTOR: CadConnector;

package/lib/types/cad_connector/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Connector registry, ordered like the README table: the built-in kernel
+ * first, then external CAD executors by support status.
+ */
+import type { CadConnector } from './types.js';
+export declare const CONNECTORS: readonly CadConnector[];
+export declare function connectorById(id: string): CadConnector | undefined;
+export * from './types.js';

package/lib/types/cad_connector/onshape.d.ts

@@ -0,0 +1,3 @@
+/** Onshape — planned external executor, cloud-native. */
+import type { CadConnector } from './types.js';
+export declare const ONSHAPE_CONNECTOR: CadConnector;

package/lib/types/cad_connector/solidworks.d.ts

@@ -0,0 +1,3 @@
+/** SolidWorks — planned external executor (Windows-only COM/.NET). */
+import type { CadConnector } from './types.js';
+export declare const SOLIDWORKS_CONNECTOR: CadConnector;

package/lib/types/cad_connector/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Connector contracts: how dsh-cad describes the CAD engines it can drive.
+ * The built-in WebGL/OCCT kernel is one entry; external engines (FreeCAD,
+ * SolidWorks, …) are executors reached through the language declared here.
+ */
+export type ConnectorStatus = 'built-in' | 'available' | 'experimental' | 'coming-soon' | 'planned';
+/**
+ * The language/binding a connector speaks. `sdk` marks vendor
+ * secondary-development kits whose surface is not a single language.
+ */
+export type ExecutorLanguage = 'webgl' | 'python' | 'csharp' | 'cpp' | 'javascript' | 'rest' | 'sdk';
+export interface CadConnector {
+    id: string;
+    label: string;
+    vendor: string;
+    /** The external language this engine is driven through. */
+    language: ExecutorLanguage;
+    status: ConnectorStatus;
+    /** Short note on the binding path. */
+    binding?: string;
+}

package/lib/types/cad_connector/zw3d.d.ts

@@ -0,0 +1,3 @@
+/** ZW3D / 中望3D — planned external executor. */
+import type { CadConnector } from './types.js';
+export declare const ZW3D_CONNECTOR: CadConnector;

package/lib/types/convert/dcprt.d.ts

@@ -0,0 +1,14 @@
+/**
+ * .dcprt converter: parse the native part document, replay its feature
+ * history on the OCCT worker, and tessellate the rebuilt bodies into
+ * indexed CadMeshes.
+ *
+ * Replay runs on the SHARED worker (via runModelOp): the opencascade.js WASM
+ * heap is too large for a second concurrent instance. Every replay posts a
+ * `reset`, which bumps the client's reset epoch — the live modeling session
+ * detects the stale epoch and re-replays its own document before the next
+ * modeling op, so out-of-band replays cannot corrupt the session.
+ */
+import type { CadMesh } from '../types.js';
+/** Convert a .dcprt buffer to indexed CadMeshes by replaying its features. */
+export declare function parseDcprt(buffer: Buffer, fallbackName: string, timeoutMs?: number): Promise<CadMesh[]>;

package/lib/types/convert/detect.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CAD format detection by file extension (case-insensitive). Returns null for
+ * formats this plugin does not consume.
+ */
+export type CadFormat = 'stl' | 'obj' | 'step' | 'iges' | 'brep' | 'dxf' | 'svg' | 'dcprt';
+export declare function detectFormat(fileName: string): CadFormat | null;
+export declare function is3DFormat(format: CadFormat): boolean;

package/lib/types/convert/dxf.d.ts

@@ -0,0 +1,3 @@
+import type { CadDrawing2D } from '../types.js';
+/** Convert DXF text into a 2D drawing. */
+export declare function parseDXF(text: string): CadDrawing2D;

package/lib/types/convert/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * File buffer → CadScene: format dispatch, bounds computation, unit handling.
+ */
+import type { CadScene, CadScene3D, CadMesh } from '../types.js';
+import type { CadFormat } from './detect.js';
+/** Scan a set of CadMeshes for their axis-aligned bounds. */
+export declare function computeMeshBounds(meshes: CadMesh[]): CadScene3D['bounds'];
+/** Convert a supported CAD file buffer into a renderable scene. */
+export declare function convert(buffer: Buffer, format: CadFormat, fileName: string): Promise<CadScene>;

package/lib/types/convert/obj.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Minimal OBJ parser (v / vn / f with polygon triangulation, o / g groups).
+ * Ignores materials, curves, and other entities the viewer cannot show.
+ */
+import type { CadMesh } from '../types.js';
+/** Convert OBJ text into CadMeshes (one per non-empty group). */
+export declare function parseOBJ(text: string, fallbackName: string): CadMesh[];

package/lib/types/convert/png.d.ts

@@ -0,0 +1,8 @@
+export interface GrayImage {
+    width: number;
+    height: number;
+    /** Luma per pixel, row-major, 0–255. */
+    gray: Uint8Array;
+}
+/** Decode a PNG buffer to a luma image. */
+export declare function decodePng(buffer: Buffer): GrayImage;

package/lib/types/convert/step.d.ts

@@ -0,0 +1,4 @@
+import type { CadMesh } from '../types.js';
+export type OcctFormat = 'step' | 'iges' | 'brep';
+/** Convert a STEP/IGES/BREP buffer to indexed CadMeshes. */
+export declare function parseOcct(buffer: Buffer, format: OcctFormat, fallbackName: string, timeoutMs?: number): Promise<CadMesh[]>;

package/lib/types/convert/stl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Minimal STL parser (binary and ASCII) producing indexed triangle meshes.
+ * Written by hand so the host side carries no Three.js dependency.
+ */
+import type { CadMesh } from '../types.js';
+/** Convert an STL buffer into one indexed CadMesh. */
+export declare function parseSTL(buffer: Buffer, name: string): CadMesh;

package/lib/types/convert/svg.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SVG → CadDrawing2D. The raw SVG source is carried through and rendered in a
+ * sandboxed <img>; entities/bounds are a best-effort scan of basic shapes for
+ * the stats line.
+ */
+import type { CadDrawing2D } from '../types.js';
+/** Extract the renderable entity subset from an SVG document. */
+export declare function parseSVG(text: string): CadDrawing2D;

package/lib/types/feature_script/dc_asm.d.ts

@@ -0,0 +1,40 @@
+/**
+ * dsh-cad assembly document (`.dcasm`) — instances of parts placed in one
+ * coordinate system. Parts are referenced, never embedded, so an assembly
+ * stays small and part edits propagate on reload.
+ *
+ * Placement mirrors the `cad_transform` op semantics (mm, Z-up, Euler degrees)
+ * so an instance can be materialized by replaying a transform on the
+ * referenced body.
+ */
+export declare const DC_ASM_FORMAT: "dcasm";
+export declare const DC_ASM_EXTENSION = ".dcasm";
+export interface DcAsmHeader {
+    format: typeof DC_ASM_FORMAT;
+    version: 1;
+    units: 'mm';
+    upAxis: 'Z';
+}
+export interface DcAsmPlacement {
+    at: [number, number, number];
+    /** Euler XYZ rotation in degrees, matching `cad_transform`. */
+    rotate?: [number, number, number];
+    mirror?: [number, number, number];
+}
+export type DcAsmSource = {
+    kind: 'body';
+    bodyId: string;
+} | {
+    kind: 'prt';
+    path: string;
+};
+export interface DcAsmInstance {
+    instanceId: string;
+    source: DcAsmSource;
+    placement: DcAsmPlacement;
+}
+export interface DcAsmDocument {
+    header: DcAsmHeader;
+    instances: DcAsmInstance[];
+}
+export declare function isDcAsmDocument(value: unknown): value is DcAsmDocument;

package/lib/types/feature_script/dc_engineering.d.ts

@@ -0,0 +1,55 @@
+/**
+ * dsh-cad engineering drawing document (`.dceng`) — a 2D sheet referencing 3D
+ * models through projected views, plus dimensions. Views are projections of
+ * referenced parts/bodies, so the drawing stays in sync with the geometry.
+ *
+ * Default sheet is A4 landscape (297 × 210 mm), matching the DXF/SVG 2D
+ * pipeline's true-drawing-units convention.
+ */
+export declare const DC_ENG_FORMAT: "dceng";
+export declare const DC_ENG_EXTENSION = ".dceng";
+export declare const DC_ENG_SHEET_A4: DcEngSheet;
+export interface DcEngHeader {
+    format: typeof DC_ENG_FORMAT;
+    version: 1;
+    units: 'mm';
+}
+export interface DcEngSheet {
+    width: number;
+    height: number;
+}
+export type DcEngProjection = 'front' | 'top' | 'right' | 'iso';
+export type DcEngSource = {
+    kind: 'body';
+    bodyId: string;
+} | {
+    kind: 'prt';
+    path: string;
+};
+export interface DcEngView {
+    viewId: string;
+    projection: DcEngProjection;
+    source: DcEngSource;
+    /** Sheet-space placement of the view origin. */
+    at: [number, number];
+    scale: number;
+}
+export type DcEngDimensionKind = 'linear' | 'diameter' | 'radius' | 'angle';
+export interface DcEngDimension {
+    dimensionId: string;
+    kind: DcEngDimensionKind;
+    /** Sheet-space anchor points; the value is derived unless overridden. */
+    from: [number, number];
+    to?: [number, number];
+    /** Explicit override for derived dimensions. */
+    value?: number;
+}
+export interface DcEngDocument {
+    header: DcEngHeader;
+    sheet: DcEngSheet;
+    /** Sheet-wide default scale (1:2 = 0.5); views may override. */
+    scale: number;
+    views: DcEngView[];
+    dimensions: DcEngDimension[];
+}
+export declare function isDcEngDocument(value: unknown): value is DcEngDocument;