dsh-cad 0.2.0

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

@@ -0,0 +1,37 @@
+/**
+ * dsh-cad part document (`.dcprt`) — the standalone, shareable counterpart of
+ * the workspace modeling document: a replayable feature history plus a body
+ * manifest. Replaying `features` through the OCCT modeling worker reproduces
+ * every body exactly, which keeps the file itself geometry-free.
+ *
+ * Format definition only — runtime persistence/exchange (cad_export filters,
+ * loaders) lands together with the assembly and drawing pipelines.
+ */
+import type { ModelOp } from '../modeling/client.js';
+import type { ModelDoc } from '../modeling/document.js';
+export declare const DC_PRT_FORMAT: "dcprt";
+export declare const DC_PRT_EXTENSION = ".dcprt";
+export interface DcPrtHeader {
+    format: typeof DC_PRT_FORMAT;
+    version: 1;
+    units: 'mm';
+    upAxis: 'Z';
+}
+export interface DcPrtBody {
+    bodyId: string;
+    name?: string;
+}
+export interface DcPrtDocument {
+    header: DcPrtHeader;
+    /** Document id from the originating workspace; doubles as the scene viewId. */
+    docId: string;
+    /** Document version at export time (monotonic op counter). */
+    version?: number;
+    /** Feature history — replayable by the OCCT modeling worker, in order. */
+    features: ModelOp[];
+    bodies: DcPrtBody[];
+    createdAt?: string;
+}
+/** Serialize a live workspace modeling document into the shareable .dcprt form. */
+export declare function toDcPrtDocument(doc: ModelDoc): DcPrtDocument;
+export declare function isDcPrtDocument(value: unknown): value is DcPrtDocument;

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

@@ -0,0 +1,7 @@
+/**
+ * Native document formats ("feature scripts"): part, assembly and engineering
+ * drawing. See each module for its format contract.
+ */
+export * from './dc_prt.js';
+export * from './dc_asm.js';
+export * from './dc_engineering.js';

package/lib/types/image/profile.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Image → 2D profile extraction: Otsu binarization, connected components,
+ * Moore boundary tracing, Douglas-Peucker simplification. Coordinates flip
+ * to CAD orientation (y up, mm via `scale`, default 1 px = 1 mm).
+ */
+import type { GrayImage } from '../convert/png.js';
+export interface ExtractOptions {
+    /** Manual binarization threshold (0–255); omit for Otsu. */
+    threshold?: number;
+    /** Trace light-on-dark shapes instead of dark-on-light. */
+    invert?: boolean;
+    /** Simplification tolerance in pixels (default 1.5). */
+    tolerance?: number;
+    /** Pixels per mm (default 1). */
+    scale?: number;
+    /** Ignore components smaller than this pixel area (default 24). */
+    minArea?: number;
+}
+export interface ExtractedProfile {
+    /** Flat [x0,y0, x1,y1, …] closed loop, mm, y-up. */
+    points: number[];
+    /** Pixel area of the source component (rough size ranking). */
+    area: number;
+}
+/** Otsu's threshold for a luma image. */
+export declare function otsuThreshold(gray: Uint8Array): number;
+/** Extract simplified outer contours from a luma image, largest first. */
+export declare function extractProfiles(image: GrayImage, options?: ExtractOptions): ExtractedProfile[];

package/lib/types/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * dsh-cad host plugin: registers the `cad_view` / `cad_info` tools and the
+ * same-origin scene route on the Web composition's shared HTTP server.
+ *
+ * The HTTP server is an optional backend: fibers may activate before the web
+ * composition defines it (and headless never does), so the route registers
+ * lazily at first `cad_view` execution — the platform's use-time-resolution
+ * idiom rather than a hard inject.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "dsh-cad";
+/** Hard dependencies: the tool registry. */
+export declare const inject: string[];
+export interface Config {
+    /** Directory the scene spill store uses; defaults to the workspace root. */
+    root?: string;
+}
+export declare function apply(ctx: Context, config?: Config): void;

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

