archigraph.yaml

archigraph: '0.3'
meta:
  system: DraftDown
  description: "A free, open-source 3D CAD application built with Electron + React + Three.js.\n    Features push/pull\
    \ modeling (dual-mode: extrude 2D faces, move 3D faces), drawing tools\n    (line, rectangle, circle, arc, polygon), axis\
    \ locking, snap system, face splitting,\n    CSG boolean operations via Manifold WASM, and an AI chat assistant.\n    Available\
    \ as a web app at draftdownapp.com and as desktop binaries for\n    macOS (signed/notarized DMG, x64+arm64), Windows (NSIS\
    \ installer, x64), and Linux (AppImage, x64).\n    SKP file import via native skp2obj tool linked against DraftDown 2026 C\
    \ SDK. All computation runs locally."
  environment:
  - desktop
  - web
  tags:
  - cad
  - 3d-modeling
  - electron
  - 3d-cad
  - local-first
  owners:
  - core-team
nodes:
- id: actor.designer
  kind: actor
  layer: product
  name: 3D Designer
  x:
    docs:
      description: 'Primary user — architects, interior designers, makers, hobbyists who create 3D models using intuitive
        push/pull modeling. Expects native-style UX: click to draw faces, push/pull to extrude, orbit to navigate.'
    impl:
      status: implemented
  uuid: g7fVsvXA
- id: actor.plugin_dev
  kind: actor
  layer: product
  name: Plugin Developer
  x:
    docs:
      description: Developer who extends DraftDown with custom tools, importers/exporters, and rendering modes via the plugin
        API.
    impl:
      status: implemented
  uuid: oN4ZxAP3
- id: window.main
  kind: window
  layer: ui
  name: Main Window
  x:
    electron:
      processType: renderer
      windowOptions: '{"width": 1400, "height": 900, "minWidth": 800, "minHeight": 600, "title": "DraftDown", "webPreferences":
        {"nodeIntegration": false, "contextIsolation": true, "preload": "preload.js"}}'
      devTools: true
    ui:
      framework: React
      layout: docked
      resizable: true
    impl:
      language: TypeScript
      framework: React
      complexity: complex
      status: implemented
    docs:
      description: >-
        Main application window containing the 3D viewport, toolbars, panels, and menus. Uses a flexbox-based docking
        layout with resizable panels. The viewport occupies the center, with toolbars on top/left and panels on right. Supports
        dark/light themes. Global keyboard handler in App.tsx: Cmd/Ctrl+G creates component from selection
        (auto-includes face edges), Escape exits component editing before clearing selection.
        Context menu (ContextMenu.tsx): face/edge menus include Make Component, component menu has
        Edit Component and Explode. Actions wired to SceneManager component API.
  uuid: 6jdgpbuQ
- id: window.preferences
  kind: window
  layer: ui
  name: Preferences Window
  x:
    electron:
      processType: renderer
      windowOptions: '{"width": 600, "height": 500, "modal": true, "resizable": false, "title": "Preferences"}'
    ui:
      framework: React
      layout: modal
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: 'Modal preferences dialog for configuring application settings: default units (metric/imperial), grid spacing,
        snap settings, rendering quality, keyboard shortcuts, plugin management, and auto-save intervals.'
  uuid: Tj4qa0I2
- id: window.materials
  kind: window
  layer: ui
  name: Materials Browser
  x:
    electron:
      processType: renderer
      windowOptions: '{"width": 400, "height": 600, "title": "Materials"}'
    ui:
      framework: React
      layout: floating
      resizable: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Floating materials browser window. Displays material library with thumbnails, allows drag-and-drop onto
        faces, and supports creating/editing PBR materials (albedo, roughness, metalness, normal map). Materials are stored
        as JSON with texture file references.
  uuid: iLjOOnSg
- id: toolbar.main
  kind: toolbar
  layer: ui
  name: Main Toolbar (Removed)
  x:
    ui:
      framework: React
      position: top
    docs:
      description: 'REMOVED — replaced by native Electron menu bar (menu.main). File/Edit dropdown menus were removed from
        the renderer. All tools previously here are now in toolbar.drawing.'
    impl:
      status: removed
  uuid: sVgEpC7b
- id: toolbar.drawing
  kind: toolbar
  layer: ui
  name: Drawing Toolbar
  x:
    ui:
      framework: React
      position: left
    docs:
      description: 'Vertical toolbar docked on the left side. Contains ALL tools organized in collapsible groups:
        Select (Select, Eraser), Draw (Line, Rectangle, Circle, Arc, Polygon), Modify (Push/Pull, Move, Rotate, Scale,
        Offset, Sweep, Paint), Measure (Tape Measure, Protractor, Dimension, Text, Section Plane, Axes),
        Navigate (Orbit, Pan, Zoom). Shows tool icon + label with keyboard shortcut in tooltip.'
    impl:
      status: implemented
  uuid: osvXnUrz
- id: toolbar.views
  kind: toolbar
  layer: ui
  name: Views Toolbar
  x:
    ui:
      framework: React
      position: top
    docs:
      description: 'Secondary toolbar for view controls: standard views (Front, Back, Left, Right, Top, Bottom, Iso), render
        modes (Wireframe, Shaded, Textured, X-Ray), zoom controls (Zoom Extents, Zoom Window), and section planes.'
    impl:
      status: implemented
  uuid: LwC50UvP
- id: menu.main
  kind: menu
  layer: ui
  name: Application Menu
  x:
    ui:
      framework: React
    docs:
      description: 'Native Electron application menu bar with menus: File (New, Open, Save, Save As, Import, Export, Recent
        Files), Edit (Undo, Redo, Cut, Copy, Paste, Delete, Select All), Draw (all drawing tools), Tools (all modification
        tools), View (render modes, toolbars, panels), Camera (standard views, projection), Window (panels), Plugins, Help.'
    impl:
      status: implemented
  uuid: 68XHTgxn
- id: menu.context
  kind: menu
  layer: ui
  name: Context Menu
  x:
    ui:
      framework: React
    docs:
      description: 'Right-click context menu that adapts based on selection. For faces: Edit Material, Reverse Face, Intersect
        Faces, Make Group/Component, Entity Info. For edges: Divide, Weld, Hide. For groups/components: Edit Group, Explode,
        Make Unique, Lock. For empty space: Paste, Select All, Zoom Extents.'
    impl:
      status: implemented
  uuid: xeMjbF7O
- id: panel.properties
  kind: panel
  layer: ui
  name: Entity Info Panel
  x:
    ui:
      framework: React
      position: right
      collapsible: true
      resizable: true
    docs:
      description: Right-side panel showing properties of the selected entity. Displays entity type, layer, material, dimensions
        (editable), area/volume calculations, and component definition info. Updates in real-time as selection changes.
    impl:
      status: implemented
  uuid: Pe6CMGVv
- id: panel.outliner
  kind: panel
  layer: ui
  name: Outliner Panel
  x:
    ui:
      framework: React
      position: right
      collapsible: true
      resizable: true
    docs:
      description: Hierarchical tree view of all scene objects (groups, components, loose geometry). Supports drag-and-drop
        reordering, visibility toggles, lock toggles, and search/filter. Double-click to enter group/component editing context.
    impl:
      status: implemented
  uuid: KyznaKNF
- id: panel.layers
  kind: panel
  layer: ui
  name: Layers Panel
  x:
    ui:
      framework: React
      position: right
      collapsible: true
    docs:
      description: Layer management panel (called 'Tags' in modern DraftDown). Create, rename, delete layers. Toggle visibility
        and lock per layer. Assign selected entities to layers. Active layer indicator. Color-by-layer display mode.
    impl:
      status: implemented
  uuid: vjwdEO3q
- id: panel.components
  kind: panel
  layer: ui
  name: Components Panel
  x:
    ui:
      framework: React
      position: right
      collapsible: true
      resizable: true
    docs:
      description: Component browser panel. Lists all component definitions in the model. Shows thumbnail preview, instance
        count, and description. Supports creating new components from selection, editing in-place, and importing from local
        .skp files.
    impl:
      status: implemented
  uuid: uliv0zgg
- id: panel.measurements
  kind: panel
  layer: ui
  name: Measurements Panel
  x:
    ui:
      framework: React
      position: bottom
    docs:
      description: Bottom status bar showing the Measurements/VCB (Value Control Box). Displays current measurement while
        drawing (length, angle, radius). Accepts typed input for precise values. Shows axis indicators (red=X, green=Y, blue=Z)
        and inference engine status.
    impl:
      status: implemented
  uuid: 146eQPLI
- id: tool.base
  kind: service
  layer: interaction
  name: Tool Base (shared infrastructure)
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Shared infrastructure every tool.* node extends, in implementations/tool.base/.\n          BaseTool.ts:\
        \ lifecycle (activate/deactivate/phase), VCB + status helpers, undo transactions,\n          drawing-plane + axis-lock\
        \ helpers, snap-aware point resolution, and classic-CAD-style directional\n          inference (applyDirectionInference:\
        \ auto axis snap, Shift-pin, parallel-to-edge — guides + labels).\n          drawingPlanes.ts: DRAWING_PLANES /\
        \ DrawingPlaneAxis arrow-key plane vocabulary. planeGeometry.ts:\n          planeBasis (orthonormal in-plane axes)\
        \ and rayPlaneIntersect — used by circle/polygon/rectangle/rotate.\n          VertexTransformSession.ts: gather/snapshot/apply/restore\
        \ of selection vertices — used by move/rotate/scale.\n          GripOverlay.ts: clickable camera-scaled overlay grips\
        \ with hover highlight — used by rotate (handles)\n          and scale (grips). New tools should compose these instead\
        \ of re-implementing them."
  uuid: sToolBase
- id: tool.manager
  kind: service
  layer: interaction
  name: Tool Manager
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: "Tool registry + activation (implementations/tool.manager/ToolManager.ts). Registers all\n          23 tools\
        \ at Application.initialize, routes activate/deactivate, emits tool-changed events consumed\n          by the React\
        \ toolbar and ViewportCanvas."
  uuid: sToolMgr1
- id: tool.select
  kind: tool
  layer: interaction
  name: Select Tool
  x:
    tool:
      category: select
      shortcut: Space
      cursor: pointer
      icon: cursor-arrow
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Point-pick on mouseDown with instant feedback. Shift+click toggles multi-select.\n\
        \          Drag-box selection with visual overlay (blue solid=window, green dashed=crossing).\n\
        \          Cursor changes to pointer over selectable entities. Pre-selection highlight on hover\n\
        \          (orange for faces, orange glow tube for edges). Also hosts BaseTool and ToolManager.\n\
        \          Resolves component IDs for component selection.\n\
        \          Double-click on component enters editing mode (dimmed surroundings, blue bounding box).\n\
        \          Escape exits component editing. Delete on component deletes all member geometry.\n\
        \          BaseTool.resolveSelectedEntityIds() expands component IDs to member face/edge IDs.\n\
        \          BaseTool provides default getEventNeeds(phase) based on category — tools override\n\
        \          to declare snap/raycast/edgeRaycast/liveSyncOnMove/mutatesOnClick needs per phase.\n\
        \          ToolEventNeeds drives unified buildToolEvent() in ViewportCanvas, eliminating\n\
        \          hardcoded tool ID lists."
      notes: "## Typed Interface\n\n```typescript\nimport { ITool, ToolContext, ToolEvent, MouseEvent3D, KeyEvent } from '../types/tool';\n\
        import { SelectionManager, SelectionSet, SelectionMode } from '../data/selection';\nimport { SceneManager, Entity,\
        \ EntityType } from '../data/scene';\nimport { RaycastResult } from '../rendering/raycast';\nimport { InferenceResult\
        \ } from '../geometry/inference';\nimport { Rect2D, Vector2 } from '../math/types';\n\nexport interface SelectToolState\
        \ {\n  mode: 'idle' | 'clicking' | 'box-selecting' | 'dragging';\n  boxStart: Vector2 | null;\n  boxEnd: Vector2 |\
        \ null;\n  boxDirection: 'window' | 'crossing'; // left-to-right vs right-to-left\n  lastClickTime: number;\n  clickCount:\
        \ number; // for double/triple click detection\n  hoverEntity: Entity | null;\n}\n\nexport interface SelectToolConfig\
        \ {\n  doubleClickTimeout: number; // ms, default 300\n  tripleClickTimeout: number; // ms, default 500\n  dragThreshold:\
        \ number; // pixels before click becomes drag, default 5\n  boxSelectColor: { window: string; crossing: string };\n\
        }\n\nexport class SelectTool implements ITool {\n  readonly id = 'tool.select';\n  readonly category = 'select';\n\
        \  readonly shortcut = 'Space';\n  readonly cursor = 'pointer';\n\n  private state: SelectToolState;\n  private config:\
        \ SelectToolConfig;\n  private ctx: ToolContext;\n\n  // Lifecycle\n  activate(ctx: ToolContext): void;\n  deactivate():\
        \ void;\n\n  // Input handlers\n  onMouseDown(event: MouseEvent3D): void;\n  onMouseMove(event: MouseEvent3D): void;\n\
        \  onMouseUp(event: MouseEvent3D): void;\n  onKeyDown(event: KeyEvent): void;\n  onKeyUp(event: KeyEvent): void;\n\
        \n  // Internal\n  private performRaycast(event: MouseEvent3D): RaycastResult | null;\n  private handleSingleClick(hit:\
        \ RaycastResult | null, modifiers: { shift: boolean; ctrl: boolean }): void;\n  private handleDoubleClick(hit: RaycastResult):\
        \ void;\n  private handleTripleClick(hit: RaycastResult): void;\n  private updateBoxSelection(start: Vector2, end:\
        \ Vector2, direction: 'window' | 'crossing'): void;\n  private getEntitiesInBox(rect: Rect2D, mode: 'window' | 'crossing'):\
        \ Entity[];\n  private updatePreselectionHighlight(event: MouseEvent3D): void;\n}\n```\n\n## Selection Logic\n- **Single\
        \ click**: `selectionManager.replace(hit.entity)` or `selectionManager.clear()` if no hit\n- **Shift+click**: `selectionManager.toggle(hit.entity)`\n\
        - **Ctrl+click**: `selectionManager.add(hit.entity)`\n- **Double-click on group**: `sceneManager.enterEditingContext(hit.entity)`\n\
        - **Triple-click**: `selectionManager.selectConnected(hit.entity)`\n- **Box select (window)**: Only entities fully\
        \ inside the box\n- **Box select (crossing)**: Entities intersecting or inside the box\n\n## Pre-selection\nOn every\
        \ mouseMove, raycast and highlight the entity under cursor with a subtle overlay (different from full selection highlight).\
        \ This gives the user visual feedback before clicking."
  uuid: ceUtTwvQ
- id: tool.line
  kind: tool
  layer: interaction
  name: Line Tool
  x:
    tool:
      category: draw
      shortcut: L
      cursor: crosshair
      icon: line
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Multi-point line drawing with axis locking (Up=Y, Right=X, Left=Z, Down=unlock).\n          Uses ray-to-axis\
        \ projection for accurate 3D positioning from any camera angle.\n          VCB input respects locked axis direction\
        \ and cursor sign. Auto-face via createEdgeWithAutoFace.\n          splitFaceWithPath on deactivate. findOrCreateVertex\
        \ from BaseTool for vertex reuse.\n          Commits on deactivate (not abort). Midpoint snap works via getStandardDrawPoint.\n\
        \          Face plane lock: when the first click lands on a face (event.hitFaceId set),\n          the tool captures\
        \ that face's plane as lockedFacePlane. Subsequent points raycast onto\n          the locked plane unless the snapped\
        \ worldPoint already lies on it (within 0.01).\n          This mirrors DraftDown behavior — drawing a line that starts\
        \ on a face stays on the\n          face even when the cursor strays into empty space."
      notes: "## Typed Interface\n\n```typescript\nimport { ITool, ToolContext, MouseEvent3D, KeyEvent } from '../types/tool';\n\
        import { Vector3 } from '../math/types';\nimport { InferenceResult, InferenceEngine } from '../geometry/inference';\n\
        import { Edge, Face, Vertex } from '../geometry/mesh';\nimport { SceneManager } from '../data/scene';\nimport { HistoryManager,\
        \ Transaction } from '../data/history';\n\nexport interface LineToolState {\n  phase: 'idle' | 'drawing'; // idle\
        \ = waiting for first click, drawing = placing subsequent points\n  points: Vector3[]; // accumulated points in current\
        \ polyline\n  currentInference: InferenceResult | null;\n  activeTransaction: Transaction | null;\n  lockedAxis: 'x'\
        \ | 'y' | 'z' | null; // arrow key axis lock\n}\n\nexport interface LineToolResult {\n  edges: Edge[]; // newly created\
        \ edges\n  faces: Face[]; // auto-detected faces from closed loops\n  vertices: Vertex[]; // new or snapped-to vertices\n\
        }\n\nexport class LineTool implements ITool {\n  readonly id = 'tool.line';\n  readonly category = 'draw';\n  readonly\
        \ shortcut = 'L';\n  readonly cursor = 'crosshair';\n\n  private state: LineToolState;\n  private ctx: ToolContext;\n\
        \  private inference: InferenceEngine;\n\n  // Lifecycle\n  activate(ctx: ToolContext): void;\n  deactivate(): void;\n\
        \n  // Input\n  onMouseDown(event: MouseEvent3D): void; // place point\n  onMouseMove(event: MouseEvent3D): void;\
        \ // update inference preview\n  onMouseUp(event: MouseEvent3D): void;\n  onKeyDown(event: KeyEvent): void; // Esc=finish,\
        \ Arrow=lock axis, Enter=finish\n  onVCBInput(value: string): void; // typed distance like '500' or '300,200'\n\n\
        \  // Core logic\n  private placePoint(position: Vector3, inference: InferenceResult | null): void;\n  private createEdge(from:\
        \ Vector3, to: Vector3): Edge;\n  private detectClosedLoop(edges: Edge[]): Face | null;\n  private finishDrawing():\
        \ LineToolResult;\n  private updatePreview(cursorPos: Vector3, inference: InferenceResult | null): void;\n  private\
        \ drawRubberBandLine(from: Vector3, to: Vector3, axisColor?: string): void;\n}\n```\n\n## Face Auto-Detection\nAfter\
        \ each edge is created, check if the new edge completes a closed loop of coplanar edges. If so, automatically create\
        \ a Face from that loop. Algorithm:\n1. From the new edge's endpoint, traverse connected edges\n2. If a path returns\
        \ to the start vertex and all edges are coplanar (within tolerance), create face\n3. Use the face normal consistent\
        \ with the winding order\n\n## VCB Input\n- Single number `500`: set edge length to 500 in current direction\n- Two\
        \ numbers `300,200`: set relative X,Y offset from start point\n- Three numbers `100,200,50`: set relative X,Y,Z offset\n\
        - Negative numbers allowed for reverse direction"
  uuid: WXBGmpCI
- id: tool.rectangle
  kind: tool
  layer: interaction
  name: Rectangle Tool
  x:
    tool:
      category: draw
      shortcut: R
      cursor: crosshair
      icon: rectangle
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Two-click rectangle with arrow key plane switching (Right=YZ, Left=XY,\n          Up=XZ, Down=reset).\
        \ Uses raycastDrawingPlane for mouse position on active plane.\n          VCB direction-aware: cursor quadrant determines\
        \ sign of width/height.\n          Degenerate check prevents faces with < 0.001 width or height.\n          Preview\
        \ shows dashed polygon outline that updates on plane change.\n          Face-snap drawing plane: when the first click\
        \ hits a face, getEffectiveDrawingPlane\n          captures that face's plane as drawPlane. getPlaneAxes() builds two\
        \ orthogonal axes\n          that LIE IN the drawing plane via cross(normal, ref) × cross(normal, axis1) for any\n\
        \          non-axis-aligned plane (e.g., slanted/diagonal faces) — earlier code used world\n          axes which\
        \ pushed two of the four corners off the plane. Axis-aligned planes keep\n          the existing world-axis pairs for\
        \ VCB compatibility."
  uuid: QWmYWzAR
- id: tool.circle
  kind: tool
  layer: interaction
  name: Circle Tool
  x:
    tool:
      category: draw
      shortcut: C
      cursor: crosshair
      icon: circle
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Draw circles by clicking center then radius point. Type radius in VCB for exact size.\n          Configurable\
        \ segment count (default 24, type 's' + number). Arrow keys change drawing plane.\n          Creates edges with intersection\
        \ detection (createEdgeWithIntersection), groups edges\n          with a shared curveId. Explicitly creates face from\
        \ vertex loop since autoCreateFaces\n          BFS maxDepth=20 is too small for 24-segment circles. Snaps center to\
        \ existing geometry."
  uuid: wnTrJPzS
- id: tool.arc
  kind: tool
  layer: interaction
  name: Arc Tool
  x:
    tool:
      category: draw
      shortcut: A
      cursor: crosshair
      icon: arc
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Draw arcs with 3 clicks: start point, end point, then bulge distance. Type radius or number of segments
        in VCB. Creates arc edges that form tangent connections with adjacent lines. Supports 2-point arc (start/end + bulge)
        and pie arc modes.'
  uuid: 28E5lsDz
- id: tool.polygon
  kind: tool
  layer: interaction
  name: Polygon Tool
  x:
    tool:
      category: draw
      shortcut: Shift+P
      cursor: crosshair
      icon: polygon
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Draw regular polygons (3-100 sides). Type number of sides before clicking center. Click center, then drag
        to set radius. Creates a face with N edges. Default is hexagon (6 sides).
  uuid: wBEeXzL9
- id: tool.pushpull
  kind: tool
  layer: interaction
  name: Push/Pull Tool
  x:
    tool:
      category: modify
      shortcut: P
      cursor: move
      icon: push-pull
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Dual-mode push/pull: 2D standalone faces extrude (create side walls + top cap),\n          3D faces with\
        \ existing side walls just move vertices (walls stretch automatically).\n          Detects mode via hasSideWalls()\
        \ — checks adjacent face normals for non-coplanar neighbors.\n          Recomputes face normal from current vertex\
        \ positions (Newell's method) so push/pull\n          works correctly on rotated geometry. Screen-space Y for distance.\
        \ Pre-selected face auto-starts.\n          Preview shows top face outline + vertical guide lines. VCB for exact distance."
      notes: "## Typed Interface\n\n```typescript\nimport { ITool, ToolContext, MouseEvent3D, KeyEvent } from '../types/tool';\n\
        import { Face, Mesh, Edge, Vertex } from '../geometry/mesh';\nimport { Vector3 } from '../math/types';\nimport { InferenceResult\
        \ } from '../geometry/inference';\nimport { ExtrudeOperation, ExtrudeParams, ExtrudeResult } from '../operations/extrude';\n\
        import { HistoryManager, Transaction } from '../data/history';\n\nexport interface PushPullState {\n  phase: 'idle'\
        \ | 'face-picked' | 'dragging';\n  targetFace: Face | null;\n  faceNormal: Vector3 | null;\n  dragStartPoint: Vector3\
        \ | null;\n  currentDistance: number;\n  lastDistance: number | null; // for double-click repeat\n  createNewFace:\
        \ boolean; // Ctrl mode - leave original face\n  preview: ExtrudeResult | null;\n  activeTransaction: Transaction\
        \ | null;\n}\n\nexport interface PushPullConfig {\n  minDistance: number; // epsilon to avoid zero-height extrusions\n\
        \  snapToExistingFaces: boolean; // snap to coplanar faces during drag\n  autoBooleanSubtract: boolean; // push into\
        \ solid = boolean cut\n}\n\nexport class PushPullTool implements ITool {\n  readonly id = 'tool.pushpull';\n  readonly\
        \ category = 'modify';\n  readonly shortcut = 'P';\n  readonly cursor = 'move';\n\n  private state: PushPullState;\n\
        \  private config: PushPullConfig;\n  private extrudeOp: ExtrudeOperation;\n\n  // Lifecycle\n  activate(ctx: ToolContext):\
        \ void;\n  deactivate(): void;\n\n  // Input\n  onMouseDown(event: MouseEvent3D): void;\n  onMouseMove(event: MouseEvent3D):\
        \ void;\n  onMouseUp(event: MouseEvent3D): void;\n  onDoubleClick(event: MouseEvent3D): void; // repeat last distance\n\
        \  onKeyDown(event: KeyEvent): void; // Ctrl=new face mode, Esc=cancel\n  onVCBInput(value: string): void; // exact\
        \ distance\n\n  // Core logic\n  private pickFace(event: MouseEvent3D): Face | null;\n  private computeDistance(event:\
        \ MouseEvent3D): number;\n  private updatePreview(distance: number): void;\n  private commitExtrude(distance: number):\
        \ ExtrudeResult;\n  private detectBooleanCut(face: Face, direction: Vector3, distance: number): boolean;\n  private\
        \ performBooleanCut(face: Face, distance: number): ExtrudeResult;\n}\n```\n\n## Extrusion Algorithm\n1. Pick a face\
        \ → get face normal as extrude direction\n2. For each boundary edge of the face, create a side face (quad)\n3. Clone\
        \ the original face and translate by `normal * distance`\n4. Connect side faces to cloned face edges\n5. If `distance\
        \ < 0`, flip the direction (push into solid)\n6. If pushing into an existing solid, delegate to `op.boolean_subtract`\n\
        7. Merge coplanar adjacent faces when applicable\n\n## Double-Click Repeat\nStore `lastDistance` as static across\
        \ tool activations. On double-click, pick face and immediately extrude by `lastDistance`."


  uuid: XlCNBL59
- id: tool.move
  kind: tool
  layer: interaction
  name: Move Tool
  x:
    tool:
      category: modify
      shortcut: M
      cursor: move
      icon: move
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Live vertex movement with preview. Gathers vertices from all selected faces/edges\n          (resolves\
        \ component IDs). Saves/restores original positions for cancel. VCB distance\n          follows cursor direction.\n\
        \          Arrow-key axis lock (Up=Y, Right=X, Left=Z, Down=unlock) — matches Line tool\n          convention. The\
        \ lock applies to the live preview, the VCB distance display, and\n          typed-distance VCB input (signs taken\
        \ from the cursor's side along the locked axis).\n          The lock auto-clears between move operations via reset()."
      notes: "## Typed Interface\n\n```typescript\nimport { ITool, ToolContext, MouseEvent3D, KeyEvent } from '../types/tool';\n\
        import { Entity } from '../data/scene';\nimport { Vector3 } from '../math/types';\nimport { InferenceResult } from\
        \ '../geometry/inference';\nimport { SelectionManager } from '../data/selection';\nimport { HistoryManager, Transaction\
        \ } from '../data/history';\n\nexport interface MoveToolState {\n  phase: 'idle' | 'base-point-picked' | 'moving';\n\
        \  entities: Entity[]; // entities being moved\n  basePoint: Vector3 | null;\n  currentOffset: Vector3;\n  copyMode:\
        \ boolean; // Ctrl held = copy instead of move\n  lockedAxis: 'x' | 'y' | 'z' | null;\n  lastMoveVector: Vector3 |\
        \ null; // for array repeat\n  activeTransaction: Transaction | null;\n}\n\nexport interface MoveResult {\n  movedEntities:\
        \ Entity[];\n  copiedEntities: Entity[] | null; // if copy mode\n  displacement: Vector3;\n}\n\nexport class MoveTool\
        \ implements ITool {\n  readonly id = 'tool.move';\n  readonly category = 'modify';\n  readonly shortcut = 'M';\n\
        \  readonly cursor = 'move';\n\n  // Lifecycle\n  activate(ctx: ToolContext): void;\n  deactivate(): void;\n\n  //\
        \ Input\n  onMouseDown(event: MouseEvent3D): void; // pick base point or destination\n  onMouseMove(event: MouseEvent3D):\
        \ void; // preview move\n  onMouseUp(event: MouseEvent3D): void;\n  onKeyDown(event: KeyEvent): void; // Ctrl=copy,\
        \ Arrow=lock axis, Esc=cancel\n  onVCBInput(value: string): void; // '500' = distance, '100,200,50' = offset, 'x3'\
        \ = array\n\n  // Core\n  private pickBasePoint(event: MouseEvent3D): Vector3;\n  private computeDisplacement(event:\
        \ MouseEvent3D): Vector3;\n  private applyMove(entities: Entity[], displacement: Vector3): MoveResult;\n  private\
        \ applyCopy(entities: Entity[], displacement: Vector3): MoveResult;\n  private createLinearArray(entities: Entity[],\
        \ displacement: Vector3, count: number): Entity[];\n  private handleAutoFold(entity: Entity, displacement: Vector3):\
        \ void; // fold connected faces\n}\n```\n\n## Auto-Fold\nWhen moving a vertex or edge that is shared between faces,\
        \ and the move would break coplanarity, automatically fold the connected faces along the shared edge rather than creating\
        \ invalid geometry.\n\n## VCB Array Input\nAfter a copy-move, typing `x3` creates 2 additional copies (3 total) evenly\
        \ spaced. Typing `/3` divides the distance into 3 equal copies."
  uuid: 56EqChJo
- id: tool.rotate
  kind: tool
  layer: interaction
  name: Rotate Tool
  x:
    tool:
      category: modify
      shortcut: Q
      cursor: rotate
      icon: rotate
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Three-step rotation: click handle for center, click for start angle, drag to rotate.\n          Arrow\
        \ keys switch rotation axis: Up=Green/Y, Right=Red/X, Left=Blue/Z, Down=reset.\n          Toggle behavior — pressing\
        \ same arrow key twice resets to Y. Bounding box handles\n          update to show rotation plane for current axis.\
        \ Protractor circle + axis line drawn\n          in overlay scene. Rodrigues rotation formula for vertex transforms.\n\
        \          VCB accepts degrees for exact angle. Handles scale to camera distance."
  uuid: WZyKJ6DX
- id: tool.scale
  kind: tool
  layer: interaction
  name: Scale Tool
  x:
    tool:
      category: modify
      shortcut: S
      cursor: scale
      icon: scale
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Shows 9 green grip handles (4 corners + 4 edge midpoints + 1 center) with yellow\n\
        \        bounding box and dotted extension lines. Edge midpoint grips constrain scaling to single\n\
        \        axis (moves just that side). Corner grips scale both axes. Grips maintain constant screen size."
  uuid: PIor44v3
- id: tool.offset
  kind: tool
  layer: interaction
  name: Offset Tool
  x:
    tool:
      category: modify
      shortcut: F
      cursor: crosshair
      icon: offset
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Click face, drag to inset/outset. Preview shows dashed offset polygon.\n          Creates inner face +\
        \ connecting ring. Replaces original face."
  uuid: 3ZdOJaJh
- id: tool.eraser
  kind: tool
  layer: interaction
  name: Eraser Tool
  x:
    tool:
      category: modify
      shortcut: E
      cursor: pointer
      icon: eraser
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: "Click/drag to delete faces and edges. Pre-selection highlight shows what will\n          be deleted. Each\
        \ click wraps in transaction for undo support."
  uuid: 96zZ0Ia9
- id: tool.paint
  kind: tool
  layer: interaction
  name: Paint Bucket Tool
  x:
    tool:
      category: modify
      shortcut: B
      cursor: pointer
      icon: paint-bucket
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Apply materials/colors/textures to faces. Click to paint, Shift+click to sample, Alt+click to fill all
        faces with the same current material. Material selection via ToolSettingsPanel (right sidebar) with swatch grid showing
        color and procedural texture thumbnails. Supports PBR materials with albedo color, texture map, opacity, roughness,
        metalness. Paint operations are undoable.
  uuid: 2gnrR81m
- id: tool.orbit
  kind: tool
  layer: interaction
  name: Orbit Tool
  x:
    tool:
      category: view
      shortcut: O
      cursor: grab
      icon: orbit
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Orbit the camera around the model. Click+drag to orbit. Middle-mouse-button activates orbit from any tool.
        Shift+middle-mouse pans. Scroll wheel zooms. Ctrl+Shift constrains to vertical orbit. Centers orbit around clicked
        point on geometry.
  uuid: J8odz0eM
- id: tool.pan
  kind: tool
  layer: interaction
  name: Pan Tool
  x:
    tool:
      category: view
      shortcut: H
      cursor: grab
      icon: pan
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Pan the camera view. Click+drag to pan. Shift+middle-mouse activates pan from any tool. Maintains current
        zoom level and orbit center relative to panned position.
  uuid: 1NLwLQgx
- id: tool.zoom
  kind: tool
  layer: interaction
  name: Zoom Tool
  x:
    tool:
      category: view
      shortcut: Z
      cursor: pointer
      icon: zoom
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Zoom in/out. Click+drag up to zoom in, down to zoom out. Scroll wheel zooms toward cursor position. Shift+Z
        for Zoom Extents (fit all geometry in view). Ctrl+Shift+Z for Zoom Window (draw box to zoom to). Type FOV angle in
        VCB to change field of view.
  uuid: aybhjdyU
- id: tool.tape_measure
  kind: tool
  layer: interaction
  name: Tape Measure Tool
  x:
    tool:
      category: measure
      shortcut: T
      cursor: crosshair
      icon: tape-measure
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Click two points to measure distance. Live preview line during placement.\n          Creates dashed construction\
        \ guide line between measured points (linewidth=2,\n          solid black, selectable). VCB input for exact distance\n\
        \          in current cursor direction. Uses getStandardDrawPoint and findOrCreateVertex\n          from BaseTool.\
        \ Supports arrow key plane switching. Fully undoable — wraps\n          measurement in beginTransaction/commitTransaction\
        \ and records guide lines via\n          HistoryManager.recordGuideLine() for undo/redo support; deletions are recorded\n\
        \          via recordGuideLineRemoval() (added to DeltaTransaction.guideLineRemovals) so\n          select-and-Delete\
        \ on a guide line is also undoable. The guide line is registered\n          with the renderer's _entityObjects so the\
        \ existing GPU pick + Line highlight\n          pipeline (blue + glow tube) treats it as a first-class selectable entity."
  uuid: 9yqt3Wjr
- id: tool.protractor
  kind: tool
  layer: interaction
  name: Protractor Tool
  x:
    tool:
      category: measure
      shortcut: Shift+T
      cursor: crosshair
      icon: protractor
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Three-click angle measurement (center, baseline, angle point) with live preview\n          showing both\
        \ baseline and angle lines. Places dashed construction guide line at measured angle.\n          VCB input for exact\
        \ degrees. Guide extends 50 units from center."
  uuid: p5t0Ix1W
- id: tool.sweep_tool
  kind: tool
  layer: interaction
  name: Sweep Tool
  x:
    tool:
      category: modify
      shortcut: Shift+F
      cursor: crosshair
      icon: sweep
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Select face as profile, click edge to sweep along connected edges. Collects\n          path by walking\
        \ connected edges avoiding profile boundary. Calls SweepOperation which\n          generates cross-section rings at\
        \ each path vertex and connects them with quad faces.\n          Supports pre-selected face from selection."

  uuid: udD539qm
- id: tool.dimension
  kind: tool
  layer: interaction
  name: Dimension Tool
  x:
    tool:
      category: annotation
      shortcut: D
      cursor: crosshair
      icon: dimension
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Three-step workflow (start, end, offset) places linear dimensions with extension lines,\n\
        \        tick marks, and text sprite. Displays values with unit labels (mm, cm, m, \", ') at most\n\
        \        1 decimal place via formatDistance(). Dimensions are selectable and movable (constrained\n\
        \        perpendicular to measurement line). Associative — tracks vertex IDs and updates when\n\
        \        geometry moves. DimensionStore.syncToGeometry() updates sprite text with current units.\n\
        \        Fully undoable — HistoryManager snapshots DimensionDelta (serializable, no Three.js objects)\n\
        \        at begin/commit time. Undo removes dimensions and guide lines; redo recreates them\n\
        \        via Application.recreateDimension(). Uses DimensionStore singleton for state management."
  uuid: gHVP0JyU
- id: tool.text
  kind: tool
  layer: interaction
  name: 3D Text / Label Tool
  x:
    tool:
      category: annotation
      shortcut: Shift+D
      cursor: crosshair
      icon: text
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: "Creates real vector geometry (edges + faces) using Three.js Font system.\n          Opens floating dialog\
        \ with text input, font selection (Helvetica, Gentilis, Optimer + bold variants),\n          size, and color. Text\
        \ placed as actual edges/faces on the ground plane — selectable, movable, push/pullable."
  uuid: LUHz0ZsR
- id: gesture.click
  kind: gesture
  layer: interaction
  name: Click Gesture
  x:
    gesture:
      inputType: mouse
      pattern: click
      modifiers: ''
    docs:
      description: Single left-click — primary action for all tools. Used for point placement, entity selection, face picking.
    impl:
      status: implemented
  uuid: AD2u34xM
- id: gesture.double_click
  kind: gesture
  layer: interaction
  name: Double-Click Gesture
  x:
    gesture:
      inputType: mouse
      pattern: double-click
      modifiers: ''
    docs:
      description: 'Double left-click. In Select tool: enter group/component editing context. In Push/Pull: repeat last distance.
        In Offset: repeat last offset.'
    impl:
      status: implemented
  uuid: gj5q2nlZ
- id: gesture.drag
  kind: gesture
  layer: interaction
  name: Drag Gesture
  x:
    gesture:
      inputType: mouse
      pattern: click-drag
      modifiers: ''
    docs:
      description: Left-click and drag. Used by Move, Rotate, Scale, Push/Pull for interactive manipulation. Also used by
        Select for box selection.
    impl:
      status: implemented
  uuid: Q9tmi8PP
- id: gesture.middle_drag
  kind: gesture
  layer: interaction
  name: Middle Mouse Drag
  x:
    gesture:
      inputType: mouse
      pattern: middle-drag
      modifiers: ''
    docs:
      description: Middle mouse button drag activates Orbit from any tool. Most important navigation gesture — allows orbiting
        without switching tools.
    impl:
      status: implemented
  uuid: 8lnC03XS
- id: gesture.shift_middle_drag
  kind: gesture
  layer: interaction
  name: Shift + Middle Mouse Drag
  x:
    gesture:
      inputType: mouse
      pattern: middle-drag
      modifiers: Shift
    docs:
      description: Shift + middle mouse drag activates Pan from any tool. Combined with middle-drag orbit and scroll zoom,
        provides complete navigation without changing tools.
    impl:
      status: implemented
  uuid: f13DpSyN
- id: gesture.scroll
  kind: gesture
  layer: interaction
  name: Scroll Wheel Gesture
  x:
    gesture:
      inputType: mouse
      pattern: wheel
      modifiers: ''
    docs:
      description: Mouse scroll wheel zooms toward/away from cursor position. Zoom centers on the 3D point under the cursor
        for intuitive navigation. Smooth scrolling supported.
    impl:
      status: implemented
  uuid: zMGzQ3lu
- id: gesture.keyboard_value
  kind: gesture
  layer: interaction
  name: Keyboard Value Input
  x:
    gesture:
      inputType: keyboard
      pattern: type-number
      modifiers: ''
    docs:
      description: 'Typing numbers during any tool operation enters the value directly into the VCB (Value Control Box). For
        Line: sets length. For Rectangle: sets width,height. For Rotate: sets angle. For Move: sets distance. Tab switches
        between VCB fields. Enter confirms.'
    impl:
      status: implemented
  uuid: EgeltoK9
- id: viewport.main
  kind: viewport
  layer: rendering
  name: Main 3D Viewport
  x:
    viewport:
      renderMode: shaded
      projection: perspective
      grid: true
      axes: true
      background: gradient
    impl:
      language: TypeScript
      framework: Three.js
      complexity: complex
      status: implemented
    docs:
      description: "Canvas via Three.js setSize. ResizeObserver syncs dimensions.\n\
        \          projectionMatrixInverse manually recomputed before every raycast. Raycasts both main\n\
        \          and overlay scenes. Edge threshold scales with camera distance. Edges returned before\n\
        \          faces for reliable edge selection. Middle mouse orbit/pan with window-level mouseup\n\
        \          listener and e.buttons===0 safety check.\n\
        \          Unified event system: single buildToolEvent(e, needs) replaces three separate event\n\
        \          builders. GPU pick always runs first (O(1)), raycast/edge-raycast/snap are additive\n\
        \          based on tool-declared ToolEventNeeds metadata. Tools declare needs via getEventNeeds(phase)\n\
        \          — no hardcoded tool ID lists in ViewportCanvas. Throttled mousemove at 16ms (~60fps).\n\
        \          GPU pick results resolved through scene manager: layer visibility, locked state, and\n\
        \          component protection — protected entities return component ID instead of member entity ID.\n\
        \          resolveHit() applies same checks for raycast/edge-raycast fallback paths."
  uuid: f8kRBGQr
- id: renderer.webgl
  kind: renderer
  layer: rendering
  name: WebGL Renderer
  x:
    renderer:
      engine: Three.js
      antialiasing: MSAA
      shadows: true
      postProcessing: SSAO, edge detection outlines, selection highlight glow
    perf:
      critical: true
      optimizations: Frustum culling, instanced rendering for components, LOD for distant objects, GPU picking for selection,
        batched geometry for draw call reduction, Earcut triangulation cache (reuse tri indices when face topology unchanged),
        in-place Float32Array buffer writes for faces and edges (skip geometry disposal/creation during transforms),
        dirty vertex tracking with vertex→face/edge adjacency for targeted sync iteration (O(dirty) not O(all)),
        deferred component bounding box updates (unit-box with scale transform, skip unaffected components)
      benchmarks: Target 60fps for models up to 500K faces, 30fps for models up to 2M faces
    impl:
      language: TypeScript
      framework: Three.js
      complexity: very-complex
      status: implemented
    docs:
      description: "Three.js WebGL renderer with ambient+directional+hemisphere lighting, logarithmicDepthBuffer,\n\
        \        and localClippingEnabled. Infinite shader-based ground grid. Face highlighting uses an\n\
        \        OVERLAY mesh approach (not material swap) — when a face is selected/pre-selected the\n\
        \        original textured material stays attached, and a translucent tinted overlay mesh sharing\n\
        \        the same geometry is added on top so the texture shows through the highlight tint. The\n\
        \        per-entity overlays are tracked in _faceHighlightOverlays and removed on un-highlight.\n\
        \        Edge highlighting still swaps the line material and adds a camera-distance-scaled glow\n\
        \        tube cylinder. Pre-selection=orange, selection=blue. Edge lines in main scene\n\
        \        (depth-tested against faces, polygonOffset on faces prevents z-fighting).\n\
        \        setSectionPlane() for real-time clipping. GPU picking: renders entity IDs as unique\n\
        \        colors to offscreen framebuffer via ShaderMaterial (bypasses Three.js color management).\n\
        \        Per-entity pick meshes for small models, vertex-color-encoded batched pick mesh for large\n\
        \        imported models. Pick buffer re-rendered only on camera move. Batched mode: syncBatched()\n\
        \        merges all faces into single BufferGeometry with frustumCulled=false, castShadow=false.\n\
        \        Edges >200K skipped. Batched face highlighting via temporary extracted geometry (same\n\
        \        overlay-on-top pattern). extractEdgeFromBatch() promotes batched edges to individual\n\
        \        lines for component editing. Memory optimizations: glow tube object pool, numeric camera\n\
        \        movement detection (no string allocation), reusable Vector2/Vector3/Color/Plane instances.\n\
        \        refreshHighlightOriginal() retained for the edge path so syncFace material updates while\n\
        \        an edge is highlighted survive the un-highlight.\n\
        \        Non-batched sync performance: _faceTriCache caches Earcut triangulation indices keyed on\n\
        \        face.generation + vertex count — reused when topology unchanged (move/scale/rotate). syncFace()\n\
        \        and syncEdge() write Float32Array position/normal/UV buffers in-place with needsUpdate=true,\n\
        \        skipping geometry disposal/creation. markVerticesDirty(ids) accepts dirty vertex IDs from tools;\n\
        \        resolveDirtyAdjacency() uses engine.getVertexFaces/getVertexEdgeIds to compute affected faces/edges,\n\
        \        reducing iteration from O(all faces) to O(dirty faces). Dirty tracking cleared after each sync().\n\
        \        Component visuals: syncComponentBoxes() draws bounding boxes (purple=normal, blue=editing),\n\
        \        uses unit-box with scale transform instead of allocating new BoxGeometry each frame,\n\
        \        skips components whose vertices don't overlap the dirty set.\n\
        \        syncComponentDimming() uses color tinting (lerp toward gray, 0.8 factor) on faces outside\n\
        \        the editing component — no transparency overhead. Edges outside get lightened color.\n\
        \        Restores original colors on exit. Separate _origColor (dimming) and _preTintColor\n\
        \        (selection tinting) prevent conflicts. tintComponentFaces() lerps selected component\n\
        \        faces toward blue (0.25 factor) for selection feedback without expanding entity IDs\n\
        \        through the highlight pipeline — major performance improvement for large components."
      notes: "## Typed Interface\n\n```typescript\nimport * as THREE from 'three';\nimport { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';\n\
        import { HalfEdgeMesh, GPUBufferData } from '../geometry/mesh';\nimport { ISceneManager, Group, ComponentInstance\
        \ } from '../data/scene';\nimport { ISelectionManager } from '../data/selection';\nimport { IMaterialManager, Material\
        \ } from '../data/materials';\nimport { InferenceGuide } from '../geometry/inference';\nimport { Camera } from '../rendering/camera';\n\
        \nexport type RenderMode = 'wireframe' | 'shaded' | 'textured' | 'rendered' | 'xray';\n\nexport interface RenderStats\
        \ {\n  fps: number;\n  frameTime: number; // ms\n  drawCalls: number;\n  triangles: number;\n  geometryMemory: number;\
        \ // bytes\n  textureMemory: number; // bytes\n}\n\nexport interface RenderOverlay {\n  inferenceGuides: InferenceGuide[];\n\
        \  selectionHighlights: string[]; // entity IDs\n  preselectionHighlight: string | null;\n  rubberBandGeometry: THREE.BufferGeometry\
        \ | null; // tool preview lines\n  gridVisible: boolean;\n  axesVisible: boolean;\n  sectionPlanes: SectionPlaneData[];\n\
        }\n\nexport interface SectionPlaneData {\n  plane: THREE.Plane;\n  active: boolean;\n  showFill: boolean;\n}\n\nexport\
        \ interface IRenderer {\n  // Setup\n  initialize(canvas: HTMLCanvasElement, width: number, height: number): void;\n\
        \  dispose(): void;\n  resize(width: number, height: number): void;\n\n  // Render loop\n  startRenderLoop(): void;\n\
        \  stopRenderLoop(): void;\n  requestFrame(): void; // force re-render\n  render(camera: Camera, overlay: RenderOverlay):\
        \ void;\n\n  // Scene sync\n  syncScene(sceneManager: ISceneManager): void; // rebuild Three.js scene from scene graph\n\
        \  syncMesh(meshId: string, mesh: HalfEdgeMesh): void; // update single mesh\n  syncMaterial(material: Material):\
        \ void; // update single material\n  syncSelection(selectionManager: ISelectionManager): void;\n\n  // Render mode\n\
        \  setRenderMode(mode: RenderMode): void;\n  getRenderMode(): RenderMode;\n\n  // Picking (GPU-accelerated)\n  pick(screenX:\
        \ number, screenY: number): PickResult | null;\n  pickRect(x1: number, y1: number, x2: number, y2: number): PickResult[];\n\
        \n  // Stats\n  getStats(): RenderStats;\n\n  // Configuration\n  setShadowsEnabled(enabled: boolean): void;\n  setAntialiasing(mode:\
        \ 'none' | 'FXAA' | 'MSAA' | 'SMAA'): void;\n  setBackgroundMode(mode: 'solid' | 'gradient' | 'environment'): void;\n\
        \  setEdgeRendering(enabled: boolean, color?: string, width?: number): void;\n}\n\nexport interface PickResult {\n\
        \  entityId: string;\n  entityType: 'vertex' | 'edge' | 'face' | 'group' | 'component_instance';\n  point: THREE.Vector3;\
        \ // world-space intersection point\n  normal: THREE.Vector3; // face normal at hit point\n  distance: number; //\
        \ camera distance\n  faceId?: string;\n  edgeId?: string;\n  vertexId?: string;\n}\n```\n\n## Render Pipeline (per\
        \ frame)\n1. Sync dirty geometry (check HalfEdgeMesh dirty flags → update THREE.BufferGeometry)\n2. Sync dirty materials\
        \ (check Material dirty flags → update THREE.MeshStandardMaterial)\n3. Depth pre-pass (for SSAO)\n4. Main color pass\
        \ (PBR materials via shader.pbr)\n5. Edge/outline pass (shader.outline — Sobel edge detection)\n6. Selection highlight\
        \ pass (shader.selection — stencil-based)\n7. SSAO pass\n8. Overlay pass (grid, axes, inference guides, rubber-band\
        \ lines, dimensions)\n9. Present to canvas\n\n## Instanced Rendering\nComponent instances that share a definition\
        \ use THREE.InstancedMesh. One draw call for all instances of the same component, with per-instance transform matrices."
  uuid: uJZVdiUn
- id: camera.main
  kind: camera
  layer: rendering
  name: Main Camera
  x:
    camera:
      type: perspective
      fov: 45
      near: 0.1
      far: 10000
      controls: orbit
    impl:
      language: TypeScript
      framework: Three.js
      complexity: moderate
      status: implemented
    docs:
      description: Main viewport camera with native orbit controls.
      notes: "## Typed Interface\n\n```typescript\nimport * as THREE from 'three';\nimport { Vector3 } from '../math/types';\n\
        \nexport type CameraProjection = 'perspective' | 'orthographic';\nexport type StandardView = 'front' | 'back' | 'left'\
        \ | 'right' | 'top' | 'bottom' | 'iso';\n\nexport interface CameraState {\n  position: Vector3;\n  target: Vector3;\
        \ // orbit center\n  up: Vector3;\n  fov: number; // perspective FOV in degrees\n  orthoScale: number; // orthographic\
        \ zoom\n  projection: CameraProjection;\n  near: number;\n  far: number;\n}\n\nexport interface CameraAnimationOptions\
        \ {\n  duration: number; // ms, default 300\n  easing: 'linear' | 'ease-in-out' | 'ease-out'; // default 'ease-in-out'\n\
        }\n\nexport interface ICameraController {\n  // State\n  getState(): CameraState;\n  setState(state: Partial<CameraState>,\
        \ animate?: boolean): void;\n  getThreeCamera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;\n\n  // Navigation\n\
        \  orbit(deltaAzimuth: number, deltaElevation: number): void;\n  pan(deltaX: number, deltaY: number): void; // screen-space\
        \ pixels\n  zoom(delta: number, cursorWorldPos?: Vector3): void; // zoom toward cursor\n  dolly(distance: number):\
        \ void;\n\n  // Standard views\n  setStandardView(view: StandardView, animate?: boolean): void;\n  zoomExtents(boundingBox:\
        \ THREE.Box3, animate?: boolean): void;\n  zoomToSelection(entities: any[], animate?: boolean): void;\n\n  // Projection\n\
        \  setProjection(projection: CameraProjection, animate?: boolean): void;\n  toggleProjection(): void;\n\n  // FOV\n\
        \  setFOV(degrees: number): void;\n  getFOV(): number;\n\n  // View undo/redo\n  pushViewState(): void; // save current\
        \ view to view history\n  undoView(): void;\n  redoView(): void;\n\n  // Screen ↔ World conversion\n  screenToWorld(screenX:\
        \ number, screenY: number, depth?: number): Vector3;\n  worldToScreen(worldPos: Vector3): { x: number; y: number;\
        \ depth: number };\n  screenToRay(screenX: number, screenY: number): { origin: Vector3; direction: Vector3 };\n\n\
        \  // Configuration\n  setOrbitSpeed(speed: number): void;\n  setPanSpeed(speed: number): void;\n  setZoomSpeed(speed:\
        \ number): void;\n  setMinDistance(distance: number): void;\n  setMaxDistance(distance: number): void;\n}\n```\n\n\
        ## Orbit Behavior (native)\n- Orbit center = last clicked point on geometry (or scene center if no hit)\n\
        - Vertical orbit wraps but has soft limits to prevent flipping\n- Zoom scrolls toward the 3D point under cursor (not\
        \ just along camera forward)\n- Pan speed scales with distance from target\n- Smooth transitions between standard\
        \ views (slerp rotation, lerp position)"
  uuid: VTdUp24q
- id: shader.pbr
  kind: shader
  layer: rendering
  name: PBR Material Shader
  x:
    shader:
      type: fragment
      language: GLSL
      features: Physically-based rendering with metalness/roughness workflow, normal mapping, environment reflections, texture
        tiling, opacity/transparency
    impl:
      language: GLSL
      complexity: complex
      status: implemented
    docs:
      description: 'Custom PBR fragment shader for material rendering. Extends Three.js MeshStandardMaterial with DraftDown-specific
        features: face front/back coloring (front=material, back=blue tint), edge rendering as dark lines, support for native
        ''colored'' materials (tinted textures), and projected textures. Uses Three.js onBeforeCompile to inject custom shader
        chunks.'
  uuid: C65BEFgu
- id: shader.outline
  kind: shader
  layer: rendering
  name: Edge Outline Shader
  x:
    shader:
      type: fragment
      language: GLSL
      features: Sobel edge detection, depth-based outlines, normal-based outlines, profile edges, crease edges
    impl:
      language: GLSL
      complexity: moderate
      status: implemented
    docs:
      description: Post-processing shader for architectural edge rendering. Detects edges using depth and normal discontinuities
        (Sobel filter). Renders profile edges (silhouette), crease edges (hard edges between faces), and border edges as dark
        lines. Line weight varies by type. Essential for the DraftDown 'sketchy' aesthetic. Implemented as a Three.js EffectComposer
        pass.
    references: https://threejs.org/examples/#webgl_postprocessing_sobel
  uuid: Ec5FM5kb
- id: shader.selection
  kind: shader
  layer: rendering
  name: Selection Highlight Shader
  x:
    shader:
      type: fragment
      language: GLSL
      features: Selection glow, face highlight, edge highlight, vertex dots, hover preview
    impl:
      language: GLSL
      complexity: simple
      status: implemented
    docs:
      description: Shader for rendering selection state. Selected faces get a blue semi-transparent overlay. Selected edges
        render thicker in blue. Hover preview shows a subtle highlight. Pre-selection (inference) shows green/red/blue axis-colored
        highlights. Uses stencil buffer to avoid z-fighting.
  uuid: ZAl6LXs0
- id: shader.xray
  kind: shader
  layer: rendering
  name: X-Ray Shader
  x:
    shader:
      type: fragment
      language: GLSL
      features: Transparency, back-face visibility, ghost mode, wireframe overlay
    impl:
      language: GLSL
      complexity: simple
      status: implemented
    docs:
      description: X-Ray rendering mode shader. Makes all faces semi-transparent so the entire model structure is visible.
        Front faces are more opaque than back faces (depth-based transparency). Edges remain fully opaque. Useful for seeing
        inside complex models and verifying internal geometry.
  uuid: KcicMePc
- id: op.extrude
  kind: operation
  layer: modeling
  name: Extrude (Push/Pull)
  x:
    operation:
      type: extrude
      destructive: true
      preview: true
    perf:
      critical: true
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: Core push/pull extrusion operation — the heart of DraftDown modeling. Takes a planar face and a distance,
        creates new side faces connecting the original boundary to a translated copy.
      notes: "## Typed Interface\n\n```typescript\nimport { Operation, OperationParams, OperationResult } from '../types/operation';\n\
        import { Face, Edge, Vertex, HalfEdgeMesh } from '../geometry/mesh';\nimport { Vector3 } from '../math/types';\nimport\
        \ { SolidEngine } from '../geometry/solid';\n\nexport interface ExtrudeParams extends OperationParams {\n  face: Face;\
        \ // the face to extrude\n  distance: number; // positive = along normal, negative = against\n  direction?: Vector3;\
        \ // override face normal\n  createNewStartFace: boolean; // Ctrl mode: leave original face behind\n  autoBooleanCut:\
        \ boolean; // detect and perform boolean subtraction\n}\n\nexport interface ExtrudeResult extends OperationResult\
        \ {\n  newFaces: Face[]; // all newly created faces (sides + cap)\n  capFace: Face; // the translated copy of the\
        \ original face\n  sideFaces: Face[]; // faces connecting original boundary to cap\n  newEdges: Edge[];\n  newVertices:\
        \ Vertex[];\n  removedFaces: Face[]; // faces consumed by boolean cut\n  wasBooleanCut: boolean;\n}\n\nexport interface\
        \ ExtrudeDelta {\n  // For undo system — minimal diff to reverse this operation\n  addedVertices: { id: string; position:\
        \ Vector3 }[];\n  addedEdges: { id: string; v1: string; v2: string }[];\n  addedFaces: { id: string; loop: string[]\
        \ }[];\n  removedFaces: { id: string; loop: string[]; material: string }[];\n  movedVertices: { id: string; from:\
        \ Vector3; to: Vector3 }[];\n}\n\nexport class ExtrudeOperation implements Operation {\n  readonly id = 'op.extrude';\n\
        \  readonly type = 'extrude';\n  readonly destructive = true;\n\n  execute(mesh: HalfEdgeMesh, params: ExtrudeParams):\
        \ ExtrudeResult;\n  preview(mesh: HalfEdgeMesh, params: ExtrudeParams): ExtrudeResult; // non-destructive preview\n\
        \  undo(mesh: HalfEdgeMesh, delta: ExtrudeDelta): void;\n  redo(mesh: HalfEdgeMesh, delta: ExtrudeDelta): void;\n\n\
        \  // Internal\n  private createSideFaces(boundary: Edge[], normal: Vector3, distance: number): Face[];\n  private\
        \ cloneAndTranslateFace(face: Face, offset: Vector3): Face;\n  private mergeCoplanarFaces(mesh: HalfEdgeMesh, newFaces:\
        \ Face[]): void;\n  private detectBooleanCutNeeded(face: Face, direction: Vector3, distance: number, mesh: HalfEdgeMesh):\
        \ boolean;\n  private performBooleanCut(face: Face, distance: number, solid: SolidEngine): ExtrudeResult;\n}\n```\n\
        \n## Algorithm Detail\n1. Get ordered boundary edges of face: `face.getOuterLoop()` → `HalfEdge[]`\n2. For each boundary\
        \ vertex, create a new vertex at `vertex.position + normal * distance`\n3. For each boundary edge (v1→v2), create\
        \ a quad side face: (v1, v2, v2_new, v1_new)\n4. Create cap face from all new vertices in same winding order as original\n\
        5. Update half-edge connectivity: side face half-edges link to cap and original\n6. If `createNewStartFace`: keep\
        \ original face, else original face becomes part of the solid\n7. Run `mergeCoplanarFaces` to clean up coplanar adjacencies\n\
        8. Return delta for undo system"


  uuid: Pkot4oID
- id: op.sweep
  kind: operation
  layer: modeling
  name: Sweep
  x:
    operation:
      type: sweep
      destructive: true
      preview: true
    perf:
      critical: true
    impl:
      language: TypeScript
      complexity: very-complex
      status: basic
    docs:
      description: 'Sweep a profile face along a path of connected edges. At each path vertex, the profile is oriented perpendicular
        to the path tangent and scaled/rotated to maintain smooth transitions. Handles: open paths, closed paths (full revolution),
        acute angles, and path-profile orientation. Used for cornices, pipes, lathe operations, and complex moldings.'
  uuid: AratDxCv
- id: op.offset
  kind: operation
  layer: modeling
  name: Offset Edges
  x:
    operation:
      type: offset
      destructive: true
      preview: true
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: Create an offset copy of a face's boundary edges, inward or outward by a specified distance. Handles convex
        and concave vertices (miter vs. arc), self-intersecting offsets (clips), and multi-loop faces (faces with holes).
        Creates new edges and a new inner/outer face. Uses straight skeleton or Minkowski offset algorithm.
    references: https://en.wikipedia.org/wiki/Straight_skeleton
  uuid: 7trpP7FO
- id: op.boolean_union
  kind: operation
  layer: modeling
  name: Boolean Union
  x:
    operation:
      type: boolean
      destructive: true
      preview: true
    perf:
      critical: true
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: "CSG boolean union via ManifoldBridge. Converts region faces to indexed triangle mesh,\n          performs\
        \ union via Manifold WASM, imports result back as half-edge geometry.\n          Shared helpers: regionToManifoldMesh()\
        \ and applyManifoldResult(). Async operation.\n          Handles edge cases via Manifold's robust geometric kernel."
  uuid: mwY0P4UZ
- id: op.boolean_subtract
  kind: operation
  layer: modeling
  name: Boolean Subtract
  x:
    operation:
      type: boolean
      destructive: true
      preview: true
    perf:
      critical: true
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: "CSG boolean subtraction via ManifoldBridge. Primary solid minus tool solid.\n          Async operation\
        \ using shared regionToManifoldMesh()/applyManifoldResult() helpers.\n          Result is a watertight solid with the\
        \ tool shape removed."
  uuid: CTMzXBwQ
- id: op.boolean_intersect
  kind: operation
  layer: modeling
  name: Boolean Intersect
  x:
    operation:
      type: boolean
      destructive: true
      preview: true
    perf:
      critical: true
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: "CSG boolean intersection via ManifoldBridge. Keeps only the volume shared by\n          two solids. Async\
        \ operation using shared helpers. Useful for creating complex\n          shapes from simple primitives."
  uuid: ubWPwaAA
- id: op.intersect_faces
  kind: operation
  layer: modeling
  name: Intersect Faces
  x:
    operation:
      type: boolean
      destructive: true
      preview: false
    perf:
      critical: true
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: "Face intersection with bounding box acceleration. Three modes: model-wide,\n          selection-only, and\
        \ context. Plane-plane intersection for coplanar/parallel detection.\n          Clips intersection lines to face boundaries.\
        \ Splits faces at intersection edges.\n          Handles coplanar face merging. Creates new edges at every face-face\
        \ intersection."
  uuid: njBTb2Rp
- id: op.subdivide
  kind: operation
  layer: modeling
  name: Subdivide
  x:
    operation:
      type: subdivide
      destructive: true
      preview: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Catmull-Clark subdivision with boundary edge preservation and crease support.\n          Iterative subdivision\
        \ with configurable iteration count and face count limits.\n          Computes face points, edge points, and updated\
        \ vertex positions per the\n          Catmull-Clark algorithm. Boundary vertices use midpoint averaging."
  uuid: CYIk0NpW
- id: op.triangulate
  kind: operation
  layer: modeling
  name: Triangulate
  x:
    operation:
      type: triangulate
      destructive: true
      preview: false
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Ear-clipping triangulation with best-fit plane projection for arbitrary polygons.\n          Handles non-convex\
        \ faces, colinear vertex detection, and hole support.\n          Projects 3D polygon onto 2D using dominant normal\
        \ axis, then performs\n          ear clipping with convexity and containment checks."
  uuid: xXMBWmbl
- id: mod.array
  kind: modifier
  layer: modeling
  name: Array Modifier
  x:
    modifier:
      type: array
      stack: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Linear and radial arrays with count limits (max 1000). Material preservation\n          on cloned geometry.\
        \ Vertex merging at boundaries for seamless results.\n          Linear: count + spacing or total distance. Radial:\
        \ count + center + axis + angle."
  uuid: cr9dEi8q
- id: mod.mirror
  kind: modifier
  layer: modeling
  name: Mirror Modifier
  x:
    modifier:
      type: mirror
      stack: true
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: "Mirror geometry across a plane (X, Y, or Z axis through a point). Material\n          preservation on\
        \ mirrored faces. Plane validation and degenerate face checks.\n          Option to merge vertices at the mirror plane\
        \ for seamless models."
  uuid: sRdon4Ok
- id: mod.smooth
  kind: modifier
  layer: modeling
  name: Smooth Modifier
  x:
    modifier:
      type: smooth
      stack: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Actual Catmull-Clark subdivision for geometric smoothing with multi-pass support.\n          Crease edge\
        \ preservation, boundary handling, configurable iteration count.\n          Also supports angle-based edge softening\
        \ for smooth normals without subdivision."
  uuid: 1m0uhGig
- id: constraint.parallel
  kind: constraint
  layer: modeling
  name: Parallel Constraint
  x:
    constraint:
      type: parallel
      parametric: false
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Inference engine constraint that snaps drawing to parallel with existing edges. Shows magenta inference
        line when cursor aligns parallel to a recently referenced edge. Part of the real-time inference system, not a persistent
        parametric constraint.
  uuid: KmT7UMl4
- id: constraint.perpendicular
  kind: constraint
  layer: modeling
  name: Perpendicular Constraint
  x:
    constraint:
      type: perpendicular
      parametric: false
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Inference engine constraint that snaps drawing to perpendicular with existing edges. Shows magenta inference
        line when cursor aligns perpendicular to a recently referenced edge.
  uuid: XTB2zoYP
- id: constraint.on_axis
  kind: constraint
  layer: modeling
  name: On-Axis Constraint
  x:
    constraint:
      type: parallel
      parametric: false
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Inference engine constraint that snaps drawing to the Red (X), Green (Y), or Blue (Z) axis. Shows colored
        line matching the axis. Arrow keys can lock to a specific axis. Most fundamental inference constraint — provides the
        'DraftDown feel' of guided drawing.
  uuid: Mx6PeYve
- id: constraint.distance
  kind: constraint
  layer: modeling
  name: Distance Constraint
  x:
    constraint:
      type: distance
      parametric: false
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: VCB (Value Control Box) distance constraint. When user types a number during drawing/moving operations,
        the tool snaps to exactly that distance. Displayed in the measurements panel at the bottom of the screen.
  uuid: 7rzUNdJO
- id: constraint.snap_point
  kind: constraint
  layer: modeling
  name: Snap Point Constraint
  x:
    constraint:
      type: coincident
      parametric: false
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Inference engine point snapping. Snaps cursor to: endpoints (green dot), midpoints (cyan dot), on-edge
        (red dot), on-face (blue dot), edge intersections, axis intersections, and construction guide intersections. Priority
        system resolves conflicts when multiple snap points are near the cursor.'
  uuid: a2iANJ3J
- id: engine.geometry
  kind: geometry_engine
  layer: geometry
  name: Core Geometry Engine
  x:
    geometry:
      precision: float64
      representation: B-Rep
    solid:
      kernel: Custom
    perf:
      critical: true
      optimizations: Spatial indexing (octree) for ray intersection, edge hash map for fast topology queries, lazy face triangulation,
        incremental validation, vertex→face adjacency via getVertexFaces(), vertex→edge adjacency via getVertexEdgeIds()
      benchmarks: Face creation < 1ms, edge split < 0.5ms, face-face intersection < 5ms per pair
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: "B-Rep geometry kernel with half-edge mesh. createEdgeWithIntersection detects\n\
        \          where new edges cross ANY existing edge — loose lines included, not just\n\
        \          face boundary edges (bbox-pruned scan; loose crossings are what let\n\
        \          rectangle regions close into faces around free-standing edges) — splits\n\
        \          them at shared vertices, and uses splitFaceWithPath\n\
        \          to split faces when vertices lie on boundary edges. It heals T-junctions\n\
        \          at draw time (splitEdgesThroughVertex): an endpoint landing in the MIDDLE\n\
        \          of an existing edge splits that edge, so a line drawn across a face-less\n\
        \          loop (deleted face) closes sub-loops that auto-face can fill — without it\n\
        \          the endpoint sits on the edge unconnected and no face forms.\n\
        \          TOLERANCES: geometric welds (vertex reuse, on-segment detection, T-junction\n\
        \          healing, boundary insertion/classification) use WELD_TOL = 0.001m ABSOLUTE.\n\
        \          Interior checks use absolute margins from endpoints, never relative-t slop —\n\
        \          a 1% t-tolerance on a 4m edge welded collinear points 4cm BEYOND the corner\n\
        \          into the boundary (phantom diameter edges, duplicated host faces when a small\n\
        \          circle sat on a rect corner). createFace rejects zero-area (degenerate) rings.\n\
        \          Circle/polygon tools refuse commits whose segment chords < 3×WELD_TOL.\n\
        \          It also runs a\n\
        \          vertex-on-segment scan (bbox-pruned, scalar-math, skips protected components)\n\
        \          so a line drawn through an existing vertex is split at that vertex —\n\
        \          chain becomes v1 → V → v2 with line-through-point junctions instead of\n\
        \          a single edge that visually overlaps but topologically ignores V.\n\
        \          Auto-face BFS finds coplanar loops with hard caps to prevent exponential\n\
        \          path enumeration: maxDepth=8, maxExplore=5000 dequeues, maxLoopsFound=200\n\
        \          (real face loops are short; deg^maxDepth blew up at depth 20 on small\n\
        \          dense graphs like stair components). Coplanarity tolerance 0.05.\n\
        \          Face normals stored at creation time — tools must recompute from vertex\n\
        \          positions after transforms. Guards: no self-edges, no zero-length edges,\n\
        \          degenerate face prevention. Serialization for undo/redo snapshots.\n\
        \          IFace.generation: monotonically increasing counter bumped on face creation\n\
        \          and material assignment changes. Used by SceneBridge for dirty tracking —\n\
        \          avoids per-vertex position hashing when only material/topology changed.\n\
        \          splitFaceWithPath scans the full chain to find entry/exit points on a face\n\
        \          boundary (handles lines extending beyond face). Wrapping edge insertion uses\n\
        \          modular indexing. When inserting boundary vertices it keeps face.uvs aligned\n\
        \          with face.vertexIds via parametric lerp, so the parent's texture mapping\n\
        \          survives the split. autoCreateFaces uses loopContainsInteriorVertex — 2D\n\
        \          point-in-polygon test rejects loops enclosing subdivided geometry.\n\
        \          splitFaceAtBoundary snapshots parent materialIndex/backMaterialIndex/uvs\n\
        \          before deletion, fits an affine UV map (3-point planar barycentric) to\n\
        \          carry texture coordinates onto child faces, and fires onFaceSplit(parentId,\n\
        \          childIds) so external managers can port faceId-keyed state. The Application\n\
        \          wires onFaceSplit to MaterialManager.inheritAssignment so the actual face\n\
        \          material (keyed by faceId, NOT IFace.materialIndex) carries over.\n\
        \          Adjacency queries: getVertexFaces(vertexId) and getVertexEdgeIds(vertexId)\n\
        \          forward to HalfEdgeMesh for O(1) half-edge-walk adjacency lookups.\n\
        \          Used by SceneBridge dirty tracking to resolve affected faces/edges from\n\
        \          dirty vertex sets during move/scale/rotate operations."
      notes: "## Typed Interface\n\n```typescript\nimport { Vector3, Matrix4, Plane, BoundingBox } from '../math/types';\n\
        \n// ========== Core Geometry Types ==========\n\nexport interface GeometryId {\n  readonly id: string; // unique\
        \ stable ID (UUID)\n}\n\nexport interface Vertex extends GeometryId {\n  position: Vector3; // float64\n  edges: HalfEdge[];\
        \ // outgoing half-edges (circular linked)\n  selected: boolean;\n  hidden: boolean;\n}\n\nexport interface HalfEdge\
        \ extends GeometryId {\n  origin: Vertex; // start vertex\n  twin: HalfEdge; // opposite direction half-edge\n  next:\
        \ HalfEdge; // next half-edge in face loop\n  prev: HalfEdge; // previous half-edge in face loop\n  face: Face | null;\
        \ // face this half-edge bounds (null = boundary)\n  edge: Edge; // parent edge\n}\n\nexport interface Edge extends\
        \ GeometryId {\n  halfEdge: HalfEdge; // one of the two half-edges\n  soft: boolean; // softened (hidden but still\
        \ exists)\n  smooth: boolean; // smooth normals across this edge\n  selected: boolean;\n  hidden: boolean;\n  materialIndex:\
        \ number;\n}\n\nexport interface Face extends GeometryId {\n  outerLoop: HalfEdge; // first half-edge of outer boundary\n\
        \  innerLoops: HalfEdge[]; // first half-edge of each hole\n  normal: Vector3; // face normal (computed, cached)\n\
        \  plane: Plane; // face plane equation\n  materialIndex: number; // front material\n  backMaterialIndex: number;\
        \ // back material\n  selected: boolean;\n  hidden: boolean;\n  area: number; // cached, invalidated on change\n}\n\
        \nexport interface Loop {\n  firstHalfEdge: HalfEdge;\n  vertices(): IterableIterator<Vertex>;\n  edges(): IterableIterator<Edge>;\n\
        \  halfEdges(): IterableIterator<HalfEdge>;\n  length(): number; // number of edges in loop\n  isClosed(): boolean;\n\
        }\n\n// ========== Geometry Engine API ==========\n\nexport interface IGeometryEngine {\n  // Vertex operations\n\
        \  createVertex(position: Vector3): Vertex;\n  moveVertex(vertex: Vertex, newPosition: Vector3): void;\n  mergeVertices(v1:\
        \ Vertex, v2: Vertex, tolerance?: number): Vertex;\n  deleteVertex(vertex: Vertex): void;\n\n  // Edge operations\n\
        \  createEdge(v1: Vertex, v2: Vertex): Edge;\n  splitEdge(edge: Edge, point: Vector3): { edge1: Edge; edge2: Edge;\
        \ vertex: Vertex };\n  collapseEdge(edge: Edge): Vertex;\n  deleteEdge(edge: Edge): void;\n\n  // Face operations\n\
        \  createFace(vertices: Vertex[]): Face; // creates edges + face from ordered vertex loop\n  createFaceFromEdges(edges:\
        \ Edge[]): Face | null; // detect closed coplanar loop\n  deleteFace(face: Face): void;\n  splitFace(face: Face, v1:\
        \ Vertex, v2: Vertex): { face1: Face; face2: Face; edge: Edge };\n  triangulateFace(face: Face): Face[];\n\n  // Topology\
        \ queries\n  getAdjacentFaces(face: Face): Face[];\n  getVertexFaces(vertex: Vertex): Face[];\n  getEdgeFaces(edge:\
        \ Edge): [Face | null, Face | null];\n  getConnectedComponent(entity: Vertex | Edge | Face): Set<Face>;\n  isManifold(faces:\
        \ Face[]): boolean;\n  isWatertight(faces: Face[]): boolean;\n\n  // Spatial queries\n  raycast(origin: Vector3, direction:\
        \ Vector3): RaycastHit[];\n  pointInFace(point: Vector3, face: Face): boolean;\n  closestPointOnEdge(point: Vector3,\
        \ edge: Edge): { point: Vector3; t: number };\n  faceFaceIntersection(f1: Face, f2: Face): Vector3[] | null;\n  edgeFaceIntersection(edge:\
        \ Edge, face: Face): Vector3 | null;\n\n  // Validation\n  validate(): ValidationResult;\n  healTJunctions(tolerance:\
        \ number): number; // returns count of healed\n  computeFaceNormal(face: Face): Vector3;\n}\n\nexport interface RaycastHit\
        \ {\n  entity: Vertex | Edge | Face;\n  point: Vector3;\n  distance: number;\n  normal: Vector3;\n  faceIndex?: number;\n\
        }\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: ValidationError[];\n}\n\nexport interface ValidationError\
        \ {\n  type: 'non-planar-face' | 'degenerate-edge' | 'duplicate-vertex' | 'broken-topology' | 'inconsistent-normal';\n\
        \  entities: GeometryId[];\n  message: string;\n}\n```\n\n## Performance Notes\n- All topology queries must be O(1)\
        \ via half-edge traversal\n- Spatial queries use an octree (rebuilt lazily on geometry change)\n- Face normals and\
        \ areas are cached with dirty flags\n- Vertex positions use Float64Array for precision\n- Entity IDs are stable across\
        \ undo/redo (never reused)"
      references: https://en.wikipedia.org/wiki/Boundary_representation, https://en.wikipedia.org/wiki/Doubly_connected_edge_list
    references: https://en.wikipedia.org/wiki/Boundary_representation, https://en.wikipedia.org/wiki/Doubly_connected_edge_list
  uuid: 9eEZxKvS
- id: mesh.halfedge
  kind: mesh
  layer: geometry
  name: Half-Edge Mesh
  x:
    mesh:
      structure: half-edge
      attributes: position, normal, uv, color, materialIndex, selected, hidden, soft, smooth
      lod: false
    geometry:
      precision: float64
      topology: non-manifold
      representation: mesh
    perf:
      critical: true
      optimizations: Indexed vertex buffer for GPU upload, lazy normal recomputation, dirty flag system for incremental updates,
        pooled object allocation, vertex→face adjacency via getVertexFaces() (half-edge walk with fallback scan),
        vertex→edge adjacency via getVertexEdgeIds() (half-edge walk with fallback scan)
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: "Primary mesh data structure using half-edge (DCEL) representation. Each edge is stored as two half-edges\n\
        \        pointing in opposite directions, each belonging to a face.\n\
        \        getVertexFaces(vertexId): walks vertexToHalfEdges map to collect unique face IDs in O(degree).\n\
        \        Fallback linear scan for bulk-imported meshes without full half-edge topology.\n\
        \        getVertexEdgeIds(vertexId): walks half-edges to collect edge IDs, plus fallback edge map scan.\n\
        \        Both methods used by SceneBridge for targeted dirty sync — only iterate faces/edges\n\
        \        adjacent to moved vertices instead of the full mesh."
      notes: "## Typed Interface\n\n```typescript\nimport { Vertex, Edge, HalfEdge, Face, Loop, GeometryId } from '../geometry/types';\n\
        import { Vector3, BoundingBox } from '../math/types';\nimport { Octree } from '../spatial/octree';\n\nexport interface\
        \ HalfEdgeMeshStats {\n  vertexCount: number;\n  edgeCount: number;\n  faceCount: number;\n  halfEdgeCount: number;\n\
        \  triangleCount: number; // after triangulation (for GPU)\n  boundaryEdgeCount: number; // edges with only one face\n\
        \  isManifold: boolean;\n  isWatertight: boolean;\n  eulerCharacteristic: number; // V - E + F\n}\n\nexport interface\
        \ GPUBufferData {\n  positions: Float32Array; // vec3 per vertex\n  normals: Float32Array; // vec3 per vertex\n  uvs:\
        \ Float32Array; // vec2 per vertex\n  colors: Float32Array; // vec4 per vertex (material color)\n  indices: Uint32Array;\
        \ // triangle indices\n  edgePositions: Float32Array; // line segment positions for edge rendering\n  edgeColors:\
        \ Float32Array; // per-edge colors (axis colors, selection)\n  selectedFaceIndices: Uint32Array; // triangle indices\
        \ of selected faces\n  selectedEdgePositions: Float32Array; // line positions of selected edges\n}\n\nexport class\
        \ HalfEdgeMesh {\n  // Storage\n  private vertices: Map<string, Vertex>;\n  private edges: Map<string, Edge>;\n  private\
        \ halfEdges: Map<string, HalfEdge>;\n  private faces: Map<string, Face>;\n  private spatialIndex: Octree;\n  private\
        \ gpuBuffersDirty: boolean;\n  private cachedGPUBuffers: GPUBufferData | null;\n\n  // CRUD\n  addVertex(position:\
        \ Vector3): Vertex;\n  addEdge(v1: Vertex, v2: Vertex): Edge;\n  addFace(vertexLoop: Vertex[], innerLoops?: Vertex[][]):\
        \ Face;\n  removeVertex(vertex: Vertex): void;\n  removeEdge(edge: Edge): void;\n  removeFace(face: Face): void;\n\
        \n  // Queries\n  getVertex(id: string): Vertex | undefined;\n  getEdge(id: string): Edge | undefined;\n  getFace(id:\
        \ string): Face | undefined;\n  getAllVertices(): IterableIterator<Vertex>;\n  getAllEdges(): IterableIterator<Edge>;\n\
        \  getAllFaces(): IterableIterator<Face>;\n  getStats(): HalfEdgeMeshStats;\n  getBoundingBox(): BoundingBox;\n\n\
        \  // Topology traversal\n  vertexEdges(vertex: Vertex): Edge[];\n  vertexFaces(vertex: Vertex): Face[];\n  edgeFaces(edge:\
        \ Edge): [Face | null, Face | null];\n  faceBoundary(face: Face): Edge[];\n  faceVertices(face: Face): Vertex[];\n\
        \  adjacentFaces(face: Face): Face[];\n\n  // GPU buffer generation\n  getGPUBuffers(): GPUBufferData; // lazy triangulation\
        \ + buffer generation\n  invalidateGPUBuffers(): void;\n\n  // Serialization (for undo/redo copy-on-write)\n  snapshot():\
        \ MeshSnapshot;\n  restoreFromSnapshot(snapshot: MeshSnapshot): void;\n  computeDelta(before: MeshSnapshot, after:\
        \ MeshSnapshot): MeshDelta;\n  applyDelta(delta: MeshDelta): void;\n  reverseDelta(delta: MeshDelta): MeshDelta;\n\
        }\n\nexport interface MeshSnapshot {\n  vertices: Map<string, { position: Float64Array }>;\n  edges: Map<string, {\
        \ v1: string; v2: string; soft: boolean; smooth: boolean }>;\n  faces: Map<string, { outerLoop: string[]; innerLoops:\
        \ string[][]; materialIndex: number }>;\n}\n\nexport interface MeshDelta {\n  addedVertices: Map<string, { position:\
        \ Float64Array }>;\n  removedVertices: Set<string>;\n  movedVertices: Map<string, { from: Float64Array; to: Float64Array\
        \ }>;\n  addedEdges: Map<string, { v1: string; v2: string }>;\n  removedEdges: Set<string>;\n  addedFaces: Map<string,\
        \ { outerLoop: string[]; materialIndex: number }>;\n  removedFaces: Map<string, { outerLoop: string[]; materialIndex:\
        \ number }>;\n}\n```\n\n## GPU Buffer Generation\nLazy triangulation: only re-triangulate dirty faces. Use ear-clipping\
        \ for simple convex faces, constrained Delaunay for complex/concave/holed faces. Output indexed triangle buffer +\
        \ separate line buffer for edge rendering."
      references: https://en.wikipedia.org/wiki/Doubly_connected_edge_list
    references: https://en.wikipedia.org/wiki/Doubly_connected_edge_list
  uuid: 6s5Lzex1
- id: solid.manifold
  kind: solid
  layer: geometry
  name: Manifold Solid Engine
  x:
    solid:
      kernel: Manifold
      booleanOps: true
    geometry:
      precision: float64
      topology: manifold
      representation: CSG
    perf:
      critical: true
      optimizations: Manifold library compiled to WASM for near-native boolean performance, parallel face classification
      benchmarks: Boolean union of two 10K-face solids < 100ms
    impl:
      language: TypeScript
      complexity: complex
      status: basic
    docs:
      description: 'Solid modeling engine using the Manifold library (compiled to WebAssembly) for robust CSG boolean operations.
        Converts DraftDown B-Rep geometry to Manifold''s mesh format for boolean operations, then converts back. Handles:
        union, subtraction, intersection, and minkowski sum. Used for Solid Tools and Push/Pull into existing geometry. Validates
        that input geometry is a proper 2-manifold (watertight) before operations.'
    references: https://github.com/elalish/manifold
  uuid: TECynygY
- id: curve.polyline
  kind: curve
  layer: geometry
  name: Polyline Curve
  x:
    curve:
      type: polyline
      degree: 1
      closed: false
    geometry:
      precision: float64
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: "Full polyline implementation with parametric evaluation, split at parameter,\n          simplify (Ramer-Douglas-Peucker\
        \ algorithm), subdivide, closest point computation,\n          bounding box, reverse, and JSON serialization. Supports\
        \ both open and closed polylines.\n          Used as the base curve type — circles and arcs are segmented polylines."
  uuid: Hog7HfrU
- id: curve.arc
  kind: curve
  layer: geometry
  name: Arc Curve
  x:
    curve:
      type: arc
      closed: false
    geometry:
      precision: float64
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Circular arc curve. Stores: center, normal, radius, start angle, end angle, segment count. Generates polyline
        approximation with configurable segment count (default 12 for arcs, 24 for full circles). Maintains parametric definition
        so arcs can be recognized and re-segmented. Tangent computation for Sweep and inference engine.'
  uuid: pwXXwKDt
- id: data.scene
  kind: scene_manager
  layer: data
  name: Scene Manager
  x:
    scene:
      hierarchy: tree
      layers: true
      groups: true
      components: true
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: >-
        Manages the hierarchical scene graph. Root contains loose geometry, groups, and component instances.
        Component system: createComponent(name, entityIds) groups face/edge IDs into a selectable unit.
        Components support nested editing — getEntityComponent() returns innermost non-editing component.
        isEntityProtected() and isEntityEditable() enforce component boundaries.
        enterComponent()/exitComponent() toggle editing mode with editingComponentId state.
      notes: "## Typed Interface\n\n```typescript\nimport { HalfEdgeMesh } from '../geometry/mesh';\nimport { Matrix4, Vector3\
        \ } from '../math/types';\nimport { Material } from '../data/materials';\n\n// ========== Scene Graph Types ==========\n\
        \nexport type EntityType = 'vertex' | 'edge' | 'face' | 'group' | 'component_instance' | 'component_definition' |\
        \ 'guide_line' | 'guide_point' | 'dimension' | 'text' | 'section_plane' | 'image';\n\nexport interface Entity {\n\
        \  readonly id: string;\n  readonly type: EntityType;\n  name: string;\n  layer: Layer;\n  visible: boolean;\n  locked:\
        \ boolean;\n  parentGroup: Group | null;\n}\n\nexport interface Group extends Entity {\n  type: 'group';\n  transform:\
        \ Matrix4; // local-to-parent transform\n  mesh: HalfEdgeMesh; // geometry in local coords\n  children: Entity[];\
        \ // nested groups/instances\n}\n\nexport interface ComponentDefinition {\n  readonly id: string;\n  name: string;\n\
        \  description: string;\n  mesh: HalfEdgeMesh; // prototype geometry\n  instances: ComponentInstance[];\n  thumbnail:\
        \ ImageBitmap | null;\n}\n\nexport interface ComponentInstance extends Entity {\n  type: 'component_instance';\n \
        \ definition: ComponentDefinition;\n  transform: Matrix4; // local-to-parent transform\n  // geometry comes from definition.mesh\
        \ — all instances share it\n}\n\nexport interface Layer {\n  readonly id: string;\n  name: string;\n  visible: boolean;\n\
        \  locked: boolean;\n  color: string; // for color-by-layer mode\n  isDefault: boolean;\n}\n\nexport interface ScenePage\
        \ {\n  readonly id: string;\n  name: string;\n  cameraPosition: Vector3;\n  cameraTarget: Vector3;\n  cameraFov: number;\n\
        \  cameraProjection: 'perspective' | 'orthographic';\n  layerVisibility: Map<string, boolean>;\n  activeSectionPlanes:\
        \ string[];\n  renderMode: string;\n}\n\nexport interface EditingContext {\n  path: Group[]; // stack of groups we've\
        \ entered\n  currentGroup: Group | null; // null = editing root\n  activeEntities: Set<string>; // IDs of entities\
        \ in current context (editable)\n}\n\n// ========== Scene Manager API ==========\n\nexport interface ISceneManager\
        \ {\n  // Scene graph\n  readonly root: Group; // root group containing all top-level entities\n  readonly editingContext:\
        \ EditingContext;\n\n  // Entity management\n  addEntity(entity: Entity, parent?: Group): void;\n  removeEntity(entity:\
        \ Entity): void;\n  moveEntity(entity: Entity, newParent: Group): void;\n  getEntity(id: string): Entity | undefined;\n\
        \  getAllEntities(): Entity[];\n  findEntitiesByType(type: EntityType): Entity[];\n\n  // Groups\n  createGroup(entities:\
        \ Entity[]): Group;\n  explodeGroup(group: Group): Entity[];\n  enterEditingContext(group: Group): void;\n  exitEditingContext():\
        \ void;\n\n  // Components\n  createComponentDefinition(group: Group, name: string): ComponentDefinition;\n  placeComponentInstance(definition:\
        \ ComponentDefinition, transform: Matrix4): ComponentInstance;\n  makeUnique(instance: ComponentInstance): ComponentDefinition;\n\
        \n  // Layers\n  createLayer(name: string): Layer;\n  deleteLayer(layer: Layer): void;\n  assignLayer(entity: Entity,\
        \ layer: Layer): void;\n  getActiveLayer(): Layer;\n  setActiveLayer(layer: Layer): void;\n  getLayers(): Layer[];\n\
        \n  // Scene Pages\n  createPage(name: string): ScenePage;\n  deletePage(page: ScenePage): void;\n  activatePage(page:\
        \ ScenePage): void;\n  getPages(): ScenePage[];\n\n  // Events\n  on(event: 'entity-added' | 'entity-removed' | 'entity-changed'\
        \ | 'layer-changed' | 'context-changed', handler: (data: any) => void): void;\n  off(event: string, handler: Function):\
        \ void;\n}\n```\n\n## Editing Context\nWhen the user double-clicks a group/component, we \"enter\" it — only its entities\
        \ are editable, everything else renders semi-transparent. The context stack allows nested group editing. Exiting pops\
        \ the stack."
  uuid: A2js2ESA
- id: data.selection
  kind: selection
  layer: data
  name: Selection Manager
  x:
    selection:
      mode: object
      multi: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Manages current selection state. Supports selection of vertices, edges, faces, groups, component instances.
      notes: "## Typed Interface\n\n```typescript\nimport { Entity, EntityType } from '../data/scene';\nimport { Vertex, Edge,\
        \ Face } from '../geometry/mesh';\nimport { Rect2D } from '../math/types';\n\nexport type SelectableEntity = Vertex\
        \ | Edge | Face | Entity;\n\nexport type SelectionMode = 'object' | 'face' | 'edge' | 'vertex';\n\nexport interface\
        \ SelectionState {\n  mode: SelectionMode;\n  entities: Set<string>; // selected entity IDs\n  preselection: string\
        \ | null; // hovered entity ID (for highlight)\n}\n\nexport interface SelectionChangeEvent {\n  added: SelectableEntity[];\n\
        \  removed: SelectableEntity[];\n  mode: SelectionMode;\n  source: 'click' | 'box' | 'api' | 'outliner';\n}\n\nexport\
        \ interface ISelectionManager {\n  // State\n  readonly state: Readonly<SelectionState>;\n  readonly isEmpty: boolean;\n\
        \  readonly count: number;\n\n  // Selection operations\n  select(entity: SelectableEntity): void; // replace selection\n\
        \  add(entity: SelectableEntity): void; // add to selection\n  remove(entity: SelectableEntity): void; // remove from\
        \ selection\n  toggle(entity: SelectableEntity): void; // toggle in/out\n  selectAll(): void; // select all in current\
        \ editing context\n  clear(): void;\n  selectConnected(entity: SelectableEntity): void; // select all connected geometry\n\
        \n  // Box selection\n  selectInBox(rect: Rect2D, mode: 'window' | 'crossing'): void;\n\n  // Queries\n  isSelected(entity:\
        \ SelectableEntity): boolean;\n  getSelected(): SelectableEntity[];\n  getSelectedByType<T extends SelectableEntity>(type:\
        \ EntityType): T[];\n  getSelectedFaces(): Face[];\n  getSelectedEdges(): Edge[];\n  getSelectedVertices(): Vertex[];\n\
        \n  // Pre-selection (hover)\n  setPreselection(entity: SelectableEntity | null): void;\n  getPreselection(): SelectableEntity\
        \ | null;\n\n  // Mode\n  setMode(mode: SelectionMode): void;\n  getMode(): SelectionMode;\n\n  // Events\n  on(event:\
        \ 'selection-changed', handler: (e: SelectionChangeEvent) => void): void;\n  on(event: 'preselection-changed', handler:\
        \ (entity: SelectableEntity | null) => void): void;\n  off(event: string, handler: Function): void;\n}\n```\n\n##\
        \ Selection Rules\n- In `object` mode: clicking a face selects its parent group/component (if any), or the face if\
        \ loose\n- In `face`/`edge`/`vertex` mode: clicking selects the sub-element directly\n- Selection is scoped to the\
        \ current editing context\n- Exiting an editing context clears sub-selections\n- Selection changes emit events consumed\
        \ by Entity Info panel, Outliner, and renderer (highlight)"
  uuid: vjsYHMBn
- id: data.history
  kind: history
  layer: data
  name: Undo/Redo Manager
  x:
    history:
      maxSteps: 100
      persistent: false
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: Delta-based undo/redo system. Each transaction records only what changed (add/delete/modify
        deltas on mesh entity maps and material face assignments) rather than serializing the full geometry state.
        TrackedMap subclasses intercept mutations on vertices, edges, faces, halfEdges, and faceAssignments.
        Undo applies inverse deltas in reverse order; redo applies forward deltas. O(1) begin/commit for most
        operations. Move/rotate/scale tools use snapshotVertices() for direct position mutations. ModelDocument
        re-wires setTrackedSources() after any geometry.deserialize() call that replaces the internal mesh.
        Dimension undo/redo via DimensionDelta snapshots (serializable, no Three.js objects) — setDimensionHandlers()
        registers getSnapshot/onRestore callbacks. Guide line undo/redo via GuideLineDelta — setGuideLineHandler()
        registers add/remove callback. Both are stored on DeltaTransaction and applied during undo/redo.
      notes: "## Key Files\n- `DeltaRecorder.ts` — DeltaOp type, DeltaRecorder class, GuideLineDelta interface,\
        \ entity clone helpers\n\
        - `TrackedMap.ts` — Map subclass that intercepts get/set/delete/iteration to capture deltas\n- `HistoryManager.ts`\
        \ — Transaction lifecycle, applyInverse/applyForward, vertex snapshots, DimensionDelta interface,\
        \ dimension/guide line snapshot and restore callbacks\n\n## Design Decisions\n- **Delta-based**:\
        \ Each transaction stores only changed entities (~KB), not full mesh snapshots (~57MB for large models).\n\
        - **TrackedMap instrumentation**: Intercepts set(), delete(), get(), forEach(), entries(), values(),\
        \ and [Symbol.iterator]() to capture before-snapshots on first access during a transaction.\n- **Deferred\
        \ flush**: Add deltas are deferred to flushDeltas() at commit time to capture final entity state after\
        \ in-place mutations (e.g., half-edge next/prev linking).\n- **Direct mutation support**: Move/rotate/scale\
        \ tools write v.position.x/y/z directly; snapshotVertices() captures before-state, commit diffs against\
        \ current.\n- **Lookup rebuild**: vertexToHalfEdges and edgeToHalfEdges are derived state, rebuilt via\
        \ rebuildLookups() after undo/redo.\n- **Bulk import bypass**: bulkAdd() uses Map.prototype.set to skip\
        \ recording during file import.\n- **Transaction grouping**: Complex operations wrapped in single transaction.\n\
        - **Redo invalidation**: New action after undo clears redo stack.\n- **Max steps**: Default 100 transactions."
  uuid: sF6Q1SXe
- id: file.native
  kind: file_format
  layer: data
  name: DraftDown Native Format (.scf)
  x:
    file:
      format: SKP
      direction: both
      options: '{"compressed": true, "includeTextures": true, "version": "1.0"}'
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: 'Native file format for DraftDown (.scf). Binary format with sections: header (version, checksum), geometry
        (vertices, edges, faces in B-Rep), materials (definitions + embedded textures), scene structure (groups, components,
        layers), metadata (scenes/pages, camera positions, styles). Uses zlib compression. Supports incremental save (only
        changed sections rewritten). File extension: .scf. Note: uses SKP enum as closest match — this is a custom binary
        format inspired by SKP structure.'
  uuid: GmIenGm4
- id: file.obj
  kind: file_format
  layer: data
  name: OBJ Format
  x:
    file:
      format: OBJ
      direction: both
      options: '{"includeNormals": true, "includeMaterials": true, "triangulate": false}'
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Wavefront OBJ import/export. Import: reads vertices, normals, UVs, faces, material references (.mtl).
        Export: writes geometry with material assignments. Handles groups as OBJ groups. Supports n-gon faces (no forced triangulation).
        Material file (.mtl) maps to DraftDown PBR materials.'
  uuid: fsFhJEJy
- id: file.stl
  kind: file_format
  layer: data
  name: STL Format
  x:
    file:
      format: STL
      direction: both
      options: '{"binary": true, "checkManifold": true}'
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: 'STL import/export for 3D printing. Import: reads binary/ASCII STL into triangle mesh. Export: triangulates
        all faces and writes binary STL. Validates manifold/watertight for 3D printing. Reports volume, surface area, and
        potential printing issues.'
  uuid: Vu0C2xyU
- id: file.gltf
  kind: file_format
  layer: data
  name: glTF Format
  x:
    file:
      format: GLTF
      direction: both
      options: '{"binary": true, "embedTextures": true, "draco": false}'
    impl:
      language: TypeScript
      complexity: moderate
      status: basic
    docs:
      description: 'glTF 2.0 import/export. The ''JPEG of 3D'' — excellent for sharing and web viewing. Import: reads geometry,
        materials (PBR metalness/roughness), textures, scene hierarchy. Export: writes .glb (binary) or .gltf + .bin + textures.
        Supports Draco mesh compression option. Maps DraftDown PBR materials to glTF PBR materials.'
  uuid: 5CEAe10D
- id: file.dxf
  kind: file_format
  layer: data
  name: DXF Format
  x:
    file:
      format: DXF
      direction: both
    impl:
      language: TypeScript
      complexity: moderate
      status: basic
    docs:
      description: 'AutoCAD DXF import/export for CAD interoperability. Import: reads 2D/3D entities (lines, arcs, circles,
        polylines, 3D faces, blocks). Export: writes edges as LINE entities, faces as 3DFACE entities, groups as BLOCKs. Handles
        unit conversion and coordinate system differences.'
  uuid: J9iodp3B
- id: file.step
  kind: file_format
  layer: data
  name: STEP Format
  x:
    file:
      format: STEP
      direction: import
    impl:
      language: TypeScript
      complexity: complex
      status: stub
    docs:
      description: STEP file import for mechanical CAD interoperability. Uses OpenCascade (via native module) to parse STEP
        files and convert B-Rep solids to DraftDown mesh geometry. Handles assemblies, part hierarchy, and material colors.
        Import-only due to DraftDown's mesh-based (not NURBS-based) internal representation.
  uuid: INzz62YY
- id: datastore.filesystem
  kind: datastore
  layer: data
  name: Local File System
  x:
    data:
      storage: File System
      schema: Project files (.scf), texture images (PNG/JPG), material libraries (.json), component libraries (.scf), preferences
        (user-data/preferences.json), recent files list
    docs:
      description: Local file system storage managed by the Electron main process. Project files saved to user-chosen locations.
        App data (preferences, recent files, material/component libraries) stored in Electron's app.getPath('userData'). Texture
        files stored alongside or embedded in project files. Auto-save to temp directory every 5 minutes.
    impl:
      status: implemented
  uuid: 5PAU2N3O
- id: datastore.localstorage
  kind: datastore
  layer: data
  name: Browser localStorage
  x:
    data:
      storage: Browser localStorage
      schema: '{"draftdown:plugin-src:<id>": "string (JS source)", "draftdown:ext-enabled:<id>": "0 | 1", "draftdown:default:<section>:<key>": "JSON"}'
    docs:
      description: Renderer-side persistent key-value store. Used by the Plugin System to cache installed plugin
        sources (so they reload on next launch), persist explicit Enable/Disable choices that override the plugin's
        loadOnStart flag, and back `DraftDown.read_default` / `DraftDown.write_default` extension preferences.
    impl:
      status: implemented
  uuid: dLclStrCm
- id: datastore.preferences
  kind: datastore
  layer: data
  name: Preferences Store
  x:
    data:
      storage: File System
      schema: '{"units": "mm|cm|m|inches|feet", "gridSpacing": "number", "snapEnabled": "boolean", "autoSaveInterval": "number",
        "theme": "light|dark", "shortcuts": "Map<string,string>", "recentFiles": "string[]", "defaultTemplate": "string"}'
    docs:
      description: 'JSON-based preferences storage. Stored in app userData directory. Includes: measurement units, grid settings,
        snap settings, auto-save interval, UI theme, custom keyboard shortcuts, recent files list, default template path,
        rendering quality settings.'
    impl:
      status: implemented
  uuid: d2rK1WcP
- id: process.main
  kind: main_process
  layer: system
  name: Electron Main Process
  x:
    electron:
      processType: main
    impl:
      language: TypeScript
      framework: Electron
      complexity: complex
      status: implemented
    docs:
      description: Electron main process — the Node.js backend of the application.
      notes: "## Typed Interface\n\n```typescript\nimport { app, BrowserWindow, ipcMain, dialog, Menu } from 'electron';\n\
        \n// ========== IPC Channel Contracts ==========\n\n/** Channels: renderer → main (invoke/send) */\nexport interface\
        \ MainProcessAPI {\n  // File operations\n  'file:open': () => Promise<{ filePath: string; data: ArrayBuffer } | null>;\n\
        \  'file:save': (args: { filePath: string; data: ArrayBuffer }) => Promise<boolean>;\n  'file:save-as': (args: { data:\
        \ ArrayBuffer; defaultName: string }) => Promise<{ filePath: string } | null>;\n  'file:export': (args: { data: ArrayBuffer;\
        \ format: string; defaultName: string }) => Promise<{ filePath: string } | null>;\n  'file:import': (args: { formats:\
        \ string[] }) => Promise<{ filePath: string; data: ArrayBuffer; format: string } | null>;\n  'file:read': (args: {\
        \ filePath: string }) => Promise<ArrayBuffer>;\n  'file:write': (args: { filePath: string; data: ArrayBuffer }) =>\
        \ Promise<boolean>;\n  'file:get-recent': () => Promise<string[]>;\n  'file:add-recent': (args: { filePath: string\
        \ }) => Promise<void>;\n\n  // Preferences\n  'prefs:get': () => Promise<UserPreferences>;\n  'prefs:set': (args:\
        \ Partial<UserPreferences>) => Promise<void>;\n\n  // Native modules\n  'native:boolean': (args: { op: 'union' | 'subtract'\
        \ | 'intersect'; meshA: ArrayBuffer; meshB: ArrayBuffer }) => Promise<ArrayBuffer>;\n  'native:step-import': (args:\
        \ { data: ArrayBuffer }) => Promise<ArrayBuffer>;\n\n  // App\n  'app:get-version': () => Promise<string>;\n  'app:get-user-data-path':\
        \ () => Promise<string>;\n  'app:quit': () => Promise<void>;\n}\n\n/** Channels: main → renderer (send) */\nexport\
        \ interface RendererEvents {\n  'menu:action': { action: MenuAction };\n  'file:auto-save-tick': {};\n  'app:before-quit':\
        \ {};\n}\n\nexport type MenuAction =\n  | 'new' | 'open' | 'save' | 'save-as'\n  | 'undo' | 'redo'\n  | 'cut' | 'copy'\
        \ | 'paste' | 'delete' | 'select-all'\n  | 'zoom-extents' | 'zoom-window'\n  | 'preferences' | 'about';\n\nexport\
        \ interface UserPreferences {\n  units: 'mm' | 'cm' | 'm' | 'inches' | 'feet';\n  gridSpacing: number;\n  snapEnabled:\
        \ boolean;\n  autoSaveInterval: number; // ms\n  theme: 'light' | 'dark';\n  shortcuts: Record<string, string>;\n\
        \  recentFiles: string[];\n  defaultTemplate: string;\n  renderQuality: 'low' | 'medium' | 'high';\n}\n```\n\n## Preload\
        \ Script\nUses `contextBridge.exposeInMainWorld()` to expose a typed `window.api` object:\n```typescript\n// preload.ts\n\
        contextBridge.exposeInMainWorld('api', {\n  invoke: <K extends keyof MainProcessAPI>(channel: K, ...args: Parameters<MainProcessAPI[K]>)\
        \ =>\n    ipcRenderer.invoke(channel, ...args),\n  on: <K extends keyof RendererEvents>(channel: K, handler: (data:\
        \ RendererEvents[K]) => void) =>\n    ipcRenderer.on(channel, (_, data) => handler(data)),\n});\n```\n\n## Security\n\
        - `contextIsolation: true` — renderer cannot access Node.js directly\n- `nodeIntegration: false` — no `require()`\
        \ in renderer\n- All file system access goes through IPC\n- Native modules loaded only in main process"
  uuid: ZOA1mLbr
- id: process.renderer
  kind: renderer_process
  layer: system
  name: Main Renderer Process
  x:
    electron:
      processType: renderer
      devTools: true
    impl:
      language: TypeScript
      framework: React
      complexity: complex
      status: implemented
    docs:
      description: >-
        Electron renderer process for the main window. Runs React UI, Three.js viewport, tool system, and all data
        managers. syncSelection() expands component IDs to member face/edge IDs for highlight rendering,
        extracts both batched faces (extractFromBatch) and batched edges (extractEdgeFromBatch) when a
        component is selected so individual entities can be moved/edited.
        syncScene(dirtyVertexIds?) accepts optional dirty vertex IDs from tools — forwards to
        SceneBridge.markVerticesDirty() for targeted sync. Tools (move, scale, rotate, offset) set
        _dirtyVertexIds after mutating vertex positions; ViewportCanvas reads and passes them through
        on liveSyncOnMove and syncAfterAction callbacks.
      notes: "## Typed Interface\n\n```typescript\nimport { MainProcessAPI, RendererEvents } from '../system/main-process';\n\
        import { IModelDocument } from '../data/document';\nimport { IRenderer } from '../rendering/renderer';\nimport { ICameraController\
        \ } from '../rendering/camera';\nimport { IInferenceEngine } from '../geometry/inference';\nimport { ITool } from\
        \ '../types/tool';\n\n/** Global API exposed via preload script */\ndeclare global {\n  interface Window {\n    api:\
        \ {\n      invoke<K extends keyof MainProcessAPI>(channel: K, ...args: Parameters<MainProcessAPI[K]>): ReturnType<MainProcessAPI[K]>;\n\
        \      on<K extends keyof RendererEvents>(channel: K, handler: (data: RendererEvents[K]) => void): void;\n      off<K\
        \ extends keyof RendererEvents>(channel: K, handler: Function): void;\n    };\n  }\n}\n\n/** Application singleton\
        \ — bootstrapped in renderer entry point */\nexport interface IApplication {\n  // Core subsystems\n  readonly document:\
        \ IModelDocument;\n  readonly renderer: IRenderer;\n  readonly camera: ICameraController;\n  readonly inference: IInferenceEngine;\n\
        \  readonly toolManager: IToolManager;\n\n  // Lifecycle\n  initialize(canvas: HTMLCanvasElement): Promise<void>;\n\
        \  dispose(): void;\n\n  // Document operations\n  newDocument(): Promise<void>;\n  openDocument(): Promise<void>;\n\
        \  saveDocument(): Promise<void>;\n  saveDocumentAs(): Promise<void>;\n  importFile(): Promise<void>;\n  exportFile(format:\
        \ string): Promise<void>;\n\n  // Tool management\n  activateTool(toolId: string): void;\n  getActiveTool(): ITool\
        \ | null;\n  getAvailableTools(): ITool[];\n}\n\nexport interface IToolManager {\n  registerTool(tool: ITool): void;\n\
        \  unregisterTool(toolId: string): void;\n  activateTool(toolId: string): void;\n  deactivateTool(): void;\n  getActiveTool():\
        \ ITool | null;\n  getTool(toolId: string): ITool | undefined;\n  getAllTools(): ITool[];\n  on(event: 'tool-changed',\
        \ handler: (tool: ITool | null) => void): void;\n}\n```\n\n## Bootstrap Sequence\n1. `window.api` available from preload\n\
        2. Create React root and mount `<App />`\n3. Initialize IModelDocument (new or from file)\n4. Initialize IRenderer\
        \ (Three.js on canvas)\n5. Initialize ICameraController\n6. Initialize IInferenceEngine\n7. Register all tools with\
        \ IToolManager\n8. Start render loop\n9. Listen for `menu:action` events from main process"
  uuid: pqtkBdp1
- id: web.platform
  kind: renderer_process
  layer: system
  name: Web Build Target
  x:
    impl:
      language: TypeScript
      framework: React + Three.js
      complexity: moderate
      status: implemented
    docs:
      description: "Browser-based build of DraftDown. Uses the same React UI, geometry engine, tools,\n\
        \        and Three.js renderer as the Electron version. WebPlatformBridge implements the WindowAPI\n\
        \        interface using browser APIs (File System Access API, localStorage, fetch) so existing\n\
        \        code runs unchanged. WebMenuBar replaces Electron native menus. Build via webpack.web.config.js\n\
        \        producing a static site (HTML + JS). Excluded features: SKP import (native binary),\n\
        \        auto-update, native menus, filesystem paths. 2.8 MB JS bundle.\n\
        \        Entry: src/web/index.tsx. Bridge: src/web/WebPlatformBridge.ts.\n\
        \        Build: npm run build:web. Dev: npm run dev:web (port 3001)."
  uuid: wPltWeb1
- id: web.menubar
  kind: ui_component
  layer: ui
  name: Web Menu Bar
  x:
    impl:
      language: TypeScript
      framework: React
      status: implemented
    docs:
      description: "Browser menu bar replacing Electron native menus. Renders File, Edit, View, Tools, and Help\n\
        \        menus with full parity to the Electron version. Dispatches menu:action events through\n\
        \        WebPlatformBridge.emit(). Platform-adaptive keyboard shortcuts (Cmd on Mac, Ctrl on Windows).\n\
        \        File: src/web/WebMenuBar.tsx."
  uuid: wMenuBar1
- id: web.deploy
  kind: build_pipeline
  layer: system
  name: Web Deployment
  x:
    impl:
      status: implemented
    docs:
      description: "Static web build deployed to draftdownapp.com. Built with webpack.web.config.js\n\
        \        producing dist/web/ with content-hashed JS bundle. Deployed to S3 + CloudFront.\n\
        \        Platform env var PLATFORM=web set via DefinePlugin. Native modules (manifold-3d,\n\
        \        opencascade.js) stubbed as empty objects for browser compatibility."
  uuid: wDeploy1
- id: build.electron
  kind: build_pipeline
  layer: system
  name: Electron Binary Builds
  x:
    impl:
      status: implemented
    docs:
      description: "Desktop binary builds using electron-builder. Targets:\n\
        \        - macOS: DMG for x64 and arm64, signed and notarized (Apple Developer ID)\n\
        \        - Windows: NSIS installer for x64\n\
        \        - Linux: AppImage for x64\n\
        \        Build commands: npm run dist:mac, dist:win, dist:linux, dist:all.\n\
        \        Output directory: release/. Uses .env.signing for macOS code signing credentials.\n\
        \        Configured in package.json build section."
  uuid: bldElec1
- id: tool.skp2obj
  kind: native_tool
  layer: system
  name: SKP to OBJ Converter
  x:
    impl:
      language: C
      status: implemented
    docs:
      description: "Native C binary (tools/skp2obj) that converts DraftDown .skp files to Wavefront OBJ+MTL\n\
        \        using the DraftDown C API (linked against DraftDownAPI.framework from DraftDown 2026).\n\
        \        Exports geometry with materials (Kd colors, d opacity), textures (map_Kd PNGs via\n\
        \        SUTextureWriteToFile), and UV coordinates (SUUVHelperGetFrontUVQ). Handles groups\n\
        \        and component instances recursively with transform accumulation. Converts inches to\n\
        \        meters. Compiled as arm64 binary. Copied to dist/tools/ during webpack build via\n\
        \        CopyPlugin. Called by main process via file:convert-skp IPC handler."
  uuid: tSkp2Obj
- id: worker.mesh
  kind: worker
  layer: system
  name: Mesh Processing Worker
  x:
    worker:
      type: Web Worker
      task: 'Background mesh operations: boolean operations, triangulation, decimation, STL export, face intersection computation'
    perf:
      critical: true
      optimizations: Transferable ArrayBuffers for zero-copy mesh data transfer, SharedArrayBuffer for shared geometry access
    impl:
      language: TypeScript
      complexity: complex
      status: basic
    docs:
      description: Web Worker dedicated to heavy mesh processing tasks that would block the UI thread.
      notes: "## Typed Interface\n\n```typescript\n// ========== Worker Message Protocol ==========\n\n/** Messages: main\
        \ thread → worker */\nexport type MeshWorkerRequest =\n  | { type: 'boolean'; id: string; op: 'union' | 'subtract'\
        \ | 'intersect'; meshA: TransferableMesh; meshB: TransferableMesh }\n  | { type: 'triangulate'; id: string; mesh:\
        \ TransferableMesh }\n  | { type: 'decimate'; id: string; mesh: TransferableMesh; targetFaceCount: number }\n  | {\
        \ type: 'intersect-faces'; id: string; meshA: TransferableMesh; meshB: TransferableMesh }\n  | { type: 'compute-normals';\
        \ id: string; mesh: TransferableMesh; smoothAngle: number }\n  | { type: 'validate'; id: string; mesh: TransferableMesh\
        \ };\n\n/** Messages: worker → main thread */\nexport type MeshWorkerResponse =\n  | { type: 'result'; id: string;\
        \ mesh: TransferableMesh }\n  | { type: 'progress'; id: string; percent: number; message: string }\n  | { type: 'error';\
        \ id: string; error: string }\n  | { type: 'validation'; id: string; result: ValidationResult };\n\n/** Mesh data\
        \ format for worker transfer (uses Transferable ArrayBuffers) */\nexport interface TransferableMesh {\n  positions:\
        \ Float64Array; // [x,y,z, x,y,z, ...] — vertex positions\n  indices: Uint32Array; // [i,j,k, i,j,k, ...] — triangle\
        \ face indices\n  faceGroups?: Uint32Array; // material index per face\n  normals?: Float32Array; // per-vertex normals\n\
        \  uvs?: Float32Array; // per-vertex UVs\n}\n\n// ========== Worker-side API ==========\n\nexport class MeshWorker\
        \ {\n  private manifold: ManifoldModule | null; // lazy-loaded WASM\n\n  constructor();\n\n  // Message handler\n\
        \  onMessage(event: MessageEvent<MeshWorkerRequest>): void;\n\n  // Operations\n  private performBoolean(op: string,\
        \ meshA: TransferableMesh, meshB: TransferableMesh): TransferableMesh;\n  private performTriangulate(mesh: TransferableMesh):\
        \ TransferableMesh;\n  private performDecimate(mesh: TransferableMesh, targetFaces: number): TransferableMesh;\n \
        \ private performIntersectFaces(meshA: TransferableMesh, meshB: TransferableMesh): TransferableMesh;\n\n  // Manifold\
        \ WASM loading\n  private ensureManifoldLoaded(): Promise<void>;\n\n  // Progress reporting\n  private reportProgress(id:\
        \ string, percent: number, message: string): void;\n}\n\n// ========== Main thread wrapper ==========\n\nexport class\
        \ MeshWorkerClient {\n  private worker: Worker;\n  private pending: Map<string, { resolve: Function; reject: Function\
        \ }>;\n\n  constructor();\n\n  // Typed async operations\n  boolean(op: 'union' | 'subtract' | 'intersect', meshA:\
        \ TransferableMesh, meshB: TransferableMesh, onProgress?: (p: number) => void): Promise<TransferableMesh>;\n  triangulate(mesh:\
        \ TransferableMesh): Promise<TransferableMesh>;\n  decimate(mesh: TransferableMesh, targetFaceCount: number): Promise<TransferableMesh>;\n\
        \  intersectFaces(meshA: TransferableMesh, meshB: TransferableMesh): Promise<TransferableMesh>;\n  validate(mesh:\
        \ TransferableMesh): Promise<ValidationResult>;\n\n  // Lifecycle\n  terminate(): void;\n}\n```\n\n## Transfer Protocol\n\
        Use `postMessage()` with Transferable ArrayBuffers for zero-copy data transfer between threads. After transfer, the\
        \ sender loses access to the buffer. The worker transfers the result buffer back the same way.\n\n## Manifold WASM\
        \ Loading\nManifold is loaded lazily on first boolean operation. The WASM file is bundled with the app and loaded\
        \ via `fetch()` inside the worker."
  uuid: 0KcEMSuo
- id: worker.fileio
  kind: worker
  layer: system
  name: File I/O Worker
  x:
    worker:
      type: Web Worker
      task: 'Background file parsing and generation: parse OBJ/STL/glTF files, generate export data, compress/decompress native
        format'
    impl:
      language: TypeScript
      complexity: moderate
      status: basic
    docs:
      description: Web Worker for file import/export operations. Parses incoming file data into geometry structures.
      notes: "## Typed Interface\n\n```typescript\nimport { TransferableMesh } from './mesh-worker';\n\n/** Messages: main\
        \ thread → worker */\nexport type FileIORequest =\n  | { type: 'import'; id: string; format: 'obj' | 'stl' | 'gltf'\
        \ | 'dxf' | 'fbx' | 'step'; data: ArrayBuffer; options?: any }\n  | { type: 'export'; id: string; format: 'obj' |\
        \ 'stl' | 'gltf' | 'dxf' | 'fbx'; mesh: TransferableMesh; materials?: SerializedMaterial[]; options?: any };\n\n/**\
        \ Messages: worker → main thread */\nexport type FileIOResponse =\n  | { type: 'import-result'; id: string; result:\
        \ ImportedScene }\n  | { type: 'export-result'; id: string; data: ArrayBuffer }\n  | { type: 'progress'; id: string;\
        \ percent: number; message: string }\n  | { type: 'error'; id: string; error: string };\n\nexport interface ImportedScene\
        \ {\n  meshes: ImportedMesh[];\n  materials: SerializedMaterial[];\n  hierarchy: SceneNode[];\n}\n\nexport interface\
        \ ImportedMesh {\n  name: string;\n  positions: Float64Array;\n  indices: Uint32Array;\n  normals?: Float32Array;\n\
        \  uvs?: Float32Array;\n  materialIndex: number;\n}\n\nexport interface SerializedMaterial {\n  name: string;\n  albedoColor:\
        \ [number, number, number];\n  roughness: number;\n  metalness: number;\n  opacity: number;\n  albedoTextureData?:\
        \ ArrayBuffer; // embedded texture\n  albedoTextureFormat?: 'png' | 'jpg';\n}\n\nexport interface SceneNode {\n  name:\
        \ string;\n  meshIndices: number[];\n  transform: number[]; // 4x4 matrix as 16 floats\n  children: SceneNode[];\n\
        }\n\n// ========== Main thread wrapper ==========\n\nexport class FileIOWorkerClient {\n  private worker: Worker;\n\
        \  private pending: Map<string, { resolve: Function; reject: Function }>;\n\n  importFile(format: string, data: ArrayBuffer,\
        \ options?: any, onProgress?: (p: number) => void): Promise<ImportedScene>;\n  exportFile(format: string, mesh: TransferableMesh,\
        \ materials?: SerializedMaterial[], options?: any, onProgress?: (p: number) => void): Promise<ArrayBuffer>;\n  terminate():\
        \ void;\n}\n```\n\n## Format-Specific Notes\n- **OBJ**: Pure JS parser. Handles v/vn/vt/f lines, material .mtl references.\n\
        - **STL**: Binary header check (80 bytes), then triangle loop. Very simple.\n- **glTF**: Use Three.js GLTFLoader adapted\
        \ for worker (no DOM). Parse JSON + binary buffers.\n- **DXF**: Parse ASCII DXF entities (LINE, 3DFACE, CIRCLE, ARC,\
        \ POLYLINE, BLOCK).\n- **FBX**: Use fbx-parser library for binary FBX decoding.\n- **STEP**: Load OpenCascade WASM\
        \ on demand. Heavy — show progress bar."
  uuid: t7DdLeOV
- id: native.manifold
  kind: native_module
  layer: system
  name: Manifold WASM Module
  x:
    native:
      language: TypeScript
      api: WASM
      reason: Manifold geometry kernel provides robust, fast CSG boolean operations. Compiled to WebAssembly for cross-platform
        compatibility without native compilation.
    perf:
      critical: true
      optimizations: WASM SIMD instructions, pre-allocated memory pools, batch operation API
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "ManifoldBridge wraps the manifold-3d npm package (WASM). Provides CSG boolean\n          operations (union,\
        \ subtract, intersect) on triangle meshes. Dynamic import with\n          webpackIgnore to avoid bundling node:module\
        \ dependency. Shared singleton via\n          getSharedManifoldBridge(). Converts between DraftDown half-edge mesh\
        \ and Manifold's\n          indexed triangle format (vertProperties + triVerts). Used by SolidToolsTool,\n          BooleanUnion,\
        \ BooleanSubtract, BooleanIntersect, and MeshWorker."
    references: https://github.com/elalish/manifold
  uuid: elHCHV0r
- id: lib.electron
  kind: library
  layer: system
  name: Electron
  x:
    library:
      name: Electron
      version: 28.x
      license: MIT
    docs:
      description: Desktop application framework. Provides BrowserWindow, IPC, native file dialogs, menus, auto-update, tray,
        notifications. Using latest stable release for Chromium security updates.
    impl:
      status: implemented
  uuid: SeFEZ0NA
- id: lib.threejs
  kind: library
  layer: system
  name: Three.js
  x:
    library:
      name: Three.js
      version: 0.160.x
      license: MIT
    docs:
      description: 'WebGL rendering library. Provides: Scene, Camera, Mesh, Material, Light, Raycaster, EffectComposer (post-processing),
        GLTFLoader/Exporter, OrbitControls foundation. The core rendering dependency.'
    references: https://threejs.org/
    impl:
      status: implemented
  uuid: 0ipvbH5T
- id: lib.react
  kind: library
  layer: system
  name: React
  x:
    library:
      name: React
      version: 18.x
      license: MIT
    docs:
      description: UI framework for all window/panel/toolbar rendering. Used with TypeScript, React hooks, and a component
        library for consistent UI. Panels, toolbars, menus, and dialogs are all React components.
    impl:
      status: implemented
  uuid: F79Qe514
- id: lib.manifold_wasm
  kind: library
  layer: system
  name: Manifold (WASM)
  x:
    library:
      name: manifold-3d
      version: 2.x
      license: Apache-2.0
    docs:
      description: Manifold geometry library WASM build. Pre-compiled WebAssembly module loaded by the mesh worker. Provides
        fast CSG boolean operations on triangle meshes.
    references: https://github.com/elalish/manifold
    impl:
      status: implemented
  uuid: iUTd4dmz
- id: plugin.system
  kind: plugin
  layer: system
  name: Plugin System
  x:
    plugin:
      type: tool
      api: '1.0'
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: Plugin architecture for extending DraftDown. Plugins are pure JavaScript modules that target
        the DraftDown Ruby API JS façade (DraftDown, Geom, UI, Length globals on window). The runtime evaluates the
        plugin source via an `AsyncFunction` constructor inside the renderer (CSP allows 'unsafe-eval' for this),
        with a tightly-scoped global. Sources installed via the Extension Manager are persisted in localStorage
        and reloaded on next launch. Sub-modules `plugin.system.draftdown.*` implement the API surface; the
        PluginLoader / DraftDown module / HostUIBackend / ParametersStore wire them together.
      notes: "## Typed Interface\n\n```typescript\nimport { ITool, ToolContext } from '../types/tool';\nimport { Operation,\
        \ OperationParams, OperationResult } from '../types/operation';\nimport { ISceneManager, Entity } from '../data/scene';\n\
        import { ISelectionManager } from '../data/selection';\nimport { IMaterialManager, Material } from '../data/materials';\n\
        import { HalfEdgeMesh, Vertex, Edge, Face } from '../geometry/mesh';\n\n// ========== Plugin Manifest (manifest.json)\
        \ ==========\nexport interface PluginManifest {\n  id: string; // unique plugin ID: 'com.example.my-plugin'\n  name:\
        \ string;\n  version: string;\n  description: string;\n  author: string;\n  entry: string; // relative path to main\
        \ JS/TS file\n  permissions: PluginPermission[];\n  dependencies?: Record<string, string>; // other plugin IDs + versions\n\
        }\n\nexport type PluginPermission =\n  | 'scene:read' // read scene graph\n  | 'scene:write' // modify scene graph\n\
        \  | 'geometry:read' // read mesh data\n  | 'geometry:write' // modify mesh data\n  | 'materials:read'\n  | 'materials:write'\n\
        \  | 'ui:panel' // create UI panels\n  | 'ui:toolbar' // add toolbar buttons\n  | 'ui:menu' // add menu items\n  |\
        \ 'file:import' // register file importers\n  | 'file:export' // register file exporters\n  | 'filesystem:read' //\
        \ read files (sandboxed)\n  | 'filesystem:write'; // write files (sandboxed)\n\n// ========== Plugin API (provided\
        \ to plugins) ==========\nexport interface PluginAPI {\n  // Registration\n  registerTool(tool: ITool): void;\n  registerOperation(operation:\
        \ Operation): void;\n  registerFileImporter(format: string, importer: FileImporter): void;\n  registerFileExporter(format:\
        \ string, exporter: FileExporter): void;\n  registerPanel(panel: PanelDefinition): void;\n  registerMenuItem(menu:\
        \ string, item: MenuItemDefinition): void;\n\n  // Scene access (sandboxed)\n  readonly scene: Readonly<ISceneManager>;\
        \ // read-only unless scene:write permission\n  readonly selection: Readonly<ISelectionManager>;\n  readonly materials:\
        \ Readonly<IMaterialManager>;\n\n  // Geometry access (sandboxed)\n  getMesh(entityId: string): Readonly<HalfEdgeMesh>\
        \ | null;\n  modifyMesh(entityId: string, callback: (mesh: HalfEdgeMesh) => void): void; // wrapped in transaction\n\
        \n  // UI\n  showDialog(options: DialogOptions): Promise<DialogResult>;\n  showNotification(message: string, type:\
        \ 'info' | 'warning' | 'error'): void;\n  log(message: string, level?: 'debug' | 'info' | 'warn' | 'error'): void;\n\
        }\n\nexport interface FileImporter {\n  extensions: string[]; // ['.xyz', '.pts']\n  description: string;\n  import(data:\
        \ ArrayBuffer, options?: any): Promise<ImportResult>;\n}\n\nexport interface FileExporter {\n  extensions: string[];\n\
        \  description: string;\n  export(scene: ISceneManager, options?: any): Promise<ArrayBuffer>;\n}\n\nexport interface\
        \ ImportResult {\n  vertices: Float64Array;\n  faces: Uint32Array;\n  materials?: Material[];\n}\n\nexport interface\
        \ PanelDefinition {\n  id: string;\n  title: string;\n  icon: string;\n  position: 'left' | 'right' | 'bottom';\n\
        \  render: (container: HTMLElement) => void; // vanilla DOM rendering\n  dispose: () => void;\n}\n\nexport interface\
        \ MenuItemDefinition {\n  id: string;\n  label: string;\n  shortcut?: string;\n  onClick: () => void;\n}\n\n// ==========\
        \ Plugin Lifecycle ==========\nexport interface IPlugin {\n  activate(api: PluginAPI): void;\n  deactivate(): void;\n\
        }\n\n// ========== Plugin System (internal) ==========\nexport interface IPluginSystem {\n  loadPlugin(pluginPath:\
        \ string): Promise<void>;\n  unloadPlugin(pluginId: string): void;\n  getLoadedPlugins(): PluginManifest[];\n  isPluginLoaded(pluginId:\
        \ string): boolean;\n  getPluginAPI(pluginId: string): PluginAPI;\n  scanPluginDirectory(dirPath: string): Promise<PluginManifest[]>;\n\
        }\n```\n\n## Security Model\nPlugins run in the renderer process but with sandboxed API access:\n- Permissions declared\
        \ in manifest.json and approved by user on install\n- `scene:write` wraps all mutations in history transactions (undoable)\n\
        - `filesystem:*` access is sandboxed to plugin's own directory\n- No direct Node.js or Electron API access\n- Plugin\
        \ errors are caught and don't crash the host app"
  uuid: zlpTImRU
- id: plugin.system.draftdown
  kind: component
  layer: system
  name: DraftDown Ruby API JS Façade
  x:
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: Near-1:1 JavaScript mirror of  Exposes the `DraftDown`, `Geom`, `UI`,
        `Length` modules on `window` so plugins (and the AI chat's `execute_script` tool) can drive the model with
        snake_case→camelCase translations of DraftDown Ruby code. Implements full surface — DraftDown module, Model,
        Entities, Face/Edge/Vertex/Group/ComponentInstance/ComponentDefinition, Selection, Materials, Layers, Pages,
        DefinitionList, Styles, RenderingOptions, ShadowInfo, OptionsManager, Tool/PluginToolAdapter/ToolStack,
        View, Camera, PickHelper, InputPoint, Curve/ArcCurve, Annotations (Text/Image/Dimension/ConstructionLine/
        ConstructionPoint), SectionPlane, Importer/Exporter — plus a full Geom toolkit (Point3d, Vector3d,
        Transformation, BoundingBox, Point2d, Vector2d, PolygonMesh, OrientedBoundingBox, Latlong, UTM with
        WGS-84 forward+inverse Mercator, intersect_line_line/intersect_line_plane/intersect_plane_plane/closest_points/
        point_in_polygon_2D/tesselate). Lives under `implementations/plugin.system/draftdown/`.
  uuid: zPlSkSrf
- id: plugin.system.attributes
  kind: component
  layer: system
  name: Plugin Attribute Store
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Document-level entity-id → AttributeDictionary store backing
        `DraftDown.Entity#set_attribute` / `#get_attribute` / `#delete_attribute`. Survives model swaps and emits
        add/change/remove events. JSON-safe values only. Implemented in
        `implementations/plugin.system/draftdown/AttributeStore.ts` + `AttributeDictionary.ts`.
  uuid: zPlAtrSt
- id: plugin.system.host_ui
  kind: component
  layer: ui
  name: Plugin Host UI Backend
  x:
    impl:
      language: TypeScript
      framework: React
      complexity: moderate
      status: implemented
    docs:
      description: Backs `UI.menu(...)`, `UI.toolbar(...)`, and `UI.htmlDialog(...)` with live React-observable
        stores (MenuStore, ToolbarStore, DialogStore). The renderer subscribes — any plugin call mutates a store
        and its corresponding panel re-renders. Includes a postMessage bridge so HtmlDialog iframes can call back
        into the host via `window.draftdown.callAction(name, ...args)`. Implemented in `HostUIBackend.ts`.
  uuid: zPlHsUiB
- id: plugin.system.loader
  kind: component
  layer: system
  name: Plugin Loader
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Loads JS plugin source via `AsyncFunction(...)` with `DraftDown`/`UI`/`Geom`/`Length`/`console`
        in scope. Persists installed sources in `localStorage` (key `draftdown:plugin-src:<id>`) so plugins reload
        on next launch. `PluginLoader.unload(id)` removes both the cached source and the explicit-enabled flag.
  uuid: zPlLdrCm
- id: plugin.system.parameters
  kind: component
  layer: ui
  name: Tool Parameters Panel
  x:
    impl:
      language: TypeScript
      framework: React
      complexity: moderate
      status: implemented
    docs:
      description: Right-rail panel mounted under EntityInfoPanel. Tools and plugins push declarative form schemas
        via `UI.parameters.show({ id, title, fields, onChange, onClose, footer })`. Field kinds — header, separator,
        number, integer, slider, text, boolean, select, color, vec3, point3d, button. NumberInput holds its own
        string state so users can type partial values like "0." or "-" and clear the field without snap-back.
        `PluginToolDescriptor.parameters` lets a custom tool auto-show its panel on activate and hide on deactivate.
        Implemented in `ParametersStore.ts` + `ParametersPanel.tsx`.
  uuid: zPlPrmPn
- id: plugin.system.console
  kind: component
  layer: ui
  name: Ruby Console
  x:
    impl:
      language: TypeScript
      framework: React
      complexity: moderate
      status: implemented
    docs:
      description: Inline REPL panel that evaluates JavaScript against the installed `DraftDown`/`Geom`/`UI`/`Length`
        globals. Supports both expression and statement forms; ↑/↓ recall history; captures return values and
        console output. Modeled after DraftDown's Ruby Console. Implemented in `RubyConsolePanel.tsx`.
  uuid: zPlCnsPn
- id: plugin.system.extension_manager
  kind: component
  layer: ui
  name: Extension Manager
  x:
    impl:
      language: TypeScript
      framework: React
      complexity: moderate
      status: implemented
    docs:
      description: Modal panel listing all installed extensions with their state. Buttons — Install (pick a .js
        file), Enable / Disable (sticky tri-state in localStorage that overrides plugin's loadOnStart), and
        Uninstall (calls `DraftDown.uninstallExtension(id)` + `loader.unload(id)` to fully remove the cached source
        and any plugin-registered tools). Implemented in `ExtensionManagerPanel.tsx`.
  uuid: zPlExMgr
- id: plugin.system.plugins_bar
  kind: component
  layer: ui
  name: Plugins Menu Bar
  x:
    impl:
      language: TypeScript
      framework: React
      complexity: simple
      status: implemented
    docs:
      description: Top-right Plugins dropdown. Renders the live MenuStore (any `UI.menu("Plugins").addItem(...)`
        shows up immediately, with submenu support), plus prepended Extension Manager… and Console actions.
        Also mounts the HtmlDialogHost so plugins' `UI.htmlDialog` instances appear above the viewport.
        Implemented in `PluginsBar.tsx` + `PluginsMenu.tsx` + `HtmlDialogHost.tsx`.
  uuid: zPlPlgBr
- id: plugin.system.tool_registry
  kind: component
  layer: system
  name: Plugin Tool Registry
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Singleton (`getPluginToolRegistry()`) that tracks plugin-registered tools so the Drawing toolbar
        can render a "Plugins" section listing them. `DraftDown.activeModel.tools.registerTool(descriptor)` adds a
        tool without activating it; `pushTool` registers + activates; `unregisterTool` removes from both ToolManager
        and the registry. Implemented in `Tool.ts`.
  uuid: zPlTlReg
- id: plugin.system.observers
  kind: component
  layer: system
  name: Plugin Observer Protocols
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: All 17+ DraftDown observer protocols expressed as TypeScript interfaces — App, Model, Selection,
        Entity, Entities, Tools, View, Materials, Layers, Pages, Definitions, Instance, FrameChange, OptionsManager,
        RenderingOptions, ShadowInfo. Each collection class hosts its own observer set. Wired from
        `DraftDown.addObserver(...)` / `addModelObserver` / `addSelectionObserver` and per-collection `addObserver`.
  uuid: zPlObsCm
- id: plugin.system.example.sample_box
  kind: plugin
  layer: system
  name: 'Example Plugin: Sample Box'
  x:
    plugin:
      type: example
    impl:
      language: JavaScript
      complexity: simple
      status: implemented
    docs:
      description: Minimal worked example demonstrating menu registration, `DraftDown.registerExtension`, and a
        single Make Box action via `entities.addFace(...).pushpull(1)`. Includes the equivalent DraftDown Ruby in
        a comment for reference. Lives at `examples/plugins/com.draftdown.sample-box/`.
  uuid: zPlExSmp
- id: plugin.system.example.stairs
  kind: plugin
  layer: system
  name: 'Example Plugin: Stairs Builder'
  x:
    plugin:
      type: example
    impl:
      language: JavaScript
      complexity: complex
      status: implemented
    docs:
      description: Parametric stair builder demonstrating `UI.parameters.show(...)` with an interactive form,
        per-flight Add/Remove buttons rebuilding the schema live, and `DraftDown.activeModel.tools.registerTool(...)`
        so the plugin appears under the Drawing toolbar's Plugins section. Supports multi-flight straight stairs
        chained with arbitrary L-90 / U-180 landing turns, plus a spiral mode (pie-shaped treads around a central
        column with optional inner radius and configurable sweep angle). All runs + landings commit in one undo
        step and wrap into a single Group. Lives at `examples/plugins/com.draftdown.stairs/`.
  uuid: zPlExStr
- id: tool.solid_tools
  kind: tool
  layer: interaction
  name: Solid Tools
  x:
    tool:
      category: modify
      shortcut: Shift+S
      cursor: pointer
      icon: solid-tools
    impl:
      language: TypeScript
      complexity: moderate
      status: placeholder
    docs:
      description: Solid modeling tools — Union, Subtract, Intersect, Trim, Split. Operates on watertight solid groups/components.
        User selects two solid groups, then chooses the boolean operation. Validates that both inputs are manifold (watertight)
        before proceeding. Shows preview of result before confirming. Delegates computation to Manifold engine via mesh worker.
  uuid: 8P4Hsuon
- id: tool.section_plane
  kind: tool
  layer: interaction
  name: Section Plane Tool
  x:
    tool:
      category: view
      shortcut: Shift+X
      cursor: crosshair
      icon: section-plane
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Click a face to place a section plane aligned to that face's normal. Uses real Three.js\n\
        \        clipping planes via WebGLRenderer.setSectionPlane(). Visual orange rectangle with cross at\n\
        \        placement. Escape clears all planes. Multiple planes tracked, one active at a time."
  uuid: dhw8Tl5i
- id: op.fillet
  kind: operation
  layer: modeling
  name: Fillet
  x:
    operation:
      type: fillet
      destructive: true
      preview: true
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Fillet edges with radius validation and adaptive segmentation. Self-intersection\n          detection prevents\
        \ invalid geometry. Arc approximation with configurable segment count.\n          Handles chains of connected edges\
        \ and corner transitions."
  uuid: iFq9wtMg
- id: op.chamfer
  kind: operation
  layer: modeling
  name: Chamfer
  x:
    operation:
      type: chamfer
      destructive: true
      preview: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Chamfer edges with edge validation, distance limits, proper normal computation,\n          and corner handling.\
        \ Creates flat angled faces. Supports equal or asymmetric\n          distances from each adjacent face."
  uuid: I3zSZZ7x
- id: native.opencascade
  kind: native_module
  layer: system
  name: OpenCascade WASM Module
  x:
    native:
      language: TypeScript (stub — WASM not installed)
      api: N-API
      reason: OpenCascade Technology (OCCT) provides STEP/IGES file parsing and B-Rep kernel for importing mechanical CAD
        data. Compiled to WASM for cross-platform. Required because STEP is a complex format that cannot be reasonably parsed
        in JavaScript.
    perf:
      critical: true
      optimizations: WASM compilation with SIMD, selective module loading (only import-related APIs)
    impl:
      language: TypeScript
      complexity: complex
      status: stub
    docs:
      description: OpenCascade Technology compiled to WebAssembly. Used specifically for STEP/IGES file import — reads B-Rep
        solid data and tessellates to triangle mesh for import into DraftDown's half-edge mesh format. Loaded on-demand
        (not at startup) only when STEP import is requested. Runs in the file I/O worker.
  uuid: KkGIzTXU
- id: lib.opencascade_wasm
  kind: library
  layer: system
  name: OpenCascade (WASM)
  x:
    library:
      name: opencascade.js
      version: 2.x
      license: LGPL-3.0
    docs:
      description: OpenCascade Technology compiled to WebAssembly. LGPL-licensed B-Rep kernel used for STEP/IGES file import.
        Loaded on-demand.
      references: https://github.com/nicedoc/opencascade.js
    impl:
      status: implemented
  uuid: fcuDXOv3
- id: file.fbx
  kind: file_format
  layer: data
  name: FBX Format
  x:
    file:
      format: FBX
      direction: both
      options: '{"binary": true, "embedTextures": true}'
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: "Full binary FBX 7500 import/export. Import: parses FBX binary header, node records,\n          all property\
        \ types (S/I/D/L/F/Y/C/f/d/i/l/R), extracts geometry from PolygonVertexIndex\n          (negative index convention),\
        \ reads materials with diffuse color. Export: writes complete\n          FBX binary with FBXHeaderExtension, GlobalSettings,\
        \ Objects (Geometry + Model + Material),\n          Connections, and proper null records. No external parser dependency."
  uuid: ibYTuKUH
- id: data.materials
  kind: scene_manager
  layer: data
  name: Material Manager
  x:
    scene:
      hierarchy: flat
      layers: false
      groups: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Manages material definitions, procedural texture generation, and face assignments. Stores PBR
        material properties (color, roughness, metalness, opacity, albedoMap). Includes 11 built-in procedural textures
        (Brick, Wood, Concrete, Metal, Glass, Stone, Tile, Grass, Asphalt, Plaster, Roof Shingle) generated via canvas
        at startup. Face assignments are serialized for undo/redo snapshots alongside geometry state. Face material
        is resolved by faceId via faceAssignments (TrackedMap) — IFace.materialIndex is a parallel side-channel
        and NOT what SceneBridge reads. inheritAssignment(parentId, childIds) ports the keyed entry onto new face
        IDs after a split; wired to GeometryEngine.onFaceSplit in Application so a line bisecting a textured face
        keeps the texture on both halves."
      notes: "## Typed Interface\n\n```typescript\nimport { Color3, Vector2 } from '../math/types';\n\nexport interface TextureMap\
        \ {\n  filePath: string; // relative path to texture file\n  width: number;\n  height: number;\n  scale: Vector2;\
        \ // UV scale (tiling)\n  offset: Vector2; // UV offset\n  rotation: number; // UV rotation in radians\n  gpuTexture:\
        \ WebGLTexture | null; // cached GPU handle\n  imageData: ImageBitmap | null; // cached CPU image\n}\n\nexport interface\
        \ Material {\n  readonly id: string;\n  name: string;\n  // PBR properties\n  albedoColor: Color3; // base color (RGB\
        \ 0-1)\n  albedoTexture: TextureMap | null;\n  roughness: number; // 0 (mirror) to 1 (matte)\n  roughnessTexture:\
        \ TextureMap | null;\n  metalness: number; // 0 (dielectric) to 1 (metal)\n  metalnessTexture: TextureMap | null;\n\
        \  normalTexture: TextureMap | null;\n  opacity: number; // 0 (transparent) to 1 (opaque)\n  opacityTexture: TextureMap\
        \ | null;\n  // native\n  colorized: boolean; // tint texture with albedoColor\n  thumbnail: ImageBitmap |\
        \ null;\n}\n\nexport interface MaterialLibrary {\n  readonly id: string;\n  name: string;\n  materials: Material[];\n\
        \  filePath: string; // JSON file on disk\n}\n\nexport interface IMaterialManager {\n  // Material CRUD\n  createMaterial(name:\
        \ string, props?: Partial<Material>): Material;\n  deleteMaterial(material: Material): void;\n  updateMaterial(material:\
        \ Material, changes: Partial<Material>): void;\n  getMaterial(id: string): Material | undefined;\n  getAllMaterials():\
        \ Material[];\n  getDefaultMaterial(): Material; // white, no texture\n\n  // Texture loading\n  loadTexture(filePath:\
        \ string): Promise<TextureMap>;\n  unloadTexture(texture: TextureMap): void;\n\n  // Libraries\n  loadLibrary(filePath:\
        \ string): Promise<MaterialLibrary>;\n  saveLibrary(library: MaterialLibrary): Promise<void>;\n  getBuiltInLibraries():\
        \ MaterialLibrary[]; // wood, metal, glass, etc.\n\n  // Face assignment\n  assignToFace(face: Face, material: Material,\
        \ backMaterial?: Material): void;\n  sampleFromFace(face: Face): Material;\n  replaceAll(oldMaterial: Material, newMaterial:\
        \ Material): number; // returns count\n\n  // GPU sync\n  getThreeMaterial(material: Material): THREE.MeshStandardMaterial;\n\
        \  invalidateGPUMaterial(material: Material): void;\n\n  // Events\n  on(event: 'material-created' | 'material-changed'\
        \ | 'material-deleted' | 'library-loaded', handler: (data: any) => void): void;\n  off(event: string, handler: Function):\
        \ void;\n}\n```\n\n## Built-in Libraries\nShip with default material libraries: Colors (basic colors), Wood (oak,\
        \ pine, walnut), Metal (steel, aluminum, copper), Glass (clear, tinted, frosted), Concrete, Brick, Stone, Fabric.\
        \ Each library is a JSON file with embedded texture file references."
  uuid: m7eNPgOv
- id: engine.inference
  kind: geometry_engine
  layer: geometry
  name: Inference Engine
  x:
    geometry:
      precision: float64
      representation: B-Rep
    perf:
      critical: true
      optimizations: Spatial indexing for nearest-point queries, cached edge/face geometry for snap computation, frame-rate
        throttled inference updates
      benchmarks: Snap computation < 2ms per frame for models up to 100K edges
    impl:
      language: TypeScript
      complexity: very-complex
      status: implemented
    docs:
      description: Centralized inference engine — the core of native guided drawing. Runs every frame during tool
        operations to find snap targets and constraint guides.
      notes: "## Typed Interface\n\n```typescript\nimport { Vector3, Ray, Plane } from '../math/types';\nimport { Vertex,\
        \ Edge, Face } from '../geometry/mesh';\nimport { IGeometryEngine } from '../geometry/engine';\n\nexport type InferenceType\
        \ =\n  | 'endpoint' // green dot — vertex snap\n  | 'midpoint' // cyan dot — edge midpoint\n  | 'on-edge' // red dot\
        \ — point on edge\n  | 'on-face' // blue dot — point on face\n  | 'intersection' // black dot — edge-edge or edge-axis\
        \ intersection\n  | 'on-axis-x' // red line — constrained to X axis\n  | 'on-axis-y' // green line — constrained to\
        \ Y axis\n  | 'on-axis-z' // blue line — constrained to Z axis\n  | 'parallel' // magenta line — parallel to referenced\
        \ edge\n  | 'perpendicular' // magenta line — perpendicular to referenced edge\n  | 'from-point' // dotted line —\
        \ inference from a previously referenced point\n  | 'tangent'; // tangent to arc/circle\n\nexport interface InferenceResult\
        \ {\n  type: InferenceType;\n  point: Vector3; // the snapped-to 3D point\n  priority: number; // higher = stronger\
        \ snap (endpoint > on-edge > on-face)\n  referenceEntity: Vertex | Edge | Face | null; // what we snapped to\n  guideGeometry:\
        \ InferenceGuide[]; // visual guides to draw\n  tooltip: string; // 'Endpoint', 'On Edge', 'Midpoint', etc.\n  color:\
        \ string; // guide color (#FF0000 for X axis, etc.)\n}\n\nexport interface InferenceGuide {\n  type: 'point' | 'line'\
        \ | 'dashed-line' | 'arc';\n  points: Vector3[]; // [center] for point, [start, end] for line\n  color: string;\n\
        \  size: number; // dot size or line width in pixels\n}\n\nexport interface InferenceContext {\n  toolStartPoint:\
        \ Vector3 | null; // where the current tool operation started\n  recentPoints: Vector3[]; // recently clicked/referenced\
        \ points (for from-point inference)\n  recentEdges: Edge[]; // recently referenced edges (for parallel/perpendicular)\n\
        \  lockedAxis: 'x' | 'y' | 'z' | null; // arrow key axis lock\n  lockedPlane: Plane | null; // face plane lock\n \
        \ customAxes: { origin: Vector3; xAxis: Vector3; yAxis: Vector3; zAxis: Vector3 } | null;\n}\n\nexport interface InferenceConfig\
        \ {\n  snapRadius: number; // screen pixels — default 15\n  axisSnapAngle: number; // degrees deviation to snap to\
        \ axis — default 5\n  pointPriority: number; // endpoint/midpoint priority — default 100\n  edgePriority: number;\
        \ // on-edge priority — default 50\n  facePriority: number; // on-face priority — default 10\n  axisPriority: number;\
        \ // axis constraint priority — default 75\n  enabled: boolean;\n}\n\nexport interface IInferenceEngine {\n  // Main\
        \ query — called every frame during tool operation\n  findInference(\n    screenPos: { x: number; y: number },\n \
        \   ray: Ray, // 3D ray from camera through screen point\n    context: InferenceContext,\n    config?: Partial<InferenceConfig>\n\
        \  ): InferenceResult | null;\n\n  // Batch query — find all inferences sorted by priority\n  findAllInferences(\n\
        \    screenPos: { x: number; y: number },\n    ray: Ray,\n    context: InferenceContext\n  ): InferenceResult[];\n\
        \n  // Specific snap tests\n  snapToPoint(ray: Ray, candidates: Vertex[], screenRadius: number): InferenceResult |\
        \ null;\n  snapToEdge(ray: Ray, candidates: Edge[], screenRadius: number): InferenceResult | null;\n  snapToFace(ray:\
        \ Ray, candidates: Face[]): InferenceResult | null;\n  snapToAxis(point: Vector3, origin: Vector3, axes: Vector3[]):\
        \ InferenceResult | null;\n  snapToParallel(point: Vector3, direction: Vector3, referenceEdge: Edge): InferenceResult\
        \ | null;\n  snapToPerpendicular(point: Vector3, direction: Vector3, referenceEdge: Edge): InferenceResult | null;\n\
        \n  // Configuration\n  setConfig(config: Partial<InferenceConfig>): void;\n  getConfig(): InferenceConfig;\n}\n```\n\
        \n## Inference Pipeline (per frame)\n1. Cast ray from camera through cursor position\n2. Spatial query: get all vertices/edges/faces\
        \ within snap radius (screen space)\n3. Test point snaps: endpoint, midpoint, intersection (highest priority)\n4.\
        \ Test edge snaps: on-edge, perpendicular, parallel\n5. Test face snaps: on-face\n6. Test axis constraints: X/Y/Z\
        \ axis from start point\n7. Test from-point inferences: lines from recently referenced points\n8. Rank all results\
        \ by priority + distance\n9. Return best result + guide geometry for rendering\n\n## Performance Budget\nMust complete\
        \ in < 2ms per frame for models up to 100K edges. Uses spatial index (octree) for candidate collection. Caches screen-space\
        \ projections of nearby geometry."

  uuid: Eqy9cs0S
- id: test.e2e.tools
  kind: test_suite
  layer: testing
  name: Tool E2E Tests
  x:
    test:
      type: e2e
      framework: Playwright
      ci: true
      timeout: 30000
      coverage: 'All interactive tools: select, line, rectangle, circle, arc, polygon, push/pull, move, rotate, scale, offset,
        eraser, paint, orbit, pan, zoom, tape measure, protractor, dimension, text, follow me, solid tools, section plane.
        Tests complete workflows from tool activation through geometry creation to undo.'
      fixtures: Empty scene, pre-built cube model, pre-built house model, multi-component scene
    impl:
      language: TypeScript
      complexity: very-complex
      status: spec-only
    docs:
      description: End-to-end Playwright tests for all interactive tools. Launches Electron app and tests complete user workflows.
      notes: "## Typed Interface\n\n```typescript\nimport { test, expect, ElectronApplication, Page } from '@playwright/test';\n\
        \n// ========== Test Helpers ==========\n\nexport interface ViewportHelper {\n  // Mouse interactions on the 3D viewport\
        \ canvas\n  clickAt(x: number, y: number): Promise<void>;\n  doubleClickAt(x: number, y: number): Promise<void>;\n\
        \  dragFrom(x1: number, y1: number, x2: number, y2: number): Promise<void>;\n  scrollAt(x: number, y: number, delta:\
        \ number): Promise<void>;\n  middleDragFrom(x1: number, y1: number, x2: number, y2: number): Promise<void>;\n\n  //\
        \ Tool activation\n  activateTool(toolId: string): Promise<void>;\n  pressShortcut(key: string): Promise<void>;\n\
        \  typeVCB(value: string): Promise<void>;\n\n  // Geometry assertions (via IPC to renderer)\n  getVertexCount(): Promise<number>;\n\
        \  getFaceCount(): Promise<number>;\n  getEdgeCount(): Promise<number>;\n  getEntityCount(type: string): Promise<number>;\n\
        \  getSelectionCount(): Promise<number>;\n  getSelectedIds(): Promise<string[]>;\n  getMeshBoundingBox(): Promise<{\
        \ min: number[]; max: number[] }>;\n}\n\nexport interface AppHelper {\n  electronApp: ElectronApplication;\n  page:\
        \ Page;\n  viewport: ViewportHelper;\n\n  // Setup\n  launch(): Promise<void>;\n  close(): Promise<void>;\n  newDocument():\
        \ Promise<void>;\n  loadFixture(name: string): Promise<void>;\n\n  // Assertions\n  expectToolActive(toolId: string):\
        \ Promise<void>;\n  expectUndoAvailable(available: boolean): Promise<void>;\n  expectRedoAvailable(available: boolean):\
        \ Promise<void>;\n  expectDirty(dirty: boolean): Promise<void>;\n}\n```\n\n## Test Scenarios\n\n### Drawing Tool Tests\n\
        ```typescript\ntest.describe('Line Tool', () => {\n  test('draw a single line', async ({ app }) => {\n    await app.viewport.activateTool('tool.line');\n\
        \    await app.viewport.clickAt(400, 300); // start point\n    await app.viewport.clickAt(600, 300); // end point\n\
        \    await app.viewport.pressShortcut('Escape'); // finish\n    expect(await app.viewport.getEdgeCount()).toBe(1);\n\
        \    expect(await app.viewport.getVertexCount()).toBe(2);\n  });\n\n  test('draw rectangle creates face', async ({\
        \ app }) => {\n    // draw 4 lines forming closed loop\n    await app.viewport.activateTool('tool.line');\n    await\
        \ app.viewport.clickAt(300, 300);\n    await app.viewport.clickAt(500, 300);\n    await app.viewport.clickAt(500,\
        \ 500);\n    await app.viewport.clickAt(300, 500);\n    await app.viewport.clickAt(300, 300); // close loop\n    expect(await\
        \ app.viewport.getFaceCount()).toBe(1);\n  });\n\n  test('VCB input sets exact length', async ({ app }) => {\n   \
        \ await app.viewport.activateTool('tool.line');\n    await app.viewport.clickAt(400, 300);\n    await app.viewport.typeVCB('1000');\
        \ // 1000mm\n    // verify edge length matches\n  });\n\n  test('undo removes last edge', async ({ app }) => {\n \
        \   await app.viewport.activateTool('tool.line');\n    await app.viewport.clickAt(400, 300);\n    await app.viewport.clickAt(600,\
        \ 300);\n    await app.viewport.pressShortcut('Escape');\n    expect(await app.viewport.getEdgeCount()).toBe(1);\n\
        \    await app.viewport.pressShortcut('Control+z');\n    expect(await app.viewport.getEdgeCount()).toBe(0);\n  });\n\
        });\n```\n\n### Push/Pull Tests\n```typescript\ntest.describe('Push/Pull Tool', () => {\n  test('extrude face creates\
        \ solid', async ({ app }) => {\n    await app.loadFixture('unit-rectangle'); // flat rectangle face\n    await app.viewport.activateTool('tool.pushpull');\n\
        \    await app.viewport.clickAt(400, 350); // click face\n    await app.viewport.dragFrom(400, 350, 400, 200); //\
        \ drag up\n    expect(await app.viewport.getFaceCount()).toBe(6); // box = 6 faces\n  });\n\n  test('double-click\
        \ repeats last distance', async ({ app }) => {\n    await app.loadFixture('two-rectangles');\n    await app.viewport.activateTool('tool.pushpull');\n\
        \    // extrude first face\n    await app.viewport.clickAt(300, 350);\n    await app.viewport.typeVCB('500');\n  \
        \  // double-click second face\n    await app.viewport.doubleClickAt(500, 350);\n    // both should be extruded by\
        \ 500\n  });\n\n  test('VCB input sets exact extrude distance', async ({ app }) => {\n    await app.loadFixture('unit-rectangle');\n\
        \    await app.viewport.activateTool('tool.pushpull');\n    await app.viewport.clickAt(400, 350);\n    await app.viewport.typeVCB('250');\n\
        \    const bbox = await app.viewport.getMeshBoundingBox();\n    expect(bbox.max[2] - bbox.min[2]).toBeCloseTo(250,\
        \ 0);\n  });\n});\n```\n\n### Selection Tests\n```typescript\ntest.describe('Select Tool', () => {\n  test('click\
        \ selects entity', async ({ app }) => {\n    await app.loadFixture('cube');\n    await app.viewport.activateTool('tool.select');\n\
        \    await app.viewport.clickAt(400, 300); // click face\n    expect(await app.viewport.getSelectionCount()).toBe(1);\n\
        \  });\n\n  test('click empty space deselects', async ({ app }) => {\n    await app.loadFixture('cube');\n    await\
        \ app.viewport.activateTool('tool.select');\n    await app.viewport.clickAt(400, 300);\n    await app.viewport.clickAt(50,\
        \ 50); // empty space\n    expect(await app.viewport.getSelectionCount()).toBe(0);\n  });\n\n  test('shift-click toggles\
        \ selection', async ({ app }) => {\n    await app.loadFixture('two-cubes');\n    await app.viewport.activateTool('tool.select');\n\
        \    await app.viewport.clickAt(300, 300); // select first\n    await app.page.keyboard.down('Shift');\n    await\
        \ app.viewport.clickAt(500, 300); // add second\n    await app.page.keyboard.up('Shift');\n    expect(await app.viewport.getSelectionCount()).toBe(2);\n\
        \  });\n\n  test('box select (window) selects entities inside', async ({ app }) => {\n    await app.loadFixture('scattered-cubes');\n\
        \    await app.viewport.activateTool('tool.select');\n    await app.viewport.dragFrom(200, 200, 600, 600); // left-to-right\
        \ = window\n    // only fully-inside entities selected\n  });\n\n  test('box select (crossing) selects intersecting\
        \ entities', async ({ app }) => {\n    await app.loadFixture('scattered-cubes');\n    await app.viewport.activateTool('tool.select');\n\
        \    await app.viewport.dragFrom(600, 200, 200, 600); // right-to-left = crossing\n    // entities intersecting or\
        \ inside selected\n  });\n});\n```\n\n### Navigation Tests\n```typescript\ntest.describe('Camera Navigation', () =>\
        \ {\n  test('middle mouse drag orbits', async ({ app }) => {\n    await app.loadFixture('cube');\n    await app.viewport.middleDragFrom(400,\
        \ 300, 500, 200);\n    // camera position should change\n  });\n\n  test('scroll zooms toward cursor', async ({ app\
        \ }) => {\n    await app.loadFixture('cube');\n    await app.viewport.scrollAt(400, 300, -3); // zoom in\n  });\n\n\
        \  test('keyboard shortcut switches tool', async ({ app }) => {\n    await app.viewport.pressShortcut('l'); // Line\
        \ tool\n    await app.expectToolActive('tool.line');\n    await app.viewport.pressShortcut('p'); // Push/Pull\n  \
        \  await app.expectToolActive('tool.pushpull');\n    await app.viewport.pressShortcut('Space'); // Select\n    await\
        \ app.expectToolActive('tool.select');\n  });\n});\n```\n\n### Move/Rotate/Scale Tests\n```typescript\ntest.describe('Move\
        \ Tool', () => {\n  test('move entity with drag', async ({ app }) => {\n    await app.loadFixture('cube');\n    await\
        \ app.viewport.activateTool('tool.select');\n    await app.viewport.clickAt(400, 300);\n    await app.viewport.activateTool('tool.move');\n\
        \    await app.viewport.clickAt(400, 300); // base point\n    await app.viewport.clickAt(500, 300); // destination\n\
        \    const bbox = await app.viewport.getMeshBoundingBox();\n    // verify bounding box shifted\n  });\n\n  test('ctrl+move\
        \ creates copy', async ({ app }) => {\n    await app.loadFixture('cube');\n    await app.viewport.activateTool('tool.select');\n\
        \    await app.viewport.clickAt(400, 300);\n    await app.viewport.activateTool('tool.move');\n    await app.page.keyboard.down('Control');\n\
        \    await app.viewport.clickAt(400, 300);\n    await app.viewport.clickAt(500, 300);\n    await app.page.keyboard.up('Control');\n\
        \    expect(await app.viewport.getFaceCount()).toBe(12); // two cubes\n  });\n});\n```\n\n### Solid Tools Tests\n\
        ```typescript\ntest.describe('Solid Tools', () => {\n  test('boolean union merges two solids', async ({ app }) =>\
        \ {\n    await app.loadFixture('overlapping-cubes');\n    await app.viewport.activateTool('tool.select');\n    await\
        \ app.viewport.clickAt(300, 300); // select first\n    await app.page.keyboard.down('Shift');\n    await app.viewport.clickAt(500,\
        \ 300); // add second\n    await app.page.keyboard.up('Shift');\n    await app.viewport.activateTool('tool.solid_tools');\n\
        \    // trigger union via toolbar button\n    const faceCount = await app.viewport.getFaceCount();\n    expect(faceCount).toBeLessThan(12);\
        \ // merged = fewer faces than 2 cubes\n  });\n});\n```\n\n### Complete Workflow Test\n```typescript\ntest.describe('Complete\
        \ Workflow: Build a House', () => {\n  test('draw floor plan, extrude walls, add roof', async ({ app }) => {\n   \
        \ // 1. Draw floor rectangle\n    await app.viewport.activateTool('tool.rectangle');\n    await app.viewport.clickAt(300,\
        \ 400);\n    await app.viewport.clickAt(600, 250);\n    await app.viewport.typeVCB('6000,4000');\n\n    // 2. Extrude\
        \ walls\n    await app.viewport.activateTool('tool.pushpull');\n    await app.viewport.clickAt(450, 325); // click\
        \ floor face\n    await app.viewport.typeVCB('3000'); // 3m walls\n    expect(await app.viewport.getFaceCount()).toBe(6);\n\
        \n    // 3. Draw roof line on top face\n    await app.viewport.activateTool('tool.line');\n    await app.viewport.clickAt(300,\
        \ 200); // midpoint of top edge\n    await app.viewport.clickAt(600, 200); // to opposite side\n\n    // 4. Push up\
        \ roof ridge\n    await app.viewport.activateTool('tool.pushpull');\n    // ... extrude roof peak\n\n    // 5. Save\n\
        \    await app.page.keyboard.press('Control+s');\n    await app.expectDirty(false);\n\n    // 6. Undo everything\n\
        \    for (let i = 0; i < 10; i++) {\n      await app.page.keyboard.press('Control+z');\n    }\n    expect(await app.viewport.getFaceCount()).toBe(0);\n\
        \  });\n});\n```"
  uuid: ShWboHjU
- id: test.e2e.file_io
  kind: test_suite
  layer: testing
  name: File I/O E2E Tests
  x:
    test:
      type: e2e
      framework: Playwright
      ci: true
      timeout: 60000
      coverage: Native .scf save/open roundtrip, OBJ import/export, STL import/export, glTF import/export, DXF import/export,
        STEP import, FBX import/export. Tests large file handling, texture embedding, material preservation.
      fixtures: Sample .obj files, sample .stl files, sample .gltf files, sample .step files, sample .fbx files, sample .dxf
        files
    impl:
      language: TypeScript
      complexity: complex
      status: spec-only
    docs:
      description: End-to-end tests for all file import/export operations. Tests roundtrip fidelity and error handling.
      notes: "## Test Scenarios\n\n```typescript\nimport { test, expect } from '@playwright/test';\n\ntest.describe('Native\
        \ Format (.scf)', () => {\n  test('save and reopen preserves geometry', async ({ app }) => {\n    await app.loadFixture('house-model');\n\
        \    const beforeFaces = await app.viewport.getFaceCount();\n    await app.page.keyboard.press('Control+s');\n   \
        \ // close and reopen\n    await app.newDocument();\n    await app.page.keyboard.press('Control+o');\n    // select\
        \ the saved file\n    const afterFaces = await app.viewport.getFaceCount();\n    expect(afterFaces).toBe(beforeFaces);\n\
        \  });\n\n  test('save preserves materials', async ({ app }) => {\n    await app.loadFixture('textured-model');\n\
        \    // save, close, reopen\n    // verify material assignments are preserved\n  });\n\n  test('save preserves groups\
        \ and components', async ({ app }) => {\n    await app.loadFixture('component-scene');\n    // save, close, reopen\n\
        \    // verify group/component hierarchy intact\n  });\n\n  test('auto-save creates recovery file', async ({ app })\
        \ => {\n    await app.loadFixture('cube');\n    // wait for auto-save interval\n    // verify temp file exists\n \
        \ });\n});\n\ntest.describe('OBJ Import/Export', () => {\n  test('import OBJ file', async ({ app }) => {\n    // File\
        \ > Import > select sample.obj\n    expect(await app.viewport.getFaceCount()).toBeGreaterThan(0);\n  });\n\n  test('export\
        \ and reimport preserves geometry', async ({ app }) => {\n    await app.loadFixture('cube');\n    // export as OBJ,\
        \ reimport, compare face/vertex counts\n  });\n\n  test('import OBJ with materials', async ({ app }) => {\n    //\
        \ import OBJ with .mtl file\n    // verify materials applied to faces\n  });\n});\n\ntest.describe('STL Import/Export',\
        \ () => {\n  test('import binary STL', async ({ app }) => {\n    // import sample-binary.stl\n    expect(await app.viewport.getFaceCount()).toBeGreaterThan(0);\n\
        \  });\n\n  test('import ASCII STL', async ({ app }) => {\n    // import sample-ascii.stl\n    expect(await app.viewport.getFaceCount()).toBeGreaterThan(0);\n\
        \  });\n\n  test('export STL triangulates all faces', async ({ app }) => {\n    await app.loadFixture('cube');\n \
        \   // export as STL, reimport\n    // all faces should be triangles\n  });\n\n  test('export reports manifold status',\
        \ async ({ app }) => {\n    await app.loadFixture('non-manifold-mesh');\n    // export should warn about non-manifold\n\
        \  });\n});\n\ntest.describe('glTF Import/Export', () => {\n  test('import glTF with PBR materials', async ({ app\
        \ }) => {\n    // import sample.gltf with metalness/roughness maps\n    // verify materials imported\n  });\n\n  test('export\
        \ GLB binary', async ({ app }) => {\n    await app.loadFixture('textured-model');\n    // export as .glb, verify file\
        \ size > 0\n  });\n\n  test('roundtrip preserves hierarchy', async ({ app }) => {\n    await app.loadFixture('grouped-scene');\n\
        \    // export glTF, reimport, verify scene nodes\n  });\n});\n\ntest.describe('DXF Import/Export', () => {\n  test('import\
        \ 2D DXF floor plan', async ({ app }) => {\n    // import architectural floor plan DXF\n    expect(await app.viewport.getEdgeCount()).toBeGreaterThan(0);\n\
        \  });\n\n  test('import 3D DXF with 3DFACE entities', async ({ app }) => {\n    // import 3D DXF\n    expect(await\
        \ app.viewport.getFaceCount()).toBeGreaterThan(0);\n  });\n});\n\ntest.describe('STEP Import', () => {\n  test('import\
        \ STEP mechanical part', async ({ app }) => {\n    // File > Import > sample.step (triggers OpenCascade WASM loading)\n\
        \    // should show progress bar\n    expect(await app.viewport.getFaceCount()).toBeGreaterThan(0);\n  });\n\n  test('import\
        \ STEP assembly with hierarchy', async ({ app }) => {\n    // import multi-part STEP assembly\n    // verify groups\
        \ created for each part\n  });\n});\n\ntest.describe('FBX Import/Export', () => {\n  test('import FBX with materials',\
        \ async ({ app }) => {\n    // import sample.fbx\n    expect(await app.viewport.getFaceCount()).toBeGreaterThan(0);\n\
        \  });\n});\n\ntest.describe('Error Handling', () => {\n  test('corrupt file shows error dialog', async ({ app })\
        \ => {\n    // try to import corrupted file\n    // verify error dialog shown\n  });\n\n  test('empty file shows error\
        \ dialog', async ({ app }) => {\n    // try to import empty file\n  });\n\n  test('unsupported format shows error',\
        \ async ({ app }) => {\n    // try to import .xyz file\n  });\n\n  test('large file shows progress bar', async ({\
        \ app }) => {\n    // import large (50MB) OBJ file\n    // verify progress bar appears\n  });\n});\n```"
  uuid: vowpGPhq
- id: test.e2e.ui
  kind: test_suite
  layer: testing
  name: UI E2E Tests
  x:
    test:
      type: e2e
      framework: Playwright
      ci: true
      timeout: 30000
      coverage: Window lifecycle, panel open/close/resize, toolbar button states, menu navigation, context menu items, preferences
        dialog, materials browser, outliner tree interaction, layers panel, components panel, measurements VCB display
      fixtures: Default window layout, custom layout presets
    impl:
      language: TypeScript
      complexity: complex
      status: spec-only
    docs:
      description: End-to-end Playwright tests for all UI elements — windows, panels, toolbars, menus, dialogs.
      notes: "## Test Scenarios\n\n```typescript\nimport { test, expect } from '@playwright/test';\n\ntest.describe('Window\
        \ Management', () => {\n  test('main window opens with correct dimensions', async ({ app }) => {\n    const size =\
        \ await app.electronApp.evaluate(({ BrowserWindow }) => {\n      const win = BrowserWindow.getAllWindows()[0];\n \
        \     return win.getSize();\n    });\n    expect(size[0]).toBeGreaterThanOrEqual(800);\n    expect(size[1]).toBeGreaterThanOrEqual(600);\n\
        \  });\n\n  test('preferences window opens as modal', async ({ app }) => {\n    await app.page.click('[data-testid=\"\
        menu-edit\"]');\n    await app.page.click('[data-testid=\"menu-preferences\"]');\n    const prefsWindow = await app.electronApp.waitForEvent('window');\n\
        \    expect(prefsWindow).toBeTruthy();\n  });\n\n  test('materials browser opens as floating window', async ({ app\
        \ }) => {\n    await app.page.click('[data-testid=\"menu-window\"]');\n    await app.page.click('[data-testid=\"menu-materials\"\
        ]');\n    // verify floating window appeared\n  });\n});\n\ntest.describe('Panel Interactions', () => {\n  test('entity\
        \ info panel shows selection properties', async ({ app }) => {\n    await app.loadFixture('cube');\n    await app.viewport.activateTool('tool.select');\n\
        \    await app.viewport.clickAt(400, 300);\n    const panel = app.page.locator('[data-testid=\"panel-properties\"\
        ]');\n    await expect(panel.locator('.entity-type')).toHaveText('Face');\n  });\n\n  test('outliner shows scene hierarchy',\
        \ async ({ app }) => {\n    await app.loadFixture('grouped-scene');\n    const outliner = app.page.locator('[data-testid=\"\
        panel-outliner\"]');\n    await expect(outliner.locator('.tree-item')).toHaveCount(5);\n  });\n\n  test('outliner\
        \ click selects entity', async ({ app }) => {\n    await app.loadFixture('grouped-scene');\n    await app.page.click('[data-testid=\"\
        outliner-item-group1\"]');\n    expect(await app.viewport.getSelectionCount()).toBe(1);\n  });\n\n  test('layers panel\
        \ toggles visibility', async ({ app }) => {\n    await app.loadFixture('layered-scene');\n    await app.page.click('[data-testid=\"\
        layer-toggle-Layer1\"]');\n    // verify geometry on Layer1 is hidden in viewport\n  });\n\n  test('panels can be\
        \ collapsed and expanded', async ({ app }) => {\n    const panel = app.page.locator('[data-testid=\"panel-properties\"\
        ]');\n    await panel.locator('.collapse-button').click();\n    await expect(panel.locator('.panel-content')).not.toBeVisible();\n\
        \    await panel.locator('.collapse-button').click();\n    await expect(panel.locator('.panel-content')).toBeVisible();\n\
        \  });\n\n  test('panels can be resized by dragging', async ({ app }) => {\n    const handle = app.page.locator('[data-testid=\"\
        panel-resize-handle\"]');\n    const box = await handle.boundingBox();\n    await app.page.mouse.move(box!.x, box!.y);\n\
        \    await app.page.mouse.down();\n    await app.page.mouse.move(box!.x - 100, box!.y);\n    await app.page.mouse.up();\n\
        \    // verify panel width changed\n  });\n});\n\ntest.describe('Toolbar Interactions', () => {\n  test('clicking\
        \ toolbar button activates tool', async ({ app }) => {\n    await app.page.click('[data-testid=\"tool-button-line\"\
        ]');\n    await app.expectToolActive('tool.line');\n  });\n\n  test('active tool button shows highlight', async ({\
        \ app }) => {\n    await app.page.click('[data-testid=\"tool-button-line\"]');\n    await expect(app.page.locator('[data-testid=\"\
        tool-button-line\"]')).toHaveClass(/active/);\n  });\n\n  test('tooltip shows keyboard shortcut', async ({ app })\
        \ => {\n    await app.page.hover('[data-testid=\"tool-button-line\"]');\n    const tooltip = app.page.locator('.tooltip');\n\
        \    await expect(tooltip).toContainText('L');\n  });\n});\n\ntest.describe('Menu Interactions', () => {\n  test('File\
        \ > New creates empty document', async ({ app }) => {\n    await app.loadFixture('cube');\n    await app.page.click('[data-testid=\"\
        menu-file\"]');\n    await app.page.click('[data-testid=\"menu-new\"]');\n    expect(await app.viewport.getFaceCount()).toBe(0);\n\
        \  });\n\n  test('Edit > Undo undoes last action', async ({ app }) => {\n    await app.loadFixture('cube');\n    await\
        \ app.viewport.activateTool('tool.eraser');\n    await app.viewport.clickAt(400, 300); // delete something\n    await\
        \ app.page.click('[data-testid=\"menu-edit\"]');\n    await app.page.click('[data-testid=\"menu-undo\"]');\n    expect(await\
        \ app.viewport.getFaceCount()).toBe(6);\n  });\n\n  test('context menu adapts to selection', async ({ app }) => {\n\
        \    await app.loadFixture('cube');\n    await app.viewport.activateTool('tool.select');\n    await app.viewport.clickAt(400,\
        \ 300); // select face\n    await app.page.click('canvas', { button: 'right' });\n    const contextMenu = app.page.locator('[data-testid=\"\
        context-menu\"]');\n    await expect(contextMenu.locator('text=Reverse Face')).toBeVisible();\n    await expect(contextMenu.locator('text=Entity\
        \ Info')).toBeVisible();\n  });\n\n  test('context menu on empty space shows paste option', async ({ app }) => {\n\
        \    await app.page.click('canvas', { button: 'right', position: { x: 50, y: 50 } });\n    const contextMenu = app.page.locator('[data-testid=\"\
        context-menu\"]');\n    await expect(contextMenu.locator('text=Paste')).toBeVisible();\n    await expect(contextMenu.locator('text=Select\
        \ All')).toBeVisible();\n  });\n});\n\ntest.describe('Measurements / VCB', () => {\n  test('VCB shows measurement\
        \ during line draw', async ({ app }) => {\n    await app.viewport.activateTool('tool.line');\n    await app.viewport.clickAt(400,\
        \ 300);\n    await app.viewport.clickAt(500, 300); // move mouse\n    const vcb = app.page.locator('[data-testid=\"\
        vcb-value\"]');\n    await expect(vcb).not.toHaveText('');\n  });\n\n  test('typing value in VCB sets exact dimension',\
        \ async ({ app }) => {\n    await app.viewport.activateTool('tool.line');\n    await app.viewport.clickAt(400, 300);\n\
        \    await app.page.keyboard.type('1000');\n    await app.page.keyboard.press('Enter');\n    // line should be exactly\
        \ 1000 units\n  });\n});\n\ntest.describe('Preferences Dialog', () => {\n  test('change units and verify VCB updates',\
        \ async ({ app }) => {\n    // open preferences\n    await app.page.keyboard.press('Control+,');\n    // change units\
        \ to feet\n    await app.page.selectOption('[data-testid=\"pref-units\"]', 'feet');\n    await app.page.click('[data-testid=\"\
        pref-save\"]');\n    // verify VCB now shows feet\n  });\n\n  test('custom keyboard shortcuts persist', async ({ app\
        \ }) => {\n    // open preferences, change Line shortcut to K\n    // close preferences\n    // press K, verify line\
        \ tool activates\n  });\n});\n```"
  uuid: bKoj9Yyd
- id: test.integration.geometry
  kind: test_suite
  layer: testing
  name: Geometry Integration Tests
  x:
    test:
      type: integration
      framework: Vitest
      ci: true
      timeout: 10000
      coverage: Half-edge mesh CRUD, face creation from edge loops, edge splitting, vertex merging, topology validation, B-Rep
        consistency checks, extrude operation, sweep operation, offset operation, boolean operations via Manifold, intersect
        faces, subdivide, triangulate, fillet, chamfer
      fixtures: Unit cube mesh, L-shaped solid, cylinder mesh, mesh with holes, non-manifold mesh
    impl:
      language: TypeScript
      complexity: very-complex
      status: spec-only
    docs:
      description: Integration tests for the geometry engine and all modeling operations. Runs headless without Electron.
      notes: "## Test Scenarios\n\n```typescript\nimport { describe, it, expect, beforeEach } from 'vitest';\nimport { HalfEdgeMesh\
        \ } from '../geometry/mesh';\nimport { GeometryEngine } from '../geometry/engine';\nimport { ExtrudeOperation } from\
        \ '../operations/extrude';\nimport { SweepOperation } from '../operations/sweep';\nimport { OffsetOperation } from\
        \ '../operations/offset';\nimport { BooleanOperation } from '../operations/boolean';\nimport { TestFixtures, MeshAssertions\
        \ } from './fixtures';\n\ndescribe('HalfEdgeMesh CRUD', () => {\n  it('creates a triangle face from 3 vertices', ()\
        \ => {\n    const mesh = new HalfEdgeMesh();\n    const v1 = mesh.addVertex([0, 0, 0]);\n    const v2 = mesh.addVertex([1,\
        \ 0, 0]);\n    const v3 = mesh.addVertex([0, 1, 0]);\n    const face = mesh.addFace([v1, v2, v3]);\n    expect(mesh.getStats().faceCount).toBe(1);\n\
        \    expect(mesh.getStats().edgeCount).toBe(3);\n    expect(mesh.getStats().vertexCount).toBe(3);\n    MeshAssertions.assertTopologyConsistent(mesh);\n\
        \  });\n\n  it('creates face when edges form closed coplanar loop', () => {\n    // add 4 edges forming a square,\
        \ verify face auto-detected\n  });\n\n  it('splits edge and maintains topology', () => {\n    // create face, split\
        \ one edge at midpoint\n    // verify face count unchanged, edge count +1, vertex count +1\n  });\n\n  it('removes\
        \ edge and connected faces', () => {\n    // create two faces sharing an edge, remove the shared edge\n    // verify\
        \ both faces removed\n  });\n\n  it('merges coincident vertices', () => {\n    // create two vertices at same position,\
        \ merge\n    // verify connected edges updated\n  });\n\n  it('handles faces with holes (inner loops)', () => {\n\
        \    // create face with rectangular outer loop and rectangular inner loop\n    // verify inner loop stored correctly\n\
        \  });\n\n  it('supports non-manifold topology', () => {\n    // create T-junction (3 faces sharing one edge)\n  \
        \  // verify mesh allows this without errors\n  });\n});\n\ndescribe('Extrude Operation', () => {\n  it('extrudes\
        \ square face into cube', () => {\n    const { mesh, face } = TestFixtures.createUnitRectangle();\n    const op =\
        \ new ExtrudeOperation();\n    const result = op.execute(mesh, { face, distance: 1, createNewStartFace: false, autoBooleanCut:\
        \ false });\n    expect(result.newFaces.length).toBe(5); // 4 sides + 1 cap\n    expect(mesh.getStats().faceCount).toBe(6);\
        \ // original bottom + 5 new\n    MeshAssertions.assertWatertight(mesh);\n    MeshAssertions.assertVolume(mesh, 1.0,\
        \ 0.001);\n  });\n\n  it('extrudes non-rectangular face', () => {\n    // L-shaped face → L-shaped extrusion\n  });\n\
        \n  it('extrudes face with hole', () => {\n    // rectangular face with rectangular hole → hollow extrusion\n  });\n\
        \n  it('negative distance pushes inward', () => {\n    const { mesh } = TestFixtures.createUnitCube();\n    // select\
        \ top face, push down -0.5\n    // verify volume decreased\n  });\n\n  it('Ctrl mode creates new starting face', ()\
        \ => {\n    const { mesh, face } = TestFixtures.createUnitRectangle();\n    const op = new ExtrudeOperation();\n \
        \   op.execute(mesh, { face, distance: 1, createNewStartFace: true, autoBooleanCut: false });\n    // original face\
        \ still exists + new cap face\n  });\n});\n\ndescribe('Boolean Operations', () => {\n  it('union of overlapping cubes\
        \ produces valid solid', () => {\n    const { cubeA, cubeB } = TestFixtures.createOverlappingCubes();\n    const result\
        \ = BooleanOperation.union(cubeA, cubeB);\n    MeshAssertions.assertManifold(result);\n    MeshAssertions.assertWatertight(result);\n\
        \    // volume should be > each cube individually but < sum\n  });\n\n  it('subtraction creates hole', () => {\n \
        \   // subtract small cube from large cube\n    // verify result has more faces (hole geometry)\n  });\n\n  it('intersection\
        \ keeps shared volume', () => {\n    // intersect overlapping cubes\n    // verify result volume < either input\n\
        \  });\n\n  it('handles coincident faces', () => {\n    // two cubes sharing a face exactly\n    // boolean should\
        \ still produce valid result\n  });\n});\n\ndescribe('Offset Operation', () => {\n  it('inset creates smaller inner\
        \ face', () => {\n    // offset rectangle face inward by 0.1\n    // verify new inner face exists and is smaller\n\
        \  });\n\n  it('handles concave faces', () => {\n    // offset L-shaped face\n  });\n});\n\ndescribe('Topology Validation',\
        \ () => {\n  it('Euler characteristic V-E+F=2 for closed solids', () => {\n    const { mesh } = TestFixtures.createUnitCube();\n\
        \    const stats = mesh.getStats();\n    expect(stats.vertexCount - stats.edgeCount + stats.faceCount).toBe(2);\n\
        \  });\n\n  it('detects non-manifold vertices', () => {\n    const mesh = TestFixtures.createNonManifoldMesh();\n\
        \    const result = mesh.validate();\n    expect(result.valid).toBe(false);\n  });\n});\n```"
  uuid: gQzG4cml
- id: test.integration.scene
  kind: test_suite
  layer: testing
  name: Scene & Data Integration Tests
  x:
    test:
      type: integration
      framework: Vitest
      ci: true
      timeout: 10000
      coverage: Scene graph hierarchy, group/component creation, layer management, selection modes (object/face/edge/vertex),
        multi-select, undo/redo stack, transaction grouping, material assignment, inference engine snap computation
      fixtures: Empty scene, scene with groups, scene with components, scene with layers
    impl:
      language: TypeScript
      complexity: complex
      status: spec-only
    docs:
      description: Integration tests for scene manager, selection, history, materials, and inference engine. Runs headless.
      notes: "## Test Scenarios\n\n```typescript\nimport { describe, it, expect } from 'vitest';\nimport { SceneManager }\
        \ from '../data/scene';\nimport { SelectionManager } from '../data/selection';\nimport { HistoryManager } from '../data/history';\n\
        import { MaterialManager } from '../data/materials';\nimport { InferenceEngine } from '../geometry/inference';\nimport\
        \ { TestFixtures } from './fixtures';\n\ndescribe('Scene Manager', () => {\n  it('creates groups from entities', ()\
        \ => {\n    const scene = TestFixtures.createEmptyScene();\n    const mesh = TestFixtures.createUnitCube();\n    scene.addEntity(mesh);\n\
        \    const group = scene.createGroup([mesh]);\n    expect(group.children.length).toBe(1);\n  });\n\n  it('entering\
        \ editing context isolates group', () => {\n    const { scene, groups } = TestFixtures.createGroupedScene();\n   \
        \ scene.enterEditingContext(groups[0]);\n    expect(scene.editingContext.currentGroup).toBe(groups[0]);\n    // only\
        \ group[0] entities should be active\n  });\n\n  it('component instances share definition', () => {\n    const { scene,\
        \ definitions } = TestFixtures.createComponentScene();\n    const instances = definitions[0].instances;\n    expect(instances.length).toBeGreaterThan(1);\n\
        \    // all instances reference same definition mesh\n  });\n\n  it('make unique creates new definition', () => {\n\
        \    const { scene, definitions } = TestFixtures.createComponentScene();\n    const instance = definitions[0].instances[0];\n\
        \    const newDef = scene.makeUnique(instance);\n    expect(newDef.id).not.toBe(definitions[0].id);\n  });\n\n  it('layers\
        \ control visibility', () => {\n    const { scene, layers } = TestFixtures.createLayeredScene();\n    const layer\
        \ = scene.getLayers().find(l => l.name === layers[0])!;\n    layer.visible = false;\n    // entities on this layer\
        \ should be hidden\n  });\n});\n\ndescribe('Selection Manager', () => {\n  it('select replaces current selection',\
        \ () => {\n    const sel = new SelectionManager();\n    sel.select(entityA);\n    sel.select(entityB);\n    expect(sel.count).toBe(1);\n\
        \    expect(sel.isSelected(entityB)).toBe(true);\n  });\n\n  it('toggle adds and removes', () => {\n    const sel\
        \ = new SelectionManager();\n    sel.toggle(entityA);\n    expect(sel.isSelected(entityA)).toBe(true);\n    sel.toggle(entityA);\n\
        \    expect(sel.isSelected(entityA)).toBe(false);\n  });\n\n  it('emits selection-changed events', () => {\n    const\
        \ events: any[] = [];\n    sel.on('selection-changed', e => events.push(e));\n    sel.select(entityA);\n    expect(events.length).toBe(1);\n\
        \    expect(events[0].added).toContain(entityA);\n  });\n\n  it('selectConnected finds all connected geometry', ()\
        \ => {\n    // create mesh, select one face\n    // selectConnected should select all faces in same mesh\n  });\n\
        });\n\ndescribe('History Manager', () => {\n  it('undo reverses last transaction', () => {\n    const history = new\
        \ HistoryManager();\n    const mesh = TestFixtures.createUnitCube();\n    history.beginTransaction('Delete Face');\n\
        \    // delete a face\n    history.commitTransaction();\n    expect(mesh.getStats().faceCount).toBe(5);\n    history.undo();\n\
        \    expect(mesh.getStats().faceCount).toBe(6);\n  });\n\n  it('redo re-applies undone transaction', () => {\n   \
        \ // undo then redo, verify state matches post-action\n  });\n\n  it('new action after undo clears redo stack', ()\
        \ => {\n    // undo, then perform new action\n    expect(history.canRedo()).toBe(false);\n  });\n\n  it('respects\
        \ max steps limit', () => {\n    history.setMaxSteps(5);\n    for (let i = 0; i < 10; i++) {\n      history.beginTransaction(`Action\
        \ ${i}`);\n      history.commitTransaction();\n    }\n    expect(history.getUndoStack().length).toBe(5);\n  });\n\n\
        \  it('abort rolls back current transaction', () => {\n    history.beginTransaction('Failed Op');\n    // partially\
        \ modify mesh\n    history.abortTransaction();\n    // mesh should be unchanged\n  });\n\n  it('nested transactions\
        \ are grouped', () => {\n    // Sweep creates many edges in one transaction\n    // verify single undo reverses\
        \ all\n  });\n});\n\ndescribe('Inference Engine', () => {\n  it('snaps to endpoint', () => {\n    const mesh = TestFixtures.createUnitCube();\n\
        \    const result = inference.findInference(screenPos, ray, context);\n    expect(result?.type).toBe('endpoint');\n\
        \  });\n\n  it('snaps to midpoint', () => {\n    // cast ray near edge midpoint\n  });\n\n  it('snaps to on-axis',\
        \ () => {\n    // set context.toolStartPoint, move along X axis\n    // should return on-axis-x inference\n  });\n\
        \n  it('detects parallel inference', () => {\n    // reference an edge, move parallel to it\n  });\n\n  it('detects\
        \ perpendicular inference', () => {\n    // reference an edge, move perpendicular\n  });\n\n  it('priority: endpoint\
        \ > on-edge > on-face', () => {\n    // when multiple inferences near cursor, endpoint wins\n  });\n\n  it('completes\
        \ within 2ms budget', () => {\n    const largeMesh = TestFixtures.createGeneratedMesh(100000);\n    const start =\
        \ performance.now();\n    inference.findInference(screenPos, ray, context);\n    expect(performance.now() - start).toBeLessThan(2);\n\
        \  });\n});\n```"
  uuid: G9gtH930
- id: test.visual.rendering
  kind: test_suite
  layer: testing
  name: Visual Regression Tests
  x:
    test:
      type: visual-regression
      framework: Playwright
      ci: true
      timeout: 30000
      coverage: Render modes (wireframe, shaded, textured, xray), PBR materials, edge outlines, selection highlights, section
        planes, shadows, grid/axes display, camera views (front/back/left/right/top/iso), perspective vs orthographic
      fixtures: Reference cube scene, reference house scene, reference material showcase scene
    impl:
      language: TypeScript
      complexity: complex
      status: spec-only
    docs:
      description: 'Screenshot-based visual regression tests using Playwright. Renders predefined scenes in all render modes
        and compares against golden reference images (pixel diff with configurable threshold). Tests: each shader mode, material
        rendering, selection highlight appearance, section plane clipping, camera standard views. Detects visual regressions
        in renderer, shaders, and post-processing.'
  uuid: INjqxBGs
- id: test.perf.geometry
  kind: test_suite
  layer: testing
  name: Geometry Performance Tests
  x:
    test:
      type: performance
      framework: Vitest
      ci: true
      timeout: 120000
      coverage: Mesh creation throughput, extrude operation latency (100-face to 100K-face models), boolean operation latency
        (1K to 100K faces), triangulation speed, inference engine frame budget (< 2ms), file parse speed (OBJ/STL/glTF 1MB-100MB)
      fixtures: 'Generated meshes: 1K, 10K, 100K, 500K, 1M faces'
    impl:
      language: TypeScript
      complexity: complex
      status: spec-only
    docs:
      description: 'Performance benchmark tests for geometry operations. Measures: mesh creation rate (faces/sec), operation
        latency at various model sizes, memory usage during boolean operations, inference engine computation time per frame,
        file I/O throughput. Fails if any benchmark exceeds the defined budget. Outputs benchmark results as JSON for tracking
        over time.'
  uuid: ksY5HU7H
- id: test.perf.rendering
  kind: test_suite
  layer: testing
  name: Rendering Performance Tests
  x:
    test:
      type: performance
      framework: Playwright
      ci: false
      timeout: 120000
      coverage: FPS at various model sizes (1K-2M faces), draw call count, GPU memory usage, orbit/zoom interaction latency,
        render mode switching speed, shader compilation time
      fixtures: 'Generated scenes: sparse 1K faces, dense 100K faces, complex 500K faces, stress test 2M faces'
    impl:
      language: TypeScript
      complexity: complex
      status: spec-only
    docs:
      description: Rendering performance benchmarks. Launches Electron with predefined scenes of increasing complexity, measures
        FPS during orbit navigation, records GPU memory via WebGL extensions, counts draw calls. Tests instanced rendering
        efficiency with component-heavy scenes. Requires GPU — not run in CI by default (headless CI has no GPU). Can be run
        manually on target hardware.
  uuid: W4N7C02x
- id: test.fixture.models
  kind: test_fixture
  layer: testing
  name: Test Model Fixtures
  x:
    test:
      framework: Vitest
    impl:
      language: TypeScript
      complexity: moderate
      status: spec-only
    docs:
      description: Shared test fixtures providing pre-built 3D models and helper functions for all test suites.
      notes: "## Typed Interface\n\n```typescript\nimport { HalfEdgeMesh, Vertex, Edge, Face } from '../geometry/mesh';\n\
        import { ISceneManager, Group, ComponentDefinition } from '../data/scene';\nimport { Material } from '../data/materials';\n\
        import { Vector3 } from '../math/types';\n\n// ========== Fixture Models ==========\n\nexport interface TestFixtures\
        \ {\n  // Basic primitives\n  createEmptyScene(): ISceneManager;\n  createUnitCube(): { mesh: HalfEdgeMesh; faces:\
        \ Face[]; vertices: Vertex[] };\n  createUnitRectangle(): { mesh: HalfEdgeMesh; face: Face }; // flat rectangle on\
        \ XY plane\n  createLSolid(): { mesh: HalfEdgeMesh; faces: Face[] }; // L-shaped extrusion\n  createCylinder(segments?:\
        \ number): { mesh: HalfEdgeMesh; faces: Face[] };\n  createSphere(segments?: number): { mesh: HalfEdgeMesh; faces:\
        \ Face[] };\n\n  // Complex models\n  createHouseModel(): { scene: ISceneManager; groups: Group[] };\n  createOverlappingCubes():\
        \ { scene: ISceneManager; cubeA: Group; cubeB: Group };\n  createTwoCubes(): { scene: ISceneManager; cubeA: Group;\
        \ cubeB: Group };\n  createScatteredCubes(count: number): { scene: ISceneManager; cubes: Group[] };\n  createGroupedScene():\
        \ { scene: ISceneManager; groups: Group[]; components: ComponentDefinition[] };\n  createLayeredScene(): { scene:\
        \ ISceneManager; layers: string[] };\n\n  // Textured/material models\n  createTexturedModel(): { scene: ISceneManager;\
        \ materials: Material[] };\n  createComponentScene(): { scene: ISceneManager; definitions: ComponentDefinition[] };\n\
        \n  // Edge cases\n  createMeshWithHoles(): HalfEdgeMesh; // face with inner loops\n  createNonManifoldMesh(): HalfEdgeMesh;\
        \ // T-junction, butterfly vertex\n  createDegenerateMesh(): HalfEdgeMesh; // zero-area faces, duplicate vertices\n\
        \n  // Generated meshes for performance testing\n  createGeneratedMesh(faceCount: number): HalfEdgeMesh; // subdivided\
        \ grid\n  createRandomMesh(vertexCount: number): HalfEdgeMesh;\n}\n\n// ========== Assertion Helpers ==========\n\n\
        export interface MeshAssertions {\n  assertMeshValid(mesh: HalfEdgeMesh): void; // topology, normals, planarity\n\
        \  assertTopologyConsistent(mesh: HalfEdgeMesh): void; // half-edge invariants\n  assertManifold(mesh: HalfEdgeMesh):\
        \ void;\n  assertWatertight(mesh: HalfEdgeMesh): void;\n  assertFaceCount(mesh: HalfEdgeMesh, expected: number): void;\n\
        \  assertVertexCount(mesh: HalfEdgeMesh, expected: number): void;\n  assertEdgeCount(mesh: HalfEdgeMesh, expected:\
        \ number): void;\n  assertEulerCharacteristic(mesh: HalfEdgeMesh, expected: number): void; // V-E+F\n  assertBoundingBox(mesh:\
        \ HalfEdgeMesh, min: Vector3, max: Vector3, tolerance?: number): void;\n  assertVolume(mesh: HalfEdgeMesh, expected:\
        \ number, tolerance?: number): void;\n  assertSurfaceArea(mesh: HalfEdgeMesh, expected: number, tolerance?: number):\
        \ void;\n}\n\n// ========== Screenshot Helpers (for visual regression) ==========\n\nexport interface ScreenshotHelpers\
        \ {\n  compareScreenshot(page: any, name: string, threshold?: number): Promise<boolean>;\n  updateGoldenScreenshot(page:\
        \ any, name: string): Promise<void>;\n}\n\n// ========== Playwright Helpers ==========\n\nexport interface E2EHelpers\
        \ {\n  launchApp(): Promise<AppHelper>;\n  loadFixtureFile(name: string): Promise<ArrayBuffer>; // load .obj/.stl/.gltf\
        \ fixture file\n  waitForMeshReady(page: any): Promise<void>; // wait for geometry to finish loading\n  waitForRenderFrame(page:\
        \ any): Promise<void>; // wait for next render frame\n}\n```\n\n## Fixture File Inventory\n- `fixtures/cube.scf` —\
        \ Unit cube (6 faces, 8 vertices, 12 edges)\n- `fixtures/rectangle.scf` — Flat rectangle on XY plane (1 face)\n- `fixtures/house.scf`\
        \ — Simple house (walls + peaked roof, ~50 faces)\n- `fixtures/overlapping-cubes.scf` — Two overlapping cubes for\
        \ boolean tests\n- `fixtures/grouped-scene.scf` — Scene with nested groups and components\n- `fixtures/textured-model.scf`\
        \ — Model with multiple PBR materials\n- `fixtures/sample.obj` — Reference OBJ file\n- `fixtures/sample-binary.stl`\
        \ — Reference binary STL\n- `fixtures/sample-ascii.stl` — Reference ASCII STL\n- `fixtures/sample.gltf` — Reference\
        \ glTF with materials\n- `fixtures/sample.step` — Reference STEP mechanical part\n- `fixtures/sample.dxf` — Reference\
        \ DXF floor plan\n- `fixtures/sample.fbx` — Reference FBX model\n- `fixtures/corrupt.obj` — Deliberately malformed\
        \ file\n- `fixtures/large-100k.obj` — Large 100K-face model for performance"
  uuid: cwg1B1OO
- id: test.e2e.house
  kind: test
  layer: system
  name: E2E Draw House Test
  implementable: true
  x:
    test:
      framework: Playwright
      scope: e2e
      requiresElectron: true
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: 'Comprehensive E2E test that draws a complete house using every tool at least once, exercising the full
        application through real mouse and keyboard interactions on the Electron app. 36 serial tests covering: all 23 tools
        (Select, Line, Rectangle, Circle, Arc, Polygon, Push/Pull, Move, Rotate, Scale, Offset, Sweep, Eraser, Paint,
        Orbit, Pan, Zoom, Tape Measure, Protractor, Dimension, Text, Section Plane, Solid Tools), all 4 render modes, all
        7 standard views, grid/axes toggle, layer CRUD, outliner interaction, context menu, VCB precise input, keyboard shortcuts,
        undo/redo, and zoom extents. No mocks — tests the real running application.'
  uuid: tE2eH0us
- id: test.e2e.drawing_tools
  kind: test
  layer: system
  name: E2E Drawing Tools Test
  implementable: true
  x:
    test:
      framework: Playwright
      scope: e2e
      requiresElectron: true
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: E2E test suite verifying that drawing tools create real geometry in the viewport. Tests Three.js initialization,
        Line/Rectangle/Circle tool drawing with mouse clicks, VCB exact dimension input, Orbit/Pan/Zoom camera navigation,
        Escape cancellation, and tool switching. 12 tests using real Electron app.
  uuid: tE2eDrTl
- id: lib.playwright
  kind: library
  layer: system
  name: Playwright
  x:
    library:
      name: '@playwright/test'
      version: 1.x
      license: Apache-2.0
    docs:
      description: E2E testing framework with Electron support. Used for UI interaction tests, visual regression screenshots,
        and rendering performance measurement. Supports Electron via electron.launch() for full application testing.
      references: https://playwright.dev/docs/api/class-electron
    impl:
      status: implemented
  uuid: k5FeTQff
- id: lib.vitest
  kind: library
  layer: system
  name: Vitest
  x:
    library:
      name: vitest
      version: 1.x
      license: MIT
    docs:
      description: Fast unit/integration test runner. Used for headless geometry engine tests, scene manager tests, and performance
        benchmarks. Runs without Electron — pure TypeScript logic testing.
      references: https://vitest.dev/
    impl:
      status: implemented
  uuid: cjLXXZy3
- id: data.document
  kind: scene_manager
  layer: data
  name: Model Document
  x:
    scene:
      hierarchy: tree
      layers: true
      groups: true
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: The in-memory model document — the single source of truth for an open project. Owns and coordinates all
        model state.
      notes: "## Typed Interface\n\n```typescript\nimport { ISceneManager, ScenePage, Layer } from '../data/scene';\nimport\
        \ { ISelectionManager } from '../data/selection';\nimport { IHistoryManager } from '../data/history';\nimport { IMaterialManager,\
        \ Material } from '../data/materials';\nimport { HalfEdgeMesh } from '../geometry/mesh';\nimport { Vector3 } from\
        \ '../math/types';\n\nexport type LengthUnit = 'mm' | 'cm' | 'm' | 'inches' | 'feet';\n\nexport interface DocumentMetadata\
        \ {\n  name: string;\n  description: string;\n  author: string;\n  createdAt: number;\n  modifiedAt: number;\n  units:\
        \ LengthUnit;\n  geoLocation?: { latitude: number; longitude: number; northAngle: number };\n}\n\nexport interface\
        \ DocumentState {\n  dirty: boolean; // has unsaved changes\n  filePath: string | null; // null = never saved\n  autoSaveEnabled:\
        \ boolean;\n  autoSaveIntervalMs: number;\n  lastAutoSave: number | null;\n}\n\nexport interface IModelDocument {\n\
        \  // Sub-managers (owned)\n  readonly scene: ISceneManager;\n  readonly selection: ISelectionManager;\n  readonly\
        \ history: IHistoryManager;\n  readonly materials: IMaterialManager;\n\n  // Document state\n  readonly metadata:\
        \ DocumentMetadata;\n  readonly state: DocumentState;\n\n  // Lifecycle\n  static createNew(template?: string): IModelDocument;\n\
        \  static openFromFile(filePath: string, data: ArrayBuffer): Promise<IModelDocument>;\n  save(): Promise<ArrayBuffer>;\
        \ // serialize to native format\n  saveAs(filePath: string): Promise<void>;\n  close(): void; // cleanup, release\
        \ resources\n\n  // Metadata\n  setUnits(units: LengthUnit): void;\n  getUnits(): LengthUnit;\n  setMetadata(partial:\
        \ Partial<DocumentMetadata>): void;\n\n  // Dirty tracking\n  isDirty(): boolean;\n  markClean(): void; // after successful\
        \ save\n\n  // Auto-save\n  getAutoSaveData(): ArrayBuffer; // serialize for temp file\n  hasAutoSaveRecovery(filePath:\
        \ string): boolean;\n  recoverAutoSave(filePath: string): Promise<IModelDocument>;\n\n  // Import/Export (delegates\
        \ to file_format nodes)\n  importFile(format: string, data: ArrayBuffer, options?: any): Promise<void>;\n  exportFile(format:\
        \ string, options?: any): Promise<ArrayBuffer>;\n\n  // Events\n  on(event: 'dirty-changed' | 'saved' | 'units-changed'\
        \ | 'metadata-changed', handler: (data: any) => void): void;\n  off(event: string, handler: Function): void;\n}\n\
        ```\n\n## Document Ownership\nThe document is the root owner of all model state:\n- `document.scene` → SceneManager\
        \ (groups, layers, pages)\n- `document.selection` → SelectionManager\n- `document.history` → HistoryManager\n- `document.materials`\
        \ → MaterialManager\n- Scene graph nodes own their `HalfEdgeMesh` instances\n\n## Auto-Save\nEvery `autoSaveIntervalMs`\
        \ (default 5 min), serialize the document to a temp file in `app.getPath('temp')`. On crash recovery, check for temp\
        \ files newer than the last save."
  uuid: LDuh74wJ
- id: lib.playwright
  kind: library
  layer: system
  name: Playwright
  x:
    library:
      name: '@playwright/test'
      version: 1.x
      license: Apache-2.0
    docs:
      description: E2E testing framework with Electron support. Used for UI interaction tests, visual regression screenshots,
        and rendering performance measurement. Supports Electron via electron.launch() for full application testing.
      references: https://playwright.dev/docs/api/class-electron
    impl:
      status: implemented
  uuid: V78jJCce
- id: lib.vitest
  kind: library
  layer: system
  name: Vitest
  x:
    library:
      name: vitest
      version: 1.x
      license: MIT
    docs:
      description: Fast unit/integration test runner. Used for headless geometry engine tests, scene manager tests, and performance
        benchmarks. Runs without Electron — pure TypeScript logic testing.
      references: https://vitest.dev/
    impl:
      status: implemented
  uuid: t2KU6fmm
- id: bridge.scene
  kind: service
  layer: runtime
  name: Scene Bridge
  x:
    impl:
      language: TypeScript
      framework: Three.js
      complexity: moderate
      status: implemented
    docs:
      description: "Syncs geometry engine B-Rep → Three.js objects. Faces as THREE.Group\n\
        \          (DoubleSide meshes) in main scene with per-face PBR materials from MaterialManager.\n\
        \          Texture mapping uses face-local UV projection (tangent/bitangent from first edge) so\n\
        \          textures stick to faces when moved/rotated. Edges as THREE.Line in main scene (depth-tested).\n\
        \          Component bounding boxes as purple wireframe. Snap system: vertices, midpoints,\n\
        \          and edge-edge intersections. Texture cache for data URL → THREE.Texture.\n\
        \          Preview lines and snap markers non-raycastable (raycast=()=>{}).\n\
        \          Batched mode: syncBatched() merges all faces into single BufferGeometry for large\n\
        \          imports (>10K faces). Tracks batched face/edge IDs so sync() only processes NEW geometry.\n\
        \          GPU pick mesh with vertex-color-encoded face IDs (ShaderMaterial, per-face RGB).\n\
        \          Batched edges skip raycast. Edge creation skipped for >10K face imports (~375MB savings).\n\
        \          Dirty tracking: dual check using IFace.generation counter (bumped on material/topology\n\
        \          changes) and vertex position hashing (catches direct position mutations by move/rotate/scale\n\
        \          tools). Skips re-triangulation when both are clean. When updating highlighted faces,\n\
        \          detects swapped highlight material and updates renderer's saved original via\n\
        \          refreshHighlightOriginal() to prevent material loss on highlight restore."
  uuid: sBr1dg3X
- id: app.singleton
  kind: service
  layer: runtime
  name: Application Singleton
  x:
    impl:
      language: TypeScript
      complexity: complex
      status: implemented
    docs:
      description: 'Main application orchestrator instantiated by ViewportCanvas on mount. Bootstraps and owns all subsystems:
        ModelDocument (geometry engine + scene + selection + history + materials), Viewport (Three.js renderer + camera),
        InferenceEngine, ToolManager (registers all 23 tools), and SceneBridge. Provides syncScene() to push geometry changes
        to the renderer after tool operations. Handles IPC menu actions (new/open/save/undo/redo/delete). Exposes activateTool/getActiveTool/getAvailableTools
        for the UI layer. Also provides syncSelection() which pushes selection state to both the Three.js renderer (for visual
        highlights) and the React UI (Entity Info panel, selection count badge).'
  uuid: aS1ngl3T
- id: system.snap
  kind: service
  layer: interaction
  name: Snap System
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "classic-CAD-style snap + inference detection. SceneBridge.findSnapPoint() detects\n          origin, vertex (endpoint),\
        \ midpoint, edge-edge intersection (0.05 tolerance), on-edge, and face snaps\n          for EVERY tool that declares needs.snap\
        \ (draw, measure, construct, active modify, axes). The snap\n          kind is delivered to tools on ToolMouseEvent.snapKind\
        \ ('origin' | 'vertex' | 'midpoint' |\n          'intersection' | 'edge' | 'face' | 'cursor'). Markers: green ring+dot endpoint/origin,\
        \ cyan midpoint,\n          dark intersection, red on-edge, yellow square face-snap, blue dot free cursor.\n          ViewportCanvas\
        \ renders a convention-named label near the cursor (Origin/Endpoint/Midpoint/Intersection/On\n          Edge/On Face) for all snapping\
        \ tools; a tool's directional inference label (getInferenceLabel())\n          overrides it. BaseTool.applyDirectionInference()\
        \ adds automatic axis inference (On Red/Green/Blue\n          Axis, colored guide line + rubber band, ~7° tolerance, Shift pins\
        \ the inference) and\n          parallel-to-edge inference (magenta), shared by Line, Move, and Tape Measure tools.\n         \
        \ Hard point snaps always beat directional inference.\n          INVARIANT — indicator == geometry: tools sizing a shape on a locked\
        \ drawing plane\n          (rectangle 2nd corner, circle/polygon radius, arc end/bulge/center points) resolve the\n\
        \          point via BaseTool.getPlanePointHonoringSnap(): a hard point snap (origin/vertex/\n\
        \          midpoint/intersection/on-edge) wins and is projected onto the plane; otherwise the\n\
        \          cursor is raycast onto the plane. Face/cursor snaps are surfaces, not points, and\n\
        \          don't override the raycast. A raw raycastOntoPlane here diverges from the shown\n\
        \          snap marker — that bug class placed corners a few pixels off snapped endpoints.\n\
        \          Rectangle applies the SAME proportion inference (Square/Golden Section) at commit\n\
        \          as in the preview; a hard snap suppresses it."
  uuid: sSnpSys1
- id: system.autoface
  kind: service
  layer: geometry
  name: Auto-Face Creation
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: |
        Four auto-face mechanisms in GeometryEngine:
        (1) autoCreateFaces via createEdgeWithAutoFace(): BFS finds short closed coplanar loops
        through existing edges. Hard caps prevent exponential blow-up: maxDepth=8
        (down from 20), maxExplore=5000 dequeues, maxLoopsFound=200. Real face loops are
        short; depth 20 caused 6^20 path enumeration on dense graphs (e.g. imported stair
        components). Coplanarity tolerance is 0.05 (practical for hand-drawn geometry).
        Three loop-rejection checks: chord detection (edges between non-adjacent loop
        vertices), loopContainsInteriorVertex (2D point-in-polygon rejects loops enclosing
        other coplanar vertices with edges; plane normal via Newell's method — a cross
        product of the first three loop vertices is zero when they are collinear, which
        silently skipped the check and stacked overlapping faces. An interior vertex only
        disqualifies when it is enclosed STRUCTURE: a path crossing the loop with ≥2
        boundary contacts, a cycle, or face-bearing edges — a dangling tree with ≤1
        contact does not; classic CAD forms the face under a dangling edge), AND
        loopPartiallyOverlapsExistingFace (rejects loops that straddle an existing coplanar
        face's boundary — some vertices strictly inside, some outside, or edges properly
        crossing it. Fully-enclosed loops still pass and punch holes via cutHoleIfEnclosed).
        (2) splitFaceWithEdge: splits face when edge connects two non-adjacent boundary vertices.
        (3) splitFaceWithPath(): splits face along multi-vertex path (arc). Scans
        full chain to find first/last vertices on face boundary (handles lines extending
        beyond the face). Handles endpoints ON face edges via proximity detection
        (0.05 threshold), vertex insertion with modular indexing for wrapping edges
        (shared helper insertOnBoundaryVertices), and edge splitting. Both
        resulting faces include arc vertices on shared boundary (no chord edge).
        (4) splitFacesWithClosedRing(): classic CAD coplanar-merge for closed shape outlines.
        Expands the drawn corner ring with existing on-segment vertices (the intersection
        vertices createEdgeWithIntersection made), classifies each ring vertex per face as
        on-boundary / strictly-inside / outside, and splits every crossed face along
        boundary→interior→boundary runs (plus interior-crossing chords), iterating until
        stable. Ring vertices OUTSIDE a face are never treated as split paths (the old
        per-rotation splitFaceWithPath hack did, corrupting faces). Finishes by re-running
        autoCreateFaces per ring segment so regions outside the crossed faces form.
        Returns the split count; 0 lets circle/polygon tools safely createFace the full ring.
        Material/UV inheritance: child faces inherit the parent's materialIndex
        and reconstructed UVs (affine 3-point fit on the parent's plane); the engine
        fires onFaceSplit so MaterialManager carries the faceId-keyed material assignment
        onto the new IDs.
        Guards: no self-edges, no zero-length edges, no degenerate faces (< 3 unique vertices).
        Arc tool uses plain createEdge + splitFaceWithPath. Line tool uses createEdgeWithAutoFace.
        Rectangle/Circle/Polygon use createEdgeWithIntersection + splitFacesWithClosedRing.
  uuid: sAutFce1
- id: system.undo
  kind: service
  layer: data
  name: Snapshot Undo/Redo
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Delta-based undo/redo system. TrackedMap intercepts all mutations on mesh entity maps (vertices,
        edges, faces, halfEdges) and material faceAssignments. Each transaction records add/delete/modify deltas.
        Undo applies inverse deltas in reverse order. Move/rotate/scale tools use snapshotVertices() for direct
        position mutations. ModelDocument re-wires setTrackedSources() after newDocument() and deserialize()
        since geometry.deserialize() replaces the internal HalfEdgeMesh.
        INVARIANT: a delete delta records the entity''s PRE-TRANSACTION state (the get()-time beforeSnapshot),
        NOT its delete-time state. An entity mutated then deleted in one transaction (a face whose boundary
        gained intersection vertices before a split deleted it) must be restored without those mutations —
        the vertices they reference are removed by the same undo. Recording delete-time state left restored
        faces pointing at missing vertices (the circle type-to-redo corruption: commit → undo → redraw).
        Redo is unaffected: forward delta application only uses the recorded value for add deltas.'
  uuid: sUndoSys
- id: system.keyboard
  kind: service
  layer: interaction
  name: Keyboard Event Router
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: "Single window-level keyboard handler in App.tsx. Shortcut maps are built
          from DEFAULT_PREFERENCES.shortcuts (single source of truth in ipc-types.ts).
          Routes: Cmd+Z→undo, Cmd+Shift+Z→redo, Cmd+S/O/N→file ops,
          letters→tool activation (from preferences), arrows→tool onKeyDown
          (axis lock for Line, plane switch for shapes), Enter/Delete→tool action.
          Escape clears selection and switches to Select tool.
          Arrow keys bypass INPUT focus check. Uses syncToolState() and
          syncPreviews() helpers from AppContext to avoid duplicated state sync."
  uuid: sKbdRout
- id: system.components
  kind: service
  layer: data
  name: Component System
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Groups of face/edge IDs that act as a single unit in SceneManager. Components protect their internal geometry
        from main-scene editing. Key methods: createComponent(name, entityIds), explodeComponent(id), enterComponent(id),
        exitComponent(). isEntityProtected(id) returns true if the entity is in a component NOT currently being edited. isEntityEditable(id)
        returns true for entities in the active component (edit mode) or not in any component (main scene). When a component
        is selected, the hitEntityId is replaced with the component ID in the raycast pipeline. Application.syncSelection()
        resolves component IDs to member IDs for visual highlighting. SceneBridge renders purple wireframe bounding boxes
        around components. Move/Rotate/Scale tools resolve component IDs to member vertices via BaseTool.resolveSelectedEntityIds().
        Entity Info panel shows component name, entity count, and Edit/Explode buttons.'
  uuid: sCompSys
- id: system.layers
  kind: service
  layer: data
  name: Layer System
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'Layer management in SceneManager. Each layer has visibility, locked, and color properties. Active layer
        (activeLayerId) determines where new geometry is assigned. SceneBridge auto-assigns new faces/edges to active layer
        via geometryLayerMap. Layer visibility hides Three.js objects (face groups and edge lines set visible=false). Layer
        locking prevents selection (raycast pipeline filters via isEntityLocked). Layers panel supports: create, delete, toggle
        visibility, toggle lock, set active, assign selected entities to layer.'
  uuid: sLayrSys
- id: system.fileio
  kind: service
  layer: data
  name: OBJ File I/O
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: "OBJ text format save/open in Application. exportOBJ() writes vertices (v),
          faces (f), and edges (l). importOBJ() parses and creates geometry.
          Native menu bar (File menu) and shortcuts (Cmd+N/O/S/Shift+S).
          Uses Electron IPC for native file dialogs."
  uuid: sFileIO1
- id: system.dragselect
  kind: service
  layer: interaction
  name: Drag Box Selection
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Drag-to-select in SelectTool. Left-to-right drag shows blue solid box (window mode), right-to-left shows
        green dashed box (crossing mode). Projects face centers and edge midpoints to screen space and checks containment
        within the box. Visual overlay rendered as an HTML div in ViewportCanvas. Cursor changes to pointer when hovering
        over selectable entities.
  uuid: sDrgSel1
- id: system.face_snap
  kind: service
  layer: interaction
  name: On-Face Drawing Snap
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: 'native "On Face" inference. When a draw tool''s cursor hovers a face,
        ViewportCanvas (a) tracks the underlying face id separately from the component-resolved
        hitEntityId, and (b) projects the cursor ray onto that face''s plane to give the tool an
        exact on-face world point. SceneBridge.findSnapPoint shows a yellow square indicator
        (oriented to the face normal, lifted slightly toward the camera) when no higher-priority
        snap fires. BaseTool.getEffectiveDrawingPlane prefers the hit face''s plane so shape
        tools (Rectangle/Circle/Polygon/Arc) lock their drawing plane to the face on first
        click; subsequent moves use raycastOntoPlane(this.drawPlane, ...) so the cursor stays
        on the face plane regardless of where it strays. The Line tool has a parallel mechanism
        via lockedFacePlane. BaseTool.getEventNeeds returns raycast=true for draw/measure/construct
        tools in ALL phases (including idle), so the FIRST click on a face populates hitFaceId
        even when the snap pulls the point onto a vertex/edge — otherwise the shape would lock
        to the ground/axis plane instead of the face. RectangleTool.getPlaneAxes() builds in-plane
        axes (cross of normal with the world axis least parallel to it, then a second cross) for
        non-axis-aligned planes so all four computed corners stay on the locked plane — earlier
        code used world axes which only worked for axis-aligned drawing planes. createFace then
        runs cutHoleIfEnclosed, which punches a matching hole in the host face — and SceneBridge.sync
        was widened to re-triangulate any face whose generation bumped (the host face) so the hole
        renders instead of z-fighting. The renderer also exposes SceneBridge.getLastSnapKind() so
        ViewportCanvas can render a small floating label ("Point" / "Line" / "Face") near the
        cursor for draw-category tools.'
  uuid: sFaceSnp1
- id: system.error_logging
  kind: service
  layer: system
  name: Renderer Error Logging
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: Global error visibility. Renderer entry installs window 'error' and
        'unhandledrejection' listeners that log message + filename:line:col + stack. Every
        try/catch across the codebase logs via console.error (unexpected) or console.warn
        (expected-might-fail). The AI tool surface additionally writes a ring buffer of every
        invocation to `window.__AI_LOG__` and to `localStorage` keys `draftdown:ai-log:*` for
        forensic debugging across reloads.
  uuid: sErrLog1
- id: panel.tool_settings
  kind: panel
  layer: ui
  name: Tool Settings Panel
  x:
    ui:
      position: right-sidebar
      visibility: conditional
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: Right-side panel showing tool-specific settings. Appears when a tool with settings is active (e.g. Paint Bucket).
        Extensible via toolPanels map keyed by tool ID. Paint tool settings include color picker, material swatch grid with
        procedural texture thumbnails, add/delete material controls, and active material preview.
  uuid: sPnlTlSt
- id: api.model
  kind: component
  layer: logical
  name: Model API Facade
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: High-level programmatic API for 3D model operations. Provides shape primitives (box, cylinder, sphere),
        transforms (move, rotate, scale), extrude, material assignment, queries, and batch operations. Every mutation
        is wrapped in a history transaction for automatic undo. Serves as the interface for both AI chat and plugin system.
        Exposed on window.modelAPI for dev console access.
  uuid: aP1MdlAp
- id: ai.chat
  kind: component
  layer: logical
  name: AI Chat Assistant
  x:
    impl:
      language: TypeScript
      framework: React
      complexity: complex
      status: implemented
    docs:
      description: AI-powered chat sub-window that interprets natural language instructions into 3D model operations.
        Uses the Claude API via main process IPC. Built around the DraftDown Ruby API JS façade — the model is given
        three tools (`execute_script` runs JavaScript against window.DraftDown/Geom/UI/Length inside one auto-managed
        undo step; `read_selection` returns a JSON snapshot; `read_api_reference` returns the markdown surface). Any
        snippet Claude writes is paste-able into the Ruby Console or installable as a plugin verbatim.
  uuid: aI1ChAtP
- id: tool.walk
  kind: tool
  layer: interaction
  name: Camera Walk Tools (Position/Look/Walk)
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: |
        implementations/tool.walk/walkTools.ts — three classic CAD camera tools
        sharing one eye-height state (default 1.68m, VCB-settable):
        PositionCameraTool (click ground → eye at height, horizontal gaze),
        LookAroundTool (drag yaws/pitches in place, pitch clamped), WalkTool
        (rAF loop while dragging: vertical drag advances at constant eye
        height, horizontal turns). All registered in Application + Navigate
        toolbar group.
  uuid: sToolWalk
- id: engine.spatial_grid
  kind: service
  layer: geometry
  name: Spatial Grid Index
  x:
    impl:
      language: TypeScript
      complexity: moderate
      status: implemented
    docs:
      description: |
        implementations/engine.geometry/SpatialGrid.ts — lazy uniform hash
        grid (0.5m cells) over vertices and edges, rebuilt when mesh counts
        change or after 500ms (position-only drags don't bump counts). Ray
        corridor queries feed findSnapPoint candidates; AABB queries feed
        createEdgeWithIntersection crossing/weld scans and T-junction healing
        above GRID_THRESHOLD (2000 entities). Replaces the hard bail-outs
        that disabled snapping/merging on large models.
  uuid: sSpatGrid
- id: core.units
  kind: service
  layer: system
  name: Unit System & Distance Parsing
  x:
    impl:
      language: TypeScript
      complexity: simple
      status: implemented
    docs:
      description: |
        src/core/units.ts — internal unit is METERS everywhere; display/input
        conversion happens only at the VCB boundary. Singleton current unit
        (setCurrentUnit/getCurrentUnit, updated from preferences).
        parseDistanceExpr(): classic-CAD-style VCB distance grammar — unit
        suffixes (' or ft/feet, " or in/inch/inches, mm, cm, m; longest-match,
        case-insensitive), feet+inches combos (8'10", and a bare number after
        a feet term means inches: 8'10), fractions (1/2", 3/8, mixed 10 1/2"),
        additive multi-term expressions (1m 20cm), signs, NaN on trailing
        garbage (so 24s segment-count syntax never parses as a distance).
        BaseTool.parseDistance/parseDimensions route ALL tool VCB input
        through it; a bare number uses the current document unit. Angles
        (rotate/protractor) use plain parseFloat — no length conversion.
  uuid: sCoreUnit
edges:
- kind: reads
  from: engine.geometry
  to: engine.spatial_grid
  layer: geometry
  x:
    docs:
      description: Draw-time crossing/weld scans query the grid above GRID_THRESHOLD.
  uuid: eGeoGrid
- kind: reads
  from: system.snap
  to: engine.spatial_grid
  layer: interaction
  x:
    docs:
      description: findSnapPoint collects large-model snap candidates via ray-corridor queries.
  uuid: eSnapGrid
- kind: calls
  from: tool.walk
  to: camera.main
  layer: interaction
  x:
    docs:
      description: Walk tools drive CameraController.position/target/lookAt directly.
  uuid: eWalkCam
- kind: calls
  from: tool.base
  to: core.units
  layer: interaction
  x:
    docs:
      description: BaseTool.parseDistance/parseDimensions/formatDist delegate to parseDistanceExpr/formatDistance for all VCB input and display.
  uuid: eTbUnits
- kind: contains
  from: data.scene
  to: system.components
  layer: data
  x:
    docs:
      description: SceneManager hosts the component system (createComponent, enterComponent, etc.)
  uuid: eDsCompCn
- kind: calls
  from: window.main
  to: system.components
  layer: ui
  x:
    docs:
      description: Entity Info panel shows Make Component / Edit Component / Explode buttons.
  uuid: eWmCompCl
- kind: reads
  from: tool.select
  to: system.components
  layer: interaction
  x:
    docs:
      description: Select tool resolves component IDs — clicking component geometry selects the whole component.
  uuid: eSlCompRd
- kind: contains
  from: data.scene
  to: system.layers
  layer: data
  x:
    docs:
      description: SceneManager hosts the layer system (activeLayerId, geometryLayerMap, visibility, locking).
  uuid: eDsLayrCn
- kind: reads
  from: bridge.scene
  to: system.layers
  layer: runtime
  x:
    docs:
      description: SceneBridge reads layer visibility to show/hide Three.js objects during sync.
  uuid: eBsLayrRd
- kind: contains
  from: window.main
  to: system.keyboard
  layer: interaction
  x:
    docs:
      description: App.tsx hosts the single global keyboard event handler.
  uuid: eWmKbdCn
- kind: calls
  from: system.keyboard
  to: tool.select
  layer: interaction
  x:
    docs:
      description: Keyboard handler forwards arrow keys, Escape, Enter, Delete to the active tool.
  uuid: eKbdTlCl
- kind: calls
  from: app.singleton
  to: system.fileio
  layer: data
  x:
    docs:
      description: Application.exportOBJ/importOBJ handles OBJ format save/open.
  uuid: eApFioCl
- kind: calls
  from: system.fileio
  to: process.main
  layer: runtime
  x:
    docs:
      description: File I/O uses Electron IPC (file:import, file:export, file:write) for native dialogs.
  uuid: eFioPmCl
- kind: contains
  from: tool.select
  to: system.dragselect
  layer: interaction
  x:
    docs:
      description: SelectTool implements drag box selection with visual overlay in ViewportCanvas.
  uuid: eSlDrgCn
- kind: calls
  from: test.e2e.house
  to: window.main
  layer: system
  x:
    docs:
      description: Draw House E2E test exercises all tools through the main window UI.
  uuid: eTHsWmCl
- kind: calls
  from: test.e2e.drawing_tools
  to: window.main
  layer: system
  x:
    docs:
      description: Drawing Tools E2E test verifies tool interactions create geometry.
  uuid: eTDtWmCl
- kind: creates
  from: process.renderer
  to: app.singleton
  layer: runtime
  x:
    docs:
      description: ViewportCanvas React component instantiates the Application singleton on mount and calls initialize(container)
        to bootstrap all subsystems.
  uuid: eVCcr8Ap
- kind: creates
  from: web.platform
  to: app.singleton
  layer: runtime
  x:
    docs:
      description: Web entry point installs WebPlatformBridge as window.api, then renders the same App
        component. The Application singleton boots identically to Electron — all tools, geometry engine,
        and Three.js renderer work unchanged.
  uuid: eWebApp1
- kind: creates
  from: app.singleton
  to: bridge.scene
  layer: runtime
  x:
    docs:
      description: Application creates the SceneBridge during initialization, passing the geometry engine and WebGL renderer.
  uuid: eApSbr1d
- kind: contains
  from: bridge.scene
  to: system.snap
  layer: runtime
  x:
    docs:
      description: SceneBridge hosts the snap detection system. findSnapPoint() projects vertices to screen, finds nearest
        within threshold, and positions the snap marker.
  uuid: eSbSnpCn
- kind: calls
  from: system.autoface
  to: engine.geometry
  layer: geometry
  x:
    docs:
      description: Auto-face system uses BFS on the geometry engine's edge graph to find closed loops, checkCoplanar() for
        validation, and createFace()/deleteFace() for face splitting.
  uuid: eAfGeCl
- kind: calls
  from: tool.line
  to: system.autoface
  layer: interaction
  x:
    docs:
      description: Line tool calls createEdgeWithAutoFace() which triggers auto-face detection after each edge.
  uuid: eTlLnAf
- kind: calls
  from: system.undo
  to: engine.geometry
  layer: data
  x:
    docs:
      description: Undo/redo calls geometry.serialize() for snapshots and geometry.deserialize() to restore state.
  uuid: eUndGeCl
- kind: reads
  from: bridge.scene
  to: engine.geometry
  layer: runtime
  x:
    docs:
      description: SceneBridge reads vertices, edges, and faces from the geometry engine's B-Rep mesh and creates corresponding
        Three.js objects for rendering.
  uuid: eSbGeoRd
- kind: calls
  from: bridge.scene
  to: renderer.webgl
  layer: runtime
  x:
    docs:
      description: SceneBridge adds/removes Three.js objects to/from the WebGL renderer's scene. Registers entity objects
        for GPU picking and manages preview overlays (rubber-band lines, rectangle previews).
  uuid: eSbWglCl
- kind: calls
  from: app.singleton
  to: data.document
  layer: runtime
  x:
    docs:
      description: Application owns and manages the ModelDocument. Calls newDocument/serialize/deserialize for file operations
        and delegates undo/redo/delete to the document's history and scene managers.
  uuid: eApDocCl
- kind: calls
  from: app.singleton
  to: viewport.main
  layer: runtime
  x:
    docs:
      description: Application creates and initializes the Viewport during bootstrap. Passes the container element for canvas
        creation and Three.js renderer setup.
  uuid: eApVpCl
- kind: calls
  from: app.singleton
  to: engine.inference
  layer: runtime
  x:
    docs:
      description: Application creates the InferenceEngine and passes it to all tools during registration for snap/constraint
        detection during drawing operations.
  uuid: eApInfCl
- kind: uses
  from: actor.designer
  to: window.main
  layer: product
  x:
    docs:
      description: Designer uses the main application window for all 3D modeling, drawing, and viewing tasks.
  uuid: 8S8skuAV
- kind: uses
  from: actor.designer
  to: window.materials
  layer: product
  x:
    docs:
      description: Designer opens the materials browser to apply and manage materials on model faces.
  uuid: sRaMoEMN
- kind: uses
  from: actor.designer
  to: window.preferences
  layer: product
  x:
    docs:
      description: Designer opens preferences to configure units, shortcuts, grid, and other settings.
  uuid: 3fedGaSL
- kind: uses
  from: actor.plugin_dev
  to: plugin.system
  layer: product
  x:
    docs:
      description: Plugin developer uses the plugin system API to create extensions.
  uuid: sJetwdQx
- kind: contains
  from: window.main
  to: toolbar.drawing
  layer: ui
  x:
    docs:
      description: Main window contains the drawing toolbar on the left.
  uuid: svL3v71N
- kind: contains
  from: window.main
  to: toolbar.views
  layer: ui
  x:
    docs:
      description: Main window contains the views toolbar (secondary, top).
  uuid: UY5VLVJS
- kind: contains
  from: window.main
  to: menu.main
  layer: ui
  x:
    docs:
      description: Main window contains the application menu bar.
  uuid: 9pZ6sJiV
- kind: contains
  from: window.main
  to: menu.context
  layer: ui
  x:
    docs:
      description: Main window contains the context menu (shown on right-click).
  uuid: sGugnEWx
- kind: contains
  from: window.main
  to: viewport.main
  layer: ui
  x:
    docs:
      description: Main window contains the 3D viewport (center area).
  uuid: ceXb5yRd
- kind: contains
  from: window.main
  to: panel.properties
  layer: ui
  x:
    docs:
      description: Main window contains the entity info panel on the right.
  uuid: GpEiDSX1
- kind: contains
  from: window.main
  to: panel.outliner
  layer: ui
  x:
    docs:
      description: Main window contains the outliner panel on the right.
  uuid: 3MFQ59Eh
- kind: contains
  from: window.main
  to: panel.layers
  layer: ui
  x:
    docs:
      description: Main window contains the layers panel on the right.
  uuid: iA7e7Qxi
- kind: contains
  from: window.main
  to: panel.components
  layer: ui
  x:
    docs:
      description: Main window contains the components panel on the right.
  uuid: Kw12FVpY
- kind: contains
  from: window.main
  to: panel.measurements
  layer: ui
  x:
    docs:
      description: Main window contains the measurements/VCB panel at the bottom.
  uuid: opqVDDrd
- kind: contains
  from: toolbar.drawing
  to: tool.select
  layer: ui
  uuid: sHaG47Wy
- kind: contains
  from: toolbar.drawing
  to: tool.eraser
  layer: ui
  uuid: XiSpqTYE
- kind: contains
  from: toolbar.drawing
  to: tool.paint
  layer: ui
  uuid: dAj7q4M4
- kind: contains
  from: toolbar.drawing
  to: tool.orbit
  layer: ui
  uuid: HabJC52Y
- kind: contains
  from: toolbar.drawing
  to: tool.pan
  layer: ui
  uuid: cJHW1CGY
- kind: contains
  from: toolbar.drawing
  to: tool.zoom
  layer: ui
  uuid: 8D5hAYNb
- kind: contains
  from: toolbar.drawing
  to: tool.line
  layer: ui
  uuid: HvB0BSiu
- kind: contains
  from: toolbar.drawing
  to: tool.rectangle
  layer: ui
  uuid: xh53p8yr
- kind: contains
  from: toolbar.drawing
  to: tool.circle
  layer: ui
  uuid: uJ20pB7F
- kind: contains
  from: toolbar.drawing
  to: tool.arc
  layer: ui
  uuid: D9ey9zwB
- kind: contains
  from: toolbar.drawing
  to: tool.polygon
  layer: ui
  uuid: QW3fqmGv
- kind: contains
  from: toolbar.drawing
  to: tool.pushpull
  layer: ui
  uuid: p63GTRLi
- kind: contains
  from: toolbar.drawing
  to: tool.move
  layer: ui
  uuid: 5sOMatTt
- kind: contains
  from: toolbar.drawing
  to: tool.rotate
  layer: ui
  uuid: RJHLMf9k
- kind: contains
  from: toolbar.drawing
  to: tool.scale
  layer: ui
  uuid: x7YwwFNI
- kind: contains
  from: toolbar.drawing
  to: tool.offset
  layer: ui
  uuid: 7WDTycl9
- kind: contains
  from: toolbar.drawing
  to: tool.sweep_tool
  layer: ui
  uuid: KW2yCCns
- kind: contains
  from: toolbar.drawing
  to: tool.tape_measure
  layer: ui
  uuid: vpSJCMTS
- kind: contains
  from: toolbar.drawing
  to: tool.protractor
  layer: ui
  uuid: 0j3Zo7ta
- kind: contains
  from: toolbar.drawing
  to: tool.dimension
  layer: ui
  uuid: A0i6dSnV
- kind: contains
  from: toolbar.drawing
  to: tool.text
  layer: ui
  uuid: P76r7MYb
- kind: contains
  from: menu.main
  to: tool.select
  layer: ui
  uuid: zYMMq6D6
- kind: contains
  from: menu.main
  to: tool.line
  layer: ui
  uuid: SL55JXQN
- kind: contains
  from: menu.main
  to: tool.rectangle
  layer: ui
  uuid: nnVi0sFg
- kind: contains
  from: menu.main
  to: tool.circle
  layer: ui
  uuid: 98Y6yBiA
- kind: contains
  from: menu.main
  to: tool.pushpull
  layer: ui
  uuid: zzgTtsNW
- kind: contains
  from: menu.main
  to: tool.move
  layer: ui
  uuid: Eq71bFQe
- kind: contains
  from: menu.main
  to: tool.rotate
  layer: ui
  uuid: 1W5h1q5d
- kind: triggers
  from: gesture.click
  to: tool.select
  layer: interaction
  x:
    docs:
      description: Click gesture triggers selection in the Select tool.
  uuid: RmIS7T6Y
- kind: triggers
  from: gesture.click
  to: tool.line
  layer: interaction
  x:
    docs:
      description: Click gesture places points in the Line tool.
  uuid: Vk6zmZOG
- kind: triggers
  from: gesture.double_click
  to: tool.pushpull
  layer: interaction
  x:
    docs:
      description: Double-click in Push/Pull repeats the last distance.
  uuid: d8EKLOfE
- kind: triggers
  from: gesture.drag
  to: tool.move
  layer: interaction
  x:
    docs:
      description: Drag gesture moves entities in the Move tool.
  uuid: Xq6vmi1h
- kind: triggers
  from: gesture.drag
  to: tool.pushpull
  layer: interaction
  x:
    docs:
      description: Drag gesture extrudes faces in the Push/Pull tool.
  uuid: yCaiAr31
- kind: triggers
  from: gesture.drag
  to: tool.rotate
  layer: interaction
  x:
    docs:
      description: Drag gesture sets rotation angle in the Rotate tool.
  uuid: fL3i6wNn
- kind: triggers
  from: gesture.drag
  to: tool.scale
  layer: interaction
  x:
    docs:
      description: Drag gesture scales entities using grip handles.
  uuid: GoUZoIZx
- kind: triggers
  from: gesture.middle_drag
  to: camera.main
  layer: interaction
  x:
    docs:
      description: Middle mouse drag activates orbit camera rotation from any tool.
  uuid: wCyJBr3w
- kind: triggers
  from: gesture.shift_middle_drag
  to: camera.main
  layer: interaction
  x:
    docs:
      description: Shift + middle drag activates pan camera movement from any tool.
  uuid: 5Pg95roE
- kind: triggers
  from: gesture.scroll
  to: camera.main
  layer: interaction
  x:
    docs:
      description: Scroll wheel triggers zoom toward cursor position.
  uuid: ST4KtXEN
- kind: triggers
  from: gesture.keyboard_value
  to: tool.line
  layer: interaction
  x:
    docs:
      description: Keyboard number input sets exact length in Line tool VCB.
  uuid: 4cB2bYIJ
- kind: triggers
  from: gesture.keyboard_value
  to: tool.pushpull
  layer: interaction
  x:
    docs:
      description: Keyboard number input sets exact distance in Push/Pull tool VCB.
  uuid: IIuevvnZ
- kind: triggers
  from: gesture.keyboard_value
  to: tool.move
  layer: interaction
  x:
    docs:
      description: Keyboard number input sets exact distance in Move tool VCB.
  uuid: 6oKnO16r
- kind: invokes
  from: tool.pushpull
  to: op.extrude
  layer: interaction
  x:
    docs:
      description: Push/Pull tool invokes the extrude operation on the selected face.
  uuid: aoQaZLot
- kind: invokes
  from: tool.sweep_tool
  to: op.sweep
  layer: interaction
  x:
    docs:
      description: Sweep tool invokes the sweep operation along the selected path.
  uuid: Rjb92guZ
- kind: invokes
  from: tool.offset
  to: op.offset
  layer: interaction
  x:
    docs:
      description: Offset tool invokes the offset edges operation.
  uuid: 8ll6nuqM
- kind: uses
  from: tool.line
  to: constraint.on_axis
  layer: interaction
  x:
    docs:
      description: Line tool uses axis constraints for guided drawing.
  uuid: JZN4soQQ
- kind: uses
  from: tool.line
  to: constraint.parallel
  layer: interaction
  x:
    docs:
      description: Line tool uses parallel constraints for inference.
  uuid: vzJOmnX8
- kind: uses
  from: tool.line
  to: constraint.perpendicular
  layer: interaction
  x:
    docs:
      description: Line tool uses perpendicular constraints for inference.
  uuid: 0uulzZX4
- kind: uses
  from: tool.line
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Line tool uses point snapping for precise placement.
  uuid: NHlxZfmK
- kind: uses
  from: tool.line
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Line tool uses distance constraint for VCB input.
  uuid: CjQ2PYLo
- kind: uses
  from: tool.rectangle
  to: constraint.on_axis
  layer: interaction
  uuid: s6EDVRxN
- kind: uses
  from: tool.rectangle
  to: constraint.snap_point
  layer: interaction
  uuid: MjXZ5AOW
- kind: uses
  from: tool.rectangle
  to: constraint.distance
  layer: interaction
  uuid: hfcpQVKA
- kind: uses
  from: tool.move
  to: constraint.on_axis
  layer: interaction
  uuid: Ng2Vk5hf
- kind: uses
  from: tool.move
  to: constraint.snap_point
  layer: interaction
  uuid: tE1jJdr5
- kind: uses
  from: tool.move
  to: constraint.distance
  layer: interaction
  uuid: vt5lSrJs
- kind: uses
  from: tool.pushpull
  to: constraint.distance
  layer: interaction
  uuid: 6kdhIbd1
- kind: uses
  from: tool.pushpull
  to: constraint.snap_point
  layer: interaction
  uuid: d4xjh1nU
- kind: modifies
  from: tool.select
  to: data.selection
  layer: interaction
  x:
    docs:
      description: Select tool modifies the current selection state.
  uuid: Okpm5Xq0
- kind: modifies
  from: tool.select
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Select tool modifies scene (enter/leave editing context on double-click).
  uuid: KV5HcNg4
- kind: modifies
  from: tool.line
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Line tool adds edges (and auto-creates faces) in the scene.
  uuid: 3fp7t0iB
- kind: modifies
  from: tool.eraser
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Eraser tool deletes edges/faces from the scene.
  uuid: picB9EFi
- kind: modifies
  from: tool.paint
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Paint tool modifies face materials in the scene.
  uuid: 0bVaXfgb
- kind: modifies
  from: tool.move
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Move tool translates entities in the scene.
  uuid: bHJXChdq
- kind: modifies
  from: tool.rotate
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Rotate tool rotates entities in the scene.
  uuid: L7dDpugY
- kind: modifies
  from: tool.scale
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Scale tool scales entities in the scene.
  uuid: AaKRWZcp
- kind: uses
  from: viewport.main
  to: renderer.webgl
  layer: rendering
  x:
    docs:
      description: Viewport uses the WebGL renderer to draw the 3D scene.
  uuid: EMZkFXHL
- kind: uses
  from: viewport.main
  to: camera.main
  layer: rendering
  x:
    docs:
      description: Viewport uses the main camera for view projection.
  uuid: kAFIKZjt
- kind: invokes
  from: viewport.main
  to: renderer.webgl
  layer: rendering
  x:
    docs:
      description: Viewport invokes the renderer each frame to draw the scene.
  uuid: uHr9thPB
- kind: renders
  from: viewport.main
  to: data.scene
  layer: rendering
  x:
    docs:
      description: Viewport renders the scene manager's object hierarchy.
  uuid: VWX8DWmi
- kind: draws
  from: renderer.webgl
  to: viewport.main
  layer: rendering
  x:
    docs:
      description: Renderer draws output to the viewport canvas.
  uuid: RcUSECGW
- kind: renders
  from: renderer.webgl
  to: mesh.halfedge
  layer: rendering
  x:
    docs:
      description: Renderer converts half-edge mesh to GPU buffers and renders triangulated faces.
  uuid: FVGe3zAm
- kind: renders
  from: renderer.webgl
  to: curve.polyline
  layer: rendering
  x:
    docs:
      description: Renderer draws polyline curves as line segments.
  uuid: W39kJv5q
- kind: renders
  from: renderer.webgl
  to: curve.arc
  layer: rendering
  x:
    docs:
      description: Renderer draws arc curves as segmented line geometry.
  uuid: 6H7MEVBe
- kind: uses
  from: renderer.webgl
  to: shader.pbr
  layer: rendering
  x:
    docs:
      description: Renderer uses PBR shader for material rendering.
  uuid: AJ09oJgF
- kind: uses
  from: renderer.webgl
  to: shader.outline
  layer: rendering
  x:
    docs:
      description: Renderer uses outline shader for architectural edge rendering.
  uuid: AO22Idj2
- kind: uses
  from: renderer.webgl
  to: shader.selection
  layer: rendering
  x:
    docs:
      description: Renderer uses selection shader for highlight/hover effects.
  uuid: IjQFc2ba
- kind: uses
  from: renderer.webgl
  to: shader.xray
  layer: rendering
  x:
    docs:
      description: Renderer uses x-ray shader when x-ray render mode is active.
  uuid: EXHIKDND
- kind: uses
  from: renderer.webgl
  to: lib.threejs
  layer: rendering
  x:
    docs:
      description: Renderer depends on Three.js for WebGL abstraction.
  uuid: LxpOH9Fw
- kind: draws
  from: shader.pbr
  to: mesh.halfedge
  layer: rendering
  x:
    docs:
      description: PBR shader draws mesh faces with physically-based materials.
  uuid: RDFe4VNK
- kind: draws
  from: shader.outline
  to: mesh.halfedge
  layer: rendering
  x:
    docs:
      description: Outline shader draws edge outlines on mesh geometry.
  uuid: qOIfqSFv
- kind: draws
  from: shader.selection
  to: mesh.halfedge
  layer: rendering
  x:
    docs:
      description: Selection shader draws highlights on selected mesh entities.
  uuid: vzRXi3wh
- kind: draws
  from: shader.xray
  to: mesh.halfedge
  layer: rendering
  x:
    docs:
      description: X-Ray shader draws semi-transparent mesh for see-through mode.
  uuid: ZBcrUGVr
- kind: applies
  from: op.extrude
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Extrude operation creates new faces/edges in the half-edge mesh.
  uuid: 811xoiU6
- kind: applies
  from: op.sweep
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Sweep operation creates swept geometry in the half-edge mesh.
  uuid: yX9E09lX
- kind: applies
  from: op.offset
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Offset operation creates inset/outset edges in the mesh.
  uuid: NJmaUC1z
- kind: applies
  from: op.boolean_union
  to: solid.manifold
  layer: modeling
  x:
    docs:
      description: Boolean union passes solids to Manifold engine.
  uuid: 8pOjcyL5
- kind: applies
  from: op.boolean_subtract
  to: solid.manifold
  layer: modeling
  x:
    docs:
      description: Boolean subtract passes solids to Manifold engine.
  uuid: nswMh1Bg
- kind: applies
  from: op.boolean_intersect
  to: solid.manifold
  layer: modeling
  x:
    docs:
      description: Boolean intersect passes solids to Manifold engine.
  uuid: UIMRYbik
- kind: applies
  from: op.intersect_faces
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Intersect Faces splits mesh faces at intersection curves.
  uuid: cCJnOt2l
- kind: applies
  from: op.subdivide
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Subdivide operation splits mesh faces into smaller faces.
  uuid: GFliGxrv
- kind: applies
  from: op.triangulate
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Triangulate operation converts n-gon faces to triangles.
  uuid: tTSdjJuu
- kind: modifies
  from: op.extrude
  to: engine.geometry
  layer: modeling
  uuid: zq6oej6B
- kind: modifies
  from: op.sweep
  to: engine.geometry
  layer: modeling
  uuid: ndjhce3D
- kind: modifies
  from: op.offset
  to: engine.geometry
  layer: modeling
  uuid: uPHMwCzD
- kind: modifies
  from: op.intersect_faces
  to: engine.geometry
  layer: modeling
  uuid: oYJh4MoJ
- kind: applies
  from: mod.array
  to: mesh.halfedge
  layer: modeling
  uuid: 8X2iKJTV
- kind: applies
  from: mod.mirror
  to: mesh.halfedge
  layer: modeling
  uuid: EnfFSB04
- kind: applies
  from: mod.smooth
  to: mesh.halfedge
  layer: modeling
  uuid: 3SK2FLXJ
- kind: applies
  from: constraint.on_axis
  to: curve.polyline
  layer: modeling
  uuid: 3XOmXlGM
- kind: applies
  from: constraint.parallel
  to: curve.polyline
  layer: modeling
  uuid: xrpXA49o
- kind: applies
  from: constraint.perpendicular
  to: curve.polyline
  layer: modeling
  uuid: 1x32F9yW
- kind: applies
  from: constraint.snap_point
  to: mesh.halfedge
  layer: modeling
  uuid: gg9LlRE4
- kind: computes
  from: engine.geometry
  to: mesh.halfedge
  layer: geometry
  x:
    docs:
      description: Geometry engine creates and modifies half-edge mesh topology.
  uuid: F5KUNvV8
- kind: computes
  from: engine.geometry
  to: curve.polyline
  layer: geometry
  x:
    docs:
      description: Geometry engine computes polyline curves for edges and construction lines.
  uuid: X4UG28wh
- kind: computes
  from: engine.geometry
  to: curve.arc
  layer: geometry
  x:
    docs:
      description: Geometry engine computes arc curves for circles and arcs.
  uuid: ccGQ7lsn
- kind: manages
  from: data.scene
  to: mesh.halfedge
  layer: data
  x:
    docs:
      description: Scene manager owns and manages all mesh entities in the scene graph.
  uuid: nlhnxT2s
- kind: manages
  from: data.scene
  to: curve.polyline
  layer: data
  uuid: uGQeKbrv
- kind: manages
  from: data.scene
  to: curve.arc
  layer: data
  uuid: KahcO8Zh
- kind: manages
  from: data.selection
  to: mesh.halfedge
  layer: data
  x:
    docs:
      description: Selection manager tracks which mesh entities (faces, edges, vertices) are selected.
  uuid: KN4N61os
- kind: manages
  from: data.selection
  to: curve.polyline
  layer: data
  uuid: QYrQbXbm
- kind: manages
  from: data.history
  to: op.extrude
  layer: data
  x:
    docs:
      description: History manager records extrude operations for undo/redo.
  uuid: 5k06u0OB
- kind: manages
  from: data.history
  to: op.sweep
  layer: data
  uuid: GugXptyf
- kind: manages
  from: data.history
  to: op.offset
  layer: data
  uuid: 5Rc0JuJO
- kind: manages
  from: data.history
  to: op.boolean_union
  layer: data
  uuid: IT2ZoMC6
- kind: manages
  from: data.history
  to: op.boolean_subtract
  layer: data
  uuid: 4CGlgr9M
- kind: manages
  from: data.history
  to: op.boolean_intersect
  layer: data
  uuid: 6ej10moX
- kind: manages
  from: data.history
  to: op.intersect_faces
  layer: data
  uuid: sQhgkYxU
- kind: manages
  from: data.history
  to: mod.array
  layer: data
  uuid: jBFNJm3F
- kind: manages
  from: data.history
  to: mod.mirror
  layer: data
  uuid: lW4OZgEh
- kind: manages
  from: data.history
  to: mod.smooth
  layer: data
  uuid: hsRciMuD
- kind: reads
  from: file.native
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Native format reads .scf project files from the file system.
  uuid: RdYsMK6Y
- kind: writes
  from: file.native
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Native format writes .scf project files to the file system.
  uuid: g6Ar310K
- kind: reads
  from: file.obj
  to: datastore.filesystem
  layer: data
  uuid: VATnYRzl
- kind: writes
  from: file.obj
  to: datastore.filesystem
  layer: data
  uuid: LATS78M2
- kind: reads
  from: file.stl
  to: datastore.filesystem
  layer: data
  uuid: hXposepc
- kind: writes
  from: file.stl
  to: datastore.filesystem
  layer: data
  uuid: lv20gqUD
- kind: reads
  from: file.gltf
  to: datastore.filesystem
  layer: data
  uuid: KwTlSzrw
- kind: writes
  from: file.gltf
  to: datastore.filesystem
  layer: data
  uuid: c5fv9VdA
- kind: reads
  from: file.dxf
  to: datastore.filesystem
  layer: data
  uuid: 3GfRdhRu
- kind: writes
  from: file.dxf
  to: datastore.filesystem
  layer: data
  uuid: z57Ssy2m
- kind: reads
  from: file.step
  to: datastore.filesystem
  layer: data
  uuid: purY0R7r
- kind: reads
  from: data.scene
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Scene manager reads project files on open.
  uuid: ltD2VRC4
- kind: writes
  from: data.scene
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Scene manager writes project files on save.
  uuid: pP0K4wyA
- kind: reads
  from: data.scene
  to: datastore.preferences
  layer: data
  x:
    docs:
      description: Scene manager reads user preferences for defaults.
  uuid: q4TmwrBi
- kind: writes
  from: data.history
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: History writes auto-save recovery data.
  uuid: CZ8is5tO
- kind: contains
  from: process.main
  to: worker.mesh
  layer: system
  uuid: 2TXXmZAJ
- kind: contains
  from: process.main
  to: worker.fileio
  layer: system
  uuid: CwObZPZ5
- kind: contains
  from: process.main
  to: native.manifold
  layer: system
  uuid: myV2WhaQ
- kind: contains
  from: process.renderer
  to: window.main
  layer: system
  uuid: kXDlkrzS
- kind: contains
  from: process.renderer
  to: viewport.main
  layer: system
  uuid: qXk1Ilhc
- kind: contains
  from: process.renderer
  to: renderer.webgl
  layer: system
  uuid: 3EY2N99A
- kind: contains
  from: process.renderer
  to: data.scene
  layer: system
  uuid: ExIh1YqI
- kind: contains
  from: process.renderer
  to: data.selection
  layer: system
  uuid: rpuGOnqT
- kind: contains
  from: process.renderer
  to: data.history
  layer: system
  uuid: V22OtWfn
- kind: sends
  from: process.renderer
  to: process.main
  layer: system
  x:
    electron:
      ipcChannel: file:open
    docs:
      description: Renderer requests main process to show file open dialog and read file contents.
  uuid: 24d7pL7z
- kind: sends
  from: process.renderer
  to: process.main
  layer: system
  x:
    electron:
      ipcChannel: file:save
    docs:
      description: Renderer sends project data to main process for file save (with native dialog).
  uuid: 3M5yIvCH
- kind: sends
  from: process.renderer
  to: process.main
  layer: system
  x:
    electron:
      ipcChannel: file:export
    docs:
      description: Renderer requests export operation through main process file dialog.
  uuid: FqSlwakD
- kind: receives
  from: process.renderer
  to: process.main
  layer: system
  x:
    electron:
      ipcChannel: file:data
    docs:
      description: Renderer receives file data from main process after open/read.
  uuid: csc8rPfk
- kind: sends
  from: process.main
  to: process.renderer
  layer: system
  x:
    electron:
      ipcChannel: menu:action
    docs:
      description: Main process sends menu action events (New, Open, Save, Undo, Redo, etc.) to renderer.
  uuid: KsxmOKZT
- kind: invokes
  from: process.renderer
  to: process.main
  layer: system
  x:
    electron:
      ipcChannel: native:boolean
    docs:
      description: Renderer invokes main process to run boolean operations via Manifold native module.
  uuid: NFfQtjST
- kind: sends
  from: process.renderer
  to: worker.mesh
  layer: system
  x:
    docs:
      description: Renderer sends mesh data to mesh worker for background processing (boolean ops, triangulation).
  uuid: U7Rpg4oV
- kind: sends
  from: process.renderer
  to: worker.fileio
  layer: system
  x:
    docs:
      description: Renderer sends file data to file I/O worker for background parsing/generation.
  uuid: OM1h8nPo
- kind: receives
  from: process.renderer
  to: worker.mesh
  layer: system
  x:
    docs:
      description: Renderer receives processed mesh results from mesh worker.
  uuid: RpDoqX9u
- kind: receives
  from: process.renderer
  to: worker.fileio
  layer: system
  x:
    docs:
      description: Renderer receives parsed geometry data from file I/O worker.
  uuid: ZMPbMwsP
- kind: computes
  from: worker.mesh
  to: mesh.halfedge
  layer: system
  x:
    docs:
      description: Mesh worker performs heavy mesh computations (boolean, triangulation) off the UI thread.
  uuid: C2D0AH2j
- kind: computes
  from: worker.mesh
  to: solid.manifold
  layer: system
  x:
    docs:
      description: Mesh worker runs Manifold CSG boolean operations.
  uuid: 9KWZRkYF
- kind: computes
  from: native.manifold
  to: solid.manifold
  layer: system
  x:
    docs:
      description: Manifold WASM module performs native-speed CSG boolean computation.
  uuid: aAHXvGWn
- kind: implements
  from: native.manifold
  to: solid.manifold
  layer: system
  x:
    docs:
      description: Manifold WASM module implements the solid boolean operations engine.
  uuid: YiopKL5s
- kind: depends_on
  from: process.main
  to: lib.electron
  layer: system
  x:
    docs:
      description: Main process runs on the Electron framework.
  uuid: zlE0l8OA
- kind: depends_on
  from: process.renderer
  to: lib.electron
  layer: system
  x:
    docs:
      description: Renderer process runs inside Electron's Chromium.
  uuid: KN7z11Y8
- kind: depends_on
  from: process.renderer
  to: lib.threejs
  layer: system
  x:
    docs:
      description: Renderer process uses Three.js for 3D rendering.
  uuid: NgxcmgvV
- kind: depends_on
  from: process.renderer
  to: lib.react
  layer: system
  x:
    docs:
      description: Renderer process uses React for UI components.
  uuid: sUhWeFLg
- kind: depends_on
  from: worker.mesh
  to: lib.manifold_wasm
  layer: system
  x:
    docs:
      description: Mesh worker loads Manifold WASM for boolean operations.
  uuid: UfXzsAS6
- kind: depends_on
  from: native.manifold
  to: lib.manifold_wasm
  layer: system
  x:
    docs:
      description: Native module wraps the Manifold WASM library.
  uuid: NJ7BaOIZ
- kind: uses
  from: engine.geometry
  to: native.manifold
  layer: geometry
  x:
    docs:
      description: Geometry engine delegates solid boolean operations to Manifold native module.
  uuid: GJHg47U3
- kind: extends
  from: plugin.system
  to: tool.select
  layer: system
  x:
    docs:
      description: Plugin system can extend with new tools registered alongside built-in tools.
  uuid: 9PUQefvX
- kind: extends
  from: plugin.system
  to: op.extrude
  layer: system
  x:
    docs:
      description: Plugin system can register new operations alongside built-in operations.
  uuid: UuphG2Y6
- kind: extends
  from: plugin.system
  to: file.native
  layer: system
  x:
    docs:
      description: Plugin system can register new file format importers/exporters.
  uuid: ubMqFS31
- kind: invokes
  from: tool.solid_tools
  to: op.boolean_union
  layer: interaction
  x:
    docs:
      description: Solid Tools invokes boolean union when Union mode is selected.
  uuid: PBsLOoN7
- kind: invokes
  from: tool.solid_tools
  to: op.boolean_subtract
  layer: interaction
  x:
    docs:
      description: Solid Tools invokes boolean subtract when Subtract mode is selected.
  uuid: 0UT4wuzx
- kind: invokes
  from: tool.solid_tools
  to: op.boolean_intersect
  layer: interaction
  x:
    docs:
      description: Solid Tools invokes boolean intersect when Intersect mode is selected.
  uuid: SfAEKM7y
- kind: modifies
  from: tool.solid_tools
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Solid Tools modifies the scene by replacing input solids with boolean result.
  uuid: QGL56miU
- kind: modifies
  from: tool.solid_tools
  to: data.selection
  layer: interaction
  x:
    docs:
      description: Solid Tools selects the resulting solid after operation.
  uuid: yx343191
- kind: modifies
  from: tool.section_plane
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Section Plane tool adds/modifies section plane entities in the scene.
  uuid: 0iTWImTk
- kind: uses
  from: tool.section_plane
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Section Plane tool uses snap points to align to faces.
  uuid: 2UBCXdi6
- kind: modifies
  from: tool.circle
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Circle tool creates edges and a face forming a circle polygon in the scene.
  uuid: 445PqISX
- kind: uses
  from: tool.circle
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Circle tool snaps center point to existing geometry.
  uuid: A8McL5Ln
- kind: uses
  from: tool.circle
  to: constraint.on_axis
  layer: interaction
  x:
    docs:
      description: Circle tool uses axis constraints for orientation.
  uuid: TvQj1NKy
- kind: uses
  from: tool.circle
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Circle tool uses distance constraint for VCB radius input.
  uuid: gmDSdVi4
- kind: modifies
  from: tool.arc
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Arc tool creates arc edges in the scene.
  uuid: 1bdqwc6f
- kind: uses
  from: tool.arc
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Arc tool snaps start/end points to existing geometry.
  uuid: YiDfWlMu
- kind: uses
  from: tool.arc
  to: constraint.on_axis
  layer: interaction
  x:
    docs:
      description: Arc tool uses axis constraints.
  uuid: SlBT8Ivc
- kind: uses
  from: tool.arc
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Arc tool uses distance constraint for VCB radius/bulge input.
  uuid: vq52F5w5
- kind: modifies
  from: tool.polygon
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Polygon tool creates polygon edges and face in the scene.
  uuid: Zp8S84Lw
- kind: uses
  from: tool.polygon
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Polygon tool snaps center to existing geometry.
  uuid: DJ6oBt03
- kind: uses
  from: tool.polygon
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Polygon tool uses distance constraint for radius VCB input.
  uuid: l6OwKJkc
- kind: modifies
  from: tool.tape_measure
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Tape Measure creates construction lines and points in the scene.
  uuid: 5sKisECl
- kind: uses
  from: tool.tape_measure
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Tape Measure snaps to endpoints, midpoints, edges.
  uuid: zztMqkU2
- kind: uses
  from: tool.tape_measure
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Tape Measure uses distance constraint for offset input.
  uuid: osIpH2l6
- kind: modifies
  from: tool.protractor
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Protractor creates angular construction lines in the scene.
  uuid: uhsFZwjq
- kind: uses
  from: tool.protractor
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Protractor snaps vertex to existing geometry.
  uuid: SdcaqW1h
- kind: modifies
  from: tool.dimension
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Dimension tool adds dimension annotation entities to the scene.
  uuid: d98yVyqa
- kind: uses
  from: tool.dimension
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Dimension tool snaps endpoints to geometry.
  uuid: ugb0p1e3
- kind: modifies
  from: tool.text
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Text tool adds label/3D text entities to the scene.
  uuid: TKzz3wqC
- kind: uses
  from: tool.text
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Text tool snaps anchor to geometry.
  uuid: A5xzmUvb
- kind: modifies
  from: tool.sweep_tool
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Sweep modifies scene with swept geometry.
  uuid: 77uSsXOZ
- kind: uses
  from: tool.sweep_tool
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Sweep snaps to edges for path selection.
  uuid: rVRHl4mS
- kind: modifies
  from: tool.orbit
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Orbit tool modifies the scene's active camera view state.
  uuid: trOZV4dc
- kind: modifies
  from: tool.pan
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Pan tool modifies the scene's camera position.
  uuid: oWTQbY3d
- kind: modifies
  from: tool.zoom
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Zoom tool modifies the scene's camera zoom/FOV.
  uuid: ul1FEIF3
- kind: uses
  from: tool.paint
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Paint Bucket snaps to faces for material application.
  uuid: 3sJU95pA
- kind: uses
  from: tool.eraser
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Eraser snaps to edges for deletion.
  uuid: Phuatr2c
- kind: uses
  from: tool.scale
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Scale tool snaps grip handles to geometry.
  uuid: F5r82bnn
- kind: uses
  from: tool.scale
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Scale tool uses distance for VCB scale factor input.
  uuid: ms4UYB31
- kind: uses
  from: tool.offset
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Offset tool snaps to face boundaries.
  uuid: STqe5U2u
- kind: uses
  from: tool.offset
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Offset tool uses distance for VCB offset input.
  uuid: or4ZlphS
- kind: uses
  from: tool.rotate
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Rotate tool snaps center/angle to geometry.
  uuid: 2JwiX4gF
- kind: uses
  from: tool.rotate
  to: constraint.on_axis
  layer: interaction
  x:
    docs:
      description: Rotate tool uses axis constraints for rotation axis locking.
  uuid: VCC8K1cv
- kind: uses
  from: tool.rotate
  to: constraint.distance
  layer: interaction
  x:
    docs:
      description: Rotate tool uses distance for VCB angle input.
  uuid: x3lcvLyJ
- kind: applies
  from: op.fillet
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Fillet operation creates rounded edge faces in the mesh.
  uuid: D1E7Ac8w
- kind: modifies
  from: op.fillet
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Fillet modifies geometry through the core engine.
  uuid: L2SWN7Gp
- kind: applies
  from: op.chamfer
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Chamfer operation creates beveled edge faces in the mesh.
  uuid: vuM2Hob2
- kind: modifies
  from: op.chamfer
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Chamfer modifies geometry through the core engine.
  uuid: IMJpzpkp
- kind: manages
  from: data.history
  to: op.subdivide
  layer: data
  x:
    docs:
      description: History records subdivide operations for undo/redo.
  uuid: cn6KcOYd
- kind: manages
  from: data.history
  to: op.triangulate
  layer: data
  x:
    docs:
      description: History records triangulate operations for undo/redo.
  uuid: dYJcV9ch
- kind: manages
  from: data.history
  to: op.fillet
  layer: data
  x:
    docs:
      description: History records fillet operations for undo/redo.
  uuid: qwktMJYx
- kind: manages
  from: data.history
  to: op.chamfer
  layer: data
  x:
    docs:
      description: History records chamfer operations for undo/redo.
  uuid: jMBCBzQO
- kind: computes
  from: engine.inference
  to: mesh.halfedge
  layer: geometry
  x:
    docs:
      description: Inference engine queries mesh geometry for snap point candidates (endpoints, midpoints, on-edge, on-face).
  uuid: DPXmOzGh
- kind: computes
  from: engine.inference
  to: curve.polyline
  layer: geometry
  x:
    docs:
      description: Inference engine computes construction lines and inference guide geometry as polylines.
  uuid: 4CZ6VwmG
- kind: computes
  from: engine.inference
  to: curve.arc
  layer: geometry
  x:
    docs:
      description: Inference engine computes tangent and arc snap targets.
  uuid: fAej7Ll8
- kind: modifies
  from: constraint.on_axis
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: On-axis constraint feeds axis-aligned inference rules into the inference engine.
  uuid: 34hq7TN8
- kind: modifies
  from: constraint.parallel
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Parallel constraint feeds parallel inference rules into the inference engine.
  uuid: rIcNLDlV
- kind: modifies
  from: constraint.perpendicular
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Perpendicular constraint feeds perpendicular inference rules into the inference engine.
  uuid: z9tzqzax
- kind: modifies
  from: constraint.snap_point
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Snap point constraint feeds point-snap rules into the inference engine.
  uuid: oAi9Ze76
- kind: modifies
  from: constraint.distance
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Distance constraint feeds VCB distance rules into the inference engine.
  uuid: U68tghVS
- kind: manages
  from: data.materials
  to: mesh.halfedge
  layer: data
  x:
    docs:
      description: Material manager manages material assignments on mesh faces.
  uuid: KKgcazCK
- kind: reads
  from: data.materials
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Material manager reads texture files and material libraries from the file system.
  uuid: Hv150PzH
- kind: writes
  from: data.materials
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Material manager writes custom material libraries to the file system.
  uuid: UulQwbG6
- kind: reads
  from: file.fbx
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: FBX format reads .fbx files from the file system.
  uuid: MSpvxWuK
- kind: writes
  from: file.fbx
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: FBX format writes .fbx files to the file system.
  uuid: QXYCzRQn
- kind: implements
  from: native.opencascade
  to: engine.geometry
  layer: system
  x:
    docs:
      description: OpenCascade WASM implements B-Rep operations for STEP/IGES file parsing.
  uuid: aUabPP3z
- kind: depends_on
  from: native.opencascade
  to: lib.opencascade_wasm
  layer: system
  x:
    docs:
      description: OpenCascade native module wraps the opencascade.js WASM library.
  uuid: RWr5M7PK
- kind: depends_on
  from: worker.fileio
  to: lib.opencascade_wasm
  layer: system
  x:
    docs:
      description: File I/O worker loads OpenCascade WASM on demand for STEP import.
  uuid: Btt5iou4
- kind: contains
  from: process.main
  to: native.opencascade
  layer: system
  x:
    docs:
      description: Main process contains the OpenCascade WASM native module.
  uuid: dUsDo93F
- kind: contains
  from: process.renderer
  to: data.materials
  layer: system
  x:
    docs:
      description: Renderer process contains the material manager.
  uuid: aLkZ6dnx
- kind: triggers
  from: toolbar.drawing
  to: tool.solid_tools
  layer: ui
  x:
    docs:
      description: Drawing toolbar triggers the Solid Tools tool.
  uuid: PkcUcERF
- kind: triggers
  from: toolbar.views
  to: tool.section_plane
  layer: ui
  x:
    docs:
      description: Views toolbar triggers the Section Plane tool.
  uuid: 202wMdep
- kind: triggers
  from: toolbar.views
  to: tool.orbit
  layer: ui
  x:
    docs:
      description: Views toolbar triggers the Orbit view tool.
  uuid: hJREeMKn
- kind: triggers
  from: toolbar.views
  to: tool.pan
  layer: ui
  x:
    docs:
      description: Views toolbar triggers the Pan view tool.
  uuid: cKKaekGQ
- kind: triggers
  from: toolbar.views
  to: tool.zoom
  layer: ui
  x:
    docs:
      description: Views toolbar triggers the Zoom view tool.
  uuid: QT6CF0Gm
- kind: triggers
  from: panel.outliner
  to: tool.select
  layer: ui
  x:
    docs:
      description: Clicking items in the Outliner triggers selection changes.
  uuid: 2R1o5ACD
- kind: triggers
  from: panel.layers
  to: tool.select
  layer: ui
  x:
    docs:
      description: Layer visibility toggles affect selection state.
  uuid: FIeLmFS4
- kind: triggers
  from: panel.components
  to: tool.select
  layer: ui
  x:
    docs:
      description: Clicking a component in the panel triggers selection.
  uuid: Xz9R604u
- kind: modifies
  from: tool.pushpull
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Push/Pull modifies scene geometry by extruding faces.
  uuid: cxi92ePw
- kind: applies
  from: op.extrude
  to: solid.manifold
  layer: modeling
  x:
    docs:
      description: Extrude delegates to Manifold when pushing into existing solid geometry (boolean cut).
  uuid: IJvBy8Jg
- kind: modifies
  from: op.boolean_union
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Boolean union modifies geometry through the core engine.
  uuid: g8AjI2TK
- kind: modifies
  from: op.boolean_subtract
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Boolean subtract modifies geometry through the core engine.
  uuid: SVb1FLiS
- kind: modifies
  from: op.boolean_intersect
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Boolean intersect modifies geometry through the core engine.
  uuid: M1wcODeS
- kind: modifies
  from: op.subdivide
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Subdivide modifies geometry through the core engine.
  uuid: DDu7HJsl
- kind: modifies
  from: op.triangulate
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Triangulate modifies geometry through the core engine.
  uuid: o9xxJS32
- kind: modifies
  from: mod.array
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Array modifier modifies geometry through the core engine.
  uuid: ke2L3MuJ
- kind: modifies
  from: mod.mirror
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Mirror modifier modifies geometry through the core engine.
  uuid: 2HgTbhmA
- kind: modifies
  from: mod.smooth
  to: engine.geometry
  layer: modeling
  x:
    docs:
      description: Smooth modifier modifies geometry through the core engine.
  uuid: hvBIrLaP
- kind: tests
  from: test.e2e.tools
  to: tool.select
  layer: testing
  uuid: zdILIdF9
- kind: tests
  from: test.e2e.tools
  to: tool.line
  layer: testing
  uuid: b9Fp1HXW
- kind: tests
  from: test.e2e.tools
  to: tool.rectangle
  layer: testing
  uuid: IBBKsdyk
- kind: tests
  from: test.e2e.tools
  to: tool.circle
  layer: testing
  uuid: MPuKa6VG
- kind: tests
  from: test.e2e.tools
  to: tool.arc
  layer: testing
  uuid: fJ9Tov9v
- kind: tests
  from: test.e2e.tools
  to: tool.polygon
  layer: testing
  uuid: 2H4Z2nzj
- kind: tests
  from: test.e2e.tools
  to: tool.pushpull
  layer: testing
  uuid: jjcxWtvx
- kind: tests
  from: test.e2e.tools
  to: tool.move
  layer: testing
  uuid: A28k37bO
- kind: tests
  from: test.e2e.tools
  to: tool.rotate
  layer: testing
  uuid: HzEO7Mks
- kind: tests
  from: test.e2e.tools
  to: tool.scale
  layer: testing
  uuid: lCIfsQrW
- kind: tests
  from: test.e2e.tools
  to: tool.offset
  layer: testing
  uuid: zqL0YF7K
- kind: tests
  from: test.e2e.tools
  to: tool.eraser
  layer: testing
  uuid: repl9RqL
- kind: tests
  from: test.e2e.tools
  to: tool.paint
  layer: testing
  uuid: BgtY1lzQ
- kind: tests
  from: test.e2e.tools
  to: tool.orbit
  layer: testing
  uuid: G4Ec3H3R
- kind: tests
  from: test.e2e.tools
  to: tool.pan
  layer: testing
  uuid: xowGozkq
- kind: tests
  from: test.e2e.tools
  to: tool.zoom
  layer: testing
  uuid: holOrEgW
- kind: tests
  from: test.e2e.tools
  to: tool.tape_measure
  layer: testing
  uuid: f9yOo5oS
- kind: tests
  from: test.e2e.tools
  to: tool.protractor
  layer: testing
  uuid: YdDvPG1D
- kind: tests
  from: test.e2e.tools
  to: tool.dimension
  layer: testing
  uuid: jX4Doo94
- kind: tests
  from: test.e2e.tools
  to: tool.text
  layer: testing
  uuid: BllavggJ
- kind: tests
  from: test.e2e.tools
  to: tool.sweep_tool
  layer: testing
  uuid: iaG1R91j
- kind: tests
  from: test.e2e.tools
  to: tool.solid_tools
  layer: testing
  uuid: XYRsBDqD
- kind: tests
  from: test.e2e.tools
  to: tool.section_plane
  layer: testing
  uuid: 7qAGsG6M
- kind: tests
  from: test.e2e.tools
  to: test.fixture.models
  layer: testing
  uuid: dvzPcCca
- kind: uses
  from: test.e2e.tools
  to: test.fixture.models
  layer: testing
  uuid: MM9Kh56L
- kind: depends_on
  from: test.e2e.tools
  to: lib.playwright
  layer: testing
  uuid: T1jiftzF
- kind: tests
  from: test.e2e.file_io
  to: file.native
  layer: testing
  uuid: ZVeZWoIT
- kind: tests
  from: test.e2e.file_io
  to: file.obj
  layer: testing
  uuid: pyF4rJll
- kind: tests
  from: test.e2e.file_io
  to: file.stl
  layer: testing
  uuid: xBHjQZxQ
- kind: tests
  from: test.e2e.file_io
  to: file.gltf
  layer: testing
  uuid: l8S8CQnM
- kind: tests
  from: test.e2e.file_io
  to: file.dxf
  layer: testing
  uuid: 2GHbDUKN
- kind: tests
  from: test.e2e.file_io
  to: file.step
  layer: testing
  uuid: MRmWFKqJ
- kind: tests
  from: test.e2e.file_io
  to: file.fbx
  layer: testing
  uuid: pu3K7T45
- kind: tests
  from: test.e2e.file_io
  to: window.main
  layer: testing
  uuid: h1YS7Ho6
- kind: tests
  from: test.e2e.file_io
  to: worker.fileio
  layer: testing
  uuid: d9exRkhe
- kind: uses
  from: test.e2e.file_io
  to: test.fixture.models
  layer: testing
  uuid: H4ZS7eX0
- kind: depends_on
  from: test.e2e.file_io
  to: lib.playwright
  layer: testing
  uuid: 7DwOgWVw
- kind: tests
  from: test.e2e.ui
  to: window.main
  layer: testing
  uuid: AbPZ2qIo
- kind: tests
  from: test.e2e.ui
  to: window.preferences
  layer: testing
  uuid: VinnYLmi
- kind: tests
  from: test.e2e.ui
  to: window.materials
  layer: testing
  uuid: NoOMeyOZ
- kind: tests
  from: test.e2e.ui
  to: renderer.webgl
  layer: testing
  uuid: kuY84B10
- kind: depends_on
  from: test.e2e.ui
  to: lib.playwright
  layer: testing
  uuid: Aln6EI4X
- kind: tests
  from: test.integration.geometry
  to: mesh.halfedge
  layer: testing
  uuid: D5aT7PzI
- kind: tests
  from: test.integration.geometry
  to: solid.manifold
  layer: testing
  uuid: MilYIXjO
- kind: tests
  from: test.integration.geometry
  to: curve.polyline
  layer: testing
  uuid: Gmue61Xv
- kind: tests
  from: test.integration.geometry
  to: curve.arc
  layer: testing
  uuid: EjCVZowk
- kind: tests
  from: test.integration.geometry
  to: geometry_engine
  layer: testing
  x:
    docs:
      description: Tests core geometry engine operations
  uuid: lLi4hROJ
- kind: tests
  from: test.integration.geometry
  to: op.extrude
  layer: testing
  uuid: nGIoue9f
- kind: tests
  from: test.integration.geometry
  to: op.sweep
  layer: testing
  uuid: y8pK7f2h
- kind: tests
  from: test.integration.geometry
  to: op.offset
  layer: testing
  uuid: MMNYORxZ
- kind: tests
  from: test.integration.geometry
  to: op.boolean_union
  layer: testing
  uuid: LDgWGCmf
- kind: tests
  from: test.integration.geometry
  to: op.boolean_subtract
  layer: testing
  uuid: elCJWiwV
- kind: tests
  from: test.integration.geometry
  to: op.boolean_intersect
  layer: testing
  uuid: QR3yBlsY
- kind: tests
  from: test.integration.geometry
  to: op.intersect_faces
  layer: testing
  uuid: wUXSqS5W
- kind: tests
  from: test.integration.geometry
  to: op.subdivide
  layer: testing
  uuid: tBKO8djA
- kind: tests
  from: test.integration.geometry
  to: op.triangulate
  layer: testing
  uuid: 2D6qVZKW
- kind: tests
  from: test.integration.geometry
  to: op.fillet
  layer: testing
  uuid: pnnUaJxh
- kind: tests
  from: test.integration.geometry
  to: op.chamfer
  layer: testing
  uuid: eW7teD6c
- kind: uses
  from: test.integration.geometry
  to: test.fixture.models
  layer: testing
  uuid: 08LiW0pL
- kind: depends_on
  from: test.integration.geometry
  to: lib.vitest
  layer: testing
  uuid: ZUAYVD7Q
- kind: tests
  from: test.integration.scene
  to: scene_manager
  layer: testing
  x:
    docs:
      description: Tests scene graph hierarchy operations
  uuid: FyNfsBPM
- kind: tests
  from: test.integration.scene
  to: data.selection
  layer: testing
  uuid: MBlmU3tj
- kind: tests
  from: test.integration.scene
  to: data.history
  layer: testing
  uuid: OMksuMzl
- kind: uses
  from: test.integration.scene
  to: test.fixture.models
  layer: testing
  uuid: 3uETL50f
- kind: depends_on
  from: test.integration.scene
  to: lib.vitest
  layer: testing
  uuid: hPTr4Usa
- kind: tests
  from: test.visual.rendering
  to: viewport.main
  layer: testing
  uuid: bY1YAekm
- kind: tests
  from: test.visual.rendering
  to: renderer.webgl
  layer: testing
  uuid: Vo6asLVJ
- kind: tests
  from: test.visual.rendering
  to: camera.main
  layer: testing
  uuid: rzRGe9xi
- kind: uses
  from: test.visual.rendering
  to: test.fixture.models
  layer: testing
  uuid: 2BTctu2V
- kind: depends_on
  from: test.visual.rendering
  to: lib.playwright
  layer: testing
  uuid: KB4JwVFZ
- kind: tests
  from: test.perf.geometry
  to: mesh.halfedge
  layer: testing
  uuid: RW6OzYY5
- kind: tests
  from: test.perf.geometry
  to: solid.manifold
  layer: testing
  uuid: 7fjDxBl4
- kind: tests
  from: test.perf.geometry
  to: op.extrude
  layer: testing
  uuid: jPtJsr3L
- kind: tests
  from: test.perf.geometry
  to: op.boolean_union
  layer: testing
  uuid: I4YlTx0u
- kind: tests
  from: test.perf.geometry
  to: native.manifold
  layer: testing
  uuid: gRG5S5pl
- kind: tests
  from: test.perf.geometry
  to: worker.mesh
  layer: testing
  uuid: MBp6QiNG
- kind: uses
  from: test.perf.geometry
  to: test.fixture.models
  layer: testing
  uuid: x4gF07ra
- kind: depends_on
  from: test.perf.geometry
  to: lib.vitest
  layer: testing
  uuid: MmWZMV43
- kind: tests
  from: test.perf.rendering
  to: viewport.main
  layer: testing
  uuid: p8ddYBmw
- kind: tests
  from: test.perf.rendering
  to: renderer.webgl
  layer: testing
  uuid: uArJHX43
- kind: uses
  from: test.perf.rendering
  to: test.fixture.models
  layer: testing
  uuid: kzTkm0ML
- kind: depends_on
  from: test.perf.rendering
  to: lib.playwright
  layer: testing
  uuid: p48qyTCs
- kind: depends_on
  from: test.fixture.models
  to: lib.vitest
  layer: testing
  uuid: IJOVCIgy
- kind: invokes
  from: tool.solid_tools
  to: op.boolean_union
  layer: interaction
  x:
    docs:
      description: Solid Tools invokes boolean union when Union mode is selected.
  uuid: fzTeSCjP
- kind: invokes
  from: tool.solid_tools
  to: op.boolean_subtract
  layer: interaction
  x:
    docs:
      description: Solid Tools invokes boolean subtract when Subtract mode is selected.
  uuid: iCxK5aLx
- kind: invokes
  from: tool.solid_tools
  to: op.boolean_intersect
  layer: interaction
  x:
    docs:
      description: Solid Tools invokes boolean intersect when Intersect mode is selected.
  uuid: fd4LWNAS
- kind: modifies
  from: tool.solid_tools
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Solid Tools replaces input solids with boolean result in the scene.
  uuid: GX66rPlZ
- kind: modifies
  from: tool.solid_tools
  to: data.selection
  layer: interaction
  x:
    docs:
      description: Solid Tools selects resulting solid after operation.
  uuid: D7D6ien4
- kind: modifies
  from: tool.section_plane
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Section Plane tool adds/modifies section plane entities in the scene.
  uuid: 1WG5OeX4
- kind: uses
  from: tool.section_plane
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Section Plane snaps to face normals for alignment.
  uuid: Ye5pjxBW
- kind: modifies
  from: tool.circle
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Circle tool creates polygon edges and face in the scene.
  uuid: YlNzuWb0
- kind: uses
  from: tool.circle
  to: constraint.snap_point
  layer: interaction
  uuid: eFjyXW4g
- kind: uses
  from: tool.circle
  to: constraint.on_axis
  layer: interaction
  uuid: SaS2X7CP
- kind: uses
  from: tool.circle
  to: constraint.distance
  layer: interaction
  uuid: DTB34DMp
- kind: modifies
  from: tool.arc
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Arc tool creates arc edges in the scene.
  uuid: WxonH1k3
- kind: uses
  from: tool.arc
  to: constraint.snap_point
  layer: interaction
  uuid: NUtUJHal
- kind: uses
  from: tool.arc
  to: constraint.on_axis
  layer: interaction
  uuid: ZxnbEy2a
- kind: uses
  from: tool.arc
  to: constraint.distance
  layer: interaction
  uuid: 05dmX1FH
- kind: modifies
  from: tool.polygon
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Polygon tool creates polygon edges and face in the scene.
  uuid: zbA7J4Qi
- kind: uses
  from: tool.polygon
  to: constraint.snap_point
  layer: interaction
  uuid: FTWQ6uEi
- kind: uses
  from: tool.polygon
  to: constraint.distance
  layer: interaction
  uuid: faMkSpMt
- kind: modifies
  from: tool.tape_measure
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Tape Measure creates construction lines and points in the scene.
  uuid: cbtBvl4K
- kind: uses
  from: tool.tape_measure
  to: constraint.snap_point
  layer: interaction
  uuid: h1SIWIA0
- kind: uses
  from: tool.tape_measure
  to: constraint.distance
  layer: interaction
  uuid: CGtP4bVU
- kind: modifies
  from: tool.protractor
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Protractor creates angular construction lines in the scene.
  uuid: zaK6DZ9P
- kind: uses
  from: tool.protractor
  to: constraint.snap_point
  layer: interaction
  uuid: KV1P2Hmi
- kind: modifies
  from: tool.dimension
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Dimension tool adds dimension annotations to the scene.
  uuid: dG1q8BfH
- kind: uses
  from: tool.dimension
  to: constraint.snap_point
  layer: interaction
  uuid: BWhX1ugv
- kind: modifies
  from: tool.text
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Text tool adds label/3D text entities to the scene.
  uuid: xspReKk3
- kind: uses
  from: tool.text
  to: constraint.snap_point
  layer: interaction
  uuid: 8KonGOvM
- kind: modifies
  from: tool.sweep_tool
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Sweep modifies scene with swept geometry.
  uuid: Np528sgd
- kind: uses
  from: tool.sweep_tool
  to: constraint.snap_point
  layer: interaction
  uuid: dfPhObc0
- kind: modifies
  from: tool.orbit
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Orbit modifies the active camera view state in the scene.
  uuid: Rr4wJy7u
- kind: modifies
  from: tool.pan
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Pan modifies camera position in the scene.
  uuid: CAs4l1GD
- kind: modifies
  from: tool.zoom
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Zoom modifies camera zoom/FOV in the scene.
  uuid: 4Os7R5tS
- kind: uses
  from: tool.paint
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Paint Bucket snaps to faces for material application.
  uuid: PfSxFLO8
- kind: uses
  from: tool.eraser
  to: constraint.snap_point
  layer: interaction
  x:
    docs:
      description: Eraser snaps to edges for deletion.
  uuid: PW61I7pw
- kind: uses
  from: tool.scale
  to: constraint.snap_point
  layer: interaction
  uuid: cVGpUukm
- kind: uses
  from: tool.scale
  to: constraint.distance
  layer: interaction
  uuid: 1bW52QSe
- kind: uses
  from: tool.offset
  to: constraint.snap_point
  layer: interaction
  uuid: t2XmAxYw
- kind: uses
  from: tool.offset
  to: constraint.distance
  layer: interaction
  uuid: uV9t2xG2
- kind: uses
  from: tool.rotate
  to: constraint.snap_point
  layer: interaction
  uuid: mQHY56k5
- kind: uses
  from: tool.rotate
  to: constraint.on_axis
  layer: interaction
  uuid: azvxgnNi
- kind: uses
  from: tool.rotate
  to: constraint.distance
  layer: interaction
  uuid: CWWD7V4a
- kind: modifies
  from: tool.pushpull
  to: data.scene
  layer: interaction
  x:
    docs:
      description: Push/Pull modifies scene geometry by extruding faces.
  uuid: qqJsrivi
- kind: applies
  from: op.fillet
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Fillet creates rounded edge faces in the mesh.
  uuid: Nyw3VTCl
- kind: modifies
  from: op.fillet
  to: engine.geometry
  layer: modeling
  uuid: hV5jCK8N
- kind: applies
  from: op.chamfer
  to: mesh.halfedge
  layer: modeling
  x:
    docs:
      description: Chamfer creates beveled edge faces in the mesh.
  uuid: tK538QJf
- kind: modifies
  from: op.chamfer
  to: engine.geometry
  layer: modeling
  uuid: JsAdUgnp
- kind: manages
  from: data.history
  to: op.subdivide
  layer: data
  uuid: ewBg1mCS
- kind: manages
  from: data.history
  to: op.triangulate
  layer: data
  uuid: yapaL6B2
- kind: manages
  from: data.history
  to: op.fillet
  layer: data
  uuid: SPwe5tQR
- kind: manages
  from: data.history
  to: op.chamfer
  layer: data
  uuid: JK2XV7CH
- kind: applies
  from: op.extrude
  to: solid.manifold
  layer: modeling
  x:
    docs:
      description: Extrude delegates to Manifold when pushing into existing solid (boolean cut).
  uuid: D2U6H699
- kind: modifies
  from: op.boolean_union
  to: engine.geometry
  layer: modeling
  uuid: f5z1aEfl
- kind: modifies
  from: op.boolean_subtract
  to: engine.geometry
  layer: modeling
  uuid: VUUOkCH1
- kind: modifies
  from: op.boolean_intersect
  to: engine.geometry
  layer: modeling
  uuid: s6My3UuP
- kind: modifies
  from: op.subdivide
  to: engine.geometry
  layer: modeling
  uuid: ORnEh1F1
- kind: modifies
  from: op.triangulate
  to: engine.geometry
  layer: modeling
  uuid: dzXqZPPx
- kind: modifies
  from: mod.array
  to: engine.geometry
  layer: modeling
  uuid: OiQiDEPV
- kind: modifies
  from: mod.mirror
  to: engine.geometry
  layer: modeling
  uuid: b3OtQQHZ
- kind: modifies
  from: mod.smooth
  to: engine.geometry
  layer: modeling
  uuid: 8g5dvGJH
- kind: computes
  from: engine.inference
  to: mesh.halfedge
  layer: geometry
  x:
    docs:
      description: Inference engine queries mesh for snap point candidates (endpoints, midpoints, on-edge, on-face).
  uuid: 6FGQGENr
- kind: computes
  from: engine.inference
  to: curve.polyline
  layer: geometry
  x:
    docs:
      description: Inference engine computes construction lines and guide geometry as polylines.
  uuid: j0Efqhiw
- kind: computes
  from: engine.inference
  to: curve.arc
  layer: geometry
  x:
    docs:
      description: Inference engine computes arc/tangent snap targets.
  uuid: FSTRVJfM
- kind: modifies
  from: constraint.on_axis
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: On-axis constraint feeds axis inference rules into the inference engine.
  uuid: pV1JypEv
- kind: modifies
  from: constraint.parallel
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Parallel constraint feeds parallel inference rules into the inference engine.
  uuid: 5kcAjvAw
- kind: modifies
  from: constraint.perpendicular
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Perpendicular constraint feeds perpendicular inference rules into the inference engine.
  uuid: dAPD2DIU
- kind: modifies
  from: constraint.snap_point
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Snap point constraint feeds point-snap rules into the inference engine.
  uuid: Q4YjCjlq
- kind: modifies
  from: constraint.distance
  to: engine.inference
  layer: modeling
  x:
    docs:
      description: Distance constraint feeds VCB distance rules into the inference engine.
  uuid: Ngj7Mp6e
- kind: manages
  from: data.materials
  to: mesh.halfedge
  layer: data
  x:
    docs:
      description: Material manager manages material assignments on mesh faces.
  uuid: 5ACDrCvk
- kind: reads
  from: data.materials
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Material manager reads texture files and material libraries from file system.
  uuid: j5ze5EEj
- kind: writes
  from: data.materials
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Material manager writes custom material libraries to file system.
  uuid: dff1MCEZ
- kind: reads
  from: file.fbx
  to: datastore.filesystem
  layer: data
  uuid: SrpYyYWo
- kind: writes
  from: file.fbx
  to: datastore.filesystem
  layer: data
  uuid: SPPfnKy9
- kind: implements
  from: native.opencascade
  to: engine.geometry
  layer: system
  x:
    docs:
      description: OpenCascade WASM implements B-Rep operations for STEP/IGES file parsing.
  uuid: kwsNp3J7
- kind: depends_on
  from: native.opencascade
  to: lib.opencascade_wasm
  layer: system
  uuid: jUIPHx0H
- kind: depends_on
  from: worker.fileio
  to: lib.opencascade_wasm
  layer: system
  x:
    docs:
      description: File I/O worker loads OpenCascade WASM on demand for STEP import.
  uuid: p46SiU5r
- kind: contains
  from: process.main
  to: native.opencascade
  layer: system
  uuid: 3T8Ma6lH
- kind: contains
  from: process.renderer
  to: data.materials
  layer: system
  uuid: q5msYnmu
- kind: triggers
  from: toolbar.drawing
  to: tool.solid_tools
  layer: ui
  uuid: nvVgarIR
- kind: triggers
  from: toolbar.views
  to: tool.section_plane
  layer: ui
  uuid: 6yXW5OoH
- kind: triggers
  from: toolbar.views
  to: tool.orbit
  layer: ui
  uuid: fXd6e9ZE
- kind: triggers
  from: toolbar.views
  to: tool.pan
  layer: ui
  uuid: AH7Zs39A
- kind: triggers
  from: toolbar.views
  to: tool.zoom
  layer: ui
  uuid: 9DutGTBP
- kind: triggers
  from: panel.outliner
  to: tool.select
  layer: ui
  x:
    docs:
      description: Clicking items in the Outliner triggers selection changes.
  uuid: 4DaT4Rkh
- kind: triggers
  from: panel.layers
  to: tool.select
  layer: ui
  x:
    docs:
      description: Layer visibility toggles affect selection state.
  uuid: OYy9jbgz
- kind: triggers
  from: panel.components
  to: tool.select
  layer: ui
  x:
    docs:
      description: Clicking a component in the panel triggers selection.
  uuid: GV899yJo
- kind: tests
  from: test.integration.scene
  to: data.scene
  layer: testing
  uuid: VVu7qOb7
- kind: tests
  from: test.integration.geometry
  to: engine.geometry
  layer: testing
  uuid: YGfnFGOL
- kind: manages
  from: data.document
  to: mesh.halfedge
  layer: data
  x:
    docs:
      description: Document owns all mesh geometry in the model — vertices, edges, faces stored in the half-edge structure.
  uuid: N2XWXvEw
- kind: manages
  from: data.document
  to: solid.manifold
  layer: data
  x:
    docs:
      description: Document owns solid group/component designations used for boolean operations.
  uuid: jkAg9sUJ
- kind: manages
  from: data.document
  to: curve.polyline
  layer: data
  x:
    docs:
      description: Document owns all polyline curves (edges, construction lines).
  uuid: xuYbcnlr
- kind: manages
  from: data.document
  to: curve.arc
  layer: data
  x:
    docs:
      description: Document owns all arc curves (circles, arcs).
  uuid: yLRmquY4
- kind: reads
  from: data.document
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Document reads project files (.scf) from disk on File > Open. Deserializes geometry, materials, scene hierarchy,
        metadata, and scene pages into in-memory structures.
  uuid: G4m3OaRU
- kind: writes
  from: data.document
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Document writes project files (.scf) to disk on File > Save/Save As. Serializes all in-memory state. Also
        triggers auto-save to temp directory on interval.
  uuid: zUmBeFPS
- kind: reads
  from: data.document
  to: datastore.preferences
  layer: data
  x:
    docs:
      description: Document reads user preferences on creation (default units, template, grid settings) to initialize new
        documents.
  uuid: PMYCMOBI
- kind: renders
  from: viewport.main
  to: data.document
  layer: rendering
  x:
    docs:
      description: Viewport renders the document — traverses the document's scene graph to build the Three.js render scene.
  uuid: g1nC5zsB
- kind: contains
  from: process.renderer
  to: data.document
  layer: system
  x:
    docs:
      description: Renderer process contains the in-memory model document.
  uuid: ucKUFQCo
- kind: manages
  from: data.materials
  to: mesh.halfedge
  layer: data
  x:
    docs:
      description: Material manager manages material assignments on mesh faces. Each face stores a material index referencing
        a material definition managed here.
  uuid: YfCtjX75
- kind: reads
  from: data.materials
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Material manager reads texture image files (PNG/JPG) and material library JSON files from the file system.
        Textures loaded on demand and cached in GPU memory via Three.js TextureLoader.
  uuid: s1wGxyc9
- kind: writes
  from: data.materials
  to: datastore.filesystem
  layer: data
  x:
    docs:
      description: Material manager writes user-created material libraries and exported texture files to the file system.
  uuid: a1jZVZE9
- kind: contains
  from: process.renderer
  to: data.materials
  layer: system
  x:
    docs:
      description: Renderer process contains the material manager.
  uuid: wZE7EXVC
- kind: tests
  from: test.integration.scene
  to: data.document
  layer: testing
  x:
    docs:
      description: 'Scene integration tests cover the model document lifecycle: new, open, save, auto-save, dirty tracking,
        sub-manager coordination.'
  uuid: uFefaNb1
- kind: tests
  from: test.e2e.tools
  to: tool.select
  layer: testing
  uuid: AkvWH8uU
- kind: tests
  from: test.e2e.tools
  to: tool.line
  layer: testing
  uuid: AiiCPK6F
- kind: tests
  from: test.e2e.tools
  to: tool.rectangle
  layer: testing
  uuid: R5hPI7vr
- kind: tests
  from: test.e2e.tools
  to: tool.circle
  layer: testing
  uuid: oDIU5OQd
- kind: tests
  from: test.e2e.tools
  to: tool.arc
  layer: testing
  uuid: 2fd8O1aV
- kind: tests
  from: test.e2e.tools
  to: tool.polygon
  layer: testing
  uuid: uW59zw6o
- kind: tests
  from: test.e2e.tools
  to: tool.pushpull
  layer: testing
  uuid: 6bW01QGL
- kind: tests
  from: test.e2e.tools
  to: tool.move
  layer: testing
  uuid: aFvYRDpH
- kind: tests
  from: test.e2e.tools
  to: tool.rotate
  layer: testing
  uuid: kU3FDYLC
- kind: tests
  from: test.e2e.tools
  to: tool.scale
  layer: testing
  uuid: CT551s2j
- kind: tests
  from: test.e2e.tools
  to: tool.offset
  layer: testing
  uuid: c6hDEuyH
- kind: tests
  from: test.e2e.tools
  to: tool.eraser
  layer: testing
  uuid: eMhO4Wgf
- kind: tests
  from: test.e2e.tools
  to: tool.paint
  layer: testing
  uuid: OqKrnpAK
- kind: tests
  from: test.e2e.tools
  to: tool.orbit
  layer: testing
  uuid: UbAkUtC8
- kind: tests
  from: test.e2e.tools
  to: tool.pan
  layer: testing
  uuid: v0VajsdE
- kind: tests
  from: test.e2e.tools
  to: tool.zoom
  layer: testing
  uuid: 7baeruay
- kind: tests
  from: test.e2e.tools
  to: tool.tape_measure
  layer: testing
  uuid: xPcjrbT4
- kind: tests
  from: test.e2e.tools
  to: tool.protractor
  layer: testing
  uuid: Vm0buchF
- kind: tests
  from: test.e2e.tools
  to: tool.dimension
  layer: testing
  uuid: 2HLTzaO0
- kind: tests
  from: test.e2e.tools
  to: tool.text
  layer: testing
  uuid: eOOHI0Nd
- kind: tests
  from: test.e2e.tools
  to: tool.sweep_tool
  layer: testing
  uuid: BWxIAgT4
- kind: tests
  from: test.e2e.tools
  to: tool.solid_tools
  layer: testing
  uuid: jqDNyWz0
- kind: tests
  from: test.e2e.tools
  to: tool.section_plane
  layer: testing
  uuid: iwGqH2Y9
- kind: tests
  from: test.e2e.tools
  to: test.fixture.models
  layer: testing
  uuid: Kt95wouA
- kind: uses
  from: test.e2e.tools
  to: test.fixture.models
  layer: testing
  uuid: hlr3iIn5
- kind: depends_on
  from: test.e2e.tools
  to: lib.playwright
  layer: testing
  uuid: ypZ56svA
- kind: tests
  from: test.e2e.file_io
  to: file.native
  layer: testing
  uuid: VyUo1fY1
- kind: tests
  from: test.e2e.file_io
  to: file.obj
  layer: testing
  uuid: 3TrxR1Vw
- kind: tests
  from: test.e2e.file_io
  to: file.stl
  layer: testing
  uuid: mOYs7lvP
- kind: tests
  from: test.e2e.file_io
  to: file.gltf
  layer: testing
  uuid: VeLcMeNi
- kind: tests
  from: test.e2e.file_io
  to: file.dxf
  layer: testing
  uuid: Ox1q8MwB
- kind: tests
  from: test.e2e.file_io
  to: file.step
  layer: testing
  uuid: ZgKU75rS
- kind: tests
  from: test.e2e.file_io
  to: file.fbx
  layer: testing
  uuid: nk6OyK3E
- kind: tests
  from: test.e2e.file_io
  to: window.main
  layer: testing
  uuid: efKiJBHi
- kind: tests
  from: test.e2e.file_io
  to: worker.fileio
  layer: testing
  uuid: 5bwzOUIX
- kind: uses
  from: test.e2e.file_io
  to: test.fixture.models
  layer: testing
  uuid: Ndeio5Zq
- kind: depends_on
  from: test.e2e.file_io
  to: lib.playwright
  layer: testing
  uuid: xjRO2MLd
- kind: tests
  from: test.e2e.ui
  to: window.main
  layer: testing
  uuid: m8TIoLOI
- kind: tests
  from: test.e2e.ui
  to: window.preferences
  layer: testing
  uuid: 7SVc0bxm
- kind: tests
  from: test.e2e.ui
  to: window.materials
  layer: testing
  uuid: sGxnD2LD
- kind: tests
  from: test.e2e.ui
  to: renderer.webgl
  layer: testing
  uuid: xpCYo1lL
- kind: depends_on
  from: test.e2e.ui
  to: lib.playwright
  layer: testing
  uuid: n4LQGQcS
- kind: tests
  from: test.integration.geometry
  to: mesh.halfedge
  layer: testing
  uuid: xihugbaX
- kind: tests
  from: test.integration.geometry
  to: solid.manifold
  layer: testing
  uuid: y23uiIMO
- kind: tests
  from: test.integration.geometry
  to: curve.polyline
  layer: testing
  uuid: 6DbB26s2
- kind: tests
  from: test.integration.geometry
  to: curve.arc
  layer: testing
  uuid: BGv0NV4Y
- kind: tests
  from: test.integration.geometry
  to: engine.geometry
  layer: testing
  x:
    docs:
      description: Tests core geometry engine operations
  uuid: S3aOkrm8
- kind: tests
  from: test.integration.geometry
  to: op.extrude
  layer: testing
  uuid: glmp477k
- kind: tests
  from: test.integration.geometry
  to: op.sweep
  layer: testing
  uuid: 6moUbCmq
- kind: tests
  from: test.integration.geometry
  to: op.offset
  layer: testing
  uuid: CR8NS0J2
- kind: tests
  from: test.integration.geometry
  to: op.boolean_union
  layer: testing
  uuid: hn6wrSkJ
- kind: tests
  from: test.integration.geometry
  to: op.boolean_subtract
  layer: testing
  uuid: 6KMVxqSm
- kind: tests
  from: test.integration.geometry
  to: op.boolean_intersect
  layer: testing
  uuid: 6oC1oF3b
- kind: tests
  from: test.integration.geometry
  to: op.intersect_faces
  layer: testing
  uuid: 8aSNTJsg
- kind: tests
  from: test.integration.geometry
  to: op.subdivide
  layer: testing
  uuid: juyRMCCI
- kind: tests
  from: test.integration.geometry
  to: op.triangulate
  layer: testing
  uuid: ONagrteN
- kind: tests
  from: test.integration.geometry
  to: op.fillet
  layer: testing
  uuid: pAJQm1SI
- kind: tests
  from: test.integration.geometry
  to: op.chamfer
  layer: testing
  uuid: 02LEzxUU
- kind: uses
  from: test.integration.geometry
  to: test.fixture.models
  layer: testing
  uuid: M0Gk7yod
- kind: depends_on
  from: test.integration.geometry
  to: lib.vitest
  layer: testing
  uuid: R6wOfIKO
- kind: tests
  from: test.integration.scene
  to: data.scene
  layer: testing
  uuid: mISDDvMO
- kind: tests
  from: test.integration.scene
  to: data.selection
  layer: testing
  uuid: vsGc3Sdk
- kind: tests
  from: test.integration.scene
  to: data.history
  layer: testing
  uuid: q7jSn9jL
- kind: tests
  from: test.integration.scene
  to: data.document
  layer: testing
  x:
    docs:
      description: 'Scene integration tests cover the model document lifecycle: new, open, save, auto-save, dirty tracking,
        sub-manager coordination.'
  uuid: JFfUTKpu
- kind: uses
  from: test.integration.scene
  to: test.fixture.models
  layer: testing
  uuid: stNhpVGN
- kind: depends_on
  from: test.integration.scene
  to: lib.vitest
  layer: testing
  uuid: 2AKvuz2m
- kind: tests
  from: test.visual.rendering
  to: viewport.main
  layer: testing
  uuid: kpjbiIR1
- kind: tests
  from: test.visual.rendering
  to: renderer.webgl
  layer: testing
  uuid: qOySxKuU
- kind: tests
  from: test.visual.rendering
  to: camera.main
  layer: testing
  uuid: 5YZz5Ebw
- kind: uses
  from: test.visual.rendering
  to: test.fixture.models
  layer: testing
  uuid: M5igdfKy
- kind: depends_on
  from: test.visual.rendering
  to: lib.playwright
  layer: testing
  uuid: rtvIwXn5
- kind: tests
  from: test.perf.geometry
  to: mesh.halfedge
  layer: testing
  uuid: 1kTDWe4U
- kind: tests
  from: test.perf.geometry
  to: solid.manifold
  layer: testing
  uuid: wZDWSpzU
- kind: tests
  from: test.perf.geometry
  to: op.extrude
  layer: testing
  uuid: kgb6E1Lm
- kind: tests
  from: test.perf.geometry
  to: op.boolean_union
  layer: testing
  uuid: j6yNunFJ
- kind: tests
  from: test.perf.geometry
  to: native.manifold
  layer: testing
  uuid: gW3soCZF
- kind: tests
  from: test.perf.geometry
  to: worker.mesh
  layer: testing
  uuid: cKbAEGD4
- kind: uses
  from: test.perf.geometry
  to: test.fixture.models
  layer: testing
  uuid: zHyNbytG
- kind: depends_on
  from: test.perf.geometry
  to: lib.vitest
  layer: testing
  uuid: RQy5Ncxm
- kind: tests
  from: test.perf.rendering
  to: viewport.main
  layer: testing
  uuid: hZ0E9yVs
- kind: tests
  from: test.perf.rendering
  to: renderer.webgl
  layer: testing
  uuid: 79z2wtxl
- kind: uses
  from: test.perf.rendering
  to: test.fixture.models
  layer: testing
  uuid: oQnmYd7f
- kind: depends_on
  from: test.perf.rendering
  to: lib.playwright
  layer: testing
  uuid: rqoItzSx
- kind: depends_on
  from: test.fixture.models
  to: lib.vitest
  layer: testing
  uuid: 3haau5fb
# ── Paint tool / Materials / History integration edges ──
- kind: modifies
  from: tool.paint
  to: data.materials
  layer: interaction
  x:
    docs:
      description: Paint tool applies materials to faces via MaterialManager.applyToFace(). Wraps each paint operation in
        a history transaction for undo support.
  uuid: ePntMatM
- kind: reads
  from: tool.paint
  to: data.materials
  layer: interaction
  x:
    docs:
      description: Paint tool reads material assignments for Shift+click sampling (getFaceMaterial) and checks material existence.
  uuid: ePntMatR
- kind: reads
  from: panel.tool_settings
  to: data.materials
  layer: ui
  x:
    docs:
      description: ToolSettingsPanel reads all materials to display swatch grid with color/texture thumbnails.
  uuid: ePnlMatR
- kind: contains
  from: window.main
  to: panel.tool_settings
  layer: ui
  x:
    docs:
      description: Tool settings panel is rendered in the right sidebar of the main window layout.
  uuid: eWnPnlCn
- kind: manages
  from: data.history
  to: data.materials
  layer: data
  x:
    docs:
      description: History snapshots include serialized material face assignments. Undo/redo restores both geometry and material
        state atomically via packed binary format.
  uuid: eHstMatMg
- kind: reads
  from: bridge.scene
  to: data.materials
  layer: runtime
  x:
    docs:
      description: SceneBridge reads material definitions to apply PBR properties (color, roughness, metalness, opacity) and
        texture maps to Three.js mesh materials. Uses face-local UV projection for texture mapping.
  uuid: eSbMatRd
- kind: contains
  from: process.renderer
  to: api.model
  layer: system
  x:
    docs:
      description: Application instantiates and owns the ModelAPI, exposing it on window.modelAPI.
  uuid: ePrApiMd
- kind: calls
  from: api.model
  to: engine.geometry
  layer: runtime
  x:
    docs:
      description: ModelAPI delegates shape creation, transforms, and queries to the geometry engine.
  uuid: eApGeoEn
- kind: calls
  from: api.model
  to: data.materials
  layer: runtime
  x:
    docs:
      description: ModelAPI creates and assigns materials via the material manager.
  uuid: eApMatMg
- kind: calls
  from: api.model
  to: data.history
  layer: runtime
  x:
    docs:
      description: ModelAPI wraps every mutation in begin/commit transaction for automatic undo.
  uuid: eApHstMg
- kind: calls
  from: api.model
  to: data.selection
  layer: runtime
  x:
    docs:
      description: ModelAPI provides select/clear/selectAll operations.
  uuid: eApSelMg
- kind: uses
  from: plugin.system
  to: api.model
  layer: system
  x:
    docs:
      description: Plugins call ModelAPI to create geometry, apply materials, and query the model.
  uuid: ePlgApi
- kind: calls
  from: ai.chat
  to: api.model
  layer: runtime
  x:
    docs:
      description: AI chat executes tool calls (createBox, extrudeFace, moveEntities, etc.) against the ModelAPI.
  uuid: eAiApiMd
- kind: calls
  from: ai.chat
  to: process.main
  layer: runtime
  x:
    docs:
      description: AI chat sends messages to main process via IPC ai:chat channel for Claude API calls.
    ipc:
      channel: ai:chat
      protocol: ipc
  uuid: eAiMainP
- kind: contains
  from: window.main
  to: ai.chat
  layer: ui
  x:
    docs:
      description: AI chat panel is rendered as a floating sub-window inside the main application window.
  uuid: eWnAiCht
- kind: contains
  from: web.platform
  to: web.menubar
  layer: ui
  x:
    docs:
      description: Web platform renders WebMenuBar component at top of the app layout, replacing Electron native menus.
  uuid: eWbMenu1
- kind: calls
  from: web.menubar
  to: app.singleton
  layer: runtime
  x:
    docs:
      description: WebMenuBar dispatches menu:action events via WebPlatformBridge.emit() which are received by Application's menu:action listener.
  uuid: eWbMnApp
- kind: calls
  from: process.main
  to: tool.skp2obj
  layer: system
  x:
    docs:
      description: Main process executes skp2obj native binary via execFile() when handling file:convert-skp IPC. Passes input SKP path and temp OBJ output path.
  uuid: eMainSkp
- kind: produces
  from: build.electron
  to: process.main
  layer: system
  x:
    docs:
      description: electron-builder packages the Electron app into platform-specific binaries (DMG, NSIS, AppImage) with the main process as the entry point.
  uuid: eBldMain
- kind: produces
  from: web.deploy
  to: web.platform
  layer: system
  x:
    docs:
      description: Web build pipeline produces the static site deployed to draftdownapp.com from the web.platform source.
  uuid: eDplWeb1

# ─── Plugin system edges ──────────────────────────────────────────────────────────
- kind: contains
  from: plugin.system
  to: plugin.system.draftdown
  layer: system
  x: { docs: { description: 'Plugin System exposes the DraftDown Ruby API JS façade as the plugin-facing surface.' } }
  uuid: ePlSurfCn
- kind: contains
  from: plugin.system
  to: plugin.system.attributes
  layer: system
  x: { docs: { description: 'Plugin System owns the document-level AttributeStore powering set/get_attribute.' } }
  uuid: ePlAtrCn
- kind: contains
  from: plugin.system
  to: plugin.system.host_ui
  layer: ui
  x: { docs: { description: 'Plugin System backs UI.menu / UI.toolbar / UI.htmlDialog with React-observable stores.' } }
  uuid: ePlHsUiCn
- kind: contains
  from: plugin.system
  to: plugin.system.loader
  layer: system
  x: { docs: { description: 'PluginLoader runs JS plugin source via AsyncFunction with the DraftDown globals in scope.' } }
  uuid: ePlLdrCn
- kind: contains
  from: plugin.system
  to: plugin.system.parameters
  layer: ui
  x: { docs: { description: 'Plugin System provides the right-rail Parameters panel via UI.parameters.* API.' } }
  uuid: ePlPrmCn
- kind: contains
  from: plugin.system
  to: plugin.system.console
  layer: ui
  x: { docs: { description: 'Plugin System ships an inline Ruby Console REPL panel.' } }
  uuid: ePlCnsCn
- kind: contains
  from: plugin.system
  to: plugin.system.extension_manager
  layer: ui
  x: { docs: { description: 'Plugin System ships the Extension Manager modal for Install / Enable / Disable / Uninstall.' } }
  uuid: ePlExmCn
- kind: contains
  from: plugin.system
  to: plugin.system.plugins_bar
  layer: ui
  x: { docs: { description: 'Plugin System mounts the top-right Plugins menu bar + HtmlDialog host.' } }
  uuid: ePlPgbCn
- kind: contains
  from: plugin.system
  to: plugin.system.tool_registry
  layer: system
  x: { docs: { description: 'Plugin System keeps a registry of plugin-registered tools so the toolbar can list them.' } }
  uuid: ePlTlRCn
- kind: contains
  from: plugin.system
  to: plugin.system.observers
  layer: system
  x: { docs: { description: 'Plugin System defines all 17+ DraftDown observer protocols as TS interfaces.' } }
  uuid: ePlObsCn

- kind: calls
  from: plugin.system.draftdown
  to: api.model
  layer: logical
  x: { docs: { description: 'DraftDown.Model exposes m.api_ that delegates to the high-level ModelAPI for booleans, sweep, arrays, etc.' } }
  uuid: ePlSkApiCl
- kind: reads
  from: plugin.system.draftdown
  to: data.document
  layer: data
  x: { docs: { description: 'DraftDown.Model wraps ModelDocument (geometry, scene, selection, materials, history).' } }
  uuid: ePlSkDocRd
- kind: writes
  from: plugin.system.draftdown
  to: engine.geometry
  layer: data
  x: { docs: { description: 'Entities.add_face/addLine/etc. mutate the GeometryEngine inside transactions.' } }
  uuid: ePlSkGeoWr

- kind: reads
  from: plugin.system.parameters
  to: plugin.system.host_ui
  layer: ui
  x: { docs: { description: 'ParametersPanel subscribes to the ParametersStore (separate store, peer to MenuStore).' } }
  uuid: ePlPrmStRd
- kind: contains
  from: window.main
  to: plugin.system.parameters
  layer: ui
  x: { docs: { description: 'Main window mounts <ParametersPanel/> in the right rail under EntityInfoPanel.' } }
  uuid: ePlMnPrmCn
- kind: contains
  from: window.main
  to: plugin.system.plugins_bar
  layer: ui
  x: { docs: { description: 'Main window mounts <PluginsBar/> at the top right of the app frame.' } }
  uuid: ePlMnPgbCn
- kind: reads
  from: toolbar.drawing
  to: plugin.system.tool_registry
  layer: ui
  x: { docs: { description: 'DrawingToolbar subscribes to the plugin tool registry and renders a Plugins section listing every registered tool.' } }
  uuid: ePlDrTlRd

- kind: calls
  from: plugin.system.loader
  to: plugin.system.draftdown
  layer: system
  x: { docs: { description: 'PluginLoader installs the DraftDown global, then evaluates plugin source against it.' } }
  uuid: ePlLdSkCl
- kind: writes
  from: plugin.system.loader
  to: datastore.localstorage
  layer: data
  x: { docs: { description: 'PluginLoader persists installed plugin sources at draftdown:plugin-src:<id>.' } }
  uuid: ePlLdLsWr

- kind: writes
  from: plugin.system.attributes
  to: data.document
  layer: data
  x: { docs: { description: 'AttributeStore is owned by the DraftDown module which is keyed off the active ModelDocument.' } }
  uuid: ePlAtDocWr

- kind: calls
  from: actor.plugin_dev
  to: plugin.system.draftdown
  layer: system
  x: { docs: { description: 'Plugin developers write JS that imports/uses the DraftDown Ruby API JS façade globals.' } }
  uuid: ePlDvSkCl
- kind: reads
  from: actor.plugin_dev
  to: plugin.system.console
  layer: ui
  x: { docs: { description: 'Plugin developers iterate on snippets in the inline Ruby Console.' } }
  uuid: ePlDvCnRd
- kind: calls
  from: actor.plugin_dev
  to: plugin.system.extension_manager
  layer: ui
  x: { docs: { description: 'Plugin developers install / enable / disable / uninstall their plugin via the Extension Manager.' } }
  uuid: ePlDvEmCl

- kind: calls
  from: ai.chat
  to: plugin.system.draftdown
  layer: logical
  x: { docs: { description: 'AI execute_script tool runs JavaScript against the DraftDown Ruby API JS façade — same surface as plugins.' } }
  uuid: ePlAiSkCl

- kind: calls
  from: plugin.system.example.sample_box
  to: plugin.system.draftdown
  layer: system
  x: { docs: { description: 'Sample Box plugin demonstrates entities.addFace + face.pushpull.' } }
  uuid: ePlSmpSkCl
- kind: calls
  from: plugin.system.example.stairs
  to: plugin.system.draftdown
  layer: system
  x: { docs: { description: 'Stairs Builder uses entities.addFace + face.pushpull + tools.registerTool to drive the geometry engine.' } }
  uuid: ePlStrSkCl
- kind: reads
  from: plugin.system.example.stairs
  to: plugin.system.parameters
  layer: ui
  x: { docs: { description: 'Stairs Builder drives its multi-flight UI via UI.parameters.show / update / values / hide.' } }
  uuid: ePlStrPrCl
- kind: contains
  from: plugin.system
  to: plugin.system.example.sample_box
  layer: system
  x: { docs: { description: 'Sample Box ships in examples/plugins/.' } }
  uuid: ePlSmpEx
- kind: contains
  from: plugin.system
  to: plugin.system.example.stairs
  layer: system
  x: { docs: { description: 'Stairs Builder ships in examples/plugins/.' } }
  uuid: ePlStrEx

# ─── Face-snap + error-logging edges ────────────────────────────────────────────
- kind: contains
  from: viewport.main
  to: system.face_snap
  layer: interaction
  x: { docs: { description: 'ViewportCanvas computes the on-face world point + tracks underlying face id for on-face snapping.' } }
  uuid: eVpFaceSnp
- kind: reads
  from: system.face_snap
  to: engine.geometry
  layer: data
  x: { docs: { description: 'Face-snap reads face.plane to project the cursor ray onto the face plane.' } }
  uuid: eFsGeoRd
- kind: contains
  from: renderer.webgl
  to: system.face_snap
  layer: rendering
  x: { docs: { description: 'SceneBridge owns the yellow on-face indicator marker and dirty-tracking widening for hole-punched host faces.' } }
  uuid: eRwFaceSnp
- kind: reads
  from: tool.rectangle
  to: system.face_snap
  layer: interaction
  x: { docs: { description: 'Rectangle tool locks its drawing plane to the hovered face via getEffectiveDrawingPlane on first click.' } }
  uuid: eToolRectFs
- kind: reads
  from: tool.circle
  to: system.face_snap
  layer: interaction
  x: { docs: { description: 'Circle tool locks its drawing plane to the hovered face via getEffectiveDrawingPlane on first click.' } }
  uuid: eToolCirFs
- kind: reads
  from: tool.polygon
  to: system.face_snap
  layer: interaction
  x: { docs: { description: 'Polygon tool locks its drawing plane to the hovered face via getEffectiveDrawingPlane on first click.' } }
  uuid: eToolPolFs
- kind: reads
  from: tool.arc
  to: system.face_snap
  layer: interaction
  x: { docs: { description: 'Arc tool locks its drawing plane to the hovered face via getEffectiveDrawingPlane on first click (all three modes).' } }
  uuid: eToolArcFs

- kind: contains
  from: process.renderer
  to: system.error_logging
  layer: system
  x: { docs: { description: 'Renderer entry registers global error/unhandledrejection handlers; every try/catch in the codebase logs via console.error/warn.' } }
  uuid: ePrErrLog

- kind: notifies
  from: engine.geometry
  to: data.materials
  layer: data
  x:
    docs:
      description: 'GeometryEngine.onFaceSplit(parentId, childIds) callback fires from splitFaceAtBoundary after children
        are created. Application wires it to MaterialManager.inheritAssignment so faceId-keyed face material assignments
        carry over when a face is bisected. Necessary because the renderer reads materials via faceAssignments[faceId],
        not IFace.materialIndex — without this hook the new faces lose their texture.'
  uuid: eGeoMatSplit

views:
- name: User Workflow
  description: End-to-end view from actor through UI to geometry
  include:
    nodes:
    - actor.designer
    - window.main
    - toolbar.drawing
    - menu.main
    - tool.select
    - tool.line
    - tool.pushpull
    - tool.move
    - viewport.main
    - renderer.webgl
    - camera.main
    - op.extrude
    - engine.geometry
    - mesh.halfedge
    - data.scene
    - data.selection
  id: view.user_workflow
- name: Rendering Pipeline
  description: 3D rendering stack from viewport to shaders
  include:
    nodes:
    - viewport.main
    - renderer.webgl
    - camera.main
    - shader.pbr
    - shader.outline
    - shader.selection
    - shader.xray
    - mesh.halfedge
    - lib.threejs
  id: view.rendering_pipeline
- name: Modeling Operations
  description: All modeling operations and their geometry targets
  include:
    nodes:
    - op.extrude
    - op.sweep
    - op.offset
    - op.boolean_union
    - op.boolean_subtract
    - op.boolean_intersect
    - op.intersect_faces
    - op.subdivide
    - op.triangulate
    - mod.array
    - mod.mirror
    - mod.smooth
    - engine.geometry
    - mesh.halfedge
    - solid.manifold
  id: view.modeling_operations
- name: Electron Architecture
  description: System-level process architecture and IPC
  include:
    nodes:
    - process.main
    - process.renderer
    - worker.mesh
    - worker.fileio
    - native.manifold
    - lib.electron
    - lib.threejs
    - lib.react
    - lib.manifold_wasm
  id: view.electron_architecture
- name: File I/O
  description: File format support and data flow
  include:
    nodes:
    - file.native
    - file.obj
    - file.stl
    - file.gltf
    - file.dxf
    - file.step
    - datastore.filesystem
    - datastore.preferences
    - worker.fileio
    - data.scene
  id: view.file_i_o
- name: Tools & Inference
  description: Drawing tools and inference engine constraints
  include:
    nodes:
    - tool.line
    - tool.rectangle
    - tool.circle
    - tool.arc
    - tool.pushpull
    - tool.move
    - tool.rotate
    - tool.offset
    - constraint.on_axis
    - constraint.parallel
    - constraint.perpendicular
    - constraint.snap_point
    - constraint.distance
  id: view.tools_inference
rules: []