working through somee editor bugs, etc

Cargo.lock

···
  "jacquard-common",
  "jacquard-repo",
  "k256",
+ "loro",
  "miette 7.6.0",
+ "mini-moka 0.11.0",
  "n0-future 0.1.3",
  "rand 0.8.5",
  "regex",

Cargo.toml

···
 # [patch.crates-io]
 # #secp256k1-zkp = { git = "https://github.com/dpc/rust-secp256k1-zkp/", branch = "sanket-pr" }
 # ring = { git = "https://github.com/dpc/ring", rev = "5493e7e76d0d8fb1d3cbb0be9c4944700741b802" }
-
+loro = "1.9.1"
 
 [profile]
 

build-workers.sh

···
 export RUSTFLAGS='--cfg getrandom_backend="wasm_js"'
 cargo build -p weaver-app --bin editor_worker --bin embed_worker \
     --target wasm32-unknown-unknown --release \
-    --no-default-features --features "web","collab-worker"
+    --no-default-features --features "web","collab-worker","use-index"
 
 echo "==> Running wasm-bindgen"
 wasm-bindgen target/wasm32-unknown-unknown/release/editor_worker.wasm \

crates/weaver-app/Dockerfile

···
 # Build wasm workers
 RUN RUSTFLAGS='--cfg getrandom_backend="wasm_js"' cargo build -p weaver-app --bin editor_worker --bin embed_worker \
     --target wasm32-unknown-unknown --release \
-    --no-default-features --features "web, use-index"
+    --no-default-features --features "web","collab-worker","use-index"
 
 # Run wasm-bindgen on workers
 RUN wasm-bindgen target/wasm32-unknown-unknown/release/editor_worker.wasm \

crates/weaver-app/public/editor_worker.js

···
         ? { register: () => {}, unregister: () => {} }
         : new FinalizationRegistry(state => state.dtor(state.a, state.b));
 
+    function debugString(val) {
+        // primitive types
+        const type = typeof val;
+        if (type == 'number' || type == 'boolean' || val == null) {
+            return  `${val}`;
+        }
+        if (type == 'string') {
+            return `"${val}"`;
+        }
+        if (type == 'symbol') {
+            const description = val.description;
+            if (description == null) {
+                return 'Symbol';
+            } else {
+                return `Symbol(${description})`;
+            }
+        }
+        if (type == 'function') {
+            const name = val.name;
+            if (typeof name == 'string' && name.length > 0) {
+                return `Function(${name})`;
+            } else {
+                return 'Function';
+            }
+        }
+        // objects
+        if (Array.isArray(val)) {
+            const length = val.length;
+            let debug = '[';
+            if (length > 0) {
+                debug += debugString(val[0]);
+            }
+            for(let i = 1; i < length; i++) {
+                debug += ', ' + debugString(val[i]);
+            }
+            debug += ']';
+            return debug;
+        }
+        // Test for built-in
+        const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+        let className;
+        if (builtInMatches && builtInMatches.length > 1) {
+            className = builtInMatches[1];
+        } else {
+            // Failed to match the standard '[object ClassName]'
+            return toString.call(val);
+        }
+        if (className == 'Object') {
+            // we're a user defined class or Object
+            // JSON.stringify avoids problems with cycles, and is generally much
+            // easier than looping through ownProperties of `val`.
+            try {
+                return 'Object(' + JSON.stringify(val) + ')';
+            } catch (_) {
+                return 'Object';
+            }
+        }
+        // errors
+        if (val instanceof Error) {
+            return `${val.name}: ${val.message}\n${val.stack}`;
+        }
+        // TODO we could test for more things here, like `Set`s and `Map`s.
+        return className;
+    }
+
     function getArrayU8FromWasm0(ptr, len) {
         ptr = ptr >>> 0;
         return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
···
 
     let WASM_VECTOR_LEN = 0;
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent______1_(arg0, arg1, arg2) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent______1_(arg0, arg1, arg2);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_(arg0, arg1);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2) {
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2);
     }
 
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_CloseEvent__CloseEvent_____(arg0, arg1, arg2) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_CloseEvent__CloseEvent_____(arg0, arg1, arg2);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______2_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______2_(arg0, arg1);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
+    }
+
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2, arg3) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2, arg3);
+    }
+
+    const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+
+    const __wbindgen_enum_ReadableStreamType = ["bytes"];
+
+    const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
+
+    const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+
+    const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+
+    const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+
+    const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+
+    const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+
     const JSOwnerFinalization = (typeof FinalizationRegistry === 'undefined')
         ? { register: () => {}, unregister: () => {} }
         : new FinalizationRegistry(ptr => wasm.__wbg_jsowner_free(ptr >>> 0, 1));
 
+    class IntoUnderlyingByteSource {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            IntoUnderlyingByteSourceFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
+        }
+        /**
+         * @returns {number}
+         */
+        get autoAllocateChunkSize() {
+            const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @param {ReadableByteStreamController} controller
+         * @returns {Promise<any>}
+         */
+        pull(controller) {
+            const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+            return ret;
+        }
+        /**
+         * @param {ReadableByteStreamController} controller
+         */
+        start(controller) {
+            wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+        }
+        /**
+         * @returns {ReadableStreamType}
+         */
+        get type() {
+            const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+            return __wbindgen_enum_ReadableStreamType[ret];
+        }
+        cancel() {
+            const ptr = this.__destroy_into_raw();
+            wasm.intounderlyingbytesource_cancel(ptr);
+        }
+    }
+    if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
+    __exports.IntoUnderlyingByteSource = IntoUnderlyingByteSource;
+
+    class IntoUnderlyingSink {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            IntoUnderlyingSinkFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_intounderlyingsink_free(ptr, 0);
+        }
+        /**
+         * @param {any} reason
+         * @returns {Promise<any>}
+         */
+        abort(reason) {
+            const ptr = this.__destroy_into_raw();
+            const ret = wasm.intounderlyingsink_abort(ptr, reason);
+            return ret;
+        }
+        /**
+         * @returns {Promise<any>}
+         */
+        close() {
+            const ptr = this.__destroy_into_raw();
+            const ret = wasm.intounderlyingsink_close(ptr);
+            return ret;
+        }
+        /**
+         * @param {any} chunk
+         * @returns {Promise<any>}
+         */
+        write(chunk) {
+            const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+            return ret;
+        }
+    }
+    if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
+    __exports.IntoUnderlyingSink = IntoUnderlyingSink;
+
+    class IntoUnderlyingSource {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            IntoUnderlyingSourceFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_intounderlyingsource_free(ptr, 0);
+        }
+        /**
+         * @param {ReadableStreamDefaultController} controller
+         * @returns {Promise<any>}
+         */
+        pull(controller) {
+            const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+            return ret;
+        }
+        cancel() {
+            const ptr = this.__destroy_into_raw();
+            wasm.intounderlyingsource_cancel(ptr);
+        }
+    }
+    if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
+    __exports.IntoUnderlyingSource = IntoUnderlyingSource;
+
     class JSOwner {
         __destroy_into_raw() {
             const ptr = this.__wbg_ptr;
···
     function __wbg_get_imports() {
         const imports = {};
         imports.wbg = {};
+        imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        };
+        imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
         imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
···
             const ret = arg0 === undefined;
             return ret;
         };
+        imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
         imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         };
         imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
             arg0._wbg_cb_unref();
         };
+        imports.wbg.__wbg_abort_07646c894ebbf2bd = function(arg0) {
+            arg0.abort();
+        };
+        imports.wbg.__wbg_abort_399ecbcfd6ef3c8e = function(arg0, arg1) {
+            arg0.abort(arg1);
+        };
+        imports.wbg.__wbg_addEventListener_e792423147a80626 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3);
+        }, arguments) };
+        imports.wbg.__wbg_append_c5cbdf46455cc776 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments) };
+        imports.wbg.__wbg_arrayBuffer_c04af4fce566092d = function() { return handleError(function (arg0) {
+            const ret = arg0.arrayBuffer();
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_body_947b901c33f7fe32 = function(arg0) {
+            const ret = arg0.body;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_buffer_6cb2fecb1f253d71 = function(arg0) {
+            const ret = arg0.buffer;
+            return ret;
+        };
+        imports.wbg.__wbg_byobRequest_f8e3517f5f8ad284 = function(arg0) {
+            const ret = arg0.byobRequest;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_byteLength_faa9938885bdeee6 = function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
+        };
+        imports.wbg.__wbg_byteOffset_3868b6a19ba01dea = function(arg0) {
+            const ret = arg0.byteOffset;
+            return ret;
+        };
         imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
···
             const ret = arg0.call(arg1);
             return ret;
         }, arguments) };
+        imports.wbg.__wbg_cancel_a65cf45dca50ba4c = function(arg0) {
+            const ret = arg0.cancel();
+            return ret;
+        };
+        imports.wbg.__wbg_catch_b9db41d97d42bd02 = function(arg0, arg1) {
+            const ret = arg0.catch(arg1);
+            return ret;
+        };
+        imports.wbg.__wbg_clearTimeout_b716ecb44bea14ed = function(arg0) {
+            const ret = clearTimeout(arg0);
+            return ret;
+        };
+        imports.wbg.__wbg_clearTimeout_f7a6c75a3d228439 = function() { return handleError(function (arg0, arg1) {
+            arg0.clearTimeout(arg1);
+        }, arguments) };
+        imports.wbg.__wbg_close_0af5661bf3d335f2 = function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments) };
         imports.wbg.__wbg_close_0b472ca2d13f54f7 = function(arg0) {
             arg0.close();
         };
+        imports.wbg.__wbg_close_1db3952de1b5b1cf = function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments) };
+        imports.wbg.__wbg_close_3ec111e7b23d94d8 = function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments) };
+        imports.wbg.__wbg_code_85a811fe6ca962be = function(arg0) {
+            const ret = arg0.code;
+            return ret;
+        };
+        imports.wbg.__wbg_code_c2a85f2863ec11b3 = function(arg0) {
+            const ret = arg0.code;
+            return ret;
+        };
         imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
             const ret = arg0.crypto;
             return ret;
···
             const ret = arg0.data;
             return ret;
         };
+        imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+            const ret = arg0.done;
+            return ret;
+        };
+        imports.wbg.__wbg_enqueue_a7e6b1ee87963aad = function() { return handleError(function (arg0, arg1) {
+            arg0.enqueue(arg1);
+        }, arguments) };
         imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
···
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         };
+        imports.wbg.__wbg_fetch_7fb7602a1bf647ec = function(arg0) {
+            const ret = fetch(arg0);
+            return ret;
+        };
+        imports.wbg.__wbg_fetch_90447c28cc0b095e = function(arg0, arg1) {
+            const ret = arg0.fetch(arg1);
+            return ret;
+        };
+        imports.wbg.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments) };
         imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
             arg0.getRandomValues(arg1);
         }, arguments) };
+        imports.wbg.__wbg_getReader_48e00749fe3f6089 = function() { return handleError(function (arg0) {
+            const ret = arg0.getReader();
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_get_done_f98a6e62c4e18fb9 = function(arg0) {
+            const ret = arg0.done;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        };
+        imports.wbg.__wbg_get_value_63e39884ef11812e = function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        };
+        imports.wbg.__wbg_has_0e670569d65d3a45 = function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.has(arg0, arg1);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_headers_654c30e1bcccc552 = function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_Blob_e9c51ce33a4b6181 = function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Blob;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_Response_cd74d1c2ac92cb0b = function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Response;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
         imports.wbg.__wbg_instanceof_Window_b5cf7783caa68180 = function(arg0) {
             let result;
             try {
···
                 result = false;
             }
             const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+            const ret = Symbol.iterator;
             return ret;
         };
         imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
···
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         }, arguments) };
+        imports.wbg.__wbg_message_a4e9a39ee8f92b17 = function(arg0, arg1) {
+            const ret = arg1.message;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
         imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
             const ret = arg0.msCrypto;
             return ret;
         };
+        imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+            const ret = new Object();
+            return ret;
+        };
+        imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+            const ret = new Array();
+            return ret;
+        };
+        imports.wbg.__wbg_new_3c79b3bb1b32b7d3 = function() { return handleError(function () {
+            const ret = new Headers();
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        };
+        imports.wbg.__wbg_new_7c30d1f874652e62 = function() { return handleError(function (arg0, arg1) {
+            const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_new_881a222c65f168fc = function() { return handleError(function () {
+            const ret = new AbortController();
+            return ret;
+        }, arguments) };
         imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
             const ret = new Error();
             return ret;
         };
+        imports.wbg.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        };
         imports.wbg.__wbg_new_from_slice_f9c22b9153b26992 = function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
···
             const ret = new Function(getStringFromWasm0(arg0, arg1));
             return ret;
         };
+        imports.wbg.__wbg_new_with_byte_offset_and_length_d85c3da1fd8df149 = function(arg0, arg1, arg2) {
+            const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        };
         imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
             const ret = new Uint8Array(arg0 >>> 0);
             return ret;
         };
+        imports.wbg.__wbg_new_with_str_and_init_c5748f76f5108934 = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_new_with_str_sequence_073466a4a5387941 = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new WebSocket(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        };
+        imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments) };
         imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
             const ret = arg0.node;
+            return ret;
+        };
+        imports.wbg.__wbg_now_2c95c9de01293173 = function(arg0) {
+            const ret = arg0.now();
+            return ret;
+        };
+        imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+            const ret = Date.now();
             return ret;
         };
         imports.wbg.__wbg_now_8cf15d6e317793e1 = function(arg0) {
···
             const ret = Date.now();
             return ret;
         };
+        imports.wbg.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
+            const ret = arg0.performance;
+            return ret;
+        };
         imports.wbg.__wbg_performance_c77a440eff2efd9b = function(arg0) {
             const ret = arg0.performance;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
···
         imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         };
+        imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        };
         imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
···
         imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
             arg0.randomFillSync(arg1);
         }, arguments) };
+        imports.wbg.__wbg_read_39c4b35efcd03c25 = function(arg0) {
+            const ret = arg0.read();
+            return ret;
+        };
+        imports.wbg.__wbg_readyState_9d0976dcad561aa9 = function(arg0) {
+            const ret = arg0.readyState;
+            return ret;
+        };
+        imports.wbg.__wbg_reason_d4eb9e40592438c2 = function(arg0, arg1) {
+            const ret = arg1.reason;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_releaseLock_a5912f590b185180 = function(arg0) {
+            arg0.releaseLock();
+        };
+        imports.wbg.__wbg_removeEventListener_54bf92f4a849bd7d = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            arg0.removeEventListener(getStringFromWasm0(arg1, arg2), arg3);
+        }, arguments) };
         imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
             const ret = module.require;
             return ret;
···
             const ret = Promise.resolve(arg0);
             return ret;
         };