@@ -0,0 +1,17 @@
+/**
+ * Assembly composition (main thread): instances reference body meshes by id
+ * and place them with translate + XYZ-Euler rotate (degrees, the same
+ * "translate → rotate" convention as cad_transform / the worker's
+ * BRepBuilderAPI_Transform path: p' = T + Rx·(Ry·(Rz·p))). Composition is
+ * pure typed-array math on the already-tessellated body meshes — no worker
+ * round-trip, no re-tessellation.
+ */
+import type { BinMeshData } from './bin-format.js';
+import type { AssemblyInstance } from './client.js';
+/**
+ * Compose the assembly scene: one transformed mesh copy per instance.
+ * Instances referencing bodies missing from `bodies` (consumed by a later
+ * boolean) are skipped — the worker's live list already filters them, this is
+ * the replay-side double guard. Duplicate names get a ·N suffix.
+ */
+export declare function composeAssemblyMeshes(bodies: Map<string, BinMeshData>, instances: AssemblyInstance[]): BinMeshData[];

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

@@ -0,0 +1,42 @@
+/**
+ * Binary scene format: the direct worker→three.js transport. One packed
+ * buffer (JSON header + raw f32/u32 payloads) that the browser decodes with
+ * typed-array views — no base64, no JSON number arrays, no intermediate file
+ * unless the debounced disk mirror or an explicit cad_export happens.
+ *
+ * Layout (little-endian):
+ *   [4B magic "DCB1"][4B headerByteLength][header JSON utf8][payload bytes]
+ * Header: { meshes: [{ name, color?, vertexCount, triangleCount,
+ *            posOffset, posBytes, nrmOffset?, nrmBytes, idxOffset, idxBytes }],
+ *           bounds: { min: [x,y,z], max: [x,y,z] }, units }
+ * Offsets/lengths are byte counts relative to the payload start.
+ */
+export interface BinMeshDesc {
+    name: string;
+    color?: number;
+    vertexCount: number;
+    triangleCount: number;
+    posOffset: number;
+    posBytes: number;
+    nrmOffset?: number;
+    nrmBytes?: number;
+    idxOffset: number;
+    idxBytes: number;
+}
+export interface BinHeader {
+    meshes: BinMeshDesc[];
+    bounds: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    units: string;
+}
+export interface BinMeshData {
+    name: string;
+    color?: number;
+    positions: Float32Array;
+    normals?: Float32Array;
+    indices: Uint32Array;
+}
+/** Pack meshes into the binary transport buffer. */
+export declare function packBinaryScene(meshes: BinMeshData[]): Buffer;

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

@@ -0,0 +1,20 @@
+import type { BinMeshData } from './bin-format.js';
+interface Entry {
+    buffer: Buffer;
+    version: number;
+    etag: string;
+}
+export declare class BinarySceneStore {
+    private readonly root;
+    private readonly memory;
+    private readonly diskTimers;
+    constructor(root: string);
+    private get directory();
+    /** Publish a new version under a stable viewId; returns the version. */
+    publish(viewId: string, meshes: BinMeshData[]): Promise<number>;
+    /** Fetch for serving: memory first, disk mirror as the restart fallback. */
+    get(viewId: string): Promise<Entry | null>;
+    /** Debounced disk mirror: one write after modeling quiesces, not per step. */
+    private scheduleDiskMirror;
+}
+export {};

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

