bunch of fixes, maybe starting CRDT stuff

Cargo.lock

···
 checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
+ "getrandom 0.3.4",
  "once_cell",
  "version_check",
  "zerocopy",
···
 checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
+name = "append-only-bytes"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac436601d6bdde674a0d7fb593e829ffe7b3387c351b356dd20e2d40f5bf3ee5"
+
+[[package]]
 name = "ar_archive_writer"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
 name = "arraydeque"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "arref"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ccd462b64c3c72f1be8305905a85d85403d768e8690c9b8bd3b9009a5761679"
 
 [[package]]
 name = "ascii"
···
 ]
 
 [[package]]
+name = "bitmaps"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
 name = "block"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77e9d642a7e3a318e37c2c9427b5a6a48aa1ad55dcd986f3034ab2239045a645"
 dependencies = [
- "darling",
+ "darling 0.21.3",
  "ident_case",
  "prettyplease",
  "proc-macro2",
···
 
 [[package]]
 name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core 0.20.11",
+ "darling_macro 0.20.11",
+]
+
+[[package]]
+name = "darling"
 version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
 dependencies = [
- "darling_core",
- "darling_macro",
+ "darling_core 0.21.3",
+ "darling_macro 0.21.3",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.110",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core 0.20.11",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "darling_macro"
 version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
- "darling_core",
+ "darling_core 0.21.3",
  "quote",
  "syn 2.0.110",
 ]
···
 ]
 
 [[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
 name = "derive_more"
 version = "0.99.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "syn 2.0.110",
 ]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
 [[package]]
 name = "digest"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd122633e4bef06db27737f21d3738fb89c8f6d5360d6d9d7635dda142a7757e"
 dependencies = [
- "darling",
+ "darling 0.21.3",
  "either",
  "heck 0.5.0",
  "proc-macro2",
···
 checksum = "a3d8a32ae18130a3c84dd492d4215c3d913c3b07c6b63c2eb3eb7ff1101ab7bf"
 
 [[package]]
+name = "ensure-cov"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33753185802e107b8fa907192af1f0eca13b1fb33327a59266d650fef29b2b4e"
+
+[[package]]
+name = "enum-as-inner"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
 name = "enum-as-inner"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
 dependencies = [
  "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "enum_dispatch"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
+dependencies = [
+ "once_cell",
  "proc-macro2",
  "quote",
  "syn 2.0.110",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f43e744e4ea338060faee68ed933e46e722fb7f3617e722a5772d7e856d8b3ce"
 dependencies = [
- "darling",
+ "darling 0.21.3",
  "proc-macro2",
  "quote",
  "syn 2.0.110",
···
 ]
 
 [[package]]
+name = "generic-btree"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c1bce85c110ab718fd139e0cc89c51b63bd647b14a767e24bdfc77c83df79b"
+dependencies = [
+ "arref",
+ "heapless 0.9.2",
+ "itertools 0.11.0",
+ "loro-thunderdome",
+ "proc-macro2",
+ "rustc-hash 2.1.1",
+]
+
+[[package]]
 name = "gethostname"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
 dependencies = [
  "atomic-polyfill",
- "hash32",
+ "hash32 0.2.1",
  "rustc_version",
  "serde",
  "spin 0.9.8",
···
 ]
 
 [[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32 0.3.1",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heapless"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af2455f757db2b292a9b1768c4b70186d443bcb3b316252d6b540aec1cd89ed"
+dependencies = [
+ "hash32 0.3.1",
+ "stable_deref_trait",
+]
+
+[[package]]
 name = "heck"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "async-trait",
  "cfg-if",
  "data-encoding",
- "enum-as-inner",
+ "enum-as-inner 0.6.1",
  "futures-channel",
  "futures-io",
  "futures-util",
···
 ]
 
 [[package]]
+name = "im"
+version = "15.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0acd33ff0285af998aaf9b57342af478078f53492322fafc47450e09397e0e9"
+dependencies = [
+ "bitmaps",
+ "rand_core 0.6.4",
+ "rand_xoshiro",
+ "serde",
+ "sized-chunks",
+ "typenum",
+ "version_check",
+]
+
+[[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
+name = "itertools"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
 name = "itoa"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
+[[package]]
 name = "libappindicator"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "cfg-if",
  "generator",
  "scoped-tls",
+ "serde",
+ "serde_json",
  "tracing",
  "tracing-subscriber",
 ]
 
 [[package]]
+name = "loro"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "546b01ae9bb635853dc8beacfc74a7eb5d0b90cdfdb9c63175cdc1e319fae414"
+dependencies = [
+ "enum-as-inner 0.6.1",
+ "generic-btree",
+ "loro-common",
+ "loro-delta",
+ "loro-internal",
+ "loro-kv-store",
+ "rustc-hash 2.1.1",
+ "tracing",
+]
+
+[[package]]
+name = "loro-common"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d354299916ca5b8b50a14d9b6bc04943477f5ac5ad6a1351a99eae25a4bb3fd8"
+dependencies = [
+ "arbitrary",
+ "enum-as-inner 0.6.1",
+ "leb128",
+ "loro-rle",
+ "nonmax",
+ "rustc-hash 2.1.1",
+ "serde",
+ "serde_columnar",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "loro-delta"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eafa788a72c1cbf0b7dc08a862cd7cc31b96d99c2ef749cdc94c2330f9494d3"
+dependencies = [
+ "arrayvec",
+ "enum-as-inner 0.5.1",
+ "generic-btree",
+ "heapless 0.8.0",
+]
+
+[[package]]
+name = "loro-internal"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824ea2d4a3bb4e9d95d145b6d539509d7988a12b9e5e54d20956722d719af17b"
+dependencies = [
+ "append-only-bytes",
+ "arref",
+ "bytes",
+ "either",
+ "ensure-cov",
+ "enum-as-inner 0.6.1",
+ "enum_dispatch",
+ "generic-btree",
+ "getrandom 0.2.16",
+ "im",
+ "itertools 0.12.1",
+ "leb128",
+ "loom",
+ "loro-common",
+ "loro-delta",
+ "loro-kv-store",
+ "loro-rle",
+ "loro_fractional_index",
+ "md5",
+ "nonmax",
+ "num",
+ "num-traits",
+ "once_cell",
+ "parking_lot",
+ "pest",
+ "pest_derive",
+ "postcard",
+ "pretty_assertions",
+ "rand 0.8.5",
+ "rustc-hash 2.1.1",
+ "serde",
+ "serde_columnar",
+ "serde_json",
+ "smallvec",
+ "thiserror 1.0.69",
+ "thread_local",
+ "tracing",
+ "wasm-bindgen",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "loro-kv-store"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "849d246b5791e97cf37f1bbd54ad7885f128b690ee3a634ee89cf52a1930fb88"
+dependencies = [
+ "bytes",
+ "ensure-cov",
+ "loro-common",
+ "lz4_flex",
+ "once_cell",
+ "quick_cache",
+ "rustc-hash 2.1.1",
+ "tracing",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "loro-rle"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76400c3eea6bb39b013406acce964a8db39311534e308286c8d8721baba8ee20"
+dependencies = [
+ "append-only-bytes",
+ "num",
+ "smallvec",
+]
+
+[[package]]
+name = "loro-thunderdome"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f3d053a135388e6b1df14e8af1212af5064746e9b87a06a345a7a779ee9695a"
+
+[[package]]
+name = "loro_fractional_index"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427c8ea186958094052b971fe7e322a934b034c3bf62f0458ccea04fcd687ba1"
+dependencies = [
+ "once_cell",
+ "rand 0.8.5",
+ "serde",
+]
+
+[[package]]
 name = "lru"
 version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "lz4_flex"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a"
+dependencies = [
+ "twox-hash",
+]
 
 [[package]]
 name = "mac"
···
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 
 [[package]]
 name = "mediatype"
···
 ]
 
 [[package]]
+name = "nonmax"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51"
+
+[[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
 name = "num-bigint"
 version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
 name = "num-traits"
 version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
+name = "pest"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbcfd20a6d4eeba40179f05735784ad32bdaef05ce8e8af05f180d45bb3e7e22"
+dependencies = [
+ "memchr",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51f72981ade67b1ca6adc26ec221be9f463f2b5839c7508998daa17c23d94d7f"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dee9efd8cdb50d719a80088b76f81aec7c41ed6d522ee750178f83883d271625"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf1d70880e76bdc13ba52eafa6239ce793d85c8e43896507e43dd8984ff05b82"
+dependencies = [
+ "pest",
+ "sha2",
+]
+
+[[package]]
 name = "phf"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "cobs",
  "embedded-io 0.4.0",
  "embedded-io 0.6.1",
- "heapless",
+ "heapless 0.7.17",
  "serde",
 ]
 
···
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
+dependencies = [
+ "diff",
+ "yansi",
+]
 
 [[package]]
 name = "prettyplease"
···
 ]
 
 [[package]]
+name = "quick_cache"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ada44a88ef953a3294f6eb55d2007ba44646015e18613d2f213016379203ef3"
+dependencies = [
+ "ahash",
+ "equivalent",
+ "hashbrown 0.16.1",
+ "parking_lot",
+]
+
+[[package]]
 name = "quinn"
 version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
 dependencies = [
  "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_xoshiro"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+dependencies = [
+ "rand_core 0.6.4",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "serde_columnar"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a16e404f17b16d0273460350e29b02d76ba0d70f34afdc9a4fa034c97d6c6eb"
+dependencies = [
+ "itertools 0.11.0",
+ "postcard",
+ "serde",
+ "serde_columnar_derive",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "serde_columnar_derive"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45958fce4903f67e871fbf15ac78e289269b21ebd357d6fecacdba233629112e"
+dependencies = [
+ "darling 0.20.11",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.110",
+]
+
+[[package]]
 name = "serde_core"
 version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08a72d8216842fdd57820dc78d840bef99248e35fb2554ff923319e60f2d686b"
 dependencies = [
- "darling",
+ "darling 0.21.3",
  "proc-macro2",
  "quote",
  "syn 2.0.110",
···
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
+name = "sized-chunks"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
+dependencies = [
+ "bitmaps",
+ "typenum",
+]
+
+[[package]]
 name = "slab"
 version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "smartstring"
···
 ]
 
 [[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
 name = "typed-arena"
 version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
 [[package]]
 name = "uds_windows"
···
  "js-sys",
  "jumprope",
  "lol_alloc",
+ "loro",
  "markdown-weaver",
  "markdown-weaver-escape",
  "mime-sniffer",

crates/weaver-app/Cargo.toml

···
 tracing.workspace = true
 serde_ipld_dagcbor = { version = "0.6" }
 jumprope = { version = "1.1", features = ["wchar_conversion"] }
+loro = "1.9.1"
 markdown-weaver-escape = { workspace = true }
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
···
 chrono = { version = "0.4", features = ["wasmbind"] }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3", features = ["ServiceWorkerContainer", "ServiceWorker", "ServiceWorkerRegistration", "RegistrationOptions", "Window", "Navigator", "MessageEvent", "console", "Document", "Element", "HtmlImageElement", "Selection", "Range", "Node", "HtmlElement", "TreeWalker", "NodeFilter"] }
+web-sys = { version = "0.3", features = ["ServiceWorkerContainer", "ServiceWorker", "ServiceWorkerRegistration", "RegistrationOptions", "Window", "Navigator", "MessageEvent", "console", "Document", "Element", "HtmlImageElement", "Selection", "Range", "Node", "HtmlElement", "TreeWalker", "NodeFilter", "DomTokenList"] }
 js-sys = "0.3"
 gloo-storage = "0.3"
 gloo-timers = "0.3"

crates/weaver-app/assets/styling/editor.css

···
     opacity: 0.6;
 }
 
-.md-syntax-inline:[hidden] {
-    color: var(--color-muted);
-    opacity: 0.6;
-    width: 0;
-    user-select: none; /* idk if we want this when its hidden or not */
-}
-
 /* Markdown syntax characters - block level (#, >, -, etc) */
 .md-syntax-block {
     color: var(--color-muted);
     opacity: 0.7;
-    width: 0;
     font-weight: normal;
 }
 
-.md-syntax-block:[hidden] {
-    content: attr(data-syntax);
-    display: inline-block;
-    margin-right: 4px;
-    user-select: none; /* idk if we want this when its hidden or not */
+/* Hidden syntax spans - collapsed when cursor is not near */
+.md-syntax-inline.hidden,
+.md-syntax-block.hidden {
+    display: none;
+}
+
+/* Hide HTML list markers when markdown syntax is visible (not hidden) */
+/* This prevents double bullets/numbers when showing "- " or "1. " */
+li:has(.md-syntax-block:not(.hidden)) {
+    list-style-type: none;
 }
 
 /* Cursor positioning helper after <br> */
···
     line-height: 1em;
     vertical-align: baseline;
 }
-
-/* Future: contextual hiding based on cursor position */
-/* .cursor-active .md-syntax-inline { display: none; } */

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

···
 mod rope_writer;
 mod storage;
 mod toolbar;
+mod visibility;
 mod writer;
 
 #[cfg(test)]
···
 pub use formatting::{FormatAction, apply_formatting, find_word_boundaries};
 pub use offset_map::{OffsetMapping, RenderResult, find_mapping_for_byte};
 pub use paragraph::ParagraphRender;
-pub use render::{RenderCache, render_paragraphs, render_paragraphs_incremental};
+pub use render::{RenderCache, render_paragraphs_incremental};
 pub use rope_writer::RopeWriter;
 pub use storage::{EditorSnapshot, clear_storage, load_from_storage, save_to_storage};
 pub use toolbar::EditorToolbar;
-pub use writer::WriterResult;
+pub use visibility::VisibilityState;
+pub use writer::{SyntaxSpanInfo, SyntaxType, WriterResult};
 
 use dioxus::prelude::*;
 
···
             .collect::<Vec<_>>()
     });
 
+    // Flatten syntax spans from all paragraphs
+    let syntax_spans = use_memo(move || {
+        paragraphs()
+            .iter()
+            .flat_map(|p| p.syntax_spans.iter().cloned())
+            .collect::<Vec<_>>()
+    });
+
     // Cache paragraphs for change detection AND for event handlers to access
     let mut cached_paragraphs = use_signal(|| Vec::<ParagraphRender>::new());
 
···
         }
 
         // Store for next comparison AND for event handlers (write-only, no reactive read)
-        cached_paragraphs.set(new_paras);
+        cached_paragraphs.set(new_paras.clone());
+
+        // Update syntax visibility after DOM changes
+        let doc = document();
+        let spans = syntax_spans();
+        update_syntax_visibility(
+            doc.cursor.offset,
+            doc.selection.as_ref(),
+            &spans,
+            &new_paras,
+        );
     });
 
     // Auto-save with debounce
···
                         if dominated {
                             let paras = cached_paragraphs();
                             sync_cursor_from_dom(&mut document, editor_id, &paras);
+                            // Update syntax visibility after cursor sync
+                            let doc = document();
+                            let spans = syntax_spans();
+                            update_syntax_visibility(
+                                doc.cursor.offset,
+                                doc.selection.as_ref(),
+                                &spans,
+                                &paras,
+                            );
                         }
                     },
 
···
                         // After mouse click, sync cursor from DOM
                         let paras = cached_paragraphs();
                         sync_cursor_from_dom(&mut document, editor_id, &paras);
+                        // Update syntax visibility after cursor sync
+                        let doc = document();
+                        let spans = syntax_spans();
+                        update_syntax_visibility(
+                            doc.cursor.offset,
+                            doc.selection.as_ref(),
+                            &spans,
+                            &paras,
+                        );
+                    },
+
+                    onmouseup: move |_evt| {
+                        // After drag selection, sync cursor/selection from DOM
+                        let paras = cached_paragraphs();
+                        sync_cursor_from_dom(&mut document, editor_id, &paras);
+                        // Update syntax visibility after cursor sync
+                        let doc = document();
+                        let spans = syntax_spans();
+                        update_syntax_visibility(
+                            doc.cursor.offset,
+                            doc.selection.as_ref(),
+                            &spans,
+                            &paras,
+                        );
                     },
 
                     onpaste: move |evt| {
···
 
                     oncut: move |evt| {
                         handle_cut(evt, &mut document);
+                    },
+
+                    oncopy: move |evt| {
+                        handle_copy(evt, &document);
                     },
                 }
 
···
     // No-op on non-wasm
 }
 
+/// Update syntax span visibility in the DOM based on cursor position.
+///
+/// Toggles the "hidden" class on syntax spans based on calculated visibility.
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+fn update_syntax_visibility(
+    cursor_offset: usize,
+    selection: Option<&Selection>,
+    syntax_spans: &[SyntaxSpanInfo],
+    paragraphs: &[ParagraphRender],
+) {
+    let visibility =
+        visibility::VisibilityState::calculate(cursor_offset, selection, syntax_spans, paragraphs);
+
+    let Some(window) = web_sys::window() else {
+        return;
+    };
+    let Some(document) = window.document() else {
+        return;
+    };
+
+    // Update each syntax span's visibility
+    for span in syntax_spans {
+        let selector = format!("[data-syn-id='{}']", span.syn_id);
+        if let Ok(Some(element)) = document.query_selector(&selector) {
+            let class_list = element.class_list();
+            if visibility.is_visible(&span.syn_id) {
+                let _ = class_list.remove_1("hidden");
+            } else {
+                let _ = class_list.add_1("hidden");
+            }
+        }
+    }
+}
+
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+fn update_syntax_visibility(
+    _cursor_offset: usize,
+    _selection: Option<&Selection>,
+    _syntax_spans: &[SyntaxSpanInfo],
+    _paragraphs: &[ParagraphRender],
+) {
+    // No-op on non-wasm
+}
+
 /// Handle paste events and insert text at cursor
 fn handle_paste(evt: Event<ClipboardData>, document: &mut Signal<EditorDocument>) {
     tracing::info!("[PASTE] handle_paste called");
···
     }
 }
 
-/// Handle cut events - browser copies selection, we delete it from rope
-/// Selection is synced via onkeyup/onclick, so doc.selection should be current
-fn handle_cut(_evt: Event<ClipboardData>, document: &mut Signal<EditorDocument>) {
+/// Handle cut events - extract text, write to clipboard, then delete from rope
+fn handle_cut(evt: Event<ClipboardData>, document: &mut Signal<EditorDocument>) {
     tracing::info!("[CUT] handle_cut called");
 
-    document.with_mut(|doc| {
-        if let Some(sel) = doc.selection {
-            let (start, end) = (sel.anchor.min(sel.head), sel.anchor.max(sel.head));
-            if start != end {
-                tracing::info!("[CUT] Deleting selection {}..{}", start, end);
-                doc.rope.remove(start..end);
-                doc.cursor.offset = start;
-                doc.selection = None;
+    #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+    {
+        use dioxus::web::WebEventExt;
+        use wasm_bindgen::JsCast;
+
+        let base_evt = evt.as_web_event();
+        if let Some(clipboard_evt) = base_evt.dyn_ref::<web_sys::ClipboardEvent>() {
+            document.with_mut(|doc| {
+                if let Some(sel) = doc.selection {
+                    let (start, end) = (sel.anchor.min(sel.head), sel.anchor.max(sel.head));
+                    if start != end {
+                        // Extract text from rope
+                        let selected_text = extract_rope_slice(&doc.rope, start, end);
+                        tracing::info!(
+                            "[CUT] Extracted {} chars: {:?}",
+                            selected_text.len(),
+                            &selected_text[..selected_text.len().min(50)]
+                        );
+
+                        // Write to clipboard BEFORE deleting
+                        if let Some(data_transfer) = clipboard_evt.clipboard_data() {
+                            if let Err(e) = data_transfer.set_data("text/plain", &selected_text) {
+                                tracing::warn!("[CUT] Failed to set clipboard data: {:?}", e);
+                            }
+                        }
+
+                        // Now delete from rope
+                        doc.rope.remove(start..end);
+                        doc.cursor.offset = start;
+                        doc.selection = None;
+                    }
+                }
+            });
+        }
+    }
+
+    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    {
+        let _ = evt; // suppress unused warning
+    }
+}
+
+/// Handle copy events - extract text from rope, clean it up, write to clipboard
+fn handle_copy(evt: Event<ClipboardData>, document: &Signal<EditorDocument>) {
+    tracing::info!("[COPY] handle_copy called");
+
+    #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+    {
+        use dioxus::web::WebEventExt;
+        use wasm_bindgen::JsCast;
+
+        let base_evt = evt.as_web_event();
+        if let Some(clipboard_evt) = base_evt.dyn_ref::<web_sys::ClipboardEvent>() {
+            let doc = document.read();
+            if let Some(sel) = doc.selection {
+                let (start, end) = (sel.anchor.min(sel.head), sel.anchor.max(sel.head));
+                if start != end {
+                    // Extract text from rope
+                    let selected_text = extract_rope_slice(&doc.rope, start, end);
+
+                    // Strip zero-width chars used for gap handling
+                    let clean_text = selected_text
+                        .replace('\u{200C}', "")
+                        .replace('\u{200B}', "");
+
+                    tracing::info!(
+                        "[COPY] Extracted {} chars (cleaned to {})",
+                        selected_text.len(),
+                        clean_text.len()
+                    );
+
+                    // Write to clipboard
+                    if let Some(data_transfer) = clipboard_evt.clipboard_data() {
+                        if let Err(e) = data_transfer.set_data("text/plain", &clean_text) {
+                            tracing::warn!("[COPY] Failed to set clipboard data: {:?}", e);
+                        }
+                    }
+
+                    // Prevent browser's default copy (which would copy rendered HTML)
+                    evt.prevent_default();
+                }
             }
         }
-    });
+    }
+
+    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    {
+        let _ = (evt, document); // suppress unused warnings
+    }
+}
+
+/// Extract a slice of text from the rope as a String
+fn extract_rope_slice(rope: &jumprope::JumpRopeBuf, start: usize, end: usize) -> String {
+    let mut result = String::new();
+    let rope_ref = rope.borrow();
+    for substr in rope_ref.slice_substrings(start..end) {
+        result.push_str(substr);
+    }
+    result
 }
 
 /// Handle keyboard events and update document state
···
                     // Shift+Enter: hard line break (soft break)
                     doc.rope.insert(doc.cursor.offset, "  \n\u{200C}");
                     doc.cursor.offset += 3;
+                } else if let Some(ctx) = detect_list_context(&doc.rope, doc.cursor.offset) {
+                    // We're in a list item
+                    tracing::debug!("[ENTER] List context detected: {:?}", ctx);
+                    tracing::debug!(
+                        "[ENTER] Cursor at {}, rope len {}",
+                        doc.cursor.offset,
+                        doc.rope.len_chars()
+                    );
+                    if is_list_item_empty(&doc.rope, doc.cursor.offset, &ctx) {
+                        tracing::debug!("[ENTER] Item is empty, exiting list");
+                        // Empty item - exit list by removing marker and inserting paragraph break
+                        let line_start = find_line_start(&doc.rope, doc.cursor.offset);
+                        let line_end = find_line_end(&doc.rope, doc.cursor.offset);
+
+                        // Delete the empty list item line INCLUDING its trailing newline
+                        // line_end points to the newline, so +1 to include it
+                        let delete_end = (line_end + 1).min(doc.rope.len_chars());
+
+                        doc.rope.remove(line_start..delete_end);
+                        doc.cursor.offset = line_start;
+
+                        // Insert two newlines, a zero-width whitespace character, and then another
+                        // newline to properly split the list (TODO: clean up the weird whitespace
+                        // char once that new paragraph has content)
+                        doc.rope.insert(doc.cursor.offset, "\n\n\u{200C}\n");
+                        doc.cursor.offset += 2;
+                    } else {
+                        // Non-empty item - continue list
+                        let continuation = match ctx {
+                            ListContext::Unordered { indent, marker } => {
+                                format!("\n{}{} ", indent, marker)
+                            }
+                            ListContext::Ordered { indent, number } => {
+                                format!("\n{}{}. ", indent, number + 1)
+                            }
+                        };
+                        let len = continuation.chars().count();
+                        doc.rope.insert(doc.cursor.offset, &continuation);
+                        doc.cursor.offset += len;
+                    }
                 } else {
-                    // Enter: paragraph break
+                    // Not in a list - normal paragraph break
                     doc.rope.insert(doc.cursor.offset, "\n\n");
                     doc.cursor.offset += 2;
                 }
···
             _ => {}
         }
     });
+}
+
+/// Describes what kind of list item the cursor is in, if any
+#[derive(Debug, Clone)]
+enum ListContext {
+    /// Unordered list with the given marker char ('-' or '*') and indentation
+    Unordered { indent: String, marker: char },
+    /// Ordered list with the current number and indentation
+    Ordered { indent: String, number: usize },
+}
+
+/// Detect if cursor is in a list item and return context for continuation.
+///
+/// Scans backwards to find start of current line, then checks for list marker.
+fn detect_list_context(rope: &jumprope::JumpRopeBuf, cursor_offset: usize) -> Option<ListContext> {
+    // Find start of current line
+    let line_start = find_line_start(rope, cursor_offset);
+
+    // Get the line content from start to cursor
+    let line_end = find_line_end(rope, cursor_offset);
+    if line_start >= line_end {
+        return None;
+    }
+
+    // Extract line text
+    let mut line = String::new();
+    let rope_ref = rope.borrow();
+    for substr in rope_ref.slice_substrings(line_start..line_end) {
+        line.push_str(substr);
+    }
+
+    // Parse indentation
+    let indent: String = line
+        .chars()
+        .take_while(|c| *c == ' ' || *c == '\t')
+        .collect();
+    let trimmed = &line[indent.len()..];
+
+    // Check for unordered list marker: "- " or "* "
+    if trimmed.starts_with("- ") {
+        return Some(ListContext::Unordered {
+            indent,
+            marker: '-',
+        });
+    }
+    if trimmed.starts_with("* ") {
+        return Some(ListContext::Unordered {
+            indent,
+            marker: '*',
+        });
+    }
+
+    // Check for ordered list marker: "1. ", "2. ", "123. ", etc.
+    if let Some(dot_pos) = trimmed.find(". ") {
+        let num_part = &trimmed[..dot_pos];
+        if !num_part.is_empty() && num_part.chars().all(|c| c.is_ascii_digit()) {
+            if let Ok(number) = num_part.parse::<usize>() {
+                return Some(ListContext::Ordered { indent, number });
+            }
+        }
+    }
+
+    None
+}
+
+/// Check if the current list item is empty (just the marker, no content after cursor).
+///
+/// Used to determine whether Enter should continue the list or exit it.
+fn is_list_item_empty(
+    rope: &jumprope::JumpRopeBuf,
+    cursor_offset: usize,
+    ctx: &ListContext,
+) -> bool {
+    let line_start = find_line_start(rope, cursor_offset);
+    let line_end = find_line_end(rope, cursor_offset);
+
+    // Get line content
+    let mut line = String::new();
+    let rope_ref = rope.borrow();
+    for substr in rope_ref.slice_substrings(line_start..line_end) {
+        line.push_str(substr);
+    }
+
+    // Calculate expected marker length
+    let marker_len = match ctx {
+        ListContext::Unordered { indent, .. } => indent.len() + 2, // "- "
+        ListContext::Ordered { indent, number } => {
+            indent.len() + number.to_string().len() + 2 // "1. "
+        }
+    };
+
+    tracing::debug!(
+        "[LIST] is_empty check: line={:?}, line.len()={}, marker_len={}, result={}",
+        line,
+        line.len(),
+        marker_len,
+        line.len() <= marker_len
+    );
+
+    // Item is empty if line length equals marker length (nothing after marker)
+    line.len() <= marker_len
 }
 
 /// Get character at the given offset in the rope

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