+        imports.wbg.__wbg_respond_9f7fc54636c4a3af = function() { return handleError(function (arg0, arg1) {
+            arg0.respond(arg1 >>> 0);
+        }, arguments) };
+        imports.wbg.__wbg_send_7cc36bb628044281 = function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.send(getStringFromWasm0(arg1, arg2));
+        }, arguments) };
+        imports.wbg.__wbg_send_ea59e150ab5ebe08 = function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.send(getArrayU8FromWasm0(arg1, arg2));
+        }, arguments) };
+        imports.wbg.__wbg_setTimeout_4302406184dcc5be = function(arg0, arg1) {
+            const ret = setTimeout(arg0, arg1);
+            return ret;
+        };
+        imports.wbg.__wbg_setTimeout_ceaa8eadc563d26e = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.setTimeout(arg1, arg2);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
+            arg0.set(getArrayU8FromWasm0(arg1, arg2));
+        };
+        imports.wbg.__wbg_set_binaryType_73e8c75df97825f8 = function(arg0, arg1) {
+            arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+        };
+        imports.wbg.__wbg_set_body_8e743242d6076a4f = function(arg0, arg1) {
+            arg0.body = arg1;
+        };
+        imports.wbg.__wbg_set_cache_0e437c7c8e838b9b = function(arg0, arg1) {
+            arg0.cache = __wbindgen_enum_RequestCache[arg1];
+        };
+        imports.wbg.__wbg_set_credentials_55ae7c3c106fd5be = function(arg0, arg1) {
+            arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+        };
+        imports.wbg.__wbg_set_handle_event_14baa3949ef6909d = function(arg0, arg1) {
+            arg0.handleEvent = arg1;
+        };
+        imports.wbg.__wbg_set_headers_5671cf088e114d2b = function(arg0, arg1) {
+            arg0.headers = arg1;
+        };
+        imports.wbg.__wbg_set_method_76c69e41b3570627 = function(arg0, arg1, arg2) {
+            arg0.method = getStringFromWasm0(arg1, arg2);
+        };
+        imports.wbg.__wbg_set_mode_611016a6818fc690 = function(arg0, arg1) {
+            arg0.mode = __wbindgen_enum_RequestMode[arg1];
+        };
+        imports.wbg.__wbg_set_onclose_032729b3d7ed7a9e = function(arg0, arg1) {
+            arg0.onclose = arg1;
+        };
+        imports.wbg.__wbg_set_onerror_7819daa6af176ddb = function(arg0, arg1) {
+            arg0.onerror = arg1;
+        };
         imports.wbg.__wbg_set_onmessage_5fe29d0fb54cb575 = function(arg0, arg1) {
             arg0.onmessage = arg1;
         };
+        imports.wbg.__wbg_set_onmessage_71321d0bed69856c = function(arg0, arg1) {
+            arg0.onmessage = arg1;
+        };
+        imports.wbg.__wbg_set_onopen_6d4abedb27ba5656 = function(arg0, arg1) {
+            arg0.onopen = arg1;
+        };
+        imports.wbg.__wbg_set_signal_e89be862d0091009 = function(arg0, arg1) {
+            arg0.signal = arg1;
+        };
+        imports.wbg.__wbg_signal_3c14fbdc89694b39 = function(arg0) {
+            const ret = arg0.signal;
+            return ret;
+        };
         imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
···
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         };
+        imports.wbg.__wbg_status_9bfc680efca4bdfd = function(arg0) {
+            const ret = arg0.status;
+            return ret;
+        };
+        imports.wbg.__wbg_stringify_655a6390e1f5eb6b = function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments) };
         imports.wbg.__wbg_subarray_845f2f5bce7d061a = function(arg0, arg1, arg2) {
             const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
             return ret;
         };
+        imports.wbg.__wbg_then_429f7caf1026411d = function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        };
         imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
             const ret = arg0.then(arg1);
             return ret;
         };
+        imports.wbg.__wbg_url_b6d11838a4f95198 = function(arg0, arg1) {
+            const ret = arg1.url;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_url_df28eef824b04410 = function(arg0, arg1) {
+            const ret = arg1.url;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        };
         imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
             const ret = arg0.versions;
             return ret;
         };
+        imports.wbg.__wbg_view_788aaf149deefd2f = function(arg0) {
+            const ret = arg0.view;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_wasClean_4154a2d59fdb4dd7 = function(arg0) {
+            const ret = arg0.wasClean;
+            return ret;
+        };
         imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_3fda284bdcf7704e = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 941, function: Function { arguments: [Externref], shim_idx: 942, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
+        imports.wbg.__wbindgen_cast_4d50504c7960c7db = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 5089, function: Function { arguments: [], shim_idx: 5090, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________2_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______3_);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_56c1ebb4e8528c2a = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 132, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 133, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____);
+        imports.wbg.__wbindgen_cast_4f4fadff60f85046 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 4976, function: Function { arguments: [], shim_idx: 4977, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________1_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______2_);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_75c82a975d6b40cd = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 5269, function: Function { arguments: [Externref], shim_idx: 5270, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
             return ret;
         };
         imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_ccbfef0f15d2f2b2 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3405, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 3406, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__web_sys_1984c39bba2ffe3a___features__gen_CloseEvent__CloseEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_CloseEvent__CloseEvent_____);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_d086004c1192dab2 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3461, function: Function { arguments: [], shim_idx: 3462, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_d9e01159fa505611 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3438, function: Function { arguments: [], shim_idx: 3439, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_ec4f04da93f4f5b8 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3959, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 3960, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent______1_);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_f7b350875fdc9e82 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 145, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 146, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____);
             return ret;
         };
         imports.wbg.__wbindgen_init_externref_table = function() {

crates/weaver-app/public/embed_worker.js

···
 
     let WASM_VECTOR_LEN = 0;
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
     }
 
-    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2) {
-        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____(arg0, arg1, arg2);
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_(arg0, arg1);
     }
 
     function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______(arg0, arg1) {
···
         wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2);
     }
 
+    function wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2, arg3) {
+        wasm.wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(arg0, arg1, arg2, arg3);
+    }
+
+    const __wbindgen_enum_ReadableStreamType = ["bytes"];
+
     const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
 
     const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
 
     const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
 
+    const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+
+    const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+
+    const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+
     const JSOwnerFinalization = (typeof FinalizationRegistry === 'undefined')
         ? { register: () => {}, unregister: () => {} }
         : new FinalizationRegistry(ptr => wasm.__wbg_jsowner_free(ptr >>> 0, 1));
 
+    class IntoUnderlyingByteSource {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            IntoUnderlyingByteSourceFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
+        }
+        /**
+         * @returns {number}
+         */
+        get autoAllocateChunkSize() {
+            const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @param {ReadableByteStreamController} controller
+         * @returns {Promise<any>}
+         */
+        pull(controller) {
+            const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+            return ret;
+        }
+        /**
+         * @param {ReadableByteStreamController} controller
+         */
+        start(controller) {
+            wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+        }
+        /**
+         * @returns {ReadableStreamType}
+         */
+        get type() {
+            const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+            return __wbindgen_enum_ReadableStreamType[ret];
+        }
+        cancel() {
+            const ptr = this.__destroy_into_raw();
+            wasm.intounderlyingbytesource_cancel(ptr);
+        }
+    }
+    if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
+    __exports.IntoUnderlyingByteSource = IntoUnderlyingByteSource;
+
+    class IntoUnderlyingSink {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            IntoUnderlyingSinkFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_intounderlyingsink_free(ptr, 0);
+        }
+        /**
+         * @param {any} reason
+         * @returns {Promise<any>}
+         */
+        abort(reason) {
+            const ptr = this.__destroy_into_raw();
+            const ret = wasm.intounderlyingsink_abort(ptr, reason);
+            return ret;
+        }
+        /**
+         * @returns {Promise<any>}
+         */
+        close() {
+            const ptr = this.__destroy_into_raw();
+            const ret = wasm.intounderlyingsink_close(ptr);
+            return ret;
+        }
+        /**
+         * @param {any} chunk
+         * @returns {Promise<any>}
+         */
+        write(chunk) {
+            const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+            return ret;
+        }
+    }
+    if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
+    __exports.IntoUnderlyingSink = IntoUnderlyingSink;
+
+    class IntoUnderlyingSource {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            IntoUnderlyingSourceFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_intounderlyingsource_free(ptr, 0);
+        }
+        /**
+         * @param {ReadableStreamDefaultController} controller
+         * @returns {Promise<any>}
+         */
+        pull(controller) {
+            const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+            return ret;
+        }
+        cancel() {
+            const ptr = this.__destroy_into_raw();
+            wasm.intounderlyingsource_cancel(ptr);
+        }
+    }
+    if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
+    __exports.IntoUnderlyingSource = IntoUnderlyingSource;
+
     class JSOwner {
         __destroy_into_raw() {
             const ptr = this.__wbg_ptr;
···
             const ret = arg0.arrayBuffer();
             return ret;
         }, arguments) };
+        imports.wbg.__wbg_buffer_6cb2fecb1f253d71 = function(arg0) {
+            const ret = arg0.buffer;
+            return ret;
+        };
+        imports.wbg.__wbg_byobRequest_f8e3517f5f8ad284 = function(arg0) {
+            const ret = arg0.byobRequest;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_byteLength_faa9938885bdeee6 = function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
+        };
+        imports.wbg.__wbg_byteOffset_3868b6a19ba01dea = function(arg0) {
+            const ret = arg0.byteOffset;
+            return ret;
+        };
+        imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments) };
         imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
···
         imports.wbg.__wbg_clearTimeout_15dfc3d1dcb635c6 = function() { return handleError(function (arg0, arg1) {
             arg0.clearTimeout(arg1);
         }, arguments) };
-        imports.wbg.__wbg_clearTimeout_3b6a9a13d4bde075 = function(arg0) {
+        imports.wbg.__wbg_clearTimeout_b716ecb44bea14ed = function(arg0) {
             const ret = clearTimeout(arg0);
             return ret;
         };
+        imports.wbg.__wbg_close_0af5661bf3d335f2 = function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments) };
         imports.wbg.__wbg_close_0b472ca2d13f54f7 = function(arg0) {
             arg0.close();
         };
+        imports.wbg.__wbg_close_3ec111e7b23d94d8 = function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments) };
         imports.wbg.__wbg_data_8bf4ae669a78a688 = function(arg0) {
             const ret = arg0.data;
             return ret;
···
             const ret = arg0.done;
             return ret;
         };
+        imports.wbg.__wbg_enqueue_a7e6b1ee87963aad = function() { return handleError(function (arg0, arg1) {
+            arg0.enqueue(arg1);
+        }, arguments) };
         imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
···
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         };
-        imports.wbg.__wbg_fetch_90447c28cc0b095e = function(arg0, arg1) {
-            const ret = arg0.fetch(arg1);
-            return ret;
-        };
-        imports.wbg.__wbg_fetch_df3fa17a5772dafb = function(arg0) {
+        imports.wbg.__wbg_fetch_7fb7602a1bf647ec = function(arg0) {
             const ret = fetch(arg0);
             return ret;
         };
-        imports.wbg.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
-            const ret = arg0.getTime();
+        imports.wbg.__wbg_fetch_90447c28cc0b095e = function(arg0, arg1) {
+            const ret = arg0.fetch(arg1);
             return ret;
         };
         imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
···
             const ret = arg0.length;
             return ret;
         };
-        imports.wbg.__wbg_new_0_23cedd11d9b40c9d = function() {
-            const ret = new Date();
-            return ret;
-        };
         imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
             const ret = new Object();
             return ret;
···
             const ret = new Error();
             return ret;
         };
+        imports.wbg.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue__wasm_bindgen_1add006a0ed82fd3___JsValue_____(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        };
         imports.wbg.__wbg_new_from_slice_f9c22b9153b26992 = function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
         };
         imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
             const ret = new Function(getStringFromWasm0(arg0, arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_new_with_byte_offset_and_length_d85c3da1fd8df149 = function(arg0, arg1, arg2) {
+            const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         };
         imports.wbg.__wbg_new_with_str_and_init_c5748f76f5108934 = function() { return handleError(function (arg0, arg1, arg2) {
···
             const ret = Promise.resolve(arg0);
             return ret;
         };
-        imports.wbg.__wbg_setTimeout_35a07631c669fbee = function(arg0, arg1) {
+        imports.wbg.__wbg_respond_9f7fc54636c4a3af = function() { return handleError(function (arg0, arg1) {
+            arg0.respond(arg1 >>> 0);
+        }, arguments) };
+        imports.wbg.__wbg_setTimeout_4302406184dcc5be = function(arg0, arg1) {
             const ret = setTimeout(arg0, arg1);
             return ret;
         };
···
             const ret = arg0.setTimeout(arg1, arg2);
             return ret;
         }, arguments) };
+        imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
+            arg0.set(getArrayU8FromWasm0(arg1, arg2));
+        };
         imports.wbg.__wbg_set_body_8e743242d6076a4f = function(arg0, arg1) {
             arg0.body = arg1;
         };
···
             const ret = arg0.value;
             return ret;
         };
-        imports.wbg.__wbindgen_cast_067e3c0104867449 = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 225, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 226, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_8b37e013ecf136cb___features__gen_MessageEvent__MessageEvent_____);
-            return ret;
+        imports.wbg.__wbg_view_788aaf149deefd2f = function(arg0) {
+            const ret = arg0.view;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         };
         imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_4c40eebfb345262b = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1169, function: Function { arguments: [], shim_idx: 1170, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______);
+        imports.wbg.__wbindgen_cast_6e929a04fb6adb86 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 389, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 390, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__Fn__web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___web_sys_1984c39bba2ffe3a___features__gen_MessageEvent__MessageEvent_____);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_ba06f0048889102c = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2202, function: Function { arguments: [Externref], shim_idx: 2203, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        imports.wbg.__wbindgen_cast_a206bfcc4c940d5e = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2181, function: Function { arguments: [Externref], shim_idx: 2182, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut__wasm_bindgen_1add006a0ed82fd3___JsValue____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke___wasm_bindgen_1add006a0ed82fd3___JsValue_____);
             return ret;
         };
-        imports.wbg.__wbindgen_cast_dd8568660229206d = function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 1434, function: Function { arguments: [], shim_idx: 1435, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        imports.wbg.__wbindgen_cast_e6dcebc0071508b8 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1096, function: Function { arguments: [], shim_idx: 1097, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output_______, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke______);
+            return ret;
+        };
+        imports.wbg.__wbindgen_cast_ee2795d3f0e223fa = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1359, function: Function { arguments: [], shim_idx: 1360, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_1add006a0ed82fd3___closure__destroy___dyn_core_b125d98f3949a913___ops__function__FnMut_____Output________1_, wasm_bindgen_1add006a0ed82fd3___convert__closures_____invoke_______1_);
             return ret;
         };

crates/weaver-app/src/components/editor/component.rs

···
         let draft_key = draft_key.clone();
         let entry_uri = parsed_uri.clone();
         let initial_content = initial_content.clone();