@@ -0,0 +1,125 @@
+export interface WorkerMesh {
+    name: string;
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    vertexCount: number;
+    triangleCount: number;
+}
+/** One placed reference of a body inside the assembly. */
+export interface AssemblyInstance {
+    instanceId: string;
+    bodyId: string;
+    name: string;
+    translate: [number, number, number];
+    rotate: [number, number, number];
+}
+/** One projected hidden-line drawing view (flat [x,y, x,y, …] polylines, mm). */
+export interface DrawingView {
+    name: string;
+    visible: number[][];
+    hidden: number[][];
+}
+export interface OpResult {
+    bodyId?: string;
+    name?: string;
+    removed?: string[];
+    edges?: number;
+    mesh?: WorkerMesh;
+    meshes?: Array<WorkerMesh & {
+        bodyId: string;
+    }>;
+    bytes?: ArrayBuffer;
+    volume?: number;
+    deleted?: string;
+    cleared?: boolean;
+    views?: DrawingView[];
+    instanceId?: string;
+    instances?: AssemblyInstance[];
+}
+export interface DrawingViewSpec {
+    name: string;
+    dir: [number, number, number];
+    xDir: [number, number, number];
+}
+export type ModelOp = {
+    kind: 'create_prim';
+    bodyId: string;
+    prim: string;
+    params?: Record<string, unknown>;
+    name?: string;
+} | {
+    kind: 'extrude_profile';
+    bodyId: string;
+    points: number[];
+    height?: number;
+    base?: number;
+    name?: string;
+} | {
+    kind: 'boolean';
+    op: 'fuse' | 'cut' | 'common';
+    target: string;
+    tools: string[];
+} | {
+    kind: 'fillet';
+    target: string;
+    radius: number;
+} | {
+    kind: 'transform';
+    target: string;
+    translate?: [number, number, number];
+    rotate?: [number, number, number];
+    mirror?: [number, number, number];
+} | {
+    kind: 'tessellate_all';
+} | {
+    kind: 'export';
+    target: string;
+    format: 'step' | 'stl';
+} | {
+    kind: 'volume';
+    target: string;
+} | {
+    kind: 'delete';
+    target: string;
+} | {
+    kind: 'reset';
+} | {
+    kind: 'drawing';
+    target: string;
+    views: DrawingViewSpec[];
+    sceneViewId?: string;
+    name?: string;
+    paper?: 'A4' | 'A3';
+} | {
+    kind: 'assembly_insert';
+    instanceId: string;
+    bodyId: string;
+    name?: string;
+    translate?: [number, number, number];
+    rotate?: [number, number, number];
+} | {
+    kind: 'assembly_transform';
+    instanceId: string;
+    translate?: [number, number, number];
+    rotate?: [number, number, number];
+} | {
+    kind: 'assembly_remove';
+    instanceId: string;
+} | {
+    kind: 'export_assembly';
+    format: 'step' | 'stl';
+};
+export interface ModelClient {
+    /** Run one modeling operation on this client's worker. */
+    run(op: ModelOp, timeoutMs?: number): Promise<OpResult>;
+    /** Terminate the worker and fail any in-flight jobs. */
+    dispose(): void;
+}
+export declare function createModelClient(): ModelClient;
+/** Run one modeling operation on the shared session worker. */
+export declare function runModelOp(op: ModelOp, timeoutMs?: number): Promise<OpResult>;
+/** Current reset epoch of the shared worker (see above). */
+export declare function workerResetEpoch(): number;
+/** Test/Dev helper: hard worker file path (used by the vitest suite). */
+export declare function workerEntryPath(): string;

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

