refactor: move lexicons into lexicon crate

Signed-off-by: tjh <did:plc:65gha4t3avpfpzmvpbwovss7>

Cargo.lock

···
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.61.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
 checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
 dependencies = [
  "crc32fast",
- "libz-rs-sys",
  "miniz_oxide",
 ]
 
···
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
 [[package]]
 name = "foreign-types"
···
 
 [[package]]
 name = "gix"
-version = "0.73.0"
+version = "0.74.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514c29cc879bdc0286b0cbc205585a49b252809eb86c69df4ce4f855ee75f635"
+checksum = "d3fd3d8b30e15352c955ae99f3497a7ee5e346a6fa2662fc9301001691c4fb7e"
 dependencies = [
  "gix-actor",
  "gix-archive",
  "gix-attributes",
+ "gix-blame",
  "gix-command",
  "gix-commitgraph",
  "gix-config",
···
  "gix-worktree",
  "gix-worktree-state",
  "gix-worktree-stream",
- "once_cell",
  "parking_lot",
  "regex",
  "signal-hook",
···
 
 [[package]]
 name = "gix-actor"
-version = "0.35.4"
+version = "0.35.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d36dcf9efe32b51b12dfa33cedff8414926124e760a32f9e7a6b5580d280967"
+checksum = "575bb2dafa4e56721c0f7e8b2da647452e6c10c69b6157b118388a132cccb892"
 dependencies = [
  "bstr",
  "gix-date",
···
 
 [[package]]
 name = "gix-archive"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be088a0e1b30abe15572ffafb3409172a3d88148e13959734f24f52112a19d6"
+checksum = "015d177dcb7c2d9efc71ab9163cfa9cc83aa3c2409a2cd57d723a3c3cfbcb4c5"
 dependencies = [
  "bstr",
  "gix-date",
···
 
 [[package]]
 name = "gix-attributes"
-version = "0.27.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45442188216d08a5959af195f659cb1f244a50d7d2d0c3873633b1cd7135f638"
+checksum = "42bbbbe6e01d238f7cf1ce7f604d742e91639006f2ac1685b008cfa55903206d"
 dependencies = [
  "bstr",
  "gix-glob",
···
 
 [[package]]
 name = "gix-bitmap"
-version = "0.2.14"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1db9765c69502650da68f0804e3dc2b5f8ccc6a2d104ca6c85bc40700d37540"
+checksum = "5e150161b8a75b5860521cb876b506879a3376d3adc857ec7a9d35e7c6a5e531"
 dependencies = [
  "thiserror",
 ]
 
 [[package]]
-name = "gix-chunk"
-version = "0.4.11"
+name = "gix-blame"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b1f1d8764958699dc764e3f727cef280ff4d1bd92c107bbf8acd85b30c1bd6f"
+checksum = "260df64cea7bf3ab6db00e8f8cd8f1f85513d69c19fadd714422a39b8e8a8617"
+dependencies = [
+ "gix-commitgraph",
+ "gix-date",
+ "gix-diff",
+ "gix-hash",
+ "gix-object",
+ "gix-revwalk",
+ "gix-trace",
+ "gix-traverse",
+ "gix-worktree",
+ "smallvec",
+ "thiserror",
+]
+
+[[package]]
+name = "gix-chunk"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c356b3825677cb6ff579551bb8311a81821e184453cbd105e2fc5311b288eeb"
 dependencies = [
  "thiserror",
 ]
 
 [[package]]
 name = "gix-command"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b31b65ca48a352ae86312b27a514a0c661935f96b481ac8b4371f65815eb196"
+checksum = "095c8367c9dc4872a7706fbc39c7f34271b88b541120a4365ff0e36366f66e62"
 dependencies = [
  "bstr",
  "gix-path",
···
 
 [[package]]
 name = "gix-commitgraph"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bb23121e952f43a5b07e3e80890336cb847297467a410475036242732980d06"
+checksum = "5b7c0f17a94a27283afce5c1c5d7b1778cacc0a70bb8affc0e38611f06ffcb2b"
 dependencies = [
  "bstr",
  "gix-chunk",
···
 
 [[package]]
 name = "gix-config"
-version = "0.46.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfb898c5b695fd4acfc3c0ab638525a65545d47706064dcf7b5ead6cdb136c0"
+checksum = "76acbe8307019b17411a3c50e181e4dd97d78a840dead884a4f2dd35a8d38f6a"
 dependencies = [
  "bstr",
  "gix-config-value",
···
  "gix-ref",
  "gix-sec",
  "memchr",
- "once_cell",
  "smallvec",
  "thiserror",
  "unicode-bom",
···
 
 [[package]]
 name = "gix-config-value"
-version = "0.15.1"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f012703eb67e263c6c1fc96649fec47694dd3e5d2a91abfc65e4a6a6dc85309"
+checksum = "7d837b93598b240624ed9b30f3a7629dc6088db60a025c90a628116a16d26719"
 dependencies = [
  "bitflags",
  "bstr",
···
 
 [[package]]
 name = "gix-credentials"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0039dd3ac606dd80b16353a41b61fc237ca5cb8b612f67a9f880adfad4be4e05"
+checksum = "86a332d35e543005d61a7d517ccc32812476309e71aac02aef52525a501f1cae"
 dependencies = [
  "bstr",
  "gix-command",
···
 
 [[package]]
 name = "gix-date"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "996b6b90bafb287330af92b274c3e64309dc78359221d8612d11cd10c8b9fe1c"
+checksum = "36911ec97d0343048c6ecbcd2dcbcc6a9adf8272845417593915d1f8514b44ee"
 dependencies = [
  "bstr",
  "itoa",
···
 
 [[package]]
 name = "gix-diff"
-version = "0.53.0"
+version = "0.54.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de854852010d44a317f30c92d67a983e691c9478c8a3fb4117c1f48626bcdea8"
+checksum = "b9844abf11a6dc5ab1d9e8670e17d35afbfebbebe216522454883140745bc68b"
 dependencies = [
  "bstr",
  "gix-attributes",
···
 
 [[package]]
 name = "gix-dir"
-version = "0.15.0"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dad34e4f373f94902df1ba1d2a1df3a1b29eacd15e316ac5972d842e31422dd7"
+checksum = "f99fb4dcba076453d791949bf3af977c5678a1cbd76740ec2cfe37e29431daf3"
 dependencies = [
  "bstr",
  "gix-discover",
···
 
 [[package]]
 name = "gix-discover"
-version = "0.41.0"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb180c91ca1a2cf53e828bb63d8d8f8fa7526f49b83b33d7f46cbeb5d79d30a"
+checksum = "9d24547153810634636471af88338240e6ab0831308cd41eb6ebfffea77811c6"
 dependencies = [
  "bstr",
  "dunce",
···
 
 [[package]]
 name = "gix-features"
-version = "0.43.1"
+version = "0.44.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd1543cd9b8abcbcebaa1a666a5c168ee2cda4dea50d3961ee0e6d1c42f81e5b"
+checksum = "4ff90017694214e1445b1baab8ca299e548cdf42c9d4588c02017c352d32652b"
 dependencies = [
  "bytes",
  "bytesize",
  "crc32fast",
  "crossbeam-channel",
- "flate2",
  "gix-path",
  "gix-trace",
  "gix-utils",
  "libc",
+ "libz-rs-sys",
  "once_cell",
  "parking_lot",
  "prodash",
···
 
 [[package]]
 name = "gix-filter"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa6571a3927e7ab10f64279a088e0dae08e8da05547771796d7389bbe28ad9ff"
+checksum = "1d1253452c9808da01eaaf9b1c4929b9982efec29ef0a668b3326b8046d9b8fb"
 dependencies = [
  "bstr",
  "encoding_rs",
···
 
 [[package]]
 name = "gix-fs"
-version = "0.16.1"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a4d90307d064fa7230e0f87b03231be28f8ba63b913fc15346f489519d0c304"
+checksum = "3f1ecd896258cdc5ccd94d18386d17906b8de265ad2ecf68e3bea6b007f6a28f"
 dependencies = [
  "bstr",
  "fastrand",
···
 
 [[package]]
 name = "gix-glob"
-version = "0.21.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b947db8366823e7a750c254f6bb29e27e17f27e457bf336ba79b32423db62cd5"
+checksum = "56089c688b74d628bdd7f38c9cadf08d39948c783decc48474cbfdf341ba68c4"
 dependencies = [
  "bitflags",
  "bstr",
···
 
 [[package]]
 name = "gix-hash"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "251fad79796a731a2a7664d9ea95ee29a9e99474de2769e152238d4fdb69d50e"
+checksum = "0732910f9595d1600a6355f37241c1960a851a7250df0e04ad0dad85a20cbf73"
 dependencies = [
  "faster-hex",
  "gix-features",
···
 
 [[package]]
 name = "gix-hashtable"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c35300b54896153e55d53f4180460931ccd69b7e8d2f6b9d6401122cdedc4f07"
+checksum = "a27d4a3ea9640da504a2657fef3419c517fd71f1767ad8935298bcc805edd195"
 dependencies = [
  "gix-hash",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.0",
  "parking_lot",
 ]
 
 [[package]]
 name = "gix-ignore"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "564d6fddf46e2c981f571b23d6ad40cb08bddcaf6fc7458b1d49727ad23c2870"
+checksum = "cd53028c6adea0b41e0ae35499542f164115c555b6c15b80778e4c22b148a3d0"
 dependencies = [
  "bstr",
  "gix-glob",
···
 
 [[package]]
 name = "gix-index"
-version = "0.41.0"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2af39fde3ce4ce11371d9ce826f2936ec347318f2d1972fe98c2e7134e267e25"
+checksum = "91c389a09b9575b6e856bf2199bd717f5bd5e37333c24575a0cf9d08c41d75d6"
 dependencies = [
  "bitflags",
  "bstr",
···
  "gix-traverse",
  "gix-utils",
  "gix-validate",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.0",
  "itoa",
  "libc",
  "memmap2",
···
 
 [[package]]
 name = "gix-lock"
-version = "18.0.0"
+version = "19.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9fa71da90365668a621e184eb5b979904471af1b3b09b943a84bc50e8ad42ed"
+checksum = "729d7857429a66023bc0c29d60fa21d0d6ae8862f33c1937ba89e0f74dd5c67f"
 dependencies = [
  "gix-tempfile",
  "gix-utils",
···
 
 [[package]]
 name = "gix-mailmap"
-version = "0.27.2"
+version = "0.27.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8982e1874a2034d7dd481bcdd6a05579ba444bcda748511eb0f8e50eb10487"
+checksum = "ef3b9794fa2545ab583e7fcd952900cdd8673fe51e57ee2a85b6728abb6bcb22"
 dependencies = [
  "bstr",
  "gix-actor",
···
 
 [[package]]
 name = "gix-negotiate"
-version = "0.21.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d58d4c9118885233be971e0d7a589f5cfb1a8bd6cb6e2ecfb0fc6b1b293c83b"
+checksum = "89e16c96e052467d64c8f75a703b78976b33b034b9ff1f1d0c056c584319b0b8"
 dependencies = [
  "bitflags",
  "gix-commitgraph",
···
 
 [[package]]
 name = "gix-object"
-version = "0.50.2"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d69ce108ab67b65fbd4fb7e1331502429d78baeb2eee10008bdef55765397c07"
+checksum = "f4d23c75c112f03724792155ff847f12df6396e2528a5f2ed26eca2cf9a11896"
 dependencies = [
  "bstr",
  "gix-actor",
···
 
 [[package]]
 name = "gix-odb"
-version = "0.70.0"
+version = "0.71.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9d7af10fda9df0bb4f7f9bd507963560b3c66cb15a5b825caf752e0eb109ac"
+checksum = "8c5f6d4ba857982cd2225de0a5d8b61d3b63a314395327f8a15943977203da08"
 dependencies = [
  "arc-swap",
  "gix-date",
···
 
 [[package]]
 name = "gix-pack"
-version = "0.60.0"
+version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8571df89bfca5abb49c3e3372393f7af7e6f8b8dbe2b96303593cef5b263019"
+checksum = "b3afaaa2205a477f5c59a5459bad9205e6de438d218d2af6f0092e19cec03a60"
 dependencies = [
  "clru",
  "gix-chunk",
···
 
 [[package]]
 name = "gix-packetline"
-version = "0.19.1"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2592fbd36249a2fea11056f7055cc376301ef38d903d157de41998335bbf1f93"
+checksum = "cd57d692b4625c2ece7634ba5d71939bbfe07bcc70eac92e10875faaf83f5316"
 dependencies = [
  "bstr",
  "faster-hex",
···
 
 [[package]]
 name = "gix-packetline-blocking"
-version = "0.19.1"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc4e706f328cd494cc8f932172e123a72b9a4711b0db5e411681432a89bd4c94"
+checksum = "d10476ed5b3c9e04113e16dbee1fa7a4690279f257a74691e85372c63588c4fd"
 dependencies = [
  "bstr",
  "faster-hex",
···
 
 [[package]]
 name = "gix-path"
-version = "0.10.20"
+version = "0.10.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06d37034a4c67bbdda76f7bcd037b2f7bc0fba0c09a6662b19697a5716e7b2fd"
+checksum = "0416b41cd00ff292af9b94b0660880c44bd2ed66828ddca9a2b333535cbb71b8"
 dependencies = [
  "bstr",
  "gix-trace",
  "gix-validate",
  "home",
- "once_cell",
  "thiserror",
 ]
 
 [[package]]
 name = "gix-pathspec"
-version = "0.12.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daedead611c9bd1f3640dc90a9012b45f790201788af4d659f28d94071da7fba"
+checksum = "d05e28457dca7c65a2dbe118869aab922a5bd382b7bb10cff5354f366845c128"
 dependencies = [
  "bitflags",
  "bstr",
···
 
 [[package]]
 name = "gix-prompt"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ffa1a7a34c81710aaa666a428c142b6c5d640492fcd41267db0740d923c7906"
+checksum = "868e6516dfa16fdcbc5f8c935167d085f2ae65ccd4c9476a4319579d12a69d8d"
 dependencies = [
  "gix-command",
  "gix-config-value",
···
 
 [[package]]
 name = "gix-protocol"
-version = "0.51.0"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12b4b807c47ffcf7c1e5b8119585368a56449f3493da93b931e1d4239364e922"
+checksum = "681901ef2f057fd1d856941f43d9f8b84a30df61f46182c0f26297b1a16f1f7f"
 dependencies = [
  "bstr",
  "gix-date",
···
 
 [[package]]
 name = "gix-quote"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a375a75b4d663e8bafe3bf4940a18a23755644c13582fa326e99f8f987d83fd"
+checksum = "e912ec04b7b1566a85ad486db0cab6b9955e3e32bcd3c3a734542ab3af084c5b"
 dependencies = [
  "bstr",
  "gix-utils",
···
 
 [[package]]
 name = "gix-ref"
-version = "0.53.1"
+version = "0.54.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b966f578079a42f4a51413b17bce476544cca1cf605753466669082f94721758"
+checksum = "b3e8559e2f6eb30785f13a689764d571d9aaf2e60603829e7504b97cae5aaaad"
 dependencies = [
  "gix-actor",
  "gix-features",
···
 
 [[package]]
 name = "gix-refspec"
-version = "0.31.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d29cae1ae31108826e7156a5e60bffacab405f4413f5bc0375e19772cce0055"
+checksum = "93147960f77695ba89b72019b789679278dd4dad6a0f9a4a5bf2fd07aba56912"
 dependencies = [
  "bstr",
  "gix-hash",
···
 
 [[package]]
 name = "gix-revision"
-version = "0.35.0"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f651f2b1742f760bb8161d6743229206e962b73d9c33c41f4e4aefa6586cbd3d"
+checksum = "235c2338044e1e901e98cc44d669574592394212803d3956b6ac025e88963512"
 dependencies = [
  "bitflags",
  "bstr",
···
 
 [[package]]
 name = "gix-revwalk"
-version = "0.21.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06e74f91709729e099af6721bd0fa7d62f243f2005085152301ca5cdd86ec02c"
+checksum = "02e2de4f91d712b1f6873477f769225fe430ffce2af8c7c85721c3ff955783b3"
 dependencies = [
  "gix-commitgraph",
  "gix-date",
···
 
 [[package]]
 name = "gix-sec"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09f7053ed7c66633b56c57bc6ed3377be3166eaf3dc2df9f1c5ec446df6fdf2c"
+checksum = "52e45952d0f94824e6ae7e4388b4cf9691cf50ca2ac544e3540858305a316ce7"
 dependencies = [
  "bitflags",
  "gix-path",
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "gix-shallow"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d936745103243ae4c510f19e0760ce73fb0f08096588fdbe0f0d7fb7ce8944b7"
+checksum = "e2374692db1ee1ffa0eddcb9e86ec218f7c4cdceda800ebc5a9fdf73a8c08223"
 dependencies = [
  "bstr",
  "gix-hash",
···
 
 [[package]]
 name = "gix-status"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a4afff9b34eeececa8bdc32b42fb318434b6b1391d9f8d45fe455af08dc2d35"
+checksum = "84e01b3762e781e3d4800dfcd25140878d704b018cf792f4a0c55a1298cfdba1"
 dependencies = [
  "bstr",
  "filetime",
···
 
 [[package]]
 name = "gix-submodule"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "657cc5dd43cbc7a14d9c5aaf02cfbe9c2a15d077cded3f304adb30ef78852d3e"
+checksum = "9bacc06333b50abc4fc06204622c2dd92850de2066bb5d421ac776d2bef7ae55"
 dependencies = [
  "bstr",
  "gix-config",
···
 
 [[package]]
 name = "gix-tempfile"
-version = "18.0.0"
+version = "19.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "666c0041bcdedf5fa05e9bef663c897debab24b7dc1741605742412d1d47da57"
+checksum = "0c413fdfca2dea768903b7ca73e46b0a8c32e4b61662c68af127bcfb7c2f7c20"
 dependencies = [
  "dashmap",
  "gix-fs",
  "libc",
- "once_cell",
  "parking_lot",
  "signal-hook",
  "signal-hook-registry",
···
 
 [[package]]
 name = "gix-trace"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2ccaf54b0b1743a695b482ca0ab9d7603744d8d10b2e5d1a332fef337bee658"
+checksum = "d35bf1c8c1a883bdbb17ed1fef49be8c751a50dc3a28a2deb4234d826eddb4bb"
 
 [[package]]
 name = "gix-transport"
-version = "0.48.0"
+version = "0.49.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f7cc0179fc89d53c54e1f9ce51229494864ab4bf136132d69db1b011741ca3"
+checksum = "bd65513315c16ec52f479858b15fc89057e5ff6342cad1ea5573789ca4448f25"
 dependencies = [
  "bstr",
  "gix-command",
···
 
 [[package]]
 name = "gix-traverse"
-version = "0.47.0"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7cdc82509d792ba0ad815f86f6b469c7afe10f94362e96c4494525a6601bdd5"
+checksum = "412126bade03a34f5d4125fd64878852718575b3b360eaae3b29970cb555e2a2"
 dependencies = [
  "bitflags",
  "gix-commitgraph",
···
 
 [[package]]
 name = "gix-url"
-version = "0.32.0"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b76a9d266254ad287ffd44467cd88e7868799b08f4d52e02d942b93e514d16f"
+checksum = "788faa4421a720200c532e4377b17214963583cef7d43f0741a299f81e6b634e"
 dependencies = [
  "bstr",
  "gix-features",
···
 
 [[package]]
 name = "gix-utils"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5351af2b172caf41a3728eb4455326d84e0d70fe26fc4de74ab0bd37df4191c5"
+checksum = "befcdbdfb1238d2854591f760a48711bed85e72d80a10e8f2f93f656746ef7c5"
 dependencies = [
  "bstr",
  "fastrand",
···
 
 [[package]]
 name = "gix-validate"
-version = "0.10.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77b9e00cacde5b51388d28ed746c493b18a6add1f19b5e01d686b3b9ece66d4d"
+checksum = "5b1e63a5b516e970a594f870ed4571a8fdcb8a344e7bd407a20db8bd61dbfde4"
 dependencies = [
  "bstr",
  "thiserror",
···
 
 [[package]]
 name = "gix-worktree"
-version = "0.42.0"
+version = "0.43.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55f625ac9126c19bef06dbc6d2703cdd7987e21e35b497bb265ac37d383877b1"
+checksum = "c5a40efab3eef5485365fee7b5df60732110bc3521af5e48c5cd1c153c48dae0"
 dependencies = [
  "bstr",
  "gix-attributes",
···
 
 [[package]]
 name = "gix-worktree-state"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ba9b17cbacc02b25801197b20100f7f9bd621db1e7fce9d3c8ab3175207bf8"
+checksum = "046efd191ff842cc22ddce61a4e8cea75ef7e3c659772de0838b2ad74b0016ef"
 dependencies = [
  "bstr",
  "gix-features",
···
 
 [[package]]
 name = "gix-worktree-stream"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f56a737cefbcd90b573cb5393d636f6dc5e0d08a8086356d8c4fcc623b49a0e8"
+checksum = "a629188d528f5ed8abe023cdbdc4d51ef19223552cd7e2808733f96163fbf79d"
 dependencies = [
  "gix-attributes",
  "gix-features",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
- "allocator-api2",
- "equivalent",
- "foldhash",
+ "foldhash 0.1.5",
 ]
 
 [[package]]
···
 version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
 
 [[package]]
 name = "heapless"
···
  "http-body-util",
  "hyper-util",
  "identity",
+ "lexicon",
  "oauth",
  "reqwest",
  "rustc-hash",
···
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
  "spin",
+]
+
+[[package]]
+name = "lexicon"
+version = "0.0.0"
+dependencies = [
+ "data-encoding",
+ "gix-hash",
+ "identity",
+ "serde",
+ "thiserror",
+ "time",
 ]
 
 [[package]]
···
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
 dependencies = [
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.61.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
  "signal-hook-registry",
  "socket2 0.6.0",
  "tokio-macros",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "windows-link"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-registry"
···
 
 [[package]]
 name = "windows-sys"
-version = "0.61.0"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e201184e40b2ede64bc2ea34968b28e33622acdbbf37104f0e4a33f7abe657aa"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows-link 0.2.0",
+ "windows-link 0.2.1",
 ]
 
 [[package]]

Cargo.toml

···
   "crates/credential_helper",
   "crates/identity",
   "crates/knot",
+  "crates/lexicon",
   "crates/oauth",
   "crates/serve_git",
   "crates/xrpc"
···
 
 [workspace.dependencies]
 identity = { path = "crates/identity" }
+lexicon = { path = "crates/lexicon" }
 oauth = { path = "crates/oauth" }
 serve_git = { path = "crates/serve_git"}
 xrpc = { path = "crates/xrpc" }
 
 anyhow = "1.0.100"
 axum = "0.8.4"
-gix = { version = "0.73.0", features = ["max-performance"] }
+data-encoding = "2.9.0"
+gix = { version = "0.74.0", features = ["max-performance"] }
 reqwest = { version = "0.12.23", features = ["json"] }
 serde = { version = "1.0.226", features = ["derive"] }
 serde_json = "1.0.145"
 thiserror = "2.0.16"
+time = { version = "0.3.43", features = ["formatting", "macros", "parsing", "serde"] }
 tracing = "0.1.41"
 url = { version = "2.5.7", features = ["serde"] }
 

crates/knot/Cargo.toml

···
 
 [dependencies]
 identity.workspace = true
+lexicon.workspace = true
 oauth.workspace = true
 serve_git.workspace = true
 xrpc.workspace = true
···
 axum-extra = { version = "0.10.1", features = ["async-read-body"] }
 bytes = "1.10.1"
 clap = { version = "4.5.47", features = ["derive", "env", "string"] }
-data-encoding = "2.9.0"
+data-encoding.workspace = true
 futures-util = "0.3.31"
 hyper-util = { version = "0.1.17", features = ["client"] }
 rustc-hash = "2.1.1"
-time = { version = "0.3.43", features = ["formatting", "macros", "parsing", "serde"] }
+time.workspace = true
 tokio = { version = "1.47.1", features = ["io-util", "macros", "net", "process", "signal", "rt-multi-thread"] }
 tokio-stream = { version = "0.1.17", features = ["time"] }
 tokio-tungstenite = "0.28.0"

crates/knot/src/convert.rs

···
-//!
-//! Utility conversions.
-//!
-use gix::date::Time;
-use time::OffsetDateTime;
-use time::UtcOffset;
-use time::error::ComponentRange;
-
-/// Convert a [`gix::date::Time`] to a [`time::OffsetDateTime`].
-///
-#[allow(unused)]
-pub fn time_to_offsetdatetime(time: &Time) -> Result<OffsetDateTime, ComponentRange> {
-    let odt = OffsetDateTime::from_unix_timestamp(time.seconds)?
-        .to_offset(UtcOffset::from_whole_seconds(time.offset)?);
-
-    Ok(odt)
-}

crates/knot/src/lib.rs

···
 pub(crate) mod atproto;
-pub(crate) mod convert;
 pub mod model;
 pub mod public;
 pub mod types;
-
-mod objectid;
-pub use objectid::ObjectId;
-
-pub mod repospec;

crates/knot/src/main.rs

···
     rt::TokioExecutor,
 };
 use identity::Resolver;
-use knot::{model::Knot, repospec::RepoSpec};
+use knot::model::Knot;
+use lexicon::extra::repopath::RepoPath;
 use reqwest::{ClientBuilder, StatusCode};
 use serde::Deserialize;
 use std::{
···
 
 #[derive(Deserialize)]
 struct Repo {
-    #[serde(with = "knot::repospec::query_param")]
-    repo: RepoSpec,
+    #[serde(with = "lexicon::extra::repopath::string")]
+    repo: RepoPath,
 }
 
 fn extract_request_id<B>(request: &Request<B>) -> Option<&str> {
···
                                 else => break,
                             }
                         }
+                        tracing::info!("/events websocket closed");
                     })
                 },
             ),
···
                     }
 
                     if let Ok(Query(Repo { repo })) = Query::try_from_uri(uri) {
-                        span.record("repo", format!("{}/{}", repo.owner, repo.name));
+                        span.record("repo", repo.to_string());
                     }
 
                     span

crates/knot/src/model.rs

···
+pub mod convert;
+pub mod errors;
+mod knot_state;
+pub mod nicediff;
+
 use crate::{
-    convert::time_to_offsetdatetime,
     model::errors::{HeadDetached, PathNotFound, RefNotFound, RepoEmpty, RepoError, RepoNotFound},
     public::{
         git::{Error, GitAuthorization, NotFound},
         xrpc::XrpcError,
     },
-    repospec::RepoSpec,
     types::sh::tangled::repo::{
-        BlobEncoding, BlobParams, BlobResponse, Branch, BranchesParams, BranchesResponse,
-        DefaultBranchResponse, Diff, DiffParams, DiffResponse, GetDefaultBranchParams, JsonBlob,
-        LogParams, LogResponse, Readme, Reference, Tag, TagParams, TagsResponse, TreeEntry,
-        TreeParams, TreeResponse,
+        blob::BlobResponse, branches::BranchesOutput, diff::DiffResponse, log::LogOutput,
+        tags::TagsOutput,
     },
 };
 use axum::{
     extract::{FromRef, FromRequestParts},
     http::request::Parts,
 };
+use convert::convert_entry;
 use gix::{Commit, ObjectId, Repository, bstr::ByteSlice as _, open::Options};
 use identity::{Did, Resolver};
+use lexicon::{
+    extra::repopath::RepoPath,
+    sh::tangled::repo::{blob, branches, diff, get_default_branch, log, refs, tags, tree},
+};
 use oauth::public_key::PublicKey;
 use reqwest::ClientBuilder;
 use serve_git::state::GitServiceState;
···
     b"readme.asciidoc",
     b"index.rst",
 ];
-
-pub mod errors;
-mod gitoxide;
-mod knot_state;
 
 #[derive(Clone)]
 pub struct Knot {
···
 pub trait RepositoryManager {
     type Error;
 
-    fn resolve_repo_path(&self, repo: &RepoSpec) -> PathBuf;
+    fn resolve_repo_path(&self, repo: &RepoPath) -> PathBuf;
 
-    fn open(&self, repo: &RepoSpec) -> Result<Repository, Self::Error>;
+    fn open(&self, repo: &RepoPath) -> Result<Repository, Self::Error>;
 
     /// Determine whether the specified account has permission to push to the
     /// specified repository.
-    fn can_push(&self, repo: &RepoSpec, did: &Did) -> impl Future<Output = bool>;
+    fn can_push(&self, repo: &RepoPath, did: &Did) -> impl Future<Output = bool>;
 }
 
 impl RepositoryManager for Knot {
     type Error = Box<gix::open::Error>;
 
-    fn resolve_repo_path(&self, repo: &RepoSpec) -> PathBuf {
+    fn resolve_repo_path(&self, repo: &RepoPath) -> PathBuf {
         let mut path = self.inner.repository_base.clone();
         path.push(repo.owner());
         path.push(repo.name());
         path
     }
 
-    fn open(&self, repo: &RepoSpec) -> Result<Repository, Self::Error> {
+    fn open(&self, repo: &RepoPath) -> Result<Repository, Self::Error> {
         let path = self.resolve_repo_path(repo);
         let repository = Options::default()
             .strict_config(true)
···
     }
 
     // Currently defers to the real knotserver's internal "/push-allowed" route.
-    async fn can_push(&self, repo: &RepoSpec, did: &Did) -> bool {
+    async fn can_push(&self, repo: &RepoPath, did: &Did) -> bool {
         use reqwest::StatusCode;
 
         let url = format!("http://localhost:5444/push-allowed?user={did}&repo={repo}");
···
 
     pub async fn get_default_branch(
         &self,
-        params: &GetDefaultBranchParams,
-    ) -> Result<DefaultBranchResponse, XrpcError> {
+        params: &get_default_branch::Input,
+    ) -> Result<get_default_branch::Output, XrpcError> {
         tokio::task::block_in_place(|| {
             let repo = self.open(&params.repo).map_err(RepoNotFound)?;
 
···
                 .shorten()
                 .to_string();
 
-            let hash = head.id().map(|id| id.into());
+            let hash = head.id().map(|id| id.detach().into());
             let when = head
-                .peel_to_commit_in_place()
+                .peel_to_commit()
                 .ok()
                 .and_then(|commit| {
                     commit
···
                         .ok()
                         .and_then(|committer| committer.time().ok())
                 })
-                .and_then(|time| time_to_offsetdatetime(&time).ok());
+                .and_then(|time| convert::time_to_offsetdatetime(&time).ok());
 
-            Ok(DefaultBranchResponse { name, hash, when })
+            Ok(get_default_branch::Output { name, hash, when })
         })
     }
 
-    pub async fn branches(&self, params: &BranchesParams) -> Result<BranchesResponse, XrpcError> {
+    pub async fn branches(&self, params: &branches::Input) -> Result<BranchesOutput, XrpcError> {
+        use crate::types::sh::tangled::repo::branches::Branch;
         tokio::task::block_in_place(|| {
             let repo = self.open(&params.repo).map_err(RepoNotFound)?;
 
···
                 .to_string();
 
             let mut branches = Vec::new();
-            for branch in repo
-                .references()?
-                .local_branches()?
-                .skip(params.cursor)
-                .take(params.limit.into())
+            for branch in repo.references()?.local_branches()?
+            // .skip(params.cursor)
+            // .take(params.limit.into())
             {
                 let Ok(branch) = branch.inspect_err(|error| tracing::error!(?error)) else {
                     continue;
···
 
                 let is_default = name == default_name;
                 branches.push(Branch {
-                    reference: Reference {
+                    reference: refs::Reference {
                         name,
                         hash: commit.id.into(),
                     },
-                    commit: commit.try_into()?,
+                    commit: convert::try_convert_commit(commit)?,
                     is_default,
                 });
             }
 
-            Ok(BranchesResponse { branches })
+            Ok(BranchesOutput { branches })
         })
     }
 
-    pub async fn log(&self, params: &LogParams) -> Result<LogResponse, XrpcError> {
+    pub async fn log(&self, params: &log::Input) -> Result<LogOutput, XrpcError> {
         tokio::task::block_in_place(|| {
             let repo = self.open(&params.repo).map_err(RepoNotFound)?;
 
-            let commit_graph = repo.commit_graph_if_enabled().unwrap();
+            let commit_graph = repo.commit_graph_if_enabled()?;
             let total = match &commit_graph {
                 Some(cg) => cg
                     .num_commits()
···
                 match commit {
                     Ok(commit) => {
                         let commit = repo.find_commit(commit.id()).map_err(RepoError)?;
-                        commits.push(commit.try_into().map_err(RepoError)?);
+                        commits.push(convert::try_convert_commit(commit).map_err(RepoError)?);
                     }
                     Err(error) => {
                         tracing::error!(?error);
···
                 }
             }
 
-            Ok(LogResponse {
+            Ok(LogOutput {
                 commits,
                 log: true,
                 total,
···
         })
     }
 
-    pub async fn tags(&self, params: &TagParams) -> Result<TagsResponse, XrpcError> {
-        // @TODO Implement cursor.
+    pub async fn tags(&self, params: &tags::Input) -> Result<TagsOutput, XrpcError> {
+        use crate::types::sh::tangled::repo::tags::{Tag, TagsOutput};
+
         tokio::task::block_in_place(|| {
             let repo = self.open(&params.repo).map_err(RepoNotFound)?;
 
···
                 )
             });
 
-            tags.truncate(params.limit);
-
-            Ok(TagsResponse { tags })
+            Ok(TagsOutput { tags })
         })
     }
 
-    pub async fn tree(&self, params: &TreeParams) -> Result<TreeResponse, XrpcError> {
+    pub async fn tree(&self, params: &tree::Input) -> Result<tree::Output, XrpcError> {
         tokio::task::block_in_place(|| {
             let repo = self.open(&params.repo).map_err(RepoNotFound)?;
             let tip = Self::resolve_rev(&repo, params.rev.as_deref())?;
···
                     .ok_or(PathNotFound(subpath.to_string_lossy()))?;
 
                 if !entry.mode().is_tree() {
-                    return Ok(TreeResponse {
+                    return Ok(tree::Output {
                         files: vec![],
                         dotdot,
                         parent: params.path.clone(),
···
                 parent = Some(subpath.to_path_buf());
             }
 
-            let mut files: Vec<TreeEntry> = vec![];
+            let mut files: Vec<tree::TreeEntry> = vec![];
             let mut readme = None;
             for entry in tree.iter() {
                 let Ok(entry) = entry else {
···
                 {
                     let mut file = repo.find_blob(entry.id())?;
                     if let Ok(contents) = String::from_utf8(file.take_data()) {
-                        readme.replace(Readme {
+                        readme.replace(tree::Readme {
                             contents,
                             filename: entry.filename().to_string(),
                         });
                     }
                 }
 
-                files.push(entry.into());
+                files.push(convert_entry(entry));
             }
 
             let files: Vec<_> = tree
                 .iter()
                 .filter_map(|entry| {
                     let entry = entry.ok()?;
-                    let file: TreeEntry = entry.try_into().ok()?;
+                    let file = convert::convert_entry(entry);
                     Some(file)
                 })
                 .collect();
 
-            Ok(TreeResponse {
+            Ok(tree::Output {
                 files,
                 dotdot,
                 parent,
···
         })
     }
 
-    pub async fn blob(&self, params: &BlobParams) -> Result<BlobResponse, XrpcError> {
+    pub async fn blob(&self, params: &blob::Input) -> Result<BlobResponse, XrpcError> {
+        use lexicon::sh::tangled::repo::blob::{Encoding, Output};
         tokio::task::block_in_place(|| {
             let repo = self.open(&params.repo).map_err(RepoNotFound)?;
             let tip = Self::resolve_rev(&repo, params.rev.as_deref())?;
···
 
             let size = data.len();
             let (content, is_binary, encoding) = match String::from_utf8(data) {
-                Ok(content) => (content, false, BlobEncoding::Utf8),
+                Ok(content) => (content, false, blob::Encoding::Utf8),
                 Err(error) => (
                     data_encoding::BASE64.encode(&error.into_bytes()),
                     true,
-                    BlobEncoding::Base64,
+                    Encoding::Base64,
                 ),
             };
 
-            Ok(BlobResponse::Json(JsonBlob {
+            Ok(BlobResponse::Json(Output {
+                rev: params.rev.as_deref().unwrap_or_default().to_owned(),
+                path: params.path.to_owned(),
                 content,
                 encoding,
+                size,
                 is_binary,
                 mime_type: "".to_string(),
-                path: params.path.to_owned(),
-                rev: params.rev.as_deref().unwrap_or_default().to_owned(),
-                size,
+                last_commit: None,
             }))
         })
     }
 
-    pub async fn diff(&self, params: &DiffParams) -> Result<DiffResponse, XrpcError> {
-        {
-            tokio::task::block_in_place(|| {
-                let repo = self.open(&params.repo).map_err(RepoNotFound)?;
-
-                let revision = match ObjectId::from_str(&params.rev) {
-                    Ok(id) => repo.find_commit(id).map_err(RefNotFound)?,
-                    Err(_) => {
-                        // Assume the refspec is a branch or tag.
-                        let mut reference =
-                            repo.find_reference(&params.rev).map_err(RefNotFound)?;
-                        reference.peel_to_commit().map_err(RefNotFound)?
-                    }
-                };
-
-                // let parent_tree = match revision.parent_ids().next() {
-                //     Some(id) => repository.find_commit(id)?.tree()?,
-                //     None => repository.empty_tree(),
-                // };
-
-                // let mut cache = repository
-                //     .diff_resource_cache(
-                //         gix::diff::blob::pipeline::Mode::ToGit,
-                //         WorktreeRoots::default(),
-                //     )
-                //     .unwrap();
-
-                // let this_tree = revision.tree()?;
-                // this_tree
-                //     .changes()?
-                //     .for_each_to_obtain_tree(&parent_tree, |change| {
-                //         tracing::debug!(?change);
-                //         if change.entry_mode().is_blob() {
-                //             println!("{}:", change.location().to_string());
-                //             let mut line_diff = change.diff(&mut cache).unwrap();
-                //             line_diff
-                //                 .resource_cache
-                //                 .options
-                //                 .algorithm
-                //                 .replace(Algorithm::Histogram);
-
-                //             let out = line_diff.lines(|_|  Ok::<_, Er>(()) )?;
-
-                //             let input = out.interned_input();
-                //             let diff = gix::diff::blob::diff(
-                //                 Algorithm::Histogram,
-                //                 &input,
-                //                 UnifiedDiff::new(
-                //                     &input,
-                //                     String::new(),
-                //                     gix::diff::blob::unified_diff::NewlineSeparator::AfterHeaderAndWhenNeeded("\n"),
-                //                     ContextSize::symmetrical(3),
-                //                 ),
-                //             ).unwrap()
-                //             .finish();
-
-                //             println!("{diff}");
-                //         }
-                //         Ok::<_, Er>(Action::Continue)
-                //     })?;
-
-                let diff = Diff {
-                    commit: revision.try_into()?,
-                    stat: Default::default(),
-                    deltas: vec![],
-                };
-
-                let response = DiffResponse {
-                    rev: params.rev.to_owned(),
-                    diff,
-                };
-
-                Ok(response)
-            })
-        }
+    pub async fn diff(&self, params: diff::Input) -> Result<DiffResponse, XrpcError> {
+        tokio::task::block_in_place(|| {
+            let repo = self.open(&params.repo).map_err(RepoNotFound)?;
+            let this_commit = Self::resolve_rev(&repo, Some(&params.rev))?;
+            let diff = nicediff::unified_diff_from_parent(this_commit).unwrap();
+            let response = DiffResponse {
+                rev: params.rev,
+                diff,
+            };
+            Ok(response)
+        })
     }
 }
 
···
         parts: &mut Parts,
     ) -> Result<tokio::process::Command, Self::Rejection> {
         use axum::extract::Path;
-        let Path(repospec) = Path::<RepoSpec>::from_request_parts(parts, &()).await?;
-        let repo = self.open(&repospec).map_err(NotFound)?;
+        let Path(repopath) = Path::<RepoPath>::from_request_parts(parts, &()).await?;
+        let repo = self.open(&repopath).map_err(NotFound)?;
         let command = serve_git::commands::upload_pack_info_refs("/usr/bin/git", repo.path());
         Ok(command)
     }
···
         parts: &mut Parts,
     ) -> Result<tokio::process::Command, Self::Rejection> {
         use axum::extract::Path;
-        let Path(repospec) = Path::<RepoSpec>::from_request_parts(parts, &()).await?;
-        let repo = self.open(&repospec).map_err(NotFound)?;
+        let Path(repopath) = Path::<RepoPath>::from_request_parts(parts, &()).await?;
+        let repo = self.open(&repopath).map_err(NotFound)?;
         let command = serve_git::commands::upload_pack("/usr/bin/git", repo.path());
         Ok(command)
     }
···
         }
 
         use axum::extract::Path;
-        let Path(repospec) = Path::<RepoSpec>::from_request_parts(parts, &()).await?;
-        if !self.can_push(&repospec, &auth.iss).await {
+        let Path(repopath) = Path::<RepoPath>::from_request_parts(parts, &()).await?;
+        if !self.can_push(&repopath, &auth.iss).await {
             tracing::error!(did = %auth.iss, "push denied");
             return Err(Error::forbidden(
                 self,
···
             ))?;
         }
 
-        let repo = self.open(&repospec).map_err(NotFound)?;
+        let repo = self.open(&repopath).map_err(NotFound)?;
         let command = serve_git::commands::receive_pack_info_refs("/usr/bin/git", repo.path());
         Ok(command)
     }
···
         }
 
         use axum::extract::Path;
-        let Path(repospec) = Path::<RepoSpec>::from_request_parts(parts, &()).await?;
-        if !self.can_push(&repospec, &auth.iss).await {
+        let Path(repopath) = Path::<RepoPath>::from_request_parts(parts, &()).await?;
+        if !self.can_push(&repopath, &auth.iss).await {
             tracing::error!(did = %auth.iss, "push denied");
             return Err(Error::forbidden(
                 self,
···
             ))?;
         }
 
-        let repo = self.open(&repospec).map_err(NotFound)?;
+        let repo = self.open(&repopath).map_err(NotFound)?;
         let command = serve_git::commands::receive_pack("/usr/bin/git", repo.path());
         Ok(command)
     }

crates/knot/src/model/convert.rs

···
+use crate::{public::xrpc::XrpcError, types::sh::tangled::repo::tags};
+use data_encoding::BASE64URL;
+use gix::bstr::ByteSlice;
+use lexicon::sh::tangled::repo::{refs, tree};
+use reqwest::StatusCode;
+use std::{borrow::Cow, collections::HashMap};
+use time::{OffsetDateTime, error::ComponentRange};
+
+#[derive(Debug, thiserror::Error)]
+pub enum ConversionError {
+    #[error("Failed to decode object: {0}")]
+    Decode(#[from] gix::objs::decode::Error),
+    #[error("Failed to parse git time: {0}")]
+    TimeParse(#[from] gix::date::parse::Error),
+    #[error("Failed to convert git time: {0}")]
+    TimeConversion(#[from] time::error::ComponentRange),
+}
+
+impl From<ConversionError> for XrpcError {
+    fn from(value: ConversionError) -> Self {
+        Self {
+            status: StatusCode::INTERNAL_SERVER_ERROR,
+            error: "RepositoryError".into(),
+            message: value.to_string().into(),
+        }
+    }
+}
+
+/// Convert a git timestamp to an [`OffsetDateTime`].
+pub fn time_to_offsetdatetime(time: &gix::date::Time) -> Result<OffsetDateTime, ComponentRange> {
+    use time::UtcOffset;
+
+    let odt = OffsetDateTime::from_unix_timestamp(time.seconds)?
+        .to_offset(UtcOffset::from_whole_seconds(time.offset)?);
+
+    Ok(odt)
+}
+
+pub fn try_convert_commit(value: gix::Commit<'_>) -> Result<refs::Commit, ConversionError> {
+    let id = value.id().detach();
+    let decoded = value.decode()?;
+    let mut merge_tag = String::default();
+    let mut extra_headers = HashMap::default();
+    for (key, value) in decoded.extra_headers {
+        match key.as_bytes() {
+            b"mergetag" => merge_tag = value.to_string(),
+            b"gpgsig" => {}
+            _ => {
+                extra_headers.insert(key.to_string(), BASE64URL.encode(value.as_bytes()));
+            }
+        }
+    }
+
+    Ok(refs::Commit {
+        hash: id.into(),
+        author: try_convert_signature(decoded.author)?,
+        committer: try_convert_signature(decoded.committer)?,
+        merge_tag,
+        pgp_signature: value.signature()?.map(|(sig, _)| sig.to_string()),
+        message: decoded.message.to_string(),
+        tree_hash: value.tree_id()?.detach().into(),
+        parent_hashes: value.parent_ids().map(|id| id.detach().into()).collect(),
+        // @TODO Review encoding parameter
+        encoding: Cow::Borrowed("UTF-8"),
+        extra_headers,
+    })
+}
+
+pub fn convert_entry(value: gix::object::tree::EntryRef<'_, '_>) -> tree::TreeEntry {
+    use gix::objs::tree::EntryKind;
+
+    let name = value.filename().to_string();
+    let mode = value.mode();
+
+    let is_file = mode.is_blob();
+    let is_subtree = mode.is_tree();
+
+    let mode_string = match mode.kind() {
+        EntryKind::Tree => "drwxr-xr-x",
+        EntryKind::Blob => "-rw-r--r--",
+        EntryKind::BlobExecutable => "-rwxr-xr-x",
+        EntryKind::Link => "----------",
+        EntryKind::Commit => "----------",
+    };
+
+    tree::TreeEntry {
+        name,
+        mode: Cow::Borrowed(mode_string),
+        is_file,
+        is_subtree,
+        ..Default::default()
+    }
+}
+
+pub fn convert_reference(value: &gix::Reference<'_>) -> refs::Reference {
+    refs::Reference {
+        name: value.name().shorten().to_string(),
+        hash: value.id().detach().into(),
+    }
+}
+
+pub fn try_convert_signature(
+    signature: gix::actor::SignatureRef<'_>,
+) -> Result<refs::Signature, ConversionError> {
+    let signature = signature.trim();
+    Ok(refs::Signature {
+        name: signature.name.to_string(),
+        email: signature.email.to_string(),
+        when: time_to_offsetdatetime(&signature.time()?)?,
+    })
+}
+
+impl TryFrom<gix::Tag<'_>> for tags::TagAnnotation {
+    type Error = gix::objs::decode::Error;
+
+    fn try_from(value: gix::Tag<'_>) -> Result<Self, Self::Error> {
+        use gix::object::Kind;
+
+        let hash = value.id.into();
+        let decoded = value.decode()?;
+
+        // cf. <https://github.com/git/git/blob/7014b55638da979331baf8dc31c4e1d697cf2d67/object.h#L97>
+        let target_type = match decoded.target_kind {
+            Kind::Commit => 1,
+            Kind::Tree => 2,
+            Kind::Blob => 3,
+            Kind::Tag => 4,
+        };
+
+        Ok(tags::TagAnnotation {
+            hash,
+            name: decoded.name.to_string(),
+            tagger: decoded
+                .tagger
+                .and_then(|tagger| try_convert_signature(tagger).ok()),
+            message: decoded.message.to_string(),
+            pgp_signature: decoded.pgp_signature.map(ToString::to_string),
+            target_type,
+            target: decoded.target().into(),
+        })
+    }
+}
+
+impl TryFrom<gix::Reference<'_>> for tags::Tag {
+    type Error = gix::objs::decode::Error;
+
+    fn try_from(mut value: gix::Reference<'_>) -> Result<Self, Self::Error> {
+        let r#ref: refs::Reference = convert_reference(&value);
+        let annotation = value
+            .peel_to_tag()
+            .ok()
+            .map(TryFrom::try_from)
+            .transpose()?;
+
+        Ok(tags::Tag { r#ref, annotation })
+    }
+}

crates/knot/src/model/gitoxide.rs

···
-//!
-//! [`TryFrom`] impls for converting Gitoxide objects into Tangled objects.
-//!
-use crate::{
-    public::xrpc::XrpcError,
-    types::sh::tangled::repo::{Commit, Reference, Signature, Tag, TagAnnotation, TreeEntry},
-};
-
-use data_encoding::BASE64URL;
-use gix::bstr::ByteSlice;
-use reqwest::StatusCode;
-use std::{borrow::Cow, collections::HashMap};
-
-#[derive(Debug, thiserror::Error)]
-pub enum ConversionError {
-    #[error("{0}")]
-    Decode(#[from] gix::objs::decode::Error),
-    #[error("{0}")]
-    TimeParse(#[from] gix::date::parse::Error),
-    #[error("{0}")]
-    TimeConversion(#[from] time::error::ComponentRange),
-}
-
-impl From<ConversionError> for XrpcError {
-    fn from(value: ConversionError) -> Self {
-        Self {
-            status: StatusCode::INTERNAL_SERVER_ERROR,
-            error: "RepositoryError".into(),
-            message: value.to_string().into(),
-        }
-    }
-}
-
-impl TryFrom<gix::actor::SignatureRef<'_>> for Signature {
-    type Error = ConversionError;
-
-    fn try_from(value: gix::actor::SignatureRef<'_>) -> Result<Self, Self::Error> {
-        let signature = value.trim();
-        Ok(Self {
-            name: signature.name.to_string(),
-            email: signature.email.to_string(),
-            when: crate::convert::time_to_offsetdatetime(&signature.time()?)?,
-        })
-    }
-}
-
-impl TryFrom<gix::Commit<'_>> for Commit {
-    type Error = ConversionError;
-
-    fn try_from(value: gix::Commit<'_>) -> Result<Self, Self::Error> {
-        let id = value.id();
-        let decoded = value.decode()?;
-        let signature = value.signature()?.map(|(sig, _)| sig.to_string());
-        let mut merge_tag = String::default();
-        let mut extra_headers = HashMap::default();
-        for (key, value) in decoded.extra_headers {
-            match key.as_bytes() {
-                b"mergetag" => merge_tag = value.to_string(),
-                b"gpgsig" => {}
-                _ => {
-                    extra_headers.insert(key.to_string(), BASE64URL.encode(value.as_bytes()));
-                }
-            }
-        }
-
-        Ok(Self {
-            hash: id.into(),
-            author: decoded.author.try_into()?,
-            committer: decoded.committer.try_into()?,
-            merge_tag,
-            signature,
-            message: decoded.message.to_string(),
-            tree_hash: value.tree_id()?.into(),
-            parent_hashes: value.parent_ids().map(|id| id.into()).collect(),
-            encoding: Cow::Borrowed("UTF-8"),
-            extra_headers,
-        })
-    }
-}
-
-impl From<gix::Reference<'_>> for Reference {
-    fn from(value: gix::Reference<'_>) -> Self {
-        Self {
-            name: value.name().shorten().to_string(),
-            hash: value.id().into(),
-        }
-    }
-}
-
-impl TryFrom<gix::Tag<'_>> for TagAnnotation {
-    type Error = gix::objs::decode::Error;
-
-    fn try_from(value: gix::Tag<'_>) -> Result<Self, Self::Error> {
-        use gix::object::Kind;
-
-        let hash = value.id.into();
-        let decoded = value.decode()?;
-
-        // cf. <https://github.com/git/git/blob/7014b55638da979331baf8dc31c4e1d697cf2d67/object.h#L97>
-        let target_type = match decoded.target_kind {
-            Kind::Commit => 1,
-            Kind::Tree => 2,
-            Kind::Blob => 3,
-            Kind::Tag => 4,
-        };
-
-        Ok(Self {
-            hash,
-            name: decoded.name.to_string(),
-            tagger: decoded.tagger.and_then(|tagger| tagger.try_into().ok()),
-            message: decoded.message.to_string(),
-            signature: decoded.pgp_signature.map(ToString::to_string),
-            target_type,
-            target: decoded.target().into(),
-        })
-    }
-}
-
-impl TryFrom<gix::Reference<'_>> for Tag {
-    type Error = gix::objs::decode::Error;
-
-    fn try_from(mut value: gix::Reference<'_>) -> Result<Self, Self::Error> {
-        let r#ref: Reference = value.clone().into();
-        let annotation = value
-            .peel_to_tag()
-            .ok()
-            .map(TryFrom::try_from)
-            .transpose()?;
-
-        Ok(Self { r#ref, annotation })
-    }
-}
-
-impl From<gix::object::tree::EntryRef<'_, '_>> for TreeEntry {
-    fn from(value: gix::object::tree::EntryRef<'_, '_>) -> Self {
-        use gix::objs::tree::EntryKind;
-
-        let name = value.filename().to_string();
-        let mode = value.mode();
-
-        let is_file = mode.is_blob();
-        let is_subtree = mode.is_tree();
-
-        let mode_string = match mode.kind() {
-            EntryKind::Tree => "drwxr-xr-x",
-            EntryKind::Blob => "-rw-r--r--",
-            EntryKind::BlobExecutable => "-rwxr-xr-x",
-            EntryKind::Link => "----------",
-            EntryKind::Commit => "----------",
-        };
-
-        Self {
-            name,
-            mode: Cow::Borrowed(mode_string),
-            is_file,
-            is_subtree,
-            ..Default::default()
-        }
-    }
-}

crates/knot/src/model/knot_state.rs

···
 use identity::Did;
 use identity::Resolver;
 use oauth::public_key::PublicKey;
-use serde::Deserialize;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Mutex;
···
     }
 
     pub async fn fetch_public_keys(&self, did: &Did) -> anyhow::Result<Vec<PublicKey>> {
+        use lexicon::sh::tangled::PublicKey as LexiconPublicKey;
         use url::Url;
-
-        #[allow(unused)]
-        #[derive(Debug, Deserialize)]
-        #[serde(rename = "sh.tangled.publicKey", rename_all = "camelCase")]
-        pub struct ShTangledPublicKey {
-            #[serde(rename = "$type")]
-            pub r#type: String,
-            pub name: String,
-            pub key: String,
-            #[serde(alias = "created")]
-            pub created_at: String,
-        }
 
         fn list_records_url(mut pds: Url, collection: &str, repo: &Did) -> Url {
             pds.set_path("/xrpc/com.atproto.repo.listRecords");
···
             .ok_or(anyhow::anyhow!("DID document does not declare a pds"))?
             .service_endpoint;
 
-        let response: crate::atproto::Response<ShTangledPublicKey> = self
+        let response: crate::atproto::Response<LexiconPublicKey> = self
             .public_http
             .get(list_records_url(pds.clone(), "sh.tangled.publicKey", did))
             .send()

crates/knot/src/model/nicediff.rs

···
+use std::borrow::Cow;
+
+use crate::types::sh::tangled::repo::diff::{
+    Commit, Diff, Line, Name, NiceDiff, Stat, TextFragment,
+};
+use gix::{
+    Repository,
+    diff::blob::{
+        Algorithm, UnifiedDiff,
+        pipeline::{Mode, WorktreeRoots},
+        unified_diff::{ConsumeHunk, ContextSize, DiffLineKind},
+    },
+    object::tree::diff::Action,
+};
+
+#[derive(Debug, thiserror::Error)]
+enum Error {
+    #[error("{0}")]
+    Io(#[from] std::io::Error),
+    #[error("{0}")]
+    Platform(#[from] gix::diff::blob::platform::set_resource::Error),
+    #[error("{0}")]
+    Diff(#[from] gix::object::blob::diff::lines::Error<SubError>),
+}
+
+#[derive(Debug, thiserror::Error)]
+enum SubError {}
+
+#[derive(Default)]
+struct DiffHunkConsumer {
+    hunks: Vec<TextFragment>,
+}
+
+impl DiffHunkConsumer {
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            hunks: Vec::with_capacity(capacity),
+        }
+    }
+}
+
+impl ConsumeHunk for DiffHunkConsumer {
+    type Out = Vec<TextFragment>;
+
+    fn consume_hunk(
+        &mut self,
+        header: gix::diff::blob::unified_diff::HunkHeader,
+        raw_lines: &[(gix::diff::blob::unified_diff::DiffLineKind, &[u8])],
+    ) -> std::io::Result<()> {
+        let mut lines_added = 0;
+        let mut lines_deleted = 0;
+        let mut leading_context = 0;
+        let mut trailing_context = 0;
+        let lines = raw_lines
+            .iter()
+            .map(|(kind, data)| {
+                let line = String::from_utf8_lossy(data).to_string();
+                match kind {
+                    DiffLineKind::Context => {
+                        *if lines_added == 0 && lines_deleted == 0 {
+                            &mut leading_context
+                        } else {
+                            &mut trailing_context
+                        } += 1;
+                        Line::Context { line }
+                    }
+                    DiffLineKind::Remove => {
+                        lines_deleted += 1;
+                        Line::Addition { line }
+                    }
+                    DiffLineKind::Add => {
+                        lines_added += 1;
+                        Line::Deletion { line }
+                    }
+                }
+            })
+            .collect();
+
+        let hunk = TextFragment {
+            comment: "".into(),
+            old_position: header.after_hunk_start,
+            old_lines: header.after_hunk_len,
+            new_position: header.before_hunk_start,
+            new_lines: header.before_hunk_len,
+            lines,
+            lines_added,
+            lines_deleted,
+            leading_context,
+            trailing_context,
+        };
+
+        self.hunks.push(hunk);
+        Ok(())
+    }
+
+    fn finish(self) -> Self::Out {
+        self.hunks
+    }
+}
+
+/// Produce a unified diff from the first parent of the specified commit.
+///
+pub fn unified_diff_from_parent<'r>(commit: gix::Commit<'r>) -> anyhow::Result<NiceDiff> {
+    let current_tree = commit.tree()?;
+    let parent_tree = match commit.parent_ids().next() {
+        Some(id) => commit.repo.find_commit(id)?.tree()?,
+        // If the commit does not have a parent, compute the diff against an empty tree.
+        None => commit.repo.empty_tree(),
+    };
+
+    let (stat, deltas) = unified_diff(&commit.repo, &current_tree, &parent_tree)?;
+    let decoded = commit.decode()?;
+    let diff = NiceDiff {
+        commit: Commit {
+            message: decoded.message.to_string(),
+            author: super::convert::try_convert_signature(decoded.author)?,
+            this: commit.id.into(),
+            parent: commit.parent_ids().next().map(|id| id.detach().into()),
+            pgp_signature: commit
+                .signature()?
+                .map(|(sig, _)| Cow::Owned(sig.to_string()))
+                .unwrap_or(Cow::Borrowed("")),
+            committer: super::convert::try_convert_signature(decoded.committer)?,
+            tree: current_tree.id.into(),
+            change_id: decoded
+                .extra_headers()
+                .find("change-id")
+                .map(|v| Cow::Owned(v.to_string()))
+                .unwrap_or(Cow::Borrowed("")),
+        },
+        stat,
+        deltas,
+    };
+
+    Ok(diff)
+}
+
+/// Produce a unified diff between two trees.
+///
+pub fn unified_diff<'r>(
+    repo: &'r Repository,
+    this_tree: &gix::Tree<'r>,
+    parent_tree: &gix::Tree<'r>,
+) -> anyhow::Result<(Stat, Vec<Diff>)> {
+    let mut cache = repo.diff_resource_cache(Mode::ToGit, WorktreeRoots::default())?;
+
+    // let mut diffs: BTreeMap<_, Vec<DiffHunk>> = BTreeMap::default();
+    let mut deltas: Vec<Diff> = Default::default();
+    let mut insertions = 0;
+    let mut deletions = 0;
+
+    let context = 3;
+    parent_tree
+        .changes()?
+        .for_each_to_obtain_tree(&this_tree, |change| {
+            use gix::object::tree::diff::Change;
+            let mut delta = match change {
+                Change::Addition { location, .. } => Diff {
+                    name: Name {
+                        old: location.to_string(),
+                        new: location.to_string(),
+                    },
+                    text_fragments: vec![],
+                    is_binary: false,
+                    is_new: true,
+                    is_delete: false,
+                    is_copy: false,
+                    is_rename: false,
+                },
+                Change::Deletion { location, .. } => Diff {
+                    name: Name {
+                        old: location.to_string(),
+                        new: location.to_string(),
+                    },
+                    text_fragments: vec![],
+                    is_binary: false,
+                    is_new: false,
+                    is_delete: true,
+                    is_copy: false,
+                    is_rename: false,
+                },
+                Change::Modification { location, .. } => Diff {
+                    name: Name {
+                        old: location.to_string(),
+                        new: location.to_string(),
+                    },
+                    text_fragments: vec![],
+                    is_binary: false,
+                    is_new: false,
+                    is_delete: false,
+                    is_copy: false,
+                    is_rename: false,
+                },
+                Change::Rewrite {
+                    source_location,
+                    location,
+                    copy,
+                    ..
+                } => Diff {
+                    name: Name {
+                        old: source_location.to_string(),
+                        new: location.to_string(),
+                    },
+                    text_fragments: vec![],
+                    is_binary: false,
+                    is_new: false,
+                    is_delete: false,
+                    is_copy: copy,
+                    is_rename: !copy,
+                },
+            };
+
+            if change.entry_mode().is_blob() {
+                let mut line_count = 0;
+                let mut platform = change.diff(&mut cache)?;
+                let outcome = platform.lines(|_| {
+                    line_count += 1;
+                    Ok::<_, SubError>(())
+                })?;
+
+                if matches!(
+                    outcome.operation,
+                    gix::diff::blob::platform::prepare_diff::Operation::SourceOrDestinationIsBinary
+                ) {
+                    delta.is_binary = true;
+                    deltas.push(delta);
+                    return Ok(Action::Continue);
+                }
+
+                let input = outcome.interned_input();
+                let hunks = gix::diff::blob::diff(
+                    Algorithm::Histogram,
+                    &input,
+                    UnifiedDiff::new(
+                        &input,
+                        DiffHunkConsumer::with_capacity(line_count),
+                        ContextSize::symmetrical(context),
+                    ),
+                )?;
+
+                tracing::debug!(prealloc = %line_count, outcome = %hunks.len());
+                insertions += hunks.iter().map(|hunk| hunk.lines_added).sum::<u32>();
+                deletions += hunks.iter().map(|hunk| hunk.lines_deleted).sum::<u32>();
+                delta.text_fragments = hunks;
+                deltas.push(delta);
+            }
+            Ok::<_, Error>(Action::Continue)
+        })?;
+
+    let stat = Stat {
+        files_changed: deltas.len() as u32,
+        insertions,
+        deletions,
+    };
+
+    deltas.sort_by_cached_key(|d| d.name.old.clone());
+    Ok((stat, deltas))
+}

crates/knot/src/objectid.rs crates/lexicon/src/extra/objectid.rs

···
 #[doc(hidden)]
 pub struct Array;
 
+/// An object ID that can serialized as a hex-string or an array of integers.
+///
+/// This only exists because knotserver uses both representations.
+///
 #[derive(Clone, PartialEq, Eq)]
 pub struct ObjectId<E = Hex> {
-    inner: gix::ObjectId,
+    inner: gix_hash::ObjectId,
     enc: PhantomData<E>,
 }
 
 impl<E> ObjectId<E> {
-    pub fn id(&self) -> gix::ObjectId {
+    pub fn id(&self) -> gix_hash::ObjectId {
         self.inner
     }
 }
···
     #[inline]
     fn default() -> Self {
         Self {
-            inner: gix::ObjectId::null(gix::hash::Kind::Sha1),
+            inner: gix_hash::ObjectId::null(gix_hash::Kind::Sha1),
             enc: PhantomData,
         }
     }
···
     }
 }
 
-impl<E> From<gix::ObjectId> for ObjectId<E> {
+impl<E> From<gix_hash::ObjectId> for ObjectId<E> {
     #[inline]
-    fn from(value: gix::ObjectId) -> Self {
+    fn from(value: gix_hash::ObjectId) -> Self {
         Self {
             inner: value,
             enc: PhantomData,
···
     }
 }
 
-impl<E> From<ObjectId<E>> for gix::ObjectId {
+impl<E> From<ObjectId<E>> for gix_hash::ObjectId {
     #[inline]
     fn from(value: ObjectId<E>) -> Self {
         value.inner
-    }
-}
-
-impl<E> From<gix::Id<'_>> for ObjectId<E> {
-    #[inline]
-    fn from(value: gix::Id<'_>) -> Self {
-        Self {
-            inner: value.detach(),
-            enc: PhantomData,
-        }
     }
 }
 
···
 }
 
 impl FromStr for ObjectId<Hex> {
-    type Err = gix::hash::decode::Error;
+    type Err = gix_hash::decode::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let id = gix::ObjectId::from_hex(s.as_bytes())?;
+        let id = gix_hash::ObjectId::from_hex(s.as_bytes())?;
         Ok(Self {
             inner: id,
             enc: PhantomData,

crates/knot/src/public.rs

···
-use crate::model::Knot;
-use axum::{
-    Router,
-    extract::{WebSocketUpgrade, ws::WebSocket},
-};
-use std::time::Duration;
-use tokio::time::Instant;
-
 pub mod git;
 pub mod xrpc;
 
-pub fn router() -> Router<Knot> {
-    Router::new()
+use crate::model::Knot;
+
+pub fn router() -> axum::Router<Knot> {
+    axum::Router::new()
         .without_v07_checks()
-        // .route("/events", axum::routing::get(events_handler))
         .nest("/xrpc", xrpc::router())
         .nest("/{owner}/{name}", serve_git::router())
-}
-
-pub async fn events_handler(ws: WebSocketUpgrade) -> axum::response::Response {
-    ws.on_upgrade(handle_events_socket)
-}
-
-pub async fn handle_events_socket(mut socket: WebSocket) {
-    use axum::extract::ws::Message;
-
-    let start = Instant::now();
-    let mut timeout = tokio::time::interval(Duration::from_secs(45));
-
-    // The first tick of an interval always resolves immediately.
-    timeout.tick().await;
-
-    tracing::trace!(?socket, "new websocket connection");
-    loop {
-        let message = tokio::select! {
-            now = timeout.tick() => {
-                let diff = now.saturating_duration_since(start);
-                let payload = format!("{}", diff.as_millis());
-                if let Err(error) = socket.send(Message::Ping(payload.into())).await {
-                    tracing::error!(?error);
-                    break;
-                }
-                continue;
-            }
-            Some(message) = socket.recv() => match message {
-                Ok(message) => message,
-                Err(error) => {
-                    tracing::error!(?error);
-                    break;
-                }
-            }
-        };
-
-        match message {
-            Message::Pong(payload) => match std::str::from_utf8(&payload) {
-                Ok(payload) => tracing::debug!(%payload, "received pong"),
-                Err(error) => {
-                    tracing::error!(?error, ?payload, "received non-utf8 payload in pong")
-                }
-            },
-            Message::Close(_) => {
-                tracing::debug!("client closed connection");
-                break;
-            }
-            Message::Text(payload) => {
-                tracing::info!(payload = payload.as_str(), "received message from client");
-            }
-            _ => {} //
-        }
-    }
 }

crates/knot/src/public/git/helpers.rs

···
-use std::ffi::OsStr;
-
-trait SetEnv {
-    fn env<K, V>(&mut self, key: K, val: V) -> &mut Self
-    where
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>;
-}
-
-macro_rules! impl_set_env {
-    ($ty:ty) => {
-        impl SetEnv for $ty {
-            fn env<K, V>(&mut self, key: K, val: V) -> &mut Self
-            where
-                K: AsRef<OsStr>,
-                V: AsRef<OsStr>,
-            {
-                Self::env(self, key, val)
-            }
-        }
-    };
-}
-
-impl_set_env!(std::process::Command);
-impl_set_env!(tokio::process::Command);
-
-pub trait SetOptionEnv {
-    /// Inserts or updates an environment variable mapping if, and only if,
-    /// `val` is [`Some`].
-    fn option_env<K, V>(&mut self, key: K, val: Option<V>) -> &mut Self
-    where
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>;
-}
-
-impl<T: SetEnv> SetOptionEnv for T {
-    fn option_env<K, V>(&mut self, key: K, val: Option<V>) -> &mut Self
-    where
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>,
-    {
-        if let Some(val) = val {
-            self.env(key, val);
-        }
-        self
-    }
-}

crates/knot/src/public/xrpc.rs

···
         .merge(sh::tangled::knot::version())
         .merge(sh::tangled::repo::blob())
         .merge(sh::tangled::repo::branches())
-        // .merge(sh::tangled::repo::diff())
+        .merge(sh::tangled::repo::diff())
         .merge(sh::tangled::repo::get_default_branch())
         .merge(sh::tangled::repo::languages())
         .merge(sh::tangled::repo::log())
···
 ise!(std::io::Error);
 ise!(gix::diff::blob::platform::set_resource::Error);
 ise!(gix::diff::options::init::Error);
+ise!(gix::repository::diff_resource_cache::Error);
 ise!(gix::object::commit::Error);
+ise!(gix::objs::decode::Error);
 ise!(gix::object::find::existing::Error);
 ise!(gix::object::find::existing::with_conversion::Error);
 ise!(gix::object::tree::diff::for_each::Error);
···
 ise!(gix::reference::iter::init::Error);
 ise!(gix::reference::head_tree::Error);
 ise!(gix::reference::find::existing::Error, StatusCode::NOT_FOUND);
+ise!(gix::repository::commit_graph_if_enabled::Error);

crates/knot/src/public/xrpc/sh/tangled.rs

···
-use crate::{model::Knot, types::sh::tangled::Owner};
+use crate::model::Knot;
 use axum::{
     Json,
     extract::{FromRef, State},
 };
+use lexicon::sh::tangled::OwnerOutput;
 
 pub mod knot;
 pub mod repo;
 
 #[xrpc::query("sh.tangled.owner")]
-#[tracing::instrument]
-pub async fn owner(State(knot): State<Knot>) -> Json<Owner>
+pub async fn owner(State(knot): State<Knot>) -> Json<OwnerOutput>
 where
     Knot: FromRef<S>,
 {
-    Owner::new(knot.owner().clone()).into()
+    OwnerOutput {
+        owner: knot.owner().clone(),
+    }
+    .into()
 }

crates/knot/src/public/xrpc/sh/tangled/knot.rs

···
 use axum::Json;
-
-/// Response type for 'sh.tangled.knot.version'.
-#[derive(Debug, serde::Serialize)]
-pub struct Version {
-    pub version: &'static str,
-}
+use lexicon::sh::tangled::knot::VersionOutput;
 
 #[xrpc::query("sh.tangled.knot.version")]
-pub async fn version() -> Json<Version> {
-    Json(Version {
-        version: concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION")),
+pub async fn version() -> Json<VersionOutput> {
+    Json(VersionOutput {
+        version: concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION")).into(),
     })
 }

crates/knot/src/public/xrpc/sh/tangled/repo.rs

···
 use crate::{
     model::{Knot, errors::InvalidRequest},
     public::xrpc::XrpcError,
-    types::sh::tangled::repo::*,
+    types::sh::tangled::repo::{
+        branches::BranchesOutput, diff::DiffResponse, log::LogOutput, tags::TagsOutput,
+    },
 };
 use axum::{
     Json,
     extract::{FromRef, Query, State},
     response::{IntoResponse, Response},
 };
+use lexicon::sh::tangled::repo::{
+    blob, branches, diff, get_default_branch, languages, log, tags, tree,
+};
 
 type Result<T> = std::result::Result<Json<T>, XrpcError>;
 
 #[xrpc::query("sh.tangled.repo.getDefaultBranch")]
-#[tracing::instrument]
+#[tracing::instrument(skip(knot))]
 pub async fn get_default_branch(
     State(knot): State<Knot>,
-    Query(params): Query<GetDefaultBranchParams>,
-) -> Result<DefaultBranchResponse>
+    Query(params): Query<get_default_branch::Input>,
+) -> Result<get_default_branch::Output>
 where
     Knot: FromRef<S>,
 {
···
 }
 
 #[xrpc::query("sh.tangled.repo.branches")]
-#[tracing::instrument]
+#[tracing::instrument(skip(knot))]
 pub async fn branches(
     State(knot): State<Knot>,
-    Query(params): Query<BranchesParams>,
-) -> Result<BranchesResponse>
+    Query(params): Query<branches::Input>,
+) -> Result<BranchesOutput>
 where
     Knot: FromRef<S>,
 {
···
 }
 
 #[xrpc::query("sh.tangled.repo.log")]
-#[tracing::instrument]
-pub async fn log(State(knot): State<Knot>, Query(params): Query<LogParams>) -> Result<LogResponse>
+#[tracing::instrument(skip(knot))]
+pub async fn log(State(knot): State<Knot>, Query(params): Query<log::Input>) -> Result<LogOutput>
 where
     Knot: FromRef<S>,
 {
···
 }
 
 #[xrpc::query("sh.tangled.repo.tags")]
-#[tracing::instrument]
-pub async fn tags(State(knot): State<Knot>, Query(params): Query<TagParams>) -> Result<TagsResponse>
+#[tracing::instrument(skip(knot))]
+pub async fn tags(State(knot): State<Knot>, Query(params): Query<tags::Input>) -> Result<TagsOutput>
 where
     Knot: FromRef<S>,
 {
···
 }
 
 #[xrpc::query("sh.tangled.repo.tree")]
-#[tracing::instrument]
+#[tracing::instrument(skip(knot))]
 pub async fn tree(
     State(knot): State<Knot>,
-    Query(params): Query<TreeParams>,
-) -> Result<TreeResponse>
+    Query(params): Query<tree::Input>,
+) -> Result<tree::Output>
 where
     Knot: FromRef<S>,
 {
···
 }
 
 #[xrpc::query("sh.tangled.repo.blob")]
-#[tracing::instrument]
+#[tracing::instrument(skip(knot))]
 pub async fn blob(
     State(knot): State<Knot>,
-    Query(params): Query<BlobParams>,
+    Query(params): Query<blob::Input>,
 ) -> std::result::Result<Response, XrpcError>
 where
     Knot: FromRef<S>,
 {
+    use crate::types::sh::tangled::repo::blob::BlobResponse;
     match knot.blob(&params).await? {
         BlobResponse::Json(blob) => Ok(Json(blob).into_response()),
         BlobResponse::Raw(blob) => Ok(blob.into_response()),
···
 }
 
 #[xrpc::query("sh.tangled.repo.languages")]
-#[tracing::instrument]
-pub async fn languages() -> Json<Languages> {
+#[tracing::instrument(skip(_knot))]
+pub async fn languages(
+    State(_knot): State<Knot>,
+    Query(params): Query<languages::Input>,
+) -> Json<languages::Output>
+where
+    Knot: FromRef<S>,
+{
     Default::default()
 }
 
 #[xrpc::query("sh.tangled.repo.diff")]
-#[tracing::instrument]
-pub async fn diff(
+#[tracing::instrument(skip(knot))]
+pub async fn diff<S>(
     State(knot): State<Knot>,
-    Query(params): Query<DiffParams>,
+    Query(params): Query<diff::Input>,
 ) -> Result<DiffResponse>
 where
     Knot: FromRef<S>,
 {
-    Ok(knot.diff(&params).await?.into())
+    Ok(knot.diff(params).await?.into())
 }

crates/knot/src/repospec.rs

···
-use serde::{Deserialize, Serialize};
-use std::str::FromStr;
-
-/// Repository path specifier.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
-#[serde(try_from = "UnvalidatedRepoSpec")]
-pub struct RepoSpec {
-    /// DID of the repository owner
-    pub owner: Box<str>,
-
-    /// Repository name
-    pub name: Box<str>,
-}
-
-#[derive(Deserialize)]
-struct UnvalidatedRepoSpec {
-    pub owner: Box<str>,
-    pub name: Box<str>,
-}
-
-impl TryFrom<UnvalidatedRepoSpec> for RepoSpec {
-    type Error = RepoSpecError;
-
-    #[inline]
-    fn try_from(
-        UnvalidatedRepoSpec { owner, name }: UnvalidatedRepoSpec,
-    ) -> Result<Self, Self::Error> {
-        Self::from_parts(owner, name)
-    }
-}
-
-impl RepoSpec {
-    pub fn from_parts(
-        owner: impl Into<Box<str>>,
-        name: impl Into<Box<str>>,
-    ) -> Result<Self, RepoSpecError> {
-        let owner = owner.into();
-        let name = name.into();
-
-        validate(owner.as_ref())?;
-        validate(name.as_ref())?;
-
-        Ok(Self { owner, name })
-    }
-
-    pub const fn owner(&self) -> &str {
-        &self.owner
-    }
-
-    pub const fn name(&self) -> &str {
-        &self.name
-    }
-}
-
-impl std::fmt::Display for RepoSpec {
-    #[inline]
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}/{}", self.owner, self.name)
-    }
-}
-
-impl FromStr for RepoSpec {
-    type Err = RepoSpecError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let Some((owner, name)) = s.split_once('/') else {
-            return Err(RepoSpecError::Format);
-        };
-
-        validate(owner)?;
-        validate(name)?;
-
-        Ok(Self {
-            owner: owner.into(),
-            name: name.into(),
-        })
-    }
-}
-
-pub mod query_param {
-    //! Serialize/Deserialize a `RepoSpec` from a string.
-    //!
-    //! # Example
-    //!
-    //! ```rust,no_run
-    //! # use knot::repospec::RepoSpec;
-    //! #[derive(serde::Deserialize)]
-    //! struct Params {
-    //!     #[serde(with = "knot::repospec::query_param")]
-    //!     repo: RepoSpec,
-    //! }
-    //! ```
-    //!
-    use super::RepoSpec;
-    use serde::{Deserialize, Deserializer, Serializer};
-    use std::{borrow::Cow, str::FromStr};
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<RepoSpec, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = <Cow<str>>::deserialize(deserializer)?;
-        let repo = RepoSpec::from_str(&s).map_err(serde::de::Error::custom)?;
-        Ok(repo)
-    }
-
-    #[allow(unused)]
-    pub fn serialize<S>(v: &RepoSpec, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&format!("{}/{}", v.owner(), v.name()))
-    }
-}
-
-fn validate(name: &str) -> Result<(), RepoSpecError> {
-    static FORBIDDEN_SUBSTRINGS: &[&str] = &[".."];
-    static FORBIDDEN_PREFIXES: &[&str] = &[".", "-"];
-    static ACCEPTED_SYMBOLS: &[char] = &['.', '-', '_', ':'];
-
-    if name.is_empty() {
-        return Err(RepoSpecError::Empty);
-    }
-
-    for value in name.chars() {
-        if !(value.is_ascii_alphanumeric() || ACCEPTED_SYMBOLS.contains(&value)) {
-            return Err(RepoSpecError::Character { value });
-        }
-    }
-
-    for substring in FORBIDDEN_SUBSTRINGS {
-        if name.contains(substring) {
-            return Err(RepoSpecError::Substring { substring });
-        }
-    }
-
-    for prefix in FORBIDDEN_PREFIXES {
-        if name.starts_with(prefix) {
-            return Err(RepoSpecError::Prefix { prefix });
-        }
-    }
-
-    Ok(())
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum RepoSpecError {
-    #[error("expected a repository specifier in form '{{owner}}/{{name}}'")]
-    Format,
-    #[error("repository name cannot be empty")]
-    Empty,
-    #[error("invalid character in repository name: '{value}'")]
-    Character { value: char },
-    #[error("invalid sub-string in repository name: '{substring}'")]
-    Substring { substring: &'static str },
-    #[error("invalid prefix for respository name: '{prefix}'")]
-    Prefix { prefix: &'static str },
-}
-
-#[cfg(test)]
-mod tests {
-    use axum::{
-        Json, Router,
-        body::Body,
-        extract::{Path, Query},
-        http::{Request, Response},
-        routing,
-    };
-    use http_body_util::BodyExt as _;
-    use serde::Deserialize;
-    use tower::ServiceExt as _;
-
-    use super::RepoSpec;
-
-    const SAMPLE_OWNER: &str = "did:plc:65gha4t3avpfpzmvpbwovss7";
-    const SAMPLE_NAME: &str = "gordian";
-
-    async fn check_response(res: Response<Body>) {
-        let body = res.into_body().collect().await.unwrap();
-        let repo: RepoSpec = serde_json::from_slice(&body.to_bytes()).unwrap();
-
-        assert_eq!(repo.owner.as_ref(), SAMPLE_OWNER);
-        assert_eq!(repo.name.as_ref(), SAMPLE_NAME);
-    }
-
-    #[tokio::test]
-    async fn extract_from_query() {
-        #[derive(Deserialize)]
-        struct Params {
-            #[serde(with = "super::query_param")]
-            repo: RepoSpec,
-        }
-
-        let res = Router::new()
-            .route(
-                "/something",
-                routing::get(async |Query(Params { repo }): Query<Params>| Json(repo)),
-            )
-            .oneshot(
-                Request::builder()
-                    .uri(format!("/something?repo={SAMPLE_OWNER}/{SAMPLE_NAME}"))
-                    .body(Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        check_response(res).await;
-    }
-
-    #[tokio::test]
-    async fn extract_from_path() {
-        let res = Router::new()
-            .route(
-                "/{owner}/{name}",
-                routing::get(async |Path(repo): Path<RepoSpec>| Json(repo)),
-            )
-            .oneshot(
-                Request::builder()
-                    .uri(format!("/{SAMPLE_OWNER}/{SAMPLE_NAME}"))
-                    .body(Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        check_response(res).await;
-    }
-
-    #[tokio::test]
-    async fn extract_from_path_backwards() {
-        // Ensure we are extracting placeholders by name not position.
-
-        let res = Router::new()
-            .route(
-                "/{name}/{owner}",
-                routing::get(async |Path(repo): Path<RepoSpec>| Json(repo)),
-            )
-            .oneshot(
-                Request::builder()
-                    .uri(format!("/{SAMPLE_NAME}/{SAMPLE_OWNER}"))
-                    .body(Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        check_response(res).await;
-    }
-}

crates/knot/src/revspec.rs

···
-use axum::{
-    extract::{FromRequestParts, Query, rejection::QueryRejection},
-    http::request::Parts,
-};
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize)]
-pub struct RevSpec {
-    pub r#ref: String,
-}
-
-impl<S: Send + Sync> FromRequestParts<S> for RevSpec {
-    type Rejection = QueryRejection;
-
-    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
-        let Query(revspec) = Query::from_request_parts(parts, state).await?;
-        Ok(revspec)
-    }
-}
-
-impl RevSpec {
-    //
-}

crates/knot/src/types.rs

···
 pub mod sh {
     pub mod tangled {
-        use identity::Did;
-        use serde::{Deserialize, Serialize};
-        use time::OffsetDateTime;
-
-        /// Response for `sh.tangled.owner`.
-        #[derive(Debug, Serialize)]
-        pub struct Owner {
-            pub owner: Did,
-        }
-
-        impl Owner {
-            pub fn new(owner: Did) -> Self {
-                Self { owner }
-            }
-        }
-
-        /// Lexicon definition `sh.tangled.repo`
-        #[derive(Debug, Deserialize)]
-        #[serde(rename_all = "camelCase")]
-        pub struct Repo {
-            #[serde(rename = "$type")]
-            pub typ: String,
-            pub knot: String,
-            pub name: String,
-            #[serde(default)]
-            pub labels: Vec<String>,
-            #[serde(with = "time::serde::rfc3339")]
-            pub created_at: OffsetDateTime,
-        }
-
         pub mod repo {
-            use crate::{ObjectId, objectid::Array, repospec::RepoSpec};
-            use serde::{Deserialize, Serialize};
-            use std::{borrow::Cow, collections::HashMap, path::PathBuf};
-            use time::OffsetDateTime;
+            pub mod blob {
+                use lexicon::sh::tangled::repo::blob;
 
-            #[derive(Debug, Deserialize)]
-            pub struct GetDefaultBranchParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
+                #[derive(Debug)]
+                pub enum BlobResponse {
+                    Json(blob::Output),
+                    Raw(Vec<u8>),
+                }
             }
 
-            /// Response type for the `sh.tangled.repo.getDefaultBranch` query.
-            #[derive(Debug, Default, Serialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct DefaultBranchResponse {
-                /// Short-name of the default branch.
-                pub name: String,
+            pub mod branches {
+                use lexicon::sh::tangled::repo::refs;
+                use serde::Serialize;
 
-                /// ID of the most recent commit on the default branch
-                //
-                // @NOTE Official knotserver always returns an empty string.
-                #[serde(skip_serializing_if = "Option::is_none")]
-                pub hash: Option<ObjectId>,
+                /// Output of `sh.tangled.repo.branches` query.
+                #[derive(Debug, Default, Serialize)]
+                #[serde(rename_all = "camelCase")]
+                pub struct BranchesOutput {
+                    #[serde(skip_serializing_if = "Vec::is_empty")]
+                    pub branches: Vec<Branch>,
+                }
 
-                /// Timestamp of the most recent commit on the default branch
-                //
-                // @NOTE Official knotserver always returns the unix epoch.
-                #[serde(
-                    with = "time::serde::rfc3339::option",
-                    skip_serializing_if = "Option::is_none"
-                )]
-                pub when: Option<OffsetDateTime>,
+                #[derive(Debug, Serialize)]
+                #[serde(rename_all = "camelCase")]
+                pub struct Branch {
+                    pub reference: refs::Reference,
+                    pub commit: refs::Commit,
+                    #[serde(rename = "is_deafult")]
+                    pub is_default: bool,
+                }
             }
 
-            #[derive(Debug, Default, Serialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct Reference {
-                /// Short-name of the reference.
-                pub name: String,
+            pub mod diff {
+                use lexicon::{extra::objectid::ObjectId, sh::tangled::repo::refs};
+                use serde::Serialize;
+                use std::borrow::Cow;
 
-                // @TODO What is this for?
-                pub hash: ObjectId,
+                #[derive(Debug, Serialize)]
+                pub struct DiffResponse {
+                    #[serde(rename = "ref")]
+                    pub rev: Box<str>,
+                    pub diff: NiceDiff,
+                }
+
+                /// Unified diff replicating Tangled's `NiceDiff` structure.
+                ///
+                /// See: <https://tangled.org/@tangled.org/core/blob/master/types/diff.go#L44>
+                #[derive(Debug, Serialize)]
+                pub struct NiceDiff {
+                    pub commit: Commit,
+                    pub stat: Stat,
+                    #[serde(rename = "diff")]
+                    pub deltas: Vec<Diff>,
+                }
+
+                #[derive(Debug, Serialize)]
+                pub struct Commit {
+                    pub message: String,
+                    pub author: refs::Signature,
+                    pub this: ObjectId,
+                    #[serde(skip_serializing_if = "Option::is_none")]
+                    pub parent: Option<ObjectId>,
+                    #[serde(default)]
+                    pub pgp_signature: Cow<'static, str>,
+                    pub committer: refs::Signature,
+                    pub tree: ObjectId,
+                    #[serde(default)]
+                    pub change_id: Cow<'static, str>,
+                }
+
+                #[derive(Debug, Default, Serialize)]
+                pub struct Stat {
+                    pub files_changed: u32,
+                    pub insertions: u32,
+                    pub deletions: u32,
+                }
+
+                #[derive(Debug, Default, Serialize)]
+                pub struct Diff {
+                    pub name: Name,
+                    pub text_fragments: Vec<TextFragment>,
+                    pub is_binary: bool,
+                    pub is_new: bool,
+                    pub is_delete: bool,
+                    pub is_copy: bool,
+                    pub is_rename: bool,
+                }
+
+                #[derive(Debug, Default, Serialize)]
+                pub struct Name {
+                    pub old: String,
+                    pub new: String,
+                }
+
+                #[derive(Debug, Default, Serialize)]
+                #[serde(rename_all = "PascalCase")]
+                pub struct TextFragment {
+                    #[serde(skip_serializing_if = "str::is_empty")]
+                    pub comment: Cow<'static, str>,
+                    pub old_position: u32,
+                    pub old_lines: u32,
+                    pub new_position: u32,
+                    pub new_lines: u32,
+                    pub lines_added: u32,
+                    pub lines_deleted: u32,
+                    pub leading_context: u32,
+                    pub trailing_context: u32,
+                    #[serde(skip_serializing_if = "Vec::is_empty")]
+                    pub lines: Vec<Line>,
+                }
+
+                #[derive(Debug)]
+                pub enum Line {
+                    Context { line: String },
+                    Addition { line: String },
+                    Deletion { line: String },
+                }
+
+                // Manual impl because this enum is tagged with an integer.
+                impl Serialize for Line {
+                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                    where
+                        S: serde::Serializer,
+                    {
+                        #[derive(Serialize)]
+                        #[serde(rename_all = "PascalCase")]
+                        struct IntTagged<'a> {
+                            op: u8,
+                            line: &'a str,
+                        }
+
+                        match self {
+                            Self::Context { line } => IntTagged { op: 0, line },
+                            Self::Addition { line } => IntTagged { op: 1, line },
+                            Self::Deletion { line } => IntTagged { op: 2, line },
+                        }
+                        .serialize(serializer)
+                    }
+                }
             }
 
-            /// Git commit signature (ie. the author or committer).
-            #[derive(Debug, Serialize)]
-            #[serde(rename_all = "PascalCase")]
-            pub struct Signature {
-                pub name: String,
-                pub email: String,
-                #[serde(with = "time::serde::rfc3339")]
-                pub when: OffsetDateTime,
+            pub mod log {
+                use lexicon::sh::tangled::repo::refs;
+                use serde::Serialize;
+
+                #[derive(Debug, Serialize)]
+                pub struct LogOutput {
+                    pub commits: Vec<refs::Commit>,
+                    pub log: bool,
+                    pub total: usize,
+                    pub page: usize,
+                    pub per_page: u16,
+                }
             }
 
-            #[derive(Debug, Serialize)]
-            #[serde(rename_all = "PascalCase")]
-            pub struct Commit {
-                pub hash: ObjectId<Array>,
-                pub author: Signature,
-                pub committer: Signature,
-                pub merge_tag: String,
-                #[serde(rename = "PGPSignature")]
-                pub signature: Option<String>,
-                pub message: String,
-                pub tree_hash: ObjectId<Array>,
-                pub parent_hashes: Vec<ObjectId<Array>>,
-                pub encoding: Cow<'static, str>,
-                /// Non-standard object headers. Values are always base64 encoded.
-                pub extra_headers: HashMap<String, String>,
-            }
+            pub mod tags {
+                use lexicon::{
+                    extra::objectid::{Array, ObjectId},
+                    sh::tangled::repo::refs,
+                };
+                use serde::Serialize;
 
-            #[derive(Debug, Serialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct Branch {
-                pub reference: Reference,
-                pub commit: Commit,
-                #[serde(rename = "is_deafult")]
-                pub is_default: bool,
-            }
+                /// Output of `sh.tangled.repo.tags` query.
+                ///
+                /// This is not defined in the lexicon, but models what knotserver currently
+                /// produces.
+                #[derive(Debug, Serialize)]
+                pub struct TagsOutput {
+                    pub tags: Vec<Tag>,
+                }
 
-            #[derive(Debug, Deserialize)]
-            pub struct BranchesParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
-                #[serde(default = "branches_limit_default")]
-                pub limit: u16,
-                #[serde(default)]
-                pub cursor: usize,
-            }
+                #[derive(Debug, Serialize)]
+                #[serde(rename_all = "PascalCase")]
+                pub struct TagAnnotation {
+                    pub hash: ObjectId<Array>,
+                    pub name: String,
+                    pub tagger: Option<refs::Signature>,
+                    pub message: String,
+                    #[serde(rename = "PGPSignature")]
+                    pub pgp_signature: Option<String>,
+                    pub target_type: i32,
+                    pub target: ObjectId<Array>,
+                }
 
-            const fn branches_limit_default() -> u16 {
-                50
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct BranchesResponse {
-                #[serde(skip_serializing_if = "Vec::is_empty")]
-                pub branches: Vec<Branch>,
-            }
-
-            #[derive(Debug, serde::Serialize)]
-            pub struct LogResponse {
-                pub commits: Vec<Commit>,
-                pub log: bool,
-                pub total: usize,
-                pub page: usize,
-                pub per_page: u16,
-            }
-
-            #[derive(Debug, Deserialize)]
-            pub struct LogParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
-                #[serde(rename = "ref")]
-                pub rev: Option<String>,
-                // @NOTE The lexicon states `cursor` is a string containing a pagination
-                // cursor of a commit id. AppView actually gives us an integer for
-                // the number of commits to skip.
-                #[serde(default)]
-                pub cursor: usize,
-                #[serde(default = "log_limit_default")]
-                pub limit: u16,
-            }
-
-            const fn log_limit_default() -> u16 {
-                50
-            }
-
-            #[derive(Debug, Deserialize)]
-            pub struct TagParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
-                #[serde(default)]
-                pub cursor: usize,
-                #[serde(default = "tag_limit_default")]
-                pub limit: usize,
-            }
-
-            const fn tag_limit_default() -> usize {
-                50
-            }
-
-            #[derive(Debug, Serialize)]
-            #[serde(rename_all = "PascalCase")]
-            pub struct TagAnnotation {
-                pub hash: ObjectId<Array>,
-                pub name: String,
-                pub tagger: Option<Signature>,
-                pub message: String,
-                #[serde(rename = "PGPSignature")]
-                pub signature: Option<String>,
-                pub target_type: i32,
-                pub target: ObjectId<Array>,
-            }
-
-            #[derive(Debug, Serialize)]
-            pub struct Tag {
-                #[serde(flatten)]
-                pub r#ref: Reference,
-                #[serde(rename = "tag", skip_serializing_if = "Option::is_none")]
-                pub annotation: Option<TagAnnotation>,
-            }
-
-            #[derive(Debug, Serialize)]
-            pub struct TagsResponse {
-                pub tags: Vec<Tag>,
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            pub struct TreeEntry {
-                pub name: String,
-                pub mode: Cow<'static, str>,
-                pub size: usize,
-                pub is_file: bool,
-                pub is_subtree: bool,
-            }
-
-            #[derive(Debug, Deserialize)]
-            pub struct TreeParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
-                #[serde(rename = "ref")]
-                pub rev: Option<String>,
-                pub path: Option<PathBuf>,
-            }
-
-            #[derive(Debug, Serialize)]
-            pub struct Readme {
-                pub contents: String,
-                pub filename: String,
-            }
-
-            /// Return type for `sh.tangled.repo.tree`.
-            #[derive(Debug, Serialize)]
-            pub struct TreeResponse {
-                pub files: Vec<TreeEntry>,
-                #[serde(skip_serializing_if = "Option::is_none")]
-                pub dotdot: Option<PathBuf>,
-                #[serde(skip_serializing_if = "Option::is_none")]
-                pub parent: Option<PathBuf>,
-                #[serde(rename = "ref")]
-                pub rev: String,
-                #[serde(skip_serializing_if = "Option::is_none")]
-                pub readme: Option<Readme>,
-            }
-
-            #[derive(Debug, Deserialize)]
-            pub struct BlobParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
-                #[serde(rename = "ref")]
-                pub rev: Option<String>,
-                pub path: PathBuf,
-                #[serde(default)]
-                pub raw: bool,
-            }
-
-            #[derive(Debug, Serialize)]
-            pub enum BlobEncoding {
-                #[serde(rename = "utf-8")]
-                Utf8,
-                #[serde(rename = "base64")]
-                Base64,
-            }
-
-            #[derive(Debug, Serialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct JsonBlob {
-                pub content: String,
-                pub encoding: BlobEncoding,
-                pub is_binary: bool,
-                pub mime_type: String,
-                pub path: PathBuf,
-                #[serde(rename = "ref")]
-                pub rev: String,
-                pub size: usize,
-            }
-
-            #[derive(Debug)]
-            pub enum BlobResponse {
-                Json(JsonBlob),
-                Raw(Vec<u8>),
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            #[serde(rename_all = "PascalCase")]
-            pub struct DiffLine {
-                pub op: u8,
-                pub line: String,
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            #[serde(rename_all = "PascalCase")]
-            pub struct DiffHunk {
-                // comment: String,
-                pub old_position: u32,
-                pub old_lines: u32,
-                pub new_position: u32,
-                pub new_lines: u32,
-                pub lines_added: u32,
-                pub lines_deleted: u32,
-                pub leading_context: u32,
-                pub trailing_context: u32,
-                pub lines: Vec<DiffLine>,
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            pub struct Delta {
-                pub name: DeltaName,
-                #[serde(rename = "text_fragments")]
-                pub hunks: Vec<DiffHunk>,
-                pub is_binary: bool,
-                pub is_new: bool,
-                pub is_delete: bool,
-                pub is_copy: bool,
-                pub is_rename: bool,
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            pub struct DiffStat {
-                pub files_changed: usize,
-                pub insertions: usize,
-                pub deletions: usize,
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            pub struct DeltaName {
-                pub old: String,
-                pub new: String,
-            }
-
-            #[derive(Debug, Serialize)]
-            pub struct Diff {
-                pub commit: Commit,
-                pub stat: DiffStat,
-                #[serde(rename = "diff")]
-                pub deltas: Vec<Delta>,
-            }
-
-            #[derive(Debug, Deserialize)]
-            pub struct DiffParams {
-                #[serde(with = "crate::repospec::query_param")]
-                pub repo: RepoSpec,
-                #[serde(rename = "ref")]
-                pub rev: String,
-            }
-
-            #[derive(Debug, Serialize)]
-            pub struct DiffResponse {
-                #[serde(rename = "ref")]
-                pub rev: String,
-                pub diff: Diff,
-            }
-
-            #[derive(Debug, Default, Serialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct Languages {
-                #[serde(skip_serializing_if = "Vec::is_empty")]
-                pub languages: Vec<()>,
-            }
-
-            // Mutations
-
-            #[derive(Debug, Deserialize)]
-            #[serde(rename_all = "camelCase")]
-            pub struct CreateParams {
-                pub rkey: String,
+                #[derive(Debug, Serialize)]
+                pub struct Tag {
+                    #[serde(flatten)]
+                    pub r#ref: refs::Reference,
+                    #[serde(rename = "tag", skip_serializing_if = "Option::is_none")]
+                    pub annotation: Option<TagAnnotation>,
+                }
             }
         }
     }

crates/lexicon/Cargo.toml

···
+[package]
+name = "lexicon"
+version.workspace = true
+authors.workspace = true
+repository.workspace = true
+license.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+identity.workspace = true
+
+data-encoding.workspace = true
+serde.workspace = true
+thiserror.workspace = true
+time.workspace = true
+
+gix-hash = "^0.20.0"

crates/lexicon/src/extra.rs

···
+pub mod objectid;
+pub mod repopath;

crates/lexicon/src/extra/repopath.rs

···
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+
+/// Repository path specifier.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(try_from = "UnvalidatedRepoPath")]
+pub struct RepoPath {
+    /// Repository owner
+    pub owner: Box<str>,
+
+    /// Repository name
+    pub name: Box<str>,
+}
+
+#[derive(Deserialize)]
+struct UnvalidatedRepoPath {
+    owner: Box<str>,
+    name: Box<str>,
+}
+
+impl TryFrom<UnvalidatedRepoPath> for RepoPath {
+    type Error = RepoPathError;
+
+    #[inline]
+    fn try_from(
+        UnvalidatedRepoPath { owner, name }: UnvalidatedRepoPath,
+    ) -> Result<Self, Self::Error> {
+        Self::from_parts(owner, name)
+    }
+}
+
+impl RepoPath {
+    pub fn from_parts(
+        owner: impl Into<Box<str>>,
+        name: impl Into<Box<str>>,
+    ) -> Result<Self, RepoPathError> {
+        fn inner(owner: Box<str>, name: Box<str>) -> Result<RepoPath, RepoPathError> {
+            validate(owner.as_ref())?;
+            validate(name.as_ref())?;
+            Ok(RepoPath { owner, name })
+        }
+        inner(owner.into(), name.into())
+    }
+
+    pub const fn owner(&self) -> &str {
+        &self.owner
+    }
+
+    pub const fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl std::fmt::Display for RepoPath {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}/{}", self.owner, self.name)
+    }
+}
+
+impl FromStr for RepoPath {
+    type Err = RepoPathError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let Some((owner, name)) = s.split_once('/') else {
+            return Err(RepoPathError::Format);
+        };
+
+        validate(owner)?;
+        validate(name)?;
+
+        Ok(Self {
+            owner: owner.into(),
+            name: name.into(),
+        })
+    }
+}
+
+pub mod string {
+    //! Serialize/Deserialize a `RepoSpec` from a string.
+    //!
+    //! # Example
+    //!
+    //! ```rust,no_run
+    //! # use lexicon::extra::repopath::RepoPath;
+    //! #[derive(serde::Deserialize)]
+    //! struct Params {
+    //!     #[serde(with = "lexicon::extra::repopath::string")]
+    //!     repo: RepoPath,
+    //! }
+    //! ```
+    //!
+    use super::RepoPath;
+    use serde::{Deserialize, Deserializer, Serializer};
+    use std::{borrow::Cow, str::FromStr};
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<RepoPath, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = <Cow<str>>::deserialize(deserializer)?;
+        let repo = RepoPath::from_str(&s).map_err(serde::de::Error::custom)?;
+        Ok(repo)
+    }
+
+    #[allow(unused)]
+    pub fn serialize<S>(v: &RepoPath, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&format!("{}/{}", v.owner(), v.name()))
+    }
+}
+
+fn validate(name: &str) -> Result<(), RepoPathError> {
+    static FORBIDDEN_SUBSTRINGS: &[&str] = &[".."];
+    static FORBIDDEN_PREFIXES: &[&str] = &[".", "-"];
+    static ACCEPTED_SYMBOLS: &[char] = &['.', '-', '_', ':'];
+
+    if name.is_empty() {
+        return Err(RepoPathError::Empty);
+    }
+
+    for value in name.chars() {
+        if !(value.is_ascii_alphanumeric() || ACCEPTED_SYMBOLS.contains(&value)) {
+            return Err(RepoPathError::Character { value });
+        }
+    }
+
+    for substring in FORBIDDEN_SUBSTRINGS {
+        if name.contains(substring) {
+            return Err(RepoPathError::Substring { substring });
+        }
+    }
+
+    for prefix in FORBIDDEN_PREFIXES {
+        if name.starts_with(prefix) {
+            return Err(RepoPathError::Prefix { prefix });
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum RepoPathError {
+    #[error("expected a repository specifier in form '{{owner}}/{{name}}'")]
+    Format,
+    #[error("repository name cannot be empty")]
+    Empty,
+    #[error("invalid character in repository name: '{value}'")]
+    Character { value: char },
+    #[error("invalid sub-string in repository name: '{substring}'")]
+    Substring { substring: &'static str },
+    #[error("invalid prefix for respository name: '{prefix}'")]
+    Prefix { prefix: &'static str },
+}

crates/lexicon/src/lib.rs

···
+//!
+//! Artisinal, hand-written Lexicon definitions.
+//!
+//! When you're too lazy to setup codegen, not lazy enough to not write them
+//! all out manually.
+//!
+pub mod sh;
+
+/// Types which aren't part of the lexicon, but are used for serializing
+/// and deserializing.
+pub mod extra;

crates/lexicon/src/sh.rs

···
+pub mod tangled;

crates/lexicon/src/sh/tangled.rs

···
+pub mod knot;
+pub mod repo;
+pub mod spindle;
+
+use identity::Did;
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/owner.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.owner")]
+pub struct OwnerOutput {
+    pub owner: Did,
+}
+
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/publicKey.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.publicKey", rename_all = "camelCase")]
+pub struct PublicKey {
+    #[serde(rename = "$type")]
+    pub r#type: String,
+
+    /// Public key contents
+    pub key: String,
+
+    /// Human-readable name for this key
+    pub name: String,
+
+    /// Key upload timestamp
+    #[serde(alias = "created", with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+}

crates/lexicon/src/sh/tangled/knot.rs

···
+use identity::Did;
+use serde::{Deserialize, Serialize};
+use std::borrow::Cow;
+use time::OffsetDateTime;
+
+/// Output of `sh.tangled.knot.version` query.
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VersionOutput {
+    pub version: Cow<'static, str>,
+}
+
+/// `sh.tangled.knot` record.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/knot/knot.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.knot", rename_all = "camelCase")]
+pub struct Knot {
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+}
+
+/// `sh.tangled.knot.member` record.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/knot/member.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.knot.member", rename_all = "camelCase")]
+pub struct Member {
+    pub subject: Did,
+
+    /// Domain that this member now belongs to
+    pub domain: String,
+
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+}

crates/lexicon/src/sh/tangled/repo.rs

···
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+
+/// `sh.tangled.repo` record.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/repo.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.repo", rename_all = "camelCase")]
+pub struct Repo {
+    #[serde(rename = "$type")]
+    pub r#type: String,
+
+    /// Name of the repo
+    pub name: String,
+
+    /// Knot where the repo was created
+    pub knot: String,
+
+    /// CI runner to send jobs to and receive results from
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub spindle: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+
+    /// Source of the repo
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+
+    /// List of labels that this repo subscribes to
+    // @NOTE These should be at-uris.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub labels: Vec<String>,
+
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+}
+
+pub mod blob;
+pub mod branches;
+pub mod diff;
+pub mod get_default_branch;
+pub mod languages;
+pub mod log;
+pub mod tags;
+pub mod tree;
+
+/// Lexicon sub-types.
+pub mod refs {
+    use crate::extra::objectid::{Array, ObjectId};
+    use serde::Serialize;
+    use std::{borrow::Cow, collections::HashMap};
+    use time::OffsetDateTime;
+
+    #[derive(Debug, Default, Serialize)]
+    #[serde(rename_all = "camelCase")]
+    pub struct Reference {
+        /// Short-name of the reference.
+        pub name: String,
+        pub hash: ObjectId,
+    }
+
+    /// Git commit signature (ie. the author or committer).
+    #[derive(Debug, Serialize)]
+    #[serde(rename_all = "PascalCase")]
+    pub struct Signature {
+        pub name: String,
+        pub email: String,
+        #[serde(with = "time::serde::rfc3339")]
+        pub when: OffsetDateTime,
+    }
+
+    #[derive(Debug, Serialize)]
+    #[serde(rename_all = "PascalCase")]
+    pub struct Commit {
+        pub hash: ObjectId<Array>,
+        pub author: Signature,
+        pub committer: Signature,
+        pub merge_tag: String,
+        #[serde(rename = "PGPSignature")]
+        pub pgp_signature: Option<String>,
+        pub message: String,
+        pub tree_hash: ObjectId<Array>,
+        pub parent_hashes: Vec<ObjectId<Array>>,
+        pub encoding: Cow<'static, str>,
+        /// Non-standard object headers. Values are always base64 encoded.
+        pub extra_headers: HashMap<String, String>,
+    }
+}

crates/lexicon/src/sh/tangled/repo/blob.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/blob.json>
+//!
+use crate::extra::{
+    objectid::{Hex, ObjectId},
+    repopath::RepoPath,
+};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use time::OffsetDateTime;
+
+use super::refs;
+
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in format `did:plc:.../repoName`.
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Git reference (branch, tag, or commit SHA).
+    #[serde(rename = "ref")]
+    pub rev: Option<String>,
+
+    /// Path to the file within the repository.
+    pub path: PathBuf,
+
+    /// Return raw file content instead of JSON response.
+    #[serde(default)]
+    pub raw: bool,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    /// The git reference used.
+    #[serde(rename = "ref")]
+    pub rev: String,
+
+    /// This file path.
+    pub path: PathBuf,
+
+    /// File content (base64 encoded for binary files).
+    pub content: String,
+
+    /// Content encoding.
+    pub encoding: Encoding,
+
+    /// File size in bytes.
+    pub size: usize,
+
+    /// Whether the file is binary.
+    pub is_binary: bool,
+
+    /// MIME type of the file.
+    pub mime_type: String,
+
+    pub last_commit: Option<LastCommit>,
+}
+
+#[derive(Debug, Serialize)]
+pub enum Encoding {
+    #[serde(rename = "utf-8")]
+    Utf8,
+    #[serde(rename = "base64")]
+    Base64,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LastCommit {
+    /// Commit hash.
+    pub hash: ObjectId<Hex>,
+
+    /// Short commit hash.
+    pub short_hash: Option<Box<str>>,
+
+    /// Commit message.
+    pub message: Box<str>,
+
+    pub author: Option<refs::Signature>,
+
+    /// Commit timestamp.
+    #[serde(with = "time::serde::rfc3339")]
+    pub when: OffsetDateTime,
+}

crates/lexicon/src/sh/tangled/repo/branches.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/branches.json>
+//!
+use crate::extra::repopath::RepoPath;
+use serde::Deserialize;
+
+/// Parameters for the `sh.tangled.repo.branches` query.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/branches.json>
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in the format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Maximum number of branches to return.
+    ///
+    /// (1..=100); Default: 50
+    #[serde(default = "branches_limit_default")]
+    pub limit: u16,
+
+    /// Pagination cursor
+    pub cursor: Option<String>,
+}
+
+const fn branches_limit_default() -> u16 {
+    50
+}

crates/lexicon/src/sh/tangled/repo/diff.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/diff.json>
+//!
+use crate::extra::repopath::RepoPath;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in the format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Git reference (branch, tag, or commit SHA)
+    #[serde(rename = "ref")]
+    pub rev: Box<str>,
+}

crates/lexicon/src/sh/tangled/repo/get_default_branch.rs

···
+use crate::extra::{
+    objectid::{Hex, ObjectId},
+    repopath::RepoPath,
+};
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+
+use super::refs;
+
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in the format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+}
+
+/// Response type for the `sh.tangled.repo.getDefaultBranch` query.
+//
+// @NOTE This completely different to what the lexicon describes,
+// but it is what knotserver outputs.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    /// Short-name of the default branch.
+    pub name: String,
+
+    /// ID of the most recent commit on the default branch
+    //
+    // @NOTE Official knotserver always returns an empty string.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hash: Option<ObjectId>,
+
+    /// Timestamp of the most recent commit on the default branch
+    //
+    // @NOTE Official knotserver always returns the unix epoch.
+    #[serde(
+        with = "time::serde::rfc3339::option",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub when: Option<OffsetDateTime>,
+}
+
+/// Defined response type for the `sh.tangled.repo.getDefaultBranch` query.
+//
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LexiOutput {
+    /// Default branch name.
+    pub name: Box<str>,
+
+    /// Latest commit hash on default branch.
+    pub hash: ObjectId<Hex>,
+
+    /// Short commit hash.
+    pub short_hash: Box<str>,
+
+    /// Timestamp of the latest commit.
+    #[serde(with = "time::serde::rfc3339")]
+    pub when: OffsetDateTime,
+
+    /// Latest commit message.
+    pub message: Option<Box<str>>,
+
+    pub author: Option<refs::Signature>,
+}

crates/lexicon/src/sh/tangled/repo/languages.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/languages.json>
+//!
+use crate::extra::repopath::RepoPath;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Respository identifier in format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Git reference (branch, tag, or commit SHA)
+    #[serde(rename = "ref")]
+    pub rev: String,
+}
+
+#[derive(Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    /// The git reference used
+    #[serde(rename = "ref")]
+    pub rev: String,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub languages: Vec<Language>,
+
+    /// Total size of all analyzed files in bytes
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub total_size: Option<u64>,
+
+    /// Total number of files analyzed
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub total_files: Option<u64>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Language {
+    /// Programming language name
+    pub name: String,
+
+    /// Total size of files in this language (bytes)
+    pub size: u64,
+
+    /// Percentage of total codebase 0..=100
+    pub percentage: u8,
+
+    /// Number of files in this language
+    pub file_count: u64,
+
+    /// Hex color code for this language
+    pub color: String,
+
+    /// File extensions associated with this language
+    pub extensions: Vec<String>,
+}

crates/lexicon/src/sh/tangled/repo/log.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/log.json>
+//!
+use crate::extra::repopath::RepoPath;
+use serde::Deserialize;
+use std::path::PathBuf;
+
+/// Parameters for the `sh.tangled.repo.log` query.
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in the format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Git reference (branch, tag, or commit SHA)
+    #[serde(rename = "ref")]
+    pub rev: Option<String>,
+
+    /// Path to filter commits by
+    pub path: Option<PathBuf>,
+
+    /// Maximum number of commits to return.
+    ///
+    /// (1..=100); Default: 50
+    #[serde(default = "log_limit_default")]
+    pub limit: u16,
+
+    /// Pagination cursor (commit SHA)
+    //
+    // @NOTE AppView actually gives us an integer for the number of
+    // commits to skip.
+    #[serde(default)]
+    pub cursor: usize,
+}
+
+const fn log_limit_default() -> u16 {
+    50
+}

crates/lexicon/src/sh/tangled/repo/tags.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/tags.json>
+//!
+use crate::extra::repopath::RepoPath;
+use serde::Deserialize;
+
+/// Parameters for the `sh.tangled.repo.tags` query.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/tags.json>
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in the format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Maximum number of commits to return.
+    ///
+    /// (1..=100); Default: 50
+    #[serde(default = "tag_limit_default")]
+    pub limit: u16,
+
+    /// Pagnination cursor
+    pub cursor: Option<String>,
+}
+
+const fn tag_limit_default() -> u16 {
+    50
+}

crates/lexicon/src/sh/tangled/repo/tree.rs

···
+//!
+//! <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/tree.json>
+//!
+use std::{borrow::Cow, path::PathBuf};
+
+use crate::extra::{objectid::ObjectId, repopath::RepoPath};
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+
+/// Parameters for the `sh.tangled.repo.tree` query.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/repo/tree.json>
+#[derive(Debug, Deserialize)]
+pub struct Input {
+    /// Repository identifier in the format `did:plc:.../repoName`
+    #[serde(with = "crate::extra::repopath::string")]
+    pub repo: RepoPath,
+
+    /// Git reference (branch, tag, or commit SHA)
+    #[serde(rename = "ref")]
+    pub rev: Option<String>,
+
+    /// Path within the repository tree
+    pub path: Option<PathBuf>,
+}
+
+/// Output of `sh.tangled.repo.tree` query.
+#[derive(Debug, Serialize)]
+pub struct Output {
+    /// The git reference used
+    #[serde(rename = "ref")]
+    pub rev: String,
+
+    /// The parent path in the tree
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parent: Option<PathBuf>,
+
+    /// Parent directory path
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dotdot: Option<PathBuf>,
+
+    /// Readme for this file tree
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub readme: Option<Readme>,
+
+    pub files: Vec<TreeEntry>,
+}
+
+#[derive(Debug, Default, Serialize)]
+pub struct TreeEntry {
+    /// Relative file or directory name
+    pub name: String,
+
+    /// File mode
+    pub mode: Cow<'static, str>,
+
+    /// File size in bytes
+    pub size: usize,
+
+    /// Whether this entry is a file
+    pub is_file: bool,
+
+    /// Whether this entry is a directory/subtree
+    pub is_subtree: bool,
+
+    pub last_commit: Option<LastCommit>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Readme {
+    /// Contents of the readme file
+    pub filename: String,
+
+    /// Name of the readme file
+    pub contents: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct LastCommit {
+    /// Commit hash
+    pub hash: ObjectId,
+
+    /// Commit message
+    pub message: String,
+
+    /// Commit timestamp
+    #[serde(with = "time::serde::rfc3339")]
+    pub when: OffsetDateTime,
+}

crates/lexicon/src/sh/tangled/spindle.rs

···
+use identity::Did;
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+
+/// `sh.tangled.spindle` record.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/spindle/spindle.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.spindle", rename_all = "camelCase")]
+pub struct Spindle {
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+}
+
+/// `sh.tangled.spindle.member` record.
+///
+/// <https://tangled.org/@tangled.org/core/blob/master/lexicons/spindle/member.json>
+#[derive(Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename = "sh.tangled.spindle.member", rename_all = "camelCase")]
+pub struct Member {
+    pub subject: Did,
+
+    /// Domain that this member now belongs to
+    pub domain: String,
+
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+}