···
     // Rust ranges are end-exclusive, so range 0..10 covers positions 0-9.
     // When cursor is exactly at a boundary (e.g., position 10 between 0..10 and 10..20),
     // prefer the NEXT mapping so cursor goes "down" to new content.
-    let idx = offset_map
-        .binary_search_by(|mapping| {
-            if mapping.char_range.end <= char_offset {
-                // Cursor is at or after end of this mapping - look forward
-                std::cmp::Ordering::Less
-            } else if mapping.char_range.start > char_offset {
-                // Cursor is before this mapping
-                std::cmp::Ordering::Greater
+    let result = offset_map.binary_search_by(|mapping| {
+        if mapping.char_range.end <= char_offset {
+            // Cursor is at or after end of this mapping - look forward
+            std::cmp::Ordering::Less
+        } else if mapping.char_range.start > char_offset {
+            // Cursor is before this mapping
+            std::cmp::Ordering::Greater
+        } else {
+            // Cursor is within [start, end)
+            std::cmp::Ordering::Equal
+        }
+    });
+
+    let mapping = match result {
+        Ok(idx) => &offset_map[idx],
+        Err(idx) => {
+            // No exact match - cursor is at boundary between mappings (or past end)
+            // If cursor is exactly at end of previous mapping, return that mapping
+            // This handles cursor at end of document or end of last mapping
+            if idx > 0 && offset_map[idx - 1].char_range.end == char_offset {
+                &offset_map[idx - 1]
             } else {
-                // Cursor is within [start, end)
-                std::cmp::Ordering::Equal
+                return None;
             }
-        })
-        .ok()?;
+        }
+    };
 
-    let mapping = &offset_map[idx];
     let should_snap = mapping.is_invisible();
-
     Some((mapping, should_snap))
 }
 

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

