statebus 6.1.9 → 6.1.13

package/client.js

@@ -57,6 +57,62 @@
         return {clientid: me.client}
     }
 
+    function braid_http_mount (prefix, url) {
+        var preprefix = prefix.slice(0,-1)
+        var has_prefix = new RegExp('^' + preprefix)
+        var is_absolute = /^https?:\/\//
+        var client_fetched_keys = new bus.Set()
+        if (url[url.length-1]=='/') url = url.substr(0,url.length-1)
+        function add_prefix (key) {
+            return is_absolute.test(key) ? key : preprefix + key }
+        function rem_prefix (key) {
+            return has_prefix.test(key) ? key.substr(preprefix.length) : key }
+        function add_prefixes (obj) {
+            return bus.translate_keys(bus.clone(obj), add_prefix) }
+        function rem_prefixes (obj) {
+            return bus.translate_keys(bus.clone(obj), rem_prefix) }
+
+        bus(prefix).to_save   = function (obj, t) {
+            console.log('saving', prefix, obj)
+            bus.save.fire(obj)
+
+            // var x = {save: 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)
+
+            braid_fetch(url + obj.key,
+                        {
+                            method: 'put',
+                            body: JSON.stringify(obj.val)
+                        })
+        }
+
+        bus(prefix).to_fetch  = function (key, t) {
+            try {
+                braid_fetch(url + rem_prefix(key),
+                            {
+                                method: 'get',
+                                subscribe: true
+                            }
+                           ).andThen( x => {
+                               t.return({
+                                   key,
+                                   val: add_prefixes(JSON.parse(x.body))
+                               })
+                           })
+            } catch (e) {
+                console.error('Braid-HTTP network error:', e)
+            }
+            client_fetched_keys.add(key)
+        }
+        bus(prefix).to_forget = function (key) {
+            // send({forget: key}),
+            client_fetched_keys.delete(key)
+        }
+    }
+
 
     // ****************
     // Manipulate Localstorage
@@ -382,16 +438,22 @@
         react_render = React.version >= '0.14.' ? ReactDOM.render : React.render
         make_client_statebus_maker()
         window.bus = window.statebus()
-        window.bus.label = 'bus'
-        window.sb = bus.sb
+        bus.label = 'bus'
+        if (clientjs_option('braid_mode_test'))
+            bus.state = bus.braid_proxy()
+        else
+            window.sb = bus.sb
         statebus.widget = React_View
         statebus.create_react_class = React_View
         statebus.createReactClass = React_View
 
         improve_react()
         window.ignore_flashbacks = false
-        if (statebus_server !== 'none')
+        if (statebus_server !== 'none') {
             bus.net_mount ('/*', statebus_server)
+            if (clientjs_option('braid_mode_test'))
+                braid_http_mount ('http/*', statebus_server)
+        }
 
         if (window.statebus_backdoor) {
             window.master = statebus()
@@ -399,16 +461,19 @@
         }
         bus.net_automount()
 
