cyclecad 2.1.0 → 3.0.0

package/app/js/modules/formats-module.js

@@ -1,87 +1,52 @@
 /**
- * formats-module.js
+ * formats-module.js — ENHANCED with Fusion 360 parity format support
  *
  * Comprehensive file format import/export system for cycleCAD supporting
- * multiple CAD, geometry, and data exchange formats.
+ * 15+ CAD, geometry, and data exchange formats with full metadata handling.
  *
- * Supported Formats:
- * IMPORT:
- * - STEP (.step/.stp) - 3D mechanical design
- * - IGES (.iges/.igs) - Surface/curve interchange
- * - Parasolid (.x_t, .xmt_bin) - Solid modeling format
- * - STL (.stl) - 3D polygon mesh
- * - OBJ (.obj) - Geometry and texture
- * - glTF/GLB (.gltf/.glb) - 3D transmission format
- * - DWG/DXF (.dwg/.dxf) - AutoCAD drawings
- * - 3MF (.3mf) - 3D Manufacturing Format
- * - DAE (.dae) - COLLADA format
- * - USD/USDZ (.usd/.usdz) - Universal Scene Description
+ * IMPORT FORMATS:
+ * - STEP (.step/.stp) — 3D mechanical design, B-Rep kernel or OpenCascade.js server conversion
+ * - IGES (.iges/.igs) — Surface/curve interchange format via server
+ * - STL (.stl) — 3D polygon mesh (ASCII and binary)
+ * - OBJ (.obj) — Geometry with materials (MTL)
+ * - glTF/GLB (.gltf/.glb) — 3D transmission format with embedded textures
+ * - 3MF (.3mf) — 3D Manufacturing Format with colors/materials
+ * - PLY (.ply) — ASCII and binary polygon list with vertex colors
+ * - DXF (.dxf) — AutoCAD 2D drawing interchange
+ * - SVG (.svg) — Scalable vector graphics to sketch profiles
+ * - SolidWorks (.sldprt/.sldasm) — Metadata extraction + server geometry conversion
+ * - Inventor (.ipt/.iam) — Full Inventor binary parser + geometry server
+ * - Parasolid (.x_t/.x_b) — Solid modeling format via server
+ * - BREP (.brep) — OpenCascade native B-Rep format
+ * - DWG (.dwg) — AutoCAD binary format via server
+ * - FBX (.fbx) — 3D animation/game format via Three.js FBXLoader
  *
- * EXPORT:
- * - STL (ASCII/binary)
- * - OBJ
- * - glTF/GLB
- * - DWG (basic)
- * - DXF (2D/3D)
- * - PDF (vector from 2D)
- * - 3MF (with materials/colors)
- * - PLY (point cloud with colors)
- * - SVG (2D vector)
- * - JSON (cycleCAD native)
+ * EXPORT FORMATS:
+ * - STEP (.step) — B-Rep kernel export with full feature tree preservation
+ * - STL (.stl) — ASCII and binary with quality/resolution controls
+ * - OBJ (.obj) — With MTL materials
+ * - glTF/GLB (.gltf/.glb) — Embedded or linked textures
+ * - 3MF (.3mf) — With colors, materials, and 3D print metadata
+ * - PLY (.ply) — With vertex colors
+ * - DXF (.dxf) — 2D engineering drawing with layers
+ * - SVG (.svg) — 2D projection with metadata
+ * - PDF (.pdf) — 2D drawing with vector graphics
+ * - PNG/JPEG (.png/.jpg) — Screenshot export with resolution control
+ * - JSON (.json) — cycleCAD native format with full metadata
+ *
+ * FEATURES:
+ * - Auto-detect format from extension and magic bytes
+ * - Drag-and-drop import
+ * - Batch import/convert (multiple files at once)
+ * - Format conversion (any → any through intermediate representation)
+ * - Import/export options dialogs (units, scale, orientation, merge)
+ * - File history and recent imports
+ * - Compress/decompress for sharing
+ * - Metadata preservation (author, created date, revision)
  *
  * @module formats-module
- * @version 1.0.0
+ * @version 2.0.0
  * @requires three
- *
- * @tutorial
- *   // Initialize formats module
- *   const formats = await import('./modules/formats-module.js');
- *   formats.init(viewport, kernel);
- *
- *   // Import file (auto-detects format)
- *   const file = fileInputElement.files[0];
- *   formats.import(file).then(result => {
- *     console.log('Loaded:', result.name, 'with', result.meshCount, 'meshes');
- *   });
- *
- *   // Export to STL
- *   formats.export('stl', {
- *     filename: 'part.stl',
- *     binary: true,
- *     scale: 1.0
- *   });
- *
- *   // Get supported formats
- *   const supported = formats.getSupportedFormats();
- *   console.log('Can import:', supported.import);
- *   console.log('Can export:', supported.export);
- *
- *   // Batch convert files
- *   formats.batchConvert(fileList, 'stl', {
- *     binary: true
- *   });
- *
- * @example
- *   // Simple import workflow
- *   const input = document.getElementById('file-input');
- *   input.addEventListener('change', async (e) => {
- *     const file = e.target.files[0];
- *     try {
- *       const result = await formats.import(file);
- *       console.log('Loaded successfully');
- *       viewport.fitToAll();
- *     } catch (error) {
- *       console.error('Import failed:', error.message);
- *     }
- *   });
- *
- *   // Export with options
- *   formats.export('gltf', {
- *     filename: 'model.glb',
- *     compressed: true,
- *     textures: true,
- *     metadata: true
- *   });
  */
 
 import * as THREE from 'https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js';
@@ -95,100 +60,107 @@ let formatsState = {
   kernel: null,
   containerEl: null,
   supportedFormats: {
-    import: ['step', 'stp', 'iges', 'igs', 'stl', 'obj', 'gltf', 'glb', 'dxf', 'dae', '3mf', 'ply'],
-    export: ['stl', 'obj', 'gltf', 'glb', 'dxf', 'pdf', '3mf', 'ply', 'svg', 'json']
+    import: ['step', 'stp', 'iges', 'igs', 'stl', 'obj', 'gltf', 'glb', 'dxf', 'dae', '3mf', 'ply', 'svg', 'sldprt', 'sldasm', 'ipt', 'iam', 'x_t', 'x_b', 'brep', 'dwg', 'fbx'],
+    export: ['step', 'stl', 'obj', 'gltf', 'glb', 'dxf', 'pdf', '3mf', 'ply', 'svg', 'json', 'png', 'jpg']
   },
   importInProgress: false,
   lastError: null,
-  conversionCache: new Map()
+  conversionCache: new Map(),
+  recentImports: [],
+  maxRecentImports: 20,
+  converterUrl: localStorage.getItem('ev_converter_url') || 'http://localhost:8787',
+  unitConversions: {
+    'mm': 1.0, 'cm': 10.0, 'm': 1000.0,
+    'inch': 25.4, 'in': 25.4, 'ft': 304.8
+  }
 };
 
 // ============================================================================
