braid-text 0.2.85 → 0.2.87

package/.claude/settings.local.json

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

package/index.js

@@ -165,13 +165,18 @@ function create_braid_text() {
                         signal: ac.signal,
                         subscribe: update => {
                             update.signal = ac.signal
+                            update.dont_retry = true
                             braid_text.put(b, update).then((x) => {
-                                local_first_put()
-                                extend_fork_point(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)
                             }).catch(e => {
                                 if (e.name === 'AbortError') {
                                     // ignore
-                                } else throw e
+                                } else handle_error(e)
                             })
                         }
                     }
@@ -180,12 +185,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?.()
@@ -193,14 +216,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)
@@ -542,9 +567,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))
 
@@ -705,8 +733,9 @@ function create_braid_text() {
             var params = {
                 method: 'PUT',
                 signal: options.signal,
-                retry: () => true,
             }
+            if (!options.dont_retry)
+                params.retry = () => true
             for (var x of ['headers', 'parents', 'version', 'peer', 'body', 'patches'])
                 if (options[x] != null) params[x] = options[x]
 

package/package.json

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

package/test/test.js

@@ -69,6 +69,21 @@ function createTestServer(options = {}) {
             return res.end('error')
         }
 
+        if (req.url.startsWith('/unauthorized') && req.method === 'PUT') {
+            res.statusCode = 401
+            return res.end('Unauthorized')
+        }
+
+        if (req.url.startsWith('/forbidden') && req.method === 'PUT') {
+            res.statusCode = 403
+            return res.end('Forbidden')
+        }
+
+        if (req.url.startsWith('/server_error') && req.method === 'PUT') {
+            res.statusCode = 500
+            return res.end('Internal Server Error')
+        }
+
         if (req.url.startsWith('/404')) {
             res.statusCode = 404
             return res.end('Not Found')

package/test/tests.js

@@ -2066,6 +2066,173 @@ 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 () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a local resource with content
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'initial'
+        })
+        if (!r.ok) return 'initial put failed: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var connect_count = 0
+                var ac = new AbortController()
+
+                braid_text.sync('/${key}', new URL('http://localhost:8889/server_error'), {
+                    signal: ac.signal,
+                    on_pre_connect: () => {
+                        connect_count++
+                        if (connect_count >= 2) {
+                            ac.abort()
+                            res.end('reconnected after put failure')
+                        }
+                    }
+                })
+
+                // Trigger a local put which will fail when synced to the error endpoint
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${key}', { body: 'trigger sync' })
+
+                // Wait for reconnect attempt
+                await new Promise(done => setTimeout(done, 2000))
+                ac.abort()
+                res.end('did not reconnect')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'reconnected after put failure'
+)
+
+runTest(
+    "test braid_text.sync on_unauthorized callback for 401",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a local resource with content
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'initial'
+        })
+        if (!r.ok) return 'initial put failed: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var unauthorized_called = false
+                var ac = new AbortController()
+
+                braid_text.sync('/${key}', new URL('http://localhost:8889/unauthorized'), {
+                    signal: ac.signal,
+                    on_unauthorized: () => {
+                        unauthorized_called = true
+                        ac.abort()
+                        res.end('on_unauthorized called')
+                    }
+                })
+
+                // Trigger a local put which will get 401 when synced
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${key}', { body: 'trigger sync' })
+
+                // Wait for callback
+                await new Promise(done => setTimeout(done, 2000))
+                ac.abort()
+                res.end('on_unauthorized not called')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'on_unauthorized called'
+)
+
+runTest(
+    "test braid_text.sync on_unauthorized callback for 403",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a local resource with content
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'initial'
+        })
+        if (!r.ok) return 'initial put failed: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var unauthorized_called = false
+                var ac = new AbortController()
+
+                braid_text.sync('/${key}', new URL('http://localhost:8889/forbidden'), {
+                    signal: ac.signal,
+                    on_unauthorized: () => {
+                        unauthorized_called = true
+                        ac.abort()
+                        res.end('on_unauthorized called')
+                    }
+                })
+
+                // Trigger a local put which will get 403 when synced
+                await new Promise(done => setTimeout(done, 100))
+                await braid_text.put('/${key}', { body: 'trigger sync' })
+
+                // Wait for callback
+                await new Promise(done => setTimeout(done, 2000))
+                ac.abort()
+                res.end('on_unauthorized not called')
+            })()`
+        })
+        if (!r.ok) return 'eval failed: ' + r.status
+
+        return await r.text()
+    },
+    'on_unauthorized called'
+)
+
 runTest(
     "test getting a binary update from a subscription",
     async () => {