-        // bus('*').to_save = function (obj) { bus.save.fire(obj) }
-        bus('/new/*').to_save = function (o) {
-            if (o.key.split('/').length > 3) return
+        // This /new/* code is deprecated
+        if (!clientjs_option('braid_mode_test')) {
+            bus('/new/*').to_save = function (o) {
+                if (o.key.split('/').length > 3) return
 
-            var old_key = o.key
-            o.key = old_key + '/' + Math.random().toString(36).substring(2,12)
-            statebus.cache[o.key] = o
-            delete statebus.cache[old_key]
-            bus.save(o)
+                var old_key = o.key
+                o.key = old_key + '/' + Math.random().toString(36).substring(2,12)
+                statebus.cache[o.key] = o
+                delete statebus.cache[old_key]
+                bus.save(o)
+            }
         }
+
         load_coffee()
 
         statebus.compile_coffee = compile_coffee

package/extras/tests.js

@@ -294,6 +294,43 @@ test(function url_translation (done) {
     done()
 })
 
+test(function translate_fields (done) {
+    // Translate Statebus -> Proxy format
+    var tests1 = [
+        [{key: 'foo', link: 'boo'}, {key: 'foo', link: 'boo'}],
+        [{_key: 'foo', link: 'boo'}, {key: 'foo', link: 'boo'}],
+        [{__key: 'foo', link: 'boo'}, {_key: 'foo', link: 'boo'}],
+        [[{_key: 'foo', link: 'boo'}], [{key: 'foo', link: 'boo'}]],
+        [{a: [{_key: 'foo'}]}, {a: [{key: 'foo'}]}]
+    ]
+
+    // Translate Proxy -> Statebus format
+    var tests2 = [
+        [{key: 'foo', link: 'boo'}, {_key: 'foo', link: 'boo'}],
+        [{_key: 'foo', link: 'boo'}, {__key: 'foo', link: 'boo'}],
+        [[{_key: 'foo', link: ['boo']}], [{__key: 'foo', link: ['boo']}]]
+    ]
+
+    // Test 1
+    var tests = tests1
+    for (var i=0; i<tests.length; i++) {
+        var trans = bus.translate_fields(tests[i][0], bus.keyed_2_proxied)
+        assert(bus.deep_equals(trans, tests[i][1]),
+               'Bad translation1: ' + i + ' ' + JSON.stringify(trans))
+    }
+
+    // Test 2
+    tests = tests2
+    for (var i=0; i<tests2.length; i++) {
+        var trans = bus.translate_fields(tests[i][0], bus.proxied_2_keyed)
+        assert(bus.deep_equals(trans, tests[i][1]),
+               'Bad translation2: ' + i + ' ' + JSON.stringify(trans))
+    }
+
+    log('Passed translate_fields')
+    done()
+})
+
 test(function basics (done) {
     bus('basic wait').to_fetch = function () {
         setTimeout(function () {bus.save.fire({key:'basic wait', a:1})},
@@ -834,6 +871,102 @@ test(function proxies2 (done) {
     // Getting a normal property should do a fetch
 })
 
+test(function braid_proxies (done) {
+    var bus = require('../statebus').serve({braid_mode_test: true,
+                                            file_store: false})
+    var state = bus.state
+
+    assert(state.array === undefined)
+    assert(state.bar === undefined)
+
+    state.array = []
+    log('array:', state.array)
+    assert(state.array.length === 0)
+    state.array[0] = 1
+    log('array:', state.array)
+    assert(state.array.length === 1)
+    state.bar = {}
+    log('bar:', state.bar)
+    state.bar = {a: 1}
+    log('bar:', state.bar)
+    assert(state.bar.a === 1)
+    state.bar.a = state.array
+    log('bar:', state.bar)
+    state.array[1] = 2
+    log('array:', state.array)
+    log('bar:', state.bar)
+    assert(state.bar.a[1] !== 2,
+           "Array ref linked.\n\t"
+           + JSON.stringify(bus.cache.bar) + '\n\t'
+           + JSON.stringify(bus.cache.array))
+
+    state.undefining = undefined
+    assert(state.undefining === undefined)
+    state.undefining = {a: undefined}
+    log('state.undefining =', state.undefining)
+    // assert(state.undefining.a === undefined)
+    // TODO: fix https://github.com/invisible-college/statebus/issues/34
+    state.undefining = {}
+    assert(!('a' in state.undefining))
+    state.undefining.a = undefined
+    assert('a' in state.undefining)
+    assert(state.undefining.a === undefined)
+
+    state.b = {a: undefined}
+    assert('a' in state.b)
+    assert(state.b.a === undefined)
+    delete state.b.a
+    // TODO: https://github.com/invisible-college/statebus/issues/34
+    assert(!('a' in state.b))
+    assert(state.b.a === undefined)
+
+    return done()
+
+    /*
+      Things I want to test:
+
+      - Setting nested items
+      - Escaping their fields
+      - Calling fetch on them
+      - Converting state[..] to keyed objects internally
+      - has() potentially doing a fetch, or loading()
+      - set() returning a proxy object
+      - console output
+      - node AND chrome
+      - having nice colors and distinctions and shit
+    */
+
+    state.foo = 3
+    // This should set into _
+    console.assert(bus.validate(bus.cache.foo,
+                                {key: 'foo', _: 3}))
+
+
+    state.foo = {a: 5}
+    // This should set directly on it
+    console.assert(bus.validate(bus.cache.foo,
+                                {key: 'foo', a: 5}))
+    state.foo.b = 6
+    console.assert(bus.validate(bus.cache.foo,
+                                {key: 'foo', b: 6}))
+
+    state.bar = [3]
+    state.foo = {a: 3, bar: state.bar}
+
+    bus(() => {
+        state.foo      // foo triggers re-render
+        state.foo.bar  // bar triggers re-render
+        state.foo.a    // triggers re-render too
+    })
+
+    // Getting a linked item should do a fetch
+    bus(() => {
+        state.bar
+    })
+
+    // Getting a normal property should do a fetch
+})
+
 test(function only_one (done) {
     bus('only_one/*').to_fetch = function (k) {
         var id = k[k.length-1]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statebus",
-  "version": "6.1.9",
+  "version": "6.1.13",
   "description": "Synchronize state.",
   "main": "statebus.js",
   "scripts": {
@@ -10,6 +10,7 @@
   "repository": "invisible-college/statebus",
   "dependencies": {
     "bcrypt-nodejs": "0.0.3",
+    "braidify": "^0.1.18",
     "chokidar": "^3.4.0",
     "coffeescript": "^2.3.1",
     "cookie": "^0.3.1",

package/server.js

@@ -96,7 +96,7 @@ function import_server (bus, options)
                 bus.sync_files(x.state_path, x.fs_path)
         })
 
-        // User will put their routes in here
+        // User will put his routes in here
         bus.express.use('/', bus.http)
 
         // Use braidify if it's available
@@ -107,7 +107,7 @@ function import_server (bus, options)
             var braidify = undefined
         }
 
-        // Add a fallback that goes to state
+        // Mirror state over HTTP
         bus.express.get('*', function (req, res) {
             // Make a temporary client bus
             var cbus = bus.bus_for_http_client(req, res)
@@ -115,6 +115,7 @@ function import_server (bus, options)
             function end_it_all () {
                 cbus.forget(key, cb)
                 cbus.delete_bus()
+                res.end()
             }
 
             braidify && braidify(req, res)
@@ -128,25 +129,86 @@ function import_server (bus, options)
             cbus.honk = 'statelog'
             var key = req.path.substr(1)
             cbus.fetch(key, cb = (o) => {
-                if (braidify)
-                    res.sendVersion({body: bus.to_http_body(o)})
+                var body = bus.to_http_body(o)
+
+                // Return 404 if the value is undefined
+                if (!body) {
+                    console.log('no body! time to 404')
+                    res.statusCode = 404
+                    res.end()
+                }
+
+                // Or if we're braid, send via subscription
+                else if (braidify)
+                    res.sendVersion({body})
+
+                // Or just return the current version
                 else
-                    res.send(bus.to_http_body(o))
+                    res.send(body)
 
-                if (!braidify || !req.subscribe)
+                // And shut down the connection if there's nothing left to do
+                if (!braidify || !req.subscribe || !body)
                     end_it_all()
             })
         })
 
+        bus.express.put('*', function (req, res) {
+            console.log('Got a put with body', req.body)
+
+            // Make a temporary client bus
+            var cbus = bus.bus_for_http_client(req, res)
+
+            // Maybe the new state is expressed in patches
+            if (req.headers.patches) {
+                console.error("We don't actually handle PUT patches yet")
+
+                // var patches = await req.patches()
+                // console.log("...but we see these patches:", patches)
+
+                res.statusCode = 500
+                res.end()
+            } else {
+                // Otherwise, we assume the body is content-type: json
+                if (typeof req.headers['content-type'] !== 'string'
+                    || req.headers['content-type'].toLowerCase() !== 'application/json')
+                    console.error('Error: PUT content-type is not application/json')
+                var body = ''
+                req.on('data', chunk => {body += chunk.toString()})
+                req.on('end', () => {
+                    try {
+                        console.log('gonna parse', body)
+                        var path = req.url.substr(1)
+                        var obj = bus.from_http_body(path, body)
+                    } catch (e) {
+                        console.error('Error: PUT body was not valid json', e)
+                        res.statusCode = 500
+                        res.end()
+                        return
+                    }
+                    cbus.save(obj)
+                    res.statusCode = 200
+                    res.end()
+                })
+            }
+        })
+
         // Set up default linked json converters
-        bus.to_http_body = (o) => {
-            var unwrap = (Object.keys(o).length === 2
-                          && '_' in o
-                          && typeof o._ === 'string')
-            // To do: translate pointers as keys
-            return unwrap ? o._ : JSON.stringify(o)
-        }
-        bus.from_http_body = (o) => {}
+        if (bus.options.braid_mode_test) {
+            bus.to_http_body = (o) => JSON.stringify(o.val)
+            bus.state = bus.braid_proxy()
+        } else
+            bus.to_http_body = (o) => {
+                var unwrap = (Object.keys(o).length === 2
+                              && '_' in o
+                              && typeof o._ === 'string')
+                // To do: translate pointers as keys
+                return unwrap ? o._ : JSON.stringify(o)
+            }
+
+        bus.from_http_body = (key, body) => ({
+            key,
+            val: JSON.parse(body)
+        })
 
         // Serve Client Coffee
         bus.serve_client_coffee()

package/statebus.js

@@ -1197,358 +1197,443 @@
         })
     }
 
-    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
+    // 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(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
-                    k = encode_field(k)
-                    return item_proxy(base, o[k])
+                    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) {
-                    var result = o[encode_field(k)] = v
-                    bus.save(base)
-                    return result
-                },
-                has: function has(o, k) {
-                    return o.hasOwnProperty(encode_field(k))
+                    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) {
-                    delete o[encode_field(k)]
-                },
-                apply: function apply (o, This, args) {
-                    return o
+                    bus.delete(escape_keys(k))
                 }
-            })}
-
-        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(encode_field(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) {
+        // ******** 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
-                bus.fetch(o.key)
+                if (bus.validate(o, {key: '*', '?_': '*'})) {
+                    // console.log('pget: jumping into the _')
+                    o = o._
+                }
+                if (typeof o === 'object' && o.key)
+                    base = o
             }
-        } 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._
+
+            // 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]
             }