···
 //! Tag::Paragraph events. This allows updating only changed paragraphs in the DOM.
 
 use super::offset_map::OffsetMapping;
+use super::writer::SyntaxSpanInfo;
 use jumprope::JumpRopeBuf;
 use std::ops::Range;
 
···
 
     /// Offset mappings for this paragraph
     pub offset_map: Vec<OffsetMapping>,
+
+    /// Syntax spans for conditional visibility
+    pub syntax_spans: Vec<SyntaxSpanInfo>,
 
     /// Hash of source text for quick change detection
     pub source_hash: u64,

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

···
 use super::document::EditInfo;
 use super::offset_map::{OffsetMapping, RenderResult};
 use super::paragraph::{ParagraphRender, hash_source, rope_slice_to_string};
-use super::writer::EditorWriter;
+use super::writer::{EditorWriter, SyntaxSpanInfo};
 use jumprope::JumpRopeBuf;
 use markdown_weaver::Parser;
 use std::ops::Range;
···
     pub paragraphs: Vec<CachedParagraph>,
     /// Next available node ID for fresh renders
     pub next_node_id: usize,
+    /// Next available syntax span ID for fresh renders
+    pub next_syn_id: usize,
 }
 
 /// A cached paragraph render that can be reused if source hasn't changed.
···
     pub html: String,
     /// Offset mappings for cursor positioning
     pub offset_map: Vec<OffsetMapping>,
-}
-
-/// Render markdown in paragraph chunks for incremental DOM updates.
-///
-/// First renders the whole document to discover paragraph boundaries via
-/// markdown events (Tag::Paragraph), then re-renders each paragraph separately.
-/// This allows updating only changed paragraphs in the DOM, preserving cursor
-/// position naturally.
-///
-/// # Returns
-///
-/// A vector of `ParagraphRender` structs, each containing:
-/// - Source byte and char ranges
-/// - Rendered HTML (without wrapper div)
-/// - Offset mappings for that paragraph
-/// - Source hash for change detection
-///
-/// # Phase 2 Benefits
-/// - Only re-render changed paragraphs
-/// - Browser preserves cursor in unchanged paragraphs naturally
-/// - Faster for large documents
-/// - No manual cursor restoration needed for most edits
-pub fn render_paragraphs(rope: &JumpRopeBuf) -> Vec<ParagraphRender> {
-    let source = rope.to_string();
-
-    // Handle empty rope - return single empty paragraph for cursor positioning
-    if source.is_empty() {
-        let empty_node_id = "n0".to_string();
-        let empty_html = format!(r#"<span id="{}">{}</span>"#, empty_node_id, '\u{200B}');
-
-        return vec![ParagraphRender {
-            byte_range: 0..0,
-            char_range: 0..0,
-            html: empty_html,
-            offset_map: vec![],
-            source_hash: 0,
-        }];
-    }
-
-    // First pass: render whole document to get paragraph boundaries
-    // TODO: CACHE THIS!
-    let parser = Parser::new_ext(&source, weaver_renderer::default_md_options()).into_offset_iter();
-    let mut scratch_output = String::new();
-
-    let paragraph_ranges =
-        match EditorWriter::<_, _, ()>::new(&source, rope, parser, &mut scratch_output).run() {
-            Ok(result) => result.paragraph_ranges,
-            Err(_) => return Vec::new(),
-        };
-
-    // Second pass: render each paragraph separately
-    let mut paragraphs = Vec::with_capacity(paragraph_ranges.len());
-    let mut node_id_offset = 0; // Track total nodes used so far for unique IDs
-
-    for (_idx, (byte_range, char_range)) in paragraph_ranges.iter().enumerate() {
-        // Extract paragraph source
-        let para_source = rope_slice_to_string(rope, char_range.clone());
-        let source_hash = hash_source(&para_source);
-
-        // Render this paragraph with unique node IDs
-        let para_rope = JumpRopeBuf::from(para_source.as_str());
-        let parser =
-            Parser::new_ext(&para_source, weaver_renderer::default_md_options()).into_offset_iter();
-        let mut output = String::new();
-
-        let mut offset_map = match EditorWriter::<_, _, ()>::new_with_node_offset(
-            &para_source,
-            &para_rope,
-            parser,
-            &mut output,
-            node_id_offset,
-        )
-        .run()
-        {
-            Ok(result) => {
-                // Update node ID offset for next paragraph
-                // Count how many unique node IDs were used in this paragraph
-                let max_node_id = result
-                    .offset_maps
-                    .iter()
-                    .filter_map(|m| {
-                        m.node_id
-                            .strip_prefix("n")
-                            .and_then(|s| s.parse::<usize>().ok())
-                    })
-                    .max()
-                    .unwrap_or(node_id_offset);
-                node_id_offset = max_node_id + 1;
-
-                result.offset_maps
-            }
-            Err(_) => Vec::new(),
-        };
-
-        // Adjust offset map to be relative to document, not paragraph
-        // Each mapping's ranges need to be shifted by paragraph start
-        let para_char_start = char_range.start;
-        let para_byte_start = byte_range.start;
-
-        for mapping in &mut offset_map {
-            mapping.byte_range.start += para_byte_start;
-            mapping.byte_range.end += para_byte_start;
-            mapping.char_range.start += para_char_start;
-            mapping.char_range.end += para_char_start;
-        }
-
-        paragraphs.push(ParagraphRender {
-            byte_range: byte_range.clone(),
-            char_range: char_range.clone(),
-            html: output,
-            offset_map,
-            source_hash,
-        });
-    }
-
-    // Insert gap paragraphs for EXTRA whitespace between blocks.
-    // Standard paragraph break is 2 newlines (\n\n) - no gap needed for that.
-    // Gaps are only for whitespace BEYOND the minimum, giving cursor a landing spot.
-    // Gap IDs are position-based for stability across renders.
-    const MIN_PARAGRAPH_BREAK: usize = 2; // \n\n
-
-    let mut paragraphs_with_gaps = Vec::with_capacity(paragraphs.len() * 2);
-    let mut prev_end_char = 0usize;
-    let mut prev_end_byte = 0usize;
-
-    for para in paragraphs {
-        // Check for gap before this paragraph - only if MORE than minimum break
-        let gap_size = para.char_range.start.saturating_sub(prev_end_char);
-        if gap_size > MIN_PARAGRAPH_BREAK {
-            // Gap covers the EXTRA whitespace beyond the minimum break
-            let gap_start_char = prev_end_char + MIN_PARAGRAPH_BREAK;
-            let gap_end_char = para.char_range.start;
-            let gap_start_byte = prev_end_byte + MIN_PARAGRAPH_BREAK;
-            let gap_end_byte = para.byte_range.start;
-
-            // Position-based ID: deterministic, stable across cache states
-            let gap_node_id = format!("gap-{}-{}", gap_start_char, gap_end_char);
-            let gap_html = format!(r#"<span id="{}">{}</span>"#, gap_node_id, '\u{200B}');
-
-            paragraphs_with_gaps.push(ParagraphRender {
-                byte_range: gap_start_byte..gap_end_byte,
-                char_range: gap_start_char..gap_end_char,
-                html: gap_html,
-                offset_map: vec![OffsetMapping {
-                    byte_range: gap_start_byte..gap_end_byte,
-                    char_range: gap_start_char..gap_end_char,
-                    node_id: gap_node_id,
-                    char_offset_in_node: 0,
-                    child_index: None,
-                    utf16_len: 1, // zero-width space represents the gap
-                }],
-                source_hash: hash_source(&rope_slice_to_string(rope, gap_start_char..gap_end_char)),
-            });
-        }
-
-        prev_end_char = para.char_range.end;
-        prev_end_byte = para.byte_range.end;
-        paragraphs_with_gaps.push(para);
-    }
-
-    // Check if rope ends with trailing newlines (empty paragraph at end)
-    // If so, add an empty paragraph div for cursor positioning
-    let source = rope.to_string();
-    let has_trailing_newlines = source.ends_with("\n\n") || source.ends_with("\n");
-
-    if has_trailing_newlines {
-        let doc_end_char = rope.len_chars();
-        let doc_end_byte = rope.len_bytes();
-
-        // Only add if there's actually a gap at the end
-        if doc_end_char > prev_end_char {
-            // Position-based ID for trailing gap
-            let trailing_node_id = format!("gap-{}-{}", prev_end_char, doc_end_char);
-            let trailing_html = format!(r#"<span id="{}">{}</span>"#, trailing_node_id, '\u{200B}');
-
-            paragraphs_with_gaps.push(ParagraphRender {
-                byte_range: prev_end_byte..doc_end_byte,
-                char_range: prev_end_char..doc_end_char,
-                html: trailing_html,
-                offset_map: vec![OffsetMapping {
-                    byte_range: prev_end_byte..doc_end_byte,
-                    char_range: prev_end_char..doc_end_char,
-                    node_id: trailing_node_id,
-                    char_offset_in_node: 0,
-                    child_index: None,
-                    utf16_len: 1, // zero-width space is 1 UTF-16 code unit
-                }],
-                source_hash: 0, // always render this paragraph
-            });
-        }
-    }
-
-    paragraphs_with_gaps
+    /// Syntax spans for conditional visibility
+    pub syntax_spans: Vec<SyntaxSpanInfo>,
 }
 
 /// Check if an edit affects paragraph boundaries.
···
         mapping.char_range.end = (mapping.char_range.end as isize + char_delta) as usize;
         mapping.byte_range.start = (mapping.byte_range.start as isize + byte_delta) as usize;
         mapping.byte_range.end = (mapping.byte_range.end as isize + byte_delta) as usize;
+    }
+
+    let mut adjusted_syntax = cached.syntax_spans.clone();
+    for span in &mut adjusted_syntax {
+        span.char_range.start = (span.char_range.start as isize + char_delta) as usize;
+        span.char_range.end = (span.char_range.end as isize + char_delta) as usize;
     }
 
     ParagraphRender {
···
             ..(cached.char_range.end as isize + char_delta) as usize,
         html: cached.html.clone(),
         offset_map: adjusted_map,
+        syntax_spans: adjusted_syntax,
         source_hash: cached.source_hash,
     }
 }
···
             char_range: 0..0,
             html: empty_html.clone(),
             offset_map: vec![],
+            syntax_spans: vec![],
             source_hash: 0,
         };
 
···
                 char_range: 0..0,
                 html: empty_html,
                 offset_map: vec![],
+                syntax_spans: vec![],
             }],
             next_node_id: 1,
+            next_syn_id: 0,
         };
 
         return (vec![para], new_cache);
···
         }
     };
 
+    tracing::debug!("[RENDER] Discovered {} paragraph ranges", paragraph_ranges.len());
+    for (i, (byte_range, char_range)) in paragraph_ranges.iter().enumerate() {
+        tracing::debug!("[RENDER]   Range {}: bytes {:?}, chars {:?}", i, byte_range, char_range);
+    }
+
     // Render paragraphs, reusing cache where possible
     let mut paragraphs = Vec::with_capacity(paragraph_ranges.len());
     let mut new_cached = Vec::with_capacity(paragraph_ranges.len());
     let mut node_id_offset = cache.map(|c| c.next_node_id).unwrap_or(0);
+    let mut syn_id_offset = cache.map(|c| c.next_syn_id).unwrap_or(0);
 
-    for (byte_range, char_range) in paragraph_ranges.iter() {
+    for (idx, (byte_range, char_range)) in paragraph_ranges.iter().enumerate() {
         let para_source = rope_slice_to_string(rope, char_range.clone());
         let source_hash = hash_source(&para_source);
 
+        tracing::debug!(
+            "[RENDER] Para {}: char_range {:?}, source preview: {:?}",
+            idx,
+            char_range,
+            &para_source[..para_source.len().min(50)]
+        );
+
         // Check if we have a cached render with matching hash
         let cached_match =
             cache.and_then(|c| c.paragraphs.iter().find(|p| p.source_hash == source_hash));
 
-        let (html, offset_map) = if let Some(cached) = cached_match {
-            // Reuse cached HTML and offset map (adjusted for position)
+        let (html, offset_map, syntax_spans) = if let Some(cached) = cached_match {
+            // Reuse cached HTML, offset map, and syntax spans (adjusted for position)
             let char_delta = char_range.start as isize - cached.char_range.start as isize;
             let byte_delta = byte_range.start as isize - cached.byte_range.start as isize;
 
···
                 mapping.byte_range.end = (mapping.byte_range.end as isize + byte_delta) as usize;
             }
 
-            (cached.html.clone(), adjusted_map)
+            let mut adjusted_syntax = cached.syntax_spans.clone();
+            for span in &mut adjusted_syntax {
+                span.char_range.start = (span.char_range.start as isize + char_delta) as usize;
+                span.char_range.end = (span.char_range.end as isize + char_delta) as usize;
+            }
+
+            (cached.html.clone(), adjusted_map, adjusted_syntax)
         } else {
             // Fresh render needed
             let para_rope = JumpRopeBuf::from(para_source.as_str());
···
                 .into_offset_iter();
             let mut output = String::new();
 
-            let mut offset_map = match EditorWriter::<_, _, ()>::new_with_node_offset(
-                &para_source,
-                &para_rope,
-                parser,
-                &mut output,
-                node_id_offset,
-            )
-            .run()
-            {
-                Ok(result) => {
-                    // Update node ID offset
-                    let max_node_id = result
-                        .offset_maps
-                        .iter()
-                        .filter_map(|m| {
-                            m.node_id
-                                .strip_prefix("n")
-                                .and_then(|s| s.parse::<usize>().ok())
-                        })
-                        .max()
-                        .unwrap_or(node_id_offset);
-                    node_id_offset = max_node_id + 1;
-                    result.offset_maps
-                }
-                Err(_) => Vec::new(),
-            };
+            let (mut offset_map, mut syntax_spans) =
+                match EditorWriter::<_, _, ()>::new_with_offsets(
+                    &para_source,
+                    &para_rope,
+                    parser,
+                    &mut output,
+                    node_id_offset,
+                    syn_id_offset,
+                )
+                .run()
+                {
+                    Ok(result) => {
+                        // Update node ID offset
+                        let max_node_id = result
+                            .offset_maps
+                            .iter()
+                            .filter_map(|m| {
+                                m.node_id
+                                    .strip_prefix("n")
+                                    .and_then(|s| s.parse::<usize>().ok())
+                            })
+                            .max()
+                            .unwrap_or(node_id_offset);
+                        node_id_offset = max_node_id + 1;
+
+                        // Update syn ID offset
+                        let max_syn_id = result
+                            .syntax_spans
+                            .iter()
+                            .filter_map(|s| {
+                                s.syn_id
+                                    .strip_prefix("s")
+                                    .and_then(|id| id.parse::<usize>().ok())
+                            })
+                            .max()
+                            .unwrap_or(syn_id_offset.saturating_sub(1));
+                        syn_id_offset = max_syn_id + 1;
+
+                        (result.offset_maps, result.syntax_spans)
+                    }
+                    Err(_) => (Vec::new(), Vec::new()),
+                };
 
             // Adjust offsets to document coordinates
             let para_char_start = char_range.start;
···
                 mapping.char_range.start += para_char_start;
                 mapping.char_range.end += para_char_start;
             }
+            for span in &mut syntax_spans {
+                span.char_range.start += para_char_start;
+                span.char_range.end += para_char_start;
+            }
 
-            (output, offset_map)
+            (output, offset_map, syntax_spans)
         };
 
         // Store in cache
···
             char_range: char_range.clone(),
             html: html.clone(),
             offset_map: offset_map.clone(),
+            syntax_spans: syntax_spans.clone(),
         });
 
         paragraphs.push(ParagraphRender {
···
             char_range: char_range.clone(),
             html,
             offset_map,
+            syntax_spans,
             source_hash,
         });
     }