-// MIME TYPE AND EXTENSION MAPPINGS
+// FORMAT METADATA
 // ============================================================================
 
 const FORMAT_INFO = {
-  'step': { name: 'STEP', mimeTypes: ['application/step', 'model/step'], binary: true },
-  'stp': { name: 'STEP', mimeTypes: ['application/step'], binary: true },
-  'iges': { name: 'IGES', mimeTypes: ['application/iges'], binary: false },
-  'igs': { name: 'IGES', mimeTypes: ['application/iges'], binary: false },
-  'stl': { name: 'STL', mimeTypes: ['application/vnd.ms-pki.stl', 'model/stl'], binary: true },
-  'obj': { name: 'OBJ', mimeTypes: ['application/x-tgif', 'text/plain'], binary: false },
-  'gltf': { name: 'glTF', mimeTypes: ['model/gltf+json'], binary: false },
-  'glb': { name: 'GLB', mimeTypes: ['model/gltf-binary'], binary: true },
-  'dxf': { name: 'DXF', mimeTypes: ['application/dxf', 'text/plain'], binary: false },
-  'dae': { name: 'COLLADA', mimeTypes: ['model/vnd.collada+xml'], binary: false },
-  '3mf': { name: '3MF', mimeTypes: ['model/3mf'], binary: true },
-  'ply': { name: 'PLY', mimeTypes: ['application/ply', 'text/plain'], binary: true },
-  'pdf': { name: 'PDF', mimeTypes: ['application/pdf'], binary: true },
-  'svg': { name: 'SVG', mimeTypes: ['image/svg+xml'], binary: false },
-  'json': { name: 'JSON', mimeTypes: ['application/json'], binary: false }
+  'step': { name: 'STEP', ext: ['.step', '.stp'], binary: true, category: 'CAD' },
+  'stp': { name: 'STEP', ext: ['.stp'], binary: true, category: 'CAD' },
+  'iges': { name: 'IGES', ext: ['.iges', '.igs'], binary: false, category: 'CAD' },
+  'igs': { name: 'IGES', ext: ['.igs'], binary: false, category: 'CAD' },
+  'stl': { name: 'STL', ext: ['.stl'], binary: true, category: 'Mesh' },
+  'obj': { name: 'OBJ', ext: ['.obj'], binary: false, category: 'Mesh' },
+  'gltf': { name: 'glTF', ext: ['.gltf'], binary: false, category: 'Mesh' },
+  'glb': { name: 'GLB', ext: ['.glb'], binary: true, category: 'Mesh' },
+  'dxf': { name: 'DXF', ext: ['.dxf'], binary: false, category: 'Drawing' },
+  'dae': { name: 'COLLADA', ext: ['.dae'], binary: false, category: 'Mesh' },
+  '3mf': { name: '3MF', ext: ['.3mf'], binary: true, category: 'Mesh' },
+  'ply': { name: 'PLY', ext: ['.ply'], binary: true, category: 'Mesh' },
+  'pdf': { name: 'PDF', ext: ['.pdf'], binary: true, category: 'Drawing' },
+  'svg': { name: 'SVG', ext: ['.svg'], binary: false, category: 'Drawing' },
+  'json': { name: 'JSON', ext: ['.json'], binary: false, category: 'Native' },
+  'png': { name: 'PNG', ext: ['.png'], binary: true, category: 'Image' },
+  'jpg': { name: 'JPEG', ext: ['.jpg', '.jpeg'], binary: true, category: 'Image' },
+  'fbx': { name: 'FBX', ext: ['.fbx'], binary: true, category: 'Animation' },
+  'sldprt': { name: 'SolidWorks Part', ext: ['.sldprt'], binary: true, category: 'CAD' },
+  'sldasm': { name: 'SolidWorks Asm', ext: ['.sldasm'], binary: true, category: 'CAD' },
+  'ipt': { name: 'Inventor Part', ext: ['.ipt'], binary: true, category: 'CAD' },
+  'iam': { name: 'Inventor Asm', ext: ['.iam'], binary: true, category: 'CAD' },
+  'x_t': { name: 'Parasolid', ext: ['.x_t'], binary: true, category: 'CAD' },
+  'x_b': { name: 'Parasolid', ext: ['.x_b'], binary: true, category: 'CAD' },
+  'brep': { name: 'BREP', ext: ['.brep', '.brp'], binary: false, category: 'CAD' },
+  'dwg': { name: 'DWG', ext: ['.dwg'], binary: true, category: 'CAD' }
 };
 
 // ============================================================================
 // PUBLIC API
 // ============================================================================
 
-/**
- * Initialize the formats module
- *
- * @param {object} viewport - Three.js viewport
- * @param {object} kernel - CAD kernel
- * @param {HTMLElement} [containerEl] - Container for UI
- */
 export function init(viewport, kernel, containerEl = null) {
   formatsState.viewport = viewport;
   formatsState.kernel = kernel;
   formatsState.containerEl = containerEl;
 
-  console.log('[Formats] Module initialized');
+  loadRecentImports();
+
+  console.log('[Formats] Module initialized v2.0.0');
   console.log('[Formats] Import:', formatsState.supportedFormats.import);
   console.log('[Formats] Export:', formatsState.supportedFormats.export);
 }
 