+        let target_notebook = target_notebook.clone();
 
         async move {
+            // Resolve target_notebook to a URI if provided
+            let notebook_uri: Option<SmolStr> = if let Some(ref title) = target_notebook {
+                if let Some(did) = fetcher.current_did().await {
+                    let ident = jacquard::types::ident::AtIdentifier::Did(did);
+                    match fetcher.get_notebook(ident, title.clone()).await {
+                        Ok(Some(notebook_data)) => {
+                            Some(notebook_data.0.uri.to_smolstr())
+                        }
+                        Ok(None) | Err(_) => {
+                            tracing::debug!("Could not resolve notebook '{}' to URI", title);
+                            None
+                        }
+                    }
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
             match load_and_merge_document(&fetcher, &draft_key, entry_uri.as_ref()).await {
-                Ok(Some(state)) => {
+                Ok(Some(mut state)) => {
                     tracing::debug!("Loaded merged document state");
+                    // If we resolved a notebook URI and state doesn't have one, use it
+                    if state.notebook_uri.is_none() {
+                        state.notebook_uri = notebook_uri;
+                    }
                     return LoadResult::Loaded(state);
                 }
                 Ok(None) => {
···
                                     synced_version: None, // Fresh from entry, never synced
                                     last_seen_diffs: std::collections::HashMap::new(),
                                     resolved_content,
+                                    notebook_uri: notebook_uri.clone(),
                                 });
                             }
                             Err(e) => {
···
                         synced_version: None, // New doc, never synced
                         last_seen_diffs: std::collections::HashMap::new(),
                         resolved_content: weaver_common::ResolvedContent::default(),
+                        notebook_uri,
                     })
                 }
                 Err(e) => {
···
                         cursor_offset,
                         editing_uri,
                         editing_cid,
+                        notebook_uri,
                         export_ms,
                         encode_ms,
                     } => {
···
                             cursor_offset,
                             editing_uri,
                             editing_cid,
+                            notebook_uri,
                         };
                         let write_start = crate::perf::now();
                         let _ = gloo_storage::LocalStorage::set(
···
                     let cursor_offset = doc.cursor.read().offset;
                     let editing_uri = doc.entry_ref().map(|r| r.uri.to_smolstr());
                     let editing_cid = doc.entry_ref().map(|r| r.cid.to_smolstr());
+                    let notebook_uri = doc.notebook_uri();
 
                     let sink_clone = worker_sink.clone();
 
···
                                     cursor_offset,
                                     editing_uri,
                                     editing_cid,
+                                    notebook_uri,
                                 })
                                 .await;
                         }

crates/weaver-app/src/components/editor/document.rs

···
 
 use jacquard::IntoStatic;
 use jacquard::from_json_value;
+use jacquard::smol_str::SmolStr;
 use jacquard::types::string::AtUri;
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
 use weaver_api::sh_weaver::embed::images::Image;
···
     /// None for new entries that haven't been published yet.
     /// Signal so cloned docs share the same state after publish.
     pub entry_ref: Signal<Option<StrongRef<'static>>>,
+
+    /// AT-URI of the notebook this draft belongs to (for re-publishing)
+    pub notebook_uri: Signal<Option<SmolStr>>,
 
     // --- Edit sync state (for PDS sync) ---
     /// StrongRef to the sh.weaver.edit.root record for this edit session.
···
     /// Pre-resolved embed content fetched during load.
     /// Avoids embed pop-in on initial render.
     pub resolved_content: weaver_common::ResolvedContent,
+    /// Notebook URI for re-publishing to the same notebook.
+    pub notebook_uri: Option<SmolStr>,
 }
 
 impl PartialEq for LoadedDocState {
···
             tags,
             embeds,
             entry_ref: Signal::new(None),
+            notebook_uri: Signal::new(None),
             edit_root: Signal::new(None),
             last_diff: Signal::new(None),
             last_synced_version: Signal::new(None),
···
     /// Set the StrongRef when editing an existing entry.
     pub fn set_entry_ref(&mut self, entry: Option<StrongRef<'static>>) {
         self.entry_ref.set(entry);
+    }
+
+    /// Get the notebook URI if this draft belongs to a notebook.
+    pub fn notebook_uri(&self) -> Option<SmolStr> {
+        self.notebook_uri.read().clone()
+    }
+
+    /// Set the notebook URI for re-publishing to the same notebook.
+    pub fn set_notebook_uri(&mut self, uri: Option<SmolStr>) {
+        self.notebook_uri.set(uri);
     }
 
     // --- Tags accessors ---
···
             tags,
             embeds,
             entry_ref: Signal::new(None),
+            notebook_uri: Signal::new(None),
             edit_root: Signal::new(None),
             last_diff: Signal::new(None),
             last_synced_version: Signal::new(None),
···
             tags,
             embeds,
             entry_ref: Signal::new(state.entry_ref),
+            notebook_uri: Signal::new(state.notebook_uri),
             edit_root: Signal::new(state.edit_root),
             last_diff: Signal::new(state.last_diff),
             // Use the synced version from state (tracks the PDS version vector)

crates/weaver-app/src/components/editor/mod.rs

···
 // Storage
 #[allow(unused_imports)]
 pub use storage::{
-    DRAFT_KEY_PREFIX, EditorSnapshot, clear_all_drafts, delete_draft, list_drafts,
-    load_from_storage, load_snapshot_from_storage, save_to_storage,
+    DRAFT_KEY_PREFIX, EditorSnapshot, clear_all_drafts, delete_draft, delete_draft_from_pds,
+    list_drafts, load_from_storage, load_snapshot_from_storage, save_to_storage,
 };
 
 // Sync

crates/weaver-app/src/components/editor/publish.rs

···
 
 use dioxus::prelude::*;
 use jacquard::cowstr::ToCowStr;
+use jacquard::smol_str::ToSmolStr;
 use jacquard::types::collection::Collection;
 use jacquard::types::ident::AtIdentifier;
 use jacquard::types::recordkey::RecordKey;
···
             .maybe_embeds(entry_embeds)
             .build();
 
+        // Check if we have a stored notebook URI (for re-publishing to same notebook)
+        // This avoids duplicate notebook creation when re-publishing
+        let (notebook_uri, entry_refs) = if let Some(stored_uri) = doc.notebook_uri() {
+            // Try to fetch notebook directly by URI to avoid duplicate creation
+            match client.get_notebook_by_uri(&stored_uri).await {
+                Ok(Some((uri, refs))) => {
+                    tracing::debug!("Found notebook by stored URI: {}", uri);
+                    (uri, refs)
+                }
+                Ok(None) | Err(_) => {
+                    // Stored URI invalid or notebook deleted, fall back to title lookup
+                    tracing::warn!("Stored notebook URI invalid, falling back to title lookup");
+                    let (did, _) = client
+                        .session_info()
+                        .await
+                        .ok_or_else(|| WeaverError::InvalidNotebook("Not authenticated".into()))?;
+                    client.upsert_notebook(notebook, &did).await?
+                }
+            }
+        } else {
+            // No stored URI, use title-based lookup/creation
+            let (did, _) = client
+                .session_info()
+                .await
+                .ok_or_else(|| WeaverError::InvalidNotebook("Not authenticated".into()))?;
+            client.upsert_notebook(notebook, &did).await?
+        };
+
         // Pass existing rkey if re-publishing (to allow title changes without creating new entry)
         let doc_entry_ref = doc.entry_ref();
         let existing_rkey = doc_entry_ref.as_ref().and_then(|r| r.uri.rkey());
-        let (entry_ref, was_created) = client
-            .upsert_entry(
-                notebook,
+
+        // Use upsert_entry_with_notebook since we already have notebook data
+        let (entry_ref, notebook_uri_final, was_created) = client
+            .upsert_entry_with_notebook(
+                notebook_uri,
+                entry_refs,
                 &doc.title(),
                 entry,
                 existing_rkey.map(|r| r.0.as_str()),
···
         // Set entry_ref so subsequent publishes update this record
         doc.set_entry_ref(Some(entry_ref));
 
+        // Store the notebook URI for future re-publishing
+        doc.set_notebook_uri(Some(notebook_uri_final.to_smolstr()));
+
         if was_created {
             PublishResult::Created(uri)
         } else {
···
         // Check if we're the owner or a collaborator
         let owner_did = match existing_ref.uri.authority() {
             AtIdentifier::Did(d) => d.clone(),
-            AtIdentifier::Handle(h) => fetcher
-                .client
-                .resolve_handle(h)
-                .await
-                .map_err(|e| WeaverError::InvalidNotebook(format!("Failed to resolve handle: {}", e)))?,
+            AtIdentifier::Handle(h) => fetcher.client.resolve_handle(h).await.map_err(|e| {
+                WeaverError::InvalidNotebook(format!("Failed to resolve handle: {}", e))
+            })?,
         };
         let is_collaborator = owner_did != current_did;
 
···
             .title(doc.title())
             .path(path)
             .created_at(Datetime::now())
+            .updated_at(Datetime::now())
             .maybe_tags(tags)
             .maybe_embeds(entry_embeds)
             .build();

crates/weaver-app/src/components/editor/storage.rs

···
 use jacquard::IntoStatic;
 use jacquard::smol_str::{SmolStr, ToSmolStr};
 use jacquard::types::string::{AtUri, Cid};
-use weaver_api::com_atproto::repo::strong_ref::StrongRef;
 use loro::cursor::Cursor;
 use serde::{Deserialize, Serialize};
+use weaver_api::com_atproto::repo::strong_ref::StrongRef;
 
 use super::document::EditorDocument;
 
···
     /// CID of the entry if editing an existing entry
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub editing_cid: Option<SmolStr>,
+
+    /// AT-URI of the notebook this draft belongs to (for re-publishing)
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub notebook_uri: Option<SmolStr>,
 }
 
 /// Build the full storage key from a draft key.
···
         cursor_offset: doc.cursor.read().offset,
         editing_uri: doc.entry_ref().map(|r| r.uri.to_smolstr()),
         editing_cid: doc.entry_ref().map(|r| r.cid.to_smolstr()),
+        notebook_uri: doc.notebook_uri(),
     };
 
     let write_start = crate::perf::now();
···
             // Verify the content matches (sanity check)
             if doc.content() == snapshot.content {
                 doc.set_entry_ref(entry_ref.clone());
+                if let Some(notebook_uri) = snapshot.notebook_uri {
+                    doc.set_notebook_uri(Some(notebook_uri));
+                }
                 return Some(doc);
             }
             tracing::warn!("Snapshot content mismatch, falling back to text content");
···
     doc.cursor.write().offset = snapshot.cursor_offset.min(doc.len_chars());
     doc.sync_loro_cursor();
     doc.set_entry_ref(entry_ref);
+    if let Some(notebook_uri) = snapshot.notebook_uri {
+        doc.set_notebook_uri(Some(notebook_uri));
+    }
     Some(doc)
 }
 
···
     pub snapshot: Vec<u8>,
     /// Entry StrongRef if editing an existing entry
     pub entry_ref: Option<StrongRef<'static>>,
+    /// Notebook URI for re-publishing
+    pub notebook_uri: Option<SmolStr>,
 }
 
 /// Load snapshot data from LocalStorage (WASM only).
···
     Some(LocalSnapshotData {
         snapshot: snapshot_bytes,
         entry_ref,
+        notebook_uri: snapshot.notebook_uri,
     })
 }
 
···
     }
 
     drafts
+}
+
+/// Delete a draft stub record from PDS.
+///
+/// This deletes the sh.weaver.edit.draft record, making the draft
+/// invisible in listDrafts. Edit history (edit.root, edit.diff) is
+/// preserved for potential recovery.
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub async fn delete_draft_from_pds(
+    fetcher: &crate::fetch::Fetcher,
+    draft_key: &str,
+) -> Result<(), weaver_common::WeaverError> {
+    use jacquard::prelude::XrpcClient;
+    use jacquard::types::ident::AtIdentifier;
+    use jacquard::types::recordkey::RecordKey;
+    use jacquard::types::string::Nsid;
+    use weaver_api::com_atproto::repo::delete_record::DeleteRecord;
+
+    // Only delete if authenticated
+    let Some(did) = fetcher.current_did().await else {
+        tracing::debug!("Not authenticated, skipping PDS draft deletion");
+        return Ok(());
+    };
+
+    // Extract rkey from draft_key
+    let rkey_str = if let Some(tid) = draft_key.strip_prefix("new:") {
+        tid.to_string()
+    } else if draft_key.starts_with("at://") {
+        draft_key.split('/').last().unwrap_or(draft_key).to_string()
+    } else {
+        draft_key.to_string()
+    };
+
+    let rkey = RecordKey::any(&rkey_str)
+        .map_err(|e| weaver_common::WeaverError::InvalidNotebook(e.to_string()))?;
+
+    // Build the delete request
+    let request = DeleteRecord::new()
+        .repo(AtIdentifier::Did(did))
+        .collection(Nsid::new_static("sh.weaver.edit.draft").unwrap())
+        .rkey(rkey)
+        .build();
+
+    // Execute deletion
+    let client = fetcher.get_client();
+    match client.send(request).await {
+        Ok(_) => {
+            tracing::info!("Deleted draft stub from PDS: {}", draft_key);
+            Ok(())
+        }
+        Err(e) => {
+            // Log but don't fail - draft may not exist on PDS
+            tracing::warn!("Failed to delete draft from PDS (may not exist): {}", e);
+            Ok(())
+        }
+    }
+}
+
+/// Non-WASM stub for delete_draft_from_pds
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+pub async fn delete_draft_from_pds(
+    _fetcher: &crate::fetch::Fetcher,
+    _draft_key: &str,
+) -> Result<(), weaver_common::WeaverError> {
+    Ok(())
 }
 
 /// Clear all editor drafts from LocalStorage (WASM only).

crates/weaver-app/src/components/editor/sync.rs

···
     }
 }
 
+/// Convert a DocRef to an entry_ref StrongRef.
+///
+/// For EntryRef: returns the entry's StrongRef directly
+/// For DraftRef: parses the draft_key as AT-URI, fetches the draft record to get CID, builds StrongRef
+/// For NotebookRef: returns the notebook's StrongRef
+async fn doc_ref_to_entry_ref(
+    fetcher: &Fetcher,
+    doc_ref: &DocRef<'_>,
+) -> Option<StrongRef<'static>> {
+    match &doc_ref.value {
+        DocRefValue::EntryRef(entry_ref) => Some(entry_ref.entry.clone().into_static()),
+        DocRefValue::DraftRef(draft_ref) => {
+            // draft_key contains the canonical AT-URI: at://{did}/sh.weaver.edit.draft/{rkey}
+            let draft_uri = AtUri::new(&draft_ref.draft_key).ok()?.into_static();
+
+            // Fetch the draft record to get its CID
+            match fetcher.client.get_record::<Draft>(&draft_uri).await {
+                Ok(response) => {
+                    let output = response.into_output().ok()?;
+                    let cid = output.cid?.into_static();
+                    Some(StrongRef::new().uri(draft_uri).cid(cid).build())
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to fetch draft record for entry_ref: {}", e);
+                    None
+                }
+            }
+        }
+        DocRefValue::NotebookRef(notebook_ref) => Some(notebook_ref.notebook.clone().into_static()),
+        DocRefValue::Unknown(_) => {
+            tracing::warn!("Unknown DocRefValue variant, cannot convert to entry_ref");
+            None
+        }
+    }
+}
+
 /// Result of a sync operation.
 #[derive(Clone, Debug)]
 pub enum SyncResult {
···
     Ok(all_diffs)
 }
 
+/// Result of creating an edit root, includes optional draft stub info.
+pub struct CreateRootResult {
+    /// The root record URI
+    pub root_uri: AtUri<'static>,
+    /// The root record CID
+    pub root_cid: Cid<'static>,
+    /// Draft stub StrongRef if this was a new draft (not editing published entry)
+    pub draft_ref: Option<StrongRef<'static>>,
+}
+
 /// Create the edit root record for an entry.
 ///
 /// Uploads the current Loro snapshot as a blob and creates an `sh.weaver.edit.root`
 /// record referencing the entry (or draft key if unpublished).
 ///
 /// For drafts, also creates the `sh.weaver.edit.draft` stub record first.
