moving stuff around, getting ready for atproto

Cargo.lock

···
 checksum = "087113bd50d9adce24850eed5d0476c7d199d532fce8fab5173650331e09033a"
 dependencies = [
  "abnf-core",
- "nom",
+ "nom 7.1.3",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c44e09c43ae1c368fb91a03a566472d0087c26cf7e1b9e8e289c14ede681dd7d"
 dependencies = [
- "nom",
+ "nom 7.1.3",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
 dependencies = [
  "libc",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
 ]
 
 [[package]]
···
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
+[[package]]
 name = "autocfg"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "hyper-util",
  "itoa",
  "matchit",
- "memchr",
+ "memchr 2.7.6",
  "mime",
  "percent-encoding",
  "pin-project-lite",
···
 checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
 dependencies = [
  "addr2line",
- "cfg-if",
+ "cfg-if 1.0.4",
  "libc",
  "miniz_oxide",
  "object",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
  "serde",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b953a6887648bb07a535631f2bc00fbdb2a2216f135552cb3f534ed136b9c07f"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
  "safemem",
 ]
 
···
 
 [[package]]
 name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
···
 
 [[package]]
 name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags 1.3.2",
+ "strsim 0.8.0",
+ "textwrap 0.11.0",
+ "unicode-width 0.1.14",
+ "vec_map",
+]
+
+[[package]]
+name = "clap"
 version = "4.5.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c26d721170e0295f191a69bd9a1f93efcdb0aff38684b61ab5750468972e5f5"
···
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim",
+ "strsim 0.11.1",
  "unicase",
  "unicode-width 0.2.2",
 ]
···
 checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
