braidfs 0.0.82 → 0.0.85

package/index.js

@@ -4,10 +4,10 @@ var { diff_main } = require(`${__dirname}/diff.js`),
     braid_text = require("braid-text"),
     braid_fetch = require('braid-http').fetch
 
-var proxy_base = `${require('os').homedir()}/http`,
-    braidfs_config_dir = `${proxy_base}/.braidfs`,
+var sync_base = `${require('os').homedir()}/http`,
+    braidfs_config_dir = `${sync_base}/.braidfs`,
     braidfs_config_file = `${braidfs_config_dir}/config`,
-    proxy_base_meta = `${braidfs_config_dir}/proxy_base_meta`
+    sync_base_meta = `${braidfs_config_dir}/proxy_base_meta`
 braid_text.db_folder = `${braidfs_config_dir}/braid-text-db`
 var trash = `${braidfs_config_dir}/trash`
 var temp_folder = `${braidfs_config_dir}/temp`
@@ -15,7 +15,7 @@ var temp_folder = `${braidfs_config_dir}/temp`
 var config = null,
     watcher_misses = 0
 
-if (require('fs').existsSync(proxy_base)) {
+if (require('fs').existsSync(sync_base)) {
     try {
         config = require('fs').readFileSync(braidfs_config_file, 'utf8')
     } catch (e) { return console.log(`could not find config file: ${braidfs_config_file}`) }
@@ -44,18 +44,21 @@ if (require('fs').existsSync(proxy_base)) {
     require('fs').writeFileSync(braidfs_config_file, JSON.stringify(config, null, 4))
 }
 
-require('fs').mkdirSync(proxy_base_meta, { recursive: true })
+require('fs').mkdirSync(sync_base_meta, { recursive: true })
 require('fs').mkdirSync(trash, { recursive: true })
 require('fs').mkdirSync(temp_folder, { recursive: true })
 
-// process command line args
-let to_run_in_background = process.platform === 'darwin' ? `
+// Add instructions for how to run in the background on this OS
+var to_run_in_background = process.platform === 'darwin' ? `
 To run daemon in background:
     launchctl submit -l org.braid.braidfs -- braidfs run` : ''
-let argv = process.argv.slice(2)
+// ...except this doesn't work yet.  So disable.
+to_run_in_background = ''
 
 console.log(`braidfs version: ${require(`${__dirname}/package.json`).version}`)
 
+// process command line args
+var argv = process.argv.slice(2)
 if (argv.length === 1 && argv[0].match(/^(run|serve)$/)) {
     return main()
 } else if (argv.length && argv.length % 2 == 0 && argv.every((x, i) => i % 2 != 0 || x.match(/^(sync|unsync)$/))) {
@@ -64,7 +67,7 @@ if (argv.length === 1 && argv[0].match(/^(run|serve)$/)) {
             var sync = argv[i] === 'sync',
                 url = argv[i + 1]
             if (!url.match(/^https?:\/\//)) {
-                if (url.startsWith('/')) url = require('path').relative(proxy_base, url)
+                if (url.startsWith('/')) url = require('path').relative(sync_base, url)
                 url = `https://${url}`
             }
             console.log(`${sync ? '' : 'un'}subscribing ${sync ? 'to' : 'from'} ${url}`)
@@ -124,9 +127,9 @@ async function main() {
                 var fullpath = decodeURIComponent(m[1])
                 var hash = decodeURIComponent(m[2])
 
-                var path = require('path').relative(proxy_base, fullpath)
-                var proxy = await proxy_url.cache[normalize_url(path)]
-                var version = proxy?.hash_to_version_cache.get(hash)?.version
+                var path = require('path').relative(sync_base, fullpath)
+                var sync = await sync_url.cache[normalize_url(path)]
+                var version = sync?.hash_to_version_cache.get(hash)?.version
                 if (!version) res.statusCode = 404
                 return res.end(JSON.stringify(version))
             }
@@ -134,11 +137,11 @@ async function main() {
             var m = url.match(/^\.braidfs\/set_version\/([^\/]*)\/([^\/]*)/)
             if (m) {
                 var fullpath = decodeURIComponent(m[1])
-                var path = require('path').relative(proxy_base, fullpath)
-                var proxy = await proxy_url.cache[normalize_url(path)]
+                var path = require('path').relative(sync_base, fullpath)
+                var sync = await sync_url.cache[normalize_url(path)]
 
                 var parents = JSON.parse(decodeURIComponent(m[2]))
-                var parent_text = proxy?.version_to_text_cache.get(JSON.stringify(parents)) ?? (await braid_text.get(proxy.url, { parents })).body
+                var parent_text = sync?.version_to_text_cache.get(JSON.stringify(parents)) ?? (await braid_text.get(sync.url, { parents })).body
 
                 var text = await new Promise(done => {
                     const chunks = []
@@ -149,14 +152,14 @@ async function main() {
                 var patches = diff(parent_text, text)
 
                 if (patches.length) {
-                    proxy.local_edit_counter += patches_to_code_points(patches, parent_text)
-                    var version = [proxy.peer + "-" + (proxy.local_edit_counter - 1)]
-                    await braid_text.put(proxy.url, { version, parents, patches, merge_type: 'dt' })
+                    sync.local_edit_counter += patches_to_code_points(patches, parent_text)
+                    var version = [sync.peer + "-" + (sync.local_edit_counter - 1)]
+                    await braid_text.put(sync.url, { version, parents, patches, merge_type: 'dt' })
 
                     // may be able to do this more efficiently.. we want to make sure we're capturing a file write that is after our version was written.. there may be a way we can avoid calling file_needs_writing here
                     var stat = await new Promise(done => {
-                        proxy.file_written_cbs.push(done)
-                        proxy.signal_file_needs_writing()
+                        sync.file_written_cbs.push(done)
+                        sync.signal_file_needs_writing()
                     })
 
                     res.writeHead(200, { 'Content-Type': 'application/json' })
@@ -179,7 +182,7 @@ async function main() {
         console.log(`daemon started on port ${config.port}`)
         if (!config.allow_remote_access) console.log('!! only accessible from localhost !!')
 
-        proxy_url('.braidfs/config').then(() => {
+        sync_url('.braidfs/config').then(() => {
             braid_text.get('.braidfs/config', {
                 subscribe: async update => {
                     let prev = config
@@ -192,10 +195,10 @@ async function main() {
                         var old_syncs = Object.entries(prev.sync).filter(x => x[1]).map(x => normalize_url(x[0]).replace(/^https?:\/\//, ''))
                         var new_syncs = new Set(Object.entries(config.sync).filter(x => x[1]).map(x => normalize_url(x[0]).replace(/^https?:\/\//, '')))
                         for (let url of old_syncs.filter(x => !new_syncs.has(x)))
-                            unproxy_url(url)
+                            unsync_url(url)
 
-                        // proxy all the new stuff
-                        for (let x of Object.entries(config.sync)) if (x[1]) proxy_url(x[0])
+                        // sync all the new stuff
+                        for (let x of Object.entries(config.sync)) if (x[1]) sync_url(x[0])
 
                         // if any auth stuff has changed,
                         // have the appropriate connections reconnect
@@ -209,7 +212,7 @@ async function main() {
                                 || JSON.stringify(prev.cookies[domain]) !== JSON.stringify(v))
                                 changed.add(domain)
                         // ok, have every domain which has changed reconnect
-                        for (let [path, x] of Object.entries(proxy_url.cache))
+                        for (let [path, x] of Object.entries(sync_url.cache))
                             if (changed.has(path.split(/\//)[0].split(/:/)[0]))
                                 (await x).reconnect?.()
                     } catch (e) {
@@ -219,10 +222,10 @@ async function main() {
                 }
             })
         })
-        proxy_url('.braidfs/errors')
+        sync_url('.braidfs/errors')
 
         console.log({ sync: config.sync })
-        for (let x of Object.entries(config.sync)) if (x[1]) proxy_url(x[0])
+        for (let x of Object.entries(config.sync)) if (x[1]) sync_url(x[0])
 
         watch_files()
         setTimeout(scan_files, 1200)
@@ -255,7 +258,6 @@ function skip_file(path) {
 async function trash_file(fullpath, path) {
     // throw this unrecognized file into the trash,
     let dest = `${trash}/${braid_text.encode_filename(path)}_${Math.random().toString(36).slice(2)}`
-    console.log(`moving untracked file ${fullpath} to ${dest}`)
     await require('fs').promises.rename(fullpath, dest)
 
     // and log an error
@@ -263,6 +265,8 @@ async function trash_file(fullpath, path) {
 }
 
 async function log_error(text) {
+    console.log(`LOGGING ERROR: ${text}`)
+
     var x = await braid_text.get('.braidfs/errors', {}),
         len = [...x.body].length
     await braid_text.put('.braidfs/errors', {
@@ -282,28 +286,28 @@ async function watch_files() {
     await w?.close()
 
     console.log('watch files..')
-    watch_files.watcher = require('chokidar').watch(proxy_base).
+    watch_files.watcher = require('chokidar').watch(sync_base).
         on('add', x => chokidar_handler(x, 'add')).
         on('change', x => chokidar_handler(x, 'change')).
         on('unlink', x => chokidar_handler(x, 'unlink'))
 
     async function chokidar_handler(fullpath, event) {
-        // Make sure the path is within proxy_base..
-        if (!fullpath.startsWith(proxy_base))
-            return on_watcher_miss(`path ${fullpath} outside ${proxy_base}`)
+        // Make sure the path is within sync_base..
+        if (!fullpath.startsWith(sync_base))
+            return on_watcher_miss(`path ${fullpath} outside ${sync_base}`)
 
         // Make sure the path is to a file, and not a directory
         if (event != 'unlink' && (await require('fs').promises.stat(fullpath)).isDirectory())
             return on_watcher_miss(`expected file, got: ${fullpath}`)
 
-        var path = require('path').relative(proxy_base, fullpath)
+        var path = require('path').relative(sync_base, fullpath)
         if (skip_file(path)) return
         console.log(`file event: ${path}, event: ${event}`)
 
-        var proxy = await proxy_url.cache[normalize_url(path)]
+        var sync = await sync_url.cache[normalize_url(path)]
 
-        if (proxy && event != 'add') proxy.signal_file_needs_reading()
-        if (!proxy && event != 'unlink') await trash_file(fullpath, path)
+        if (sync && event != 'add') sync.signal_file_needs_reading()
+        if (!sync && event != 'unlink') await trash_file(fullpath, path)
     }
 }
 
@@ -316,7 +320,7 @@ async function scan_files() {
     while (scan_files.do_again) {
         scan_files.do_again = false
         console.log(`scan files..`)
-        if (await f(proxy_base))
+        if (await f(sync_base))
             on_watcher_miss(`scanner picked up a change that the watcher should have gotten`, false)
     }
     scan_files.running = false
@@ -324,7 +328,7 @@ async function scan_files() {
     scan_files.timeout = setTimeout(scan_files, config.scan_interval_ms ?? (20 * 1000))
 
     async function f(fullpath) {
-        path = require('path').relative(proxy_base, fullpath)
+        path = require('path').relative(sync_base, fullpath)
         if (skip_file(path)) return
 
         let stat = await require('fs').promises.stat(fullpath, { bigint: true })
@@ -334,30 +338,30 @@ async function scan_files() {
                 found ||= await f(`${fullpath}/${file}`)
             return found
         } else {
-            var proxy = await proxy_url.cache[normalize_url(path)]
-            if (!proxy) return await trash_file(fullpath, path)
+            var sync = await sync_url.cache[normalize_url(path)]
+            if (!sync) return await trash_file(fullpath, path)
 
             stat = await require('fs').promises.stat(fullpath, { bigint: true })
-            if (!stat_eq(stat, proxy.file_last_stat)) {
+            if (!stat_eq(stat, sync.file_last_stat)) {
                 console.log(`scan thinks ${path} has changed`)
-                proxy.signal_file_needs_reading()
+                sync.signal_file_needs_reading()
                 return true
             }
         }
     }
 }
 
-function unproxy_url(url) {
+function unsync_url(url) {
     url = normalize_url(url).replace(/^https?:\/\//, '')
-    if (!proxy_url.cache?.[url]) return
+    if (!sync_url.cache?.[url]) return
 
-    console.log(`unproxy_url: ${url}`)
+    console.log(`unsync_url: ${url}`)
 
-    delete proxy_url.cache[url]
-    unproxy_url.cache[url] = unproxy_url.cache[url]()
+    delete sync_url.cache[url]
+    unsync_url.cache[url] = unsync_url.cache[url]()
 }
 
-async function proxy_url(url) {
+async function sync_url(url) {
     // normalize url by removing any trailing /index/index/
     var normalized_url = normalize_url(url),
         wasnt_normal = normalized_url != url
@@ -365,12 +369,12 @@ async function proxy_url(url) {
 
     var is_external_link = url.match(/^https?:\/\//),
         path = is_external_link ? url.replace(/^https?:\/\//, '') : url,
-        fullpath = `${proxy_base}/${path}`,
-        meta_path = `${proxy_base_meta}/${braid_text.encode_filename(url)}`
+        fullpath = `${sync_base}/${path}`,
+        meta_path = `${sync_base_meta}/${braid_text.encode_filename(url)}`
 
-    if (!proxy_url.cache) proxy_url.cache = {}
-    if (!proxy_url.chain) proxy_url.chain = Promise.resolve()
-    if (!proxy_url.cache[path]) proxy_url.cache[path] = proxy_url.chain = proxy_url.chain.then(async () => {
+    if (!sync_url.cache) sync_url.cache = {}
+    if (!sync_url.chain) sync_url.chain = Promise.resolve()
+    if (!sync_url.cache[path]) sync_url.cache[path] = sync_url.chain = sync_url.chain.then(async () => {
         var freed = false,
             aborts = new Set(),
             braid_text_get_options = null,
@@ -385,9 +389,9 @@ async function proxy_url(url) {
             wait_count--
             if (!wait_count) wait_promise_done()
         }
-        if (!unproxy_url.cache) unproxy_url.cache = {}
-        var old_unproxy = unproxy_url.cache[path]
-        unproxy_url.cache[path] = async () => {
+        if (!unsync_url.cache) unsync_url.cache = {}
+        var old_unsync = unsync_url.cache[path]
+        unsync_url.cache[path] = async () => {
             freed = true
             for (let a of aborts) a.abort()
             await wait_promise
@@ -402,11 +406,11 @@ async function proxy_url(url) {
             try { await require('fs').promises.unlink(meta_path) } catch (e) {}
             try { await require('fs').promises.unlink(await get_fullpath()) } catch (e) {}
         }
-        await old_unproxy
+        await old_unsync
 
         var self = {url}
 
-        console.log(`proxy_url: ${url}`)
+        console.log(`sync_url: ${url}`)
 
         if (!start_something()) return
 
@@ -426,6 +430,7 @@ async function proxy_url(url) {
 
         self.peer = Math.random().toString(36).slice(2)
         self.local_edit_counter = 0
+        self.fork_point = null
         var file_last_version = null,
             file_last_digest = null
         self.file_last_text = null
@@ -468,47 +473,60 @@ async function proxy_url(url) {
             file_loop_pump()
         }
 
-        self.signal_file_needs_writing = () => {
+        self.signal_file_needs_writing = (just_meta_file) => {
             if (freed) return
-            file_needs_writing = true
+
+            if (!just_meta_file) file_needs_writing = true
+            else if (just_meta_file && !file_needs_writing)
+                file_needs_writing = 'just_meta_file'
+
             file_loop_pump()
         }
 
-        async function send_out(stuff) {
+        async function my_fetch(params) {
             if (!start_something()) return
-            if (is_external_link) {
-                try {
-                    console.log(`send_out ${url} ${JSON.stringify(stuff, null, 4).slice(0, 1000)}`)
-
-                    let a = new AbortController()
-                    aborts.add(a)
-                    var r = await braid_fetch(url, {
-                        signal: a.signal,
-                        headers: {
-                            "Merge-Type": "dt",
-                            "Content-Type": 'text/plain',
-                            ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname])
-                        },
-                        method: "PUT",
-                        retry: true,
-                        ...stuff
-                    })
-                    aborts.delete(a)
-                    // if we're not authorized,
-                    if (r.status == 401 || r.status == 403) {
-                        // and it's one of our versions (a local edit),
-                        if (self.peer === braid_text.decode_version(stuff.version[0])[0]) {
-                            // then revert it
-                            console.log(`access denied: reverting local edits`)
-                            unproxy_url(url)
-                            proxy_url(url)
-                        }
-                    }
-                } catch (e) {
-                    if (e?.name !== "AbortError") console.log(e)
+            try {
+                var a = new AbortController()
+                aborts.add(a)
+                return await braid_fetch(url, {
+                    signal: a.signal,
+                    headers: {
+                        "Merge-Type": "dt",
+                        "Content-Type": 'text/plain',
+                        ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname])
+                    },
+                    retry: true,
+                    ...params
+                })
+            } catch (e) {
+                if (e?.name !== "AbortError") console.log(e)
+            } finally {
+                aborts.delete(a)
+                finish_something()
+            }
+        }
+        
+        async function send_out(stuff) {
+            if (!is_external_link) return
+
+            console.log(`send_out ${url} ${JSON.stringify(stuff, null, 4).slice(0, 1000)}`)
+
+            var r = await my_fetch({ method: "PUT", ...stuff })
+
+            // the server has acknowledged this version,
+            // so add it to the fork point
+            if (r.ok) await self.update_fork_point(stuff.version[0], stuff.parents)
+
+            // if we're not authorized,
+            if (r.status == 401 || r.status == 403) {
+                // and it's one of our versions (a local edit),
+                if (self.peer === braid_text.decode_version(stuff.version[0])[0]) {
+                    // then revert it
+                    console.log(`access denied: reverting local edits`)
+                    unsync_url(url)
+                    sync_url(url)
                 }
             }
-            finish_something()
         }
 
         if (!start_something()) return
@@ -523,7 +541,8 @@ async function proxy_url(url) {
                     version: file_last_version,
                     digest: file_last_digest,
                     peer: self.peer,
-                    local_edit_counter: self.local_edit_counter
+                    local_edit_counter: self.local_edit_counter,
+                    fork_point: self.fork_point
                 } = Array.isArray(meta) ? { version: meta } : meta)
 
                 if (!self.peer) self.peer = Math.random().toString(36).slice(2)
@@ -569,6 +588,16 @@ async function proxy_url(url) {
                 var fullpath = await get_fullpath()
 
                 while (file_needs_reading || file_needs_writing) {
+                    async function write_meta_file() {
+                        await require('fs').promises.writeFile(meta_path, JSON.stringify({
+                            version: file_last_version,
+                            digest: sha256(self.file_last_text),
+                            peer: self.peer,
+                            local_edit_counter: self.local_edit_counter,
+                            fork_point: self.fork_point
+                        }))
+                    }
+
                     if (file_needs_reading) {
                         console.log(`reading file: ${fullpath}`)
 
@@ -611,12 +640,7 @@ async function proxy_url(url) {
 
                             await braid_text.put(url, { version, parents, patches, peer: self.peer, merge_type: 'dt' })
 
-                            await require('fs').promises.writeFile(meta_path, JSON.stringify({
-                                version: file_last_version,
-                                digest: sha256(self.file_last_text),
-                                peer: self.peer,
-                                local_edit_counter: self.local_edit_counter
-                            }))
+                            await write_meta_file()
                         } else {
                             add_to_version_cache(text, file_last_version)
 
@@ -630,7 +654,10 @@ async function proxy_url(url) {
                         self.file_last_stat = stat
                         self.file_ignore_until = Date.now() + 1000
                     }
-                    if (file_needs_writing) {
+                    if (file_needs_writing === 'just_meta_file') {
+                        file_needs_writing = false
+                        await write_meta_file()
+                    } else if (file_needs_writing) {
                         file_needs_writing = false
                         let { version, body } = await braid_text.get(url, {})
                         if (!v_eq(version, file_last_version)) {
@@ -654,16 +681,10 @@ async function proxy_url(url) {
                             self.file_last_text = body
                             self.file_ignore_until = Date.now() + 1000
                             await require('fs').promises.writeFile(fullpath, self.file_last_text)
-
-
-                            await require('fs').promises.writeFile(meta_path, JSON.stringify({
-                                version: file_last_version,
-                                digest: sha256(self.file_last_text),
-                                peer: self.peer,
-                                local_edit_counter: self.local_edit_counter
-                            }))
                         }
 
+                        await write_meta_file()
+
                         if (await is_read_only(fullpath) !== self.file_read_only) {
                             self.file_ignore_until = Date.now() + 1000
                             await set_read_only(fullpath, self.file_read_only)
@@ -682,8 +703,90 @@ async function proxy_url(url) {
             file_loop_pump_lock--
         }
 
-        if (is_external_link) connect()
-        function connect() {
+        self.update_fork_point = async (event, parents) => {
+            var resource = await braid_text.get_resource(url)
+
+            // special case:
+            // if current fork point has all parents,
+            //    then we can just remove those
+            //    and add event
+            var fork_set = new Set(self.fork_point)
+            if (parents.every(p => fork_set.has(p))) {
+                parents.forEach(p => fork_set.delete(p))
+                fork_set.add(event)
+                self.fork_point = [...fork_set.values()]
+            } else {
+                // full-proof approach..
+                var looking_for = fork_set
+                looking_for.add(event)
+
+                self.fork_point = []
+                var shadow = new Set()
+
+                var bytes = resource.doc.toBytes()
+                var [_, events, parentss] = braid_text.dt_parse([...bytes])
+                for (var i = events.length - 1; i >= 0 && looking_for.size; i--) {
+                    var e = events[i].join('-')
+                    if (looking_for.has(e)) {
+                        looking_for.delete(e)
+                        if (!shadow.has(e)) self.fork_point.push(e)
+                        shadow.add(e)
+                    }
+                    if (shadow.has(e))
+                        parentss[i].forEach(p => shadow.add(p.join('-')))
+                }
+            }
+            self.fork_point.sort()
+            self.signal_file_needs_writing(true)
+        }
+
+        async function find_fork_point() {
+            console.log(`[find_fork_point] url: ${url}`)
+
+            // see if they have the fork point
+            if (self.fork_point) {
+                var r = await my_fetch({ method: "HEAD", version: self.fork_point })
+                if (r.ok) {
+                    console.log(`[find_fork_point] they have our latest fork point, horray!`)
+                    return self.fork_point
+                }
+            }
+
+            // otherwise let's binary search for new fork point..
+            var resource = await braid_text.get_resource(url)
+            var bytes = resource.doc.toBytes()
+            var [_, events, __] = braid_text.dt_parse([...bytes])
+            events = events.map(x => x.join('-'))
+
+            var min = -1
+            var max = events.length
+            self.fork_point = []
+            while (min + 1 < max) {
+                var i = Math.floor((min + max)/2)
+                var version = [events[i]]
+
+                console.log(`min=${min}, max=${max}, i=${i}, version=${version}`)
+
+                var st = Date.now()
+                var r = await my_fetch({ method: "HEAD", version })
+                console.log(`fetched in ${Date.now() - st}`)
+
+                if (r.ok) {
+                    min = i
+                    self.fork_point = version
+                } else max = i
+            }
+            console.log(`[find_fork_point] settled on: ${JSON.stringify(self.fork_point)}`)
+            self.signal_file_needs_writing(true)
+            return self.fork_point
+        }
+
+        if (is_external_link) find_fork_point().then(fork_point => {
+            connect(fork_point)
+            send_new_stuff(fork_point)
+        })
+        
+        function connect(fork_point) {
             let a = new AbortController()
             aborts.add(a)
             self.reconnect = () => {
@@ -691,7 +794,7 @@ async function proxy_url(url) {
 
                 aborts.delete(a)
                 a.abort()
-                connect()
+                connect(fork_point)
             }
 
             console.log(`connecting to ${url}`)
@@ -705,12 +808,8 @@ async function proxy_url(url) {
                 subscribe: true,
                 retry: {
                     onRes: (res) => {
-                        if (res.status !== 209) {
-                            log_error(`Can't sync ${url} -- got bad response ${res.status} from server (expected 209)`)
-                            return console.log(
-                                `FAILED TO CONNECT TO: ${url}\n` +
-                                `GOT STATUS CODE: ${res.status}, expected 209.`)
-                        }
+                        if (res.status !== 209)
+                            return log_error(`Can't sync ${url} -- got bad response ${res.status} from server (expected 209)`)
 
                         console.log(`connected to ${url}`)
                         console.log(`  editable = ${res.headers.get('editable')}`)
@@ -721,8 +820,9 @@ async function proxy_url(url) {
                 },
                 heartbeats: 120,
                 parents: async () => {
-                    let cur = await braid_text.get(url, {})
-                    if (cur.version.length) return cur.version
+                    var x = fork_point || await find_fork_point()
+                    fork_point = null
+                    return x
                 },
                 peer: self.peer
             }).then(x => {
@@ -740,6 +840,10 @@ async function proxy_url(url) {
 
                     await braid_text.put(url, { ...update, peer: self.peer, merge_type: 'dt' })
 
+                    // the server is giving us this version,
+                    // so they must have it,
+                    // so let's add it to our fork point
+                    await self.update_fork_point(update.version[0], update.parents)
 
                     self.signal_file_needs_writing()
                     finish_something()
@@ -748,112 +852,35 @@ async function proxy_url(url) {
         }
 
         // send them stuff we have but they don't
-        if (is_external_link) send_new_stuff()
-        async function send_new_stuff() {
-            if (!start_something()) return
-            try {
-                var a = new AbortController()
-                aborts.add(a)
-                var r = await braid_fetch(url, {
-                    signal: a.signal,
-                    method: "HEAD",
-                    headers: {
-                        Accept: 'text/plain',
-                        ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname]),
-                    },
-                    retry: true
-                })
-                aborts.delete(a)
-
-                if (r.headers.get('editable') === 'false') {
-                    console.log('do not send updates for read-only file: ' + url)
-                    return
-                }
-
-                if (r.headers.get('version') == null) {
-                    log_error(`Can't sync ${url} -- got no version from server`)
-                    return console.log(`GOT NO VERSION FROM: ${url}`)
-                }
-                var parents = JSON.parse(`[${r.headers.get('version')}]`)                
-
-                var bytes = (await braid_text.get_resource(url)).doc.toBytes()
-                var [_, versions, __] = braid_text.dt_parse([...bytes])
-                var agents = {}
-                for (var v of versions) agents[v[0]] = v[1]
-
-                function we_have_it(version) {
-                    var m = version.match(/^(.*)-(\d+)$/s)
-                    var agent = m[1]
-                    var seq = 1 * m[2]
-                    return (agents[agent] ?? -1) >= seq
-                }
-
-                if (parents.length && !parents.some(we_have_it)) {
-                    var min = 0
-                    var max = versions.length
-                    var last_good_parents = []
-                    while (min < max) {
-                        var i = Math.ceil((min + max)/2)
-                        parents = i ? [versions[i - 1].join('-')] : []
-
-                        console.log(`min=${min}, max=${max}, i=${i}, parents=${parents}`)
-
-                        var a = new AbortController()
-                        aborts.add(a)
-                        var st = Date.now()
-                        var r = await braid_fetch(url, {
-                            signal: a.signal,
-                            method: "HEAD",
-                            parents,
-                            headers: {
-                                Accept: 'text/plain',
-                                ...(x => x && {Cookie: x})(config.cookies?.[new URL(url).hostname]),
-                            },
-                            retry: true
-                        })
-                        console.log(`fetched in ${Date.now() - st}`)
-                        aborts.delete(a)
-
-                        if (r.ok) {
-                            min = i
-                            last_good_parents = parents
-                        } else {
-                            max = i - 1
-                        }
+        async function send_new_stuff(fork_point) {
+            var r = await my_fetch({ method: "HEAD" })
+            if (r.headers.get('editable') === 'false')
+                return console.log('do not send updates for read-only file: ' + url)
+
+            var in_parallel = create_parallel_promises(10)
+            braid_text.get(url, braid_text_get_options = {
+                parents: fork_point,
+                merge_type: 'dt',
+                peer: self.peer,
+                subscribe: async (u) => {
+                    if (u.version.length) {
+                        self.signal_file_needs_writing()
+                        in_parallel(() => send_out({...u, peer: self.peer}))
                     }
-                    parents = last_good_parents
-
-                    console.log(`found good parents: ${parents}: ${url}`)
-                }
-
-                var in_parallel = create_parallel_promises(10)
-                braid_text.get(url, braid_text_get_options = {
-                    parents,
-                    merge_type: 'dt',
-                    peer: self.peer,
-                    subscribe: async (u) => {
-                        if (u.version.length) {
-                            self.signal_file_needs_writing()
-                            in_parallel(() => send_out({...u, peer: self.peer}))
-                        }
-                    },
-                })
-            } catch (e) {
-                if (e?.name !== "AbortError") console.log(e)
-            }
-            finish_something()
+                },
+            })
         }
 
         // for config and errors file, listen for web changes
         if (!is_external_link) braid_text.get(url, braid_text_get_options = {
             merge_type: 'dt',
             peer: self.peer,
-            subscribe: self.signal_file_needs_writing,
+            subscribe: () => self.signal_file_needs_writing(),
         })
 
         return self
     })
-    return await proxy_url.cache[url]
+    return await sync_url.cache[url]
 }
 
 async function ensure_path(path) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "braidfs",
-  "version": "0.0.82",
+  "version": "0.0.85",
   "description": "braid technology synchronizing files and webpages",
   "author": "Braid Working Group",
   "repository": "braid-org/braidfs",
   "homepage": "https://braid.org",
   "dependencies": {
     "braid-http": "^1.3.73",
-    "braid-text": "^0.2.22",
+    "braid-text": "^0.2.25",
     "chokidar": "^3.6.0"
   },
   "bin": {