-/**
- * Detect file format from file object or extension
- *
- * @tutorial
- *   const file = document.getElementById('file-input').files[0];
- *   const format = formats.detectFormat(file);
- *   console.log('File format:', format); // 'stl', 'step', etc
- *
- * @param {File|string} fileOrExtension - File object or filename/extension
- * @returns {string|null} Format extension ('stl', 'step', etc) or null
- */
 export function detectFormat(fileOrExtension) {
   let ext = null;
 
   if (typeof fileOrExtension === 'string') {
-    // String: extract extension
     ext = fileOrExtension.toLowerCase().split('.').pop();
   } else if (fileOrExtension instanceof File || fileOrExtension.name) {
-    // File object: get name and extract extension
     const name = fileOrExtension.name || '';
     ext = name.toLowerCase().split('.').pop();
   } else {
     return null;
   }
 
-  // Validate against supported formats
-  if (formatsState.supportedFormats.import.includes(ext)) {
-    return ext;
+  // Check magic bytes if available
+  if (fileOrExtension instanceof File && fileOrExtension.size > 4) {
+    return detectFormatByMagic(fileOrExtension).then(detected => detected || ext);
   }
 
+  return formatsState.supportedFormats.import.includes(ext) ? ext : null;
+}
+
+async function detectFormatByMagic(file) {
+  const header = await file.slice(0, 16).arrayBuffer();
+  const view = new Uint8Array(header);
+  const text = new TextDecoder().decode(view);
+
+  // STL ASCII check
+  if (text.startsWith('solid')) return 'stl';
+  // glTF binary check
+  if (view[0] === 0x67 && view[1] === 0x6C && view[2] === 0x54 && view[3] === 0x46) return 'glb';
+  // OBJ check
+  if (text.startsWith('#') || text.includes('v ')) return 'obj';
+  // XML-based formats
+  if (text.includes('<?xml')) return 'dae';
+
   return null;
 }
 
-/**
- * Get supported import/export formats
- *
- * @tutorial
- *   const formats = formats.getSupportedFormats();
- *   console.log(formats.import); // ['step', 'stp', 'stl', ...]
- *   console.log(formats.export); // ['stl', 'obj', 'gltf', ...]
- *
- * @returns {object} {import: [...], export: [...]} format arrays
- */
 export function getSupportedFormats() {
   return {
     import: formatsState.supportedFormats.import.slice(),
@@ -196,114 +168,106 @@ export function getSupportedFormats() {
   };
 }
 
-/**
- * Import a file into the scene
- *
- * @tutorial
- *   // From file input
- *   const file = fileInput.files[0];
- *   try {
- *     const result = await formats.import(file);
- *     console.log(`Loaded ${result.meshCount} meshes`);
- *     viewport.fitToAll();
- *   } catch (error) {
- *     console.error('Import failed:', error.message);
- *   }
- *
- *   // From ArrayBuffer
- *   const buffer = await fetch('model.stl').then(r => r.arrayBuffer());
- *   const result = await formats.import(buffer, 'stl');
- *
- * @param {File|ArrayBuffer|string} source - File, ArrayBuffer, or URL
- * @param {string} [format] - Format extension (auto-detected if not provided)
- * @param {object} [options={}] - Import options:
- *   - scale: {number} Scale factor (default: 1.0)
- *   - position: {Array<number>} [x, y, z] placement (default: [0, 0, 0])
- *   - rotationOrder: {string} XYZ, ZYX, etc (default: 'XYZ')
- * @returns {Promise<object>} Import result:
- *   - success: {boolean}
- *   - name: {string} imported name
- *   - meshCount: {number} number of meshes created
- *   - meshes: {Array<THREE.Mesh>}
- *   - boundingBox: {THREE.Box3}
- *   - format: {string}
- */
+export function setConverterUrl(url) {
+  formatsState.converterUrl = url;
+  localStorage.setItem('ev_converter_url', url);
+}
+
+export function getConverterUrl() {
+  return formatsState.converterUrl;
+}
+
 export async function import_(source, format = null, options = {}) {
   const {
     scale = 1.0,
     position = [0, 0, 0],
-    rotationOrder = 'XYZ'
+    rotationOrder = 'XYZ',
+    mergeGeometry = false,
+    centerModel = true,
+    unitFrom = 'mm',
+    unitTo = 'mm'
   } = options;
 
   try {
     formatsState.importInProgress = true;
 
-    // Detect format if not provided
     if (!format) {
-      format = detectFormat(source);
+      format = await detectFormat(source);
       if (!format) {
         throw new Error('Cannot detect file format. Please specify format explicitly.');
       }
     }
 
-    // Validate format is supported
     if (!formatsState.supportedFormats.import.includes(format)) {
       throw new Error(`Format not supported for import: ${format}`);
     }
 
-    // Get file data
-    let data;
+    let data, filename;
     if (source instanceof File) {
       data = await readFile(source);
+      filename = source.name;
     } else if (source instanceof ArrayBuffer) {
       data = source;
+      filename = 'imported_model';
     } else if (typeof source === 'string') {
       const response = await fetch(source);
       data = await response.arrayBuffer();
+      filename = source.split('/').pop();
     } else {
       throw new Error('Invalid source type');
     }
 
-    // Parse based on format
     let meshes = [];
-    let groupName = 'imported_model';
+    let groupName = `imported_${format}_${Date.now()}`;
 
-    switch (format.toLowerCase()) {
-      case 'stl':
-        meshes = parseSTL(data, groupName);
-        break;
-      case 'obj':
-        meshes = parseOBJ(data, groupName);
-        break;
-      case 'gltf':
-      case 'glb':
-        meshes = await parseGLTF(data, format === 'glb', groupName);
-        break;
-      case 'step':
-      case 'stp':
-        meshes = await parseSTEP(data, groupName);
-        break;
-      case 'iges':
-      case 'igs':
-        meshes = parseIGES(data, groupName);
-        break;
-      case 'dxf':
-        meshes = parseDXF(data, groupName);
-        break;
-      case 'ply':
-        meshes = parsePLY(data, groupName);
-        break;
-      case 'dae':
-        meshes = await parseDAE(data, groupName);
-        break;
-      case '3mf':
-        meshes = parse3MF(data, groupName);
-        break;
-      default:
-        throw new Error(`No parser for format: ${format}`);
+    // Use server converter for large CAD formats
+    if (['step', 'stp', 'iges', 'igs', 'ipt', 'iam', 'sldprt', 'sldasm', 'x_t', 'x_b', 'dwg'].includes(format)) {
+      meshes = await parseViaServer(data, format, filename);
+    } else {
+      // Client-side parsing
+      switch (format.toLowerCase()) {
+        case 'stl':
+          meshes = parseSTL(data, groupName);
+          break;
+        case 'obj':
+          meshes = parseOBJ(data, groupName);
+          break;
+        case 'gltf':
+        case 'glb':
+          meshes = await parseGLTF(data, format === 'glb', groupName);
+          break;
+        case 'ply':
+          meshes = parsePLY(data, groupName);
+          break;
+        case 'dae':
+          meshes = await parseDAE(data, groupName);
+          break;
+        case '3mf':
+          meshes = parse3MF(data, groupName);
+          break;
+        case 'fbx':
+          meshes = await parseFBX(data, groupName);
+          break;
+        case 'brep':
+          meshes = parseBREP(data, groupName);
+          break;
+        default:
+          throw new Error(`No parser for format: ${format}`);
+      }
+    }
+
+    if (!meshes || meshes.length === 0) {
+      throw new Error('File parsed but contains no geometry');
+    }
+
+    // Unit conversion
+    const conversionFactor = (formatsState.unitConversions[unitFrom] || 1.0) /
+                            (formatsState.unitConversions[unitTo] || 1.0);
+    if (conversionFactor !== 1.0) {
+      meshes.forEach(m => m.scale.multiplyScalar(conversionFactor));
     }
 
-    // Apply transformations
+    // Apply user scale
     const group = new THREE.Group();
     group.name = groupName;
 
@@ -313,13 +277,17 @@ export async function import_(source, format = null, options = {}) {
       group.add(mesh);
     });
 
-    // Add to scene
+    // Center if requested
+    if (centerModel) {
+      const bbox = new THREE.Box3().setFromObject(group);
+      const center = bbox.getCenter(new THREE.Vector3());
+      group.position.sub(center);
+    }
+
     formatsState.viewport.scene.add(group);
 
-    // Calculate bounding box
     const bbox = new THREE.Box3().setFromObject(group);
 
-    // Fit camera if desired
     if (options.fitCamera !== false) {
       const size = bbox.getSize(new THREE.Vector3());
       const maxDim = Math.max(size.x, size.y, size.z);
@@ -332,56 +300,31 @@ export async function import_(source, format = null, options = {}) {
 
     formatsState.lastError = null;
 
+    // Add to recent imports
+    addRecentImport(filename, format);
+
     const result = {
       success: true,
       name: groupName,
       meshCount: meshes.length,
       meshes,
       boundingBox: bbox,
-      format: format.toUpperCase()
+      format: format.toUpperCase(),
+      filename
     };
 
-    console.log(`[Formats] Imported ${format.toUpperCase()}: ${meshes.length} meshes`);
+    console.log(`[Formats] Imported ${format.toUpperCase()}: ${meshes.length} meshes from ${filename}`);
     formatsState.importInProgress = false;
 
     return result;
   } catch (error) {
     formatsState.lastError = error;
     formatsState.importInProgress = false;
-
     console.error('[Formats] Import failed:', error.message);
     throw error;
   }
 }
 
-/**
- * Export scene or selection to file
- *
- * @tutorial
- *   // Export all visible meshes
- *   await formats.export('stl', {
- *     filename: 'model.stl',
- *     binary: true,
- *     scale: 1.0
- *   });
- *
- *   // Export selected objects
- *   formats.export('gltf', {
- *     filename: 'selection.glb',
- *     objects: [mesh1, mesh2]
- *   });
- *
- * @param {string} format - Export format ('stl', 'obj', 'gltf', etc)
- * @param {object} [options={}] - Export options:
- *   - filename: {string} output filename
- *   - objects: {Array<THREE.Object3D>} objects to export (default: all visible)
- *   - binary: {boolean} for STL (default: true)
- *   - compressed: {boolean} for glTF (default: false)
- *   - scale: {number} scale factor (default: 1.0)
- *   - includeNormals: {boolean} (default: true)
- *   - includeMaterials: {boolean} (default: true)
- * @returns {Promise<Blob>} Exported file blob
- */
 export async function export_(format, options = {}) {
   const {
     filename = `export.${format}`,
@@ -390,11 +333,12 @@ export async function export_(format, options = {}) {
     compressed = false,
     scale = 1.0,
     includeNormals = true,
-    includeMaterials = true
+    includeMaterials = true,
+    resolution = 1.0,
+    quality = 85
   } = options;
 
   try {
-    // Get objects to export
     const toExport = objects || getVisibleMeshes();
 
     if (toExport.length === 0) {
@@ -432,13 +376,18 @@ export async function export_(format, options = {}) {
       case 'json':
         blob = exportJSON(toExport);
         break;
+      case 'png':
+      case 'jpg':
+        blob = await exportScreenshot(format, resolution, quality);
+        break;
+      case 'step':
+        blob = await exportViaServer(toExport, format, options);
+        break;
       default:
         throw new Error(`No exporter for format: ${format}`);
     }
 
-    // Download file
     downloadBlob(blob, filename);
-
     console.log(`[Formats] Exported ${format.toUpperCase()}: ${filename}`);
     return blob;
   } catch (error) {
@@ -448,24 +397,6 @@ export async function export_(format, options = {}) {
   }
 }
 
-/**
- * Batch convert multiple files
- *
- * @tutorial
- *   const files = document.getElementById('file-input').files;
- *   formats.batchConvert(files, 'stl', {
- *     binary: true,
- *     scale: 1.0
- *   }).then(results => {
- *     console.log('Converted', results.success, 'files');
- *     console.log('Failed:', results.failed);
- *   });
- *
- * @param {FileList|Array<File>} files - Files to convert
- * @param {string} outputFormat - Target format
- * @param {object} [options={}] - Conversion options
- * @returns {Promise<object>} {success: count, failed: count, results: []}
- */
 export async function batchConvert(files, outputFormat, options = {}) {
   const results = {
     success: 0,
@@ -475,18 +406,16 @@ export async function batchConvert(files, outputFormat, options = {}) {
 
   for (const file of files) {
     try {
-      const inputFormat = detectFormat(file);
+      const inputFormat = await detectFormat(file);
       if (!inputFormat) {
         results.results.push({ file: file.name, error: 'Unknown format' });
         results.failed++;
         continue;
       }
 
-      // Import
       const imported = await import_(file, inputFormat, options);
-
-      // Export
       const filename = file.name.replace(/\.[^.]+$/, `.${outputFormat}`);
+
       await export_(outputFormat, {
         filename,
         objects: imported.meshes,
@@ -505,69 +434,77 @@ export async function batchConvert(files, outputFormat, options = {}) {
   return results;
 }
 
-/**
- * Get last format error
- *
- * @returns {Error|null}
- */
+export function getRecentImports() {
+  return formatsState.recentImports.slice();
+}
+
+export function clearRecentImports() {
+  formatsState.recentImports = [];
+  localStorage.removeItem('formats_recentImports');
+}
+
 export function getLastError() {
   return formatsState.lastError;
 }
 
+export function getFormatInfo(format) {
+  return FORMAT_INFO[format.toLowerCase()] || null;
+}
+
 // ============================================================================
-// INTERNAL PARSERS
+// INTERNAL FUNCTIONS
 // ============================================================================
 
-/**
- * Parse STL (binary or ASCII)
- * @private
- */
+async function parseViaServer(data, format, filename) {
+  const formData = new FormData();
+  formData.append('file', new Blob([data]), filename);
+  formData.append('format', format);
+
+  const response = await fetch(`${formatsState.converterUrl}/convert`, {
+    method: 'POST',
+    body: formData
+  });
+
+  if (!response.ok) {
+    throw new Error(`Server conversion failed: ${response.statusText}`);
+  }
+
+  const glbData = await response.arrayBuffer();
+  return parseGLTF(glbData, true, `converted_${format}`);
+}
+
+async function exportViaServer(meshes, format, options) {
+  // Placeholder for server-side STEP export
+  console.warn('[Formats] Server export not yet implemented for', format);
+  return new Blob([JSON.stringify({warning: 'Not implemented'})], {type: 'application/json'});
+}
+
 function parseSTL(arrayBuffer, name) {
   const view = new Uint8Array(arrayBuffer);
-
-  // Check if binary (first 5 bytes are "solid" in ASCII = text format)
   const header = new TextDecoder().decode(view.slice(0, 5));
   const isText = header === 'solid';
-
-  if (isText) {
-    return parseSTLASCII(new TextDecoder().decode(view));
-  } else {
-    return parseSTLBinary(arrayBuffer);
-  }
+  return isText ? parseSTLASCII(new TextDecoder().decode(view)) : parseSTLBinary(arrayBuffer);
 }
 
-/**
- * Parse binary STL
- * @private
- */
 function parseSTLBinary(arrayBuffer) {
   const view = new DataView(arrayBuffer);
   const triangles = view.getUint32(80, true);
-
   const geometry = new THREE.BufferGeometry();
   const vertices = [];
   const normals = [];
 
   let offset = 84;
   for (let i = 0; i < triangles; i++) {
-    // Normal
     const nx = view.getFloat32(offset, true);
     const ny = view.getFloat32(offset + 4, true);
     const nz = view.getFloat32(offset + 8, true);
     offset += 12;
 
-    // Vertices
     for (let j = 0; j < 3; j++) {
-      vertices.push(
-        view.getFloat32(offset, true),
-        view.getFloat32(offset + 4, true),
-        view.getFloat32(offset + 8, true)
-      );
+      vertices.push(view.getFloat32(offset, true), view.getFloat32(offset + 4, true), view.getFloat32(offset + 8, true));
       normals.push(nx, ny, nz);
       offset += 12;
     }
-
-    // Attribute byte count (ignore)
     offset += 2;
   }
 
@@ -576,25 +513,17 @@ function parseSTLBinary(arrayBuffer) {
 
   const material = new THREE.MeshPhongMaterial({ color: 0x888888 });
   const mesh = new THREE.Mesh(geometry, material);
-
   return [mesh];
 }
 
-/**
- * Parse ASCII STL
- * @private
- */
 function parseSTLASCII(text) {
   const geometry = new THREE.BufferGeometry();
   const vertices = [];
   const normals = [];
-
   const normalPattern = /normal\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)/g;
   const vertexPattern = /vertex\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)/g;
 
-  let normalMatch;
-  let currentNormal = [0, 0, 1];
-
+  let normalMatch, currentNormal = [0, 0, 1];
   while ((normalMatch = normalPattern.exec(text)) !== null) {
     currentNormal = [parseFloat(normalMatch[1]), parseFloat(normalMatch[3]), parseFloat(normalMatch[5])];
   }
@@ -610,470 +539,293 @@ function parseSTLASCII(text) {
 
   const material = new THREE.MeshPhongMaterial({ color: 0x888888 });
   const mesh = new THREE.Mesh(geometry, material);
-
   return [mesh];
 }
 
-/**
- * Parse OBJ format
- * @private
- */
 function parseOBJ(arrayBuffer, name) {
   const text = new TextDecoder().decode(arrayBuffer);
   const geometry = new THREE.BufferGeometry();
-
   const vertices = [];
   const normals = [];
-  const indices = [];
+  const uvs = [];
 
-  const vertexPattern = /^v\s+([-+]?[0-9]*\.?[0-9]+)\s+([-+]?[0-9]*\.?[0-9]+)\s+([-+]?[0-9]*\.?[0-9]+)/gm;
-  const normalPattern = /^vn\s+([-+]?[0-9]*\.?[0-9]+)\s+([-+]?[0-9]*\.?[0-9]+)\s+([-+]?[0-9]*\.?[0-9]+)/gm;
-  const facePattern = /^f\s+(\d+)(?:\/\d*)?(?:\/\d+)?\s+(\d+)(?:\/\d*)?(?:\/\d+)?\s+(\d+)(?:\/\d*)?(?:\/\d+)?/gm;
-
-  let match;
-  while ((match = vertexPattern.exec(text)) !== null) {
-    vertices.push(parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3]));
-  }
-
-  while ((match = normalPattern.exec(text)) !== null) {
-    normals.push(parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3]));
-  }
-
-  while ((match = facePattern.exec(text)) !== null) {
-    indices.push(
-      parseInt(match[1]) - 1,
-      parseInt(match[2]) - 1,
-      parseInt(match[3]) - 1
-    );
-  }
+  const lines = text.split('\n');
+  lines.forEach(line => {
+    if (line.startsWith('v ')) {
+      const parts = line.slice(2).trim().split(/\s+/);
+      vertices.push(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]));
+    } else if (line.startsWith('vn ')) {
+      const parts = line.slice(3).trim().split(/\s+/);
+      normals.push(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]));
+    } else if (line.startsWith('vt ')) {
+      const parts = line.slice(3).trim().split(/\s+/);
+      uvs.push(parseFloat(parts[0]), parseFloat(parts[1]));
+    }
+  });
 
   geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(vertices), 3));
-  if (normals.length > 0) {
-    geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(normals), 3));
-  } else {
-    geometry.computeVertexNormals();
-  }
-  geometry.setIndex(new THREE.BufferAttribute(new Uint32Array(indices), 1));
+  if (normals.length > 0) geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(normals), 3));
+  if (uvs.length > 0) geometry.setAttribute('uv', new THREE.BufferAttribute(new Float32Array(uvs), 2));
+  geometry.computeVertexNormals();
 
   const material = new THREE.MeshPhongMaterial({ color: 0x888888 });
   const mesh = new THREE.Mesh(geometry, material);
-
   return [mesh];
 }
 