+name = "cloudabi"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
 name = "colorchoice"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
 dependencies = [
  "bytes",
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 dependencies = [
  "compression-core",
  "flate2",
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "cpufeatures",
  "curve25519-dalek-derive",
  "digest",
···
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim",
+ "strsim 0.11.1",
  "syn 2.0.108",
 ]
 
···
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim",
+ "strsim 0.11.1",
  "syn 2.0.108",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "crossbeam-utils",
  "hashbrown 0.14.5",
- "lock_api",
+ "lock_api 0.4.14",
  "once_cell",
- "parking_lot_core",
+ "parking_lot_core 0.9.12",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc0505cd1b6fa6580283f6bdf70a73fcf4aba1184038c90902b92b3dd0df63ed"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "libc",
  "libredox",
  "windows-sys 0.60.2",
···
 checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
 
 [[package]]
+name = "fixedbitset"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d"
+
+[[package]]
 name = "flate2"
 version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "futures-macro",
  "futures-sink",
  "futures-task",
- "memchr",
+ "memchr 2.7.6",
  "pin-project-lite",
  "pin-utils",
  "slab",
···
 checksum = "605183a538e3e2a9c1038635cc5c2d194e2ee8fd0d1b66b8349fad7dbacce5a2"
 dependencies = [
  "cc",
- "cfg-if",
+ "cfg-if 1.0.4",
  "libc",
  "log",
  "rustversion",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "js-sys",
  "libc",
  "wasi",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "js-sys",
  "libc",
  "r-efi",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "crunchy",
  "zerocopy",
 ]
···
 
 [[package]]
 name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
···
 checksum = "92652067c9ce6f66ce53cc38d1169daa36e6e7eb7dd3b63b5103bd9d97117248"
 dependencies = [
  "async-trait",
- "cfg-if",
+ "cfg-if 1.0.4",
  "data-encoding",
  "enum-as-inner",
  "futures-channel",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cbb117a1ca520e111743ab2f6688eddee69db4e0ea242545a604dce8a66fd22e"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "futures-util",
  "hickory-proto",
  "ipconfig",
  "lru-cache",
  "once_cell",
- "parking_lot",
+ "parking_lot 0.12.5",
  "rand 0.8.5",
  "resolv-conf",
  "smallvec",
···
  "crossbeam-deque",
  "globset",
  "log",
- "memchr",
+ "memchr 2.7.6",
  "regex-automata",
  "same-file",
  "walkdir",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
  "serde",
 ]
 
···
 [[package]]
 name = "jacquard"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "bytes",
  "getrandom 0.2.16",
···
 [[package]]
 name = "jacquard-api"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-axum"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "axum",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "cid",
  "dashmap",
···
 [[package]]
 name = "jacquard-oauth"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#ece153be8332f8f222163257b910ba03d50951c8"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#10d719d2a2c459ab562b2be6fecdfe11f52b521c"
 dependencies = [
  "base64 0.22.1",
  "bytes",
···
 checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
 dependencies = [
  "cesu8",
- "cfg-if",
+ "cfg-if 1.0.4",
  "combine",
  "jni-sys",
  "log",
···
 checksum = "de791f8b277ef903d49b0c6f3f3b866569ae8cb1d0829825eea28374cc4c803c"
 dependencies = [
  "base64ct",
- "cfg-if",
+ "cfg-if 1.0.4",
  "digest",
  "ecdsa",
  "ed25519-dalek",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "ecdsa",
  "elliptic-curve",
  "sha2",
···
 checksum = "e03e2e96c5926fe761088d66c8c2aee3a4352a2573f4eaca50043ad130af9117"
 dependencies = [
  "miette 5.10.0",
- "nom",
+ "nom 7.1.3",
  "thiserror 1.0.69",
 ]
 
···
 dependencies = [
  "bitflags 2.10.0",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.5.18",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "lock_api"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "lock_api"
 version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "generator",
  "scoped-tls",
  "tracing",
···
  "bitflags 2.10.0",
  "getopts",
  "markdown-weaver-escape",
- "memchr",
+ "memchr 2.7.6",
  "serde",
  "unicase",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "digest",
 ]
 
···
 checksum = "33746aadcb41349ec291e7f2f0a3aa6834d1d7c58066fb4b01f68efc4c4b7631"
 dependencies = [
  "serde",
+]
+
+[[package]]
+name = "memchr"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "148fab2e51b4f1cfc66da2a7c32981d1d3c083a803978268bb11fe4b86925e7a"
+dependencies = [
+ "libc",
 ]
 
 [[package]]
···
 dependencies = [
  "backtrace",
  "backtrace-ext",
- "cfg-if",
+ "cfg-if 1.0.4",
  "miette-derive 7.6.0",
  "owo-colors",
  "supports-color",
···
  "supports-unicode",
  "syntect",
  "terminal_size",
- "textwrap",
+ "textwrap 0.16.2",
  "unicode-width 0.1.14",
 ]
 
···
  "equivalent",
  "event-listener",
  "futures-util",
- "parking_lot",
+ "parking_lot 0.12.5",
  "portable-atomic",
  "rustc_version",
  "smallvec",
···
 
 [[package]]
 name = "nom"
+version = "3.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05aec50c70fd288702bcd93284a8444607f3292dbdf2a30de5ea5dcdbe72287b"
+dependencies = [
+ "memchr 1.0.2",
+]
+
+[[package]]
+name = "nom"
 version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
  "minimal-lexical",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.5.2",
  "libc",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 checksum = "24ad14dd45412269e1a30f52ad8f0664f0f4f4a89ee8fe28c3b3527021ebb654"
 dependencies = [
  "bitflags 2.10.0",
- "cfg-if",
+ "cfg-if 1.0.4",
  "foreign-types",
  "libc",
  "once_cell",
···
 
 [[package]]
 name = "parking_lot"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3a704eb390aafdc107b0e392f56a82b668e3a71366993b5340f5833fd62505e"
+dependencies = [
+ "lock_api 0.3.4",
+ "parking_lot_core 0.7.3",
+]
+
+[[package]]
+name = "parking_lot"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
- "lock_api",
- "parking_lot_core",
+ "lock_api 0.4.14",
+ "parking_lot_core 0.9.12",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93f386bb233083c799e6e642a9d73db98c24a5deeb95ffc85bf281255dffc98"
+dependencies = [
+ "cfg-if 0.1.10",
+ "cloudabi",
+ "libc",
+ "redox_syscall 0.1.57",
+ "smallvec",
+ "winapi",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.5.18",
  "smallvec",
  "windows-link 0.2.1",
 ]
···
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
+name = "petgraph"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "467d164a6de56270bd7c4d070df81d07beace25012d5103ced4e9ff08d6afdb7"
+dependencies = [
+ "fixedbitset",
+ "indexmap 1.9.3",
+]
+
+[[package]]
 name = "phf"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "fallible-iterator",
  "hmac",
  "md-5",
- "memchr",
+ "memchr 2.7.6",
  "rand 0.9.2",
  "sha2",
  "stringprep",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42a232e7487fc2ef313d96dde7948e7a3c05101870d8985e4fd8d26aedd27b89"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "redox_syscall"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+
+[[package]]
+name = "redox_syscall"
 version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
···
 checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
- "memchr",
+ "memchr 2.7.6",
  "regex-automata",
  "regex-syntax",
 ]
···
 checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
- "memchr",
+ "memchr 2.7.6",
  "regex-syntax",
 ]
 
···
 checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
- "cfg-if",
+ "cfg-if 1.0.4",
  "getrandom 0.2.16",
  "libc",
  "untrusted",
···
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
 [[package]]
+name = "scoped_threadpool"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d51f5df5af43ab3f1360b429fa5e0152ac5ce8c0bd6485cae490332e96846a8"
+
+[[package]]
 name = "scopeguard"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "indexmap 2.12.0",
  "itoa",
- "memchr",
+ "memchr 2.7.6",
  "ryu",
  "serde",
  "serde_core",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "cpufeatures",
  "digest",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "cpufeatures",
  "digest",
 ]
···
 checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
 dependencies = [
  "new_debug_unreachable",
- "parking_lot",
+ "parking_lot 0.12.5",
  "phf_shared 0.11.3",
  "precomputed-hash",
  "serde",
···
 
 [[package]]
 name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "strsim"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
···
 ]
 
 [[package]]
+name = "tabwriter"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fce91f2f0ec87dff7e6bcbbeb267439aa1188703003c6055193c821487400432"
+dependencies = [
+ "unicode-width 0.2.2",
+]
+
+[[package]]
 name = "tagptr"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "rustix",
  "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width 0.1.14",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
 ]
 
 [[package]]
···
  "bytes",
  "libc",
  "mio",
- "parking_lot",
+ "parking_lot 0.12.5",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2 0.6.1",
···
  "futures-channel",
  "futures-util",
  "log",
- "parking_lot",
+ "parking_lot 0.12.5",
  "percent-encoding",
  "phf 0.13.1",
  "pin-project-lite",
···
  "cookie",
  "futures-util",
  "http",
- "parking_lot",
+ "parking_lot 0.12.5",
  "pin-project-lite",
  "tower-layer",
  "tower-service",
···
 checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf"
 dependencies = [
  "crossbeam-channel",
- "parking_lot",
+ "parking_lot 0.12.5",
  "thiserror 1.0.69",
  "time",
  "tracing-subscriber",
···
 ]
 
 [[package]]
+name = "tree_magic"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1d99367ce3e553a84738f73bd626ccca541ef90ae757fdcdc4cbe728e6cb629"
+dependencies = [
+ "clap 2.34.0",
+ "fnv",
+ "lazy_static",
+ "nom 3.2.1",
+ "num_cpus",
+ "parking_lot 0.10.2",
+ "petgraph",
+ "scoped_threadpool",
+ "tabwriter",
+ "walkdir",
+]
+
+[[package]]
 name = "try-lock"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59b11b2b5241ba34be09c3cc85a36e56e48f9888862e19cedf23336d35316ed1"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "551f88106c6d5e7ccc7cd9a16f312dd3b5d36ea8b4954304657d5dfba115d4a0"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "js-sys",
  "once_cell",
  "wasm-bindgen",
···
 
 [[package]]
 name = "weaver-api"
-version = "0.8.0"
+version = "0.1.0"
 dependencies = [
  "bytes",
  "jacquard-common",
···
 dependencies = [
  "axum",
  "chrono",
- "clap",
+ "clap 4.5.51",
  "dashmap",
  "diesel",
  "diesel-async",
···
 name = "weaver-cli"
 version = "0.1.0"
 dependencies = [
- "clap",
+ "clap 4.5.51",
  "dirs",
  "jacquard",
  "jacquard-api",
···
  "hickory-resolver",
  "http",
  "jacquard",
- "jacquard-api",
  "jose-jwk",
  "markdown-weaver",
  "markdown-weaver-escape",
···
  "tower-service",
  "tracing",
  "trait-variant",
+ "tree_magic",
+ "weaver-api",
  "weaver-workspace-hack",
 ]
 
···
 version = "0.1.0"
 dependencies = [
  "axum",
- "clap",
+ "clap 4.5.51",
  "jacquard",
  "jacquard-axum",
  "notify",
···
  "jacquard-lexicon",
  "jacquard-oauth",
  "log",
- "memchr",
+ "memchr 2.7.6",
  "miette 7.6.0",
  "minijinja",
  "minimal-lexical",
- "nom",
+ "nom 7.1.3",
  "num-traits",
  "p384",
  "percent-encoding",
···
 checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
 
 [[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
 name = "winapi-util"
 version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "windows-sys 0.61.2",
 ]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
- "memchr",
+ "memchr 2.7.6",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.4",
  "windows-sys 0.48.0",
 ]
 

Cargo.toml

···
 jacquard = { git = "https://tangled.org/@nonbinary.computer/jacquard", default-features = false, features = ["derive", "api_bluesky", "dns"] }
 jacquard-api = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
 jacquard-axum = { git = "https://tangled.org/@nonbinary.computer/jacquard" }
+tree_magic = { version = "0.2.3", features = ["cli"] }

crates/weaver-api/Cargo.toml

···
 name = "weaver-api"
 description = "Generated AT Protocol API bindings for Weaver"
 edition.workspace = true
-version = "0.8.0"
+version = "0.1.0"
 authors.workspace = true
 
 [dependencies]

crates/weaver-api/lexicons/sh_weaver_edit_root.json

···
       "record": {
         "type": "object",
         "required": [
-          "cid",
-          "uri",
           "doc",
           "snapshot"
         ],
         "properties": {
-          "cid": {
-            "type": "string",
-            "format": "cid"
-          },
           "doc": {
             "type": "ref",
             "ref": "sh.weaver.edit.defs#docRef"
···
               "*/*"
             ],
             "maxSize": 30000000
-          },
-          "uri": {
-            "type": "string",
-            "format": "at-uri"
           }
         }
       }

crates/weaver-api/lexicons/sh_weaver_embed_recordWithMedia.json

···
     "main": {
       "type": "object",
       "required": [
-        "record",
+        "records",
         "media"
       ],
       "properties": {
···
           "refs": [
             "sh.weaver.embed.images",
             "sh.weaver.embed.external",
-            "sh.weaver.embed.video",
-            "app.bsky.embed.images",
-            "app.bsky.embed.video",
-            "app.bsky.embed.external"
+            "sh.weaver.embed.video"
           ]
         },
-        "record": {
-          "type": "union",
-          "refs": [
-            "app.bsky.embed.record",
-            "sh.weaver.embed.records"
-          ]
+        "records": {
+          "type": "ref",
+          "ref": "sh.weaver.embed.records"
         }
       }
     },
···
           "refs": [
             "sh.weaver.embed.images#view",
             "sh.weaver.embed.external#view",
-            "sh.weaver.embed.video#view",
-            "app.bsky.embed.images#view",
-            "app.bsky.embed.video#view",
-            "app.bsky.embed.external#view"
+            "sh.weaver.embed.video#view"
           ]
         },
-        "record": {
-          "type": "union",
-          "refs": [
-            "sh.weaver.embed.records#view",
-            "app.bsky.embed.record#view"
-          ]
+        "records": {
+          "type": "ref",
+          "ref": "sh.weaver.embed.records#view"
         }
       }
     }

crates/weaver-api/lexicons/sh_weaver_embed_records.json

···
         "recordView": {
           "type": "union",
           "refs": [
-            "app.bsky.embed.images#view",
-            "app.bsky.embed.video#view",
-            "app.bsky.embed.external#view",
-            "app.bsky.embed.record#view",
-            "app.bsky.embed.recordWithMedia#view",
             "sh.weaver.embed.records#view",
             "sh.weaver.embed.images#view",
             "sh.weaver.embed.recordWithMedia#view",

crates/weaver-api/lexicons/sh_weaver_publish_blob.json

···
       "record": {
         "type": "object",
         "required": [
-          "upload"
+          "upload",
+          "path"
         ],
         "properties": {
+          "path": {
+            "type": "string",
+            "description": "relative path to the blob",
+            "minLength": 1
+          },
           "upload": {
             "type": "blob",
             "description": "Reference to the uploaded file",

crates/weaver-api/src/sh_weaver/edit/root.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct Root<'a> {
     #[serde(borrow)]
-    pub cid: jacquard_common::types::string::Cid<'a>,
-    #[serde(borrow)]
     pub doc: crate::sh_weaver::edit::DocRef<'a>,
     #[serde(borrow)]
     pub snapshot: jacquard_common::types::blob::BlobRef<'a>,
-    #[serde(borrow)]
-    pub uri: jacquard_common::types::string::AtUri<'a>,
 }
 
 pub mod root_state {
···
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
-        type Uri;
         type Doc;
         type Snapshot;
     }
···
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
-        type Uri = Unset;
         type Doc = Unset;
         type Snapshot = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
-    impl<S: State> sealed::Sealed for SetCid<S> {}
-    impl<S: State> State for SetCid<S> {
-        type Cid = Set<members::cid>;
-        type Uri = S::Uri;
-        type Doc = S::Doc;
-        type Snapshot = S::Snapshot;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
-    impl<S: State> sealed::Sealed for SetUri<S> {}
-    impl<S: State> State for SetUri<S> {
-        type Cid = S::Cid;
-        type Uri = Set<members::uri>;
-        type Doc = S::Doc;
-        type Snapshot = S::Snapshot;
-    }
     ///State transition - sets the `doc` field to Set
     pub struct SetDoc<S: State = Empty>(PhantomData<fn() -> S>);
     impl<S: State> sealed::Sealed for SetDoc<S> {}
     impl<S: State> State for SetDoc<S> {
-        type Cid = S::Cid;
-        type Uri = S::Uri;
         type Doc = Set<members::doc>;
         type Snapshot = S::Snapshot;
     }
···
     pub struct SetSnapshot<S: State = Empty>(PhantomData<fn() -> S>);
     impl<S: State> sealed::Sealed for SetSnapshot<S> {}
     impl<S: State> State for SetSnapshot<S> {
-        type Cid = S::Cid;
-        type Uri = S::Uri;
         type Doc = S::Doc;
         type Snapshot = Set<members::snapshot>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `doc` field
         pub struct doc(());
         ///Marker type for the `snapshot` field
···
 pub struct RootBuilder<'a, S: root_state::State> {
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
-        ::core::option::Option<jacquard_common::types::string::Cid<'a>>,
         ::core::option::Option<crate::sh_weaver::edit::DocRef<'a>>,
         ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
-        ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
 }
···
     pub fn new() -> Self {
         RootBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None, None, None, None),
-            _phantom: ::core::marker::PhantomData,
-        }
-    }
-}
-
-impl<'a, S> RootBuilder<'a, S>
-where
-    S: root_state::State,
-    S::Cid: root_state::IsUnset,
-{
-    /// Set the `cid` field (required)
-    pub fn cid(
-        mut self,
-        value: impl Into<jacquard_common::types::string::Cid<'a>>,
-    ) -> RootBuilder<'a, root_state::SetCid<S>> {
-        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
-        RootBuilder {
-            _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: self.__unsafe_private_named,
+            __unsafe_private_named: (None, None),
             _phantom: ::core::marker::PhantomData,
         }
     }
···
         mut self,
         value: impl Into<crate::sh_weaver::edit::DocRef<'a>>,
     ) -> RootBuilder<'a, root_state::SetDoc<S>> {
-        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
         RootBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
         mut self,
         value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
     ) -> RootBuilder<'a, root_state::SetSnapshot<S>> {
-        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
-        RootBuilder {
-            _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: self.__unsafe_private_named,
-            _phantom: ::core::marker::PhantomData,
-        }
-    }
-}
-
-impl<'a, S> RootBuilder<'a, S>
-where
-    S: root_state::State,
-    S::Uri: root_state::IsUnset,
-{
-    /// Set the `uri` field (required)
-    pub fn uri(
-        mut self,
-        value: impl Into<jacquard_common::types::string::AtUri<'a>>,
-    ) -> RootBuilder<'a, root_state::SetUri<S>> {
-        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
         RootBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
 impl<'a, S> RootBuilder<'a, S>
 where
     S: root_state::State,
-    S::Cid: root_state::IsSet,
-    S::Uri: root_state::IsSet,
     S::Doc: root_state::IsSet,
     S::Snapshot: root_state::IsSet,
 {
     /// Build the final struct
     pub fn build(self) -> Root<'a> {
         Root {
-            cid: self.__unsafe_private_named.0.unwrap(),
-            doc: self.__unsafe_private_named.1.unwrap(),
-            snapshot: self.__unsafe_private_named.2.unwrap(),
-            uri: self.__unsafe_private_named.3.unwrap(),
+            doc: self.__unsafe_private_named.0.unwrap(),
+            snapshot: self.__unsafe_private_named.1.unwrap(),
             extra_data: Default::default(),
         }
     }
···
         >,
     ) -> Root<'a> {
         Root {
-            cid: self.__unsafe_private_named.0.unwrap(),
-            doc: self.__unsafe_private_named.1.unwrap(),
-            snapshot: self.__unsafe_private_named.2.unwrap(),
-            uri: self.__unsafe_private_named.3.unwrap(),
+            doc: self.__unsafe_private_named.0.unwrap(),
+            snapshot: self.__unsafe_private_named.1.unwrap(),
             extra_data: Some(extra_data),
         }
     }
