fluidcad 0.0.4 → 0.0.6

package/README.md

@@ -6,7 +6,23 @@
 
 <p align="center"><strong>Write CAD models in JavaScript. See the result in real time.</strong></p>
 
+<p align="center">
+  <a href="https://fluidcad.io/docs/getting-started">Getting Started</a> &middot;
+  <a href="https://fluidcad.io/docs/tutorials/">Tutorials</a> &middot;
+  <a href="https://fluidcad.io/docs/guides">Guides</a>
+</p>
+
 > FluidCAD is under active development. APIs and features may change as the project evolves.
+>
+> I'm not accepting pull requests just yet -- I'm still finalizing the design and putting together a roadmap. Once I hit **v0.1.0**, I'd love to have contributions from the community. Stay tuned!
+
+---
+
+## Under the Hood
+
+FluidCAD is built on [OpenCascade](https://dev.opencascade.org/), a full B-Rep (boundary representation) modeling kernel, through the [opencascade.js](https://ocjs.org/) WebAssembly binding. This means precise, production-grade geometry -- exact edges, fillets, and booleans -- not mesh approximations.
+
+A huge thanks to the [opencascade.js](https://ocjs.org/) team for making this possible.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluidcad",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Parametric CAD modeling library using javascript",
   "author": "Marwan Aouida <contact@marwan.dev>",
   "homepage": "https://fluidcad.io",
@@ -39,7 +39,7 @@
     "./server": "./server/dist/index.js"
   },
   "scripts": {
-    "clean": "rm -rf lib/dist server/dist ui/dist",
+    "clean": "rm -rf lib/dist server/dist ui/dist lib/tsconfig.tsbuildinfo server/tsconfig.tsbuildinfo",
     "build:lib": "tsc -p lib/tsconfig.json",
     "build:server": "tsc -p server/tsconfig.json",
     "build:ui": "vite build --config ui/vite.config.ts",

package/server/dist/fluidcad-server.d.ts

@@ -0,0 +1,32 @@
+export type SceneRenderedData = {
+    absPath: string;
+    result: any[];
+    rollbackStop: number;
+};
+export declare class FluidCadServer {
+    private viteManager;
+    private sceneManager;
+    private previousScenes;
+    private renderingCache;
+    private currentFileName;
+    init(workspacePath: string): Promise<void>;
+    processFile(filePath: string, ignoreCache?: boolean): Promise<SceneRenderedData | null>;
+    updateLiveCode(fileName: string, code: string): Promise<SceneRenderedData | null>;
+    rollbackFromUI(index: number): Promise<SceneRenderedData | null>;
+    rollback(fileName: string, index: number): Promise<SceneRenderedData | null>;
+    importFile(workspacePath: string, fileName: string, data: string): Promise<void>;
+    getShapeProperties(shapeId: string): any;
+    getFaceProperties(shapeId: string, faceIndex: number): any;
+    getEdgeProperties(shapeId: string, edgeIndex: number): any;
+    exportShapes(shapeIds: string[], options: {
+        format: 'step' | 'stl';
+        includeColors?: boolean;
+        resolution?: string;
+        customLinearDeflection?: number;
+        customAngularDeflectionDeg?: number;
+    }): {
+        data: string | Uint8Array;
+        fileName: string;
+    } | null;
+    hitTest(shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): any;
+}

package/server/dist/fluidcad-server.js

@@ -0,0 +1,150 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { ViteManager } from "./vite-manager.js";
+export class FluidCadServer {
+    viteManager = new ViteManager();
+    sceneManager;
+    previousScenes = new Map();
+    renderingCache = new Map();
+    currentFileName = '';
+    async init(workspacePath) {
+        await this.viteManager.init(workspacePath);
+        const initFilePath = join(workspacePath, 'init.js');
+        if (existsSync(initFilePath)) {
+            const { default: _sceneManager } = await this.viteManager.loadModule(initFilePath);
+            this.sceneManager = await _sceneManager;
+        }
+    }
+    async processFile(filePath, ignoreCache = false) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const normalizedFileName = filePath.replace('virtual:live-render:', '');
+        this.currentFileName = normalizedFileName;
+        if (!ignoreCache) {
+            const fromCache = this.renderingCache.get(normalizedFileName);
+            if (fromCache) {
+                return {
+                    absPath: normalizedFileName,
+                    result: fromCache,
+                    rollbackStop: fromCache.length - 1,
+                };
+            }
+        }
+        try {
+            let scene = this.sceneManager.startScene();
+            this.sceneManager.setCurrentFile(normalizedFileName);
+            this.viteManager.invalidateModule();
+            await this.viteManager.loadModule(filePath);
+            if (this.previousScenes.has(normalizedFileName)) {
+                const previousScene = this.previousScenes.get(normalizedFileName);
+                scene = this.sceneManager.compare(previousScene, scene);
+            }
+            this.previousScenes.set(normalizedFileName, scene);
+            this.sceneManager.renderScene(scene);
+            const result = scene.getRenderedObjects();
+            for (const obj of result) {
+                if (obj.sourceLocation) {
+                    obj.sourceLocation.filePath = obj.sourceLocation.filePath.replace('virtual:live-render:', '');
+                }
+            }
+            if (!filePath.startsWith('virtual:live-render')) {
+                this.renderingCache.set(normalizedFileName, result);
+            }
+            return {
+                absPath: normalizedFileName,
+                result,
+                rollbackStop: result.length - 1,
+            };
+        }
+        catch (error) {
+            this.viteManager.invalidateModule();
+            console.log('Error processing file:', error);
+            throw error;
+        }
+    }
+    async updateLiveCode(fileName, code) {
+        const id = `virtual:live-render:${fileName}`;
+        this.viteManager.setBuffer(id, code);
+        this.renderingCache.delete(fileName);
+        return this.processFile(id, true);
+    }
+    async rollbackFromUI(index) {
+        return this.rollback(this.currentFileName, index);
+    }
+    async rollback(fileName, index) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(fileName);
+        if (!scene) {
+            return null;
+        }
+        const totalObjects = scene.getAllSceneObjects().length;
+        const rollbackIndex = index >= totalObjects - 1 ? totalObjects - 1 : index;
+        this.sceneManager.rollbackScene(scene, rollbackIndex);
+        const result = scene.getRenderedObjects();
+        return {
+            absPath: fileName,
+            result,
+            rollbackStop: index,
+        };
+    }
+    async importFile(workspacePath, fileName, data) {
+        if (!this.sceneManager) {
+            throw new Error('SceneManager not initialized');
+        }
+        const binaryData = Buffer.from(data, 'base64');
+        await this.sceneManager.importFile(workspacePath, fileName, binaryData);
+    }
+    getShapeProperties(shapeId) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.getShapeProperties(scene, shapeId);
+    }
+    getFaceProperties(shapeId, faceIndex) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.getFaceProperties(scene, shapeId, faceIndex);
+    }
+    getEdgeProperties(shapeId, edgeIndex) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.getEdgeProperties(scene, shapeId, edgeIndex);
+    }
+    exportShapes(shapeIds, options) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.exportShapes(scene, shapeIds, options);
+    }
+    hitTest(shapeId, rayOrigin, rayDir, edgeThreshold) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold);
+    }
+}

