@cognipilot/rumoca 0.9.4 → 0.9.5

package/rumoca_worker.js

@@ -1,3 +1,10 @@
+import {
+    ensureParsedSourceRootCache,
+    normalizeSimulationSolver,
+    renderDaeTextWithRuntime,
+    simulateModelWithRuntime,
+} from './rumoca_runtime.js';
+
 // Web Worker for Rumoca WASM with rayon threading support
 // This worker runs WASM functions that use Atomics.wait (not allowed on main thread)
 
@@ -7,13 +14,34 @@ const cacheBust = workerUrl.searchParams.get('v') || '';
 const withCacheBust = (path) =>
     cacheBust ? `${path}?v=${encodeURIComponent(cacheBust)}` : path;
 
+// WASM scenario-config commands take JSON-string arguments. Accept either an
+// already-stringified payload field or a structured object from the main thread.
+const jsonArg = (value, emptyDefault = '') =>
+    value == null ? emptyDefault : (typeof value === 'string' ? value : JSON.stringify(value));
+
+function hasWorkspaceSources(workspaceSources) {
+    if (typeof workspaceSources !== 'string') {
+        return false;
+    }
+    const trimmed = workspaceSources.trim();
+    return Boolean(trimmed && trimmed !== '{}');
+}
+
+function syncWorkspaceSources(workspaceSources) {
+    if (typeof sync_workspace_sources !== 'function') {
+        throw new Error('Workspace-source simulation not available in this WASM build.');
+    }
+    sync_workspace_sources(workspaceSources);
+}
+
 let init;
 let wasm_init;
 let get_version;
 let get_builtin_targets;
 let compile_to_json;
-let compile_with_project_sources;
-let sync_project_sources;
+let compile_with_workspace_sources;
+let sync_workspace_sources;
+let workspace_effective_source_roots;
 let get_source_root_statuses;
 let get_simulation_models;
 let compile_with_source_roots;
@@ -22,6 +50,7 @@ let clear_source_root_cache;
 let get_source_root_document_count;
 let export_parsed_source_roots_binary;
 let merge_parsed_source_roots_binary;
+let prime_source_root_completion_cache;
 let lsp_diagnostics;
 let lsp_hover;
 let lsp_completion;
@@ -34,52 +63,30 @@ let lsp_semantic_token_legend;
 let list_classes;
 let get_class_info;
 let render_target;
+let scenario_get_simulation_config;
+let scenario_set_simulation_preset;
+let scenario_reset_simulation_preset;
+let scenario_get_visualization_config;
+let scenario_set_visualization_config;
+let scenario_get_codegen_config;
+let scenario_set_codegen_config;
+let scenario_get_source_roots;
+let scenario_set_source_roots;
+let scenario_get_scenario_config;
+let scenario_get_scenario_config_full;
+let scenario_set_scenario_config;
+let scenario_default_scenario_config;
 let simulate_model = null;
-let simulate_model_with_project_sources = null;
+let simulate_model_with_workspace_sources = null;
 let lower_model_to_solve_json = null;
+let model_parameter_metadata = null;
+let model_parameter_metadata_with_workspace_sources = null;
+let model_parameter_metadata_with_source_roots = null;
+let prepare_gpu_simulation = null;
+let wasmRuntimeModule = null;
 let wasmModuleLoaded = false;
 let activeRequestId = null;
 