···
                         description: None,
                         required: Some(
                             vec![
-                                ::jacquard_common::smol_str::SmolStr::new_static("cid"),
-                                ::jacquard_common::smol_str::SmolStr::new_static("uri"),
                                 ::jacquard_common::smol_str::SmolStr::new_static("doc"),
                                 ::jacquard_common::smol_str::SmolStr::new_static("snapshot")
                             ],
···
                             #[allow(unused_mut)]
                             let mut map = ::std::collections::BTreeMap::new();
                             map.insert(
-                                ::jacquard_common::smol_str::SmolStr::new_static("cid"),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
-                                    ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
                                 ::jacquard_common::smol_str::SmolStr::new_static("doc"),
                                 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
                                     description: None,
···
                                     description: None,
                                     accept: None,
                                     max_size: None,
-                                }),
-                            );
-                            map.insert(
-                                ::jacquard_common::smol_str::SmolStr::new_static("uri"),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
-                                    ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
                                 }),
                             );
                             map

crates/weaver-api/src/sh_weaver/embed/record_with_media.rs

···
     #[serde(borrow)]
     pub media: RecordWithMediaMedia<'a>,
     #[serde(borrow)]
-    pub record: RecordWithMediaRecord<'a>,
+    pub records: crate::sh_weaver::embed::records::Records<'a>,
 }
 
 pub mod record_with_media_state {
···
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Record;
+        type Records;
         type Media;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Record = Unset;
+        type Records = Unset;
         type Media = Unset;
     }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<S: State = Empty>(PhantomData<fn() -> S>);