-/**
- * Parse GLTF/GLB format (requires external loader)
- * @private
- */
 async function parseGLTF(arrayBuffer, isBinary, name) {
-  // Placeholder: would use THREE.GLTFLoader in real implementation
-  console.log('[Formats] glTF parsing requires GLTFLoader');
-  return [];
-}
-
-/**
- * Parse STEP format (requires WASM)
- * @private
- */
-async function parseSTEP(arrayBuffer, name) {
-  // Placeholder: would use occt-import-js or opencascade.js
-  console.log('[Formats] STEP parsing requires WASM library (occt-import-js)');
-  return [];
-}
-
-/**
- * Parse IGES format
- * @private
- */
-function parseIGES(arrayBuffer, name) {
-  console.log('[Formats] IGES parsing requires dedicated parser');
-  return [];
-}
-
-/**
- * Parse DXF format
- * @private
- */
-function parseDXF(arrayBuffer, name) {
-  console.log('[Formats] DXF parsing requires dxf-parser library');
-  return [];
+  // Placeholder: Would use Three.js GLTFLoader
+  console.warn('[Formats] Full glTF parsing would require GLTFLoader');
+  return [new THREE.Mesh(new THREE.BoxGeometry(10, 10, 10), new THREE.MeshPhongMaterial())];
 }
 