···
         // Check for gap before this paragraph - only if MORE than minimum break
         let gap_size = para.char_range.start.saturating_sub(prev_end_char);
         if gap_size > MIN_PARAGRAPH_BREAK_INCR {
-            // Gap covers the EXTRA whitespace beyond the minimum break
+            // Visible gap element covers EXTRA whitespace beyond minimum break
             let gap_start_char = prev_end_char + MIN_PARAGRAPH_BREAK_INCR;
             let gap_end_char = para.char_range.start;
             let gap_start_byte = prev_end_byte + MIN_PARAGRAPH_BREAK_INCR;
···
             let gap_node_id = format!("gap-{}-{}", gap_start_char, gap_end_char);
             let gap_html = format!(r#"<span id="{}">{}</span>"#, gap_node_id, '\u{200B}');
 
+            // Gap paragraph covers ALL whitespace (like trailing gaps do)
+            // so cursor anywhere in the inter-paragraph zone triggers restoration
             paragraphs_with_gaps.push(ParagraphRender {
-                byte_range: gap_start_byte..gap_end_byte,
-                char_range: gap_start_char..gap_end_char,
+                byte_range: prev_end_byte..gap_end_byte,
+                char_range: prev_end_char..gap_end_char,
                 html: gap_html,
                 offset_map: vec![OffsetMapping {
-                    byte_range: gap_start_byte..gap_end_byte,
-                    char_range: gap_start_char..gap_end_char,
+                    byte_range: prev_end_byte..gap_end_byte,
+                    char_range: prev_end_char..gap_end_char,
                     node_id: gap_node_id,
                     char_offset_in_node: 0,
                     child_index: None,
                     utf16_len: 1,
                 }],
+                syntax_spans: vec![],
                 source_hash: hash_source(&rope_slice_to_string(rope, gap_start_char..gap_end_char)),
             });
         }
···
                     child_index: None,
                     utf16_len: 1,
                 }],
+                syntax_spans: vec![],
                 source_hash: 0,
             });
         }
···
     let new_cache = RenderCache {
         paragraphs: new_cached,
         next_node_id: node_id_offset,
+        next_syn_id: syn_id_offset,
     };
 
     (paragraphs_with_gaps, new_cache)

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__blockquote.snap

···
   char_range:
     - 0
     - 18
-  html: "<blockquote>\n<p id=\"n0\"><span class=\"md-syntax-block\">&gt; </span>This is a quote<span class=\"md-syntax-inline\">\n</span></p>\n</blockquote>\n"
+  html: "<blockquote>\n<p id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">&gt; </span>This is a quote<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"17\" data-char-end=\"18\">\n</span></p>\n</blockquote>\n"
   offset_map:
     - byte_range:
         - 43
···
       utf16_len: 1
   source_hash: 11268153476336590706
 - byte_range:
-    - 20
+    - 18
     - 22
   char_range:
-    - 20
+    - 18
     - 22
   html: "<span id=\"gap-20-22\">​</span>"
   offset_map:
     - byte_range:
-        - 20
+        - 18
         - 22
       char_range:
-        - 20
+        - 18
         - 22
       node_id: gap-20-22
       char_offset_in_node: 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__bold.snap

···
   char_range:
     - 0
     - 18
-  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\">**</span><strong>bold<span class=\"md-syntax-inline\">**</span></strong> text</p>\n"
+  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"7\">**</span><strong>bold<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"11\" data-char-end=\"13\">**</span></strong> text</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__bold_italic.snap

···
   char_range:
     - 0
     - 27
-  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\">*</span><em><span class=\"md-syntax-inline\">**</span><strong>bold italic<span class=\"md-syntax-inline\">**</span></strong><span class=\"md-syntax-inline\">*</span></em> text</p>\n"
+  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">*</span><em><span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"6\" data-char-end=\"8\">**</span><strong>bold italic<span class=\"md-syntax-inline\" data-syn-id=\"s2\" data-char-start=\"19\" data-char-end=\"21\">**</span></strong><span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"21\" data-char-end=\"22\">*</span></em> text</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__code_block_fenced.snap

···
   char_range:
     - 0
     - 24
-  html: "<span class=\"md-syntax-block\">```rust</span>\n<pre><code class=\"wvc-code language-Rust\"><span class=\"wvc-source wvc-rust\"><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-storage wvc-type wvc-function wvc-rust\">fn</span> </span><span class=\"wvc-entity wvc-name wvc-function wvc-rust\">main</span></span><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-function wvc-parameters wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-parameters wvc-begin wvc-rust\">(</span></span><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-function wvc-parameters wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-parameters wvc-end wvc-rust\">)</span></span></span></span><span class=\"wvc-meta wvc-function wvc-rust\"> </span><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-block wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-block wvc-begin wvc-rust\">{</span></span><span class=\"wvc-meta wvc-block wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-block wvc-end wvc-rust\">}</span></span></span>\n</span></code></pre><span class=\"md-syntax-block\">```</span>"
+  html: "<span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"8\">```rust</span>\n<pre><code class=\"wvc-code language-Rust\"><span class=\"wvc-source wvc-rust\"><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-storage wvc-type wvc-function wvc-rust\">fn</span> </span><span class=\"wvc-entity wvc-name wvc-function wvc-rust\">main</span></span><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-function wvc-parameters wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-parameters wvc-begin wvc-rust\">(</span></span><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-function wvc-parameters wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-parameters wvc-end wvc-rust\">)</span></span></span></span><span class=\"wvc-meta wvc-function wvc-rust\"> </span><span class=\"wvc-meta wvc-function wvc-rust\"><span class=\"wvc-meta wvc-block wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-block wvc-begin wvc-rust\">{</span></span><span class=\"wvc-meta wvc-block wvc-rust\"><span class=\"wvc-punctuation wvc-section wvc-block wvc-end wvc-rust\">}</span></span></span>\n</span></code></pre><span class=\"md-syntax-block\" data-syn-id=\"s1\" data-char-start=\"21\" data-char-end=\"24\">```</span>"
   offset_map:
     - byte_range:
         - 8

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__gap_between_blocks.snap

···
   char_range:
     - 0
     - 10
-  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\"># </span>Heading<span class=\"md-syntax-inline\">\n</span></h1>\n"
+  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>Heading<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"9\" data-char-end=\"10\">\n</span></h1>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__hard_break.snap

···
   char_range:
     - 0
     - 19
-  html: "<p id=\"n0\">Line one<span class=\"md-syntax-inline\">  </span><br />​Line two</p>\n"
+  html: "<p id=\"n0\">Line one<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"8\" data-char-end=\"10\">  </span><br />​Line two</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__heading_h1.snap

···
   char_range:
     - 0
     - 11
-  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\"># </span>Heading 1</h1>\n"
+  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>Heading 1</h1>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__heading_levels.snap

···
   char_range:
     - 0
     - 5
-  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\"># </span>H1<span class=\"md-syntax-inline\">\n</span></h1>\n"
+  html: "<h1 data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\"># </span>H1<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"4\" data-char-end=\"5\">\n</span></h1>\n"
   offset_map:
     - byte_range:
         - 0
···
   char_range:
     - 6
     - 12
-  html: "<h2 data-node-id=\"n1\"><span class=\"md-syntax-block\">## </span>H2<span class=\"md-syntax-inline\">\n</span></h2>\n"
+  html: "<h2 data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"0\" data-char-end=\"3\">## </span>H2<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"5\" data-char-end=\"6\">\n</span></h2>\n"
   offset_map:
     - byte_range:
         - 6
···
   char_range:
     - 13
     - 20
-  html: "<h3 data-node-id=\"n2\"><span class=\"md-syntax-block\">### </span>H3<span class=\"md-syntax-inline\">\n</span></h3>\n"
+  html: "<h3 data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s4\" data-char-start=\"0\" data-char-end=\"4\">### </span>H3<span class=\"md-syntax-inline\" data-syn-id=\"s5\" data-char-start=\"6\" data-char-end=\"7\">\n</span></h3>\n"
   offset_map:
     - byte_range:
         - 13
···
   char_range:
     - 21
     - 28
-  html: "<h4 data-node-id=\"n3\"><span class=\"md-syntax-block\">#### </span>H4</h4>\n"
+  html: "<h4 data-node-id=\"n3\"><span class=\"md-syntax-block\" data-syn-id=\"s6\" data-char-start=\"0\" data-char-end=\"5\">#### </span>H4</h4>\n"
   offset_map:
     - byte_range:
         - 21

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__inline_code.snap

···
   char_range:
     - 0
     - 16
-  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\">`</span><code>code</code><span class=\"md-syntax-inline\">`</span> here</p>\n"
+  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">`</span><code>code</code><span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"10\" data-char-end=\"11\">`</span> here</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__italic.snap

···
   char_range:
     - 0
     - 18
-  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\">*</span><em>italic<span class=\"md-syntax-inline\">*</span></em> text</p>\n"
+  html: "<p id=\"n0\">Some <span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">*</span><em>italic<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"12\" data-char-end=\"13\">*</span></em> text</p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__multiple_blank_lines.snap

···
   char_range:
     - 0
     - 6
-  html: "<p id=\"n0\">First<span class=\"md-syntax-inline\">\n</span></p>\n"
+  html: "<p id=\"n0\">First<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">\n</span></p>\n"
   offset_map:
     - byte_range:
         - 0
···
       utf16_len: 1
   source_hash: 6799294212516041738
 - byte_range:
-    - 8
+    - 6
     - 9
   char_range:
-    - 8
+    - 6
     - 9
   html: "<span id=\"gap-8-9\">​</span>"
   offset_map:
     - byte_range:
-        - 8
+        - 6
         - 9
       char_range:
-        - 8
+        - 6
         - 9
       node_id: gap-8-9
       char_offset_in_node: 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__multiple_inline_formats.snap

···
   char_range:
     - 0
     - 32
-  html: "<p id=\"n0\"><span class=\"md-syntax-inline\">**</span><strong>Bold<span class=\"md-syntax-inline\">**</span></strong> and <span class=\"md-syntax-inline\">*</span><em>italic<span class=\"md-syntax-inline\">*</span></em> and <span class=\"md-syntax-inline\">`</span><code>code</code><span class=\"md-syntax-inline\">`</span></p>\n"
+  html: "<p id=\"n0\"><span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">**</span><strong>Bold<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"6\" data-char-end=\"8\">**</span></strong> and <span class=\"md-syntax-inline\" data-syn-id=\"s2\" data-char-start=\"13\" data-char-end=\"14\">*</span><em>italic<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"20\" data-char-end=\"21\">*</span></em> and <span class=\"md-syntax-inline\" data-syn-id=\"s4\" data-char-start=\"26\" data-char-end=\"27\">`</span><code>code</code><span class=\"md-syntax-inline\" data-syn-id=\"s5\" data-char-start=\"31\" data-char-end=\"32\">`</span></p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__nested_list.snap

···
 expression: result
 ---
 - byte_range:
-    - 2
+    - 0
     - 11
   char_range:
-    - 2
+    - 0
     - 11
   html: "<span id=\"gap-2-11\">​</span>"
   offset_map:
     - byte_range:
-        - 2
+        - 0
         - 11
       char_range:
-        - 2
+        - 0
         - 11
       node_id: gap-2-11
       char_offset_in_node: 0
···
   char_range:
     - 11
     - 33
-  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\">- </span>Child 1<span class=\"md-syntax-inline\">\n  </span>\n<ul>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\">- </span>Child 2<span class=\"md-syntax-inline\">\n</span></li>\n</ul>\n</li>\n</ul>\n"
+  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">- </span>Child 1<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"9\" data-char-end=\"12\">\n  </span>\n<ul>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"12\" data-char-end=\"14\">- </span>Child 2<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"21\" data-char-end=\"22\">\n</span></li>\n</ul>\n</li>\n</ul>\n"
   offset_map:
     - byte_range:
         - 11

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__ordered_list.snap

···
   char_range:
     - 0
     - 27
-  html: "<ol>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\">1.</span><span class=\"md-syntax-inline\"> </span>First<span class=\"md-syntax-inline\">\n</span></li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\">2.</span><span class=\"md-syntax-inline\"> </span>Second<span class=\"md-syntax-inline\">\n</span></li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\">3.</span><span class=\"md-syntax-inline\"> </span>Third</li>\n</ol>\n"
+  html: "<ol>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">1.</span><span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"2\" data-char-end=\"3\"> </span>First<span class=\"md-syntax-inline\" data-syn-id=\"s2\" data-char-start=\"8\" data-char-end=\"9\">\n</span></li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s3\" data-char-start=\"9\" data-char-end=\"11\">2.</span><span class=\"md-syntax-inline\" data-syn-id=\"s4\" data-char-start=\"11\" data-char-end=\"12\"> </span>Second<span class=\"md-syntax-inline\" data-syn-id=\"s5\" data-char-start=\"18\" data-char-end=\"19\">\n</span></li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s6\" data-char-start=\"19\" data-char-end=\"21\">3.</span><span class=\"md-syntax-inline\" data-syn-id=\"s7\" data-char-start=\"21\" data-char-end=\"22\"> </span>Third</li>\n</ol>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__three_paragraphs.snap

···
   char_range:
     - 0
     - 5
-  html: "<p id=\"n0\">One.<span class=\"md-syntax-inline\">\n</span></p>\n"
+  html: "<p id=\"n0\">One.<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"4\" data-char-end=\"5\">\n</span></p>\n"
   offset_map:
     - byte_range:
         - 0
···
   char_range:
     - 6
     - 11