-    impl<S: State> sealed::Sealed for SetRecord<S> {}
-    impl<S: State> State for SetRecord<S> {
-        type Record = Set<members::record>;
+    ///State transition - sets the `records` field to Set
+    pub struct SetRecords<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetRecords<S> {}
+    impl<S: State> State for SetRecords<S> {
+        type Records = Set<members::records>;
         type Media = S::Media;
     }
     ///State transition - sets the `media` field to Set
     pub struct SetMedia<S: State = Empty>(PhantomData<fn() -> S>);
     impl<S: State> sealed::Sealed for SetMedia<S> {}
     impl<S: State> State for SetMedia<S> {
-        type Record = S::Record;
+        type Records = S::Records;
         type Media = Set<members::media>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `record` field
-        pub struct record(());
+        ///Marker type for the `records` field
+        pub struct records(());
         ///Marker type for the `media` field
         pub struct media(());
     }
···
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
         ::core::option::Option<RecordWithMediaMedia<'a>>,
-        ::core::option::Option<RecordWithMediaRecord<'a>>,
+        ::core::option::Option<crate::sh_weaver::embed::records::Records<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
 }
···
 impl<'a, S> RecordWithMediaBuilder<'a, S>
 where
     S: record_with_media_state::State,
-    S::Record: record_with_media_state::IsUnset,
+    S::Records: record_with_media_state::IsUnset,
 {
-    /// Set the `record` field (required)
-    pub fn record(
+    /// Set the `records` field (required)
+    pub fn records(
         mut self,
-        value: impl Into<RecordWithMediaRecord<'a>>,
-    ) -> RecordWithMediaBuilder<'a, record_with_media_state::SetRecord<S>> {
+        value: impl Into<crate::sh_weaver::embed::records::Records<'a>>,
+    ) -> RecordWithMediaBuilder<'a, record_with_media_state::SetRecords<S>> {
         self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
         RecordWithMediaBuilder {
             _phantom_state: ::core::marker::PhantomData,
···
 impl<'a, S> RecordWithMediaBuilder<'a, S>
 where
     S: record_with_media_state::State,
-    S::Record: record_with_media_state::IsSet,
+    S::Records: record_with_media_state::IsSet,
     S::Media: record_with_media_state::IsSet,
 {
     /// Build the final struct
     pub fn build(self) -> RecordWithMedia<'a> {
         RecordWithMedia {
             media: self.__unsafe_private_named.0.unwrap(),
-            record: self.__unsafe_private_named.1.unwrap(),
+            records: self.__unsafe_private_named.1.unwrap(),
             extra_data: Default::default(),
         }
     }
···
     ) -> RecordWithMedia<'a> {
         RecordWithMedia {
             media: self.__unsafe_private_named.0.unwrap(),
-            record: self.__unsafe_private_named.1.unwrap(),
+            records: self.__unsafe_private_named.1.unwrap(),
             extra_data: Some(extra_data),
         }
     }
···
     External(Box<crate::sh_weaver::embed::external::External<'a>>),
     #[serde(rename = "sh.weaver.embed.video")]
     Video(Box<crate::sh_weaver::embed::video::VideoRecord<'a>>),
-    #[serde(rename = "app.bsky.embed.images")]
-    BskyImages(Box<crate::app_bsky::embed::images::Images<'a>>),
-    #[serde(rename = "app.bsky.embed.video")]
-    BskyVideo(Box<crate::app_bsky::embed::video::Video<'a>>),
-    #[serde(rename = "app.bsky.embed.external")]
-    BskyExternal(Box<crate::app_bsky::embed::external::ExternalRecord<'a>>),
-}
-
-#[jacquard_derive::open_union]
-#[derive(
-    serde::Serialize,
-    serde::Deserialize,
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    jacquard_derive::IntoStatic
-)]
-#[serde(tag = "$type")]
-#[serde(bound(deserialize = "'de: 'a"))]
-pub enum RecordWithMediaRecord<'a> {
-    #[serde(rename = "app.bsky.embed.record")]
-    Record(Box<crate::app_bsky::embed::record::Record<'a>>),
-    #[serde(rename = "sh.weaver.embed.records")]
-    Records(Box<crate::sh_weaver::embed::records::Records<'a>>),
 }
 
 fn lexicon_doc_sh_weaver_embed_recordWithMedia() -> ::jacquard_lexicon::lexicon::LexiconDoc<
···
                     description: None,
                     required: Some(
                         vec![
-                            ::jacquard_common::smol_str::SmolStr::new_static("record"),
+                            ::jacquard_common::smol_str::SmolStr::new_static("records"),
                             ::jacquard_common::smol_str::SmolStr::new_static("media")
                         ],
                     ),
···
                                 refs: vec![
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.images"),
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.external"),
-                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.video"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.images"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.video"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.external")
+                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.video")
                                 ],
                                 closed: None,
                             }),
                         );
                         map.insert(
-                            ::jacquard_common::smol_str::SmolStr::new_static("record"),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
+                            ::jacquard_common::smol_str::SmolStr::new_static("records"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
                                 description: None,
-                                refs: vec![
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.record"),
-                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.records")
-                                ],
-                                closed: None,
+                                r#ref: ::jacquard_common::CowStr::new_static(
+                                    "sh.weaver.embed.records",
+                                ),
                             }),
                         );
                         map
···
                                 refs: vec![
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.images#view"),
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.external#view"),
-                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.video#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.images#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.video#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.external#view")
+                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.video#view")
                                 ],
                                 closed: None,
                             }),
                         );
                         map.insert(
-                            ::jacquard_common::smol_str::SmolStr::new_static("record"),
-                            ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
+                            ::jacquard_common::smol_str::SmolStr::new_static("records"),
+                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
                                 description: None,
-                                refs: vec![
-                                    ::jacquard_common::CowStr::new_static("sh.weaver.embed.records#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.record#view")
-                                ],
-                                closed: None,
+                                r#ref: ::jacquard_common::CowStr::new_static(
+                                    "sh.weaver.embed.records#view",
+                                ),
                             }),
                         );
                         map