package/server/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/server/dist/index.js

@@ -0,0 +1,290 @@
+import crypto from 'crypto';
+import http from 'http';
+import path from 'path';
+import express from 'express';
+import { WebSocketServer, WebSocket } from 'ws';
+import { FluidCadServer } from "./fluidcad-server.js";
+import { createPropertiesRouter } from "./routes/properties.js";
+import { createActionsRouter } from "./routes/actions.js";
+import { createExportRouter } from "./routes/export.js";
+import { createScreenshotRouter } from "./routes/screenshot.js";
+const PORT = parseInt(process.env.FLUIDCAD_SERVER_PORT || '3100', 10);
+const WORKSPACE_PATH = process.env.FLUIDCAD_WORKSPACE_PATH || '';
+const UI_DIST = path.resolve(import.meta.dirname, '../../ui/dist');
+// ---------------------------------------------------------------------------
+// IPC helpers — communication with extension host process
+// ---------------------------------------------------------------------------
+function sendToExtension(msg) {
+    if (process.send) {
+        process.send(msg);
+    }
+}
+// ---------------------------------------------------------------------------
+// Express app
+// ---------------------------------------------------------------------------
+const fluidCadServer = new FluidCadServer();
+const app = express();
+app.use(express.json({ limit: '50mb' }));
+app.use('/api', createPropertiesRouter(fluidCadServer));
+app.use('/api', createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, WORKSPACE_PATH));
+app.use('/api', createExportRouter(fluidCadServer));
+app.use('/api', createScreenshotRouter(requestScreenshot));
+// Static files — serve UI build, with SPA fallback
+app.use(express.static(UI_DIST, {
+    setHeaders(res, filePath) {
+        if (path.extname(filePath) === '.html') {
+            res.setHeader('Cache-Control', 'no-cache');
+        }
+    },
+}));
+app.get('*splat', (_req, res) => {
+    res.setHeader('Cache-Control', 'no-cache');
+    res.sendFile(path.join(UI_DIST, 'index.html'));
+});
+// ---------------------------------------------------------------------------
+// HTTP + WebSocket server
+// ---------------------------------------------------------------------------
+const httpServer = http.createServer(app);
+const wss = new WebSocketServer({ server: httpServer });
+const uiClients = new Set();
+let lastSceneMessage = null;
+let initCompleteMessage = null;
+function broadcastToUI(msg) {
+    const data = JSON.stringify(msg);
+    if (msg.type === 'scene-rendered') {
+        lastSceneMessage = data;
+    }
+    if (msg.type === 'init-complete') {
+        initCompleteMessage = data;
+    }
+    for (const client of uiClients) {
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(data);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Screenshot request/response coordination
+// ---------------------------------------------------------------------------
+const SCREENSHOT_TIMEOUT_MS = 10_000;
+const pendingScreenshots = new Map();
+function requestScreenshot(options) {
+    return new Promise((resolve, reject) => {
+        if (uiClients.size === 0) {
+            reject(new Error('No UI client connected.'));
+            return;
+        }
+        const requestId = crypto.randomUUID();
+        const timeout = setTimeout(() => {
+            pendingScreenshots.delete(requestId);
+            reject(new Error('Screenshot request timed out.'));
+        }, SCREENSHOT_TIMEOUT_MS);
+        pendingScreenshots.set(requestId, {
+            resolve(data) {
+                clearTimeout(timeout);
+                pendingScreenshots.delete(requestId);
+                resolve(data);
+            },
+            reject(err) {
+                clearTimeout(timeout);
+                pendingScreenshots.delete(requestId);
+                reject(err);
+            },
+        });
+        broadcastToUI({ type: 'take-screenshot', requestId, options });
+    });
+}
+function handleUIMessage(raw) {
+    let msg;
+    try {
+        msg = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    if (msg.type === 'screenshot-result' && msg.requestId) {
+        const pending = pendingScreenshots.get(msg.requestId);
+        if (!pending) {
+            return;
+        }
+        if (msg.success && msg.data) {
+            pending.resolve(Buffer.from(msg.data, 'base64'));
+        }
+        else {
+            pending.reject(new Error(msg.error || 'Screenshot failed.'));
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// WebSocket connections
+// ---------------------------------------------------------------------------
+wss.on('connection', (ws) => {
+    uiClients.add(ws);
+    // Replay init-complete and last scene to newly connected UI client
+    if (initCompleteMessage) {
+        ws.send(initCompleteMessage);
+    }
+    if (lastSceneMessage) {
+        ws.send(lastSceneMessage);
+    }
+    ws.on('message', (data) => {
+        handleUIMessage(String(data));
+    });
+    ws.on('close', () => {
+        uiClients.delete(ws);
+    });
+});
+// ---------------------------------------------------------------------------
+// IPC message handling — extension host → server
+// ---------------------------------------------------------------------------
+let currentFile = null;
+let renderVersion = 0;
+async function handleExtensionMessage(msg) {
+    try {
+        switch (msg.type) {
+            case 'process-file': {
+                const myVersion = ++renderVersion;
+                broadcastToUI({ type: 'processing-file' });
+                currentFile = msg.filePath;
+                const data = await fluidCadServer.processFile(msg.filePath);
+                if (myVersion !== renderVersion) {
+                    return;
+                }
+                if (data) {
+                    sendToExtension({
+                        type: 'scene-rendered',
+                        absPath: data.absPath,
+                        result: data.result,
+                        rollbackStop: data.rollbackStop,
+                    });
+                    broadcastToUI({
+                        type: 'scene-rendered',
+                        result: data.result,
+                        absPath: data.absPath,
+                    });
+                }
+                break;
+            }
+            case 'live-update': {
+                const myVersion = ++renderVersion;
+                if (msg.fileName !== currentFile) {
+                    broadcastToUI({ type: 'processing-file' });
+                    currentFile = msg.fileName;
+                }
+                const data = await fluidCadServer.updateLiveCode(msg.fileName, msg.code);
+                if (myVersion !== renderVersion) {
+                    return;
+                }
+                if (data) {
+                    sendToExtension({
+                        type: 'scene-rendered',
+                        absPath: data.absPath,
+                        result: data.result,
+                        rollbackStop: data.rollbackStop,
+                    });
+                    broadcastToUI({
+                        type: 'scene-rendered',
+                        result: data.result,
+                        absPath: data.absPath,
+                    });
+                }
+                break;
+            }
+            case 'rollback': {
+                const myVersion = ++renderVersion;
+                const data = await fluidCadServer.rollback(msg.fileName, msg.index);
+                if (myVersion !== renderVersion) {
+                    return;
+                }
+                if (data) {
+                    sendToExtension({
+                        type: 'scene-rendered',
+                        absPath: data.absPath,
+                        result: data.result,
+                        rollbackStop: data.rollbackStop,
+                    });
+                    broadcastToUI({
+                        type: 'scene-rendered',
+                        result: data.result,
+                        absPath: data.absPath,
+                        rollbackStop: data.rollbackStop,
+                    });
+                }
+                break;
+            }
+            case 'import-file': {
+                try {
+                    await fluidCadServer.importFile(msg.workspacePath, msg.fileName, msg.data);
+                    sendToExtension({ type: 'import-complete', success: true });
+                }
+                catch (err) {
+                    sendToExtension({ type: 'error', message: err.stack || err.message || String(err) });
+                }
+                break;
+            }
+            case 'highlight-shape': {
+                broadcastToUI({ type: 'highlight-shape', shapeId: msg.shapeId });
+                break;
+            }
+            case 'clear-highlight': {
+                broadcastToUI({ type: 'clear-highlight' });
+                break;
+            }
+            case 'show-shape-properties': {
+                broadcastToUI({ type: 'show-shape-properties', shapeId: msg.shapeId });
+                break;
+            }
+            case 'export-scene': {
+                try {
+                    const result = fluidCadServer.exportShapes(msg.shapeIds, msg.options);
+                    if (result) {
+                        const data = typeof result.data === 'string'
+                            ? Buffer.from(result.data, 'utf-8').toString('base64')
+                            : Buffer.from(result.data).toString('base64');
+                        sendToExtension({
+                            type: 'export-complete',
+                            success: true,
+                            data,
+                            fileName: result.fileName,
+                        });
+                    }
+                    else {
+                        sendToExtension({ type: 'export-complete', success: false, error: 'No active scene to export.' });
+                    }
+                }
+                catch (err) {
+                    sendToExtension({ type: 'export-complete', success: false, error: err.message || String(err) });
+                }
+                break;
+            }
+        }
+    }
+    catch (err) {
+        sendToExtension({
+            type: 'error',
+            message: err.stack || err.message || String(err),
+        });
+    }
+}
+// Listen for IPC messages from extension host
+process.on('message', (msg) => {
+    handleExtensionMessage(msg);
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+httpServer.listen(PORT, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`FluidCAD server listening on ${url}`);
+    // Signal ready immediately so extension can show the webview
+    sendToExtension({ type: 'ready', port: PORT, url });
+    // Initialize FluidCAD server in the background
+    fluidCadServer.init(WORKSPACE_PATH).then(() => {
+        sendToExtension({ type: 'init-complete', success: true });
+        broadcastToUI({ type: 'init-complete', success: true });
+    }).catch((err) => {
+        const error = err.stack || err.message || String(err);
+        sendToExtension({ type: 'init-complete', success: false, error });
+        broadcastToUI({ type: 'init-complete', success: false, error });
+    });
+});

package/server/dist/routes/actions.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createActionsRouter(fluidCadServer: FluidCadServer, sendToExtension: (msg: any) => void, broadcastToUI: (msg: any) => void, workspacePath: string): Router;

package/server/dist/routes/actions.js

@@ -0,0 +1,100 @@
+import { Router } from 'express';
+export function createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, workspacePath) {
+    const router = Router();
+    router.post('/hit-test', (req, res) => {
+        const { shapeId, rayOrigin, rayDir, edgeThreshold } = req.body;
+        if (typeof shapeId !== 'string' ||
+            !Array.isArray(rayOrigin) || rayOrigin.length !== 3 ||
+            !Array.isArray(rayDir) || rayDir.length !== 3 ||
+            typeof edgeThreshold !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        const result = fluidCadServer.hitTest(shapeId, rayOrigin, rayDir, edgeThreshold);
+        res.json(result);
+    });
+    router.post('/insert-point', (req, res) => {
+        const { point, sourceLocation } = req.body;
+        if (!Array.isArray(point) || point.length !== 2 ||
+            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        sendToExtension({
+            type: 'insert-point',
+            point: point,
+            sourceLocation,
+        });
+        res.json({ success: true });
+    });
+    router.post('/remove-point', (req, res) => {
+        const { point, sourceLocation } = req.body;
+        if (!Array.isArray(point) || point.length !== 2 ||
+            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        sendToExtension({
+            type: 'remove-point',
+            point: point,
+            sourceLocation,
+        });
+        res.json({ success: true });
+    });
+    router.post('/rollback', async (req, res) => {
+        const { index } = req.body;
+        if (typeof index !== 'number' || index < 0) {
+            res.status(400).json({ error: 'Invalid index' });
+            return;
+        }
+        const data = await fluidCadServer.rollbackFromUI(index);
+        if (!data) {
+            res.status(404).json({ error: 'No active scene' });
+            return;
+        }
+        sendToExtension({
+            type: 'scene-rendered',
+            absPath: data.absPath,
+            result: data.result,
+            rollbackStop: data.rollbackStop,
+        });
+        broadcastToUI({
+            type: 'scene-rendered',
+            result: data.result,
+            absPath: data.absPath,
+            rollbackStop: data.rollbackStop,
+        });
+        res.json({ success: true });
+    });
+    router.post('/set-pick-points', (req, res) => {
+        const { points, sourceLocation } = req.body;
+        if (!Array.isArray(points) ||
+            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        sendToExtension({
+            type: 'set-pick-points',
+            points: points,
+            sourceLocation,
+        });
+        res.json({ success: true });
+    });
+    router.post('/import-file', async (req, res) => {
+        const { fileName, data } = req.body;
+        if (typeof fileName !== 'string' || typeof data !== 'string') {
+            res.status(400).json({ error: 'Invalid request body' });
+            return;
+        }
+        try {
+            await fluidCadServer.importFile(workspacePath, fileName, data);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || String(err) });
+            return;
+        }
+        const loadName = fileName.replace(/\.(step|stp)$/i, '');
+        res.json({ success: true, fileName: loadName });
+    });
+    return router;
+}

package/server/dist/routes/export.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createExportRouter(fluidCadServer: FluidCadServer): Router;

package/server/dist/routes/export.js

@@ -0,0 +1,55 @@
+import { Router } from 'express';
+export function createExportRouter(fluidCadServer) {
+    const router = Router();
+    router.post('/export', (req, res) => {
+        const { format, shapeIds, includeColors, resolution, customAngularDeflectionDeg, customLinearDeflection } = req.body;
+        if (format !== 'step' && format !== 'stl') {
+            res.status(400).json({ error: 'Invalid format. Must be "step" or "stl".' });
+            return;
+        }
+        if (!Array.isArray(shapeIds) || shapeIds.length === 0) {
+            res.status(400).json({ error: 'shapeIds must be a non-empty array.' });
+            return;
+        }
+        if (format === 'stl') {
+            const validResolutions = ['coarse', 'medium', 'fine', 'custom'];
+            if (resolution && !validResolutions.includes(resolution)) {
+                res.status(400).json({ error: 'Invalid resolution.' });
+                return;
+            }
+            if (resolution === 'custom') {
+                if (typeof customLinearDeflection !== 'number' || typeof customAngularDeflectionDeg !== 'number') {
+                    res.status(400).json({ error: 'Custom resolution requires customLinearDeflection and customAngularDeflectionDeg.' });
+                    return;
+                }
+            }
+        }
+        try {
+            const result = fluidCadServer.exportShapes(shapeIds, {
+                format,
+                includeColors,
+                resolution: resolution || 'medium',
+                customLinearDeflection,
+                customAngularDeflectionDeg,
+            });
+            if (!result) {
+                res.status(404).json({ error: 'No active scene to export.' });
+                return;
+            }
+            const ext = format === 'step' ? '.step' : '.stl';
+            const mimeType = format === 'step' ? 'application/step' : 'application/sla';
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Content-Disposition', `attachment; filename="export${ext}"`);
+            if (typeof result.data === 'string') {
+                res.send(Buffer.from(result.data, 'utf-8'));
+            }
+            else {
+                res.send(Buffer.from(result.data));
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || String(err) });
+        }
+    });
+    return router;
+}

package/server/dist/routes/properties.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+export declare function createPropertiesRouter(fluidCadServer: FluidCadServer): Router;

package/server/dist/routes/properties.js

@@ -0,0 +1,46 @@
+import { Router } from 'express';
+import { getMaterials } from '../../../lib/dist/common/materials.js';
+export function createPropertiesRouter(fluidCadServer) {
+    const router = Router();
+    router.get('/materials', (_req, res) => {
+        res.json(getMaterials());
+    });
+    router.get('/shape-properties', (req, res) => {
+        const shapeId = req.query.shapeId || '';
+        const props = fluidCadServer.getShapeProperties(shapeId);
+        if (!props) {
+            res.status(404).json({ error: 'Shape not found' });
+            return;
+        }
+        res.json(props);
+    });
+    router.get('/face-properties', (req, res) => {
+        const shapeId = req.query.shapeId || '';
+        const faceIndex = parseInt(req.query.faceIndex || '', 10);
+        if (!shapeId || isNaN(faceIndex) || faceIndex < 0) {
+            res.status(400).json({ error: 'Missing or invalid shapeId / faceIndex' });
+            return;
+        }
+        const props = fluidCadServer.getFaceProperties(shapeId, faceIndex);
+        if (!props) {
+            res.status(404).json({ error: 'Face not found' });
+            return;
+        }
+        res.json(props);
+    });
+    router.get('/edge-properties', (req, res) => {
+        const shapeId = req.query.shapeId || '';
+        const edgeIndex = parseInt(req.query.edgeIndex || '', 10);
+        if (!shapeId || isNaN(edgeIndex) || edgeIndex < 0) {
+            res.status(400).json({ error: 'Missing or invalid shapeId / edgeIndex' });
+            return;
+        }
+        const props = fluidCadServer.getEdgeProperties(shapeId, edgeIndex);
+        if (!props) {
+            res.status(404).json({ error: 'Edge not found' });
+            return;
+        }
+        res.json(props);
+    });
+    return router;
+}

package/server/dist/routes/screenshot.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'express';
+export declare function createScreenshotRouter(requestScreenshot: (options: Record<string, unknown>) => Promise<Buffer>): Router;

package/server/dist/routes/screenshot.js

@@ -0,0 +1,76 @@
+import { Router } from 'express';
+export function createScreenshotRouter(requestScreenshot) {
+    const router = Router();
+    router.post('/screenshot', async (req, res) => {
+        const { width, height, showGrid, showAxes, transparent, autoCrop, fitToModel, margin } = req.body;
+        const options = {};
+        if (width !== undefined) {
+            if (typeof width !== 'number' || width < 1 || width > 8192) {
+                res.status(400).json({ error: 'width must be a number between 1 and 8192.' });
+                return;
+            }
+            options.width = width;
+        }
+        if (height !== undefined) {
+            if (typeof height !== 'number' || height < 1 || height > 8192) {
+                res.status(400).json({ error: 'height must be a number between 1 and 8192.' });
+                return;
+            }
+            options.height = height;
+        }
+        if (showGrid !== undefined) {
+            if (typeof showGrid !== 'boolean') {
+                res.status(400).json({ error: 'showGrid must be a boolean.' });
+                return;
+            }
+            options.showGrid = showGrid;
+        }
+        if (showAxes !== undefined) {
+            if (typeof showAxes !== 'boolean') {
+                res.status(400).json({ error: 'showAxes must be a boolean.' });
+                return;
+            }
+            options.showAxes = showAxes;
+        }
+        if (transparent !== undefined) {
+            if (typeof transparent !== 'boolean') {
+                res.status(400).json({ error: 'transparent must be a boolean.' });
+                return;
+            }
+            options.transparent = transparent;
+        }
+        if (autoCrop !== undefined) {
+            if (typeof autoCrop !== 'boolean') {
+                res.status(400).json({ error: 'autoCrop must be a boolean.' });
+                return;
+            }
+            options.autoCrop = autoCrop;
+        }
+        if (fitToModel !== undefined) {
+            if (typeof fitToModel !== 'boolean') {
+                res.status(400).json({ error: 'fitToModel must be a boolean.' });
+                return;
+            }
+            options.fitToModel = fitToModel;
+        }
+        if (margin !== undefined) {
+            if (typeof margin !== 'number' || margin < 0) {
+                res.status(400).json({ error: 'margin must be a non-negative number.' });
+                return;
+            }
+            options.margin = margin;
+        }
+        try {
+            const png = await requestScreenshot(options);
+            res.setHeader('Content-Type', 'image/png');
+            res.setHeader('Content-Disposition', 'inline; filename="screenshot.png"');
+            res.send(png);
+        }
+        catch (err) {
+            const message = err.message || String(err);
+            const status = message.includes('No UI client') || message.includes('timed out') ? 503 : 500;
+            res.status(status).json({ error: message });
+        }
+    });
+    return router;
+}

package/server/dist/vite-manager.d.ts

@@ -0,0 +1,10 @@
+import { type ViteDevServer } from 'vite';
+export declare class ViteManager {
+    server: ViteDevServer;
+    private rootPath;
+    private buffers;
+    init(rootPath: string): Promise<void>;
+    setBuffer(id: string, code: string): void;
+    loadModule(filePath: string): Promise<Record<string, any>>;
+    invalidateModule(): void;
+}

package/server/dist/vite-manager.js

@@ -0,0 +1,93 @@
+import { createServer } from 'vite';
+import { dirname, resolve, isAbsolute } from 'path';
+const BLOCKED_NODE_MODULES = new Set([
+    'fs',
+    'child_process',
+    'net',
+    'dgram',
+    'tls',
+    'http',
+    'https',
+    'http2',
+    'os',
+    'worker_threads',
+    'vm',
+    'cluster',
+    'dns',
+    'module',
+]);
+function getBlockedNodeModule(id) {
+    let name = id;
+    if (name.startsWith('node:')) {
+        name = name.slice(5);
+    }
+    const baseName = name.split('/')[0];
+    return BLOCKED_NODE_MODULES.has(baseName) ? baseName : null;
+}
+export class ViteManager {
+    server;
+    rootPath = '';
+    buffers = new Map();
+    async init(rootPath) {
+        this.rootPath = rootPath;
+        const that = this;
+        this.server = await createServer({
+            root: rootPath,
+            server: {
+                watch: {
+                    ignoreInitial: true,
+                    ignored: ['**/node_modules/**']
+                }
+            },
+            optimizeDeps: {
+                noDiscovery: true,
+                include: []
+            },
+            plugins: [
+                {
+                    name: 'virtual-module',
+                    resolveId(id, importer) {
+                        const blockedModule = getBlockedNodeModule(id);
+                        if (blockedModule) {
+                            throw new Error(`Module "${id}" is not allowed in FluidCAD scripts. ` +
+                                `Access to Node.js "${blockedModule}" module is restricted for security.`);
+                        }
+                        if (id.startsWith('virtual:')) {
+                            return id;
+                        }
+                        // Resolve relative imports from virtual modules against the real file path
+                        if (importer && importer.startsWith('virtual:live-render:') && !isAbsolute(id)) {
+                            const realImporter = importer.replace('virtual:live-render:', '');
+                            return resolve(dirname(realImporter), id);
+                        }
+                    },
+                    load(id) {
+                        if (id.startsWith('virtual:live-render')) {
+                            let mod = this.getModuleInfo(id);
+                            if (mod) {
+                                that.server.moduleGraph.invalidateModule(that.server.moduleGraph.getModuleById(id));
+                            }
+                            return that.buffers.get(id) || '';
+                        }
+                        else if (that.buffers.has(`virtual:live-render:${id}`)) {
+                            return that.buffers.get(`virtual:live-render:${id}`);
+                        }
+                    }
+                }
+            ]
+        });
+    }
+    setBuffer(id, code) {
+        this.buffers.set(id, code);
+    }
+    async loadModule(filePath) {
+        return this.server.ssrLoadModule(filePath);
+    }
+    invalidateModule() {
+        for (const [id, mod] of this.server.moduleGraph.idToModuleMap) {
+            if (id.startsWith(this.rootPath) || id.startsWith('virtual:live-render')) {
+                this.server.moduleGraph.invalidateModule(mod);
+            }
+        }
+    }
+}

package/server/dist/ws-protocol.d.ts

@@ -0,0 +1,138 @@
+export type ProcessFileMessage = {
+    type: 'process-file';
+    filePath: string;
+};
+export type LiveUpdateMessage = {
+    type: 'live-update';
+    fileName: string;
+    code: string;
+};
+export type RollbackMessage = {
+    type: 'rollback';
+    fileName: string;
+    index: number;
+};
+export type ImportFileMessage = {
+    type: 'import-file';
+    workspacePath: string;
+    fileName: string;
+    data: string;
+};
+export type HighlightShapeMessage = {
+    type: 'highlight-shape';
+    shapeId: string;
+};
+export type ClearHighlightMessage = {
+    type: 'clear-highlight';
+};
+export type ShowShapePropertiesMessage = {
+    type: 'show-shape-properties';
+    shapeId: string;
+};
+export type ExportSceneMessage = {
+    type: 'export-scene';
+    shapeIds: string[];
+    options: {
+        format: 'step' | 'stl';
+        includeColors?: boolean;
+        resolution?: string;
+        customLinearDeflection?: number;
+        customAngularDeflectionDeg?: number;
+    };
+};
+export type ExtensionMessage = ProcessFileMessage | LiveUpdateMessage | RollbackMessage | ImportFileMessage | HighlightShapeMessage | ClearHighlightMessage | ShowShapePropertiesMessage | ExportSceneMessage;
+export type ReadyMessage = {
+    type: 'ready';
+    port: number;
+    url: string;
+};
+export type InitCompleteMessage = {
+    type: 'init-complete';
+    success: boolean;
+    error?: string;
+};
+export type SceneRenderedMessage = {
+    type: 'scene-rendered';
+    absPath: string;
+    result: any[];
+    rollbackStop: number;
+};
+export type ErrorMessage = {
+    type: 'error';
+    message: string;
+};
+export type ImportCompleteMessage = {
+    type: 'import-complete';
+    success: boolean;
+};
+export type InsertPointMessage = {
+    type: 'insert-point';
+    point: [number, number];
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+};
+export type RemovePointMessage = {
+    type: 'remove-point';
+    point: [number, number];
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+};
+export type SetPickPointsMessage = {
+    type: 'set-pick-points';
+    points: [number, number][];
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+};
+export type ExportCompleteMessage = {
+    type: 'export-complete';
+    success: boolean;
+    data?: string;
+    fileName?: string;
+    error?: string;
+};
+export type ServerToExtensionMessage = ReadyMessage | InitCompleteMessage | SceneRenderedMessage | ErrorMessage | ImportCompleteMessage | InsertPointMessage | RemovePointMessage | SetPickPointsMessage | ExportCompleteMessage;
+export type UISceneRenderedMessage = {
+    type: 'scene-rendered';
+    result: any[];
+    absPath: string;
+    rollbackStop?: number;
+};
+export type UIHighlightShapeMessage = {
+    type: 'highlight-shape';
+    shapeId: string;
+};
+export type UIClearHighlightMessage = {
+    type: 'clear-highlight';
+};
+export type UIShowShapePropertiesMessage = {
+    type: 'show-shape-properties';
+    shapeId: string;
+};
+export type UIInitCompleteMessage = {
+    type: 'init-complete';
+    success: boolean;
+    error?: string;
+};
+export type UIProcessingFileMessage = {
+    type: 'processing-file';
+};
+export type UITakeScreenshotMessage = {
+    type: 'take-screenshot';
+    requestId: string;
+    options: {
+        width?: number;
+        height?: number;
+        showGrid?: boolean;
+        showAxes?: boolean;
+        transparent?: boolean;
+        autoCrop?: boolean;
+        margin?: number;
+    };
+};
+export type ServerToUIMessage = UIInitCompleteMessage | UIProcessingFileMessage | UISceneRenderedMessage | UIHighlightShapeMessage | UIClearHighlightMessage | UIShowShapePropertiesMessage | UITakeScreenshotMessage;

package/server/dist/ws-protocol.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// IPC: Extension → Server messages
+// ---------------------------------------------------------------------------
+export {};