-  html: "<p id=\"n1\">Two.<span class=\"md-syntax-inline\">\n</span></p>\n"
+  html: "<p id=\"n1\">Two.<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"4\" data-char-end=\"5\">\n</span></p>\n"
   offset_map:
     - byte_range:
         - 6

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__trailing_double_newline.snap

···
   char_range:
     - 0
     - 6
-  html: "<p id=\"n0\">Hello<span class=\"md-syntax-inline\">\n</span></p>\n"
+  html: "<p id=\"n0\">Hello<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">\n</span></p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__trailing_single_newline.snap

···
   char_range:
     - 0
     - 6
-  html: "<p id=\"n0\">Hello<span class=\"md-syntax-inline\">\n</span></p>\n"
+  html: "<p id=\"n0\">Hello<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"5\" data-char-end=\"6\">\n</span></p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__two_paragraphs.snap

···
   char_range:
     - 0
     - 17
-  html: "<p id=\"n0\">First paragraph.<span class=\"md-syntax-inline\">\n</span></p>\n"
+  html: "<p id=\"n0\">First paragraph.<span class=\"md-syntax-inline\" data-syn-id=\"s0\" data-char-start=\"16\" data-char-end=\"17\">\n</span></p>\n"
   offset_map:
     - byte_range:
         - 0

crates/weaver-app/src/components/editor/snapshots/weaver_app__components__editor__tests__unordered_list.snap

···
   char_range:
     - 0
     - 26
-  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\">- </span>Item 1<span class=\"md-syntax-inline\">\n</span></li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\">- </span>Item 2<span class=\"md-syntax-inline\">\n</span></li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\">- </span>Item 3</li>\n</ul>\n"
+  html: "<ul>\n<li data-node-id=\"n0\"><span class=\"md-syntax-block\" data-syn-id=\"s0\" data-char-start=\"0\" data-char-end=\"2\">- </span>Item 1<span class=\"md-syntax-inline\" data-syn-id=\"s1\" data-char-start=\"8\" data-char-end=\"9\">\n</span></li>\n<li data-node-id=\"n1\"><span class=\"md-syntax-block\" data-syn-id=\"s2\" data-char-start=\"9\" data-char-end=\"11\">- </span>Item 2<span class=\"md-syntax-inline\" data-syn-id=\"s3\" data-char-start=\"17\" data-char-end=\"18\">\n</span></li>\n<li data-node-id=\"n2\"><span class=\"md-syntax-block\" data-syn-id=\"s4\" data-char-start=\"18\" data-char-end=\"20\">- </span>Item 3</li>\n</ul>\n"
   offset_map:
     - byte_range:
         - 0

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

···
 
 use super::offset_map::{OffsetMapping, find_mapping_for_char};
 use super::paragraph::ParagraphRender;
-use super::render::render_paragraphs;
+use super::render::render_paragraphs_incremental;
 use jumprope::JumpRopeBuf;
 use serde::Serialize;
 
···
 /// Helper: render markdown and convert to serializable test output.
 fn render_test(input: &str) -> Vec<TestParagraph> {
     let rope = JumpRopeBuf::from(input);
-    let paragraphs = render_paragraphs(&rope);
+    let (paragraphs, _cache) = render_paragraphs_incremental(&rope, None, None);
     paragraphs.iter().map(TestParagraph::from).collect()
 }
 
···
 
 #[test]
 fn regression_bug11_gap_paragraphs_for_whitespace() {
-    // Bug #11: Gap paragraphs should be created for inter-block whitespace
-    let result = render_test("# Title\n\nContent");
+    // Bug #11: Gap paragraphs should be created for EXTRA inter-block whitespace
+    // Note: Headings consume trailing newline, so need 4 newlines total for gap > MIN_PARAGRAPH_BREAK
 
-    // Check that char ranges cover the full document without gaps
-    let mut prev_end = 0;
-    for para in &result {
-        // Allow gaps to be filled by gap paragraphs
-        if para.char_range.0 > prev_end {
-            // This would be a gap - but gap paragraphs should fill it
-            panic!(
-                "Gap in char ranges: {}..{} missing coverage",
-                prev_end, para.char_range.0
-            );
-        }
-        prev_end = para.char_range.1;
-    }
+    // Test with extra whitespace (4 newlines = heading eats 1, leaves 3, gap = 3 > 2)
+    let result = render_test("# Title\n\n\n\nContent"); // 4 newlines
+    assert_eq!(result.len(), 3, "Expected 3 elements with extra whitespace");
+    assert!(result[1].html.contains("gap-"), "Middle element should be a gap");
+
+    // Test standard break (3 newlines = heading eats 1, leaves 2, gap = 2 = MIN, no gap element)
+    let result2 = render_test("# Title\n\n\nContent"); // 3 newlines
+    assert_eq!(result2.len(), 2, "Expected 2 elements with standard break equivalent");
 }
 
 // =============================================================================
···
 // =============================================================================
 
 #[test]
-fn test_char_range_full_coverage() {
-    // Verify that char ranges cover entire document
+fn test_char_range_coverage_allows_paragraph_breaks() {
+    // Verify char ranges cover document content, allowing standard \n\n breaks
+    // The MIN_PARAGRAPH_BREAK zone (2 chars) is intentionally not covered -
+    // cursor snaps to adjacent paragraphs for standard breaks.
+    // Only EXTRA whitespace beyond \n\n gets gap elements.
     let input = "Hello\n\nWorld";
     let rope = JumpRopeBuf::from(input);
-    let paragraphs = render_paragraphs(&rope);
+    let (paragraphs, _cache) = render_paragraphs_incremental(&rope, None, None);
 
-    let doc_len = rope.len_chars();
+    // With standard \n\n break, we expect 2 paragraphs (no gap element)
+    // Paragraph ranges include some trailing whitespace from markdown parsing
+    assert_eq!(paragraphs.len(), 2, "Expected 2 paragraphs for standard break");
 
-    // Collect all ranges
-    let mut ranges: Vec<_> = paragraphs.iter().map(|p| p.char_range.clone()).collect();
-    ranges.sort_by_key(|r| r.start);
+    // First paragraph ends before second starts, with gap for \n\n
+    let gap_start = paragraphs[0].char_range.end;
+    let gap_end = paragraphs[1].char_range.start;
+    let gap_size = gap_end - gap_start;
+    assert!(gap_size <= 2, "Gap should be at most MIN_PARAGRAPH_BREAK (2), got {}", gap_size);
+}
 
-    // Check coverage
-    let mut covered = 0;
-    for range in &ranges {
-        assert!(
-            range.start <= covered,
-            "Gap at position {}, next range starts at {}",
-            covered,
-            range.start
-        );
-        covered = covered.max(range.end);
-    }
+#[test]
+fn test_char_range_coverage_with_extra_whitespace() {
+    // Extra whitespace beyond MIN_PARAGRAPH_BREAK (2) gets gap elements
+    // Plain paragraphs don't consume trailing newlines like headings do
+    let input = "Hello\n\n\n\nWorld"; // 4 newlines = gap of 4 > 2
+    let rope = JumpRopeBuf::from(input);
+    let (paragraphs, _cache) = render_paragraphs_incremental(&rope, None, None);
 
-    assert!(
-        covered >= doc_len,
-        "Ranges don't cover full document: covered {} of {}",
-        covered,
-        doc_len
-    );
+    // With extra newlines, we expect 3 elements: para, gap, para
+    assert_eq!(paragraphs.len(), 3, "Expected 3 elements with extra whitespace");
+
+    // Gap element should exist and cover whitespace zone
+    let gap = &paragraphs[1];
+    assert!(gap.html.contains("gap-"), "Second element should be a gap");
+
+    // Gap should cover ALL whitespace (not just extra)
+    assert_eq!(gap.char_range.start, paragraphs[0].char_range.end,
+        "Gap should start where first paragraph ends");
+    assert_eq!(gap.char_range.end, paragraphs[2].char_range.start,
+        "Gap should end where second paragraph starts");
 }
 
 #[test]
···
 // Incremental Rendering Tests
 // =============================================================================
 
-use super::render::render_paragraphs_incremental;
-
-#[test]
-fn test_incremental_renders_same_as_full() {
-    // Incremental render with no cache should produce same result as full render
-    let input = "# Heading\n\nParagraph with **bold**\n\n- List item";
-    let rope = JumpRopeBuf::from(input);
-
-    let full = render_paragraphs(&rope);
-    let (incremental, _cache) = render_paragraphs_incremental(&rope, None, None);
-
-    // Compare HTML output (hashes may differ due to caching internals)
-    assert_eq!(
-        full.len(),
-        incremental.len(),
-        "Different paragraph count: full={}, incr={}",
-        full.len(),
-        incremental.len()
-    );
-
-    for (i, (f, inc)) in full.iter().zip(incremental.iter()).enumerate() {
-        assert_eq!(
-            f.html, inc.html,
-            "Paragraph {} HTML differs:\nFull: {}\nIncr: {}",
-            i, f.html, inc.html
-        );
-        assert_eq!(
-            f.byte_range, inc.byte_range,
-            "Paragraph {} byte_range differs",
-            i
-        );
-        assert_eq!(
-            f.char_range, inc.char_range,
-            "Paragraph {} char_range differs",
-            i
-        );
-    }
-}
-
 #[test]
 fn test_incremental_cache_reuse() {
     // Verify cache is populated and can be reused
···
         assert_eq!(p1.html, p2.html);
     }
 }
+
+// =============================================================================
+// Loro CRDT API Spike Tests
+// =============================================================================
+
+#[test]
+fn test_loro_basic_text_operations() {
+    use loro::LoroDoc;
+
+    let doc = LoroDoc::new();
+    let text = doc.get_text("content");
+
+    // Insert
+    text.insert(0, "Hello").unwrap();
+    assert_eq!(text.to_string(), "Hello");
+    assert_eq!(text.len_unicode(), 5);
+
+    // Insert at position
+    text.insert(5, " world").unwrap();
+    assert_eq!(text.to_string(), "Hello world");
+    assert_eq!(text.len_unicode(), 11);
+
+    // Delete
+    text.delete(5, 6).unwrap(); // delete " world"
+    assert_eq!(text.to_string(), "Hello");
+    assert_eq!(text.len_unicode(), 5);
+}
+
+#[test]
+fn test_loro_unicode_handling() {
+    use loro::LoroDoc;
+
+    let doc = LoroDoc::new();
+    let text = doc.get_text("content");
+
+    // Insert unicode
+    text.insert(0, "Hello 🎉 世界").unwrap();
+
+    // Check lengths
+    let content = text.to_string();
+    assert_eq!(content, "Hello 🎉 世界");
+
+    // Unicode length (chars)
+    assert_eq!(text.len_unicode(), 10); // H e l l o   🎉   世 界
+
+    // UTF-16 length (for DOM)
+    // 🎉 is a surrogate pair (2 UTF-16 units), rest are 1 each
+    assert_eq!(text.len_utf16(), 11); // 6 + 2 + 1 + 2 = 11
+
+    // UTF-8 length (bytes)
+    assert_eq!(text.len_utf8(), content.len());
+}
+
+#[test]
+fn test_loro_undo_redo() {
+    use loro::{LoroDoc, UndoManager};
+
+    let doc = LoroDoc::new();
+    let text = doc.get_text("content");
+    let mut undo_mgr = UndoManager::new(&doc);
+
+    // Type some text
+    text.insert(0, "Hello").unwrap();
+    doc.commit();
+
+    text.insert(5, " world").unwrap();
+    doc.commit();
+
+    assert_eq!(text.to_string(), "Hello world");
+
+    // Undo last change
+    assert!(undo_mgr.can_undo());
+    undo_mgr.undo().unwrap();
+    assert_eq!(text.to_string(), "Hello");
+
+    // Undo first change
+    undo_mgr.undo().unwrap();
+    assert_eq!(text.to_string(), "");
+
+    // Redo
+    assert!(undo_mgr.can_redo());
+    undo_mgr.redo().unwrap();
+    assert_eq!(text.to_string(), "Hello");
+
+    undo_mgr.redo().unwrap();
+    assert_eq!(text.to_string(), "Hello world");
+}
+
+#[test]
+fn test_loro_char_to_utf16_conversion() {
+    use loro::LoroDoc;
+
+    let doc = LoroDoc::new();
+    let text = doc.get_text("content");
+
+    text.insert(0, "Hello 🎉 世界").unwrap();
+
+    // Simulate char→UTF16 conversion for cursor positioning
+    // Given a char offset, compute UTF-16 offset
+    fn char_to_utf16(text: &loro::LoroText, char_pos: usize) -> usize {
+        if char_pos == 0 {
+            return 0;
+        }
+        // Fast path: if all ASCII, char == UTF-16
+        if text.len_unicode() == text.len_utf16() {
+            return char_pos;
+        }
+        // Slow path: get slice and count UTF-16 units
+        match text.slice(0, char_pos) {
+            Ok(slice) => slice.encode_utf16().count(),
+            Err(_) => 0,
+        }
+    }
+
+    // "Hello 🎉 世界"
+    // Positions: H(0) e(1) l(2) l(3) o(4) ' '(5) 🎉(6) ' '(7) 世(8) 界(9)
+    // UTF-16:    0     1    2    3    4     5     6,7    8     9    10
+
+    assert_eq!(char_to_utf16(&text, 0), 0);
+    assert_eq!(char_to_utf16(&text, 6), 6);  // before emoji
+    assert_eq!(char_to_utf16(&text, 7), 8);  // after emoji (emoji is 2 UTF-16 units)
+    assert_eq!(char_to_utf16(&text, 10), 11); // end
+}
+
+#[test]
+fn test_loro_ascii_fast_path() {
+    use loro::LoroDoc;
+
+    let doc = LoroDoc::new();
+    let text = doc.get_text("content");
+
+    // Pure ASCII content
+    text.insert(0, "Hello world, this is a test!").unwrap();
+
+    // Verify fast path condition: all lengths equal for ASCII
+    assert_eq!(text.len_unicode(), text.len_utf8());
+    assert_eq!(text.len_unicode(), text.len_utf16());
+
+    // Fast path should just return char_pos directly
+    fn char_to_utf16(text: &loro::LoroText, char_pos: usize) -> usize {
+        if char_pos == 0 {
+            return 0;
+        }
+        if text.len_unicode() == text.len_utf16() {
+            return char_pos; // fast path
+        }
+        text.slice(0, char_pos).map(|s| s.encode_utf16().count()).unwrap_or(0)
+    }
+
+    // All positions should be identity for ASCII
+    for i in 0..=text.len_unicode() {
+        assert_eq!(char_to_utf16(&text, i), i, "ASCII fast path failed at pos {}", i);
+    }
+}

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