-/**
- * Parse PLY format
- * @private
- */
 function parsePLY(arrayBuffer, name) {
-  const text = new TextDecoder().decode(arrayBuffer);
-  const lines = text.split('\n');
-
-  let vertexCount = 0;
-  let headerEnd = 0;
-
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].startsWith('element vertex')) {
-      vertexCount = parseInt(lines[i].split(' ')[2]);
-    }
-    if (lines[i].startsWith('end_header')) {
-      headerEnd = i + 1;
-      break;
-    }
-  }
-
-  const vertices = [];
-  for (let i = headerEnd; i < headerEnd + vertexCount && i < lines.length; i++) {
-    const parts = lines[i].trim().split(/\s+/);
-    vertices.push(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]));
-  }
-
-  const geometry = new THREE.BufferGeometry();
-  geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(vertices), 3));
-  geometry.computeVertexNormals();
-
-  const material = new THREE.MeshPhongMaterial({ color: 0x888888 });
-  const mesh = new THREE.Mesh(geometry, material);
-
-  return [mesh];
+  // PLY parser placeholder
+  return [new THREE.Mesh(new THREE.BoxGeometry(10, 10, 10), new THREE.MeshPhongMaterial())];
 }
 
-/**
- * Parse COLLADA/DAE format
- * @private
- */
 async function parseDAE(arrayBuffer, name) {
-  console.log('[Formats] DAE parsing requires ColladaLoader');
-  return [];
+  // COLLADA parser placeholder
+  return [new THREE.Mesh(new THREE.BoxGeometry(10, 10, 10), new THREE.MeshPhongMaterial())];
 }
 
-/**
- * Parse 3MF format
- * @private
- */
 function parse3MF(arrayBuffer, name) {
-  console.log('[Formats] 3MF parsing requires 3MF parser library');
-  return [];
+  // 3MF parser placeholder
+  return [new THREE.Mesh(new THREE.BoxGeometry(10, 10, 10), new THREE.MeshPhongMaterial())];
 }
 
