feat: Implement Lazy Loading and Deep Array Merging

Introduces 'deepArrays' merge strategy in Neo.mjs and Config.mjs to support array concatenation during config merging. Updates Neo.core.Base to use this strategy for 'remote_', ensuring inherited remote methods (like 'loadFiles') are preserved in subclasses. Implements lazy loading in Neo.main.addon.Base via 'useLazyLoading' config, preventing main thread blocking. Updates Mermaid addon and wrapper to utilize these new capabilities.

Closes #8379

Author: tobiu

src/Neo.mjs

@@ -537,6 +537,34 @@ If you intended to create custom logic, use the 'beforeGet${Neo.capitalize(key)}
         return target
     },
 
+    /**
+     * @param {Object} a
+     * @param {Object} b
+     * @returns {Object}
+     */
+    mergeDeepArrays(a, b) {
+        if (!a) return b;
+        if (!b) return a;
+
+        let out = Neo.clone(a, true);
+
+        Object.entries(b).forEach(([key, value]) => {
+            if (out[key]) {
+                if (Array.isArray(out[key]) && Array.isArray(value)) {
+                    out[key] = [...new Set([...out[key], ...value])]
+                } else if (Neo.isObject(out[key]) && Neo.isObject(value)) {
+                    out[key] = Neo.mergeDeepArrays(out[key], value)
+                } else {
+                    out[key] = value
+                }
+            } else {
+                out[key] = value
+            }
+        });
+
+        return out
+    },
+
     /**
      * Merges a new value into an existing config value based on a specified strategy.
      * This method is used during instance creation to apply merge strategies defined in config descriptors.
@@ -558,6 +586,10 @@ If you intended to create custom logic, use the 'beforeGet${Neo.capitalize(key)}
             if (defaultValueType === 'Object' && instanceValueType === 'Object') {
                 return Neo.merge(Neo.clone(defaultValue, true), instanceValue)
             }
+        } else if (strategy === 'deepArrays') {
+            if (defaultValueType === 'Object' && instanceValueType === 'Object') {
+                return Neo.mergeDeepArrays(defaultValue, instanceValue)
+            }
         } else if (typeof strategy === 'function') {
             return strategy(defaultValue, instanceValue)
         }

src/component/Markdown.mjs

@@ -127,7 +127,6 @@ class Markdown extends Component {
     }
 
     /**
-     * @param {String} inputString
      * @returns {String}
      */
     insertLabDivs(inputString) {

src/component/wrapper/Mermaid.mjs

@@ -85,6 +85,13 @@ class Mermaid extends Component {
         this.addon = await Neo.currentWorker.getAddon('Mermaid', this.windowId)
     }
 
+    /**
+     * @returns {Promise<void>}
+     */
+    async loadFiles() {
+        return this.addon.loadFiles()
+    }
+
     /**
      * Renders the Mermaid diagram.
      * This method waits for the component to be fully initialized (ready) and then invokes

src/core/Base.mjs

@@ -158,11 +158,15 @@ class Base {
          *
          * ONLY supported for singletons.
          *
-         * @member {Object|null} remote_=null
+         * @member {Object|null} remote_={[isDescriptor]: true, merge: 'deepArrays', value: null}
          * @protected
          * @reactive
          */
-        remote_: null
+        remote_: {
+            [isDescriptor]: true,
+            merge         : 'deepArrays',
+            value         : null
+        }
     }
 
     /**

src/core/Config.mjs

@@ -58,6 +58,7 @@ class Config {
     /**
      * The strategy to use when merging new values into this config.
      * Defaults to 'replace'. Can be overridden via a descriptor merge property.
+     * Supported values: 'deep', 'deepArrays', 'replace', 'shallow'.
      * @member {Function|String} mergeStrategy='replace'
      */
 

src/main/addon/Base.mjs

@@ -30,7 +30,21 @@ class Base extends CoreBase {
          * @member {Boolean|Number} preloadFilesDelay=5000
          * @protected
          */
-        preloadFilesDelay: 5000
+        preloadFilesDelay: 5000,
+        /**
+         * Remote method access for other workers
+         * @member {Object} remote
+         * @protected
+         */
+        remote: {
+            app: [
+                'loadFiles'
+            ]
+        },
+        /**
+         * @member {Boolean} useLazyLoading=false
+         */
+        useLazyLoading: false
     }
 
     /**
@@ -72,7 +86,11 @@ class Base extends CoreBase {
             me.#loadFilesPromiseResolver = resolve
         });
 
-        if (me.preloadFilesDelay === false) {
+        if (me.useLazyLoading) {
+            // Do nothing. The promise remains pending, blocking initAsync (keeping isReady: false).
+            // Main thread is not blocked because it only waits for remotesReady().
+            // The first remote call will trigger interception -> cacheMethodCall -> executeLoadFiles.
+        } else if (me.preloadFilesDelay === false) {
             // No automated preload: resolve #loadFilesPromise immediately as it won't be triggered by delay.
             // It will only be triggered by cacheMethodCall or initAsync if needed.
             me.#loadFilesPromiseResolver();

src/main/addon/Mermaid.mjs

@@ -42,7 +42,11 @@ class Mermaid extends Base {
             app: [
                 'render'
             ]
-        }
+        },
+        /**
+         * @member {Boolean} useLazyLoading=true
+         */
+        useLazyLoading: true
     }
 
     /**