···
 pub struct View<'a> {
     #[serde(borrow)]
     pub media: ViewMedia<'a>,
+    #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub record: ViewRecord<'a>,
+    pub records: Option<crate::sh_weaver::embed::records::View<'a>>,
 }
 
 pub mod view_state {
···
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
         ::core::option::Option<ViewMedia<'a>>,
-        ::core::option::Option<ViewRecord<'a>>,
+        ::core::option::Option<crate::sh_weaver::embed::records::View<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
 }
···
     }
 }
 
-impl<'a, S> ViewBuilder<'a, S>
-where
-    S: view_state::State,
-    S::Record: view_state::IsUnset,
-{
-    /// Set the `record` field (required)
-    pub fn record(
+impl<'a, S: view_state::State> ViewBuilder<'a, S> {
+    /// Set the `records` field (optional)
+    pub fn records(
         mut self,
-        value: impl Into<ViewRecord<'a>>,
-    ) -> ViewBuilder<'a, view_state::SetRecord<S>> {
-        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
-        ViewBuilder {
-            _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: self.__unsafe_private_named,
-            _phantom: ::core::marker::PhantomData,
-        }
+        value: impl Into<Option<crate::sh_weaver::embed::records::View<'a>>>,
+    ) -> Self {
+        self.__unsafe_private_named.1 = value.into();
+        self
+    }
+    /// Set the `records` field to an Option value (optional)
+    pub fn maybe_records(
+        mut self,
+        value: Option<crate::sh_weaver::embed::records::View<'a>>,
+    ) -> Self {
+        self.__unsafe_private_named.1 = value;
+        self
     }
 }
 
···
     pub fn build(self) -> View<'a> {
         View {
             media: self.__unsafe_private_named.0.unwrap(),
-            record: self.__unsafe_private_named.1.unwrap(),
+            records: self.__unsafe_private_named.1,
             extra_data: Default::default(),
         }
     }
···
     ) -> View<'a> {
         View {
             media: self.__unsafe_private_named.0.unwrap(),
-            record: self.__unsafe_private_named.1.unwrap(),
+            records: self.__unsafe_private_named.1,
             extra_data: Some(extra_data),
         }
     }
