statebus 6.1.20 → 7.0.0

package/statebus.js

@@ -3,17 +3,19 @@
     if (typeof module != 'undefined') module.exports = definition()
     else if (typeof define == 'function' && typeof define.amd == 'object') define(definition)
     else this[name] = definition()
-}('statebus', function() {statelog_indent = 0; var busses = {}, executing_funk, global_funk, funks = {}, clean_timer, symbols, nodejs = typeof window === 'undefined'; function make_bus (options) {
+}('statebus', function() {statelog_indent = 0; var busses = {}, bus_count = 0, executing_funk, global_funk, funks = {}, clean_timer, symbols, nodejs = typeof window === 'undefined'; function make_bus (options) {
     
 
     // ****************
-    // Fetch, Save, Forget, Delete
+    // Get, Set, Forget, Delete
 
-    function fetch (key, callback) {
+    function get (key, callback) {
+        if (typeof key !== 'string'
+            && !(typeof key === 'object' && typeof key.key === 'string'))
+            throw ('Error: get(key) called with key = '
+                   + JSON.stringify(key))
         key = key.key || key    // You can pass in an object instead of key
                                 // We should probably disable this in future
-        if (typeof key !== 'string')
-            throw ('Error: fetch(key) called with a non-string key: '+key)
         bogus_check(key)
 
         var called_from_reactive_funk = !callback
@@ -22,7 +24,7 @@
         // Initialize callback
         if (callback) {
             (callback.defined = callback.defined || []
-            ).push({as:'fetch callback', key:key});
+            ).push({as:'get callback', key:key});
             callback.has_seen = callback.has_seen || function (bus, key, version) {
                 callback.seen_keys = callback.seen_keys || {}
                 var bus_key = JSON.stringify([bus.id, key])
@@ -35,27 +37,27 @@
 
         // ** Subscribe the calling funk **
 
-        fetches_in.add(key, funk_key(funk))
+        gets_in.add(key, funk_key(funk))
         if (to_be_forgotten[key]) {
             clearTimeout(to_be_forgotten[key])
             delete to_be_forgotten[key]
         }
 
-        bind(key, 'on_save', funk)
+        bind(key, 'on_set', funk)
 
-        // ** Call fetchers upstream **
+        // ** Call getters upstream **
 
-        // TODO: checking fetches_out[] doesn't count keys that we got which
+        // TODO: checking gets_out[] doesn't count keys that we got which
         // arrived nested within a bigger object, because we never explicity
-        // fetched those keys.  But we don't need to fetch them now cause we
+        // got those keys.  But we don't need to get them now cause we
         // already have them.
-        var to_fetchers = 0
-        if (!fetches_out[key])
-            to_fetchers = bus.route(key, 'to_fetch', key)
+        var to_getters = 0
+        if (!gets_out[key])
+            to_getters = bus.route(key, 'to_get', key)
 
         // Now there might be a new value pubbed onto this bus.
-        // Or there might be a pending fetch.
-        // ... or there weren't any fetchers upstream.
+        // Or there might be a pending get.
+        // ... or there weren't any getters upstream.
 
 
         // ** Return a value **
@@ -68,29 +70,29 @@
         }
 
         // Otherwise, we want to make sure that a pub gets called on the
-        // handler.  If there's a pending fetch, then it'll get called later.
-        // If there was a to_fetch, then it already got called.  Otherwise,
+        // handler.  If there's a pending get, then it'll get called later.
+        // If there was a to_get, then it already got called.  Otherwise,
         // let's call it now.
-        else if (!pending_fetches[key] && to_fetchers === 0) {
+        else if (!pending_gets[key] && to_getters === 0) {
             // TODO: my intuition suggests that we might prefer to delay this
-            // .on_save getting called in a setTimeout(f,0), to be consistent
-            // with other calls to .on_save.
+            // .on_set getting called in a setTimeout(f,0), to be consistent
+            // with other calls to .on_set.
             backup_cache[key] = backup_cache[key] || {key: key}
-            run_handler(funk, 'on_save', cache[key] = cache[key] || {key: key})
+            run_handler(funk, 'on_set', cache[key] = cache[key] || {key: key})
         }
     }
-    function fetch_once (key, cb) {
+    function get_once (key, cb) {
         function cb2 (o) { cb(o); forget(key, cb2) }
-        // fetch(key)   // This prevents key from being forgotten
-        fetch(key, cb2)
+        // get(key)   // This prevents key from being forgotten
+        get(key, cb2)
     }
-    fetch.once = fetch_once
-    var pending_fetches = {}
-    var fetches_out = {}                // Maps `key' to `func' iff we've fetched `key'
-    var fetches_in = new One_To_Many()  // Maps `key' to `pub_funcs' subscribed to our key
+    get.once = get_once
+    var pending_gets = {}
+    var gets_out = {}                // Maps `key' to `func' iff we've got `key'
+    var gets_in = new One_To_Many()  // Maps `key' to `pub_funcs' subscribed to our key
 
     var currently_saving
-    function save (obj, t) {
+    function set (obj, t) {
         // First let's handle diffs
         if (typeof obj === 'string' && t && t.patch) {
             if (typeof t.patch == 'string') t.patch = [t.patch]
@@ -99,8 +101,8 @@
         }
 
         if (!('key' in obj) || typeof obj.key !== 'string') {
-            console.error('Error: save(obj) called on object without a key: ', obj)
-            console.trace('Bad save(obj)')
+            console.error('Error: set(obj) called on object without a key: ', obj)
+            console.trace('Bad set(obj)')
         }
         bogus_check(obj.key)
 
@@ -114,7 +116,7 @@
         }
 
         if (honking_at(obj.key))
-            var message = save_msg(obj, t, 'save')
+            var message = set_msg(obj, t, 'set')
 
         // Ignore if nothing happened
         if (obj.key && !changed(obj)) {
@@ -128,11 +130,11 @@
             var was_saving = currently_saving
             currently_saving = obj.key
 
-            // Call the to_save() handlers!
-            var num_handlers = bus.route(obj.key, 'to_save', obj, t)
+            // Call the to_set() handlers!
+            var num_handlers = bus.route(obj.key, 'to_set', obj, t)
             if (num_handlers === 0) {
                 // And fire if there weren't any!
-                save.fire(obj, t)
+                set.fire(obj, t)
                 bus.route(obj.key, 'on_set_sync', obj, t)
             }
         }
@@ -141,13 +143,13 @@
             currently_saving = was_saving
         }
         // TODO: Here's an alternative.  Instead of counting the handlers and
-        // seeing if there are zero, I could just make a to_save handler that
+        // seeing if there are zero, I could just make a to_set handler that
         // is shadowed by other handlers if I can get later handlers to shadow
         // earlier ones.
     }
 
-    // save.sync() will save with the version of the current executing reaction
-    save.sync = function save_sync (obj, t) {
+    // set.sync() will set with the version of the current executing reaction
+    set.sync = function set_sync (obj, t) {
         t = bus.clone(t || {})
         // t.version: executing_funk?.transaction?.version
         //          || executing_funk?.latest_reaction_at
@@ -156,13 +158,13 @@
                       && executing_funk.transaction.version)
                      || (executing_funk
                          && executing_funk.latest_reaction_at))
-        save(obj, t)
+        set(obj, t)
     }
 
-    // We might eventually want a save.fire.sync() too, which defaults the
+    // We might eventually want a set.fire.sync() too, which defaults the
     // version to `executing_funk?.transaction?.version`
 
-    save.fire = fire
+    set.fire = fire
     function fire (obj, t) {
         t = t || {}
 
@@ -176,7 +178,7 @@
             // Warning: Changes to *nested* objects will *not* be printed out!
             // In the future, we'll remove the recursion from fire() so that
             // nested objects aren't even changed.
-            var message = save_msg(obj, t, 'save.fire')
+            var message = set_msg(obj, t, 'set.fire')
             var color, icon
             if (currently_saving === obj.key &&
                 !(obj.key && !changed(obj))) {
@@ -189,18 +191,18 @@
                 if (obj.key && !changed(obj)) {
                     color = grey
                     icon = 'x'
-                    if (t.to_fetch)
-                        message = (t.m) || 'Fetched ' + bus + "('"+obj.key+"')"
+                    if (t.to_get)
+                        message = (t.m) || 'Got ' + bus + "('"+obj.key+"')"
                     if (t.version) message += ' [' + t.version + ']'
                     statelog(obj.key, color, icon, message)
                     return
                 }
 
                 color = red, icon = '•'
-                if (t.to_fetch || pending_fetches[obj.key]) {
+                if (t.to_get || pending_gets[obj.key]) {
                     color = green
                     icon = '^'
-                    message = add_diff_msg((t.m)||'Fetched '+bus+"('"+obj.key+"')",
+                    message = add_diff_msg((t.m)||'Got '+bus+"('"+obj.key+"')",
                                            obj)
                     if (t.version) message += ' [' + t.version + ']'
                 }
@@ -213,7 +215,7 @@
         // Recursively add all of obj, and its sub-objects, into the cache
         var modified_keys = update_cache(obj, cache)
 
-        delete pending_fetches[obj.key]
+        delete pending_gets[obj.key]
 
         if ((executing_funk !== global_funk) && executing_funk.loading()) {
             abort_changes(modified_keys)
@@ -234,7 +236,7 @@
         }
     }
 
-    save.abort = function (obj, t) {
+    set.abort = function (obj, t) {
         if (!obj) console.error('No obj', obj)
         abort_changes([obj.key])
         statelog(obj.key, yellow, '<', 'Aborting ' + obj.key)
@@ -247,19 +249,19 @@
     }
 
     // Now create the statebus object
-    function bus (arg) {
+    function bus (arg1, arg2) {
         // Called with a function to react to
-        if (typeof arg === 'function') {
-            var f = reactive(arg)
+        if (typeof arg1 === 'function') {
+            var f = reactive(arg1)
             f()
             return f
         }
 
         // Called with a key to produce a subspace
-        else return subspace(arg)
+        else return subspace(arg1, arg2)
     }
-    var id = 'bus ' + Math.random().toString(36).substring(7)
-    bus.toString = function () { return bus.label || id }
+    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++) {
@@ -295,7 +297,7 @@
             //    time they are pubbed into the cache.  After that, we can
             //    trust that they aren't referenced elsewhere.  (We make it
             //    the programmer's responsibility to clone data if necessary
-            //    on fetch, but not when on pub.)
+            //    on get, but not when on pub.)
             //
             //    We'll optimize this once we have history.  We can look at
             //    the old version to see if an object/array existed already
@@ -303,7 +305,7 @@
             //
             // 2. Don't go infinitely deep.
             //
-            //    Eventually, each save/pub will be limited to the scope
+            //    Eventually, each set/pub will be limited to the scope
             //    underneath nested keyed objects.  Right now I'm just
             //    recursing infinitely on the whole data structure with each
             //    pub.
@@ -363,7 +365,7 @@
     }
 
     function changed (object) {
-        return pending_fetches[object.key]
+        return pending_gets[object.key]
             || !       cache.hasOwnProperty(object.key)
             || !backup_cache.hasOwnProperty(object.key)
             || !(deep_equals(object, backup_cache[object.key]))
@@ -374,7 +376,7 @@
     }
 
 
-    function forget (key, save_handler, t) {
+    function forget (key, set_handler, t) {
         if (arguments.length === 0) {
             // Then we're forgetting the executing funk
             console.assert(executing_funk !== global_funk,
@@ -384,26 +386,26 @@
         }
         bogus_check(key)
 
-        //log('forget:', key, funk_name(save_handler), funk_name(executing_funk))
-        save_handler = save_handler || executing_funk
-        var fkey = funk_key(save_handler)
-        //console.log('Fetches in is', fetches_in.hash)
-        if (!fetches_in.has(key, fkey)) {
+        //log('forget:', key, funk_name(set_handler), funk_name(executing_funk))
+        set_handler = set_handler || executing_funk
+        var fkey = funk_key(set_handler)
+        //console.log('Gets in is', gets_in.hash)
+        if (!gets_in.has(key, fkey)) {
             console.error("***\n****\nTrying to forget lost key", key,
-                          'from', funk_name(save_handler), fkey,
-                          "that hasn't fetched that key.")
+                          'from', funk_name(set_handler), fkey,
+                          "that hasn't got that key.")
             console.trace()
             return
             // throw Error('asdfalsdkfajsdf')
         }
 
-        fetches_in.delete(key, fkey)
-        unbind(key, 'on_save', save_handler)
+        gets_in.delete(key, fkey)
+        unbind(key, 'on_set', set_handler)
 
         // If this is the last handler listening to this key, then we can
         // delete the cache entry, send a forget upstream, and de-activate the
-        // .on_fetch handler.
-        if (!fetches_in.has_any(key)) {
+        // .on_get handler.
+        if (!gets_in.has_any(key)) {
             clearTimeout(to_be_forgotten[key])
             to_be_forgotten[key] = setTimeout(function () {
                 // Send a forget upstream
@@ -411,7 +413,7 @@
 
                 // Delete the cache entry...?
                 // delete cache[key]
-                delete fetches_out[key]
+                delete gets_out[key]
                 delete to_be_forgotten[key]
             }, 200)
         }
@@ -443,7 +445,7 @@
         //    etc.
         //    - NOTE: I did a crappy implementation of abort just now above!
         //      But it doesn't work if called after the to_delete handler returns.
-        //    - Generalize the code across save and del with a "mutate"
+        //    - Generalize the code across set and del with a "mutate"
         //      operation
         //
         //  - Right now we fire the to_delete handlers right here.
@@ -458,18 +460,18 @@
     }
 
     var changed_keys = new Set()
-    var dirty_fetchers = {}       // Maps funk_key => version dirtied at
+    var dirty_getters = {}       // Maps funk_key => version dirtied at
     function dirty (key, t) {
         statelog(key, brown, '*', bus + ".dirty('"+key+"')")
         bogus_check(key)
 
         var version = (t && t.version) || 'dirty-' + new_version()
 
-        // Find any .to_fetch, and mark as dirty so that it re-runs
+        // Find any .to_get, and mark as dirty so that it re-runs
         var found = false
-        if (fetches_out.hasOwnProperty(key))
-            for (var i=0; i<fetches_out[key].length; i++) {
-                dirty_fetchers[funk_key(fetches_out[key][i])] = version
+        if (gets_out.hasOwnProperty(key))
+            for (var i=0; i<gets_out[key].length; i++) {
+                dirty_getters[funk_key(gets_out[key][i])] = version
                 found = true
             }
         clean_timer = clean_timer || setTimeout(clean)
@@ -486,7 +488,7 @@
     }
 
     function clean () {
-        // 1. Collect all functions for all keys and dirtied fetchers
+        // 1. Collect all functions for all keys and dirtied getters
         var dirty_funks = {}
         for (var b in busses) {
             var fs = busses[b].rerunnable_funks()
@@ -495,7 +497,7 @@
         }
         clean_timer = null
 
-        // 2. Run any priority function first (e.g. file_store's on_save)
+        // 2. Run any priority function first (e.g. file_store's on_set)
         log(bus.label, 'Cleaning up', Object.keys(dirty_funks).length, 'funks')
         for (var k in dirty_funks) {
             var funk    = funks[k],
@@ -535,19 +537,19 @@
         var result = []
         var keys = changed_keys.values()
 
-        //log(bus+' Cleaning up!', keys, 'keys, and', fetchers.length, 'fetchers')
+        //log(bus+' Cleaning up!', keys, 'keys, and', getters.length, 'getters')
         for (var i=0; i<keys.length; i++) {          // Collect all keys
             // if (to_be_forgotten[keys[i]])
             //     // Ignore changes to keys that have been forgotten, but not
             //     // processed yet
             //     continue
-            var fs = bindings(keys[i], 'on_save')
+            var fs = bindings(keys[i], 'on_set')
             for (var j=0; j<fs.length; j++) {
                 var f = fs[j].func
                 if (f.react) {
                     // Skip if it's already up to date
-                    var v = f.fetched_keys[JSON.stringify([this.id, keys[i]])]
-                    //log('re-run:', keys[i], f.statebus_id, f.fetched_keys)
+                    var v = f.getted_keys[JSON.stringify([this.id, keys[i]])]
+                    //log('re-run:', keys[i], f.statebus_id, f.getted_keys)
                     if (v && v.indexOf(versions[keys[i]]) !== -1) {
                         log('skipping', funk_name(f), 'already at version', versions[keys[i]], 'proof:', v)
                         continue
@@ -564,19 +566,19 @@
                         continue
                     }
                     autodetect_args(f)
-                    f = run_handler(f, 'on_save', cache[keys[i]], {dont_run: true,
-                                                                   binding: keys[i]})
+                    f = run_handler(f, 'on_set', cache[keys[i]], {dont_run: true,
+                                                                  binding: keys[i]})
                 }
                 result.push({funk_key: funk_key(f),
                              at_version: versions[keys[i]]})
             }
         }
-        for (var k in dirty_fetchers)  // Collect all fetchers
+        for (var k in dirty_getters)  // Collect all getters
             result.push({funk_key: k,
-                         at_version: dirty_fetchers[k]})
+                         at_version: dirty_getters[k]})
 
         changed_keys.clear()
-        dirty_fetchers = {}
+        dirty_getters = {}
 
         //log('found', result.length, 'funks to re run')
 
@@ -585,28 +587,43 @@
 
     // ****************
     // Connections
-    function subspace (key) {
-        var result = {}
-        for (var method in {to_fetch:null, to_save:null, on_save:null, on_set_sync:null,
-                            on_delete:null, to_delete:null, to_forget:null})
-            (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
+    function subspace (key, params) {
+        var methods = {to_get:null, to_set:null, on_set:null, on_set_sync:null,
+                       on_delete:null, to_delete:null, to_forget:null}
+
+        if (params) {
+            for (var method in params) {
+                console.assert(method in methods)
+                var func = params[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
+        }
     }
 
     function autodetect_args (handler) {
@@ -630,6 +647,7 @@
             case 'star':
             case 'rest':
                 handler.args['rest'] = i; break
+            case 'cb':
             case 't':
             case 'transaction':
                 handler.args['t'] = i; break
@@ -644,7 +662,7 @@
             }
     }
 
-    // The funks attached to each key, maps e.g. 'fetch /point/3' to '/30'
+    // 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}
 
@@ -659,7 +677,7 @@
         else
             handlers.add(method + ' ' + key, funk_key(func))
 
-        // Now check if the method is a fetch and there's a fetched
+        // 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) {
@@ -726,9 +744,9 @@
             just_make_it = options.dont_run,
             binding = options.binding
 
-        // When we first run a handler (e.g. a fetch or save), we wrap it in a
-        // reactive() funk that calls it with its arg.  Then if it fetches or
-        // saves, it'll register a .on_save handler with this funk.
+        // When we first run a handler (e.g. a get or set), we wrap it in a
+        // reactive() funk that calls it with its arg.  Then if it gets or
+        // sets, it'll register a .on_set handler with this funk.
 
         // Is it reactive already?  Let's distinguish it.
         var funk = funck.react && funck,  // Funky!  So reactive!
@@ -738,7 +756,7 @@
 
         if (false && !funck.global_funk) {
             // \u26A1
-            var event = {'to_save':'save','on_save':'save.fire','to_fetch':'fetch',
+            var event = {'to_set':'set','on_set':'set.fire','to_get':'get',
                          'to_delete':'delete','to_forget':'forget'}[method],
                 triggering = funk ? 're-running' : 'initiating'
             console.log('   > a', bus+'.'+event + "('" + (arg.key||arg) + "') is " + triggering
@@ -746,43 +764,50 @@
         }
 
         if (funk) {
-            // Then this is an on_save event re-triggering an already-wrapped
+            // Then this is an on_set event re-triggering an already-wrapped
             // funk.  It has its own arg internally that it's calling itself
             // with.  Let's tell it to re-trigger itself with that arg.
 
-            if (method !== 'on_save') {
-                console.error(method === 'on_save', 'Funk is being re-triggered, but isn\'t on_save. It is: "' + method + '", oh and funk: ' + funk_name(funk))
+            if (method !== 'on_set') {
+                console.error(method === 'on_set', 'Funk is being re-triggered, but isn\'t on_set. It is: "' + method + '", oh and funk: ' + funk_name(funk))
                 return
             }
             return funk.react()
 
             // Hmm... does this do the right thing?  Example:
             //
-            //    bus('foo').on_save = function (o) {...}
-            //    save({key: 'foo'})
-            //    save({key: 'foo'})
-            //    save({key: 'foo'})
+            //    bus('foo').on_set = function (o) {...}
+            //    set({key: 'foo'})
+            //    set({key: 'foo'})
+            //    set({key: 'foo'})
             //
             // Does this spin up 3 reactive functions?  Hmm...
             // Well, I think it does, but they all get forgotten once
             // they run once, and then are garbage collected.
             //
-            //    bus('foo*').on_save = function (o) {...}
-            //    save({key: 'foo1'})
-            //    save({key: 'foo2'})
-            //    save({key: 'foo1'})
-            //    save({key: 'foo3'})
+            //    bus('foo*').on_set = function (o) {...}
+            //    set({key: 'foo1'})
+            //    set({key: 'foo2'})
+            //    set({key: 'foo1'})
+            //    set({key: 'foo3'})
             //
             // Does this work ok?  Yeah, I think so.
         }
 
         // Alright then.  Let's wrap this func with some funk.
 
-        // Fresh fetch/save/forget/delete handlers will just be regular
+        // 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 val_arg () {
+            console.assert(method === 'to_set' || method === 'on_set' || method === 'on_set_sync')
+            // 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
+        }
         function vars_arg () {
             var r = rest_arg()
             try {
@@ -792,49 +817,50 @@
             }
         }
         var f = reactive(function () {
-
             // Initialize transaction
             t = clone(t || {})
 
             // Add .abort() method
-            if (method === 'to_save' || method === 'to_delete')
+            if (method === 'to_set' || method === 'to_delete')
                 t.abort = function () {
-                    var key = method === 'to_save' ? arg.key : arg
+                    var key = method === 'to_set' ? arg.key : arg
                     if (f.loading()) return
                     bus.cache[key] = bus.cache[key] || {key: key}
                     bus.backup_cache[key] = bus.backup_cache[key] || {key: key}
-                    bus.save.abort(bus.cache[key])
+                    bus.set.abort(bus.cache[key])
                 }
 
             // Add .done() method
             if (method !== 'to_forget')
                 t.done = function (o) {
-                    var key = method === 'to_save' ? arg.key : arg
+                    var key = method === 'to_set' ? arg.key : arg
+                    if (func.use_linked_json)
+                        o = {key, val: o}
                     bus.log('We are DONE()ing', method, key, o||arg)
 
                     // We use a simple (and crappy?) heuristic to know if the
-                    // to_save handler has changed the state: whether the
+                    // to_set handler has changed the state: whether the
                     // programmer passed (o) to the t.done(o) handler.  If
                     // not, we assume it hasn't changed.  If so, we assume it
                     // *has* changed, and thus we change the version of the
                     // state.  I imagine it would be more accurate to diff
-                    // from before the to_save handler began with when
+                    // from before the to_set handler began with when
                     // t.done(o) ran.
                     //
                     // Note: We will likely solve this in the future by
-                    // preventing .to_save() from changing the incoming state,
+                    // preventing .to_set() from changing the incoming state,
                     // except through an explicit .revise() function.
                     if (o) t.version = new_version()
 
                     if (method === 'to_delete')
                         delete bus.cache[key]
-                    else if (method === 'to_save') {
-                        bus.save.fire(o || arg, t)
+                    else if (method === 'to_set') {
+                        bus.set.fire(o || arg, t)
                         bus.route(key, 'on_set_sync', o || arg, t)
                     } else {
-                        // Now method === 'to_fetch'
+                        // Now method === 'to_get'
                         o.key = key
-                        bus.save.fire(o, t)
+                        bus.set.fire(o, t)
                         // And now reset the version cause it could get called again
                         delete t.version
                     }
@@ -843,14 +869,14 @@
             // Alias .return() to .done(), in case that feels better to you
             t.return = t.done
 
-            // Alias t.refetch() to bus.dirty()
-            if (method === 'to_save')
-                t.refetch = function () { bus.dirty(arg.key) }
+            // Alias t.reget() to bus.dirty()
+            if (method === 'to_set')
+                t.reget = function () { bus.dirty(arg.key) }
 
             // Now to call the handler, let's line up the function's special
             // named arguemnts like key, o, t, rest, vars, etc.
             var args = []
-            args[0] = arg
+            args[0] = (method in {to_set:1, on_set:1, on_set_sync:1}) ? val_arg() : arg
             args[1] = t
             for (var k in (func.args||{})) {
                 switch (k) {
@@ -864,7 +890,7 @@
                 case 't':
                     args[func.args[k]] = t; break
                 case 'obj':
-                    args[func.args[k]] = arg.key ? arg : bus.cache[arg]; break
+                    args[func.args[k]] = val_arg(); break
                 case 'old':
                     var key = key_arg()
                     args[func.args[k]] = bus.cache[key] || (bus.cache[key] = {key:key})
@@ -881,35 +907,45 @@
             //    arr[func.args[k]] = <compute_blah(k)>
 
             // Trigger done() or abort() by return value
-            console.assert(!(result === 'to_fetch' &&
+            console.assert(!(result === 'to_get' &&
                              (result === 'done' || result === 'abort')),
-                           'Returning "done" or "abort" is not allowed from to_fetch handlers')
+                           'Returning "done" or "abort" is not allowed from to_get handlers')
             if (result === 'done')  t.done()
             if (result === 'abort') t.abort()
 
-            // For fetch
-            if (method === 'to_fetch' && result instanceof Object
-                && !f.loading()     // Experimental.
-               ) {
-                result.key = arg
-                var new_t = clone(t || {})
-                new_t.to_fetch = true
-                save.fire(result, new_t)
-                return result
+            // For get
+            if (func.use_linked_json) {
+                if (method === 'to_get' && result !== undefined && !f.loading()) {
+                    var obj = {key: arg, val: result}
+                    var new_t = clone(t || {})
+                    new_t.to_get = true
+                    set.fire(obj, new_t)
+                    return result
+                }
+            } else {
+                if (method === 'to_get' && result instanceof Object
+                    && !f.loading()     // Experimental.
+                   ) {
+                    result.key = arg
+                    var new_t = clone(t || {})
+                    new_t.to_get = true
+                    set.fire(result, new_t)
+                    return result
+                }
             }
 
-            // Save, forget and delete handlers stop re-running once they've
+            // Set, forget and delete handlers stop re-running once they've
             // completed without anything loading.
             // ... with f.forget()
-            if (method !== 'to_fetch' && !f.loading())
+            if (method !== 'to_get' && !f.loading())
                 f.forget()
         })
         f.proxies_for = func
         f.arg = arg
         f.transaction = t || {}
 
-        // to_fetch handlers stop re-running when the key is forgotten
-        if (method === 'to_fetch') {
+        // to_get handlers stop re-running when the key is forgotten
+        if (method === 'to_get') {
             var key = arg
             function handler_done () {
                 f.forget()
@@ -918,13 +954,13 @@
             bind(key, 'to_forget', handler_done)
 
             // // Check if it's doubled-up
-            // if (fetches_out[key])
-            //     console.error('Two .to_fetch functions are running on the same key',
-            //                   key+'!', funk_name(funck), funk_name(fetches_out[key]))
+            // if (gets_out[key])
+            //     console.error('Two .to_get functions are running on the same key',
+            //                   key+'!', funk_name(funck), funk_name(gets_out[key]))
 
-            fetches_out[key] = fetches_out[key] || []
-            fetches_out[key].push(f)   // Record active to_fetch handler
-            pending_fetches[key] = f   // Record that the fetch is pending
+            gets_out[key] = gets_out[key] || []
+            gets_out[key].push(f)   // Record active to_get handler
+            pending_gets[key] = f   // Record that the get is pending
         }
 
         if (just_make_it)
@@ -943,9 +979,9 @@
         for (var i=0; i<handlers.length; i++)
             bus.run_handler(handlers[i].func, method, arg, {t: t, binding: handlers[i].key})
 
-        // if (method === 'to_fetch')
+        // if (method === 'to_get')
         //     console.assert(handlers.length<2,
-        //                    'Two to_fetch functions are registered for the same key '+key,
+        //                    'Two to_get functions are registered for the same key '+key,
         //                    handlers)
         return handlers.length
     }
@@ -955,7 +991,7 @@
     // Reactive functions
     //
     // We wrap any function with a reactive wrapper that re-calls it whenever
-    // state it's fetched changes.
+    // state it's got changes.
 
     if (!global_funk) {
         global_funk = reactive(function global_funk () {})
@@ -970,7 +1006,7 @@
         //    f = reactive(func)
         //    f(arg1, arg2)
         //
-        // This will remember every fetch it depends on, and make it re-call
+        // This will remember every get it depends on, and make it re-call
         // itself whenever that state changes.  It will remember arg1 and arg2
         // and use those again.  You can also trigger a re-action manually
         // with:
@@ -1029,14 +1065,14 @@
 
         funk.func = func  // just for debugging
         funk.called_directly = true
-        funk.fetched_keys = {} // maps [bus,key] to version
+        funk.getted_keys = {} // maps [bus,key] to version
                                // version will be undefined until loaded
         funk.abortable_keys = []
         funk.has_seen = function (bus, key, version) {
             //console.log('depend:', bus, key, versions[key])
             var bus_key = JSON.stringify([bus.id, key])
             var seen_versions =
-                this.fetched_keys[bus_key] = this.fetched_keys[bus_key] || []
+                this.getted_keys[bus_key] = this.getted_keys[bus_key] || []
             seen_versions.push(version)
             if (seen_versions.length > 50) seen_versions.shift()
         }
@@ -1051,29 +1087,29 @@
             return result
         }
         funk.forget = function () {
-            // Todo: This will bug out if an .on_save handler for a key also
-            // fetches that key once, and then doesn't fetch it again, because
-            // when it fetches the key, that key will end up being a
-            // fetched_key, and will then be forgotten as soon as the funk is
-            // re-run, and doesn't fetch it again, and the fact that it is
-            // defined as an .on_save .on_save handler won't matter anymore.
+            // Todo: This will bug out if an .on_set handler for a key also
+            // gets that key once, and then doesn't get it again, because
+            // when it gets the key, that key will end up being a
+            // getted_key, and will then be forgotten as soon as the funk is
+            // re-run, and doesn't get it again, and the fact that it is
+            // defined as an .on_set .on_set handler won't matter anymore.
 
             if (funk.statebus_id === 'global funk') return
 
-            for (var hash in funk.fetched_keys) {
+            for (var hash in funk.getted_keys) {
                 var tmp = JSON.parse(hash),
                     bus = busses[tmp[0]], key = tmp[1]
                 if (bus)  // Cause it might have been deleted
                     bus.forget(key, funk)
             }
-            funk.fetched_keys = {}
+            funk.getted_keys = {}
         }
         funk.loading = function () {
-            for (var hash in funk.fetched_keys) {
+            for (var hash in funk.getted_keys) {
                 var tmp = JSON.parse(hash),
                     bus = busses[tmp[0]], key = tmp[1]
                 if (bus  // Cause it might have been deleted
-                    && bus.pending_fetches[key])
+                    && bus.pending_gets[key])
                     return true
             }
             return false
@@ -1087,9 +1123,9 @@
 
     function loading_keys (keys) {
         // Do any of these keys have outstanding gets?
-        //console.log('Loading: pending_keys is', pending_fetches)
+        //console.log('Loading: pending_keys is', pending_gets)
         for (var i=0; i<keys.length; i++)
-            if (pending_fetches[keys[i]]) return true
+            if (pending_gets[keys[i]]) return true
         return false
     }
 
@@ -1123,7 +1159,8 @@
         var red = '', normal = '', grey = '',
             green = '', brown = ''
     function add_diff_msg (message, obj) {
-        var diff = sorta_diff(backup_cache[obj.key], obj)
+        var diff = sorta_diff(backup_cache[obj.key] && backup_cache[obj.key].val,
+                              obj && obj.val)
         if (diff) {
             var end_col = message.length + 2 + statelog_indent * 3
             for (var i=0; i<40-end_col; i++) message += ' '
@@ -1132,7 +1169,7 @@
         else message += ' <no diff>'
         return message
     }
-    function save_msg (obj, t, meth) {
+    function set_msg (obj, t, meth) {
         if (!honking_at(obj.key)) return
         var message = (t && t.m) || bus + "."+meth+"('"+obj.key+"')"
         message = add_diff_msg(message, obj)
@@ -1150,14 +1187,14 @@
         if (!name) throw 'Uncallback function needs a name'
         var watching = {}
         var prefix = 'uncallback/' + name
-        bus(prefix + '/*').to_fetch = function (key, json) {
+        bus(prefix + '/*').to_get = function (key, json) {
             var args = json
             function cb (err, result) {
                 if (err) {
                     console.trace('have err:', err, 'and result is', JSON.stringify(result))
                     throw err
                 } else
-                    bus.save.fire({key: key, _: result})
+                    bus.set.fire({key: key, _: result})
             }
 
             // Inject the callback into the right place
@@ -1184,7 +1221,7 @@
             }
         return function () {
             var args = [].slice.call(arguments)
-            return bus.fetch(prefix + '/' + JSON.stringify(args))._
+            return bus.get(prefix + '/' + JSON.stringify(args))._
         }
     }
 
@@ -1198,392 +1235,31 @@
     }
 
 
-    // Old Proxy Prototype
-    if (true) {
-        var sb = (function sb () {
-            // I have the cache behind the scenes
-            // Each proxy has a target object -- the raw data on cache
-            // If we're proxying a {_: ...} singleton then ...
-
-            function item_proxy (base, o) {
-                if (typeof o === 'number'
-                    || typeof o === 'string'
-                    || typeof o === 'boolean'
-                    || o === undefined
-                    || o === null
-                    || typeof o === 'function') return o
-
-                return new Proxy(o, {
-                    get: function get(o, k) {
-                        if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
-                            return undefined
-                        k = escape_keys(k)
-                        return item_proxy(base, o[k])
-                    },
-                    set: function set(o, k, v) {
-                        var result = o[escape_keys(k)] = v
-                        bus.save(base)
-                        return result
-                    },
-                    has: function has(o, k) {
-                        return o.hasOwnProperty(escape_keys(k))
-                    },
-                    deleteProperty: function del (o, k) {
-                        delete o[escape_keys(k)]
-                    },
-                    apply: function apply (o, This, args) {
-                        return o
-                    }
-                })}
-
-            return new Proxy(cache, {
-                get: function get(o, k) {
-                    if (k in bogus_keys) return o[k]
-                    if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
-                        return undefined
-                    var raw = bus.fetch(k),
-                        obj = raw
-                    while (typeof obj == 'object' && '_' in obj) obj = obj._
-                    return item_proxy(raw, obj)
-                },
-                set: function set(o, k, v) {
-                    if (typeof v === 'number'
-                        || typeof v === 'string'
-                        || typeof v === 'boolean'
-                        || v === undefined
-                        || v === null
-                        || typeof v === 'function'
-                        || Array.isArray(v))
-                        v = {_:v}
-                    else
-                        v = bus.clone(v)
-                    v.key = k
-                    bus.save(v)
-                },
-                // In future, this might check if there's a .to_fetch function OR
-                // something in the cache:
-                //
-                // has: function has(o, k) {
-                //     return k in o
-                // },
-                // ... but I haven't had a need yet.
-                deleteProperty: function del (o, k) {
-                    bus.delete(escape_keys(k))
-                }
-            })
-        })()
-
-
-        // ******** State (Proxy) API *********
-        //
-        // The top-level state[..] object translates pointers of the
-        // special form:
-        //
-        //    {key: <s>, _: *}
-        //
-        // Examples:
-        //
-        //    state['uninitialized']
-        //    >> undefined
-        //
-        //    state['uninitialized'] = {}
-        //    >> {key: 'uninitialized'}
-        //
-        //    state['uninitialized'] = {a: 3}
-        //    >> {key: 'uninitialized', a: 3}
-        //
-        //    state['uninitialized'] = []
-        //    >> {key: 'uninitialized', _: []}
-        //
-        //    delete state['uninitialized']
-        //    state['uninitialized']
-        //    >> undefined
-        //
-        // ** Rules
-        //  Setting:
-        //    - Escape-translate each field recursively
-        //    - If setting an object, put each field directly on it
-        //    - If setting anything else, put it into ._
-        //
-        //  Getting:
-        //    - If it has unescaped fields other than ._, return object with them
-        //    - Otherwise, return ._
-        //    - Unescape all fields
-
-        var strict_mode = (function () {return !this})()
-        function pget (base, o, k) {
-            // console.log('pget:', {base, o, k})
-
-            if (base) {
-                o = o[k]
-
-                // If new base, update and subscribe
-                if (typeof o == 'object' && 'key' in o) {
-                    base = o
-                    bus.fetch(o.key)
-                }
-            } else {
-                // We are getting from the Root
-                o = bus.fetch(k)
-                // console.log('pget: fetched', k, 'and got', o)
-                base = o
-                if (bus.validate(o, {key: '*', '?_': '*'})) {
-                    // console.log('pget: jumping into the _')
-                    o = o._
-                }
-                if (typeof o === 'object' && o.key)
-                    base = o
-            }
-
-            // Follow symlinks
-            if (typeof o == 'object' && 'key' in o && '_' in o) {
-                // Note: I don't actually need this recursion here, because
-                // recursively linked state cannot be created by the proxy API.
-                // So it can be undefined behavior.
-                var tmp = pget(base, o, '_')
-                base = tmp[0]
-                o = tmp[1]
-            }
-
-            return [base, o]
-        }
-
-        function proxy_encode_val (x) {
-            // Arrays
-            if (Array.isArray(x)) {
-                var result = []
-                for (var i=0; i < x.length; i++)
-                    result[i] = proxy_encode_val(x[i])
-                return result
-            }
-
-            // Objects
-            else if (typeof x === 'object') {
-                // Actual objects need their keys translated
-                var result = {}
-                for (var k in x)
-                    result[escape_keys(k)] = proxy_encode_val(x[k])
-                return result
-            }
-
-            // Proxieds: already have JSON, stored inside. Return it.
-            else if (typeof x === 'function' && x[symbols.is_proxy]) {
-                return x()
-            }
-
-            // Everything else return
-            return x
-        }
-        function proxy_decode_json (json) {
-            // Returns data for proxies
-            //  - Remove keys
-            //  - Translate
-
-            // Root objects of special form
-            if (bus.validate(json, {key: '*', '_': '*'}))
-                return proxy_decode_json(json._)
-
-            // Arrays
-            if (Array.isArray(json)) {
-                var arr = json.slice()
-                for (var i=0; i<arr.length; i++)
-                    arr[i] = proxy_decode_json(arr[i])
-                return arr
-            }
-
-            // Objects
-            if (typeof json === 'object' && json !== null) {
-                var obj = {}
-                for (var k in json)
-                    if (k !== 'key')
-                        obj[unescape_keys(k)] = proxy_decode_json(json[k])
-                return obj
-            }
-
-            // Other primitives just return
-            return json
-        }
-
-        if (nodejs) var util = require('util')
-        function make_proxy (base, o) {
-            if (!symbols)
-                symbols = {is_proxy: Symbol('is_proxy'),
-                           get_json: Symbol('get_json'),
-                           get_base: Symbol('get_base')}
-
-            if (typeof o !== 'object' || o === null) return o
-
-            function get_json() {
-                // Pop up to parent if this is a singleton array.
-                // We know it's a singleton array if base._ === x(), and base is
-                // of the form {key: *, _: x}
-                if (base && base._ && Object.keys(base).length === 2
-                    && base._ === o)
-                    return base
-
-                // Otherwise return x's JSON.
-                return o
-            }
-
-            // Javascript won't let us function call a proxy unless the "target"
-            // is a function.  So we make a dummy target, and don't use it.
-            var dummy_obj = function () {}
-            return new Proxy(dummy_obj, {
-                get: function (dummy_obj, k) {
-                    // console.log('get:', k, '::'+typeof k, 'on', o)
-
-                    // Print something nice for Node console inspector
-                    if (nodejs && k === util.inspect.custom) {
-                        if (o == bus.cache)
-                            return function () {return 'state'+bus.toString().substr(3)}
-                        return function () {return 'p: '+util.format(proxy_decode_json(o))}
-                    }
-                    if (k in bogus_keys) return o[k]
-                    // Proxies distinguish themselves via proxy.is_proxy == true
-                    if (k === symbols.is_proxy) return true
-                    if (k === symbols.get_json) return get_json()
-                    if (k === symbols.get_base) return base
-                    if (k === Symbol.isConcatSpreadable) return Array.isArray(o)
-                    if (k === Symbol.toPrimitive) return function () {
-                        return JSON.stringify(proxy_decode_json(o))
-                    }
-                    if (typeof k === 'symbol') {
-                        console.warn('Got request for weird symbol', k)
-                        return undefined
-                    }
-
-                    var tmp2 = pget(base, o, escape_keys(k))
-                    var base2 = tmp2[0]
-                    var o2 = tmp2[1]
-
-                    // console.log('returning proxy on', base2, o2)
-                    return make_proxy(base2, o2)
-                },
-                set: function (dummy_obj, k, v) {
-                    // console.log('set:', {base, o, k, v})
-
-                    if (base) {
-                        var encoded_v = o[escape_keys(k)] = proxy_encode_val(v)
-                        // console.log('  set: saving', encoded_v, 'into', base)
-
-                        // Collapse state of the form:
-                        //    {key: '*', _: {foo: bar, ...}}
-                        // down to:
-                        //    {key: '*', foo: bar}
-                        if (base._
-                            && Object.keys(base).length === 2
-                            && typeof base._ === 'object'
-                            && base._ !== null
-                            && !Array.isArray(base._)
-                            && !base._.key
-                            && Object.keys(base._).length !== 0) {
-                            // console.log('Collapsing', JSON.stringify(base))
-                            for (var k2 in base._)
-                                base[k2] = base._[k2]
-                            delete base._
-                        }
-
-                        bus.save(base)
-                    }
-
-                    // Saving into top-level state
-                    else {
-                        var encoded_v = proxy_encode_val(v)
-                        // console.log('  set top-level:', {v, encoded_v})
-
-                        // Setting a top-level object to undefined wipes it out
-                        if (v === undefined)
-                            encoded_v = {key: k}
-
-                        // Prefix with _: anything that is:
-                        else if (// A proxy to another state
-                            (typeof v === 'object' && v[symbols.is_proxy])
-                            // An empty {} object
-                                || (typeof v === 'object' && Object.keys(v).length === 0)
-                            // A number, bool, string, function, etc
-                                || typeof v !== 'object' || v === null
-                            // An array
-                                || Array.isArray(v))
-                            encoded_v = {_: encoded_v}
-                        encoded_v.key = k
-
-                        // console.log('  set top-level: now encoded_v is', encoded_v)
-                        bus.save(encoded_v)
-                    }
+    // ******************
+    // Proxy
 
-                    var newbase = (encoded_v && encoded_v.key) ? encoded_v : base
-                    return true
-                },
-                has: function has(O, k) {
-                    // XXX QUESTIONS:
-                    //
-                    //  - Do I want this to return true if there's a .to_fetch()
-                    //    function for this o, k?
-                    //
-                    //  - Does this need to do a fetch as well?
-                    //
-                    //  - For a keyed object, should this do a loading() check?
-                    return o.hasOwnProperty(escape_keys(k))
-                },
-                deleteProperty: function del (O, k) {
-                    if (base) {
-                        // console.log('  deleting:', escape_keys(k), 'of', o)
-                        delete o[escape_keys(k)]   // Deleting innards
-                        if (Object.keys(o).length === 1 && o.key)
-                            o._ = {}
-                        bus.save(base)
-                    }
-                    else
-                        bus.delete(escape_keys(k)) // Deleting top-level
-                },
-                apply: function apply (f, This, args) { return get_json() }
-            })
-        }
-        if (nodejs || window.Proxy)
-            var state = make_proxy(null, cache)
-
-        // So chrome can print out proxy objects decently
-        if (!nodejs)
-            window.devtoolsFormatters = [{
-                header: function (x) {
-                    if (x[symbols.is_proxy])
-                        return ['span', {style: 'background-color: #feb; padding: 3px;'},
-                                JSON.stringify(proxy_decode_json(x()))]
-                    else if (x[symbols.is_braid_proxy])
-                        return ['span', {style: 'background-color: #fffbe5; padding: 3px;'},
-                                JSON.stringify(x)]
-                                // For function proxies:
-                                // JSON.stringify(x(), null, 2)]
-                },
-                hasBody: function (x) {return false}
-            }]
+    var symbols = {
+        is_proxy: Symbol('is_proxy'),
+        is_link: Symbol('is_link'),
+        get_json: Symbol('get_json'),
+        get_base: Symbol('get_base')
     }
-
-    // ******************
-    // Braid Test Mode Proxy
-
-    var symbols = {is_braid_proxy: Symbol('is_braid_proxy'),
-                   is_proxy: Symbol('is_proxy'),
-                   is_link: Symbol('is_link'),
-                   get_json: Symbol('get_json'),
-                   get_base: Symbol('get_base')
-                  }
-    function braid_proxy () {
+    function make_proxy () {
         function item_proxy (base, o) {
 
-            // We only create a proxy for objects.
+            // Primitives pass through unscathed
             if (typeof o === 'number'
                 || typeof o === 'string'
                 || typeof o === 'boolean'
                 || o === undefined
                 || o === null
                 || typeof o === 'function')
-                // Everything else passes through unscathed
+
                 return o
 
             // We recursively descend through {key: ...} links
             if (typeof o === 'object' && 'key' in o) {
-                var new_base = bus.fetch(o.key)
+                var new_base = bus.get(o.key)
                 return item_proxy(new_base, new_base.val)
             }
 
@@ -1600,7 +1276,7 @@
                 get: function get(o, k) {
                     if (k === 'inspect' || k === 'valueOf')
                         return undefined
-                    if (k === symbols.is_braid_proxy)
+                    if (k === symbols.is_proxy)
                         return true
                     if (typeof k === 'symbol')
                         return undefined
@@ -1609,7 +1285,7 @@
                 set: function set(o, k, v) {
                     var value = translate_fields(v, proxied_2_keyed)
                     o[proxied_2_keyed(k)] = value
-                    bus.save(base)
+                    bus.set(base)
                     return true
                 },
                 has: function has(o, k) {
@@ -1635,11 +1311,11 @@
                 if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
                     return undefined
                 bogus_check(k)
-                var base = bus.fetch(k)
+                var base = bus.get(k)
                 return item_proxy(base, base.val)
             },
             set: function set(o, key, val) {
-                bus.save({key: key,
+                bus.set({key: key,
                           val: translate_fields(val, proxied_2_keyed)})
                 return true
             },
@@ -1652,17 +1328,27 @@
             // }
         })
     }
+    bus.state = make_proxy()
 
     function link (url) {
-        var result = fetch(url)
+        var result = bus.get(url)
         result[symbols.is_link] = true
         return result
     }
 
-    if ((nodejs && bus.options && bus.options.braid_mode)
-        || (!nodejs && window.Proxy && clientjs_option('braid_mode')))
-        state = braid_proxy()
 
+    // So chrome can print out proxy objects decently
+    if (!nodejs)
+        window.devtoolsFormatters = [{
+            header: function (x) {
+                if (x[symbols.is_proxy])
+                    return ['span', {style: 'background-color: #fffbe5; padding: 3px;'},
+                            JSON.stringify(x)]
+                // For function proxies:
+                // JSON.stringify(x(), null, 2)]
+            },
+            hasBody: function (x) {return false}
+        }]
 
     // ******************
     // Network client
@@ -1671,13 +1357,13 @@
         return m && m[0]
     }
     function message_method (m) {
-        return (m.fetch && 'fetch')
-            || (m.save && 'save')
+        return (m.get && 'get')
+            || (m.set && 'set')
             || (m['delete'] && 'delete')
             || (m.forget && 'forget')
     }
 
-    function net_mount (prefix, url, client_creds) {
+    function ws_mount (prefix, url, client_creds) {
         // Local: state://foo.com/* or /*
         var preprefix = prefix.slice(0,-1)
         var is_absolute = /^i?statei?:\/\//
@@ -1686,7 +1372,7 @@
         var sock
         var attempts = 0
         var outbox = []
-        var client_fetched_keys = new bus.Set()
+        var client_getted_keys = new bus.Set()
         var heartbeat
         if (url[url.length-1]=='/') url = url.substr(0,url.length-1)
         function nlog (s) {
@@ -1696,9 +1382,9 @@
             pushpop = pushpop || 'push'
             o = rem_prefixes(o)
             var m = message_method(o)
-            if (m == 'fetch' || m == 'delete' || m == 'forget')
+            if (m == 'get' || m == 'delete' || m == 'forget')
                 o[m] = rem_prefix(o[m])
-            bus.log('net_mount.send:', JSON.stringify(o))
+            bus.log('ws_mount.send:', JSON.stringify(o))
             outbox[pushpop](JSON.stringify(o))
             flush_outbox()
         }
@@ -1727,19 +1413,19 @@
         function rem_prefixes (obj) {
             return bus.translate_keys(bus.clone(obj), rem_prefix) }
 
-        bus(prefix).to_save   = function (obj, t) {
-            bus.save.fire(obj)
-            var x = {save: obj}
+        bus(prefix).to_set   = function (obj, t) {
+            bus.set.fire(obj)
+            var x = {set: obj}
             if (t.version) x.version = t.version
             if (t.parents) x.parents = t.parents
             if (t.patch)   x.patch   = t.patch
-            if (t.patch)   x.save    = rem_prefix(x.save.key)
+            if (t.patch)   x.set    = rem_prefix(x.set.key)
             send(x)
         }
-        bus(prefix).to_fetch  = function (key) { send({fetch: key}),
-                                                 client_fetched_keys.add(key) }
+        bus(prefix).to_get  = function (key) { send({get: key}),
+                                                 client_getted_keys.add(key) }
         bus(prefix).to_forget = function (key) { send({forget: key}),
-                                                 client_fetched_keys.delete(key) }
+                                                 client_getted_keys.delete(key) }
         bus(prefix).to_delete = function (key) { send({'delete': key}) }
 
         function connect () {
@@ -1749,16 +1435,16 @@
                 nlog('[*] opened ' + url)
 
                 // Update state
-                var peers = bus.fetch('peers')
+                var peers = bus.get('peers')
                 peers[url] = peers[url] || {}
                 peers[url].connected = true
-                save(peers)
+                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({save: o}))}
+                    function intro (o) {i.push(JSON.stringify({set: o}))}
                     if (creds.clientid)
                         intro({key: 'current_user', client: creds.clientid})
                     if (creds.name && creds.pass)
@@ -1777,11 +1463,11 @@
 
                 // Reconnect
                 if (attempts > 0) {
-                    // Then we need to refetch everything, cause it
+                    // Then we need to reget everything, cause it
                     // might have changed
-                    var keys = client_fetched_keys.values()
+                    var keys = client_getted_keys.values()
                     for (var i=0; i<keys.length; i++)
-                        send({fetch: keys[i]})
+                        send({get: keys[i]})
                 }
 
                 attempts = 0
@@ -1797,14 +1483,14 @@
                 setTimeout(connect, attempts++ < 3 ? 1500 : 5000)
 
                 // Update state
-                var peers = bus.fetch('peers')
+                var peers = bus.get('peers')
                 peers[url] = peers[url] || {}
                 peers[url].connected = false
-                save(peers)
+                set(peers)
 
-                // Remove all fetches and forgets from queue
+                // Remove all gets and forgets from queue
                 var new_outbox = []
-                var bad = {'fetch':1, 'forget':1}
+                var bad = {'get':1, 'forget':1}
                 for (var i=0; i<outbox.length; i++)
                     if (!bad[JSON.parse(outbox[i]).method])
                         new_outbox.push(outbox[i])
@@ -1826,18 +1512,18 @@
                     var message = JSON.parse(event.data)
                     var method = message_method(message)
 
-                    // We only take saves from the server for now
-                    if (method !== 'save' && method !== 'pong') throw 'barf'
+                    // We only take sets from the server for now
+                    if (method !== 'set' && method !== 'pong') throw 'barf'
                     bus.log('net client received', message)
                     var t = {version: message.version,
                              parents: message.parents,
                              patch: message.patch}
                     if (t.patch)
-                        msg.save = apply_patch(bus.cache[msg.save] || {key: msg.save},
+                        msg.set = apply_patch(bus.cache[msg.set] || {key: msg.set},
                                                message.patch[0])
                     if (!(t.version||t.parents||t.patch))
                         t = undefined
-                    bus.save.fire(add_prefixes(message.save), t)
+                    bus.set.fire(add_prefixes(message.set), t)
                 } catch (err) {
                     console.error('Received bad network message from '
                                   +url+': ', event.data, err)
@@ -1861,7 +1547,7 @@
         bus.route = function (key, method, arg, t) {
             var d = get_domain(key)
             if (d && !connections[d]) {
-                bus.net_mount(d + '/*', d)
+                bus.ws_mount(d + '/*', d)
                 connections[d] = true
             }
 
@@ -2210,8 +1896,8 @@
     }
 
     // This prune() function is a temporary workaround for dealing with nested
-    // objects in save() handlers, until we change statebus' behavior.  Right
-    // now, it calls .to_save only on the top-level state.  But if that state
+    // objects in set() handlers, until we change statebus' behavior.  Right
+    // now, it calls .to_set only on the top-level state.  But if that state
     // validates, it calls fire() on *every* level of state.  This means that
     // state changes can sneak inside.  Prune() will take out any changes from
     // the nested levels of state in a new object -- replacing them with the
@@ -2228,7 +1914,7 @@
             // Recurse through each property on objects
             else if (typeof(o) === 'object')
                 if (o !== null && o.key)
-                    return bus.fetch(o.key)
+                    return bus.get(o.key)
                 else
                     for (var k in o)
                         o[k] = recurse(o[k])
@@ -2334,8 +2020,8 @@
         switch (def.as) {
         case 'handler':
             return def.bus+"('"+def.key+"')."+def.method+' = '+f_string
-        case 'fetch callback':
-                return 'fetch('+def.key+', '+f_string+')'
+        case 'get callback':
+                return 'get('+def.key+', '+f_string+')'
         case 'reactive':
             return "reactive('"+f_string+"')"
         default:
@@ -2346,7 +2032,7 @@
     function deps (key) {
         // First print out everything waiting for it to pub
         var result = 'Deps: ('+key+') fires into:'
-        var pubbers = bindings(key, 'on_save')
+        var pubbers = bindings(key, 'on_set')
         if (pubbers.length === 0) result += ' nothing'
         for (var i=0; i<pubbers.length; i++)
             result += '\n  ' + funk_name(pubbers[i].func)
@@ -2390,16 +2076,16 @@
     }
 
     // Make these private methods accessible
-    var api = ['cache backup_cache fetch save forget del fire dirty fetch_once',
+    var api = ['cache backup_cache get set forget del fire dirty get_once',
                'subspace bindings run_handler bind unbind reactive uncallback',
                'versions new_version',
-               'make_proxy braid_proxy state sb link',
+               'link',
                'funk_key funk_name funks key_id key_name id',
-               'pending_fetches fetches_in fetches_out loading_keys loading once',
+               'pending_gets gets_in gets_out loading_keys loading once',
                'global_funk busses rerunnable_funks',
                'escape_keys unescape_keys translate_keys apply_patch',
                'keyed_2_proxied proxied_2_keyed translate_fields',
-               'net_mount net_automount message_method',
+               '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(' ')
     for (var i=0; i<api.length; i++)
@@ -2417,27 +2103,20 @@
             document.querySelector('script[src^="client"][src$=".js"]'))
         return script_elem && script_elem.getAttribute(option_name)
     }
-    if (nodejs || clientjs_option('globals') !== 'false') {
-        var globals = ['loading', 'clone', 'forget']
-        var client_globals = ['fetch', 'save', 'del', 'state']
-        if (!nodejs && Object.keys(busses).length == 0)
-            globals = globals.concat(client_globals)
-
-        this.og_fetch = this.fetch    // Cause fetch() is actually a browser API now
-        for (var i=0; i<globals.length; i++)
-            this[globals[i]] = eval(globals[i])
-    }
 
     busses[bus.id] = bus
+    var this_bus_num = bus_count++
+
+    bus.libs = {}
 
     if (nodejs)
-        require('./server').import_server(bus, options)
+        require('./servers').import_server(bus, options)
     
     bus.render_when_loading = true
     return bus
 }
 
-if (nodejs) require('./server').import_module(make_bus)
+if (nodejs) require('./servers').import_module(make_bus)
 
 return make_bus
 }))