···
+//! Conditional syntax visibility based on cursor position.
+//!
+//! Implements Obsidian-style formatting character visibility: syntax markers
+//! are hidden when cursor is not near them, revealed when cursor approaches.
+
+use super::document::Selection;
+use super::paragraph::ParagraphRender;
+use super::writer::{SyntaxSpanInfo, SyntaxType};
+use std::collections::HashSet;
+use std::ops::Range;
+
+/// Determines which syntax spans should be visible based on cursor/selection.
+#[derive(Debug, Clone, Default)]
+pub struct VisibilityState {
+    /// Set of syn_ids that should be visible
+    pub visible_span_ids: HashSet<String>,
+}
+
+impl VisibilityState {
+    /// Calculate visibility based on cursor position and selection.
+    ///
+    /// # Arguments
+    /// - `cursor_offset`: Current cursor position (char offset)
+    /// - `selection`: Optional selection range
+    /// - `syntax_spans`: All syntax spans in the document
+    /// - `paragraphs`: All paragraphs (for block-level visibility lookup)
+    pub fn calculate(
+        cursor_offset: usize,
+        selection: Option<&Selection>,
+        syntax_spans: &[SyntaxSpanInfo],
+        paragraphs: &[ParagraphRender],
+    ) -> Self {
+        let mut visible = HashSet::new();
+
+        for span in syntax_spans {
+            let should_show = match span.syntax_type {
+                SyntaxType::Inline => {
+                    // Show if cursor within formatted span content OR adjacent to markers
+                    // "Adjacent" means within 1 char of the syntax boundaries
+                    let extended_range = span.char_range.start.saturating_sub(1)
+                        ..span.char_range.end.saturating_add(1);
+
+                    // Also show if cursor is anywhere in the formatted_range
+                    // (the region between paired opening/closing markers)
+                    let in_formatted_region = span
+                        .formatted_range
+                        .as_ref()
+                        .map(|r| r.contains(&cursor_offset))
+                        .unwrap_or(false);
+
+                    extended_range.contains(&cursor_offset)
+                        || in_formatted_region
+                        || selection_overlaps(selection, &span.char_range)
+                        || span
+                            .formatted_range
+                            .as_ref()
+                            .map(|r| selection_overlaps(selection, r))
+                            .unwrap_or(false)
+                }
+                SyntaxType::Block => {
+                    // Show if cursor anywhere in same paragraph
+                    cursor_in_same_paragraph(cursor_offset, &span.char_range, paragraphs)
+                        || selection_overlaps(selection, &span.char_range)
+                }
+            };
+
+            if should_show {
+                visible.insert(span.syn_id.clone());
+            }
+        }
+
+        Self {
+            visible_span_ids: visible,
+        }
+    }
+
+    /// Check if a specific span should be visible.
+    pub fn is_visible(&self, syn_id: &str) -> bool {
+        self.visible_span_ids.contains(syn_id)
+    }
+}
+
+/// Check if selection overlaps with a char range.
+fn selection_overlaps(selection: Option<&Selection>, range: &Range<usize>) -> bool {
+    let Some(sel) = selection else {
+        return false;
+    };
+
+    let sel_start = sel.anchor.min(sel.head);
+    let sel_end = sel.anchor.max(sel.head);
+
+    // Check if ranges overlap
+    sel_start < range.end && sel_end > range.start
+}
+
+/// Check if cursor is in the same paragraph as a syntax span.
+fn cursor_in_same_paragraph(
+    cursor_offset: usize,
+    syntax_range: &Range<usize>,
+    paragraphs: &[ParagraphRender],
+) -> bool {
+    // Find which paragraph contains the syntax span
+    for para in paragraphs {
+        // Skip gap paragraphs (they have no syntax spans)
+        if para.syntax_spans.is_empty() && !para.char_range.is_empty() {
+            continue;
+        }
+
+        // Check if this paragraph contains the syntax span
+        if para.char_range.start <= syntax_range.start && syntax_range.end <= para.char_range.end {
+            // Check if cursor is also in this paragraph
+            return para.char_range.contains(&cursor_offset);
+        }
+    }
+
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_span(syn_id: &str, start: usize, end: usize, syntax_type: SyntaxType) -> SyntaxSpanInfo {
+        SyntaxSpanInfo {
+            syn_id: syn_id.to_string(),
+            char_range: start..end,
+            syntax_type,
+            formatted_range: None,
+        }
+    }
+
+    fn make_span_with_range(
+        syn_id: &str,
+        start: usize,
+        end: usize,
+        syntax_type: SyntaxType,
+        formatted_range: Range<usize>,
+    ) -> SyntaxSpanInfo {
+        SyntaxSpanInfo {
+            syn_id: syn_id.to_string(),
+            char_range: start..end,
+            syntax_type,
+            formatted_range: Some(formatted_range),
+        }
+    }
+
+    fn make_para(start: usize, end: usize, syntax_spans: Vec<SyntaxSpanInfo>) -> ParagraphRender {
+        ParagraphRender {
+            byte_range: start..end,
+            char_range: start..end,
+            html: String::new(),
+            offset_map: vec![],
+            syntax_spans,
+            source_hash: 0,
+        }
+    }
+
+    #[test]
+    fn test_inline_visibility_cursor_inside() {
+        // **bold** at chars 0-2 (opening **) and 6-8 (closing **)
+        // Text positions: 0-1 = **, 2-5 = bold, 6-7 = **
+        // formatted_range is 0..8 (the whole **bold** region)
+        let spans = vec![
+            make_span_with_range("s0", 0, 2, SyntaxType::Inline, 0..8), // opening **
+            make_span_with_range("s1", 6, 8, SyntaxType::Inline, 0..8), // closing **
+        ];
+        let paras = vec![make_para(0, 8, spans.clone())];
+
+        // Cursor at position 4 (middle of "bold", inside formatted region)
+        let vis = VisibilityState::calculate(4, None, &spans, &paras);
+        assert!(vis.is_visible("s0"), "opening ** should be visible when cursor inside formatted region");
+        assert!(vis.is_visible("s1"), "closing ** should be visible when cursor inside formatted region");
+
+        // Cursor at position 2 (adjacent to opening **, start of "bold")
+        let vis = VisibilityState::calculate(2, None, &spans, &paras);
+        assert!(vis.is_visible("s0"), "opening ** should be visible when cursor adjacent at start of bold");
+
+        // Cursor at position 5 (adjacent to closing **, end of "bold")
+        let vis = VisibilityState::calculate(5, None, &spans, &paras);
+        assert!(vis.is_visible("s1"), "closing ** should be visible when cursor adjacent at end of bold");
+    }
+
+    #[test]
+    fn test_inline_visibility_without_formatted_range() {
+        // Test without formatted_range - just adjacency-based visibility
+        let spans = vec![
+            make_span("s0", 0, 2, SyntaxType::Inline), // opening ** (no formatted_range)
+            make_span("s1", 6, 8, SyntaxType::Inline), // closing ** (no formatted_range)
+        ];
+        let paras = vec![make_para(0, 8, spans.clone())];
+
+        // Cursor at position 4 (middle of "bold", not adjacent to either marker)
+        let vis = VisibilityState::calculate(4, None, &spans, &paras);
+        assert!(!vis.is_visible("s0"), "opening ** should be hidden when no formatted_range and cursor not adjacent");
+        assert!(!vis.is_visible("s1"), "closing ** should be hidden when no formatted_range and cursor not adjacent");
+    }
+
+    #[test]
+    fn test_inline_visibility_cursor_adjacent() {
+        let spans = vec![
+            make_span("s0", 5, 7, SyntaxType::Inline), // ** at positions 5-6
+        ];
+        let paras = vec![make_para(0, 20, spans.clone())];
+
+        // Cursor at position 4 (one before ** which starts at 5)
+        let vis = VisibilityState::calculate(4, None, &spans, &paras);
+        assert!(vis.is_visible("s0"), "** should be visible when cursor adjacent");
+
+        // Cursor at position 7 (one after ** which ends at 6, since range is exclusive)
+        let vis = VisibilityState::calculate(7, None, &spans, &paras);
+        assert!(vis.is_visible("s0"), "** should be visible when cursor adjacent after span");
+    }
+
+    #[test]
+    fn test_inline_visibility_cursor_far() {
+        let spans = vec![
+            make_span("s0", 10, 12, SyntaxType::Inline),
+        ];
+        let paras = vec![make_para(0, 30, spans.clone())];
+
+        // Cursor at position 0 (far from **)
+        let vis = VisibilityState::calculate(0, None, &spans, &paras);
+        assert!(!vis.is_visible("s0"), "** should be hidden when cursor far away");
+    }
+
+    #[test]
+    fn test_block_visibility_same_paragraph() {
+        // # at start of heading
+        let spans = vec![
+            make_span("s0", 0, 2, SyntaxType::Block), // "# "
+        ];
+        let paras = vec![
+            make_para(0, 10, spans.clone()), // heading paragraph
+            make_para(12, 30, vec![]),       // next paragraph
+        ];
+
+        // Cursor at position 5 (inside heading)
+        let vis = VisibilityState::calculate(5, None, &spans, &paras);
+        assert!(vis.is_visible("s0"), "# should be visible when cursor in same paragraph");
+    }
+
+    #[test]
+    fn test_block_visibility_different_paragraph() {
+        let spans = vec![
+            make_span("s0", 0, 2, SyntaxType::Block),
+        ];
+        let paras = vec![
+            make_para(0, 10, spans.clone()),
+            make_para(12, 30, vec![]),
+        ];
+
+        // Cursor at position 20 (in second paragraph)
+        let vis = VisibilityState::calculate(20, None, &spans, &paras);
+        assert!(!vis.is_visible("s0"), "# should be hidden when cursor in different paragraph");
+    }
+
+    #[test]
+    fn test_selection_reveals_syntax() {
+        let spans = vec![
+            make_span("s0", 5, 7, SyntaxType::Inline),
+        ];
+        let paras = vec![make_para(0, 20, spans.clone())];
+
+        // Selection overlaps the syntax span
+        let selection = Selection { anchor: 3, head: 10 };
+        let vis = VisibilityState::calculate(10, Some(&selection), &spans, &paras);
+        assert!(vis.is_visible("s0"), "** should be visible when selection overlaps");
+    }
+}

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

···
     /// Paragraph boundaries in source: (byte_range, char_range)
     /// These are extracted during rendering by tracking Tag::Paragraph events
     pub paragraph_ranges: Vec<(Range<usize>, Range<usize>)>,
+
+    /// Syntax spans that can be conditionally hidden
+    pub syntax_spans: Vec<SyntaxSpanInfo>,
 }
 
 /// Classification of markdown syntax characters
-#[derive(Debug, Clone, Copy, PartialEq)]
-enum SyntaxClass {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SyntaxType {
     /// Inline formatting: **, *, ~~, `, $, [, ], (, )
     Inline,
     /// Block formatting: #, >, -, *, 1., ```, ---
     Block,
 }
 
+/// Information about a syntax span for conditional visibility
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SyntaxSpanInfo {
+    /// Unique identifier for this syntax span (e.g., "s0", "s1")
+    pub syn_id: String,
+    /// Source char range this syntax covers (just this marker)
+    pub char_range: Range<usize>,
+    /// Whether this is inline or block-level syntax
+    pub syntax_type: SyntaxType,
+    /// For paired inline syntax (**, *, etc), the full formatted region
+    /// from opening marker through content to closing marker.
+    /// When cursor is anywhere in this range, the syntax is visible.
+    pub formatted_range: Option<Range<usize>>,
+}
+
 /// Classify syntax text as inline or block level
-fn classify_syntax(text: &str) -> SyntaxClass {
+fn classify_syntax(text: &str) -> SyntaxType {
     let trimmed = text.trim_start();
 
     // Check for block-level markers
···
             .unwrap_or(false)
             && trimmed.contains('.')
     {
-        SyntaxClass::Block
+        SyntaxType::Block
     } else {
-        SyntaxClass::Inline
+        SyntaxType::Inline
     }
 }
 
···
 
     // Paragraph boundary tracking for incremental rendering
     paragraph_ranges: Vec<(Range<usize>, Range<usize>)>, // (byte_range, char_range)
-    current_paragraph_start: Option<(usize, usize)>, // (byte_offset, char_offset)
+    current_paragraph_start: Option<(usize, usize)>,     // (byte_offset, char_offset)
+    list_depth: usize, // Track nesting depth to avoid paragraph boundary override inside lists
 
     /// When true, skip HTML generation and only track paragraph boundaries.
     /// Used for fast boundary discovery in incremental rendering.
     boundary_only: bool,
+
+    // Syntax span tracking for conditional visibility
+    syntax_spans: Vec<SyntaxSpanInfo>,
+    next_syn_id: usize,
+    /// Stack of pending inline formats: (syn_id of opening span, char start of region)
+    /// Used to set formatted_range when closing paired inline markers
+    pending_inline_formats: Vec<(String, usize)>,
 
     _phantom: std::marker::PhantomData<&'a ()>,
 }
···
         writer: W,
         node_id_offset: usize,
     ) -> Self {
+        Self::new_with_offsets(source, source_rope, events, writer, node_id_offset, 0)
+    }
+
+    pub fn new_with_offsets(
+        source: &'a str,
+        source_rope: &'a JumpRopeBuf,
+        events: I,
+        writer: W,
+        node_id_offset: usize,
+        syn_id_offset: usize,
+    ) -> Self {
         Self {
             source,
             source_rope,
···
             current_node_child_count: 0,
             paragraph_ranges: Vec::new(),
             current_paragraph_start: None,
+            list_depth: 0,
             boundary_only: false,
+            syntax_spans: Vec::new(),
+            next_syn_id: syn_id_offset,
+            pending_inline_formats: Vec::new(),
             _phantom: std::marker::PhantomData,
         }
     }
···
             current_node_id: None,
             current_node_char_offset: 0,
             current_node_child_count: 0,
+            syntax_spans: Vec::new(),
+            next_syn_id: 0,
+            pending_inline_formats: Vec::new(),
             paragraph_ranges: Vec::new(),
             current_paragraph_start: None,
+            list_depth: 0,
             boundary_only: true,
             _phantom: std::marker::PhantomData,
         }
···
             current_node_child_count: self.current_node_child_count,
             paragraph_ranges: self.paragraph_ranges,
             current_paragraph_start: self.current_paragraph_start,
+            list_depth: self.list_depth,
             boundary_only: self.boundary_only,
+            syntax_spans: self.syntax_spans,
+            next_syn_id: self.next_syn_id,
+            pending_inline_formats: self.pending_inline_formats,
             _phantom: std::marker::PhantomData,
         }
     }
···
         self.writer.write_str(s)
     }
 
