fluidcad 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluidcad",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Parametric CAD modeling library using javascript",
   "author": "Marwan Aouida <contact@marwan.dev>",
   "homepage": "https://fluidcad.io",

package/server/dist/index.js

@@ -10,6 +10,7 @@ import { createExportRouter } from "./routes/export.js";
 import { createScreenshotRouter } from "./routes/screenshot.js";
 import { createPreferencesRouter } from "./routes/preferences.js";
 import { normalizePath } from "./normalize-path.js";
+import { extractSourceLocation } from '../../lib/dist/index.js';
 const PORT = parseInt(process.env.FLUIDCAD_SERVER_PORT || '3100', 10);
 const WORKSPACE_PATH = normalizePath(process.env.FLUIDCAD_WORKSPACE_PATH || '');
 const UI_DIST = path.resolve(import.meta.dirname, '../../ui/dist');
@@ -142,6 +143,62 @@ wss.on('connection', (ws) => {
 // ---------------------------------------------------------------------------
 let currentFile = null;
 let renderVersion = 0;
+const lastSceneByFile = new Map();
+function emitSuccess(absPath, result, rollbackStop, breakpointHit) {
+    lastSceneByFile.set(absPath, { result, rollbackStop });
+    sendToExtension({
+        type: 'scene-rendered',
+        absPath,
+        result,
+        rollbackStop,
+    });
+    broadcastToUI({
+        type: 'scene-rendered',
+        result,
+        absPath,
+        rollbackStop,
+        breakpointHit,
+    });
+}
+function buildCompileError(filePath, err) {
+    const message = err?.message || String(err);
+    const stack = typeof err?.stack === 'string' ? err.stack : '';
+    let sourceLocation = stack ? extractSourceLocation(stack) : null;
+    const normalized = normalizePath(filePath).replace('virtual:live-render:', '');
+    if (sourceLocation) {
+        sourceLocation = {
+            filePath: sourceLocation.filePath.replace('virtual:live-render:', ''),
+            line: sourceLocation.line,
+            column: sourceLocation.column,
+        };
+    }
+    return {
+        message,
+        filePath: normalized,
+        sourceLocation: sourceLocation ?? undefined,
+    };
+}
+function emitCompileError(filePath, err) {
+    const compileError = buildCompileError(filePath, err);
+    const key = compileError.filePath ?? normalizePath(filePath).replace('virtual:live-render:', '');
+    const prev = lastSceneByFile.get(key);
+    const result = prev?.result ?? [];
+    const rollbackStop = prev?.rollbackStop ?? -1;
+    sendToExtension({
+        type: 'scene-rendered',
+        absPath: key,
+        result,
+        rollbackStop,
+        compileError,
+    });
+    broadcastToUI({
+        type: 'scene-rendered',
+        result,
+        absPath: key,
+        rollbackStop,
+        compileError,
+    });
+}
 async function handleExtensionMessage(msg) {
     try {
         switch (msg.type) {
@@ -149,23 +206,20 @@ async function handleExtensionMessage(msg) {
                 const myVersion = ++renderVersion;
                 broadcastToUI({ type: 'processing-file' });
                 currentFile = msg.filePath;
-                const data = await fluidCadServer.processFile(msg.filePath);
-                if (myVersion !== renderVersion) {
-                    return;
+                try {
+                    const data = await fluidCadServer.processFile(msg.filePath);
+                    if (myVersion !== renderVersion) {
+                        return;
+                    }
+                    if (data) {
+                        emitSuccess(data.absPath, data.result, data.rollbackStop, data.breakpointHit);
+                    }
                 }
-                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,
-                        breakpointHit: data.breakpointHit,
-                    });
+                catch (err) {
+                    if (myVersion !== renderVersion) {
+                        return;
+                    }
+                    emitCompileError(msg.filePath, err);
                 }
                 break;
             }
@@ -181,25 +235,14 @@ async function handleExtensionMessage(msg) {
                         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,
-                            breakpointHit: data.breakpointHit,
-                        });
+                        emitSuccess(data.absPath, data.result, data.rollbackStop, data.breakpointHit);
                     }
                 }
-                catch {
-                    // Silently ignore errors during live-update (syntax errors, incomplete
-                    // expressions, etc. while the user is typing). The last successful
-                    // render remains visible. Model-building errors are delivered separately
-                    // via scene-rendered object properties and are not affected.
+                catch (err) {
+                    if (myVersion !== renderVersion) {
+                        return;
+                    }
+                    emitCompileError(msg.fileName, err);
                 }
                 break;
             }
@@ -210,18 +253,7 @@ async function handleExtensionMessage(msg) {
                     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,
-                    });
+                    emitSuccess(data.absPath, data.result, data.rollbackStop);
                 }
                 break;
             }

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

@@ -51,11 +51,21 @@ export type InitCompleteMessage = {
     success: boolean;
     error?: string;
 };
+export type CompileError = {
+    message: string;
+    filePath?: string;
+    sourceLocation?: {
+        filePath: string;
+        line: number;
+        column: number;
+    };
+};
 export type SceneRenderedMessage = {
     type: 'scene-rendered';
     absPath: string;
     result: any[];
     rollbackStop: number;
+    compileError?: CompileError;
 };
 export type ErrorMessage = {
     type: 'error';
@@ -131,6 +141,7 @@ export type UISceneRenderedMessage = {
     absPath: string;
     rollbackStop?: number;
     breakpointHit?: boolean;
+    compileError?: CompileError;
 };
 export type UIHighlightShapeMessage = {
     type: 'highlight-shape';