fluidcad 0.0.34 → 0.0.36

package/server/dist/fluidcad-server.js

@@ -1,107 +1,206 @@
 import { createHash } from 'crypto';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { ViteManager } from "./vite-manager.js";
+import { LocalSceneHost } from "./host/local-scene-host.js";
 import { normalizePath } from "./normalize-path.js";
 import { BreakpointHit } from '../../lib/dist/common/breakpoint-hit.js';
+import { createParamRegistry, getParamRegistry } from '../../lib/dist/index.js';
+/**
+ * `sessionId` is the per-renderer state key. In desktop mode it equals the
+ * file path being edited (so per-file state survives switching files). In
+ * hub mode it's a WebSocket connection UUID (so concurrent viewers stay
+ * isolated). Map keys called `sessionId` accept either flavour.
+ */
 export class FluidCadServer {
-    viteManager = new ViteManager();
+    host;
     sceneManager;
+    // Per-session render output, scene cache, and param overrides. Desktop's
+    // sessionId is the normalized filePath; hub mode's sessionId is the WS
+    // connection UUID. Maps must be cleared via `destroySession` on hub-side
+    // disconnect to avoid leaks.
     previousScenes = new Map();
     renderingCache = new Map();
-    // Per-file hash + full result of the most recent successful render. Any
-    // incoming render request — IPC live-update from the extension, watcher-
-    // driven live-update under `fluidcad serve`, or HTTP /api/render from the
-    // MCP — short-circuits here when the new code hashes to the same value.
-    // Avoids redundant OCC work when multiple producers see the same write.
+    // Records the last successful render per session as `{ paramsHash, data }`.
+    // Any subsequent render request short-circuits when the new params hash to
+    // the same value — avoids redundant OCC work when desktop producers see the
+    // same code+params, or hub clients re-emit the same param mutation.
     lastRendered = new Map();
+    paramOverrides = new Map();
+    // What file each session is rendering. For desktop, sessionId === filePath
+    // (set lazily on first processFile call). For hub, set explicitly via
+    // createSession with the bundle's manifest entry.
+    sessionFiles = new Map();
+    // Serializes OCC calls across all sessions. OCC isn't thread-safe and we
+    // share one engine instance per host process; concurrent param edits from
+    // multiple hub clients have to queue. Promise-chain pattern: each render
+    // awaits the previous one's settlement before starting.
+    renderMutex = Promise.resolve();
     currentFileName = '';
     currentFilePath = '';
     lastRollbackStop = -1;
     compileError = null;
+    constructor(host = new LocalSceneHost()) {
+        this.host = host;
+    }
+    getCurrentCode() {
+        if (!this.currentFileName)
+            return null;
+        return this.host.getBuffer(this.currentFileName);
+    }
     async init(workspacePath) {
-        await this.viteManager.init(workspacePath);
+        await this.host.init(workspacePath);
         const initFilePath = normalizePath(join(workspacePath, 'init.js'));
         if (existsSync(initFilePath)) {
-            const { default: _sceneManager } = await this.viteManager.loadModule(initFilePath);
+            const { default: _sceneManager } = await this.host.loadModule(initFilePath);
             this.sceneManager = await _sceneManager;
         }
     }
-    async processFile(filePath, ignoreCache = false) {
-        if (!this.sceneManager) {
-            return null;
+    /**
+     * Capture an already-initialized SceneManager. Used by the hub-mode entry
+     * after running the packed bundle once to materialize the engine globals.
+     */
+    setSceneManager(manager) {
+        this.sceneManager = manager;
+    }
+    /**
+     * Run `fn` with exclusive access to the OCC engine. The mutex is process-
+     * wide: in hub mode concurrent client sessions land here too. Order is
+     * first-come, first-served via Promise chain.
+     */
+    async serialized(fn) {
+        const prev = this.renderMutex;
+        let release = () => { };
+        const next = new Promise((resolve) => { release = resolve; });
+        this.renderMutex = next;
+        try {
+            await prev;
+            return await fn();
         }
-        filePath = normalizePath(filePath);
-        const normalizedFileName = filePath.replace('virtual:live-render:', '');
-        this.currentFileName = normalizedFileName;
-        this.currentFilePath = filePath;
-        if (!ignoreCache) {
-            const fromCache = this.renderingCache.get(normalizedFileName);
-            if (fromCache) {
-                this.lastRollbackStop = fromCache.length - 1;
-                this.compileError = null;
-                return {
-                    absPath: normalizedFileName,
-                    result: fromCache,
-                    rollbackStop: fromCache.length - 1,
-                };
-            }
+        finally {
+            release();
         }
-        try {
-            let scene = this.sceneManager.startScene();
-            this.sceneManager.setCurrentFile(normalizedFileName);
-            this.viteManager.invalidateModule();
-            let breakpointHit = false;
-            try {
-                await this.viteManager.loadModule(filePath);
+    }
+    // ---------------------------------------------------------------------------
+    // Session lifecycle (hub mode)
+    // ---------------------------------------------------------------------------
+    createSession(sessionId, entryFilePath) {
+        this.sessionFiles.set(sessionId, normalizePath(entryFilePath));
+    }
+    destroySession(sessionId) {
+        this.previousScenes.delete(sessionId);
+        this.renderingCache.delete(sessionId);
+        this.lastRendered.delete(sessionId);
+        this.paramOverrides.delete(sessionId);
+        this.sessionFiles.delete(sessionId);
+    }
+    /**
+     * Re-render the session's entry, ignoring caches. Hub clients call this
+     * after editing a param. Returns the fresh render or null if no manager.
+     */
+    async recomputeForSession(sessionId) {
+        const filePath = this.sessionFiles.get(sessionId);
+        if (!filePath)
+            return null;
+        this.renderingCache.delete(sessionId);
+        this.lastRendered.delete(sessionId);
+        return this.processFileInternal(sessionId, filePath, true);
+    }
+    // ---------------------------------------------------------------------------
+    // Render — internal core used by both desktop and hub entry points
+    // ---------------------------------------------------------------------------
+    async processFileInternal(sessionId, filePath, ignoreCache) {
+        return this.serialized(async () => {
+            if (!this.sceneManager) {
+                return null;
             }
-            catch (e) {
-                if (e instanceof BreakpointHit) {
-                    breakpointHit = true;
-                }
-                else {
-                    throw e;
+            const normalizedFileName = filePath.replace('virtual:live-render:', '');
+            this.currentFileName = normalizedFileName;
+            this.currentFilePath = filePath;
+            if (!ignoreCache) {
+                const fromCache = this.renderingCache.get(sessionId);
+                if (fromCache) {
+                    this.lastRollbackStop = fromCache.length - 1;
+                    this.compileError = null;
+                    return {
+                        absPath: normalizedFileName,
+                        result: fromCache,
+                        rollbackStop: fromCache.length - 1,
+                    };
                 }
             }
-            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:', '');
+            try {
+                let scene = this.sceneManager.startScene();
+                this.sceneManager.setCurrentFile(normalizedFileName);
+                this.host.invalidateModule();
+                const registry = createParamRegistry();
+                const overrides = this.paramOverrides.get(sessionId);
+                if (overrides) {
+                    registry.setOverrides(overrides);
+                }
+                let breakpointHit = false;
+                try {
+                    await this.host.loadModule(filePath);
+                }
+                catch (e) {
+                    if (e instanceof BreakpointHit) {
+                        breakpointHit = true;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                const params = getParamRegistry().getDefinitions();
+                if (this.previousScenes.has(sessionId)) {
+                    const previousScene = this.previousScenes.get(sessionId);
+                    scene = this.sceneManager.compare(previousScene, scene);
                 }
+                this.previousScenes.set(sessionId, 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(sessionId, result);
+                }
+                this.lastRollbackStop = result.length - 1;
+                this.compileError = null;
+                return {
+                    absPath: normalizedFileName,
+                    result,
+                    rollbackStop: result.length - 1,
+                    breakpointHit,
+                    params,
+                };
             }
-            if (!filePath.startsWith('virtual:live-render')) {
-                this.renderingCache.set(normalizedFileName, result);
+            catch (error) {
+                this.host.invalidateModule();
+                console.log('Error processing file:', error);
+                throw error;
             }
-            this.lastRollbackStop = result.length - 1;
-            this.compileError = null;
-            return {
-                absPath: normalizedFileName,
-                result,
-                rollbackStop: result.length - 1,
-                breakpointHit,
-            };
-        }
-        catch (error) {
-            this.viteManager.invalidateModule();
-            console.log('Error processing file:', error);
-            throw error;
-        }
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Desktop API — sessionId is implicit (filePath)
+    // ---------------------------------------------------------------------------
+    async processFile(filePath, ignoreCache = false) {
+        filePath = normalizePath(filePath);
+        const sessionId = filePath.replace('virtual:live-render:', '');
+        this.sessionFiles.set(sessionId, sessionId);
+        return this.processFileInternal(sessionId, filePath, ignoreCache);
     }
     async updateLiveCode(fileName, code) {
         fileName = normalizePath(fileName);
-        // Dedup against the last successful render of this file. Multiple
-        // producers (editor live-update, save-triggered process-file, watcher,
-        // MCP /api/render) commonly hand us identical content; without this
-        // short-circuit each one would trigger a redundant OCC pass.
-        const hash = hashCode(code);
+        // Dedup against the last successful render. Multiple producers (editor
+        // live-update, save-triggered process-file, watcher, MCP /api/render)
+        // commonly hand us identical content; without this short-circuit each
+        // would trigger a redundant OCC pass. paramsHash mixes code content with
+        // current param overrides so a param change invalidates the cache.
+        const paramsHash = this.computeParamsHash(fileName, code);
         const cached = this.lastRendered.get(fileName);
-        if (cached && cached.hash === hash) {
+        if (cached && cached.paramsHash === paramsHash) {
             this.compileError = null;
             this.currentFileName = fileName;
             this.currentFilePath = `virtual:live-render:${fileName}`;
@@ -109,11 +208,12 @@ export class FluidCadServer {
             return cached.data;
         }
         const id = `virtual:live-render:${fileName}`;
-        this.viteManager.setBuffer(id, code);
+        this.host.setBuffer(id, code);
         this.renderingCache.delete(fileName);
-        const result = await this.processFile(id, true);
+        this.sessionFiles.set(fileName, fileName);
+        const result = await this.processFileInternal(fileName, id, true);
         if (result) {
-            this.lastRendered.set(fileName, { hash, data: result });
+            this.lastRendered.set(fileName, { paramsHash, data: result });
         }
         return result;
     }
@@ -124,10 +224,10 @@ export class FluidCadServer {
         if (!this.currentFilePath) {
             return null;
         }
-        this.previousScenes.delete(this.currentFileName);
-        this.renderingCache.delete(this.currentFileName);
-        this.lastRendered.delete(this.currentFileName);
-        return this.processFile(this.currentFilePath, true);
+        const sessionId = this.currentFileName;
+        this.renderingCache.delete(sessionId);
+        this.lastRendered.delete(sessionId);
+        return this.processFileInternal(sessionId, this.currentFilePath, true);
     }
     async rollback(fileName, index) {
         if (!this.sceneManager) {
@@ -195,6 +295,36 @@ export class FluidCadServer {
         }
         return this.sceneManager.exportShapes(scene, shapeIds, options);
     }
+    /**
+     * Export every solid of a hub session's latest render. The session-keyed twin
+     * of `exportShapes` (which reads the desktop `currentFileName`): hub mode keys
+     * each render's scene by `sessionId`, so exporting/downloading from a hub
+     * session must look it up the same way — exactly why `hitTestForSession`
+     * exists. Gathers all solids itself ("download the whole model"); returns null
+     * when the session has no rendered scene or it holds no solids (the caller maps
+     * that to a "nothing to export" response).
+     */
+    exportShapesForSession(sessionId, options) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(sessionId);
+        if (!scene) {
+            return null;
+        }
+        const shapeIds = [];
+        for (const obj of scene.getAllSceneObjects()) {
+            for (const shape of obj.getAddedShapes()) {
+                if (shape.isSolid()) {
+                    shapeIds.push(shape.id);
+                }
+            }
+        }
+        if (shapeIds.length === 0) {
+            return null;
+        }
+        return this.sceneManager.exportShapes(scene, shapeIds, options);
+    }
     hitTest(shapeId, rayOrigin, rayDir, edgeThreshold) {
         if (!this.sceneManager) {
             return null;
@@ -205,12 +335,41 @@ export class FluidCadServer {
         }
         return this.sceneManager.hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold);
     }
+    hitTestForSession(sessionId, shapeId, rayOrigin, rayDir, edgeThreshold) {
+        if (!this.sceneManager) {
+            return null;
+        }
+        const scene = this.previousScenes.get(sessionId);
+        if (!scene) {
+            return null;
+        }
+        return this.sceneManager.hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold);
+    }
     setCompileError(err) {
         this.compileError = err;
     }
     getCompileError() {
         return this.compileError;
     }
+    setParam(sessionId, label, value) {
+        sessionId = normalizePath(sessionId);
+        if (!this.paramOverrides.has(sessionId)) {
+            this.paramOverrides.set(sessionId, new Map());
+        }
+        this.paramOverrides.get(sessionId).set(label, value);
+        this.lastRendered.delete(sessionId);
+    }
+    resetParams(sessionId) {
+        sessionId = normalizePath(sessionId);
+        this.paramOverrides.delete(sessionId);
+        this.lastRendered.delete(sessionId);
+    }
+    getParamOverrides(sessionId) {
+        const map = this.paramOverrides.get(normalizePath(sessionId));
+        if (!map)
+            return {};
+        return Object.fromEntries(map);
+    }
     getCurrentFileName() {
         return this.currentFileName;
     }
@@ -279,15 +438,22 @@ export class FluidCadServer {
         }
         return { shapes };
     }
-}
-/**
- * Hash a `.fluid.js` source for dedup. Newlines are normalised to LF so a
- * round-trip through an editor (CRLF) and a disk write (LF) hashes the
- * same. SHA1 is plenty here — we just need a stable equality check, not
- * collision resistance against an adversary.
- */
-function hashCode(code) {
-    return createHash('sha1').update(code.replace(/\r\n/g, '\n')).digest('hex');
+    /**
+     * Compose a stable cache key over the rendering inputs: the source bytes
+     * being rendered plus the param overrides currently in effect for the
+     * session. Param changes flip the hash so cached entries don't shadow a
+     * recompute, even when the code text is byte-identical.
+     */
+    computeParamsHash(sessionId, codeOrBundle) {
+        const overrides = this.paramOverrides.get(sessionId);
+        const sortedEntries = overrides ? [...overrides.entries()].sort(([a], [b]) => a.localeCompare(b)) : [];
+        const normalized = codeOrBundle.replace(/\r\n/g, '\n');
+        return createHash('sha1')
+            .update(normalized)
+            .update('\0')
+            .update(JSON.stringify(sortedEntries))
+            .digest('hex');
+    }
 }
 const MAX_PARAM_DEPTH = 6;
 function sanitizeParams(value, depth = 0) {

package/server/dist/host/blocked-imports.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Node built-in modules that user `.fluid.js` code must not import. Same set
+ * enforced by LocalSceneHost (at SSR transform time) and the model packer
+ * (at bundle time) so a packed model can't smuggle in capabilities a live
+ * workspace would have rejected.
+ */
+export declare const BLOCKED_NODE_MODULES: Set<string>;
+export declare function getBlockedNodeModule(id: string): string | null;

package/server/dist/host/blocked-imports.js

@@ -0,0 +1,30 @@
+/**
+ * Node built-in modules that user `.fluid.js` code must not import. Same set
+ * enforced by LocalSceneHost (at SSR transform time) and the model packer
+ * (at bundle time) so a packed model can't smuggle in capabilities a live
+ * workspace would have rejected.
+ */
+export const BLOCKED_NODE_MODULES = new Set([
+    'fs',
+    'child_process',
+    'net',
+    'dgram',
+    'tls',
+    'http',
+    'https',
+    'http2',
+    'os',
+    'worker_threads',
+    'vm',
+    'cluster',
+    'dns',
+    'module',
+]);
+export 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;
+}

package/server/dist/{vite-manager.d.ts → host/local-scene-host.d.ts}

@@ -1,10 +1,12 @@
 import { type ViteDevServer } from 'vite';
-export declare class ViteManager {
+import type { SceneHost } from './scene-host.ts';
+export declare class LocalSceneHost implements SceneHost {
     server: ViteDevServer;
     private rootPath;
     private buffers;
     init(rootPath: string): Promise<void>;
     setBuffer(id: string, code: string): void;
+    getBuffer(fileName: string): string | null;
     loadModule(filePath: string): Promise<Record<string, any>>;
     invalidateModule(): void;
 }

package/server/dist/{vite-manager.js → host/local-scene-host.js}

@@ -1,30 +1,7 @@
 import { createServer } from 'vite';
 import { dirname, resolve, isAbsolute } from 'path';
-import { normalizePath } from "./normalize-path.js";
-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;
-}
+import { normalizePath } from "../normalize-path.js";
+import { getBlockedNodeModule } from "./blocked-imports.js";
 const IMPORT_PATTERN = /\b(?:import|export)\s[\s\S]*?from\s+['"]([^'"]+)['"]|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 function scanForBlockedImports(code) {
     let match;
@@ -38,7 +15,7 @@ function scanForBlockedImports(code) {
     }
     return null;
 }
-export class ViteManager {
+export class LocalSceneHost {
     server;
     rootPath = '';
     buffers = new Map();
@@ -102,6 +79,9 @@ export class ViteManager {
     setBuffer(id, code) {
         this.buffers.set(id, code);
     }
+    getBuffer(fileName) {
+        return this.buffers.get(`virtual:live-render:${fileName}`) ?? null;
+    }
     async loadModule(filePath) {
         const mod = await this.server.ssrLoadModule(filePath);
         for (const value of Object.values(mod)) {

package/server/dist/host/scene-host.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Source-of-truth + execution seam for a workspace's scene code.
+ *
+ * `FluidCadServer` owns the engine pipeline (param registry, scene cache,
+ * render orchestration) and does not care where `.fluid.js` source comes
+ * from or how it gets turned into a runnable module. That responsibility
+ * lives behind this interface.
+ *
+ * Implementations:
+ *   - LocalSceneHost: Vite SSR over the workspace directory (desktop).
+ *   - HubSceneHost (Phase 2): in-memory consumer of a packed model bundle.
+ */
+export interface SceneHost {
+    init(workspacePath: string): Promise<void>;
+    loadModule(filePath: string): Promise<Record<string, any>>;
+    setBuffer(id: string, code: string): void;
+    getBuffer(fileName: string): string | null;
+    invalidateModule(): void;
+}

package/server/dist/host/scene-host.js

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