statebus 7.0.32 → 7.1.0

package/statebus.js

@@ -92,6 +92,10 @@
     var gets_in = new One_To_Many()  // Maps `key' to `pub_funcs' subscribed to our key
 
     var currently_saving
+
+    // Two forms:
+    //  - set(obj, t)  with snapshot
+    //  - set(key, t)  with patches
     function set (obj, t) {
         // First let's handle patches.  We receive them as:
         //
@@ -105,11 +109,11 @@
             var key = obj,
                 obj = bus.cache[key]
 
-            console.log('set: applying the patches!', {
-                key: key,
-                obj: obj,
-                patches: t.patches[0]
-            })
+            // console.log('set: applying the patches!', {
+            //     key: key,
+            //     obj: obj,
+            //     patches: t.patches[0]
+            // })
             obj.val = apply_patch(obj.val, t.patches[0])
         }
 
@@ -290,16 +294,25 @@
             return f
         }
 
-        // Called with a key to produce a subspace
-        else return subspace(arg1, arg2)
+        // Called with a key to produce a subspace.
+        // We currently have two forms:
+        //
+        //    old_subspace('foo').to_get = ... // etc.
+        //
+        //    new_subspace('foo', {get: ...})  // etc
+        //
+        else if (arg2 === undefined)
+            return old_subspace(arg1)
+        else
+            return new_subspace(arg1, arg2)
     }
     var id = 'bus-' + Math.random().toString(36).substring(7)
     bus.toString = function () { return bus.label || 'bus'+this_bus_num || id }
     bus.delete_bus = function () {
-        // // Forget all wildcard handlers
-        // for (var i=0; i<wildcard_handlers.length; i++) {
-        //     console.log('Forgetting', funk_name(wildcard_handlers[i].funk))
-        //     wildcard_handlers[i].funk.forget()
+        // // Forget all pattern handlers
+        // for (var i=0; i<pattern_handlers.length; i++) {
+        //     console.log('Forgetting', funk_name(pattern_handlers[i].funk))
+        //     pattern_handlers[i].funk.forget()
         // }
 
         // // Forget all handlers
@@ -393,6 +406,7 @@
 
             return obj
         }
+
         deep_map(object, update_object)
         return modified_keys.values()
     }
@@ -449,6 +463,12 @@
                 // delete backup_cache[key]
                 delete gets_out[key]
                 delete to_be_forgotten[key]
+
+                if (bus.auto_delete && gets_in.empty()) {
+                    bus.auto_delete()
+                    bus.delete_bus()
+                }
+
             }, 200)
         }
     }
@@ -622,50 +642,49 @@
 
     // ****************
     // Connections
