braid-blob 0.0.52 → 0.0.54

package/README.md

@@ -20,39 +20,27 @@ require('http').createServer((req, res) => {
 }).listen(8888)
 ```
 
-That's it! You now have a blob synchronization server.
+That's it! You now have a blob synchronization server. Upload an image:
 
-### Usage Examples
-
-First let's upload a file:
 ```bash
-curl -X PUT -H "Content-Type: image/png" -T blob.png http://localhost:8888/image.png
+curl -X PUT -H "Content-Type: image/png" -T blob.png http://localhost:8888/blob.png
 ```
 
-View image in browser at http://localhost:8888/image.png
+Then view it at http://localhost:8888/blob.png
 
-To see updates, let's do a textual example for easy viewing:
+### Demo
 
-```
-curl -X PUT -H "Content-Type: text/plain" -d "hello" http://localhost:8888/text
-```
-
-Next, subscribe for updates:
-```
-curl -H "Subscribe: true" http://localhost:8888/text
-```
+Run the demo server:
 
-Now, in another terminal, write over the file:
 ```bash
-curl -X PUT -H "Content-Type: text/plain" -d "world" http://localhost:8888/text
+node server-demo.js
 ```
 
-Should see activity in the first terminal showing the update.
+Then open http://localhost:8888 in your browser. You can drag and drop images to upload them, and open multiple browser windows to see real-time sync in action.
 
-```
-# Delete a file
-curl -X DELETE http://localhost:8888/text
-```
+<!-- TODO: Add demo video
+![Demo](demo.mp4)
+-->
 
 ## API
 
@@ -61,16 +49,8 @@ curl -X DELETE http://localhost:8888/text
 ```javascript
 var braid_blob = require('braid-blob')
 