···
     ExternalView(Box<crate::sh_weaver::embed::external::View<'a>>),
     #[serde(rename = "sh.weaver.embed.video#view")]
     VideoView(Box<crate::sh_weaver::embed::video::View<'a>>),
-    #[serde(rename = "app.bsky.embed.images#view")]
-    BskyImagesView(Box<crate::app_bsky::embed::images::View<'a>>),
-    #[serde(rename = "app.bsky.embed.video#view")]
-    BskyVideoView(Box<crate::app_bsky::embed::video::View<'a>>),
-    #[serde(rename = "app.bsky.embed.external#view")]
-    BskyExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
-}
-
-#[jacquard_derive::open_union]
-#[derive(
-    serde::Serialize,
-    serde::Deserialize,
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    jacquard_derive::IntoStatic
-)]
-#[serde(tag = "$type")]
-#[serde(bound(deserialize = "'de: 'a"))]
-pub enum ViewRecord<'a> {
-    #[serde(rename = "sh.weaver.embed.records#view")]
-    RecordsView(Box<crate::sh_weaver::embed::records::View<'a>>),
-    #[serde(rename = "app.bsky.embed.record#view")]
-    RecordView(Box<crate::app_bsky::embed::record::View<'a>>),
 }
 
 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for View<'a> {

crates/weaver-api/src/sh_weaver/embed/records.rs

···
                             ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
                                 description: None,
                                 refs: vec![
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.images#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.video#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.external#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.record#view"),
-                                    ::jacquard_common::CowStr::new_static("app.bsky.embed.recordWithMedia#view"),
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.records#view"),
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.images#view"),
                                     ::jacquard_common::CowStr::new_static("sh.weaver.embed.recordWithMedia#view"),
···
 #[serde(tag = "$type")]
 #[serde(bound(deserialize = "'de: 'a"))]
 pub enum RecordEmbedViewRecordView<'a> {
-    #[serde(rename = "app.bsky.embed.images#view")]
-    BskyImagesView(Box<crate::app_bsky::embed::images::View<'a>>),
-    #[serde(rename = "app.bsky.embed.video#view")]
-    BskyVideoView(Box<crate::app_bsky::embed::video::View<'a>>),
-    #[serde(rename = "app.bsky.embed.external#view")]
-    ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
-    #[serde(rename = "app.bsky.embed.record#view")]
-    RecordView(Box<crate::app_bsky::embed::record::View<'a>>),
-    #[serde(rename = "app.bsky.embed.recordWithMedia#view")]
-    BskyRecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),
     #[serde(rename = "sh.weaver.embed.records#view")]
     View(Box<crate::sh_weaver::embed::records::View<'a>>),
     #[serde(rename = "sh.weaver.embed.images#view")]

crates/weaver-api/src/sh_weaver/publish/blob.rs

···
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Blob<'a> {
+    /// relative path to the blob
+    #[serde(borrow)]
+    pub path: jacquard_common::CowStr<'a>,
     /// Reference to the uploaded file
     #[serde(borrow)]
     pub upload: jacquard_common::types::blob::BlobRef<'a>,
···
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Upload;
+        type Path;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Upload = Unset;
+        type Path = Unset;
     }
     ///State transition - sets the `upload` field to Set
     pub struct SetUpload<S: State = Empty>(PhantomData<fn() -> S>);
     impl<S: State> sealed::Sealed for SetUpload<S> {}
     impl<S: State> State for SetUpload<S> {
         type Upload = Set<members::upload>;
+        type Path = S::Path;
+    }
+    ///State transition - sets the `path` field to Set
+    pub struct SetPath<S: State = Empty>(PhantomData<fn() -> S>);
+    impl<S: State> sealed::Sealed for SetPath<S> {}
+    impl<S: State> State for SetPath<S> {
+        type Upload = S::Upload;
+        type Path = Set<members::path>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `upload` field
         pub struct upload(());
+        ///Marker type for the `path` field
+        pub struct path(());
     }
 }
 
···
 pub struct BlobBuilder<'a, S: blob_state::State> {
     _phantom_state: ::core::marker::PhantomData<fn() -> S>,
     __unsafe_private_named: (
+        ::core::option::Option<jacquard_common::CowStr<'a>>,
         ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
     ),
     _phantom: ::core::marker::PhantomData<&'a ()>,
···
     pub fn new() -> Self {
         BlobBuilder {
             _phantom_state: ::core::marker::PhantomData,
-            __unsafe_private_named: (None,),
+            __unsafe_private_named: (None, None),
+            _phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, S> BlobBuilder<'a, S>
+where
+    S: blob_state::State,
+    S::Path: blob_state::IsUnset,
+{
+    /// Set the `path` field (required)
+    pub fn path(
+        mut self,
+        value: impl Into<jacquard_common::CowStr<'a>>,
+    ) -> BlobBuilder<'a, blob_state::SetPath<S>> {
+        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        BlobBuilder {
+            _phantom_state: ::core::marker::PhantomData,
+            __unsafe_private_named: self.__unsafe_private_named,
             _phantom: ::core::marker::PhantomData,
         }
     }
···
         mut self,
         value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
     ) -> BlobBuilder<'a, blob_state::SetUpload<S>> {
-        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
+        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
         BlobBuilder {
             _phantom_state: ::core::marker::PhantomData,
             __unsafe_private_named: self.__unsafe_private_named,
···
 where
     S: blob_state::State,
     S::Upload: blob_state::IsSet,
+    S::Path: blob_state::IsSet,
 {
     /// Build the final struct
     pub fn build(self) -> Blob<'a> {
         Blob {
-            upload: self.__unsafe_private_named.0.unwrap(),
+            path: self.__unsafe_private_named.0.unwrap(),
+            upload: self.__unsafe_private_named.1.unwrap(),
             extra_data: Default::default(),
         }
     }
···
         >,
     ) -> Blob<'a> {
         Blob {
-            upload: self.__unsafe_private_named.0.unwrap(),
+            path: self.__unsafe_private_named.0.unwrap(),
+            upload: self.__unsafe_private_named.1.unwrap(),
             extra_data: Some(extra_data),
         }
     }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
+        {
+            let value = &self.path;
+            #[allow(unused_comparisons)]
+            if <str>::len(value.as_ref()) < 1usize {
+                return Err(::jacquard_lexicon::validation::ConstraintError::MinLength {
+                    path: ::jacquard_lexicon::validation::ValidationPath::from_field(
+                        "path",
+                    ),
+                    min: 1usize,
+                    actual: <str>::len(value.as_ref()),
+                });
+            }
+        }
         Ok(())
     }
 }
···
                         description: None,
                         required: Some(
                             vec![
-                                ::jacquard_common::smol_str::SmolStr::new_static("upload")
+                                ::jacquard_common::smol_str::SmolStr::new_static("upload"),
+                                ::jacquard_common::smol_str::SmolStr::new_static("path")
                             ],
                         ),
                         nullable: None,
                         properties: {
                             #[allow(unused_mut)]
                             let mut map = ::std::collections::BTreeMap::new();
+                            map.insert(
+                                ::jacquard_common::smol_str::SmolStr::new_static("path"),
+                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
+                                    description: Some(
+                                        ::jacquard_common::CowStr::new_static(
+                                            "relative path to the blob",
+                                        ),
+                                    ),
+                                    format: None,
+                                    default: None,
+                                    min_length: Some(1usize),
+                                    max_length: None,
+                                    min_graphemes: None,
+                                    max_graphemes: None,
+                                    r#enum: None,
+                                    r#const: None,
+                                    known_values: None,
+                                }),
+                            );
                             map.insert(
                                 ::jacquard_common::smol_str::SmolStr::new_static("upload"),
                                 ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {

crates/weaver-common/Cargo.toml

···
 [dependencies]
 n0-future = { workspace = true }
 weaver-workspace-hack = { version = "0.1", path = "../weaver-workspace-hack" }
+weaver-api = { version = "0.1", path = "../weaver-api" }
 markdown-weaver = { workspace = true }
 #libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 
 http = "1.3.1"
 
 jacquard = { workspace = true }
-jacquard-api = { workspace = true, features = ["sh_weaver"] }
 trait-variant = "0.1"
 
 serde = { workspace = true }
···
 dirs = "6.0.0"
 regex = "1.11.1"
 markdown-weaver-escape = { workspace = true, features = ["std"] }
-
+tree_magic.workspace = true
 
 
 [dev-dependencies]

crates/weaver-common/src/error.rs

···
 //! Error types for weaver - thin wrapper over jacquard errors
 
+use jacquard::{types::string::AtStrError, xrpc::GenericXrpcError};
 use miette::{Diagnostic, NamedSource, SourceOffset, SourceSpan};
 use std::borrow::Cow;
 
···
     /// Task join error
     #[error(transparent)]
     Task(#[from] n0_future::task::JoinError),
+
+    /// atproto string parsing error
+    #[error(transparent)]
+    AtprotoString(#[from] AtStrError),
+
+    /// XRPC error
+    #[error(transparent)]
+    Xrpc(#[from] jacquard::xrpc::XrpcError<GenericXrpcError>),
 }
 
 /// Parse error with source code location information

crates/weaver-common/src/lib.rs

···
 
 // Re-export jacquard for convenience
 pub use jacquard;
-use jacquard::CowStr;
-pub use jacquard_api;
+use jacquard::error::ClientError;
+use jacquard::types::ident::AtIdentifier;
+use jacquard::{CowStr, IntoStatic, xrpc};
 
 pub use error::WeaverError;
+use jacquard::types::tid::{Ticker, Tid};
 
-use jacquard::client::{Agent, AgentSession};
-use jacquard::types::blob::BlobRef;
-use jacquard::types::string::{AtUri, Cid, Did};
-use jacquard_api::sh_weaver::notebook::{book, chapter, entry};
+use jacquard::bytes::Bytes;
+use jacquard::client::{Agent, AgentError, AgentErrorKind, AgentSession, AgentSessionExt};
+use jacquard::prelude::*;
+use jacquard::smol_str::SmolStr;
+use jacquard::types::blob::{BlobRef, MimeType};
+use jacquard::types::string::{AtUri, Cid, Did, Handle, RecordKey};
+use jacquard::xrpc::Response;
 use std::path::Path;
+use std::sync::LazyLock;
+use tokio::sync::Mutex;
+use weaver_api::com_atproto::repo::get_record::GetRecordResponse;
+use weaver_api::com_atproto::repo::strong_ref::StrongRef;
+use weaver_api::sh_weaver::notebook::{book, chapter, entry};
+use weaver_api::sh_weaver::publish::blob::Blob as PublishedBlob;
+
+use crate::error::ParseError;
+
+static W_TICKER: LazyLock<Mutex<Ticker>> = LazyLock::new(|| Mutex::new(Ticker::new()));
 
 /// Extension trait providing weaver-specific multi-step operations on Agent
 ///
···
 /// - `agent.upload_blob()` - Upload a single blob
 ///
 /// This trait is for multi-step workflows that coordinate between multiple operations.
-#[trait_variant::make(Send)]
-pub trait WeaverExt {
+//#[trait_variant::make(Send)]
+pub trait WeaverExt: AgentSessionExt {
     /// Publish a notebook directory to the user's PDS
     ///
     /// Multi-step workflow:
···
     /// 5. Create book record with entry refs
     ///
     /// Returns the AT-URI of the published book
-    async fn publish_notebook(&self, path: &Path) -> Result<PublishResult<'_>, WeaverError>;
+    fn publish_notebook(
+        &self,
+        path: &Path,
+    ) -> impl Future<Output = Result<PublishResult<'_>, WeaverError>>;
 
-    /// Upload assets from markdown content
+    /// Publish a blob to the user's PDS
     ///
     /// Multi-step workflow:
-    /// 1. Parse markdown for image/asset refs
-    /// 2. Upload each asset → BlobRef
-    /// 3. Return mapping of original path → BlobRef
+    /// 1. Upload blob to PDS
+    /// 2. Create blob record with CID
     ///
-    /// Used by renderer to transform local refs to atproto refs
-    async fn upload_assets(
+    /// Returns the AT-URI of the published blob
+    fn publish_blob<'a>(
+        &self,
+        blob: Bytes,
+        url_path: &'a str,
+        prev: Option<Tid>,
+    ) -> impl Future<Output = Result<(StrongRef<'a>, PublishedBlob<'a>), WeaverError>>;
+
+    fn confirm_record_ref(
         &self,
-        markdown: &str,
-    ) -> Result<Vec<(String, BlobRef<'_>)>, WeaverError>;
+        uri: &AtUri<'_>,
+    ) -> impl Future<Output = Result<StrongRef<'_>, WeaverError>>;
 }
 
-impl<A: AgentSession> WeaverExt for Agent<A> {
+impl<A: AgentSession + IdentityResolver> WeaverExt for Agent<A> {
     async fn publish_notebook(&self, _path: &Path) -> Result<PublishResult<'_>, WeaverError> {
         // TODO: Implementation
         todo!("publish_notebook not yet implemented")
     }
 
-    async fn upload_assets(
+    async fn publish_blob<'a>(
         &self,
-        _markdown: &str,
-    ) -> Result<Vec<(String, BlobRef<'_>)>, WeaverError> {
-        // TODO: Implementation
-        todo!("upload_assets not yet implemented")
+        blob: Bytes,
+        url_path: &'a str,
+        prev: Option<Tid>,
+    ) -> Result<(StrongRef<'a>, PublishedBlob<'a>), WeaverError> {
+        let mime_type = MimeType::new_owned(tree_magic::from_u8(blob.as_ref()));
+
+        let blob = self.upload_blob(blob, mime_type).await?;
+        let publish_record = PublishedBlob::new()
+            .path(url_path)
+            .upload(BlobRef::Blob(blob))
+            .build();
+        let tid = W_TICKER.lock().await.next(prev);
+        let record = self
+            .create_record(publish_record.clone(), Some(RecordKey::any(tid.as_str())?))
+            .await?;
+        let strong_ref = StrongRef::new().uri(record.uri).cid(record.cid).build();
+
+        Ok((strong_ref, publish_record))
+    }
+
+    async fn confirm_record_ref(&self, uri: &AtUri<'_>) -> Result<StrongRef<'_>, WeaverError> {
+        let rkey = uri.rkey().ok_or_else(|| {
+            AgentError::from(
+                ClientError::invalid_request("AtUri missing rkey")
+                    .with_help("ensure the URI includes a record key after the collection"),
+            )
+        })?;
+
+        // Resolve authority (DID or handle) to get DID and PDS
+        use jacquard::types::ident::AtIdentifier;
+        let (repo_did, pds_url) = match uri.authority() {
+            AtIdentifier::Did(did) => {
+                let pds = self.pds_for_did(did).await.map_err(|e| {
+                    AgentError::from(
+                        ClientError::from(e)
+                            .with_context("DID document resolution failed during record retrieval"),
+                    )
+                })?;
+                (did.clone(), pds)
+            }
+            AtIdentifier::Handle(handle) => self.pds_for_handle(handle).await.map_err(|e| {
+                AgentError::from(
+                    ClientError::from(e)
+                        .with_context("handle resolution failed during record retrieval"),
+                )
+            })?,
+        };
+
+        // Make stateless XRPC call to that PDS (no auth required for public records)
+        use weaver_api::com_atproto::repo::get_record::GetRecord;
+        let request = GetRecord::new()
+            .repo(AtIdentifier::Did(repo_did))
+            .collection(
+                uri.collection()
+                    .expect("collection should exist if rkey does")
+                    .clone(),
+            )
+            .rkey(rkey.clone())
+            .build();
+
+        let response: Response<GetRecordResponse> = {
+            let http_request = xrpc::build_http_request(&pds_url, &request, &self.opts().await)
+                .map_err(|e| AgentError::from(ClientError::transport(e)))?;
+
+            let http_response = self
+                .send_http(http_request)
+                .await
+                .map_err(|e| AgentError::from(ClientError::transport(e)))?;
+
+            xrpc::process_response(http_response)
+        }
+        .map_err(|e| AgentError::new(AgentErrorKind::Client, Some(e.into())))?;
+        let record = response.parse().map_err(|e| AgentError::xrpc(e))?;
+        let strong_ref = StrongRef::new()
+            .uri(record.uri)
+            .cid(record.cid.expect("when does this NOT have a CID?"))
+            .build();
+        Ok(strong_ref.into_static())
     }
 }
 
···
     /// CID of the book record
     pub cid: Cid<'a>,
     /// URIs of published entries
-    pub entries: Vec<AtUri<'a>>,
+    pub entries: Vec<StrongRef<'a>>,
 }
 
 /// too many cows, so we have conversions
···
         Some(CowStr::Borrowed(aturi))
     }
 }
+
+pub enum LinkUri<'a> {
+    AtRecord(AtUri<'a>),
+    AtIdent(Did<'a>, Handle<'a>),
+    Web(jacquard::url::Url),
+    Path(markdown_weaver::CowStr<'a>),
+    Heading(markdown_weaver::CowStr<'a>),
+    Footnote(markdown_weaver::CowStr<'a>),
+}
+
+impl<'a> LinkUri<'a> {
+    pub async fn resolve<A>(dest_url: &'a str, agent: &Agent<A>) -> LinkUri<'a>
+    where
+        A: AgentSession + IdentityResolver,
+    {
+        if dest_url.starts_with('@') {
+            if let Ok(handle) = Handle::new(dest_url) {
+                if let Ok(did) = agent.resolve_handle(&handle).await {
+                    return Self::AtIdent(did, handle);
+                }
+            }
+        } else if dest_url.starts_with("did:") {
+            if let Ok(did) = Did::new(dest_url) {
+                if let Ok(doc) = agent.resolve_did_doc(&did).await {
+                    if let Ok(doc) = doc.parse_validated() {
+                        if let Some(handle) = doc.handles().first() {
+                            return Self::AtIdent(did, handle.clone());
+                        }
+                    }
+                }
+            }
+        } else if dest_url.starts_with('#') {
+            // local fragment
+            return Self::Heading(markdown_weaver::CowStr::Borrowed(dest_url));
+        } else if dest_url.starts_with('^') {
+            // footnote
+            return Self::Footnote(markdown_weaver::CowStr::Borrowed(dest_url));
+        }
+        if let Ok(url) = jacquard::url::Url::parse(dest_url) {
+            if let Some(uri) = jacquard::richtext::extract_at_uri_from_url(
+                url.as_str(),
+                jacquard::richtext::DEFAULT_EMBED_DOMAINS,
+            ) {
+                if let AtIdentifier::Handle(handle) = uri.authority() {
+                    if let Ok(did) = agent.resolve_handle(handle).await {
+                        let mut aturi = format!("at://{did}");
+                        if let Some(collection) = uri.collection() {
+                            aturi.push_str(&format!("/{}", collection));
+                            if let Some(record) = uri.rkey() {
+                                aturi.push_str(&format!("/{}", record.0));
+                            }
+                        }
+                        if let Ok(aturi) = AtUri::new_owned(aturi) {
+                            return Self::AtRecord(aturi);
+                        }
+                    }
+                    return Self::AtRecord(uri);
+                } else {
+                    return Self::AtRecord(uri);
+                }
+            } else if url.scheme() == "http" || url.scheme() == "https" {
+                return Self::Web(url);
+            }
+        }
+
+        LinkUri::Path(markdown_weaver::CowStr::Borrowed(dest_url))
+    }
+}

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;

crates/weaver-renderer/src/utils.rs

···
-use std::{fmt::Arguments, path::Path, sync::OnceLock};
+use std::{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")))]

flake.nix

···
       # cargo won't be able to find the sources for all members.
       weaver-cli = craneLib.buildPackage (individualCrateArgs
         // {
-          pname = "${name}-cli";
+          pname = "${name}";
           cargoExtraArgs = "-p ${name}-cli";
           src = fileSetForCrate ./crates/weaver-cli;
         });
···
         };
       };
 
-      devShells.default = craneLib.devShell {
-        inherit name;
-        # Inherit inputs from checks.
-        checks = self.checks.${system};
-        NIX_LD_LIBRARY_PATH = with pkgs;
-          lib.makeLibraryPath [
-            stdenv.cc.cc
-            openssl
-            # ...
-          ];
-        NIX_LD = lib.fileContents "${pkgs.stdenv.cc}/nix-support/dynamic-linker";
+      devShells.default = let
+        # dioxus-cli = pkgs.dioxus-cli.overrideAttrs (_: {
+        #   postPatch = ''
+        #     rm Cargo.lock
+        #     cp ${./Dioxus.lock} Cargo.lock
+        #   '';
+        #   cargoDeps = pkgs.rustPlatform.importCargoLock {
+        #     lockFile = ./Dioxus.lock;
+        #   };
+        # });
+        cargoLock = builtins.fromTOML (builtins.readFile ./Cargo.lock);
 
-        LD_LIBRARY_PATH = "$LD_LIBRARY_PATH:$NIX_LD_LIBRARY_PATH";
-        DATABASE_URL = "postgres://postgres:@localhost/weaver_appview";
+        wasmBindgen =
+          pkgs.lib.findFirst
+          (pkg: pkg.name == "wasm-bindgen")
+          (throw "Could not find wasm-bindgen package")
+          cargoLock.package;
 
-        # Additional dev-shell environment variables can be set directly
-        # MY_CUSTOM_DEVELOPMENT_VAR = "something else";
+        wasm-bindgen-cli = pkgs.buildWasmBindgenCli rec {
+          src = pkgs.fetchCrate {
+            pname = "wasm-bindgen-cli";
+            version = wasmBindgen.version;
+            hash = "sha256-zLPFFgnqAWq5R2KkaTGAYqVQswfBEYm9x3OPjx8DJRY=";
+          };
 
-        # Extra inputs can be added here; cargo and rustc are provided by default.
-        packages = with pkgs; [
-          cargo-hakari
-          nixd
-          alejandra
-          diesel-cli
-          postgresql
-          cargo-insta
-          jq
-        ];
-      };
+          cargoDeps = pkgs.rustPlatform.fetchCargoVendor {
+            inherit src;
+            inherit (src) pname version;
+            hash = "sha256-a2X9bzwnMWNt0fTf30qAiJ4noal/ET1jEtf5fBFj5OU=";
+          };
+        };
+      in
+        craneLib.devShell {
+          inherit name;
+          # Inherit inputs from checks.
+          checks = self.checks.${system};
+          NIX_LD_LIBRARY_PATH = with pkgs;
+            lib.makeLibraryPath [
+              stdenv.cc.cc
+              openssl
+              # ...
+            ];
+          NIX_LD = lib.fileContents "${pkgs.stdenv.cc}/nix-support/dynamic-linker";
+
+          LD_LIBRARY_PATH = "$LD_LIBRARY_PATH:$NIX_LD_LIBRARY_PATH";
+          DATABASE_URL = "postgres://postgres:@localhost/weaver_appview";
+
+          # Additional dev-shell environment variables can be set directly
+          # MY_CUSTOM_DEVELOPMENT_VAR = "something else";
+
+          # Extra inputs can be added here; cargo and rustc are provided by default.
+          packages = with pkgs; [
+            cargo-hakari
+            nixd
+            alejandra
+            diesel-cli
+            postgresql
+            cargo-insta
+            jq
+            dioxus-cli
+            wasm-bindgen-cli
+          ];
+        };
     });
 }

lexicons/embed/recordWithMedia.json

···
+{
+  "lexicon": 1,
+  "id": "sh.weaver.embed.recordWithMedia",
+  "description": "A representation of a record embedded in a Weaver record (eg, a notebook entry), alongside other compatible embeds. For example, a quote post and image, or a quote post and external URL card.",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": ["records", "media"],
+      "properties": {
+        "records": {
+          "type": "ref",
+          "ref": "sh.weaver.embed.records"
+        },
+        "media": {
+          "type": "union",
+          "refs": ["sh.weaver.embed.images", "sh.weaver.embed.external", "sh.weaver.embed.video"]
+        }
+      }
+    },
+    "view": {
+      "type": "object",
+      "required": ["record", "media"],
+      "properties": {
+        "records": {
+          "type": "ref",
+          "ref": "sh.weaver.embed.records#view"
+        },
+        "media": {
+          "type": "union",
+          "refs": ["sh.weaver.embed.images#view", "sh.weaver.embed.external#view", "sh.weaver.embed.video#view"]
+        }
+      }
+    }
+  }
+}

lexicons/sh/weaver/edit/root.json lexicons/edit/root.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": ["cid", "uri", "doc", "snapshot"],
+        "required": ["doc", "snapshot"],
         "properties": {
-          "uri": { "type": "string", "format": "at-uri" },
-          "cid": { "type": "string", "format": "cid" },
           "snapshot": {
             "type": "blob",
             "accept": ["*/*"],

lexicons/sh/weaver/embed/recordWithMedia.json

···
-{
-  "lexicon": 1,
-  "id": "sh.weaver.embed.recordWithMedia",
-  "description": "A representation of a record embedded in a Weaver record (eg, a notebook entry), alongside other compatible embeds. For example, a quote post and image, or a quote post and external URL card.",
-  "defs": {
-    "main": {
-      "type": "object",
-      "required": ["record", "media"],
-      "properties": {
-        "record": {
-          "type": "union",
-          "refs": ["app.bsky.embed.record", "sh.weaver.embed.records"]
-        },
-        "media": {
-          "type": "union",
-          "refs": [
-            "sh.weaver.embed.images",
-            "sh.weaver.embed.external",
-            "sh.weaver.embed.video",
-            "app.bsky.embed.images",
-            "app.bsky.embed.video",
-            "app.bsky.embed.external"
-          ]
-        }
-      }
-    },
-    "view": {
-      "type": "object",
-      "required": ["record", "media"],
-      "properties": {
-        "record": {
-          "type": "union",
-          "refs": ["sh.weaver.embed.records#view", "app.bsky.embed.record#view"]
-        },
-        "media": {
-          "type": "union",
-          "refs": [
-            "sh.weaver.embed.images#view",
-            "sh.weaver.embed.external#view",
-            "sh.weaver.embed.video#view",
-            "app.bsky.embed.images#view",
-            "app.bsky.embed.video#view",
-            "app.bsky.embed.external#view"
-          ]
-        }
-      }
-    }
-  }
-}

lexicons/sh/weaver/embed/records.json lexicons/embed/records.json

···
         "recordView": {
           "type": "union",
           "refs": [
-            "app.bsky.embed.images#view",
-            "app.bsky.embed.video#view",
-            "app.bsky.embed.external#view",
-            "app.bsky.embed.record#view",
-            "app.bsky.embed.recordWithMedia#view",
             "sh.weaver.embed.records#view",
             "sh.weaver.embed.images#view",
             "sh.weaver.embed.recordWithMedia#view",

lexicons/sh/weaver/publish/blob.json lexicons/publish/blob.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": ["upload"],
+        "required": ["upload", "path"],
         "properties": {
+          "path": {
+            "type": "string",
+            "description": "relative path to the blob",
+            "minLength": 1
+          },
           "upload": {
             "type": "blob",
             "description": "Reference to the uploaded file",