+/// Returns the draft stub info so caller can set entry_ref.
 pub async fn create_edit_root(
     fetcher: &Fetcher,
     doc: &EditorDocument,
     draft_key: &str,
     entry_uri: Option<&AtUri<'_>>,
     entry_cid: Option<&Cid<'_>>,
-) -> Result<(AtUri<'static>, Cid<'static>), WeaverError> {
+) -> Result<CreateRootResult, WeaverError> {
     let client = fetcher.get_client();
     let did = fetcher
         .current_did()
···
         .ok_or_else(|| WeaverError::InvalidNotebook("Not authenticated".into()))?;
 
     // For drafts, create the stub record first (makes it discoverable via listRecords)
-    if entry_uri.is_none() {
+    let draft_ref: Option<StrongRef<'static>> = if entry_uri.is_none() {
         let rkey = extract_draft_rkey(draft_key);
-        // Try to create draft stub, ignore if it already exists
+        // Try to create draft stub, or get existing one
         match create_draft_stub(fetcher, &did, &rkey).await {
-            Ok((uri, _cid)) => {
+            Ok((uri, cid)) => {
                 tracing::debug!("Created draft stub: {}", uri);
+                Some(StrongRef::new().uri(uri).cid(cid).build())
             }
             Err(e) => {
-                // Check if it's a "record already exists" error - that's fine
+                // Check if it's a "record already exists" error
                 let err_str = e.to_string();
-                if !err_str.contains("RecordAlreadyExists") && !err_str.contains("already exists") {
+                if err_str.contains("RecordAlreadyExists") || err_str.contains("already exists") {
+                    // Draft exists - fetch it to get the CID
+                    let draft_uri_str = format!("at://{}/{}/{}", did, DRAFT_NSID, rkey);
+                    if let Ok(draft_uri) = AtUri::new(&draft_uri_str) {
+                        if let Ok(response) =
+                            fetcher.get_client().get_record::<Draft>(&draft_uri).await
+                        {
+                            if let Ok(output) = response.into_output() {
+                                if let Some(cid) = output.cid {
+                                    Some(
+                                        StrongRef::new()
+                                            .uri(draft_uri.into_static())
+                                            .cid(cid.into_static())
+                                            .build(),
+                                    )
+                                } else {
+                                    tracing::warn!("Draft exists but has no CID");
+                                    None
+                                }
+                            } else {
+                                tracing::warn!("Draft exists but couldn't parse output");
+                                None
+                            }
+                        } else {
+                            tracing::warn!("Draft exists but couldn't fetch record");
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                } else {
                     tracing::warn!("Failed to create draft stub (continuing anyway): {}", e);
+                    None
                 }
             }
         }
-    }
+    } else {
+        None // Published entry, not a draft
+    };
 
     // Export full snapshot
     let snapshot = doc.export_snapshot();
···
         .into_output()
         .map_err(|e| WeaverError::InvalidNotebook(e.to_string()))?;
 
-    Ok((output.uri.into_static(), output.cid.into_static()))
+    Ok(CreateRootResult {
+        root_uri: output.uri.into_static(),
+        root_cid: output.cid.into_static(),
+        draft_ref,
+    })
 }
 
 /// Create a diff record with updates since the last sync.
···
     if doc.edit_root().is_none() {
         // First sync - create root
         let create_start = crate::perf::now();
-        let (root_uri, root_cid) = create_edit_root(
+        let result = create_edit_root(
             fetcher,
             doc,
             draft_key,
···
 
         // Build StrongRef for the root
         let root_ref = StrongRef::new()
-            .uri(root_uri.clone())
-            .cid(root_cid.clone())
+            .uri(result.root_uri.clone())
+            .cid(result.root_cid.clone())
             .build();
 
         // Update document state
···
         doc.set_last_diff(None);
         doc.mark_synced();
 
+        // For drafts: set entry_ref to the draft record (enables draft discovery/recovery)
+        if let Some(draft_ref) = result.draft_ref {
+            if doc.entry_ref().is_none() {
+                tracing::debug!("Setting entry_ref to draft: {}", draft_ref.uri);
+                doc.set_entry_ref(Some(draft_ref));
+            }
+        }
+
         let total_ms = crate::perf::now() - fn_start;
         tracing::debug!(total_ms, create_ms, "sync_to_pds: created root");
 
         Ok(SyncResult::CreatedRoot {
-            uri: root_uri,
-            cid: root_cid,
+            uri: result.root_uri,
+            cid: result.root_cid,
         })
     } else {
         // Subsequent sync - create diff
···
     /// Last seen diff URI per collaborator root (for incremental sync).
     /// Maps root URI -> last diff URI we've imported from that root.
     pub last_seen_diffs: std::collections::HashMap<AtUri<'static>, AtUri<'static>>,
+    /// The DocRef from the root record (tells us what's being edited)
+    pub doc_ref: DocRef<'static>,
 }
 
 /// Fetch a blob from the PDS.
···
     let merged_doc = LoroDoc::new();
     let mut our_root_ref: Option<StrongRef<'static>> = None;
     let mut our_last_diff_ref: Option<StrongRef<'static>> = None;
+    let mut merged_doc_ref: Option<DocRef<'static>> = None;
     let mut updated_last_seen = last_seen_diffs.clone();
 
     // Get current user's DID to identify "our" root for sync state tracking
···
                 updated_last_seen.insert(uri.clone(), last_diff.uri.clone().into_static());
             }
 
+            // Track doc_ref from the first root we process (they should all match)
+            if merged_doc_ref.is_none() {
+                merged_doc_ref = Some(pds_state.doc_ref.clone());
+            }
+
             // Track "our" root/diff refs for sync state (used when syncing back)
             // We want to track our own edit.root so subsequent diffs go to the right place
             let is_our_root = current_did.as_ref().is_some_and(|did| root_did == *did);
···
         root_snapshot: merged_snapshot.into(),
         diff_updates: vec![], // Already merged into snapshot
         last_seen_diffs: updated_last_seen,
+        doc_ref: merged_doc_ref.expect("Should have at least one doc_ref if we have a root"),
     }))
 }
 
···
         .uri(root_uri.clone())
         .cid(root_cid.into_static())
         .build();
+
+    // Extract the DocRef from the root record
+    let doc_ref = root_output.value.doc.into_static();
 
     // Fetch the root snapshot blob
     let root_snapshot = fetch_blob(
···
             root_snapshot,
             diff_updates: vec![],
             last_seen_diffs: std::collections::HashMap::new(),
+            doc_ref,
         }));
     }
 
···
             }
         }
 
-        let diff_uri = AtUri::new(&format_smolstr!("at://{}/{}/{}", diff_id.did, DIFF_NSID, rkey_str))
-            .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid diff URI: {}", e)))?
-            .into_static();
+        let diff_uri = AtUri::new(&format_smolstr!(
+            "at://{}/{}/{}",
+            diff_id.did,
+            DIFF_NSID,
+            rkey_str
+        ))
+        .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid diff URI: {}", e)))?
+        .into_static();
 
         let diff_response = fetcher
             .client
···
         root_snapshot,
         diff_updates,
         last_seen_diffs: std::collections::HashMap::new(),
+        doc_ref,
     }))
 }
 
···
                 synced_version: None, // Local-only, never synced to PDS
                 last_seen_diffs: std::collections::HashMap::new(),
                 resolved_content,
+                notebook_uri: local.notebook_uri, // Restored from localStorage
             }))
         }
 
···
             // Capture the version after loading all PDS state - this is our sync baseline
             let synced_version = Some(doc.oplog_vv());
 
+            // Reconstruct entry_ref from the DocRef stored in edit.root
+            let entry_ref = doc_ref_to_entry_ref(fetcher, &pds.doc_ref).await;
+            if entry_ref.is_some() {
+                tracing::debug!("Reconstructed entry_ref from PDS DocRef");
+            }
+
             let resolved_content =
                 prefetch_embeds_from_doc(&doc, fetcher, owner_ident.as_deref()).await;
 
             Ok(Some(LoadedDocState {
                 doc,
-                entry_ref: None, // Entry ref comes from the entry itself, not edit state
+                entry_ref,
                 edit_root: Some(pds.root_ref),
                 last_diff: pds.last_diff_ref,
                 synced_version, // Just loaded from PDS, fully synced
                 last_seen_diffs: pds.last_seen_diffs,
                 resolved_content,
+                notebook_uri: None, // PDS-only, notebook context comes from target_notebook
             }))
         }
 
···
                 synced_version: Some(pds_version),
                 last_seen_diffs: pds.last_seen_diffs,
                 resolved_content,
+                notebook_uri: local.notebook_uri, // Restored from localStorage
             }))
         }
     }
···
     pub document: EditorDocument,
     /// Draft key for this document
     pub draft_key: String,
-    /// Auto-sync interval in milliseconds (0 to disable)
-    #[props(default = 30_000)]
+    /// Auto-sync interval in milliseconds (0 to disable, default disabled)
+    #[props(default = 0)]
     pub auto_sync_interval_ms: u32,
     /// Callback to refresh/reload document from collaborators
     #[props(default)]
···
 /// Sync status indicator with auto-sync functionality.
 ///
 /// Displays the current sync state and automatically syncs to PDS periodically.