+    /// Generate a unique syntax span ID
+    fn gen_syn_id(&mut self) -> String {
+        let id = format!("s{}", self.next_syn_id);
+        self.next_syn_id += 1;
+        id
+    }
+
+    /// Finalize a paired inline format (Strong, Emphasis, Strikethrough).
+    /// Pops the pending format info and sets formatted_range on both opening and closing spans.
+    fn finalize_paired_inline_format(&mut self) {
+        if let Some((opening_syn_id, format_start)) = self.pending_inline_formats.pop() {
+            let format_end = self.last_char_offset;
+            let formatted_range = format_start..format_end;
+
+            // Update the opening span's formatted_range
+            if let Some(opening_span) = self
+                .syntax_spans
+                .iter_mut()
+                .find(|s| s.syn_id == opening_syn_id)
+            {
+                opening_span.formatted_range = Some(formatted_range.clone());
+            }
+
+            // Update the closing span's formatted_range (the most recent one)
+            // The closing syntax was just emitted by emit_gap_before, so it's the last span
+            if let Some(closing_span) = self.syntax_spans.last_mut() {
+                // Only update if it's an inline span (closing syntax should be inline)
+                if closing_span.syntax_type == SyntaxType::Inline {
+                    closing_span.formatted_range = Some(formatted_range);
+                }
+            }
+        }
+    }
+
     /// Emit syntax span for a given range and record offset mapping
     fn emit_syntax(&mut self, range: Range<usize>) -> Result<(), W::Error> {
         if range.start < range.end {
···
             if !syntax.is_empty() {
                 let char_start = self.last_char_offset;
                 let syntax_char_len = syntax.chars().count();
+                let char_end = char_start + syntax_char_len;
 
                 // In boundary_only mode, just update offsets without HTML
                 if self.boundary_only {
-                    self.last_char_offset = char_start + syntax_char_len;
+                    self.last_char_offset = char_end;
                     self.last_byte_offset = range.end;
                     return Ok(());
                 }
 
-                let class = match classify_syntax(syntax) {
-                    SyntaxClass::Inline => "md-syntax-inline",
-                    SyntaxClass::Block => "md-syntax-block",
+                let syntax_type = classify_syntax(syntax);
+                let class = match syntax_type {
+                    SyntaxType::Inline => "md-syntax-inline",
+                    SyntaxType::Block => "md-syntax-block",
                 };
 
+                // Generate unique ID for this syntax span
+                let syn_id = self.gen_syn_id();
+
                 // If we're outside any node, create a wrapper span for tracking
                 let created_node = if self.current_node_id.is_none() {
                     let node_id = self.gen_node_id();
                     write!(
                         &mut self.writer,
-                        "<span id=\"{}\" class=\"{}\">",
-                        node_id, class
+                        "<span id=\"{}\" class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        node_id, class, syn_id, char_start, char_end
                     )?;
                     self.begin_node(node_id);
                     true
                 } else {
-                    self.write("<span class=\"")?;
-                    self.write(class)?;
-                    self.write("\">")?;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        class, syn_id, char_start, char_end
+                    )?;
                     false
                 };
 
                 escape_html(&mut self.writer, syntax)?;
                 self.write("</span>")?;
 
+                // Record syntax span info for visibility toggling
+                self.syntax_spans.push(SyntaxSpanInfo {
+                    syn_id,
+                    char_range: char_start..char_end,
+                    syntax_type,
+                    formatted_range: None,
+                });
+
                 // Record offset mapping for this syntax
-                self.record_mapping(range.clone(), char_start..char_start + syntax_char_len);
-                let new_char = char_start + syntax_char_len;
-                let new_byte = range.end;
-                tracing::debug!("[EMIT_SYNTAX] Updating offsets: last_char {} -> {}, last_byte {} -> {}",
-                    self.last_char_offset, new_char, self.last_byte_offset, new_byte);
-                self.last_char_offset = new_char;
-                self.last_byte_offset = new_byte; // Mark bytes as processed
+                self.record_mapping(range.clone(), char_start..char_end);
+                tracing::debug!(
+                    "[EMIT_SYNTAX] Updating offsets: last_char {} -> {}, last_byte {} -> {}",
+                    self.last_char_offset,
+                    char_end,
+                    self.last_byte_offset,
+                    range.end
+                );
+                self.last_char_offset = char_end;
+                self.last_byte_offset = range.end; // Mark bytes as processed
 
                 // Close wrapper if we created one
                 if created_node {
···
         &mut self,
         syntax: &str,
         byte_start: usize,
-        class: SyntaxClass,
+        syntax_type: SyntaxType,
     ) -> Result<(), W::Error> {
         if syntax.is_empty() {
             return Ok(());
···
 
         let char_start = self.last_char_offset;
         let syntax_char_len = syntax.chars().count();
+        let char_end = char_start + syntax_char_len;
         let byte_end = byte_start + syntax.len();
 
         // In boundary_only mode, just update offsets
         if self.boundary_only {
-            self.last_char_offset = char_start + syntax_char_len;
+            self.last_char_offset = char_end;
             self.last_byte_offset = byte_end;
             return Ok(());
         }
 
-        let class_str = match class {
-            SyntaxClass::Inline => "md-syntax-inline",
-            SyntaxClass::Block => "md-syntax-block",
+        let class_str = match syntax_type {
+            SyntaxType::Inline => "md-syntax-inline",
+            SyntaxType::Block => "md-syntax-block",
         };
 
-        self.write("<span class=\"")?;
-        self.write(class_str)?;
-        self.write("\">")?;
+        // Generate unique ID for this syntax span
+        let syn_id = self.gen_syn_id();
+
+        write!(
+            &mut self.writer,
+            "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+            class_str, syn_id, char_start, char_end
+        )?;
         escape_html(&mut self.writer, syntax)?;
         self.write("</span>")?;
 
+        // Record syntax span info for visibility toggling
+        self.syntax_spans.push(SyntaxSpanInfo {
+            syn_id,
+            char_range: char_start..char_end,
+            syntax_type,
+            formatted_range: None,
+        });
+
         // Record offset mapping for cursor positioning
-        self.record_mapping(
-            byte_start..byte_end,
-            char_start..char_start + syntax_char_len,
-        );
+        self.record_mapping(byte_start..byte_end, char_start..char_end);
 
-        self.last_char_offset = char_start + syntax_char_len;
+        self.last_char_offset = char_end;
         self.last_byte_offset = byte_end;
 
         Ok(())
···
     pub fn run(mut self) -> Result<WriterResult, W::Error> {
         while let Some((event, range)) = self.events.next() {
             // Log events for debugging
-            tracing::debug!("[WRITER] Event: {:?}, range: {:?}, last_byte: {}, last_char: {}",
-                match &event {
-                    Event::Start(tag) => format!("Start({:?})", tag),
-                    Event::End(tag) => format!("End({:?})", tag),
-                    Event::Text(t) => format!("Text('{}')", t),
-                    Event::Code(t) => format!("Code('{}')", t),
-                    Event::Html(t) => format!("Html('{}')", t),
-                    Event::InlineHtml(t) => format!("InlineHtml('{}')", t),
-                    Event::FootnoteReference(t) => format!("FootnoteReference('{}')", t),
-                    Event::SoftBreak => "SoftBreak".to_string(),
-                    Event::HardBreak => "HardBreak".to_string(),
-                    Event::Rule => "Rule".to_string(),
-                    Event::TaskListMarker(b) => format!("TaskListMarker({})", b),
-                    Event::WeaverBlock(t) => format!("WeaverBlock('{}')", t),
-                    Event::InlineMath(t) => format!("InlineMath('{}')", t),
-                    Event::DisplayMath(t) => format!("DisplayMath('{}')", t),
-                },
-                &range,
-                self.last_byte_offset,
-                self.last_char_offset
-            );
+            // tracing::debug!("[WRITER] Event: {:?}, range: {:?}, last_byte: {}, last_char: {}",
+            //     match &event {
+            //         Event::Start(tag) => format!("Start({:?})", tag),
+            //         Event::End(tag) => format!("End({:?})", tag),
+            //         Event::Text(t) => format!("Text('{}')", t),
+            //         Event::Code(t) => format!("Code('{}')", t),
+            //         Event::Html(t) => format!("Html('{}')", t),
+            //         Event::InlineHtml(t) => format!("InlineHtml('{}')", t),
+            //         Event::FootnoteReference(t) => format!("FootnoteReference('{}')", t),
+            //         Event::SoftBreak => "SoftBreak".to_string(),
+            //         Event::HardBreak => "HardBreak".to_string(),
+            //         Event::Rule => "Rule".to_string(),
+            //         Event::TaskListMarker(b) => format!("TaskListMarker({})", b),
+            //         Event::WeaverBlock(t) => format!("WeaverBlock('{}')", t),
+            //         Event::InlineMath(t) => format!("InlineMath('{}')", t),
+            //         Event::DisplayMath(t) => format!("DisplayMath('{}')", t),
+            //     },
+            //     &range,
+            //     self.last_byte_offset,
+            //     self.last_char_offset
+            // );
 
             // For End events, emit any trailing content within the event's range
             // BEFORE calling end_tag (which calls end_node and clears current_node_id)
···
                     let char_start = self.last_char_offset;
                     let trailing_char_len = trailing.chars().count();
 
-                    self.write("<span class=\"md-syntax-inline\">")?;
+                    let char_end = char_start + trailing_char_len;
+                    let syn_id = self.gen_syn_id();
+
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        syn_id, char_start, char_end
+                    )?;
                     escape_html(&mut self.writer, trailing)?;
                     self.write("</span>")?;
 
+                    // Record syntax span info
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
+
                     // Record mapping if we have a node
                     if let Some(ref node_id) = self.current_node_id {
                         let mapping = OffsetMapping {
                             byte_range: self.last_byte_offset..doc_byte_len,
-                            char_range: char_start..char_start + trailing_char_len,
+                            char_range: char_start..char_end,
                             node_id: node_id.clone(),
                             char_offset_in_node: self.current_node_char_offset,
                             child_index: None,
···
         Ok(WriterResult {
             offset_maps: self.offset_maps,
             paragraph_ranges: self.paragraph_ranges,
+            syntax_spans: self.syntax_spans,
         })
     }
 
···
                     } else {
                         // First text in code block - start tracking
                         self.code_buffer_byte_range = Some(range.clone());
-                        self.code_buffer_char_range = Some(self.last_char_offset..self.last_char_offset + text_char_len);
+                        self.code_buffer_char_range =
+                            Some(self.last_char_offset..self.last_char_offset + text_char_len);
                     }
                     // Update offsets so paragraph boundary is correct
                     self.last_char_offset += text_char_len;
···
 
                 // Emit opening backtick and track it
                 if raw_text.starts_with('`') {
-                    self.write("<span class=\"md-syntax-inline\">`</span>")?;
+                    let syn_id = self.gen_syn_id();
+                    let backtick_char_end = char_start + 1;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">`</span>",
+                        syn_id, char_start, backtick_char_end
+                    )?;
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..backtick_char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
                     self.last_char_offset += 1;
                 }
 
···
 
                 // Emit closing backtick and track it
                 if raw_text.ends_with('`') {
-                    self.write("<span class=\"md-syntax-inline\">`</span>")?;
+                    let syn_id = self.gen_syn_id();
+                    let backtick_char_start = self.last_char_offset;
+                    let backtick_char_end = backtick_char_start + 1;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">`</span>",
+                        syn_id, backtick_char_start, backtick_char_end
+                    )?;
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: backtick_char_start..backtick_char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
                     self.last_char_offset += 1;
                 }
             }
···
 
                 // Emit opening $ and track it
                 if raw_text.starts_with('$') {
-                    self.write("<span class=\"md-syntax-inline\">$</span>")?;
+                    let syn_id = self.gen_syn_id();
+                    let char_start = self.last_char_offset;
+                    let char_end = char_start + 1;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$</span>",
+                        syn_id, char_start, char_end
+                    )?;
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
                     self.last_char_offset += 1;
                 }
 
···
 
                 // Emit closing $ and track it
                 if raw_text.ends_with('$') {
-                    self.write("<span class=\"md-syntax-inline\">$</span>")?;
+                    let syn_id = self.gen_syn_id();
+                    let char_start = self.last_char_offset;
+                    let char_end = char_start + 1;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$</span>",
+                        syn_id, char_start, char_end
+                    )?;
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
                     self.last_char_offset += 1;
                 }
             }
···
 
                 // Emit opening $$ and track it
                 if raw_text.starts_with("$$") {
-                    self.write("<span class=\"md-syntax-inline\">$$</span>")?;
+                    let syn_id = self.gen_syn_id();
+                    let char_start = self.last_char_offset;
+                    let char_end = char_start + 2;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$$</span>",
+                        syn_id, char_start, char_end
+                    )?;
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
                     self.last_char_offset += 2;
                 }
 
···
 
                 // Emit closing $$ and track it
                 if raw_text.ends_with("$$") {
-                    self.write("<span class=\"md-syntax-inline\">$$</span>")?;
+                    let syn_id = self.gen_syn_id();
+                    let char_start = self.last_char_offset;
+                    let char_end = char_start + 2;
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">$$</span>",
+                        syn_id, char_start, char_end
+                    )?;
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
                     self.last_char_offset += 2;
                 }
             }
···
                     let spaces = &gap[..gap.len() - 1]; // everything except the \n
                     let char_start = self.last_char_offset;
                     let spaces_char_len = spaces.chars().count();
+                    let char_end = char_start + spaces_char_len;
 
                     // Emit and map the visible spaces
-                    self.write("<span class=\"md-syntax-inline\">")?;
+                    let syn_id = self.gen_syn_id();
+                    write!(
+                        &mut self.writer,
+                        "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                        syn_id, char_start, char_end
+                    )?;
                     escape_html(&mut self.writer, spaces)?;
                     self.write("</span>")?;
 
+                    // Record syntax span info
+                    self.syntax_spans.push(SyntaxSpanInfo {
+                        syn_id,
+                        char_range: char_start..char_end,
+                        syntax_type: SyntaxType::Inline,
+                        formatted_range: None,
+                    });
+
                     // Count this span as a child
                     self.current_node_child_count += 1;
 
                     self.record_mapping(
                         range.start..range.start + spaces.len(),
-                        char_start..char_start + spaces_char_len,
+                        char_start..char_end,
                     );
 
                     // Now the actual line break <br>
···
                             node_id: node_id.clone(),
                             char_offset_in_node: self.current_node_char_offset,
                             child_index: None, // text node - TreeWalker will find it
-                            utf16_len: 1, // zero-width space is 1 UTF-16 unit
+                            utf16_len: 1,      // zero-width space is 1 UTF-16 unit
                         };
                         self.offset_maps.push(mapping);
 
