diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6770f3158..29b8dabb0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,18 @@
+#### 0.19.4: Maintenance Release
+
+ - Fix race condition in non-cache lfs context Fixes #1888
+ - LocalFileSystem Context: Remove extra flush code
+ - Prevent race condition in caching mode of lfs context (#1889)
+ - Allow context store name to be provided in the key
+ - Switch node: only use promises when absolutely necessary
+ - Fix dbl-click handling on webkit-based browsers
+ - Ensure context.flow/global cannot be deleted or enumerated
+ - Handle context.get with multiple levels of unknown key Fixes #1883
+ - Fix global.get("foo.bar") for functionGlobalContext set values
+ - Fix node color bug (#1877)
+ - Merge pull request #1857 from cclauss/patch-1
+ - Define raw_input() in Python 3 & fix time.sleep()
+
 #### 0.19.3: Maintenance Release
 
  - Split node - fix complete to send msg for k/v object
diff --git a/editor/js/ui/utils.js b/editor/js/ui/utils.js
index 8e6654a7a..c944f3504 100644
--- a/editor/js/ui/utils.js
+++ b/editor/js/ui/utils.js
@@ -826,7 +826,11 @@ RED.utils = (function() {
             }
             result = nodeColorCache[type];
         }
-        return result;
+        if (result) {
+            return result;
+        } else {
+            return "#ddd";
+        }
     }
 
     function addSpinnerOverlay(container,contain) {
diff --git a/editor/js/ui/view.js b/editor/js/ui/view.js
index 4688c15cd..f3928351f 100644
--- a/editor/js/ui/view.js
+++ b/editor/js/ui/view.js
@@ -1766,7 +1766,7 @@ RED.view = (function() {
         clickTime = now;
 
         dblClickPrimed = (lastClickNode == mousedown_node &&
-            d3.event.buttons === 1 &&
+            d3.event.button === 0 &&
             !d3.event.shiftKey && !d3.event.metaKey && !d3.event.altKey && !d3.event.ctrlKey);
         lastClickNode = mousedown_node;
 
diff --git a/nodes/99-sample.html.demo b/nodes/99-sample.html.demo
index 94e049e31..c7548b032 100644
--- a/nodes/99-sample.html.demo
+++ b/nodes/99-sample.html.demo
@@ -67,6 +67,7 @@
         },
         inputs:1,               // set the number of inputs - only 0 or 1
         outputs:1,              // set the number of outputs - 0 to n
+        color: "#ddd",          // set icon color
         // set the icon (held in icons dir below where you save the node)
         icon: "myicon.png",     // saved in  icons/myicon.png
         label: function() {     // sets the default label contents
diff --git a/nodes/core/hardware/nrgpio.py b/nodes/core/hardware/nrgpio.py
index 0cde0e4df..7908ca117 100755
--- a/nodes/core/hardware/nrgpio.py
+++ b/nodes/core/hardware/nrgpio.py
@@ -21,7 +21,12 @@ import os
 import subprocess
 from time import sleep
 
-bounce = 25;
+try:
+    raw_input          # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+bounce = 25
 
 if len(sys.argv) > 2:
     cmd = sys.argv[1].lower()
@@ -198,7 +203,7 @@ if len(sys.argv) > 2:
     elif cmd == "kbd":  # catch keyboard button events
         try:
             while not os.path.isdir("/dev/input/by-path"):
-                time.sleep(10)
+                sleep(10)
             infile = subprocess.check_output("ls /dev/input/by-path/ | grep -m 1 'kbd'", shell=True).strip()
             infile_path = "/dev/input/by-path/" + infile
             EVENT_SIZE = struct.calcsize('llHHI')
diff --git a/nodes/core/logic/10-switch.js b/nodes/core/logic/10-switch.js
index 89593047e..1d9c52971 100644
--- a/nodes/core/logic/10-switch.js
+++ b/nodes/core/logic/10-switch.js
@@ -92,31 +92,80 @@ module.exports = function(RED) {
     }
 
     function getProperty(node,msg) {
-        return new Promise((resolve,reject) => {
+        if (node.useAsyncRules) {
+            return new Promise((resolve,reject) => {
+                if (node.propertyType === 'jsonata') {
+                    RED.util.evaluateJSONataExpression(node.property,msg,(err,value) => {
+                        if (err) {
+                            reject(RED._("switch.errors.invalid-expr",{error:err.message}));
+                        } else {
+                            resolve(value);
+                        }
+                    });
+                } else {
+                    RED.util.evaluateNodeProperty(node.property,node.propertyType,node,msg,(err,value) => {
+                        if (err) {
+                            resolve(undefined);
+                        } else {
+                            resolve(value);
+                        }
+                    });
+                }
+            });
+        } else {
             if (node.propertyType === 'jsonata') {
-                RED.util.evaluateJSONataExpression(node.property,msg,(err,value) => {
-                    if (err) {
-                        reject(RED._("switch.errors.invalid-expr",{error:err.message}));
-                    } else {
-                        resolve(value);
-                    }
-                });
+                try {
+                    return RED.util.evaluateJSONataExpression(node.property,msg);
+                } catch(err) {
+                    throw new Error(RED._("switch.errors.invalid-expr",{error:err.message}))
+                }
             } else {
-                RED.util.evaluateNodeProperty(node.property,node.propertyType,node,msg,(err,value) => {
-                    if (err) {
-                        resolve(undefined);
-                    } else {
-                        resolve(value);
-                    }
-                });
+                try {
+                    return RED.util.evaluateNodeProperty(node.property,node.propertyType,node,msg);
+                } catch(err) {
+                    return undefined;
+                }
             }
-        });
+        }
     }
 
     function getV1(node,msg,rule,hasParts) {
-        return new Promise( (resolve,reject) => {
+        if (node.useAsyncRules) {
+            return new Promise( (resolve,reject) => {
+                if (rule.vt === 'prev') {
+                    resolve(node.previousValue);
+                } else if (rule.vt === 'jsonata') {
+                    var exp = rule.v;
+                    if (rule.t === 'jsonata_exp') {
+                        if (hasParts) {
+                            exp.assign("I", msg.parts.index);
+                            exp.assign("N", msg.parts.count);
+                        }
+                    }
+                    RED.util.evaluateJSONataExpression(exp,msg,(err,value) => {
+                        if (err) {
+                            reject(RED._("switch.errors.invalid-expr",{error:err.message}));
+                        } else {
+                            resolve(value);
+                        }
+                    });
+                } else if (rule.vt === 'json') {
+                    resolve("json"); // TODO: ?! invalid case
+                } else if (rule.vt === 'null') {
+                    resolve("null");
+                } else {
+                    RED.util.evaluateNodeProperty(rule.v,rule.vt,node,msg, function(err,value) {
+                        if (err) {
+                            resolve(undefined);
+                        } else {
+                            resolve(value);
+                        }
+                    });
+                }
+            });
+        } else {
             if (rule.vt === 'prev') {
-                resolve(node.previousValue);
+                return node.previousValue;
             } else if (rule.vt === 'jsonata') {
                 var exp = rule.v;
                 if (rule.t === 'jsonata_exp') {
@@ -125,83 +174,120 @@ module.exports = function(RED) {
                         exp.assign("N", msg.parts.count);
                     }
                 }
-                RED.util.evaluateJSONataExpression(exp,msg,(err,value) => {
-                    if (err) {
-                        reject(RED._("switch.errors.invalid-expr",{error:err.message}));
-                    } else {
-                        resolve(value);
-                    }
-                });
+                try {
+                    return RED.util.evaluateJSONataExpression(exp,msg);
+                } catch(err) {
+                    throw new Error(RED._("switch.errors.invalid-expr",{error:err.message}))
+                }
             } else if (rule.vt === 'json') {
-                resolve("json");
+                return "json"; // TODO: ?! invalid case
             } else if (rule.vt === 'null') {
-                resolve("null");
+                return "null";
             } else {
-                RED.util.evaluateNodeProperty(rule.v,rule.vt,node,msg, function(err,value) {
-                    if (err) {
-                        resolve(undefined);
-                    } else {
-                        resolve(value);
-                    }
-                });
+                try {
+                    return RED.util.evaluateNodeProperty(rule.v,rule.vt,node,msg);
+                } catch(err) {
+                    return undefined;
+                }
             }
-        });
+        }
     }
 
     function getV2(node,msg,rule) {
-        return new Promise((resolve,reject) => {
+        if (node.useAsyncRules) {
+            return new Promise((resolve,reject) => {
+                var v2 = rule.v2;
+                if (rule.v2t === 'prev') {
+                    resolve(node.previousValue);
+                } else if (rule.v2t === 'jsonata') {
+                    RED.util.evaluateJSONataExpression(rule.v2,msg,(err,value) => {
+                        if (err) {
+                            reject(RED._("switch.errors.invalid-expr",{error:err.message}));
+                        } else {
+                            resolve(value);
+                        }
+                    });
+                } else if (typeof v2 !== 'undefined') {
+                    RED.util.evaluateNodeProperty(rule.v2,rule.v2t,node,msg, function(err,value) {
+                        if (err) {
+                            resolve(undefined);
+                        } else {
+                            resolve(value);
+                        }
+                    });
+                } else {
+                    resolve(v2);
+                }
+            })
+        } else {
             var v2 = rule.v2;
             if (rule.v2t === 'prev') {
-                resolve(node.previousValue);
+                return node.previousValue;
             } else if (rule.v2t === 'jsonata') {
-                RED.util.evaluateJSONataExpression(rule.v2,msg,(err,value) => {
-                    if (err) {
-                        reject(RED._("switch.errors.invalid-expr",{error:err.message}));
-                    } else {
-                        resolve(value);
-                    }
-                });
+                try {
+                    return RED.util.evaluateJSONataExpression(rule.v2,msg);
+                } catch(err) {
+                    throw new Error(RED._("switch.errors.invalid-expr",{error:err.message}))
+                }
             } else if (typeof v2 !== 'undefined') {
-                RED.util.evaluateNodeProperty(rule.v2,rule.v2t,node,msg, function(err,value) {
-                    if (err) {
-                        resolve(undefined);
-                    } else {
-                        resolve(value);
-                    }
-                });
+                try {
+                    return RED.util.evaluateNodeProperty(rule.v2,rule.v2t,node,msg);
+                } catch(err) {
+                    return undefined;
+                }
             } else {
-                resolve(v2);
+                return v2;
             }
-        })
+        }
     }
 
     function applyRule(node, msg, property, state) {
-        return new Promise((resolve,reject) => {
+        if (node.useAsyncRules) {
+            return new Promise((resolve,reject) => {
 
-            var rule = node.rules[state.currentRule];
-            var v1,v2;
+                var rule = node.rules[state.currentRule];
+                var v1,v2;
 
-            getV1(node,msg,rule,state.hasParts).then(value => {
-                v1 = value;
-            }).then(()=>getV2(node,msg,rule)).then(value => {
-                v2 = value;
-            }).then(() => {
-                if (rule.t == "else") {
-                    property = state.elseflag;
-                    state.elseflag = true;
-                }
-                if (operators[rule.t](property,v1,v2,rule.case,msg.parts)) {
-                    state.onward.push(msg);
-                    state.elseflag = false;
-                    if (node.checkall == "false") {
-                        return resolve(false);
+                getV1(node,msg,rule,state.hasParts).then(value => {
+                    v1 = value;
+                }).then(()=>getV2(node,msg,rule)).then(value => {
+                    v2 = value;
+                }).then(() => {
+                    if (rule.t == "else") {
+                        property = state.elseflag;
+                        state.elseflag = true;
                     }
-                } else {
-                    state.onward.push(null);
+                    if (operators[rule.t](property,v1,v2,rule.case,msg.parts)) {
+                        state.onward.push(msg);
+                        state.elseflag = false;
+                        if (node.checkall == "false") {
+                            return resolve(false);
+                        }
+                    } else {
+                        state.onward.push(null);
+                    }
+                    resolve(state.currentRule < node.rules.length - 1);
+                });
+            })
+        } else {
+            var rule = node.rules[state.currentRule];
+            var v1 = getV1(node,msg,rule,state.hasParts);
+            var v2 = getV2(node,msg,rule);
+            if (rule.t == "else") {
+                property = state.elseflag;
+                state.elseflag = true;
+            }
+            if (operators[rule.t](property,v1,v2,rule.case,msg.parts)) {
+                state.onward.push(msg);
+                state.elseflag = false;
+                if (node.checkall == "false") {
+                    return false;
                 }
-                resolve(state.currentRule < node.rules.length - 1);
-            });
-        })
+            } else {
+                state.onward.push(null);
+            }
+            return state.currentRule < node.rules.length - 1
+        }
     }
 
     function applyRules(node, msg, property,state) {
@@ -215,7 +301,18 @@ module.exports = function(RED) {
                                 msg.parts.hasOwnProperty("index")
             }
         }
-        return applyRule(node,msg,property,state).then(hasMore => {
+        if (node.useAsyncRules) {
+            return applyRule(node,msg,property,state).then(hasMore => {
+                if (hasMore) {
+                    state.currentRule++;
+                    return applyRules(node,msg,property,state);
+                } else {
+                    node.previousValue = property;
+                    return state.onward;
+                }
+            });
+        } else {
+            var hasMore = applyRule(node,msg,property,state);
             if (hasMore) {
                 state.currentRule++;
                 return applyRules(node,msg,property,state);
@@ -223,7 +320,7 @@ module.exports = function(RED) {
                 node.previousValue = property;
                 return state.onward;
             }
-        });
+        }
     }
 
 
@@ -248,6 +345,14 @@ module.exports = function(RED) {
         var valid = true;
         var repair = n.repair;
         var needsCount = repair;
+        this.useAsyncRules = (
+            this.propertyType === 'flow' ||
+            this.propertyType === 'global' || (
+                this.propertyType === 'jsonata' &&
+                /\$(flow|global)Context/.test(this.property)
+            )
+        );
+
         for (var i=0; i<this.rules.length; i+=1) {
             var rule = this.rules[i];
             needsCount = needsCount || ((rule.t === "tail") || (rule.t === "jsonata_exp"));
@@ -258,6 +363,13 @@ module.exports = function(RED) {
                     rule.vt = 'str';
                 }
             }
+            this.useAsyncRules = this.useAsyncRules || (
+                rule.vt === 'flow' ||
+                rule.vt === 'global' || (
+                    rule.vt === 'jsonata' &&
+                    /\$(flow|global)Context/.test(rule.v)
+                )
+            );
             if (rule.vt === 'num') {
                 if (!isNaN(Number(rule.v))) {
                     rule.v = Number(rule.v);
@@ -270,6 +382,9 @@ module.exports = function(RED) {
                     valid = false;
                 }
             }
+            if (rule.vt === 'flow' || rule.vt === 'global' || rule.vt === 'jsonata') {
+                this.useAsyncRules = true;
+            }
             if (typeof rule.v2 !== 'undefined') {
                 if (!rule.v2t) {
                     if (!isNaN(Number(rule.v2))) {
@@ -278,6 +393,13 @@ module.exports = function(RED) {
                         rule.v2t = 'str';
                     }
                 }
+                this.useAsyncRules = this.useAsyncRules || (
+                    rule.v2t === 'flow' ||
+                    rule.v2t === 'global' || (
+                        rule.v2t === 'jsonata' &&
+                        /\$(flow|global)Context/.test(rule.v2)
+                    )
+                );
                 if (rule.v2t === 'num') {
                     rule.v2 = Number(rule.v2);
                 } else if (rule.v2t === 'jsonata') {
@@ -290,7 +412,6 @@ module.exports = function(RED) {
                 }
             }
         }
-
         if (!valid) {
             return;
         }
@@ -420,18 +541,32 @@ module.exports = function(RED) {
             if (needsCount && checkParts && hasParts) {
                 return addMessageToPending(msg);
             }
-            return getProperty(node,msg)
-                    .then(property => applyRules(node,msg,property))
-                    .then(onward => {
-                        if (!repair || !hasParts) {
-                            node.send(onward);
-                        }
-                        else {
-                            sendGroupMessages(onward, msg);
-                        }
-                    }).catch(err => {
-                        node.warn(err);
-                    });
+            if (node.useAsyncRules) {
+                return getProperty(node,msg)
+                        .then(property => applyRules(node,msg,property))
+                        .then(onward => {
+                            if (!repair || !hasParts) {
+                                node.send(onward);
+                            }
+                            else {
+                                sendGroupMessages(onward, msg);
+                            }
+                        }).catch(err => {
+                            node.warn(err);
+                        });
+            } else {
+                try {
+                    var property = getProperty(node,msg);
+                    var onward = applyRules(node,msg,property);
+                    if (!repair || !hasParts) {
+                        node.send(onward);
+                    } else {
+                        sendGroupMessages(onward, msg);
+                    }
+                } catch(err) {
+                    node.warn(err);
+                }
+            }
         }
 
         function clearPending() {
@@ -473,7 +608,11 @@ module.exports = function(RED) {
         }
 
         this.on('input', function(msg) {
-            processMessageQueue(msg);
+            if (node.useAsyncRules) {
+                processMessageQueue(msg);
+            } else {
+                processMessage(msg,true);
+            }
         });
 
         this.on('close', function() {
diff --git a/package.json b/package.json
index 59e6161c0..c0bf3b94d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "node-red",
-  "version": "0.19.3",
+  "version": "0.19.4",
   "description": "A visual tool for wiring the Internet of Things",
   "homepage": "http://nodered.org",
   "license": "Apache-2.0",
diff --git a/red/runtime/nodes/context/index.js b/red/runtime/nodes/context/index.js
index be79eb00e..d08734a2f 100644
--- a/red/runtime/nodes/context/index.js
+++ b/red/runtime/nodes/context/index.js
@@ -17,6 +17,7 @@
 var clone = require("clone");
 var log = require("../../log");
 var memory = require("./memory");
+var util = require("../../util");
 
 var settings;
 
@@ -209,104 +210,131 @@ function createContext(id,seed) {
         insertSeedValues = function(keys,values) {
             if (!Array.isArray(keys)) {
                 if (values[0] === undefined) {
-                    values[0] = seed[keys];
+                    values[0] = util.getObjectProperty(seed,keys);
                 }
             } else {
                 for (var i=0;i<keys.length;i++) {
                     if (values[i] === undefined) {
-                        values[i] = seed[keys[i]];
+                        values[i] = util.getObjectProperty(seed,keys[i]);
                     }
                 }
             }
         }
     }
+    Object.defineProperties(obj, {
+        get: {
+            value: function(key, storage, callback) {
+                var context;
 
-    obj.get = function(key, storage, callback) {
-        var context;
-        if (!storage && !callback) {
-            context = stores["_"];
-        } else {
-            if (typeof storage === 'function') {
-                callback = storage;
-                storage = "_";
-            }
-            if (callback && typeof callback !== 'function'){
-                throw new Error("Callback must be a function");
-            }
-            context = getContextStorage(storage);
-        }
-        if (callback) {
-            if (!seed) {
-                context.get(scope,key,callback);
-            } else {
-                context.get(scope,key,function() {
-                    if (arguments[0]) {
-                        callback(arguments[0]);
-                        return;
+                if (!callback && typeof storage === 'function') {
+                    callback = storage;
+                    storage = undefined;
+                }
+                if (callback && typeof callback !== 'function'){
+                    throw new Error("Callback must be a function");
+                }
+
+                if (!Array.isArray(key)) {
+                    var keyParts = util.parseContextStore(key);
+                    key = keyParts.key;
+                    if (!storage) {
+                        storage = keyParts.store || "_";
                     }
-                    var results = Array.prototype.slice.call(arguments,[1]);
-                    insertSeedValues(key,results);
-                    // Put the err arg back
-                    results.unshift(undefined);
-                    callback.apply(null,results);
-                });
-            }
-        } else {
-            // No callback, attempt to do this synchronously
-            var results = context.get(scope,key);
-            if (seed) {
-                if (Array.isArray(key)) {
-                    insertSeedValues(key,results);
-                } else if (results === undefined){
-                    results = seed[key];
+                } else {
+                    if (!storage) {
+                        storage = "_";
+                    }
+                }
+                context = getContextStorage(storage);
+
+                if (callback) {
+                    if (!seed) {
+                        context.get(scope,key,callback);
+                    } else {
+                        context.get(scope,key,function() {
+                            if (arguments[0]) {
+                                callback(arguments[0]);
+                                return;
+                            }
+                            var results = Array.prototype.slice.call(arguments,[1]);
+                            insertSeedValues(key,results);
+                            // Put the err arg back
+                            results.unshift(undefined);
+                            callback.apply(null,results);
+                        });
+                    }
+                } else {
+                    // No callback, attempt to do this synchronously
+                    var results = context.get(scope,key);
+                    if (seed) {
+                        if (Array.isArray(key)) {
+                            insertSeedValues(key,results);
+                        } else if (results === undefined){
+                            results = util.getObjectProperty(seed,key);
+                        }
+                    }
+                    return results;
+                }
+            }
+        },
+        set: {
+            value: function(key, value, storage, callback) {
+                var context;
+
+                if (!callback && typeof storage === 'function') {
+                    callback = storage;
+                    storage = undefined;
+                }
+                if (callback && typeof callback !== 'function'){
+                    throw new Error("Callback must be a function");
+                }
+
+                if (!Array.isArray(key)) {
+                    var keyParts = util.parseContextStore(key);
+                    key = keyParts.key;
+                    if (!storage) {
+                        storage = keyParts.store || "_";
+                    }
+                } else {
+                    if (!storage) {
+                        storage = "_";
+                    }
+                }
+                context = getContextStorage(storage);
+
+                context.set(scope, key, value, callback);
+            }
+        },
+        keys: {
+            value: function(storage, callback) {
+                var context;
+                if (!storage && !callback) {
+                    context = stores["_"];
+                } else {
+                    if (typeof storage === 'function') {
+                        callback = storage;
+                        storage = "_";
+                    }
+                    if (callback && typeof callback !== 'function') {
+                        throw new Error("Callback must be a function");
+                    }
+                    context = getContextStorage(storage);
+                }
+                if (seed) {
+                    if (callback) {
+                        context.keys(scope, function(err,keys) {
+                            callback(err,Array.from(new Set(seedKeys.concat(keys)).keys()));
+                        });
+                    } else {
+                        var keys = context.keys(scope);
+                        return Array.from(new Set(seedKeys.concat(keys)).keys())
+                    }
+                } else {
+                    return context.keys(scope, callback);
                 }
             }
-            return results;
         }
-    };
-    obj.set = function(key, value, storage, callback) {
-        var context;
-        if (!storage && !callback) {
-            context = stores["_"];
-        } else {
-            if (typeof storage === 'function') {
-                callback = storage;
-                storage = "_";
-            }
-            if (callback && typeof callback !== 'function') {
-                throw new Error("Callback must be a function");
-            }
-            context = getContextStorage(storage);
-        }
-        context.set(scope, key, value, callback);
-    };
-    obj.keys = function(storage, callback) {
-        var context;
-        if (!storage && !callback) {
-            context = stores["_"];
-        } else {
-            if (typeof storage === 'function') {
-                callback = storage;
-                storage = "_";
-            }
-            if (callback && typeof callback !== 'function') {
-                throw new Error("Callback must be a function");
-            }
-            context = getContextStorage(storage);
-        }
-        if (seed) {
-            if (callback) {
-                context.keys(scope, function(err,keys) {
-                    callback(err,Array.from(new Set(seedKeys.concat(keys)).keys()));
-                });
-            } else {
-                var keys = context.keys(scope);
-                return Array.from(new Set(seedKeys.concat(keys)).keys())
-            }
-        } else {
-            return context.keys(scope, callback);
-        }
-    };
+    });
     return obj;
 }
 
@@ -320,9 +348,13 @@ function getContext(localId,flowId) {
     }
     var newContext = createContext(contextId);
     if (flowId) {
-        newContext.flow = getContext(flowId);
+        Object.defineProperty(newContext, 'flow', {
+            value: getContext(flowId)
+        });
     }
-    newContext.global = contexts['global'];
+    Object.defineProperty(newContext, 'global', {
+        value: contexts['global']
+    })
     contexts[contextId] = newContext;
     return newContext;
 }
diff --git a/red/runtime/nodes/context/localfilesystem.js b/red/runtime/nodes/context/localfilesystem.js
index dc25b6290..0e6f8735b 100644
--- a/red/runtime/nodes/context/localfilesystem.js
+++ b/red/runtime/nodes/context/localfilesystem.js
@@ -140,6 +140,7 @@ function stringify(value) {
 function LocalFileSystem(config){
     this.config = config;
     this.storageBaseDir = getBasePath(this.config);
+    this.writePromise = Promise.resolve();
     if (config.hasOwnProperty('cache')?config.cache:true) {
         this.cache = MemoryStore({});
     }
@@ -213,12 +214,13 @@ LocalFileSystem.prototype.open = function(){
 }
 
 LocalFileSystem.prototype.close = function(){
-    if (this.cache && this._flushPendingWrites) {
+    var self = this;
+    if (this.cache && this._pendingWriteTimeout) {
         clearTimeout(this._pendingWriteTimeout);
         delete this._pendingWriteTimeout;
-        return this._flushPendingWrites();
+        this.flushInterval = 0;
     }
-    return Promise.resolve();
+    return this.writePromise;
 }
 
 LocalFileSystem.prototype.get = function(scope, key, callback) {
@@ -230,14 +232,31 @@ LocalFileSystem.prototype.get = function(scope, key, callback) {
     }
     var storagePath = getStoragePath(this.storageBaseDir ,scope);
     loadFile(storagePath + ".json").then(function(data){
+        var value;
         if(data){
             data = JSON.parse(data);
             if (!Array.isArray(key)) {
-                callback(null, util.getObjectProperty(data,key));
+                try {
+                    value = util.getObjectProperty(data,key);
+                } catch(err) {
+                    if (err.code === "INVALID_EXPR") {
+                        throw err;
+                    }
+                    value = undefined;
+                }
+                callback(null, value);
             } else {
                 var results = [undefined];
                 for (var i=0;i<key.length;i++) {
-                    results.push(util.getObjectProperty(data,key[i]))
+                    try {
+                        value = util.getObjectProperty(data,key[i]);
+                    } catch(err) {
+                        if (err.code === "INVALID_EXPR") {
+                            throw err;
+                        }
+                        value = undefined;
+                    }
+                    results.push(value)
                 }
                 callback.apply(null,results);
             }
@@ -260,15 +279,17 @@ LocalFileSystem.prototype.set = function(scope, key, value, callback) {
             return;
         } else {
             this._pendingWriteTimeout = setTimeout(function() {
-                self._flushPendingWrites.call(self).catch(function(err) {
-                    log.error(log._("context.localfilesystem.error-write",{message:err.toString()}))
+                self.writePromise = self.writePromise.then(function(){
+                    return self._flushPendingWrites.call(self).catch(function(err) {
+                        log.error(log._("context.localfilesystem.error-write",{message:err.toString()}));
+                    });
                 });
             }, this.flushInterval);
         }
     } else if (callback && typeof callback !== 'function') {
         throw new Error("Callback must be a function");
     } else {
-        loadFile(storagePath + ".json").then(function(data){
+        self.writePromise = self.writePromise.then(function() { return loadFile(storagePath + ".json") }).then(function(data){
             var obj = data ? JSON.parse(data) : {}
             if (!Array.isArray(key)) {
                 key = [key];
diff --git a/red/runtime/nodes/context/memory.js b/red/runtime/nodes/context/memory.js
index 3e7f37ad1..2fa0ba7ce 100644
--- a/red/runtime/nodes/context/memory.js
+++ b/red/runtime/nodes/context/memory.js
@@ -32,7 +32,14 @@ Memory.prototype._getOne = function(scope, key) {
     var value;
     var error;
     if(this.data[scope]){
-        value = util.getObjectProperty(this.data[scope], key);
+        try {
+            value = util.getObjectProperty(this.data[scope], key);
+        } catch(err) {
+            if (err.code === "INVALID_EXPR") {
+                throw err;
+            }
+            value = undefined;
+        }
     }
     return value;
 }
diff --git a/red/runtime/util.js b/red/runtime/util.js
index d5643fcd5..b1ca7a977 100644
--- a/red/runtime/util.js
+++ b/red/runtime/util.js
@@ -130,13 +130,19 @@ function compareObjects(obj1,obj2) {
     return true;
 }
 
+function createError(code, message) {
+    var e = new Error(message);
+    e.code = code;
+    return e;
+}
+
 function normalisePropertyExpression(str) {
     // This must be kept in sync with validatePropertyExpression
     // in editor/js/ui/utils.js
 
     var length = str.length;
     if (length === 0) {
-        throw new Error("Invalid property expression: zero-length");
+        throw createError("INVALID_EXPR","Invalid property expression: zero-length");
     }
     var parts = [];
     var start = 0;
@@ -149,14 +155,14 @@ function normalisePropertyExpression(str) {
         if (!inString) {
             if (c === "'" || c === '"') {
                 if (i != start) {
-                    throw new Error("Invalid property expression: unexpected "+c+" at position "+i);
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected "+c+" at position "+i);
                 }
                 inString = true;
                 quoteChar = c;
                 start = i+1;
             } else if (c === '.') {
                 if (i===0) {
-                    throw new Error("Invalid property expression: unexpected . at position 0");
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected . at position 0");
                 }
                 if (start != i) {
                     v = str.substring(start,i);
@@ -167,57 +173,57 @@ function normalisePropertyExpression(str) {
                     }
                 }
                 if (i===length-1) {
-                    throw new Error("Invalid property expression: unterminated expression");
+                    throw createError("INVALID_EXPR","Invalid property expression: unterminated expression");
                 }
                 // Next char is first char of an identifier: a-z 0-9 $ _
                 if (!/[a-z0-9\$\_]/i.test(str[i+1])) {
-                    throw new Error("Invalid property expression: unexpected "+str[i+1]+" at position "+(i+1));
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected "+str[i+1]+" at position "+(i+1));
                 }
                 start = i+1;
             } else if (c === '[') {
                 if (i === 0) {
-                    throw new Error("Invalid property expression: unexpected "+c+" at position "+i);
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected "+c+" at position "+i);
                 }
                 if (start != i) {
                     parts.push(str.substring(start,i));
                 }
                 if (i===length-1) {
-                    throw new Error("Invalid property expression: unterminated expression");
+                    throw createError("INVALID_EXPR","Invalid property expression: unterminated expression");
                 }
                 // Next char is either a quote or a number
                 if (!/["'\d]/.test(str[i+1])) {
-                    throw new Error("Invalid property expression: unexpected "+str[i+1]+" at position "+(i+1));
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected "+str[i+1]+" at position "+(i+1));
                 }
                 start = i+1;
                 inBox = true;
             } else if (c === ']') {
                 if (!inBox) {
-                    throw new Error("Invalid property expression: unexpected "+c+" at position "+i);
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected "+c+" at position "+i);
                 }
                 if (start != i) {
                     v = str.substring(start,i);
                     if (/^\d+$/.test(v)) {
                         parts.push(parseInt(v));
                     } else {
-                        throw new Error("Invalid property expression: unexpected array expression at position "+start);
+                        throw createError("INVALID_EXPR","Invalid property expression: unexpected array expression at position "+start);
                     }
                 }
                 start = i+1;
                 inBox = false;
             } else if (c === ' ') {
-                throw new Error("Invalid property expression: unexpected ' ' at position "+i);
+                throw createError("INVALID_EXPR","Invalid property expression: unexpected ' ' at position "+i);
             }
         } else {
             if (c === quoteChar) {
                 if (i-start === 0) {
-                    throw new Error("Invalid property expression: zero-length string at position "+start);
+                    throw createError("INVALID_EXPR","Invalid property expression: zero-length string at position "+start);
                 }
                 parts.push(str.substring(start,i));
                 // If inBox, next char must be a ]. Otherwise it may be [ or .
                 if (inBox && !/\]/.test(str[i+1])) {
-                    throw new Error("Invalid property expression: unexpected array expression at position "+start);
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected array expression at position "+start);
                 } else if (!inBox && i+1!==length && !/[\[\.]/.test(str[i+1])) {
-                    throw new Error("Invalid property expression: unexpected "+str[i+1]+" expression at position "+(i+1));
+                    throw createError("INVALID_EXPR","Invalid property expression: unexpected "+str[i+1]+" expression at position "+(i+1));
                 }
                 start = i+1;
                 inString = false;
@@ -226,7 +232,7 @@ function normalisePropertyExpression(str) {
 
     }
     if (inBox || inString) {
-        throw new Error("Invalid property expression: unterminated expression");
+        throw new createError("INVALID_EXPR","Invalid property expression: unterminated expression");
     }
     if (start < length) {
         parts.push(str.substring(start));
diff --git a/test/red/runtime/nodes/context/index_spec.js b/test/red/runtime/nodes/context/index_spec.js
index 9a2907ef3..c723a0a6e 100644
--- a/test/red/runtime/nodes/context/index_spec.js
+++ b/test/red/runtime/nodes/context/index_spec.js
@@ -113,6 +113,21 @@ describe('context', function() {
             context2.global.get("foo").should.equal("test");
         });
 
+        it('context.flow/global are not enumerable', function() {
+            var context1 = Context.get("1","flowA");
+            Object.keys(context1).length.should.equal(0);
+            Object.keys(context1.flow).length.should.equal(0);
+            Object.keys(context1.global).length.should.equal(0);
+        })
+
+        it('context.flow/global cannot be deleted', function() {
+            var context1 = Context.get("1","flowA");
+            delete context1.flow;
+            should.exist(context1.flow);
+            delete context1.global;
+            should.exist(context1.global);
+        })
+
         it('deletes context',function() {
             var context = Context.get("1","flowA");
             should.not.exist(context.get("foo"));
@@ -191,15 +206,26 @@ describe('context', function() {
         });
 
 
-
         it('returns functionGlobalContext value if store value undefined', function() {
             Context.init({functionGlobalContext: {foo:"bar"}});
-            Context.load().then(function(){
+            return Context.load().then(function(){
                 var context = Context.get("1","flowA");
                 var v = context.global.get('foo');
                 v.should.equal('bar');
             });
         })
+
+        it('returns functionGlobalContext sub-value if store value undefined', function() {
+            Context.init({functionGlobalContext: {foo:{bar:123}}});
+            return Context.load().then(function(){
+                var context = Context.get("1","flowA");
+                var v = context.global.get('foo.bar');
+                should.equal(v,123);
+            });
+        })
+
+
+
     });
 
     describe('external context storage',function() {
@@ -473,6 +499,23 @@ describe('context', function() {
                     done();
                 }).catch(done);
             });
+            
+            it('should allow the store name to be provide in the key', function(done) {
+                Context.init({contextStorage:contextDefaultStorage});
+                Context.load().then(function(){
+                    var context =  Context.get("1","flow");
+                    var cb = function(){done("An error occurred")}
+                    context.set("#:(test)::foo","bar");
+                    context.get("#:(test)::foo");
+                    stubGet2.called.should.be.false();
+                    stubSet2.called.should.be.false();
+                    stubSet.calledWithExactly("1:flow","foo","bar",undefined).should.be.true();
+                    stubGet.calledWith("1:flow","foo").should.be.true();
+                    done();
+                }).catch(done);
+            });
+
+
             it('should use default as the alias of other context', function(done) {
                 Context.init({contextStorage:contextAlias});
                 Context.load().then(function(){
@@ -579,16 +622,16 @@ describe('context', function() {
             });
 
             it('should return multiple functionGlobalContext values if key is an array', function(done) {
-                var fGC = { "foo1": 456, "foo2": 789 };
+                var fGC = { "foo1": 456, "foo2": {"bar":789} };
                 Context.init({contextStorage:memoryStorage, functionGlobalContext:fGC });
                 Context.load().then(function(){
                     var context =  Context.get("1","flow");
-                    context.global.get(["foo1","foo2","foo3"], "memory", function(err,foo1,foo2,foo3){
+                    context.global.get(["foo1","foo2.bar","foo3"], "memory", function(err,foo1,foo2,foo3){
                         if (err) {
                             done(err);
                         } else {
-                            foo1.should.be.equal(456);
-                            foo2.should.be.equal(789);
+                            should.equal(foo1, 456);
+                            should.equal(foo2, 789);
                             should.not.exist(foo3);
                             done();
                         }
diff --git a/test/red/runtime/nodes/context/localfilesystem_spec.js b/test/red/runtime/nodes/context/localfilesystem_spec.js
index 62028cdfe..fda5cf11d 100644
--- a/test/red/runtime/nodes/context/localfilesystem_spec.js
+++ b/test/red/runtime/nodes/context/localfilesystem_spec.js
@@ -672,7 +672,7 @@ describe('localfilesystem',function() {
 
         it('should enumerate context keys in the cache',function() {
             var globalData = {foo:"bar"};
-            fs.outputFile(path.join(resourcesDir,defaultContextBase,"global","global.json"), JSON.stringify(globalData,null,4), "utf8").then(function(){
+            return fs.outputFile(path.join(resourcesDir,defaultContextBase,"global","global.json"), JSON.stringify(globalData,null,4), "utf8").then(function(){
                 context = LocalFileSystem({dir: resourcesDir, cache: true, flushInterval: 2});
                 return context.open()
             }).then(function(){
diff --git a/test/red/runtime/nodes/context/memory_spec.js b/test/red/runtime/nodes/context/memory_spec.js
index b353fd209..61ef63cc0 100644
--- a/test/red/runtime/nodes/context/memory_spec.js
+++ b/test/red/runtime/nodes/context/memory_spec.js
@@ -96,7 +96,7 @@ describe('memory',function() {
                 context.set("nodeX","three","test3");
                 context.set("nodeX","four","test4");
 
-                var values = context.get("nodeX",["one","unknown"]);
+                var values = context.get("nodeX",["one","unknown.with.multiple.levels"]);
                 values.should.eql(["test1",undefined])
             })
             it('should throw error if bad key included in multiple keys', function() {