+/// Initially shows "Start syncing" until user activates sync, then auto-syncs.
 #[component]
 pub fn SyncStatus(props: SyncStatusProps) -> Element {
     let fetcher = use_context::<Fetcher>();
     let auth_state = use_context::<Signal<AuthState>>();
 
+    let doc = props.document.clone();
+    let draft_key = props.draft_key.clone();
+
+    // Sync activated - true if sync has been started (either manually or doc already has edit_root)
+    // Once activated, auto-sync is enabled
+    let mut sync_activated = use_signal(|| {
+        // If document already has an edit_root, syncing is already active
+        props.document.edit_root().is_some()
+    });
+
     // Sync state management
     let mut sync_state = use_signal(|| {
         if props.document.has_unsynced_changes() {
···
     });
     let mut last_error: Signal<Option<String>> = use_signal(|| None);
 
-    let doc = props.document.clone();
-    let draft_key = props.draft_key.clone();
-
     // Check if we're authenticated (drafts can sync via DraftRef even without entry)
     let is_authenticated = auth_state.read().is_authenticated();
 
     // Auto-sync trigger signal - set to true to trigger a sync
     let mut trigger_sync = use_signal(|| false);
 
-    // Auto-sync timer - triggers sync when there are unsynced changes
+    // Auto-sync timer - only triggers after sync has been activated
     {
-        let auto_sync_interval_ms = props.auto_sync_interval_ms;
         let doc_for_check = doc.clone();
 
-        dioxus_sdk::time::use_interval(
-            std::time::Duration::from_millis(auto_sync_interval_ms as u64),
-            move |_| {
-                if auto_sync_interval_ms == 0 {
-                    return;
-                }
-                // Only trigger if there are unsynced changes
-                if doc_for_check.has_unsynced_changes() {
-                    trigger_sync.set(true);
-                }
-            },
-        );
+        // Use 30s interval for auto-sync once activated
+        dioxus_sdk::time::use_interval(std::time::Duration::from_secs(30), move |_| {
+            // Only auto-sync if activated
+            if !*sync_activated.peek() {
+                return;
+            }
+            // Only trigger if there are unsynced changes
+            if doc_for_check.has_unsynced_changes() {
+                trigger_sync.set(true);
+            }
+        });
     }
 
     // Collaborator poll timer - checks for collaborator updates periodically
···
                 Ok(_) => {
                     sync_state.set(SyncState::Synced);
                     last_error.set(None);
+                    // Activate auto-sync after first successful sync
+                    if !*sync_activated.peek() {
+                        sync_activated.set(true);
+                        tracing::debug!("Sync activated - auto-sync enabled");
+                    }
                     tracing::debug!("Sync completed successfully");
                 }
                 Err(e) => {
···
     });
 
     // Determine display state (drafts can sync too via DraftRef)
+    let is_activated = *sync_activated.read();
     let display_state = if !is_authenticated {
         SyncState::Disabled
     } else {
         *sync_state.read()
     };
 
-    let (icon, label, class) = match display_state {
-        SyncState::Synced => ("✓", "Synced", "sync-status synced"),
-        SyncState::Syncing => ("◌", "Syncing...", "sync-status syncing"),
-        SyncState::Unsynced => ("●", "Unsynced", "sync-status unsynced"),
-        SyncState::RemoteChanges => ("↓", "Updates", "sync-status remote-changes"),
-        SyncState::Error => ("✕", "Sync error", "sync-status error"),
-        SyncState::Disabled => ("○", "Sync disabled", "sync-status disabled"),
+    // Before activation: show "Start syncing" button
+    // After activation: show normal sync states
+    let (icon, label, class) = if !is_activated && is_authenticated {
+        ("▶", "Start syncing", "sync-status start-sync")
+    } else {
+        match display_state {
+            SyncState::Synced => ("✓", "Synced", "sync-status synced"),
+            SyncState::Syncing => ("◌", "Syncing...", "sync-status syncing"),
+            SyncState::Unsynced => ("●", "Unsynced", "sync-status unsynced"),
+            SyncState::RemoteChanges => ("↓", "Updates", "sync-status remote-changes"),
+            SyncState::Error => ("✕", "Sync error", "sync-status error"),
+            SyncState::Disabled => ("○", "Sync disabled", "sync-status disabled"),
+        }
+    };
+
+    // Long-press detection for deactivating sync
+    let mut long_press_active = use_signal(|| false);
+    #[cfg(target_arch = "wasm32")]
+    let mut long_press_timeout: Signal<Option<gloo_timers::callback::Timeout>> =
+        use_signal(|| None);
+
+    let on_pointer_down = move |_: dioxus::events::PointerEvent| {
+        // Only allow deactivation if sync is currently activated
+        if !*sync_activated.peek() {
+            return;
+        }
+
+        long_press_active.set(true);
+
+        // Start 1 second timer for long press
+        #[cfg(target_arch = "wasm32")]
+        let timeout = gloo_timers::callback::Timeout::new(1000, move || {
+            if *long_press_active.peek() {
+                sync_activated.set(false);
+                long_press_active.set(false);
+                tracing::debug!("Sync deactivated via long press");
+            }
+        });
+        #[cfg(target_arch = "wasm32")]
+        long_press_timeout.set(Some(timeout));
+    };
+
+    let on_pointer_up = move |_: dioxus::events::PointerEvent| {
+        long_press_active.set(false);
+        // Cancel the timeout by dropping it
+        #[cfg(target_arch = "wasm32")]
+        long_press_timeout.set(None);
+    };
+
+    let on_pointer_leave = move |_: dioxus::events::PointerEvent| {
+        long_press_active.set(false);
+        #[cfg(target_arch = "wasm32")]
+        long_press_timeout.set(None);
     };
 
     // Combined sync handler - pulls remote changes first if needed, then pushes local
···
         let on_refresh = props.on_refresh.clone();
         let current_state = display_state;
         move |_: dioxus::events::MouseEvent| {
+            // Don't trigger click if long press just fired
+            if !*sync_activated.peek() && *long_press_active.peek() {
+                return;
+            }
+
             if *sync_state.peek() == SyncState::Syncing {
                 return; // Already syncing
             }
···
         }
     };
 
+    // Show tooltip hint about long-press when sync is active
+    let title = if is_activated {
+        if let Some(ref err) = *last_error.read() {
+            err.clone()
+        } else {
+            format!("{} (hold to stop syncing)", label)
+        }
+    } else {
+        label.to_string()
+    };
+
     rsx! {
         div {
             class: "{class}",
-            title: if let Some(ref err) = *last_error.read() { err.clone() } else { label.to_string() },
+            title: "{title}",
             onclick: on_sync_click,
+            onpointerdown: on_pointer_down,
+            onpointerup: on_pointer_up,
+            onpointerleave: on_pointer_leave,
 
             span { class: "sync-icon", "{icon}" }
             span { class: "sync-label", "{label}" }

crates/weaver-app/src/components/editor/worker.rs

···
         editing_uri: Option<SmolStr>,
         /// Editing CID if editing existing entry
         editing_cid: Option<SmolStr>,
+        /// Notebook URI for re-publishing
+        notebook_uri: Option<SmolStr>,
     },
     /// Start collab session (worker will spawn CollabNode)
     StartCollab {
···
         editing_uri: Option<SmolStr>,
         /// Editing CID
         editing_cid: Option<SmolStr>,
+        /// Notebook URI for re-publishing
+        notebook_uri: Option<SmolStr>,
         /// Export timing in ms
         export_ms: f64,
         /// Encode timing in ms
···
                             cursor_offset,
                             editing_uri,
                             editing_cid,
+                            notebook_uri,
                         } => {
                             let Some(ref doc) = doc else {
                                 if let Err(e) = scope
···
                                     cursor_offset,
                                     editing_uri,
                                     editing_cid,
+                                    notebook_uri,
                                     export_ms,
                                     encode_ms,
                                 })
···
                         cursor_offset,
                         editing_uri,
                         editing_cid,
+                        notebook_uri,
                     } => {
                         let Some(ref doc) = doc else {
                             if let Err(e) = scope
···
                                 cursor_offset,
                                 editing_uri,
                                 editing_cid,
+                                notebook_uri,
                                 export_ms,
                                 encode_ms,
                             })

crates/weaver-app/src/components/entry.rs

···
 
             div { class: "entry-meta-info",
                 // Authors
-                if !entry_view.authors.is_empty() {
                     div { class: "entry-authors",
                         AuthorList {
                             authors: entry_view.authors.clone(),
                             owner_ident: Some(ident.clone()),
                         }
                     }
-                }
+
 
                 // Date
                 div { class: "entry-date",

crates/weaver-app/src/views/drafts.rs

···
 use crate::components::button::{Button, ButtonVariant};
 use crate::components::dialog::{DialogContent, DialogDescription, DialogRoot, DialogTitle};
 use crate::components::editor::{list_drafts_from_pds, RemoteDraft};
-use crate::components::editor::{delete_draft, list_drafts};
+use crate::components::editor::{delete_draft, delete_draft_from_pds, list_drafts};
 use crate::fetch::Fetcher;
 use dioxus::prelude::*;
 use jacquard::smol_str::{SmolStr, format_smolstr};
···
     let mut local_drafts = use_signal(list_drafts);
     let mut show_delete_confirm = use_signal(|| None::<String>);
 
+    // Clone fetcher early for use in both resource and delete handler
+    let fetcher_for_resource = fetcher.clone();
+    let fetcher_for_delete = fetcher.clone();
+
     // Fetch remote drafts from PDS (depends on auth state to re-run when logged in)
     let remote_drafts_resource = use_resource(move || {
-        let fetcher = fetcher.clone();
+        let fetcher = fetcher_for_resource.clone();
         let _did = auth_state.read().did.clone(); // Track auth state for reactivity
         async move { list_drafts_from_pds(&fetcher).await.ok().unwrap_or_default() }
     });
···
     });
 
     let mut handle_delete = move |key: String| {
+        let fetcher = fetcher_for_delete.clone();
+        let key_clone = key.clone();
+
+        // Delete from localStorage immediately
         delete_draft(&key);
         local_drafts.set(list_drafts());
         show_delete_confirm.set(None);
+
+        // Also delete from PDS (async, fire-and-forget)
+        spawn(async move {
+            if let Err(e) = delete_draft_from_pds(&fetcher, &key_clone).await {
+                tracing::warn!("Failed to delete draft from PDS: {}", e);
+            }
+        });
     };
 
     rsx! {

crates/weaver-app/src/views/home.rs

···
 /// Pinned content items - can be notebooks or entries
 #[derive(Clone, PartialEq)]
 pub enum PinnedItem {
+    #[allow(dead_code)]
     Notebook {
         ident: AtIdentifier<'static>,
         title: SmolStr,
···
         // },
         PinnedItem::Entry {
             ident: AtIdentifier::Did(Did::new_static("did:plc:yfvwmnlztr4dwkb7hwz55r2g").unwrap()),
-            rkey: SmolStr::new_static("3m4rbphjzt62b"),
+            rkey: SmolStr::new_static("3m7ysqf2z5s22"),
         },
+        // PinnedItem::Entry {
+        //     ident: AtIdentifier::Did(Did::new_static("did:plc:yfvwmnlztr4dwkb7hwz55r2g").unwrap()),
+        //     rkey: SmolStr::new_static("3m4rbphjzt62b"),
+        // },
     ]
 }
 

crates/weaver-cli/src/main.rs

···
         // Use WeaverExt to upsert entry (handles notebook + entry creation/updates)
         use jacquard::http_client::HttpClient;
         use weaver_common::WeaverExt;
-        let (entry_ref, was_created) = agent
+        let (entry_ref, _, was_created) = agent
             .upsert_entry(&title, entry_title.as_ref(), entry, None)
             .await?;
 

crates/weaver-common/src/agent.rs

···
         }
     }
 
+    /// Fetch a notebook by URI and return its entry list
+    ///
+    /// Returns Ok(Some((uri, entry_list))) if the notebook exists and can be parsed,
+    /// Ok(None) if the notebook doesn't exist,
+    /// Err if there's a network or parsing error.
+    fn get_notebook_by_uri(
+        &self,
+        uri: &str,
+    ) -> impl Future<Output = Result<Option<(AtUri<'static>, Vec<StrongRef<'static>>)>, WeaverError>>
+    where
+        Self: Sized,
+    {
+        async move {
+            use weaver_api::sh_weaver::notebook::book::Book;
+
+            let at_uri = AtUri::new(uri)
+                .map_err(|e| WeaverError::InvalidNotebook(format!("Invalid notebook URI: {}", e)))?;
+
+            let response = match self.get_record::<Book>(&at_uri).await {
+                Ok(r) => r,
+                Err(_) => return Ok(None), // Notebook doesn't exist
+            };
+
+            let output = match response.into_output() {
+                Ok(o) => o,
+                Err(_) => return Ok(None), // Failed to parse
+            };
+
+            let entries = output
+                .value
+                .entry_list
+                .iter()
+                .cloned()
+                .map(IntoStatic::into_static)
+                .collect();
+
+            Ok(Some((at_uri.into_static(), entries)))
+        }
+    }
+
     /// Find or create a notebook by title, returning its URI and entry list
     ///
     /// If the notebook doesn't exist, creates it with the given DID as author.
···
         }
     }
 
-    /// Find or create an entry within a notebook
+    /// Find or create an entry within a notebook (with pre-fetched notebook data)
     ///
-    /// Multi-step workflow:
-    /// 1. Find the notebook by title
-    /// 2. If existing_rkey is provided, match by rkey; otherwise match by title
-    /// 3. If found: update the entry with new content
-    /// 4. If not found: create new entry and append to notebook's entry_list
-    ///
-    /// The `existing_rkey` parameter allows updating an entry even if its title changed,
-    /// and enables pre-generating rkeys for path rewriting before publish.
+    /// This variant accepts notebook URI and entry_refs directly to avoid redundant
+    /// notebook lookups when the caller has already fetched this data.
     ///
-    /// Returns (entry_ref, was_created)
-    fn upsert_entry(
+    /// Returns (entry_ref, notebook_uri, was_created)
+    fn upsert_entry_with_notebook(
         &self,
-        notebook_title: &str,
+        notebook_uri: AtUri<'static>,
+        entry_refs: Vec<StrongRef<'static>>,
         entry_title: &str,
         entry: entry::Entry<'_>,
         existing_rkey: Option<&str>,
-    ) -> impl Future<Output = Result<(StrongRef<'static>, bool), WeaverError>>
+    ) -> impl Future<Output = Result<(StrongRef<'static>, AtUri<'static>, bool), WeaverError>>
     where
         Self: Sized,
     {
         async move {
-            // Get our own DID
-            let (did, _) = self.session_info().await.ok_or_else(|| {
-                AgentError::from(ClientError::invalid_request("No session info available"))
-            })?;
-
-            // Find or create notebook
-            let (notebook_uri, entry_refs) = self.upsert_notebook(notebook_title, &did).await?;
-
             // If we have an existing rkey, try to find and update that specific entry
             if let Some(rkey) = existing_rkey {
                 // Check if this entry exists in the notebook by comparing rkeys
···
                             .uri(output.uri.into_static())
                             .cid(output.cid.into_static())
                             .build();
-                        return Ok((updated_ref, false));
+                        return Ok((updated_ref, notebook_uri, false));
                     }
                 }
 
···
                 })
                 .await?;
 
-                return Ok((new_ref, true));
+                return Ok((new_ref, notebook_uri, true));
             }
 
-            // No existing rkey - use title-based matching (original behavior)
+            // No existing rkey - use title-based matching
 
             // Fast path: if notebook is empty, skip search and create directly
             if entry_refs.is_empty() {
···
                 })
                 .await?;
 
-                return Ok((new_ref, true));
+                return Ok((new_ref, notebook_uri, true));
             }
 
             // Check if entry with this title exists in the notebook
···
                             .uri(output.uri.into_static())
                             .cid(output.cid.into_static())
                             .build();
-                        return Ok((updated_ref, false));
+                        return Ok((updated_ref, notebook_uri, false));
                     }
                 }
             }
···
             })
             .await?;
 
-            Ok((new_ref, true))
+            Ok((new_ref, notebook_uri, true))
+        }
+    }
+
+    /// Find or create an entry within a notebook
+    ///
+    /// Multi-step workflow:
+    /// 1. Find the notebook by title
+    /// 2. If existing_rkey is provided, match by rkey; otherwise match by title
+    /// 3. If found: update the entry with new content
+    /// 4. If not found: create new entry and append to notebook's entry_list
+    ///
+    /// The `existing_rkey` parameter allows updating an entry even if its title changed,
+    /// and enables pre-generating rkeys for path rewriting before publish.
+    ///
+    /// Returns (entry_ref, notebook_uri, was_created)
+    fn upsert_entry(
+        &self,
+        notebook_title: &str,
+        entry_title: &str,
+        entry: entry::Entry<'_>,
+        existing_rkey: Option<&str>,
+    ) -> impl Future<Output = Result<(StrongRef<'static>, AtUri<'static>, bool), WeaverError>>
+    where
+        Self: Sized,
+    {
+        async move {
+            // Get our own DID
+            let (did, _) = self.session_info().await.ok_or_else(|| {
+                AgentError::from(ClientError::invalid_request("No session info available"))
+            })?;
+
+            // Find or create notebook
+            let (notebook_uri, entry_refs) = self.upsert_notebook(notebook_title, &did).await?;
+
+            // Delegate to the variant with pre-fetched notebook data
+            self.upsert_entry_with_notebook(
+                notebook_uri,
+                entry_refs,
+                entry_title,
+                entry,
+                existing_rkey,
+            )
+            .await
         }
     }
 

crates/weaver-index/Cargo.toml

···
 chrono = { version = "0.4", features = ["serde"] }
 smol_str = "0.3"
 
+# CRDT (for parsing draft snapshots)
+loro = { workspace = true }
+
 # CID handling (for CAR block lookups)
 cid = "0.11"
 
···
 dashmap = "6"
 include_dir = "0.7.4"
 regex = "1"
+mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d" }
 
 # WebSocket (for tap consumer)
 tokio-tungstenite = { version = "0.26", features = ["native-tls"] }

crates/weaver-index/migrations/clickhouse/040_draft_titles.sql

···
+-- Draft titles extracted from Loro snapshots
+-- Updated by background task when edit_heads changes
+
+CREATE TABLE IF NOT EXISTS draft_titles (
+    -- Draft identity (matches drafts table)
+    did String,
+    rkey String,
+
+    -- Extracted title from Loro doc
+    title String DEFAULT '',
+
+    -- Head used for extraction (stale if doesn't match edit_heads)
+    head_did String DEFAULT '',
+    head_rkey String DEFAULT '',
+    head_cid String DEFAULT '',
+
+    -- Timestamps
+    updated_at DateTime64(3) DEFAULT now64(3),
+    indexed_at DateTime64(3) DEFAULT now64(3)
+)
+ENGINE = ReplacingMergeTree(indexed_at)
+ORDER BY (did, rkey)

crates/weaver-index/src/bin/weaver_indexer.rs

···
 
 use clap::{Parser, Subcommand};
 use tracing::{error, info, warn};
+use jacquard::client::UnauthenticatedSession;
 use weaver_index::clickhouse::InserterConfig;
 use weaver_index::clickhouse::{Client, Migrator};
 use weaver_index::config::{
···
 };
 use weaver_index::firehose::FirehoseConsumer;
 use weaver_index::server::{AppState, ServerConfig, TelemetryConfig, telemetry};
-use weaver_index::{FirehoseIndexer, ServiceIdentity, TapIndexer, load_cursor};
+use weaver_index::{
+    DraftTitleTaskConfig, FirehoseIndexer, ServiceIdentity, TapIndexer, load_cursor,
+    run_draft_title_task,
+};
 
 #[derive(Parser)]
 #[command(name = "indexer")]
···
     });
     let did_doc = identity.did_document_with_service(&server_config.service_did, &service_endpoint);
 
-    // Create separate clients for indexer and server
+    // Create separate clients for indexer, server, and background tasks
     let indexer_client = Client::new(&ch_config)?;
     let server_client = Client::new(&ch_config)?;
+    let task_client = std::sync::Arc::new(Client::new(&ch_config)?);
 
     // Build AppState for server
     let state = AppState::new(
···
             tokio::spawn(async move { indexer.run().await })
         }
     };