···
                     let raw_text = &self.source[range];
                     let trimmed = raw_text.trim();
                     if !trimmed.is_empty() {
-                        self.write("<span class=\"md-syntax-block\">")?;
+                        let syn_id = self.gen_syn_id();
+                        let char_start = self.last_char_offset;
+                        let char_len = trimmed.chars().count();
+                        let char_end = char_start + char_len;
+
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            syn_id, char_start, char_end
+                        )?;
                         escape_html(&mut self.writer, trimmed)?;
                         self.write("</span>\n")?;
+
+                        self.syntax_spans.push(SyntaxSpanInfo {
+                            syn_id,
+                            char_range: char_start..char_end,
+                            syntax_type: SyntaxType::Block,
+                            formatted_range: None,
+                        });
                     }
                 }
 
···
                     if let Some(bracket_pos) = raw_text.find('[') {
                         let end_pos = raw_text.find(']').map(|p| p + 1).unwrap_or(bracket_pos + 3);
                         let syntax = &raw_text[bracket_pos..end_pos.min(raw_text.len())];
-                        self.write("<span class=\"md-syntax-inline\">")?;
+
+                        let syn_id = self.gen_syn_id();
+                        let char_start = self.last_char_offset;
+                        let syntax_char_len = syntax.chars().count();
+                        let char_end = char_start + syntax_char_len;
+
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            syn_id, char_start, char_end
+                        )?;
                         escape_html(&mut self.writer, syntax)?;
                         self.write("</span> ")?;
+
+                        self.syntax_spans.push(SyntaxSpanInfo {
+                            syn_id,
+                            char_range: char_start..char_end,
+                            syntax_type: SyntaxType::Inline,
+                            formatted_range: None,
+                        });
                     }
                 }
 
···
             };
 
             if let Some(syntax) = opening_syntax {
-                let class = match classify_syntax(syntax) {
-                    SyntaxClass::Inline => "md-syntax-inline",
-                    SyntaxClass::Block => "md-syntax-block",
+                let syntax_type = classify_syntax(syntax);
+                let class = match syntax_type {
+                    SyntaxType::Inline => "md-syntax-inline",
+                    SyntaxType::Block => "md-syntax-block",
                 };
 
                 let char_start = self.last_char_offset;
                 let syntax_char_len = syntax.chars().count();
+                let char_end = char_start + syntax_char_len;
                 let syntax_byte_len = syntax.len();
 
-                self.write("<span class=\"")?;
-                self.write(class)?;
-                self.write("\">")?;
+                // Generate unique ID for this syntax span
+                let syn_id = self.gen_syn_id();
+
+                write!(
+                    &mut self.writer,
+                    "<span class=\"{}\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                    class, syn_id, char_start, char_end
+                )?;
                 escape_html(&mut self.writer, syntax)?;
                 self.write("</span>")?;
 
+                // Record syntax span info for visibility toggling
+                self.syntax_spans.push(SyntaxSpanInfo {
+                    syn_id: syn_id.clone(),
+                    char_range: char_start..char_end,
+                    syntax_type,
+                    formatted_range: None, // Will be updated when closing tag is emitted
+                });
+
+                // For paired inline syntax (Strong, Emphasis, Strikethrough),
+                // track the opening span so we can set formatted_range when closing
+                if matches!(tag, Tag::Strong | Tag::Emphasis | Tag::Strikethrough) {
+                    self.pending_inline_formats.push((syn_id, char_start));
+                }
+
                 // Update tracking - we've consumed this opening syntax
-                tracing::debug!("[START_TAG] Opening syntax '{}': last_char {} -> {}, last_byte {} -> {}",
-                    syntax, self.last_char_offset, char_start + syntax_char_len,
-                    self.last_byte_offset, range.start + syntax_byte_len);
-                self.last_char_offset = char_start + syntax_char_len;
+                tracing::debug!(
+                    "[START_TAG] Opening syntax '{}': last_char {} -> {}, last_byte {} -> {}",
+                    syntax,
+                    self.last_char_offset,
+                    char_end,
+                    self.last_byte_offset,
+                    range.start + syntax_byte_len
+                );
+                self.last_char_offset = char_end;
                 self.last_byte_offset = range.start + syntax_byte_len;
             }
         }
···
             Tag::HtmlBlock => Ok(()),
             Tag::Paragraph => {
                 // Record paragraph start for boundary tracking
-                self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                // BUT skip if inside a list - list owns the paragraph boundary
+                if self.list_depth == 0 {
+                    self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                }
 
                 let node_id = self.gen_node_id();
                 if self.end_newline {
···
 
                             let syntax = &raw_text[gt_pos..syntax_end];
                             let syntax_byte_start = bq_range.start + gt_pos;
-                            self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxClass::Block)?;
+                            self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxType::Block)?;
                         }
                     }
                 }
···
                         let syntax = &raw_text[hash_pos..syntax_end];
                         let syntax_byte_start = range.start + hash_pos;
 
-                        self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxClass::Block)?;
+                        self.emit_inner_syntax(syntax, syntax_byte_start, SyntaxType::Block)?;
                     }
                 }
                 Ok(())
···
                                 let syntax = &raw_text[fence_pos..fence_end];
                                 let syntax_char_len = syntax.chars().count() + 1; // +1 for newline
                                 let syntax_byte_len = syntax.len() + 1; // +1 for newline
-                                self.write("<span class=\"md-syntax-block\">")?;
+
+                                let syn_id = self.gen_syn_id();
+                                let char_start = self.last_char_offset;
+                                let char_end = char_start + syntax_char_len;
+
+                                write!(
+                                    &mut self.writer,
+                                    "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                    syn_id, char_start, char_end
+                                )?;
                                 escape_html(&mut self.writer, syntax)?;
                                 self.write("</span>\n")?;
+
+                                self.syntax_spans.push(SyntaxSpanInfo {
+                                    syn_id,
+                                    char_range: char_start..char_end,
+                                    syntax_type: SyntaxType::Block,
+                                    formatted_range: None,
+                                });
+
                                 self.last_char_offset += syntax_char_len;
                                 self.last_byte_offset = range.start + fence_pos + syntax_byte_len;
                             }
···
             Tag::List(Some(1)) => {
                 // Track list as paragraph-level block
                 self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                self.list_depth += 1;
                 if self.end_newline {
                     self.write("<ol>\n")
                 } else {
···
             Tag::List(Some(start)) => {
                 // Track list as paragraph-level block
                 self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                self.list_depth += 1;
                 if self.end_newline {
                     self.write("<ol start=\"")?;
                 } else {
···
             Tag::List(None) => {
                 // Track list as paragraph-level block
                 self.current_paragraph_start = Some((self.last_byte_offset, self.last_char_offset));
+                self.list_depth += 1;
                 if self.end_newline {
                     self.write("<ul>\n")
                 } else {
···
                             let char_start = self.last_char_offset;
                             let syntax_char_len = leading_ws_chars + syntax.chars().count();
                             let syntax_byte_len = leading_ws_bytes + syntax.len();
-                            self.write("<span class=\"md-syntax-block\">")?;
+                            let char_end = char_start + syntax_char_len;
+
+                            let syn_id = self.gen_syn_id();
+                            write!(
+                                &mut self.writer,
+                                "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                syn_id, char_start, char_end
+                            )?;
                             escape_html(&mut self.writer, syntax)?;
                             self.write("</span>")?;
+
+                            self.syntax_spans.push(SyntaxSpanInfo {
+                                syn_id,
+                                char_range: char_start..char_end,
+                                syntax_type: SyntaxType::Block,
+                                formatted_range: None,
+                            });
+
                             // Record offset mapping for cursor positioning
                             self.record_mapping(
                                 range.start..range.start + syntax_byte_len,
-                                char_start..char_start + syntax_char_len,
+                                char_start..char_end,
                             );
-                            self.last_char_offset = char_start + syntax_char_len;
+                            self.last_char_offset = char_end;
                             self.last_byte_offset = range.start + syntax_byte_len;
                         } else if marker.is_ascii_digit() {
-                            // Ordered list: extract "1. " or similar
+                            // Ordered list: extract "1. " or similar (including trailing space)
                             if let Some(dot_pos) = trimmed.find('.') {
                                 let syntax_end = (dot_pos + 2).min(trimmed.len());
-                                let syntax = &trimmed[..syntax_end].trim_end();
+                                let syntax = &trimmed[..syntax_end];
                                 let char_start = self.last_char_offset;
                                 let syntax_char_len = leading_ws_chars + syntax.chars().count();
                                 let syntax_byte_len = leading_ws_bytes + syntax.len();
-                                self.write("<span class=\"md-syntax-block\">")?;
+                                let char_end = char_start + syntax_char_len;
+
+                                let syn_id = self.gen_syn_id();
+                                write!(
+                                    &mut self.writer,
+                                    "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                    syn_id, char_start, char_end
+                                )?;
                                 escape_html(&mut self.writer, syntax)?;
                                 self.write("</span>")?;
+
+                                self.syntax_spans.push(SyntaxSpanInfo {
+                                    syn_id,
+                                    char_range: char_start..char_end,
+                                    syntax_type: SyntaxType::Block,
+                                    formatted_range: None,
+                                });
+
                                 // Record offset mapping for cursor positioning
                                 self.record_mapping(
                                     range.start..range.start + syntax_byte_len,
-                                    char_start..char_start + syntax_char_len,
+                                    char_start..char_end,
                                 );
-                                self.last_char_offset = char_start + syntax_char_len;
+                                self.last_char_offset = char_end;
                                 self.last_byte_offset = range.start + syntax_byte_len;
                             }
                         }
···
                 if range.start < range.end {
                     let raw_text = &self.source[range.clone()];
                     if raw_text.starts_with("![") {
-                        self.write("<span class=\"md-syntax-inline\">![</span>")?;
+                        let syn_id = self.gen_syn_id();
+                        let char_start = self.last_char_offset;
+                        let char_end = char_start + 2;
+
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">![</span>",
+                            syn_id, char_start, char_end
+                        )?;
+
+                        self.syntax_spans.push(SyntaxSpanInfo {
+                            syn_id,
+                            char_range: char_start..char_end,
+                            syntax_type: SyntaxType::Inline,
+                            formatted_range: None,
+                        });
                     }
                 }
 
···
                     let raw_text = &self.source[range];
                     if let Some(paren_pos) = raw_text.rfind("](") {
                         let syntax = &raw_text[paren_pos..];
-                        self.write("<span class=\"md-syntax-inline\">")?;
+                        let syn_id = self.gen_syn_id();
+                        let char_start = self.last_char_offset;
+                        let syntax_char_len = syntax.chars().count();
+                        let char_end = char_start + syntax_char_len;
+
+                        write!(
+                            &mut self.writer,
+                            "<span class=\"md-syntax-inline\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                            syn_id, char_start, char_end
+                        )?;
                         escape_html(&mut self.writer, syntax)?;
                         self.write("</span>")?;
+
+                        self.syntax_spans.push(SyntaxSpanInfo {
+                            syn_id,
+                            char_range: char_start..char_end,
+                            syntax_type: SyntaxType::Inline,
+                            formatted_range: None,
+                        });
                     }
                 }
                 Ok(())
···
             TagEnd::HtmlBlock => Ok(()),
             TagEnd::Paragraph => {
                 // Record paragraph end for boundary tracking
-                if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
-                    let byte_range = byte_start..self.last_byte_offset;
-                    let char_range = char_start..self.last_char_offset;
-                    self.paragraph_ranges.push((byte_range, char_range));
+                // BUT skip if inside a list - list owns the paragraph boundary
+                if self.list_depth == 0 {
+                    if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
+                        let byte_range = byte_start..self.last_byte_offset;
+                        let char_range = char_start..self.last_char_offset;
+                        self.paragraph_ranges.push((byte_range, char_range));
+                    }
                 }
 
                 self.end_node();
···
 
                 if let Some((lang, buffer)) = self.code_buffer.take() {
                     // Create offset mapping for code block content if we tracked ranges
-                    if let (Some(code_byte_range), Some(code_char_range)) =
-                        (self.code_buffer_byte_range.take(), self.code_buffer_char_range.take()) {
+                    if let (Some(code_byte_range), Some(code_char_range)) = (
+                        self.code_buffer_byte_range.take(),
+                        self.code_buffer_char_range.take(),
+                    ) {
                         // Record mapping before writing HTML
                         // (current_node_id should be set by start_tag for CodeBlock)
                         self.record_mapping(code_byte_range, code_char_range);
···
                         if fence_line.trim().starts_with("```") {
                             let fence = fence_line.trim();
                             let fence_char_len = fence.chars().count();
-                            self.write("<span class=\"md-syntax-block\">")?;
+
+                            let syn_id = self.gen_syn_id();
+                            let char_start = self.last_char_offset;
+                            let char_end = char_start + fence_char_len;
+
+                            write!(
+                                &mut self.writer,
+                                "<span class=\"md-syntax-block\" data-syn-id=\"{}\" data-char-start=\"{}\" data-char-end=\"{}\">",
+                                syn_id, char_start, char_end
+                            )?;
                             escape_html(&mut self.writer, fence)?;
                             self.write("</span>")?;
+
+                            self.syntax_spans.push(SyntaxSpanInfo {
+                                syn_id,
+                                char_range: char_start..char_end,
+                                syntax_type: SyntaxType::Block,
+                                formatted_range: None,
+                            });
+
                             self.last_char_offset += fence_char_len;
                             self.last_byte_offset += fence.len();
                         }
···
                 Ok(())
             }
             TagEnd::List(true) => {
+                self.list_depth = self.list_depth.saturating_sub(1);
                 // Record list end for paragraph boundary tracking
                 if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
                     let byte_range = byte_start..self.last_byte_offset;
···
                 self.write("</ol>\n")
             }
             TagEnd::List(false) => {
+                self.list_depth = self.list_depth.saturating_sub(1);
                 // Record list end for paragraph boundary tracking
                 if let Some((byte_start, char_start)) = self.current_paragraph_start.take() {
                     let byte_range = byte_start..self.last_byte_offset;
···
                 self.end_node();
                 self.write("</dd>\n")
             }
-            TagEnd::Emphasis => self.write("</em>"),
+            TagEnd::Emphasis => {
+                self.finalize_paired_inline_format();
+                self.write("</em>")
+            }
             TagEnd::Superscript => self.write("</sup>"),
             TagEnd::Subscript => self.write("</sub>"),
-            TagEnd::Strong => self.write("</strong>"),
-            TagEnd::Strikethrough => self.write("</s>"),
+            TagEnd::Strong => {
+                self.finalize_paired_inline_format();
+                self.write("</strong>")
+            }
+            TagEnd::Strikethrough => {
+                self.finalize_paired_inline_format();
+                self.write("</s>")
+            }
             TagEnd::Link => self.write("</a>"),
             TagEnd::Image => Ok(()), // No-op: raw_text() already consumed the End(Image) event
             TagEnd::Embed => Ok(()),