-            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]
         }
 
-        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
+            }
 
-    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
+            }
 
-        // Objects
-        else if (typeof x === 'object') {
-            // Actual objects need their keys translated
-            var result = {}
-            for (var k in x)
-                result[encode_field(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()
+            }
 
-        // 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
+            }
 
-        // 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._)
+            // 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
+            }
 
-        // 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
+            // Other primitives just return
+            return json
         }
 
-        // Objects
-        if (typeof json === 'object' && json !== null) {
-            var obj = {}
-            for (var k in json)
-                if (k !== 'key')
-                    obj[decode_field(k)] = proxy_decode_json(json[k])
-            return obj
-        }
+        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
+            }
 
-        // Other primitives just return
-        return json
-    }
+            // 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
+                    }
 
-    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')}
+                    var tmp2 = pget(base, o, escape_keys(k))
+                    var base2 = tmp2[0]
+                    var o2 = tmp2[1]
 
-        if (typeof o !== 'object' || o === null) return o
+                    // 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._
+                        }
 
-        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
+                        bus.save(base)
+                    }
 
-            // Otherwise return x's JSON.
-            return o
+                    // 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)
+                    }
+
+                    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) {
+                    return x[symbols.is_proxy] &&
+                        ['span', {style: 'background-color: #feb; padding: 3px;'},
+                         JSON.stringify(proxy_decode_json(x()))]
+                },
+                hasBody: function (x) {return false}
+            }]
+    }
 