@@ -0,0 +1,26 @@
+import type { ModelOp } from './client.js';
+export interface ModelDoc {
+    /** Stable document id; doubles as the viewer scene viewId. */
+    docId: string;
+    /** Monotonic operation counter; the viewer uses it as a cache-busting version. */
+    version: number;
+    ops: ModelOp[];
+    /** Body display names, kept in the manifest for cad_list without a worker round-trip. */
+    bodyNames: Record<string, string>;
+}
+export declare class ModelDocument {
+    readonly root: string;
+    doc: ModelDoc;
+    constructor(root: string);
+    private get directory();
+    private get file();
+    /** Load the persisted document if one exists. */
+    restore(): Promise<void>;
+    /** Append an applied operation and persist. */
+    record(op: ModelOp, bodyName: {
+        bodyId: string;
+        name: string;
+    } | null): Promise<void>;
+    /** Clear the document (cad_new / tests). */
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Engineering-drawing sheet assembly (main thread, pure geometry — unit
+ * tested). Takes projected hidden-line views (from the modeling worker's mesh
+ * HLR) and lays them out on a GB-flavoured first-angle sheet: 主视图 front,
+ * 左视图 right of front, 俯视图 below front, 轴测 in the free corner; frame,
+ * title block, overall-dimension annotations, and a uniform standard scale
+ * for the three standard views.
+ *
+ * Output is the plain 2D entity subset the client viewport already renders
+ * (polylines + text, layer-classified), plus SVG/DXF serializations for
+ * cad_export.
+ */
+import type { CadBounds2, CadEntity2D } from '../types.js';
+import type { DrawingView } from './client.js';
+export type PaperSize = 'A4' | 'A3';
+export interface DrawingSheetInput {
+    partName: string;
+    views: DrawingView[];
+    paper?: PaperSize;
+    drawingNo?: string;
+    date?: string;
+}
+export interface DrawingSheet {
+    entities: CadEntity2D[];
+    bounds: CadBounds2;
+    layers: string[];
+    width: number;
+    height: number;
+    /** Standard scale of the three standard views (iso is fit independently). */
+    scale: number;
+    entityCount: number;
+}
+/** Build the full drawing sheet (frame, title block, views, dimensions). */
+export declare function buildDrawingSheet(input: DrawingSheetInput): DrawingSheet;
+/** Serialize the sheet to a standalone SVG (paper mm = user units, Y flipped). */
+export declare function drawingToSvg(sheet: DrawingSheet): string;
+/** Minimal R12 ASCII DXF (LINE + TEXT entities; polylines expand to lines). */
+export declare function drawingToDxf(sheet: DrawingSheet): string;

package/lib/types/routes.d.ts

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { SceneStore } from './store.js';
+import type { BinarySceneStore } from './modeling/bin-store.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";
+/** 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];
+/** Register the scene route on the shared HTTP server. Returns a disposer. */
+export declare function registerSceneRoute(server: {
+    register: (route: SceneRoute) => () => void;
+}, store: SceneStore): () => void;
+interface SceneRoute {
+    kind: 'prefix' | 'exact';
+    path: string;
+    handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+}
+/** Register the binary scene route. Returns a disposer. */
+export declare function registerBinRoute(server: {
+    register: (route: SceneRoute) => () => void;
+}, store: BinarySceneStore): () => void;
+/** Register the demo-scene route: GET /dsh-cad/demo-scene?part=<bracket|flange|shaft>. */
+export declare function registerDemoRoute(server: {
+    register: (route: SceneRoute) => () => void;
+}): () => void;
+export type { SceneRoute };

package/lib/types/store.d.ts

@@ -0,0 +1,18 @@
+import type { CadScene } from './types.js';
+export declare class SceneStore {
+    private readonly root;
+    private readonly memory;
+    constructor(root: string);
+    private get directory();
+    /** Persist a scene and return its viewId. */
+    put(scene: CadScene): Promise<string>;
+    /** Persist a scene under a stable viewId (overwrites; used by the modeling
+     *  document so every operation refreshes the same viewer card). */
+    putAt(viewId: string, scene: CadScene): Promise<void>;
+    /** Fetch a scene by viewId, restoring from disk when the memory copy aged out. */
+    get(viewId: string): Promise<CadScene | null>;
+    /** Best-effort removal (unused for now; kept for completeness of the API). */
+    delete(viewId: string): Promise<void>;
+    /** ETag for a scene payload (cache helper for the route handler). */
+    etag(scene: CadScene): string;
+}

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

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { BinarySceneStore } from '../modeling/bin-store.js';
+import { normalizeOps } from '../cad_connector/executor.js';
+export declare const normalizeFreeCadSteps: typeof normalizeOps;
+export interface FreeCadToolDeps {
+    store: BinarySceneStore;
+    workspaceRoot: string;
+    ensureSceneRoute: () => string | null;
+}
+export declare function createFreeCadTool(deps: FreeCadToolDeps): ToolDefinition;

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

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { BinarySceneStore } from '../modeling/bin-store.js';
+export interface FusionToolDeps {
+    store: BinarySceneStore;
+    workspaceRoot: string;
+    ensureSceneRoute: () => string | null;
+}
+export declare function createFusionTool(deps: FusionToolDeps): ToolDefinition;

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

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { SceneStore } from '../store.js';
+export interface CadImageToolDeps {
+    store: SceneStore;
+    workspaceRoot: string;
+    ensureSceneRoute: () => string | null;
+}
+export declare function createCadImageTool(deps: CadImageToolDeps): ToolDefinition;

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

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+export interface CadInfoToolDeps {
+    workspaceRoot: string;
+}
+/** Build the cad_info tool definition. */
+export declare function createCadInfoTool(deps: CadInfoToolDeps): ToolDefinition;

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

@@ -0,0 +1,13 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { BinarySceneStore } from '../modeling/bin-store.js';
+import type { SceneStore } from '../store.js';
+export interface ModelToolDeps {
+    store: BinarySceneStore;
+    /** JSON scene store (drawing sheets). */
+    sceneStore: SceneStore;
+    workspaceRoot: string;
+    ensureSceneRoute: () => string | null;
+}
+/** Build the whole tool family over one document + worker + scene store. */
+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"];

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

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { SceneStore } from '../store.js';
+export interface CadViewToolDeps {
+    store: SceneStore;
+    workspaceRoot: string;
+    /** Idempotent lazy route registration; returns the scene URL base or null. */
+    ensureSceneRoute: () => string | null;
+}
+/** Build the cad_view tool definition over the scene store. */
+export declare function createCadViewTool(deps: CadViewToolDeps): ToolDefinition;

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

@@ -0,0 +1,4 @@
+/** Resolve a model-supplied path against the workspace root. */
+export declare function resolveWorkspacePath(input: string, workspaceRoot: string): string;
+/** Load a CAD file buffer, failing with model-friendly errors. */
+export declare function loadCadFile(resolvedPath: string): Promise<Buffer>;

package/lib/types/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Shared CAD scene model: the normalized JSON the host produces from a CAD
+ * file and the browser card renders. Binary payloads (positions, normals,
+ * indices) are base64-encoded typed arrays to keep large meshes transportable.
+ */
+/** 3D axis-aligned bounds. */
+export interface CadBounds3 {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** 2D axis-aligned bounds. */
+export interface CadBounds2 {
+    min: {
+        x: number;
+        y: number;
+    };
+    max: {
+        x: number;
+        y: number;
+    };
+}
+/** One tessellated solid, ready for WebGL. */
+export interface CadMesh {
+    /** Human-readable part name (STEP product name, OBJ group, file stem, …). */
+    name: string;
+    /** base64 Float32Array of xyz vertex triplets. */
+    positions: string;
+    /** base64 Float32Array of xyz normal triplets, parallel to positions. */
+    normals?: string;
+    /** base64 Uint32Array of triangle vertex indices. */
+    indices: string;
+    /** Vertex count (one entry per xyz triplet). */
+    vertexCount: number;
+    /** Triangle count. */
+    triangleCount: number;
+    /** Optional 0xRRGGBB part color. */
+    color?: number;
+}
+/** A tessellated 3D scene. */
+export interface CadScene3D {
+    kind: '3d';
+    /** Source format: stl | obj | step | iges | brep. */
+    format: string;
+    meshes: CadMesh[];
+    bounds: CadBounds3;
+    /** Source units (STEP carries them; mesh formats are unitless → assumed mm). */
+    units: 'mm' | 'm' | 'in' | 'unitless';
+}
+/** 2D drawing entity, the lossless subset the 2D viewport renders. */
+export type CadEntity2D = {
+    type: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    layer?: string;
+    color?: number;
+} | {
+    type: 'circle';
+    cx: number;
+    cy: number;
+    r: number;
+    layer?: string;
+    color?: number;
+} | {
+    type: 'arc';
+    cx: number;
+    cy: number;
+    r: number;
+    startAngle: number;
+    endAngle: number;
+    layer?: string;
+    color?: number;
+} | {
+    type: 'polyline';
+    points: number[];
+    closed: boolean;
+    layer?: string;
+    color?: number;
+} | {
+    type: 'text';
+    x: number;
+    y: number;
+    text: string;
+    height: number;
+    rotation?: number;
+    layer?: string;
+    color?: number;
+};
+/** A 2D drawing. */
+export interface CadDrawing2D {
+    kind: '2d';
+    /** Source format: dxf | svg. */
+    format: string;
+    entities: CadEntity2D[];
+    bounds: CadBounds2;
+    layers: string[];
+    /** Raw SVG source when format === 'svg' (rendered verbatim in a sandboxed img). */
+    svgText?: string;
+}
+/** The union a `cad_view` scene payload carries. */
+export type CadScene = CadScene3D | CadDrawing2D;
+/** Presentation metadata projected through the tool's `output.presentationMeta`. */
+export interface CadViewMeta {
+    viewId: string;
+    kind: '3d' | '2d';
+    format: string;
+    file: string;
+    /** Same-origin URL serving the scene JSON (absent without a web composition). */
+    sceneUrl?: string;
+    title: string;
+    stats: {
+        meshes?: number;
+        triangles?: number;
+        entities?: number;
+        layers?: number;
+        boundsMin?: [number, number, number] | [number, number];
+        boundsMax?: [number, number, number] | [number, number];
+        units?: string;
+    };
+}
+/** Geometric summary shared by cad_view and cad_info. */
+export interface CadStats {
+    format: string;
+    meshes?: number;
+    triangles?: number;
+    entities?: number;
+    layers?: string[];
+    boundsMin?: [number, number, number] | [number, number];
+    boundsMax?: [number, number, number] | [number, number];
+    units?: string;
+}
+/** Flatten a converted scene into the model/card-facing summary. */
+export declare function sceneStats(scene: CadScene): CadStats;

package/lib/types.js

@@ -0,0 +1,25 @@
+/**
+ * Shared CAD scene model: the normalized JSON the host produces from a CAD
+ * file and the browser card renders. Binary payloads (positions, normals,
+ * indices) are base64-encoded typed arrays to keep large meshes transportable.
+ */
+/** Flatten a converted scene into the model/card-facing summary. */
+export function sceneStats(scene) {
+    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],
+            units: scene.units,
+        };
+    }
+    return {
+        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],
+    };
+}