+
+    // Spawn background tasks
+    let resolver = UnauthenticatedSession::new_public();
+    tokio::spawn(run_draft_title_task(
+        task_client,
+        resolver,
+        DraftTitleTaskConfig::default(),
+    ));
 
     // Run server, monitoring indexer health
     tokio::select! {

crates/weaver-index/src/clickhouse.rs

···
 pub use client::{Client, TableSize};
 pub use migrations::{DbObject, MigrationResult, Migrator, ObjectType};
 pub use queries::{
-    CollaboratorRow, EditHeadRow, EditNodeRow, EntryRow, HandleMappingRow, NotebookRow,
-    ProfileCountsRow, ProfileRow, ProfileWithCounts,
+    CollaboratorRow, EditChainNode, EditHeadRow, EditNodeRow, EntryRow, HandleMappingRow,
+    NotebookRow, ProfileCountsRow, ProfileRow, ProfileWithCounts, StaleDraftRow,
 };
 pub use resilient_inserter::{InserterConfig, ResilientRecordInserter};
 pub use schema::{

crates/weaver-index/src/clickhouse/queries.rs

···
 
 pub use collab::PermissionRow;
 pub use collab_state::{CollaboratorRow, EditHeadRow};
-pub use edit::EditNodeRow;
+pub use edit::{EditChainNode, EditNodeRow, StaleDraftRow};
 pub use identity::HandleMappingRow;
 pub use notebooks::{EntryRow, NotebookRow};
 pub use profiles::{ProfileCountsRow, ProfileRow, ProfileWithCounts};

crates/weaver-index/src/clickhouse/queries/edit.rs

···
     pub root_cid: SmolStr,
     #[serde(with = "clickhouse::serde::chrono::datetime64::millis::option")]
     pub last_edit_at: Option<chrono::DateTime<chrono::Utc>>,
+    /// Title extracted from Loro doc (may be empty if not yet extracted)
+    pub title: SmolStr,
+}
+
+/// Draft needing title extraction (stale or missing from draft_titles)
+#[derive(Debug, Clone, Row, Deserialize)]
+pub struct StaleDraftRow {
+    /// Draft DID
+    pub did: SmolStr,
+    /// Draft rkey
+    pub rkey: SmolStr,
+    /// Current head DID
+    pub head_did: SmolStr,
+    /// Current head rkey
+    pub head_rkey: SmolStr,
+    /// Current head CID
+    pub head_cid: SmolStr,
+    /// Root DID for this edit chain
+    pub root_did: SmolStr,
+    /// Root rkey
+    pub root_rkey: SmolStr,
+    /// Root CID
+    pub root_cid: SmolStr,
+}
+
+/// Edit chain node for reconstructing Loro doc
+#[derive(Debug, Clone, Row, Deserialize)]
+pub struct EditChainNode {
+    pub did: SmolStr,
+    pub rkey: SmolStr,
+    pub cid: SmolStr,
+    pub node_type: SmolStr,
+    pub prev_did: SmolStr,
+    pub prev_rkey: SmolStr,
 }
 
 impl Client {
···
 
     /// List drafts for an actor.
     ///
-    /// Returns draft records with associated edit root info if available.
+    /// Returns draft records with associated edit root info and title if available.
     pub async fn list_drafts(
         &self,
         actor_did: &str,
         cursor: Option<i64>,
         limit: i64,
     ) -> Result<Vec<DraftWithRootRow>, IndexError> {
-        // Query drafts table with LEFT JOIN to get associated edit roots
+        // Query drafts table with LEFT JOINs to get edit roots and titles
         // Edit roots reference drafts via resource_type/did/rkey fields
+        // Titles are extracted from Loro snapshots by background task
         let query = r#"
             SELECT
                 d.did,
···
                 COALESCE(e.did, '') AS root_did,
                 COALESCE(e.rkey, '') AS root_rkey,
                 COALESCE(e.cid, '') AS root_cid,
-                e.created_at AS last_edit_at
+                e.created_at AS last_edit_at,
+                COALESCE(t.title, '') AS title
             FROM drafts d FINAL
             LEFT JOIN (
                 SELECT
···
                   AND resource_type = 'draft'
                   AND deleted_at = toDateTime64(0, 3)
             ) e ON e.resource_did = d.did AND e.resource_rkey = d.rkey
+            LEFT JOIN draft_titles t FINAL ON t.did = d.did AND t.rkey = d.rkey
             WHERE d.did = ?
               AND d.deleted_at = toDateTime64(0, 3)
               AND (? = 0 OR toUnixTimestamp64Milli(d.created_at) < ?)
···
             })?;
 
         Ok(rows)
+    }
+
+    /// Find drafts with stale or missing titles.
+    ///
+    /// Compares edit_heads to draft_titles to find drafts where the current
+    /// head doesn't match the head used for title extraction.
+    pub async fn get_stale_draft_titles(&self, limit: i64) -> Result<Vec<StaleDraftRow>, IndexError> {
+        // Join drafts -> edit_heads (for current head) -> draft_titles (to check staleness)
+        // edit_heads uses resource_type='draft' and resource_did/resource_rkey to link
+        let query = r#"
+            SELECT
+                d.did,
+                d.rkey,
+                h.head_did,
+                h.head_rkey,
+                h.head_cid,
+                h.root_did,
+                h.root_rkey,
+                h.root_cid
+            FROM drafts d FINAL
+            INNER JOIN edit_heads h FINAL
+                ON h.resource_did = d.did
+                AND h.resource_rkey = d.rkey
+                AND h.resource_collection = 'sh.weaver.edit.draft'
+            LEFT JOIN draft_titles t FINAL
+                ON t.did = d.did
+                AND t.rkey = d.rkey
+            WHERE d.deleted_at = toDateTime64(0, 3)
+              AND (t.head_cid IS NULL OR t.head_cid = '' OR t.head_cid != h.head_cid)
+            LIMIT ?
+        "#;
+
+        let rows = self
+            .inner()
+            .query(query)
+            .bind(limit)
+            .fetch_all::<StaleDraftRow>()
+            .await
+            .map_err(|e| ClickHouseError::Query {
+                message: "failed to get stale draft titles".into(),
+                source: e,
+            })?;
+
+        Ok(rows)
+    }
+
+    /// Get the edit chain from head back to root for reconstructing a Loro doc.
+    ///
+    /// Returns nodes in order from root to head (for sequential application).
+    /// Validates that the chain terminates at the expected root.
+    pub async fn get_edit_chain(
+        &self,
+        root_did: &str,
+        root_rkey: &str,
+        head_did: &str,
+        head_rkey: &str,
+    ) -> Result<Vec<EditChainNode>, IndexError> {
+        // Walk backwards from head to root via prev links
+        // Use recursive CTE to traverse the chain, stopping when we hit the expected root
+        let query = r#"
+            WITH RECURSIVE chain AS (
+                -- Start from head
+                SELECT did, rkey, cid, node_type, prev_did, prev_rkey, 0 as depth,
+                       (did = ? AND rkey = ?) as is_root
+                FROM edit_nodes FINAL
+                WHERE did = ? AND rkey = ?
+                  AND deleted_at = toDateTime64(0, 3)
+
+                UNION ALL
+
+                -- Follow prev links until we hit the root
+                SELECT e.did, e.rkey, e.cid, e.node_type, e.prev_did, e.prev_rkey, c.depth + 1,
+                       (e.did = ? AND e.rkey = ?) as is_root
+                FROM edit_nodes e FINAL
+                INNER JOIN chain c ON e.did = c.prev_did AND e.rkey = c.prev_rkey
+                WHERE e.deleted_at = toDateTime64(0, 3)
+                  AND c.is_root = 0  -- stop when we've reached the root
+                  AND c.depth < 1000  -- safety limit
+            )
+            SELECT did, rkey, cid, node_type, prev_did, prev_rkey
+            FROM chain
+            ORDER BY depth DESC  -- root first, then diffs in order
+        "#;
+
+        let rows = self
+            .inner()
+            .query(query)
+            .bind(root_did)
+            .bind(root_rkey)
+            .bind(head_did)
+            .bind(head_rkey)
+            .bind(root_did)
+            .bind(root_rkey)
+            .fetch_all::<EditChainNode>()
+            .await
+            .map_err(|e| ClickHouseError::Query {
+                message: "failed to get edit chain".into(),
+                source: e,
+            })?;
+
+        // Validate chain terminates at expected root
+        if let Some(first) = rows.first() {
+            if first.did != root_did || first.rkey != root_rkey {
+                return Err(ClickHouseError::Query {
+                    message: format!(
+                        "edit chain did not terminate at expected root {}:{}, got {}:{}",
+                        root_did, root_rkey, first.did, first.rkey
+                    ),
+                    source: clickhouse::error::Error::Custom("chain validation failed".into()),
+                }
+                .into());
+            }
+        }
+
+        Ok(rows)
+    }
+
+    /// Upsert a draft title after extraction.
+    pub async fn upsert_draft_title(
+        &self,
+        did: &str,
+        rkey: &str,
+        title: &str,
+        head_did: &str,
+        head_rkey: &str,
+        head_cid: &str,
+    ) -> Result<(), IndexError> {
+        let query = r#"
+            INSERT INTO draft_titles (did, rkey, title, head_did, head_rkey, head_cid)
+            VALUES (?, ?, ?, ?, ?, ?)
+        "#;
+
+        self.inner()
+            .query(query)
+            .bind(did)
+            .bind(rkey)
+            .bind(title)
+            .bind(head_did)
+            .bind(head_rkey)
+            .bind(head_cid)
+            .execute()
+            .await
+            .map_err(|e| ClickHouseError::Query {
+                message: "failed to upsert draft title".into(),
+                source: e,
+            })?;
+
+        Ok(())
     }
 }

crates/weaver-index/src/clickhouse/queries/notebooks.rs

···
                 e.indexed_at AS indexed_at,
                 e.record AS record
             FROM notebook_entries ne FINAL
-            INNER JOIN entries FINAL AS e ON
+            INNER JOIN entries e FINAL ON
                 e.did = ne.entry_did
                 AND e.rkey = ne.entry_rkey
                 AND e.deleted_at = toDateTime64(0, 3)
···
                 e.indexed_at AS indexed_at,
                 e.record AS record
             FROM notebook_entries ne FINAL
-            INNER JOIN entries FINAL AS e ON
+            INNER JOIN entries e FINAL ON
                 e.did = ne.entry_did
                 AND e.rkey = ne.entry_rkey
                 AND e.deleted_at = toDateTime64(0, 3)

crates/weaver-index/src/endpoints/edit.rs

···
 
         let last_edit_at = row.last_edit_at.map(|dt| Datetime::new(dt.fixed_offset()));
 
+        // Include title if available
+        let title = if row.title.is_empty() {
+            None
+        } else {
+            Some(row.title.to_cowstr().into_static())
+        };
+
         drafts.push(
             DraftView::new()
                 .uri(uri)
···
                 .created_at(created_at)
                 .maybe_edit_root(edit_root)
                 .maybe_last_edit_at(last_edit_at)
+                .maybe_title(title)
                 .build(),
         );
     }

crates/weaver-index/src/endpoints/notebook.rs

···
             XrpcErrorResponse::internal_error("Invalid CID stored")
         })?;
 
+        let entry_contributors = state
+            .clickhouse
+            .get_entry_contributors(did_str, &entry_row.rkey)
+            .await
+            .map_err(|e| {
+                tracing::error!("Failed to get entry contributors: {}", e);
+                XrpcErrorResponse::internal_error("Database query failed")
+            })?;
+
+        let mut all_author_dids: HashSet<SmolStr> = entry_contributors.iter().cloned().collect();
+        // Also include author_dids from the record (explicit declarations)
+        for did in &entry_row.author_dids {
+            all_author_dids.insert(did.clone());
+        }
+
+        let author_dids_vec: Vec<SmolStr> = all_author_dids.into_iter().collect();
+
         // Hydrate entry authors
-        let entry_authors = hydrate_authors(&entry_row.author_dids, &profile_map)?;
+        let entry_authors = hydrate_authors(&author_dids_vec, &profile_map)?;
 
         // Parse record JSON
         let entry_record = parse_record_json(&entry_row.record)?;

crates/weaver-index/src/error.rs

···
     #[error(transparent)]
     #[diagnostic(transparent)]
     Sqlite(#[from] SqliteError),
+
+    #[error("resource not found: {resource}")]
+    #[diagnostic(code(index::not_found))]
+    NotFound { resource: String },
 }
 
 /// HTTP server errors

crates/weaver-index/src/lib.rs

···
 pub mod service_identity;
 pub mod sqlite;
 pub mod tap;
+pub mod tasks;
 
 pub use config::Config;
 pub use error::{IndexError, Result};
···
 pub use server::{AppState, ServerConfig};
 pub use service_identity::ServiceIdentity;
 pub use sqlite::{ShardKey, ShardRouter, SqliteShard};
+pub use tasks::{run_draft_title_task, DraftTitleTaskConfig};

crates/weaver-index/src/tasks/draft_titles.rs