-        // 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
-                }
+    // ******************
+    // Braid Test Mode Proxy
 
-                var tmp2 = pget(base, o, encode_field(k))
-                var base2 = tmp2[0]
-                var o2 = tmp2[1]
+    var symbols = {is_proxy: Symbol('is_proxy'),
+                   is_link: Symbol('is_link'),
+                   get_json: Symbol('get_json'),
+                   get_base: Symbol('get_base')}
+    function braid_proxy () {
+        function item_proxy (base, o) {
 
-                // 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[encode_field(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._
-                    }
-                        
+            // We only create a proxy for objects.
+            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)
+                return item_proxy(new_base, new_base.val)
+            }
+
+            return new Proxy(o, {
+                get: function get(o, k) {
+                    if (k === 'inspect'
+                        || k === 'valueOf' || typeof k === 'symbol')
+                        return undefined
+                    return item_proxy(base, o[proxied_2_keyed(k)])
+                },
+                set: function set(o, k, v) {
+                    var value = translate_fields(v, proxied_2_keyed)
+                    o[proxied_2_keyed(k)] = value
                     bus.save(base)
+                    return value
+                },
+                has: function has(o, k) {
+                    return o.hasOwnProperty(proxied_2_keyed(k))
+                },
+                deleteProperty: function del (o, k) {
+                    delete o[proxied_2_keyed(k)]
+                },
+                apply: function apply (o, This, args) {
+                    return o
                 }
+            })}
 
-                // 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)
-                }
 