-    function subspace (key, params) {
+    function old_subspace (key, params) {
         var methods = {getter:null, setter:null, on_set:null, on_set_sync:null,
                        on_delete:null, deleter:null, forgetter:null}
 
-        if (params) {
-            for (var method in params) {
-                var func = params[method]
-                var param_names = {get:'getter', set:'setter',
-                                   delete: 'deleter', forget: 'forgetter',
-                                   on_set:'on_set', on_set_sync:'on_set_sync'}
-
-                // Map it from the API's name to our internal name
-                console.assert(param_names[method],
-                               'Method "' + method + '" is invalid')
-                method = param_names[method]
-
-                autodetect_args(func)
-                func.defined = func.defined || []
-                func.defined.push({bus, method, key, as: 'handler'})
-                func.use_linked_json = true
-                bind(key, method, func, 'allow_wildcards')
-            }
-        }
-        else {
-            var result = {}
-            for (var method in methods)
-                (function (method) {
-                    Object.defineProperty(result, method, {
-                        set: function (func) {
-                            autodetect_args(func)
-                            func.defined = func.defined || []
-                            func.defined.push(
-                                {as:'handler', bus:bus, method:method, key:key})
-                            bind(key, method, func, 'allow_wildcards')
-                        },
-                        get: function () {
-                            var result = bindings(key, method)
-                            for (var i=0; i<result.length; i++) result[i] = result[i].func
-                            result.delete = function (func) { unbind (key, method, func, 'allow_wildcards') }
-                            return result
-                        }
-                    })
-                })(method)
-            return result
+        var result = {}
+        for (var method in methods)
+            (function (method) {
+                Object.defineProperty(result, method, {
+                    set: function (func) {
+                        autodetect_args(func)
+                        func.defined = func.defined || []
+                        func.defined.push(
+                            {as:'handler', bus:bus, method:method, key:key})
+                        bind(key, method, func, 'pattern')
+                    },
+                    get: function () {
+                        var result = bindings(key, method)
+                        for (var i=0; i<result.length; i++) result[i] = result[i].func
+                        result.delete = function (func) { unbind (key, method, func, 'pattern') }
+                        return result
+                    }
+                })
+            })(method)
+        return result
+    }
+
+    function new_subspace (key, params) {
+        for (var method in params) {
+            var func = params[method]
+            var param_names = {get:'getter', set:'setter',
+                               delete: 'deleter', forget: 'forgetter',
+                               on_set:'on_set', on_set_sync:'on_set_sync'}
+
+            // Map it from the API's name to our internal name
+            console.assert(param_names[method],
+                           'Method "' + method + '" is invalid')
+            method = param_names[method]
+
+            autodetect_args(func)
+            func.call_with_proxies = true
+            func.defined = func.defined || []
+            func.defined.push({bus, method, key, as: 'handler'})
+            bind(key, method, func, 'pattern')
         }
     }
 
@@ -684,6 +703,8 @@
             case 'key':
             case 'k':
                 handler.args['key'] = i; break
+            case 'path':
+                handler.args['path'] = i; break
             case 'json':
             case 'vars':
                 handler.args['vars'] = i; break
@@ -702,44 +723,96 @@
                 handler.args['obj'] = i; break
             case 'old':
                 handler.args['old'] = i; break
+            case 'func_args':
+                handler.args['func_args'] = i; break
             }
     }
 
     // The funks attached to each key, maps e.g. 'get /point/3' to '/30'
     var handlers = new One_To_Many()
-    var wildcard_handlers = []  // An array of {prefix, method, funk}
+    var pattern_handlers = []  // An array of {pattern, method, funk}
 
     // A set of timers, for keys to send forgets on
     var to_be_forgotten = {}
