bunch more lexicon stuff and buildout

.gitignore

···
 
 .db/
 **/.db/
+
+**/.claude/settings.local.json

.zed/settings.json

···
           "command": ["alejandra", "--quiet", "--"] // or ["nixfmt"]
         }
       }
+    },
+    "rust-analyzer": {
+      "binary": {
+        "path": "/nix/store/qs17clvcja2b5wy5wmcqd5mqly6wypax-rust-default-1.89.0-nightly-2025-05-21/bin/rust-analyzer"
+      },
+      "initialization_options": {
+        "cargo": {
+          "allFeatures": true
+        }
+      }
     }
   }
 }

Cargo.lock

···
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.7"
+version = "3.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+checksum = "6680de5231bd6ee4c6191b8a1325daa282b415391ec9d3a37bd34f2060dc73fa"
 dependencies = [
  "anstyle",
- "once_cell",
+ "once_cell_polyfill",
  "windows-sys 0.59.0",
 ]
 
···
 
 [[package]]
 name = "atrium-api"
-version = "0.25.3"
+version = "0.25.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7225f0ca3c78564b784828e3db3e92619cf6e786530c3468df73f49deebc0bd4"
+checksum = "46355d3245edc7b3160b2a45fe55d09a6963ebd3eee0252feb6b72fb0eb71463"
 dependencies = [
  "atrium-common",
  "atrium-xrpc",
···
 
 [[package]]
 name = "atrium-identity"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84939a5e3a0a442467d6a000f586c092bb763a31c2d38ec1648f5179a720395a"
+checksum = "c9e2d42bb4dbea038f4f5f45e3af2a89d61a9894a75f06aa550b74a60d2be380"
 dependencies = [
  "atrium-api",
  "atrium-common",
···
 
 [[package]]
 name = "atrium-oauth"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4f210da8f2d7199b15e6b02c0628175791ae5caaf506cfcafe45a20917f37c"
+checksum = "ca22dc4eaf77fd9bf050b21192ac58cd654a437d28e000ec114ebd93a51d36f5"
 dependencies = [
  "atrium-api",
  "atrium-common",
···
 ]
 
 [[package]]
+name = "bit-set"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "bstr"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
 name = "buf_redux"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "cc"
-version = "1.2.23"
+version = "1.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4ac86a9e5bc1e2b3449ab9d7d3a6a405e3d1bb28d7b9be8614f55846ae3766"
+checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
 dependencies = [
  "shlex",
 ]
···
 
 [[package]]
 name = "clap"
-version = "4.5.38"
+version = "4.5.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000"
+checksum = "fd60e63e9be68e5fb56422e397cf9baddded06dae1d2e523401542383bc72a9f"
 dependencies = [
  "clap_builder",
  "clap_derive",
···
 
 [[package]]
 name = "clap_builder"
-version = "4.5.38"
+version = "4.5.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120"
+checksum = "89cc6392a1f72bbeb820d71f32108f61fdaf18bc526e1d23954168a67759ef51"
 dependencies = [
  "anstream",
  "anstyle",
···
 
 [[package]]
 name = "cordyceps"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0392f465ceba1713d30708f61c160ebf4dc1cf86bb166039d16b11ad4f3b5b6"
+checksum = "688d7fbb8092b8de775ef2536f36c8c31f2bc4006ece2e8d8ad2d17d00ce0a2a"
 dependencies = [
  "loom",
  "tracing",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
···
 ]
 
 [[package]]
+name = "dynosaur"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "277b2cb52d2df4acece06bb16bc0bb0a006970c7bf504eac2d310927a6f65890"
+dependencies = [
+ "dynosaur_derive",
+ "trait-variant",
+]
+
+[[package]]
+name = "dynosaur_derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a4102713839a8c01c77c165bc38ef2e83948f6397fa1e1dcfacec0f07b149d3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "ecdsa"
 version = "0.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
 
 [[package]]
+name = "fancy-regex"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2"
+dependencies = [
+ "bit-set",
+ "regex",
+]
+
+[[package]]
 name = "fastrand"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
 
 [[package]]
+name = "globset"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54a1028dfc5f5df5da8a56a73e6c153c9a9708ec57232470703592a3f18e49f5"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata 0.4.9",
+ "regex-syntax 0.8.5",
+]
+
+[[package]]
 name = "group"
 version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "hashlink"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+dependencies = [
+ "hashbrown 0.15.3",
+]
+
+[[package]]
 name = "heck"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "hyper-rustls"
-version = "0.27.5"
+version = "0.27.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d191583f3da1305256f22463b9bb0471acad48a4e534a5218b9963e9c1f59b2"
+checksum = "03a01595e11bdcec50946522c32dde3fc6914743000a68b93000965f2f02406d"
 dependencies = [
- "futures-util",
  "http",
  "hyper",
  "hyper-util",
···
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots 0.26.11",
+ "webpki-roots",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "hyper-util"
-version = "0.1.11"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497bbc33a26fdd4af9ed9c70d63f61cf56a938375fbb32df34db9b1cd6d643f2"
+checksum = "b1c293b6b3d21eca78250dc7dbebd6b9210ec5530e038cbfe0661b5c47ab06e8"
 dependencies = [
+ "base64 0.22.1",
  "bytes",
  "futures-channel",
+ "futures-core",
  "futures-util",
  "http",
  "http-body",
  "hyper",
+ "ipnet",
  "libc",
+ "percent-encoding",
  "pin-project-lite",
  "socket2",
+ "system-configuration",
  "tokio",
  "tower-service",
  "tracing",
+ "windows-registry",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "icu_properties"
-version = "2.0.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2549ca8c7241c82f59c80ba2a6f415d931c5b58d24fb8412caa1a1f02c49139a"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
 dependencies = [
  "displaydoc",
  "icu_collections",
···
 
 [[package]]
 name = "icu_properties_data"
-version = "2.0.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8197e866e47b68f8f7d95249e172903bec06004b18b2937f1095d40a0c57de04"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
 
 [[package]]
 name = "icu_provider"
···
 ]
 
 [[package]]
+name = "ignore"
+version = "0.4.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"
+dependencies = [
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata 0.4.9",
+ "same-file",
+ "walkdir",
+ "winapi-util",
+]
+
+[[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "iri-string"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2"
+dependencies = [
+ "memchr",
+ "serde",
+]
 
 [[package]]
 name = "is_ci"
···
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.30.1"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+checksum = "947e6816f7825b2b45027c2c32e7085da9934defa535de4a6a46b10a4d5257fa"
 dependencies = [
  "pkg-config",
  "vcpkg",
···
 [[package]]
 name = "markdown-weaver"
 version = "0.13.0"
-source = "git+https://github.com/rsform/markdown-weaver#593f968ec3c4515c23273715eaeb33801342439b"
+source = "git+https://github.com/rsform/markdown-weaver#5a93522bc6b69058a34e7eb46f89b39d1b6be006"
 dependencies = [
  "bitflags 2.9.1",
  "getopts",
···
 [[package]]
 name = "markdown-weaver-escape"
 version = "0.11.0"
-source = "git+https://github.com/rsform/markdown-weaver#593f968ec3c4515c23273715eaeb33801342439b"
+source = "git+https://github.com/rsform/markdown-weaver#5a93522bc6b69058a34e7eb46f89b39d1b6be006"
 
 [[package]]
 name = "matchers"
···
 checksum = "7c36f61da594ecad0ed986ceeb5061eba47a36fcf839576ce525c7e4ff08f3fa"
 dependencies = [
  "merde_core",
- "yaml-rust2",
+ "yaml-rust2 0.8.1",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "mio"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
  "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+
+[[package]]
 name = "onig"
-version = "6.4.0"
+version = "6.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f"
+checksum = "336b9c63443aceef14bea841b899035ae3abe89b7c486aaf4c5bd8aafedac3f0"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.1",
  "libc",
  "once_cell",
  "onig_sys",
···
 
 [[package]]
 name = "onig_sys"
-version = "69.8.1"
+version = "69.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b829e3d7e9cc74c7e315ee8edb185bf4190da5acde74afd7fc59c35b1f086e7"
+checksum = "c7f86c6eef3d6df15f23bcfb6af487cbd2fed4e5581d58d5bf1f5f8b7f6727dc"
 dependencies = [
  "cc",
  "pkg-config",
···
  "smallvec",
  "windows-targets 0.52.6",
 ]
+
+[[package]]
+name = "pathdiff"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
 
 [[package]]
 name = "pem-rfc7468"
···
 
 [[package]]
 name = "reqwest"
-version = "0.12.15"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d19c46a6fdd48bc4dab94b6103fccc55d34c67cc0ad04653aad4ea2a07cd7bbb"
+checksum = "2bf597b113be201cb2269b4c39b39a804d01b99ee95a4278f0ed04e45cff1c71"
 dependencies = [
  "async-compression",
  "base64 0.22.1",
···
  "pin-project-lite",
  "quinn",
  "rustls 0.23.27",
- "rustls-pemfile 2.2.0",
  "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper",
- "system-configuration",
  "tokio",
  "tokio-native-tls",
  "tokio-rustls",
  "tokio-util",
  "tower",
+ "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "webpki-roots 0.26.11",
- "windows-registry",
+ "webpki-roots",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "rustls-pemfile"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
-dependencies = [
- "rustls-pki-types",
-]
-
-[[package]]
 name = "rustls-pki-types"
 version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "rustversion"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
 
 [[package]]
 name = "ryu"
···
 
 [[package]]
 name = "socket2"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
···
 dependencies = [
  "bincode",
  "bitflags 1.3.2",
+ "fancy-regex",
  "flate2",
  "fnv",
  "once_cell",
···
  "httpdate",
  "log",
  "rustls 0.20.9",
- "rustls-pemfile 0.2.1",
+ "rustls-pemfile",
  "zeroize",
 ]
 
···
 
 [[package]]
 name = "tokio"
-version = "1.45.0"
+version = "1.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2513ca694ef9ede0fb23fe71a4ee4107cb102b9dc1930f6d0fd77aae068ae165"
+checksum = "75ef51a33ef1da925cea3e4eb122833cb377c61439ca401b770f54902b806779"
 dependencies = [
  "backtrace",
  "bytes",
···
  "http-body-util",
  "http-range-header",
  "httpdate",
+ "iri-string",
  "mime",
  "mime_guess",
  "percent-encoding",
  "pin-project-lite",
  "tokio",
  "tokio-util",
+ "tower",
  "tower-layer",
  "tower-service",
  "tracing",
···
 
 [[package]]
 name = "uuid"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
+checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
 dependencies = [
  "getrandom 0.3.3",
+ "js-sys",
  "serde",
+ "wasm-bindgen",
 ]
 
 [[package]]
···
  "http",
  "jose-jwk",
  "markdown-weaver",
+ "markdown-weaver-escape",
  "merde",
  "miette",
  "minijinja",
  "multibase",
  "n0-future",
  "owo-colors",
+ "regex",
  "reqwest",
  "serde",
  "serde_bytes",
···
 name = "weaver-renderer"
 version = "0.1.0"
 dependencies = [
+ "async-trait",
  "atrium-api",
+ "bitflags 2.9.1",
  "compact_string",
+ "dashmap",
+ "dynosaur",
  "http",
+ "ignore",
+ "markdown-weaver",
+ "markdown-weaver-escape",
+ "miette",
  "n0-future",
+ "pathdiff",
+ "pin-project",
+ "pin-utils",
+ "regex",
+ "syntect",
+ "thiserror 2.0.12",
+ "tokio",
+ "tokio-util",
+ "unicode-normalization",
  "url",
  "weaver-common",
  "weaver-workspace-hack",
+ "yaml-rust2 0.10.2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "webpki-roots"
-version = "0.26.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
-dependencies = [
- "webpki-roots 1.0.0",
-]
-
-[[package]]
-name = "webpki-roots"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2853738d1cc4f2da3a225c18ec6c3721abb31961096e9dbf5ab35fa88b19cfdb"
···
 
 [[package]]
 name = "windows-core"
-version = "0.61.1"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46ec44dc15085cea82cf9c78f85a9114c463a369786585ad2882d1ff0b0acf40"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
  "windows-implement",
  "windows-interface",
  "windows-link",
  "windows-result",
- "windows-strings 0.4.1",
+ "windows-strings 0.4.2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "windows-result"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b895b5356fc36103d0f64dd1e94dfa7ac5633f1c9dd6e80fe9ec4adef69e09d"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
 dependencies = [
  "windows-link",
 ]
···
 
 [[package]]
 name = "windows-strings"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a7ab927b2637c19b3dbe0965e75d8f2d30bdd697a1516191cad2ec4df8fb28a"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
 dependencies = [
  "windows-link",
 ]
···
 checksum = "8902160c4e6f2fb145dbe9d6760a75e3c9522d8bf796ed7047c85919ac7115f8"
 dependencies = [
  "arraydeque",
- "hashlink",
+ "hashlink 0.8.4",
+]
+
+[[package]]
+name = "yaml-rust2"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18b783b2c2789414f8bb84ca3318fc9c2d7e7be1c22907d37839a58dedb369d3"
+dependencies = [
+ "arraydeque",
+ "encoding_rs",
+ "hashlink 0.10.0",
 ]
 
 [[package]]

Cargo.toml

···
 miette = { version = "7.6" }
 owo-colors = { version = "4.2.0" }
 thiserror = "2.0"
-syntect = "5.2.0"
+syntect = { version = "5.2.0", default-features = false }
 jane-eyre = "0.6.12"
 n0-future = "=0.1.3"
 tracing = { version = "0.1.41", default-features = false, features = ["std"] }
···
   "serde-codec",
 ] }
 markdown-weaver = { git = "https://github.com/rsform/markdown-weaver" }
+markdown-weaver-escape = { git = "https://github.com/rsform/markdown-weaver" }
 
 esquema-codegen = { git = "https://github.com/fatfingers23/esquema.git", branch = "main" }
 atrium-lex = { git = "https://github.com/sugyan/atrium.git", rev = "f162f815a04b5ecb0421b390d521c883c41d5f75" }

crates/weaver-common/Cargo.toml

···
 tower-layer = "0.3.3"
 multibase = "0.9.1"
 dirs = "6.0.0"
+regex = "1.11.1"
+markdown-weaver-escape = { workspace = true, features = ["std"] }
 
 
 

crates/weaver-common/src/agent.rs

···
 use crate::resolver::HickoryDnsTxtResolver;
 use crate::sh::weaver::actor::defs::ProfileDataViewInnerRefs;
 use atrium_api::agent::{CloneWithProxy, Configure};
-use atrium_api::types::string::{Cid, Did, Handle, Nsid, RecordKey};
-use atrium_api::types::{Collection, Union, Unknown};
+use atrium_api::types::string::{Cid, Did, Handle, Nsid, RecordKey, Tid};
+use atrium_api::types::{BlobRef, Collection, LimitedU32, TryIntoUnknown, Union, Unknown};
 use atrium_api::{agent::SessionManager, types::string::AtIdentifier};
 use atrium_common::resolver::Resolver;
 use atrium_identity::did::{CommonDidResolver, CommonDidResolverConfig, DEFAULT_PLC_DIRECTORY_URL};
···
             AtprotoHandleResolver<HickoryDnsTxtResolver, WeaverHttpClient>,
         >,
     >,
+    pub client: Arc<WeaverHttpClient>,
     pub api: Service<Wrapper<M>>,
 }
 
···
         Self {
             session_manager,
             resolver: Arc::new(IdentityResolver::new(resolver_config)),
+            client: Arc::clone(&http_client),
             api,
         }
     }
···
 
     pub async fn did(&self) -> Option<Did> {
         self.session_manager.did().await
+    }
+
+    pub fn pds(&self) -> String {
+        self.session_manager.base_uri()
     }
 }
 
···
             }
         }
     }
+    pub async fn create_record(
+        &self,
+        collection: Nsid,
+        record: Unknown,
+        repo: AtIdentifier,
+        rkey: Option<RecordKey>,
+    ) -> Result<crate::com::atproto::repo::create_record::OutputData, Error> {
+        use crate::com::atproto::repo::create_record::*;
+        let result = self
+            .api
+            .com
+            .atproto
+            .repo
+            .create_record(
+                InputData {
+                    collection,
+                    record,
+                    repo,
+                    rkey,
+                    swap_commit: None,
+                    validate: None,
+                }
+                .into(),
+            )
+            .await?;
+        Ok(result.data)
+    }
 
     pub async fn put_record(
         &self,
···
         Ok(result.data)
     }
 
+    pub async fn publish_blob(
+        &self,
+        input: Vec<u8>,
+    ) -> Result<
+        (
+            BlobRef,
+            crate::com::atproto::repo::create_record::OutputData,
+        ),
+        Error,
+    > {
+        use crate::sh::weaver::publish;
+        let blobref = self
+            .api
+            .com
+            .atproto
+            .repo
+            .upload_blob(input.into())
+            .await?
+            .blob
+            .clone();
+        let upload_record = publish::blob::RecordData {
+            upload: blobref.clone(),
+        };
+        let at_identifier = AtIdentifier::try_from(self.did().await.expect("valid did"))
+            .expect("valid did should be valid at identifier");
+        let result = self
+            .create_record(
+                Nsid::new(publish::Blob::NSID.to_string())
+                    .expect("sh.weaver.publish.blob should be a valid NSID"),
+                upload_record
+                    .try_into_unknown()
+                    .expect("this should just work"),
+                at_identifier,
+                None,
+            )
+            .await?;
+        Ok((blobref, result))
+    }
+
     pub async fn upload_artifact(
         &self,
         content: String,
···
     M: CloneWithProxy + SessionManager + Send + Sync,
 {
     /// Configures the atproto-proxy header to be applied on requests.
-
     ///
-
     /// Returns a new client service with the proxy header configured.
 
     pub fn api_with_proxy(&self, did: Did, service_type: impl AsRef<str>) -> Service<Wrapper<M>> {

crates/weaver-common/src/lexicons/app/bsky/feed/defs.rs

···
     pub reason: core::option::Option<atrium_api::types::Union<FeedViewPostReasonRefs>>,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub reply: core::option::Option<ReplyRef>,
+    ///Unique identifier per request that may be passed back alongside interactions.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub req_id: core::option::Option<String>,
 }
 pub type FeedViewPost = atrium_api::types::Object<FeedViewPostData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
     pub feed_context: core::option::Option<String>,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub item: core::option::Option<String>,
+    ///Unique identifier per request that may be passed back alongside interactions.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub req_id: core::option::Option<String>,
 }
 pub type Interaction = atrium_api::types::Object<InteractionData>;
 ///User liked the feed item
···
 #[serde(rename_all = "camelCase")]
 pub struct ReasonRepostData {
     pub by: crate::app::bsky::actor::defs::ProfileViewBasic,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub cid: core::option::Option<atrium_api::types::string::Cid>,
     pub indexed_at: atrium_api::types::string::Datetime,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub uri: core::option::Option<String>,
 }
 pub type ReasonRepost = atrium_api::types::Object<ReasonRepostData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

crates/weaver-common/src/lexicons/app/bsky/feed/get_feed_skeleton.rs

···
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub cursor: core::option::Option<String>,
     pub feed: Vec<crate::app::bsky::feed::defs::SkeletonFeedPost>,
+    ///Unique identifier per request that may be passed back alongside interactions.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub req_id: core::option::Option<String>,
 }
 pub type Output = atrium_api::types::Object<OutputData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]

crates/weaver-common/src/lexicons/app/bsky/feed/like.rs

···
 pub struct RecordData {
     pub created_at: atrium_api::types::string::Datetime,
     pub subject: crate::com::atproto::repo::strong_ref::Main,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub via: core::option::Option<crate::com::atproto::repo::strong_ref::Main>,
 }
 pub type Record = atrium_api::types::Object<RecordData>;
 impl From<atrium_api::types::Unknown> for RecordData {

crates/weaver-common/src/lexicons/app/bsky/feed/repost.rs

···
 pub struct RecordData {
     pub created_at: atrium_api::types::string::Datetime,
     pub subject: crate::com::atproto::repo::strong_ref::Main,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub via: core::option::Option<crate::com::atproto::repo::strong_ref::Main>,
 }
 pub type Record = atrium_api::types::Object<RecordData>;
 impl From<atrium_api::types::Unknown> for RecordData {

crates/weaver-common/src/lexicons/app/bsky/notification/list_notifications.rs

···
     pub is_read: bool,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub labels: core::option::Option<Vec<crate::com::atproto::label::defs::Label>>,
-    ///Expected values are 'like', 'repost', 'follow', 'mention', 'reply', 'quote', 'starterpack-joined', 'verified', and 'unverified'.
+    ///The reason why this notification was delivered - e.g. your post was liked, or you received a new follower.
     pub reason: String,
     #[serde(skip_serializing_if = "core::option::Option::is_none")]
     pub reason_subject: core::option::Option<String>,

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

···
             _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
         }
     }
-    ///Find posts matching search criteria, returning views of those posts.
+    ///Find posts matching search criteria, returning views of those posts. Note that this API endpoint may require authentication (eg, not public) for some service providers and implementations.
     pub async fn search_posts(
         &self,
         params: crate::app::bsky::feed::search_posts::Parameters,

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

···
     #[serde(rename = "app.bsky.actor.status")]
     LexiconsAppBskyActorStatus(Box<crate::lexicons::app::bsky::actor::status::Record>),
     #[serde(rename = "app.bsky.feed.generator")]
-    LexiconsAppBskyFeedGenerator(
-        Box<crate::lexicons::app::bsky::feed::generator::Record>,
-    ),
+    LexiconsAppBskyFeedGenerator(Box<crate::lexicons::app::bsky::feed::generator::Record>),
     #[serde(rename = "app.bsky.feed.like")]
     LexiconsAppBskyFeedLike(Box<crate::lexicons::app::bsky::feed::like::Record>),
     #[serde(rename = "app.bsky.feed.post")]
···
     #[serde(rename = "app.bsky.feed.repost")]
     LexiconsAppBskyFeedRepost(Box<crate::lexicons::app::bsky::feed::repost::Record>),
     #[serde(rename = "app.bsky.feed.threadgate")]
-    LexiconsAppBskyFeedThreadgate(
-        Box<crate::lexicons::app::bsky::feed::threadgate::Record>,
-    ),
+    LexiconsAppBskyFeedThreadgate(Box<crate::lexicons::app::bsky::feed::threadgate::Record>),
     #[serde(rename = "app.bsky.graph.block")]
     LexiconsAppBskyGraphBlock(Box<crate::lexicons::app::bsky::graph::block::Record>),
     #[serde(rename = "app.bsky.graph.follow")]
···
     #[serde(rename = "app.bsky.graph.list")]
     LexiconsAppBskyGraphList(Box<crate::lexicons::app::bsky::graph::list::Record>),
     #[serde(rename = "app.bsky.graph.listblock")]
-    LexiconsAppBskyGraphListblock(
-        Box<crate::lexicons::app::bsky::graph::listblock::Record>,
-    ),
+    LexiconsAppBskyGraphListblock(Box<crate::lexicons::app::bsky::graph::listblock::Record>),
     #[serde(rename = "app.bsky.graph.listitem")]
-    LexiconsAppBskyGraphListitem(
-        Box<crate::lexicons::app::bsky::graph::listitem::Record>,
-    ),
+    LexiconsAppBskyGraphListitem(Box<crate::lexicons::app::bsky::graph::listitem::Record>),
     #[serde(rename = "app.bsky.graph.starterpack")]
-    LexiconsAppBskyGraphStarterpack(
-        Box<crate::lexicons::app::bsky::graph::starterpack::Record>,
-    ),
+    LexiconsAppBskyGraphStarterpack(Box<crate::lexicons::app::bsky::graph::starterpack::Record>),
     #[serde(rename = "app.bsky.graph.verification")]
-    LexiconsAppBskyGraphVerification(
-        Box<crate::lexicons::app::bsky::graph::verification::Record>,
-    ),
+    LexiconsAppBskyGraphVerification(Box<crate::lexicons::app::bsky::graph::verification::Record>),
     #[serde(rename = "app.bsky.labeler.service")]
-    LexiconsAppBskyLabelerService(
-        Box<crate::lexicons::app::bsky::labeler::service::Record>,
-    ),
+    LexiconsAppBskyLabelerService(Box<crate::lexicons::app::bsky::labeler::service::Record>),
     #[serde(rename = "chat.bsky.actor.declaration")]
-    LexiconsChatBskyActorDeclaration(
-        Box<crate::lexicons::chat::bsky::actor::declaration::Record>,
-    ),
+    LexiconsChatBskyActorDeclaration(Box<crate::lexicons::chat::bsky::actor::declaration::Record>),
     #[serde(rename = "com.atproto.lexicon.schema")]
-    LexiconsComAtprotoLexiconSchema(
-        Box<crate::lexicons::com::atproto::lexicon::schema::Record>,
-    ),
+    LexiconsComAtprotoLexiconSchema(Box<crate::lexicons::com::atproto::lexicon::schema::Record>),
     #[serde(rename = "sh.tangled.actor.profile")]
-    LexiconsShTangledActorProfile(
-        Box<crate::lexicons::sh::tangled::actor::profile::Record>,
-    ),
+    LexiconsShTangledActorProfile(Box<crate::lexicons::sh::tangled::actor::profile::Record>),
     #[serde(rename = "sh.weaver.actor.profile")]
-    LexiconsShWeaverActorProfile(
-        Box<crate::lexicons::sh::weaver::actor::profile::Record>,
-    ),
+    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")]
···
     #[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>,
-    ),
+    LexiconsShWeaverNotebookAuthors(Box<crate::lexicons::sh::weaver::notebook::authors::Record>),
     #[serde(rename = "sh.weaver.notebook.book")]
-    LexiconsShWeaverNotebookBook(
-        Box<crate::lexicons::sh::weaver::notebook::book::Record>,
-    ),
+    LexiconsShWeaverNotebookBook(Box<crate::lexicons::sh::weaver::notebook::book::Record>),
+    #[serde(rename = "sh.weaver.notebook.chapter")]
+    LexiconsShWeaverNotebookChapter(Box<crate::lexicons::sh::weaver::notebook::chapter::Record>),
     #[serde(rename = "sh.weaver.notebook.entry")]
-    LexiconsShWeaverNotebookEntry(
-        Box<crate::lexicons::sh::weaver::notebook::entry::Record>,
-    ),
+    LexiconsShWeaverNotebookEntry(Box<crate::lexicons::sh::weaver::notebook::entry::Record>),
+    #[serde(rename = "sh.weaver.publish.blob")]
+    LexiconsShWeaverPublishBlob(Box<crate::lexicons::sh::weaver::publish::blob::Record>),
 }
 impl From<crate::lexicons::app::bsky::actor::profile::Record> for KnownRecord {
     fn from(record: crate::lexicons::app::bsky::actor::profile::Record) -> Self {
···
     }
 }
 impl From<crate::lexicons::app::bsky::actor::profile::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::actor::profile::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::actor::profile::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyActorProfile(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::feed::generator::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::feed::generator::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::feed::generator::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyFeedGenerator(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::feed::postgate::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::feed::postgate::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::feed::postgate::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyFeedPostgate(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::feed::threadgate::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::feed::threadgate::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::feed::threadgate::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyFeedThreadgate(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::graph::listblock::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::graph::listblock::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::graph::listblock::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyGraphListblock(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::graph::listitem::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::graph::listitem::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::graph::listitem::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyGraphListitem(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::graph::starterpack::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::graph::starterpack::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::graph::starterpack::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyGraphStarterpack(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::graph::verification::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::graph::verification::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::graph::verification::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyGraphVerification(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::app::bsky::labeler::service::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::app::bsky::labeler::service::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::app::bsky::labeler::service::RecordData) -> Self {
         KnownRecord::LexiconsAppBskyLabelerService(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::chat::bsky::actor::declaration::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::chat::bsky::actor::declaration::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::chat::bsky::actor::declaration::RecordData) -> Self {
         KnownRecord::LexiconsChatBskyActorDeclaration(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::com::atproto::lexicon::schema::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::com::atproto::lexicon::schema::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::com::atproto::lexicon::schema::RecordData) -> Self {
         KnownRecord::LexiconsComAtprotoLexiconSchema(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::sh::tangled::actor::profile::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::sh::tangled::actor::profile::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::sh::tangled::actor::profile::RecordData) -> Self {
         KnownRecord::LexiconsShTangledActorProfile(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::sh::weaver::actor::profile::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::sh::weaver::actor::profile::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::sh::weaver::actor::profile::RecordData) -> Self {
         KnownRecord::LexiconsShWeaverActorProfile(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::sh::weaver::notebook::authors::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::sh::weaver::notebook::authors::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::sh::weaver::notebook::authors::RecordData) -> Self {
         KnownRecord::LexiconsShWeaverNotebookAuthors(Box::new(record_data.into()))
     }
 }
···
     }
 }
 impl From<crate::lexicons::sh::weaver::notebook::book::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::sh::weaver::notebook::book::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::sh::weaver::notebook::book::RecordData) -> Self {
         KnownRecord::LexiconsShWeaverNotebookBook(Box::new(record_data.into()))
     }
 }
+impl From<crate::lexicons::sh::weaver::notebook::chapter::Record> for KnownRecord {
+    fn from(record: crate::lexicons::sh::weaver::notebook::chapter::Record) -> Self {
+        KnownRecord::LexiconsShWeaverNotebookChapter(Box::new(record))
+    }
+}
+impl From<crate::lexicons::sh::weaver::notebook::chapter::RecordData> for KnownRecord {
+    fn from(record_data: crate::lexicons::sh::weaver::notebook::chapter::RecordData) -> Self {
+        KnownRecord::LexiconsShWeaverNotebookChapter(Box::new(record_data.into()))
+    }
+}
 impl From<crate::lexicons::sh::weaver::notebook::entry::Record> for KnownRecord {
     fn from(record: crate::lexicons::sh::weaver::notebook::entry::Record) -> Self {
         KnownRecord::LexiconsShWeaverNotebookEntry(Box::new(record))
     }
 }
 impl From<crate::lexicons::sh::weaver::notebook::entry::RecordData> for KnownRecord {
-    fn from(
-        record_data: crate::lexicons::sh::weaver::notebook::entry::RecordData,
-    ) -> Self {
+    fn from(record_data: crate::lexicons::sh::weaver::notebook::entry::RecordData) -> Self {
         KnownRecord::LexiconsShWeaverNotebookEntry(Box::new(record_data.into()))
+    }
+}
+impl From<crate::lexicons::sh::weaver::publish::blob::Record> for KnownRecord {
+    fn from(record: crate::lexicons::sh::weaver::publish::blob::Record) -> Self {
+        KnownRecord::LexiconsShWeaverPublishBlob(Box::new(record))
+    }
+}
+impl From<crate::lexicons::sh::weaver::publish::blob::RecordData> for KnownRecord {
+    fn from(record_data: crate::lexicons::sh::weaver::publish::blob::RecordData) -> Self {
+        KnownRecord::LexiconsShWeaverPublishBlob(Box::new(record_data.into()))
     }
 }
 impl Into<atrium_api::types::Unknown> for KnownRecord {

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

···
 pub mod edit;
 pub mod embed;
 pub mod notebook;
+pub mod publish;

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

···
 // @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
 //!Definitions for the `sh.weaver.actor.defs` namespace.
+///A single author in a Weaver notebook.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct AuthorData {
+    pub did: atrium_api::types::string::Did,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub display_name: core::option::Option<String>,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub handle: core::option::Option<atrium_api::types::string::Handle>,
+}
+pub type Author = atrium_api::types::Object<AuthorData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileDataViewData {

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

···
 //!Definitions for the `sh.weaver.notebook` namespace.
 pub mod authors;
 pub mod book;
+pub mod chapter;
 pub mod defs;
 pub mod entry;
 #[derive(Debug)]
···
 impl atrium_api::types::Collection for Book {
     const NSID: &'static str = "sh.weaver.notebook.book";
     type Record = book::Record;
+}
+#[derive(Debug)]
+pub struct Chapter;
+impl atrium_api::types::Collection for Chapter {
+    const NSID: &'static str = "sh.weaver.notebook.chapter";
+    type Record = chapter::Record;
 }
 #[derive(Debug)]
 pub struct Entry;

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

···
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct RecordData {
-    pub authors: crate::sh::weaver::notebook::defs::AuthorListView,
+    pub authors: Vec<crate::sh::weaver::actor::defs::Author>,
     ///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 entry_list: Vec<crate::com::atproto::repo::strong_ref::Main>,
     #[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")]

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

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.notebook.chapter` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    pub authors: Vec<crate::sh::weaver::actor::defs::Author>,
+    ///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::com::atproto::repo::strong_ref::Main>,
+    ///The notebook this chapter belongs to.
+    pub notebook: crate::com::atproto::repo::strong_ref::Main,
+    #[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 {
+    fn from(value: atrium_api::types::Unknown) -> Self {
+        Self::try_from_unknown(value).unwrap()
+    }
+}

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

···
     pub prev: core::option::Option<BookEntryRef>,
 }
 pub type BookEntryView = atrium_api::types::Object<BookEntryViewData>;
+///The format of the content. This is used to determine how to render the content.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContentFormatData {
+    ///The format of the content. This is used to determine how to render the content.
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub markdown: core::option::Option<String>,
+}
+pub type ContentFormat = atrium_api::types::Object<ContentFormatData>;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct EntryViewData {

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

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

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

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.publish.blob` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    ///Reference to the uploaded file
+    pub upload: 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/publish/defs.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.weaver.publish.defs` namespace.

crates/weaver-common/src/lib.rs

···
 pub mod oauth;
 pub mod resolver;
 pub mod xrpc_server;
-use atrium_api::types::{BlobRef, TypedBlobRef, string::Did};
+use std::sync::OnceLock;
+
+pub use atrium_api::types::*;
 pub use lexicons::*;
+use regex::Regex;
+use string::Did;
 
 pub use crate::error::{Error, IoError, ParseError, SerDeError};
 
···
         mime_type.strip_prefix("image/").unwrap_or(mime_type)
     )
 }
+
+pub fn blob_url(did: &Did, pds: &str, blob_ref: &BlobRef) -> String {
+    let cid = match blob_ref {
+        BlobRef::Typed(TypedBlobRef::Blob(b)) => atrium_api::types::string::Cid::new(b.r#ref.0)
+            .as_ref()
+            .to_string(),
+
+        BlobRef::Untyped(r) => r.cid.clone(),
+    };
+    format!(
+        "https://{}/xrpc/com.atproto.repo.getBlob?did={}&cid={}",
+        pds,
+        did.as_str(),
+        cid,
+    )
+}
+
+pub fn match_identifier(maybe_identifier: &str) -> Option<&str> {
+    static RE_HANDLE: OnceLock<Regex> = OnceLock::new();
+    static RE_DID: OnceLock<Regex> = OnceLock::new();
+    if maybe_identifier.len() > 253 {
+         None
+    } else if !RE_DID.get_or_init(|| Regex::new(r"^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$").unwrap())
+        .is_match(&maybe_identifier) && !RE_HANDLE
+        .get_or_init(|| Regex::new(r"^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$").unwrap())
+        .is_match(&maybe_identifier)
+    {
+        None
+    } else {
+        Some(maybe_identifier)
+    }
+}
+
+pub fn match_nsid(maybe_nsid: &str) -> Option<&str> {
+    static RE_NSID: OnceLock<Regex> = OnceLock::new();
+    if maybe_nsid.len() > 317 {
+        None
+    } else if !RE_NSID
+        .get_or_init(|| Regex::new(r"^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z0-9]{0,62}[a-zA-Z0-9])?)$").unwrap())
+        .is_match(&maybe_nsid)
+    {
+        None
+    } else {
+        Some(maybe_nsid)
+    }
+}
+
+/// Convert an ATURI to a HTTP URL
+/// Currently has some failure modes and should restrict the NSIDs to a known subset
+pub fn aturi_to_http<'s>(aturi: &'s str, appview: &'s str) -> Option<markdown_weaver::CowStr<'s>> {
+    use markdown_weaver::CowStr;
+
+    if aturi.starts_with("at://") {
+        let rest = aturi.strip_prefix("at:://").unwrap();
+        let mut split = rest.splitn(2, '/');
+        let maybe_identifier = split.next()?;
+        let maybe_nsid = split.next()?;
+        let maybe_rkey = split.next()?;
+
+        // https://atproto.com/specs/handle#handle-identifier-syntax
+        let identifier = match_identifier(maybe_identifier)?;
+
+        let nsid = if let Some(nsid) = match_nsid(maybe_nsid) {
+            // Last part of the nsid is generally the middle component of the URL
+            // TODO: check for bsky ones specifically, because those are the ones where this is valid
+            nsid.rsplitn(1, '.').next()?
+        } else {
+            return None;
+        };
+        Some(CowStr::Boxed(
+            format!(
+                "https://{}/profile/{}/{}/{}",
+                appview, identifier, nsid, maybe_rkey
+            )
+            .into_boxed_str(),
+        ))
+    } else {
+        Some(CowStr::Borrowed(aturi))
+    }
+}

crates/weaver-renderer/Cargo.toml

···
 publish = false
 
 [dependencies]
-n0-future = { workspace = true }
+n0-future.workspace = true
 atrium-api = { version = "0.25.3", default-features = false }
 
 weaver-common = { path = "../weaver-common" }
-
+markdown-weaver = { workspace = true }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
 compact_string = "0.1.0"
 http = "1.3.1"
 url = "2.5.4"
+syntect = { workspace = true, default-features = false, features = ["default-fancy"]}
+markdown-weaver-escape = { workspace = true, features = ["std"] }
+thiserror.workspace = true
+miette.workspace = true
+pathdiff = "0.2.3"
+unicode-normalization = "0.1.24"
+yaml-rust2 = { version = "0.10.2" }
+bitflags = "2.9.1"
+ignore = "0.4.23"
+dashmap = "6.1.0"
+regex = "1.11.1"
+pin-utils = "0.1.0"
+pin-project = "1.1.10"
+dynosaur = "0.2.0"
+async-trait = "0.1.88"
+
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+tokio = { version = "1.28", features = ["rt", "time"] }
+tokio-util = { version = "0.7.14", features = ["rt"] }

crates/weaver-renderer/src/atproto.rs

···
+//! Atproto renderer
+//!
+//! This mode of the renderer renders either an entire notebook or entries in it to files suitable for inclusion
+//! in a single-page app and uploads them to your Atproto PDS
+//! It can be accessed via the appview at {your-handle}.weaver.sh/{notebook-name}.
+//!
+//! It can also be edited there.
+//!
+//! Link altering logic:
+//!  - Option 1: leave (non-embed) links the same as in the markdown, have the CSM deal with them via some means
+//!    such as adding "data-did" and "data-cid" attributes to the `<a/>` tag containing the DID and CID
+//!    Pushes toward having the SPA/Appview do a bit more, but makes this step MUCH simpler
+//!     - In this scenario, the rendering step can happen upon access (and then be cached) in the appview
+//!     - More flexible in some ways, less in others
+//!  - Option 2: alter links to point to other rendered blobs. Requires a certain amount of work to handle
+//!    scenarios with a complex mesh of internal links, as the CID is altered by the editing of the link.
+//!    Such cycles are handled in the simplest way, by rendering an absolute url which will make a call to the appview.
+//!

crates/weaver-renderer/src/base_html.rs

···
+// use std::{string::String, vec::Vec};
+// #[cfg(all(feature = "std", not(feature = "hashbrown")))]
+// use std::collections::HashMap;
+
+// #[cfg(feature = "hashbrown")]
+// use hashbrown::HashMap;
+//
+use std::collections::HashMap;
+//#[cfg(feature = "std")]
+use markdown_weaver_escape::IoWriter;
+use markdown_weaver_escape::{
+    FmtWriter, StrWrite, escape_href, escape_html, escape_html_body_text,
+};
+
+use markdown_weaver::{
+    Alignment, BlockQuoteKind, CodeBlockKind, CowStr, Event, Event::*, LinkType, Tag, TagEnd,
+};
+
+pub enum TableState {
+    Head,
+    Body,
+}
+
+struct HtmlWriter<'a, I, W> {
+    /// Iterator supplying events.
+    iter: I,
+
+    /// Writer to write to.
+    writer: W,
+
+    /// Whether or not the last write wrote a newline.
+    end_newline: bool,
+
+    /// Whether if inside a metadata block (text should not be written)
+    in_non_writing_block: bool,
+
+    table_state: TableState,
+    table_alignments: Vec<Alignment>,
+    table_cell_index: usize,
+    numbers: HashMap<CowStr<'a>, usize>,
+}
+
+impl<'a, I, W> HtmlWriter<'a, I, W>
+where
+    I: Iterator<Item = Event<'a>>,
+    W: StrWrite,
+{
+    fn new(iter: I, writer: W) -> Self {
+        Self {
+            iter,
+            writer,
+            end_newline: true,
+            in_non_writing_block: false,
+            table_state: TableState::Head,
+            table_alignments: vec![],
+            table_cell_index: 0,
+            numbers: HashMap::new(),
+        }
+    }
+
+    /// Writes a new line.
+    #[inline]
+    fn write_newline(&mut self) -> Result<(), W::Error> {
+        self.end_newline = true;
+        self.writer.write_str("\n")
+    }
+
+    /// Writes a buffer, and tracks whether or not a newline was written.
+    #[inline]
+    fn write(&mut self, s: &str) -> Result<(), W::Error> {
+        self.writer.write_str(s)?;
+
+        if !s.is_empty() {
+            self.end_newline = s.ends_with('\n');
+        }
+        Ok(())
+    }
+
+    fn run(mut self) -> Result<(), W::Error> {
+        while let Some(event) = self.iter.next() {
+            match event {
+                Start(tag) => {
+                    self.start_tag(tag)?;
+                }
+                End(tag) => {
+                    self.end_tag(tag)?;
+                }
+                Text(text) => {
+                    if !self.in_non_writing_block {
+                        escape_html_body_text(&mut self.writer, &text)?;
+                        self.end_newline = text.ends_with('\n');
+                    }
+                }
+                Code(text) => {
+                    self.write("<code>")?;
+                    escape_html_body_text(&mut self.writer, &text)?;
+                    self.write("</code>")?;
+                }
+                InlineMath(text) => {
+                    self.write(r#"<span class="math math-inline">"#)?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("</span>")?;
+                }
+                DisplayMath(text) => {
+                    self.write(r#"<span class="math math-display">"#)?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("</span>")?;
+                }
+                Html(html) | InlineHtml(html) => {
+                    self.write(&html)?;
+                }
+                SoftBreak => {
+                    self.write_newline()?;
+                }
+                HardBreak => {
+                    self.write("<br />\n")?;
+                }
+                Rule => {
+                    if self.end_newline {
+                        self.write("<hr />\n")?;
+                    } else {
+                        self.write("\n<hr />\n")?;
+                    }
+                }
+                FootnoteReference(name) => {
+                    let len = self.numbers.len() + 1;
+                    self.write("<sup class=\"footnote-reference\"><a href=\"#")?;
+                    escape_html(&mut self.writer, &name)?;
+                    self.write("\">")?;
+                    let number = *self.numbers.entry(name).or_insert(len);
+                    write!(&mut self.writer, "{}", number)?;
+                    self.write("</a></sup>")?;
+                }
+                TaskListMarker(true) => {
+                    self.write("<input disabled=\"\" type=\"checkbox\" checked=\"\"/>\n")?;
+                }
+                TaskListMarker(false) => {
+                    self.write("<input disabled=\"\" type=\"checkbox\"/>\n")?;
+                }
+                WeaverBlock(_text) => {}
+            }
+        }
+        Ok(())
+    }
+
+    /// Writes the start of an HTML tag.
+    fn start_tag(&mut self, tag: Tag<'a>) -> Result<(), W::Error> {
+        match tag {
+            Tag::HtmlBlock => Ok(()),
+            Tag::Paragraph => {
+                if self.end_newline {
+                    self.write("<p>")
+                } else {
+                    self.write("\n<p>")
+                }
+            }
+            Tag::Heading {
+                level,
+                id,
+                classes,
+                attrs,
+            } => {
+                if self.end_newline {
+                    self.write("<")?;
+                } else {
+                    self.write("\n<")?;
+                }
+                write!(&mut self.writer, "{}", level)?;
+                if let Some(id) = id {
+                    self.write(" id=\"")?;
+                    escape_html(&mut self.writer, &id)?;
+                    self.write("\"")?;
+                }
+                let mut classes = classes.iter();
+                if let Some(class) = classes.next() {
+                    self.write(" class=\"")?;
+                    escape_html(&mut self.writer, class)?;
+                    for class in classes {
+                        self.write(" ")?;
+                        escape_html(&mut self.writer, class)?;
+                    }
+                    self.write("\"")?;
+                }
+                for (attr, value) in attrs {
+                    self.write(" ")?;
+                    escape_html(&mut self.writer, &attr)?;
+                    if let Some(val) = value {
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, &val)?;
+                        self.write("\"")?;
+                    } else {
+                        self.write("=\"\"")?;
+                    }
+                }
+                self.write(">")
+            }
+            Tag::Table(alignments) => {
+                self.table_alignments = alignments;
+                self.write("<table>")
+            }
+            Tag::TableHead => {
+                self.table_state = TableState::Head;
+                self.table_cell_index = 0;
+                self.write("<thead><tr>")
+            }
+            Tag::TableRow => {
+                self.table_cell_index = 0;
+                self.write("<tr>")
+            }
+            Tag::TableCell => {
+                match self.table_state {
+                    TableState::Head => {
+                        self.write("<th")?;
+                    }
+                    TableState::Body => {
+                        self.write("<td")?;
+                    }
+                }
+                match self.table_alignments.get(self.table_cell_index) {
+                    Some(&Alignment::Left) => self.write(" style=\"text-align: left\">"),
+                    Some(&Alignment::Center) => self.write(" style=\"text-align: center\">"),
+                    Some(&Alignment::Right) => self.write(" style=\"text-align: right\">"),
+                    _ => self.write(">"),
+                }
+            }
+            Tag::BlockQuote(kind) => {
+                let class_str = match kind {
+                    None => "",
+                    Some(kind) => match kind {
+                        BlockQuoteKind::Note => " class=\"markdown-alert-note\"",
+                        BlockQuoteKind::Tip => " class=\"markdown-alert-tip\"",
+                        BlockQuoteKind::Important => " class=\"markdown-alert-important\"",
+                        BlockQuoteKind::Warning => " class=\"markdown-alert-warning\"",
+                        BlockQuoteKind::Caution => " class=\"markdown-alert-caution\"",
+                    },
+                };
+                if self.end_newline {
+                    self.write(&format!("<blockquote{}>\n", class_str))
+                } else {
+                    self.write(&format!("\n<blockquote{}>\n", class_str))
+                }
+            }
+            Tag::CodeBlock(info) => {
+                if !self.end_newline {
+                    self.write_newline()?;
+                }
+                match info {
+                    CodeBlockKind::Fenced(info) => {
+                        let lang = info.split(' ').next().unwrap();
+                        if lang.is_empty() {
+                            self.write("<pre><code>")
+                        } else {
+                            self.write("<pre><code class=\"language-")?;
+                            escape_html(&mut self.writer, lang)?;
+                            self.write("\">")
+                        }
+                    }
+                    CodeBlockKind::Indented => self.write("<pre><code>"),
+                }
+            }
+            Tag::List(Some(1)) => {
+                if self.end_newline {
+                    self.write("<ol>\n")
+                } else {
+                    self.write("\n<ol>\n")
+                }
+            }
+            Tag::List(Some(start)) => {
+                if self.end_newline {
+                    self.write("<ol start=\"")?;
+                } else {
+                    self.write("\n<ol start=\"")?;
+                }
+                write!(&mut self.writer, "{}", start)?;
+                self.write("\">\n")
+            }
+            Tag::List(None) => {
+                if self.end_newline {
+                    self.write("<ul>\n")
+                } else {
+                    self.write("\n<ul>\n")
+                }
+            }
+            Tag::Item => {
+                if self.end_newline {
+                    self.write("<li>")
+                } else {
+                    self.write("\n<li>")
+                }
+            }
+            Tag::DefinitionList => {
+                if self.end_newline {
+                    self.write("<dl>\n")
+                } else {
+                    self.write("\n<dl>\n")
+                }
+            }
+            Tag::DefinitionListTitle => {
+                if self.end_newline {
+                    self.write("<dt>")
+                } else {
+                    self.write("\n<dt>")
+                }
+            }
+            Tag::DefinitionListDefinition => {
+                if self.end_newline {
+                    self.write("<dd>")
+                } else {
+                    self.write("\n<dd>")
+                }
+            }
+            Tag::Subscript => self.write("<sub>"),
+            Tag::Superscript => self.write("<sup>"),
+            Tag::Emphasis => self.write("<em>"),
+            Tag::Strong => self.write("<strong>"),
+            Tag::Strikethrough => self.write("<del>"),
+            Tag::Link {
+                link_type: LinkType::Email,
+                dest_url,
+                title,
+                id: _,
+            } => {
+                self.write("<a href=\"mailto:")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Link {
+                link_type: _,
+                dest_url,
+                title,
+                id: _,
+            } => {
+                self.write("<a href=\"")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Image {
+                link_type: _,
+                dest_url,
+                title,
+                id: _,
+                attrs,
+            } => {
+                self.write("<img src=\"")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if let Some(attrs) = attrs {
+                    if !attrs.classes.is_empty() {
+                        self.write("\" class=\"")?;
+                        for class in &attrs.classes {
+                            escape_html(&mut self.writer, class)?;
+                            self.write(" ")?;
+                        }
+                        self.write("\" ")?;
+                    } else {
+                        self.write("\" ")?;
+                    }
+                    if !attrs.attrs.is_empty() {
+                        for (attr, value) in &attrs.attrs {
+                            escape_html(&mut self.writer, attr)?;
+                            self.write("=\"")?;
+                            escape_html(&mut self.writer, value)?;
+                            self.write("\" ")?;
+                        }
+                    }
+                } else {
+                    self.write("\" ")?;
+                }
+                self.write("alt=\"")?;
+                self.raw_text()?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\" />")
+            }
+            Tag::Embed {
+                embed_type: _,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                // rewrite this to work correctly
+                self.write("<iframe src=\"")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                self.write("\" title=\"")?;
+                escape_html(&mut self.writer, &title)?;
+                if !id.is_empty() {
+                    self.write("\" id=\"")?;
+                    escape_html(&mut self.writer, &id)?;
+                    self.write("\"")?;
+                }
+                if let Some(attrs) = attrs {
+                    self.write(" ")?;
+                    if !attrs.classes.is_empty() {
+                        self.write("class=\"")?;
+                        for class in &attrs.classes {
+                            escape_html(&mut self.writer, class)?;
+                            self.write(" ")?;
+                        }
+                        self.write("\" ")?;
+                    }
+                    if !attrs.attrs.is_empty() {
+                        for (attr, value) in &attrs.attrs {
+                            escape_html(&mut self.writer, attr)?;
+                            self.write("=\"")?;
+                            escape_html(&mut self.writer, value)?;
+                            self.write("\" ")?;
+                        }
+                    }
+                }
+                self.write("/>")
+            }
+            Tag::WeaverBlock(_, _attrs) => {
+                println!("Weaver block");
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+            Tag::FootnoteDefinition(name) => {
+                if self.end_newline {
+                    self.write("<div class=\"footnote-definition\" id=\"")?;
+                } else {
+                    self.write("\n<div class=\"footnote-definition\" id=\"")?;
+                }
+                escape_html(&mut self.writer, &name)?;
+                self.write("\"><sup class=\"footnote-definition-label\">")?;
+                let len = self.numbers.len() + 1;
+                let number = *self.numbers.entry(name).or_insert(len);
+                write!(&mut self.writer, "{}", number)?;
+                self.write("</sup>")
+            }
+            Tag::MetadataBlock(_) => {
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+        }
+    }
+
+    fn end_tag(&mut self, tag: TagEnd) -> Result<(), W::Error> {
+        match tag {
+            TagEnd::HtmlBlock => {}
+            TagEnd::Paragraph => {
+                self.write("</p>\n")?;
+            }
+            TagEnd::Heading(level) => {
+                self.write("</")?;
+                write!(&mut self.writer, "{}", level)?;
+                self.write(">\n")?;
+            }
+            TagEnd::Table => {
+                self.write("</tbody></table>\n")?;
+            }
+            TagEnd::TableHead => {
+                self.write("</tr></thead><tbody>\n")?;
+                self.table_state = TableState::Body;
+            }
+            TagEnd::TableRow => {
+                self.write("</tr>\n")?;
+            }
+            TagEnd::TableCell => {
+                match self.table_state {
+                    TableState::Head => {
+                        self.write("</th>")?;
+                    }
+                    TableState::Body => {
+                        self.write("</td>")?;
+                    }
+                }
+                self.table_cell_index += 1;
+            }
+            TagEnd::BlockQuote(_) => {
+                self.write("</blockquote>\n")?;
+            }
+            TagEnd::CodeBlock => {
+                self.write("</code></pre>\n")?;
+            }
+            TagEnd::List(true) => {
+                self.write("</ol>\n")?;
+            }
+            TagEnd::List(false) => {
+                self.write("</ul>\n")?;
+            }
+            TagEnd::Item => {
+                self.write("</li>\n")?;
+            }
+            TagEnd::DefinitionList => {
+                self.write("</dl>\n")?;
+            }
+            TagEnd::DefinitionListTitle => {
+                self.write("</dt>\n")?;
+            }
+            TagEnd::DefinitionListDefinition => {
+                self.write("</dd>\n")?;
+            }
+            TagEnd::Emphasis => {
+                self.write("</em>")?;
+            }
+            TagEnd::Superscript => {
+                self.write("</sup>")?;
+            }
+            TagEnd::Subscript => {
+                self.write("</sub>")?;
+            }
+            TagEnd::Strong => {
+                self.write("</strong>")?;
+            }
+            TagEnd::Strikethrough => {
+                self.write("</del>")?;
+            }
+            TagEnd::Link => {
+                self.write("</a>")?;
+            }
+            TagEnd::Image => (), // shouldn't happen, handled in start
+            TagEnd::Embed => (), // shouldn't happen, handled in start
+            TagEnd::WeaverBlock(_) => {
+                self.in_non_writing_block = false;
+            }
+            TagEnd::FootnoteDefinition => {
+                self.write("</div>\n")?;
+            }
+            TagEnd::MetadataBlock(_) => {
+                self.in_non_writing_block = false;
+            }
+        }
+        Ok(())
+    }
+
+    // run raw text, consuming end tag
+    fn raw_text(&mut self) -> Result<(), W::Error> {
+        let mut nest = 0;
+        while let Some(event) = self.iter.next() {
+            match event {
+                Start(_) => nest += 1,
+                End(_) => {
+                    if nest == 0 {
+                        break;
+                    }
+                    nest -= 1;
+                }
+                Html(_) => {}
+                InlineHtml(text) | Code(text) | Text(text) => {
+                    // Don't use escape_html_body_text here.
+                    // The output of this function is used in the `alt` attribute.
+                    escape_html(&mut self.writer, &text)?;
+                    self.end_newline = text.ends_with('\n');
+                }
+                InlineMath(text) => {
+                    self.write("$")?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("$")?;
+                }
+                DisplayMath(text) => {
+                    self.write("$$")?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("$$")?;
+                }
+                SoftBreak | HardBreak | Rule => {
+                    self.write(" ")?;
+                }
+                FootnoteReference(name) => {
+                    let len = self.numbers.len() + 1;
+                    let number = *self.numbers.entry(name).or_insert(len);
+                    write!(&mut self.writer, "[{}]", number)?;
+                }
+                TaskListMarker(true) => self.write("[x]")?,
+                TaskListMarker(false) => self.write("[ ]")?,
+                WeaverBlock(_) => {
+                    println!("Weaver block internal");
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Iterate over an `Iterator` of `Event`s, generate HTML for each `Event`, and
+/// push it to a `String`.
+///
+/// # Examples
+///
+/// ```
+/// use pulldown_cmark::{html, Parser};
+///
+/// let markdown_str = r#"
+/// hello
+/// =====
+///
+/// * alpha
+/// * beta
+/// "#;
+/// let parser = Parser::new(markdown_str);
+///
+/// let mut html_buf = String::new();
+/// html::push_html(&mut html_buf, parser);
+///
+/// assert_eq!(html_buf, r#"<h1>hello</h1>
+/// <ul>
+/// <li>alpha</li>
+/// <li>beta</li>
+/// </ul>
+/// "#);
+/// ```
+pub fn push_html<'a, I>(s: &mut String, iter: I)
+where
+    I: Iterator<Item = Event<'a>>,
+{
+    write_html_fmt(s, iter).unwrap()
+}
+
+/// Iterate over an `Iterator` of `Event`s, generate HTML for each `Event`, and
+/// write it out to an I/O stream.
+///
+/// **Note**: using this function with an unbuffered writer like a file or socket
+/// will result in poor performance. Wrap these in a
+/// [`BufWriter`](https://doc.rust-lang.org/std/io/struct.BufWriter.html) to
+/// prevent unnecessary slowdowns.
+///
+/// # Examples
+///
+/// ```
+/// use pulldown_cmark::{html, Parser};
+/// use std::io::Cursor;
+///
+/// let markdown_str = r#"
+/// hello
+/// =====
+///
+/// * alpha
+/// * beta
+/// "#;
+/// let mut bytes = Vec::new();
+/// let parser = Parser::new(markdown_str);
+///
+/// html::write_html_io(Cursor::new(&mut bytes), parser);
+///
+/// assert_eq!(&String::from_utf8_lossy(&bytes)[..], r#"<h1>hello</h1>
+/// <ul>
+/// <li>alpha</li>
+/// <li>beta</li>
+/// </ul>
+/// "#);
+/// ```
+//#[cfg(feature = "std")]
+pub fn write_html_io<'a, I, W>(writer: W, iter: I) -> std::io::Result<()>
+where
+    I: Iterator<Item = Event<'a>>,
+    W: std::io::Write,
+{
+    HtmlWriter::new(iter, IoWriter(writer)).run()
+}
+
+/// Iterate over an `Iterator` of `Event`s, generate HTML for each `Event`, and
+/// write it into Unicode-accepting buffer or stream.
+///
+/// # Examples
+///
+/// ```
+/// use pulldown_cmark::{html, Parser};
+///
+/// let markdown_str = r#"
+/// hello
+/// =====
+///
+/// * alpha
+/// * beta
+/// "#;
+/// let mut buf = String::new();
+/// let parser = Parser::new(markdown_str);
+///
+/// html::write_html_fmt(&mut buf, parser);
+///
+/// assert_eq!(buf, r#"<h1>hello</h1>
+/// <ul>
+/// <li>alpha</li>
+/// <li>beta</li>
+/// </ul>
+/// "#);
+/// ```
+pub fn write_html_fmt<'a, I, W>(writer: W, iter: I) -> core::fmt::Result
+where
+    I: Iterator<Item = Event<'a>>,
+    W: core::fmt::Write,
+{
+    HtmlWriter::new(iter, FmtWriter(writer)).run()
+}

crates/weaver-renderer/src/code_pretty.rs

···
+use markdown_weaver_escape::StrWrite;
+// use syntect::highlighting::ThemeSet;
+// use syntect::html::css_for_theme_with_class_style;
+use syntect::html::{ClassStyle, ClassedHTMLGenerator};
+use syntect::parsing::SyntaxSet;
+use syntect::util::LinesWithEndings;
+
+/// Perform syntax highlighting on a code block.
+/// This requires an external stylesheet, also generated by syntect to be loaded by the page.
+/// The syntect SyntaxSet is also provided, so that it is not re-created on every call.
+pub fn highlight<M>(
+    syn_set: SyntaxSet,
+    lang: Option<&str>,
+    code: impl AsRef<str>,
+    writer: &mut M,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
+where
+    M: StrWrite,
+    <M as StrWrite>::Error: std::error::Error + Send + Sync + 'static,
+{
+    let lang_syn = if let Some(lang) = lang {
+        syn_set
+            .find_syntax_by_token(lang)
+            .unwrap_or_else(|| syn_set.find_syntax_plain_text())
+    } else {
+        syn_set
+            .find_syntax_by_first_line(code.as_ref())
+            .unwrap_or_else(|| syn_set.find_syntax_plain_text())
+    };
+    writer.write_str("<pre><code class=\"language-")?;
+    writer.write_str(&lang_syn.name)?;
+    writer.write_str("\">")?;
+
+    let mut html_gen = ClassedHTMLGenerator::new_with_class_style(
+        lang_syn,
+        &syn_set,
+        ClassStyle::SpacedPrefixed { prefix: CSS_PREFIX },
+    );
+    for line in LinesWithEndings::from(code.as_ref()) {
+        html_gen
+            .parse_html_for_line_which_includes_newline(line)
+            .unwrap();
+    }
+    writer.write_str(&html_gen.finalize())?;
+    writer.write_str("</code></pre>")?;
+    Ok(())
+}
+
+pub const CSS_PREFIX: &str = "wvrcode-";

crates/weaver-renderer/src/lib.rs

···
 //! This crate works with the weaver-markdown crate to render and optionally upload markdown notebooks to your Atproto PDS.
 //!
 
+use async_trait::async_trait;
+use markdown_weaver::CowStr;
+use markdown_weaver::Event;
+use markdown_weaver::LinkType;
+use markdown_weaver::Tag;
+use n0_future::Stream;
+use n0_future::StreamExt;
+use n0_future::pin;
+use n0_future::stream::once_future;
+use yaml_rust2::Yaml;
+use yaml_rust2::YamlLoader;
+
+use regex::Regex;
+use std::iter::Iterator;
+use std::path::PathBuf;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::sync::LazyLock;
+use std::sync::RwLock;
+use std::task::Poll;
+
+pub mod atproto;
+pub mod base_html;
+pub mod code_pretty;
+pub mod static_site;
 pub mod types;
+pub mod utils;
+pub mod walker;
+
+pub static OBSIDIAN_NOTE_LINK_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"^(?P<file>[^#|]+)??(#(?P<section>.+?))??(\|(?P<label>.+?))??$").unwrap()
+});
+
+#[derive(Debug, Default)]
+pub struct ContextIterator<'a, I: Iterator<Item = Event<'a>>> {
+    pub context: Option<EventContext>,
+    pub iter: I,
+    _phantom: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> ContextIterator<'a, I> {
+    pub fn new(context: EventContext, iter: I) -> Self {
+        Self {
+            context: Some(context),
+            iter,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+
+    pub fn default(iter: I) -> Self {
+        Self {
+            context: None,
+            iter,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> Iterator for ContextIterator<'a, I> {
+    type Item = (Event<'a>, EventContext);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(next) = self.iter.next() {
+            let ctxt = EventContext::get_context(&next, self.context.as_ref());
+            self.context = Some(ctxt);
+            Some((next, ctxt))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+#[pin_project::pin_project]
+pub struct NotebookProcessor<'a, I: Iterator<Item = Event<'a>>, CTX> {
+    context: CTX,
+    iter: ContextIterator<'a, I>,
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>, CTX> NotebookProcessor<'a, I, CTX> {
+    pub fn new(ctx: CTX, iter: ContextIterator<'a, I>) -> Self {
+        Self { context: ctx, iter }
+    }
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>, CTX: NotebookContext> Stream
+    for NotebookProcessor<'a, I, CTX>
+{
+    type Item = Event<'a>;
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        let this = self.project();
+        let iter: &mut ContextIterator<'a, I> = this.iter;
+        if let Some((event, ctxt)) = iter.next() {
+            match ctxt {
+                EventContext::EmbedLink => match event {
+                    Event::Start(ref tag) => match tag {
+                        Tag::Embed { .. } => {
+                            let fut = once_future(this.context.handle_embed(tag.clone()));
+                            pin!(fut);
+                            fut.poll_next(cx)
+                                .map(|tag| tag.map(|t| Event::Start(t.into_static())))
+                        }
+                        _ => Poll::Ready(Some(event)),
+                    },
+                    _ => Poll::Ready(Some(event)),
+                },
+                EventContext::CodeBlock => Poll::Ready(Some(event)),
+                EventContext::Text => Poll::Ready(Some(event)),
+                EventContext::Html => Poll::Ready(Some(event)),
+                EventContext::Heading => Poll::Ready(Some(event)),
+                EventContext::Reference => match event {
+                    Event::Start(ref tag) => match tag {
+                        Tag::Link { .. } => {
+                            let fut = once_future(this.context.handle_link(tag.clone()));
+                            pin!(fut);
+                            fut.poll_next(cx).map(|tag| tag.map(|t| Event::Start(t)))
+                        }
+                        _ => Poll::Ready(Some(event)),
+                    },
+                    Event::FootnoteReference(ref name) => {
+                        this.context.handle_reference(name.clone());
+                        Poll::Ready(Some(event))
+                    }
+                    _ => Poll::Ready(Some(event)),
+                },
+                EventContext::RefDef => match event {
+                    Event::Start(ref tag) => match tag {
+                        Tag::FootnoteDefinition(name) => {
+                            this.context.add_reference(name.clone());
+                            Poll::Ready(Some(event))
+                        }
+                        _ => Poll::Ready(Some(event)),
+                    },
+                    _ => Poll::Ready(Some(event)),
+                },
+                EventContext::Link => match event {
+                    Event::Start(ref tag) => match tag {
+                        Tag::Link { .. } => {
+                            let fut = once_future(this.context.handle_link(tag.clone()));
+                            pin!(fut);
+                            fut.poll_next(cx).map(|tag| tag.map(|t| Event::Start(t)))
+                        }
+                        _ => Poll::Ready(Some(event)),
+                    },
+                    _ => Poll::Ready(Some(event)),
+                },
+                EventContext::Image => match event {
+                    Event::Start(ref tag) => match tag {
+                        Tag::Image { .. } => {
+                            let fut = once_future(this.context.handle_image(tag.clone()));
+                            pin!(fut);
+                            fut.poll_next(cx).map(|tag| tag.map(|t| Event::Start(t)))
+                        }
+                        _ => Poll::Ready(Some(event)),
+                    },
+                    _ => Poll::Ready(Some(event)),
+                },
+
+                EventContext::Table => Poll::Ready(Some(event)),
+                EventContext::Metadata => match event {
+                    Event::Text(ref text) => {
+                        let frontmatter = Frontmatter::new(&text);
+                        this.context.set_frontmatter(frontmatter);
+                        Poll::Ready(Some(event))
+                    }
+                    _ => Poll::Ready(Some(event)),
+                },
+                EventContext::Other => Poll::Ready(Some(event)),
+                EventContext::None => Poll::Ready(Some(event)),
+            }
+        } else {
+            Poll::Ready(None)
+        }
+    }
+}
+
+#[async_trait]
+pub trait NotebookContext {
+    fn set_entry_title(&self, title: CowStr<'_>);
+    fn entry_title(&self) -> CowStr<'_>;
+    fn normalized_entry_title(&self) -> CowStr<'_> {
+        let title = self.entry_title();
+        let mut normalized = String::new();
+        for c in title.chars() {
+            if c.is_ascii_alphanumeric() {
+                normalized.push(c);
+            } else if c.is_whitespace() && !normalized.is_empty() && !(c == '\n' || c == '\r') {
+                normalized.push('-');
+            } else if c == '\n' {
+                normalized.push('_');
+            } else if c == '\r' {
+                continue;
+            } else if !crate::utils::AVOID_URL_CHARS.contains(&c) {
+                normalized.push(c);
+            }
+        }
+        CowStr::Boxed(normalized.into_boxed_str())
+    }
+    fn frontmatter(&self) -> Frontmatter;
+    fn set_frontmatter(&self, frontmatter: Frontmatter);
+    async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s>;
+    async fn handle_image<'s>(&self, image: Tag<'s>) -> Tag<'s>;
+    async fn handle_embed<'s>(&self, embed: Tag<'s>) -> Tag<'s>;
+    fn handle_reference(&self, reference: CowStr<'_>) -> CowStr<'_>;
+    fn add_reference(&self, reference: CowStr<'_>);
+}
+
+#[derive(Debug, Clone)]
+pub struct Frontmatter {
+    yaml: Arc<RwLock<Vec<Yaml>>>,
+}
+
+impl Frontmatter {
+    pub fn new(text: &str) -> Self {
+        let yaml = YamlLoader::load_from_str(text).unwrap_or_else(|_| vec![Yaml::BadValue]);
+        Self {
+            yaml: Arc::new(RwLock::new(yaml)),
+        }
+    }
+
+    pub fn contents(&self) -> Arc<RwLock<Vec<Yaml>>> {
+        self.yaml.clone()
+    }
+}
+
+impl Default for Frontmatter {
+    fn default() -> Self {
+        Frontmatter {
+            yaml: Arc::new(RwLock::new(vec![])),
+        }
+    }
+}
+
+#[derive(thiserror::Error, Debug, miette::Diagnostic)]
+pub enum RenderError {
+    #[error("WalkDir error at {}", path.display())]
+    #[diagnostic(code(crate::static_site::walker))]
+    WalkDirError { path: PathBuf, msg: String },
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum EventContext {
+    EmbedLink,
+    CodeBlock,
+    #[default]
+    Text,
+    Html,
+    Heading,
+    Reference,
+    RefDef,
+    Image,
+    Link,
+    Table,
+    Metadata,
+    Other,
+    None,
+}
+
+impl EventContext {
+    pub fn get_context<'a>(event: &Event<'a>, prev: Option<&Self>) -> Self {
+        match event {
+            Event::Start(tag) => match tag {
+                Tag::Paragraph => Self::Text,
+                Tag::Heading { .. } => Self::Heading,
+                Tag::BlockQuote(_block_quote_kind) => Self::Text,
+                Tag::CodeBlock(_code_block_kind) => Self::CodeBlock,
+                Tag::HtmlBlock => Self::Text,
+                Tag::List(_) => Self::Other,
+                Tag::Item => Self::Other,
+                Tag::FootnoteDefinition(_cow_str) => Self::RefDef,
+                Tag::DefinitionList => Self::Other,
+                Tag::DefinitionListTitle => Self::Other,
+                Tag::DefinitionListDefinition => Self::Other,
+                Tag::Table(_alignments) => Self::Table,
+                Tag::TableHead => Self::Table,
+                Tag::TableRow => Self::Table,
+                Tag::TableCell => Self::Table,
+                Tag::Emphasis => Self::Text,
+                Tag::Strong => Self::Text,
+                Tag::Strikethrough => Self::Text,
+                Tag::Superscript => Self::Text,
+                Tag::Subscript => Self::Text,
+                Tag::Link { .. } => Self::Link,
+                Tag::Image { .. } => Self::Image,
+                Tag::Embed { .. } => Self::EmbedLink,
+                Tag::WeaverBlock(_weaver_block_kind, _weaver_attributes) => Self::Metadata,
+                Tag::MetadataBlock(_metadata_block_kind) => Self::Metadata,
+            },
+            Event::End(_tag_end) => Self::None,
+            Event::Text(_cow_str) => match prev {
+                Some(ctxt) => match ctxt {
+                    EventContext::None => Self::Text,
+                    _ => *ctxt,
+                },
+                None => Self::Text,
+            },
+            Event::Code(_cow_str) => Self::CodeBlock,
+            Event::InlineMath(_cow_str) => Self::Other,
+            Event::DisplayMath(_cow_str) => Self::Other,
+            Event::Html(_cow_str) => Self::Html,
+            Event::InlineHtml(_cow_str) => Self::Html,
+            Event::FootnoteReference(_cow_str) => Self::Reference,
+            Event::SoftBreak => Self::Other,
+            Event::HardBreak => Self::Other,
+            Event::Rule => Self::Other,
+            Event::TaskListMarker(_cow_str) => Self::Other,
+            Event::WeaverBlock(_cow_str) => Self::Other,
+        }
+    }
+
+    pub fn is_non_writing_block(&self) -> bool {
+        match self {
+            Self::Metadata => true,
+            _ => false,
+        }
+    }
+}

crates/weaver-renderer/src/static_site.rs

···
+//! Static renderer
+//!
+//! This mode of the renderer creates a static html and css website from a notebook in a local directory.
+//! It does not upload it to the PDS by default (though it can ). This is good for testing and for self-hosting.
+//! URLs in the notebook are mostly unaltered. It is compatible with GitHub or Cloudflare Pages
+//! and other similar static hosting services.
+
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use crate::{ContextIterator, NotebookProcessor, base_html::TableState, walker::WalkOptions};
+use async_trait::async_trait;
+use atrium_api::agent::{Configure, SessionManager};
+use bitflags::bitflags;
+use dashmap::DashMap;
+use markdown_weaver::{
+    Alignment, BlockQuoteKind, BrokenLink, CodeBlockKind, CowStr, EmbedType, Event, LinkType,
+    Parser, Tag, WeaverAttributes,
+};
+use markdown_weaver_escape::{
+    FmtWriter, StrWrite, escape_href, escape_html, escape_html_body_text,
+};
+use miette::IntoDiagnostic;
+use n0_future::StreamExt;
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use n0_future::io::AsyncWriteExt;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use tokio::io::AsyncWriteExt;
+use unicode_normalization::UnicodeNormalization;
+use weaver_common::{
+    agent::{WeaverAgent, WeaverHttpClient},
+    aturi_to_http,
+};
+use yaml_rust2::Yaml;
+
+use crate::{Frontmatter, NotebookContext};
+
+bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct StaticSiteOptions:u32 {
+        const FLATTEN_STRUCTURE = 1 << 1;
+        const UPLOAD_BLOBS = 1 << 2;
+        const INLINE_EMBEDS = 1 << 3;
+        const ADD_LINK_PREVIEWS = 1 << 4;
+        const RESOLVE_AT_IDENTIFIERS = 1 << 5;
+        const RESOLVE_AT_URIS = 1 << 6;
+        const ADD_BSKY_COMMENTS_EMBED = 1 << 7;
+        const CREATE_INDEX = 1 << 8;
+        const CREATE_CHAPTERS_BY_DIRECTORY = 1 << 9;
+        const CREATE_PAGES_BY_TITLE = 1 << 10;
+        const NORMALIZE_DIR_NAMES = 1 << 11;
+        const ADD_TOC_TO_PAGES = 1 << 12;
+    }
+}
+
+impl Default for StaticSiteOptions {
+    fn default() -> Self {
+        Self::FLATTEN_STRUCTURE
+            | Self::UPLOAD_BLOBS
+            | Self::RESOLVE_AT_IDENTIFIERS
+            | Self::RESOLVE_AT_URIS
+            | Self::CREATE_INDEX
+            | Self::CREATE_CHAPTERS_BY_DIRECTORY
+            | Self::CREATE_PAGES_BY_TITLE
+            | Self::NORMALIZE_DIR_NAMES
+    }
+}
+
+pub fn default_md_options() -> markdown_weaver::Options {
+    markdown_weaver::Options::ENABLE_WIKILINKS
+        | markdown_weaver::Options::ENABLE_FOOTNOTES
+        | markdown_weaver::Options::ENABLE_TABLES
+        | markdown_weaver::Options::ENABLE_GFM
+        | markdown_weaver::Options::ENABLE_STRIKETHROUGH
+        | markdown_weaver::Options::ENABLE_YAML_STYLE_METADATA_BLOCKS
+        | markdown_weaver::Options::ENABLE_OBSIDIAN_EMBEDS
+        | markdown_weaver::Options::ENABLE_MATH
+        | markdown_weaver::Options::ENABLE_HEADING_ATTRIBUTES
+}
+
+pub struct StaticSiteContext<'a, M: SessionManager + Send + Sync> {
+    options: StaticSiteOptions,
+    md_options: markdown_weaver::Options,
+    pub bsky_appview: CowStr<'a>,
+    root: PathBuf,
+    pub destination: PathBuf,
+    start_at: PathBuf,
+    pub frontmatter: Arc<DashMap<PathBuf, Frontmatter>>,
+    dir_contents: Option<Arc<[PathBuf]>>,
+    reference_map: Arc<DashMap<CowStr<'a>, PathBuf>>,
+    titles: Arc<DashMap<PathBuf, CowStr<'a>>>,
+    position: usize,
+    agent: Option<Arc<WeaverAgent<M>>>,
+}
+
+impl<M: SessionManager + Send + Sync> StaticSiteContext<'_, M> {
+    pub fn clone_with_dir_contents(&self, dir_contents: &[PathBuf]) -> Self {
+        Self {
+            start_at: self.start_at.clone(),
+            root: self.root.clone(),
+            bsky_appview: self.bsky_appview.clone(),
+            options: self.options.clone(),
+            md_options: self.md_options.clone(),
+            frontmatter: self.frontmatter.clone(),
+            dir_contents: Some(Arc::from(dir_contents)),
+            destination: self.destination.clone(),
+            reference_map: self.reference_map.clone(),
+            titles: self.titles.clone(),
+            position: self.position,
+            agent: self.agent.clone(),
+        }
+    }
+
+    pub fn clone_with_path(&self, path: impl AsRef<Path>) -> Self {
+        let position = if let Some(dir_contents) = &self.dir_contents {
+            dir_contents
+                .iter()
+                .position(|p| p == path.as_ref())
+                .unwrap_or(0)
+        } else {
+            0
+        };
+        Self {
+            start_at: self.start_at.clone(),
+            root: self.root.clone(),
+            bsky_appview: self.bsky_appview.clone(),
+            options: self.options.clone(),
+            md_options: self.md_options.clone(),
+            frontmatter: self.frontmatter.clone(),
+            dir_contents: self.dir_contents.clone(),
+            destination: self.destination.clone(),
+            reference_map: self.reference_map.clone(),
+            titles: self.titles.clone(),
+            position,
+            agent: self.agent.clone(),
+        }
+    }
+    pub fn new(root: PathBuf, destination: PathBuf, session: Option<M>) -> Self {
+        Self {
+            start_at: root.clone(),
+            root,
+            bsky_appview: CowStr::Borrowed("deer.social"),
+            options: StaticSiteOptions::default(),
+            md_options: default_md_options(),
+            frontmatter: Arc::new(DashMap::new()),
+            dir_contents: None,
+            destination,
+            reference_map: Arc::new(DashMap::new()),
+            titles: Arc::new(DashMap::new()),
+            position: 0,
+            agent: session.map(|session| Arc::new(WeaverAgent::new(session))),
+        }
+    }
+
+    pub fn current_path(&self) -> &PathBuf {
+        if let Some(dir_contents) = &self.dir_contents {
+            &dir_contents[self.position]
+        } else {
+            &self.start_at
+        }
+    }
+
+    #[inline]
+    pub fn handle_link_aturi<'s>(&self, link: Tag<'s>) -> Tag<'s> {
+        let link = crate::utils::resolve_at_ident_or_uri(&link, &self.bsky_appview);
+        self.handle_link_normal(link)
+    }
+
+    pub async fn handle_embed_aturi<'s>(&self, embed: Tag<'s>) -> Tag<'s> {
+        if let Some(agent) = &self.agent {
+            match &embed {
+                Tag::Embed {
+                    embed_type,
+                    dest_url,
+                    title,
+                    id,
+                    attrs,
+                } => {
+                    if dest_url.starts_with("at://") {
+                        let width = if let Some(attrs) = attrs {
+                            let mut width = 600;
+                            for attr in &attrs.attrs {
+                                if attr.0 == CowStr::Borrowed("width".into()) {
+                                    width = attr.1.parse::<usize>().unwrap_or(600);
+                                    break;
+                                }
+                            }
+                            width
+                        } else {
+                            600
+                        };
+                        let html = if let Ok(resp) = agent
+                            .client
+                            .client
+                            .get("https://embed.bsky.app/oembed")
+                            .query(&[
+                                ("url", dest_url.clone().into_string()),
+                                ("maxwidth", width.to_string()),
+                            ])
+                            .send()
+                            .await
+                        {
+                            resp.text().await.ok()
+                        } else {
+                            None
+                        };
+                        if let Some(html) = html {
+                            let link = aturi_to_http(&dest_url, &self.bsky_appview)
+                                .expect("assuming the at-uri is valid rn");
+                            let mut attrs = if let Some(attrs) = attrs {
+                                attrs.clone()
+                            } else {
+                                WeaverAttributes {
+                                    classes: vec![],
+                                    attrs: vec![],
+                                }
+                            };
+                            attrs.attrs.push(("content".into(), html.into()));
+                            Tag::Embed {
+                                embed_type: EmbedType::Comments, // change this when i update markdown-weaver
+                                dest_url: link.into_static(),
+                                title: title.clone(),
+                                id: id.clone(),
+                                attrs: Some(attrs),
+                            }
+                        } else {
+                            self.handle_embed_normal(embed).await
+                        }
+                    } else {
+                        self.handle_embed_normal(embed).await
+                    }
+                }
+                _ => embed,
+            }
+        } else {
+            self.handle_embed_normal(embed).await
+        }
+    }
+
+    pub async fn handle_embed_normal<'s>(&self, embed: Tag<'s>) -> Tag<'s> {
+        // This option will REALLY slow down iteration over events.
+        if self.options.contains(StaticSiteOptions::INLINE_EMBEDS) {
+            match &embed {
+                Tag::Embed {
+                    embed_type: _,
+                    dest_url,
+                    title,
+                    id,
+                    attrs,
+                } => {
+                    let mut attrs = if let Some(attrs) = attrs {
+                        attrs.clone()
+                    } else {
+                        WeaverAttributes {
+                            classes: vec![],
+                            attrs: vec![],
+                        }
+                    };
+                    let contents = if crate::utils::is_local_path(dest_url) {
+                        let file_path = if crate::utils::is_relative_link(dest_url) {
+                            let root_path = self.root.clone();
+                            root_path.join(Path::new(&dest_url as &str))
+                        } else {
+                            PathBuf::from(&dest_url as &str)
+                        };
+                        crate::utils::inline_file(&file_path).await
+                    } else if let Some(agent) = &self.agent {
+                        if let Ok(resp) = agent
+                            .client
+                            .client
+                            .get(dest_url.clone().into_string())
+                            .send()
+                            .await
+                        {
+                            resp.text().await.ok()
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    };
+                    if let Some(contents) = contents {
+                        attrs.attrs.push(("content".into(), contents.into()));
+                        Tag::Embed {
+                            embed_type: EmbedType::Markdown, // change this when i update markdown-weaver
+                            dest_url: dest_url.clone(),
+                            title: title.clone(),
+                            id: id.clone(),
+                            attrs: Some(attrs),
+                        }
+                    } else {
+                        embed
+                    }
+                }
+                _ => embed,
+            }
+        } else {
+            embed
+        }
+    }
+
+    /// This is a no-op for the static site renderer currently.
+    #[inline]
+    pub fn handle_link_normal<'s>(&self, link: Tag<'s>) -> Tag<'s> {
+        link
+    }
+
+    /// This is a no-op for the static site renderer currently.
+    #[inline]
+    pub fn handle_image_normal<'s>(&self, image: Tag<'s>) -> Tag<'s> {
+        image
+    }
+}
+
+impl<M: SessionManager + Configure + Send + Sync> StaticSiteContext<'_, M> {
+    pub async fn upload_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
+        if let Some(agent) = &self.agent {
+            match &image {
+                Tag::Image {
+                    link_type,
+                    dest_url,
+                    title,
+                    id,
+                    attrs,
+                } => {
+                    if crate::utils::is_local_path(&dest_url) {
+                        let root_path = self.root.clone();
+                        let file_path = root_path.join(Path::new(&dest_url as &str));
+                        if let Ok(bytes) = std::fs::read(&file_path) {
+                            if let Ok(blob_data) = agent.upload_blob(bytes).await {
+                                let url = weaver_common::blob_url(
+                                    agent.did().await.as_ref().unwrap(),
+                                    &agent.pds(),
+                                    &blob_data.blob,
+                                );
+                                return Tag::Image {
+                                    link_type: *link_type,
+                                    dest_url: url.into(),
+                                    title: title.clone(),
+                                    id: id.clone(),
+                                    attrs: attrs.clone(),
+                                };
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        image
+    }
+}
+
+#[async_trait]
+impl<M: SessionManager + Configure + Send + Sync> NotebookContext for StaticSiteContext<'_, M> {
+    fn set_entry_title(&self, title: CowStr<'_>) {
+        let path = self.current_path();
+        self.titles
+            .insert(path.clone(), title.clone().into_static());
+        self.frontmatter.get_mut(path).map(|frontmatter| {
+            if let Ok(mut yaml) = frontmatter.yaml.write() {
+                if yaml.get(0).is_some_and(|y| y.is_hash()) {
+                    let map = yaml.get_mut(0).unwrap().as_mut_hash().unwrap();
+                    map.insert(
+                        Yaml::String("title".into()),
+                        Yaml::String(title.into_static().into()),
+                    );
+                }
+            }
+        });
+    }
+    fn entry_title(&self) -> CowStr<'_> {
+        let path = self.current_path();
+        self.titles.get(path).unwrap().clone()
+    }
+
+    fn frontmatter(&self) -> Frontmatter {
+        let path = self.current_path();
+        self.frontmatter.get(path).unwrap().value().clone()
+    }
+
+    fn set_frontmatter(&self, frontmatter: Frontmatter) {
+        let path = self.current_path();
+        self.frontmatter.insert(path.clone(), frontmatter);
+    }
+
+    async fn handle_link<'s>(&self, link: Tag<'s>) -> Tag<'s> {
+        bitflags::bitflags_match!(self.options, {
+            // Split this somehow or just combine the options
+            StaticSiteOptions::RESOLVE_AT_URIS | StaticSiteOptions::RESOLVE_AT_IDENTIFIERS => {
+                self.handle_link_aturi(link)
+            }
+            _ => match &link {
+                Tag::Link { link_type, dest_url, title, id } => {
+                    if self.options.contains(StaticSiteOptions::FLATTEN_STRUCTURE) {
+                        let (parent, filename) = crate::utils::flatten_dir_to_just_one_parent(&dest_url);
+                        let dest_url = if crate::utils::is_relative_link(&dest_url)
+                            && self.options.contains(StaticSiteOptions::CREATE_CHAPTERS_BY_DIRECTORY) {
+                            CowStr::Boxed(format!("./{}/{}", parent, filename).into_boxed_str())
+                        } else {
+                            CowStr::Boxed(format!("./entry/{}", filename).into_boxed_str())
+                        };
+                        Tag::Link {
+                            link_type: *link_type,
+                            dest_url,
+                            title: title.clone(),
+                            id: id.clone(),
+                        }
+                    } else {
+                        link
+
+                    }
+                },
+                _ => link,
+            }
+        })
+    }
+
+    async fn handle_image<'s>(&self, image: Tag<'s>) -> Tag<'s> {
+        if self.options.contains(StaticSiteOptions::UPLOAD_BLOBS) {
+            self.upload_image(image).await
+        } else {
+            self.handle_image_normal(image)
+        }
+    }
+
+    async fn handle_embed<'s>(&self, embed: Tag<'s>) -> Tag<'s> {
+        if self.options.contains(StaticSiteOptions::RESOLVE_AT_URIS)
+            || self.options.contains(StaticSiteOptions::ADD_LINK_PREVIEWS)
+        {
+            self.handle_embed_aturi(embed).await
+        } else {
+            self.handle_embed_normal(embed).await
+        }
+    }
+
+    fn handle_reference(&self, reference: CowStr<'_>) -> CowStr<'_> {
+        let reference = reference.into_static();
+        if let Some(reference) = self.reference_map.get(&reference) {
+            let path = reference.value().clone();
+            CowStr::Boxed(path.to_string_lossy().into_owned().into_boxed_str())
+        } else {
+            reference
+        }
+    }
+
+    fn add_reference(&self, reference: CowStr<'_>) {
+        let path = self.current_path();
+        self.reference_map
+            .insert(reference.into_static(), path.clone());
+    }
+}
+
+pub struct StaticSiteWriter<'a, M>
+where
+    M: SessionManager + Send + Sync,
+{
+    context: StaticSiteContext<'a, M>,
+}
+
+impl<'a, M> StaticSiteWriter<'a, M>
+where
+    M: SessionManager + Send + Sync,
+{
+    pub fn new(root: PathBuf, destination: PathBuf, session: Option<M>) -> Self {
+        let context = StaticSiteContext::new(root, destination, session);
+        Self { context }
+    }
+}
+
+impl<'a, M> StaticSiteWriter<'a, M>
+where
+    M: SessionManager + Configure + Send + Sync,
+{
+    pub async fn run(self) -> Result<(), miette::Report> {
+        todo!()
+    }
+
+    pub async fn export_page<'s, 'input>(
+        &'s self,
+        contents: &'input str,
+        context: StaticSiteContext<'s, M>,
+    ) -> Result<String, miette::Report> {
+        let callback = if let Some(dir_contents) = context.dir_contents.clone() {
+            Some(VaultBrokenLinkCallback {
+                vault_contents: dir_contents,
+            })
+        } else {
+            None
+        };
+        let parser = Parser::new_with_broken_link_callback(&contents, context.md_options, callback);
+        let iterator = ContextIterator::default(parser);
+        let mut output = String::new();
+        let writer = StaticPageWriter::new(
+            NotebookProcessor::new(context, iterator),
+            FmtWriter(&mut output),
+        );
+        writer.run().await.into_diagnostic()?;
+        Ok(output)
+    }
+
+    pub async fn write_page(&'a self, path: PathBuf) -> Result<(), miette::Report> {
+        let contents = tokio::fs::read_to_string(&path).await.into_diagnostic()?;
+        let mut output_file = crate::utils::create_file(&path).await?;
+        let context = self.context.clone_with_path(&path);
+        let output = self.export_page(&contents, context).await?;
+        output_file
+            .write_all(output.as_bytes())
+            .await
+            .into_diagnostic()?;
+        Ok(())
+    }
+}
+
+pub struct StaticPageWriter<
+    'a,
+    'input,
+    I: Iterator<Item = Event<'input>>,
+    M: SessionManager + Send + Sync,
+    W: StrWrite,
+> {
+    context: NotebookProcessor<'input, I, StaticSiteContext<'a, M>>,
+    writer: W,
+    /// Whether or not the last write wrote a newline.
+    end_newline: bool,
+
+    /// Whether if inside a metadata block (text should not be written)
+    in_non_writing_block: bool,
+
+    table_state: TableState,
+    table_alignments: Vec<Alignment>,
+    table_cell_index: usize,
+    numbers: DashMap<CowStr<'a>, usize>,
+}
+
+impl<'a, 'input, I: Iterator<Item = Event<'input>>, M: SessionManager + Send + Sync, W: StrWrite>
+    StaticPageWriter<'a, 'input, I, M, W>
+{
+    pub fn new(context: NotebookProcessor<'input, I, StaticSiteContext<'a, M>>, writer: W) -> Self {
+        Self {
+            context,
+            writer,
+            end_newline: true,
+            in_non_writing_block: false,
+            table_state: TableState::Head,
+            table_alignments: vec![],
+            table_cell_index: 0,
+            numbers: DashMap::new(),
+        }
+    }
+
+    /// Writes a new line.
+    #[inline]
+    fn write_newline(&mut self) -> Result<(), W::Error> {
+        self.end_newline = true;
+        self.writer.write_str("\n")
+    }
+
+    /// Writes a buffer, and tracks whether or not a newline was written.
+    #[inline]
+    fn write(&mut self, s: &str) -> Result<(), W::Error> {
+        self.writer.write_str(s)?;
+
+        if !s.is_empty() {
+            self.end_newline = s.ends_with('\n');
+        }
+        Ok(())
+    }
+
+    fn end_tag(&mut self, tag: markdown_weaver::TagEnd) -> Result<(), W::Error> {
+        use markdown_weaver::TagEnd;
+        match tag {
+            TagEnd::HtmlBlock => {}
+            TagEnd::Paragraph => {
+                self.write("</p>\n")?;
+            }
+            TagEnd::Heading(level) => {
+                self.write("</")?;
+                write!(&mut self.writer, "{}", level)?;
+                self.write(">\n")?;
+            }
+            TagEnd::Table => {
+                self.write("</tbody></table>\n")?;
+            }
+            TagEnd::TableHead => {
+                self.write("</tr></thead><tbody>\n")?;
+                self.table_state = TableState::Body;
+            }
+            TagEnd::TableRow => {
+                self.write("</tr>\n")?;
+            }
+            TagEnd::TableCell => {
+                match self.table_state {
+                    TableState::Head => {
+                        self.write("</th>")?;
+                    }
+                    TableState::Body => {
+                        self.write("</td>")?;
+                    }
+                }
+                self.table_cell_index += 1;
+            }
+            TagEnd::BlockQuote(_) => {
+                self.write("</blockquote>\n")?;
+            }
+            TagEnd::CodeBlock => {
+                self.write("</code></pre>\n")?;
+            }
+            TagEnd::List(true) => {
+                self.write("</ol>\n")?;
+            }
+            TagEnd::List(false) => {
+                self.write("</ul>\n")?;
+            }
+            TagEnd::Item => {
+                self.write("</li>\n")?;
+            }
+            TagEnd::DefinitionList => {
+                self.write("</dl>\n")?;
+            }
+            TagEnd::DefinitionListTitle => {
+                self.write("</dt>\n")?;
+            }
+            TagEnd::DefinitionListDefinition => {
+                self.write("</dd>\n")?;
+            }
+            TagEnd::Emphasis => {
+                self.write("</em>")?;
+            }
+            TagEnd::Superscript => {
+                self.write("</sup>")?;
+            }
+            TagEnd::Subscript => {
+                self.write("</sub>")?;
+            }
+            TagEnd::Strong => {
+                self.write("</strong>")?;
+            }
+            TagEnd::Strikethrough => {
+                self.write("</del>")?;
+            }
+            TagEnd::Link => {
+                self.write("</a>")?;
+            }
+            TagEnd::Image => (), // shouldn't happen, handled in start
+            TagEnd::Embed => (), // shouldn't happen, handled in start
+            TagEnd::WeaverBlock(_) => {
+                self.in_non_writing_block = false;
+            }
+            TagEnd::FootnoteDefinition => {
+                self.write("</div>\n")?;
+            }
+            TagEnd::MetadataBlock(_) => {
+                self.in_non_writing_block = false;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<
+    'a,
+    'input,
+    I: Iterator<Item = Event<'input>>,
+    M: SessionManager + Configure + Send + Sync,
+    W: StrWrite,
+> StaticPageWriter<'a, 'input, I, M, W>
+{
+    async fn run(mut self) -> Result<(), W::Error> {
+        while let Some(event) = self.context.next().await {
+            self.process_event(event).await?
+        }
+        Ok(())
+    }
+
+    async fn process_event(&mut self, event: Event<'input>) -> Result<(), W::Error> {
+        use markdown_weaver::Event::*;
+        match event {
+            Start(tag) => {
+                self.start_tag(tag).await?;
+            }
+            End(tag) => {
+                self.end_tag(tag)?;
+            }
+            Text(text) => {
+                if !self.in_non_writing_block {
+                    escape_html_body_text(&mut self.writer, &text)?;
+                    self.end_newline = text.ends_with('\n');
+                }
+            }
+            Code(text) => {
+                self.write("<code>")?;
+                escape_html_body_text(&mut self.writer, &text)?;
+                self.write("</code>")?;
+            }
+            InlineMath(text) => {
+                self.write(r#"<span class="math math-inline">"#)?;
+                escape_html(&mut self.writer, &text)?;
+                self.write("</span>")?;
+            }
+            DisplayMath(text) => {
+                self.write(r#"<span class="math math-display">"#)?;
+                escape_html(&mut self.writer, &text)?;
+                self.write("</span>")?;
+            }
+            Html(html) | InlineHtml(html) => {
+                self.write(&html)?;
+            }
+            SoftBreak => {
+                self.write_newline()?;
+            }
+            HardBreak => {
+                self.write("<br />\n")?;
+            }
+            Rule => {
+                if self.end_newline {
+                    self.write("<hr />\n")?;
+                } else {
+                    self.write("\n<hr />\n")?;
+                }
+            }
+            FootnoteReference(name) => {
+                let len = self.numbers.len() + 1;
+                self.write("<sup class=\"footnote-reference\"><a href=\"#")?;
+                escape_html(&mut self.writer, &name)?;
+                self.write("\">")?;
+                let number = *self.numbers.entry(name.into_static()).or_insert(len);
+                write!(&mut self.writer, "{}", number)?;
+                self.write("</a></sup>")?;
+            }
+            TaskListMarker(true) => {
+                self.write("<input disabled=\"\" type=\"checkbox\" checked=\"\"/>\n")?;
+            }
+            TaskListMarker(false) => {
+                self.write("<input disabled=\"\" type=\"checkbox\"/>\n")?;
+            }
+            WeaverBlock(_text) => {}
+        }
+        Ok(())
+    }
+
+    // run raw text, consuming end tag
+    async fn raw_text(&mut self) -> Result<(), W::Error> {
+        use markdown_weaver::Event::*;
+        let mut nest = 0;
+        while let Some(event) = self.context.next().await {
+            match event {
+                Start(_) => nest += 1,
+                End(_) => {
+                    if nest == 0 {
+                        break;
+                    }
+                    nest -= 1;
+                }
+                Html(_) => {}
+                InlineHtml(text) | Code(text) | Text(text) => {
+                    // Don't use escape_html_body_text here.
+                    // The output of this function is used in the `alt` attribute.
+                    escape_html(&mut self.writer, &text)?;
+                    self.end_newline = text.ends_with('\n');
+                }
+                InlineMath(text) => {
+                    self.write("$")?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("$")?;
+                }
+                DisplayMath(text) => {
+                    self.write("$$")?;
+                    escape_html(&mut self.writer, &text)?;
+                    self.write("$$")?;
+                }
+                SoftBreak | HardBreak | Rule => {
+                    self.write(" ")?;
+                }
+                FootnoteReference(name) => {
+                    let len = self.numbers.len() + 1;
+                    let number = *self.numbers.entry(name.into_static()).or_insert(len);
+                    write!(&mut self.writer, "[{}]", number)?;
+                }
+                TaskListMarker(true) => self.write("[x]")?,
+                TaskListMarker(false) => self.write("[ ]")?,
+                WeaverBlock(_) => {
+                    println!("Weaver block internal");
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Writes the start of an HTML tag.
+    async fn start_tag(&mut self, tag: Tag<'input>) -> Result<(), W::Error> {
+        match tag {
+            Tag::HtmlBlock => Ok(()),
+            Tag::Paragraph => {
+                if self.end_newline {
+                    self.write("<p>")
+                } else {
+                    self.write("\n<p>")
+                }
+            }
+            Tag::Heading {
+                level,
+                id,
+                classes,
+                attrs,
+            } => {
+                if self.end_newline {
+                    self.write("<")?;
+                } else {
+                    self.write("\n<")?;
+                }
+                write!(&mut self.writer, "{}", level)?;
+                if let Some(id) = id {
+                    self.write(" id=\"")?;
+                    escape_html(&mut self.writer, &id)?;
+                    self.write("\"")?;
+                }
+                let mut classes = classes.iter();
+                if let Some(class) = classes.next() {
+                    self.write(" class=\"")?;
+                    escape_html(&mut self.writer, class)?;
+                    for class in classes {
+                        self.write(" ")?;
+                        escape_html(&mut self.writer, class)?;
+                    }
+                    self.write("\"")?;
+                }
+                for (attr, value) in attrs {
+                    self.write(" ")?;
+                    escape_html(&mut self.writer, &attr)?;
+                    if let Some(val) = value {
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, &val)?;
+                        self.write("\"")?;
+                    } else {
+                        self.write("=\"\"")?;
+                    }
+                }
+                self.write(">")
+            }
+            Tag::Table(alignments) => {
+                self.table_alignments = alignments;
+                self.write("<table>")
+            }
+            Tag::TableHead => {
+                self.table_state = TableState::Head;
+                self.table_cell_index = 0;
+                self.write("<thead><tr>")
+            }
+            Tag::TableRow => {
+                self.table_cell_index = 0;
+                self.write("<tr>")
+            }
+            Tag::TableCell => {
+                match self.table_state {
+                    TableState::Head => {
+                        self.write("<th")?;
+                    }
+                    TableState::Body => {
+                        self.write("<td")?;
+                    }
+                }
+                match self.table_alignments.get(self.table_cell_index) {
+                    Some(&Alignment::Left) => self.write(" style=\"text-align: left\">"),
+                    Some(&Alignment::Center) => self.write(" style=\"text-align: center\">"),
+                    Some(&Alignment::Right) => self.write(" style=\"text-align: right\">"),
+                    _ => self.write(">"),
+                }
+            }
+            Tag::BlockQuote(kind) => {
+                let class_str = match kind {
+                    None => "",
+                    Some(kind) => match kind {
+                        BlockQuoteKind::Note => " class=\"markdown-alert-note\"",
+                        BlockQuoteKind::Tip => " class=\"markdown-alert-tip\"",
+                        BlockQuoteKind::Important => " class=\"markdown-alert-important\"",
+                        BlockQuoteKind::Warning => " class=\"markdown-alert-warning\"",
+                        BlockQuoteKind::Caution => " class=\"markdown-alert-caution\"",
+                    },
+                };
+                if self.end_newline {
+                    self.write(&format!("<blockquote{}>\n", class_str))
+                } else {
+                    self.write(&format!("\n<blockquote{}>\n", class_str))
+                }
+            }
+            Tag::CodeBlock(info) => {
+                if !self.end_newline {
+                    self.write_newline()?;
+                }
+                match info {
+                    CodeBlockKind::Fenced(info) => {
+                        let lang = info.split(' ').next().unwrap();
+                        if lang.is_empty() {
+                            self.write("<pre><code>")
+                        } else {
+                            self.write("<pre><code class=\"language-")?;
+                            escape_html(&mut self.writer, lang)?;
+                            self.write("\">")
+                        }
+                    }
+                    CodeBlockKind::Indented => self.write("<pre><code>"),
+                }
+            }
+            Tag::List(Some(1)) => {
+                if self.end_newline {
+                    self.write("<ol>\n")
+                } else {
+                    self.write("\n<ol>\n")
+                }
+            }
+            Tag::List(Some(start)) => {
+                if self.end_newline {
+                    self.write("<ol start=\"")?;
+                } else {
+                    self.write("\n<ol start=\"")?;
+                }
+                write!(&mut self.writer, "{}", start)?;
+                self.write("\">\n")
+            }
+            Tag::List(None) => {
+                if self.end_newline {
+                    self.write("<ul>\n")
+                } else {
+                    self.write("\n<ul>\n")
+                }
+            }
+            Tag::Item => {
+                if self.end_newline {
+                    self.write("<li>")
+                } else {
+                    self.write("\n<li>")
+                }
+            }
+            Tag::DefinitionList => {
+                if self.end_newline {
+                    self.write("<dl>\n")
+                } else {
+                    self.write("\n<dl>\n")
+                }
+            }
+            Tag::DefinitionListTitle => {
+                if self.end_newline {
+                    self.write("<dt>")
+                } else {
+                    self.write("\n<dt>")
+                }
+            }
+            Tag::DefinitionListDefinition => {
+                if self.end_newline {
+                    self.write("<dd>")
+                } else {
+                    self.write("\n<dd>")
+                }
+            }
+            Tag::Subscript => self.write("<sub>"),
+            Tag::Superscript => self.write("<sup>"),
+            Tag::Emphasis => self.write("<em>"),
+            Tag::Strong => self.write("<strong>"),
+            Tag::Strikethrough => self.write("<del>"),
+            Tag::Link {
+                link_type: LinkType::Email,
+                dest_url,
+                title,
+                id: _,
+            } => {
+                self.write("<a href=\"mailto:")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Link {
+                link_type: _,
+                dest_url,
+                title,
+                id: _,
+            } => {
+                self.write("<a href=\"")?;
+                escape_href(&mut self.writer, &dest_url)?;
+                if !title.is_empty() {
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                }
+                self.write("\">")
+            }
+            Tag::Image {
+                link_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                self.write_image(Tag::Image {
+                    link_type,
+                    dest_url,
+                    title,
+                    id,
+                    attrs,
+                })
+                .await
+            }
+            Tag::Embed {
+                embed_type,
+                dest_url,
+                title,
+                id,
+                attrs,
+            } => {
+                if let Some(attrs) = attrs {
+                    if let Some((_, content)) = attrs
+                        .attrs
+                        .iter()
+                        .find(|(attr, _)| attr.as_ref() == "content")
+                    {
+                        match embed_type {
+                            EmbedType::Image => {
+                                self.write_image(Tag::Image {
+                                    link_type: LinkType::Inline,
+                                    dest_url,
+                                    title,
+                                    id,
+                                    attrs: Some(attrs.clone()),
+                                })
+                                .await?
+                            }
+                            EmbedType::Comments => {
+                                self.write("leaflet would go here\n")?;
+                            }
+                            EmbedType::Post => {
+                                // Bluesky post embed, basically just render the raw html we got
+                                self.write(content)?;
+                                self.write_newline()?;
+                            }
+                            EmbedType::Markdown => {
+                                // let context = self
+                                //     .context
+                                //     .context
+                                //     .clone_with_path(&Path::new(&dest_url.to_string()));
+                                // let callback =
+                                //     if let Some(dir_contents) = context.dir_contents.clone() {
+                                //         Some(VaultBrokenLinkCallback {
+                                //             vault_contents: dir_contents,
+                                //         })
+                                //     } else {
+                                //         None
+                                //     };
+                                // let parser = Parser::new_with_broken_link_callback(
+                                //     &content,
+                                //     context.md_options,
+                                //     callback,
+                                // );
+                                // let iterator = ContextIterator::default(parser);
+                                // let mut stream = NotebookProcessor::new(context, iterator);
+                                // while let Some(event) = stream.next().await {
+                                //     self.process_event(event).await?;
+                                // }
+                                //
+                                self.write("markdown embed would go here\n")?;
+                            }
+                            EmbedType::Leaflet => {
+                                self.write("leaflet would go here\n")?;
+                            }
+                            EmbedType::Other => {
+                                self.write("other embed would go here\n")?;
+                            }
+                        }
+                    }
+                } else {
+                    self.write("<iframe src=\"")?;
+                    escape_href(&mut self.writer, &dest_url)?;
+                    self.write("\" title=\"")?;
+                    escape_html(&mut self.writer, &title)?;
+                    if !id.is_empty() {
+                        self.write("\" id=\"")?;
+                        escape_html(&mut self.writer, &id)?;
+                        self.write("\"")?;
+                    }
+                    if let Some(attrs) = attrs {
+                        self.write(" ")?;
+                        if !attrs.classes.is_empty() {
+                            self.write("class=\"")?;
+                            for class in &attrs.classes {
+                                escape_html(&mut self.writer, class)?;
+                                self.write(" ")?;
+                            }
+                            self.write("\" ")?;
+                        }
+                        if !attrs.attrs.is_empty() {
+                            for (attr, value) in &attrs.attrs {
+                                escape_html(&mut self.writer, attr)?;
+                                self.write("=\"")?;
+                                escape_html(&mut self.writer, value)?;
+                                self.write("\" ")?;
+                            }
+                        }
+                    }
+                    self.write("/>")?;
+                }
+                Ok(())
+            }
+            Tag::WeaverBlock(_, _attrs) => {
+                println!("Weaver block");
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+            Tag::FootnoteDefinition(name) => {
+                if self.end_newline {
+                    self.write("<div class=\"footnote-definition\" id=\"")?;
+                } else {
+                    self.write("\n<div class=\"footnote-definition\" id=\"")?;
+                }
+                escape_html(&mut self.writer, &name)?;
+                self.write("\"><sup class=\"footnote-definition-label\">")?;
+                let len = self.numbers.len() + 1;
+                let number = *self.numbers.entry(name.into_static()).or_insert(len);
+                write!(&mut self.writer, "{}", number)?;
+                self.write("</sup>")
+            }
+            Tag::MetadataBlock(_) => {
+                self.in_non_writing_block = true;
+                Ok(())
+            }
+        }
+    }
+
+    async fn write_image(&mut self, tag: Tag<'input>) -> Result<(), W::Error> {
+        if let Tag::Image {
+            link_type: _,
+            dest_url,
+            title,
+            id: _,
+            attrs,
+        } = tag
+        {
+            self.write("<img src=\"")?;
+            escape_href(&mut self.writer, &dest_url)?;
+            if let Some(attrs) = attrs {
+                if !attrs.classes.is_empty() {
+                    self.write("\" class=\"")?;
+                    for class in &attrs.classes {
+                        escape_html(&mut self.writer, class)?;
+                        self.write(" ")?;
+                    }
+                    self.write("\" ")?;
+                } else {
+                    self.write("\" ")?;
+                }
+                if !attrs.attrs.is_empty() {
+                    for (attr, value) in &attrs.attrs {
+                        escape_html(&mut self.writer, attr)?;
+                        self.write("=\"")?;
+                        escape_html(&mut self.writer, value)?;
+                        self.write("\" ")?;
+                    }
+                }
+            } else {
+                self.write("\" ")?;
+            }
+            self.write("alt=\"")?;
+            self.raw_text().await?;
+            if !title.is_empty() {
+                self.write("\" title=\"")?;
+                escape_html(&mut self.writer, &title)?;
+            }
+            self.write("\" />")
+        } else {
+            self.write_newline()
+        }
+    }
+}
+
+/// Path lookup in an Obsidian vault
+///
+/// Credit to https://github.com/zoni
+///
+/// Taken from https://github.com/zoni/obsidian-export/blob/main/src/lib.rs.rs on 2025-05-21
+///
+pub fn lookup_filename_in_vault<'a>(
+    filename: &str,
+    vault_contents: &'a [PathBuf],
+) -> Option<&'a PathBuf> {
+    let filename = PathBuf::from(filename);
+    let filename_normalized: String = filename.to_string_lossy().nfc().collect();
+
+    vault_contents.iter().find(|path| {
+        let path_normalized_str: String = path.to_string_lossy().nfc().collect();
+        let path_normalized = PathBuf::from(&path_normalized_str);
+        let path_normalized_lowered = PathBuf::from(&path_normalized_str.to_lowercase());
+
+        // It would be convenient if we could just do `filename.set_extension("md")` at the start
+        // of this funtion so we don't need multiple separate + ".md" match cases here, however
+        // that would break with a reference of `[[Note.1]]` linking to `[[Note.1.md]]`.
+
+        path_normalized.ends_with(&filename_normalized)
+            || path_normalized.ends_with(filename_normalized.clone() + ".md")
+            || path_normalized_lowered.ends_with(filename_normalized.to_lowercase())
+            || path_normalized_lowered.ends_with(filename_normalized.to_lowercase() + ".md")
+    })
+}
+
+pub struct VaultBrokenLinkCallback {
+    vault_contents: Arc<[PathBuf]>,
+}
+
+impl<'input> markdown_weaver::BrokenLinkCallback<'input> for VaultBrokenLinkCallback {
+    fn handle_broken_link(
+        &mut self,
+        link: BrokenLink<'input>,
+    ) -> Option<(CowStr<'input>, CowStr<'input>)> {
+        let text = link.reference;
+        let captures = crate::OBSIDIAN_NOTE_LINK_RE
+            .captures(&text)
+            .expect("note link regex didn't match - bad input?");
+        let file = captures.name("file").map(|v| v.as_str().trim());
+        let label = captures.name("label").map(|v| v.as_str());
+        let section = captures.name("section").map(|v| v.as_str().trim());
+
+        if let Some(file) = file {
+            if let Some(path) = lookup_filename_in_vault(file, self.vault_contents.as_ref()) {
+                let mut link_text = String::from(path.to_string_lossy());
+                if let Some(section) = section {
+                    link_text.push('#');
+                    link_text.push_str(section);
+                    if let Some(label) = label {
+                        let label = label.to_string();
+                        Some((CowStr::from(link_text), CowStr::from(label)))
+                    } else {
+                        Some((link_text.into(), format!("{} > {}", file, section).into()))
+                    }
+                } else {
+                    Some((link_text.into(), format!("{}", file).into()))
+                }
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+}

crates/weaver-renderer/src/utils.rs

···
+use std::{fmt::Arguments, path::Path, sync::OnceLock};
+
+use markdown_weaver::{CodeBlockKind, CowStr, Event, Tag};
+use markdown_weaver_escape::StrWrite;
+use miette::IntoDiagnostic;
+use n0_future::TryFutureExt;
+use n0_future::io::AsyncWrite;
+use n0_future::io::AsyncWriteExt;
+use regex::Regex;
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+pub async fn inline_file(path: impl AsRef<Path>) -> Option<String> {
+    tokio::fs::read_to_string(path).await.ok()
+}
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub async fn inline_file(path: impl AsRef<Path>) -> Option<String> {
+    todo!()
+}
+
+pub const AVOID_URL_CHARS: &[char] = &[
+    '!', '#', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=', ':', '@', '%', '[', ']', '?', '/',
+    '~', '|', '{', '}', '^', '`',
+];
+
+pub fn resolve_at_ident_or_uri<'s>(
+    link: &markdown_weaver::Tag<'s>,
+    appview: &str,
+) -> markdown_weaver::Tag<'s> {
+    use markdown_weaver::Tag;
+    match link {
+        Tag::Link {
+            link_type,
+            dest_url,
+            title,
+            id,
+        } => {
+            if dest_url.starts_with("at://") {
+                // Make the appview string swappable
+                let at_uri = weaver_common::aturi_to_http(dest_url.as_ref(), appview);
+                if let Some(at_uri) = at_uri {
+                    Tag::Link {
+                        link_type: *link_type,
+                        dest_url: at_uri.into_static(),
+                        title: title.clone(),
+                        id: id.clone(),
+                    }
+                } else {
+                    link.clone()
+                }
+            } else if dest_url.starts_with("@") {
+                let maybe_identifier = dest_url.strip_prefix("@").unwrap();
+                if let Some(identifier) = weaver_common::match_identifier(maybe_identifier) {
+                    let link = CowStr::Boxed(
+                        format!("https://{}/profile/{}", appview, identifier).into_boxed_str(),
+                    );
+                    Tag::Link {
+                        link_type: *link_type,
+                        dest_url: link,
+                        title: title.clone(),
+                        id: id.clone(),
+                    }
+                } else {
+                    link.clone()
+                }
+            } else {
+                link.clone()
+            }
+        }
+        _ => link.clone(),
+    }
+}
+
+/// Rough and ready check if a path is a local path.
+/// Basically checks if the path is absolute and if so, is it accessible.
+/// Relative paths are assumed to be local
+pub fn is_local_path(path: &str) -> bool {
+    let path = Path::new(path);
+    path.is_relative() || path.try_exists().unwrap_or(false)
+}
+
+/// Is this link relative to somewhere?
+/// Rust has built-in checks for file paths, so this just wraps that.
+pub fn is_relative_link(link: &str) -> bool {
+    let path = Path::new(link);
+    path.is_relative()
+}
+
+/// Flatten a directory path to just the parent and filename, if present.
+/// Maybe worth to swap to using the Path tools, but this works.
+pub fn flatten_dir_to_just_one_parent(path: &str) -> (&str, &str) {
+    static RE_PARENT_DIR: OnceLock<Regex> = OnceLock::new();
+    let caps = RE_PARENT_DIR
+        .get_or_init(|| {
+            Regex::new(r".*[/\\](?P<parent>[^/\\]+)[/\\](?P<filename>[^/\\]+)$").unwrap()
+        })
+        .captures(path);
+    if let Some(caps) = caps {
+        if let Some(parent) = caps.name("parent") {
+            if let Some(filename) = caps.name("filename") {
+                return (parent.as_str(), filename.as_str());
+            }
+            return (parent.as_str(), "");
+        }
+        if let Some(filename) = caps.name("filename") {
+            return ("", filename.as_str());
+        }
+    }
+    ("", path)
+}
+
+fn event_to_owned<'a>(event: Event<'a>) -> Event<'a> {
+    match event {
+        Event::Start(tag) => Event::Start(tag_to_owned(tag)),
+        Event::End(tag) => Event::End(tag),
+        Event::Text(cowstr) => Event::Text(CowStr::from(cowstr.into_string())),
+        Event::Code(cowstr) => Event::Code(CowStr::from(cowstr.into_string())),
+        Event::Html(cowstr) => Event::Html(CowStr::from(cowstr.into_string())),
+        Event::InlineHtml(cowstr) => Event::InlineHtml(CowStr::from(cowstr.into_string())),
+        Event::FootnoteReference(cowstr) => {
+            Event::FootnoteReference(CowStr::from(cowstr.into_string()))
+        }
+        Event::SoftBreak => Event::SoftBreak,
+        Event::HardBreak => Event::HardBreak,
+        Event::Rule => Event::Rule,
+        Event::TaskListMarker(checked) => Event::TaskListMarker(checked),
+        Event::InlineMath(cowstr) => Event::InlineMath(CowStr::from(cowstr.into_string())),
+        Event::DisplayMath(cowstr) => Event::DisplayMath(CowStr::from(cowstr.into_string())),
+        Event::WeaverBlock(cow_str) => todo!(),
+    }
+}
+
+fn tag_to_owned<'a>(tag: Tag<'a>) -> Tag<'a> {
+    match tag {
+        Tag::Paragraph => Tag::Paragraph,
+        Tag::Heading {
+            level: heading_level,
+            id,
+            classes,
+            attrs,
+        } => Tag::Heading {
+            level: heading_level,
+            id: id.map(|cowstr| CowStr::from(cowstr.into_string())),
+            classes: classes
+                .into_iter()
+                .map(|cowstr| CowStr::from(cowstr.into_string()))
+                .collect(),
+            attrs: attrs
+                .into_iter()
+                .map(|(attr, value)| {
+                    (
+                        CowStr::from(attr.into_string()),
+                        value.map(|cowstr| CowStr::from(cowstr.into_string())),
+                    )
+                })
+                .collect(),
+        },
+        Tag::BlockQuote(blockquote_kind) => Tag::BlockQuote(blockquote_kind),
+        Tag::CodeBlock(codeblock_kind) => Tag::CodeBlock(codeblock_kind_to_owned(codeblock_kind)),
+        Tag::List(optional) => Tag::List(optional),
+        Tag::Item => Tag::Item,
+        Tag::FootnoteDefinition(cowstr) => {
+            Tag::FootnoteDefinition(CowStr::from(cowstr.into_string()))
+        }
+        Tag::Table(alignment_vector) => Tag::Table(alignment_vector),
+        Tag::TableHead => Tag::TableHead,
+        Tag::TableRow => Tag::TableRow,
+        Tag::TableCell => Tag::TableCell,
+        Tag::Emphasis => Tag::Emphasis,
+        Tag::Strong => Tag::Strong,
+        Tag::Strikethrough => Tag::Strikethrough,
+        Tag::Link {
+            link_type,
+            dest_url,
+            title,
+            id,
+        } => Tag::Link {
+            link_type,
+            dest_url: CowStr::from(dest_url.into_string()),
+            title: CowStr::from(title.into_string()),
+            id: CowStr::from(id.into_string()),
+        },
+        Tag::Embed {
+            embed_type,
+            dest_url,
+            title,
+            id,
+            attrs,
+        } => Tag::Embed {
+            embed_type,
+            dest_url: CowStr::from(dest_url.into_string()),
+            title: CowStr::from(title.into_string()),
+            id: CowStr::from(id.into_string()),
+            attrs,
+        },
+        Tag::Image {
+            link_type,
+            dest_url,
+            title,
+            id,
+            attrs,
+        } => Tag::Image {
+            link_type,
+            dest_url: CowStr::from(dest_url.into_string()),
+            title: CowStr::from(title.into_string()),
+            id: CowStr::from(id.into_string()),
+            attrs,
+        },
+        Tag::HtmlBlock => Tag::HtmlBlock,
+        Tag::MetadataBlock(metadata_block_kind) => Tag::MetadataBlock(metadata_block_kind),
+        Tag::DefinitionList => Tag::DefinitionList,
+        Tag::DefinitionListTitle => Tag::DefinitionListTitle,
+        Tag::DefinitionListDefinition => Tag::DefinitionListDefinition,
+        Tag::Superscript => todo!(),
+        Tag::Subscript => todo!(),
+        Tag::WeaverBlock(weaver_block_kind, weaver_attributes) => todo!(),
+    }
+}
+
+fn codeblock_kind_to_owned<'a>(codeblock_kind: CodeBlockKind<'_>) -> CodeBlockKind<'a> {
+    match codeblock_kind {
+        CodeBlockKind::Indented => CodeBlockKind::Indented,
+        CodeBlockKind::Fenced(cowstr) => CodeBlockKind::Fenced(CowStr::from(cowstr.into_string())),
+    }
+}
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use tokio::fs::{self, File};
+
+pub async fn create_file(dest: &Path) -> miette::Result<File> {
+    let file = File::create(dest)
+        .or_else(async |err| {
+            {
+                if err.kind() == std::io::ErrorKind::NotFound {
+                    let parent = dest.parent().expect("file should have a parent directory");
+                    fs::create_dir_all(parent).await?
+                }
+                File::create(dest)
+            }
+            .await
+        })
+        .await
+        .into_diagnostic()?;
+    Ok(file)
+}

crates/weaver-renderer/src/walker.rs

···
+/// Credit to https://github.com/zoni
+///
+/// Modified from https://github.com/zoni/obsidian-export/blob/main/src/walker.rs on 2025-05-21
+///
+use std::fmt;
+use std::path::{Path, PathBuf};
+
+use ignore::{DirEntry, Walk, WalkBuilder};
+
+use crate::RenderError;
+
+type FilterFn = dyn Fn(&DirEntry) -> bool + Send + Sync + 'static;
+
+/// `WalkOptions` specifies how an Obsidian vault directory is scanned for eligible files to export.
+#[derive(Clone)]
+#[allow(clippy::exhaustive_structs)]
+pub struct WalkOptions<'a> {
+    /// The filename for ignore files, following the
+    /// [gitignore](https://git-scm.com/docs/gitignore) syntax.
+    ///
+    /// By default `.export-ignore` is used.
+    pub ignore_filename: &'a str,
+    /// Whether to ignore hidden files.
+    ///
+    /// This is enabled by default.
+    pub ignore_hidden: bool,
+    /// Whether to honor git's ignore rules (`.gitignore` files, `.git/config/exclude`, etc) if
+    /// the target is within a git repository.
+    ///
+    /// This is enabled by default.
+    pub honor_gitignore: bool,
+    /// An optional custom filter function which is called for each directory entry to determine if
+    /// it should be included or not.
+    ///
+    /// This is passed to [`ignore::WalkBuilder::filter_entry`].
+    pub filter_fn: Option<&'static FilterFn>,
+}
+
+impl<'a> fmt::Debug for WalkOptions<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let filter_fn_fmt = match self.filter_fn {
+            Some(_) => "<function set>",
+            None => "<not set>",
+        };
+        f.debug_struct("WalkOptions")
+            .field("ignore_filename", &self.ignore_filename)
+            .field("ignore_hidden", &self.ignore_hidden)
+            .field("honor_gitignore", &self.honor_gitignore)
+            .field("filter_fn", &filter_fn_fmt)
+            .finish()
+    }
+}
+
+impl<'a> WalkOptions<'a> {
+    /// Create a new set of options using default values.
+    #[must_use]
+    pub fn new() -> Self {
+        WalkOptions {
+            ignore_filename: ".export-ignore",
+            ignore_hidden: true,
+            honor_gitignore: true,
+            filter_fn: None,
+        }
+    }
+
+    fn build_walker(self, path: &Path) -> Walk {
+        let mut walker = WalkBuilder::new(path);
+        walker
+            .standard_filters(false)
+            .parents(true)
+            .hidden(self.ignore_hidden)
+            .add_custom_ignore_filename(self.ignore_filename)
+            .require_git(true)
+            .git_ignore(self.honor_gitignore)
+            .git_global(self.honor_gitignore)
+            .git_exclude(self.honor_gitignore);
+
+        if let Some(filter) = self.filter_fn {
+            walker.filter_entry(filter);
+        }
+        walker.build()
+    }
+}
+
+impl<'a> Default for WalkOptions<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// `vault_contents` returns all of the files in an Obsidian vault located at `path` which would be
+/// exported when using the given [`WalkOptions`].
+pub fn vault_contents(root: &Path, opts: WalkOptions<'_>) -> Result<Vec<PathBuf>, RenderError> {
+    let mut contents = Vec::new();
+    let walker = opts.build_walker(root);
+    for entry in walker {
+        let entry = entry.map_err(|e| RenderError::WalkDirError {
+            path: root.to_path_buf(),
+            msg: e.to_string(),
+        })?;
+        let path = entry.path();
+        let metadata = entry.metadata().map_err(|e| RenderError::WalkDirError {
+            path: root.to_path_buf(),
+            msg: e.to_string(),
+        })?;
+
+        if metadata.is_dir() {
+            continue;
+        }
+        contents.push(path.to_path_buf());
+    }
+    Ok(contents)
+}

crates/weaver-server/Cargo.toml

···
 license.workspace = true
 publish = false
 
+[[bin]]
+name = "weaver-server"
+path = "src/main.rs"
+
+[lib]
+name = "weaver_server"
+path = "src/lib.rs"
+
 [dependencies]
 weaver-common = { path = "../weaver-common" }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }

crates/weaver-server/src/lib.rs

···
+

flake.lock

···
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1747467164,
-        "narHash": "sha256-JBXbjJ0t6T6BbVc9iPVquQI9XSXCGQJD8c8SgnUquus=",
+        "lastModified": 1747728033,
+        "narHash": "sha256-NnXFQu7g4LnvPIPfJmBuZF7LFy/fey2g2+LCzjQhTUk=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "3fcbdcfc707e0aa42c541b7743e05820472bdaec",
+        "rev": "2f9173bde1d3fbf1ad26ff6d52f952f9e9da52ea",
         "type": "github"
       },
       "original": {
···
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1747535902,
-        "narHash": "sha256-rKWBtLcqQeu8PpfKIBn1ORXS2udSH/MwnQFwfSpFOLg=",
+        "lastModified": 1747795013,
+        "narHash": "sha256-c7i0xJ+xFhgjO9SWHYu5dF/7lq63RPDvwKAdjc6VCE4=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "b7a99615d26b82c39b73ccc9026545c3f3403b71",
+        "rev": "6b1cf12374361859242a562e1933a7930649131a",
         "type": "github"
       },
       "original": {

flake.nix

···
         p.rust-bin.selectLatestNightlyWith(toolchain: toolchain.default.override {
           # Set the build targets supported by the toolchain,
           # wasm32-unknown-unknown is required for trunk.
-          #targets = ["wasm32-unknown-unknown"];
+          targets = ["wasm32-unknown-unknown"];
           extensions = [
-            "llvm-tools"
             "rust-src"
             "rust-analyzer"
             "clippy"

lexicons/sh/weaver/actor/defs.json

···
         }
       }
     },
+    "author": {
+      "type": "object",
+      "description": "A single author in a Weaver notebook.",
+      "required": ["did"],
+      "properties": {
+        "did": { "type": "string", "format": "did" },
+        "handle": { "type": "string", "format": "handle" },
+        "displayName": {
+          "type": "string",
+          "maxGraphemes": 64,
+          "maxLength": 640
+        }
+      }
+    },
     "tangledProfileView": {
       "type": "object",
       "required": ["bluesky", "did", "handle"],

lexicons/sh/weaver/notebook/authors.json

···
     "main": {
       "type": "record",
       "description": "Authors of a Weaver notebook.",
-      "key": "literal:self",
+      "key": "tid",
       "record": {
         "type": "object",
         "required": ["authorList"],

lexicons/sh/weaver/notebook/book.json

···
           "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"
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "sh.weaver.actor.defs#author"
+            }
           },
           "entryList": {
             "type": "array",
             "items": {
               "type": "ref",
-              "ref": "sh.weaver.notebook.defs#bookEntryView"
+              "ref": "com.atproto.repo.strongRef"
             }
           },
           "createdAt": {

lexicons/sh/weaver/notebook/chapter.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.chapter",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A grouping of entries in a notebook.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["notebook", "authors", "entryList"],
+        "properties": {
+          "title": { "type": "ref", "ref": "sh.weaver.notebook.defs#title" },
+          "tags": { "type": "ref", "ref": "sh.weaver.notebook.defs#tags" },
+          "notebook": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef",
+            "description": "The notebook this chapter belongs to."
+          },
+          "authors": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "sh.weaver.actor.defs#author"
+            }
+          },
+          "entryList": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "com.atproto.repo.strongRef"
+            }
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Client-declared timestamp when this was originally created."
+          }
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/notebook/defs.json