-                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(encode_field(k))
+        // The top-level Proxy object holds HTTP resources
+        return new Proxy(cache, {
+            get: function get(o, k) {
+                if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
+                    return undefined
+                if (k in bogus_keys)
+                    return o[k]
+                var base = bus.fetch(k)
+                return item_proxy(base, base.val)
             },
-            deleteProperty: function del (O, k) {
-                if (base) {
-                    // console.log('  deleting:', encode_field(k), 'of', o)
-                    delete o[encode_field(k)]   // Deleting innards
-                    if (Object.keys(o).length === 1 && o.key)
-                        o._ = {}
-                    bus.save(base)
-                }
-                else
-                    bus.delete(encode_field(k)) // Deleting top-level
+            set: function set(o, key, val) {
+                bus.save({key: key, val: val})
             },
-            apply: function apply (f, This, args) { return get_json() }
+            deleteProperty: function del (o, k) {
+                bus.delete(proxied_2_keyed(k))
+            }
         })
     }
-    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) {
-                return x[symbols.is_proxy] &&
-                    ['span', {style: 'background-color: #feb; padding: 3px;'},
-                     JSON.stringify(proxy_decode_json(x()))]
-            },
-            hasBody: function (x) {return false}
-        }]
+    function link (url) {
+        var result = fetch(url)
+        result[symbols.is_link] = true
+        return result
+    }
+
+    if ((nodejs && bus.options && bus.options.braid_mode_test)
+        || (!nodejs && window.Proxy && clientjs_option('braid_mode_test')))
+        state = braid_proxy()
+
 
     // ******************
     // Network client
@@ -1756,8 +1841,8 @@
     }
 
 
-    // ******************
-    // Key translation
+    // ************************************************
+    // Translating the URLs under keys of state
     function translate_keys (obj, f) {
         // Recurse through each element in arrays
         if (Array.isArray(obj))
@@ -1779,14 +1864,60 @@
             }
         return obj
     }
-    function encode_field(k) {
+    function escape_keys(k) {
         return k.replace(/(_(keys?|time)?$|^key$)/, '$1_')
     }
-    function decode_field (k) {
+    function unescape_keys (k) {
         return k.replace(/(_$)/, '')
     }
 
 
+    // ************************************************
+    // Translating fields of objects
+
+    // Recurse through JSON and swap all object fields with other field names,
+    // according to the function f(field, object).  Returns a copy.
+    //
+    // f(field, object) takes a string `field` and returns the new field name
+    // for `object`.
+    function translate_fields (input, f) {
+        var result
+
+        // Recurse through each element in arrays
+        if (Array.isArray(input)) {
+            var new_array = input.slice()
+            for (var i=0; i < input.length; i++)
+                new_array[i] = translate_fields(input[i], f)
+            result = new_array
+        }
+
+        // Recurse through each property on objects
+        else if (typeof input === 'object') {
+            var new_obj = {}
+            for (var k in input)
+                new_obj[f(k, input)] = translate_fields(input[k], f)
+            result = new_obj
+        }
+
+        // Everything else passes through unscathed
+        else
+            result = input
+
+        return result
+    }
+    // Remove underscore from _key
+    function keyed_2_proxied (k, object) {
+        if (object[symbols.is_link])
+            return k
+        else
+            return k.replace(/^(_*)_key$/, '$1key')
+    }
+    // Add underscore to key
+    function proxied_2_keyed (k) {
+        return k.replace(/^(_*)key$/, '$1_key')
+    }
+
+
     // ******************
     // JSON encoding
     //  - Does both escape/unescape keys, and wraps/unwraps pointers
@@ -2209,7 +2340,7 @@
             if (bus.honking_colors === false)
                 indented_log(icon + ' ' + message)
             else
-                indented_log(color + icon + ' ' + message + normal_color)
+                indented_log(color + icon + ' ' + message + normal)
     }
     function honking_at (key) {
         return (bus.honk instanceof RegExp
@@ -2233,11 +2364,12 @@
     var api = ['cache backup_cache fetch save forget del fire dirty fetch_once',
                'subspace bindings run_handler bind unbind reactive uncallback',
                'versions new_version',
-               'make_proxy state sb',
+               'make_proxy braid_proxy state sb link',
                'funk_key funk_name funks key_id key_name id',
                'pending_fetches fetches_in fetches_out loading_keys loading once',
                'global_funk busses rerunnable_funks',
-               'encode_field decode_field translate_keys apply_patch',
+               'escape_keys unescape_keys translate_keys apply_patch',
+               'keyed_2_proxied proxied_2_keyed translate_fields',
                'net_mount net_automount message_method',
                'parse Set One_To_Many clone extend deep_map deep_equals prune validate sorta_diff log deps'
               ].join(' ').split(' ')