@node-red/editor-client 3.0.1 → 3.1.0-beta.1

package/public/red/red.js

@@ -340,8 +340,35 @@ var RED = (function() {
                         RED.nodes.import(nodes.flows);
                         RED.nodes.dirty(false);
                         RED.view.redraw(true);
-                        if (/^#flow\/.+$/.test(currentHash)) {
-                            RED.workspaces.show(currentHash.substring(6),true);
+                        if (/^#(flow|node|group)\/.+$/.test(currentHash)) {
+                            const hashParts = currentHash.split('/')
+                            const showEditDialog = hashParts.length > 2 && hashParts[2] === 'edit'
+                            if (hashParts[0] === '#flow') {
+                                RED.workspaces.show(hashParts[1], true);
+                                if (showEditDialog) {
+                                    RED.workspaces.edit()
+                                }
+                            } else if (hashParts[0] === '#node') {
+                                const nodeToShow = RED.nodes.node(hashParts[1])
+                                if (nodeToShow) {
+                                    setTimeout(() => {
+                                        RED.view.reveal(nodeToShow.id)
+                                        window.location.hash = currentHash
+                                        if (showEditDialog) {
+                                            RED.editor.edit(nodeToShow)
+                                        }
+                                    }, 50)
+                                }
+                            } else if (hashParts[0] === '#group') {
+                                const nodeToShow = RED.nodes.group(hashParts[1])
+                                if (nodeToShow) {
+                                    RED.view.reveal(nodeToShow.id)
+                                    window.location.hash = currentHash
+                                    if (showEditDialog) {
+                                        RED.editor.editGroup(nodeToShow)
+                                    }
+                                }
+                            }
                         }
                         if (RED.workspaces.count() > 0) {
                             const hiddenTabs = JSON.parse(RED.settings.getLocal("hiddenTabs")||"{}");
@@ -412,6 +439,8 @@ var RED = (function() {
                         loader.end()
                         RED.notify($("<p>").text(message));
                         RED.sidebar.info.refresh()
+                        RED.menu.setDisabled('menu-item-projects-open',false);
+                        RED.menu.setDisabled('menu-item-projects-settings',false);
                     });
                 });
                 return;
@@ -732,11 +761,6 @@ var RED = (function() {
         ]});
 
         menuOptions.push({id:"menu-item-arrange-menu", label:RED._("menu.label.arrange"), options: [
-            {id: "menu-item-view-tools-move-to-back", label:RED._("menu.label.moveToBack"), disabled: true, onselect: "core:move-selection-to-back"},
-            {id: "menu-item-view-tools-move-to-front", label:RED._("menu.label.moveToFront"), disabled: true, onselect: "core:move-selection-to-front"},
-            {id: "menu-item-view-tools-move-backwards", label:RED._("menu.label.moveBackwards"), disabled: true, onselect: "core:move-selection-backwards"},
-            {id: "menu-item-view-tools-move-forwards", label:RED._("menu.label.moveForwards"), disabled: true, onselect: "core:move-selection-forwards"},
-            null,
             {id: "menu-item-view-tools-align-left", label:RED._("menu.label.alignLeft"), disabled: true, onselect: "core:align-selection-to-left"},
             {id: "menu-item-view-tools-align-center", label:RED._("menu.label.alignCenter"), disabled: true, onselect: "core:align-selection-to-center"},
             {id: "menu-item-view-tools-align-right", label:RED._("menu.label.alignRight"), disabled: true, onselect: "core:align-selection-to-right"},
@@ -746,7 +770,12 @@ var RED = (function() {
             {id: "menu-item-view-tools-align-bottom", label:RED._("menu.label.alignBottom"), disabled: true, onselect: "core:align-selection-to-bottom"},
             null,
             {id: "menu-item-view-tools-distribute-horizontally", label:RED._("menu.label.distributeHorizontally"), disabled: true, onselect: "core:distribute-selection-horizontally"},
-            {id: "menu-item-view-tools-distribute-veritcally", label:RED._("menu.label.distributeVertically"), disabled: true, onselect: "core:distribute-selection-vertically"}
+            {id: "menu-item-view-tools-distribute-veritcally", label:RED._("menu.label.distributeVertically"), disabled: true, onselect: "core:distribute-selection-vertically"},
+            null,
+            {id: "menu-item-view-tools-move-to-back", label:RED._("menu.label.moveToBack"), disabled: true, onselect: "core:move-selection-to-back"},
+            {id: "menu-item-view-tools-move-to-front", label:RED._("menu.label.moveToFront"), disabled: true, onselect: "core:move-selection-to-front"},
+            {id: "menu-item-view-tools-move-backwards", label:RED._("menu.label.moveBackwards"), disabled: true, onselect: "core:move-selection-backwards"},
+            {id: "menu-item-view-tools-move-forwards", label:RED._("menu.label.moveForwards"), disabled: true, onselect: "core:move-selection-forwards"}
         ]});
 
         menuOptions.push(null);
@@ -839,6 +868,7 @@ var RED = (function() {
         RED.deploy.init(RED.settings.theme("deployButton",null));
 
         RED.keyboard.init(buildMainMenu);
+        RED.envVar.init();
 
         RED.nodes.init();
         RED.runtime.init()
@@ -3681,7 +3711,6 @@ RED.state = {
  * @namespace RED.nodes
 */
 RED.nodes = (function() {
-
     var PORT_TYPE_INPUT = 1;
     var PORT_TYPE_OUTPUT = 0;
 
@@ -3725,6 +3754,7 @@ RED.nodes = (function() {
             defaults: {
                 label: {value:""},
                 disabled: {value: false},
+                locked: {value: false},
                 info: {value: ""},
                 env: {value: []}
             }
@@ -4237,15 +4267,48 @@ RED.nodes = (function() {
         }
     }
 
+    const nodeProxyHandler = {
+        get(node, prop) {
+            if (prop === '__isProxy__') {
+                return true
+            } else if (prop == '__node__') {
+                return node
+            }
+            return node[prop]
+        },
+        set(node, prop, value) {
+            if (node.z && (RED.nodes.workspace(node.z)?.locked || RED.nodes.subflow(node.z)?.locked)) {
+                if (
+                    node._def.defaults[prop] ||
+                    prop === 'z' ||
+                    prop === 'l' ||
+                    prop === 'd' ||
+                    (prop === 'changed' && (!!node.changed) !== (!!value)) || // jshint ignore:line
+                    ((prop === 'x' || prop === 'y') && !node.resize && node.type !== 'group')
+                ) {
+                    throw new Error(`Cannot modified property '${prop}' of locked object '${node.type}:${node.id}'`)
+                }
+            }
+            node[prop] = value;
+            return true
+        }
+    }
 
     function addNode(n) {
+        let newNode
+        if (!n.__isProxy__) {
+            newNode = new Proxy(n, nodeProxyHandler)
+        } else {
+            newNode = n
+        }
+
         if (n.type.indexOf("subflow") !== 0) {
             n["_"] = n._def._;
         } else {
             var subflowId = n.type.substring(8);
             var sf = RED.nodes.subflow(subflowId);
             if (sf) {
-                sf.instances.push(sf);
+                sf.instances.push(newNode);
             }
             n["_"] = RED._;
         }
@@ -4262,12 +4325,13 @@ RED.nodes = (function() {
                 });
                 n.i = nextId+1;
             }
-            allNodes.addNode(n);
+            allNodes.addNode(newNode);
             if (!nodeLinks[n.id]) {
                 nodeLinks[n.id] = {in:[],out:[]};
             }
         }
-        RED.events.emit('nodes:add',n);
+        RED.events.emit('nodes:add',newNode);
+        return newNode
     }
     function addLink(l) {
         if (nodeLinks[l.source.id]) {
@@ -4530,14 +4594,7 @@ RED.nodes = (function() {
             var node;
 
             if (allNodes.hasTab(id)) {
-                removedNodes = allNodes.getNodes(id).filter(n => {
-                    if (n.type === 'junction') {
-                        removedJunctions.push(n)
-                        return false
-                    } else {
-                        return true
-                    }
-                })
+                removedNodes = allNodes.getNodes(id).slice()
             }
             for (i in configNodes) {
                 if (configNodes.hasOwnProperty(i)) {
@@ -4547,6 +4604,7 @@ RED.nodes = (function() {
                     }
                 }
             }
+            removedJunctions = RED.nodes.junctions(id)
 
             for (i=0;i<removedNodes.length;i++) {
                 var result = removeNode(removedNodes[i].id);
@@ -4714,6 +4772,9 @@ RED.nodes = (function() {
         node.type = n.type;
         for (var d in n._def.defaults) {
             if (n._def.defaults.hasOwnProperty(d)) {
+                if (d === 'locked' && !n.locked) {
+                    continue
+                }
                 node[d] = n[d];
             }
         }
@@ -4993,7 +5054,6 @@ RED.nodes = (function() {
         } else {
             nodeSet = [sf];
         }
-        console.log(nodeSet);
         return createExportableNodeSet(nodeSet);
     }
     /**
@@ -5029,6 +5089,10 @@ RED.nodes = (function() {
                             exportedConfigNodes[n.id] = true;
                         }
                     });
+
+                    subflowSet = subflowSet.concat(RED.nodes.junctions(subflowId))
+                    subflowSet = subflowSet.concat(RED.nodes.groups(subflowId))
+
                     var exportableSubflow = createExportableNodeSet(subflowSet, exportedIds, exportedSubflows, exportedConfigNodes);
                     nns = exportableSubflow.concat(nns);
                 }
@@ -5630,7 +5694,7 @@ RED.nodes = (function() {
                         }
                     }
                 } else {
-                    const keepNodesCurrentZ = reimport && n.z && RED.workspaces.contains(n.z)
+                    const keepNodesCurrentZ = reimport && n.z && (RED.workspaces.contains(n.z) || RED.nodes.subflow(n.z))
                     if (!keepNodesCurrentZ && n.z && !workspace_map[n.z] && !subflow_map[n.z]) {
                         n.z = activeWorkspace;
                     }
@@ -5732,7 +5796,7 @@ RED.nodes = (function() {
                         node.id = getID();
                     } else {
                         node.id = n.id;
-                        const keepNodesCurrentZ = reimport && node.z && RED.workspaces.contains(node.z)
+                        const keepNodesCurrentZ = reimport && node.z && (RED.workspaces.contains(node.z) || RED.nodes.subflow(node.z))
                         if (!keepNodesCurrentZ && (node.z == null || (!workspace_map[node.z] && !subflow_map[node.z]))) {
                             if (createMissingWorkspace) {
                                 if (missingWorkspace === null) {
@@ -5980,19 +6044,6 @@ RED.nodes = (function() {
             if (n.g && !new_group_set.has(n.g)) {
                 delete n.g;
             }
-            n.nodes = n.nodes.map(function(id) {
-                return node_map[id];
-            })
-            // Just in case the group references a node that doesn't exist for some reason
-            n.nodes = n.nodes.filter(function(v) {
-                if (v) {
-                    // Repair any nodes that have forgotten they are in this group
-                    if (v.g !== n.id) {
-                        v.g = n.id;
-                    }
-                }
-                return !!v
-            });
             if (!n.g) {
                 groupDepthMap[n.id] = 0;
             }
@@ -6015,21 +6066,22 @@ RED.nodes = (function() {
             return groupDepthMap[A.id] - groupDepthMap[B.id];
         });
         for (i=0;i<new_groups.length;i++) {
-            n = new_groups[i];
-            addGroup(n);
+            new_groups[i] = addGroup(new_groups[i]);
+            node_map[new_groups[i].id] = new_groups[i]
         }
 
         for (i=0;i<new_junctions.length;i++) {
-            var junction = new_junctions[i];
-            addJunction(junction);
+            new_junctions[i] = addJunction(new_junctions[i]);
+            node_map[new_junctions[i].id] = new_junctions[i]
         }
 
 
         // Now the nodes have been fully updated, add them.
         for (i=0;i<new_nodes.length;i++) {
-            var node = new_nodes[i];
-            addNode(node);
+            new_nodes[i] = addNode(new_nodes[i])
+            node_map[new_nodes[i].id] = new_nodes[i]
         }
+
         // Finally validate them all.
         // This has to be done after everything is added so that any checks for
         // dependent config nodes will pass
@@ -6037,6 +6089,39 @@ RED.nodes = (function() {
             var node = new_nodes[i];
             RED.editor.validateNode(node);
         }
+        const lookupNode = (id) => {
+            const mappedNode = node_map[id]
+            if (!mappedNode) {
+                return null
+            }
+            if (mappedNode.__isProxy__) {
+                return mappedNode
+            } else {
+                return node_map[mappedNode.id]
+            }
+        }
+        // Update groups to reference proxy node objects
+        for (i=0;i<new_groups.length;i++) {
+            n = new_groups[i];
+            // bypass the proxy in case the flow is locked
+            n.__node__.nodes = n.nodes.map(lookupNode)
+            // Just in case the group references a node that doesn't exist for some reason
+            n.__node__.nodes = n.nodes.filter(function(v) {
+                if (v) {
+                    // Repair any nodes that have forgotten they are in this group
+                    if (v.g !== n.id) {
+                        v.g = n.id;
+                    }
+                }
+                return !!v
+            });
+        }
+
+        // Update links to use proxy node objects
+        for (i=0;i<new_links.length;i++) {
+            new_links[i].source = lookupNode(new_links[i].source.id) || new_links[i].source
+            new_links[i].target = lookupNode(new_links[i].target.id) || new_links[i].target
+        }
 
         RED.workspaces.refresh();
 
@@ -6165,11 +6250,17 @@ RED.nodes = (function() {
         junctions = {};
         junctionsByZ = {};
 
+        var workspaceIds = Object.keys(workspaces);
+        // Ensure all workspaces are unlocked so we don't get any edit-protection
+        // preventing removal
+        workspaceIds.forEach(function(id) {
+            workspaces[id].locked = false
+        });
+
         var subflowIds = Object.keys(subflows);
         subflowIds.forEach(function(id) {
             RED.subflow.removeSubflow(id)
         });
-        var workspaceIds = Object.keys(workspaces);
         workspaceIds.forEach(function(id) {
             RED.workspaces.remove(workspaces[id]);
         });
@@ -6190,10 +6281,14 @@ RED.nodes = (function() {
     }
 
     function addGroup(group) {
+        if (!group.__isProxy__) {
+            group = new Proxy(group, nodeProxyHandler)
+        }
         groupsByZ[group.z] = groupsByZ[group.z] || [];
         groupsByZ[group.z].push(group);
         groups[group.id] = group;
         RED.events.emit("groups:add",group);
+        return group
     }
     function removeGroup(group) {
         var i = groupsByZ[group.z].indexOf(group);
@@ -6214,6 +6309,9 @@ RED.nodes = (function() {
     }
 
     function addJunction(junction) {
+        if (!junction.__isProxy__) {
+            junction = new Proxy(junction, nodeProxyHandler)
+        }
         junctionsByZ[junction.z] = junctionsByZ[junction.z] || []
         junctionsByZ[junction.z].push(junction)
         junctions[junction.id] = junction;
@@ -6221,6 +6319,7 @@ RED.nodes = (function() {
             nodeLinks[junction.id] = {in:[],out:[]};
         }
         RED.events.emit("junctions:add", junction)
+        return junction
     }
     function removeJunction(junction) {
         var i = junctionsByZ[junction.z].indexOf(junction)
@@ -6405,6 +6504,7 @@ RED.nodes = (function() {
                     }
                 });
 
+                const nodeGroupMap = {}
                 var replaceNodeIds = Object.keys(replaceNodes);
                 if (replaceNodeIds.length > 0) {
                     var reimportList = [];
@@ -6415,6 +6515,12 @@ RED.nodes = (function() {
                         } else {
                             allNodes.removeNode(n);
                         }
+                        if (n.g) {
+                            // reimporting a node *without* including its group object
+                            // will cause the g property to be cleared. Cache it
+                            // here so we can restore it
+                            nodeGroupMap[n.id] = n.g
+                        }
                         reimportList.push(convertNode(n));
                         RED.events.emit('nodes:remove',n);
                     });
@@ -6436,6 +6542,18 @@ RED.nodes = (function() {
                     var newNodeMap = {};
                     result.nodes.forEach(function(n) {
                         newNodeMap[n.id] = n;
+                        if (nodeGroupMap[n.id]) {
+                            // This node is in a group - need to substitute the
+                            // node reference inside the group
+                            n.g = nodeGroupMap[n.id]
+                            const group = RED.nodes.group(n.g)
+                            if (group) {
+                                var index = group.nodes.findIndex(gn => gn.id === n.id)
+                                if (index > -1) {
+                                    group.nodes[index] = n
+                                }
+                            }
+                        }
                     });
                     RED.nodes.eachLink(function(l) {
                         if (newNodeMap.hasOwnProperty(l.source.id)) {
@@ -6496,7 +6614,7 @@ RED.nodes = (function() {
         },
         addWorkspace: addWorkspace,
         removeWorkspace: removeWorkspace,
-        getWorkspaceOrder: function() { return workspacesOrder },
+        getWorkspaceOrder: function() { return [...workspacesOrder] },
         setWorkspaceOrder: function(order) { workspacesOrder = order; },
         workspace: getWorkspace,
 
@@ -7423,7 +7541,7 @@ RED.nodes.fontAwesome = (function() {
  * limitations under the License.
  **/
 
-/** 
+/**
  * An API for undo / redo history buffer
  * @namespace RED.history
 */
@@ -7843,7 +7961,9 @@ RED.history = (function() {
 
                 if (ev.node.type === 'tab' && ev.changes.hasOwnProperty('disabled')) {
                     $("#red-ui-tab-"+(ev.node.id.replace(".","-"))).toggleClass('red-ui-workspace-disabled',!!ev.node.disabled);
-                    $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled",!!ev.node.disabled);
+                }
+                if (ev.node.type === 'tab' && ev.changes.hasOwnProperty('locked')) {
+                    $("#red-ui-tab-"+(ev.node.id.replace(".","-"))).toggleClass('red-ui-workspace-locked',!!ev.node.locked);
                 }
                 if (ev.subflow) {
                     inverseEv.subflow = {};
@@ -8251,6 +8371,52 @@ RED.validators = {
         };
     }
 };
+;// Mermaid diagram stub library for on-demand dynamic loading
+// Will be overwritten after script loading by $.getScript
+var mermaid = (function () {
+    var enabled /* = undefined */;
+    
+    var initializing = false;
+    var initCalled = false;
+
+    function initialize(opt) {
+        if (enabled === undefined) {
+            if (RED.settings.markdownEditor &&
+                RED.settings.markdownEditor.mermaid) {
+                enabled = RED.settings.markdownEditor.mermaid.enabled;
+            }
+            else {
+                enabled = true;
+            }
+        }
+        if (enabled) {
+            initializing = true;
+            $.getScript("vendor/mermaid/mermaid.min.js",
+                        function (data, stat, jqxhr) {
+                            $(".mermaid").show();
+                            // invoke loaded mermaid API
+                            initializing = false; 
+                            mermaid.initialize(opt);
+                            if (initCalled) {
+                                mermaid.init();
+                                initCalled = false;
+                            }
+                        });
+        }
+    }
+
+    function init() {
+        if (initializing) {
+            $(".mermaid").hide();
+            initCalled = true;
+        }
+    }
+    
+    return {
+        initialize: initialize,
+        init: init,
+    };
+})();
 ;/**
  * Copyright JS Foundation and other contributors, http://js.foundation
  *
@@ -8349,6 +8515,37 @@ RED.utils = (function() {
         }
     }
 
+    var mermaidIsInitialized = false;
+    var mermaidIsEnabled /* = undefined */;
+
+    renderer.code = function (code, lang) {
+        if(lang === "mermaid") {
+            // mermaid diagram rendering 
+            if (mermaidIsEnabled === undefined) {
+                if (RED.settings.markdownEditor &&
+                    RED.settings.markdownEditor.mermaid) {
+                    mermaidIsEnabled = RED.settings.markdownEditor.mermaid.enabled;
+                }
+                else {
+                    mermaidIsEnabled = true;
+                }
+            }
+            if (mermaidIsEnabled) {
+                if (!mermaidIsInitialized) {
+                    mermaidIsInitialized = true;
+                    mermaid.initialize({startOnLoad:false});
+                }
+                return `<pre class='mermaid'>${code}</pre>`;
+            }
+            else {
+                return `<details><summary>${RED._("markdownEditor.mermaid.summary")}</summary><pre><code>${code}</code></pre></details>`;
+            }
+        }
+        else {
+            return "<pre><code>" +code +"</code></pre>";
+        }
+    };
+
     window._marked.setOptions({
         renderer: renderer,
         gfm: true,
@@ -9838,7 +10035,7 @@ RED.utils = (function() {
                 this.element.css("maxHeight",null);
             }
             if (this.options.height !== 'auto') {
-                this.uiContainer.css("overflow-y","scroll");
+                this.uiContainer.css("overflow-y","auto");
                 if (!isNaN(this.options.height)) {
                     this.uiHeight = this.options.height;
                 }
@@ -11285,8 +11482,8 @@ RED.menu = (function() {
 
             var link = $(linkContent).appendTo(item);
             opt.link = link;
-            if (typeof opt.onselect === 'string') {
-                var shortcut = RED.keyboard.getShortcut(opt.onselect);
+            if (typeof opt.onselect === 'string' || opt.shortcut) {
+                var shortcut = opt.shortcut || RED.keyboard.getShortcut(opt.onselect);
                 if (shortcut && shortcut.key) {
                     opt.shortcutSpan = $('<span class="red-ui-popover-key">'+RED.keyboard.formatKey(shortcut.key, true)+'</span>').appendTo(link.find(".red-ui-menu-label"));
                 }
@@ -12698,7 +12895,29 @@ RED.tabs = (function() {
             })
         }
 
-
+        if (options.contextmenu) {
+            wrapper.on('contextmenu', function(evt) {
+                let clickedTab
+                let target = evt.target
+                while(target.nodeName !== 'A' && target.nodeName !== 'UL' && target.nodeName !== 'BODY') {
+                    target = target.parentNode
+                }
+                if (target.nodeName === 'A') {
+                    const href = target.getAttribute('href')
+                    if (href) {
+                        clickedTab = tabs[href.slice(1)]
+                    }
+                }
+                evt.preventDefault()
+                evt.stopPropagation()
+                RED.contextMenu.show({
+                    x:evt.clientX-5,
+                    y:evt.clientY-5,
+                    options: options.contextmenu(clickedTab)
+                })
+                return false
+            })
+        }
 
         var scrollLeft;
         var scrollRight;
@@ -13364,19 +13583,19 @@ RED.tabs = (function() {
                         event.preventDefault();
                         removeTab(tab.id);
                     });
-                    RED.popover.tooltip(closeLink,RED._("workspace.hideFlow"));
-                }
-                if (tab.hideable) {
-                    li.addClass("red-ui-tabs-closeable")
-                    var closeLink = $("<a/>",{href:"#",class:"red-ui-tab-close red-ui-tab-hide"}).appendTo(li);
-                    closeLink.append('<i class="fa fa-eye" />');
-                    closeLink.append('<i class="fa fa-eye-slash" />');
-                    closeLink.on("click",function(event) {
-                        event.preventDefault();
-                        hideTab(tab.id);
-                    });
-                    RED.popover.tooltip(closeLink,RED._("workspace.hideFlow"));
-                }
+                    RED.popover.tooltip(closeLink,RED._("workspace.closeFlow"));
+                }
+                // if (tab.hideable) {
+                //     li.addClass("red-ui-tabs-closeable")
+                //     var closeLink = $("<a/>",{href:"#",class:"red-ui-tab-close red-ui-tab-hide"}).appendTo(li);
+                //     closeLink.append('<i class="fa fa-eye" />');
+                //     closeLink.append('<i class="fa fa-eye-slash" />');
+                //     closeLink.on("click",function(event) {
+                //         event.preventDefault();
+                //         hideTab(tab.id);
+                //     });
+                //     RED.popover.tooltip(closeLink,RED._("workspace.hideFlow"));
+                // }
 
                 var badges = $('<span class="red-ui-tabs-badges"></span>').appendTo(li);
                 if (options.onselect) {
@@ -13495,6 +13714,9 @@ RED.tabs = (function() {
             activeIndex: function() {
                 return ul.find("li.active").index()
             },
+            getTabIndex: function (id) {
+                return ul.find("a[href='#"+id+"']").parent().index()
+            },
             contains: function(id) {
                 return ul.find("a[href='#"+id+"']").length > 0;
             },
@@ -13897,7 +14119,7 @@ RED.stack = (function() {
         { value: "reset", source: ["delay","trigger","join","rbe"] },
         { value: "responseCookies", source: ["http request"] },
         { value: "responseTopic", source: ["mqtt"] },
-        { value: "responseURL", source: ["http request"] },
+        { value: "responseUrl", source: ["http request"] },
         { value: "restartTimeout", source: ["join"] },
         { value: "retain", source: ["mqtt"] },
         { value: "schema", source: ["json"] },
@@ -15933,6 +16155,11 @@ RED.deploy = (function() {
                 RED.notify('<p>' + RED._("deploy.successfulDeploy") + '</p>', "success");
             }
             RED.nodes.eachNode(function (node) {
+                const flow = node.z && (RED.nodes.workspace(node.z) || RED.nodes.subflow(node.z) || null);
+                const isLocked = flow ? flow.locked : false;
+                if (flow && isLocked) {
+                    flow.locked = false;
+                }
                 if (node.changed) {
                     node.dirty = true;
                     node.changed = false;
@@ -15944,6 +16171,9 @@ RED.deploy = (function() {
                 if (node.credentials) {
                     delete node.credentials;
                 }
+                if (flow && isLocked) {
+                    flow.locked = isLocked;
+                }
             });
             RED.nodes.eachConfig(function (confNode) {
                 confNode.changed = false;
@@ -18985,6 +19215,181 @@ RED.keyboard = (function() {
         enable: enable
     }
 
+})();
+;RED.envVar = (function() {
+    function saveEnvList(list) {
+        const items = list.editableList("items")
+        const new_env = [];
+        items.each(function (i,el) {
+            var data = el.data('data');
+            var item;
+            if (data.nameField && data.valueField) {
+                item = {
+                    name: data.nameField.val(),
+                    value: data.valueField.typedInput("value"),
+                    type: data.valueField.typedInput("type")
+                };
+                new_env.push(item);
+            }
+        });
+        return new_env;
+    }
+
+    function getGlobalConf(create) {
+        var gconf = null;
+        RED.nodes.eachConfig(function (conf) {
+            if (conf.type === "global-config") {
+                gconf = conf;
+            }
+        });
+        if ((gconf === null) && create) {
+            var cred = {
+                _ : {},
+                map: {}
+            };
+            gconf = {
+                id: RED.nodes.id(),
+                type: "global-config",
+                env: [],
+                name: "global-config",
+                label: "",
+                hasUsers: false,
+                users: [],
+                credentials: cred,
+                _def: RED.nodes.getType("global-config"),
+            };
+            RED.nodes.add(gconf);
+        }
+        return gconf;
+    }
+
+    function applyChanges(list) {
+        var gconf = getGlobalConf(false);
+        var new_env = [];
+        var items = list.editableList('items');
+        var credentials = gconf ? gconf.credentials : null;
+
+        if (!credentials) {
+            credentials = {
+                _ : {},
+                map: {}
+            };
+        }
+        items.each(function (i,el) {
+            var data = el.data('data');
+            if (data.nameField && data.valueField) {
+                var item = {
+                    name: data.nameField.val(),
+                    value: data.valueField.typedInput("value"),
+                    type: data.valueField.typedInput("type")
+                };
+                if (item.name.trim() !== "") {
+                    new_env.push(item);
+                    if ((item.type === "cred") && (item.value !== "__PWRD__")) {
+                        credentials.map[item.name] = item.value;
+                        credentials.map["has_"+item.name] = (item.value !== "");
+                        item.value = "__PWRD__";
+                    }
+                }
+            }
+        });
+        if (gconf === null) {
+            gconf = getGlobalConf(true);
+        }
+        if ((JSON.stringify(new_env) !== JSON.stringify(gconf.env)) ||
+            (JSON.stringify(credentials) !== JSON.stringify(gconf.credentials))) {
+            gconf.env = new_env;
+            gconf.credentials = credentials;
+            RED.nodes.dirty(true);
+        }
+    }
+
+    function getSettingsPane() {
+        var gconf = getGlobalConf(false);
+        var env = gconf ? gconf.env : [];
+        var cred = gconf ? gconf.credentials : null;
+        if (!cred) {
+            cred = {
+                _ : {},
+                map: {}
+            };
+        }
+
+        var pane = $("<div/>", {
+            id: "red-ui-settings-tab-envvar",
+            class: "form-horizontal"
+        });
+        var content = $("<div/>", {
+            class: "form-row node-input-env-container-row"
+        }).css({
+            "margin": "10px"
+        }).appendTo(pane);
+
+        var label = $("<label></label>").css({
+            width: "100%"
+        }).appendTo(content);
+        $("<i/>", {
+            class: "fa fa-list"
+        }).appendTo(label);
+        $("<span/>").text(" "+RED._("env-var.header")).appendTo(label);
+
+        var list = $("<ol/>", {
+            id: "node-input-env-container"
+        }).appendTo(content);
+        var node = {
+            type: "",
+            env: env,
+            credentials: cred.map,
+        };
+        RED.editor.envVarList.create(list, node);
+
+        var buttons = $("<div/>").css({
+            "text-align": "right",
+        }).appendTo(content);
+        var revertButton = $("<button/>", {
+            class: "red-ui-button"
+        }).css({
+        }).text(RED._("env-var.revert")).appendTo(buttons);
+
+        var items = saveEnvList(list);
+        revertButton.on("click", function (ev) {
+            list.editableList("empty");
+            list.editableList("addItems", items);
+        });
+
+        return pane;
+    }
+
+    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"),
+            get: getSettingsPane,
+            focus: function() {
+                var height = $("#red-ui-settings-tab-envvar").parent().height();
+                $("#node-input-env-container").editableList("height", (height -100));
+            },
+            close: function() {
+                var list = $("#node-input-env-container");
+                try {
+                    applyChanges(list);
+                }
+                catch (e) {
+                    console.log(e);
+                    console.log(e.stack);
+                }
+            }
+        });
+    }
+
+    return {
+        init: init,
+    };
+
 })();
 ;/**
  * Copyright JS Foundation and other contributors, http://js.foundation
@@ -19046,6 +19451,9 @@ RED.workspaces = (function() {
             if (!ws.closeable) {
                 ws.hideable = true;
             }
+            if (!ws.hasOwnProperty('locked')) {
+                ws.locked = false
+            }
             workspace_tabs.addTab(ws,targetIndex);
 
             var hiddenTabs = JSON.parse(RED.settings.getLocal("hiddenTabs")||"{}");
@@ -19063,6 +19471,7 @@ RED.workspaces = (function() {
                 type: "tab",
                 id: tabId,
                 disabled: false,
+                locked: false,
                 info: "",
                 label: RED._('workspace.defaultName',{number:workspaceIndex}),
                 env: [],
@@ -19087,6 +19496,9 @@ RED.workspaces = (function() {
         if (workspaceTabCount === 1) {
             return;
         }
+        if (ws.locked) {
+            return
+        }
         var workspaceOrder = RED.nodes.getWorkspaceOrder();
         ws._index = workspaceOrder.indexOf(ws.id);
         removeWorkspace(ws);
@@ -19107,13 +19519,206 @@ RED.workspaces = (function() {
                 RED.editor.editSubflow(subflow);
             }
         } else {
-            RED.editor.editFlow(workspace);
+            if (!workspace.locked) {
+                RED.editor.editFlow(workspace);
+            }
         }
     }
 
 
     var workspace_tabs;
     var workspaceTabCount = 0;
+
+    function getMenuItems(isMenuButton, tab) {
+        let hiddenFlows = new Set()
+        for (let i = 0; i < hideStack.length; i++) {
+            let ids = hideStack[i]
+            if (!Array.isArray(ids)) {
+                ids = [ids]
+            }
+            ids.forEach(id => {
+                if (RED.nodes.workspace(id)) {
+                    hiddenFlows.add(id)
+                }
+            })
+        }
+        const hiddenflowCount = hiddenFlows.size;
+        let activeWorkspace = tab || RED.nodes.workspace(RED.workspaces.active()) || RED.nodes.subflow(RED.workspaces.active())
+        let isFlowDisabled = activeWorkspace ? activeWorkspace.disabled : false
+        const currentTabs = workspace_tabs.listTabs();
+        let flowCount = 0;
+        currentTabs.forEach(tab => {
+            if (RED.nodes.workspace(tab)) {
+                flowCount++;
+            }
+        });
+
+        let isCurrentLocked = RED.workspaces.isActiveLocked()
+        if (tab) {
+            isCurrentLocked = tab.locked
+        }
+
+        var menuItems = []
+        if (isMenuButton) {
+            menuItems.push({
+                id:"red-ui-tabs-menu-option-search-flows",
+                label: RED._("workspace.listFlows"),
+                onselect: "core:list-flows"
+            },
+            {
+                id:"red-ui-tabs-menu-option-search-subflows",
+                label: RED._("workspace.listSubflows"),
+                onselect: "core:list-subflows"
+            },
+            null)
+        }
+        menuItems.push(
+            {
+                id:"red-ui-tabs-menu-option-add-flow",
+                label: RED._("workspace.addFlow"),
+                onselect: "core:add-flow"
+            }
+        )
+        if (isMenuButton || !!tab) {
+            menuItems.push(
+                {
+                    id:"red-ui-tabs-menu-option-add-flow-right",
+                    label: RED._("workspace.addFlowToRight"),
+                    shortcut: RED.keyboard.getShortcut("core:add-flow-to-right"),
+                    onselect: function() {
+                        RED.actions.invoke("core:add-flow-to-right", tab)
+                    }
+                },
+                null
+            )
+            if (activeWorkspace && activeWorkspace.type === 'tab') {
+                menuItems.push(
+                    isFlowDisabled ? {
+                        label: RED._("workspace.enableFlow"),
+                        shortcut: RED.keyboard.getShortcut("core:enable-flow"),
+                        onselect: function() {
+                            RED.actions.invoke("core:enable-flow", tab?tab.id:undefined)
+                        },
+                        disabled: isCurrentLocked
+                    } : {
+                        label: RED._("workspace.disableFlow"),
+                        shortcut: RED.keyboard.getShortcut("core:disable-flow"),
+                        onselect: function() {
+                            RED.actions.invoke("core:disable-flow", tab?tab.id:undefined)
+                        },
+                        disabled: isCurrentLocked
+                    },
+                    isCurrentLocked? {
+                        label: RED._("workspace.unlockFlow"),
+                        shortcut: RED.keyboard.getShortcut("core:unlock-flow"),
+                        onselect: function() {
+                            RED.actions.invoke('core:unlock-flow', tab?tab.id:undefined)
+                        }
+                    } : {
+                        label: RED._("workspace.lockFlow"),
+                        shortcut: RED.keyboard.getShortcut("core:lock-flow"),
+                        onselect: function() {
+                            RED.actions.invoke('core:lock-flow', tab?tab.id:undefined)
+                        }
+                    },
+                    null
+                )
+            }
+            const activeIndex = currentTabs.findIndex(id => (activeWorkspace && (id === activeWorkspace.id)));
+            menuItems.push(
+                {
+                    label: RED._("workspace.moveToStart"),
+                    shortcut: RED.keyboard.getShortcut("core:move-flow-to-start"),
+                    onselect: function() {
+                        RED.actions.invoke("core:move-flow-to-start", tab?tab.id:undefined)
+                    },
+                    disabled: activeIndex === 0
+                },
+                {
+                    label: RED._("workspace.moveToEnd"),
+                    shortcut: RED.keyboard.getShortcut("core:move-flow-to-end"),
+                    onselect: function() {
+                        RED.actions.invoke("core:move-flow-to-end", tab?tab.id:undefined)
+                    },
+                    disabled: activeIndex === currentTabs.length - 1
+                }
+            )
+        }
+        menuItems.push(null)
+        if (isMenuButton || !!tab) {
+            menuItems.push(
+                {
+                    id:"red-ui-tabs-menu-option-add-hide-flows",
+                    label: RED._("workspace.hideFlow"),
+                    shortcut: RED.keyboard.getShortcut("core:hide-flow"),
+                    onselect: function() {
+                        RED.actions.invoke("core:hide-flow", tab)
+                    }
+                },
+                {
+                    id:"red-ui-tabs-menu-option-add-hide-other-flows",
+                    label: RED._("workspace.hideOtherFlows"),
+                    shortcut: RED.keyboard.getShortcut("core:hide-other-flows"),
+                    onselect: function() {
+                        RED.actions.invoke("core:hide-other-flows", tab)
+                    }
+                }
+            )
+
+        }
+        
+        menuItems.push(
+            {
+                id:"red-ui-tabs-menu-option-add-hide-all-flows",
+                label: RED._("workspace.hideAllFlows"),
+                onselect: "core:hide-all-flows",
+                disabled: (hiddenflowCount === flowCount)
+            },
+            {
+                id:"red-ui-tabs-menu-option-add-show-all-flows",
+                disabled: hiddenflowCount === 0,
+                label: RED._("workspace.showAllFlows", { count: hiddenflowCount }),
+                onselect: "core:show-all-flows"
+            },
+            {
+                id:"red-ui-tabs-menu-option-add-show-last-flow",
+                disabled: hideStack.length === 0,
+                label: RED._("workspace.showLastHiddenFlow"),
+                onselect: "core:show-last-hidden-flow"
+            }
+        )
+        if (tab) {
+            menuItems.push(
+                null,
+                {
+                    label: RED._("common.label.delete"),
+                    onselect: function() {
+                        if (tab.type === 'tab') {
+                            RED.workspaces.delete(tab)
+                        } else if (tab.type === 'subflow') {
+                            RED.subflow.delete(tab.id)
+                        }
+                    },
+                    disabled: isCurrentLocked || (workspaceTabCount === 1)
+                },
+                {
+                    label: RED._("menu.label.export"),
+                    shortcut: RED.keyboard.getShortcut("core:show-export-dialog"),
+                    onselect: function() {
+                        RED.workspaces.show(tab.id)
+                        RED.actions.invoke('core:show-export-dialog', null, 'flow')
+                    }
+                }
+            )
+        }
+        // if (isMenuButton && hiddenflowCount > 0) {
+        //     menuItems.unshift({
+        //         label: RED._("workspace.hiddenFlows",{count: hiddenflowCount}),
+        //         onselect: "core:list-hidden-flows"
+        //     })
+        // }
+        return menuItems;
+    }
     function createWorkspaceTabs() {
         workspace_tabs = RED.tabs.create({
             id: "red-ui-workspace-tabs",
@@ -19125,8 +19730,9 @@ RED.workspaces = (function() {
                     $("#red-ui-workspace-chart").show();
                     activeWorkspace = tab.id;
                     window.location.hash = 'flow/'+tab.id;
-                    $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled",!!tab.disabled);
-                    } else {
+                    $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled", !!tab.disabled);
+                    $("#red-ui-workspace").toggleClass("red-ui-workspace-locked", !!tab.locked);
+                } else {
                     $("#red-ui-workspace-chart").hide();
                     activeWorkspace = 0;
                     window.location.hash = '';
@@ -19157,6 +19763,12 @@ RED.workspaces = (function() {
                 if (tab.disabled) {
                     $("#red-ui-tab-"+(tab.id.replace(".","-"))).addClass('red-ui-workspace-disabled');
                 }
+                $('<span class="red-ui-workspace-locked-icon"><i class="fa fa-lock"></i> </span>').prependTo("#red-ui-tab-"+(tab.id.replace(".","-"))+" .red-ui-tab-label");
+                if (tab.locked) {
+                    $("#red-ui-tab-"+(tab.id.replace(".","-"))).addClass('red-ui-workspace-locked');
+                }
+
+
                 RED.menu.setDisabled("menu-item-workspace-delete",activeWorkspace === 0 || workspaceTabCount <= 1);
                 if (workspaceTabCount === 1) {
                     showWorkspace();
@@ -19177,13 +19789,19 @@ RED.workspaces = (function() {
                 RED.history.push({
                     t:'reorder',
                     workspaces: {
-                        from:oldOrder,
-                        to:newOrder
+                        from: oldOrder,
+                        to: newOrder
                     },
                     dirty:RED.nodes.dirty()
                 });
-                RED.nodes.dirty(true);
-                setWorkspaceOrder(newOrder);
+                // Only mark flows dirty if flow-order has changed (excluding subflows)
+                const filteredOldOrder = oldOrder.filter(id => !!RED.nodes.workspace(id))
+                const filteredNewOrder = newOrder.filter(id => !!RED.nodes.workspace(id))
+
+                if (JSON.stringify(filteredOldOrder) !== JSON.stringify(filteredNewOrder)) {
+                    RED.nodes.dirty(true);
+                    setWorkspaceOrder(newOrder);
+                }
             },
             onselect: function(selectedTabs) {
                 RED.view.select(false)
@@ -19202,12 +19820,12 @@ RED.workspaces = (function() {
             },
             onhide: function(tab) {
                 hideStack.push(tab.id);
-
-                var hiddenTabs = JSON.parse(RED.settings.getLocal("hiddenTabs")||"{}");
-                hiddenTabs[tab.id] = true;
-                RED.settings.setLocal("hiddenTabs",JSON.stringify(hiddenTabs));
-
-                RED.events.emit("workspace:hide",{workspace: tab.id})
+                if (tab.type === "tab") {
+                    var hiddenTabs = JSON.parse(RED.settings.getLocal("hiddenTabs")||"{}");
+                    hiddenTabs[tab.id] = true;
+                    RED.settings.setLocal("hiddenTabs",JSON.stringify(hiddenTabs));
+                    RED.events.emit("workspace:hide",{workspace: tab.id})
+                }
             },
             onshow: function(tab) {
                 removeFromHideStack(tab.id);
@@ -19222,77 +19840,8 @@ RED.workspaces = (function() {
             scrollable: true,
             addButton: "core:add-flow",
             addButtonCaption: RED._("workspace.addFlow"),
-            menu: function() {
-                var menuItems = [
-                    {
-                        id:"red-ui-tabs-menu-option-search-flows",
-                        label: RED._("workspace.listFlows"),
-                        onselect: "core:list-flows"
-                    },
-                    {
-                        id:"red-ui-tabs-menu-option-search-subflows",
-                        label: RED._("workspace.listSubflows"),
-                        onselect: "core:list-subflows"
-                    },
-                    null,
-                    {
-                        id:"red-ui-tabs-menu-option-add-flow",
-                        label: RED._("workspace.addFlow"),
-                        onselect: "core:add-flow"
-                    },
-                    {
-                        id:"red-ui-tabs-menu-option-add-flow-right",
-                        label: RED._("workspace.addFlowToRight"),
-                        onselect: "core:add-flow-to-right"
-                    },
-                    null,
-                    {
-                        id:"red-ui-tabs-menu-option-add-hide-flows",
-                        label: RED._("workspace.hideFlow"),
-                        onselect: "core:hide-flow"
-                    },
-                    {
-                        id:"red-ui-tabs-menu-option-add-hide-other-flows",
-                        label: RED._("workspace.hideOtherFlows"),
-                        onselect: "core:hide-other-flows"
-                    },
-                    {
-                        id:"red-ui-tabs-menu-option-add-show-all-flows",
-                        label: RED._("workspace.showAllFlows"),
-                        onselect: "core:show-all-flows"
-                    },
-                    {
-                        id:"red-ui-tabs-menu-option-add-hide-all-flows",
-                        label: RED._("workspace.hideAllFlows"),
-                        onselect: "core:hide-all-flows"
-                    },
-                    {
-                        id:"red-ui-tabs-menu-option-add-show-last-flow",
-                        label: RED._("workspace.showLastHiddenFlow"),
-                        onselect: "core:show-last-hidden-flow"
-                    }
-                ]
-                let hiddenFlows = new Set()
-                for (let i = 0; i < hideStack.length; i++) {
-                    let ids = hideStack[i]
-                    if (!Array.isArray(ids)) {
-                        ids = [ids]
-                    }
-                    ids.forEach(id => {
-                        if (RED.nodes.workspace(id)) {
-                            hiddenFlows.add(id)
-                        }
-                    })
-                }
-                const flowCount = hiddenFlows.size;
-                if (flowCount > 0) {
-                    menuItems.unshift({
-                        label: RED._("workspace.hiddenFlows",{count: flowCount}),
-                        onselect: "core:list-hidden-flows"
-                    })
-                }
-                return menuItems;
-            }
+            menu: function() { return getMenuItems(true) },
+            contextmenu: function(tab) { return getMenuItems(false, tab) }
         });
         workspaceTabCount = 0;
     }
@@ -19343,16 +19892,33 @@ RED.workspaces = (function() {
         });
 
         RED.actions.add("core:add-flow",function(opts) { addWorkspace(undefined,undefined,opts?opts.index:undefined)});
-        RED.actions.add("core:add-flow-to-right",function(opts) { addWorkspace(undefined,undefined,workspace_tabs.activeIndex()+1)});
+        RED.actions.add("core:add-flow-to-right",function(workspace) {
+            let index
+            if (workspace) {
+                index = workspace_tabs.getTabIndex(workspace.id)+1
+            } else {
+                index = workspace_tabs.activeIndex()+1
+            }
+            addWorkspace(undefined,undefined,index)
+        });
         RED.actions.add("core:edit-flow",editWorkspace);
         RED.actions.add("core:remove-flow",removeWorkspace);
         RED.actions.add("core:enable-flow",enableWorkspace);
         RED.actions.add("core:disable-flow",disableWorkspace);
-
-        RED.actions.add("core:hide-flow", function() {
-            var selection = workspace_tabs.selection();
-            if (selection.length === 0) {
-                selection = [{id:activeWorkspace}]
+        RED.actions.add("core:lock-flow",lockWorkspace);
+        RED.actions.add("core:unlock-flow",unlockWorkspace);
+        RED.actions.add("core:move-flow-to-start", function(id) { moveWorkspace(id, 'start') });
+        RED.actions.add("core:move-flow-to-end", function(id) { moveWorkspace(id, 'end') });
+
+        RED.actions.add("core:hide-flow", function(workspace) {
+            let selection
+            if (workspace) {
+                selection = [workspace]
+            } else {
+                selection = workspace_tabs.selection();
+                if (selection.length === 0) {
+                    selection = [{id:activeWorkspace}]
+                }
             }
             var hiddenTabs = [];
             selection.forEach(function(ws) {
@@ -19366,10 +19932,15 @@ RED.workspaces = (function() {
             workspace_tabs.clearSelection();
         })
 
-        RED.actions.add("core:hide-other-flows", function() {
-            var selection = workspace_tabs.selection();
-            if (selection.length === 0) {
-                selection = [{id:activeWorkspace}]
+        RED.actions.add("core:hide-other-flows", function(workspace) {
+            let selection
+            if (workspace) {
+                selection = [workspace]
+            } else {
+                selection = workspace_tabs.selection();
+                if (selection.length === 0) {
+                    selection = [{id:activeWorkspace}]
+                }
             }
             var selected = new Set(selection.map(function(ws) { return ws.id }))
 
@@ -19474,7 +20045,7 @@ RED.workspaces = (function() {
     }
     function setWorkspaceState(id,disabled) {
         var workspace = RED.nodes.workspace(id||activeWorkspace);
-        if (!workspace) {
+        if (!workspace || workspace.locked) {
             return;
         }
         if (workspace.disabled !== disabled) {
@@ -19509,11 +20080,58 @@ RED.workspaces = (function() {
             }
         }
     }
+    function lockWorkspace(id) {
+        setWorkspaceLockState(id,true);
+    }
+    function unlockWorkspace(id) {
+        setWorkspaceLockState(id,false);
+    }
+    function setWorkspaceLockState(id,locked) {
+        var workspace = RED.nodes.workspace(id||activeWorkspace);
+        if (!workspace) {
+            return;
+        }
+        if (workspace.locked !== locked) {
+            var changes = { locked: workspace.locked };
+            workspace.locked = locked;
+            $("#red-ui-tab-"+(workspace.id.replace(".","-"))).toggleClass('red-ui-workspace-locked',!!workspace.locked);
+            if (!id || (id === activeWorkspace)) {
+                $("#red-ui-workspace").toggleClass("red-ui-workspace-locked",!!workspace.locked);
+            }
+            var historyEvent = {
+                t: "edit",
+                changes:changes,
+                node: workspace,
+                dirty: RED.nodes.dirty()
+            }
+            workspace.changed = true;
+            RED.history.push(historyEvent);
+            RED.events.emit("flows:change",workspace);
+            RED.nodes.dirty(true);
+            // RED.sidebar.config.refresh();
+            // var selection = RED.view.selection();
+            // if (!selection.nodes && !selection.links && workspace.id === activeWorkspace) {
+            //     RED.sidebar.info.refresh(workspace);
+            // }
+            // if (changes.hasOwnProperty('disabled')) {
+            //     RED.nodes.eachNode(function(n) {
+            //         if (n.z === workspace.id) {
+            //             n.dirty = true;
+            //         }
+            //     });
+            //     RED.view.redraw();
+            // }
+        }
+    }
 
     function removeWorkspace(ws) {
         if (!ws) {
-            deleteWorkspace(RED.nodes.workspace(activeWorkspace));
+            ws = RED.nodes.workspace(activeWorkspace)
+            if (ws && !ws.locked) {
+                deleteWorkspace(RED.nodes.workspace(activeWorkspace));
+            }
         } else {
+            if (ws.locked) { return }
             if (workspace_tabs.contains(ws.id)) {
                 workspace_tabs.removeTab(ws.id);
             }
@@ -19523,16 +20141,46 @@ RED.workspaces = (function() {
         }
     }
 
+    function moveWorkspace(id, direction) {
+        const workspace = RED.nodes.workspace(id||activeWorkspace) || RED.nodes.subflow(id||activeWorkspace);
+        if (!workspace) {
+            return;
+        }
+        const currentOrder = workspace_tabs.listTabs()
+        const oldOrder = [...currentOrder]
+        const currentIndex = currentOrder.findIndex(id => id === workspace.id)
+        currentOrder.splice(currentIndex, 1)
+        if (direction === 'start') {
+            currentOrder.unshift(workspace.id)
+        } else if (direction === 'end') {
+            currentOrder.push(workspace.id)
+        }
+        const newOrder = setWorkspaceOrder(currentOrder)
+        if (JSON.stringify(newOrder) !== JSON.stringify(oldOrder)) {
+            RED.history.push({
+                t:'reorder',
+                workspaces: {
+                    from:oldOrder,
+                    to:newOrder
+                },
+                dirty:RED.nodes.dirty()
+            });
+            const filteredOldOrder = oldOrder.filter(id => !!RED.nodes.workspace(id))
+            const filteredNewOrder = newOrder.filter(id => !!RED.nodes.workspace(id))
+            if (JSON.stringify(filteredOldOrder) !== JSON.stringify(filteredNewOrder)) {
+                RED.nodes.dirty(true);
+            }
+        }
+    }
     function setWorkspaceOrder(order) {
-        var newOrder = order.filter(function(id) {
-            return RED.nodes.workspace(id) !== undefined;
-        })
+        var newOrder = order.filter(id => !!RED.nodes.workspace(id))
         var currentOrder = RED.nodes.getWorkspaceOrder();
         if (JSON.stringify(newOrder) !== JSON.stringify(currentOrder)) {
             RED.nodes.setWorkspaceOrder(newOrder);
             RED.events.emit("flows:reorder",newOrder);
         }
         workspace_tabs.order(order);
+        return newOrder
     }
 
     function flashTab(tabId) {
@@ -19578,6 +20226,10 @@ RED.workspaces = (function() {
         active: function() {
             return activeWorkspace
         },
+        isActiveLocked: function() {
+            var ws = RED.nodes.workspace(activeWorkspace) || RED.nodes.subflow(activeWorkspace)
+            return ws && ws.locked
+        },
         selection: function() {
             return workspace_tabs.selection();
         },
@@ -19634,7 +20286,9 @@ RED.workspaces = (function() {
             workspace_tabs.resize();
         },
         enable: enableWorkspace,
-        disable: disableWorkspace
+        disable: disableWorkspace,
+        lock: lockWorkspace,
+        unlock: unlockWorkspace
     }
 })();
 ;/**
@@ -19744,6 +20398,7 @@ RED.view = (function() {
     var spliceTimer;
     var groupHoverTimer;
 
+    var activeFlowLocked = false;
     var activeSubflow = null;
     var activeNodes = [];
     var activeLinks = [];
@@ -19901,6 +20556,7 @@ RED.view = (function() {
             evt.preventDefault()
             evt.stopPropagation()
             RED.contextMenu.show({
+                type: 'workspace',
                 x:evt.clientX-5,
                 y:evt.clientY-5
             })
@@ -20100,8 +20756,19 @@ RED.view = (function() {
 
             activeSubflow = RED.nodes.subflow(event.workspace);
 
-            RED.menu.setDisabled("menu-item-workspace-edit", activeSubflow || event.workspace === 0);
-            RED.menu.setDisabled("menu-item-workspace-delete",event.workspace === 0 || RED.workspaces.count() == 1 || activeSubflow);
+            if (activeSubflow) {
+                activeFlowLocked = activeSubflow.locked
+            } else {
+                var activeWorkspace = RED.nodes.workspace(event.workspace)
+                if (activeWorkspace) {
+                    activeFlowLocked = activeWorkspace.locked
+                } else {
+                    activeFlowLocked = true
+                }
+            }
+
+            RED.menu.setDisabled("menu-item-workspace-edit", activeFlowLocked || activeSubflow || event.workspace === 0);
+            RED.menu.setDisabled("menu-item-workspace-delete",activeFlowLocked || event.workspace === 0 || RED.workspaces.count() == 1 || activeSubflow);
 
             if (workspaceScrollPositions[event.workspace]) {
                 chart.scrollLeft(workspaceScrollPositions[event.workspace].left);
@@ -20128,6 +20795,15 @@ RED.view = (function() {
             redraw();
         });
 
+        RED.events.on("flows:change", function(workspace) {
+            if (workspace.id === RED.workspaces.active()) {
+                activeFlowLocked = !!workspace.locked
+                $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled",!!workspace.disabled);
+                $("#red-ui-workspace").toggleClass("red-ui-workspace-locked",!!workspace.locked);
+
+            }
+        })
+
         RED.statusBar.add({
             id: "view-zoom-controls",
             align: "right",
@@ -20185,6 +20861,9 @@ RED.view = (function() {
         chart.droppable({
             accept:".red-ui-palette-node",
             drop: function( event, ui ) {
+                if (activeFlowLocked) {
+                    return
+                }
                 d3.event = event;
                 var selected_tool = $(ui.draggable[0]).attr("data-palette-type");
                 var result = createNode(selected_tool);
@@ -20192,9 +20871,7 @@ RED.view = (function() {
                     return;
                 }
                 var historyEvent = result.historyEvent;
-                var nn = result.node;
-
-                RED.nodes.add(nn);
+                var nn = RED.nodes.add(result.node);
 
                 var showLabel = RED.utils.getMessageProperty(RED.settings.get('editor'),"view.view-node-show-label");
                 if (showLabel !== undefined &&  (nn._def.hasOwnProperty("showLabel")?nn._def.showLabel:true) && !nn._def.defaults.hasOwnProperty("l")) {
@@ -20276,11 +20953,28 @@ RED.view = (function() {
 
                 var group = $(ui.helper).data("group");
                 if (group) {
+                    var oldX = group.x; 
+                    var oldY = group.y; 
                     RED.group.addToGroup(group, nn);
+                    var moveEvent = null;
+                    if ((group.x !== oldX) ||
+                        (group.y !== oldY)) {
+                        moveEvent = {
+                            t: "move",
+                            nodes: [{n: group,
+                                     ox: oldX, oy: oldY,
+                                     dx: group.x -oldX,
+                                     dy: group.y -oldY}],
+                            dirty: true
+                        };
+                    }
                     historyEvent = {
                         t: 'multi',
                         events: [historyEvent],
 
+                    };
+                    if (moveEvent) {
+                        historyEvent.events.push(moveEvent)
                     }
                     historyEvent.events.push({
                         t: "addToGroup",
@@ -20321,6 +21015,9 @@ RED.view = (function() {
         RED.actions.add("core:copy-selection-to-internal-clipboard",copySelection);
         RED.actions.add("core:cut-selection-to-internal-clipboard",function(){copySelection(true);deleteSelection();});
         RED.actions.add("core:paste-from-internal-clipboard",function(){
+            if (RED.workspaces.isActiveLocked()) {
+                return
+            }
             importNodes(clipboard,{generateIds: clipboardSource === 'copy', generateDefaultNames: clipboardSource === 'copy'});
         });
 
@@ -20329,22 +21026,27 @@ RED.view = (function() {
         RED.events.on("view:selection-changed", function(selection) {
             var hasSelection = (selection.nodes && selection.nodes.length > 0);
             var hasMultipleSelection = hasSelection && selection.nodes.length > 1;
-            RED.menu.setDisabled("menu-item-edit-cut",!hasSelection);
-            RED.menu.setDisabled("menu-item-edit-copy",!hasSelection);
-            RED.menu.setDisabled("menu-item-edit-select-connected",!hasSelection);
-            RED.menu.setDisabled("menu-item-view-tools-move-to-back",!hasSelection);
-            RED.menu.setDisabled("menu-item-view-tools-move-to-front",!hasSelection);
-            RED.menu.setDisabled("menu-item-view-tools-move-backwards",!hasSelection);
-            RED.menu.setDisabled("menu-item-view-tools-move-forwards",!hasSelection);
-
-            RED.menu.setDisabled("menu-item-view-tools-align-left",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-align-center",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-align-right",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-align-top",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-align-middle",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-align-bottom",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-distribute-horizontally",!hasMultipleSelection);
-            RED.menu.setDisabled("menu-item-view-tools-distribute-veritcally",!hasMultipleSelection);
+            var hasLinkSelected = selection.links && selection.links.length > 0;
+            var canEdit = !activeFlowLocked && hasSelection
+            var canEditMultiple = !activeFlowLocked && hasMultipleSelection
+            RED.menu.setDisabled("menu-item-edit-cut", !canEdit);
+            RED.menu.setDisabled("menu-item-edit-copy", !hasSelection);
+            RED.menu.setDisabled("menu-item-edit-select-connected", !hasSelection);
+            RED.menu.setDisabled("menu-item-view-tools-move-to-back", !canEdit);
+            RED.menu.setDisabled("menu-item-view-tools-move-to-front", !canEdit);
+            RED.menu.setDisabled("menu-item-view-tools-move-backwards", !canEdit);
+            RED.menu.setDisabled("menu-item-view-tools-move-forwards", !canEdit);
+
+            RED.menu.setDisabled("menu-item-view-tools-align-left", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-align-center", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-align-right", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-align-top", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-align-middle", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-align-bottom", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-distribute-horizontally", !canEditMultiple);
+            RED.menu.setDisabled("menu-item-view-tools-distribute-veritcally", !canEditMultiple);
+
+            RED.menu.setDisabled("menu-item-edit-split-wire-with-links", activeFlowLocked || !hasLinkSelected);
         })
 
         RED.actions.add("core:delete-selection",deleteSelection);
@@ -20734,7 +21436,7 @@ RED.view = (function() {
                             .attr("class", "nr-ui-view-lasso");
                         d3.event.preventDefault();
                     }
-                } else if (d3.event.altKey) {
+                } else if (d3.event.altKey && !activeFlowLocked) {
                     //Alt [+shift] held - Begin slicing
                     clearSelection();
                     mouse_mode = (d3.event.shiftKey) ? RED.state.SLICING_JUNCTION : RED.state.SLICING;
@@ -20748,6 +21450,9 @@ RED.view = (function() {
     }
 
     function showQuickAddDialog(options) {
+        if (activeFlowLocked) {
+            return
+        }
         options = options || {};
         var point = options.position || lastClickPosition;
         var spliceLink = options.splice;
@@ -20930,6 +21635,11 @@ RED.view = (function() {
                 if (showLabel !== undefined && (nn._def.hasOwnProperty("showLabel")?nn._def.showLabel:true) && !nn._def.defaults.hasOwnProperty("l")) {
                     nn.l = showLabel;
                 }
+                if (nn.type === 'junction') {
+                    nn = RED.nodes.addJunction(nn);
+                } else {
+                    nn = RED.nodes.add(nn);
+                }
                 if (quickAddLink) {
                     var drag_line = quickAddLink;
                     var src = null,dst,src_port;
@@ -21032,27 +21742,39 @@ RED.view = (function() {
                         }
                     }
                 }
-                if (nn.type === 'junction') {
-                    RED.nodes.addJunction(nn);
-                } else {
-                    RED.nodes.add(nn);
-                }
+
                 RED.editor.validateNode(nn);
 
                 if (targetGroup) {
+                    var oldX = targetGroup.x; 
+                    var oldY = targetGroup.y; 
                     RED.group.addToGroup(targetGroup, nn);
+                    var moveEvent = null;
+                    if ((targetGroup.x !== oldX) ||
+                        (targetGroup.y !== oldY)) {
+                        moveEvent = {
+                            t: "move",
+                            nodes: [{n: targetGroup,
+                                     ox: oldX, oy: oldY,
+                                     dx: targetGroup.x -oldX,
+                                     dy: targetGroup.y -oldY}],
+                            dirty: true
+                        };
+                    }
                     if (historyEvent.t !== "multi") {
                         historyEvent = {
                             t:'multi',
                             events: [historyEvent]
-                        }
+                        };
                     }
                     historyEvent.events.push({
                         t: "addToGroup",
                         group: targetGroup,
                         nodes: nn
-                    })
-
+                    });
+                    if (moveEvent) {
+                        historyEvent.events.push(moveEvent);
+                    }
                 }
 
                 if (spliceLink) {
@@ -21294,16 +22016,18 @@ RED.view = (function() {
             }
             var d = (mouse_offset[0]-mousePos[0])*(mouse_offset[0]-mousePos[0]) + (mouse_offset[1]-mousePos[1])*(mouse_offset[1]-mousePos[1]);
             if ((d > 3 && !dblClickPrimed) || (dblClickPrimed && d > 10)) {
-                mouse_mode = RED.state.MOVING_ACTIVE;
                 clickElapsed = 0;
-                spliceActive = false;
-                if (movingSet.length() === 1) {
-                    node = movingSet.get(0);
-                    spliceActive = node.n.hasOwnProperty("_def") &&
-                                   ((node.n.hasOwnProperty("inputs") && node.n.inputs > 0) || (!node.n.hasOwnProperty("inputs") && node.n._def.inputs > 0)) &&
-                                   ((node.n.hasOwnProperty("outputs") && node.n.outputs > 0) || (!node.n.hasOwnProperty("outputs") && node.n._def.outputs > 0)) &&
-                                   RED.nodes.filterLinks({ source: node.n }).length === 0 &&
-                                   RED.nodes.filterLinks({ target: node.n }).length === 0;
+                if (!activeFlowLocked) {
+                    mouse_mode = RED.state.MOVING_ACTIVE;
+                    spliceActive = false;
+                    if (movingSet.length() === 1) {
+                        node = movingSet.get(0);
+                        spliceActive = node.n.hasOwnProperty("_def") &&
+                                       ((node.n.hasOwnProperty("inputs") && node.n.inputs > 0) || (!node.n.hasOwnProperty("inputs") && node.n._def.inputs > 0)) &&
+                                       ((node.n.hasOwnProperty("outputs") && node.n.outputs > 0) || (!node.n.hasOwnProperty("outputs") && node.n._def.outputs > 0)) &&
+                                       RED.nodes.filterLinks({ source: node.n }).length === 0 &&
+                                       RED.nodes.filterLinks({ target: node.n }).length === 0;
+                    }
                 }
             }
         } else if (mouse_mode == RED.state.MOVING_ACTIVE || mouse_mode == RED.state.IMPORT_DRAGGING || mouse_mode == RED.state.DETACHED_DRAGGING) {
@@ -21388,6 +22112,7 @@ RED.view = (function() {
 
             // Check link splice or group-add
             if (movingSet.length() === 1 && movingSet.get(0).n.type !== "group") {
+            //}{//NIS
                 node = movingSet.get(0);
                 if (spliceActive) {
                     if (!spliceTimer) {
@@ -21747,11 +22472,25 @@ RED.view = (function() {
         if (mouse_mode == RED.state.MOVING_ACTIVE) {
             if (movingSet.length() > 0) {
                 var addedToGroup = null;
+                var moveEvent = null;
                 if (activeHoverGroup) {
+                    var oldX = activeHoverGroup.x; 
+                    var oldY = activeHoverGroup.y; 
                     for (var j=0;j<movingSet.length();j++) {
                         var n = movingSet.get(j);
                         RED.group.addToGroup(activeHoverGroup,n.n);
                     }
+                    if ((activeHoverGroup.x !== oldX) ||
+                        (activeHoverGroup.y !== oldY)) {
+                        moveEvent = {
+                            t: "move",
+                            nodes: [{n: activeHoverGroup,
+                                     ox: oldX, oy: oldY,
+                                     dx: activeHoverGroup.x -oldX,
+                                     dy: activeHoverGroup.y -oldY}],
+                            dirty: true
+                        };
+                    }
                     addedToGroup = activeHoverGroup;
 
                     activeHoverGroup.hovered = false;
@@ -21797,6 +22536,12 @@ RED.view = (function() {
                         historyEvent.addToGroup = addedToGroup;
                     }
                     RED.nodes.dirty(true);
+                    if (moveEvent) {
+                        historyEvent = {
+                            t: "multi",
+                            events: [moveEvent, historyEvent]
+                        };
+                    }
                     RED.history.push(historyEvent);
                 }
             }
@@ -22148,6 +22893,7 @@ RED.view = (function() {
     }
 
     function editSelection() {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (movingSet.length() > 0) {
             var node = movingSet.get(0).n;
             if (node.type === "subflow") {
@@ -22163,6 +22909,9 @@ RED.view = (function() {
         if (mouse_mode === RED.state.SELECTING_NODE) {
             return;
         }
+        if (activeFlowLocked) {
+            return
+        }
         if (portLabelHover) {
             portLabelHover.remove();
             portLabelHover = null;
@@ -22478,6 +23227,7 @@ RED.view = (function() {
 
 
     function detachSelectedNodes() {
+        if (RED.workspaces.isActiveLocked()) { return }
         var selection = RED.view.selection();
         if (selection.nodes) {
             const {newLinks, removedLinks} = RED.nodes.detachNodes(selection.nodes);
@@ -22619,7 +23369,7 @@ RED.view = (function() {
         mousedown_node = d;
         mousedown_port_type = portType;
         mousedown_port_index = portIndex || 0;
-        if (mouse_mode !== RED.state.QUICK_JOINING) {
+        if (mouse_mode !== RED.state.QUICK_JOINING && !activeFlowLocked) {
             mouse_mode = RED.state.JOINING;
             document.body.style.cursor = "crosshair";
             if (evt.ctrlKey || evt.metaKey) {
@@ -23059,6 +23809,14 @@ RED.view = (function() {
         }
         if (dblClickPrimed && mousedown_node == d && clickElapsed > 0 && clickElapsed < dblClickInterval) {
             mouse_mode = RED.state.DEFAULT;
+            if (RED.workspaces.isActiveLocked()) {
+                clickElapsed = 0;
+                d3.event.stopPropagation();
+                return
+            }
+            // Avoid dbl click causing text selection.
+            d3.event.preventDefault()
+            document.getSelection().removeAllRanges()
             if (d.type != "subflow") {
                 if (/^subflow:/.test(d.type) && (d3.event.ctrlKey || d3.event.metaKey)) {
                     RED.workspaces.show(d.type.substring(8));
@@ -23153,11 +23911,25 @@ RED.view = (function() {
                 updateActiveNodes();
             }
 
+            var moveEvent = null;
             if (activeHoverGroup) {
+                var oldX = activeHoverGroup.x; 
+                var oldY = activeHoverGroup.y; 
                 for (var j=0;j<movingSet.length();j++) {
                     var n = movingSet.get(j);
                     RED.group.addToGroup(activeHoverGroup,n.n);
                 }
+                if ((activeHoverGroup.x !== oldX) ||
+                    (activeHoverGroup.y !== oldY)) {
+                    moveEvent = {
+                        t: "move",
+                        nodes: [{n: activeHoverGroup,
+                                 ox: oldX, oy: oldY,
+                                 dx: activeHoverGroup.x -oldX,
+                                 dy: activeHoverGroup.y -oldY}],
+                        dirty: true
+                    };
+                }
                 historyEvent.addedToGroup = activeHoverGroup;
 
                 activeHoverGroup.hovered = false;
@@ -23166,7 +23938,6 @@ RED.view = (function() {
                 activeGroup.selected = true;
                 activeHoverGroup = null;
             }
-
             if (mouse_mode == RED.state.DETACHED_DRAGGING) {
                 var ns = [];
                 for (var j=0;j<movingSet.length();j++) {
@@ -23177,7 +23948,15 @@ RED.view = (function() {
                         n.n.moved = true;
                     }
                 }
-                RED.history.replace({t:"multi",events:[historyEvent,{t:"move",nodes:ns}],dirty: historyEvent.dirty})
+                var event = {t:"multi",events:[historyEvent,{t:"move",nodes:ns}],dirty: historyEvent.dirty};
+                if (moveEvent) {
+                    event.events.push(moveEvent);
+                }
+                RED.history.replace(event)
+            }
+            else if(moveEvent) {
+                var event = {t:"multi", events:[historyEvent, moveEvent], dirty: true};
+                RED.history.replace(event);
             }
 
             updateSelection();
@@ -23382,7 +24161,6 @@ RED.view = (function() {
             }
             // selectedLinks.clear();
             if (d3.event.button != 2) {
-                mouse_mode = RED.state.MOVING;
                 var mouse = d3.touches(this)[0]||d3.mouse(this);
                 mouse[0] += d.x-d.w/2;
                 mouse[1] += d.y-d.h/2;
@@ -23575,6 +24353,7 @@ RED.view = (function() {
         if (RED.view.DEBUG) {
             console.warn("groupMouseUp", { mouse_mode, event: d3.event });
         }
+        if (RED.workspaces.isActiveLocked()) { return }
         if (dblClickPrimed && mousedown_group == g && clickElapsed > 0 && clickElapsed < dblClickInterval) {
             mouse_mode = RED.state.DEFAULT;
             RED.editor.editGroup(g);
@@ -23745,7 +24524,7 @@ RED.view = (function() {
     function isButtonEnabled(d) {
         var buttonEnabled = true;
         var ws = RED.nodes.workspace(RED.workspaces.active());
-        if (ws && !ws.disabled && !d.d) {
+        if (ws && !ws.disabled && !d.d && !ws.locked) {
             if (d._def.button.hasOwnProperty('enabled')) {
                 if (typeof d._def.button.enabled === "function") {
                     buttonEnabled = d._def.button.enabled.call(d);
@@ -23768,7 +24547,7 @@ RED.view = (function() {
         }
         var activeWorkspace = RED.workspaces.active();
         var ws = RED.nodes.workspace(activeWorkspace);
-        if (ws && !ws.disabled && !d.d) {
+        if (ws && !ws.disabled && !d.d && !ws.locked) {
             if (d._def.button.toggle) {
                 d[d._def.button.toggle] = !d[d._def.button.toggle];
                 d.dirty = true;
@@ -23783,7 +24562,7 @@ RED.view = (function() {
             if (d.dirty) {
                 redraw();
             }
-        } else {
+        } else if (!ws || !ws.locked){
             if (activeSubflow) {
                 RED.notify(RED._("notification.warning", {message:RED._("notification.warnings.nodeActionDisabledSubflow")}),"warning");
             } else {
@@ -23798,14 +24577,15 @@ RED.view = (function() {
     function showTouchMenu(obj,pos) {
         var mdn = mousedown_node;
         var options = [];
-        options.push({name:"delete",disabled:(movingSet.length()===0 && selectedLinks.length() === 0),onselect:function() {deleteSelection();}});
-        options.push({name:"cut",disabled:(movingSet.length()===0),onselect:function() {copySelection(true);deleteSelection();}});
-        options.push({name:"copy",disabled:(movingSet.length()===0),onselect:function() {copySelection();}});
-        options.push({name:"paste",disabled:(clipboard.length===0),onselect:function() {importNodes(clipboard, {generateIds: true, touchImport: true});}});
-        options.push({name:"edit",disabled:(movingSet.length() != 1),onselect:function() { RED.editor.edit(mdn);}});
+        const isActiveLocked = RED.workspaces.isActiveLocked()
+        options.push({name:"delete",disabled:(isActiveLocked || movingSet.length()===0 && selectedLinks.length() === 0),onselect:function() {deleteSelection();}});
+        options.push({name:"cut",disabled:(isActiveLocked || movingSet.length()===0),onselect:function() {copySelection(true);deleteSelection();}});
+        options.push({name:"copy",disabled:(isActiveLocked || movingSet.length()===0),onselect:function() {copySelection();}});
+        options.push({name:"paste",disabled:(isActiveLocked || clipboard.length===0),onselect:function() {importNodes(clipboard, {generateIds: true, touchImport: true});}});
+        options.push({name:"edit",disabled:(isActiveLocked || movingSet.length() != 1),onselect:function() { RED.editor.edit(mdn);}});
         options.push({name:"select",onselect:function() {selectAll();}});
         options.push({name:"undo",disabled:(RED.history.depth() === 0),onselect:function() {RED.history.pop();}});
-        options.push({name:"add",onselect:function() {
+        options.push({name:"add",disabled:isActiveLocked, onselect:function() {
             chartPos = chart.offset();
             showQuickAddDialog({
                 position:[pos[0]-chartPos.left+chart.scrollLeft(),pos[1]-chartPos.top+chart.scrollTop()],
@@ -25296,7 +26076,24 @@ RED.view = (function() {
             if (activeSubflow) {
                 activeSubflowChanged = activeSubflow.changed;
             }
-            var result = RED.nodes.import(nodesToImport,{generateIds:options.generateIds, addFlow: addNewFlow, importMap: options.importMap});
+            var filteredNodesToImport = nodesToImport;
+            var globalConfig = null;
+            var gconf = null;
+
+            RED.nodes.eachConfig(function (conf) {
+                if (conf.type === "global-config") {
+                    gconf = conf;
+                }
+            });
+            if (gconf) {
+                filteredNodesToImport = nodesToImport.filter(function (n) {
+                    return (n.type !== "global-config");
+                });
+                globalConfig = nodesToImport.find(function (n) {
+                    return (n.type === "global-config");
+                });
+            }
+            var result = RED.nodes.import(filteredNodesToImport,{generateIds:options.generateIds, addFlow: addNewFlow, importMap: options.importMap});
             if (result) {
                 var new_nodes = result.nodes;
                 var new_links = result.links;
@@ -25428,6 +26225,50 @@ RED.view = (function() {
                     }
                 }
 
+                if (globalConfig) {
+                    // merge global env to existing global-config
+                    var env0 = gconf.env;
+                    var env1 = globalConfig.env;
+                    var newEnv = Array.from(env0);
+                    var changed = false;
+
+                    env1.forEach(function (item1) {
+                        var index = newEnv.findIndex(function (item0) {
+                            return (item0.name === item1.name);
+                        });
+                        if (index >= 0) {
+                            var item0 = newEnv[index];
+                            if ((item0.type !== item1.type) ||
+                                (item0.value !== item1.value)) {
+                                newEnv[index] = item1;
+                                changed = true;
+                            }
+                        }
+                        else {
+                            newEnv.push(item1);
+                            changed = true;
+                        }
+                    });
+                    if(changed) {
+                        gconf.env = newEnv;
+                        var replaceEvent = {
+                            t: "edit",
+                            node: gconf,
+                            changed: true,
+                            changes: {
+                                env: env0
+                            }
+                        };
+                        historyEvent = {
+                            t:"multi",
+                            events: [
+                                replaceEvent,
+                                historyEvent,
+                            ]
+                        };
+                    }
+                }
+
                 RED.history.push(historyEvent);
 
                 updateActiveNodes();
@@ -25503,6 +26344,9 @@ RED.view = (function() {
         if (mouse_mode === RED.state.SELECTING_NODE) {
             return;
         }
+        if (activeFlowLocked) {
+            return
+        }
         var workspaceSelection = RED.workspaces.selection();
         var changed = false;
         if (workspaceSelection.length > 0) {
@@ -25830,7 +26674,9 @@ RED.view = (function() {
                     if (node.z && (node.type === "group" || node._def.category !== 'config')) {
                         node.dirty = true;
                         RED.workspaces.show(node.z);
-
+                        if (node.type === "group" && !node.w && !node.h) {
+                            _redraw();
+                        }
                         var screenSize = [chart[0].clientWidth/scaleFactor,chart[0].clientHeight/scaleFactor];
                         var scrollPos = [chart.scrollLeft()/scaleFactor,chart.scrollTop()/scaleFactor];
                         var cx = node.x;
@@ -26293,7 +27139,7 @@ RED.view = (function() {
  **/
 
 RED.view.tools = (function() {
-
+    'use strict';
     function selectConnected(type) {
         var selection = RED.view.selection();
         var visited = new Set();
@@ -26317,6 +27163,9 @@ RED.view.tools = (function() {
     }
 
     function alignToGrid() {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
         if (selection.nodes) {
             var changedNodes = [];
@@ -26365,6 +27214,9 @@ RED.view.tools = (function() {
     }
 
     function moveSelection(dx,dy) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         if (moving_set === null) {
             moving_set = [];
             var selection = RED.view.selection();
@@ -26431,6 +27283,9 @@ RED.view.tools = (function() {
     }
 
     function setSelectedNodeLabelState(labelShown) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
         var historyEvents = [];
         var nodes = [];
@@ -26717,6 +27572,9 @@ RED.view.tools = (function() {
     }
 
     function alignSelectionToEdge(direction) {
+        // if (RED.workspaces.isActiveLocked()) {
+        //     return
+        // }
         var selection = RED.view.selection();
 
         if (selection.nodes && selection.nodes.length > 1) {
@@ -26817,8 +27675,10 @@ RED.view.tools = (function() {
         }
     }
 
-
     function distributeSelection(direction) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
 
         if (selection.nodes && selection.nodes.length > 2) {
@@ -26977,6 +27837,9 @@ RED.view.tools = (function() {
     }
 
     function reorderSelection(dir) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
         if (selection.nodes) {
             var nodesToMove = [];
@@ -27012,8 +27875,10 @@ RED.view.tools = (function() {
         }
     }
 
-
     function wireSeriesOfNodes() {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
         if (selection.nodes) {
             if (selection.nodes.length > 1) {
@@ -27054,6 +27919,9 @@ RED.view.tools = (function() {
     }
 
     function wireNodeToMultiple() {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
         if (selection.nodes) {
             if (selection.nodes.length > 1) {
@@ -27101,6 +27969,9 @@ RED.view.tools = (function() {
      * @param {Object || Object[]} wires The wire(s) to split and replace with link-out, link-in nodes.
      */
     function splitWiresWithLinkNodes(wires) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         let wiresToSplit = wires || (RED.view.selection().links && RED.view.selection().links.filter(e => !e.link));
         if (!wiresToSplit) {
             return
@@ -27155,7 +28026,6 @@ RED.view.tools = (function() {
             if(!nnLinkOut) {
                 const nLinkOut = RED.view.createNode("link out"); //create link node
                 nnLinkOut = nLinkOut.node;
-                nodeSrcMap[linkOutMapId] = nnLinkOut;
                 let yOffset = 0;
                 if(nSrc.outputs > 1) {
 
@@ -27170,7 +28040,8 @@ RED.view.tools = (function() {
                     updateNewNodePosXY(nSrc, nnLinkOut, false, RED.view.snapGrid, yOffset);
                 }
                 //add created node
-                RED.nodes.add(nnLinkOut);
+                nnLinkOut = RED.nodes.add(nnLinkOut);
+                nodeSrcMap[linkOutMapId] = nnLinkOut;
                 RED.editor.validateNode(nnLinkOut);
                 history.events.push(nLinkOut.historyEvent);
                 //connect node to link node
@@ -27191,10 +28062,10 @@ RED.view.tools = (function() {
             if(!nnLinkIn) {
                 const nLinkIn = RED.view.createNode("link in"); //create link node
                 nnLinkIn = nLinkIn.node;
-                nodeTrgMap[nTrg.id] = nnLinkIn;
                 updateNewNodePosXY(nTrg, nnLinkIn, true, RED.view.snapGrid, 0);
                 //add created node
-                RED.nodes.add(nnLinkIn);
+                nnLinkIn = RED.nodes.add(nnLinkIn);
+                nodeTrgMap[nTrg.id] = nnLinkIn;
                 RED.editor.validateNode(nnLinkIn);
                 history.events.push(nLinkIn.historyEvent);
                 //connect node to link node
@@ -27269,6 +28140,9 @@ RED.view.tools = (function() {
      * @param {{ renameBlank: boolean, renameClash: boolean, generateHistory: boolean }} options Possible options are `renameBlank`, `renameClash` and `generateHistory`
      */
     function generateNodeNames(node, options) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         options = Object.assign({
             renameBlank: true,
             renameClash: true,
@@ -27293,7 +28167,7 @@ RED.view.tools = (function() {
                 const nodeDef = n._def || RED.nodes.getType(n.type)
                 if (nodeDef && nodeDef.defaults && nodeDef.defaults.name) {
                     const paletteLabel = RED.utils.getPaletteLabel(n.type, nodeDef)
-                    const defaultNodeNameRE = new RegExp('^'+paletteLabel+' (\\d+)$')
+                    const defaultNodeNameRE = new RegExp('^'+paletteLabel.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')+' (\\d+)$')
                     if (!typeIndex.hasOwnProperty(n.type)) {
                         const existingNodes = RED.nodes.filterNodes({type: n.type})
                         let maxNameNumber = 0;
@@ -27339,6 +28213,9 @@ RED.view.tools = (function() {
     }
 
     function addJunctionsToWires(wires) {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         let wiresToSplit = wires || (RED.view.selection().links && RED.view.selection().links.filter(e => !e.link));
         if (!wiresToSplit) {
             return
@@ -27409,7 +28286,7 @@ RED.view.tools = (function() {
 
             var nodeGroups = new Set()
 
-            RED.nodes.addJunction(junction)
+            junction = RED.nodes.addJunction(junction)
             addedJunctions.push(junction)
             let newLink
             if (gid === links[0].source.id+":"+links[0].sourcePort) {
@@ -27470,6 +28347,30 @@ RED.view.tools = (function() {
         RED.view.redraw(true);
     }
 
+    function copyItemUrl(node, isEdit) {
+        if (!node) {
+            const selection = RED.view.selection();
+            if (selection.nodes && selection.nodes.length > 0) {
+                node = selection.nodes[0]
+            }
+        }
+        if (node) {
+            let thingType = 'node'
+            if (node.type === 'group') {
+                thingType = 'group'
+            } else if (node.type === 'tab' || node.type === 'subflow') {
+                thingType = 'flow'
+            }
+            let url = `${window.location.origin}${window.location.pathname}#${thingType}/${node.id}`
+            if (isEdit) {
+                url += '/edit'
+            }
+            if (RED.clipboard.copyText(url)) {
+                RED.notify(RED._("sidebar.info.copyURL2Clipboard"), { timeout: 2000 })
+            }
+        }
+    }
+
     return {
         init: function() {
             RED.actions.add("core:show-selected-node-labels", function() { setSelectedNodeLabelState(true); })
@@ -27536,6 +28437,9 @@ RED.view.tools = (function() {
 
             RED.actions.add("core:generate-node-names", generateNodeNames )
 
+            RED.actions.add("core:copy-item-url", function (node) { copyItemUrl(node) })
+            RED.actions.add("core:copy-item-edit-url", function (node) { copyItemUrl(node, true) })
+
             // RED.actions.add("core:add-node", function() { addNode() })
         },
         /**
@@ -28017,9 +28921,19 @@ RED.palette = (function() {
                     $('<button type="button" onclick="RED.workspaces.show(\''+type.substring(8).replace(/'/g,"\\'")+'\'); return false;" class="red-ui-button red-ui-button-small" style="float: right; margin-left: 5px;"><i class="fa fa-pencil"></i></button>').appendTo(popOverContent)
                 }
 
-                var safeType = type.replace(/'/g,"\\'");
+                const safeType = type.replace(/'/g,"\\'");
+                const wrapStr = function (str) {
+                    if(str.indexOf(' ') >= 0) {
+                        return '"' + str + '"'
+                    }
+                    return str
+                }
 
-                $('<button type="button" onclick="RED.search.show(\'type:'+safeType+'\'); return false;" class="red-ui-button red-ui-button-small" style="float: right; margin-left: 5px;"><i class="fa fa-search"></i></button>').appendTo(popOverContent)
+                $('<button type="button"; return false;" class="red-ui-button red-ui-button-small" style="float: right; margin-left: 5px;"><i class="fa fa-search"></i></button>')
+                    .appendTo(popOverContent)
+                    .on('click', function() {
+                        RED.search.show('type:' + wrapStr(safeType))
+                    })
                 $('<button type="button" onclick="RED.sidebar.help.show(\''+safeType+'\'); return false;" class="red-ui-button red-ui-button-small" style="float: right; margin-left: 5px;"><i class="fa fa-book"></i></button>').appendTo(popOverContent)
 
                 $('<p>',{style:"font-size: 0.8em"}).text(metaData).appendTo(popOverContent);
@@ -28124,6 +29038,7 @@ RED.palette = (function() {
             var hoverGroup;
             var paletteWidth;
             var paletteTop;
+            var dropEnabled;
             $(d).draggable({
                 helper: 'clone',
                 appendTo: '#red-ui-editor',
@@ -28131,6 +29046,7 @@ RED.palette = (function() {
                 revertDuration: 200,
                 containment:'#red-ui-main-container',
                 start: function() {
+                    dropEnabled = !(RED.nodes.workspace(RED.workspaces.active())?.locked);
                     paletteWidth = $("#red-ui-palette").width();
                     paletteTop = $("#red-ui-palette").parent().position().top + $("#red-ui-palette-container").position().top;
                     hoverGroup = null;
@@ -28141,96 +29057,100 @@ RED.palette = (function() {
                     RED.view.focus();
                 },
                 stop: function() {
-                    d3.select('.red-ui-flow-link-splice').classed('red-ui-flow-link-splice',false);
-                    if (hoverGroup) {
-                        document.getElementById("group_select_"+hoverGroup.id).classList.remove("red-ui-flow-group-hovered");
-                    }
-                    if (activeGroup) {
-                        document.getElementById("group_select_"+activeGroup.id).classList.remove("red-ui-flow-group-active-hovered");
+                    if (dropEnabled) {
+                        d3.select('.red-ui-flow-link-splice').classed('red-ui-flow-link-splice',false);
+                        if (hoverGroup) {
+                            document.getElementById("group_select_"+hoverGroup.id).classList.remove("red-ui-flow-group-hovered");
+                        }
+                        if (activeGroup) {
+                            document.getElementById("group_select_"+activeGroup.id).classList.remove("red-ui-flow-group-active-hovered");
+                        }
+                        if (spliceTimer) { clearTimeout(spliceTimer); spliceTimer = null; }
+                        if (groupTimer) { clearTimeout(groupTimer); groupTimer = null; }
                     }
-                    if (spliceTimer) { clearTimeout(spliceTimer); spliceTimer = null; }
-                    if (groupTimer) { clearTimeout(groupTimer); groupTimer = null; }
                 },
                 drag: function(e,ui) {
                     var paletteNode = getPaletteNode(nt);
                     ui.originalPosition.left = paletteNode.offset().left;
-                    mouseX = ui.position.left - paletteWidth + (ui.helper.width()/2) + chart.scrollLeft();
-                    mouseY = ui.position.top - paletteTop + (ui.helper.height()/2) + chart.scrollTop() + 10;
-                    if (!groupTimer) {
-                        groupTimer = setTimeout(function() {
-                            var mx = mouseX / RED.view.scale();
-                            var my = mouseY / RED.view.scale();
-                            var group = RED.view.getGroupAtPoint(mx,my);
-                            if (group !== hoverGroup) {
-                                if (hoverGroup) {
-                                    document.getElementById("group_select_"+hoverGroup.id).classList.remove("red-ui-flow-group-hovered");
-                                }
-                                if (group) {
-                                    document.getElementById("group_select_"+group.id).classList.add("red-ui-flow-group-hovered");
-                                }
-                                hoverGroup = group;
-                                if (hoverGroup) {
-                                    $(ui.helper).data('group',hoverGroup);
-                                } else {
-                                    $(ui.helper).removeData('group');
-                                }
-                            }
-                            groupTimer = null;
-
-                        },200)
-                    }
-                    if (def.inputs > 0 && def.outputs > 0) {
-                        if (!spliceTimer) {
-                            spliceTimer = setTimeout(function() {
-                                var nodes = [];
-                                var bestDistance = Infinity;
-                                var bestLink = null;
-                                if (chartSVG.getIntersectionList) {
-                                    var svgRect = chartSVG.createSVGRect();
-                                    svgRect.x = mouseX;
-                                    svgRect.y = mouseY;
-                                    svgRect.width = 1;
-                                    svgRect.height = 1;
-                                    nodes = chartSVG.getIntersectionList(svgRect,chartSVG);
-                                } else {
-                                    // Firefox doesn't do getIntersectionList and that
-                                    // makes us sad
-                                    nodes = RED.view.getLinksAtPoint(mouseX,mouseY);
-                                }
+                    if (dropEnabled) {
+                        mouseX = ui.position.left - paletteWidth + (ui.helper.width()/2) + chart.scrollLeft();
+                        mouseY = ui.position.top - paletteTop + (ui.helper.height()/2) + chart.scrollTop() + 10;
+                        if (!groupTimer) {
+                            groupTimer = setTimeout(function() {
                                 var mx = mouseX / RED.view.scale();
                                 var my = mouseY / RED.view.scale();
-                                for (var i=0;i<nodes.length;i++) {
-                                    var node = d3.select(nodes[i]);
-                                    if (node.classed('red-ui-flow-link-background') && !node.classed('red-ui-flow-link-link')) {
-                                        var length = nodes[i].getTotalLength();
-                                        for (var j=0;j<length;j+=10) {
-                                            var p = nodes[i].getPointAtLength(j);
-                                            var d2 = ((p.x-mx)*(p.x-mx))+((p.y-my)*(p.y-my));
-                                            if (d2 < 200 && d2 < bestDistance) {
-                                                bestDistance = d2;
-                                                bestLink = nodes[i];
+                                var group = RED.view.getGroupAtPoint(mx,my);
+                                if (group !== hoverGroup) {
+                                    if (hoverGroup) {
+                                        document.getElementById("group_select_"+hoverGroup.id).classList.remove("red-ui-flow-group-hovered");
+                                    }
+                                    if (group) {
+                                        document.getElementById("group_select_"+group.id).classList.add("red-ui-flow-group-hovered");
+                                    }
+                                    hoverGroup = group;
+                                    if (hoverGroup) {
+                                        $(ui.helper).data('group',hoverGroup);
+                                    } else {
+                                        $(ui.helper).removeData('group');
+                                    }
+                                }
+                                groupTimer = null;
+
+                            },200)
+                        }
+                        if (def.inputs > 0 && def.outputs > 0) {
+                            if (!spliceTimer) {
+                                spliceTimer = setTimeout(function() {
+                                    var nodes = [];
+                                    var bestDistance = Infinity;
+                                    var bestLink = null;
+                                    if (chartSVG.getIntersectionList) {
+                                        var svgRect = chartSVG.createSVGRect();
+                                        svgRect.x = mouseX;
+                                        svgRect.y = mouseY;
+                                        svgRect.width = 1;
+                                        svgRect.height = 1;
+                                        nodes = chartSVG.getIntersectionList(svgRect,chartSVG);
+                                    } else {
+                                        // Firefox doesn't do getIntersectionList and that
+                                        // makes us sad
+                                        nodes = RED.view.getLinksAtPoint(mouseX,mouseY);
+                                    }
+                                    var mx = mouseX / RED.view.scale();
+                                    var my = mouseY / RED.view.scale();
+                                    for (var i=0;i<nodes.length;i++) {
+                                        var node = d3.select(nodes[i]);
+                                        if (node.classed('red-ui-flow-link-background') && !node.classed('red-ui-flow-link-link')) {
+                                            var length = nodes[i].getTotalLength();
+                                            for (var j=0;j<length;j+=10) {
+                                                var p = nodes[i].getPointAtLength(j);
+                                                var d2 = ((p.x-mx)*(p.x-mx))+((p.y-my)*(p.y-my));
+                                                if (d2 < 200 && d2 < bestDistance) {
+                                                    bestDistance = d2;
+                                                    bestLink = nodes[i];
+                                                }
                                             }
                                         }
                                     }
-                                }
-                                if (activeSpliceLink && activeSpliceLink !== bestLink) {
-                                    d3.select(activeSpliceLink.parentNode).classed('red-ui-flow-link-splice',false);
-                                }
-                                if (bestLink) {
-                                    d3.select(bestLink.parentNode).classed('red-ui-flow-link-splice',true)
-                                } else {
-                                    d3.select('.red-ui-flow-link-splice').classed('red-ui-flow-link-splice',false);
-                                }
-                                if (activeSpliceLink !== bestLink) {
+                                    if (activeSpliceLink && activeSpliceLink !== bestLink) {
+                                        d3.select(activeSpliceLink.parentNode).classed('red-ui-flow-link-splice',false);
+                                    }
                                     if (bestLink) {
-                                        $(ui.helper).data('splice',d3.select(bestLink).data()[0]);
+                                        d3.select(bestLink.parentNode).classed('red-ui-flow-link-splice',true)
                                     } else {
-                                        $(ui.helper).removeData('splice');
+                                        d3.select('.red-ui-flow-link-splice').classed('red-ui-flow-link-splice',false);
                                     }
-                                }
-                                activeSpliceLink = bestLink;
-                                spliceTimer = null;
-                            },200);
+                                    if (activeSpliceLink !== bestLink) {
+                                        if (bestLink) {
+                                            $(ui.helper).data('splice',d3.select(bestLink).data()[0]);
+                                        } else {
+                                            $(ui.helper).removeData('splice');
+                                        }
+                                    }
+                                    activeSpliceLink = bestLink;
+                                    spliceTimer = null;
+                                },200);
+                            }
                         }
                     }
                 }
@@ -28264,6 +29184,7 @@ RED.palette = (function() {
                 categoryNode.find(".red-ui-palette-content").slideToggle();
                 categoryNode.find("i").toggleClass("expanded");
             }
+            categoryNode.hide();
         }
     }
 
@@ -28342,6 +29263,7 @@ RED.palette = (function() {
                     currentCategoryNode.find(".red-ui-palette-content").slideToggle();
                     currentCategoryNode.find("i").toggleClass("expanded");
                 }
+                currentCategoryNode.hide();
             }
         }
 
@@ -28558,6 +29480,7 @@ RED.sidebar.info = (function() {
     var propertiesPanelHeaderLabel;
     var propertiesPanelHeaderReveal;
     var propertiesPanelHeaderHelp;
+    var propertiesPanelHeaderCopyLink;
 
     var selectedObject;
 
@@ -28600,10 +29523,20 @@ RED.sidebar.info = (function() {
 
         propertiesPanelHeaderIcon = $("<span>").appendTo(propertiesPanelHeader);
         propertiesPanelHeaderLabel = $("<span>").appendTo(propertiesPanelHeader);
-        propertiesPanelHeaderHelp = $('<button class="red-ui-button red-ui-button-small"><i class="fa fa-book"></button>').css({
+
+        propertiesPanelHeaderCopyLink = $('<button type="button" class="red-ui-button red-ui-button-small"><i class="fa fa-link"></button>').css({
             position: 'absolute',
             top: '12px',
             right: '32px'
+        }).on("click", function(evt) {
+            RED.actions.invoke('core:copy-item-url',selectedObject)
+        }).appendTo(propertiesPanelHeader);
+        RED.popover.tooltip(propertiesPanelHeaderCopyLink,RED._("sidebar.info.copyItemUrl"));
+
+        propertiesPanelHeaderHelp = $('<button type="button" class="red-ui-button red-ui-button-small"><i class="fa fa-book"></button>').css({
+            position: 'absolute',
+            top: '12px',
+            right: '56px'
         }).on("click", function(evt) {
             evt.preventDefault();
             evt.stopPropagation();
@@ -28613,8 +29546,7 @@ RED.sidebar.info = (function() {
         }).appendTo(propertiesPanelHeader);
         RED.popover.tooltip(propertiesPanelHeaderHelp,RED._("sidebar.help.showHelp"));
 
-
-        propertiesPanelHeaderReveal = $('<button class="red-ui-button red-ui-button-small"><i class="fa fa-search"></button>').css({
+        propertiesPanelHeaderReveal = $('<button type="button" class="red-ui-button red-ui-button-small"><i class="fa fa-search"></button>').css({
             position: 'absolute',
             top: '12px',
             right: '8px'
@@ -28631,7 +29563,7 @@ RED.sidebar.info = (function() {
 
         propertiesPanelContent = $("<div>").css({
             "flex":"1 1 auto",
-            "overflow-y":"scroll",
+            "overflow-y":"auto",
         }).appendTo(propertiesPanel);
 
 
@@ -28718,6 +29650,7 @@ RED.sidebar.info = (function() {
             propertiesPanelHeaderLabel.text("");
             propertiesPanelHeaderReveal.hide();
             propertiesPanelHeaderHelp.hide();
+            propertiesPanelHeaderCopyLink.hide();
             return;
         } else if (Array.isArray(node)) {
             // Multiple things selected
@@ -28729,6 +29662,7 @@ RED.sidebar.info = (function() {
             propertiesPanelHeaderLabel.text("Selection");
             propertiesPanelHeaderReveal.hide();
             propertiesPanelHeaderHelp.hide();
+            propertiesPanelHeaderCopyLink.hide();
             selectedObject = null;
 
             var types = {
@@ -28810,9 +29744,11 @@ RED.sidebar.info = (function() {
             if (node.type === "tab" || node.type === "subflow") {
                 // If nothing is selected, but we're on a flow or subflow tab.
                 propertiesPanelHeaderHelp.hide();
+                propertiesPanelHeaderCopyLink.show();
 
             } else if (node.type === "group") {
                 propertiesPanelHeaderHelp.hide();
+                propertiesPanelHeaderCopyLink.show();
 
                 propRow = $('<tr class="red-ui-help-info-row"><td>&nbsp;</td><td></td></tr>').appendTo(tableBody);
 
@@ -28837,8 +29773,10 @@ RED.sidebar.info = (function() {
                 }
             } else if (node.type === 'junction') {
                 propertiesPanelHeaderHelp.hide();
+                propertiesPanelHeaderCopyLink.hide();
             } else {
                 propertiesPanelHeaderHelp.show();
+                propertiesPanelHeaderCopyLink.show();
 
                 if (!subflowRegex) {
                     propRow = $('<tr class="red-ui-help-info-row"><td>'+RED._("sidebar.info.type")+'</td><td></td></tr>').appendTo(tableBody);
@@ -28980,7 +29918,8 @@ RED.sidebar.info = (function() {
                     el = el.next();
                 }
                 $(this).toggleClass('expanded',!isExpanded);
-            })
+            });
+        mermaid.init();
     }
 
     var tips = (function() {
@@ -29345,6 +30284,22 @@ RED.sidebar.info = (function() {
         } else {
             $('<div class="red-ui-info-outline-item-control-spacer">').appendTo(controls)
         }
+        if (n.type === 'tab') {
+            var lockToggleButton = $('<button type="button" class="red-ui-info-outline-item-control-lock red-ui-button red-ui-button-small"><i class="fa fa-unlock-alt"></i><i class="fa fa-lock"></i></button>').appendTo(controls).on("click",function(evt) {
+                evt.preventDefault();
+                evt.stopPropagation();
+                if (n.locked) {
+                    RED.workspaces.unlock(n.id)
+                } else {
+                    RED.workspaces.lock(n.id)
+                }
+            })
+            RED.popover.tooltip(lockToggleButton,function() {
+                return RED._("common.label."+(n.locked?"unlock":"lock"));
+            });
+        } else {
+            $('<div class="red-ui-info-outline-item-control-spacer">').appendTo(controls)
+        }
         controls.find("button").on("dblclick", function(evt) {
             evt.preventDefault();
             evt.stopPropagation();
@@ -29488,6 +30443,8 @@ RED.sidebar.info = (function() {
         flowList.treeList.addChild(objects[ws.id])
         objects[ws.id].element.toggleClass("red-ui-info-outline-item-disabled", !!ws.disabled)
         objects[ws.id].treeList.container.toggleClass("red-ui-info-outline-item-disabled", !!ws.disabled)
+        objects[ws.id].element.toggleClass("red-ui-info-outline-item-locked", !!ws.locked)
+        objects[ws.id].treeList.container.toggleClass("red-ui-info-outline-item-locked", !!ws.locked)
         updateSearch();
 
     }
@@ -29502,6 +30459,8 @@ RED.sidebar.info = (function() {
         existingObject.element.find(".red-ui-info-outline-item-label").text(label);
         existingObject.element.toggleClass("red-ui-info-outline-item-disabled", !!n.disabled)
         existingObject.treeList.container.toggleClass("red-ui-info-outline-item-disabled", !!n.disabled)
+        existingObject.element.toggleClass("red-ui-info-outline-item-locked", !!n.locked)
+        existingObject.treeList.container.toggleClass("red-ui-info-outline-item-locked", !!n.locked)
         updateSearch();
     }
     function onFlowsReorder(order) {
@@ -29858,7 +30817,7 @@ RED.sidebar.help = (function() {
 
         tocPanel = $("<div>", {class: "red-ui-sidebar-help-toc"}).appendTo(stackContainer);
         var helpPanel = $("<div>").css({
-            "overflow-y": "scroll"
+            "overflow-y": "auto"
         }).appendTo(stackContainer);
 
         panels = RED.panels.create({
@@ -29949,7 +30908,8 @@ RED.sidebar.help = (function() {
         RED.events.on('registry:node-type-removed', queueRefresh);
         RED.events.on('subflows:change', refreshSubflow);
 
-        RED.actions.add("core:show-help-tab",show);
+        RED.actions.add("core:show-help-tab", show);
+        RED.actions.add("core:show-node-help", showNodeHelp)
 
     }
 
@@ -30146,6 +31106,19 @@ RED.sidebar.help = (function() {
         resizeStack();
     }
 
+    function showNodeHelp(node) {
+        if (!node) {
+            const selection = RED.view.selection()
+            if (selection.nodes && selection.nodes.length > 0) {
+                node = selection.nodes.find(n => n.type !== 'group' && n.type !== 'junction')
+            }
+        }
+        if (node) {
+            show(node.type, true)
+        }
+    }
+
+
     // TODO: DRY - projects.js
     function addTargetToExternalLinks(el) {
         $(el).find("a").each(function(el) {
@@ -30332,12 +31305,15 @@ RED.sidebar.config = (function() {
 
     var categories = {};
 
-    function getOrCreateCategory(name,parent,label) {
+    function getOrCreateCategory(name,parent,label,isLocked) {
         name = name.replace(/\./i,"-");
         if (!categories[name]) {
             var container = $('<div class="red-ui-palette-category red-ui-sidebar-config-category" id="red-ui-sidebar-config-category-'+name+'"></div>').appendTo(parent);
             var header = $('<div class="red-ui-sidebar-config-tray-header red-ui-palette-header"><i class="fa fa-angle-down expanded"></i></div>').appendTo(container);
+            let lockIcon
             if (label) {
+                lockIcon = $('<span style="margin-right: 5px"><i class="fa fa-lock"/></span>').appendTo(header)
+                lockIcon.toggle(!!isLocked)
                 $('<span class="red-ui-palette-node-config-label"/>').text(label).appendTo(header);
             } else {
                 $('<span class="red-ui-palette-node-config-label" data-i18n="sidebar.config.'+name+'">').appendTo(header);
@@ -30351,6 +31327,7 @@ RED.sidebar.config = (function() {
             var icon = header.find("i");
             var result = {
                 label: label,
+                lockIcon,
                 list: category,
                 size: function() {
                     return result.list.find("li:not(.red-ui-palette-node-config-none)").length
@@ -30389,6 +31366,9 @@ RED.sidebar.config = (function() {
             });
             categories[name] = result;
         } else {
+            if (isLocked !== undefined && categories[name].lockIcon) {
+                categories[name].lockIcon.toggle(!!isLocked)
+            }
             if (categories[name].label !== label) {
                 categories[name].list.parent().find('.red-ui-palette-node-config-label').text(label);
                 categories[name].label = label;
@@ -30505,7 +31485,7 @@ RED.sidebar.config = (function() {
 
         RED.nodes.eachWorkspace(function(ws) {
             validList[ws.id.replace(/\./g,"-")] = true;
-            getOrCreateCategory(ws.id,flowCategories,ws.label);
+            getOrCreateCategory(ws.id,flowCategories,ws.label, ws.locked);
         })
         RED.nodes.eachSubflow(function(sf) {
             validList[sf.id.replace(/\./g,"-")] = true;
@@ -30563,6 +31543,15 @@ RED.sidebar.config = (function() {
                     changes: {},
                     dirty: RED.nodes.dirty()
                 }
+                for (let i = 0; i < selectedNodes.length; i++) {
+                    let node = RED.nodes.node(selectedNodes[i])
+                    if (node.z) {
+                        let ws = RED.nodes.workspace(node.z)
+                        if (ws && ws.locked) {
+                            return
+                        }
+                    }
+                }
                 selectedNodes.forEach(function(id) {
                     var node = RED.nodes.node(id);
                     try {
@@ -32505,6 +33494,7 @@ RED.editor = (function() {
             var valid = validateNodeProperty(node, defaults, property,value);
             if (((typeof valid) === "string") || !valid) {
                 input.addClass("input-error");
+                input.next(".red-ui-typedInput-container").addClass("input-error");
                 if ((typeof valid) === "string") {
                     var tooltip = input.data("tooltip");
                     if (tooltip) {
@@ -32517,6 +33507,7 @@ RED.editor = (function() {
                 }
             } else {
                 input.removeClass("input-error");
+                input.next(".red-ui-typedInput-container").removeClass("input-error");
                 var tooltip = input.data("tooltip");
                 if (tooltip) {
                     input.data("tooltip", null);
@@ -34118,11 +35109,15 @@ RED.editor = (function() {
                             workspace.disabled = disabled;
 
                             $("#red-ui-tab-"+(workspace.id.replace(".","-"))).toggleClass('red-ui-workspace-disabled',!!workspace.disabled);
-                            if (workspace.id === RED.workspaces.active()) {
-                                $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled",!!workspace.disabled);
-                            }
                         }
 
+                        var locked = $("#node-input-locked").prop("checked");
+                        if (workspace.locked !== locked) {
+                            editState.changes.locked = workspace.locked;
+                            editState.changed = true;
+                            workspace.locked = locked;
+                            $("#red-ui-tab-"+(workspace.id.replace(".","-"))).toggleClass('red-ui-workspace-locked',!!workspace.locked);
+                        }
                         if (editState.changed) {
                             var historyEvent = {
                                 t: "edit",
@@ -34163,6 +35158,7 @@ RED.editor = (function() {
                 var trayBody = tray.find('.red-ui-tray-body');
                 trayBody.parent().css('overflow','hidden');
                 var trayFooterLeft = $('<div class="red-ui-tray-footer-left"></div>').appendTo(trayFooter)
+                var trayFooterRight = $('<div class="red-ui-tray-footer-right"></div>').appendTo(trayFooter)
 
                 var nodeEditPanes = [
                     'editor-tab-flow-properties',
@@ -34177,6 +35173,18 @@ RED.editor = (function() {
                     disabledIcon: "fa-ban",
                     invertState: true
                 })
+
+                if (!workspace.hasOwnProperty("locked")) {
+                    workspace.locked = false;
+                }
+                $('<input id="node-input-locked" type="checkbox">').prop("checked",workspace.locked).appendTo(trayFooterRight).toggleButton({
+                    enabledLabel: 'Unlocked',
+                    enabledIcon: "fa-unlock-alt",
+                    disabledLabel: 'Locked',
+                    disabledIcon: "fa-lock",
+                    invertState: true
+                })
+
                 prepareEditDialog(trayBody, nodeEditPanes, workspace, {}, "node-input", defaultTab, function(_activeEditPanes) {
                     activeEditPanes = _activeEditPanes;
                     trayBody.i18n();
@@ -34579,6 +35587,7 @@ RED.editor = (function() {
             RED.editor.colorPicker.create({
                 id: "red-ui-editor-node-color",
                 value: color,
+                defaultValue: "#DDAA99",
                 palette: recommendedColors,
                 sortPalette: function (a, b) {return a.l - b.l;}
             }).appendTo(colorRow);
@@ -35067,8 +36076,6 @@ RED.editor = (function() {
                     node.info = info;
                 }
                 $("#red-ui-tab-"+(node.id.replace(".","-"))).toggleClass('red-ui-workspace-disabled',!!node.disabled);
-                $("#red-ui-workspace").toggleClass("red-ui-workspace-disabled",!!node.disabled);
-
             }
         }
     });
@@ -35711,6 +36718,9 @@ RED.editor = (function() {
             selectedCodeEditor = RED.editor.codeEditor[defaultEditor];
             initialised = selectedCodeEditor.init();
         }
+
+        $('<div id="red-ui-image-drop-target"><div data-i18n="[append]workspace.dropImageHere"><i class="fa fa-download"></i><br></div></div>').appendTo('#red-ui-editor');
+        $("#red-ui-image-drop-target").hide();
     }
 
     function create(options) {
@@ -35730,6 +36740,7 @@ RED.editor = (function() {
             options = {};
         }
 
+        var editor = null;
         if (this.editor.type === MONACO) {
             // compatibility (see above note)
             if (!options.element && !options.id) {
@@ -35740,10 +36751,14 @@ RED.editor = (function() {
                 console.warn("createEditor() options.element or options.id is not valid", options);
                 $("#dialog-form").append('<div id="' + options.id + '" style="display: none;" />');
             }
-            return this.editor.create(options);
+            editor = this.editor.create(options);
         } else {
-            return this.editor.create(options);//fallback to ACE
+            editor = this.editor.create(options);//fallback to ACE
         }
+        if (options.mode === "ace/mode/markdown") {
+            RED.editor.customEditTypes['_markdown'].postInit(editor, options);
+        }
+        return editor;
     }
 
     return {
@@ -35849,6 +36864,9 @@ RED.editor = (function() {
             var focusTarget = colorInput;
             colorInput.on("change", function (e) {
                 var color = colorInput.val();
+                if (options.defaultValue && !color.match(/^([a-z]+|#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3})$/)) {
+                    color = options.defaultValue;
+                }
                 colorHiddenInput.val(color).trigger('change');
                 refreshDisplay(color);
             });
@@ -35984,7 +37002,7 @@ RED.editor = (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'];
+    var DEFAULT_ENV_TYPE_LIST_INC_CRED = ['str','num','bool','json','bin','env','cred','jsonata'];
 
     /**
      * Create env var edit interface
@@ -36862,6 +37880,9 @@ RED.editor = (function() {
                         var currentExpression = expressionEditor.getValue();
                         var expr;
                         var usesContext = false;
+                        var usesEnv = false;
+                        var usesMoment = false;
+                        var usesClone = false;
                         var legacyMode = /(^|[^a-zA-Z0-9_'".])msg([^a-zA-Z0-9_'"]|$)/.test(currentExpression);
                         $(".red-ui-editor-type-expression-legacy").toggle(legacyMode);
                         try {
@@ -36874,6 +37895,18 @@ RED.editor = (function() {
                                 usesContext = true;
                                 return null;
                             });
+                            expr.assign("env", function(name) {
+                                usesEnv = true;
+                                return null;
+                            });
+                            expr.assign("moment", function(name) {
+                                usesMoment = true;
+                                return null;
+                            });
+                            expr.assign("clone", function(name) {
+                                usesClone = true;
+                                return null;
+                            });
                         } catch(err) {
                             testResultEditor.setValue(RED._("expressionEditor.errors.invalid-expr",{message:err.message}),-1);
                             return;
@@ -36891,6 +37924,18 @@ RED.editor = (function() {
                                 testResultEditor.setValue(RED._("expressionEditor.errors.context-unsupported"),-1);
                                 return;
                             }
+                            if (usesEnv) {
+                                testResultEditor.setValue(RED._("expressionEditor.errors.env-unsupported"),-1);
+                                return;
+                            }
+                            if (usesMoment) {
+                                testResultEditor.setValue(RED._("expressionEditor.errors.moment-unsupported"),-1);
+                                return;
+                            }
+                            if (usesClone) {
+                                testResultEditor.setValue(RED._("expressionEditor.errors.clone-unsupported"),-1);
+                                return;
+                            }
 
                             var formattedResult;
                             if (result !== undefined) {
@@ -37843,6 +38888,61 @@ RED.editor = (function() {
  * limitations under the License.
  **/
 (function() {
+    /**
+     * Converts dropped image file to date URL
+     */
+    function file2base64Image(file, cb) {
+        var reader = new FileReader();
+        reader.onload = (function (fd) {
+            return function (e) {
+                cb(e.target.result);
+            };
+        })(file);
+        reader.readAsDataURL(file);
+    }
+
+    var initialized = false;
+    var currentEditor = null;
+    /**
+     * Initialize handler for image file drag events
+     */
+    function initImageDrag(elem, editor) {
+        $(elem).on("dragenter", function (ev) {
+            ev.preventDefault();
+            $("#red-ui-image-drop-target").css({display:'table'}).focus();
+            currentEditor = editor;
+        });
+
+        if (!initialized) {
+            initialized = true;
+            $("#red-ui-image-drop-target").on("dragover", function (ev) {
+                ev.preventDefault();
+            }).on("dragleave", function (ev) {
+                $("#red-ui-image-drop-target").hide();
+            }).on("drop", function (ev) {
+                ev.preventDefault();
+                if ($.inArray("Files",ev.originalEvent.dataTransfer.types) != -1) {
+                    var files = ev.originalEvent.dataTransfer.files;
+                    if (files.length === 1) {
+                        var file = files[0];
+                        var name = file.name.toLowerCase();
+
+                        if (name.match(/\.(apng|avif|gif|jpeg|png|svg|webp)$/)) {
+                            file2base64Image(file, function (image) {
+                                var session = currentEditor.getSession();
+                                var img = `<img src="${image}"/>\n`;
+                                var pos = session.getCursorPosition();
+                                session.insert(pos, img);
+                                $("#red-ui-image-drop-target").hide();
+                            });
+                            return;
+                        }
+                    }
+                }
+                $("#red-ui-image-drop-target").hide();
+            });
+        }
+    }
 
     var toolbarTemplate = '<div style="margin-bottom: 5px">'+
         '<span class="button-group">'+
@@ -37943,6 +39043,7 @@ RED.editor = (function() {
                             var currentScrollTop = $(".red-ui-editor-type-markdown-panel-preview").scrollTop();
                             $(".red-ui-editor-type-markdown-panel-preview").html(RED.utils.renderMarkdown(expressionEditor.getValue()));
                             $(".red-ui-editor-type-markdown-panel-preview").scrollTop(currentScrollTop);
+                            mermaid.init();
                         },200);
                     })
                     if (options.header) {
@@ -37951,6 +39052,7 @@ RED.editor = (function() {
 
                     if (value) {
                         $(".red-ui-editor-type-markdown-panel-preview").html(RED.utils.renderMarkdown(expressionEditor.getValue()));
+                        mermaid.init();
                     }
                     panels = RED.panels.create({
                         id:"red-ui-editor-type-markdown-panels",
@@ -37977,10 +39079,14 @@ RED.editor = (function() {
                     });
                     RED.popover.tooltip($("#node-btn-markdown-preview"), RED._("markdownEditor.toggle-preview"));
 
-                    if (options.cursor && !expressionEditor._initState) {
-                        expressionEditor.gotoLine(options.cursor.row+1,options.cursor.column,false);
-                    }
-
+                    if(!expressionEditor._initState) {
+                        if (options.cursor) {
+                            expressionEditor.gotoLine(options.cursor.row+1,options.cursor.column,false);
+                        }
+                        else {
+                            expressionEditor.gotoLine(0, 0, false);
+                        }
+                    }                        
                     dialogForm.i18n();
                 },
                 close: function() {
@@ -38044,7 +39150,11 @@ RED.editor = (function() {
                 }
             })
             return toolbar;
-        }
+        },
+        postInit: function (editor, options) {
+            var elem = $("#"+options.id);
+            initImageDrag(elem, editor);
+         }
     }
     RED.editor.registerTypeEditor("_markdown", definition);
 })();
@@ -38442,7 +39552,7 @@ RED.editor.codeEditor.monaco = (function() {
         "node-red-util": {package: "node-red", module: "util", path: "node-red/util.d.ts" },
         "node-red-func": {package: "node-red", module: "func", path: "node-red/func.d.ts" },
     }
-    const defaultServerSideTypes = [ knownModules["node-red-util"], knownModules["node-red-func"], knownModules["globals"], knownModules["console"], knownModules["buffer"] ];
+    const defaultServerSideTypes = [ knownModules["node-red-util"], knownModules["node-red-func"], knownModules["globals"], knownModules["console"], knownModules["buffer"] , knownModules["util"] ];
 
     const modulesCache = {};
 
@@ -40676,11 +41786,10 @@ RED.clipboard = (function() {
         }
     }
 
-    function showImportNodes(mode) {
+    function showImportNodes(library = 'clipboard') {
         if (disabled) {
             return;
         }
-        mode = mode || "clipboard";
 
         dialogContainer.empty();
         dialogContainer.append($(importNodesDialog));
@@ -40757,7 +41866,7 @@ RED.clipboard = (function() {
         $("#red-ui-clipboard-dialog-import-text").on("keyup", validateImport);
         $("#red-ui-clipboard-dialog-import-text").on('paste',function() { setTimeout(validateImport,10)});
 
-        if (RED.workspaces.active() === 0) {
+        if (RED.workspaces.active() === 0 || RED.workspaces.isActiveLocked()) {
             $("#red-ui-clipboard-dialog-import-opt-current").addClass('disabled').removeClass("selected");
             $("#red-ui-clipboard-dialog-import-opt-new").addClass("selected");
         } else {
@@ -40786,8 +41895,8 @@ RED.clipboard = (function() {
             $("#red-ui-clipboard-dialog-import-file-upload").trigger("click");
         })
 
-        tabs.activateTab("red-ui-clipboard-dialog-import-tab-"+mode);
-        if (mode === 'clipboard') {
+        tabs.activateTab("red-ui-clipboard-dialog-import-tab-"+library);
+        if (library === 'clipboard') {
             setTimeout(function() {
                 $("#red-ui-clipboard-dialog-import-text").trigger("focus");
             },100)
@@ -40811,13 +41920,16 @@ RED.clipboard = (function() {
         });
     }
 
-    function showExportNodes(mode) {
+    /**
+     * Show the export dialog
+     * @params library which export destination to show
+     * @params mode whether to default to 'auto' (default) or 'flow'
+     **/
+    function showExportNodes(library = 'clipboard', mode = 'auto' ) {
         if (disabled) {
             return;
         }
 
-        mode = mode || "clipboard";
-
         dialogContainer.empty();
         dialogContainer.append($(exportNodesDialog));
 
@@ -40907,7 +42019,12 @@ RED.clipboard = (function() {
         $("#red-ui-clipboard-dialog-tab-library-name").val("flows.json").select();
 
         dialogContainer.i18n();
+        
         var format = RED.settings.flowFilePretty ? "red-ui-clipboard-dialog-export-fmt-full" : "red-ui-clipboard-dialog-export-fmt-mini";
+        const userFormat = RED.settings.get("editor.dialog.export.pretty")
+        if (userFormat === false || userFormat === true) {
+            format = userFormat ? "red-ui-clipboard-dialog-export-fmt-full" : "red-ui-clipboard-dialog-export-fmt-mini";
+        }
 
         $("#red-ui-clipboard-dialog-export-fmt-group > a").on("click", function(evt) {
             evt.preventDefault();
@@ -40923,7 +42040,8 @@ RED.clipboard = (function() {
                 var nodes = JSON.parse(flow);
 
                 format = $(this).attr('id');
-                if (format === 'red-ui-clipboard-dialog-export-fmt-full') {
+                const pretty = format === "red-ui-clipboard-dialog-export-fmt-full";
+                if (pretty) {
                     flow = JSON.stringify(nodes,null,4);
                 } else {
                     flow = JSON.stringify(nodes);
@@ -40932,6 +42050,7 @@ RED.clipboard = (function() {
                 setTimeout(function() { $("#red-ui-clipboard-dialog-export-text").scrollTop(0); },50);
 
                 $("#red-ui-clipboard-dialog-export-text").trigger("focus");
+                RED.settings.set("editor.dialog.export.pretty", pretty)
             }
         });
 
@@ -41019,12 +42138,15 @@ RED.clipboard = (function() {
                 }
             }
         }
+        if (mode === 'flow' && !$("#red-ui-clipboard-dialog-export-rng-flow").hasClass('disabled')) {
+            $("#red-ui-clipboard-dialog-export-rng-flow").trigger("click");
+        }
         if (format === "red-ui-clipboard-dialog-export-fmt-full") {
             $("#red-ui-clipboard-dialog-export-fmt-full").trigger("click");
         } else {
             $("#red-ui-clipboard-dialog-export-fmt-mini").trigger("click");
         }
-        tabs.activateTab("red-ui-clipboard-dialog-export-tab-"+mode);
+        tabs.activateTab("red-ui-clipboard-dialog-export-tab-"+library);
 
         var dialogHeight = 400;
         var winHeight = $(window).height();
@@ -41519,15 +42641,17 @@ RED.clipboard = (function() {
             RED.keyboard.add("#red-ui-drop-target", "escape" ,hideDropTarget);
 
             $('#red-ui-workspace-chart').on("dragenter",function(event) {
-                if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1 ||
-                     $.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
+                if (!RED.workspaces.isActiveLocked() && (
+                    $.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1 ||
+                     $.inArray("Files",event.originalEvent.dataTransfer.types) != -1)) {
                     $("#red-ui-drop-target").css({display:'table'}).focus();
                 }
             });
 
             $('#red-ui-drop-target').on("dragover",function(event) {
                 if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1 ||
-                     $.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
+                     $.inArray("Files",event.originalEvent.dataTransfer.types) != -1 ||
+                        RED.workspaces.isActiveLocked()) {
                     event.preventDefault();
                 }
             })
@@ -41535,27 +42659,29 @@ RED.clipboard = (function() {
                 hideDropTarget();
             })
             .on("drop",function(event) {
-                try {
-                    if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1) {
-                        var data = event.originalEvent.dataTransfer.getData("text/plain");
-                        data = data.substring(data.indexOf('['),data.lastIndexOf(']')+1);
-                        importNodes(data);
-                    } else if ($.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
-                        var files = event.originalEvent.dataTransfer.files;
-                        if (files.length === 1) {
-                            var file = files[0];
-                            var reader = new FileReader();
-                            reader.onload = (function(theFile) {
-                                return function(e) {
-                                    importNodes(e.target.result);
-                                };
-                            })(file);
-                            reader.readAsText(file);
+                if (!RED.workspaces.isActiveLocked()) {
+                    try {
+                        if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1) {
+                            var data = event.originalEvent.dataTransfer.getData("text/plain");
+                            data = data.substring(data.indexOf('['),data.lastIndexOf(']')+1);
+                            importNodes(data);
+                        } else if ($.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
+                            var files = event.originalEvent.dataTransfer.files;
+                            if (files.length === 1) {
+                                var file = files[0];
+                                var reader = new FileReader();
+                                reader.onload = (function(theFile) {
+                                    return function(e) {
+                                        importNodes(e.target.result);
+                                    };
+                                })(file);
+                                reader.readAsText(file);
+                            }
                         }
+                    } catch(err) {
+                        // Ensure any errors throw above doesn't stop the drop target from
+                        // being hidden.
                     }
-                } catch(err) {
-                    // Ensure any errors throw above doesn't stop the drop target from
-                    // being hidden.
                 }
                 hideDropTarget();
                 event.preventDefault();
@@ -42877,38 +44003,51 @@ RED.search = (function() {
         return val;
     }
 
-    function search(val) {
-        var results = [];
-        var typeFilter;
-        var m = /(?:^| )type:([^ ]+)/.exec(val);
-        if (m) {
-            val = val.replace(/(?:^| )type:[^ ]+/,"");
-            typeFilter = m[1];
+    function extractType(val, flags) {
+        // extracts:  type:XYZ  &  type:"X Y Z"
+        const regEx = /(?:type):\s*(?:"([^"]+)"|([^" ]+))/;
+        let m
+        while ((m = regEx.exec(val)) !== null) {
+            // avoid infinite loops with zero-width matches
+            if (m.index === regEx.lastIndex) {
+                regEx.lastIndex++;
+            }
+            val = val.replace(m[0]," ").trim()
+            const flag = m[2] || m[1] // quoted entries in capture group 1, unquoted in capture group 2
+            flags.type = flags.type || [];
+            flags.type.push(flag);
         }
-        var flags = {};
+        return val;
+    }
+
+    function search(val) {
+        const results = [];
+        const flags = {};
         val = extractFlag(val,"invalid",flags);
         val = extractFlag(val,"unused",flags);
         val = extractFlag(val,"config",flags);
         val = extractFlag(val,"subflow",flags);
         val = extractFlag(val,"hidden",flags);
         val = extractFlag(val,"modified",flags);
-        val = extractValue(val,"flow",flags);// flow:active or flow:<flow-id>
+        val = extractValue(val,"flow",flags);// flow:current or flow:<flow-id>
         val = extractValue(val,"uses",flags);// uses:<node-id>
+        val = extractType(val,flags);// type:<node-type>
         val = val.trim();
-        var hasFlags = Object.keys(flags).length > 0;
+        const hasFlags = Object.keys(flags).length > 0;
+        const hasTypeFilter = flags.type && flags.type.length > 0
         if (flags.flow && flags.flow.indexOf("current") >= 0) {
             let idx = flags.flow.indexOf("current");
-            flags.flow[idx] = RED.workspaces.active();//convert active to flow ID
+            flags.flow[idx] = RED.workspaces.active();//convert 'current' to active flow ID
         }
         if (flags.flow && flags.flow.length) {
             flags.flow = [ ...new Set(flags.flow) ]; //deduplicate
         }
-        if (val.length > 0 || typeFilter || hasFlags) {
+        if (val.length > 0 || hasFlags) {
             val = val.toLowerCase();
-            var i;
-            var j;
-            var list = [];
-            var nodes = {};
+            let i;
+            let j;
+            let list = [];
+            const nodes = {};
             let keys = [];
             if (flags.uses) {
                 keys = flags.uses;
@@ -42916,10 +44055,10 @@ RED.search = (function() {
                 keys = Object.keys(index);
             }
             for (i=0;i<keys.length;i++) {
-                var key = keys[i];
-                var kpos = keys[i].indexOf(val);
-                if (kpos > -1) {
-                    var ids = Object.keys(index[key]||{});
+                const key = keys[i];
+                const kpos = val ? keys[i].indexOf(val) : -1;
+                if (kpos > -1 || (val === "" && hasFlags)) {
+                    const ids = Object.keys(index[key]||{});
                     for (j=0;j<ids.length;j++) {
                         var node = index[key][ids[j]];
                         var isConfigNode = node.node._def.category === "config" && node.node.type !== 'group';
@@ -42927,7 +44066,7 @@ RED.search = (function() {
                             continue;
                         }
                         if (flags.hasOwnProperty("invalid")) {
-                            var nodeIsValid = !node.node.hasOwnProperty("valid") || node.node.valid;
+                            const nodeIsValid = !node.node.hasOwnProperty("valid") || node.node.valid;
                             if (flags.invalid === nodeIsValid) {
                                 continue;
                             }
@@ -42957,7 +44096,7 @@ RED.search = (function() {
                             }
                         }
                         if (flags.hasOwnProperty("unused")) {
-                            var isUnused = (node.node.type === 'subflow' && node.node.instances.length === 0) ||
+                            const isUnused = (node.node.type === 'subflow' && node.node.instances.length === 0) ||
                                            (isConfigNode && node.node.users.length === 0 && node.node._def.hasUsers !== false)
                             if (flags.unused !== isUnused) {
                                 continue;
@@ -42968,12 +44107,16 @@ RED.search = (function() {
                                 continue;
                             }
                         }
-                        if (!typeFilter || node.node.type === typeFilter) {
-                            nodes[node.node.id] = nodes[node.node.id] = {
+                        let typeIndex = -1
+                        if(hasTypeFilter) {
+                            typeIndex = flags.type.indexOf(node.node.type)
+                        }
+                        if (!hasTypeFilter || typeIndex > -1) {
+                            nodes[node.node.id] = nodes[node.node.id] || {
                                 node: node.node,
                                 label: node.label
                             };
-                            nodes[node.node.id].index = Math.min(nodes[node.node.id].index||Infinity,kpos);
+                            nodes[node.node.id].index = Math.min(nodes[node.node.id].index || Infinity, typeIndex > -1 ? typeIndex : kpos);
                         }
                     }
                 }
@@ -43438,21 +44581,6 @@ RED.search = (function() {
 ;RED.contextMenu = (function () {
 
     let menu;
-    function createMenu() {
-        // menu = RED.popover.menu({
-        //     options: [
-        //         {
-        //             label: 'delete selection',
-        //             onselect: function() {
-        //                 RED.actions.invoke('core:delete-selection')
-        //                 RED.view.focus()
-        //             }
-        //         },
-        //         { label: 'world' }
-        //     ],
-        //     width: 200,
-        // })
-    }
 
     function disposeMenu() {
         $(document).off("mousedown.red-ui-workspace-context-menu");
@@ -43465,114 +44593,164 @@ RED.search = (function() {
         if (menu) {
             menu.remove()
         }
+        let menuItems = []
+        if (options.options) {
+            menuItems = options.options
+        } else if (options.type === 'workspace') {
+            const selection = RED.view.selection()
+            const noSelection = !selection || Object.keys(selection).length === 0
+            const hasSelection = (selection.nodes && selection.nodes.length > 0);
+            const hasMultipleSelection = hasSelection && selection.nodes.length > 1;
+            const virtulLinks = (selection.links && selection.links.filter(e => !!e.link)) || [];
+            const wireLinks = (selection.links && selection.links.filter(e => !e.link)) || [];
+            const hasLinks = wireLinks.length > 0;
+            const isSingleLink = !hasSelection && hasLinks && wireLinks.length === 1
+            const isMultipleLinks = !hasSelection && hasLinks && wireLinks.length > 1
+            const canDelete = hasSelection || hasLinks
+            const isGroup = hasSelection && selection.nodes.length === 1 && selection.nodes[0].type === 'group'
+            const canEdit = !RED.workspaces.isActiveLocked()
+            const canRemoveFromGroup = hasSelection && !!selection.nodes[0].g
+            const isAllGroups = hasSelection && selection.nodes.filter(n => n.type !== 'group').length === 0
+            const hasGroup = hasSelection && selection.nodes.filter(n => n.type === 'group' ).length > 0
+            const offset = $("#red-ui-workspace-chart").offset()
+
+            let addX = options.x - offset.left + $("#red-ui-workspace-chart").scrollLeft()
+            let addY = options.y - offset.top + $("#red-ui-workspace-chart").scrollTop()
 
-        const selection = RED.view.selection()
-        const noSelection = !selection || Object.keys(selection).length === 0
-        const hasSelection = (selection.nodes && selection.nodes.length > 0);
-        const hasMultipleSelection = hasSelection && selection.nodes.length > 1;
-        const virtulLinks = (selection.links && selection.links.filter(e => !!e.link)) || [];
-        const wireLinks = (selection.links && selection.links.filter(e => !e.link)) || [];
-        const hasLinks = wireLinks.length > 0;
-        const isSingleLink = !hasSelection && hasLinks && wireLinks.length === 1
-        const isMultipleLinks = !hasSelection && hasLinks && wireLinks.length > 1
-        const canDelete = hasSelection || hasLinks
-        const isGroup = hasSelection && selection.nodes.length === 1 && selection.nodes[0].type === 'group'
-
-        const canRemoveFromGroup = hasSelection && !!selection.nodes[0].g
-        const offset = $("#red-ui-workspace-chart").offset()
+            if (RED.view.snapGrid) {
+                const gridSize = RED.view.gridSize()
+                addX = gridSize * Math.floor(addX / gridSize)
+                addY = gridSize * Math.floor(addY / gridSize)
+            }
 
-        // addX/addY must be the position in the workspace accounting for both scroll and scale
-        // The +5 is because we display the contextMenu -5,-5 to actual click position
-        let addX = (options.x + 5 - offset.left + $("#red-ui-workspace-chart").scrollLeft()) / RED.view.scale()
-        let addY = (options.y + 5 - offset.top + $("#red-ui-workspace-chart").scrollTop()) / RED.view.scale()
+            menuItems.push(
+                { onselect: 'core:show-action-list', onpostselect: function () { } }
+            )
 
-        const menuItems = [
-            { onselect: 'core:show-action-list', onpostselect: function () { } },
-            {
-                label: RED._("contextMenu.insert"),
-                options: [
-                    {
-                        label: RED._("contextMenu.node"),
-                        onselect: function () {
-                            RED.view.showQuickAddDialog({
-                                position: [addX, addY],
-                                touchTrigger: true,
-                                splice: isSingleLink ? selection.links[0] : undefined,
-                                // spliceMultiple: isMultipleLinks
-                            })
-                        },
-                        onpostselect: function() {
-                            // ensure quick add dialog search input has focus
-                            $('#red-ui-type-search-input').trigger('focus')
-                        }
+            const insertOptions = []
+            menuItems.push({ label: RED._("contextMenu.insert"), options: insertOptions })
+            insertOptions.push(
+                {
+                    label: RED._("contextMenu.node"),
+                    onselect: function () {
+                        RED.view.showQuickAddDialog({
+                            position: [addX, addY],
+                            touchTrigger: true,
+                            splice: isSingleLink ? selection.links[0] : undefined,
+                            // spliceMultiple: isMultipleLinks
+                        })
                     },
-                    (hasLinks) ? { // has least 1 wire selected
-                        label: RED._("contextMenu.junction"),
-                        onselect: 'core:split-wires-with-junctions',
-                        disabled: !hasLinks
-                    } : {
-                        label: RED._("contextMenu.junction"),
-                        onselect: function () {
-                            const nn = {
-                                _def: { defaults: {} },
-                                type: 'junction',
-                                z: RED.workspaces.active(),
-                                id: RED.nodes.id(),
-                                x: addX,
-                                y: addY,
-                                w: 0, h: 0,
-                                outputs: 1,
-                                inputs: 1,
-                                dirty: true
-                            }
-                            const historyEvent = {
-                                dirty: RED.nodes.dirty(),
-                                t: 'add',
-                                junctions: [nn]
-                            }
-                            RED.nodes.addJunction(nn);
-                            RED.history.push(historyEvent);
-                            RED.nodes.dirty(true);
-                            RED.view.select({nodes: [nn] });
-                            RED.view.redraw(true)
-                        }
+                    disabled: !canEdit
+                },
+                (hasLinks) ? { // has least 1 wire selected
+                    label: RED._("contextMenu.junction"),
+                    onselect: 'core:split-wires-with-junctions',
+                    disabled: !canEdit || !hasLinks
+                } : {
+                    label: RED._("contextMenu.junction"),
+                    onselect: function () {
+                        const nn = {
+                            _def: { defaults: {} },
+                            type: 'junction',
+                            z: RED.workspaces.active(),
+                            id: RED.nodes.id(),
+                            x: addX,
+                            y: addY,
+                            w: 0, h: 0,
+                            outputs: 1,
+                            inputs: 1,
+                            dirty: true
+                        }
+                        const historyEvent = {
+                            dirty: RED.nodes.dirty(),
+                            t: 'add',
+                            junctions: [nn]
+                        }
+                        RED.nodes.addJunction(nn);
+                        RED.history.push(historyEvent);
+                        RED.nodes.dirty(true);
+                        RED.view.select({nodes: [nn] });
+                        RED.view.redraw(true)
                     },
-                    {
-                        label: RED._("contextMenu.linkNodes"),
-                        onselect: 'core:split-wire-with-link-nodes',
-                        disabled: !hasLinks
-                    }
-                ]
-
-
-
+                    disabled: !canEdit
+                },
+                {
+                    label: RED._("contextMenu.linkNodes"),
+                    onselect: 'core:split-wire-with-link-nodes',
+                    disabled: !canEdit || !hasLinks
+                },
+                null,
+                { onselect: 'core:show-import-dialog', label: RED._('common.label.import')},
+                { onselect: 'core:show-examples-import-dialog', label: RED._('menu.label.importExample') }
+            )
+            if (hasSelection && canEdit) {
+                const nodeOptions = []
+                if (!hasMultipleSelection && !isGroup) {
+                    nodeOptions.push(
+                        { onselect: 'core:show-node-help' },
+                        null
+                    )
+                }
+                nodeOptions.push(
+                    { onselect: 'core:enable-selected-nodes' },
+                    { onselect: 'core:disable-selected-nodes' },
+                    null,
+                    { onselect: 'core:show-selected-node-labels' },
+                    { onselect: 'core:hide-selected-node-labels' }
+                )
+                menuItems.push({
+                    label: RED._('sidebar.info.node'),
+                    options: nodeOptions
+                })
+                menuItems.push({
+                    label: RED._('sidebar.info.group'),
+                    options: [
+                        { onselect: 'core:group-selection' },
+                        { onselect: 'core:ungroup-selection', disabled: !hasGroup },
+                        null,
+                        { onselect: 'core:copy-group-style', disabled: !hasGroup },
+                        { onselect: 'core:paste-group-style', disabled: !hasGroup}
+                    ]
+                })
+                if (canRemoveFromGroup) {
+                    menuItems[menuItems.length - 1].options.push(
+                        null,
+                        { onselect: 'core:remove-selection-from-group', label: RED._("menu.label.groupRemoveSelection") }
+                    )
+                }
+            }
+            if (canEdit && hasMultipleSelection) {
+                menuItems.push({
+                    label: RED._('menu.label.arrange'),
+                    options: [
+                        { label:RED._("menu.label.alignLeft"), onselect: "core:align-selection-to-left"},
+                        { label:RED._("menu.label.alignCenter"), onselect: "core:align-selection-to-center"},
+                        { label:RED._("menu.label.alignRight"), onselect: "core:align-selection-to-right"},
+                        null,
+                        { label:RED._("menu.label.alignTop"), onselect: "core:align-selection-to-top"},
+                        { label:RED._("menu.label.alignMiddle"), onselect: "core:align-selection-to-middle"},
+                        { label:RED._("menu.label.alignBottom"), onselect: "core:align-selection-to-bottom"},
+                        null,
+                        { label:RED._("menu.label.distributeHorizontally"), onselect: "core:distribute-selection-horizontally"},
+                        { label:RED._("menu.label.distributeVertically"), onselect: "core:distribute-selection-vertically"}
+                    ]
+                })
             }
-        ]
 
-        menuItems.push(
-            null,
-            { onselect: 'core:undo', disabled: RED.history.list().length === 0 },
-            { onselect: 'core:redo', disabled: RED.history.listRedo().length === 0 },
-            null,
-            { onselect: 'core:cut-selection-to-internal-clipboard', label: RED._("keyboard.cutNode"), disabled: !hasSelection },
-            { onselect: 'core:copy-selection-to-internal-clipboard', label: RED._("keyboard.copyNode"), disabled: !hasSelection },
-            { onselect: 'core:paste-from-internal-clipboard', label: RED._("keyboard.pasteNode"), disabled: !RED.view.clipboard() },
-            { onselect: 'core:delete-selection', disabled: !canDelete },
-            { onselect: 'core:show-export-dialog', label: RED._("menu.label.export") },
-            { onselect: 'core:select-all-nodes' }
-        )
 
-        if (hasSelection) {
             menuItems.push(
                 null,
-                isGroup ?
-                    { onselect: 'core:ungroup-selection', disabled: !isGroup }
-                    : { onselect: 'core:group-selection', disabled: !hasSelection }
+                { onselect: 'core:undo', disabled: RED.history.list().length === 0 },
+                { onselect: 'core:redo', disabled: RED.history.listRedo().length === 0 },
+                null,
+                { onselect: 'core:cut-selection-to-internal-clipboard', label: RED._("keyboard.cutNode"), disabled: !canEdit || !hasSelection },
+                { onselect: 'core:copy-selection-to-internal-clipboard', label: RED._("keyboard.copyNode"), disabled: !hasSelection },
+                { onselect: 'core:paste-from-internal-clipboard', label: RED._("keyboard.pasteNode"), disabled: !canEdit || !RED.view.clipboard() },
+                { onselect: 'core:delete-selection', disabled: !canEdit || !canDelete },
+                { onselect: 'core:delete-selection-and-reconnect', label: RED._('keyboard.deleteReconnect'), disabled: !canEdit || !canDelete },
+                { onselect: 'core:show-export-dialog', label: RED._("menu.label.export") },
+                { onselect: 'core:select-all-nodes' },
             )
-            if (canRemoveFromGroup) {
-                menuItems.push({ onselect: 'core:remove-selection-from-group', label: RED._("menu.label.groupRemoveSelection") })
-            }
-
         }
 
         var direction = "right";
@@ -44567,6 +45745,11 @@ RED.subflow = (function() {
         var subflowInstances = [];
         if (activeSubflow) {
             RED.nodes.filterNodes({type:"subflow:"+activeSubflow.id}).forEach(function(n) {
+                const parentFlow = RED.nodes.workspace(n.z)
+                const wasLocked = parentFlow && parentFlow.locked
+                if (wasLocked) {
+                    parentFlow.locked = false
+                }
                 subflowInstances.push({
                     id: n.id,
                     changed: n.changed
@@ -44579,6 +45762,9 @@ RED.subflow = (function() {
                 n.resize = true;
                 n.dirty = true;
                 RED.editor.updateNodeProperties(n);
+                if (wasLocked) {
+                    parentFlow.locked = true
+                }
             });
             RED.editor.validateNode(activeSubflow);
             return {
@@ -44725,44 +45911,7 @@ RED.subflow = (function() {
 
         $("#red-ui-subflow-delete").on("click", function(event) {
             event.preventDefault();
-            var subflow = RED.nodes.subflow(RED.workspaces.active());
-            if (subflow.instances.length > 0) {
-                var msg = $('<div>')
-                $('<p>').text(RED._("subflow.subflowInstances",{count: subflow.instances.length})).appendTo(msg);
-                $('<p>').text(RED._("subflow.confirmDelete")).appendTo(msg);
-                var confirmDeleteNotification = RED.notify(msg, {
-                    modal: true,
-                    fixed: true,
-                    buttons: [
-                        {
-                            text: RED._('common.label.cancel'),
-                            click: function() {
-                                confirmDeleteNotification.close();
-                            }
-                        },
-                        {
-                            text: RED._('workspace.confirmDelete'),
-                            class: "primary",
-                            click: function() {
-                                confirmDeleteNotification.close();
-                                completeDelete();
-                            }
-                        }
-                    ]
-                });
-
-                return;
-            } else {
-                completeDelete();
-            }
-            function completeDelete() {
-                var startDirty = RED.nodes.dirty();
-                var historyEvent = removeSubflow(RED.workspaces.active());
-                historyEvent.t = 'delete';
-                historyEvent.dirty = startDirty;
-                RED.history.push(historyEvent);
-            }
-
+            RED.subflow.delete(RED.workspaces.active())
         });
 
         refreshToolbar(activeSubflow);
@@ -44775,7 +45924,51 @@ RED.subflow = (function() {
         $("#red-ui-workspace-toolbar").hide().empty();
         $("#red-ui-workspace-chart").css({"margin-top": "0"});
     }
+    function deleteSubflow(id) {
+        const subflow = RED.nodes.subflow(id || RED.workspaces.active());
+        if (!subflow) {
+            return
+        }
+        if (subflow.instances.length > 0) {
+            if (subflow.instances.some(sf => { const ws = RED.nodes.workspace(sf.z); return ws?ws.locked:false })) {
+                return
+            }
+            const msg = $('<div>')
+            $('<p>').text(RED._("subflow.subflowInstances",{count: subflow.instances.length})).appendTo(msg);
+            $('<p>').text(RED._("subflow.confirmDelete")).appendTo(msg);
+            const confirmDeleteNotification = RED.notify(msg, {
+                modal: true,
+                fixed: true,
+                buttons: [
+                    {
+                        text: RED._('common.label.cancel'),
+                        click: function() {
+                            confirmDeleteNotification.close();
+                        }
+                    },
+                    {
+                        text: RED._('workspace.confirmDelete'),
+                        class: "primary",
+                        click: function() {
+                            confirmDeleteNotification.close();
+                            completeDelete();
+                        }
+                    }
+                ]
+            });
 
+            return;
+        } else {
+            completeDelete();
+        }
+        function completeDelete() {
+            const startDirty = RED.nodes.dirty();
+            const historyEvent = removeSubflow(subflow.id);
+            historyEvent.t = 'delete';
+            historyEvent.dirty = startDirty;
+            RED.history.push(historyEvent);
+        }
+    }
     function removeSubflow(id, keepInstanceNodes) {
         // TODO:  A lot of this logic is common with RED.nodes.removeWorkspace
         var removedNodes = [];
@@ -44800,6 +45993,13 @@ RED.subflow = (function() {
         RED.nodes.groups(id).forEach(function(n) {
             removedGroups.push(n);
         })
+
+        var removedJunctions = RED.nodes.junctions(id)
+        for (var i=0;i<removedJunctions.length;i++) {
+            var removedEntities = RED.nodes.removeJunction(removedJunctions[i])
+            removedLinks = removedLinks.concat(removedEntities.links)
+        }
+
         var removedConfigNodes = [];
         for (var i=0;i<removedNodes.length;i++) {
             var removedEntities = RED.nodes.remove(removedNodes[i].id);
@@ -44830,6 +46030,7 @@ RED.subflow = (function() {
             nodes:removedNodes,
             links:removedLinks,
             groups: removedGroups,
+            junctions: removedJunctions,
             subflows: [activeSubflow]
         }
     }
@@ -44844,7 +46045,7 @@ RED.subflow = (function() {
             }
         });
         RED.events.on("view:selection-changed",function(selection) {
-            if (!selection.nodes) {
+            if (!selection.nodes || RED.workspaces.isActiveLocked()) {
                 RED.menu.setDisabled("menu-item-subflow-convert",true);
             } else {
                 RED.menu.setDisabled("menu-item-subflow-convert",false);
@@ -44907,6 +46108,9 @@ RED.subflow = (function() {
     }
 
     function convertToSubflow() {
+        if (RED.workspaces.isActiveLocked()) {
+            return
+        }
         var selection = RED.view.selection();
         if (!selection.nodes) {
             RED.notify(RED._("subflow.errors.noNodesSelected"),"error");
@@ -45062,7 +46266,7 @@ RED.subflow = (function() {
         }
         subflowInstance._def = RED.nodes.getType(subflowInstance.type);
         RED.editor.validateNode(subflowInstance);
-        RED.nodes.add(subflowInstance);
+        subflowInstance = RED.nodes.add(subflowInstance);
 
         if (containingGroup) {
             RED.group.addToGroup(containingGroup, subflowInstance);
@@ -45226,7 +46430,6 @@ RED.subflow = (function() {
 
 
     function buildEnvUIRow(row, tenv, ui, node) {
-        console.log(tenv, ui)
         ui.label = ui.label||{};
         if ((tenv.type === "cred" || (tenv.parent && tenv.parent.type === "cred")) && !ui.type) {
             ui.type = "cred";
@@ -45617,7 +46820,10 @@ RED.subflow = (function() {
         init: init,
         createSubflow: createSubflow,
         convertToSubflow: convertToSubflow,
+        // removeSubflow: Internal function to remove subflow
         removeSubflow: removeSubflow,
+        // delete: Prompt user for confirmation
+        delete: deleteSubflow,
         refresh: refresh,
         removeInput: removeSubflowInput,
         removeOutput: removeSubflowOutput,
@@ -45732,6 +46938,7 @@ RED.group = (function() {
             RED.editor.colorPicker.create({
                 id:"node-input-style-stroke",
                 value: style.stroke || defaultGroupStyle.stroke || "#a4a4a4",
+                defaultValue: "#a4a4a4",
                 palette: colorPalette,
                 cellPerRow: colorCount,
                 cellWidth: 16,
@@ -45743,6 +46950,7 @@ RED.group = (function() {
             RED.editor.colorPicker.create({
                 id:"node-input-style-fill",
                 value: style.fill || defaultGroupStyle.fill ||"none",
+                defaultValue: "none",
                 palette: colorPalette,
                 cellPerRow: colorCount,
                 cellWidth: 16,
@@ -45760,6 +46968,7 @@ RED.group = (function() {
             RED.editor.colorPicker.create({
                 id:"node-input-style-color",
                 value: style.color || defaultGroupStyle.color ||"#a4a4a4",
+                defaultValue: "#a4a4a4",
                 palette: colorPalette,
                 cellPerRow: colorCount,
                 cellWidth: 16,
@@ -45816,6 +47025,8 @@ RED.group = (function() {
             var activateMerge = false;
             var activateRemove = false;
             var singleGroupSelected = false;
+            var locked = RED.workspaces.isActiveLocked()
+
             if (activateGroup) {
                 singleGroupSelected = selection.nodes.length === 1 && selection.nodes[0].type === 'group';
                 selection.nodes.forEach(function (n) {
@@ -45830,12 +47041,12 @@ RED.group = (function() {
                     activateMerge = (selection.nodes.length > 1);
                 }
             }
-            RED.menu.setDisabled("menu-item-group-group", !activateGroup);
-            RED.menu.setDisabled("menu-item-group-ungroup", !activateUngroup);
-            RED.menu.setDisabled("menu-item-group-merge", !activateMerge);
-            RED.menu.setDisabled("menu-item-group-remove", !activateRemove);
+            RED.menu.setDisabled("menu-item-group-group", locked || !activateGroup);
+            RED.menu.setDisabled("menu-item-group-ungroup", locked || !activateUngroup);
+            RED.menu.setDisabled("menu-item-group-merge", locked || !activateMerge);
+            RED.menu.setDisabled("menu-item-group-remove", locked || !activateRemove);
             RED.menu.setDisabled("menu-item-edit-copy-group-style", !singleGroupSelected);
-            RED.menu.setDisabled("menu-item-edit-paste-group-style", !activateUngroup);
+            RED.menu.setDisabled("menu-item-edit-paste-group-style", locked || !activateUngroup);
         });
 
         RED.actions.add("core:group-selection", function() { groupSelection() })
@@ -45892,6 +47103,7 @@ RED.group = (function() {
         }
     }
     function pasteGroupStyle() {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (RED.view.state() !== RED.state.DEFAULT) { return }
         if (groupStyleClipboard) {
             var selection = RED.view.selection();
@@ -45926,6 +47138,7 @@ RED.group = (function() {
     }
 
     function groupSelection() {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (RED.view.state() !== RED.state.DEFAULT) { return }
         var selection = RED.view.selection();
         if (selection.nodes) {
@@ -45944,6 +47157,7 @@ RED.group = (function() {
         }
     }
     function ungroupSelection() {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (RED.view.state() !== RED.state.DEFAULT) { return }
         var selection = RED.view.selection();
         if (selection.nodes) {
@@ -45967,6 +47181,7 @@ RED.group = (function() {
     }
 
     function ungroup(g) {
+        if (RED.workspaces.isActiveLocked()) { return }
         var nodes = [];
         var parentGroup = RED.nodes.group(g.g);
         g.nodes.forEach(function(n) {
@@ -45993,6 +47208,7 @@ RED.group = (function() {
     }
 
     function mergeSelection() {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (RED.view.state() !== RED.state.DEFAULT) { return }
         var selection = RED.view.selection();
         if (selection.nodes) {
@@ -46062,6 +47278,7 @@ RED.group = (function() {
     }
 
     function removeSelection() {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (RED.view.state() !== RED.state.DEFAULT) { return }
         var selection = RED.view.selection();
         if (selection.nodes) {
@@ -46089,6 +47306,7 @@ RED.group = (function() {
         }
     }
     function createGroup(nodes) {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (nodes.length === 0) {
             return;
         }
@@ -46111,7 +47329,7 @@ RED.group = (function() {
         }
 
         group.z = nodes[0].z;
-        RED.nodes.addGroup(group);
+        group = RED.nodes.addGroup(group);
 
         try {
             addToGroup(group,nodes);
@@ -46194,6 +47412,7 @@ RED.group = (function() {
         markDirty(group);
     }
     function removeFromGroup(group, nodes, reparent) {
+        if (RED.workspaces.isActiveLocked()) { return }
         if (!Array.isArray(nodes)) {
             nodes = [nodes];
         }
@@ -47196,7 +48415,7 @@ RED.projects = (function() {
                         var sshwarningRow = $('<div class="red-ui-projects-dialog-screen-create-row-auth-error-no-keys"></div>').hide().appendTo(subrow);
                         $('<div class="form-row"><i class="fa fa-warning"></i> '+RED._("projects.clone-project.ssh-key-desc")+'</div>').appendTo(sshwarningRow);
                         subrow = $('<div style="text-align: center">').appendTo(sshwarningRow);
-                        $('<button class="red-ui-button red-ui-projects-dialog-button">'+RED._("projects.clone-project.ssh-key-add")+'</button>').appendTo(subrow).on("click", function(e) {
+                        $('<button type="button" class="red-ui-button red-ui-projects-dialog-button">'+RED._("projects.clone-project.ssh-key-add")+'</button>').appendTo(subrow).on("click", function(e) {
                             e.preventDefault();
                             dialog.dialog( "close" );
                             RED.userSettings.show('gitconfig');
@@ -47822,11 +49041,11 @@ RED.projects = (function() {
 
                         row = $('<div class="form-row button-group"></div>').appendTo(container);
 
-                        var openProject = $('<button data-type="open" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i style="position: absolute;" class="fa fa-folder-open"></i><br/>'+RED._("projects.create.open")+'</button>').appendTo(row);
-                        var createAsEmpty = $('<button data-type="empty" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i style="position: absolute;" class="fa fa-asterisk"></i><br/>'+RED._("projects.create.create")+'</button>').appendTo(row);
-                        // var createAsCopy = $('<button data-type="copy" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i class="fa fa-long-arrow-right fa-2x"></i><i class="fa fa-archive fa-2x"></i><br/>Copy existing</button>').appendTo(row);
-                        var createAsClone = $('<button data-type="clone" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i style="position: absolute;" class="fa fa-git"></i><br/>'+RED._("projects.create.clone")+'</button>').appendTo(row);
-                        // var createAsClone = $('<button data-type="clone" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-git fa-2x"></i><i class="fa fa-arrows-h fa-2x"></i><i class="fa fa-archive fa-2x"></i><br/>Clone Repository</button>').appendTo(row);
+                        var openProject = $('<button type="button" data-type="open" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i style="position: absolute;" class="fa fa-folder-open"></i><br/>'+RED._("projects.create.open")+'</button>').appendTo(row);
+                        var createAsEmpty = $('<button type="button" data-type="empty" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i style="position: absolute;" class="fa fa-asterisk"></i><br/>'+RED._("projects.create.create")+'</button>').appendTo(row);
+                        // var createAsCopy = $('<button type="button" data-type="copy" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i class="fa fa-long-arrow-right fa-2x"></i><i class="fa fa-archive fa-2x"></i><br/>Copy existing</button>').appendTo(row);
+                        var createAsClone = $('<button type="button" data-type="clone" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-archive fa-2x"></i><i style="position: absolute;" class="fa fa-git"></i><br/>'+RED._("projects.create.clone")+'</button>').appendTo(row);
+                        // var createAsClone = $('<button type="button" data-type="clone" class="red-ui-button red-ui-projects-dialog-button red-ui-projects-dialog-screen-create-type toggle"><i class="fa fa-git fa-2x"></i><i class="fa fa-arrows-h fa-2x"></i><i class="fa fa-archive fa-2x"></i><br/>Clone Repository</button>').appendTo(row);
                         row.find(".red-ui-projects-dialog-screen-create-type").on("click", function(evt) {
                             evt.preventDefault();
                             container.find(".red-ui-projects-dialog-screen-create-type").removeClass('selected');
@@ -47922,7 +49141,7 @@ RED.projects = (function() {
                         var credentialsLeftBox = $('<div class="red-ui-projects-dialog-credentials-box-left">').appendTo(credentialsBox);
 
                         var credentialsEnabledBox = $('<div class="form-row red-ui-projects-dialog-credentials-box-enabled"></div>').appendTo(credentialsLeftBox);
-                        $('<label class="red-ui-projects-edit-form-inline-label"><input type="radio" name="projects-encryption-type" value="enabled"> <i class="fa fa-lock"></i> <span>'+RED._("projects.encryption-config.enable")+'</span></label>').appendTo(credentialsEnabledBox);
+                        $('<label class="red-ui-projects-edit-form-inline-label"><input type="radio" name="projects-encryption-type" value="enabled" checked> <i class="fa fa-lock"></i> <span>'+RED._("projects.encryption-config.enable")+'</span></label>').appendTo(credentialsEnabledBox);
                         var credentialsDisabledBox = $('<div class="form-row red-ui-projects-dialog-credentials-box-disabled disabled"></div>').appendTo(credentialsLeftBox);
                         $('<label class="red-ui-projects-edit-form-inline-label"><input type="radio" name="projects-encryption-type" value="disabled"> <i class="fa fa-unlock"></i> <span>'+RED._("projects.encryption-config.disable")+'</span></label>').appendTo(credentialsDisabledBox);
 
@@ -48048,7 +49267,7 @@ RED.projects = (function() {
                         var sshwarningRow = $('<div class="red-ui-projects-dialog-screen-create-row-auth-error-no-keys"></div>').hide().appendTo(subrow);
                         $('<div class="form-row"><i class="fa fa-warning"></i> '+RED._("projects.create.desc2")+'</div>').appendTo(sshwarningRow);
                         subrow = $('<div style="text-align: center">').appendTo(sshwarningRow);
-                        $('<button class="red-ui-button red-ui-projects-dialog-button">'+RED._("projects.create.add-ssh-key")+'</button>').appendTo(subrow).on("click", function(e) {
+                        $('<button type="button" class="red-ui-button red-ui-projects-dialog-button">'+RED._("projects.create.add-ssh-key")+'</button>').appendTo(subrow).on("click", function(e) {
                             e.preventDefault();
                             $('#red-ui-projects-dialog-cancel').trigger("click");
                             RED.userSettings.show('gitconfig');
@@ -48282,14 +49501,14 @@ RED.projects = (function() {
     function deleteProject(row,name,done) {
         var cover = $('<div class="red-ui-projects-dialog-project-list-entry-delete-confirm"></div>').on("click", function(evt) { evt.stopPropagation(); }).appendTo(row);
         $('<span>').text(RED._("projects.delete.confirm")).appendTo(cover);
-        $('<button class="red-ui-button red-ui-projects-dialog-button">'+RED._("common.label.cancel")+'</button>')
+        $('<button type="button" class="red-ui-button red-ui-projects-dialog-button">'+RED._("common.label.cancel")+'</button>')
             .appendTo(cover)
             .on("click", function(e) {
                 e.stopPropagation();
                 cover.remove();
                 done(true);
             });
-        $('<button class="red-ui-button red-ui-projects-dialog-button primary">'+RED._("common.label.delete")+'</button>')
+        $('<button type="button" class="red-ui-button red-ui-projects-dialog-button primary">'+RED._("common.label.delete")+'</button>')
             .appendTo(cover)
             .on("click", function(e) {
                 e.stopPropagation();
@@ -48473,7 +49692,7 @@ RED.projects = (function() {
                 header.addClass("selectable");
 
                 var tools = $('<div class="red-ui-projects-dialog-project-list-entry-tools"></div>').appendTo(header);
-                $('<button class="red-ui-button red-ui-projects-dialog-button red-ui-button-small" style="float: right;"><i class="fa fa-trash"></i></button>')
+                $('<button type="button" class="red-ui-button red-ui-projects-dialog-button red-ui-button-small" style="float: right;"><i class="fa fa-trash"></i></button>')
                     .appendTo(tools)
                     .on("click", function(e) {
                         e.stopPropagation();
@@ -53229,10 +54448,15 @@ RED.touch.radialMenu = (function() {
 
     function listTour() {
         return [
+            {
+                id: "3_1",
+                label: "3.1",
+                path: "./tours/welcome.js"
+            },
             {
                 id: "3_0",
                 label: "3.0",
-                path: "./tours/welcome.js"
+                path: "./tours/3.0/welcome.js"
             },
             {
                 id: "2_2",