-    function bind (key, method, func, allow_wildcards) {
-        bogus_check(key)
-        if (allow_wildcards && key[key.length-1] === '*')
-            wildcard_handlers.push({prefix: key,
-                                    method: method,
-                                    funk: func})
+    function bind (pattern, method, func, type) {
+        bogus_check(pattern)
+
+        function pattern_matcher (pattern) {
+            var param_names = []
+
+            // console.log('Creating pattern for', pattern)
+
+            // First, convert the pattern into a regexp.
+
+            // 1. Handle :foo by swapping it with '([^/*()]+)'
+            pattern = pattern.replace(/(?<=^|\/):[^/*()]+/g, match => {
+                // Replace :foo with ([^/]+), and remember the "foo" name
+                param_names.push(match.slice(1))
+                return '([^/*()]+)'
+            })
+
+            // Now look for * and () at the end and replace with regexps
+            if (pattern.slice(-3) === '*()')
+                pattern = pattern.slice(0, -3) + '(?<star>[^()]*)(?<fstring>\\(.*\\))?'
+            else if (pattern.slice(-1) === '*')
+                pattern = pattern.slice(0, -1) + '(?<star>.*)'
+            else if (pattern.slice(-2) === '()')
+                pattern = pattern.slice(0, -2) + '(?<fstring>\\(.*\\))?'
+
+            // Construct the regexp
+            var regex = new RegExp('^' + pattern + '$')
+            
+            // console.log('Pattern became      ', regex)
+
+            // Return a matcher function that runs it
+            return path => {
+                var match = path.match(regex)
+                if (!match) return null
+                var params = {}
+                params.func_args = match.groups.fstring
+                params.star = match.groups.star
+
+                // Add to params.path all the path parts
+                params.path = {}
+                match.slice(1, param_names.length + 1).forEach((val, i) =>
+                    params.path[param_names[i]] = val
+                )
+
+                return params
+            }
+        }
+
+        // Add patterns to the list, not the hash
+        if (type === 'pattern' && /[:*]/.test(pattern))  // Is it a pattern?
+            pattern_handlers.push({pattern: pattern,
+                                   matcher: pattern_matcher(pattern),
+                                   method: method,
+                                   funk: func})
+
+        // Add simple keys to the hash
         else
-            handlers.add(method + ' ' + key, funk_key(func))
+            handlers.add(method + ' ' + pattern, funk_key(func))
 
         // Now check if the method is a get and there's a getted
         // key in this space, and if so call the handler.
     }
-    function unbind (key, method, funk, allow_wildcards) {
-        bogus_check(key)
-        if (allow_wildcards && key[key.length-1] === '*')
-            // Delete wildcard connection
-            for (var i=0; i<wildcard_handlers.length; i++) {
-                var handler = wildcard_handlers[i]
-                if (handler.prefix === key
+    function unbind (pattern, method, funk, type) {
+        bogus_check(pattern)
+        if (type === 'pattern' && /[:*]/.test(pattern))  // Is it a pattern?
+            // Delete pattern connection
+            for (var i=0; i < pattern_handlers.length; i++) {
+                var handler = pattern_handlers[i]
+                if (handler.pattern === pattern
                     && handler.method === method
                     && handler.funk === funk) {
 
-                    wildcard_handlers.splice(i,1)  // Splice this element out of the array
-                    i--                            // And decrement the counter while we're looping
+                    pattern_handlers.splice(i,1)  // Splice this element out of the array
+                    i--                           // And decrement the counter while we're looping
                 }
             }
         else
             // Delete direct connection
-            handlers.delete(method + ' ' + key, funk_key(funk))
+            handlers.delete(method + ' ' + pattern, funk_key(funk))
     }
 
     function bindings(key, method) {
@@ -764,16 +837,22 @@
             }
         }
 
-        // Now iterate through prefixes
-        for (var i=0; i < wildcard_handlers.length; i++) {
-            handler = wildcard_handlers[i]
+        // Now iterate through patterns
+        for (var i=0; i < pattern_handlers.length; i++) {
+            handler = pattern_handlers[i]
+            var matches = handler.matcher(key)
+            // console.log('The matching of', pattern_handlers[i], 'to', key, 'is', matches)
 
-            var prefix = handler.prefix.slice(0, -1)       // Cut off the *
-            if (prefix === key.substr(0,prefix.length)     // If the prefix matches
-                && method === handler.method               // And it has the right method
+            if (matches                                // If the pattern matches
+                && method === handler.method           // And it has the right method
                 && !seen[funk_key(handler.funk)]) {
-                handler.funk.statebus_binding = {key:handler.prefix, method:method}
-                result.push({method:method, key:handler.prefix, func:handler.funk})
+
+                handler.funk.statebus_binding = {
+                    key:    handler.pattern,
+                    method: method,
+                    args:   matches
+                }
+                result.push({method, key:handler.pattern, func:handler.funk})
                 seen[funk_key(handler.funk)] = true
             }
         }
@@ -782,6 +861,11 @@
     }
 
     function run_handler(funck, method, arg, options) {
+        // If method == "set",    then arg is an object {key: "foobar", ...}
+        // If method == "get",    then arg is a key     "foobar"
+        // If method == "forget", then arg is a key     "foobar"
+        // If method == "delete", then arg is a key     "foobar"
+
         options = options || {}
         var t = options.t,
             just_make_it = options.dont_run,
@@ -842,15 +926,30 @@
         // Fresh get/set/forget/delete handlers will just be regular
         // functions.  We'll store their arg and transaction and let them
         // re-run until they are done re-running.
-        function key_arg () { return ((typeof arg.key) == 'string') ? arg.key : arg }
-        function rest_arg () { return (key_arg()).substr(binding.length-1) }
+        function key_arg () { return ((typeof arg.key) === 'string') ? arg.key : arg }
+        function rest_arg () {
+            return func.statebus_binding && func.statebus_binding.args.star
+            // (key_arg()).substr(binding.length-1)
+        }
         function val_arg () {
             console.assert(method === 'setter' || method === 'on_set' || method === 'on_set_sync',
                            'Bad method for val_arg()')
-            // Is there a time I am supposed to return bus.cache[arg]?  It used to say:
-            // arg.key ? arg : bus.cache[arg]
 
-            return arg.key ? (func.use_linked_json ? arg.val : arg) : undefined
+            var value = (typeof arg === 'string'
+                         // If arg is a key, then semantics of val is "the
+                         // current value in the cache".  I'm doing this
+                         // because it *might* be useful in a getter ... but
+                         // let's see if we actually have good examples of use
+                         // for this feature.
+                         ? bus.cache[arg]
+                         // Otherwise, arg must be the actual object
+                         : arg)
+
+            // The Proxy API unwraps the .val for us
+            if (func.call_with_proxies)
+                value = value.val
+
+            return value
         }
         function vars_arg () {
             var r = rest_arg()
@@ -860,6 +959,50 @@
                 return 'Bad JSON "' + r + '" for key ' + key_arg()
             }
         }
+        // Parse out function params for URLs in the style /foo/bar(param1,param2:val2).
+        // We're currently calling that (param1,param2:val2) part "function params", and presuming
+        // that it exists in the () part of the pattern like in /foo/bar*().
+        function func_args () {
+            // This code is copied from Raphael Walker's parser.coffee
+            function split_once (str, char) {
+                var i = str.indexOf(char)
+                return i === -1 ? [str, ""] : [str.slice(0, i), str.slice(i + 1)]
+            }
+
+            // Function Strings -- an alternative to query strings
+            //
+            function parse_function_string (str) {
+                // Coffeescript doesn't have object comprehensions :(
+                var ret = {}
+
+                // Now process the string:
+                str
+                    // Pull out the parentheses
+                    .slice(1, -1)
+                    // Split by commas. TODO: Allow spaces after commas?
+                    .split(",")
+                    // Delete empty parts (this ensures that empty strings
+                    // will properly result in empty func_string, and allows trailing
+                    // commas)
+                    .filter(part => part.length)
+                    .forEach(part => {
+                        // If the part has a comma, its a key:value, otherwise
+                        // it's just a singleton
+                        var [k, v] = split_once(part, ":")
+                        
+                        if (v.length === 0) ret[k] = true
+                        // If the value is itself a func_string params object, parse it recursively
+                        else if (v.startsWith("(")) ret[k] = parse_function_string(v)
+                        else ret[k] = v
+                    })
+                return ret
+            }
+            // console.log('Getting func_args from', func.statebus_binding.args)
+            if (!(func.statebus_binding.args
+                  && func.statebus_binding.args.func_args))
+                return undefined
+            return parse_function_string(func.statebus_binding.args.func_args)
+        }
         var f = reactive(function () {
             // Initialize transaction
             t = clone(t || {})
@@ -878,8 +1021,8 @@
             if (method !== 'forgetter')
                 t.done = function (o) {
                     var key = method === 'setter' ? arg.key : arg
-                    if (func.use_linked_json)
-                        o = {key, val: o}
+                    if (func.call_with_proxies)
+                        o = {key, val: raw(o)}
                     bus.log('We are DONE()ing', method, key, o||arg)
 
                     // We use a simple (and crappy?) heuristic to know if the
@@ -934,6 +1077,11 @@
                 switch (k) {
                 case 'key':
                     args[func.args[k]] = key_arg(); break
+                case 'path':
+                    args[func.args[k]] = (func.statebus_binding
+                                          && func.statebus_binding.args
+                                          && func.statebus_binding.args.path)
+                    break
                 case 'rest':
                     args[func.args[k]] = rest_arg(); break
                 case 'vars':
@@ -946,7 +1094,11 @@
                 case 'old':
                     var key = key_arg()
                     args[func.args[k]] = bus.cache[key] || (bus.cache[key] = {key:key})
+                    if (func.call_with_proxies)
+                        args[func.args[k]] = args[func.args[k]].val
                     break
+                case 'func_args':
+                    args[func.args[k]] = func_args(); break
                 }
             }
 
@@ -967,9 +1119,9 @@
             if (result === 'abort') t.abort()
 
             // For get
-            if (func.use_linked_json) {
+            if (func.call_with_proxies) {
                 if (method === 'getter' && result !== undefined && !f.loading()) {
-                    var obj = {key: arg, val: result}
+                    var obj = {key: arg, val: raw(result)}
                     var new_t = clone(t || {})
                     new_t.getter = true
                     set.fire(obj, new_t)
@@ -1300,9 +1452,8 @@
 
     var symbols = {
         is_proxy: Symbol('is_proxy'),
-        // is_link: Symbol('is_link'),
-        // get_json: Symbol('get_json'),
-        // get_base: Symbol('get_base')
+        raw: Symbol('raw'),
+        link: Symbol('link')
     }
     function make_proxy () {
         // var custom_inspect_symbol = nodejs && require('util').inspect.custom,
@@ -1323,8 +1474,9 @@
 
             // We recursively descend through {key: ...} links
             if (typeof o === 'object' && 'link' in o) {
-                var new_base = bus.get(o.link)
-                return item_proxy(new_base, '', new_base.val)
+                // var new_base = bus.get(o.link)
+                // return item_proxy(new_base, '', new_base.val)
+                return link_proxy(o.link)
             }
 
 
@@ -1344,18 +1496,20 @@
                     //     return custom_inspect
                     if (k === symbols.is_proxy)
                         return true
+                    if (k === symbols.raw)
+                        return o
                     if (typeof k === 'symbol')
                         return undefined
 
                     // Compute the new path
                     var new_path = path + '[' + JSON.stringify(k) + ']'
-                    return item_proxy(base, new_path, o[escape_field_to_bus(escape_field_to_nelson(k))])
+                    return item_proxy(base, new_path, o[escape_field_json_to_bus(k)])
                 },
                 set: function (o, k, v) {
-                    var value = translate_fields(v, field => escape_field_to_bus(escape_field_to_nelson(field)))
-                    o[escape_field_to_bus(escape_field_to_nelson(k))] = value
+                    var value = escape_json_to_bus(v)
+                    o[escape_field_json_to_bus(k)] = value
                     var new_path = path + '[' + JSON.stringify(k) + ']'
-                    bus.set(
+                    bus.set.sync(
                         base,
                         // Forward the patches too
                         {patches: [{unit: 'json',
@@ -1367,17 +1521,17 @@
                 has: function (o, k) {
                     // if (custom_inspect && k === custom_inspect)
                     //     return true
-                    return o.hasOwnProperty(escape_field_to_bus(escape_field_to_nelson(k)))
+                    return o.hasOwnProperty(escape_field_json_to_bus(k))
                 },
                 ownKeys: function () {
-                    return Object.keys(o).map(unescape_field_from_nelson).map(unescape_field_from_bus)
+                    return Object.keys(o).map(unescape_field_bus_to_json)
                 },
                 getOwnPropertyDescriptor: function (target, key) {
                     return { enumerable: true, configurable: true, value: this.get(o, key) }
                 },
                 deleteProperty: function del (o, k) {
                     var new_path = path + '[' + JSON.stringify(k) + ']'
-                    delete o[escape_field_to_bus(escape_field_to_nelson(k))]
+                    delete o[escape_field_json_to_bus(k)]
                     bus.set(
                         base,
                         // Forward the patches too
@@ -1394,15 +1548,84 @@
                 // }
             })}
 
+        function link_proxy (url) {
+            return new Proxy(function follow_link () {}, {
+                get: function (o, k) {
+                    if (k === 'inspect' || k === 'valueOf')
+                        return undefined
+                    // if (custom_inspect && k === custom_inspect)
+                    //     return custom_inspect
+                    if (k === symbols.is_proxy)
+                        return true
+                    if (k === symbols.raw)
+                        return {link: url}
+                    if (typeof k === 'symbol')
+                        return undefined
+
+                    if (k === 'link')
+                        return url
+
+                    return undefined
+                },
+                set: function (o, k, v) {
+                    if (k === 'link') {
+                        url = v
+                    }
+
+                    console.assert(false, "Have not fully implemented setting links yet")
+
+                    // Todo: update the containing proxy object with bus.set.sync
+                    // else return 
+                    // var value = escape_json_to_bus(v)
+                    // o[escape_field_json_to_bus(k)] = value
+                    // var new_path = path + '[' + JSON.stringify(k) + ']'
+                    // bus.set.sync(
+                    //     base,
+                    //     // Forward the patches too
+                    //     {patches: [{unit: 'json',
+                    //                 range: new_path,
+                    //                 content: JSON.stringify(v)}]}
+                    // )
+                    return true
+                },
+                has: function (o, k) {
+                    return k === 'link'
+                },
+                ownKeys: function () {
+                    return ['link']
+                },
+                // getOwnPropertyDescriptor: function (target, key) {
+                //     return { enumerable: true, configurable: true, value: this.get(o, key) }
+                // },
+                // deleteProperty: function del (o, k) {
+                //     var new_path = path + '[' + JSON.stringify(k) + ']'
+                //     delete o[escape_field_json_to_bus(k)]
+                //     bus.set(
+                //         base,
+                //         // Forward the patches too
+                //         {patches: [{unit: 'json',
+                //                     range: new_path,
+                //                     content: undefined}]}
+                //     )
+                //     return true // Report success to Proxy
+                // }
+
+                // For function proxy:
+                apply: function apply (o, This, args) {
+                    // console.log('Descending into the link', url, '!')
+                    return top_level_proxy[url]
+                }
+            })            
+        }
 
-        // For function proxies:
-        // var dummy = function () {}
 
         // The top-level Proxy object holds HTTP resources
-        return new Proxy(cache, {
+        var top_level_proxy = new Proxy(cache, {
             get: function get(o, k) {
                 if (k === symbols.is_proxy)
                     return true
+                if (k === symbols.raw)
+                    return raw_proxy()
                 if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
                     return undefined
                 bogus_check(k)
@@ -1412,7 +1635,7 @@
             set: function set(o, key, val) {
                 bus.set({
                     key: key,
-                    val: translate_fields(val, field => escape_field_to_bus(escape_field_to_nelson(field)))
+                    val: escape_json_to_bus(val)
                 })
                 return true
             },
@@ -1425,15 +1648,35 @@
             //     return 'fluffy'
             // }
         })
+
+        return top_level_proxy
     }
     bus.state = make_proxy()
 
-    // function link (url) {
-    //     var result = bus.get(url)
-    //     result[symbols.is_link] = true
-    //     return result
-    // }
+    // This is temporary code to wrap the cache as a flat key/valuel store
+    // that returns raw objects, dereferencing .val.  We can remove it once we
+    // remove the internal .val stuff from statebus.
+    function raw_proxy () {
+        return new Proxy(cache, {
+            get: function get(o, k) { return bus.cache[k].val },
+            set: function set(o, key, val) {
+                return false
+            },
+            deleteProperty: function del (o, k) {
+                return false
+            }
+        })
+    }
+
+    function link (url) {
+        return {[symbols.link]: url}
+    }
+    function raw (proxy) {
+        if (!(typeof proxy === 'object' && proxy[symbols.is_proxy]))
+            return proxy
 
+        return proxy[symbols.raw]
+    }
 
     // So chrome can print out proxy objects decently
     if (!nodejs)
@@ -1449,7 +1692,55 @@
             hasBody: function (x) {return false}
         }]
 
-    // ******************
+
+    // ************************************************
+    //
+    // Every dialogue we have with a peer gets an ID.
+    // This `bus.dialogues` variable maps:
+    //
+    //      dialogue ID -> send_function
+    //
+    // for each peer we are in dialogue with.
+    //
+    // One can use this to make sure we don't send an update
+    // back to the same peer that sent it to us.
+
+    bus.dialogues = {}
+
+
+    // ************************************************
+    // Custom clients
+    var client_counter = 0
+    var client_busses  = {}
+    function client_bus_for (client_id) {
+        if (!bus.custom_clients) return bus
+
+        // Do we have a bus for this client yet?
+        if (client_busses[client_id])
+
+            // Return existing bus
+            return client_busses[client_id]
+
+        else {
+
+            // Make a new bus
+            var client_bus = make_bus()
+            client_bus.label = 'client-' + client_counter++
+            client_bus.master = bus
+
+            // Initialize the client-specific handlers
+            bus.custom_clients(client_bus, client_id)
+
+            // Remember it, and auto-delete it when it's no longer being used
+            client_busses[client_id] = client_bus
+            client_bus.auto_delete = () => delete client_busses[client_id]
+
+            return client_bus
+        }
+    }
+
+
+    // ************************************************
     // Network client
     function get_domain (key) { // Returns e.g. "state://foo.com"
         var m = key.match(/^i?statei?\:\/\/(([^:\/?#]*)(?:\:([0-9]+))?)/)
@@ -1465,9 +1756,10 @@
     function ws_mount (prefix, url, client_creds) {
         // Local: state://foo.com/* or /*
         var preprefix = prefix.slice(0,-1)
+        var bus = this
         var is_absolute = /^i?statei?:\/\//
+        var creds = client_creds || (bus.client_creds && bus.client_creds(url))
         var has_prefix = new RegExp('^' + preprefix)
-        var bus = this
         var sock
         var attempts = 0
         var outbox = []
@@ -1547,7 +1839,6 @@
                 set(peers)
 
                 // Login
-                var creds = client_creds || (bus.client_creds && bus.client_creds(url))
                 if (creds) {
                     var i = []
                     function intro (o) {i.push(JSON.stringify({set: o}))}
@@ -1753,8 +2044,10 @@
         }
 
         // Recurse through each property on objects
-        else if (typeof json === 'object' && json !== null) {
+        else if (typeof json === 'object' && json !== null && !(symbols.link in json)) {
             var new_obj = {}
+
+            // Regular objects get their fields translated
             for (var k in json)
                 if (typeof k === 'string')
                     new_obj[translate(k, json)] = translate_fields(json[k], translate)
@@ -1785,6 +2078,21 @@
         escape_to_nelson           = (obj)   => translate_fields(obj, escape_field_to_nelson)
         unescape_from_nelson       = (obj)   => translate_fields(obj, unescape_field_from_nelson)
 
+    var escape_field_json_to_bus   = (field) =>
+        escape_field_to_bus(escape_field_to_nelson(field))
+    var unescape_field_bus_to_json = (field) =>
+        unescape_field_from_nelson(unescape_field_from_bus(field))
+
+    var escape_json_to_bus = (obj) => {
+        obj = translate_fields(obj, escape_field_json_to_bus)
+        return deep_map(obj, o => (typeof o === 'object' && symbols.link in o
+                                   ? {link: o[symbols.link]}
+                                   : o))
+    }
+    var unescape_bus_to_json = (obj) =>
+        translate_fields(obj, field => unescape_field_bus_to_jsob(field))
+        
+
     var field_replace = (field, pattern, replacement) => (typeof field === 'string'
                                                           ? field.replace(pattern, replacement)
                                                           : field)
@@ -1893,6 +2201,7 @@
         this.has = function (k, v) { return hash[k] && hash[k][v] }
         this.has_any = function (k) { return counts[k] }
         this.del = this.delete // for compatibility; remove this soon
+        this.empty = function () { return !Object.values(counts).some(count => count !== 0) }
     }
     function Set () {
         var hash = {}
@@ -2234,14 +2543,15 @@
 
     // Make these private methods accessible
     var api = ['cache backup_cache get set forget del fire dirty get_once',
-               'subspace bindings run_handler bind unbind reactive uncallback',
+               'old_subspace new_subspace bindings run_handler bind unbind reactive uncallback',
                'versions new_version',
-               'aget',
+               'aget client_bus_for',
                'funk_key funk_name funks key_id key_name id',
                'pending_gets gets_in gets_out loading_keys loading once',
                'global_funk busses rerunnable_funks',
-               'translate_keys translate_links apply_patch',
+               'link raw translate_keys translate_links apply_patch',
                'translate_fields escape_to_bus unescape_from_bus escape_to_nelson unescape_from_nelson',
+               'escape_field_json_to_bus unescape_field_bus_to_json escape_json_to_bus unescape_bus_to_json',
                'ws_mount net_automount message_method',
                'parse Set One_To_Many clone extend deep_map deep_equals prune validate sorta_diff log deps symbols'
               ].join(' ').split(' ')