@node-red/editor-client 3.1.8 → 4.0.0-beta.2

package/public/red/red.js

@@ -116,6 +116,7 @@ var RED = (function() {
             cache: false,
             url: 'plugins',
             success: function(data) {
+                RED.plugins.setPluginList(data);
                 loader.reportProgress(RED._("event.loadPlugins"), 13)
                 RED.i18n.loadPluginCatalogs(function() {
                     loadPlugins(function() {
@@ -625,6 +626,41 @@ var RED = (function() {
                 RED.view.redrawStatus(node);
             }
         });
+        RED.comms.subscribe("notification/plugin/#",function(topic,msg) {
+            if (topic == "notification/plugin/added") {
+                RED.settings.refreshSettings(function(err, data) {
+                    let addedPlugins = [];
+                    msg.forEach(function(m) {
+                        let id = m.id;
+                        RED.plugins.addPlugin(m);
+
+                        m.plugins.forEach((p) => {
+                            addedPlugins.push(p.id);
+                        })
+
+                        RED.i18n.loadNodeCatalog(id, function() {
+                            var lang = localStorage.getItem("editor-language")||RED.i18n.detectLanguage();
+                            $.ajax({
+                                headers: {
+                                    "Accept":"text/html",
+                                    "Accept-Language": lang
+                                },
+                                cache: false,
+                                url: 'plugins/'+id,
+                                success: function(data) {
+                                    appendPluginConfig(data);
+                                }
+                            });
+                        });
+                    });
+                    if (addedPlugins.length) {
+                        let pluginList = "<ul><li>"+addedPlugins.map(RED.utils.sanitize).join("</li><li>")+"</li></ul>";
+                        // ToDo: Adapt notification (node -> plugin)
+                        RED.notify(RED._("palette.event.nodeAdded", {count:addedPlugins.length})+pluginList,"success");
+                    }
+                })
+            }
+        });
 
         let pendingNodeRemovedNotifications = []
         let pendingNodeRemovedTimeout
@@ -894,6 +930,10 @@ var RED = (function() {
 
         RED.nodes.init();
         RED.runtime.init()
+
+        if (RED.settings.theme("multiplayer.enabled",false)) {
+            RED.multiplayer.init()
+        }
         RED.comms.connect();
 
         $("#red-ui-main-container").show();
@@ -1812,6 +1852,7 @@ RED.user = (function() {
     }
 
     function logout() {
+        RED.events.emit('logout')
         var tokens = RED.settings.get("auth-tokens");
         var token = tokens?tokens.access_token:"";
         $.ajax({
@@ -1850,6 +1891,7 @@ RED.user = (function() {
                     });
                 }
             });
+            $('<i class="fa fa-user"></i>').appendTo("#red-ui-header-button-user");
         } else {
             RED.menu.addItem("red-ui-header-button-user",{
                 id:"usermenu-item-username",
@@ -1862,6 +1904,15 @@ RED.user = (function() {
                     RED.user.logout();
                 }
             });
+            const userMenu = $("#red-ui-header-button-user")
+            userMenu.empty()
+            if (RED.settings.user.image) {
+                $('<span class="user-profile"></span>').css({
+                    backgroundImage: "url("+RED.settings.user.image+")",
+                }).appendTo(userMenu);
+            } else {
+                $('<i class="fa fa-user"></i>').appendTo(userMenu);
+            }
         }
 
     }
@@ -1872,14 +1923,6 @@ RED.user = (function() {
 
                 var userMenu = $('<li><a id="red-ui-header-button-user" class="button hide" href="#"></a></li>')
                     .prependTo(".red-ui-header-toolbar");
-                if (RED.settings.user.image) {
-                    $('<span class="user-profile"></span>').css({
-                        backgroundImage: "url("+RED.settings.user.image+")",
-                    }).appendTo(userMenu.find("a"));
-                } else {
-                    $('<i class="fa fa-user"></i>').appendTo(userMenu.find("a"));
-                }
-
                 RED.menu.init({id:"red-ui-header-button-user",
                     options: []
                 });
@@ -1979,6 +2022,15 @@ RED.comms = (function() {
     var reconnectAttempts = 0;
     var active = false;
 
+    RED.events.on('login', function(username) {
+        // User has logged in
+        // Need to upgrade the connection to be authenticated
+        if (ws && ws.readyState == 1) {
+            const auth_tokens = RED.settings.get("auth-tokens");
+            ws.send(JSON.stringify({auth:auth_tokens.access_token}))
+        }
+    })
+
     function connectWS() {
         active = true;
         var wspath;
@@ -2009,6 +2061,7 @@ RED.comms = (function() {
                     ws.send(JSON.stringify({subscribe:t}));
                 }
             }
+            emit('connect')
         }
 
         ws = new WebSocket(wspath);
@@ -2133,10 +2186,54 @@ RED.comms = (function() {
         }
     }
 
+    function send(topic, msg) {
+        if (ws && ws.readyState == 1) {
+            ws.send(JSON.stringify({
+                topic,
+                data: msg
+            }))
+        }
+    }
+
+    const eventHandlers = {};
+    function on(evt,func) {
+        eventHandlers[evt] = eventHandlers[evt]||[];
+        eventHandlers[evt].push(func);
+    }
+    function off(evt,func) {
+        const handler = eventHandlers[evt];
+        if (handler) {
+            for (let i=0;i<handler.length;i++) {
+                if (handler[i] === func) {
+                    handler.splice(i,1);
+                    return;
+                }
+            }
+        }
+    }
+    function emit() {
+        const evt = arguments[0]
+        const args = Array.prototype.slice.call(arguments,1);
+        if (eventHandlers[evt]) {
+            let cpyHandlers = [...eventHandlers[evt]];
+            for (let i=0;i<cpyHandlers.length;i++) {
+                try {
+                    cpyHandlers[i].apply(null, args);
+                } catch(err) {
+                    console.warn("RED.comms.emit error: ["+evt+"] "+(err.toString()));
+                    console.warn(err);
+                }
+            }
+        }
+    }
+
     return {
         connect: connectWS,
         subscribe: subscribe,
-        unsubscribe:unsubscribe
+        unsubscribe:unsubscribe,
+        on,
+        off,
+        send
     }
 })();
 ;RED.runtime = (function() {
@@ -2175,6 +2272,223 @@ RED.comms = (function() {
         }
     }
 })()
+;RED.multiplayer = (function () {
+
+    // sessionId - used to identify sessions across websocket reconnects
+    let sessionId
+
+    let headerWidget
+    // Map of session id to { session:'', user:{}, location:{}}
+    let connections = {}
+    // Map of username to { user:{}, connections:[] }
+    let users = {}
+
+    function addUserConnection (connection) {
+        if (connections[connection.session]) {
+            // This is an existing connection that has been authenticated
+            const existingConnection = connections[connection.session]
+            if (existingConnection.user.username !== connection.user.username) {
+                removeUserButton(users[existingConnection.user.username])
+            }
+        }
+        connections[connection.session] = connection
+        const user = users[connection.user.username] = users[connection.user.username] || {
+            user: connection.user,
+            connections: []
+        }
+        connection.location = connection.location || {}
+        user.connections.push(connection)
+
+        if (connection.user.username === RED.settings.user?.username ||
+            connection.session === sessionId
+        ) {
+            // This is the current user - do not add a extra button for them
+        } else {
+            if (user.connections.length === 1) {
+                if (user.button) {
+                    clearTimeout(user.inactiveTimeout)
+                    clearTimeout(user.removeTimeout)
+                    user.button.removeClass('inactive')
+                } else {
+                    addUserButton(user)
+                }
+            }
+        }
+    }
+
+    function removeUserConnection (session, isDisconnected) {
+        const connection = connections[session]
+        delete connections[session]
+        const user = users[connection.user.username]
+        const i = user.connections.indexOf(connection)
+        user.connections.splice(i, 1)
+        if (isDisconnected) {
+            removeUserButton(user)
+        } else {
+            if (user.connections.length === 0) {
+                // Give the user 5s to reconnect before marking inactive
+                user.inactiveTimeout = setTimeout(() => {
+                    user.button.addClass('inactive')
+                    // Give the user further 20 seconds to reconnect before removing them
+                    // from the user toolbar entirely
+                    user.removeTimeout = setTimeout(() => {
+                        removeUserButton(user)
+                    }, 20000)
+                }, 5000)
+            }
+        }
+    }
+
+    function addUserButton (user) {
+        user.button = $('<li class="red-ui-multiplayer-user"><button type="button" class="red-ui-multiplayer-user-icon" href="#"></button></li>')
+            .attr('data-username', user.user.username)
+            .prependTo("#red-ui-multiplayer-user-list");
+        var button = user.button.find("button")
+        button.on('click', function () {
+            RED.popover.create({
+                target:button,
+                trigger: 'modal',
+                interactive: true,
+                width: "250px",
+                direction: 'bottom',
+                content: () => { 
+                    const content = $('<div>')
+                    $('<div style="text-align: center">').text(user.user.username).appendTo(content)
+
+                    const location = user.connections[0].location
+                    if (location.workspace) {
+                        const ws = RED.nodes.workspace(location.workspace) || RED.nodes.subflow(location.workspace)
+                        if (ws) {
+                            $('<div>').text(`${ws.type}: ${ws.label||ws.name||ws.id}`).appendTo(content)
+                        } else {
+                            $('<div>').text(`tab: unknown`).appendTo(content)
+                        }
+                    }
+                    if (location.node) {
+                        const node = RED.nodes.node(location.node)
+                        if (node) {
+                            $('<div>').text(`node: ${node.id}`).appendTo(content)
+                        } else {
+                            $('<div>').text(`node: unknown`).appendTo(content)
+                        }
+                    }
+                    return content
+                },
+            }).open()
+        })
+        if (!user.user.image) {
+            $('<i class="fa fa-user"></i>').appendTo(button);
+        } else {
+            $('<span class="user-profile"></span>').css({
+                backgroundImage: "url("+user.user.image+")",
+            }).appendTo(button);
+        }
+    }
+
+    function getLocation () {
+        const location = {
+            workspace: RED.workspaces.active()
+        }
+        const editStack = RED.editor.getEditStack()
+        for (let i = editStack.length - 1; i >= 0; i--) {
+            if (editStack[i].id) {
+                location.node = editStack[i].id
+                break
+            }
+        }
+        return location
+    }
+    function updateLocation () {
+        const location = getLocation()
+        if (location.workspace !== 0) {
+            log('send', 'multiplayer/location', location)
+            RED.comms.send('multiplayer/location', location)
+        }
+    }
+
+    function removeUserButton (user) {
+        user.button.remove()
+        delete user.button
+    }
+
+    function updateUserLocation (data) {
+        connections[data.session].location = data
+        delete data.session
+    }
+    return {
+        init: function () {
+            
+
+            sessionId = RED.settings.getLocal('multiplayer:sessionId')
+            if (!sessionId) {
+                sessionId = RED.nodes.id()
+                RED.settings.setLocal('multiplayer:sessionId', sessionId)
+            }
+            
+            headerWidget = $('<li><ul id="red-ui-multiplayer-user-list"></ul></li>').prependTo('.red-ui-header-toolbar')
+
+            RED.comms.on('connect', () => {
+                const location = getLocation()
+                const connectInfo = {
+                    session: sessionId
+                }
+                if (location.workspace !== 0) {
+                    connectInfo.location = location
+                }
+                RED.comms.send('multiplayer/connect', connectInfo)
+            })
+            RED.comms.subscribe('multiplayer/#', (topic, msg) => {
+                log('recv', topic, msg)
+                if (topic === 'multiplayer/init') {
+                    // We have just reconnected, runtime has sent state to
+                    // initialise the world
+                    connections = {}
+                    users = {}
+                    $('#red-ui-multiplayer-user-list').empty()
+
+                    msg.forEach(connection => {
+                        addUserConnection(connection)
+                    })
+                } else if (topic === 'multiplayer/connection-added') {
+                    addUserConnection(msg)
+                } else if (topic === 'multiplayer/connection-removed') {
+                    removeUserConnection(msg.session, msg.disconnected)
+                } else if (topic === 'multiplayer/location') {
+                    updateUserLocation(msg)
+                }
+            })
+
+            RED.events.on('workspace:change', (event) => {
+                updateLocation()
+            })
+            RED.events.on('editor:open', () => {
+                updateLocation()
+            })
+            RED.events.on('editor:close', () => {
+                updateLocation()
+            })
+            RED.events.on('editor:change', () => {
+                updateLocation()
+            })
+            RED.events.on('login', () => {
+                updateLocation()
+            })
+            RED.events.on('logout', () => {
+                const disconnectInfo = {
+                    session: sessionId
+                }
+                RED.comms.send('multiplayer/disconnect', disconnectInfo)
+                RED.settings.removeLocal('multiplayer:sessionId')
+            })
+        }
+    }
+
+    function log() {
+        if (RED.multiplayer.DEBUG) {
+            console.log('[multiplayer]', ...arguments)
+        }
+    }
+})();
 ;/**
  * Copyright JS Foundation and other contributors, http://js.foundation
  *
@@ -3672,6 +3986,7 @@ RED.state = {
 ;RED.plugins = (function() {
     var plugins = {};
     var pluginsByType = {};
+    var moduleList = {};
 
     function registerPlugin(id,definition) {
         plugins[id] = definition;
@@ -3709,10 +4024,44 @@ RED.state = {
     function getPluginsByType(type) {
         return pluginsByType[type] || [];
     }
+
+    function setPluginList(list) {
+        for(let i=0;i<list.length;i++) {
+            let p = list[i];
+            addPlugin(p);
+        }
+    }
+
+    function addPlugin(p) {
+
+        moduleList[p.module] = moduleList[p.module] || {
+            name:p.module,
+            version:p.version,
+            local:p.local,
+            sets:{},
+            plugin: true,
+            id: p.id
+        };
+        if (p.pending_version) {
+            moduleList[p.module].pending_version = p.pending_version;
+        }
+        moduleList[p.module].sets[p.name] = p;
+
+        RED.events.emit("registry:plugin-module-added",p.module);
+    }
+
+    function getModule(module) {
+        return moduleList[module];
+    }
+
     return {
         registerPlugin: registerPlugin,
         getPlugin: getPlugin,
-        getPluginsByType: getPluginsByType
+        getPluginsByType: getPluginsByType,
+
+        setPluginList: setPluginList,
+        addPlugin: addPlugin,
+        getModule: getModule
     }
 })();
 ;/**
@@ -3808,6 +4157,31 @@ RED.nodes = (function() {
             getNodeTypes: function() {
                 return Object.keys(nodeDefinitions);
             },
+            /**
+             * Get an array of node definitions
+             * @param {Object} options - options object
+             * @param {boolean} [options.configOnly] - if true, only return config nodes
+             * @param {function} [options.filter] - a filter function to apply to the list of nodes
+             * @returns array of node definitions
+             */
+            getNodeDefinitions: function(options) {
+                const result = []
+                const configOnly = (options && options.configOnly)
+                const filter = (options && options.filter)
+                const keys = Object.keys(nodeDefinitions)
+                for (const key of keys) {
+                    const def = nodeDefinitions[key]
+                    if(!def) { continue }
+                    if (configOnly && def.category !== "config") {
+                            continue
+                    }
+                    if (filter && !filter(nodeDefinitions[key])) {
+                        continue
+                    }
+                    result.push(nodeDefinitions[key])
+                }
+                return result
+            },
             setNodeList: function(list) {
                 nodeList = [];
                 for(var i=0;i<list.length;i++) {
@@ -3841,6 +4215,8 @@ RED.nodes = (function() {
             },
             removeNodeSet: function(id) {
                 var ns = nodeSets[id];
+                if (!ns) { return {} }
+
                 for (var j=0;j<ns.types.length;j++) {
                     delete typeToId[ns.types[j]];
                 }
@@ -9015,6 +9391,16 @@ RED.utils = (function() {
                 $('<span class="red-ui-debug-msg-type-string-swatch"></span>').css('backgroundColor',obj).appendTo(e);
             }
 
+            let n = RED.nodes.node(obj) ?? RED.nodes.workspace(obj);
+            if (n) {
+                if (options.nodeSelector && "function" == typeof options.nodeSelector) {
+                    e.css('cursor', 'pointer').on("click", function(evt) {
+                        evt.preventDefault();
+                        options.nodeSelector(n.id);
+                    })
+                }
+            }
+
         } else if (typeof obj === 'number') {
             e = $('<span class="red-ui-debug-msg-type-number"></span>').appendTo(entryObj);
 
@@ -9121,6 +9507,7 @@ RED.utils = (function() {
                                     exposeApi: exposeApi,
                                     // tools: tools // Do not pass tools down as we
                                                     // keep them attached to the top-level header
+                                    nodeSelector: options.nodeSelector,
                                 }
                             ).appendTo(row);
                         }
@@ -9151,6 +9538,7 @@ RED.utils = (function() {
                                                 exposeApi: exposeApi,
                                                 // tools: tools // Do not pass tools down as we
                                                                 // keep them attached to the top-level header
+                                                nodeSelector: options.nodeSelector,
                                             }
                                         ).appendTo(row);
                                     }
@@ -9207,6 +9595,7 @@ RED.utils = (function() {
                                 exposeApi: exposeApi,
                                 // tools: tools // Do not pass tools down as we
                                                 // keep them attached to the top-level header
+                                nodeSelector: options.nodeSelector,
                             }
                         ).appendTo(row);
                     }
@@ -10191,12 +10580,24 @@ RED.utils = (function() {
                 this.uiContainer.width(m[1]);
             }
             if (this.options.sortable) {
+                var isCanceled = false; // Flag to track if an item has been canceled from being dropped into a different list
+                var noDrop = false; // Flag to track if an item is being dragged into a different list
                 var handle = (typeof this.options.sortable === 'string')?
                                 this.options.sortable :
                                 ".red-ui-editableList-item-handle";
                 var sortOptions = {
                     axis: "y",
                     update: function( event, ui ) {
+                        // dont trigger update if the item is being canceled
+                        const targetList = $(event.target);
+                        const draggedItem = ui.item;
+                        const draggedItemParent = draggedItem.parent();
+                        if (!targetList.is(draggedItemParent) && draggedItem.hasClass("red-ui-editableList-item-constrained")) {
+                            noDrop = true;
+                        }
+                        if (isCanceled || noDrop) {
+                            return;
+                        }
                         if (that.options.sortItems) {
                             that.options.sortItems(that.items());
                         }
@@ -10206,8 +10607,32 @@ RED.utils = (function() {
                     tolerance: "pointer",
                     forcePlaceholderSize:true,
                     placeholder: "red-ui-editabelList-item-placeholder",
-                    start: function(e, ui){
-                        ui.placeholder.height(ui.item.height()-4);
+                    start: function (event, ui) {
+                        isCanceled = false;
+                        ui.placeholder.height(ui.item.height() - 4);
+                        ui.item.css('cursor', 'grabbing'); // TODO: this doesn't seem to work, use a class instead?
+                    },
+                    stop: function (event, ui) {
+                        ui.item.css('cursor', 'auto');
+                    },
+                    receive: function (event, ui) {
+                        if (ui.item.hasClass("red-ui-editableList-item-constrained")) {
+                            isCanceled = true;
+                            $(ui.sender).sortable('cancel');
+                        }
+                    },
+                    over: function (event, ui) {
+                        // if the dragged item is constrained, prevent it from being dropped into a different list
+                        const targetList = $(event.target);
+                        const draggedItem = ui.item;
+                        const draggedItemParent = draggedItem.parent();
+                        if (!targetList.is(draggedItemParent) && draggedItem.hasClass("red-ui-editableList-item-constrained")) {
+                            noDrop = true;
+                            draggedItem.css('cursor', 'no-drop'); // TODO: this doesn't seem to work, use a class instead?
+                        } else {
+                            noDrop = false;
+                            draggedItem.css('cursor', 'grabbing'); // TODO: this doesn't seem to work, use a class instead?
+                        }
                     }
                 };
                 if (this.options.connectWith) {
@@ -12254,7 +12679,7 @@ RED.popover = (function() {
                         closePopup(true);
                     });
                 }
-                if (trigger === 'hover' && options.interactive) {
+                if (/*trigger === 'hover' && */options.interactive) {
                     div.on('mouseenter', function(e) {
                         clearTimeout(timer);
                         active = true;
@@ -14171,25 +14596,26 @@ RED.stack = (function() {
         return icon;
     }
 
-    var autoComplete = function(options) {
-        function getMatch(value, searchValue) {
-            const idx = value.toLowerCase().indexOf(searchValue.toLowerCase());
-            const len = idx > -1 ? searchValue.length : 0;
-            return {
-                index: idx,
-                found: idx > -1,
-                pre: value.substring(0,idx),
-                match: value.substring(idx,idx+len),
-                post: value.substring(idx+len),
-            }
-        }
-        function generateSpans(match) {
-            const els = [];
-            if(match.pre) { els.push($('<span/>').text(match.pre)); }
-            if(match.match) { els.push($('<span/>',{style:"font-weight: bold; color: var(--red-ui-text-color-link);"}).text(match.match)); }
-            if(match.post) { els.push($('<span/>').text(match.post)); }
-            return els;
-        }
+    function getMatch(value, searchValue) {
+        const idx = value.toLowerCase().indexOf(searchValue.toLowerCase());
+        const len = idx > -1 ? searchValue.length : 0;
+        return {
+            index: idx,
+            found: idx > -1,
+            pre: value.substring(0,idx),
+            match: value.substring(idx,idx+len),
+            post: value.substring(idx+len),
+        }
+    }
+    function generateSpans(match) {
+        const els = [];
+        if(match.pre) { els.push($('<span/>').text(match.pre)); }
+        if(match.match) { els.push($('<span/>',{style:"font-weight: bold; color: var(--red-ui-text-color-link);"}).text(match.match)); }
+        if(match.post) { els.push($('<span/>').text(match.post)); }
+        return els;
+    }
+    
+    const msgAutoComplete = function(options) {
         return function(val) {
             var matches = [];
             options.forEach(opt => {
@@ -14219,6 +14645,197 @@ RED.stack = (function() {
         }
     }
 
+    function getEnvVars (obj, envVars = {}) {
+        contextKnownKeys.env = contextKnownKeys.env || {}
+        if (contextKnownKeys.env[obj.id]) {
+            return contextKnownKeys.env[obj.id]
+        }
+        let parent
+        if (obj.type === 'tab' || obj.type === 'subflow') {
+            RED.nodes.eachConfig(function (conf) {
+                if (conf.type === "global-config") {
+                    parent = conf;
+                }
+            })
+        } else if (obj.g) {
+            parent = RED.nodes.group(obj.g)
+        } else if (obj.z) {
+            parent = RED.nodes.workspace(obj.z) || RED.nodes.subflow(obj.z)
+        }
+        if (parent) {
+            getEnvVars(parent, envVars)
+        }
+        if (obj.env) {
+            obj.env.forEach(env => {
+                envVars[env.name] = obj
+            })
+        }
+        contextKnownKeys.env[obj.id] = envVars
+        return envVars
+    }
+
+    const envAutoComplete = function (val) {
+        const editStack = RED.editor.getEditStack()
+        if (editStack.length === 0) {
+            done([])
+            return
+        }
+        const editingNode = editStack.pop()
+        if (!editingNode) {
+            return []
+        }
+        const envVarsMap = getEnvVars(editingNode)
+        const envVars = Object.keys(envVarsMap)
+        const matches = []
+        const i = val.lastIndexOf('${')
+        let searchKey = val
+        let isSubkey = false
+        if (i > -1) {
+            if (val.lastIndexOf('}') < i) {
+                searchKey = val.substring(i+2)
+                isSubkey = true
+            }
+        }
+        envVars.forEach(v => {
+            let valMatch = getMatch(v, searchKey);
+            if (valMatch.found) {
+                const optSrc = envVarsMap[v]
+                const element = $('<div>',{style: "display: flex"});
+                const valEl = $('<div/>',{style:"font-family: var(--red-ui-monospace-font); white-space:nowrap; overflow: hidden; flex-grow:1"});
+                valEl.append(generateSpans(valMatch))
+                valEl.appendTo(element)
+
+                if (optSrc) {
+                    const optEl = $('<div>').css({ "font-size": "0.8em" });
+                    let label
+                    if (optSrc.type === 'global-config') {
+                        label = RED._('sidebar.context.global')
+                    } else if (optSrc.type === 'group') {
+                        label = RED.utils.getNodeLabel(optSrc) || (RED._('sidebar.info.group') + ': '+optSrc.id)
+                    } else {
+                        label = RED.utils.getNodeLabel(optSrc) || optSrc.id
+                    }
+
+                    optEl.append(generateSpans({ match: label }));
+                    optEl.appendTo(element);
+                }
+                matches.push({
+                    value: isSubkey ? val + v + '}' : v,
+                    label: element,
+                    i: valMatch.index
+                });
+            }
+        })
+        matches.sort(function(A,B){return A.i-B.i})
+        return matches
+    }
+
+    let contextKnownKeys = {}
+    let contextCache = {}
+    if (RED.events) {
+        RED.events.on("editor:close", function () {
+            contextCache = {}
+            contextKnownKeys = {}
+        });
+    }
+
+    const contextAutoComplete = function() {
+        const that = this
+        const getContextKeysFromRuntime = function(scope, store, searchKey, done) {
+            contextKnownKeys[scope] = contextKnownKeys[scope] || {}
+            contextKnownKeys[scope][store] = contextKnownKeys[scope][store] || new Set()
+            if (searchKey.length > 0) {
+                try {
+                    RED.utils.normalisePropertyExpression(searchKey)
+                } catch (err) {
+                    // Not a valid context key, so don't try looking up
+                    done()
+                    return
+                }
+            }
+            const url = `context/${scope}/${encodeURIComponent(searchKey)}?store=${store}&keysOnly`
+            if (contextCache[url]) {
+                // console.log('CACHED', url)
+                done()
+            } else {
+                // console.log('GET', url)
+                $.getJSON(url, function(data) {
+                    // console.log(data)
+                    contextCache[url] = true
+                    const result = data[store] || {}
+                    const keys = result.keys || []
+                    const keyPrefix = searchKey + (searchKey.length > 0 ? '.' : '')
+                    keys.forEach(key => {
+                        if (/^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(key)) {
+                            contextKnownKeys[scope][store].add(keyPrefix + key)
+                        } else {
+                            contextKnownKeys[scope][store].add(searchKey + "[\""+key.replace(/"/,"\\\"")+"\"]")
+                        }                        
+                    })
+                    done()
+                })
+            }
+        }
+        const getContextKeys = function(key, done) {
+            const keyParts = key.split('.')
+            const partialKey = keyParts.pop()
+            let scope = that.propertyType
+            if (scope === 'flow') {
+                // Get the flow id of the node we're editing
+                const editStack = RED.editor.getEditStack()
+                if (editStack.length === 0) {
+                    done([])
+                    return
+                }
+                const editingNode = editStack.pop()
+                if (editingNode.z) {
+                    scope = `${scope}/${editingNode.z}`
+                } else {
+                    done([])
+                    return
+                }
+            }
+            const store = (contextStoreOptions.length === 1) ? contextStoreOptions[0].value : that.optionValue
+            const searchKey = keyParts.join('.')
+           
+            getContextKeysFromRuntime(scope, store, searchKey, function() {
+                if (contextKnownKeys[scope][store].has(key) || key.endsWith(']')) {
+                    getContextKeysFromRuntime(scope, store, key, function() {
+                        done(contextKnownKeys[scope][store])
+                    })
+                }
+                done(contextKnownKeys[scope][store])
+            })
+        }
+
+        return function(val, done) {
+            getContextKeys(val, function (keys) {
+                const matches = []
+                keys.forEach(v => {
+                    let optVal = v
+                    let valMatch = getMatch(optVal, val);
+                    if (!valMatch.found && val.length > 0 && val.endsWith('.')) {
+                        // Search key ends in '.' - but doesn't match. Check again
+                        // with [" at the end instead so we match bracket notation
+                        valMatch = getMatch(optVal, val.substring(0, val.length - 1) + '["')
+                    }
+                    if (valMatch.found) {
+                        const element = $('<div>',{style: "display: flex"});
+                        const valEl = $('<div/>',{style:"font-family: var(--red-ui-monospace-font); white-space:nowrap; overflow: hidden; flex-grow:1"});
+                        valEl.append(generateSpans(valMatch))
+                        valEl.appendTo(element)
+                        matches.push({
+                            value: optVal,
+                            label: element,
+                        });
+                    }
+                })
+                matches.sort(function(a, b) { return a.value.localeCompare(b.value) });
+                done(matches);
+            })
+        }
+    }
+
     // This is a hand-generated list of completions for the core nodes (based on the node help html).
     var msgCompletions = [
         { value: "payload" },
@@ -14283,20 +14900,22 @@ RED.stack = (function() {
         { value: "_session", source: ["websocket out","tcp out"] },
     ]
     var allOptions = {
-        msg: {value:"msg",label:"msg.",validate:RED.utils.validatePropertyExpression, autoComplete: autoComplete(msgCompletions)},
+        msg: {value:"msg",label:"msg.",validate:RED.utils.validatePropertyExpression, autoComplete: msgAutoComplete(msgCompletions)},
         flow: {value:"flow",label:"flow.",hasValue:true,
             options:[],
             validate:RED.utils.validatePropertyExpression,
             parse: contextParse,
             export: contextExport,
-            valueLabel: contextLabel
+            valueLabel: contextLabel,
+            autoComplete: contextAutoComplete
         },
         global: {value:"global",label:"global.",hasValue:true,
             options:[],
             validate:RED.utils.validatePropertyExpression,
             parse: contextParse,
             export: contextExport,
-            valueLabel: contextLabel
+            valueLabel: contextLabel,
+            autoComplete: contextAutoComplete
         },
         str: {value:"str",label:"string",icon:"red/images/typedInput/az.svg"},
         num: {value:"num",label:"number",icon:"red/images/typedInput/09.svg",validate: function(v) {
@@ -14331,7 +14950,25 @@ RED.stack = (function() {
             }
         },
         re: {value:"re",label:"regular expression",icon:"red/images/typedInput/re.svg"},
-        date: {value:"date",label:"timestamp",icon:"fa fa-clock-o",hasValue:false},
+        date: {
+            value:"date",
+            label:"timestamp",
+            icon:"fa fa-clock-o",
+            options:[
+                {
+                    label: 'milliseconds since epoch',
+                    value: ''
+                },
+                {
+                    label: 'YYYY-MM-DDTHH:mm:ss.sssZ',
+                    value: 'iso'
+                },
+                {
+                    label: 'JavaScript Date Object',
+                    value: 'object'
+                }
+            ]
+        },
         jsonata: {
             value: "jsonata",
             label: "expression",
@@ -14368,7 +15005,8 @@ RED.stack = (function() {
         env: {
             value: "env",
             label: "env variable",
-            icon: "red/images/typedInput/env.svg"
+            icon: "red/images/typedInput/env.svg",
+            autoComplete: envAutoComplete
         },
         node: {
             value: "node",
@@ -14500,18 +15138,75 @@ RED.stack = (function() {
                     eyeButton.show();
                 }
             }
+        },
+        'conf-types': {
+            value: "conf-types",
+            label: "config",
+            icon: "fa fa-cog",
+            // hasValue: false,
+            valueLabel: function (container, value) {
+                // get the selected option (for access to the "name" and "module" properties)
+                const _options = this._optionsCache || this.typeList.find(opt => opt.value === value)?.options || []
+                const selectedOption = _options.find(opt => opt.value === value) || {
+                    title: '',
+                    name: '',
+                    module: ''
+                }
+                container.attr("title", selectedOption.title) // set tooltip to the full path/id of the module/node
+                container.text(selectedOption.name) // apply the "name" of the selected option
+                // set "line-height" such as to make the "name" appear further up, giving room for the "module" to be displayed below the value
+                container.css("line-height", "1.4em")
+                // add the module name in smaller, lighter font below the value
+                $('<div></div>').text(selectedOption.module).css({
+                    // "font-family": "var(--red-ui-monospace-font)",
+                    color: "var(--red-ui-tertiary-text-color)",
+                    "font-size": "0.8em",
+                    "line-height": "1em",
+                    opacity: 0.8
+                }).appendTo(container);
+            },
+            // hasValue: false,
+            options: function () {
+                if (this._optionsCache) {
+                    return this._optionsCache
+                }
+                const configNodes = RED.nodes.registry.getNodeDefinitions({configOnly: true, filter: (def) => def.type !== "global-config"}).map((def) => {
+                    // create a container with with 2 rows (row 1 for the name, row 2 for the module name in smaller, lighter font)
+                    const container = $('<div style="display: flex; flex-direction: column; justify-content: space-between; row-gap: 1px;">')
+                    const row1Name = $('<div>').text(def.type)
+                    const row2Module = $('<div style="font-size: 0.8em; color: var(--red-ui-tertiary-text-color);">').text(def.set.module)
+                    container.append(row1Name, row2Module)
+        
+                    return {
+                        value: def.type,
+                        name: def.type,
+                        enabled: def.set.enabled ?? true,
+                        local: def.set.local,
+                        title: def.set.id, // tooltip e.g. "node-red-contrib-foo/bar"
+                        module: def.set.module,
+                        icon: container[0].outerHTML.trim(), // the typeInput will interpret this as html text and render it in the anchor
+                    }
+                })
+                this._optionsCache = configNodes
+                return configNodes
+            }
         }
     };
 
+    
     // For a type with options, check value is a valid selection
     // If !opt.multiple, returns the valid option object
     // if opt.multiple, returns an array of valid option objects
     // If not valid, returns null;
 
     function isOptionValueValid(opt, currentVal) {
+        let _options = opt.options
+        if (typeof _options === "function") {
+            _options = _options.call(this)
+        }
         if (!opt.multiple) {
-            for (var i=0;i<opt.options.length;i++) {
-                op = opt.options[i];
+            for (var i=0;i<_options.length;i++) {
+                op = _options[i];
                 if (typeof op === "string" && op === currentVal) {
                     return {value:currentVal}
                 } else if (op.value === currentVal) {
@@ -14528,8 +15223,8 @@ RED.stack = (function() {
                     currentValues[v] = true;
                 }
             });
-            for (var i=0;i<opt.options.length;i++) {
-                op = opt.options[i];
+            for (var i=0;i<_options.length;i++) {
+                op = _options[i];
                 var val = typeof op === "string" ? op : op.value;
                 if (currentValues.hasOwnProperty(val)) {
                     delete currentValues[val];
@@ -14544,6 +15239,7 @@ RED.stack = (function() {
     }
 
     var nlsd = false;
+    let contextStoreOptions;
 
     $.widget( "nodered.typedInput", {
         _create: function() {
@@ -14555,7 +15251,7 @@ RED.stack = (function() {
                     }
                 }
                 var contextStores = RED.settings.context.stores;
-                var contextOptions = contextStores.map(function(store) {
+                contextStoreOptions = contextStores.map(function(store) {
                     return {value:store,label: store, icon:'<i class="red-ui-typedInput-icon fa fa-database"></i>'}
                 }).sort(function(A,B) {
                     if (A.value === RED.settings.context.default) {
@@ -14566,13 +15262,17 @@ RED.stack = (function() {
                         return A.value.localeCompare(B.value);
                     }
                 })
-                if (contextOptions.length < 2) {
+                if (contextStoreOptions.length < 2) {
                     allOptions.flow.options = [];
                     allOptions.global.options = [];
                 } else {
-                    allOptions.flow.options = contextOptions;
-                    allOptions.global.options = contextOptions;
+                    allOptions.flow.options = contextStoreOptions;
+                    allOptions.global.options = contextStoreOptions;
                 }
+                // Translate timestamp options
+                allOptions.date.options.forEach(opt => {
+                    opt.label = RED._("typedInput.date.format." + (opt.value || 'timestamp'), {defaultValue: opt.label})
+                })
             }
             nlsd = true;
             var that = this;
@@ -14661,7 +15361,7 @@ RED.stack = (function() {
                 that.element.trigger('paste',evt);
             });
             this.input.on('keydown', function(evt) {
-                if (that.typeMap[that.propertyType].autoComplete) {
+                if (that.typeMap[that.propertyType].autoComplete || that.input.hasClass('red-ui-autoComplete')) {
                     return
                 }
                 if (evt.keyCode >= 37 && evt.keyCode <= 40) {
@@ -14955,7 +15655,9 @@ RED.stack = (function() {
             if (this.optionMenu) {
                 this.optionMenu.remove();
             }
-            this.menu.remove();
+            if (this.menu) {
+                this.menu.remove();
+            }
             this.uiSelect.remove();
         },
         types: function(types) {
@@ -14988,7 +15690,7 @@ RED.stack = (function() {
             this.menu = this._createMenu(this.typeList,{},function(v) { that.type(v) });
             if (currentType && !this.typeMap.hasOwnProperty(currentType)) {
                 if (!firstCall) {
-                    this.type(this.typeList[0].value);
+                    this.type(this.typeList[0]?.value || ""); // permit empty typeList
                 }
             } else {
                 this.propertyType = null;
@@ -15025,6 +15727,11 @@ RED.stack = (function() {
                 var selectedOption = [];
                 var valueToCheck = value;
                 if (opt.options) {
+                    let _options = opt.options
+                    if (typeof opt.options === "function") {
+                        _options = opt.options.call(this)
+                    }
+
                     if (opt.hasValue && opt.parse) {
                         var parts = opt.parse(value);
                         if (this.options.debug) { console.log(this.identifier,"new parse",parts) }
@@ -15038,8 +15745,8 @@ RED.stack = (function() {
                         checkValues = valueToCheck.split(",");
                     }
                     checkValues.forEach(function(valueToCheck) {
-                        for (var i=0;i<opt.options.length;i++) {
-                            var op = opt.options[i];
+                        for (var i=0;i<_options.length;i++) {
+                            var op = _options[i];
                             if (typeof op === "string") {
                                 if (op === valueToCheck || op === ""+valueToCheck) {
                                     selectedOption.push(that.activeOptions[op]);
@@ -15074,7 +15781,7 @@ RED.stack = (function() {
         },
         type: function(type) {
             if (!arguments.length) {
-                return this.propertyType;
+                return this.propertyType || this.options?.default || '';
             } else {
                 var that = this;
                 if (this.options.debug) { console.log(this.identifier,"----- SET TYPE -----",type) }
@@ -15084,6 +15791,9 @@ RED.stack = (function() {
                     // If previousType is !null, then this is a change of the type, rather than the initialisation
                     var previousType = this.typeMap[this.propertyType];
                     previousValue = this.input.val();
+                    if (this.input.hasClass('red-ui-autoComplete')) {
+                        this.input.autoComplete("destroy");
+                    }
 
                     if (previousType && this.typeChanged) {
                         if (this.options.debug) { console.log(this.identifier,"typeChanged",{previousType,previousValue}) }
@@ -15130,7 +15840,9 @@ RED.stack = (function() {
                             this.input.val(this.oldValues.hasOwnProperty("_")?this.oldValues["_"]:(opt.default||""))
                         }
                         if (previousType.autoComplete) {
-                            this.input.autoComplete("destroy");
+                            if (this.input.hasClass('red-ui-autoComplete')) {
+                                this.input.autoComplete("destroy");
+                            }
                         }
                     }
                     this.propertyType = type;
@@ -15170,6 +15882,10 @@ RED.stack = (function() {
                         this.optionMenu = null;
                     }
                     if (opt.options) {
+                        let _options = opt.options
+                        if (typeof _options === "function") {
+                            _options = opt.options.call(this);
+                        }
                         if (this.optionExpandButton) {
                             this.optionExpandButton.hide();
                             this.optionExpandButton.shown = false;
@@ -15186,7 +15902,7 @@ RED.stack = (function() {
                                 this.valueLabelContainer.hide();
                             }
                             this.activeOptions = {};
-                            opt.options.forEach(function(o) {
+                            _options.forEach(function(o) {
                                 if (typeof o === 'string') {
                                     that.activeOptions[o] = {label:o,value:o};
                                 } else {
@@ -15206,7 +15922,7 @@ RED.stack = (function() {
                                     if (validValues) {
                                         that._updateOptionSelectLabel(validValues)
                                     } else {
-                                        op = opt.options[0];
+                                        op = _options[0] || {value:""}; // permit zero options
                                         if (typeof op === "string") {
                                             this.value(op);
                                             that._updateOptionSelectLabel({value:op});
@@ -15225,7 +15941,7 @@ RED.stack = (function() {
                                     that._updateOptionSelectLabel(validValues);
                                 }
                             } else {
-                                var selectedOption = this.optionValue||opt.options[0];
+                                var selectedOption = this.optionValue||_options[0];
                                 if (opt.parse) {
                                     var selectedOptionObj = typeof selectedOption === "string"?{value:selectedOption}:selectedOption
                                     var parts = opt.parse(this.input.val(),selectedOptionObj);
@@ -15258,8 +15974,18 @@ RED.stack = (function() {
                                 } else {
                                     this.optionSelectTrigger.hide();
                                 }
+                                if (opt.autoComplete) {
+                                    let searchFunction = opt.autoComplete
+                                    if (searchFunction.length === 0) {
+                                        searchFunction = opt.autoComplete.call(this)
+                                    }
+                                    this.input.autoComplete({
+                                        search: searchFunction,
+                                        minLength: 0
+                                    })
+                                }
                             }
-                            this.optionMenu = this._createMenu(opt.options,opt,function(v){
+                            this.optionMenu = this._createMenu(_options,opt,function(v){
                                 if (!opt.multiple) {
                                     that._updateOptionSelectLabel(that.activeOptions[v]);
                                     if (!opt.hasValue) {
@@ -15300,8 +16026,12 @@ RED.stack = (function() {
                             this.valueLabelContainer.hide();
                             this.elementDiv.show();
                             if (opt.autoComplete) {
+                                let searchFunction = opt.autoComplete
+                                if (searchFunction.length === 0) {
+                                    searchFunction = opt.autoComplete.call(this)
+                                }
                                 this.input.autoComplete({
-                                    search: opt.autoComplete,
+                                    search: searchFunction,
                                     minLength: 0
                                 })
                             }
@@ -19560,10 +20290,6 @@ RED.keyboard = (function() {
     }
 
     function init(done) {
-        if (!RED.user.hasPermission("settings.write")) {
-            RED.notify(RED._("user.errors.settings"),"error");
-            return;
-        }
         RED.userSettings.add({
             id:'envvar',
             title: RED._("env-var.environment"),
@@ -26818,6 +27544,10 @@ RED.view = (function() {
                             }
                         })
                     }
+                    if (selection.links) {
+                        selectedLinks.clear();
+                        selection.links.forEach(selectedLinks.add);
+                    }
                 }
             }
             updateSelection();
@@ -29071,6 +29801,10 @@ RED.palette = (function() {
     var categoryContainers = {};
     var sidebarControls;
 
+    let paletteState = { filter: "", collapsed: [] };
+
+    let filterRefreshTimeout
+
     function createCategory(originalCategory,rootCategory,category,ns) {
         if ($("#red-ui-palette-base-category-"+rootCategory).length === 0) {
             createCategoryContainer(originalCategory,rootCategory, ns+":palette.label."+rootCategory);
@@ -29096,20 +29830,57 @@ RED.palette = (function() {
         catDiv.data('label',label);
         categoryContainers[category] = {
             container: catDiv,
-            close: function() {
+            hide: function (instant) {
+                if (instant) {
+                    catDiv.hide()
+                } else {
+                    catDiv.slideUp()
+                }
+            },
+            show: function () {
+                catDiv.show()
+            },
+            isOpen: function () {
+                return !!catDiv.hasClass("red-ui-palette-open")
+            },
+            getNodeCount: function (visibleOnly) {
+                const nodes = catDiv.find(".red-ui-palette-node")
+                if (visibleOnly) {
+                    return nodes.filter(function() { return $(this).css('display') !== 'none'}).length
+                } else {
+                    return nodes.length
+                }
+            },
+            close: function(instant, skipSaveState) {
                 catDiv.removeClass("red-ui-palette-open");
                 catDiv.addClass("red-ui-palette-closed");
-                $("#red-ui-palette-base-category-"+category).slideUp();
+                if (instant) {
+                    $("#red-ui-palette-base-category-"+category).hide();
+                } else {
+                    $("#red-ui-palette-base-category-"+category).slideUp();
+                }
                 $("#red-ui-palette-header-"+category+" i").removeClass("expanded");
+                if (!skipSaveState) {
+                    if (!paletteState.collapsed.includes(category)) {
+                        paletteState.collapsed.push(category);
+                        savePaletteState();
+                    }
+                }
             },
-            open: function() {
+            open: function(skipSaveState) {
                 catDiv.addClass("red-ui-palette-open");
                 catDiv.removeClass("red-ui-palette-closed");
                 $("#red-ui-palette-base-category-"+category).slideDown();
                 $("#red-ui-palette-header-"+category+" i").addClass("expanded");
+                if (!skipSaveState) {
+                    if (paletteState.collapsed.includes(category)) {
+                        paletteState.collapsed.splice(paletteState.collapsed.indexOf(category), 1);
+                        savePaletteState();
+                    }
+                }
             },
             toggle: function() {
-                if (catDiv.hasClass("red-ui-palette-open")) {
+                if (categoryContainers[category].isOpen()) {
                     categoryContainers[category].close();
                 } else {
                     categoryContainers[category].open();
@@ -29451,8 +30222,16 @@ RED.palette = (function() {
 
             var categoryNode = $("#red-ui-palette-container-"+rootCategory);
             if (categoryNode.find(".red-ui-palette-node").length === 1) {
-                categoryContainers[rootCategory].open();
+                if (!paletteState?.collapsed?.includes(rootCategory)) {
+                    categoryContainers[rootCategory].open();
+                } else {
+                    categoryContainers[rootCategory].close(true);
+                }
             }
+            clearTimeout(filterRefreshTimeout)
+            filterRefreshTimeout = setTimeout(() => {
+                refreshFilter()
+            }, 200)
 
         }
     }
@@ -29552,7 +30331,8 @@ RED.palette = (function() {
         paletteNode.css("backgroundColor", sf.color);
     }
 
-    function filterChange(val) {
+    function refreshFilter() {
+        const val = $("#red-ui-palette-search input").val()
         var re = new RegExp(val.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'),'i');
         $("#red-ui-palette-container .red-ui-palette-node").each(function(i,el) {
             var currentLabel = $(el).attr("data-palette-label");
@@ -29564,16 +30344,26 @@ RED.palette = (function() {
             }
         });
 
-        for (var category in categoryContainers) {
+        for (let category in categoryContainers) {
             if (categoryContainers.hasOwnProperty(category)) {
-                if (categoryContainers[category].container
-                        .find(".red-ui-palette-node")
-                        .filter(function() { return $(this).css('display') !== 'none'}).length === 0) {
-                    categoryContainers[category].close();
-                    categoryContainers[category].container.slideUp();
+                const categorySection = categoryContainers[category]
+                if (categorySection.getNodeCount(true) === 0) {
+                    categorySection.hide()
                 } else {
-                    categoryContainers[category].open();
-                    categoryContainers[category].container.show();
+                    categorySection.show()
+                    if (val) {
+                        // There is a filter being applied and it has matched
+                        // something in this category - show the contents
+                        categorySection.open(true)
+                    } else {
+                        // No filter. Only show the category if it isn't in lastState
+                        if (!paletteState.collapsed.includes(category)) {
+                            categorySection.open(true)
+                        } else if (categorySection.isOpen()) {
+                            // This section should be collapsed but isn't - so make it so
+                            categorySection.close(true, true)
+                        }
+                    }
                 }
             }
         }
@@ -29589,6 +30379,9 @@ RED.palette = (function() {
 
         $("#red-ui-palette > .red-ui-palette-spinner").show();
 
+        RED.events.on('logout', function () {
+            RED.settings.removeLocal('palette-state')
+        })
 
         RED.events.on('registry:node-type-added', function(nodeType) {
             var def = RED.nodes.getType(nodeType);
@@ -29632,14 +30425,14 @@ RED.palette = (function() {
 
         RED.events.on("subflows:change",refreshSubflow);
 
-
-
         $("#red-ui-palette-search input").searchBox({
             delay: 100,
             change: function() {
-                filterChange($(this).val());
+                refreshFilter();
+                paletteState.filter = $(this).val();
+                savePaletteState();
             }
-        })
+        });
 
         sidebarControls = $('<div class="red-ui-sidebar-control-left"><i class="fa fa-chevron-left"></i></div>').appendTo($("#red-ui-palette"));
         RED.popover.tooltip(sidebarControls,RED._("keyboard.togglePalette"),"core:toggle-palette");
@@ -29705,7 +30498,23 @@ RED.palette = (function() {
                 togglePalette(state);
             }
         });
+
+        try {
+            paletteState = JSON.parse(RED.settings.getLocal("palette-state") || '{"filter":"", "collapsed": []}');
+            if (paletteState.filter) {
+                // Apply the category filter
+                $("#red-ui-palette-search input").searchBox("value", paletteState.filter);
+            }
+        } catch (error) {
+            console.error("Unexpected error loading palette state from localStorage: ", error);
+        }
+        setTimeout(() => {
+            // Lazily tidy up any categories that haven't been reloaded
+            paletteState.collapsed = paletteState.collapsed.filter(category => !!categoryContainers[category])
+            savePaletteState()
+        }, 10000)
     }
+
     function togglePalette(state) {
         if (!state) {
             $("#red-ui-main-container").addClass("red-ui-palette-closed");
@@ -29725,6 +30534,15 @@ RED.palette = (function() {
         })
         return categories;
     }
+
+    function savePaletteState() {
+        try {
+            RED.settings.setLocal("palette-state", JSON.stringify(paletteState));
+        } catch (error) {
+            console.error("Unexpected error saving palette state to localStorage: ", error);
+        }
+    }
+
     return {
         init: init,
         add:addNodeType,
@@ -31214,8 +32032,10 @@ RED.sidebar.help = (function() {
 
     function refreshSubflow(sf) {
         var item = treeList.treeList('get',"node-type:subflow:"+sf.id);
-        item.subflowLabel = sf._def.label().toLowerCase();
-        item.treeList.replaceElement(getNodeLabel({_def:sf._def,type:sf._def.label()}));
+        if (item) {
+            item.subflowLabel = sf._def.label().toLowerCase();
+            item.treeList.replaceElement(getNodeLabel({_def:sf._def,type:sf._def.label()}));
+        }
     }
 
     function hideTOC() {
@@ -32582,86 +33402,106 @@ RED.palette.editor = (function() {
             var moduleInfo = nodeEntries[module].info;
             var nodeEntry = nodeEntries[module].elements;
             if (nodeEntry) {
-                var activeTypeCount = 0;
-                var typeCount = 0;
-                var errorCount = 0;
-                nodeEntry.errorList.empty();
-                nodeEntries[module].totalUseCount = 0;
-                nodeEntries[module].setUseCount = {};
-
-                for (var setName in moduleInfo.sets) {
-                    if (moduleInfo.sets.hasOwnProperty(setName)) {
-                        var inUseCount = 0;
-                        var set = moduleInfo.sets[setName];
-                        var setElements = nodeEntry.sets[setName];
-                        if (set.err) {
-                            errorCount++;
-                            var errMessage = set.err;
-                            if (set.err.message) {
-                                errMessage = set.err.message;
-                            } else if (set.err.code) {
-                                errMessage = set.err.code;
-                            }
-                            $("<li>").text(errMessage).appendTo(nodeEntry.errorList);
-                        }
-                        if (set.enabled) {
-                            activeTypeCount += set.types.length;
-                        }
-                        typeCount += set.types.length;
-                        for (var i=0;i<moduleInfo.sets[setName].types.length;i++) {
-                            var t = moduleInfo.sets[setName].types[i];
-                            inUseCount += (typesInUse[t]||0);
-                            var swatch = setElements.swatches[t];
-                            if (set.enabled) {
-                                var def = RED.nodes.getType(t);
-                                if (def && def.color) {
-                                    swatch.css({background:RED.utils.getNodeColor(t,def)});
-                                    swatch.css({border: "1px solid "+getContrastingBorder(swatch.css('backgroundColor'))})
-                                }
+                if (moduleInfo.plugin) {
+                    nodeEntry.enableButton.hide();
+                    nodeEntry.removeButton.show();
+
+                    let pluginCount = 0;
+                    for (let setName in moduleInfo.sets) {
+                        if (moduleInfo.sets.hasOwnProperty(setName)) {
+                            let set = moduleInfo.sets[setName];
+                            if (set.plugins) {
+                                pluginCount += set.plugins.length;
                             }
                         }
-                        nodeEntries[module].setUseCount[setName] = inUseCount;
-                        nodeEntries[module].totalUseCount += inUseCount;
+                    }
+                    
+                    nodeEntry.setCount.text(RED._('palette.editor.pluginCount',{count:pluginCount,label:pluginCount}));
 
-                        if (inUseCount > 0) {
-                            setElements.enableButton.text(RED._('palette.editor.inuse'));
-                            setElements.enableButton.addClass('disabled');
-                        } else {
-                            setElements.enableButton.removeClass('disabled');
+                } else {
+                    var activeTypeCount = 0;
+                    var typeCount = 0;
+                    var errorCount = 0;
+                    nodeEntry.errorList.empty();
+                    nodeEntries[module].totalUseCount = 0;
+                    nodeEntries[module].setUseCount = {};
+
+                    for (var setName in moduleInfo.sets) {
+                        if (moduleInfo.sets.hasOwnProperty(setName)) {
+                            var inUseCount = 0;
+                            const set = moduleInfo.sets[setName];
+                            const setElements = nodeEntry.sets[setName]
+
+                            if (set.err) {
+                                errorCount++;
+                                var errMessage = set.err;
+                                if (set.err.message) {
+                                    errMessage = set.err.message;
+                                } else if (set.err.code) {
+                                    errMessage = set.err.code;
+                                }
+                                $("<li>").text(errMessage).appendTo(nodeEntry.errorList);
+                            }
                             if (set.enabled) {
-                                setElements.enableButton.text(RED._('palette.editor.disable'));
-                            } else {
-                                setElements.enableButton.text(RED._('palette.editor.enable'));
+                                activeTypeCount += set.types.length;
+                            }
+                            typeCount += set.types.length;
+                            for (var i=0;i<moduleInfo.sets[setName].types.length;i++) {
+                                var t = moduleInfo.sets[setName].types[i];
+                                inUseCount += (typesInUse[t]||0);
+                                if (setElements && set.enabled) {
+                                    var def = RED.nodes.getType(t);
+                                    if (def && def.color) {
+                                        setElements.swatches[t].css({background:RED.utils.getNodeColor(t,def)});
+                                        setElements.swatches[t].css({border: "1px solid "+getContrastingBorder(setElements.swatches[t].css('backgroundColor'))})
+                                    }
+                                }
+                            }
+                            nodeEntries[module].setUseCount[setName] = inUseCount;
+                            nodeEntries[module].totalUseCount += inUseCount;
+
+                            if (setElements) {
+                                if (inUseCount > 0) {
+                                    setElements.enableButton.text(RED._('palette.editor.inuse'));
+                                    setElements.enableButton.addClass('disabled');
+                                } else {
+                                    setElements.enableButton.removeClass('disabled');
+                                    if (set.enabled) {
+                                        setElements.enableButton.text(RED._('palette.editor.disable'));
+                                    } else {
+                                        setElements.enableButton.text(RED._('palette.editor.enable'));
+                                    }
+                                }
+                                setElements.setRow.toggleClass("red-ui-palette-module-set-disabled",!set.enabled);
                             }
                         }
-                        setElements.setRow.toggleClass("red-ui-palette-module-set-disabled",!set.enabled);
                     }
-                }
 
-                if (errorCount === 0) {
-                    nodeEntry.errorRow.hide()
-                } else {
-                    nodeEntry.errorRow.show();
-                }
+                    if (errorCount === 0) {
+                        nodeEntry.errorRow.hide()
+                    } else {
+                        nodeEntry.errorRow.show();
+                    }
 
-                var nodeCount = (activeTypeCount === typeCount)?typeCount:activeTypeCount+" / "+typeCount;
-                nodeEntry.setCount.text(RED._('palette.editor.nodeCount',{count:typeCount,label:nodeCount}));
+                    var nodeCount = (activeTypeCount === typeCount)?typeCount:activeTypeCount+" / "+typeCount;
+                    nodeEntry.setCount.text(RED._('palette.editor.nodeCount',{count:typeCount,label:nodeCount}));
 
-                if (nodeEntries[module].totalUseCount > 0) {
-                    nodeEntry.enableButton.text(RED._('palette.editor.inuse'));
-                    nodeEntry.enableButton.addClass('disabled');
-                    nodeEntry.removeButton.hide();
-                } else {
-                    nodeEntry.enableButton.removeClass('disabled');
-                    if (moduleInfo.local) {
-                        nodeEntry.removeButton.css('display', 'inline-block');
-                    }
-                    if (activeTypeCount === 0) {
-                        nodeEntry.enableButton.text(RED._('palette.editor.enableall'));
+                    if (nodeEntries[module].totalUseCount > 0) {
+                        nodeEntry.enableButton.text(RED._('palette.editor.inuse'));
+                        nodeEntry.enableButton.addClass('disabled');
+                        nodeEntry.removeButton.hide();
                     } else {
-                        nodeEntry.enableButton.text(RED._('palette.editor.disableall'));
+                        nodeEntry.enableButton.removeClass('disabled');
+                        if (moduleInfo.local) {
+                            nodeEntry.removeButton.css('display', 'inline-block');
+                        }
+                        if (activeTypeCount === 0) {
+                            nodeEntry.enableButton.text(RED._('palette.editor.enableall'));
+                        } else {
+                            nodeEntry.enableButton.text(RED._('palette.editor.disableall'));
+                        }
+                        nodeEntry.container.toggleClass("disabled",(activeTypeCount === 0));
                     }
-                    nodeEntry.container.toggleClass("disabled",(activeTypeCount === 0));
                 }
             }
             if (moduleInfo.pending_version) {
@@ -33012,6 +33852,33 @@ RED.palette.editor = (function() {
                 }
             }
         })
+
+        RED.events.on("registry:plugin-module-added", function(module) {
+
+            if (!nodeEntries.hasOwnProperty(module)) {
+                nodeEntries[module] = {info:RED.plugins.getModule(module)};
+                var index = [module];
+                for (var s in nodeEntries[module].info.sets) {
+                    if (nodeEntries[module].info.sets.hasOwnProperty(s)) {
+                        index.push(s);
+                        index = index.concat(nodeEntries[module].info.sets[s].types)
+                    }
+                }
+                nodeEntries[module].index = index.join(",").toLowerCase();
+                nodeList.editableList('addItem', nodeEntries[module]);
+            } else {
+                _refreshNodeModule(module);
+            }
+
+            for (var i=0;i<filteredList.length;i++) {
+                if (filteredList[i].info.id === module) {
+                    var installButton = filteredList[i].elements.installButton;
+                    installButton.addClass('disabled');
+                    installButton.text(RED._('palette.editor.installed'));
+                    break;
+                }
+            }
+        });
     }
 
     var settingsPane;
@@ -33138,6 +34005,7 @@ RED.palette.editor = (function() {
                         errorRow: errorRow,
                         errorList: errorList,
                         setCount: setCount,
+                        setButton: setButton,
                         container: container,
                         shade: shade,
                         versionSpan: versionSpan,
@@ -33148,49 +34016,88 @@ RED.palette.editor = (function() {
                         if (container.hasClass('expanded')) {
                             container.removeClass('expanded');
                             contentRow.slideUp();
+                            setTimeout(() => {
+                                contentRow.empty()
+                            }, 200)
+                            object.elements.sets = {}
                         } else {
                             container.addClass('expanded');
+                            populateSetList()
                             contentRow.slideDown();
                         }
                     })
-
-                    var setList = Object.keys(entry.sets)
-                    setList.sort(function(A,B) {
-                        return A.toLowerCase().localeCompare(B.toLowerCase());
-                    });
-                    setList.forEach(function(setName) {
-                        var set = entry.sets[setName];
-                        var setRow = $('<div>',{class:"red-ui-palette-module-set"}).appendTo(contentRow);
-                        var buttonGroup = $('<div>',{class:"red-ui-palette-module-set-button-group"}).appendTo(setRow);
-                        var typeSwatches = {};
-                        set.types.forEach(function(t) {
-                            var typeDiv = $('<div>',{class:"red-ui-palette-module-type"}).appendTo(setRow);
-                            typeSwatches[t] = $('<span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
-                            $('<span>',{class:"red-ui-palette-module-type-node"}).text(t).appendTo(typeDiv);
-                        })
-                        var enableButton = $('<a href="#" class="red-ui-button red-ui-button-small"></a>').appendTo(buttonGroup);
-                        enableButton.on("click", function(evt) {
-                            evt.preventDefault();
-                            if (object.setUseCount[setName] === 0) {
-                                var currentSet = RED.nodes.registry.getNodeSet(set.id);
-                                shade.show();
-                                var newState = !currentSet.enabled
-                                changeNodeState(set.id,newState,shade,function(xhr){
-                                    if (xhr) {
-                                        if (xhr.responseJSON) {
-                                            RED.notify(RED._('palette.editor.errors.'+(newState?'enable':'disable')+'Failed',{module: id,message:xhr.responseJSON.message}));
+                    const populateSetList = function () {
+                        var setList = Object.keys(entry.sets)
+                        setList.sort(function(A,B) {
+                            return A.toLowerCase().localeCompare(B.toLowerCase());
+                        });
+                        setList.forEach(function(setName) {
+                            var set = entry.sets[setName];
+                            var setRow = $('<div>',{class:"red-ui-palette-module-set"}).appendTo(contentRow);
+                            var buttonGroup = $('<div>',{class:"red-ui-palette-module-set-button-group"}).appendTo(setRow);
+                            var typeSwatches = {};
+                            let enableButton;
+                            if (set.types) {
+                                set.types.forEach(function(t) {
+                                    var typeDiv = $('<div>',{class:"red-ui-palette-module-type"}).appendTo(setRow);
+                                    typeSwatches[t] = $('<span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
+                                    if (set.enabled) {
+                                        var def = RED.nodes.getType(t);
+                                        if (def && def.color) {
+                                            typeSwatches[t].css({background:RED.utils.getNodeColor(t,def)});
+                                            typeSwatches[t].css({border: "1px solid "+getContrastingBorder(typeSwatches[t].css('backgroundColor'))})
                                         }
                                     }
-                                });
+                                    $('<span>',{class:"red-ui-palette-module-type-node"}).text(t).appendTo(typeDiv);
+                                })
+                                enableButton = $('<a href="#" class="red-ui-button red-ui-button-small"></a>').appendTo(buttonGroup);
+                                enableButton.on("click", function(evt) {
+                                    evt.preventDefault();
+                                    if (object.setUseCount[setName] === 0) {
+                                        var currentSet = RED.nodes.registry.getNodeSet(set.id);
+                                        shade.show();
+                                        var newState = !currentSet.enabled
+                                        changeNodeState(set.id,newState,shade,function(xhr){
+                                            if (xhr) {
+                                                if (xhr.responseJSON) {
+                                                    RED.notify(RED._('palette.editor.errors.'+(newState?'enable':'disable')+'Failed',{module: id,message:xhr.responseJSON.message}));
+                                                }
+                                            }
+                                        });
+                                    }
+                                })
+
+                                if (object.setUseCount[setName] > 0) {
+                                    enableButton.text(RED._('palette.editor.inuse'));
+                                    enableButton.addClass('disabled');
+                                } else {
+                                    enableButton.removeClass('disabled');
+                                    if (set.enabled) {
+                                        enableButton.text(RED._('palette.editor.disable'));
+                                    } else {
+                                        enableButton.text(RED._('palette.editor.enable'));
+                                    }
+                                }
+                                setRow.toggleClass("red-ui-palette-module-set-disabled",!set.enabled);
+
+
+                            }
+                            if (set.plugins) {
+                                set.plugins.forEach(function(p) {
+                                    var typeDiv = $('<div>',{class:"red-ui-palette-module-type"}).appendTo(setRow);
+                                    // typeSwatches[p.id] = $('<span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
+                                    $('<span><i class="fa fa-puzzle-piece" aria-hidden="true"></i>  </span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
+                                    $('<span>',{class:"red-ui-palette-module-type-node"}).text(p.id).appendTo(typeDiv);
+                                })
                             }
-                        })
 
-                        object.elements.sets[set.name] = {
-                            setRow: setRow,
-                            enableButton: enableButton,
-                            swatches: typeSwatches
-                        };
-                    });
+                            object.elements.sets[set.name] = {
+                                setRow: setRow,
+                                enableButton: enableButton,
+                                swatches: typeSwatches
+                            };
+                        });
+                    }
                     enableButton.on("click", function(evt) {
                         evt.preventDefault();
                         if (object.totalUseCount === 0) {
@@ -33560,7 +34467,55 @@ RED.palette.editor = (function() {
                                                 }
                                             }
                                         ]
-                                    });                                }
+                                    });                                
+                                }
+                            } else {
+                                // dedicated list management for plugins
+                                if (entry.plugin) {
+
+                                    let e = nodeEntries[entry.name];
+                                    if (e) {
+                                        nodeList.editableList('removeItem', e);
+                                        delete nodeEntries[entry.name];
+                                    }
+
+                                    // We assume that a plugin that implements onremove
+                                    // cleans the editor accordingly of its left-overs.
+                                    let found_onremove = true;
+
+                                    let keys = Object.keys(entry.sets);
+                                    keys.forEach((key) => {
+                                        let set = entry.sets[key];
+                                        for (let i=0; i<set.plugins?.length; i++) {
+                                            let plgn = RED.plugins.getPlugin(set.plugins[i].id);
+                                            if (plgn && plgn.onremove  && typeof plgn.onremove === 'function') {
+                                                plgn.onremove();
+                                            } else {
+                                                if (plgn && plgn.onadd && typeof plgn.onadd === 'function') {
+                                                    // if there's no 'onadd', there shouldn't be any left-overs
+                                                    found_onremove = false;
+                                                }
+                                            }
+                                        }
+                                    });
+
+                                    if (!found_onremove) {
+                                        let removeNotify = RED.notify("Removed plugin " + entry.name + ". Please reload the editor to clear left-overs.",{
+                                            modal: true,
+                                            fixed: true,
+                                            type: 'warning',
+                                            buttons: [
+                                                {
+                                                    text: "Understood",
+                                                    class:"primary",
+                                                    click: function(e) {
+                                                        removeNotify.close();
+                                                    }
+                                                }
+                                            ]
+                                        });
+                                    }
+                                }        
                             }
                         })
                         notification.close();
@@ -33975,48 +34930,108 @@ RED.editor = (function() {
 
     /**
      * Create a config-node select box for this property
-     * @param node - the node being edited
-     * @param property - the name of the field
-     * @param type - the type of the config-node
+     * @param  {Object} node - the node being edited
+     * @param {String} property - the name of the node property
+     * @param {String} type - the type of the config-node
+     * @param {"node-config-input"|"node-input"|"node-input-subflow-env"} prefix - the prefix to use in the input element ids
+     * @param {Function} [filter] - a function to filter the list of config nodes
+     * @param {Object} [env] - the environment variable object (only used for subflow env vars)
      */
-    function prepareConfigNodeSelect(node,property,type,prefix,filter) {
-        var input = $("#"+prefix+"-"+property);
-        if (input.length === 0 ) {
+    function prepareConfigNodeSelect(node, property, type, prefix, filter, env) {
+        let nodeValue
+        if (prefix === 'node-input-subflow-env') {
+            nodeValue = env?.value
+        } else {
+            nodeValue = node[property]
+        }
+
+        const addBtnId = `${prefix}-btn-${property}-add`;
+        const editBtnId = `${prefix}-btn-${property}-edit`;
+        const selectId = prefix + '-' + property;
+        const input = $(`#${selectId}`);
+        if (input.length === 0) {
             return;
         }
-        var newWidth = input.width();
-        var attrStyle = input.attr('style');
-        var m;
+        const attrStyle = input.attr('style');
+        let newWidth;
+        let m;
         if ((m = /(^|\s|;)width\s*:\s*([^;]+)/i.exec(attrStyle)) !== null) {
             newWidth = m[2].trim();
         } else {
             newWidth = "70%";
         }
-        var outerWrap = $("<div></div>").css({
+        const outerWrap = $("<div></div>").css({
             width: newWidth,
-            display:'inline-flex'
+            display: 'inline-flex'
         });
-        var select = $('<select id="'+prefix+'-'+property+'"></select>').appendTo(outerWrap);
+        const select = $('<select id="' + selectId + '"></select>').appendTo(outerWrap);
         input.replaceWith(outerWrap);
         // set the style attr directly - using width() on FF causes a value of 114%...
         select.css({
             'flex-grow': 1
         });
-        updateConfigNodeSelect(property,type,node[property],prefix,filter);
-        $('<a id="'+prefix+'-lookup-'+property+'" class="red-ui-button"><i class="fa fa-pencil"></i></a>')
-            .css({"margin-left":"10px"})
+
+        updateConfigNodeSelect(property, type, nodeValue, prefix, filter);
+
+        // create the edit button
+        const editButton = $('<a id="' + editBtnId + '" class="red-ui-button"><i class="fa fa-pencil"></i></a>')
+            .css({ "margin-left": "10px" })
             .appendTo(outerWrap);
-        $('#'+prefix+'-lookup-'+property).on("click", function(e) {
-            showEditConfigNodeDialog(property,type,select.find(":selected").val(),prefix,node);
+
+        RED.popover.tooltip(editButton, RED._('editor.editConfig', { type }));
+
+        // create the add button
+        const addButton = $('<a id="' + addBtnId + '" class="red-ui-button"><i class="fa fa-plus"></i></a>')
+            .css({ "margin-left": "10px" })
+            .appendTo(outerWrap);
+        RED.popover.tooltip(addButton, RED._('editor.addNewConfig', { type }));
+
+        const disableButton = function(button, disabled) {
+            $(button).prop("disabled", !!disabled)
+            $(button).toggleClass("disabled", !!disabled)
+        };
+
+        // add the click handler
+        addButton.on("click", function (e) {
+            if (addButton.prop("disabled")) { return }
+            showEditConfigNodeDialog(property, type, "_ADD_", prefix, node);
+            e.preventDefault();
+        });
+        editButton.on("click", function (e) {
+            const selectedOpt = select.find(":selected")
+            if (selectedOpt.data('env')) { return } // don't show the dialog for env vars items (MVP. Future enhancement: lookup the env, if present, show the associated edit dialog)
+            if (editButton.prop("disabled")) { return }
+            showEditConfigNodeDialog(property, type, selectedOpt.val(), prefix, node);
             e.preventDefault();
         });
+
+        // dont permit the user to click the button if the selected option is an env var
+        select.on("change", function () {
+            const selectedOpt = select.find(":selected");
+            const optionsLength = select.find("option").length;
+            if (selectedOpt?.data('env')) {
+                disableButton(addButton, true);
+                disableButton(editButton, true);
+            // disable the edit button if no options available
+            } else if (optionsLength === 1 && selectedOpt.val() === "_ADD_") {
+                disableButton(addButton, false);
+                disableButton(editButton, true);
+            } else if (selectedOpt.val() === "") {
+                disableButton(addButton, false);
+                disableButton(editButton, true);
+            } else {
+                disableButton(addButton, false);
+                disableButton(editButton, false);
+            }
+        });
+
         var label = "";
-        var configNode = RED.nodes.node(node[property]);
-        var node_def = RED.nodes.getType(type);
+        var configNode = RED.nodes.node(nodeValue);
 
         if (configNode) {
-            label = RED.utils.getNodeLabel(configNode,configNode.id);
+            label = RED.utils.getNodeLabel(configNode, configNode.id);
         }
+
         input.val(label);
     }
 
@@ -34417,12 +35432,9 @@ RED.editor = (function() {
     }
 
     function defaultConfigNodeSort(A,B) {
-        if (A.__label__ < B.__label__) {
-            return -1;
-        } else if (A.__label__ > B.__label__) {
-            return 1;
-        }
-        return 0;
+        // sort case insensitive so that `[env] node-name` items are at the top and
+        // not mixed inbetween the the lower and upper case items
+        return (A.__label__ || '').localeCompare((B.__label__ || ''), undefined, {sensitivity: 'base'})
     }
 
     function updateConfigNodeSelect(name,type,value,prefix,filter) {
@@ -34437,7 +35449,7 @@ RED.editor = (function() {
                 }
                 $("#"+prefix+"-"+name).val(value);
             } else {
-
+                let inclSubflowEnvvars = false
                 var select = $("#"+prefix+"-"+name);
                 var node_def = RED.nodes.getType(type);
                 select.children().remove();
@@ -34445,6 +35457,7 @@ RED.editor = (function() {
                 var activeWorkspace = RED.nodes.workspace(RED.workspaces.active());
                 if (!activeWorkspace) {
                     activeWorkspace = RED.nodes.subflow(RED.workspaces.active());
+                    inclSubflowEnvvars = true
                 }
 
                 var configNodes = [];
@@ -34460,6 +35473,31 @@ RED.editor = (function() {
                         }
                     }
                 });
+ 
+                // as includeSubflowEnvvars is true, this is a subflow.
+                // include any 'conf-types' env vars as a list of avaiable configs
+                // in the config dropdown as `[env] node-name`
+                if (inclSubflowEnvvars && activeWorkspace.env) {
+                    const parentEnv = activeWorkspace.env.filter(env => env.ui?.type === 'conf-types' && env.type === type)
+                    if (parentEnv && parentEnv.length > 0) {
+                        const locale = RED.i18n.lang()
+                        for (let i = 0; i < parentEnv.length; i++) {
+                            const tenv = parentEnv[i]
+                            const ui = tenv.ui || {}
+                            const labels = ui.label || {}
+                            const labelText = RED.editor.envVarList.lookupLabel(labels, labels["en-US"] || tenv.name, locale)
+                            const config = {
+                                env: tenv,
+                                id: '${' + parentEnv[0].name + '}',
+                                type: type,
+                                label: labelText,
+                                __label__: `[env] ${labelText}`
+                            }
+                            configNodes.push(config)
+                        }
+                    }
+                }
+
                 var configSortFn = defaultConfigNodeSort;
                 if (typeof node_def.sort == "function") {
                     configSortFn = node_def.sort;
@@ -34471,7 +35509,10 @@ RED.editor = (function() {
                 }
 
                 configNodes.forEach(function(cn) {
-                    $('<option value="'+cn.id+'"'+(value==cn.id?" selected":"")+'></option>').text(RED.text.bidi.enforceTextDirectionWithUCC(cn.__label__)).appendTo(select);
+                    const option = $('<option value="'+cn.id+'"'+(value==cn.id?" selected":"")+'></option>').text(RED.text.bidi.enforceTextDirectionWithUCC(cn.__label__)).appendTo(select);
+                    if (cn.env) {
+                        option.data('env', cn.env) // set a data attribute to indicate this is an env var (to inhibit the edit button)
+                    }
                     delete cn.__label__;
                 });
 
@@ -34484,7 +35525,12 @@ RED.editor = (function() {
                     }
                 }
 
-                select.append('<option value="_ADD_"'+(value===""?" selected":"")+'>'+RED._("editor.addNewType", {type:label})+'</option>');
+                if (!configNodes.length) {
+                    select.append('<option value="_ADD_" selected>' + RED._("editor.addNewType", { type: label }) + '</option>');
+                } else {
+                    select.append('<option value="">' + RED._("editor.inputs.none") + '</option>');
+                }
+
                 window.setTimeout(function() { select.trigger("change");},50);
             }
         }
@@ -35132,9 +36178,16 @@ RED.editor = (function() {
                     }
                     RED.tray.close(function() {
                         var filter = null;
-                        if (editContext && typeof editContext._def.defaults[configProperty].filter === 'function') {
-                            filter = function(n) {
-                                return editContext._def.defaults[configProperty].filter.call(editContext,n);
+                        // when editing a config via subflow edit panel, the `configProperty` will not
+                        // necessarily be a property of the editContext._def.defaults object
+                        // Also, when editing via dashboard sidebar, editContext can be null
+                        // so we need to guard both scenarios
+                        if (editContext?._def) {
+                            const isSubflow = (editContext._def.type === 'subflow' || /subflow:.*/.test(editContext._def.type))
+                            if (editContext && !isSubflow && typeof editContext._def.defaults?.[configProperty]?.filter === 'function') {
+                                filter = function(n) {
+                                    return editContext._def.defaults[configProperty].filter.call(editContext,n);
+                                }
                             }
                         }
                         updateConfigNodeSelect(configProperty,configType,editing_config_node.id,prefix,filter);
@@ -35195,7 +36248,7 @@ RED.editor = (function() {
                     RED.history.push(historyEvent);
                     RED.tray.close(function() {
                         var filter = null;
-                        if (editContext && typeof editContext._def.defaults[configProperty].filter === 'function') {
+                        if (editContext && typeof editContext._def.defaults[configProperty]?.filter === 'function') {
                             filter = function(n) {
                                 return editContext._def.defaults[configProperty].filter.call(editContext,n);
                             }
@@ -35736,6 +36789,7 @@ RED.editor = (function() {
             }
         },
         editBuffer: function(options) { showTypeEditor("_buffer", options) },
+        getEditStack: function () { return [...editStack] },
         buildEditForm: buildEditForm,
         validateNode: validateNode,
         updateNodeProperties: updateNodeProperties,
@@ -35780,7 +36834,8 @@ RED.editor = (function() {
                 filteredEditPanes[type] = filter
             }
             editPanes[type] = definition;
-        }
+        },
+        prepareConfigNodeSelect: prepareConfigNodeSelect,
     }
 })();
 ;;(function() {
@@ -37434,8 +38489,9 @@ RED.editor = (function() {
 ;RED.editor.envVarList = (function() {
 
     var currentLocale = 'en-US';
-    var DEFAULT_ENV_TYPE_LIST = ['str','num','bool','json','bin','env'];
-    var DEFAULT_ENV_TYPE_LIST_INC_CRED = ['str','num','bool','json','bin','env','cred','jsonata'];
+    const DEFAULT_ENV_TYPE_LIST = ['str','num','bool','json','bin','env'];
+    const DEFAULT_ENV_TYPE_LIST_INC_CONFTYPES = ['str','num','bool','json','bin','env','conf-types'];
+    const DEFAULT_ENV_TYPE_LIST_INC_CRED = ['str','num','bool','json','bin','env','cred','jsonata'];
 
     /**
      * Create env var edit interface
@@ -37443,8 +38499,8 @@ RED.editor = (function() {
      * @param node - subflow node
      */
     function buildPropertiesList(envContainer, node) {
-
-        var isTemplateNode = (node.type === "subflow");
+        if(RED.editor.envVarList.debug) { console.log('envVarList: buildPropertiesList', envContainer, node) }
+        const isTemplateNode = (node.type === "subflow");
 
         envContainer
             .css({
@@ -37516,7 +38572,14 @@ RED.editor = (function() {
                         // if `opt.ui` does not exist, then apply defaults. If these
                         // defaults do not change then they will get stripped off
                         // before saving.
-                        if (opt.type === 'cred') {
+                        if (opt.type === 'conf-types') {
+                            opt.ui = opt.ui || {
+                                icon: "fa fa-cog",
+                                type: "conf-types",
+                                opts: {opts:[]}
+                            }
+                            opt.ui.type = "conf-types";
+                        } else if (opt.type === 'cred') {
                             opt.ui = opt.ui || {
                                 icon: "",
                                 type: "cred"
@@ -37552,7 +38615,7 @@ RED.editor = (function() {
                             }
                         });
 
-                        buildEnvEditRow(uiRow, opt.ui, nameField, valueField);
+                        buildEnvEditRow(uiRow, opt, nameField, valueField);
                         nameField.trigger('change');
                     }
                 },
@@ -37614,21 +38677,23 @@ RED.editor = (function() {
      * @param nameField - name field of env var
      * @param valueField - value field of env var
      */
-     function buildEnvEditRow(container, ui, nameField, valueField) {
+     function buildEnvEditRow(container, opt, nameField, valueField) {
+        const ui = opt.ui
+        if(RED.editor.envVarList.debug) { console.log('envVarList: buildEnvEditRow', container, ui, nameField, valueField) }
          container.addClass("red-ui-editor-subflow-env-ui-row")
          var topRow = $('<div></div>').appendTo(container);
          $('<div></div>').appendTo(topRow);
          $('<div>').text(RED._("editor.icon")).appendTo(topRow);
          $('<div>').text(RED._("editor.label")).appendTo(topRow);
-         $('<div>').text(RED._("editor.inputType")).appendTo(topRow);
+         $('<div class="red-env-ui-input-type-col">').text(RED._("editor.inputType")).appendTo(topRow);
 
          var row = $('<div></div>').appendTo(container);
          $('<div><i class="red-ui-editableList-item-handle fa fa-bars"></i></div>').appendTo(row);
          var typeOptions = {
-             'input': {types:DEFAULT_ENV_TYPE_LIST},
-             'select': {opts:[]},
-             'spinner': {},
-             'cred': {}
+            'input': {types:DEFAULT_ENV_TYPE_LIST_INC_CONFTYPES},
+            'select': {opts:[]},
+            'spinner': {},
+            'cred': {}
          };
          if (ui.opts) {
              typeOptions[ui.type] = ui.opts;
@@ -37693,15 +38758,16 @@ RED.editor = (function() {
             labelInput.attr("placeholder",$(this).val())
         });
 
-        var inputCell = $('<div></div>').appendTo(row);
-        var inputCellInput = $('<input type="text">').css("width","100%").appendTo(inputCell);
+        var inputCell = $('<div class="red-env-ui-input-type-col"></div>').appendTo(row);
+        var uiInputTypeInput = $('<input type="text">').css("width","100%").appendTo(inputCell);
         if (ui.type === "input") {
-            inputCellInput.val(ui.opts.types.join(","));
+            uiInputTypeInput.val(ui.opts.types.join(","));
         }
         var checkbox;
         var selectBox;
 
-        inputCellInput.typedInput({
+        // the options presented in the UI section for an "input" type selection
+        uiInputTypeInput.typedInput({
             types: [
                 {
                     value:"input",
@@ -37862,7 +38928,7 @@ RED.editor = (function() {
                                         }
                                     });
                                     ui.opts.opts = vals;
-                                    inputCellInput.typedInput('value',Date.now())
+                                    uiInputTypeInput.typedInput('value',Date.now())
                                 }
                             }
                         }
@@ -37929,12 +38995,13 @@ RED.editor = (function() {
                                     } else {
                                         delete ui.opts.max;
                                     }
-                                    inputCellInput.typedInput('value',Date.now())
+                                    uiInputTypeInput.typedInput('value',Date.now())
                                 }
                             }
                         }
                     }
                 },
+                'conf-types',
                 {
                     value:"none",
                     label:RED._("editor.inputs.none"), icon:"fa fa-times",hasValue:false
@@ -37952,14 +39019,20 @@ RED.editor = (function() {
                 // In the case of 'input' type, the typedInput uses the multiple-option
                 // mode. Its value needs to be set to a comma-separately list of the
                 // selected options.
-                inputCellInput.typedInput('value',ui.opts.types.join(","))
+                uiInputTypeInput.typedInput('value',ui.opts.types.join(","))
+            } else if (ui.type === 'conf-types') {
+                // In the case of 'conf-types' type, the typedInput will be populated
+                // with a list of all config nodes types installed.
+                // Restore the value to the last selected type
+                uiInputTypeInput.typedInput('value', opt.type)
             } else {
                 // No other type cares about `value`, but doing this will
                 // force a refresh of the label now that `ui.opts` has
                 // been updated.
-                inputCellInput.typedInput('value',Date.now())
+                uiInputTypeInput.typedInput('value',Date.now())
             }
 
+            if(RED.editor.envVarList.debug) { console.log('envVarList: inputCellInput on:typedinputtypechange. ui.type = ' + ui.type) }
             switch (ui.type) {
                 case 'input':
                     valueField.typedInput('types',ui.opts.types);
@@ -37977,7 +39050,7 @@ RED.editor = (function() {
                     valueField.typedInput('types',['cred']);
                     break;
                 default:
-                    valueField.typedInput('types',DEFAULT_ENV_TYPE_LIST)
+                    valueField.typedInput('types', DEFAULT_ENV_TYPE_LIST);
             }
             if (ui.type === 'checkbox') {
                 valueField.typedInput('type','bool');
@@ -37989,8 +39062,46 @@ RED.editor = (function() {
             }
 
         }).on("change", function(evt,type) {
-            if (ui.type === 'input') {
-                var types = inputCellInput.typedInput('value');
+            const selectedType = $(this).typedInput('type') // the UI typedInput type
+            if(RED.editor.envVarList.debug) { console.log('envVarList: inputCellInput on:change. selectedType = ' + selectedType) }
+            if (selectedType === 'conf-types') {
+                const selectedConfigType = $(this).typedInput('value') || opt.type
+                let activeWorkspace = RED.nodes.workspace(RED.workspaces.active());
+                if (!activeWorkspace) {
+                    activeWorkspace = RED.nodes.subflow(RED.workspaces.active());
+                }
+
+                // get a list of all config nodes matching the selectedValue
+                const configNodes = [];
+                RED.nodes.eachConfig(function(config) {
+                    if (config.type == selectedConfigType && (!config.z || config.z === activeWorkspace.id)) {
+                        const modulePath = config._def?.set?.id || ''
+                        let label = RED.utils.getNodeLabel(config, config.id) || config.id;
+                        label += config.d ? ' ['+RED._('workspace.disabled')+']' : '';
+                        const _config = {
+                            _type: selectedConfigType,
+                            value: config.id,
+                            label: label,
+                            title: modulePath ? modulePath + ' - ' + label : label,
+                            enabled: config.d !== true,
+                            disabled: config.d === true,
+                        }
+                        configNodes.push(_config);
+                    }
+                });
+                const tiTypes = {
+                    value: selectedConfigType,
+                    label: "config",
+                    icon: "fa fa-cog",
+                    options: configNodes,
+                }
+                valueField.typedInput('types', [tiTypes]);
+                valueField.typedInput('type', selectedConfigType);
+                valueField.typedInput('value', opt.value);
+
+
+            } else if (ui.type === 'input') {
+                var types = uiInputTypeInput.typedInput('value');
                 ui.opts.types = (types === "") ? ["str"] : types.split(",");
                 valueField.typedInput('types',ui.opts.types);
             }
@@ -38002,7 +39113,7 @@ RED.editor = (function() {
         })
         // Set the input to the right type. This will trigger the 'typedinputtypechange'
         // event handler (just above ^^) to update the value if needed
-        inputCellInput.typedInput('type',ui.type)
+        uiInputTypeInput.typedInput('type',ui.type)
     }
 
     function setLocale(l, list) {
@@ -40529,7 +41640,7 @@ RED.editor.codeEditor.monaco = (function() {
                     createMonacoCompletionItem("set (flow context)", 'flow.set("${1:name}", ${1:value});','Set a value in flow context',range),
                     createMonacoCompletionItem("get (global context)", 'global.get("${1:name}");','Get a value from global context',range),
                     createMonacoCompletionItem("set (global context)", 'global.set("${1:name}", ${1:value});','Set a value in global context',range),
-                    createMonacoCompletionItem("get (env)", 'env.get("${1|NR_NODE_ID,NR_NODE_NAME,NR_NODE_PATH,NR_GROUP_ID,NR_GROUP_NAME,NR_FLOW_ID,NR_FLOW_NAME|}");','Get env variable value',range),
+                    createMonacoCompletionItem("get (env)", 'env.get("${1|NR_NODE_ID,NR_NODE_NAME,NR_NODE_PATH,NR_GROUP_ID,NR_GROUP_NAME,NR_FLOW_ID,NR_FLOW_NAME,NR_SUBFLOW_NAME,NR_SUBFLOW_ID,NR_SUBFLOW_PATH|}");','Get env variable value',range),
                     createMonacoCompletionItem("cloneMessage (RED.util)", 'RED.util.cloneMessage(${1:msg});',
                         ["```typescript",
                         "RED.util.cloneMessage<T extends registry.NodeMessage>(msg: T): T",
@@ -41784,6 +42895,7 @@ RED.eventLog = (function() {
                 setTimeout(function() {
                     oldTray.tray.detach();
                     showTray(options);
+                    RED.events.emit('editor:change')
                 },250)
             } else {
                 if (stack.length > 0) {
@@ -41853,6 +42965,7 @@ RED.eventLog = (function() {
                         RED.view.focus();
                     } else {
                         stack[stack.length-1].tray.css("z-index", "auto");
+                        RED.events.emit('editor:change')
                     }
                 },250)
             }
@@ -46935,17 +48048,19 @@ RED.subflow = (function() {
 
 
     /**
-     * Create interface for controlling env var UI definition
+     * Build the edit dialog for a subflow template (creating/modifying a subflow template)
+     * @param {Object} uiContainer - the jQuery container for the environment variable list
+     * @param {Object} node - the subflow template node
      */
-    function buildEnvControl(envList,node) {
+    function buildEnvControl(uiContainer,node) {
         var tabs = RED.tabs.create({
             id: "subflow-env-tabs",
             onchange: function(tab) {
                 if (tab.id === "subflow-env-tab-preview") {
                     var inputContainer = $("#subflow-input-ui");
-                    var list = envList.editableList("items");
+                    var list = uiContainer.editableList("items");
                     var exportedEnv = exportEnvList(list, true);
-                    buildEnvUI(inputContainer, exportedEnv,node);
+                    buildEnvUI(inputContainer, exportedEnv, node);
                 }
                 $("#subflow-env-tabs-content").children().hide();
                 $("#" + tab.id).show();
@@ -46983,12 +48098,33 @@ RED.subflow = (function() {
         RED.editor.envVarList.setLocale(locale);
     }
 
-
-    function buildEnvUIRow(row, tenv, ui, node) {
+    /**
+     * Build a UI row for a subflow instance environment variable
+     * Also used to build the UI row for subflow template preview
+     * @param {JQuery} row - A form row element
+     * @param {Object} tenv - A template environment variable
+     * @param {String} tenv.name - The name of the environment variable
+     * @param {String} tenv.type - The type of the environment variable
+     * @param {String} tenv.value - The value set for this environment variable
+     * @param {Object} tenv.parent - The parent environment variable
+     * @param {String} tenv.parent.value - The value set for the parent environment variable
+     * @param {String} tenv.parent.type - The type of the parent environment variable
+     * @param {Object} tenv.ui - The UI configuration for the environment variable
+     * @param {String} tenv.ui.icon - The icon for the environment variable
+     * @param {Object} tenv.ui.label - The label for the environment variable
+     * @param {String} tenv.ui.type - The type of the UI control for the environment variable
+     * @param {Object} node - The subflow instance node
+     */
+    function buildEnvUIRow(row, tenv, node) {
+        if(RED.subflow.debug) { console.log("buildEnvUIRow", tenv) }
+        const ui = tenv.ui || {}
         ui.label = ui.label||{};
         if ((tenv.type === "cred" || (tenv.parent && tenv.parent.type === "cred")) && !ui.type) {
             ui.type = "cred";
             ui.opts = {};
+        } else if (tenv.type === "conf-types") {
+            ui.type = "conf-types"
+            ui.opts = { types: ['conf-types'] }
         } else if (!ui.type) {
             ui.type = "input";
             ui.opts = { types: RED.editor.envVarList.DEFAULT_ENV_TYPE_LIST }
@@ -47032,9 +48168,10 @@ RED.subflow = (function() {
         if (tenv.hasOwnProperty('type')) {
             val.type = tenv.type;
         }
+        const elId = getSubflowEnvPropertyName(tenv.name)
         switch(ui.type) {
             case "input":
-                input = $('<input type="text">').css('width','70%').appendTo(row);
+                input = $('<input type="text">').css('width','70%').attr('id', elId).appendTo(row);
                 if (ui.opts.types && ui.opts.types.length > 0) {
                     var inputType = val.type;
                     if (ui.opts.types.indexOf(inputType) === -1) {
@@ -47061,7 +48198,7 @@ RED.subflow = (function() {
                 }
                 break;
             case "select":
-                input = $('<select>').css('width','70%').appendTo(row);
+                input = $('<select>').css('width','70%').attr('id', elId).appendTo(row);
                 if (ui.opts.opts) {
                     ui.opts.opts.forEach(function(o) {
                         $('<option>').val(o.v).text(RED.editor.envVarList.lookupLabel(o.l, o.l['en-US']||o.v, locale)).appendTo(input);
@@ -47072,7 +48209,7 @@ RED.subflow = (function() {
             case "checkbox":
                 label.css("cursor","default");
                 var cblabel = $('<label>').css('width','70%').appendTo(row);
-                input = $('<input type="checkbox">').css({
+                input = $('<input type="checkbox">').attr('id', elId).css({
                     marginTop: 0,
                     width: 'auto',
                     height: '34px'
@@ -47090,7 +48227,7 @@ RED.subflow = (function() {
                 input.prop("checked",boolVal);
                 break;
             case "spinner":
-                input = $('<input>').css('width','70%').appendTo(row);
+                input = $('<input>').css('width','70%').attr('id', elId).appendTo(row);
                 var spinnerOpts = {};
                 if (ui.opts.hasOwnProperty('min')) {
                     spinnerOpts.min = ui.opts.min;
@@ -47119,18 +48256,25 @@ RED.subflow = (function() {
                     default: 'cred'
                 })
                 break;
-        }
-        if (input) {
-            input.attr('id',getSubflowEnvPropertyName(tenv.name))
+            case "conf-types":
+                // let clsId = 'config-node-input-' + val.type + '-' + val.value + '-' + Math.floor(Math.random() * 100000);
+                // clsId = clsId.replace(/\W/g, '-');
+                // input = $('<input>').css('width','70%').addClass(clsId).attr('id', elId).appendTo(row);
+                input = $('<input>').css('width','70%').attr('id', elId).appendTo(row);
+                const _type = tenv.parent?.type || tenv.type;
+                RED.editor.prepareConfigNodeSelect(node, tenv.name, _type, 'node-input-subflow-env', null, tenv);
+                break;
         }
     }
 
     /**
-     * Create environment variable input UI
+     * Build the edit form for a subflow instance
+     * Also used to build the preview form in the subflow template edit dialog
      * @param uiContainer - container for UI
      * @param envList - env var definitions of template
      */
     function buildEnvUI(uiContainer, envList, node) {
+        if(RED.subflow.debug) { console.log("buildEnvUI",envList) }
         uiContainer.empty();
         for (var i = 0; i < envList.length; i++) {
             var tenv = envList[i];
@@ -47138,7 +48282,7 @@ RED.subflow = (function() {
                 continue;
             }
             var row = $("<div/>", { class: "form-row" }).appendTo(uiContainer);
-            buildEnvUIRow(row,tenv, tenv.ui || {}, node);
+            buildEnvUIRow(row, tenv, node);
         }
     }
     // buildEnvUI
@@ -47211,6 +48355,9 @@ RED.subflow = (function() {
                                         delete ui.opts
                                     }
                                     break;
+                                case "conf-types":
+                                    delete ui.opts;
+                                    break;
                                 default:
                                     delete ui.opts;
                             }
@@ -47233,8 +48380,9 @@ RED.subflow = (function() {
         if (/^subflow:/.test(node.type)) {
             var subflowDef = RED.nodes.subflow(node.type.substring(8));
             if (subflowDef.env) {
-                subflowDef.env.forEach(function(env) {
+                subflowDef.env.forEach(function(env, i) {
                     var item = {
+                        index: i,
                         name:env.name,
                         parent: {
                             type: env.type,
@@ -47271,14 +48419,20 @@ RED.subflow = (function() {
                     var nodePropValue = nodeProp;
                     if (prop.ui && prop.ui.type === "cred") {
                         nodePropType = "cred";
+                    } else if (prop.ui && prop.ui.type === "conf-types") {
+                        nodePropType = prop.value.type
                     } else {
                         switch(typeof nodeProp) {
                             case "string": nodePropType = "str"; break;
                             case "number": nodePropType = "num"; break;
                             case "boolean": nodePropType = "bool"; nodePropValue = nodeProp?"true":"false"; break;
                             default:
-                            nodePropType = nodeProp.type;
-                            nodePropValue = nodeProp.value;
+                                if (nodeProp) {
+                                    nodePropType = nodeProp.type;
+                                    nodePropValue = nodeProp.value;
+                                } else {
+                                    nodePropType = 'str'
+                                }
                         }
                     }
                     var item = {
@@ -47299,6 +48453,7 @@ RED.subflow = (function() {
     }
 
     function exportSubflowInstanceEnv(node) {
+        if(RED.subflow.debug) { console.log("exportSubflowInstanceEnv",node) }
         var env = [];
         // First, get the values for the SubflowTemplate defined properties
         //  - these are the ones with custom UI elements
@@ -47345,6 +48500,9 @@ RED.subflow = (function() {
                         item.type = 'bool';
                         item.value = ""+input.prop("checked");
                         break;
+                    case "conf-types":
+                        item.value = input.val()
+                        item.type = data.parent.value;
                 }
                 if (ui.type === "cred" || item.type !== data.parent.type || item.value !== data.parent.value) {
                     env.push(item);
@@ -47358,8 +48516,15 @@ RED.subflow = (function() {
         return 'node-input-subflow-env-'+name.replace(/[^a-z0-9-_]/ig,"_");
     }
 
-    // Called by subflow.oneditprepare for both instances and templates
+    
+    /**
+     * Build the subflow edit form
+     * Called by subflow.oneditprepare for both instances and templates
+     * @param {"subflow"|"subflow-template"} type - the type of subflow being edited
+     * @param {Object} node - the node being edited
+     */
     function buildEditForm(type,node) {
+        if(RED.subflow.debug) { console.log("buildEditForm",type,node) }
         if (type === "subflow-template") {
             // This is the tabbed UI that offers the env list - with UI options
             // plus the preview tab
@@ -55021,10 +56186,15 @@ RED.touch.radialMenu = (function() {
 
     function listTour() {
         return [
+            {
+                id: "4_0",
+                label: "4.0",
+                path: "./tours/welcome.js"
+            },
             {
                 id: "3_1",
                 label: "3.1",
-                path: "./tours/welcome.js"
+                path: "./tours/3.1/welcome.js"
             },
             {
                 id: "3_0",