-// Set custom blob storage location (default: './braid-blob-db')
-// This uses url-file-db for efficient URL-to-file mapping
-braid_blob.db_folder = './custom_files_folder'
-
-// Set custom metadata storage location (default: './braid-blob-meta')
-// Stores version metadata and peer information
-braid_blob.meta_folder = './custom_meta_folder'
-
-// Set custom peer ID (default: auto-generated and persisted)
-braid_blob.peer = 'my-server-id'
+// Set custom storage location (default: './braid-blobs')
+braid_blob.db_folder = './my-blobs'
 ```
 
 ### `braid_blob.serve(req, res, options)`
@@ -88,6 +68,21 @@ Handles HTTP requests for blob storage and synchronization.
 - `PUT` - Store/update a blob
 - `DELETE` - Remove a blob
 
+### `braid_blob.sync(key, url, options)`
+
+Bidirectionally synchronizes a blob between local storage and a remote URL.
+
+**Parameters:**
+- `key` - Local storage key (string)
+- `url` - Remote URL (URL object)
+- `options` - Optional configuration object
+  - `signal` - AbortSignal for cancellation (use to stop sync)
+  - `content_type` / `accept` - Content type for requests
+  - `on_pre_connect` - Async callback before connection attempt
+  - `on_disconnect` - Callback when connection drops
+  - `on_unauthorized` - Callback on 401/403 responses
+  - `on_res` - Callback receiving the response object
+
 ### `braid_blob.get(key, options)`
 
 Retrieves a blob from local storage or a remote URL.
@@ -113,30 +108,63 @@ Stores a blob to local storage or a remote URL.
 - `body` - Buffer or data to store
 - `options` - Optional configuration object
   - `version` - Version identifier
-  - `content_type` / `accept` - Content type of the blob
+  - `content_type` - Content type of the blob
   - `signal` - AbortSignal for cancellation
 
-### `braid_blob.sync(a, b, options)`
+### `braid_blob.delete(key, options)`
 
-Bidirectionally synchronizes blobs between two endpoints (local keys or URLs).
+Deletes a blob from local storage or a remote URL.
 
 **Parameters:**
-- `a` - First endpoint (local key or URL)
-- `b` - Second endpoint (local key or URL)
+- `key` - Local storage key (string) or remote URL (URL object)
 - `options` - Optional configuration object
-  - `signal` - AbortSignal for cancellation (use to stop sync)
-  - `content_type` / `accept` - Content type for requests
-  - `on_pre_connect` - Async callback before connection attempt
-  - `on_disconnect` - Callback when connection drops
-  - `on_unauthorized` - Callback on 401/403 responses
+  - `signal` - AbortSignal for cancellation
+
+## Browser Client
+
+A simple browser client is included for subscribing to blob updates.
+
+```html
+<script src="https://unpkg.com/braid-http@~1.3/braid-http-client.js"></script>
+<script src="/client.js"></script>
+<script>
+    braid_blob_client('http://localhost:8888/blob.png', {
+        on_update: (blob, content_type, version) => {
+            // Called whenever the blob is updated
+            var url = URL.createObjectURL(new Blob([blob], { type: content_type }))
+            document.getElementById('image').src = url
+        },
+        on_delete: () => console.log('Blob was deleted'),
+        on_error: (e) => console.error('Error:', e)
+    })
+</script>
+```
+
+### `braid_blob_client(url, options)`
+
+Subscribes to a blob endpoint and receives updates.
+
+**Parameters:**
+- `url` - The blob endpoint URL
+- `options` - Configuration object
+  - `on_update(blob, content_type, version)` - Callback for updates
+  - `on_delete` - Callback when blob is deleted
+  - `on_error` - Callback for errors
   - `on_res` - Callback receiving the response object
 
+**Returns:** `{ stop }` - Call `stop()` to unsubscribe.
+
 ## Testing
 
-### to run unit tests:
-first run the test server:
+```bash
+npm install
+node test/test.js
+```
+
+Or run tests in the browser:
 
-    npm install
-    node test/server.js
+```bash
+node test/test.js -b
+```
 
-then open http://localhost:8889/test.html, and the boxes should turn green as the tests pass.
+Then open http://localhost:8889/test.html

package/client.js

@@ -0,0 +1,79 @@
+// Braid-Blob Client
+// requires braid-http@~1.3/braid-http-client.js
+//
+// Usage:
+//   braid_blob_client(url, {
+//       on_update: (blob, content_type, version) => {
+//           // Called whenever there's a new version of the blob
+//           console.log('New blob:', blob, content_type, version)
+//       }
+//   })
+//
+// Returns: { stop } - call stop() to unsubscribe
+//
+function braid_blob_client(url, options = {}) {
+    var ac = new AbortController()
+    var peer = Math.random().toString(36).substr(2)
+    var current_version = null
+
+    braid_fetch(url, {
+        headers: { "Merge-Type": "aww" },
+        subscribe: true,
+        retry: () => true,
+        peer,
+        signal: ac.signal
+    }).then(res => {
+        if (options.on_res) options.on_res(res)
+
+        res.subscribe(async update => {
+            if (update.status === 404) {
+                current_version = null
+                if (options.on_delete) options.on_delete()
+                return
+            }
+
+            var content_type = update.extra_headers?.['content-type']
+            var version = update.version?.[0]
+
+            // Only update if version is newer
+            if (compare_events(version, current_version) > 0) {
+                current_version = version
+                if (options.on_update) options.on_update(update.body, content_type, update.version)
+            }
+        }, options.on_error || (e => console.error('braid_blob_client error:', e)))
+    }).catch(options.on_error || (e => console.error('braid_blob_client error:', e)))
+
+    return {
+        stop: () => ac.abort()
+    }
+
+    function compare_events(a, b) {
+        if (!a) a = ''
+        if (!b) b = ''
+
+        var c = compare_seqs(get_event_seq(a), get_event_seq(b))
+        if (c) return c
+
+        if (a < b) return -1
+        if (a > b) return 1
+        return 0
+    }
+
+    function get_event_seq(e) {
+        if (!e) return ''
+
+        for (let i = e.length - 1; i >= 0; i--)
+            if (e[i] === '-') return e.slice(i + 1)
+        return e
+    }
+
+    function compare_seqs(a, b) {
+        if (!a) a = ''
+        if (!b) b = ''
+
+        if (a.length !== b.length) return a.length - b.length
+        if (a < b) return -1
+        if (a > b) return 1
+        return 0
+    }
+}

package/index.html

@@ -0,0 +1,146 @@
+<body style="margin: 0; padding: 20px; font-family: sans-serif;">
+    <div id="drop_overlay" style="display: none; position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0, 100, 200, 0.8); z-index: 1000; justify-content: center; align-items: center;">
+        <div style="color: white; font-size: 24px; text-align: center;">
+            <div style="font-size: 48px; margin-bottom: 20px;">Drop file here</div>
+            <div>to upload to <span id="drop_url"></span></div>
+        </div>
+    </div>
+    <h2>Braid Blob Client Demo</h2>
+    <p>
+        <label>URL: <input type="text" id="url_input" style="width: 400px;" /></label>
+    </p>
+    <p>Version: <code id="version_display">-</code></p>
+    <p>Content-Type: <code id="content_type_display">-</code></p>
+    <div id="image_container">
+        <img id="blob_image" style="max-width: 100%; border: 1px solid #ccc;" />
+    </div>
+    <p id="status">Enter a URL and click Connect</p>
+</body>
+<script src="https://unpkg.com/braid-http@~1.3/braid-http-client.js"></script>
+<script src="/client.js"></script>
+<script>
+    var current_object_url = null
+    var current_client = null
+    var current_blob_url = null
+
+    // Initialize URL input from query parameter, or default to /test_blob
+    var params = new URLSearchParams(location.search)
+    var initial_url = params.get('url') || `${location.origin}/blob.png`
+    document.getElementById('url_input').value = initial_url
+
+    function connect(blob_url) {
+        current_blob_url = blob_url
+        // Stop existing subscription
+        if (current_client) {
+            current_client.stop()
+            current_client = null
+        }
+
+        // Clear previous image
+        if (current_object_url) {
+            URL.revokeObjectURL(current_object_url)
+            current_object_url = null
+        }
+        document.getElementById('blob_image').src = ''
+        document.getElementById('version_display').textContent = '-'
+        document.getElementById('content_type_display').textContent = '-'
+        document.getElementById('status').textContent = 'Connecting...'
+
+        current_client = braid_blob_client(blob_url, {
+            on_update: (blob, content_type, version) => {
+                document.getElementById('status').textContent = ''
+                document.getElementById('version_display').textContent =
+                    version ? JSON.stringify(version) : '-'
+                document.getElementById('content_type_display').textContent =
+                    content_type || '-'
+
+                // Revoke old object URL to free memory
+                if (current_object_url) {
+                    URL.revokeObjectURL(current_object_url)
+                }
+
+                // Create a blob URL from the binary data and display it
+                var image_blob = new Blob([blob], { type: content_type || 'image/png' })
+                current_object_url = URL.createObjectURL(image_blob)
+                document.getElementById('blob_image').src = current_object_url
+            },
+            on_error: (e) => {
+                document.getElementById('status').textContent = 'Connecting...'
+            },
+            on_delete: () => {
+                document.getElementById('status').textContent = 'Blob deleted'
+                document.getElementById('blob_image').src = ''
+                if (current_object_url) {
+                    URL.revokeObjectURL(current_object_url)
+                    current_object_url = null
+                }
+            }
+        })
+    }
+
+    document.getElementById('url_input').onkeydown = (e) => {
+        if (e.key === 'Enter') {
+            var url = document.getElementById('url_input').value.trim()
+            if (url) connect(url)
+        }
+    }
+
+    // Auto-connect on load
+    connect(initial_url)
+
+    // Drag and drop handling
+    var drop_overlay = document.getElementById('drop_overlay')
+    var drag_counter = 0
+
+    document.addEventListener('dragenter', (e) => {
+        e.preventDefault()
+        drag_counter++
+        if (drag_counter === 1) {
+            document.getElementById('drop_url').textContent = current_blob_url || 'the current URL'
+            drop_overlay.style.display = 'flex'
+        }
+    })
+
+    document.addEventListener('dragleave', (e) => {
+        e.preventDefault()
+        drag_counter--
+        if (drag_counter === 0) {
+            drop_overlay.style.display = 'none'
+        }
+    })
+
+    document.addEventListener('dragover', (e) => {
+        e.preventDefault()
+    })
+
+    document.addEventListener('drop', async (e) => {
+        e.preventDefault()
+        drag_counter = 0
+        drop_overlay.style.display = 'none'
+
+        if (!current_blob_url) {
+            alert('Please connect to a URL first')
+            return
+        }
+
+        var file = e.dataTransfer.files[0]
+        if (!file) return
+
+        document.getElementById('status').textContent = 'Uploading...'
+
+        try {
+            var response = await fetch(current_blob_url, {
+                method: 'PUT',
+                headers: { 'Content-Type': file.type || 'application/octet-stream' },
+                body: file
+            })
+            if (!response.ok) {
+                document.getElementById('status').textContent = 'Upload failed: ' + response.status
+            }
+            // The subscription will automatically show the new image
+        } catch (err) {
+            document.getElementById('status').textContent = 'Upload error: ' + err.message
+            console.error('Upload error:', err)
+        }
+    })
+</script>

package/index.js

@@ -2,18 +2,17 @@ var {http_server: braidify, fetch: braid_fetch} = require('braid-http')
 
 function create_braid_blob() {
     var braid_blob = {
-        db_folder: './braid-blob-db',
-        meta_folder: './braid-blob-meta',
+        db_folder: null, // defaults to './braid-blobs'
+        meta_folder: null, // defaults to './braid-blobs'
+        temp_folder: null, // defaults to './braid-blobs'
         cache: {},
-        meta_cache: {},
         key_to_subs: {},
         peer: null, // will be auto-generated if not set by the user
         db: null, // object with read/write/delete methods
+        meta_db: null, // sqlite database for meta storage
         reconnect_delay_ms: 1000,
     }
 
-    var temp_folder = null // will be set in init
-
     braid_blob.sync = (a, b, options = {}) => {
         options = normalize_options(options)
         if (!options.peer) options.peer = Math.random().toString(36).slice(2)
@@ -370,7 +369,7 @@ function create_braid_blob() {
                 if (options.content_type)
                     meta.content_type = options.content_type
 
-                await save_meta(key)
+                save_meta(key, meta)
                 if (options.signal?.aborted) return
 
                 // Notify all subscriptions of the update
@@ -441,17 +440,85 @@ function create_braid_blob() {
         await braid_blob.init()
 
         async function real_init() {
-            // Ensure our meta folder exists
-            await require('fs').promises.mkdir(braid_blob.meta_folder, { recursive: true })
-
-            // Create a temp folder inside the meta folder for writing temp files,
-            // for atomic writing.
-            // The temp folder is called "temp",
-            // And this is guaranteed not to conflict with any other files,
-            // because other files are the result of encode_filename,
-            // which always ends with a ".XX" (for handling insensitive filesystems)
-            temp_folder = `${braid_blob.meta_folder}/temp`
-            await require('fs').promises.mkdir(temp_folder, { recursive: true })
+            var fs = require('fs')
+
+            var db_was_not_set = !braid_blob.db_folder
+            if (db_was_not_set)
+                braid_blob.db_folder = './braid-blobs'
+
+            var get_db_folder = () =>
+                ((typeof braid_blob.db_folder === 'string') &&
+                braid_blob.db_folder) || './braid-blobs'
+
+            // deal with temp folder
+            if (!braid_blob.temp_folder) {
+                // Deal with versions before 0.0.53
+                await fs.promises.rm(
+                    `${braid_blob.meta_folder || './braid-blob-meta'}/temp`,
+                    { recursive: true, force: true })
+                
+                braid_blob.temp_folder = braid_blob.meta_folder ||
+                    get_db_folder()
+            }
+            await fs.promises.mkdir(braid_blob.temp_folder, 
+                { recursive: true })
+            for (var f of await fs.promises.readdir(braid_blob.temp_folder))
+                if (f.match(/^temp_\w+$/))
+                    await fs.promises.unlink(`${braid_blob.temp_folder}/${f}`)
+            
+            // deal with meta folder
+            var meta_was_not_set = !braid_blob.meta_folder
+            if (meta_was_not_set)
+                braid_blob.meta_folder = get_db_folder()
+            await fs.promises.mkdir(braid_blob.meta_folder,
+                { recursive: true })
+
+            // set up sqlite for meta storage
+            var Database = require('better-sqlite3')
+            braid_blob.meta_db = new Database(
+                `${braid_blob.meta_folder}/meta.sqlite`)
+            braid_blob.meta_db.pragma('journal_mode = WAL')
+            braid_blob.meta_db.exec(`
+                CREATE TABLE IF NOT EXISTS meta (
+                    key TEXT PRIMARY KEY,
+                    value JSON
+                )
+            `)
+
+            // Deal with versions before 0.0.53
+            async function migrate_meta_files(dir) {
+                for (var f of await fs.promises.readdir(dir)) {
+                    if (!f.match(/\.[0-9a-f]+$/i)) continue
+                    var key = decode_filename(f)
+                    var value = JSON.parse(
+                        await fs.promises.readFile(`${dir}/${f}`, 'utf8'))
+                    save_meta(key, value)
+                    await fs.promises.unlink(`${dir}/${f}`)
+                }
+            }
+            if (meta_was_not_set) {
+                try {
+                    await fs.promises.access('./braid-blob-meta')
+                    await migrate_meta_files('./braid-blob-meta')
+                    await fs.promises.rm('./braid-blob-meta', { recursive: true })
+                } catch (e) {}
+            } else if (braid_blob.meta_folder !== braid_blob.db_folder)
+                await migrate_meta_files(braid_blob.meta_folder)
+
+            // Deal with versions before 0.0.53: migrate db files from ./braid-blob-db
+            if (db_was_not_set) {
+                try {
+                    await fs.promises.access('./braid-blob-db')
+                    for (var f of await fs.promises.readdir('./braid-blob-db')) {
+                        if (!f.match(/\.[0-9a-f]+$/i)) continue
+                        await fs.promises.copyFile(
+                            `./braid-blob-db/${f}`,
+                            `${braid_blob.db_folder}/${f}`)
+                        await fs.promises.unlink(`./braid-blob-db/${f}`)
+                    }
+                    await fs.promises.rm('./braid-blob-db', { recursive: true })
+                } catch (e) {}
+            }
 
             // Set up db - either use provided object or create file-based storage
             if (typeof braid_blob.db_folder === 'string') {
@@ -468,7 +535,7 @@ function create_braid_blob() {
                     },
                     write: async (key, data) => {
                         var file_path = `${braid_blob.db_folder}/${encode_filename(key)}`
-                        await atomic_write(file_path, data, temp_folder)
+                        await atomic_write(file_path, data, braid_blob.temp_folder)
                     },
                     delete: async (key) => {
                         var file_path = `${braid_blob.db_folder}/${encode_filename(key)}`
@@ -490,34 +557,20 @@ function create_braid_blob() {
         }
     }
 
-    async function get_meta(key) {
-        if (!braid_blob.meta_cache[key]) {
-            try {
-                braid_blob.meta_cache[key] = JSON.parse(
-                    await require('fs').promises.readFile(
-                        `${braid_blob.meta_folder}/${encode_filename(key)}`, 'utf8'))
-            } catch (e) {
-                if (e.code === 'ENOENT')
-                    braid_blob.meta_cache[key] = {}
-                else throw e
-            }
-        }
-        return braid_blob.meta_cache[key]
+    function get_meta(key) {
+        var row = braid_blob.meta_db.prepare(
+            `SELECT value FROM meta WHERE key = ?`).get(key)
+        return row ? JSON.parse(row.value) : {}
     }
 
-    async function save_meta(key) {
-        await atomic_write(`${braid_blob.meta_folder}/${encode_filename(key)}`,
-            JSON.stringify(braid_blob.meta_cache[key]), temp_folder)
+    function save_meta(key, meta) {
+        braid_blob.meta_db.prepare(
+            `INSERT OR REPLACE INTO meta (key, value) VALUES (?, json(?))`)
+            .run(key, JSON.stringify(meta))
     }
 
-    async function delete_meta(key) {
-        delete braid_blob.meta_cache[key]
-        try {
-            await require('fs').promises.unlink(
-                `${braid_blob.meta_folder}/${encode_filename(key)}`)
-        } catch (e) {
-            if (e.code !== 'ENOENT') throw e
-        }
+    function delete_meta(key) {
+        braid_blob.meta_db.prepare(`DELETE FROM meta WHERE key = ?`).run(key)
     }
 
     //////////////////////////////////////////////////////////////////
@@ -663,6 +716,16 @@ function create_braid_blob() {
         }
     }
 
+    function decode_filename(s) {
+        // Remove the postfix '.XXX'
+        s = s.replace(/\.[^.]+$/, '')
+        // Decode percent-encoded characters
+        s = decodeURIComponent(s)
+        // Swap ! and / (reverse of encode)
+        s = s.replace(/[\/!]/g, x => x === '!' ? '/' : '!')
+        return s
+    }
+
     function normalize_options(options = {}) {
         if (!normalize_options.special) {
             normalize_options.special = {
@@ -704,7 +767,7 @@ function create_braid_blob() {
     }
 
     async function atomic_write(final_destination, data, temp_folder) {
-        var temp = `${temp_folder}/${Math.random().toString(36).slice(2)}`
+        var temp = `${temp_folder}/temp_${Math.random().toString(36).slice(2)}`
         await require('fs').promises.writeFile(temp, data)
         await require('fs').promises.rename(temp, final_destination)
     }
@@ -742,6 +805,7 @@ function create_braid_blob() {
 
     braid_blob.create_braid_blob = create_braid_blob
     braid_blob.braid_fetch = braid_fetch
+    braid_blob.encode_filename = encode_filename
 
     return braid_blob
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-blob",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "Library for collaborative blobs over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-blob",
@@ -10,6 +10,7 @@
     "test:browser": "node test/test.js --browser"
   },
   "dependencies": {
-    "braid-http": "~1.3.86"
+    "braid-http": "~1.3.86",
+    "better-sqlite3": "^11.7.0"
   }
 }

package/server-demo.js

@@ -3,22 +3,40 @@ var port = process.argv[2] || 8888
 var braid_blob = require(`${__dirname}/index.js`)
 
 // TODO: set a custom storage base
-// (the default is ./braid-blob-files)
+// (the default is ./braid-blobs)
 //
 // braid_blob.db_folder = './custom_files_folder'
-// braid_blob.meta_folder = './custom_meta_folder'
 
 braid_blob.init()
 
 var server = require("http").createServer(async (req, res) => {
     console.log(`${req.method} ${req.url}`)
 
+    var url = req.url.split('?')[0]
+
+    if (url === '/client.js') {
+        res.writeHead(200, {
+            "Content-Type": "text/javascript",
+            "Cache-Control": "no-cache"
+        })
+        require("fs").createReadStream(`${__dirname}/client.js`).pipe(res)
+        return
+    }
+
+    if (url === '/' || url === '/index.html') {
+        res.writeHead(200, {
+            "Content-Type": "text/html",
+            "Cache-Control": "no-cache"
+        })
+        require("fs").createReadStream(`${__dirname}/index.html`).pipe(res)
+        return
+    }
+
     braid_blob.serve(req, res)
 })
 
 server.listen(port, () => {
-    console.log(`server started on port ${port}`)
-    console.log(`files stored in: ${braid_blob.db_folder}`)
+    console.log(`server started on http://localhost:${port}`)
 })
 
 // curl -X PUT -H "Content-Type: image/png" --data-binary @blob.png http://localhost:8888/blob.png