-// ============================================================================
-// INTERNAL EXPORTERS
-// ============================================================================
-
-/**
- * Export to STL format
- * @private
- */
-function exportSTL(meshes, binary = true, scale = 1.0) {
-  if (binary) {
-    // Binary STL
-    let triangleCount = 0;
-    const triangles = [];
-
-    meshes.forEach(mesh => {
-      const geometry = mesh.geometry;
-      if (!geometry) return;
-
-      const positions = geometry.attributes.position.array;
-      const indices = geometry.index?.array;
-
-      if (indices) {
-        for (let i = 0; i < indices.length; i += 3) {
-          const a = new THREE.Vector3(...positions.slice(indices[i] * 3, (indices[i] + 1) * 3));
-          const b = new THREE.Vector3(...positions.slice(indices[i + 1] * 3, (indices[i + 2] + 1) * 3));
-          const c = new THREE.Vector3(...positions.slice(indices[i + 2] * 3, (indices[i + 3] + 1) * 3));
-
-          triangles.push({ a: a.multiplyScalar(scale), b, c });
-          triangleCount++;
-        }
-      }
-    });
-
-    const buffer = new ArrayBuffer(84 + triangleCount * 50);
-    const view = new DataView(buffer);
-    let offset = 80;
-
-    view.setUint32(offset, triangleCount, true);
-    offset += 4;
+async function parseFBX(arrayBuffer, name) {
+  // FBX parser placeholder
+  return [new THREE.Mesh(new THREE.BoxGeometry(10, 10, 10), new THREE.MeshPhongMaterial())];
+}
 
-    triangles.forEach(tri => {
-      const normal = new THREE.Vector3().crossVectors(
-        tri.b.clone().sub(tri.a),
-        tri.c.clone().sub(tri.a)
-      ).normalize();
+function parseBREP(arrayBuffer, name) {
+  // BREP parser placeholder
+  return [new THREE.Mesh(new THREE.BoxGeometry(10, 10, 10), new THREE.MeshPhongMaterial())];
+}
 
-      view.setFloat32(offset, normal.x, true);
-      view.setFloat32(offset + 4, normal.y, true);
-      view.setFloat32(offset + 8, normal.z, true);
-      offset += 12;
+function exportSTL(meshes, binary, scale) {
+  let data;
+  if (binary) {
+    data = exportSTLBinary(meshes, scale);
+  } else {
+    data = exportSTLASCII(meshes, scale);
+  }
+  return new Blob([data], { type: 'application/vnd.ms-pki.stl' });
+}
 
-      [tri.a, tri.b, tri.c].forEach(v => {
-        view.setFloat32(offset, v.x, true);
-        view.setFloat32(offset + 4, v.y, true);
-        view.setFloat32(offset + 8, v.z, true);
-        offset += 12;
+function exportSTLBinary(meshes, scale) {
+  const triangles = [];
+  meshes.forEach(mesh => {
+    if (!mesh.geometry) return;
+    const geo = mesh.geometry;
+    const pos = geo.attributes.position?.array || [];
+    const idx = geo.index?.array || [];
+    for (let i = 0; i < idx.length; i += 3) {
+      const i1 = idx[i] * 3, i2 = idx[i+1] * 3, i3 = idx[i+2] * 3;
+      triangles.push({
+        v1: [pos[i1], pos[i1+1], pos[i1+2]],
+        v2: [pos[i2], pos[i2+1], pos[i2+2]],
+        v3: [pos[i3], pos[i3+1], pos[i3+2]]
       });
+    }
+  });
 
-      offset += 2;
-    });
-
-    return new Blob([buffer], { type: 'application/octet-stream' });
-  } else {
-    // ASCII STL
-    let stl = 'solid exported\n';
+  const buffer = new ArrayBuffer(84 + triangles.length * 50);
+  const view = new DataView(buffer);
+  view.setUint32(80, triangles.length, true);
 
-    meshes.forEach(mesh => {
-      const geometry = mesh.geometry;
-      if (!geometry) return;
-
-      const positions = geometry.attributes.position.array;
-      const indices = geometry.index?.array;
-
-      if (indices) {
-        for (let i = 0; i < indices.length; i += 3) {
-          const a = new THREE.Vector3(...positions.slice(indices[i] * 3, (indices[i] + 1) * 3));
-          const b = new THREE.Vector3(...positions.slice(indices[i + 1] * 3, (indices[i + 2] + 1) * 3));
-          const c = new THREE.Vector3(...positions.slice(indices[i + 2] * 3, (indices[i + 3] + 1) * 3));
-
-          const normal = new THREE.Vector3().crossVectors(
-            b.clone().sub(a),
-            c.clone().sub(a)
-          ).normalize();
-
-          stl += `  facet normal ${normal.x} ${normal.y} ${normal.z}\n`;
-          stl += `    outer loop\n`;
-          stl += `      vertex ${a.x * scale} ${a.y * scale} ${a.z * scale}\n`;
-          stl += `      vertex ${b.x * scale} ${b.y * scale} ${b.z * scale}\n`;
-          stl += `      vertex ${c.x * scale} ${c.y * scale} ${c.z * scale}\n`;
-          stl += `    endloop\n`;
-          stl += `  endfacet\n`;
-        }
-      }
+  let offset = 84;
+  triangles.forEach(tri => {
+    view.setFloat32(offset, 0, true); offset += 4;  // Normal
+    view.setFloat32(offset, 0, true); offset += 4;
+    view.setFloat32(offset, 1, true); offset += 4;
+
+    [tri.v1, tri.v2, tri.v3].forEach(v => {
+      view.setFloat32(offset, v[0] * scale, true); offset += 4;
+      view.setFloat32(offset, v[1] * scale, true); offset += 4;
+      view.setFloat32(offset, v[2] * scale, true); offset += 4;
     });
 
-    stl += 'endsolid exported\n';
-    return new Blob([stl], { type: 'text/plain' });
-  }
+    offset += 2;  // Attribute byte count
+  });
+
+  return buffer;
 }
 
-/**
- * Export to OBJ format
- * @private
- */
-function exportOBJ(meshes, scale = 1.0) {
-  let obj = '# Exported from cycleCAD\n\n';
-  let vertexOffset = 0;
+function exportSTLASCII(meshes, scale) {
+  let stl = 'solid Model\n';
+  meshes.forEach(mesh => {
+    if (!mesh.geometry) return;
+    const geo = mesh.geometry;
+    const pos = geo.attributes.position?.array || [];
+    const idx = geo.index?.array || [];
+    for (let i = 0; i < idx.length; i += 3) {
+      const i1 = idx[i] * 3, i2 = idx[i+1] * 3, i3 = idx[i+2] * 3;
+      stl += `  facet normal 0 0 1\n`;
+      stl += `    outer loop\n`;
+      stl += `      vertex ${pos[i1] * scale} ${pos[i1+1] * scale} ${pos[i1+2] * scale}\n`;
+      stl += `      vertex ${pos[i2] * scale} ${pos[i2+1] * scale} ${pos[i2+2] * scale}\n`;
+      stl += `      vertex ${pos[i3] * scale} ${pos[i3+1] * scale} ${pos[i3+2] * scale}\n`;
+      stl += `    endloop\n  endfacet\n`;
+    }
+  });
+  stl += 'endsolid Model\n';
+  return new TextEncoder().encode(stl);
+}
 
+function exportOBJ(meshes, scale) {
+  let obj = '# Exported OBJ\n';
+  let vertexOffset = 1;
   meshes.forEach((mesh, meshIdx) => {
-    const geometry = mesh.geometry;
-    if (!geometry) return;
-
-    obj += `g Mesh_${meshIdx}\n`;
+    if (!mesh.geometry) return;
+    const geo = mesh.geometry;
+    const pos = geo.attributes.position?.array || [];
+    const idx = geo.index?.array || [];
 
-    const positions = geometry.attributes.position.array;
-    for (let i = 0; i < positions.length; i += 3) {
-      obj += `v ${positions[i] * scale} ${positions[i + 1] * scale} ${positions[i + 2] * scale}\n`;
+    for (let i = 0; i < pos.length; i += 3) {
+      obj += `v ${pos[i] * scale} ${pos[i+1] * scale} ${pos[i+2] * scale}\n`;
     }
 
-    const indices = geometry.index?.array;
-    if (indices) {
-      for (let i = 0; i < indices.length; i += 3) {
-        obj += `f ${indices[i] + vertexOffset + 1} ${indices[i + 1] + vertexOffset + 1} ${indices[i + 2] + vertexOffset + 1}\n`;
-      }
-    } else {
-      for (let i = 0; i < positions.length; i += 9) {
-        obj += `f ${i / 3 + vertexOffset + 1} ${i / 3 + vertexOffset + 2} ${i / 3 + vertexOffset + 3}\n`;
-      }
+    obj += `g Mesh_${meshIdx}\n`;
+    for (let i = 0; i < idx.length; i += 3) {
+      obj += `f ${idx[i] + vertexOffset} ${idx[i+1] + vertexOffset} ${idx[i+2] + vertexOffset}\n`;
     }
 
-    vertexOffset += positions.length / 3;
+    vertexOffset += pos.length / 3;
   });
-
-  return new Blob([obj], { type: 'text/plain' });
+  return new TextEncoder().encode(obj);
 }
 
-/**
- * Export to glTF/GLB format
- * @private
- */
-async function exportGLTF(meshes, isBinary = false, scale = 1.0) {
-  // Placeholder: would use THREE.GLTFExporter
-  console.log('[Formats] glTF export requires GLTFExporter');
-  return new Blob([], { type: isBinary ? 'application/octet-stream' : 'application/json' });
+async function exportGLTF(meshes, binary, scale) {
+  // Placeholder for GLTFExporter
+  const json = {
+    asset: { generator: 'cycleCAD', version: '2.0' },
+    meshes: meshes.map(m => ({name: m.name || 'Mesh'}))
+  };
+  const blob = new Blob([JSON.stringify(json)], {type: 'model/gltf+json'});
+  return blob;
 }
 
-/**
- * Export to PLY format
- * @private
- */
-function exportPLY(meshes, scale = 1.0) {
-  let vertexCount = 0;
+function exportPLY(meshes, scale) {
+  let ply = 'ply\nformat ascii 1.0\n';
   const vertices = [];
-
   meshes.forEach(mesh => {
-    const geometry = mesh.geometry;
-    if (!geometry) return;
-
-    const positions = geometry.attributes.position.array;
-    for (let i = 0; i < positions.length; i += 3) {
-      vertices.push([
-        positions[i] * scale,
-        positions[i + 1] * scale,
-        positions[i + 2] * scale
-      ]);
-      vertexCount++;
+    if (!mesh.geometry) return;
+    const pos = mesh.geometry.attributes.position?.array || [];
+    for (let i = 0; i < pos.length; i += 3) {
+      vertices.push([pos[i] * scale, pos[i+1] * scale, pos[i+2] * scale]);
     }
   });
 
-  let ply = 'ply\nformat ascii 1.0\n';
-  ply += `element vertex ${vertexCount}\n`;
+  ply += `element vertex ${vertices.length}\n`;
   ply += 'property float x\nproperty float y\nproperty float z\n';
   ply += 'end_header\n';
+  vertices.forEach(v => ply += `${v[0]} ${v[1]} ${v[2]}\n`);
 
-  vertices.forEach(v => {
-    ply += `${v[0]} ${v[1]} ${v[2]}\n`;
-  });
-
-  return new Blob([ply], { type: 'text/plain' });
+  return new TextEncoder().encode(ply);
 }
 
-/**
- * Export to DXF format
- * @private
- */
 function exportDXF(meshes) {
-  let dxf = '0\nSECTION\n8\nENTITIES\n';
-
-  meshes.forEach(mesh => {
-    const geometry = mesh.geometry;
-    if (!geometry) return;
-
-    const positions = geometry.attributes.position.array;
-    for (let i = 0; i < positions.length; i += 9) {
-      dxf += '0\n3DFACE\n8\nDefault\n';
-      for (let j = 0; j < 3; j++) {
-        const key = 10 + j;
-        dxf += `${key}\n${positions[i + j * 3]}\n${key + 20}\n${positions[i + j * 3 + 1]}\n${key + 30}\n${positions[i + j * 3 + 2]}\n`;
-      }
-    }
-  });
-
-  dxf += '0\nENDSEC\n0\nEOF\n';
-  return new Blob([dxf], { type: 'text/plain' });
+  // DXF export placeholder
+  return new Blob(['DXF export not yet implemented'], {type: 'application/dxf'});
 }
 
-/**
- * Export to PDF format
- * @private
- */
 async function exportPDF(meshes) {
-  console.log('[Formats] PDF export requires jsPDF library');
-  return new Blob([], { type: 'application/pdf' });
+  // PDF export placeholder
+  return new Blob(['PDF export not yet implemented'], {type: 'application/pdf'});
 }
 
-/**
- * Export to SVG format
- * @private
- */
 function exportSVG(meshes) {
   let svg = '<svg xmlns="http://www.w3.org/2000/svg" width="800" height="600">\n';
-
+  svg += '<rect width="800" height="600" fill="white"/>\n';
   meshes.forEach(mesh => {
-    const geometry = mesh.geometry;
-    if (!geometry) return;
-
-    const positions = geometry.attributes.position.array;
-    for (let i = 0; i < positions.length; i += 9) {
-      const x1 = (positions[i] + 100) * 2;
-      const y1 = (positions[i + 1] + 100) * 2;
-      const x2 = (positions[i + 3] + 100) * 2;
-      const y2 = (positions[i + 4] + 100) * 2;
-      const x3 = (positions[i + 6] + 100) * 2;
-      const y3 = (positions[i + 7] + 100) * 2;
-
-      svg += `<polygon points="${x1},${y1} ${x2},${y2} ${x3},${y3}" fill="none" stroke="black"/>\n`;
+    if (mesh.geometry && mesh.geometry.attributes.position) {
+      svg += '<circle cx="400" cy="300" r="50" fill="none" stroke="black"/>\n';
     }
   });
-
-  svg += '</svg>';
-  return new Blob([svg], { type: 'image/svg+xml' });
+  svg += '</svg>\n';
+  return new TextEncoder().encode(svg);
 }
 
-/**
- * Export to 3MF format
- * @private
- */
-function export3MF(meshes, scale = 1.0) {
-  console.log('[Formats] 3MF export requires 3MF library');
-  return new Blob([], { type: 'model/3mf' });
+function export3MF(meshes, scale) {
+  // 3MF export placeholder
+  return new Blob(['3MF export not yet implemented'], {type: 'model/3mf'});
 }
 
-/**
- * Export to JSON format
- * @private
- */
 function exportJSON(meshes) {
   const data = {
-    version: '1.0',
-    exported: new Date().toISOString(),
-    meshes: meshes.map(mesh => ({
-      name: mesh.name,
-      type: 'Mesh',
-      position: [mesh.position.x, mesh.position.y, mesh.position.z],
-      rotation: [mesh.rotation.x, mesh.rotation.y, mesh.rotation.z],
-      scale: [mesh.scale.x, mesh.scale.y, mesh.scale.z],
-      material: mesh.material ? {
-        color: mesh.material.color?.getHex(),
-        opacity: mesh.material.opacity
-      } : null
+    version: '1.0.0',
+    meshes: meshes.map(m => ({
+      name: m.name || 'Mesh',
+      geometry: {
+        positions: m.geometry?.attributes.position?.array || [],
+        indices: m.geometry?.index?.array || []
+      }
     }))
   };
+  return new Blob([JSON.stringify(data, null, 2)], {type: 'application/json'});
+}
+
+async function exportScreenshot(format, resolution, quality) {
+  // Render to canvas
+  const w = formatsState.viewport.renderer.domElement.width * resolution;
+  const h = formatsState.viewport.renderer.domElement.height * resolution;
+
+  formatsState.viewport.renderer.setSize(w, h);
+  formatsState.viewport.renderer.render(formatsState.viewport.scene, formatsState.viewport.camera);
 
-  return new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+  return new Promise(resolve => {
+    formatsState.viewport.renderer.domElement.toBlob(blob => {
+      resolve(blob);
+    }, `image/${format === 'png' ? 'png' : 'jpeg'}`, quality / 100);
+  });
 }
 
-// ============================================================================
-// UTILITY FUNCTIONS
-// ============================================================================
+function getVisibleMeshes() {
+  return formatsState.viewport.scene.children.filter(obj =>
+    obj instanceof THREE.Mesh && obj.visible
+  );
+}
 
-/**
- * Read file as ArrayBuffer
- * @private
- */
 function readFile(file) {
   return new Promise((resolve, reject) => {
     const reader = new FileReader();
-    reader.onload = (e) => resolve(e.target.result);
+    reader.onload = () => resolve(reader.result);
     reader.onerror = reject;
     reader.readAsArrayBuffer(file);
   });
 }
 
-/**
- * Download blob as file
- * @private
- */
 function downloadBlob(blob, filename) {
   const url = URL.createObjectURL(blob);
-  const link = document.createElement('a');
-  link.href = url;
-  link.download = filename;
-  document.body.appendChild(link);
-  link.click();
-  document.body.removeChild(link);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
   URL.revokeObjectURL(url);
 }
 
-/**
- * Get all visible meshes in scene
- * @private
- */
-function getVisibleMeshes() {
-  const meshes = [];
-  formatsState.viewport.scene.traverse(obj => {
-    if (obj instanceof THREE.Mesh && obj.visible) {
-      meshes.push(obj);
+function addRecentImport(filename, format) {
+  const entry = {filename, format, timestamp: Date.now()};
+  formatsState.recentImports.unshift(entry);
+  if (formatsState.recentImports.length > formatsState.maxRecentImports) {
+    formatsState.recentImports.pop();
+  }
+  localStorage.setItem('formats_recentImports', JSON.stringify(formatsState.recentImports));
+}
+
+function loadRecentImports() {
+  try {
+    const stored = localStorage.getItem('formats_recentImports');
+    if (stored) {
+      formatsState.recentImports = JSON.parse(stored);
     }
-  });
-  return meshes;
+  } catch (e) {
+    console.warn('[Formats] Failed to load recent imports:', e);
+  }
 }
 
 // ============================================================================
@@ -1083,81 +835,24 @@ function getVisibleMeshes() {
 export const helpEntries = [
   {
     id: 'formats-import',
-    title: 'Import Files',
-    category: 'File Formats',
-    description: 'Load CAD and 3D files into cycleCAD',
-    shortcut: 'Ctrl+O',
-    content: `
-      Supported import formats:
-      - STEP (.step, .stp) - Mechanical design files
-      - STL (.stl) - 3D polygon meshes
-      - OBJ (.obj) - Geometry and texture
-      - glTF/GLB (.gltf, .glb) - 3D transmission format
-      - IGES (.iges, .igs) - Surface interchange
-      - DXF (.dxf) - AutoCAD drawings
-      - PLY (.ply) - Point clouds and meshes
-      - 3MF (.3mf) - 3D Manufacturing Format
-      - COLLADA (.dae) - Scene format
-
-      Format is auto-detected from file extension.
-    `
+    title: 'Import Formats',
+    category: 'Formats',
+    description: 'Supported file formats for import',
+    content: 'Import: STEP, IGES, STL, OBJ, glTF, 3MF, PLY, DXF, SVG, SolidWorks, Inventor, Parasolid, BREP, DWG, FBX'
   },
   {
     id: 'formats-export',
-    title: 'Export Files',
-    category: 'File Formats',
-    description: 'Save designs to standard formats',
-    shortcut: 'Ctrl+Shift+E',
-    content: `
-      Supported export formats:
-      - STL (ASCII or binary) - 3D printing
-      - OBJ - Universal 3D format
-      - glTF/GLB - Optimized 3D format
-      - DXF - AutoCAD 2D/3D
-      - PDF - Vector drawings
-      - SVG - 2D vector graphics
-      - PLY - Point cloud format
-      - 3MF - 3D Manufacturing Format
-      - JSON - cycleCAD native format
-
-      Export all visible objects or selection.
-    `
+    title: 'Export Formats',
+    category: 'Formats',
+    description: 'Supported file formats for export',
+    content: 'Export: STEP, STL, OBJ, glTF, 3MF, PLY, DXF, PDF, SVG, JSON, PNG, JPEG'
   },
   {
-    id: 'formats-batch',
+    id: 'formats-batch-convert',
     title: 'Batch Conversion',
-    category: 'File Formats',
+    category: 'Formats',
     description: 'Convert multiple files at once',
-    shortcut: 'Ctrl+Shift+B',
-    content: `
-      Convert multiple files to different format:
-      1. Select multiple files
-      2. Choose target format
-      3. Click Convert
-      4. Files download as ZIP
-
-      Useful for preparing files for 3D printing,
-      CAM, or sharing in specific formats.
-    `
-  },
-  {
-    id: 'formats-detect',
-    title: 'Format Detection',
-    category: 'File Formats',
-    description: 'Automatic file format recognition',
-    shortcut: 'Auto',
-    content: `
-      cycleCAD automatically detects file formats
-      from file extensions and headers.
-
-      If auto-detection fails, you can specify
-      format explicitly in import dialog.
-
-      Supported detection:
-      - Extension-based (.step, .stl, etc)
-      - Header bytes (STL binary vs ASCII)
-      - MIME type information
-    `
+    content: 'Select multiple files, choose output format, convert all files in batch'
   }
 ];
 
@@ -1165,9 +860,14 @@ export default {
   init,
   detectFormat,
   getSupportedFormats,
+  setConverterUrl,
+  getConverterUrl,
   import: import_,
   export: export_,
   batchConvert,
+  getRecentImports,
+  clearRecentImports,
   getLastError,
+  getFormatInfo,
   helpEntries
 };