@mindexec/cli 0.2.458 → 0.2.460

package/wwwroot/_content/MindExecution.Shared/js/mind-map-nodes.js

@@ -1412,10 +1412,11 @@
         return normalizeImageAssetUrl(url).toLowerCase().includes('/assets/thumbs/');
     }
 
-    function isAnimatedGifImageUrl(url) {
+    function isAnimationCapableImageUrl(url) {
         const normalized = normalizeImageAssetUrl(url);
         if (!normalized) return false;
-        return normalized.split(/[?#]/)[0].toLowerCase().endsWith('.gif');
+        const pathname = normalized.split(/[?#]/)[0].toLowerCase();
+        return pathname.endsWith('.gif') || pathname.endsWith('.webp');
     }
 
     function getMetadataValueCaseInsensitive(metadata, ...keys) {
@@ -1441,6 +1442,34 @@
         return '';
     }
 
+    function isAnimationCapableImageNodeModel(nodeModel) {
+        if (!nodeModel || getNodeContentTypeLower(nodeModel) !== 'image') {
+            return false;
+        }
+
+        const metadata = getNodeMetadata(nodeModel) || {};
+        const mimeType = getMetadataValueCaseInsensitive(
+            metadata,
+            'fileMime',
+            'FileMime',
+            'mimeType',
+            'MimeType'
+        ).toLowerCase();
+        if (mimeType === 'image/gif' || mimeType === 'image/webp') {
+            return true;
+        }
+
+        return [
+            nodeModel?.response,
+            nodeModel?.Response,
+            metadata?.OriginalPath,
+            metadata?.OriginalUrl,
+            metadata?.originalUrl,
+            metadata?.ImageUrl,
+            metadata?.imageUrl
+        ].some(isAnimationCapableImageUrl);
+    }
+
     function isAnimatedGifImageNodeModel(nodeModel) {
         if (!nodeModel || getNodeContentTypeLower(nodeModel) !== 'image') {
             return false;
@@ -1466,7 +1495,7 @@
             metadata?.originalUrl,
             metadata?.ImageUrl,
             metadata?.imageUrl
-        ].some(isAnimatedGifImageUrl);
+        ].some(url => normalizeImageAssetUrl(url).split(/[?#]/)[0].toLowerCase().endsWith('.gif'));
     }
 
     function getAnimatedGifOriginalReference(nodeModel, fallback = '') {
@@ -1683,9 +1712,9 @@
         const metadata = ensureNodeMetadataObject(nodeModel);
         const normalizedContent = normalizeImageAssetUrl(nextContent);
         const thumbnailUrl = normalizeImageAssetUrl(metadata?.ThumbnailUrl || metadata?.thumbnailUrl || '');
-        const isAnimatedGif = isAnimatedGifImageNodeModel(nodeModel);
+        const isAnimatedImage = isAnimationCapableImageNodeModel(nodeModel);
 
-        if (isAnimatedGif) {
+        if (isAnimatedImage) {
             const originalReference = getAnimatedGifOriginalReference(nodeModel, normalizedContent);
             if (originalReference) {
                 setNodeImageOriginalReference(nodeModel, originalReference);
@@ -1697,7 +1726,7 @@
             setNodeImageOriginalReference(nodeModel, normalizedContent);
         }
 
-        if (thumbnailUrl && !isAnimatedGif) {
+        if (thumbnailUrl && !isAnimatedImage) {
             setNodeImagePreviewUrl(nodeModel, thumbnailUrl);
             return normalizeImageAssetUrl(nodeModel.response ?? nodeModel.Response ?? '');
         }
@@ -1824,15 +1853,15 @@
             ''
         );
         const missingAssetUrl = normalizeImageAssetUrl(metadata?.MissingAssetUrl || '');
-        const isAnimatedGif = isAnimatedGifImageNodeModel(nodeModel);
+        const isAnimatedImage = isAnimationCapableImageNodeModel(nodeModel);
         const responseFullResUrl = isImageContent && canUseAsFullResImageUrl(responseUrl) ? responseUrl : '';
         const missingFullResUrl = canUseAsFullResImageUrl(missingAssetUrl) ? missingAssetUrl : '';
-        const mediaPreviewUrl = isAnimatedGif ? '' : (thumbnailUrl || snapshotUrl || previewImageUrl);
-        const responsePreviewUrl = isImageContent && !isAnimatedGif ? responseUrl : '';
+        const mediaPreviewUrl = isAnimatedImage ? '' : (thumbnailUrl || snapshotUrl || previewImageUrl);
+        const responsePreviewUrl = isImageContent && !isAnimatedImage ? responseUrl : '';
         const fullResUrl = isImageContent
             ? (originalUrl || originalPath || responseFullResUrl || missingFullResUrl)
             : (originalUrl || originalPath || snapshotUrl || previewImageUrl || thumbnailUrl || missingFullResUrl);
-        const previewUrl = isAnimatedGif
+        const previewUrl = isAnimatedImage
             ? (fullResUrl || responseUrl || originalPath || originalUrl || missingAssetUrl)
             : (mediaPreviewUrl || responsePreviewUrl || originalPath || originalUrl || missingAssetUrl);
 
@@ -1846,13 +1875,14 @@
             missingAssetUrl,
             previewUrl,
             fullResUrl,
-            animatedGif: isAnimatedGif
+            animationCapable: isAnimatedImage,
+            animatedGif: isAnimatedImage
         };
     }
 
     function hasNodeImagePreviewSource(assetUrls) {
         if (!assetUrls || typeof assetUrls !== 'object') return false;
-        if (assetUrls.animatedGif === true) return false;
+        if (assetUrls.animationCapable === true || assetUrls.animatedGif === true) return false;
         return !!(
             assetUrls.thumbnailUrl ||
             (assetUrls.responseUrl && isThumbnailImageUrl(assetUrls.responseUrl))
@@ -1879,7 +1909,7 @@
         if (!assetUrls.previewUrl) {
             return;
         }
-        if (assetUrls.animatedGif === true) {
+        if (assetUrls.animationCapable === true || assetUrls.animatedGif === true) {
             return;
         }
 
@@ -4570,6 +4600,7 @@
         bringNodeToFront: bringNodeToFront,
         updateNodeSelectionStyle: updateNodeSelectionStyle,
         applySingleSelection: applySingleSelection,
+        moveCursorAfterNodePlacement: moveCursorAfterNodePlacement,
         resetState: resetState,
         captureDeleteSnapshot: captureDeleteSnapshot,
         // ▼▼▼ [New] Expose helper function for external callers ▼▼▼
@@ -4580,6 +4611,7 @@
         updateAnimatedImageStatusTextures: updateAnimatedImageStatusTextures,
         applyCanonicalNodeResponse: applyCanonicalNodeResponse,
         isGeneratedImageNodeModel: isGeneratedImageNodeModel,
+        isAnimationCapableImageNodeModel: isAnimationCapableImageNodeModel,
         isAnimatedGifImageNodeModel: isAnimatedGifImageNodeModel,
         getNodeImageAssetUrls: getNodeImageAssetUrls,
         setNodeImageOriginalUrl: setNodeImageOriginalUrl,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-render-plan.js

@@ -6,10 +6,13 @@
     const INITIAL_LINE_TEXTURE_ROWS = 1024;
     const GPU_WARM_RETRY_DELAY_MS = 120;
     const IMAGE_ATLAS_TILE_SIZE = 128;
+    const IMAGE_ATLAS_UPLOAD_SETTLE_MS = 1000;
+    const IMAGE_ATLAS_UPLOAD_MAX_WAIT_MS = 3500;
     const frameSampleStates = new WeakMap();
     const residentLinePrewarmStates = new WeakMap();
     const residentTransitionStates = new WeakMap();
     const cssMediaFrameDomStates = new WeakMap();
+    const imageAtlasUploadStates = new WeakMap();
     let cssMediaFrameDomReuseCount = 0;
     let cssMediaFrameDomApplyCount = 0;
     const RESIDENT_CSS_CACHE_TEXT_TYPES = new Set(['text', 'note', 'memo', 'markdown', 'code', 'csv-table']);
@@ -447,6 +450,108 @@
         return true;
     }
 
+    function prepareImageAtlasForEntries(renderer, entries) {
+        let imageCount = 0;
+        for (const entry of entries || []) {
+            const model = entry?.model || null;
+            const contentType = String(model?.contentType ?? model?.ContentType ?? '').toLowerCase();
+            if (contentType === 'video') {
+                imageCount++;
+                continue;
+            }
+            if (contentType === 'image') {
+                if (globalThis.MindMapNodes?.isAnimatedGifImageNodeModel?.(model) !== true) imageCount++;
+                continue;
+            }
+            if (contentType === 'embed') {
+                const urls = globalThis.MindMapNodes?.getNodeImageAssetUrls?.(model) || null;
+                if (urls?.thumbnailUrl || urls?.snapshotUrl || urls?.previewImageUrl) imageCount++;
+            }
+        }
+        return prepareImageAtlasCapacity(renderer, imageCount);
+    }
+
+    function uploadImageAtlasTile(renderer, slot, canvas) {
+        const webglRenderer = renderer?.renderer || null;
+        const gl = renderer?.gl || webglRenderer?.getContext?.() || null;
+        const texture = renderer?.imageAtlasTexture || null;
+        if (!webglRenderer?.initTexture || !gl || !texture || !canvas || !(slot?.slotIndex >= 0)) return false;
+
+        let savedTexture = null;
+        let savedFlipY = null;
+        let savedPremultiply = null;
+        let savedColorspace = null;
+        try {
+            webglRenderer.initTexture(texture);
+            const handle = webglRenderer.properties?.get?.(texture)?.__webglTexture || null;
+            if (!handle) return false;
+            savedTexture = gl.getParameter(gl.TEXTURE_BINDING_2D);
+            savedFlipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);
+            savedPremultiply = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);
+            savedColorspace = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);
+            const columns = Math.max(1, Number(renderer.imageAtlasColumns || 1));
+            const x = (slot.slotIndex % columns) * IMAGE_ATLAS_TILE_SIZE;
+            const y = Math.floor(slot.slotIndex / columns) * IMAGE_ATLAS_TILE_SIZE;
+            gl.bindTexture(gl.TEXTURE_2D, handle);
+            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+            gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+            gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, gl.RGBA, gl.UNSIGNED_BYTE, canvas);
+            renderer._imageAtlasTileUploadCount = Number(renderer._imageAtlasTileUploadCount || 0) + 1;
+            renderer._residentGpuWarmKey = '';
+            renderer._residentImageAtlasWarmVersion = -1;
+            return true;
+        } catch {
+            return false;
+        } finally {
+            if (savedFlipY !== null) gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, savedFlipY);
+            if (savedPremultiply !== null) gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, savedPremultiply);
+            if (savedColorspace !== null) gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, savedColorspace);
+            if (savedTexture !== null) gl.bindTexture(gl.TEXTURE_2D, savedTexture);
+        }
+    }
+
+    function scheduleImageAtlasUpload(renderer, module = renderer?._module) {
+        if (!renderer?.imageAtlasTexture || renderer?._disposed === true) return false;
+        const now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        let state = imageAtlasUploadStates.get(renderer);
+        if (!state) {
+            state = { timer: 0, startedAt: now, pending: false, epoch: 0 };
+            imageAtlasUploadStates.set(renderer, state);
+        }
+        state.pending = true;
+        state.epoch = Number(renderer._residentStaticPreviewEpoch || 0);
+        if (!(state.startedAt > 0)) state.startedAt = now;
+        if (state.timer) clearTimeout(state.timer);
+        const elapsedMs = Math.max(0, now - state.startedAt);
+        const delayMs = Math.max(0, Math.min(
+            IMAGE_ATLAS_UPLOAD_SETTLE_MS,
+            IMAGE_ATLAS_UPLOAD_MAX_WAIT_MS - elapsedMs
+        ));
+        state.timer = setTimeout(() => {
+            state.timer = 0;
+            if (!state.pending || renderer._disposed === true ||
+                state.epoch !== Number(renderer._residentStaticPreviewEpoch || 0)) return;
+            state.pending = false;
+            state.startedAt = 0;
+            if (!renderer.imageAtlasTexture) return;
+            renderer.imageAtlasTexture.needsUpdate = true;
+            renderer._imageAtlasTextureUploadCount = Number(renderer._imageAtlasTextureUploadCount || 0) + 1;
+            const activeModule = renderer._module || module;
+            if (activeModule) {
+                activeModule._forceUpdateFrames = Math.max(Number(activeModule._forceUpdateFrames || 0), 1);
+                activeModule.requestAnimationWake?.('image-atlas-texture-upload');
+            }
+        }, delayMs);
+        return true;
+    }
+
+    function clearScheduledImageAtlasUpload(renderer) {
+        const state = imageAtlasUploadStates.get(renderer);
+        if (state?.timer) clearTimeout(state.timer);
+        imageAtlasUploadStates.delete(renderer);
+    }
+
     function fallbackBatch(renderer, fallbackIds, limit = 12) {
         const ids = Array.from(fallbackIds || []);
         const safeLimit = Math.max(1, Number(limit || 1));
@@ -698,6 +803,12 @@
         return result === true;
     }
 
+    function hasActionableResidentLineDetails(renderer, module, lodBand) {
+        const nodeIds = renderer?.instanceData?.nodeIds || [];
+        return nodeIds.length > 0 && renderer?._hasPendingLineDetailRestore?.(lodBand) === true &&
+            areResidentLinesPrepared(renderer, module?.nodeObjectsById, nodeIds);
+    }
+
     function hasResidentDirtyWork(renderer, camera, module, resolveLodBand, buildSelectionKey, isAnimatedGifModel) {
         if (!renderer) return false;
         const lodBand = camera && typeof resolveLodBand === 'function'
@@ -710,7 +821,7 @@
             renderer._imageAtlasRebuildPending === true || Number(renderer._imageAtlasQueuedIds?.size || 0) > 0 ||
             Number(renderer._imageAtlasLoadingIds?.size || 0) > 0 || Number(renderer._imageAtlasBatchReadyIds?.size || 0) > 0 ||
             renderer._imageAtlasBatchActive === true || renderer._lodCleanupPending === true ||
-            renderer._deferLineRestorePending === true || renderer._hasPendingLineDetailRestore?.(lodBand) === true ||
+            renderer._deferLineRestorePending === true || hasActionableResidentLineDetails(renderer, module, lodBand) ||
             Number(renderer._pendingLodVisibilityVersion ?? -1) >= 0 || renderer._fullResHandoffActive === true ||
             renderer.isLoading === true || module?.isLoading === true || renderer._hasResidentLodInstances?.() !== true;
         if (hasTypedResidentDirtyWork) {
@@ -1797,6 +1908,10 @@
         ensureLineTextureCapacity,
         renderResidentWarmScene,
         prepareImageAtlasCapacity,
+        prepareImageAtlasForEntries,
+        uploadImageAtlasTile,
+        scheduleImageAtlasUpload,
+        clearScheduledImageAtlasUpload,
         fallbackBatch,
         reuseCssMediaFrameDom,
         reuseStableVisibleCss,
@@ -1807,6 +1922,7 @@
         invalidateActiveCssMediaFallbackCountCache,
         markLodImageCssFallbacksChanged,
         createTrackedLodImageCssFallbackSet,
+        hasActionableResidentLineDetails,
         hasResidentDirtyWork,
         hasPendingNearCssWarmup,
         reusePreparedImageInstances,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-texture-factory.js

@@ -593,8 +593,11 @@
             preferOriginal !== true &&
             existingSourceKind === 'original' &&
             (matchesOriginalUrl || isThumbnailAssetUrl(normalizedRequestedUrl));
+        const canUseMatchingOriginal =
+            matchesOriginalUrl &&
+            (preferOriginal === true || options.allowOriginalReuseForPreview !== false);
 
-        if (!(matchesRequestedUrl || matchesOriginalUrl || canUseOriginalForPreview)) {
+        if (!(matchesRequestedUrl || canUseMatchingOriginal || canUseOriginalForPreview)) {
             return false;
         }
 

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-2nIeTn87ps7hCIDuMs8IMWpBJVZ9YCRuQ89zxygANvg=",
+    "hash": "sha256-j3+TOGBljyWZdYIgA9a2YYTlaG+Rt2EVMQ0fB5eRn8E=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -122,16 +122,16 @@
       "System.brmz7yk5qh.dll": "System.dll",
       "netstandard.b50t77veor.dll": "netstandard.dll",
       "System.Private.CoreLib.g6ztz7cmo2.dll": "System.Private.CoreLib.dll",
-      "MindExecution.Core.2ch68iyy8o.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.dh617xfv36.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.0sm50hbae9.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.3wq01orrbu.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.z8yl28fa2a.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.m7murp5oes.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.yuyrbpf0vh.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.rwxvn00rm2.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.r9k48iyijb.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.742aribkxm.dll": "MindExecution.Web.dll",
+      "MindExecution.Core.oqju650dkd.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.7zjugdfmfg.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.qln7lkmsnn.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.rd6flxuebm.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.0qrgx3epss.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.4prauy9d1z.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.cobfta1p3l.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.99bahbgkkr.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.sevaa4rgkp.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.coqh2ccnuk.dll": "MindExecution.Web.dll",
       "dotnet.native.566r55w3xu.js": "dotnet.native.js",
       "dotnet.native.x6q5aixc38.wasm": "dotnet.native.wasm",
       "dotnet.js": "dotnet.js",
@@ -276,18 +276,18 @@
       "System.Xml.XDocument.sn51jas17n.dll": "sha256-GNI2kFgFmPTwzuzwUn8gxK+AzGLUWRJFdg9JzIbrybQ=",
       "System.brmz7yk5qh.dll": "sha256-CfM2miyj1KHApFmqMdLYWio3S/jrdON2pW9Xr2nTwlo=",
       "netstandard.b50t77veor.dll": "sha256-//jQGOXjb8ET8WtXgOJrAxLx6E7zDJ5RjRRutwkvmxo=",
-      "MindExecution.Core.2ch68iyy8o.dll": "sha256-vjKyf+PwuPX3xAYHGRgYNF2KQYxm8xW7bcY6rgDAn0o=",
-      "MindExecution.Kernel.dh617xfv36.dll": "sha256-7+11/qc2LDTbKax01MVqbO4Zx6VB7us6Ign0pLL05Ts=",
-      "MindExecution.Plugins.Business.3wq01orrbu.dll": "sha256-3QYsNFB0xvz0qfSQXlLB4Z2Xs/navunyjLYzTVmNvyw=",
-      "MindExecution.Plugins.Concept.z8yl28fa2a.dll": "sha256-o3JiuwvgNbMdnzEH4wE4xLbqckgYySvDC9P4VBu/fKM=",
-      "MindExecution.Plugins.PlanMaster.yuyrbpf0vh.dll": "sha256-OsiswutNqeV0FT6Prvyrk0ylIbTneCeGRXHbG730E/8=",
-      "MindExecution.Shared.r9k48iyijb.dll": "sha256-YZCQNctXtyPwDlxwi6SoFDAdgyBMei5ykzzqz83NrJU=",
-      "MindExecution.Web.742aribkxm.dll": "sha256-N1w254EQYnkYsUY50OpUugN8M82bonsiT4d74S+srDE="
+      "MindExecution.Core.oqju650dkd.dll": "sha256-kAa63CfXtc76u8TyQM/hYA0BET+atu75fts3/mg4pTE=",
+      "MindExecution.Kernel.7zjugdfmfg.dll": "sha256-XWt7j9wlHb+PuYdstPVmPDLv15PcRahv3rNYrGzvI40=",
+      "MindExecution.Plugins.Business.rd6flxuebm.dll": "sha256-8XhddfNWrxDyHfFYmcDQutHhXIfGqfRKW3NVPyQ9Dbw=",
+      "MindExecution.Plugins.Concept.0qrgx3epss.dll": "sha256-WL1s5FZGLq9dOF3GDGasvY4ZU8559uF2t4a52KorOZw=",
+      "MindExecution.Plugins.PlanMaster.cobfta1p3l.dll": "sha256-JCKZ9S1jGO/aZ+Xfit+r+nFxc1JqkBQIxLugL3c0r+Y=",
+      "MindExecution.Shared.sevaa4rgkp.dll": "sha256-fLiquQIwsr+IVLW6w9+MdHQTNZzETBx1MJe0e8IbXHs=",
+      "MindExecution.Web.coqh2ccnuk.dll": "sha256-TBO6TdRrS5Z/M45nFXsJKGz8Y7oQ0loKUSbFd3JbkJE="
     },
     "lazyAssembly": {
-      "MindExecution.Plugins.Admin.0sm50hbae9.dll": "sha256-kBZPshQAJw9eFT9ekAD5ZnvRqkuWzHMa3OnIGX11eZw=",
-      "MindExecution.Plugins.Directory.m7murp5oes.dll": "sha256-DuX8c4uJBEXcR8Fx2YR3zYPQ8JVzKIBdRHuCH4IEeV4=",
-      "MindExecution.Plugins.YouTube.rwxvn00rm2.dll": "sha256-a/TixIdXMDc8zcRNSZ0Laq/Vz1J5InSRaymyzTdWp94="
+      "MindExecution.Plugins.Admin.qln7lkmsnn.dll": "sha256-PthhAmI45Ysbmebc6FVPKp5YmQeb8ed0Spq5HUcwass=",
+      "MindExecution.Plugins.Directory.4prauy9d1z.dll": "sha256-uCBQe2vhbS85Awx84xfEJLmbvETRIv8o8eZsfnahtDg=",
+      "MindExecution.Plugins.YouTube.99bahbgkkr.dll": "sha256-g+tRUYc/SojxQ4PfQ2sswlIzY+dZBH0mtgtVSJetdys="
     }
   },
   "cacheBootResources": true,

package/wwwroot/appsettings.json

@@ -1,83 +1,83 @@
 {
-    "OpenRouter":  {
-                       "ApiKey":  ""
-                   },
-    "Execution":  {
-                      "Mode":  "Concept",
-                      "Model":  "openai/gpt-4o-mini"
-                  },
-    "Supabase":  {
-                     "Url":  "https://otbyfkjxrkngvjziawki.supabase.co",
-                     "Key":  "sb_publishable_NpUs0RDJH2YnllsqTKO6TQ_1jTdSsNQ"
-                 },
-    "Bridge":  {
-                   "Url":  "app-origin",
-                   "FallbackPort":  5148,
-                   "AllowHostedLocalFallback":  false
-               },
-    "ProjectStorage":  {
-                           "Mode":  "LocalOnly",
-                           "CloudProjectsEnabled":  false
-                       },
-    "CloudflareR2":  {
-                         "ProxyUrl":  "https://r2-auth-proxy.lovecrdm.workers.dev",
-                         "PublicBaseUrl":  "https://r2-auth-proxy.lovecrdm.workers.dev/public",
-                         "PrivateSignUrl":  "https://r2-auth-proxy.lovecrdm.workers.dev/sign",
-                         "PrivateBatchSignUrl":  "https://r2-auth-proxy.lovecrdm.workers.dev/sign-batch",
-                         "PrivateUrlTtlSeconds":  900
-                     },
-    "CloudflareWebCapture":  {
-                                 "EndpointUrl":  "https://web-capture-worker.lovecrdm.workers.dev/capture",
-                                 "RequestTimeoutMs":  45000
-                             },
-    "Payments":  {
-                     "Provider":  "dodo"
-                 },
-    "DodoPayments":  {
-                         "DefaultProductId":  "",
-                         "StandardPriceId":  "dodo_pro_monthly_v1",
-                         "EarlyPriceId":  "dodo_pro_monthly_v1",
-                         "LtdPriceId":  "dodo_ltd_launch_v1",
-                         "ReturnUrl":  "https://mindexec.pages.dev/pricing",
-                         "Environment":  "test_mode"
-                     },
-    "Paddle":  {
-                   "ClientToken":  "",
-                   "ProMonthlyPriceId":  ""
-               },
-    "ProductProfile":  {
-                           "VariantKey":  "platform",
-                           "Slug":  "mindexec",
-                           "BrandName":  "MindExec",
-                           "ProductName":  "MindCanvas",
-                           "AppTitle":  "MindExec",
-                           "WorkspaceNounSingular":  "canvas",
-                           "WorkspaceNounPlural":  "canvases",
-                           "SignInTitle":  "Welcome Back",
-                           "SignUpTitle":  "Create Account",
-                           "SignInSubtitle":  "Sign in to access your MindCanvas workspace.",
-                           "SignUpSubtitle":  "Sign up to start organizing your ideas on a visual canvas.",
-                           "PrimaryCheckoutProvider":  "dodo",
-                           "CanonicalHost":  "localhost",
-                           "DodoCatalog":  {
-                                               "StandardPriceId":  "dodo_pro_monthly_v1",
-                                               "EarlyPriceId":  "dodo_pro_monthly_v1",
-                                               "LtdPriceId":  "dodo_ltd_launch_v1"
-                                           },
-                           "MarketingTool":  {
-                                                 "Enabled":  false,
-                                                 "HideAppChrome":  true,
-                                                 "AllowMindCanvasRoute":  false,
-                                                 "HomeRoute":  "/",
-                                                 "ToolKey":  "",
-                                                 "HeroEyebrow":  "Free local tool",
-                                                 "HeroTitle":  "",
-                                                 "HeroSubtitle":  "",
-                                                 "PrimaryCtaText":  "Open MindCanvas",
-                                                 "PrimaryCtaHref":  "/mindcanvas",
-                                                 "SecondaryCtaText":  "",
-                                                 "SecondaryCtaHref":  "",
-                                                 "PrivacyNote":  "Runs locally in your browser. No login. No database storage."
-                                             }
-                       }
+  "OpenRouter": {
+    "ApiKey": ""
+  },
+  "Execution": {
+    "Mode": "Concept",
+    "Model": "openai/gpt-4o-mini"
+  },
+  "Supabase": {
+    "Url": "https://otbyfkjxrkngvjziawki.supabase.co",
+    "Key": "sb_publishable_NpUs0RDJH2YnllsqTKO6TQ_1jTdSsNQ"
+  },
+  "Bridge": {
+    "Url": "app-origin",
+    "FallbackPort": 5148,
+    "AllowHostedLocalFallback": false
+  },
+  "ProjectStorage": {
+    "Mode": "LocalOnly",
+    "CloudProjectsEnabled": false
+  },
+  "CloudflareR2": {
+    "ProxyUrl": "https://r2-auth-proxy.lovecrdm.workers.dev",
+    "PublicBaseUrl": "https://r2-auth-proxy.lovecrdm.workers.dev/public",
+    "PrivateSignUrl": "https://r2-auth-proxy.lovecrdm.workers.dev/sign",
+    "PrivateBatchSignUrl": "https://r2-auth-proxy.lovecrdm.workers.dev/sign-batch",
+    "PrivateUrlTtlSeconds": 900
+  },
+  "CloudflareWebCapture": {
+    "EndpointUrl": "https://web-capture-worker.lovecrdm.workers.dev/capture",
+    "RequestTimeoutMs": 45000
+  },
+  "Payments": {
+    "Provider": "dodo"
+  },
+  "DodoPayments": {
+    "DefaultProductId": "",
+    "StandardPriceId": "dodo_pro_monthly_v1",
+    "EarlyPriceId": "dodo_pro_monthly_v1",
+    "LtdPriceId": "dodo_ltd_launch_v1",
+    "ReturnUrl": "https://mindexec.pages.dev/pricing",
+    "Environment": "test_mode"
+  },
+  "Paddle": {
+    "ClientToken": "",
+    "ProMonthlyPriceId": ""
+  },
+  "ProductProfile": {
+    "VariantKey": "platform",
+    "Slug": "mindexec",
+    "BrandName": "MindExec",
+    "ProductName": "MindCanvas",
+    "AppTitle": "MindExec",
+    "WorkspaceNounSingular": "canvas",
+    "WorkspaceNounPlural": "canvases",
+    "SignInTitle": "Welcome Back",
+    "SignUpTitle": "Create Account",
+    "SignInSubtitle": "Sign in to access your MindCanvas workspace.",
+    "SignUpSubtitle": "Sign up to start organizing your ideas on a visual canvas.",
+    "PrimaryCheckoutProvider": "dodo",
+    "CanonicalHost": "localhost",
+    "DodoCatalog": {
+      "StandardPriceId": "dodo_pro_monthly_v1",
+      "EarlyPriceId": "dodo_pro_monthly_v1",
+      "LtdPriceId": "dodo_ltd_launch_v1"
+    },
+    "MarketingTool": {
+      "Enabled": false,
+      "HideAppChrome": true,
+      "AllowMindCanvasRoute": false,
+      "HomeRoute": "/",
+      "ToolKey": "",
+      "HeroEyebrow": "Free local tool",
+      "HeroTitle": "",
+      "HeroSubtitle": "",
+      "PrimaryCtaText": "Open MindCanvas",
+      "PrimaryCtaHref": "/mindcanvas",
+      "SecondaryCtaText": "",
+      "SecondaryCtaHref": "",
+      "PrivacyNote": "Runs locally in your browser. No login. No database storage."
+    }
+  }
 }