···
       },
       "maxLength": 10,
       "description": "An array of tags associated with the notebook entry. Tags can help categorize and organize entries."
+    },
+    "contentFormat": {
+      "type": "object",
+      "description": "The format of the content. This is used to determine how to render the content.",
+      "properties": {
+        "markdown": {
+          "type": "string",
+          "description": "The format of the content. This is used to determine how to render the content.",
+          "enum": ["commonmark", "gfm", "obsidian", "weaver"],
+          "default": "weaver"
+        }
+      }
     }
   }
 }

lexicons/sh/weaver/notebook/page.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.notebook.chapter",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A grouping of entries in a notebook, intended to be displayed as a single page.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["notebook", "authors", "entryList"],
+        "properties": {
+          "title": { "type": "ref", "ref": "sh.weaver.notebook.defs#title" },
+          "tags": { "type": "ref", "ref": "sh.weaver.notebook.defs#tags" },
+          "notebook": {
+            "type": "ref",
+            "ref": "com.atproto.repo.strongRef",
+            "description": "The notebook this page belongs to."
+          },
+          "entryList": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "com.atproto.repo.strongRef"
+            }
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Client-declared timestamp when this was originally created."
+          }
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/publish/blob.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.publish.blob",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A simple record referencing a file hosted on a PDS",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["upload"],
+        "properties": {
+          "upload": {
+            "type": "blob",
+            "description": "Reference to the uploaded file",
+            "accept": ["*/*"],
+            "maxSize": 10000000
+          }
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/publish/defs.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.publish.defs",
+  "defs": {}
+}