Removed the lazy submodules

Also some new lexicons related to loro CRDT format

.zed/settings.json

···
         }
       }
     }
-  },
-  "rust-analyzer": {
-    "binary": {
-      "path_lookup": true
-    }
   }
 }

Cargo.lock

···
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
 [[package]]
 name = "block-buffer"
···
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
 [[package]]
-name = "camino"
-version = "1.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
-
-[[package]]
 name = "castaway"
 version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "cc"
-version = "1.2.22"
+version = "1.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32db95edf998450acc7881c932f94cd9b05c87b4b2599e8bab064753da4acfd1"
+checksum = "5f4ac86a9e5bc1e2b3449ab9d7d3a6a405e3d1bb28d7b9be8614f55846ae3766"
 dependencies = [
  "shlex",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff3e1edb1f37b4953dd5176916347289ed43d7119cc2e6c7c3f7849ff44ea506"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "byteorder",
  "chrono",
  "diesel_derives",
···
 ]
 
 [[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "displaydoc"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "errno"
-version = "0.3.11"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
 dependencies = [
  "libc",
  "windows-sys 0.59.0",
···
 checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
 
 [[package]]
-name = "fallible-iterator"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
-
-[[package]]
-name = "fallible-streaming-iterator"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
-
-[[package]]
 name = "fastrand"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "generator"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc6bd114ceda131d3b1d665eba35788690ad37f5916457286b32ab6fd3c438dd"
+checksum = "d18470a76cb7f8ff746cf1f7470914f900252ec36bbc40b569d74b1258446827"
 dependencies = [
+ "cc",
  "cfg-if",
  "libc",
  "log",
···
 checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi",
  "wasi 0.14.2+wasi-0.2.4",
+ "wasm-bindgen",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
-dependencies = [
- "hashbrown 0.14.5",
-]
-
-[[package]]
 name = "heck"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "inotify-sys",
  "libc",
 ]
···
 ]
 
 [[package]]
-name = "lexical-parse-float"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683b3a5ebd0130b8fb52ba0bdc718cc56815b6a097e28ae5a6997d0ad17dc05f"
-dependencies = [
- "lexical-parse-integer",
- "lexical-util",
- "static_assertions",
-]
-
-[[package]]
-name = "lexical-parse-integer"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d0994485ed0c312f6d965766754ea177d07f9c00c9b82a5ee62ed5b47945ee9"
-dependencies = [
- "lexical-util",
- "static_assertions",
-]
-
-[[package]]
-name = "lexical-util"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5255b9ff16ff898710eb9eb63cb39248ea8a5bb036bea8085b1a767ff6c4e3fc"
-dependencies = [
- "static_assertions",
-]
-
-[[package]]
 name = "libc"
 version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "libc",
  "redox_syscall",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
 dependencies = [
- "cc",
  "pkg-config",
  "vcpkg",
 ]
···
 ]
 
 [[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
 name = "markdown-weaver"
 version = "0.13.0"
-source = "git+https://github.com/rsform/markdown-weaver#34bc7ad2d7e6e9b9604ba61602b68589f271404e"
+source = "git+https://github.com/rsform/markdown-weaver#593f968ec3c4515c23273715eaeb33801342439b"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "getopts",
  "markdown-weaver-escape",
  "memchr",
- "serde",
  "unicase",
 ]
 
 [[package]]
 name = "markdown-weaver-escape"
 version = "0.11.0"
-source = "git+https://github.com/rsform/markdown-weaver#34bc7ad2d7e6e9b9604ba61602b68589f271404e"
+source = "git+https://github.com/rsform/markdown-weaver#593f968ec3c4515c23273715eaeb33801342439b"
 
 [[package]]
 name = "matchers"
···
 
 [[package]]
 name = "merde"
-version = "10.0.6"
+version = "10.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ec14139b169a3bb101da2dd8c0c2e47ddaf63000075662635c64c985bb5ae7b"
+checksum = "edd8dc7668eb89ede52dc09d4b21a8c2f7c9cd47168ea1f82550f705615d9b99"
 dependencies = [
  "merde_core",
- "merde_json",
- "merde_msgpack",
  "merde_yaml",
 ]
 
 [[package]]
 name = "merde_core"
-version = "10.0.5"
+version = "10.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714d8f25279d095f8d23392476e2e82427e8689348e34f90ddc0712497e157de"
+checksum = "e937026f22a5a3567bc402f1edf871ecab0e0222cd6f829ea58abae0185e759c"
 dependencies = [
- "camino",
  "compact_bytes",
  "compact_str",
- "ordered-float 4.6.0",
- "rusqlite",
+ "ordered-float 5.0.0",
  "serde",
- "time",
-]
-
-[[package]]
-name = "merde_json"
-version = "10.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d354c179fe95a0568c8ffb95c276f73556ecb95edca76f742505320e7545cea9"
-dependencies = [
- "itoa",
- "lexical-parse-float",
- "merde_core",
- "ryu",
-]
-
-[[package]]
-name = "merde_msgpack"
-version = "10.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b710370fee77ca3cb8e6666a2586f26f3a653d7b2e338ede77a13c99108c5e"
-dependencies = [
- "merde_core",
- "rmp",
 ]
 
 [[package]]
 name = "merde_yaml"
-version = "10.0.5"
+version = "10.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb581c31249876b3b385a2cc50fafc666adc9c316874819b7aac7266b3c26c17"
+checksum = "7c36f61da594ecad0ed986ceeb5061eba47a36fcf839576ce525c7e4ff08f3fa"
 dependencies = [
  "merde_core",
  "yaml-rust2",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fee8403b3d66ac7b26aee6e40a897d85dc5ce26f44da36b8b73e987cc52e943"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "filetime",
  "fsevent-sys",
  "inotify",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "cfg-if",
  "foreign-types",
  "libc",
···
 ]
 
 [[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
 name = "ordered-float"
 version = "2.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "ordered-float"
-version = "4.6.0"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
+checksum = "e2c1f9f56e534ac6a9b8a4600bdf0f530fb393b5f393e7b4d03489c3cf0c3f01"
 dependencies = [
  "num-traits",
 ]
···
 
 [[package]]
 name = "owo-colors"
-version = "4.2.0"
+version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1036865bb9422d3300cf723f657c2851d0e9ab12567854b1f4eba3d77decf564"
+checksum = "26995317201fa17f3656c36716aed4a7c81743a9634ac4c99c0eeda495db0cec"
 
 [[package]]
 name = "p256"
···
 ]
 
 [[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
-[[package]]
 name = "pem-rfc7468"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "base64 0.22.1",
  "byteorder",
  "bytes",
- "fallible-iterator 0.2.0",
+ "fallible-iterator",
  "hmac",
  "md-5",
  "memchr",
···
 checksum = "613283563cd90e1dfc3518d548caee47e0e725455ed619881f5cf21f36de4b48"
 dependencies = [
  "bytes",
- "fallible-iterator 0.2.0",
+ "fallible-iterator",
  "postgres-protocol",
 ]
 
···
 
 [[package]]
 name = "quinn"
-version = "0.11.6"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62e96808277ec6f97351a2380e6c25114bc9e67037775464979f3037c92d05ef"
+checksum = "626214629cda6781b6dc1d316ba307189c85ba657213ce642d9c77670f8202c8"
 dependencies = [
  "bytes",
+ "cfg_aliases",
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
···
  "thiserror 2.0.12",
  "tokio",
  "tracing",
+ "web-time",
 ]
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.9"
+version = "0.11.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2fe5ef3495d7d2e377ff17b1a8ce2ee2ec2a18cde8b6ad6619d65d0701c135d"
+checksum = "49df843a9161c85bb8aae55f101bc0bac8bcafd637a620d9122fd7e0b2f7422e"
 dependencies = [
  "bytes",
- "getrandom 0.2.16",
- "rand 0.8.5",
+ "getrandom 0.3.3",
+ "lru-slab",
+ "rand 0.9.1",
  "ring 0.17.14",
  "rustc-hash",
  "rustls 0.23.27",
···
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.9"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c40286217b4ba3a71d644d752e6a0b71f13f1b6a2c5311acfcbe0c2418ed904"
+checksum = "ee4e529991f949c5e25755532370b8af5d114acae52326361d68d47af64aa842"
 dependencies = [
  "cfg_aliases",
  "libc",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
+dependencies = [
+ "getrandom 0.2.16",
+ "libredox",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "rmp"
-version = "0.8.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "228ed7c16fa39782c3b3468e974aec2795e9089153cd08ee2e9aefb3613334c4"
-dependencies = [
- "byteorder",
- "num-traits",
- "paste",
-]
-
-[[package]]
 name = "rouille"
 version = "3.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "rusqlite"
-version = "0.32.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e"
-dependencies = [
- "bitflags 2.9.0",
- "fallible-iterator 0.3.0",
- "fallible-streaming-iterator",
- "hashlink 0.9.1",
- "libsqlite3-sys",
- "smallvec",
-]
-
-[[package]]
 name = "rustc-demangle"
 version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "core-foundation",
  "core-foundation-sys",
  "libc",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "core-foundation",
  "system-configuration-sys",
 ]
···
  "async-trait",
  "byteorder",
  "bytes",
- "fallible-iterator 0.2.0",
+ "fallible-iterator",
  "futures-channel",
  "futures-util",
  "log",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fdb0c213ca27a9f57ab69ddb290fd80d970922355b83ae380b395d3986b8a2e"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
  "bytes",
  "futures-util",
  "http",
···
  "atrium-oauth",
  "atrium-xrpc-client",
  "clap",
+ "dirs",
  "esquema-codegen",
  "hickory-resolver",
  "miette",
···
  "atrium-identity",
  "atrium-oauth",
  "atrium-xrpc",
+ "dirs",
  "esquema-codegen",
  "hickory-resolver",
  "http",
  "jose-jwk",
- "libsqlite3-sys",
  "markdown-weaver",
  "merde",
  "miette",
···
 dependencies = [
  "atrium-api",
  "compact_string",
+ "http",
  "n0-future",
+ "url",
  "weaver-common",
  "weaver-workspace-hack",
 ]
···
  "group",
  "hashbrown 0.15.3",
  "idna",
- "libsqlite3-sys",
  "log",
  "memchr",
  "miette",
···
 
 [[package]]
 name = "windows"
-version = "0.58.0"
+version = "0.61.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
+dependencies = [
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-link",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
  "windows-core",
- "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-core"
-version = "0.58.0"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+checksum = "46ec44dc15085cea82cf9c78f85a9114c463a369786585ad2882d1ff0b0acf40"
 dependencies = [
  "windows-implement",
  "windows-interface",
- "windows-result 0.2.0",
- "windows-strings 0.1.0",
- "windows-targets 0.52.6",
+ "windows-link",
+ "windows-result",
+ "windows-strings 0.4.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core",
+ "windows-link",
+ "windows-threading",
 ]
 
 [[package]]
 name = "windows-implement"
-version = "0.58.0"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "windows-interface"
-version = "0.58.0"
+version = "0.59.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
 dependencies = [
  "proc-macro2",
  "quote",
···
 checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
-name = "windows-registry"
-version = "0.4.0"
+name = "windows-numerics"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4286ad90ddb45071efd1a66dfa43eb02dd0dfbae1545ad6cc3c51cf34d7e8ba3"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
- "windows-result 0.3.2",
- "windows-strings 0.3.1",
- "windows-targets 0.53.0",
+ "windows-core",
+ "windows-link",
 ]
 
 [[package]]
-name = "windows-result"
-version = "0.2.0"
+name = "windows-registry"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+checksum = "4286ad90ddb45071efd1a66dfa43eb02dd0dfbae1545ad6cc3c51cf34d7e8ba3"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-result",
+ "windows-strings 0.3.1",
+ "windows-targets 0.53.0",
 ]
 
 [[package]]
 name = "windows-result"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+checksum = "4b895b5356fc36103d0f64dd1e94dfa7ac5633f1c9dd6e80fe9ec4adef69e09d"
 dependencies = [
  "windows-link",
 ]
 
 [[package]]
 name = "windows-strings"
-version = "0.1.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
 dependencies = [
- "windows-result 0.2.0",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
 name = "windows-strings"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
+checksum = "2a7ab927b2637c19b3dbe0965e75d8f2d30bdd697a1516191cad2ec4df8fb28a"
 dependencies = [
  "windows-link",
 ]
···
  "windows_x86_64_gnu 0.53.0",
  "windows_x86_64_gnullvm 0.53.0",
  "windows_x86_64_msvc 0.53.0",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
···
 checksum = "8902160c4e6f2fb145dbe9d6760a75e3c9522d8bf796ed7047c85919ac7115f8"
 dependencies = [
  "arraydeque",
- "hashlink 0.8.4",
+ "hashlink",
 ]
 
 [[package]]

Cargo.toml

···
 [workspace.dependencies]
 
 serde = { version = "1.0", features = ["derive"] }
-merde = { version = "10.0.6", features = ["full"] }
+merde = { version = "10.0.6" }
 
 minijinja = { version = "2.9.0", default-features = false }
 minijinja-contrib = { version = "2.9.0", default-features = false }

crates/weaver-cli/Cargo.toml

···
 [dependencies]
 clap = { version = "4.5", features = ["derive", "env", "cargo", "unicode"] }
 n0-future = { workspace = true }
-weaver-common = { path = "../weaver-common" }
+weaver-common = { path = "../weaver-common", features = ["native"] }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
 miette = { workspace = true, features = ["fancy"] }
 
···
 # temp for testing
 tokio = { version = "1.45.0", features = ["full"] }
 rouille = { version = "3.6.2", features = ["rustls"] }
+dirs = "6.0.0"

crates/weaver-cli/src/main.rs

···
-use atrium_api::agent::Agent;
+use atrium_api::types::string::Did;
 use atrium_oauth::AuthorizeOptions;
 use atrium_oauth::CallbackParams;
 use atrium_oauth::KnownScope;
 use atrium_oauth::Scope;
+use miette::miette;
+use miette::{IntoDiagnostic, Result};
 use rouille::Server;
-use std::error;
+use std::path::Path;
+use std::path::PathBuf;
 use tokio::sync::mpsc;
 use weaver_common::agent::WeaverAgent;
 
+use clap::{Args, Parser, Subcommand};
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+#[command(propagate_version = true)]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Authenticate with your atproto PDS, using your handle or the URL of the PDS. You can also set the HANDLE environment variable.
+    Auth(AuthArgs),
+    /// Test the native oauth client
+    Run,
+}
+
+#[derive(Args)]
+struct AuthArgs {
+    handle: Option<String>,
+}
+
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn error::Error>> {
-    let (tx, mut rx) = mpsc::channel(5);
-    let server = Server::new("0.0.0.0:4000", move |request| {
-        create_callback_router(request, tx.clone())
-    })
-    .expect("Could not start server");
-    let (server_handle, server_stop) = server.stoppable();
-    let client = weaver_common::oauth::default_native_oauth_client()?;
-    println!(
-        "To authenticate with your PDS, visit:\r\n\t {}",
-        client
-            .authorize(
-                std::env::var("HANDLE").unwrap_or(String::from("https://atproto.systems")),
-                AuthorizeOptions {
-                    scopes: vec![
-                        Scope::Known(KnownScope::Atproto),
-                        Scope::Known(KnownScope::TransitionGeneric)
-                    ],
-                    ..Default::default()
-                }
-            )
-            .await?
-    );
+async fn main() -> Result<()> {
+    init_miette();
+    let args = Cli::parse();
+    let base_dir = weaver_common::filestore::config_dir();
+    tokio::fs::create_dir_all(&base_dir)
+        .await
+        .into_diagnostic()?;
+    let client = weaver_common::oauth::test_native_oauth_client().into_diagnostic()?;
+    let (session, server_handle) = if let Some(Commands::Auth(AuthArgs { handle })) = args.command {
+        let handle = handle.unwrap_or(String::from("https://atproto.systems"));
+        let (tx, mut rx) = mpsc::channel(5);
+        let server = Server::new("0.0.0.0:4000", move |request| {
+            create_callback_router(request, tx.clone())
+        })
+        .expect("Could not start server");
+        let (server_handle, server_stop) = server.stoppable();
 
-    let params = rx.recv().await.unwrap();
-    let (session, _) = client.callback(params).await?;
-    server_stop
-        .send(())
-        .expect("Failed to stop callback server");
+        println!(
+            "To authenticate with your PDS, visit:\r\n\t {}",
+            client
+                .authorize(
+                    handle,
+                    AuthorizeOptions {
+                        scopes: vec![
+                            Scope::Known(KnownScope::Atproto),
+                            Scope::Known(KnownScope::TransitionGeneric)
+                        ],
+                        ..Default::default()
+                    }
+                )
+                .await
+                .into_diagnostic()?
+        );
+
+        let params = rx.recv().await.unwrap();
+        let (session, _) = client.callback(params).await.into_diagnostic()?;
+        server_stop
+            .send(())
+            .expect("Failed to stop callback server");
+        Ok::<_, weaver_common::Error>((session, Some(server_handle)))
+    } else {
+        let did = find_session_did(base_dir).await?;
+        let session = client.restore(&did).await.into_diagnostic()?;
+        Ok((session, None))
+    }?;
+
     let agent = WeaverAgent::new(session);
     let output = agent
         .get_profile_pds(agent.did().await.unwrap().into())
         .await?;
     println!("{output:?}");
-
-    // let agent = Agent::new(session);
-    // let output = agent
-    //     .api
-    //     .app
-    //     .bsky
-    //     .feed
-    //     .get_timeline(
-    //         weaver_common::app::bsky::feed::get_timeline::ParametersData {
-    //             algorithm: None,
-    //             cursor: None,
-    //             limit: 3.try_into().ok(),
-    //         }
-    //         .into(),
-    //     )
-    //     .await?;
-    // for feed in &output.feed {
-    //     println!("{feed:?}");
-    // }
-    server_handle.join().unwrap();
+    if let Some(server_handle) = server_handle {
+        server_handle.join().unwrap();
+    }
     Ok(())
 }
 
···
             _ => rouille::Response::empty_404()
     )
 }
+
+pub async fn find_session_did(path: impl AsRef<Path>) -> Result<Did> {
+    let path = path.as_ref();
+    let mut dir = tokio::fs::read_dir(path).await.into_diagnostic()?;
+    while let Some(entry) = dir.next_entry().await.into_diagnostic()? {
+        let file_name = entry.file_name();
+        if let Some(file_name) = file_name.to_str() {
+            if file_name.ends_with("_session.json") {
+                let did_string = file_name
+                    .strip_suffix("_session.json")
+                    .expect("we JUST checked the suffix lol")
+                    .to_string();
+                let did = Did::new(did_string).expect("we should only be writing valid dids");
+                return Ok(did);
+            }
+        }
+    }
+    Err(miette!("couldn't find any existing sessions!"))
+}
+
+fn init_miette() {
+    miette::set_hook(Box::new(|_| {
+        Box::new(
+            miette::MietteHandlerOpts::new()
+                .terminal_links(true)
+                //.rgb_colors(miette::RgbColors::)
+                .with_cause_chain()
+                .with_syntax_highlighting(miette::highlighters::SyntectHighlighter::default())
+                .color(true)
+                .context_lines(5)
+                .tab_width(2)
+                .break_words(true)
+                .build(),
+        )
+    }))
+    .expect("couldn't set the miette hook");
+    miette::set_panic_hook();
+}

crates/weaver-common/Cargo.toml

···
 [features]
 default = ["dev"]
 dev = []
+native = ["tokio"]
 
 [dependencies]
 n0-future = { workspace = true }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
 markdown-weaver = { workspace = true }
-libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
+#libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 
 http = "1.3.1"
 
···
 #jose = { version = "0.0.2", features = ["crypto-rustcrypto"] }
 jose-jwk = "0.1.2"
 reqwest = "0.12.15"
-
+tokio = { version = "1.44", features = ["full"], optional = true }
 
 tower-service = "0.3.3"
 tower-layer = "0.3.3"
 multibase = "0.9.1"
+dirs = "6.0.0"
 
 
 

crates/weaver-common/src/error.rs

···
     #[error("HTTP client error: {0}")]
     #[diagnostic_source]
     HttpClient(Box<dyn std::error::Error + Send + Sync + 'static>),
+    #[error("DNS TXT resolver error: {0}")]
+    #[diagnostic_source]
+    DnsTxtResolver(#[from] hickory_resolver::error::ResolveError),
 }
 
 /// Generic error type for XRPC errors.

crates/weaver-common/src/filestore.rs

···
+use crate::Error;
+use crate::error::WeaverErrorKind;
+use crate::error::{IoError, SerDeError};
+use atrium_api::types::string::Did;
+use atrium_common::store::Store;
+use atrium_oauth::store::session::Session;
+use atrium_oauth::store::state::InternalStateData;
+use std::path::{Path, PathBuf};
+
+pub struct SimpleJsonFileSessionStore<T = PathBuf>
+where
+    T: AsRef<Path>,
+{
+    path: T,
+}
+
+impl<T> SimpleJsonFileSessionStore<T>
+where
+    T: AsRef<Path>,
+{
+    pub fn new(path: T) -> Self {
+        Self { path }
+    }
+
+    pub async fn get_session(&self, did: &Did) -> Result<Option<Session>, Error> {
+        let path = self
+            .path
+            .as_ref()
+            .join(format!("{}_session.json", did.as_str()));
+        let file = tokio::fs::read_to_string(path)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]));
+        let file = if let Err(e) = &file {
+            println!("Failed to read session file: {e}");
+            return Ok(None);
+        } else {
+            file?
+        };
+
+        let session = serde_json::from_str(&file)
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(SerDeError::from(e))]))?;
+        Ok(Some(session))
+    }
+
+    pub async fn set_session(&self, did: Did, session: Session) -> Result<(), Error> {
+        let path = self
+            .path
+            .as_ref()
+            .join(format!("{}_session.json", did.as_str()));
+        let file = serde_json::to_string(&session)
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(SerDeError::from(e))]))?;
+
+        tokio::fs::write(path, file)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?;
+
+        Ok(())
+    }
+
+    pub async fn get_state(&self, key: &str) -> Result<Option<InternalStateData>, Error> {
+        let path = self.path.as_ref().join(format!("{}_state.json", key));
+        let file = tokio::fs::read_to_string(path)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]));
+        let file = if let Err(e) = &file {
+            println!("Failed to read state file: {e}");
+            return Ok(None);
+        } else {
+            file?
+        };
+        let state = serde_json::from_str(&file)
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(SerDeError::from(e))]))?;
+        Ok(Some(state))
+    }
+
+    pub async fn set_state(&self, key: String, state: InternalStateData) -> Result<(), Error> {
+        let path = self.path.as_ref().join(format!("{}_state.json", key));
+
+        let file = serde_json::to_string(&state)
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(SerDeError::from(e))]))?;
+
+        tokio::fs::write(path, file)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?;
+
+        Ok(())
+    }
+}
+
+impl Store<Did, Session> for SimpleJsonFileSessionStore<PathBuf> {
+    type Error = crate::Error;
+
+    async fn get(&self, key: &Did) -> Result<Option<Session>, Self::Error> {
+        self.get_session(key).await
+    }
+
+    async fn set(&self, key: Did, value: Session) -> Result<(), Self::Error> {
+        self.set_session(key, value).await
+    }
+
+    async fn del(&self, key: &Did) -> Result<(), Self::Error> {
+        let path = self.path.join(format!("{}_session.json", key.as_str()));
+        tokio::fs::remove_file(path)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))
+    }
+
+    async fn clear(&self) -> Result<(), Self::Error> {
+        let mut files = tokio::fs::read_dir(&self.path)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?;
+        while let Some(entry) = files
+            .next_entry()
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?
+        {
+            let file_name = entry.file_name();
+            if let Some(file_name) = file_name.to_str() {
+                if file_name.ends_with("_session.json") {
+                    tokio::fs::remove_file(entry.path())
+                        .await
+                        .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Store<String, InternalStateData> for SimpleJsonFileSessionStore<PathBuf> {
+    type Error = crate::Error;
+
+    async fn get(&self, key: &String) -> Result<Option<InternalStateData>, Self::Error> {
+        self.get_state(key.as_str()).await
+    }
+
+    async fn set(&self, key: String, value: InternalStateData) -> Result<(), Self::Error> {
+        self.set_state(key, value).await
+    }
+
+    async fn del(&self, key: &String) -> Result<(), Self::Error> {
+        let path = self.path.join(format!("{}_state.json", key.as_str()));
+        tokio::fs::remove_file(path)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))
+    }
+
+    async fn clear(&self) -> Result<(), Self::Error> {
+        let mut files = tokio::fs::read_dir(&self.path)
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?;
+        while let Some(entry) = files
+            .next_entry()
+            .await
+            .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?
+        {
+            let file_name = &entry.file_name();
+            if let Some(file_name) = file_name.to_str() {
+                if file_name.ends_with("_state.json") {
+                    tokio::fs::remove_file(entry.path())
+                        .await
+                        .map_err(|e| Error::new(vec![WeaverErrorKind::from(IoError::from(e))]))?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl atrium_oauth::store::session::SessionStore for SimpleJsonFileSessionStore<PathBuf> {}
+
+impl atrium_oauth::store::state::StateStore for SimpleJsonFileSessionStore<PathBuf> {}
+
+impl Default for SimpleJsonFileSessionStore<PathBuf> {
+    fn default() -> Self {
+        let path = dirs::config_dir()
+            .unwrap_or_else(|| PathBuf::from("./"))
+            .join("weaver/sessions");
+        Self { path }
+    }
+}
+
+pub fn config_dir() -> PathBuf {
+    dirs::config_dir()
+        .unwrap_or_else(|| PathBuf::from("./"))
+        .join("weaver/sessions")
+}

crates/weaver-common/src/lexicons/app/bsky/unspecced/get_config.rs

···
 pub struct OutputData {
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub check_email_confirmed: core::option::Option<bool>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub live_now: core::option::Option<Vec<LiveNowConfig>>,
 }
 pub type Output = atrium_api::types::Object<OutputData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
         Ok(())
     }
 }
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct LiveNowConfigData {
+    pub did: atrium_api::types::string::Did,
+    pub domains: Vec<String>,
+}
+pub type LiveNowConfig = atrium_api::types::Object<LiveNowConfigData>;

crates/weaver-common/src/lexicons/record.rs

···
     LexiconsShWeaverActorProfile(
         Box<crate::lexicons::sh::weaver::actor::profile::Record>,
     ),
+    #[serde(rename = "sh.weaver.edit.cursor")]
+    LexiconsShWeaverEditCursor(Box<crate::lexicons::sh::weaver::edit::cursor::Record>),
+    #[serde(rename = "sh.weaver.edit.diff")]
+    LexiconsShWeaverEditDiff(Box<crate::lexicons::sh::weaver::edit::diff::Record>),
+    #[serde(rename = "sh.weaver.edit.root")]
+    LexiconsShWeaverEditRoot(Box<crate::lexicons::sh::weaver::edit::root::Record>),
     #[serde(rename = "sh.weaver.notebook.authors")]
     LexiconsShWeaverNotebookAuthors(
         Box<crate::lexicons::sh::weaver::notebook::authors::Record>,
···
         record_data: crate::lexicons::sh::weaver::actor::profile::RecordData,
     ) -> Self {
         KnownRecord::LexiconsShWeaverActorProfile(Box::new(record_data.into()))
+    }
+}
+impl From<crate::lexicons::sh::weaver::edit::cursor::Record> for KnownRecord {
+    fn from(record: crate::lexicons::sh::weaver::edit::cursor::Record) -> Self {
+        KnownRecord::LexiconsShWeaverEditCursor(Box::new(record))
+    }
+}
+impl From<crate::lexicons::sh::weaver::edit::cursor::RecordData> for KnownRecord {
+    fn from(record_data: crate::lexicons::sh::weaver::edit::cursor::RecordData) -> Self {
+        KnownRecord::LexiconsShWeaverEditCursor(Box::new(record_data.into()))
+    }
+}
+impl From<crate::lexicons::sh::weaver::edit::diff::Record> for KnownRecord {
+    fn from(record: crate::lexicons::sh::weaver::edit::diff::Record) -> Self {
+        KnownRecord::LexiconsShWeaverEditDiff(Box::new(record))
+    }
+}
+impl From<crate::lexicons::sh::weaver::edit::diff::RecordData> for KnownRecord {
+    fn from(record_data: crate::lexicons::sh::weaver::edit::diff::RecordData) -> Self {
+        KnownRecord::LexiconsShWeaverEditDiff(Box::new(record_data.into()))
+    }
+}
+impl From<crate::lexicons::sh::weaver::edit::root::Record> for KnownRecord {
+    fn from(record: crate::lexicons::sh::weaver::edit::root::Record) -> Self {
+        KnownRecord::LexiconsShWeaverEditRoot(Box::new(record))
+    }
+}
+impl From<crate::lexicons::sh::weaver::edit::root::RecordData> for KnownRecord {
+    fn from(record_data: crate::lexicons::sh::weaver::edit::root::RecordData) -> Self {
+        KnownRecord::LexiconsShWeaverEditRoot(Box::new(record_data.into()))
     }
 }
 impl From<crate::lexicons::sh::weaver::notebook::authors::Record> for KnownRecord {

crates/weaver-common/src/lexicons/sh/weaver.rs

···
 // @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
 //!Definitions for the `sh.weaver` namespace.
 pub mod actor;
+pub mod edit;
 pub mod embed;
 pub mod notebook;

crates/weaver-common/src/lexicons/sh/weaver/edit.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.edit` namespace.
+pub mod cursor;
+pub mod defs;
+pub mod diff;
+pub mod root;
+#[derive(Debug)]
+pub struct Cursor;
+impl atrium_api::types::Collection for Cursor {
+    const NSID: &'static str = "sh.weaver.edit.cursor";
+    type Record = cursor::Record;
+}
+#[derive(Debug)]
+pub struct Diff;
+impl atrium_api::types::Collection for Diff {
+    const NSID: &'static str = "sh.weaver.edit.diff";
+    type Record = diff::Record;
+}
+#[derive(Debug)]
+pub struct Root;
+impl atrium_api::types::Collection for Root {
+    const NSID: &'static str = "sh.weaver.edit.root";
+    type Record = root::Record;
+}

crates/weaver-common/src/lexicons/sh/weaver/edit/cursor.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.edit.cursor` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    pub container: ContainerId,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub id: core::option::Option<Id>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub side: core::option::Option<CursorSide>,
+}
+pub type Record = atrium_api::types::Object<RecordData>;
+impl From<atrium_api::types::Unknown> for RecordData {
+    fn from(value: atrium_api::types::Unknown) -> Self {
+        Self::try_from_unknown(value).unwrap()
+    }
+}
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContainerIdData {
+    pub value: atrium_api::types::Union<ContainerIdValueRefs>,
+}
+pub type ContainerId = atrium_api::types::Object<ContainerIdData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CursorSideData {
+    ///The side of an item the cursor is on (left = -1, right = 1, middle = 0)
+    pub value: i64,
+}
+pub type CursorSide = atrium_api::types::Object<CursorSideData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct IdData {
+    pub counter: i64,
+    pub peer: i64,
+}
+pub type Id = atrium_api::types::Object<IdData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NormalContainerIdData {
+    pub container_type: String,
+    pub counter: i64,
+    pub peer: i64,
+}
+pub type NormalContainerId = atrium_api::types::Object<NormalContainerIdData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RootContainerIdData {
+    pub container_type: String,
+    pub name: String,
+}
+pub type RootContainerId = atrium_api::types::Object<RootContainerIdData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(tag = "$type")]
+pub enum ContainerIdValueRefs {
+    #[serde(rename = "sh.weaver.edit.cursor#normalContainerId")]
+    NormalContainerId(Box<NormalContainerId>),
+    #[serde(rename = "sh.weaver.edit.cursor#rootContainerId")]
+    RootContainerId(Box<RootContainerId>),
+}

crates/weaver-common/src/lexicons/sh/weaver/edit/defs.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.edit.defs` namespace.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DocRefData {
+    pub value: atrium_api::types::Union<DocRefValueRefs>,
+}
+pub type DocRef = atrium_api::types::Object<DocRefData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct EntryRefData {
+    pub notebook: crate::com::atproto::repo::strong_ref::Main,
+}
+pub type EntryRef = atrium_api::types::Object<EntryRefData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NotebookRefData {
+    pub notebook: crate::com::atproto::repo::strong_ref::Main,
+}
+pub type NotebookRef = atrium_api::types::Object<NotebookRefData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(tag = "$type")]
+pub enum DocRefValueRefs {
+    #[serde(rename = "sh.weaver.edit.defs#notebookRef")]
+    NotebookRef(Box<NotebookRef>),
+    #[serde(rename = "sh.weaver.edit.defs#entryRef")]
+    EntryRef(Box<EntryRef>),
+}

crates/weaver-common/src/lexicons/sh/weaver/edit/diff.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.edit.diff` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    pub doc: crate::sh::weaver::edit::defs::DocRef,
+    pub root: crate::com::atproto::repo::strong_ref::Main,
+    pub snapshot: atrium_api::types::BlobRef,
+}
+pub type Record = atrium_api::types::Object<RecordData>;
+impl From<atrium_api::types::Unknown> for RecordData {
+    fn from(value: atrium_api::types::Unknown) -> Self {
+        Self::try_from_unknown(value).unwrap()
+    }
+}

crates/weaver-common/src/lexicons/sh/weaver/edit/root.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.edit.root` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    pub cid: atrium_api::types::string::Cid,
+    pub doc: crate::sh::weaver::edit::defs::DocRef,
+    pub snapshot: atrium_api::types::BlobRef,
+    pub uri: String,
+}
+pub type Record = atrium_api::types::Object<RecordData>;
+impl From<atrium_api::types::Unknown> for RecordData {
+    fn from(value: atrium_api::types::Unknown) -> Self {
+        Self::try_from_unknown(value).unwrap()
+    }
+}

crates/weaver-common/src/lexicons/sh/weaver/notebook/book.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct RecordData {
     pub authors: crate::sh::weaver::notebook::defs::AuthorListView,
-    pub cid: atrium_api::types::string::Cid,
+    ///Client-declared timestamp when this was originally created.
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub created_at: core::option::Option<atrium_api::types::string::Datetime>,
     pub entry_list: Vec<crate::sh::weaver::notebook::defs::BookEntryView>,
-    pub uri: String,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub tags: core::option::Option<crate::sh::weaver::notebook::defs::Tags>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub title: core::option::Option<crate::sh::weaver::notebook::defs::Title>,
 }
 pub type Record = atrium_api::types::Object<RecordData>;
 impl From<atrium_api::types::Unknown> for RecordData {

crates/weaver-common/src/lexicons/sh/weaver/notebook/defs.rs

···
     pub record: atrium_api::types::Unknown,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub rendered_view: core::option::Option<RenderedView>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub tags: core::option::Option<Tags>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub title: core::option::Option<Title>,
     pub uri: String,
 }
 pub type EntryView = atrium_api::types::Object<EntryViewData>;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NotebookViewData {
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub authors: core::option::Option<AuthorListView>,
+    pub cid: atrium_api::types::string::Cid,
+    pub indexed_at: atrium_api::types::string::Datetime,
+    pub record: atrium_api::types::Unknown,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub tags: core::option::Option<Tags>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub title: core::option::Option<Title>,
+    pub uri: String,
+}
+pub type NotebookView = atrium_api::types::Object<NotebookViewData>;
 ///View of a rendered and cached notebook entry
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
···
     pub html: atrium_api::types::BlobRef,
 }
 pub type RenderedView = atrium_api::types::Object<RenderedViewData>;
+///An array of tags associated with the notebook entry. Tags can help categorize and organize entries.
+pub type Tags = Vec<String>;
+///The title of the notebook entry.
+pub type Title = String;

crates/weaver-common/src/lexicons/sh/weaver/notebook/entry.rs

···
 pub struct RecordData {
     ///The content of the notebook entry. This should be some flavor of Markdown.
     pub content: String,
-    pub created_at: CreatedAt,
+    ///Client-declared timestamp when this was originally created.
+    pub created_at: atrium_api::types::string::Datetime,
     ///The set of images, if any, embedded in the notebook entry.
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub images: core::option::Option<crate::sh::weaver::embed::images::Main>,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
-    pub tags: core::option::Option<Tags>,
-    pub title: Title,
+    pub tags: core::option::Option<crate::sh::weaver::notebook::defs::Tags>,
+    pub title: crate::sh::weaver::notebook::defs::Title,
 }
 pub type Record = atrium_api::types::Object<RecordData>;
 impl From<atrium_api::types::Unknown> for RecordData {
···
         Self::try_from_unknown(value).unwrap()
     }
 }
-///The date and time when the notebook entry was created. This is used for sorting and displaying the entry's creation date.
-pub type CreatedAt = String;
-///An array of tags associated with the notebook entry. Tags can help categorize and organize entries.
-pub type Tags = Vec<String>;
-///The title of the notebook entry.
-pub type Title = String;

crates/weaver-common/src/lib.rs

···
 pub mod agent;
 pub mod config;
 pub mod error;
+/// This filestore is very much not production ready
+#[cfg(all(feature = "native", feature = "dev"))]
+pub mod filestore;
 pub mod lexicons;
 pub mod oauth;
 pub mod resolver;

crates/weaver-common/src/oauth.rs

···
     pub http_client: Arc<WeaverHttpClient>,
 }
 
+pub type NativeBasicOAuthSession = OAuthSession<
+    DefaultHttpClient,
+    CommonDidResolver<WeaverHttpClient>,
+    AtprotoHandleResolver<HickoryDnsTxtResolver, WeaverHttpClient>,
+    MemoryStore<Did, Session>,
+>;
+
+pub struct NativeWeaverOAuthClient<STATE, SESS>
+where
+    STATE: StateStore + Send + Sync + 'static,
+    SESS: SessionStore + Send + Sync + 'static,
+    STATE::Error: std::error::Error + Send + Sync + 'static,
+    SESS::Error: std::error::Error + Send + Sync + 'static,
+{
+    oauth: WeaverOAuthClient<STATE, SESS>,
+    pub http_client: Arc<WeaverHttpClient>,
+}
 impl NativeOAuthClient {
     pub async fn authorize(
         &self,
···
     }
 }
 
-pub type NativeBasicOAuthSession = OAuthSession<
+#[cfg(all(feature = "native", feature = "dev"))]
+impl
+    NativeWeaverOAuthClient<
+        crate::filestore::SimpleJsonFileSessionStore<std::path::PathBuf>,
+        crate::filestore::SimpleJsonFileSessionStore<std::path::PathBuf>,
+    >
+{
+    pub async fn authorize(
+        &self,
+        input: impl AsRef<str>,
+        options: AuthorizeOptions,
+    ) -> Result<String, atrium_oauth::Error> {
+        self.oauth.authorize(input, options).await
+    }
+
+    pub async fn callback(
+        &self,
+        params: CallbackParams,
+    ) -> Result<(WeaverOAuthSession, Option<String>), atrium_oauth::Error> {
+        self.oauth.callback(params).await
+    }
+
+    pub async fn restore(&self, did: &Did) -> Result<WeaverOAuthSession, atrium_oauth::Error> {
+        self.oauth.restore(did).await
+    }
+}
+
+#[cfg(all(feature = "native", feature = "dev"))]
+pub type WeaverOAuthSession = OAuthSession<
     DefaultHttpClient,
     CommonDidResolver<WeaverHttpClient>,
     AtprotoHandleResolver<HickoryDnsTxtResolver, WeaverHttpClient>,
-    MemoryStore<Did, Session>,
+    crate::filestore::SimpleJsonFileSessionStore<std::path::PathBuf>,
 >;
 
 pub type NativeBasicOAuthClient = atrium_oauth::OAuthClient<
···
         session_store: MemorySessionStore::default(),
     };
     let client = OAuthClient::new(config)?;
+    Ok(client)
+}
+
+#[cfg(all(feature = "native", feature = "dev"))]
+pub fn test_native_oauth_client() -> Result<
+    NativeWeaverOAuthClient<
+        crate::filestore::SimpleJsonFileSessionStore<std::path::PathBuf>,
+        crate::filestore::SimpleJsonFileSessionStore<std::path::PathBuf>,
+    >,
+    atrium_oauth::Error,
+> {
+    use crate::filestore::SimpleJsonFileSessionStore;
+
+    let http_client = Arc::new(WeaverHttpClient::default());
+    let config = OAuthClientConfig {
+        client_metadata: default_native_client_metadata(),
+        keys: None,
+        resolver: OAuthResolverConfig {
+            did_resolver: CommonDidResolver::new(CommonDidResolverConfig {
+                plc_directory_url: DEFAULT_PLC_DIRECTORY_URL.to_string(),
+                http_client: Arc::clone(&http_client),
+            }),
+            handle_resolver: AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
+                dns_txt_resolver: HickoryDnsTxtResolver::default(),
+                http_client: Arc::clone(&http_client),
+            }),
+            authorization_server_metadata: Default::default(),
+            protected_resource_metadata: Default::default(),
+        },
+        state_store: SimpleJsonFileSessionStore::default(),
+        session_store: SimpleJsonFileSessionStore::default(),
+    };
+    let client = NativeWeaverOAuthClient {
+        oauth: OAuthClient::new(config)?,
+        http_client: Arc::clone(&http_client),
+    };
     Ok(client)
 }
 

crates/weaver-common/src/resolver.rs

···
     async fn resolve(
         &self,
         query: &str,
-    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    ) -> core::result::Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
         Ok(self
             .resolver
             .txt_lookup(query)
-            .await?
+            .await
+            .map_err(crate::error::NetworkError::from)?
             .iter()
             .map(|txt| txt.to_string())
             .collect())

crates/weaver-renderer/Cargo.toml

···
 
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
 compact_string = "0.1.0"
+http = "1.3.1"
+url = "2.5.4"

crates/weaver-renderer/src/lib.rs

···
 //! Weaver renderer
 //!
-//! This crate works with the weaver-markdown crate to render and optionally upload markdown notebooks to your ATProto PDS.
+//! This crate works with the weaver-markdown crate to render and optionally upload markdown notebooks to your Atproto PDS.
 //!
 
 pub mod types;

crates/weaver-renderer/src/types.rs

···
 use atrium_api::types::string::{Cid, Did};
 use compact_string::CompactString;
+use http::Uri;
+
+pub struct Link {
+    pub uri: Uri,
+    pub blob: BlobLink,
+}
 
 pub type MimeType = CompactString;
 
···
 
 impl std::fmt::Display for BlobLink {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}{}/{}@{}",
-            self.url_prefix(),
-            self.did().as_str(),
-            self.cid().as_ref(),
-            self.mime_type().rsplit('/').next().unwrap()
-        )
+        match self {
+            BlobLink::PDS {
+                pds_host,
+                did,
+                cid,
+                mime_type: _,
+            } => {
+                write!(
+                    f,
+                    "{}/xrpc/com.atproto.sync.getBlob?did={}&cid={}",
+                    pds_host,
+                    did.as_str(),
+                    cid.as_ref()
+                )
+            }
+            _ => write!(
+                f,
+                "{}{}/{}@{}",
+                self.url_prefix(),
+                self.did().as_str(),
+                self.cid().as_ref(),
+                self.mime_type().rsplit('/').next().unwrap()
+            ),
+        }
     }
 }
 

crates/weaver-workspace-hack/Cargo.toml

···
 group = { version = "0.13", default-features = false, features = ["alloc"] }
 hashbrown = { version = "0.15", features = ["serde"] }
 idna = { version = "1" }
-libsqlite3-sys = { version = "0.30", features = ["bundled"] }
 log = { version = "0.4", default-features = false, features = ["std"] }
 memchr = { version = "2", features = ["use_std"] }
 miette = { version = "7", features = ["fancy", "syntect-highlighter"] }
···
 p384 = { version = "0.13", default-features = false, features = ["ecdsa"] }
 percent-encoding = { version = "2" }
 pkcs8 = { version = "0.10", default-features = false, features = ["pem"] }
-proc-macro2 = { version = "1", features = ["span-locations"] }
+proc-macro2 = { version = "1" }
 quote = { version = "1" }
 rand_core = { version = "0.6", default-features = false, features = ["std"] }
 reqwest = { version = "0.12", features = ["gzip", "json", "rustls-tls"] }
···
 diesel_derives = { version = "2", features = ["32-column-tables", "chrono", "postgres", "sqlite", "with-deprecated"] }
 either = { version = "1", features = ["use_std"] }
 hashbrown = { version = "0.15", features = ["serde"] }
-proc-macro2 = { version = "1", features = ["span-locations"] }
+proc-macro2 = { version = "1" }
 quote = { version = "1" }
 serde = { version = "1", features = ["alloc", "derive"] }
 syn = { version = "2", features = ["extra-traits", "fold", "full", "visit", "visit-mut"] }

lexicon-codegen.sh

···
 
 
 #cargo install esquema-cli --locked --git https://github.com/fatfingers23/esquema.git
+
 rm -rf ./target/lexicons
 mkdir -p ./target/lexicons
+cd target
+git clone -n --depth=1 --filter=tree:0 \
+https://github.com/bluesky-social/atproto.git
+cd atproto
+git sparse-checkout set --no-cone /lexicons
+git checkout
+cd ..
 
-cp -r ./lexicons ./target/lexicons
-cp -r ./atproto/lexicons ./target/lexicons
+cp -r ../lexicons ./
+cp -r ./atproto/lexicons ./
 
 
-~/.cargo/bin/esquema-cli generate local --lexdir ./target/lexicons/ --outdir ./crates/weaver-common/src/ --module lexicons
+~/.cargo/bin/esquema-cli generate local --lexdir ./lexicons/ --outdir ../crates/weaver-common/src/ --module lexicons

lexicons/sh/weaver/edit/cursor.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.edit.cursor",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "An edit record for a notebook.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["container", "die"],
+        "properties": {
+          "id": {
+            "type": "ref",
+            "ref": "#id"
+          },
+          "container": {
+            "type": "ref",
+            "ref": "#containerId"
+          },
+          "side": {
+            "type": "ref",
+            "ref": "#cursorSide"
+          }
+        }
+      }
+    },
+    "id": {
+      "type": "object",
+      "required": ["peer", "counter"],
+      "properties": {
+        "peer": { "type": "integer" },
+        "counter": { "type": "integer" }
+      }
+    },
+    "cursorSide": {
+      "type": "object",
+      "required": ["value"],
+      "properties": {
+        "value": {
+          "type": "integer",
+          "description": "The side of an item the cursor is on (left = -1, right = 1, middle = 0)",
+          "enum": [-1, 0, 1]
+        }
+      }
+    },
+    "containerId": {
+      "type": "object",
+      "required": ["value"],
+      "properties": {
+        "value": {
+          "type": "union",
+          "refs": ["#normalContainerId", "#rootContainerId"]
+        }
+      }
+    },
+    "normalContainerId": {
+      "type": "object",
+      "required": ["peer", "counter", "container_type"],
+      "properties": {
+        "peer": { "type": "integer" },
+        "counter": { "type": "integer" },
+        "container_type": {
+          "type": "string",
+          "enum": ["Map", "List", "Text", "Tree", "MovableList", "Counter"]
+        }
+      }
+    },
+    "rootContainerId": {
+      "type": "object",
+      "required": ["name", "container_type"],
+      "properties": {
+        "name": { "type": "string" },
+        "container_type": {
+          "type": "string",
+          "enum": ["Map", "List", "Text", "Tree", "MovableList", "Counter"]
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/edit/defs.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.edit.defs",
+  "defs": {
+    "docRef": {
+      "type": "object",
+      "required": ["value"],
+      "properties": {
+        "value": {
+          "type": "union",
+          "refs": ["#notebookRef", "#entryRef"]
+        }
+      }
+    },
+    "notebookRef": {
+      "type": "object",
+      "required": ["notebook"],
+      "properties": {
+        "notebook": {
+          "type": "ref",
+          "ref": "com.atproto.repo.strongRef"
+        }
+      }
+    },
+    "entryRef": {
+      "type": "object",
+      "required": ["notebook"],
+      "properties": {
+        "notebook": {
+          "type": "ref",
+          "ref": "com.atproto.repo.strongRef"
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/edit/diff.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.edit.diff",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "An edit record for a notebook.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["snapshot", "root", "doc"],
+        "properties": {
+          "snapshot": {
+            "type": "blob",
+            "accept": ["*/*"],
+            "maxSize": 3000000
+          },
+          "root": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef"
+          },
+          "doc": {
+            "type": "ref",
+            "ref": "sh.weaver.edit.defs#docRef"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/edit/root.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.edit.root",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "The starting point for edit history on a notebook.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["cid", "uri", "doc", "snapshot"],
+        "properties": {
+          "uri": { "type": "string", "format": "at-uri" },
+          "cid": { "type": "string", "format": "cid" },
+          "snapshot": {
+            "type": "blob",
+            "accept": ["*/*"],
+            "maxSize": 30000000
+          },
+          "doc": {
+            "type": "ref",
+            "ref": "sh.weaver.edit.defs#docRef"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/notebook/book.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": ["cid", "uri", "authors", "entryList"],
+        "required": ["authors", "entryList"],
         "properties": {
-          "uri": { "type": "string", "format": "at-uri" },
-          "cid": { "type": "string", "format": "cid" },
+          "title": { "type": "ref", "ref": "sh.weaver.notebook.defs#title" },
+          "tags": { "type": "ref", "ref": "sh.weaver.notebook.defs#tags" },
           "authors": {
             "type": "ref",
             "ref": "sh.weaver.notebook.defs#authorListView"
···
               "ref": "sh.weaver.notebook.defs#bookEntryView"
             }
           },
-          "createdAt": { "type": "string", "format": "datetime" }
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Client-declared timestamp when this was originally created."
+          }
         }
       }
     }

lexicons/sh/weaver/notebook/defs.json

···
   "lexicon": 1,
   "id": "sh.weaver.notebook.defs",
   "defs": {
+    "notebookView": {
+      "type": "object",
+      "required": ["uri", "cid", "author", "record", "indexedAt"],
+
+      "properties": {
+        "title": { "type": "ref", "ref": "#title" },
+        "tags": { "type": "ref", "ref": "#tags" },
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" },
+        "authors": {
+          "type": "ref",
+          "ref": "#authorListView"
+        },
+        "record": { "type": "unknown" },
+        "indexedAt": { "type": "string", "format": "datetime" }
+      }
+    },
     "entryView": {
       "type": "object",
       "required": ["uri", "cid", "author", "record", "indexedAt"],
 
       "properties": {
+        "title": { "type": "ref", "ref": "#title" },
+        "tags": { "type": "ref", "ref": "#tags" },
         "uri": { "type": "string", "format": "at-uri" },
         "cid": { "type": "string", "format": "cid" },
         "authors": {
···
           "ref": "#entryView"
         }
       }
+    },
+    "title": {
+      "type": "string",
+      "maxLength": 420,
+      "description": "The title of the notebook entry."
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "maxLength": 64
+      },
+      "maxLength": 10,
+      "description": "An array of tags associated with the notebook entry. Tags can help categorize and organize entries."
     }
   }
 }

lexicons/sh/weaver/notebook/entry.json

···
         "type": "object",
         "required": ["content", "title", "createdAt"],
         "properties": {
-          "title": { "type": "ref", "ref": "#title" },
-          "tags": { "type": "ref", "ref": "#tags" },
+          "title": { "type": "ref", "ref": "sh.weaver.notebook.defs#title" },
+          "tags": { "type": "ref", "ref": "sh.weaver.notebook.defs#tags" },
 
           "content": {
             "type": "string",
···
           },
 
           "createdAt": {
-            "type": "ref",
-            "ref": "#createdAt"
+            "type": "string",
+            "format": "datetime",
+            "description": "Client-declared timestamp when this was originally created."
           },
           "images": {
             "type": "ref",
···
           }
         }
       }
-    },
-
-    "createdAt": {
-      "type": "string",
-      "format": "datetime",
-      "description": "The date and time when the notebook entry was created. This is used for sorting and displaying the entry's creation date."
-    },
-    "title": {
-      "type": "string",
-      "maxLength": 420,
-      "description": "The title of the notebook entry."
-    },
-    "tags": {
-      "type": "array",
-      "items": {
-        "type": "string",
-        "maxLength": 64
-      },
-      "maxLength": 10,
-      "description": "An array of tags associated with the notebook entry. Tags can help categorize and organize entries."
     }
   }
 }

test.html

···
     <head>
         <meta charset="utf-8">
 	</head>
+	<script>
+	console.log( window.location.href );  // whatever your current location href is
+window.history.replaceState( {} , 'foo', './LICENSE' );
+console.log( window.location.href );  // oh, hey, it replaced the path with /foo
+
+
+</script>
 	<body>
 <h1>Main Title &amp; &quot;Special Chars&quot;</h1>
 <p>This is a paragraph with <em>emphasis</em>, <strong>strong emphasis</strong>, <del>strikethrough</del>, and <code>inline code</code>.
···
 </blockquote>
 </blockquote>
 <hr />
+
 <h2>Lists and Links</h2>
 <ul>
 <li><p>Unordered item 1</p>