-// Lazy diffsol (stiff/implicit) addon — a separate relaxed-SIMD module, loaded
-// only when a BDF solve is requested, so this worker (and the package) stay
-// universal. Returns the addon's exports, or rejects on browsers without
-// relaxed-SIMD.
-let diffsolAddonPromise = null;
-function loadDiffsolAddon() {
-    if (!diffsolAddonPromise) {
-        diffsolAddonPromise = (async () => {
-            const mod = await import(withCacheBust('./rumoca_bind_wasm_diffsol.js'));
-            await mod.default();
-            return mod;
-        })();
-        diffsolAddonPromise.catch(() => {
-            diffsolAddonPromise = null;
-        });
-    }
-    return diffsolAddonPromise;
-}
-
-// Run a stiff (BDF/diffsol) simulation: the main module lowers the model to a
-// `{ solve_model, t_end, dt }` payload, the addon simulates it. Returns the
-// same JSON string shape as `simulate_model`.
-async function simulateViaDiffsol(source, model, tEnd, dt) {
-    if (typeof lower_model_to_solve_json !== 'function') {
-        throw new Error('this build cannot lower models for the diffsol addon');
-    }
-    let addon;
-    try {
-        addon = await loadDiffsolAddon();
-    } catch (err) {
-        throw new Error(
-            'the stiff (BDF/diffsol) solver needs a browser with WebAssembly '
-            + 'relaxed-SIMD (Chrome 114+, Firefox 120+, Safari 16.4+). '
-            + `Use RK45 instead. (${err && err.message ? err.message : err})`,
-        );
-    }
-    const prep = lower_model_to_solve_json(source, model, tEnd, dt);
-    return addon.simulate_solve_model_diffsol(prep);
-}
-
 function canUseSharedWasmThreads() {
     return typeof self.crossOriginIsolated === 'boolean'
         && self.crossOriginIsolated
@@ -94,8 +101,9 @@ async function loadWasmModule() {
     get_version = mod.get_version;
     get_builtin_targets = mod.get_builtin_targets;
     compile_to_json = mod.compile_to_json;
-    compile_with_project_sources = mod.compile_with_project_sources;
-    sync_project_sources = mod.sync_project_sources;
+    compile_with_workspace_sources = mod.compile_with_workspace_sources;
+    sync_workspace_sources = mod.sync_workspace_sources;
+    workspace_effective_source_roots = mod.workspace_effective_source_roots;
     get_source_root_statuses = mod.get_source_root_statuses;
     get_simulation_models = mod.get_simulation_models;
     compile_with_source_roots = mod.compile_with_source_roots;
@@ -104,6 +112,7 @@ async function loadWasmModule() {
     get_source_root_document_count = mod.get_source_root_document_count;
     export_parsed_source_roots_binary = mod.export_parsed_source_roots_binary;
     merge_parsed_source_roots_binary = mod.merge_parsed_source_roots_binary;
+    prime_source_root_completion_cache = mod.prime_source_root_completion_cache;
     lsp_diagnostics = mod.lsp_diagnostics;
     lsp_hover = mod.lsp_hover;
     lsp_completion = mod.lsp_completion;
@@ -116,28 +125,66 @@ async function loadWasmModule() {
     list_classes = mod.list_classes;
     get_class_info = mod.get_class_info;
     render_target = mod.render_target;
+    scenario_get_simulation_config = mod.scenario_get_simulation_config;
+    scenario_set_simulation_preset = mod.scenario_set_simulation_preset;
+    scenario_reset_simulation_preset = mod.scenario_reset_simulation_preset;
+    scenario_get_visualization_config = mod.scenario_get_visualization_config;
+    scenario_set_visualization_config = mod.scenario_set_visualization_config;
+    scenario_get_codegen_config = mod.scenario_get_codegen_config;
+    scenario_set_codegen_config = mod.scenario_set_codegen_config;
+    scenario_get_source_roots = mod.scenario_get_source_roots;
+    scenario_set_source_roots = mod.scenario_set_source_roots;
+    scenario_get_scenario_config = mod.scenario_get_scenario_config;
+    scenario_get_scenario_config_full = mod.scenario_get_scenario_config_full;
+    scenario_set_scenario_config = mod.scenario_set_scenario_config;
+    scenario_default_scenario_config = mod.scenario_default_scenario_config;
     if (typeof mod.simulate_model === 'function') {
         simulate_model = mod.simulate_model;
     }
-    if (typeof mod.simulate_model_with_project_sources === 'function') {
-        simulate_model_with_project_sources = mod.simulate_model_with_project_sources;
-    }
+    simulate_model_with_workspace_sources = mod.simulate_model_with_workspace_sources;
     if (typeof mod.lower_model_to_solve_json === 'function') {
         lower_model_to_solve_json = mod.lower_model_to_solve_json;
     }
+    if (typeof mod.model_parameter_metadata === 'function') {
+        model_parameter_metadata = mod.model_parameter_metadata;
+    }
+    if (typeof mod.model_parameter_metadata_with_workspace_sources === 'function') {
+        model_parameter_metadata_with_workspace_sources = mod.model_parameter_metadata_with_workspace_sources;
+    }
+    if (typeof mod.model_parameter_metadata_with_source_roots === 'function') {
+        model_parameter_metadata_with_source_roots = mod.model_parameter_metadata_with_source_roots;
+    }
+    if (typeof mod.prepare_gpu_simulation === 'function') {
+        prepare_gpu_simulation = mod.prepare_gpu_simulation;
+    }
+    wasmRuntimeModule = {
+        compile: compile_to_json,
+        lower_model_to_solve_json,
+        merge_parsed_source_roots_binary,
+        model_parameter_metadata,
+        model_parameter_metadata_with_source_roots,
+        model_parameter_metadata_with_workspace_sources,
+        prime_source_root_completion_cache,
+        prepare_gpu_simulation,
+        render_target,
+        simulate_model,
+    };
     wasmModuleLoaded = true;
 }
 
 let initialized = false;
+const debugWorkerLogs = false;
 
 // Intercept console.log to forward progress messages to main thread
 const originalLog = console.log;
 console.log = function(...args) {
-    originalLog.apply(console, args);
+    if (debugWorkerLogs) {
+        originalLog.apply(console, args);
+    }
     // Forward WASM progress messages to main thread
     const message = args.join(' ');
     if (message.includes('[WASM]') && message.includes('parsing')) {
-        // Extract progress info: "[WASM] wasm::project: parsing 50/500 (10%)"
+        // Extract progress info: "[WASM] wasm::workspace: parsing 50/500 (10%)"
         const scopeMatch = message.match(/\[WASM\]\s+([^:]+(?:::[^:]+)*):\s+/);
         const match = message.match(/parsing (\d+)\/(\d+) \((\d+)%\)/);
         if (match) {
@@ -159,20 +206,20 @@ async function initialize() {
     if (initialized) return true;
 
     try {
-        console.log('[Worker] Loading WASM module...');
+        if (debugWorkerLogs) console.log('[Worker] Loading WASM module...');
         await loadWasmModule();
         await init({ module_or_path: withCacheBust('./rumoca_bind_wasm_bg.wasm') });
 
         const requestedThreads = navigator.hardwareConcurrency || 4;
         const numThreads = canUseSharedWasmThreads() ? requestedThreads : 0;
         if (numThreads > 0) {
-            console.log('[Worker] Initializing thread pool...');
+            if (debugWorkerLogs) console.log('[Worker] Initializing thread pool...');
         } else {
-            console.warn('[Worker] Shared WASM threads unavailable; using single-thread mode.');
+            if (debugWorkerLogs) console.warn('[Worker] Shared WASM threads unavailable; using single-thread mode.');
         }
         await wasm_init(numThreads);
         if (numThreads > 0) {
-            console.log(`[Worker] Thread pool initialized with ${numThreads} threads`);
+            if (debugWorkerLogs) console.log(`[Worker] Thread pool initialized with ${numThreads} threads`);
         }
         initialized = true;
         return true;
@@ -211,23 +258,35 @@ self.onmessage = async (e) => {
         switch (action) {
             case 'languageCommand': {
                 const payload = e.data.payload || {};
-                if (typeof sync_project_sources === 'function' && typeof payload.projectSources === 'string') {
-                    sync_project_sources(payload.projectSources);
+                if (typeof sync_workspace_sources === 'function' && typeof payload.workspaceSources === 'string') {
+                    sync_workspace_sources(payload.workspaceSources);
                 }
                 switch (command) {
                     case 'rumoca.language.getSourceRootDocumentCount':
                         result = get_source_root_document_count();
                         break;
                     case 'rumoca.language.diagnostics':
+                        await ensureParsedSourceRootCache(
+                            wasmRuntimeModule,
+                            payload.sourceRootCacheUrl || '',
+                        );
                         result = lsp_diagnostics(payload.source || '');
                         break;
                     case 'rumoca.language.hover':
                         result = lsp_hover(payload.source || '', payload.line, payload.character);
                         break;
                     case 'rumoca.language.completion':
+                        await ensureParsedSourceRootCache(
+                            wasmRuntimeModule,
+                            payload.sourceRootCacheUrl || '',
+                        );
                         result = lsp_completion(payload.source || '', payload.line, payload.character);
                         break;
                     case 'rumoca.language.completionWithTiming':
+                        await ensureParsedSourceRootCache(
+                            wasmRuntimeModule,
+                            payload.sourceRootCacheUrl || '',
+                        );
                         result = lsp_completion_with_timing(payload.source || '', payload.line, payload.character);
                         break;
                     case 'rumoca.language.definition':
@@ -263,53 +322,206 @@ self.onmessage = async (e) => {
                 }
                 break;
             }
-            case 'projectCommand': {
+            case 'scenarioCommand': {
                 const payload = e.data.payload || {};
                 switch (command) {
-                    case 'rumoca.project.getSimulationModels':
+                    case 'rumoca.scenario.getSimulationModels':
                         result = get_simulation_models(payload.source || '', payload.defaultModel || '');
                         break;
-                    case 'rumoca.project.startSimulation':
+                    case 'rumoca.scenario.getSimulationConfig':
+                        result = scenario_get_simulation_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            jsonArg(payload.fallback),
+                        );
+                        break;
+                    case 'rumoca.scenario.setSimulationPreset':
+                        result = scenario_set_simulation_preset(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            jsonArg(payload.preset, 'null'),
+                        );
+                        break;
+                    case 'rumoca.scenario.resetSimulationPreset':
+                        result = scenario_reset_simulation_preset(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.getVisualizationConfig':
+                        result = scenario_get_visualization_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.setVisualizationConfig':
+                        result = scenario_set_visualization_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            jsonArg(payload.views, 'null'),
+                        );
+                        break;
+                    case 'rumoca.scenario.getCodegenConfig':
+                        result = scenario_get_codegen_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.setCodegenConfig':
+                        result = scenario_set_codegen_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            jsonArg(payload.config, 'null'),
+                        );
+                        break;
+                    case 'rumoca.scenario.getSourceRoots':
+                        result = scenario_get_source_roots(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            payload.task || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.setSourceRoots':
+                        result = scenario_set_source_roots(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            jsonArg(payload.config, 'null'),
+                        );
+                        break;
+                    case 'rumoca.scenario.getScenarioConfig':
+                        result = scenario_get_scenario_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.path || payload.uri || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.getScenarioConfigFull':
+                        result = scenario_get_scenario_config_full(
+                            jsonArg(payload.workspaceSources),
+                            payload.path || payload.uri || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.setScenarioConfig':
+                        result = scenario_set_scenario_config(
+                            payload.path || payload.uri || '',
+                            jsonArg(payload.config, 'null'),
+                        );
+                        break;
+                    case 'rumoca.scenario.defaultScenarioConfig':
+                        result = scenario_default_scenario_config(
+                            jsonArg(payload.workspaceSources),
+                            payload.model || '',
+                            payload.task || '',
+                        );
+                        break;
+                    case 'rumoca.scenario.startSimulation':
                         if (!simulate_model) {
                             throw new Error('Simulation not available in this WASM build. Rebuild with rumoca-sim (diffsol feature enabled).');
                         }
-                        if ((payload.solver || '') === 'bdf') {
-                            // Stiff path: route to the lazy diffsol addon (the
-                            // main module can't simulate bdf — it has no diffsol
-                            // runtime). Project-local sources aren't supported on
-                            // this path yet.
-                            result = await simulateViaDiffsol(
+                        if (typeof payload.sourceRoots === 'string' && payload.sourceRoots.trim() && payload.sourceRoots.trim() !== '{}') {
+                            load_source_roots(payload.sourceRoots);
+                        }
+                        {
+                            const solver = normalizeSimulationSolver(payload.solver);
+                            const useWorkspaceSources = hasWorkspaceSources(payload.workspaceSources);
+                            const parameterOverrides = payload.parameterOverrides && typeof payload.parameterOverrides === 'object'
+                                ? payload.parameterOverrides
+                                : {};
+                            if (useWorkspaceSources && solver === 'bdf') {
+                                syncWorkspaceSources(payload.workspaceSources);
+                                result = JSON.stringify(await simulateModelWithRuntime({
+                                    wasm: wasmRuntimeModule,
+                                    pkgBase: './',
+                                    source: payload.source || '',
+                                    modelName: payload.modelName || 'Model',
+                                    tEnd: payload.tEnd || 1.0,
+                                    dt: payload.dt || 0,
+                                    solver,
+                                    sourceRootCacheUrl: payload.sourceRootCacheUrl || '',
+                                    parameterOverrides,
+                                }));
+                            } else if (useWorkspaceSources) {
+                                if (typeof simulate_model_with_workspace_sources !== 'function') {
+                                    throw new Error('Workspace-source simulation not available in this WASM build.');
+                                }
+                                result = simulate_model_with_workspace_sources(
+                                    payload.source || '',
+                                    payload.modelName || 'Model',
+                                    payload.workspaceSources,
+                                    payload.tEnd || 1.0,
+                                    payload.dt || 0,
+                                    solver,
+                                    jsonArg(parameterOverrides, '{}'),
+                                );
+                            } else {
+                                result = JSON.stringify(await simulateModelWithRuntime({
+                                    wasm: wasmRuntimeModule,
+                                    pkgBase: './',
+                                    source: payload.source || '',
+                                    modelName: payload.modelName || 'Model',
+                                    tEnd: payload.tEnd || 1.0,
+                                    dt: payload.dt || 0,
+                                    solver,
+                                    sourceRootCacheUrl: payload.sourceRootCacheUrl || '',
+                                    parameterOverrides,
+                                }));
+                            }
+                        }
+                        break;
+                    case 'rumoca.model.parameterMetadata':
+                        if (typeof payload.sourceRoots === 'string' && payload.sourceRoots.trim() && payload.sourceRoots.trim() !== '{}') {
+                            if (typeof model_parameter_metadata_with_source_roots !== 'function') {
+                                throw new Error('Source-root parameter metadata is not available in this WASM build.');
+                            }
+                            result = model_parameter_metadata_with_source_roots(
                                 payload.source || '',
                                 payload.modelName || 'Model',
-                                payload.tEnd || 1.0,
-                                payload.dt || 0,
+                                payload.sourceRoots,
                             );
-                        } else if (
-                            simulate_model_with_project_sources
-                            && typeof payload.projectSources === 'string'
-                            && payload.projectSources.trim()
-                            && payload.projectSources.trim() !== '{}'
-                        ) {
-                            result = simulate_model_with_project_sources(
+                        } else if (hasWorkspaceSources(payload.workspaceSources)) {
+                            if (typeof model_parameter_metadata_with_workspace_sources !== 'function') {
+                                throw new Error('Workspace parameter metadata is not available in this WASM build.');
+                            }
+                            result = model_parameter_metadata_with_workspace_sources(
                                 payload.source || '',
                                 payload.modelName || 'Model',
-                                payload.projectSources,
-                                payload.tEnd || 1.0,
-                                payload.dt || 0,
-                                payload.solver || 'auto',
+                                payload.workspaceSources,
                             );
                         } else {
-                            result = simulate_model(
+                            if (typeof model_parameter_metadata !== 'function') {
+                                throw new Error('Parameter metadata is not available in this WASM build.');
+                            }
+                            result = model_parameter_metadata(
                                 payload.source || '',
                                 payload.modelName || 'Model',
-                                payload.tEnd || 1.0,
-                                payload.dt || 0,
-                                payload.solver || 'auto',
                             );
                         }
                         break;
+                    case 'rumoca.scenario.renderDaeText':
+                        result = await renderDaeTextWithRuntime({
+                            wasm: wasmRuntimeModule,
+                            source: payload.source || '',
+                            modelName: payload.modelName || 'Model',
+                            sourceRootCacheUrl: payload.sourceRootCacheUrl || '',
+                        });
+                        break;
+                    case 'rumoca.scenario.prepareGpuSimulation':
+                        await ensureParsedSourceRootCache(
+                            wasmRuntimeModule,
+                            payload.sourceRootCacheUrl || '',
+                        );
+                        if (typeof payload.source !== 'string') {
+                            throw new Error('prepareGpuSimulation requires source text');
+                        }
+                        if (typeof prepare_gpu_simulation !== 'function') {
+                            throw new Error('prepare_gpu_simulation missing in this WASM build');
+                        }
+                        result = prepare_gpu_simulation(
+                            payload.source || '',
+                            payload.modelName || 'Model',
+                        );
+                        break;
                     default:
-                        throw new Error(`Unknown project command: ${command}`);
+                        throw new Error(`Unknown scenario command: ${command}`);
                 }
                 break;
             }
@@ -325,11 +537,11 @@ self.onmessage = async (e) => {
                     case 'rumoca.workspace.compile':
                         result = compile_to_json(payload.source || '', payload.modelName || 'Model');
                         break;
-                    case 'rumoca.workspace.compileWithProjectSources':
-                        result = compile_with_project_sources(
+                    case 'rumoca.workspace.compileWithWorkspaceSources':
+                        result = compile_with_workspace_sources(
                             payload.source || '',
                             payload.modelName || 'Model',
-                            payload.projectSources || '{}',
+                            payload.workspaceSources || '{}',
                         );
                         break;
                     case 'rumoca.workspace.compileWithSourceRoots':
@@ -345,6 +557,15 @@ self.onmessage = async (e) => {
                     case 'rumoca.workspace.getSourceRootStatuses':
                         result = get_source_root_statuses();
                         break;
+                    case 'rumoca.workspace.effectiveSourceRoots':
+                        if (typeof workspace_effective_source_roots !== 'function') {
+                            throw new Error('workspace_effective_source_roots missing in this WASM build');
+                        }
+                        result = workspace_effective_source_roots(
+                            payload.workspaceSources || '{}',
+                            payload.focusPath || payload.path || '',
+                        );
+                        break;
                     case 'rumoca.workspace.exportParsedSourceRootsBinary':
                         result = export_parsed_source_roots_binary(payload.urisJson || '[]');
                         break;
@@ -388,7 +609,6 @@ self.onmessage = async (e) => {
         self.postMessage({ id, success: true, result });
     } catch (e) {
         activeRequestId = null;
-        console.error('[Worker] Error:', e);
         self.postMessage({ id, error: e.message || String(e) });
     }
 };