···
+//! Background task for extracting draft titles from Loro snapshots.
+//!
+//! Periodically scans for drafts where the edit head has changed since
+//! the last title extraction, fetches the edit chain from PDS, reconstructs
+//! the Loro document, and extracts the title.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use jacquard::client::UnauthenticatedSession;
+use jacquard::identity::JacquardResolver;
+use jacquard::prelude::{IdentityResolver, XrpcExt};
+use jacquard::types::ident::AtIdentifier;
+use jacquard::types::string::{Cid, Did};
+use loro::LoroDoc;
+use mini_moka::sync::Cache;
+use tracing::{debug, error, info, warn};
+
+use crate::clickhouse::{Client, StaleDraftRow};
+use crate::error::IndexError;
+
+use weaver_api::com_atproto::repo::get_record::GetRecord;
+use weaver_api::com_atproto::sync::get_blob::GetBlob;
+use weaver_api::sh_weaver::edit::diff::Diff;
+use weaver_api::sh_weaver::edit::root::Root;
+
+/// Cache for PDS blob fetches.
+///
+/// Blobs are content-addressed so safe to cache indefinitely.
+/// Key is (did, cid) as a string.
+#[derive(Clone)]
+pub struct BlobCache {
+    cache: Cache<String, Arc<Vec<u8>>>,
+}
+
+impl BlobCache {
+    pub fn new(max_capacity: u64) -> Self {
+        Self {
+            cache: Cache::new(max_capacity),
+        }
+    }
+
+    fn key(did: &str, cid: &str) -> String {
+        format!("{}:{}", did, cid)
+    }
+
+    pub fn get(&self, did: &str, cid: &str) -> Option<Arc<Vec<u8>>> {
+        self.cache.get(&Self::key(did, cid))
+    }
+
+    pub fn insert(&self, did: &str, cid: &str, data: Vec<u8>) {
+        self.cache.insert(Self::key(did, cid), Arc::new(data));
+    }
+}
+
+/// Configuration for the draft title extraction task
+#[derive(Debug, Clone)]
+pub struct DraftTitleTaskConfig {
+    /// How often to check for stale titles
+    pub interval: Duration,
+    /// Maximum drafts to process per run
+    pub batch_size: i64,
+}
+
+impl Default for DraftTitleTaskConfig {
+    fn default() -> Self {
+        Self {
+            interval: Duration::from_secs(120), // 2 minutes
+            batch_size: 50,
+        }
+    }
+}
+
+/// Run the draft title extraction task in a loop
+pub async fn run_draft_title_task(
+    client: Arc<Client>,
+    resolver: UnauthenticatedSession<JacquardResolver>,
+    config: DraftTitleTaskConfig,
+) {
+    info!(
+        interval_secs = config.interval.as_secs(),
+        batch_size = config.batch_size,
+        "starting draft title extraction task"
+    );
+
+    // Cache for blob fetches - blobs are content-addressed, safe to cache indefinitely
+    // 1000 entries is plenty for typical edit chains
+    let blob_cache = BlobCache::new(1000);
+
+    loop {
+        match process_stale_drafts(&client, &resolver, &blob_cache, config.batch_size).await {
+            Ok(count) => {
+                if count > 0 {
+                    info!(processed = count, "draft title extraction complete");
+                } else {
+                    debug!("no stale draft titles to process");
+                }
+            }
+            Err(e) => {
+                error!(error = ?e, "draft title extraction failed");
+            }
+        }
+
+        tokio::time::sleep(config.interval).await;
+    }
+}
+
+/// Process a batch of stale drafts
+async fn process_stale_drafts(
+    client: &Client,
+    resolver: &UnauthenticatedSession<JacquardResolver>,
+    blob_cache: &BlobCache,
+    batch_size: i64,
+) -> Result<usize, IndexError> {
+    let stale = client.get_stale_draft_titles(batch_size).await?;
+
+    if stale.is_empty() {
+        return Ok(0);
+    }
+
+    debug!(count = stale.len(), "found stale draft titles");
+
+    let mut processed = 0;
+    for draft in stale {
+        match extract_and_save_title(client, resolver, blob_cache, &draft).await {
+            Ok(title) => {
+                debug!(
+                    did = %draft.did,
+                    rkey = %draft.rkey,
+                    title = %title,
+                    "extracted draft title"
+                );
+                processed += 1;
+            }
+            Err(e) => {
+                warn!(
+                    did = %draft.did,
+                    rkey = %draft.rkey,
+                    error = ?e,
+                    "failed to extract draft title"
+                );
+            }
+        }
+    }
+
+    Ok(processed)
+}
+
+/// Extract title from a single draft and save it
+async fn extract_and_save_title(
+    client: &Client,
+    resolver: &UnauthenticatedSession<JacquardResolver>,
+    blob_cache: &BlobCache,
+    draft: &StaleDraftRow,
+) -> Result<String, IndexError> {
+    // Get the edit chain from ClickHouse
+    let chain = client
+        .get_edit_chain(
+            &draft.root_did,
+            &draft.root_rkey,
+            &draft.head_did,
+            &draft.head_rkey,
+        )
+        .await?;
+
+    if chain.is_empty() {
+        return Err(IndexError::NotFound {
+            resource: format!("edit chain for {}:{}", draft.did, draft.rkey),
+        });
+    }
+
+    // Resolve PDS for the root DID
+    let root_did = Did::new(&draft.root_did).map_err(|e| IndexError::NotFound {
+        resource: format!("invalid root DID: {}", e),
+    })?;
+
+    let pds_url = resolver
+        .pds_for_did(&root_did)
+        .await
+        .map_err(|e| IndexError::NotFound {
+            resource: format!("PDS for {}: {}", root_did, e),
+        })?;
+
+    // Initialize Loro doc
+    let doc = LoroDoc::new();
+
+    // Process chain: first node should be root, rest are diffs
+    for (i, node) in chain.iter().enumerate() {
+        let node_did = Did::new(&node.did).map_err(|e| IndexError::NotFound {
+            resource: format!("invalid node DID: {}", e),
+        })?;
+
+        if node.node_type == "root" {
+            // Fetch root record
+            let root_record =
+                fetch_root_record(resolver, pds_url.clone(), &node_did, &node.rkey).await?;
+
+            // Fetch snapshot blob
+            let snapshot_cid = root_record.snapshot.blob().cid();
+            let snapshot_bytes =
+                fetch_blob(resolver, blob_cache, pds_url.clone(), &node_did, snapshot_cid).await?;
+
+            // Import snapshot
+            doc.import(&snapshot_bytes)
+                .map_err(|e| IndexError::NotFound {
+                    resource: format!("failed to import root snapshot: {}", e),
+                })?;
+
+            debug!(
+                did = %node.did,
+                rkey = %node.rkey,
+                bytes = snapshot_bytes.len(),
+                "imported root snapshot"
+            );
+        } else {
+            // Fetch diff record
+            let diff_record =
+                fetch_diff_record(resolver, pds_url.clone(), &node_did, &node.rkey).await?;
+
+            // Diffs can have inline diff bytes or a snapshot blob reference
+            let diff_bytes = if let Some(ref inline) = diff_record.inline_diff {
+                // Use inline diff (base64 decoded by serde)
+                inline.to_vec()
+            } else if let Some(ref snapshot_blob) = diff_record.snapshot {
+                // Fetch snapshot blob
+                let snapshot_cid = snapshot_blob.blob().cid();
+                fetch_blob(resolver, blob_cache, pds_url.clone(), &node_did, snapshot_cid).await?
+            } else {
+                warn!(
+                    did = %node.did,
+                    rkey = %node.rkey,
+                    "diff has neither inline nor snapshot data, skipping"
+                );
+                continue;
+            };
+
+            // Import diff
+            doc.import(&diff_bytes).map_err(|e| IndexError::NotFound {
+                resource: format!("failed to import diff {}: {}", i, e),
+            })?;
+
+            debug!(
+                did = %node.did,
+                rkey = %node.rkey,
+                bytes = diff_bytes.len(),
+                "imported diff"
+            );
+        }
+    }
+
+    // Extract title from Loro doc
+    let title = doc.get_text("title").to_string();
+
+    // Save to ClickHouse
+    client
+        .upsert_draft_title(
+            &draft.did,
+            &draft.rkey,
+            &title,
+            &draft.head_did,
+            &draft.head_rkey,
+            &draft.head_cid,
+        )
+        .await?;
+
+    Ok(title)
+}
+
+/// Fetch an edit.root record from PDS
+async fn fetch_root_record(
+    resolver: &UnauthenticatedSession<JacquardResolver>,
+    pds_url: jacquard::url::Url,
+    did: &Did<'_>,
+    rkey: &str,
+) -> Result<Root<'static>, IndexError> {
+    use jacquard::IntoStatic;
+    use jacquard::types::string::Nsid;
+
+    let request = GetRecord::new()
+        .repo(AtIdentifier::Did(did.clone()))
+        .collection(Nsid::new_static("sh.weaver.edit.root").unwrap())
+        .rkey(
+            jacquard::types::recordkey::RecordKey::any(rkey).map_err(|e| IndexError::NotFound {
+                resource: format!("invalid rkey: {}", e),
+            })?,
+        )
+        .build();
+
+    let response =
+        resolver
+            .xrpc(pds_url)
+            .send(&request)
+            .await
+            .map_err(|e| IndexError::NotFound {
+                resource: format!("root record {}/{}: {}", did, rkey, e),
+            })?;
+
+    let output = response.into_output().map_err(|e| IndexError::NotFound {
+        resource: format!("parse root record: {}", e),
+    })?;
+
+    let root: Root = jacquard::from_data(&output.value).map_err(|e| IndexError::NotFound {
+        resource: format!("deserialize root: {}", e),
+    })?;
+
+    Ok(root.into_static())
+}
+
+/// Fetch an edit.diff record from PDS
+async fn fetch_diff_record(
+    resolver: &UnauthenticatedSession<JacquardResolver>,
+    pds_url: jacquard::url::Url,
+    did: &Did<'_>,
+    rkey: &str,
+) -> Result<Diff<'static>, IndexError> {
+    use jacquard::IntoStatic;
+    use jacquard::types::string::Nsid;
+
+    let request = GetRecord::new()
+        .repo(AtIdentifier::Did(did.clone()))
+        .collection(Nsid::new_static("sh.weaver.edit.diff").unwrap())
+        .rkey(
+            jacquard::types::recordkey::RecordKey::any(rkey).map_err(|e| IndexError::NotFound {
+                resource: format!("invalid rkey: {}", e),
+            })?,
+        )
+        .build();
+
+    let response =
+        resolver
+            .xrpc(pds_url)
+            .send(&request)
+            .await
+            .map_err(|e| IndexError::NotFound {
+                resource: format!("diff record {}/{}: {}", did, rkey, e),
+            })?;
+
+    let output = response.into_output().map_err(|e| IndexError::NotFound {
+        resource: format!("parse diff record: {}", e),
+    })?;
+
+    let diff: Diff = jacquard::from_data(&output.value).map_err(|e| IndexError::NotFound {
+        resource: format!("deserialize diff: {}", e),
+    })?;
+
+    Ok(diff.into_static())
+}
+
+/// Fetch a blob from PDS, using cache when available
+async fn fetch_blob(
+    resolver: &UnauthenticatedSession<JacquardResolver>,
+    cache: &BlobCache,
+    pds_url: jacquard::url::Url,
+    did: &Did<'_>,
+    cid: &Cid<'_>,
+) -> Result<Vec<u8>, IndexError> {
+    // Check cache first - blobs are content-addressed
+    if let Some(cached) = cache.get(did.as_str(), cid.as_str()) {
+        debug!(cid = %cid, "blob cache hit");
+        return Ok(cached.as_ref().clone());
+    }
+
+    let request = GetBlob::new().did(did.clone()).cid(cid.clone()).build();
+
+    let response =
+        resolver
+            .xrpc(pds_url)
+            .send(&request)
+            .await
+            .map_err(|e| IndexError::NotFound {
+                resource: format!("blob {}: {}", cid, e),
+            })?;
+
+    let bytes = response.buffer().to_vec();
+
+    // Cache for future use
+    cache.insert(did.as_str(), cid.as_str(), bytes.clone());
+
+    Ok(bytes)
+}

crates/weaver-index/src/tasks/mod.rs

···
+//! Background tasks for the indexer
+
+mod draft_titles;
+
+pub use draft_titles::{run_draft_title_task, DraftTitleTaskConfig};

weaver_notes/.obsidian/workspace.json

···
             "state": {
               "type": "markdown",
               "state": {
-                "file": "Writing the AppView Last.md",
+                "file": "Untitled.md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "Writing the AppView Last"
+              "title": "Untitled"
             }
           }
         ],
···
       "bases:Create new base": false
     }
   },
-  "active": "6029beecc3d03bce",
+  "active": "2f6bdb6d2dce13ed",
   "lastOpenFiles": [
+    "cargo_bloated.png",
+    "Writing the AppView Last.md",
+    "Untitled.md",
     "weaver_index_html.png",
     "2025-12-14T23:32:19.png",
     "diff_record.png",
     "Why I rewrote pdsls in Rust (tm).md",
-    "Writing the AppView Last.md",
     "light_mode_excerpt.png",
     "notebook_entry_preview.png",
     "xkcd_345_excerpt.png",
···
     "Pasted image 20251114125028.png",
     "invalid_record.png",
     "Pasted image 20251114125031.png",
-    "Pasted image 20251114121431.png",
     "Arch.md",
     "Weaver - Long-form writing.md"
   ]

weaver_notes/Untitled.md