package/test/tests.js

@@ -1390,9 +1390,8 @@ runTest(
                     // Get the file to verify it has the expected version
                     var result1 = await bb1.get(test_key)
 
-                    // Check what metadata was saved
-                    var meta1 = bb1.meta_cache[test_key]
-                    var debug_info = 'meta1: ' + JSON.stringify(meta1) + '; '
+                    // Close the first instance's db
+                    bb1.meta_db.close()
 
                     // Wait a bit to ensure file system has settled
                     await new Promise(resolve => setTimeout(resolve, 100))
@@ -1406,20 +1405,17 @@ runTest(
                     // Initialize bb2 by doing a get (this triggers init)
                     var result2 = await bb2.get(test_key)
 
-                    // Check what metadata bb2 sees
-                    var meta2 = bb2.meta_cache[test_key]
-                    debug_info += 'meta2: ' + JSON.stringify(meta2) + '; '
-
                     // The version should be the same - no new event ID generated
                     var versions_match = (result1.version[0] === result2.version[0])
                     var both_have_expected = (result1.version[0] === 'test-peer-123456')
 
                     // Clean up
+                    bb2.meta_db.close()
                     await fs.rm(db_folder, { recursive: true, force: true })
                     await fs.rm(meta_folder, { recursive: true, force: true })
 
                     res.end(versions_match && both_have_expected ? 'true' :
-                            'false: v1=' + result1.version[0] + ', v2=' + result2.version[0] + ' | ' + debug_info)
+                            'false: v1=' + result1.version[0] + ', v2=' + result2.version[0])
                 } catch (e) {
                     // Clean up even on error
                     await fs.rm(db_folder, { recursive: true, force: true })
@@ -1789,7 +1785,7 @@ runTest(
 )
 
 runTest(
-    "test atomic write creates temp folder on init",
+    "test atomic write creates temp_folder on init",
     async () => {
         var r1 = await braid_fetch(`/eval`, {
             method: 'POST',
@@ -1807,15 +1803,14 @@ runTest(
                     // Initialize
                     await bb.init()
 
-                    // Check that temp folder exists inside meta folder
-                    var temp_folder = meta_folder + '/temp'
-                    var stat = await fs.stat(temp_folder)
-                    var is_dir = stat.isDirectory()
+                    // Check that temp_folder is set to meta_folder (no /temp subdirectory anymore)
+                    var temp_folder_correct = bb.temp_folder === meta_folder
 
-                    res.end(is_dir ? 'true' : 'not a directory')
+                    res.end(temp_folder_correct ? 'true' : 'temp_folder is ' + bb.temp_folder)
                 } catch (e) {
                     res.end('error: ' + e.message)
                 } finally {
+                    bb.meta_db.close()
                     await fs.rm(db_folder, { recursive: true, force: true })
                     await fs.rm(meta_folder, { recursive: true, force: true })
                 }
@@ -1845,14 +1840,15 @@ runTest(
                     // Do a write
                     await bb.put('/test-file', Buffer.from('hello'), { version: ['1'] })
 
-                    // Check that temp folder is empty (no leftover temp files)
-                    var temp_folder = meta_folder + '/temp'
-                    var files = await fs.readdir(temp_folder)
+                    // Check that no temp_ files remain in temp_folder
+                    var files = await fs.readdir(bb.temp_folder)
+                    var temp_files = files.filter(f => f.startsWith('temp_'))
 
-                    res.end(files.length === 0 ? 'true' : 'leftover files: ' + files.join(', '))
+                    res.end(temp_files.length === 0 ? 'true' : 'leftover files: ' + temp_files.join(', '))
                 } catch (e) {
                     res.end('error: ' + e.message)
                 } finally {
+                    bb.meta_db.close()
                     await fs.rm(db_folder, { recursive: true, force: true })
                     await fs.rm(meta_folder, { recursive: true, force: true })
                 }
@@ -1890,6 +1886,7 @@ runTest(
                 } catch (e) {
                     res.end('error: ' + e.message)
                 } finally {
+                    bb.meta_db.close()
                     await fs.rm(db_folder, { recursive: true, force: true })
                     await fs.rm(meta_folder, { recursive: true, force: true })
                 }
@@ -1926,15 +1923,16 @@ runTest(
                     var content = result.body.toString()
                     var version = result.version[0]
 
-                    // Also verify temp folder is clean
-                    var temp_folder = meta_folder + '/temp'
-                    var files = await fs.readdir(temp_folder)
+                    // Also verify no temp_ files remain
+                    var files = await fs.readdir(bb.temp_folder)
+                    var temp_files = files.filter(f => f.startsWith('temp_'))
 
-                    res.end(content === 'write3' && version === '3' && files.length === 0 ? 'true' :
-                        'content=' + content + ', version=' + version + ', temp_files=' + files.length)
+                    res.end(content === 'write3' && version === '3' && temp_files.length === 0 ? 'true' :
+                        'content=' + content + ', version=' + version + ', temp_files=' + temp_files.length)
                 } catch (e) {
                     res.end('error: ' + e.message)
                 } finally {
+                    bb.meta_db.close()
                     await fs.rm(db_folder, { recursive: true, force: true })
                     await fs.rm(meta_folder, { recursive: true, force: true })
                 }