braid-text 0.2.86 → 0.2.88

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node test/test.js:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/index.js

@@ -160,24 +160,86 @@ function create_braid_text() {
                         }
                     }
 
-                    // local -> remote
+                    // local -> remote (with in_flight queue for concurrency control)
+                    var q = []
+                    var in_flight = new Map()
+                    var max_in_flight = 10
+                    var send_pump_lock = 0
+                    var temp_acs = new Set()
+                    ac.signal.addEventListener('abort', () => {
+                        for (var t of temp_acs) t.abort()
+                    })
+
+                    async function send_out(update) {
+                        update.signal = ac.signal
+                        update.dont_retry = true
+                        var x = await braid_text.put(b, update)
+                        if (x.ok) {
+                            local_first_put()
+                            extend_fork_point(update)
+                        } else if (x.status === 401 || x.status === 403) {
+                            options.on_unauthorized?.()
+                        } else throw new Error('failed to PUT: ' + x.status)
+                    }
+
+                    async function send_pump() {
+                        send_pump_lock++
+                        if (send_pump_lock > 1) return
+                        try {
+                            if (closed) return
+                            if (in_flight.size >= max_in_flight) return
+                            if (!q.length) {
+                                // Extend frontier based on in-flight updates
+                                var frontier = resource.meta.fork_point || []
+                                for (var u of in_flight.values())
+                                    frontier = extend_frontier(frontier, u.version, u.parents)
+
+                                var temp_ac = new AbortController()
+                                temp_acs.add(temp_ac)
+                                var temp_ops = {
+                                    signal: temp_ac.signal,
+                                    parents: frontier,
+                                    merge_type: 'dt',
+                                    subscribe: u => u.version?.length && q.push(u)
+                                }
+                                await braid_text.get(a, temp_ops)
+                                temp_ac.abort()
+                                temp_acs.delete(temp_ac)
+                            }
+                            while (q.length && in_flight.size < max_in_flight) {
+                                let u = q.shift()
+                                if (!u.version?.length) continue
+                                in_flight.set(u.version[0], u);
+                                (async () => {
+                                    try {
+                                        if (closed) return
+                                        await send_out(u)
+                                        if (closed) return
+                                        in_flight.delete(u.version[0])
+                                        setTimeout(send_pump, 0)
+                                    } catch (e) {
+                                        if (e.name === 'AbortError') {
+                                            // ignore
+                                        } else handle_error(e)
+                                    }
+                                })()
+                            }
+                        } finally {
+                            var retry = send_pump_lock > 1
+                            send_pump_lock = 0
+                            if (retry) setTimeout(send_pump, 0)
+                        }
+                    }
+
                     var a_ops = {
                         signal: ac.signal,
+                        merge_type: 'dt',
                         subscribe: update => {
-                            update.signal = ac.signal
-                            update.dont_retry = true
-                            braid_text.put(b, update).then((x) => {
-                                if (x.ok) {
-                                    local_first_put()
-                                    extend_fork_point(update)
-                                } else if (x.status === 401 || x.status === 403) {
-                                    options.on_unauthorized?.()
-                                } else throw new Error('failed to PUT: ' + x.status)
-                            }).catch(e => {
-                                if (e.name === 'AbortError') {
-                                    // ignore
-                                } else handle_error(e)
-                            })
+                            if (closed) return
+                            if (update.version?.length) {
+                                q.push(update)
+                                send_pump()
+                            }
                         }
                     }
                     if (resource.meta.fork_point)
@@ -185,12 +247,30 @@ function create_braid_text() {
                     braid_text.get(a, a_ops)
 
                     // remote -> local
+                    var remote_res_done
+                    var remote_res_promise = new Promise(done => remote_res_done = done)
+                    var remote_res = null
+
                     var b_ops = {
                         signal: ac.signal,
                         dont_retry: true,
+                        headers: { 'Merge-Type': 'dt', 'accept-encoding': 'updates(dt)' },
                         subscribe: async update => {
-                            await braid_text.put(a, update)
-                            extend_fork_point(update)
+                            // Wait for remote_res to be available
+                            await remote_res_promise
+
+                            // Check if this is a dt-encoded update (initial body without status)
+                            if (!update.status) {
+                                var cv = remote_res.headers.get('current-version')
+                                await braid_text.put(a, {
+                                    body: update.body,
+                                    transfer_encoding: 'dt'
+                                })
+                                if (cv) extend_fork_point({ version: JSON.parse(`[${cv}]`), parents: resource.meta.fork_point || [] })
+                            } else {
+                                await braid_text.put(a, update)
+                                if (update.version) extend_fork_point(update)
+                            }
                         },
                         on_error: e => {
                             options.on_disconnect?.()
@@ -198,15 +278,16 @@ function create_braid_text() {
                         }
                     }
                     // Handle case where remote doesn't exist yet - wait for local to create it
-                    var remote_result = await braid_text.get(b, b_ops)
-                    if (remote_result === null) {
+                    remote_res = await braid_text.get(b, b_ops)
+                    remote_res_done()
+                    if (remote_res === null) {
                         // Remote doesn't exist yet, wait for local to put something
                         await local_first_put_promise
                         disconnect()
                         connect()
                         return
                     }
-                    options.on_res?.(remote_result)
+                    options.on_res?.(remote_res)
                     // on_error will call handle_error when connection drops
                 } catch (e) {
                     handle_error(e)
@@ -548,9 +629,12 @@ function create_braid_text() {
 
             if (options.subscribe) {
                 res.subscribe(async update => {
-                    update.body = update.body_text
-                    if (update.patches)
-                        for (var p of update.patches) p.content = p.content_text
+                    // Don't convert to text for initial dt-encoded body (no status)
+                    if (update.status) {
+                        update.body = update.body_text
+                        if (update.patches)
+                            for (var p of update.patches) p.content = p.content_text
+                    }
                     await options.subscribe(update)
                 }, e => options.on_error?.(e))
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.86",
+  "version": "0.2.88",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",

package/test/tests.js

@@ -2066,6 +2066,39 @@ runTest(
     'on_res called'
 )
 
+runTest(
+    "test braid_text.sync uses accept-encoding updates(dt)",
+    async () => {
+        var remote_key = 'test-remote-' + Math.random().toString(36).slice(2)
+        var local_key = 'test-local-' + Math.random().toString(36).slice(2)
+
+        // Create the remote resource with some content
+        var r = await braid_fetch(`/${remote_key}`, {
+            method: 'PUT',
+            body: 'remote content here'
+        })
+        if (!r.ok) return 'put failed: ' + r.status
+
+        // Start sync with URL first (like the passing "url to key" test)
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                braid_text.sync(new URL('http://localhost:8889/${remote_key}'), '/${local_key}')
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        // Wait for sync to complete
+        await new Promise(done => setTimeout(done, 100))
+
+        // Check local has remote content
+        var r = await braid_fetch(`/${local_key}`)
+        return await r.text()
+    },
+    'remote content here'
+)
+
 runTest(
     "test braid_text.sync reconnects when inner put fails with non-200 status",
     async () => {