···
+I recently used Jacquard to write an ~AppView~ Index for Weaver. I alluded in my posts about my devlog about that experience how easy I had made the actual web server side of that. Lexicon as a specification language provides a lot of ways to specify data types and a few to specify API endpoints. XRPC is the canonical way to do that, and it's an opinionated subset of HTTP, which narrows down to a specific endpoint format and set of "verbs". Your path is `/xrpc/your.lexicon.nsidEndpoint?argument=value`, your bodies are mostly JSON. 
+
+I'm going to lead off by tooting someone else's horn. Chad Miller's https://quickslice.slices.network/ provides an excellent example of the kind of thing you can do with atproto lexicons, and it doesn't use XRPC at all, but instead generates GraphQL's equivalents. This is more freeform, requires less of you upfront, and is in a lot of ways more granular than XRPC could possibly allow. Jacquard is for the moment built around the expectations of XRPC. If someone want's Jacquard support for GraphQL on atproto lexicons, I'm all ears, though.
+
+Here's to me one of the benefits of XRPC, and one of the challenges. XRPC only specifies your inputs and your output. everything else between you need to figure out. This means more work, but it also means you have internal flexibility. And Jacquard's server-side XRPC helpers follow that. Jacquard XRPC code generation itself provides the output type and the errors. For the server side it generates one additional marker type, generally labeled `YourXrpcQueryRequest`, and a trait implementation for `XrpcEndpoint`. You can also get these with `derive(XrpcRequest)` on existing Rust structs without writing out lexicon JSON.
+
+```rust
+pub trait XrpcEndpoint {
+    /// Fully-qualified path ('/xrpc/\[nsid\]') where this endpoint should live on the server
+    const PATH: &'static str;
+    /// XRPC method (query/GET or procedure/POST)
+    const METHOD: XrpcMethod;
+    /// XRPC Request data type
+    type Request<'de>: XrpcRequest + Deserialize<'de> + IntoStatic;
+    /// XRPC Response data type
+    type Response: XrpcResp;
+}
+
+/// Endpoint type for
+///sh.weaver.actor.getActorNotebooks
+pub struct GetActorNotebooksRequest;
+impl XrpcEndpoint for GetActorNotebooksRequest {
+    const PATH: &'static str = "/xrpc/sh.weaver.actor.getActorNotebooks";
+    const METHOD: XrpcMethod = XrpcMethod::Query;
+    type Request<'de> = GetActorNotebooks<'de>;
+    type Response = GetActorNotebooksResponse;
+}
+```
+
+As with many Jacquard traits you see the associated types carrying the lifetime. You may ask, why a second struct and trait? This is very similar to the `XrpcRequest` trait, which is implemented on the request struct itself, after all.
+
+```rust
+impl<'a> XrpcRequest for GetActorNotebooks<'a> {
+    const NSID: &'static str = "sh.weaver.actor.getActorNotebooks";
+    const METHOD: XrpcMethod = XrpcMethod::Query;
+    type Response = GetActorNotebooksResponse;
+}
+```
+
+## Time for magic
+The reason is that lifetime when combined with the constraints Axum puts on extractors.  Because the request type includes a lifetime, if we were to attempt to implement `FromRequest` directly for `XrpcRequest`, the trait would require that `XrpcRequest` be implemented for all lifetimes, and also apply an effective `DeserializeOwned` bound, even if we were to specify the `'static` lifetime as we do. And of course `XrpcRequest` is implemented for one specific lifetime, `'a`, the lifetime of whatever it's borrowed from. Meanwhile `XrpcEndpoint` has no lifetime itself, but instead carries the lifetime on the `Request` associated type. This allows us to do the following implementation, where `ExtractXrpc<E>` has no lifetime itself and contains an owned version of the deserialized request. And we can then implement `FromRequest` for `ExtractXrpc<R>`, and put the `for<'any>` bound on the `IntoStatic` trait requirement in a where clause, where it works perfectly. In combination with the code generation in `jacquard-lexicon`, this is the full implementation of Jacquard's Axum XRPC request extractor. Not so bad.
+
+```rust
+pub struct ExtractXrpc<E: XrpcEndpoint>(pub E::Request<'static>);
+
+impl<S, R> FromRequest<S> for ExtractXrpc<R>
+where
+    S: Send + Sync,
+    R: XrpcEndpoint,
+    for<'a> R::Request<'a>: IntoStatic<Output = R::Request<'static>>,
+{
+    type Rejection = Response;
+
+    fn from_request(
+        req: Request,
+        state: &S,
+    ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send {
+	    async {
+            match R::METHOD {
+                XrpcMethod::Procedure(_) => {
+                    let body = Bytes::from_request(req, state)
+                        .await
+                        .map_err(IntoResponse::into_response)?;
+                    let decoded = R::Request::decode_body(&body);
+                    match decoded {
+                        Ok(value) => Ok(ExtractXrpc(*value.into_static())),
+                        Err(err) => Err((
+                            StatusCode::BAD_REQUEST,
+                            Json(json!({
+                                "error": "InvalidRequest",
+                                "message": format!("failed to decode request: {}", err)
+                            })),
+                        ).into_response()),
+                    }
+                }
+                XrpcMethod::Query => {
+                    if let Some(path_query) = req.uri().path_and_query() {
+                        let query = path_query.query().unwrap_or("");
+                        let value: R::Request<'_> =
+                            serde_html_form::from_str::<R::Request<'_>>(query).map_err(|e| {
+                                (
+                                    StatusCode::BAD_REQUEST,
+                                    Json(json!({
+                                        "error": "InvalidRequest",
+                                        "message": format!("failed to decode request: {}", e)
+                                    })),
+                                ).into_response()
+                            })?;
+                        Ok(ExtractXrpc(value.into_static()))
+                    } else {
+                        Err((
+                            StatusCode::BAD_REQUEST,
+                            Json(json!({
+                                "error": "InvalidRequest",
+                                "message": "wrong path"
+                            })),
+                        ).into_response())
+                    }
+                }
+            }
+        }
+    }
+```
+
+Jacquard then also provides an additional utility to round things out, using the associated `PATH` constant to put the handler for your XRPC request at the right spot in your router.
+```rust
+/// Conversion trait to turn an XrpcEndpoint and a handler into an axum Router
+pub trait IntoRouter {
+    fn into_router<T, S, U>(handler: U) -> Router<S>
+    where
+        T: 'static,
+        S: Clone + Send + Sync + 'static,
+        U: axum::handler::Handler<T, S>;
+}
+
+impl<X> IntoRouter for X
+where
+    X: XrpcEndpoint,
+{
+    /// Creates an axum router that will invoke `handler` in response to xrpc
+    /// request `X`.
+    fn into_router<T, S, U>(handler: U) -> Router<S>
+    where
+        T: 'static,
+        S: Clone + Send + Sync + 'static,
+        U: axum::handler::Handler<T, S>,
+    {
+        Router::new().route(
+            X::PATH,
+            (match X::METHOD {
+                XrpcMethod::Query => axum::routing::get,
+                XrpcMethod::Procedure(_) => axum::routing::post,
+            })(handler),
+        )
+    }
+}
+```
+
+Which then lets the Axum router for Weaver's Index look like this (truncated for length):
+
+```rust
+pub fn router(state: AppState, did_doc: DidDocument<'static>) -> Router {
+    Router::new()
+        .route("/", get(landing))
+        .route(
+            "/assets/IoskeleyMono-Regular.woff2",
+            get(font_ioskeley_regular),
+        )
+        .route("/assets/IoskeleyMono-Bold.woff2", get(font_ioskeley_bold))
+        .route(
+            "/assets/IoskeleyMono-Italic.woff2",
+            get(font_ioskeley_italic),
+        )
+        .route("/xrpc/_health", get(health))
+        .route("/metrics", get(metrics))
+        // com.atproto.identity.* endpoints
+        .merge(ResolveHandleRequest::into_router(identity::resolve_handle))
+        // com.atproto.repo.* endpoints (record cache)
+        .merge(GetRecordRequest::into_router(repo::get_record))
+        .merge(ListRecordsRequest::into_router(repo::list_records))
+        // app.bsky.* passthrough endpoints
+        .merge(BskyGetProfileRequest::into_router(bsky::get_profile))
+        .merge(BskyGetPostsRequest::into_router(bsky::get_posts))
+        // sh.weaver.actor.* endpoints
+        .merge(GetProfileRequest::into_router(actor::get_profile))
+        .merge(GetActorNotebooksRequest::into_router(
+            actor::get_actor_notebooks,
+        ))
+        .merge(GetActorEntriesRequest::into_router(
+            actor::get_actor_entries,
+        ))
+        // sh.weaver.notebook.* endpoints
+        ...
+        // sh.weaver.collab.* endpoints
+        ...
+        // sh.weaver.edit.* endpoints
+        ...
+        .layer(TraceLayer::new_for_http())
+		.layer(CorsLayer::permissive()
+			.max_age(std::time::Duration::from_secs(86400))
+		).with_state(state)
+        .merge(did_web_router(did_doc))
+}
+```
+
+Each of the handlers is a fairly straightforward async function that takes `AppState`, the XrpcExtractor, and an extractor and validator for service auth, which allows it to be accessed through via your PDS via the `atproto-proxy` header, and return user-specific data, or gate specific endpoints as requiring authentication.
+
+> And so yeah, the actual HTTP server part of the index was dead-easy to write. The handlers themselves are some of them fairly *long* functions, as they need to pull together the required data from the database over a couple of queries and then do some conversion, but they're straightforward. At some point I may end up either adding additional specialized view tables to the database or rewriting my queries to do more in SQL or both, but for now it made sense to keep the final decision-making and assembly in Rust, where it's easier to iterate on.
+### Service Auth
+Service Auth is, for those not familiar, the non-OAuth way to talk to an XRPC server other than your PDS with an authenticated identity. It's the method the Bluesky AppView uses. There are some downsides to proxying through the PDS, like delay in being able to read your own writes without some PDS-side or app-level handling, but it is conceptually very simple. The PDS, when it pipes through an XRPC request to another service, validates authentication, then generates a short-lived JWT, signs it with the user's private key, and puts it in a header. The service then extracts that, decodes it, and validates it using the public key in the user's DID document. Jacquard provides a middleware that can be used to gate routes based on service auth validation and it also provides an extractor. Initially I provided just one where authentication is required, but as part of building the index I added an additional one for optional authentication, where the endpoint is public, but returns user-specific information when there is an authenticated user. It returns this structure.
+
+```rust
+#[derive(Debug, Clone, jacquard_derive::IntoStatic)]
+pub struct VerifiedServiceAuth<'a> {
+    /// The authenticated user's DID (from `iss` claim)
+    did: Did<'a>,
+    /// The audience (should match your service DID)
+    aud: Did<'a>,
+    /// The lexicon method NSID, if present
+    lxm: Option<Nsid<'a>>,
+    /// JWT ID (nonce), if present
+    jti: Option<CowStr<'a>>,
+}
+```
+
+Ultimately I want to provide a similar set of OAuth extractors as well, but those need to be built, still. If I move away from service proxying for the Weaver index, they will definitely get written at that point.
+
+> I mentioned some bug-fixing in Jacquard was required to make this work. There were a couple of oversights in the `DidDocument` struct and a spot I had incorrectly held a tracing span across an await point. Also, while using the `slingshot_resolver` set of options for `JacquardResolver` is great under normal circumstances (and normally I default to it), the mini-doc does NOT in fact include the signing keys, and cannot be used to validate service auth. 
+> 
+> I am not always a smart woman.
+
+## Why not go full magic?
+One thing the Jacquard service auth validation extractor does **not** provide is validation of that jti nonce. That is left as an exercise for the server developer, to maintain a cache of recent nonces and compare against them. I leave a number of things this way, and this is deliberate. I think this is the correct approach. As powerful as "magic" all-in-one frameworks like Dioxus (or the various full-stack JS frameworks) are, the magic usually ends up constraining you in a number of ways. There are a number of awkward things in the front-end app implementation which are downstream of constraints Dioxus applies to your types and functions in order to work its magic.
+
+There are a lot of possible things you might want to do as an XRPC server. You might be a PDS, you might be an AppView or index, you might be some other sort of service that doesn't really fit into the boxes (like a Tangled knot server or Streamplace node) you might authenticate via service auth or OAuth, communicate via the PDS or directly with the client app. And as such, while my approach to everything in Jacquard is to provide a comprehensive box of tools rather than a complete end-to-end solution, this is especially true on the server side of things, because of that diversity in requirements, and my desire to not constrain developers using the library to work a certain way, so that they can build anything they want on atproto.
+
+> If you haven't read the Not An AppView entry, here it is. I might recommend reading it, and some other previous entries in that notebook, as it will help put the following in context. 
+ 
+![[at://did:plc:yfvwmnlztr4dwkb7hwz55r2g/sh.weaver.notebook.entry/3m7ysqf2z5s22]]
+## Dogfooding again
+That being said, my experience writing the Weaver front-end and now the index server does leave me wanting a few things. One is a "BFF" session type, which forwards requests through a server to the PDS (or index), acting somewhat like [oatproxy](https://github.com/streamplace/oatproxy) (prototype jacquard version of that [here](https://github.com/espeon/istat/tree/main/jacquard-oatproxy) courtesy of Nat and Claude). This allows easier reading of your own writes via server-side caching, some caching and deduplication of common requests to reduce load on the PDS and roundtrip time. If the seession lives server-side it allows longer-lived confidential sessions for OAuth, and avoids putting OAuth tokens on the client device. 
+
+Once implemented, I will likely refactor the Weaver app to use this session type in fullstack-server mode, which will then help dramatically simplify a bunch of client-side code. The refactored app will likely include an internal XRPC "server" of sorts that will elide differences between the index's XRPC APIs and the index-less flow. With the "fullstack-server" and "use-index" features, the client app running in the browser will forward authenticated requests through the app server to the index or PDS. With "fullstack-server" only, the app server itself acts like a discount version of the index, implemented via generic services like Constellation. Performance will be significantly improved over the original index-less implementation due to better caching, and unifying the cache. In client-only mode there are a couple of options, and I am not sure which is ultimately correct. The straightforward way as far as separation of concerns goes would be to essentially use a web worker as intermediary and local cache. That worker would be compiled to either use the index or to make Constellation and direct PDS requests, depending on the "use-index" feature. However that brings with it the obvious overhead of copying data from the worker to the app in the default mode, and I haven't yet investigated how feasible the available options which might allow zero-copy transfer via SharedArrayBuffer are. That being said, the real-time collaboration feature already works this way (sans SharedArrayBuffer) and lag is comparable to when the iroh connection was handled in the UI thread.
+
+A fair bit of this is somewhat new territory for me, when it comes to the browser, and I would be ***very*** interested in hearing from people with more domain experience on the likely correct approach. 
+
+On that note, one of my main frustrations with Jacquard as a library is how heavy it is in terms of compiled binary size due to monomorphization. I made that choice, to do everything via static dispatch, but when you want to ship as small a binary as possible over the network, it works against you. On WASM I haven't gotten a great number of exactly the granular damage, but on x86_64 (albeit with less aggressive optimisation for size) we're talking kilobytes of pure duplicated functions for every jacquard type used in the application, plus whatever else.
+```rust
+0.0%   0.0%  9.3KiB        weaver_app weaver_app::components::editor::sync::create_diff::{closure#0}
+0.0%   0.0%  9.2KiB     loro_internal <loro_internal::txn::Transaction>::_commit
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Fetcher as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::collab::invite::Invite>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Fetcher as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::actor::profile::ProfileRecord>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Fetcher as jacquard::client::AgentSessionExt>::get_record::<weaver_api::app_bsky::actor::profile::ProfileRecord>::{closure#0}
+0.0%   0.0%  9.2KiB   weaver_renderer <jacquard_identity::JacquardResolver as jacquard_identity::resolver::IdentityResolver>::resolve_did_doc::{closure#0}::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::notebook::theme::Theme>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::notebook::entry::Entry>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::notebook::book::Book>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::notebook::colour_scheme::ColourScheme>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::actor::profile::ProfileRecord>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::edit::draft::Draft>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::edit::root::Root>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::sh_weaver::edit::diff::Diff>::{closure#0}
+0.0%   0.0%  9.2KiB        weaver_app <weaver_app::fetch::Client as jacquard::client::AgentSessionExt>::get_record::<weaver_api::app_bsky::actor::profile::ProfileRecord>::{closure#0}
+0.0%   0.0%  9.2KiB             resvg <image_webp::vp8::Vp8Decoder<std::io::Take<&mut std::io::cursor::Cursor<&[u8]>>>>::loop_filter
+0.0%   0.0%  9.2KiB            miette <miette::handlers::graphical::GraphicalReportHandler>::render_context::<alloc::string::String>
+0.0%   0.0%  9.1KiB            miette <miette::handlers::graphical::GraphicalReportHandler>::render_context::<core::fmt::Formatter>
+0.0%   0.0%  9.1KiB        weaver_app weaver_app::components::record_editor::EditableRecordContent::{closure#7}::{closure#0}
+```
+
+I've taken a couple stabs at refactors to help with this, but haven't found a solution that satisfies me, in part because one of the problems in practice is of course overhead from `serde_json` monomorphization. Unfortunately, the alternatives trade off in frustrating ways. [`facet`](https://github.com/facet-rs/facet) has its own binary size impacts and `facet-json` is missing a couple of critical features to work with atproto JSON data (internally-tagged enums, most notably). Something like [`simd-json`](https://github.com/simd-lite/simd-json) or [`serde_json_borrow`](https://github.com/PSeitz/serde_json_borrow) is fast and can borrow from the buffer in a way that is very useful to us (and honestly I intend to swap to them for some uses at some point), but `serde_json_borrow` only provides a value type, and I would then be uncertain at the monomorphization overhead of transforming that type into jacquard types. The `serde` implementation for `simd-json` is heavily based on `serde_json` and thus likely has much the same overhead problem. And [`miniserde`](https://github.com/dtolnay/miniserde) similarly lacks support for parts of JSON that atproto data requires (enums again). And writing my own custom JSON parser that deserializes into Jacquard's `Data` or `RawData` types (from where it can then be deserialized more simply into concrete types, ideally with much less code duplication) is not a project I have time for, and is on the tedious side of the kind of thing I enjoy, particularly the process of ensuring it is sufficiently robust for real-world use, and doesn't perform terribly.
+
+`dyn` compatibility for some of the Jacquard traits is possible but comes with its own challenges, as currently `Serialize` is a supertrait of `XrpcRequest`, and rewriting around removing that bound that is both a nontrivial refactor (and a breaking API change, and it's not the only barrier to dyn compatibility) and may not actually reduce the number of copies of `get_record()` in the binary as much as one would hope. Now, if most of the code could be taken out of that and put into a function that could be totally shared between all implementations or at least most, that would be ideal but the solution I found prevented the compiler from inferring the output type from the request type, it decoupled those two things too much. Obviously if I were to do a bunch of cursed internal unsafe rust I could probably make this work, but while I'm comfortable writing unsafe Rust I'm also conscious that I'm writing Jacquard not just for myself. My code will run in situations I cannot anticipate, and it needs to be as reliable as possible and as usable as possible. Additional use of unsafe could help with the latter (laundering lifetimes would make a number of things in Jacquard's main code paths much easier, both for me and for users of the library) but at potential cost to the former if I'm not smart enough or comprehensive enough in my testing.
+
+So I leave you, dear reader, with some questions this time. 
+
+What choices make sense here? For Jacquard as a library, for writing web applications in Rust, and so on. I'm pretty damn good at this (if I do say so myself, and enough other people agree that I must accept it), but I'm also one person, with a necessarily incomplete understanding of the totality of the field.