prototype actor_store; begin convert from sqlx to diesel; reorganize

Cargo.lock

···
 ]
 
 [[package]]
+name = "aligned-vec"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa90d7ce82d4be67b64039a3d588d38dbcc6736577de4a847025ce5b0c468d1"
+
+[[package]]
 name = "allocator-api2"
 version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
+name = "arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+
+[[package]]
+name = "arg_enum_proc_macro"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
 name = "argon2"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "ascii_utils"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71938f30533e4d95a6d17aa530939da3842c2ab6f4f84b9dae68447e4129f74a"
 
 [[package]]
 name = "async-channel"
···
 ]
 
 [[package]]
+name = "async-event-emitter"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0780980d45c26a07355c8eef957978ce91fb1842b98b0d194e6e5808f428e52a"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "dashmap",
+ "futures",
+ "lazy_static",
+ "serde",
+ "uuid 1.16.0",
+]
+
+[[package]]
 name = "async-io"
 version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "atoi"
-version = "2.0.0"
+name = "atomic"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
-dependencies = [
- "num-traits",
-]
+checksum = "c59bdb34bc650a32731b31bd8f0829cc15d24a708ee31559e0bb34f2bc320cba"
 
 [[package]]
 name = "atomic"
···
 
 [[package]]
 name = "atrium-api"
+version = "0.24.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c5d74937642f6b21814e82d80f54d55ebd985b681bffbe27c8a76e726c3c4db"
+dependencies = [
+ "atrium-xrpc",
+ "chrono",
+ "http 1.3.1",
+ "ipld-core",
+ "langtag",
+ "regex",
+ "serde",
+ "serde_bytes",
+ "serde_json",
+ "thiserror 1.0.69",
+ "tokio",
+ "trait-variant",
+]
+
+[[package]]
+name = "atrium-api"
 version = "0.25.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7225f0ca3c78564b784828e3db3e92619cf6e786530c3468df73f49deebc0bd4"
···
  "atrium-common",
  "atrium-xrpc",
  "chrono",
- "http",
+ "http 1.3.1",
  "ipld-core",
  "langtag",
  "regex",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73a3da430c71dd9006d61072c20771f264e5c498420a49c32305ceab8bd71955"
 dependencies = [
- "ecdsa",
+ "ecdsa 0.16.9",
  "k256",
  "multibase",
- "p256",
+ "p256 0.13.2",
  "thiserror 1.0.69",
 ]
 
···
 checksum = "1ebe74e137537277a290faab14154976851c7ff3cfc07f9872b1eb127a6a6ea3"
 dependencies = [
  "async-stream",
- "atrium-api",
+ "atrium-api 0.25.3",
  "futures",
  "ipld-core",
  "serde",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0216ad50ce34e9ff982e171c3659e65dedaa2ed5ac2994524debdc9a9647ffa8"
 dependencies = [
- "http",
+ "http 1.3.1",
  "serde",
  "serde_html_form",
  "serde_json",
···
 checksum = "e099e5171f79faef52364ef0657a4cab086a71b384a779a29597a91b780de0d5"
 dependencies = [
  "atrium-xrpc",
- "reqwest",
+ "reqwest 0.12.15",
 ]
 
 [[package]]
···
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
+name = "av1-grain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6678909d8c5d46a42abcf571271e15fdbc0a225e3646cf23762cd415046c78bf"
+dependencies = [
+ "anyhow",
+ "arrayvec",
+ "log",
+ "nom",
+ "num-rational",
+ "v_frame",
+]
+
+[[package]]
+name = "avif-serialize"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98922d6a4cfbcb08820c69d8eeccc05bb1f29bfa06b4f5b1dbfe9a868bd7608e"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "aws-config"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fcc63c9860579e4cb396239570e979376e70aab79e496621748a09913f8b36"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sdk-sso",
+ "aws-sdk-ssooidc",
+ "aws-sdk-sts",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand 2.3.0",
+ "hex",
+ "http 1.3.1",
+ "ring",
+ "time",
+ "tokio",
+ "tracing",
+ "url",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-credential-types"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "687bc16bc431a8533fe0097c7f0182874767f920989d7260950172ae8e3c4465"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "zeroize",
+]
+
+[[package]]
 name = "aws-lc-rs"
 version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "aws-runtime"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c4063282c69991e57faab9e5cb21ae557e59f5b0fb285c196335243df8dc25c"
+dependencies = [
+ "aws-credential-types",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand 2.3.0",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "percent-encoding",
+ "pin-project-lite",
+ "tracing",
+ "uuid 1.16.0",
+]
+
+[[package]]
+name = "aws-sdk-s3"
+version = "1.85.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5c82dae9304e7ced2ff6cca43dceb2d6de534c95a506ff0f168a7463c9a885d"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-checksums",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-smithy-xml",
+ "aws-types",
+ "bytes",
+ "fastrand 2.3.0",
+ "hex",
+ "hmac",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "lru",
+ "once_cell",
+ "percent-encoding",
+ "regex-lite",
+ "sha2",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "aws-sdk-sso"
+version = "1.67.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d4863da26489d1e6da91d7e12b10c17e86c14f94c53f416bd10e0a9c34057ba"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand 2.3.0",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-ssooidc"
+version = "1.68.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95caa3998d7237789b57b95a8e031f60537adab21fa84c91e35bef9455c652e4"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand 2.3.0",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-sts"
+version = "1.68.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4939f6f449a37308a78c5a910fd91265479bd2bb11d186f0b8fc114d89ec828d"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-query",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-smithy-xml",
+ "aws-types",
+ "fastrand 2.3.0",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sigv4"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3503af839bd8751d0bdc5a46b9cac93a003a353e635b0c12cf2376b5b53e41ea"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "crypto-bigint 0.5.5",
+ "form_urlencoded",
+ "hex",
+ "hmac",
+ "http 0.2.12",
+ "http 1.3.1",
+ "p256 0.11.1",
+ "percent-encoding",
+ "ring",
+ "sha2",
+ "subtle",
+ "time",
+ "tracing",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-smithy-async"
+version = "1.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e190749ea56f8c42bf15dd76c65e14f8f765233e6df9b0506d9d934ebef867c"
+dependencies = [
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "aws-smithy-checksums"
+version = "0.63.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b65d21e1ba6f2cdec92044f904356a19f5ad86961acf015741106cdfafd747c0"
+dependencies = [
+ "aws-smithy-http",
+ "aws-smithy-types",
+ "bytes",
+ "crc32c",
+ "crc32fast",
+ "crc64fast-nvme",
+ "hex",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "md-5",
+ "pin-project-lite",
+ "sha1",
+ "sha2",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-eventstream"
+version = "0.60.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c45d3dddac16c5c59d553ece225a88870cf81b7b813c9cc17b78cf4685eac7a"
+dependencies = [
+ "aws-smithy-types",
+ "bytes",
+ "crc32fast",
+]
+
+[[package]]
+name = "aws-smithy-http"
+version = "0.62.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99335bec6cdc50a346fda1437f9fefe33abf8c99060739a546a16457f2862ca9"
+dependencies = [
+ "aws-smithy-eventstream",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "percent-encoding",
+ "pin-project-lite",
+ "pin-utils",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-http-client"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e44697a9bded898dcd0b1cb997430d949b87f4f8940d91023ae9062bf218250"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "h2 0.4.9",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "hyper 0.14.32",
+ "hyper 1.6.0",
+ "hyper-rustls 0.24.2",
+ "hyper-rustls 0.27.5",
+ "hyper-util",
+ "pin-project-lite",
+ "rustls 0.21.12",
+ "rustls 0.23.26",
+ "rustls-native-certs 0.8.1",
+ "rustls-pki-types",
+ "tokio",
+ "tower",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-json"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92144e45819cae7dc62af23eac5a038a58aa544432d2102609654376a900bd07"
+dependencies = [
+ "aws-smithy-types",
+]
+
+[[package]]
+name = "aws-smithy-observability"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9364d5989ac4dd918e5cc4c4bdcc61c9be17dcd2586ea7f69e348fc7c6cab393"
+dependencies = [
+ "aws-smithy-runtime-api",
+]
+
+[[package]]
+name = "aws-smithy-query"
+version = "0.60.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2fbd61ceb3fe8a1cb7352e42689cec5335833cd9f94103a61e98f9bb61c64bb"
+dependencies = [
+ "aws-smithy-types",
+ "urlencoding",
+]
+
+[[package]]
+name = "aws-smithy-runtime"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14302f06d1d5b7d333fd819943075b13d27c7700b414f574c3c35859bfb55d5e"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-http-client",
+ "aws-smithy-observability",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "fastrand 2.3.0",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "pin-project-lite",
+ "pin-utils",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-runtime-api"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e5d9e3a80a18afa109391fb5ad09c3daf887b516c6fd805a157c6ea7994a57"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-types",
+ "bytes",
+ "http 0.2.12",
+ "http 1.3.1",
+ "pin-project-lite",
+ "tokio",
+ "tracing",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-smithy-types"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40076bd09fadbc12d5e026ae080d0930defa606856186e31d83ccc6a255eeaf3"
+dependencies = [
+ "base64-simd",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.3.1",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
+ "itoa",
+ "num-integer",
+ "pin-project-lite",
+ "pin-utils",
+ "ryu",
+ "serde",
+ "time",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "aws-smithy-xml"
+version = "0.60.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab0b0166827aa700d3dc519f72f8b3a91c35d0b8d042dc5d643a91e6f80648fc"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "aws-types"
+version = "1.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a322fec39e4df22777ed3ad8ea868ac2f94cd15e1a55f6ee8d8d6305057689a"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "rustc_version",
+ "tracing",
+]
+
+[[package]]
 name = "axum"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "bytes",
  "form_urlencoded",
  "futures-util",
- "http",
- "http-body",
+ "http 1.3.1",
+ "http-body 1.0.1",
  "http-body-util",
- "hyper",
+ "hyper 1.6.0",
  "hyper-util",
  "itoa",
  "matchit",
···
  "serde_path_to_error",
  "serde_urlencoded",
  "sha1",
- "sync_wrapper",
+ "sync_wrapper 1.0.2",
  "tokio",
- "tokio-tungstenite",
+ "tokio-tungstenite 0.26.2",
  "tower",
  "tower-layer",
  "tower-service",
···
 dependencies = [
  "bytes",
  "futures-core",
- "http",
- "http-body",
+ "http 1.3.1",
+ "http-body 1.0.1",
  "http-body-util",
  "mime",
  "pin-project-lite",
  "rustversion",
- "sync_wrapper",
+ "sync_wrapper 1.0.2",
  "tower-layer",
  "tower-service",
  "tracing",
···
 
 [[package]]
 name = "base16ct"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"
+
+[[package]]
+name = "base16ct"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
···
 
 [[package]]
 name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
 version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
+name = "base64-simd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
+dependencies = [
+ "outref",
+ "vsimd",
+]
+
+[[package]]
+name = "base64-url"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb9fb9fb058cc3063b5fc88d9a21eefa2735871498a04e1650da76ed511c8569"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
 name = "base64ct"
 version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89e25b6adfb930f02d1981565a6e5d9c547ac15a96606256d3b59040e5cd4ca3"
+
+[[package]]
+name = "binascii"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "383d29d513d8764dcdc42ea295d979eb99c3c9f00607b3692cf68a431f7dca72"
 
 [[package]]
 name = "bincode"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "cexpr",
  "clang-sys",
  "itertools",
···
 ]
 
 [[package]]
+name = "binstring"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a3c2603413428303761fae99d4b6d936404208221a44eba47d7c1e6dd03a3"
+
+[[package]]
+name = "bit_field"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc827186963e592360843fb5ba4b973e145841266c1357f7180c43526f2e5b61"
+
+[[package]]
 name = "bitcoin-internals"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
 version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
-dependencies = [
- "serde",
-]
+
+[[package]]
+name = "bitstream-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6099cdc01846bc367c4e7dd630dc5966dccf36b652fae7a74e17b640411a91b2"
 
 [[package]]
 name = "blake2"
···
  "anyhow",
  "argon2",
  "async-trait",
- "atrium-api",
+ "atrium-api 0.25.3",
  "atrium-crypto",
  "atrium-repo",
  "atrium-xrpc",
···
  "base32",
  "base64 0.22.1",
  "chrono",
+ "cid 0.10.1",
  "clap",
  "clap-verbosity-flag",
  "constcat",
+ "diesel",
+ "diesel_migrations",
  "figment",
  "futures",
  "hex",
···
  "metrics",
  "metrics-exporter-prometheus",
  "multihash 0.19.3",
+ "r2d2",
  "rand 0.8.5",
  "regex",
- "reqwest",
+ "reqwest 0.12.15",
  "reqwest-middleware",
+ "rsky-common",
+ "rsky-pds",
  "rsky-repo",
  "rsky-syntax",
  "serde",
···
  "serde_ipld_dagjson",
  "serde_json",
  "sha2",
- "sqlx",
  "thiserror 2.0.12",
  "tokio",
  "tokio-util",
···
  "tracing-subscriber",
  "url",
  "urlencoding",
- "uuid",
+ "uuid 1.16.0",
 ]
 
 [[package]]
+name = "built"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56ed6191a7e78c36abdb16ab65341eefd73d64d303fffccdbb00d51e4205967b"
+
+[[package]]
 name = "bumpalo"
 version = "3.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
 
 [[package]]
 name = "bytes"
···
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
 [[package]]
+name = "bytes-utils"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
+dependencies = [
+ "bytes",
+ "either",
+]
+
+[[package]]
 name = "cbor4ii"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
 dependencies = [
  "nom",
+]
+
+[[package]]
+name = "cfb"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
+dependencies = [
+ "byteorder",
+ "fnv",
+ "uuid 1.16.0",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "coarsetime"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91849686042de1b41cd81490edc83afbcb0abe5a9b6f2c4114f23ce8cca1bcf4"
+dependencies = [
+ "libc",
+ "wasix",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
 name = "colorchoice"
 version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ffb5df6dd5dadb422897e8132f415d7a054e3cd757e5070b663f75bea1840fb"
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "percent-encoding",
+ "time",
+ "version_check",
+]
 
 [[package]]
 name = "core-foundation"
···
 checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
 
 [[package]]
+name = "crc32c"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a47af21622d091a8f0fb295b88bc886ac74efcc613efc19f5d0b21de5c89e47"
+dependencies = [
+ "rustc_version",
+]
+
+[[package]]
 name = "crc32fast"
 version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "crc64fast-nvme"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4955638f00a809894c947f85a024020a20815b65a5eea633798ea7924edab2b3"
+dependencies = [
+ "crc",
+]
+
+[[package]]
 name = "crossbeam-channel"
 version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
+name = "crossbeam-deque"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
+ "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
-name = "crossbeam-queue"
-version = "0.3.12"
+name = "crossbeam-epoch"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
  "crossbeam-utils",
 ]
···
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
+name = "crunchy"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
 name = "crypto-bigint"
 version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "generic-array",
  "typenum",
 ]
+
+[[package]]
+name = "ct-codecs"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0d274c65cbc1c34703d2fc2ce0fb892ff68f4516b677671a2f238a30b9b2b2"
 
 [[package]]
 name = "darling"
···
 
 [[package]]
 name = "der"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1a467a65c5e759bce6e65eaf91cc29f466cdc57cb65777bd646872a8a1fd4de"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "der"
 version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
···
 ]
 
 [[package]]
+name = "devise"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1d90b0c4c777a2cad215e3c7be59ac7c15adf45cf76317009b7d096d46f651d"
+dependencies = [
+ "devise_codegen",
+ "devise_core",
+]
+
+[[package]]
+name = "devise_codegen"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71b28680d8be17a570a2334922518be6adc3f58ecc880cbb404eaeb8624fd867"
+dependencies = [
+ "devise_core",
+ "quote",
+]
+
+[[package]]
+name = "devise_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b035a542cf7abf01f2e3c4d5a7acbaebfefe120ae4efc7bde3df98186e4b8af7"
+dependencies = [
+ "bitflags 2.9.0",
+ "proc-macro2",
+ "proc-macro2-diagnostics",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "diesel"
+version = "2.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03fc05c17098f21b89bc7d98fe1dd3cce2c11c2ad8e145f2a44fe08ed28eb559"
+dependencies = [
+ "bitflags 2.9.0",
+ "byteorder",
+ "chrono",
+ "diesel_derives",
+ "itoa",
+ "libsqlite3-sys",
+ "pq-sys",
+ "r2d2",
+ "time",
+]
+
+[[package]]
+name = "diesel_derives"
+version = "2.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14701062d6bed917b5c7103bdffaee1e4609279e240488ad24e7bd979ca6866c"
+dependencies = [
+ "diesel_table_macro_syntax",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "diesel_migrations"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6036b3f0120c5961381b570ee20a02432d7e2d27ea60de9578799cf9156914ac"
+dependencies = [
+ "diesel",
+ "migrations_internals",
+ "migrations_macros",
+]
+
+[[package]]
+name = "diesel_table_macro_syntax"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc5557efc453706fed5e4fa85006fe9817c224c3f480a34c7e5959fd700921c5"
+dependencies = [
+ "syn 2.0.101",
+]
+
+[[package]]
 name = "digest"
 version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "ecdsa"
+version = "0.14.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413301934810f597c1d19ca71c8710e99a3f1ba28a0d2ebc01551a2daeea3c5c"
+dependencies = [
+ "der 0.6.1",
+ "elliptic-curve 0.12.3",
+ "rfc6979 0.3.1",
+ "signature 1.6.4",
+]
+
+[[package]]
+name = "ecdsa"
 version = "0.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
 dependencies = [
- "der",
+ "der 0.7.10",
  "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
+ "elliptic-curve 0.13.8",
+ "rfc6979 0.4.0",
+ "signature 2.2.0",
+ "spki 0.7.3",
+]
+
+[[package]]
+name = "ed25519-compact"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9b3460f44bea8cd47f45a0c70892f1eff856d97cd55358b2f73f663789f6190"
+dependencies = [
+ "ct-codecs",
+ "getrandom 0.2.16",
 ]
 
 [[package]]
···
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3"
 dependencies = [
- "serde",
+ "base16ct 0.1.1",
+ "crypto-bigint 0.4.9",
+ "der 0.6.1",
+ "digest",
+ "ff 0.12.1",
+ "generic-array",
+ "group 0.12.1",
+ "pkcs8 0.9.0",
+ "rand_core 0.6.4",
+ "sec1 0.3.0",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
 dependencies = [
- "base16ct",
- "crypto-bigint",
+ "base16ct 0.2.0",
+ "crypto-bigint 0.5.5",
  "digest",
- "ff",
+ "ff 0.13.1",
  "generic-array",
- "group",
+ "group 0.13.0",
+ "hkdf",
  "pem-rfc7468",
- "pkcs8",
+ "pkcs8 0.10.2",
  "rand_core 0.6.4",
- "sec1",
+ "sec1 0.7.3",
  "subtle",
  "zeroize",
 ]
 
 [[package]]
+name = "email_address"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "encoding_rs"
 version = "0.8.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "etcetera"
-version = "0.8.0"
+name = "event-emitter-rs"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
+checksum = "7dccdd0a59457ba353cc44c26d431ca5089f2cf93035c780a1b3f2814a017ebd"
 dependencies = [
- "cfg-if",
- "home",
- "windows-sys 0.48.0",
+ "bincode",
+ "lazy_static",
+ "serde",
+ "uuid 0.8.2",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "exr"
+version = "1.73.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83197f59927b46c04a183a619b7c29df34e63e63c7869320862268c0ef687e0"
+dependencies = [
+ "bit_field",
+ "half 2.6.0",
+ "lebe",
+ "miniz_oxide",
+ "rayon-core",
+ "smallvec",
+ "zune-inflate",
+]
+
+[[package]]
+name = "fast_chemail"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"
+dependencies = [
+ "ascii_utils",
+]
+
+[[package]]
 name = "fastrand"
 version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "ff"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
 name = "ff"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"
 dependencies = [
- "atomic",
+ "atomic 0.6.0",
  "pear",
  "serde",
  "toml 0.8.22",
···
 dependencies = [
  "crc32fast",
  "miniz_oxide",
-]
-
-[[package]]
-name = "flume"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
-dependencies = [
- "futures-core",
- "futures-sink",
- "spin",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "futures-intrusive"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
-dependencies = [
- "futures-core",
- "lock_api",
- "parking_lot",
-]
-
-[[package]]
 name = "futures-io"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "generator"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc16584ff22b460a382b7feec54b23d2908d858152e5739a120b949293bd74e"
+dependencies = [
+ "cc",
+ "libc",
+ "log",
+ "rustversion",
+ "windows 0.48.0",
+]
+
+[[package]]
+name = "generator"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc6bd114ceda131d3b1d665eba35788690ad37f5916457286b32ab6fd3c438dd"
···
  "libc",
  "log",
  "rustversion",
- "windows",
+ "windows 0.58.0",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "gif"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb2d69b19215e18bb912fa30f7ce15846e301408695e44e0ef719f1da9e19f2"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
+[[package]]
 name = "gimli"
 version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "group"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7"
+dependencies = [
+ "ff 0.12.1",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "group"
 version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
- "ff",
+ "ff 0.13.1",
  "rand_core 0.6.4",
  "subtle",
 ]
 
 [[package]]
 name = "h2"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http 0.2.12",
+ "indexmap 2.9.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "h2"
 version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75249d144030531f8dee69fe9cea04d3edf809a017ae445e2abdff6629e86633"
···
  "fnv",
  "futures-core",
  "futures-sink",
- "http",
+ "http 1.3.1",
  "indexmap 2.9.0",
  "slab",
  "tokio",
···
 version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
+
+[[package]]
+name = "half"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
 
 [[package]]
 name = "hashbrown"
···
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
-dependencies = [
- "hashbrown 0.15.3",
-]
-
-[[package]]
 name = "heck"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "hermit-abi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "hermit-abi"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f154ce46856750ed433c8649605bf7ed2de3bc35fd9d2a9f30cddd873c80cb08"
 
 [[package]]
 name = "hex"
···
 ]
 
 [[package]]
+name = "hmac-sha1-compact"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18492c9f6f9a560e0d346369b665ad2bdbc89fa9bceca75796584e79042694c3"
+
+[[package]]
+name = "hmac-sha256"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a8575493d277c9092b988c780c94737fb9fd8651a1001e16bee3eccfc1baedb"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hmac-sha512"
+version = "1.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0b3a0f572aa8389d325f5852b9e0a333a15b0f86ecccbb3fdb6e97cd86dc67c"
+dependencies = [
+ "digest",
+]
+
+[[package]]
 name = "home"
 version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http"
 version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
···
 
 [[package]]
 name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-body"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http",
+ "http 1.3.1",
 ]
 
 [[package]]
···
 dependencies = [
  "bytes",
  "futures-core",
- "http",
- "http-body",
+ "http 1.3.1",
+ "http-body 1.0.1",
  "pin-project-lite",
 ]
 
···
 dependencies = [
  "async-trait",
  "bincode",
- "http",
+ "http 1.3.1",
  "http-cache-semantics",
  "httpdate",
  "moka",
···
 dependencies = [
  "anyhow",
  "async-trait",
- "http",
+ "http 1.3.1",
  "http-cache",
  "http-cache-semantics",
- "reqwest",
+ "reqwest 0.12.15",
  "reqwest-middleware",
  "serde",
  "url",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92baf25cf0b8c9246baecf3a444546360a97b569168fdf92563ee6a47829920c"
 dependencies = [
- "http",
+ "http 1.3.1",
  "http-serde",
  "serde",
  "time",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f056c8559e3757392c8d091e796416e4649d8e49e88b8d76df6c002f05027fd"
 dependencies = [
- "http",
+ "http 1.3.1",
  "serde",
 ]
 
···
  "async-channel 1.9.0",
  "base64 0.13.1",
  "futures-lite 1.13.0",
- "infer",
+ "infer 0.2.3",
  "pin-project-lite",
  "rand 0.7.3",
  "serde",
···
 
 [[package]]
 name = "hyper"
+version = "0.14.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper"
 version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
···
  "bytes",
  "futures-channel",
  "futures-util",
- "h2",
- "http",
- "http-body",
+ "h2 0.4.9",
+ "http 1.3.1",
+ "http-body 1.0.1",
  "httparse",
  "httpdate",
  "itoa",
···
 
 [[package]]
 name = "hyper-rustls"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+dependencies = [
+ "futures-util",
+ "http 0.2.12",
+ "hyper 0.14.32",
+ "log",
+ "rustls 0.21.12",
+ "rustls-native-certs 0.6.3",
+ "tokio",
+ "tokio-rustls 0.24.1",
+]
+
+[[package]]
+name = "hyper-rustls"
 version = "0.27.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d191583f3da1305256f22463b9bb0471acad48a4e534a5218b9963e9c1f59b2"
 dependencies = [
  "futures-util",
- "http",
- "hyper",
+ "http 1.3.1",
+ "hyper 1.6.0",
  "hyper-util",
- "rustls",
- "rustls-native-certs",
+ "rustls 0.23.26",
+ "rustls-native-certs 0.8.1",
  "rustls-pki-types",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.26.2",
  "tower-service",
  "webpki-roots 0.26.11",
 ]
···
 dependencies = [
  "bytes",
  "http-body-util",
- "hyper",
+ "hyper 1.6.0",
  "hyper-util",
  "native-tls",
  "tokio",
···
  "bytes",
  "futures-channel",
  "futures-util",
- "http",
- "http-body",
- "hyper",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "hyper 1.6.0",
  "libc",
  "pin-project-lite",
  "socket2",
···
 ]
 
 [[package]]
+name = "image"
+version = "0.25.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db35664ce6b9810857a38a906215e75a9c879f0696556a39f59c62829710251a"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "color_quant",
+ "exr",
+ "gif",
+ "image-webp",
+ "num-traits",
+ "png",
+ "qoi",
+ "ravif",
+ "rayon",
+ "rgb",
+ "tiff",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b77d01e822461baa8409e156015a1d91735549f0f2c17691bd2d996bef238f7f"
+dependencies = [
+ "byteorder-lite",
+ "quick-error",
+]
+
+[[package]]
+name = "imgref"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0263a3d970d5c054ed9312c0057b4f3bde9c0b33836d3637361d4a9e6e7a408"
+
+[[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "equivalent",
  "hashbrown 0.15.3",
+ "serde",
 ]
 
 [[package]]
···
 checksum = "64e9829a50b42bb782c1df523f78d332fe371b10c661e78b7a3c34b0198e9fac"
 
 [[package]]
+name = "infer"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb33622da908807a06f9513c19b3c1ad50fab3e4137d82a78107d502075aa199"
+dependencies = [
+ "cfb",
+]
+
+[[package]]
 name = "inlinable_string"
 version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "interpolate_name"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
 name = "ipconfig"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
 
 [[package]]
+name = "is-terminal"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
+dependencies = [
+ "hermit-abi 0.5.1",
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "is_terminal_polyfill"
 version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "jpeg-decoder"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+
+[[package]]
 name = "js-sys"
 version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "jwt-simple"
+version = "0.12.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "731011e9647a71ff4f8474176ff6ce6e0d2de87a0173f15613af3a84c3e3401a"
+dependencies = [
+ "anyhow",
+ "binstring",
+ "blake2b_simd",
+ "coarsetime",
+ "ct-codecs",
+ "ed25519-compact",
+ "hmac-sha1-compact",
+ "hmac-sha256",
+ "hmac-sha512",
+ "k256",
+ "p256 0.13.2",
+ "p384",
+ "rand 0.8.5",
+ "serde",
+ "serde_json",
+ "superboring",
+ "thiserror 2.0.12",
+ "zeroize",
+]
+
+[[package]]
 name = "k256"
 version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
 dependencies = [
  "cfg-if",
- "ecdsa",
- "elliptic-curve",
+ "ecdsa 0.16.9",
+ "elliptic-curve 0.13.8",
  "once_cell",
  "sha2",
- "signature",
+ "signature 2.2.0",
 ]
 
 [[package]]
···
 checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
+name = "lebe"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
+
+[[package]]
 name = "libc"
 version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf78f52d400cf2d84a3a973a78a592b4adc535739e0a5597a0da6f0c357adc75"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
 
 [[package]]
 name = "libipld"
···
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.30.1"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f"
 dependencies = [
- "cc",
  "pkg-config",
  "vcpkg",
 ]
···
 
 [[package]]
 name = "loom"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff50ecb28bb86013e935fb6683ab1f6d3a20016f123c76fd4c27470076ac30f5"
+dependencies = [
+ "cfg-if",
+ "generator 0.7.5",
+ "scoped-tls",
+ "serde",
+ "serde_json",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "loom"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
 dependencies = [
  "cfg-if",
- "generator",
+ "generator 0.8.4",
  "scoped-tls",
  "tracing",
  "tracing-subscriber",
 ]
 
 [[package]]
+name = "loop9"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
+dependencies = [
+ "imgref",
+]
+
+[[package]]
 name = "lru"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "mailchecker"
+version = "6.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3c69370540384985601e4adbbbc3046a658853e4909a4bd744bb390f6f9759"
+dependencies = [
+ "fast_chemail",
+ "once_cell",
+]
+
+[[package]]
+name = "mailgun-rs"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ce77c6c4195bac30129f854bdff000dee52dddaa7913b6c73df7e7f062398d"
+dependencies = [
+ "reqwest 0.11.27",
+ "serde",
+ "serde_json",
+ "typed-builder",
+]
+
+[[package]]
 name = "matchers"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
 
 [[package]]
+name = "maybe-rayon"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
+dependencies = [
+ "cfg-if",
+ "rayon",
+]
+
+[[package]]
 name = "md-5"
 version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "base64 0.22.1",
  "http-body-util",
- "hyper",
- "hyper-rustls",
+ "hyper 1.6.0",
+ "hyper-rustls 0.27.5",
  "hyper-util",
  "indexmap 2.9.0",
  "ipnet",
···
 ]
 
 [[package]]
+name = "migrations_internals"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f23f71580015254b020e856feac3df5878c2c7a8812297edd6c0a485ac9dada"
+dependencies = [
+ "serde",
+ "toml 0.7.8",
+]
+
+[[package]]
+name = "migrations_macros"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cce3325ac70e67bbab5bd837a31cae01f1a6db64e0e744a33cb03a543469ef08"
+dependencies = [
+ "migrations_internals",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
 name = "mime"
 version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
 dependencies = [
  "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
···
  "crossbeam-utils",
  "event-listener 5.4.0",
  "futures-util",
- "loom",
+ "loom 0.7.2",
  "parking_lot",
  "portable-atomic",
  "rustc_version",
  "smallvec",
  "tagptr",
  "thiserror 1.0.69",
- "uuid",
+ "uuid 1.16.0",
+]
+
+[[package]]
+name = "multer"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http 1.3.1",
+ "httparse",
+ "memchr",
+ "mime",
+ "spin",
+ "tokio",
+ "tokio-util",
+ "version_check",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
 name = "nom"
 version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "noop_proc_macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
+
+[[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
 name = "num-bigint-dig"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
 [[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
 name = "num-integer"
 version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
 name = "num-traits"
 version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.9",
+ "libc",
+]
+
+[[package]]
 name = "num_threads"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "base64 0.22.1",
  "chrono",
  "getrandom 0.2.16",
- "http",
+ "http 1.3.1",
  "rand 0.8.5",
  "serde",
  "serde_json",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "cfg-if",
  "foreign-types",
  "libc",
···
 ]
 
 [[package]]
+name = "outref"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
+
+[[package]]
 name = "overload"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "p256"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51f44edd08f51e2ade572f141051021c5af22677e42b7dd28a88155151c33594"
+dependencies = [
+ "ecdsa 0.14.8",
+ "elliptic-curve 0.12.3",
+ "sha2",
+]
+
+[[package]]
+name = "p256"
 version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b"
 dependencies = [
- "ecdsa",
- "elliptic-curve",
+ "ecdsa 0.16.9",
+ "elliptic-curve 0.13.8",
+ "primeorder",
+ "sha2",
+]
+
+[[package]]
+name = "p384"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6"
+dependencies = [
+ "ecdsa 0.16.9",
+ "elliptic-curve 0.13.8",
  "primeorder",
  "sha2",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
 dependencies = [
- "der",
- "pkcs8",
- "spki",
+ "der 0.7.10",
+ "pkcs8 0.10.2",
+ "spki 0.7.3",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba"
+dependencies = [
+ "der 0.6.1",
+ "spki 0.6.0",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
 dependencies = [
- "der",
- "spki",
+ "der 0.7.10",
+ "spki 0.7.3",
 ]
 
 [[package]]
···
 version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
 
 [[package]]
 name = "polling"
···
 dependencies = [
  "cfg-if",
  "concurrent-queue",
- "hermit-abi",
+ "hermit-abi 0.4.0",
  "pin-project-lite",
  "rustix 0.38.44",
  "tracing",
···
 checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
 dependencies = [
  "zerocopy 0.8.25",
+]
+
+[[package]]
+name = "pq-sys"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31c0052426df997c0cbd30789eb44ca097e3541717a7b8fa36b1c464ee7edebd"
+dependencies = [
+ "vcpkg",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
 dependencies = [
- "elliptic-curve",
+ "elliptic-curve 0.13.8",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "profiling"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a65f2e60fbf1063868558d69c6beacf412dc755f9fc020f514b7955fc914fe30"
+dependencies = [
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "qoi"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
 name = "quanta"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "web-sys",
  "winapi",
 ]
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quick-protobuf"
···
 version = "5.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
+[[package]]
+name = "r2d2"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51de85fb3fb6524929c8a2eb85e6b6d363de4e8c48f9e2c2eac4944abc181c93"
+dependencies = [
+ "log",
+ "parking_lot",
+ "scheduled-thread-pool",
+]
 
 [[package]]
 name = "rand"
···
 ]
 
 [[package]]
+name = "rav1e"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
+dependencies = [
+ "arbitrary",
+ "arg_enum_proc_macro",
+ "arrayvec",
+ "av1-grain",
+ "bitstream-io",
+ "built",
+ "cfg-if",
+ "interpolate_name",
+ "itertools",
+ "libc",
+ "libfuzzer-sys",
+ "log",
+ "maybe-rayon",
+ "new_debug_unreachable",
+ "noop_proc_macro",
+ "num-derive",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "profiling",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "simd_helpers",
+ "system-deps",
+ "thiserror 1.0.69",
+ "v_frame",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ravif"
+version = "0.11.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6a5f31fcf7500f9401fea858ea4ab5525c99f2322cfcee732c0e6c74208c0c6"
+dependencies = [
+ "avif-serialize",
+ "imgref",
+ "loop9",
+ "quick-error",
+ "rav1e",
+ "rayon",
+ "rgb",
+]
+
+[[package]]
 name = "raw-cpuid"
 version = "11.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a0ae411dbe946a674d89546582cea4ba2bb8defac896622d6496f14c23ba5cf"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1165225c21bff1f3bbce98f5a1f889949bc902d3575308cc7b0de30b4f6d27c7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "regex-lite"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
+
+[[package]]
 name = "regex-syntax"
 version = "0.6.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "reqwest"
+version = "0.11.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "hyper 0.14.32",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper 0.1.2",
+ "system-configuration 0.5.1",
+ "tokio",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "winreg",
+]
+
+[[package]]
+name = "reqwest"
 version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d19c46a6fdd48bc4dab94b6103fccc55d34c67cc0ad04653aad4ea2a07cd7bbb"
···
  "base64 0.22.1",
  "bytes",
  "encoding_rs",
+ "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
+ "h2 0.4.9",
  "hickory-resolver",
- "http",
- "http-body",
+ "http 1.3.1",
+ "http-body 1.0.1",
  "http-body-util",
- "hyper",
- "hyper-rustls",
+ "hyper 1.6.0",
+ "hyper-rustls 0.27.5",
  "hyper-tls",
  "hyper-util",
  "ipnet",
···
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
- "rustls",
- "rustls-pemfile",
+ "rustls 0.23.26",
+ "rustls-pemfile 2.2.0",
  "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sync_wrapper",
- "system-configuration",
+ "sync_wrapper 1.0.2",
+ "system-configuration 0.6.1",
  "tokio",
  "tokio-native-tls",
- "tokio-rustls",
+ "tokio-rustls 0.26.2",
  "tokio-util",
  "tower",
  "tower-service",
···
 dependencies = [
  "anyhow",
  "async-trait",
- "http",
- "reqwest",
+ "http 1.3.1",
+ "reqwest 0.12.15",
  "serde",
  "thiserror 1.0.69",
  "tower-service",
···
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc7c8f7f733062b66dc1c63f9db168ac0b97a9210e247fa90fdc9ad08f51b302"
+
+[[package]]
+name = "rfc6979"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb"
+dependencies = [
+ "crypto-bigint 0.4.9",
+ "hmac",
+ "zeroize",
+]
 
 [[package]]
 name = "rfc6979"
···
 ]
 
 [[package]]
+name = "rgb"
+version = "0.8.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"
+
+[[package]]
 name = "ring"
 version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "rocket"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a516907296a31df7dc04310e7043b61d71954d703b603cc6867a026d7e72d73f"
+dependencies = [
+ "async-stream",
+ "async-trait",
+ "atomic 0.5.3",
+ "binascii",
+ "bytes",
+ "either",
+ "figment",
+ "futures",
+ "indexmap 2.9.0",
+ "log",
+ "memchr",
+ "multer",
+ "num_cpus",
+ "parking_lot",
+ "pin-project-lite",
+ "rand 0.8.5",
+ "ref-cast",
+ "rocket_codegen",
+ "rocket_http",
+ "serde",
+ "serde_json",
+ "state",
+ "tempfile",
+ "time",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "ubyte",
+ "version_check",
+ "yansi",
+]
+
+[[package]]
+name = "rocket_codegen"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "575d32d7ec1a9770108c879fc7c47815a80073f96ca07ff9525a94fcede1dd46"
+dependencies = [
+ "devise",
+ "glob",
+ "indexmap 2.9.0",
+ "proc-macro2",
+ "quote",
+ "rocket_http",
+ "syn 2.0.101",
+ "unicode-xid",
+ "version_check",
+]
+
+[[package]]
+name = "rocket_http"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e274915a20ee3065f611c044bd63c40757396b6dbc057d6046aec27f14f882b9"
+dependencies = [
+ "cookie",
+ "either",
+ "futures",
+ "http 0.2.12",
+ "hyper 0.14.32",
+ "indexmap 2.9.0",
+ "log",
+ "memchr",
+ "pear",
+ "percent-encoding",
+ "pin-project-lite",
+ "ref-cast",
+ "rustls 0.21.12",
+ "rustls-pemfile 1.0.4",
+ "serde",
+ "smallvec",
+ "stable-pattern",
+ "state",
+ "time",
+ "tokio",
+ "tokio-rustls 0.24.1",
+ "uncased",
+]
+
+[[package]]
+name = "rocket_sync_db_pools"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d83f32721ed79509adac4328e97f817a8f55a47c4b64799f6fd6cc3adb6e42ff"
+dependencies = [
+ "diesel",
+ "r2d2",
+ "rocket",
+ "rocket_sync_db_pools_codegen",
+ "serde",
+ "tokio",
+ "version_check",
+]
+
+[[package]]
+name = "rocket_sync_db_pools_codegen"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc890925dc79370c28eb15c9957677093fdb7e8c44966d189f38cedb995ee68"
+dependencies = [
+ "devise",
+ "quote",
+]
+
+[[package]]
+name = "rocket_ws"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f1877668c937b701177c349f21383c556cd3bb4ba8fa1d07fa96ccb3a8782e"
+dependencies = [
+ "rocket",
+ "tokio-tungstenite 0.21.0",
+]
+
+[[package]]
 name = "rsa"
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "num-integer",
  "num-traits",
  "pkcs1",
- "pkcs8",
+ "pkcs8 0.10.2",
  "rand_core 0.6.4",
- "signature",
- "spki",
+ "sha2",
+ "signature 2.2.0",
+ "spki 0.7.3",
  "subtle",
  "zeroize",
 ]
···
 [[package]]
 name = "rsky-common"
 version = "0.1.1"
-source = "git+https://github.com/blacksky-algorithms/rsky.git#37954845d06aaafea2b914d9096a1657abfc8d75"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
 dependencies = [
  "anyhow",
  "base64ct",
···
 [[package]]
 name = "rsky-crypto"
 version = "0.1.2"
-source = "git+https://github.com/blacksky-algorithms/rsky.git#37954845d06aaafea2b914d9096a1657abfc8d75"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
 dependencies = [
  "anyhow",
  "multibase",
- "p256",
+ "p256 0.13.2",
  "secp256k1",
  "unsigned-varint 0.8.0",
 ]
···
 [[package]]
 name = "rsky-identity"
 version = "0.1.0"
-source = "git+https://github.com/blacksky-algorithms/rsky.git#37954845d06aaafea2b914d9096a1657abfc8d75"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
 dependencies = [
  "anyhow",
  "hickory-resolver",
- "reqwest",
+ "reqwest 0.12.15",
  "rsky-crypto",
  "serde",
  "serde_json",
···
 [[package]]
 name = "rsky-lexicon"
 version = "0.2.7"
-source = "git+https://github.com/blacksky-algorithms/rsky.git#37954845d06aaafea2b914d9096a1657abfc8d75"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
 dependencies = [
  "anyhow",
  "chrono",
···
 ]
 
 [[package]]
+name = "rsky-pds"
+version = "0.1.0"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
+dependencies = [
+ "anyhow",
+ "argon2",
+ "async-event-emitter",
+ "atrium-api 0.24.10",
+ "atrium-xrpc-client",
+ "aws-config",
+ "aws-sdk-s3",
+ "base64 0.22.1",
+ "base64-url",
+ "base64ct",
+ "chrono",
+ "cid 0.10.1",
+ "data-encoding",
+ "diesel",
+ "dotenvy",
+ "email_address",
+ "event-emitter-rs",
+ "futures",
+ "hex",
+ "image",
+ "indexmap 1.9.3",
+ "infer 0.15.0",
+ "ipld-core",
+ "jwt-simple",
+ "lazy_static",
+ "libipld",
+ "mailchecker",
+ "mailgun-rs",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
+ "regex",
+ "reqwest 0.12.15",
+ "rocket",
+ "rocket_sync_db_pools",
+ "rocket_ws",
+ "rsky-common",
+ "rsky-crypto",
+ "rsky-identity",
+ "rsky-lexicon",
+ "rsky-repo",
+ "rsky-syntax",
+ "secp256k1",
+ "serde",
+ "serde_bytes",
+ "serde_cbor",
+ "serde_derive",
+ "serde_ipld_dagcbor",
+ "serde_json",
+ "serde_repr",
+ "sha2",
+ "thiserror 1.0.69",
+ "time",
+ "tokio",
+ "toml 0.8.22",
+ "tracing",
+ "tracing-subscriber",
+ "url",
+]
+
+[[package]]
 name = "rsky-repo"
 version = "0.0.1"
-source = "git+https://github.com/blacksky-algorithms/rsky.git#37954845d06aaafea2b914d9096a1657abfc8d75"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
 dependencies = [
  "anyhow",
  "async-recursion",
···
 [[package]]
 name = "rsky-syntax"
 version = "0.1.0"
-source = "git+https://github.com/blacksky-algorithms/rsky.git#37954845d06aaafea2b914d9096a1657abfc8d75"
+source = "git+https://github.com/blacksky-algorithms/rsky.git#e35b4c49d37df99bd2abee9307bf7d1afadc40c9"
 dependencies = [
  "anyhow",
  "chrono",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "errno",
  "libc",
  "linux-raw-sys 0.9.4",
···
 
 [[package]]
 name = "rustls"
+version = "0.21.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-webpki 0.101.7",
+ "sct",
+]
+
+[[package]]
+name = "rustls"
 version = "0.23.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df51b5869f3a441595eac5e8ff14d486ff285f7b8c0df8770e49c3b56351f0f0"
···
  "aws-lc-rs",
  "once_cell",
  "rustls-pki-types",
- "rustls-webpki",
+ "rustls-webpki 0.103.1",
  "subtle",
  "zeroize",
 ]
 
 [[package]]
 name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile 1.0.4",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
+[[package]]
+name = "rustls-native-certs"
 version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
···
 
 [[package]]
 name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pemfile"
 version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
···
 version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "917ce264624a4b4db1c364dcc35bfca9ded014d0a958cd47ad3e960e988ea51c"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted",
+]
 
 [[package]]
 name = "rustls-webpki"
···
 ]
 
 [[package]]
+name = "scheduled-thread-pool"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cbc66816425a074528352f5789333ecff06ca41b36b0b0efdfbb29edc391a19"
+dependencies = [
+ "parking_lot",
+]
+
+[[package]]
 name = "scoped-tls"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "sec1"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928"
+dependencies = [
+ "base16ct 0.1.1",
+ "der 0.6.1",
+ "generic-array",
+ "pkcs8 0.9.0",
+ "subtle",
+ "zeroize",
+]
 
 [[package]]
 name = "sec1"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
- "base16ct",
- "der",
+ "base16ct 0.2.0",
+ "der 0.7.10",
  "generic-array",
- "pkcs8",
+ "pkcs8 0.10.2",
  "subtle",
  "zeroize",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "core-foundation 0.10.0",
  "core-foundation-sys",
  "libc",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
 dependencies = [
- "half",
+ "half 1.8.3",
  "serde",
 ]
 
···
 ]
 
 [[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
+[[package]]
 name = "serde_spanned"
 version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "signature"
+version = "1.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
+dependencies = [
+ "digest",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "signature"
 version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
···
 ]
 
 [[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
+[[package]]
+name = "simd_helpers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
+dependencies = [
+ "quote",
+]
+
+[[package]]
 name = "sketches-ddsketch"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
-dependencies = [
- "serde",
-]
 
 [[package]]
 name = "socket2"
···
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-dependencies = [
- "lock_api",
-]
 
 [[package]]
 name = "spki"
-version = "0.7.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b"
 dependencies = [
  "base64ct",
- "der",
-]
-
-[[package]]
-name = "sqlx"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3a85280daca669cfd3bcb68a337882a8bc57ec882f72c5d13a430613a738e"
-dependencies = [
- "sqlx-core",
- "sqlx-macros",
- "sqlx-mysql",
- "sqlx-postgres",
- "sqlx-sqlite",
-]
-
-[[package]]
-name = "sqlx-core"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f743f2a3cea30a58cd479013f75550e879009e3a02f616f18ca699335aa248c3"
-dependencies = [
- "base64 0.22.1",
- "bytes",
- "crc",
- "crossbeam-queue",
- "either",
- "event-listener 5.4.0",
- "futures-core",
- "futures-intrusive",
- "futures-io",
- "futures-util",
- "hashbrown 0.15.3",
- "hashlink",
- "indexmap 2.9.0",
- "log",
- "memchr",
- "once_cell",
- "percent-encoding",
- "serde",
- "serde_json",
- "sha2",
- "smallvec",
- "thiserror 2.0.12",
- "tokio",
- "tokio-stream",
- "tracing",
- "url",
+ "der 0.6.1",
 ]
 
 [[package]]
-name = "sqlx-macros"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4200e0fde19834956d4252347c12a083bdcb237d7a1a1446bffd8768417dce"
-dependencies = [
- "proc-macro2",
- "quote",
- "sqlx-core",
- "sqlx-macros-core",
- "syn 2.0.101",
-]
-
-[[package]]
-name = "sqlx-macros-core"
-version = "0.8.5"
+name = "spki"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882ceaa29cade31beca7129b6beeb05737f44f82dbe2a9806ecea5a7093d00b7"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
 dependencies = [
- "dotenvy",
- "either",
- "heck",
- "hex",
- "once_cell",
- "proc-macro2",
- "quote",
- "serde",
- "serde_json",
- "sha2",
- "sqlx-core",
- "sqlx-mysql",
- "sqlx-postgres",
- "sqlx-sqlite",
- "syn 2.0.101",
- "tempfile",
- "tokio",
- "url",
+ "base64ct",
+ "der 0.7.10",
 ]
 
 [[package]]
-name = "sqlx-mysql"
-version = "0.8.5"
+name = "stable-pattern"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0afdd3aa7a629683c2d750c2df343025545087081ab5942593a5288855b1b7a7"
+checksum = "4564168c00635f88eaed410d5efa8131afa8d8699a612c80c455a0ba05c21045"
 dependencies = [
- "atoi",
- "base64 0.22.1",
- "bitflags",
- "byteorder",
- "bytes",
- "crc",
- "digest",
- "dotenvy",
- "either",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-util",
- "generic-array",
- "hex",
- "hkdf",
- "hmac",
- "itoa",
- "log",
- "md-5",
  "memchr",
- "once_cell",
- "percent-encoding",
- "rand 0.8.5",
- "rsa",
- "serde",
- "sha1",
- "sha2",
- "smallvec",
- "sqlx-core",
- "stringprep",
- "thiserror 2.0.12",
- "tracing",
- "whoami",
-]
-
-[[package]]
-name = "sqlx-postgres"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0bedbe1bbb5e2615ef347a5e9d8cd7680fb63e77d9dafc0f29be15e53f1ebe6"
-dependencies = [
- "atoi",
- "base64 0.22.1",
- "bitflags",
- "byteorder",
- "crc",
- "dotenvy",
- "etcetera",
- "futures-channel",
- "futures-core",
- "futures-util",
- "hex",
- "hkdf",
- "hmac",
- "home",
- "itoa",
- "log",
- "md-5",
- "memchr",
- "once_cell",
- "rand 0.8.5",
- "serde",
- "serde_json",
- "sha2",
- "smallvec",
- "sqlx-core",
- "stringprep",
- "thiserror 2.0.12",
- "tracing",
- "whoami",
-]
-
-[[package]]
-name = "sqlx-sqlite"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c26083e9a520e8eb87a06b12347679b142dc2ea29e6e409f805644a7a979a5bc"
-dependencies = [
- "atoi",
- "flume",
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-intrusive",
- "futures-util",
- "libsqlite3-sys",
- "log",
- "percent-encoding",
- "serde",
- "serde_urlencoded",
- "sqlx-core",
- "thiserror 2.0.12",
- "tracing",
- "url",
 ]
 
 [[package]]
···
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
-name = "stringprep"
-version = "0.1.5"
+name = "state"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
+checksum = "2b8c4a4445d81357df8b1a650d0d0d6fbbbfe99d064aa5e02f3e4022061476d8"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
- "unicode-properties",
+ "loom 0.5.6",
 ]
 
 [[package]]
···
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
+name = "superboring"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "515cce34a781d7250b8a65706e0f2a5b99236ea605cb235d4baed6685820478f"
+dependencies = [
+ "getrandom 0.2.16",
+ "hmac-sha256",
+ "hmac-sha512",
+ "rand 0.8.5",
+ "rsa",
+]
+
+[[package]]
 name = "syn"
 version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "quote",
  "unicode-ident",
 ]
+
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
 [[package]]
 name = "sync_wrapper"
···
 
 [[package]]
 name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "system-configuration-sys 0.5.0",
+]
+
+[[package]]
+name = "system-configuration"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "core-foundation 0.9.4",
- "system-configuration-sys",
+ "system-configuration-sys 0.6.0",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck",
+ "pkg-config",
+ "toml 0.8.22",
+ "version-compare",
+]
+
+[[package]]
 name = "tagptr"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tempfile"
···
 dependencies = [
  "cfg-if",
  "once_cell",
+]
+
+[[package]]
+name = "tiff"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
+dependencies = [
+ "flate2",
+ "jpeg-decoder",
+ "weezl",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.12",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
 version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b"
 dependencies = [
- "rustls",
+ "rustls 0.23.26",
  "tokio",
 ]
 
···
 
 [[package]]
 name = "tokio-tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite 0.21.0",
+]
+
+[[package]]
+name = "tokio-tungstenite"
 version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
···
  "futures-util",
  "log",
  "tokio",
- "tungstenite",
+ "tungstenite 0.26.2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "toml"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "toml"
 version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
···
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit",
+ "toml_edit 0.22.26",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.9.0",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
 version = "0.22.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
···
  "serde_spanned",
  "toml_datetime",
  "toml_write",
- "winnow",
+ "winnow 0.7.9",
 ]
 
 [[package]]
···
  "futures-core",
  "futures-util",
  "pin-project-lite",
- "sync_wrapper",
+ "sync_wrapper 1.0.2",
  "tokio",
  "tower-layer",
  "tower-service",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "403fa3b783d4b626a8ad51d766ab03cb6d2dbfc46b1c5d4448395e6628dc9697"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
  "bytes",
  "futures-util",
- "http",
- "http-body",
+ "http 1.3.1",
+ "http-body 1.0.1",
  "http-body-util",
  "http-range-header",
  "httpdate",
···
 
 [[package]]
 name = "tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http 1.3.1",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror 1.0.69",
+ "url",
+ "utf-8",
+]
+
+[[package]]
+name = "tungstenite"
 version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
 dependencies = [
  "bytes",
  "data-encoding",
- "http",
+ "http 1.3.1",
  "httparse",
  "log",
  "rand 0.9.1",
  "sha1",
  "thiserror 2.0.12",
  "utf-8",
+]
+
+[[package]]
+name = "typed-builder"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe83c85a85875e8c4cb9ce4a890f05b23d38cd0d47647db7895d3d2a79566d2"
+dependencies = [
+ "typed-builder-macro",
+]
+
+[[package]]
+name = "typed-builder-macro"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29a3151c41d0b13e3d011f98adc24434560ef06673a155a6c7f66b9879eecce2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
 ]
 
 [[package]]
···
  "http-types",
  "pin-project",
  "rand 0.8.5",
- "reqwest",
+ "reqwest 0.12.15",
  "serde",
  "serde_json",
  "time",
···
  "typespec",
  "typespec_macros",
  "url",
- "uuid",
+ "uuid 1.16.0",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "ubyte"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f720def6ce1ee2fc44d40ac9ed6d3a59c361c80a75a7aa8e75bb9baed31cf2ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "uncased"
 version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697"
 dependencies = [
+ "serde",
  "version_check",
 ]
 
···
 checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
 
 [[package]]
-name = "unicode-bidi"
-version = "0.3.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
-
-[[package]]
 name = "unicode-ident"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
-name = "unicode-normalization"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-properties"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0"
-
-[[package]]
 name = "unicode-width"
 version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "uuid"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
+dependencies = [
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "uuid"
 version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
···
 ]
 
 [[package]]
+name = "v_frame"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f32aaa24bacd11e488aa9ba66369c7cd514885742c9fe08cfe85884db3e92b"
+dependencies = [
+ "aligned-vec",
+ "num-traits",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "valuable"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
+name = "version-compare"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
+
+[[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
+[[package]]
 name = "waker-fn"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "wasite"
-version = "0.1.0"
+name = "wasix"
+version = "0.12.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+checksum = "c1fbb4ef9bbca0c1170e0b00dd28abc9e3b68669821600cad1caaed606583c6d"
+dependencies = [
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
 
 [[package]]
 name = "wasm-bindgen"
···
 ]
 
 [[package]]
+name = "weezl"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+
+[[package]]
 name = "which"
 version = "4.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "home",
  "once_cell",
  "rustix 0.38.44",
-]
-
-[[package]]
-name = "whoami"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6994d13118ab492c3c80c1f81928718159254c53c472bf9ce36f8dae4add02a7"
-dependencies = [
- "redox_syscall",
- "wasite",
 ]
 
 [[package]]
···
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
+dependencies = [
+ "windows-targets 0.48.5",
+]
 
 [[package]]
 name = "windows"
···
 
 [[package]]
 name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
 version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9fb597c990f03753e08d3c29efbfcf2019a003b4bf4ba19225c158e1549f0f3"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.0",
 ]
 
 [[package]]
···
 checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
 
 [[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
+[[package]]
 name = "yansi"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+dependencies = [
+ "is-terminal",
+]
 
 [[package]]
 name = "yoke"
···
  "quote",
  "syn 2.0.101",
 ]
+
+[[package]]
+name = "zune-core"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
+
+[[package]]
+name = "zune-inflate"
+version = "0.2.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "zune-jpeg"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99a5bab8d7dedf81405c4bb1f2b83ea057643d9cb28778cea9eecddeedd2e028"
+dependencies = [
+ "zune-core",
+]

Cargo.toml

···
 # expect_used = "deny"
 
 [dependencies]
+multihash = "0.19.3"
+diesel = { version = "2.1.5", features = ["chrono", "sqlite", "r2d2"] }
+diesel_migrations = { version = "2.1.0" }
+r2d2 = "0.8.10"
+
+atrium-repo = "0.1"
 atrium-api = "0.25"
+# atrium-common = { version = "0.1.2", path = "atrium-common" }
 atrium-crypto = "0.1"
-atrium-repo = "0.1"
+# atrium-identity = { version = "0.1.4", path = "atrium-identity" }
 atrium-xrpc = "0.12"
 atrium-xrpc-client = "0.5"
+# bsky-sdk = { version = "0.1.19", path = "bsky-sdk" }
+rsky-syntax = { git = "https://github.com/blacksky-algorithms/rsky.git" }
+rsky-repo = { git = "https://github.com/blacksky-algorithms/rsky.git" }
+rsky-pds = { git = "https://github.com/blacksky-algorithms/rsky.git" }
+rsky-common = { git = "https://github.com/blacksky-algorithms/rsky.git" }
 
+# async in streams
+# async-stream = "0.3"
+
+# DAG-CBOR codec
+ipld-core = "0.4.2"
+serde_ipld_dagcbor = { version = "0.6.2", default-features = false, features = [
+    "std",
+] }
+serde_ipld_dagjson = "0.2.0"
+cidv10 = { version = "0.10.1", package = "cid" }
+
+# Parsing and validation
+base64 = "0.22.1"
+chrono = "0.4.39"
+hex = "0.4.3"
+# langtag = "0.3"
+# multibase = "0.9.1"
+regex = "1.11.1"
+serde = { version = "1.0.218", features = ["derive"] }
+serde_bytes = "0.11.17"
+# serde_html_form = "0.2.6"
+serde_json = "1.0.139"
+# unsigned-varint = "0.8"
+
+# Cryptography
+# ecdsa = "0.16.9"
+# elliptic-curve = "0.13.6"
+# jose-jwa = "0.1.2"
+# jose-jwk = { version = "0.1.2", default-features = false }
+k256 = "0.13.4"
+# p256 = { version = "0.13.2", default-features = false }
+rand = "0.8.5"
+sha2 = "0.10.8"
+
+# Networking
+# dashmap = "6.1.0"
+futures = "0.3.31"
+# hickory-proto = { version = "0.24.3", default-features = false }
+# hickory-resolver = "0.24.1"
+# http = "1.1.0"
+# lru = "0.12.4"
+# moka = "0.12.8"
+tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread"] }
+tokio-util = { version = "0.7.13", features = ["io"] }
+
+# HTTP client integrations
+# isahc = "1.7.2"
+reqwest = { version = "0.12.12", features = ["json"] }
+
+# Errors
 anyhow = "1.0.96"
+thiserror = "2.0.11"
+
+# CLI
+clap = { version = "4.5.30", features = ["derive"] }
+# dirs = "5.0.1"
+
+# Testing
+# gloo-timers = { version = "0.3.0", features = ["futures"] }
+# mockito = "=1.6.1"
+
+# WebAssembly
+# wasm-bindgen-test = "0.3.41"
+# web-time = "1.1.0"
+# bumpalo = "~3.14.0"
+
+# Code generation
+# trait-variant = "0.1.2"
+
+# Others
+# base64ct = "=1.6.0"
+# litemap = "=0.7.4"
+# native-tls = "=0.2.13"
+# zerofrom = "=0.1.5"
 argon2 = { version = "0.5.3", features = ["std"] }
 axum = { version = "0.8.1", features = [
     "tower-log",
···
 azure_core = "0.22.0"
 azure_identity = "0.22.0"
 base32 = "0.5.1"
-base64 = "0.22.1"
-chrono = "0.4.39"
-clap = { version = "4.5.30", features = ["derive"] }
 clap-verbosity-flag = "3.0.2"
 constcat = "0.6.0"
 figment = { version = "0.10.19", features = ["toml", "env"] }
-futures = "0.3.31"
 http-cache-reqwest = { version = "0.15.1", default-features = false, features = [
     "manager-moka",
 ] }
 memmap2 = "0.9.5"
 metrics = "0.24.1"
 metrics-exporter-prometheus = "0.16.2"
-rand = "0.8.5"
-reqwest = { version = "0.12.12", features = ["json"] }
 reqwest-middleware = { version = "0.4.0", features = ["json"] }
-serde = { version = "1.0.218", features = ["derive"] }
-serde_ipld_dagcbor = { version = "0.6.2", default-features = false, features = ["std"] }
-serde_json = "1.0.139"
-sha2 = "0.10.8"
-sqlx = { version = "0.8.3", features = ["json", "runtime-tokio", "sqlite"] }
-thiserror = "2.0.11"
-tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread"] }
-tokio-util = { version = "0.7.13", features = ["io"] }
 tower-http = { version = "0.6.2", features = ["cors", "fs", "trace"] }
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
···
 uuid = { version = "1.14.0", features = ["v4"] }
 urlencoding = "2.1.3"
 async-trait = "0.1.88"
-k256 = "0.13.4"
-hex = "0.4.3"
-ipld-core = "0.4.2"
 lazy_static = "1.5.0"
-regex = "1.11.1"
-rsky-syntax = { git = "https://github.com/blacksky-algorithms/rsky.git" }
-rsky-repo = { git = "https://github.com/blacksky-algorithms/rsky.git" }
-serde_bytes = "0.11.17"
-multihash = "0.19.3"
-serde_ipld_dagjson = "0.2.0"

src/actor_store/actor_store.rs

···
 
 use super::ActorDb;
 use super::actor_store_reader::ActorStoreReader;
+use super::actor_store_resources::ActorStoreResources;
 use super::actor_store_transactor::ActorStoreTransactor;
 use super::actor_store_writer::ActorStoreWriter;
-use super::resources::ActorStoreResources;
 use crate::SigningKey;
 
 pub(crate) struct ActorStore {

src/actor_store/actor_store_reader.rs

···
 use anyhow::Result;
+use diesel::prelude::*;
 use std::sync::Arc;
 
 use super::{
···
     /// Function to get keypair.
     keypair_fn: Box<dyn Fn() -> Result<Arc<SigningKey>> + Send + Sync>,
     /// Database connection.
-    db: ActorDb,
+    pub(crate) db: ActorDb,
     /// Actor store resources.
     resources: ActorStoreResources,
 }
···
         keypair: impl Fn() -> Result<Arc<SigningKey>> + Send + Sync + 'static,
     ) -> Self {
         // Create readers
-        let record = RecordReader::new(db.clone());
-        let pref = PreferenceReader::new(db.clone());
+        let record = RecordReader::new(db.clone(), did.clone());
+        let pref = PreferenceReader::new(db.clone(), did.clone());
 
         // Store keypair function for later use
         let keypair_fn = Box::new(keypair);
···
         let _ = keypair_fn();
 
         // Create repo reader
-        let repo = RepoReader::new(db.clone(), resources.blobstore(did.clone()));
+        let repo = RepoReader::new(db.clone(), resources.blobstore(did.clone()), did.clone());
 
         Self {
             did,
···
     /// Execute a transaction with the actor store.
     pub(crate) async fn transact<T, F>(&self, f: F) -> Result<T>
     where
-        F: FnOnce(ActorStoreTransactor) -> Result<T>,
+        F: FnOnce(ActorStoreTransactor) -> Result<T> + Send,
+        T: Send + 'static,
     {
         let keypair = self.keypair()?;
         let did = self.did.clone();
         let resources = self.resources.clone();
 
         self.db
-            .transaction_no_retry(move |tx| {
+            .transaction(move |conn| {
                 // Create a transactor with the transaction
-                let store = ActorStoreTransactor::new_with_transaction(
-                    did,
-                    tx, // Pass the transaction directly
-                    keypair.clone(),
-                    resources,
-                );
+                // We'll create a temporary ActorDb with the same pool
+                let db = ActorDb {
+                    pool: self.db.pool.clone(),
+                };
+
+                let store = ActorStoreTransactor::new(did, db, keypair.clone(), resources);
 
                 // Execute user function
-                f(store).map_err(|e| sqlx::Error::Custom(Box::new(e))) // Convert anyhow::Error to sqlx::Error
+                f(store)
             })
             .await
-            .map_err(|e| anyhow::anyhow!("Transaction error: {:?}", e))
     }
 }

src/actor_store/actor_store_resources.rs

···
-use crate::repo::types::BlobStore;
-
-use super::blob::BackgroundQueue;
+use super::blob::{BackgroundQueue, BlobStorePlaceholder};
 pub(crate) struct ActorStoreResources {
-    pub(crate) blobstore: fn(did: String) -> BlobStore,
+    pub(crate) blobstore: fn(did: String) -> BlobStorePlaceholder,
     pub(crate) background_queue: BackgroundQueue,
     pub(crate) reserved_key_dir: Option<String>,
 }
 impl ActorStoreResources {
     pub(crate) fn new(
-        blobstore: fn(did: String) -> BlobStore,
+        blobstore: fn(did: String) -> BlobStorePlaceholder,
         background_queue: BackgroundQueue,
         reserved_key_dir: Option<String>,
     ) -> Self {
···
         }
     }
 
-    pub(crate) fn blobstore(&self, did: String) -> BlobStore {
+    pub(crate) fn blobstore(&self, did: String) -> BlobStorePlaceholder {
         (self.blobstore)(did)
     }
 }

src/actor_store/blob/background.rs

···
+use std::future::Future;
 use std::sync::Arc;
 use tokio::sync::{Mutex, Semaphore};
 use tokio::task::{self, JoinHandle};
 use tracing::error;
 
-/// Background Queue
+/// Background Queue for asynchronous processing tasks
+///
 /// A simple queue for in-process, out-of-band/backgrounded work
+#[derive(Clone)]
 pub struct BackgroundQueue {
     semaphore: Arc<Semaphore>,
     tasks: Arc<Mutex<Vec<JoinHandle<()>>>>,
···
     }
 
     /// Add a task to the queue
-    pub async fn add<F>(&self, fut: F)
+    pub async fn add<F>(&self, future: F)
     where
         F: Future<Output = ()> + Send + 'static,
     {
···
             return;
         }
 
-        let permit = self.semaphore.clone().acquire_owned().await.unwrap();
+        let permit = match self.semaphore.clone().acquire_owned().await {
+            Ok(p) => p,
+            Err(_) => {
+                error!("Failed to acquire semaphore permit for background task");
+                return;
+            }
+        };
+
         let tasks = self.tasks.clone();
 
         let handle = task::spawn(async move {
-            _ = fut.await;
+            future.await;
+
+            // Catch any panics to prevent task failures from propagating
             if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {})) {
-                error!("background queue task panicked: {:?}", e);
+                error!("Background queue task panicked: {:?}", e);
             }
+
+            // Release the semaphore permit
             drop(permit);
         });
 
+        // Store the handle for later cleanup
         tasks.lock().await.push(handle);
     }
 

src/actor_store/blob/mod.rs

···
+// bluepds/src/actor_store/blob/mod.rs
+
 //! Blob storage and retrieval for the actor store.
 
-mod background;
-mod reader;
-mod store;
-mod transactor;
+use std::str::FromStr;
+
+use anyhow::{Context as _, Result, bail};
+use atrium_api::com::atproto::admin::defs::StatusAttr;
+use atrium_repo::Cid;
+use diesel::associations::HasTable as _;
+use diesel::prelude::*;
+use futures::{StreamExt, future::try_join_all};
+use rsky_common::ipld::sha256_raw_to_cid;
+use rsky_pds::actor_store::blob::sha256_stream;
+use rsky_pds::image::{maybe_get_info, mime_type_from_bytes};
+use rsky_pds::schema::pds::*;
+use rsky_repo::types::{PreparedBlobRef, PreparedWrite, WriteOpAction};
+use sha2::Digest;
+use uuid::Uuid;
+
+use crate::actor_store::PreparedWrite as BluePreparedWrite;
+use crate::actor_store::db::ActorDb;
+
+/// Background task queue for blob operations
+pub mod background;
+// Re-export BackgroundQueue
+pub use background::BackgroundQueue;
+
+pub mod placeholder;
+pub(crate) use placeholder::BlobStorePlaceholder;
+
+/// Type for stream of blob data
+pub type BlobStream = Box<dyn std::io::Read + Send>;
+
+/// Blob store interface
+pub trait BlobStore: Send + Sync {
+    async fn put_temp(&self, bytes: &[u8]) -> Result<String>;
+    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()>;
+    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()>;
+    async fn quarantine(&self, cid: Cid) -> Result<()>;
+    async fn unquarantine(&self, cid: Cid) -> Result<()>;
+    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>>;
+    async fn get_stream(&self, cid: Cid) -> Result<BlobStream>;
+    async fn has_temp(&self, key: &str) -> Result<bool>;
+    async fn has_stored(&self, cid: Cid) -> Result<bool>;
+    async fn delete(&self, cid: Cid) -> Result<()>;
+    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()>;
+}
+
+/// Blob metadata for upload
+pub struct BlobMetadata {
+    pub temp_key: String,
+    pub size: i64,
+    pub cid: Cid,
+    pub mime_type: String,
+    pub width: Option<i32>,
+    pub height: Option<i32>,
+}
+
+/// Blob data with content stream
+pub struct BlobData {
+    pub size: u64,
+    pub mime_type: Option<String>,
+    pub stream: BlobStream,
+}
+
+/// Options for listing blobs
+pub struct ListBlobsOptions {
+    pub since: Option<String>,
+    pub cursor: Option<String>,
+    pub limit: i64,
+}
+
+/// Options for listing missing blobs
+pub struct ListMissingBlobsOptions {
+    pub cursor: Option<String>,
+    pub limit: i64,
+}
+
+/// Information about a missing blob
+pub struct MissingBlob {
+    pub cid: String,
+    pub record_uri: String,
+}
+
+/// Unified handler for blob operations
+pub struct BlobHandler {
+    /// Database connection
+    pub db: ActorDb,
+    /// DID of the actor
+    pub did: String,
+    /// Blob store implementation
+    pub blobstore: Box<dyn BlobStore>,
+    /// Background queue for async operations
+    pub background_queue: Option<background::BackgroundQueue>,
+}
+
+impl BlobHandler {
+    /// Create a new blob handler for read operations
+    pub fn new_reader(db: ActorDb, blobstore: impl BlobStore + 'static, did: String) -> Self {
+        Self {
+            db,
+            did,
+            blobstore: Box::new(blobstore),
+            background_queue: None,
+        }
+    }
+
+    /// Create a new blob handler with background queue for write operations
+    pub fn new_writer(
+        db: ActorDb,
+        blobstore: impl BlobStore + 'static,
+        background_queue: background::BackgroundQueue,
+        did: String,
+    ) -> Self {
+        Self {
+            db,
+            did,
+            blobstore: Box::new(blobstore),
+            background_queue: Some(background_queue),
+        }
+    }
+
+    /// Get metadata for a blob
+    pub async fn get_blob_metadata(&self, cid: &Cid) -> Result<BlobMetadata> {
+        let cid_str = cid.to_string();
+        let did = self.did.clone();
+
+        let found = self
+            .db
+            .run(move |conn| {
+                blob::table
+                    .filter(blob::cid.eq(&cid_str))
+                    .filter(blob::did.eq(&did))
+                    .filter(blob::takedownRef.is_null())
+                    .first::<BlobModel>(conn)
+                    .optional()
+            })
+            .await?;
+
+        match found {
+            Some(found) => Ok(BlobMetadata {
+                temp_key: found.temp_key.unwrap_or_default(),
+                size: found.size as i64,
+                cid: Cid::from_str(&found.cid)?,
+                mime_type: found.mime_type,
+                width: found.width,
+                height: found.height,
+            }),
+            None => bail!("Blob not found"),
+        }
+    }
 
-pub(crate) use background::BackgroundQueue;
-pub(crate) use reader::BlobReader;
-pub(crate) use store::BlobStore;
-pub(crate) use store::BlobStorePlaceholder;
-pub(crate) use store::BlobStream;
-pub(crate) use transactor::BlobTransactor;
+    /// Get a blob's complete data
+    pub async fn get_blob(&self, cid: &Cid) -> Result<BlobData> {
+        let metadata = self.get_blob_metadata(cid).await?;
+        let blob_stream = self.blobstore.get_stream(*cid).await?;
+
+        Ok(BlobData {
+            size: metadata.size as u64,
+            mime_type: Some(metadata.mime_type),
+            stream: blob_stream,
+        })
+    }
+
+    /// List blobs for a repository
+    pub async fn list_blobs(&self, opts: ListBlobsOptions) -> Result<Vec<String>> {
+        let did = self.did.clone();
+        let since = opts.since;
+        let cursor = opts.cursor;
+        let limit = opts.limit;
+
+        self.db
+            .run(move |conn| {
+                let mut query = record_blob::table
+                    .inner_join(
+                        crate::schema::record::table
+                            .on(crate::schema::record::uri.eq(record_blob::record_uri)),
+                    )
+                    .filter(record_blob::did.eq(&did))
+                    .select(record_blob::blob_cid)
+                    .distinct()
+                    .order(record_blob::blob_cid.asc())
+                    .limit(limit)
+                    .into_boxed();
+
+                if let Some(since_val) = since {
+                    query = query.filter(crate::schema::record::repo_rev.gt(since_val));
+                }
+
+                if let Some(cursor_val) = cursor {
+                    query = query.filter(record_blob::blob_cid.gt(cursor_val));
+                }
+
+                query.load::<String>(conn)
+            })
+            .await
+    }
+
+    /// Get records that reference a blob
+    pub async fn get_records_for_blob(&self, cid: &Cid) -> Result<Vec<String>> {
+        let cid_str = cid.to_string();
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                record_blob::table
+                    .filter(record_blob::blob_cid.eq(&cid_str))
+                    .filter(record_blob::did.eq(&did))
+                    .select(record_blob::record_uri)
+                    .load::<String>(conn)
+            })
+            .await
+    }
+
+    /// Get blobs referenced by a record
+    pub async fn get_blobs_for_record(&self, record_uri: &str) -> Result<Vec<String>> {
+        let record_uri_str = record_uri.to_string();
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                blob::table
+                    .inner_join(record_blob::table.on(record_blob::blob_cid.eq(blob::cid)))
+                    .filter(record_blob::record_uri.eq(&record_uri_str))
+                    .filter(blob::did.eq(&did))
+                    .select(blob::cid)
+                    .load::<String>(conn)
+            })
+            .await
+    }
+
+    /// Upload a blob and get its metadata
+    pub async fn upload_blob_and_get_metadata(
+        &self,
+        user_suggested_mime: &str,
+        blob_bytes: &[u8],
+    ) -> Result<BlobMetadata> {
+        let temp_key = self.blobstore.put_temp(blob_bytes).await?;
+        let size = blob_bytes.len() as i64;
+        let sha256 = sha256_stream(blob_bytes).await?;
+        let img_info = maybe_get_info(blob_bytes).await?;
+        let sniffed_mime = mime_type_from_bytes(blob_bytes).await?;
+        let cid = sha256_raw_to_cid(sha256);
+        let mime_type = sniffed_mime.unwrap_or_else(|| user_suggested_mime.to_string());
+
+        Ok(BlobMetadata {
+            temp_key,
+            size,
+            cid,
+            mime_type,
+            width: img_info.as_ref().map(|info| info.width as i32),
+            height: img_info.as_ref().map(|info| info.height as i32),
+        })
+    }
+
+    /// Count total blobs
+    pub async fn blob_count(&self) -> Result<i64> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                blob::table
+                    .filter(blob::did.eq(&did))
+                    .count()
+                    .get_result(conn)
+            })
+            .await
+    }
+
+    /// Count distinct blobs referenced by records
+    pub async fn record_blob_count(&self) -> Result<i64> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                record_blob::table
+                    .filter(record_blob::did.eq(&did))
+                    .select(diesel::dsl::count_distinct(record_blob::blob_cid))
+                    .first::<i64>(conn)
+            })
+            .await
+    }
+
+    /// List blobs that are referenced but missing from storage
+    pub async fn list_missing_blobs(
+        &self,
+        opts: ListMissingBlobsOptions,
+    ) -> Result<Vec<MissingBlob>> {
+        let did = self.did.clone();
+        let limit = opts.limit;
+        let cursor = opts.cursor;
+
+        self.db
+            .run(move |conn| {
+                let mut query = record_blob::table
+                    .left_join(
+                        blob::table.on(blob::cid.eq(record_blob::blob_cid).and(blob::did.eq(&did))),
+                    )
+                    .filter(record_blob::did.eq(&did))
+                    .filter(blob::cid.is_null())
+                    .select((record_blob::blob_cid, record_blob::record_uri))
+                    .order(record_blob::blob_cid.asc())
+                    .limit(limit)
+                    .into_boxed();
+
+                if let Some(cursor_val) = cursor {
+                    query = query.filter(record_blob::blob_cid.gt(cursor_val));
+                }
+
+                let results = query.load::<(String, String)>(conn)?;
+
+                Ok(results
+                    .into_iter()
+                    .map(|(cid, record_uri)| MissingBlob { cid, record_uri })
+                    .collect())
+            })
+            .await
+    }
+
+    /// Get takedown status for a blob
+    pub async fn get_blob_takedown_status(&self, cid: &Cid) -> Result<Option<StatusAttr>> {
+        let cid_str = cid.to_string();
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                let result = blob::table
+                    .filter(blob::cid.eq(&cid_str))
+                    .filter(blob::did.eq(&did))
+                    .select(blob::takedownRef)
+                    .first::<Option<String>>(conn)
+                    .optional()?;
+
+                match result {
+                    Some(takedown) => match takedown {
+                        Some(takedownRef) => Ok(Some(StatusAttr {
+                            applied: true,
+                            r#ref: Some(takedownRef),
+                        })),
+                        None => Ok(Some(StatusAttr {
+                            applied: false,
+                            r#ref: None,
+                        })),
+                    },
+                    None => Ok(None),
+                }
+            })
+            .await
+    }
+
+    /// Get all blob CIDs in the repository
+    pub async fn get_blob_cids(&self) -> Result<Vec<Cid>> {
+        let did = self.did.clone();
+
+        let rows = self
+            .db
+            .run(move |conn| {
+                blob::table
+                    .filter(blob::did.eq(&did))
+                    .select(blob::cid)
+                    .load::<String>(conn)
+            })
+            .await?;
+
+        rows.into_iter()
+            .map(|cid_str| Cid::from_str(&cid_str).context("Invalid CID format"))
+            .collect()
+    }
+
+    /// Track a blob that's not yet associated with a record
+    pub async fn track_untethered_blob(&self, metadata: &BlobMetadata) -> Result<()> {
+        let cid_str = metadata.cid.to_string();
+        let did = self.did.clone();
+
+        // Check if blob exists and is taken down
+        let existing = self
+            .db
+            .run({
+                let cid_str_clone = cid_str.clone();
+                let did_clone = did.clone();
+
+                move |conn| {
+                    blob::table
+                        .filter(blob::did.eq(&did_clone))
+                        .filter(blob::cid.eq(&cid_str_clone))
+                        .select(blob::takedownRef)
+                        .first::<Option<String>>(conn)
+                        .optional()
+                }
+            })
+            .await?;
+
+        if let Some(row) = existing {
+            if row.is_some() {
+                return Err(anyhow::anyhow!(
+                    "Blob has been taken down, cannot re-upload"
+                ));
+            }
+        }
+
+        let size = metadata.size as i32;
+        let now = chrono::Utc::now().to_rfc3339();
+        let mime_type = metadata.mime_type.clone();
+        let temp_key = metadata.temp_key.clone();
+        let width = metadata.width;
+        let height = metadata.height;
+
+        self.db.run(move |conn| {
+            diesel::insert_into(blob::table)
+                .values((
+                    blob::cid.eq(&cid_str),
+                    blob::did.eq(&did),
+                    blob::mime_type.eq(&mime_type),
+                    blob::size.eq(size),
+                    blob::temp_key.eq(&temp_key),
+                    blob::width.eq(width),
+                    blob::height.eq(height),
+                    blob::created_at.eq(&now),
+                ))
+                .on_conflict((blob::cid, blob::did))
+                .do_update()
+                .set(
+                    blob::temp_key.eq(
+                        diesel::dsl::sql::<diesel::sql_types::Text>(
+                            "CASE WHEN blob.temp_key IS NULL THEN excluded.temp_key ELSE blob.temp_key END"
+                        )
+                    )
+                )
+                .execute(conn)
+                .context("Failed to track untethered blob")
+        }).await?;
+
+        Ok(())
+    }
+
+    /// Process blobs for repository writes
+    pub async fn process_write_blobs(&self, rev: &str, writes: Vec<PreparedWrite>) -> Result<()> {
+        self.delete_dereferenced_blobs(writes.clone()).await?;
+
+        let futures = writes.iter().filter_map(|write| match write {
+            PreparedWrite::Create(w) | PreparedWrite::Update(w) => {
+                let blobs = &w.blobs;
+                let uri = w.uri.clone();
+                let handler = self;
+
+                Some(async move {
+                    for blob in blobs {
+                        handler.verify_blob_and_make_permanent(blob).await?;
+                        handler.associate_blob(blob, &uri).await?;
+                    }
+                    Ok(())
+                })
+            }
+            _ => None,
+        });
+
+        try_join_all(futures).await?;
+
+        Ok(())
+    }
+
+    /// Delete blobs that are no longer referenced
+    pub async fn delete_dereferenced_blobs(&self, writes: Vec<PreparedWrite>) -> Result<()> {
+        let uris: Vec<String> = writes
+            .iter()
+            .filter_map(|w| match w {
+                PreparedWrite::Delete(w) => Some(w.uri.clone()),
+                PreparedWrite::Update(w) => Some(w.uri.clone()),
+                _ => None,
+            })
+            .collect();
+
+        if uris.is_empty() {
+            return Ok(());
+        }
+
+        let did = self.did.clone();
+
+        // Delete record-blob associations
+        let deleted_repo_blobs = self
+            .db
+            .run({
+                let uris_clone = uris.clone();
+                let did_clone = did.clone();
+
+                move |conn| {
+                    let query = diesel::delete(record_blob::table)
+                        .filter(record_blob::did.eq(&did_clone))
+                        .filter(record_blob::record_uri.eq_any(&uris_clone))
+                        .returning(RecordBlob::as_returning());
+
+                    query.load(conn)
+                }
+            })
+            .await?;
+
+        if deleted_repo_blobs.is_empty() {
+            return Ok(());
+        }
+
+        // Collect deleted blob CIDs
+        let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs
+            .iter()
+            .map(|rb| rb.blob_cid.clone())
+            .collect();
+
+        // Find duplicates in record_blob table
+        let duplicate_cids = self
+            .db
+            .run({
+                let blob_cids = deleted_repo_blob_cids.clone();
+                let did_clone = did.clone();
+
+                move |conn| {
+                    record_blob::table
+                        .filter(record_blob::did.eq(&did_clone))
+                        .filter(record_blob::blob_cid.eq_any(&blob_cids))
+                        .select(record_blob::blob_cid)
+                        .load::<String>(conn)
+                }
+            })
+            .await?;
+
+        // Get new blob CIDs from writes
+        let new_blob_cids: Vec<String> = writes
+            .iter()
+            .filter_map(|w| match w {
+                PreparedWrite::Create(w) | PreparedWrite::Update(w) => Some(
+                    w.blobs
+                        .iter()
+                        .map(|b| b.cid.to_string())
+                        .collect::<Vec<String>>(),
+                ),
+                _ => None,
+            })
+            .flatten()
+            .collect();
+
+        // Determine which CIDs to keep and which to delete
+        let cids_to_keep: std::collections::HashSet<String> = new_blob_cids
+            .into_iter()
+            .chain(duplicate_cids.into_iter())
+            .collect();
+
+        let cids_to_delete: Vec<String> = deleted_repo_blob_cids
+            .into_iter()
+            .filter(|cid| !cids_to_keep.contains(cid))
+            .collect();
+
+        if cids_to_delete.is_empty() {
+            return Ok(());
+        }
+
+        // Delete blobs from the database
+        self.db
+            .run({
+                let cids = cids_to_delete.clone();
+                let did_clone = did.clone();
+
+                move |conn| {
+                    diesel::delete(blob::table)
+                        .filter(blob::did.eq(&did_clone))
+                        .filter(blob::cid.eq_any(&cids))
+                        .execute(conn)
+                }
+            })
+            .await?;
+
+        // Delete blobs from storage
+        let cids_to_delete_objects: Vec<Cid> = cids_to_delete
+            .iter()
+            .filter_map(|cid_str| Cid::from_str(cid_str).ok())
+            .collect();
+
+        // Use background queue if available
+        if let Some(queue) = &self.background_queue {
+            let blobstore = self.blobstore.clone();
+            queue
+                .add(async move {
+                    let _ = blobstore.delete_many(cids_to_delete_objects).await;
+                })
+                .await;
+        } else {
+            // Otherwise delete directly
+            if !cids_to_delete_objects.is_empty() {
+                self.blobstore.delete_many(cids_to_delete_objects).await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Verify blob integrity and move from temporary to permanent storage
+    pub async fn verify_blob_and_make_permanent(&self, blob: &PreparedBlobRef) -> Result<()> {
+        let cid_str = blob.cid.to_string();
+        let did = self.did.clone();
+
+        let found = self
+            .db
+            .run(move |conn| {
+                blob::table
+                    .filter(blob::did.eq(&did))
+                    .filter(blob::cid.eq(&cid_str))
+                    .filter(blob::takedownRef.is_null())
+                    .first::<BlobModel>(conn)
+                    .optional()
+            })
+            .await?;
+
+        let found = match found {
+            Some(b) => b,
+            None => bail!("Blob not found: {}", cid_str),
+        };
+
+        // Verify blob constraints
+        if let Some(max_size) = blob.constraints.max_size {
+            if found.size as usize > max_size {
+                bail!(
+                    "BlobTooLarge: This file is too large. It is {} but the maximum size is {}",
+                    found.size,
+                    max_size
+                );
+            }
+        }
+
+        if blob.mime_type != found.mime_type {
+            bail!(
+                "InvalidMimeType: Referenced MIME type does not match stored blob. Expected: {}, Got: {}",
+                found.mime_type,
+                blob.mime_type
+            );
+        }
+
+        if let Some(ref accept) = blob.constraints.accept {
+            if !accepted_mime(&blob.mime_type, accept).await {
+                bail!(
+                    "Wrong type of file. It is {} but it must match {:?}.",
+                    blob.mime_type,
+                    accept
+                );
+            }
+        }
+
+        // Move blob from temporary to permanent storage if needed
+        if let Some(temp_key) = found.temp_key {
+            self.blobstore.make_permanent(&temp_key, blob.cid).await?;
+
+            // Update database to clear temp key
+            let cid_str = blob.cid.to_string();
+            let did = self.did.clone();
+
+            self.db
+                .run(move |conn| {
+                    diesel::update(blob::table)
+                        .filter(blob::did.eq(&did))
+                        .filter(blob::cid.eq(&cid_str))
+                        .set(blob::temp_key.eq::<Option<String>>(None))
+                        .execute(conn)
+                })
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    /// Associate a blob with a record
+    pub async fn associate_blob(&self, blob: &PreparedBlobRef, record_uri: &str) -> Result<()> {
+        let cid_str = blob.cid.to_string();
+        let record_uri = record_uri.to_string();
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                diesel::insert_into(record_blob::table)
+                    .values((
+                        record_blob::blob_cid.eq(&cid_str),
+                        record_blob::record_uri.eq(&record_uri),
+                        record_blob::did.eq(&did),
+                    ))
+                    .on_conflict_do_nothing()
+                    .execute(conn)
+            })
+            .await?;
+
+        Ok(())
+    }
+
+    /// Update takedown status for a blob
+    pub async fn update_blob_takedown_status(&self, blob: Cid, takedown: StatusAttr) -> Result<()> {
+        let cid_str = blob.to_string();
+        let did = self.did.clone();
+
+        let takedownRef: Option<String> = if takedown.applied {
+            Some(takedown.r#ref.unwrap_or_else(|| Uuid::new_v4().to_string()))
+        } else {
+            None
+        };
+
+        // Update database
+        self.db
+            .run(move |conn| {
+                diesel::update(blob::table)
+                    .filter(blob::did.eq(&did))
+                    .filter(blob::cid.eq(&cid_str))
+                    .set(blob::takedownRef.eq(takedownRef))
+                    .execute(conn)
+            })
+            .await?;
+
+        // Update blob storage
+        if takedown.applied {
+            self.blobstore.quarantine(blob).await?;
+        } else {
+            self.blobstore.unquarantine(blob).await?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Verify MIME type against accepted formats
+async fn accepted_mime(mime: &str, accepted: &[String]) -> bool {
+    // Accept any type
+    if accepted.contains(&"*/*".to_string()) {
+        return true;
+    }
+
+    // Check for glob patterns (e.g., "image/*")
+    for glob in accepted {
+        if glob.ends_with("/*") {
+            let prefix = glob.split('/').next().unwrap();
+            if mime.starts_with(&format!("{}/", prefix)) {
+                return true;
+            }
+        }
+    }
+
+    // Check for exact match
+    accepted.contains(&mime.to_string())
+}

src/actor_store/blob/placeholder.rs

···
+use anyhow::Result;
+use atrium_repo::Cid;
+
+use super::{BlobStore, BlobStream};
+
+/// Placeholder implementation for blob store
+#[derive(Clone)]
+pub struct BlobStorePlaceholder;
+
+impl BlobStore for BlobStorePlaceholder {
+    async fn put_temp(&self, _bytes: &[u8]) -> Result<String> {
+        todo!("BlobStorePlaceholder::put_temp not implemented");
+    }
+
+    async fn make_permanent(&self, _key: &str, _cid: Cid) -> Result<()> {
+        todo!("BlobStorePlaceholder::make_permanent not implemented");
+    }
+
+    async fn put_permanent(&self, _cid: Cid, _bytes: &[u8]) -> Result<()> {
+        todo!("BlobStorePlaceholder::put_permanent not implemented");
+    }
+
+    async fn quarantine(&self, _cid: Cid) -> Result<()> {
+        todo!("BlobStorePlaceholder::quarantine not implemented");
+    }
+
+    async fn unquarantine(&self, _cid: Cid) -> Result<()> {
+        todo!("BlobStorePlaceholder::unquarantine not implemented");
+    }
+
+    async fn get_bytes(&self, _cid: Cid) -> Result<Vec<u8>> {
+        todo!("BlobStorePlaceholder::get_bytes not implemented");
+    }
+
+    async fn get_stream(&self, _cid: Cid) -> Result<BlobStream> {
+        todo!("BlobStorePlaceholder::get_stream not implemented");
+    }
+
+    async fn has_temp(&self, _key: &str) -> Result<bool> {
+        todo!("BlobStorePlaceholder::has_temp not implemented");
+    }
+
+    async fn has_stored(&self, _cid: Cid) -> Result<bool> {
+        todo!("BlobStorePlaceholder::has_stored not implemented");
+    }
+
+    async fn delete(&self, _cid: Cid) -> Result<()> {
+        todo!("BlobStorePlaceholder::delete not implemented");
+    }
+
+    async fn delete_many(&self, _cids: Vec<Cid>) -> Result<()> {
+        todo!("BlobStorePlaceholder::delete_many not implemented");
+    }
+}

src/actor_store/blob/reader.rs

···
-//! Blob reading functionality.
-
-use std::str::FromStr;
-
-use anyhow::{Context as _, Result};
-use atrium_api::com::atproto::admin::defs::StatusAttrData;
-use atrium_repo::Cid;
-use sqlx::Row;
-
-use crate::actor_store::ActorDb;
-
-use super::{BlobStore, BlobStorePlaceholder, BlobStream};
-
-/// Reader for blob data in the actor store.
-pub(crate) struct BlobReader {
-    /// Database connection.
-    pub db: ActorDb,
-    /// BlobStore.
-    pub blobstore: BlobStorePlaceholder,
-}
-
-impl BlobReader {
-    /// Create a new blob reader.
-    pub(crate) fn new(db: ActorDb, blobstore: BlobStorePlaceholder) -> Self {
-        Self { db, blobstore }
-    }
-
-    /// Get metadata for a blob.
-    pub(crate) async fn get_blob_metadata(&self, cid: &Cid) -> Result<Option<BlobMetadata>> {
-        let cid_str = cid.to_string();
-        let found = sqlx::query!(
-            r#"
-            SELECT mimeType, size, takedownRef
-            FROM blob
-            WHERE cid = ? AND takedownRef IS NULL
-            "#,
-            cid_str
-        )
-        .fetch_optional(&self.db.pool)
-        .await
-        .context("failed to fetch blob metadata")?;
-        if found.is_none() {
-            return Err(anyhow::anyhow!("Blob not found")); // InvalidRequestError('Blob not found')
-        }
-        let found = found.unwrap();
-        let size = found.size as u64;
-        let mime_type = found.mimeType;
-        return Ok(Some(BlobMetadata { size, mime_type }));
-    }
-
-    /// Get a blob's full data and metadata.
-    pub(crate) async fn get_blob(&self, cid: &Cid) -> Result<Option<BlobData>> {
-        let metadata = self.get_blob_metadata(cid).await?;
-        let blob_stream = self.blobstore.get_stream(*cid).await;
-        if blob_stream.is_err() {
-            return Err(anyhow::anyhow!("Blob not found")); // InvalidRequestError('Blob not found')
-        }
-        let metadata = metadata.unwrap();
-        Ok(Some(BlobData {
-            size: metadata.size,
-            mime_type: Some(metadata.mime_type),
-            stream: blob_stream.unwrap(),
-        }))
-    }
-
-    /// List blobs for a repository.
-    pub(crate) async fn list_blobs(&self, opts: ListBlobsOptions) -> Result<Vec<String>> {
-        let mut query = sqlx::QueryBuilder::new(
-            "SELECT rb.blobCid FROM record_blob rb
-             INNER JOIN record r ON r.uri = rb.recordUri",
-        );
-        if let Some(since) = &opts.since {
-            query.push(" WHERE r.repoRev > ").push_bind(since);
-        }
-        if let Some(cursor) = &opts.cursor {
-            query.push(" AND rb.blobCid > ").push_bind(cursor);
-        }
-        query
-            .push(" ORDER BY rb.blobCid ASC")
-            .push(" LIMIT ")
-            .push_bind(opts.limit);
-        let blobs = query
-            .build()
-            .map(|row: sqlx::sqlite::SqliteRow| row.get::<String, _>(0))
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to fetch blobs")?;
-        Ok(blobs)
-    }
-
-    /// Get takedown status for a blob.
-    pub(crate) async fn get_blob_takedown_status(
-        &self,
-        cid: &Cid,
-    ) -> Result<Option<StatusAttrData>> {
-        let cid_str = cid.to_string();
-        let result = sqlx::query!(r#"SELECT takedownRef FROM blob WHERE cid = ?"#, cid_str)
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to fetch blob takedown status")?;
-
-        Ok({
-            if result.is_none() {
-                None
-            } else {
-                let takedown_ref = result.unwrap().takedownRef.unwrap();
-                if takedown_ref == "false" {
-                    Some(StatusAttrData {
-                        applied: false,
-                        r#ref: None,
-                    })
-                } else {
-                    Some(StatusAttrData {
-                        applied: true,
-                        r#ref: Some(takedown_ref),
-                    })
-                }
-            }
-        })
-    }
-
-    /// Get records that reference a blob.
-    pub(crate) async fn get_records_for_blob(&self, cid: &Cid) -> Result<Vec<String>> {
-        let cid_str = cid.to_string();
-        let records = sqlx::query!(
-            r#"SELECT recordUri FROM record_blob WHERE blobCid = ?"#,
-            cid_str
-        )
-        .fetch_all(&self.db.pool)
-        .await
-        .context("failed to fetch records for blob")?;
-
-        Ok(records.into_iter().map(|r| r.recordUri).collect())
-    }
-
-    /// Get blobs referenced by a record.
-    pub(crate) async fn get_blobs_for_record(&self, record_uri: &str) -> Result<Vec<String>> {
-        let blobs = sqlx::query!(
-            r#"SELECT blob.cid FROM blob INNER JOIN record_blob ON record_blob.blobCid = blob.cid WHERE recordUri = ?"#,
-            record_uri
-        )
-        .fetch_all(&self.db.pool)
-        .await
-        .context("failed to fetch blobs for record")?;
-
-        Ok(blobs.into_iter().map(|blob| blob.cid).collect())
-    }
-
-    /// Count total blobs.
-    pub(crate) async fn blob_count(&self) -> Result<i64> {
-        let result = sqlx::query!(r#"SELECT COUNT(*) as count FROM blob"#)
-            .fetch_one(&self.db.pool)
-            .await
-            .context("failed to count blobs")?;
-
-        Ok(result.count)
-    }
-
-    /// Count distinct blobs referenced by records.
-    pub(crate) async fn record_blob_count(&self) -> Result<i64> {
-        let result = sqlx::query!(r#"SELECT COUNT(DISTINCT blobCid) as count FROM record_blob"#)
-            .fetch_one(&self.db.pool)
-            .await
-            .context("failed to count record blobs")?;
-
-        Ok(result.count)
-    }
-
-    /// List blobs that are referenced but missing from storage.
-    pub(crate) async fn list_missing_blobs(
-        &self,
-        opts: ListMissingBlobsOptions,
-    ) -> Result<Vec<MissingBlob>> {
-        let mut query = sqlx::QueryBuilder::new(
-            "SELECT rb.blobCid, rb.recordUri FROM record_blob rb
-             WHERE NOT EXISTS (
-                SELECT 1 FROM blob b WHERE b.cid = rb.blobCid
-             )",
-        );
-
-        if let Some(cursor) = &opts.cursor {
-            query.push(" AND rb.blobCid > ").push_bind(cursor);
-        }
-
-        query
-            .push(" ORDER BY rb.blobCid ASC")
-            .push(" LIMIT ")
-            .push_bind(opts.limit);
-
-        let missing = query
-            .build()
-            .map(|row: sqlx::sqlite::SqliteRow| MissingBlob {
-                cid: row.get::<String, _>(0),
-                record_uri: row.get::<String, _>(1),
-            })
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to fetch missing blobs")?;
-
-        Ok(missing)
-    }
-
-    pub(crate) async fn get_blod_cids(&self) -> Result<Vec<Cid>> {
-        let rows = sqlx::query!("SELECT cid FROM blob")
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to fetch blob CIDs")?;
-        Ok(rows
-            .into_iter()
-            .map(|row| Cid::from_str(&row.cid).unwrap())
-            .collect())
-    }
-}
-
-/// Metadata about a blob.
-#[derive(Debug, Clone)]
-pub(crate) struct BlobMetadata {
-    /// The size of the blob in bytes.
-    pub size: u64,
-    /// The MIME type of the blob.
-    pub mime_type: String,
-}
-
-/// Complete blob data with content.
-#[derive(Debug)]
-pub(crate) struct BlobData {
-    /// The size of the blob.
-    pub size: u64,
-    /// The MIME type of the blob.
-    pub mime_type: Option<String>,
-    pub stream: BlobStream, // stream.Readable,
-}
-
-/// Options for listing blobs.
-#[derive(Debug, Clone)]
-pub(crate) struct ListBlobsOptions {
-    /// Optional revision to list blobs since.
-    pub since: Option<String>,
-    /// Optional cursor for pagination.
-    pub cursor: Option<String>,
-    /// Maximum number of blobs to return.
-    pub limit: i64,
-}
-
-/// Options for listing missing blobs.
-#[derive(Debug, Clone)]
-pub(crate) struct ListMissingBlobsOptions {
-    /// Optional cursor for pagination.
-    pub cursor: Option<String>,
-    /// Maximum number of missing blobs to return.
-    pub limit: i64,
-}
-
-/// Information about a missing blob.
-#[derive(Debug, Clone)]
-pub(crate) struct MissingBlob {
-    /// CID of the missing blob.
-    pub cid: String,
-    /// URI of the record referencing the missing blob.
-    pub record_uri: String,
-}

src/actor_store/blob/store.rs

···
-use anyhow::Result;
-use atrium_repo::Cid;
-use std::fmt::Debug;
-
-/// BlobStream
-/// A stream of blob data.
-pub(crate) struct BlobStream(Box<dyn std::io::Read + Send>);
-impl Debug for BlobStream {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("BlobStream").finish()
-    }
-}
-
-pub(crate) struct BlobStorePlaceholder;
-pub(crate) trait BlobStore {
-    async fn put_temp(&self, bytes: &[u8]) -> Result<String>; // bytes: Uint8Array | stream.Readable
-    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()>;
-    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()>;
-    async fn quarantine(&self, cid: Cid) -> Result<()>;
-    async fn unquarantine(&self, cid: Cid) -> Result<()>;
-    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>>;
-    async fn get_stream(&self, cid: Cid) -> Result<BlobStream>; // Promise<stream.Readable>
-    async fn has_temp(&self, key: &str) -> Result<bool>;
-    async fn has_stored(&self, cid: Cid) -> Result<bool>;
-    async fn delete(&self, cid: Cid) -> Result<()>;
-    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()>;
-}
-impl BlobStore for BlobStorePlaceholder {
-    async fn put_temp(&self, bytes: &[u8]) -> Result<String> {
-        // Implementation here
-        todo!();
-        Ok("temp_key".to_string())
-    }
-
-    async fn make_permanent(&self, key: &str, cid: Cid) -> Result<()> {
-        // Implementation here
-        todo!();
-        Ok(())
-    }
-
-    async fn put_permanent(&self, cid: Cid, bytes: &[u8]) -> Result<()> {
-        // Implementation here
-        todo!();
-        Ok(())
-    }
-
-    async fn quarantine(&self, cid: Cid) -> Result<()> {
-        // Implementation here
-        todo!();
-        Ok(())
-    }
-
-    async fn unquarantine(&self, cid: Cid) -> Result<()> {
-        // Implementation here
-        todo!();
-        Ok(())
-    }
-
-    async fn get_bytes(&self, cid: Cid) -> Result<Vec<u8>> {
-        // Implementation here
-        todo!();
-        Ok(vec![])
-    }
-
-    async fn get_stream(&self, cid: Cid) -> Result<BlobStream> {
-        // Implementation here
-        todo!();
-        Ok(BlobStream(Box::new(std::io::empty())))
-    }
-
-    async fn has_temp(&self, key: &str) -> Result<bool> {
-        // Implementation here
-        todo!();
-        Ok(true)
-    }
-
-    async fn has_stored(&self, cid: Cid) -> Result<bool> {
-        // Implementation here
-        todo!();
-        Ok(true)
-    }
-    async fn delete(&self, cid: Cid) -> Result<()> {
-        // Implementation here
-        todo!();
-        Ok(())
-    }
-    async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
-        // Implementation here
-        todo!();
-        Ok(())
-    }
-}

src/actor_store/blob/transactor.rs

···
-//! Blob transaction functionality.
-
-use anyhow::{Context as _, Result};
-use atrium_api::{
-    com::atproto::admin::defs::StatusAttr,
-    types::{Blob, CidLink},
-};
-use atrium_repo::Cid;
-use futures::FutureExt;
-use futures::future::BoxFuture;
-use rsky_repo::types::{PreparedBlobRef, WriteOpAction};
-use uuid::Uuid;
-
-use super::{BackgroundQueue, BlobReader, BlobStore};
-use crate::actor_store::{ActorDb, PreparedWrite, blob::BlobStore as _};
-
-/// Blob metadata for a newly uploaded blob.
-#[derive(Debug, Clone)]
-pub(crate) struct BlobMetadata {
-    /// Temporary key for the blob during upload.
-    pub temp_key: String,
-    /// Size of the blob in bytes.
-    pub size: u64,
-    /// CID of the blob.
-    pub cid: Cid,
-    /// MIME type of the blob.
-    pub mime_type: String,
-    /// Optional width if the blob is an image.
-    pub width: Option<i32>,
-    /// Optional height if the blob is an image.
-    pub height: Option<i32>,
-}
-
-/// Transactor for blob operations.
-pub(crate) struct BlobTransactor {
-    /// The blob reader.
-    pub reader: BlobReader,
-    pub background_queue: BackgroundQueue,
-}
-
-impl BlobTransactor {
-    /// Create a new blob transactor.
-    pub(crate) fn new(
-        db: ActorDb,
-        blob_store: BlobStore,
-        background_queue: BackgroundQueue,
-    ) -> Self {
-        Self {
-            reader: BlobReader::new(db, blob_store),
-            background_queue,
-        }
-    }
-
-    /// Register blob associations with records.
-    pub(crate) async fn insert_blobs(&self, record_uri: &str, blobs: &[Blob]) -> Result<()> {
-        if blobs.is_empty() {
-            return Ok(());
-        }
-
-        let mut query =
-            sqlx::QueryBuilder::new("INSERT INTO record_blob (recordUri, blobCid) VALUES ");
-
-        for (i, blob) in blobs.iter().enumerate() {
-            if i > 0 {
-                query.push(", ");
-            }
-
-            let cid_str = blob.r#ref.0.to_string();
-            query
-                .push("(")
-                .push_bind(record_uri)
-                .push(", ")
-                .push_bind(cid_str)
-                .push(")");
-        }
-
-        query.push(" ON CONFLICT DO NOTHING");
-
-        query
-            .build()
-            .execute(&self.reader.db.pool)
-            .await
-            .context("failed to insert blob references")?;
-
-        Ok(())
-    }
-
-    /// Upload a blob and get its metadata.
-    pub(crate) async fn upload_blob_and_get_metadata(
-        &self,
-        user_suggested_mime: &str,
-        blob_stream: &[u8],
-    ) -> Result<BlobMetadata> {
-        let temp_key = self.reader.blobstore.put_temp(blob_stream).await?;
-        todo!();
-        let size = stream_size(blob_stream).await?;
-        let sha256 = sha256_stream(blob_stream).await?;
-        let img_info = img::maybe_get_info(blob_stream).await?;
-        let sniffed_mime = mime_type_from_stream(blob_stream).await?;
-        let cid = sha256_raw_to_cid(sha256);
-        let mime_type = sniffed_mime.unwrap_or_else(|| user_suggested_mime.to_string());
-        Ok(BlobMetadata {
-            temp_key,
-            size,
-            cid,
-            mime_type,
-            width: img_info.map(|info| info.width),
-            height: img_info.map(|info| info.height),
-        })
-    }
-
-    /// Track a new blob that's not yet associated with a record.
-    pub(crate) async fn track_untethered_blob(&self, metadata: &BlobMetadata) -> Result<Blob> {
-        let cid_str = metadata.cid.to_string();
-
-        // Check if blob exists and is taken down
-        let existing = sqlx::query!(r#"SELECT takedownRef FROM blob WHERE cid = ?"#, cid_str)
-            .fetch_optional(&self.reader.db.pool)
-            .await
-            .context("failed to check blob existence")?;
-
-        if let Some(row) = existing {
-            if row.takedownRef.is_some() {
-                return Err(anyhow::anyhow!(
-                    "Blob has been taken down, cannot re-upload"
-                ));
-            }
-        }
-
-        // Insert or update blob record
-        let size = metadata.size as i64;
-        let now = chrono::Utc::now().to_rfc3339();
-        sqlx::query!(
-            r#"
-            INSERT INTO blob
-            (cid, mimeType, size, tempKey, width, height, createdAt)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(cid) DO UPDATE SET
-            tempKey = CASE
-                WHEN blob.tempKey IS NULL THEN EXCLUDED.tempKey
-                ELSE blob.tempKey
-            END
-            "#,
-            cid_str,
-            metadata.mime_type,
-            size,
-            metadata.temp_key,
-            metadata.width,
-            metadata.height,
-            now,
-        )
-        .execute(&self.reader.db.pool)
-        .await
-        .context("failed to track blob in database")?;
-
-        // Create and return a blob reference
-        Ok(Blob {
-            r#ref: CidLink(metadata.cid.clone()),
-            mime_type: metadata.mime_type.clone(),
-            size: metadata.size as usize,
-        })
-    }
-
-    /// Process blobs for a repository write operation.
-    pub(crate) async fn process_write_blobs(
-        &self,
-        _rev: &String, // Typescript impl declares rev but never uses it
-        writes: Vec<PreparedWrite>,
-    ) -> Result<()> {
-        self.delete_dereferenced_blobs(writes.clone(), false)
-            .await
-            .context("failed to delete dereferenced blobs")?;
-
-        // Process blobs for creates and updates
-        let mut futures: Vec<BoxFuture<'_, Result<()>>> = Vec::new();
-        for write in writes.iter() {
-            if write.action() == &WriteOpAction::Create || write.action() == &WriteOpAction::Update
-            {
-                for blob in write.blobs().unwrap().iter() {
-                    futures.push(Box::pin(self.verify_blob_and_make_permanent(blob)));
-                    futures.push(Box::pin(self.associate_blob(blob, write.uri())));
-                }
-            }
-        }
-
-        // Wait for all blob operations to complete
-        futures::future::join_all(futures)
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(())
-    }
-
-    /// Update the takedown status of a blob.
-    pub(crate) async fn update_blob_takedown_status(
-        &self,
-        blob: &Blob,
-        takedown: &StatusAttr,
-    ) -> Result<()> {
-        let takedown_ref = if takedown.applied {
-            Some(
-                takedown
-                    .r#ref
-                    .clone()
-                    .unwrap_or_else(|| Uuid::new_v4().to_string()),
-            )
-        } else {
-            None
-        };
-
-        let cid_str = blob.r#ref.0.to_string();
-        sqlx::query!(
-            r#"UPDATE blob SET takedownRef = ? WHERE cid = ?"#,
-            takedown_ref,
-            cid_str
-        )
-        .execute(&self.reader.db.pool)
-        .await
-        .context("failed to update blob takedown status")?;
-
-        Ok(())
-    }
-
-    /// Delete blobs that are no longer referenced by any record.
-    pub(crate) async fn delete_dereferenced_blobs(
-        &self,
-        writes: Vec<PreparedWrite>,
-        skip_blob_store: bool,
-    ) -> Result<()> {
-        let deletes = writes
-            .iter()
-            .filter(|w| w.action() == &WriteOpAction::Delete)
-            .collect::<Vec<_>>();
-        let updates = writes
-            .iter()
-            .filter(|w| w.action() == &WriteOpAction::Update)
-            .collect::<Vec<_>>();
-        let uris: Vec<String> = deletes
-            .iter()
-            .chain(updates.iter())
-            .map(|w| w.uri().to_string())
-            .collect();
-
-        if uris.is_empty() {
-            return Ok(());
-        }
-
-        // Delete blobs from record_blob table
-        let uris = uris.join(",");
-        let deleted_repo_blobs = sqlx::query!(
-            r#"DELETE FROM record_blob WHERE recordUri IN (?1) RETURNING *"#,
-            uris
-        )
-        .fetch_all(&self.reader.db.pool)
-        .await
-        .context("failed to delete dereferenced blobs")?;
-
-        if deleted_repo_blobs.is_empty() {
-            return Ok(());
-        }
-
-        // Get the CIDs of the deleted blobs
-        let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs
-            .iter()
-            .map(|row| row.blobCid.clone())
-            .collect();
-
-        // Check for duplicates in the record_blob table
-        let duplicate_cids = deleted_repo_blob_cids.join(",");
-        let duplicate_cids = sqlx::query!(
-            r#"SELECT blobCid FROM record_blob WHERE blobCid IN (?1)"#,
-            duplicate_cids
-        )
-        .fetch_all(&self.reader.db.pool)
-        .await
-        .context("failed to fetch duplicate CIDs")?;
-
-        // Get new blob CIDs from the writes
-        let new_blob_cids: Vec<String> = writes
-            .iter()
-            .filter_map(|w| {
-                if w.action() == &WriteOpAction::Create || w.action() == &WriteOpAction::Update {
-                    Some(
-                        w.blobs()
-                            .unwrap()
-                            .iter()
-                            .map(|b| b.cid.to_string())
-                            .collect::<Vec<String>>(),
-                    )
-                } else {
-                    None
-                }
-            })
-            .flatten()
-            .collect();
-
-        // Determine which CIDs to keep and which to delete
-        let cids_to_keep: Vec<String> = new_blob_cids
-            .into_iter()
-            .chain(duplicate_cids.into_iter().map(|row| row.blobCid))
-            .collect();
-        let cids_to_delete: Vec<String> = deleted_repo_blob_cids
-            .into_iter()
-            .filter(|cid| !cids_to_keep.contains(cid))
-            .collect();
-        if cids_to_delete.is_empty() {
-            return Ok(());
-        }
-        // Delete blobs from the blob table
-        let cids_to_delete = cids_to_delete.join(",");
-        sqlx::query!(r#"DELETE FROM blob WHERE cid IN (?1)"#, cids_to_delete)
-            .execute(&self.reader.db.pool)
-            .await
-            .context("failed to delete dereferenced blobs from blob table")?;
-        // Optionally delete blobs from the blob store
-        if !skip_blob_store {
-            todo!();
-        }
-        Ok(())
-    }
-
-    /// Verify a blob's integrity and move it from temporary to permanent storage.
-    pub(crate) async fn verify_blob_and_make_permanent(
-        &self,
-        blob: &PreparedBlobRef,
-    ) -> Result<()> {
-        let cid_str = blob.cid.to_string();
-        let found = sqlx::query!(r#"SELECT * FROM blob WHERE cid = ?"#, cid_str)
-            .fetch_optional(&self.reader.db.pool)
-            .await
-            .context("failed to fetch blob")?;
-        if found.is_none() {
-            return Err(anyhow::anyhow!("Blob not found"));
-        }
-        let found = found.unwrap();
-        if found.takedownRef.is_some() {
-            return Err(anyhow::anyhow!("Blob has been taken down"));
-        }
-        if found.tempKey.is_some() {
-            todo!("verify_blob");
-            verify_blob(blob, found);
-            self.reader
-                .blobstore
-                .make_permanent(&found.tempKey.unwrap(), blob.cid)
-                .await?;
-            sqlx::query!(
-                r#"UPDATE blob SET tempKey = NULL WHERE tempKey = ?"#,
-                found.tempKey
-            )
-            .execute(&self.reader.db.pool)
-            .await
-            .context("failed to update blob temp key")?;
-        }
-        Ok(())
-    }
-
-    /// Associate a blob with a record
-    pub(crate) async fn associate_blob(
-        &self,
-        blob: &PreparedBlobRef,
-        record_uri: &str,
-    ) -> Result<()> {
-        let cid = blob.cid.to_string();
-        sqlx::query!(
-            r#"
-            INSERT INTO record_blob (blobCid, recordUri)
-            VALUES (?, ?)
-            ON CONFLICT DO NOTHING
-            "#,
-            cid,
-            record_uri
-        )
-        .execute(&self.reader.db.pool)
-        .await
-        .context("failed to associate blob with record")?;
-
-        Ok(())
-    }
-}
-
-/// Check if a mime type is accepted based on the accept list.
-fn accepted_mime(mime: &str, accepted: &[String]) -> bool {
-    // Accept all types
-    if accepted.contains(&"*/*".to_string()) {
-        return true;
-    }
-
-    // Check for explicit match
-    if accepted.contains(&mime.to_string()) {
-        return true;
-    }
-
-    // Check for type/* matches
-    let type_prefix = mime.split('/').next().unwrap_or("");
-    let wildcard = format!("{}/*", type_prefix);
-
-    accepted.contains(&wildcard)
-}

src/actor_store/db.rs

···
+//! Database schema and connection management for the actor store.
+
+use crate::db::DatabaseConnection;
+use anyhow::{Context as _, Result};
+use diesel::prelude::*;
+
+/// Type alias for the actor database.
+pub(crate) type ActorDb = DatabaseConnection;
+
+/// Gets a database connection for the actor store.
+///
+/// # Arguments
+///
+/// * `location` - The file path or URI for the SQLite database.
+/// * `disable_wal_auto_checkpoint` - Whether to disable the WAL auto-checkpoint.
+///
+/// # Returns
+///
+/// A `Result` containing the `ActorDb` instance or an error.
+pub async fn get_db(location: &str, disable_wal_auto_checkpoint: bool) -> Result<ActorDb> {
+    let pragmas = if disable_wal_auto_checkpoint {
+        Some(
+            &[
+                ("wal_autocheckpoint", "0"),
+                ("journal_mode", "WAL"),
+                ("synchronous", "NORMAL"),
+                ("foreign_keys", "ON"),
+            ][..],
+        )
+    } else {
+        Some(
+            &[
+                ("journal_mode", "WAL"),
+                ("synchronous", "NORMAL"),
+                ("foreign_keys", "ON"),
+            ][..],
+        )
+    };
+
+    let db = DatabaseConnection::new(location, pragmas)
+        .await
+        .context("Failed to initialize the actor database")?;
+
+    // Ensure WAL mode is properly set up
+    db.ensure_wal().await?;
+
+    // Run migrations
+    // TODO: make sure the migrations are populated?
+    db.run_migrations()
+        .context("Failed to run migrations on the actor database")?;
+
+    Ok(db)
+}

src/actor_store/db/migrations.rs

···
-//! Database migrations for the actor store.
-use anyhow::{Context as _, Result};
-
-use super::ActorDb;
-
-/// Migration identifier
-type Migration = fn(&ActorDb) -> Result<()>;
-
-/// Database migrator
-pub(crate) struct Migrator {
-    db: ActorDb,
-    migrations: Vec<Migration>,
-}
-
-impl Migrator {
-    /// Create a new migrator
-    pub(crate) fn new(db: ActorDb) -> Self {
-        Self {
-            db,
-            migrations: vec![_001_init],
-        }
-    }
-
-    /// Run all migrations
-    pub(crate) async fn migrate_to_latest(&self) -> Result<()> {
-        let past_migrations = sqlx::query!("SELECT name FROM actor_migration")
-            .fetch_all(&self.db.pool)
-            .await?;
-        let mut past_migration_names = past_migrations
-            .iter()
-            .map(|m| m.name.clone())
-            .collect::<Vec<_>>();
-        past_migration_names.sort();
-        for migration in &self.migrations {
-            let name = format!("{:p}", migration);
-            if !past_migration_names.contains(&name) {
-                migration(&self.db)?;
-                let now = chrono::Utc::now().to_rfc3339();
-                sqlx::query!(
-                    "INSERT INTO actor_migration (name, appliedAt) VALUES (?, ?)",
-                    name,
-                    now,
-                )
-                .execute(&self.db.pool)
-                .await
-                .context("failed to insert migration record")?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Run migrations and throw an error if any fail
-    pub(crate) async fn migrate_to_latest_or_throw(&self) -> Result<()> {
-        self.migrate_to_latest().await?;
-        self.db.ensure_wal().await?;
-        Ok(())
-    }
-}
-
-/// Initial migration to create tables
-fn _001_init(db: &ActorDb) -> Result<()> {
-    tokio::task::block_in_place(|| {
-        tokio::runtime::Handle::current()
-            .block_on(create_tables(&db))
-            .context("failed to create initial tables")
-    })
-}
-
-/// Create the initial database tables
-pub(crate) async fn create_tables(db: &ActorDb) -> Result<()> {
-    sqlx::query(
-        "
-        CREATE TABLE IF NOT EXISTS repo_root (
-            did TEXT PRIMARY KEY NOT NULL,
-            cid TEXT NOT NULL,
-            rev TEXT NOT NULL,
-            indexedAt TEXT NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS repo_block (
-            cid TEXT PRIMARY KEY NOT NULL,
-            repoRev TEXT NOT NULL,
-            size INTEGER NOT NULL,
-            content BLOB NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS record (
-            uri TEXT PRIMARY KEY NOT NULL,
-            cid TEXT NOT NULL,
-            collection TEXT NOT NULL,
-            rkey TEXT NOT NULL,
-            repoRev TEXT NOT NULL,
-            indexedAt TEXT NOT NULL,
-            takedownRef TEXT
-        );
-
-        CREATE TABLE IF NOT EXISTS blob (
-            cid TEXT PRIMARY KEY NOT NULL,
-            mimeType TEXT NOT NULL,
-            size INTEGER NOT NULL,
-            tempKey TEXT,
-            width INTEGER,
-            height INTEGER,
-            createdAt TEXT NOT NULL,
-            takedownRef TEXT
-        );
-
-        CREATE TABLE IF NOT EXISTS record_blob (
-            blobCid TEXT NOT NULL,
-            recordUri TEXT NOT NULL,
-            PRIMARY KEY (blobCid, recordUri)
-        );
-
-        CREATE TABLE IF NOT EXISTS backlink (
-            uri TEXT NOT NULL,
-            path TEXT NOT NULL,
-            linkTo TEXT NOT NULL,
-            PRIMARY KEY (uri, path)
-        );
-
-        CREATE TABLE IF NOT EXISTS account_pref (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            valueJson TEXT NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS actor_migration (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            appliedAt TEXT NOT NULL
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_repo_block_repo_rev ON repo_block(repoRev, cid);
-        CREATE INDEX IF NOT EXISTS idx_record_cid ON record(cid);
-        CREATE INDEX IF NOT EXISTS idx_record_collection ON record(collection);
-        CREATE INDEX IF NOT EXISTS idx_record_repo_rev ON record(repoRev);
-        CREATE INDEX IF NOT EXISTS idx_blob_tempkey ON blob(tempKey);
-        CREATE INDEX IF NOT EXISTS idx_backlink_link_to ON backlink(path, linkTo);
-        ",
-    )
-    .execute(&db.pool)
-    .await
-    .context("failed to create tables")?;
-
-    Ok(())
-}

src/actor_store/db/mod.rs

···
-//! Database schema and connection management for the actor store.
-
-pub(crate) mod migrations;
-pub(crate) mod schema;
-
-use crate::db::Database;
-use anyhow::{Context as _, Result};
-
-/// Type alias for the actor database.
-pub(crate) type ActorDb = Database;
-
-/// Gets a database connection for the actor store.
-///
-/// # Arguments
-///
-/// * `location` - The file path or URI for the SQLite database.
-/// * `disable_wal_auto_checkpoint` - Whether to disable the WAL auto-checkpoint.
-///
-/// # Returns
-///
-/// A `Result` containing the `ActorDb` instance or an error.
-pub async fn get_db(location: &str, disable_wal_auto_checkpoint: bool) -> Result<ActorDb> {
-    let pragmas = if disable_wal_auto_checkpoint {
-        Some(&[("wal_autocheckpoint", "0")][..])
-    } else {
-        None
-    };
-
-    Database::new(location, pragmas)
-        .await
-        .context("Failed to initialize the actor database")
-}
-
-/// Gets a migrator for the actor database.
-///
-/// # Arguments
-///
-/// * `db` - The actor database instance.
-///
-/// # Returns
-///
-/// A `migrations::Migrator` instance for managing database migrations.
-pub fn get_migrator(db: &ActorDb) -> migrations::Migrator {
-    migrations::Migrator::new(db.clone())
-}

src/actor_store/db/schema.rs

···
-//! Database schema definitions for the actor store.
-
-/// Repository root information
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct RepoRoot {
-    pub(crate) did: String,
-    pub(crate) cid: String,
-    pub(crate) rev: String,
-    pub(crate) indexed_at: String,
-}
-
-pub(crate) const REPO_ROOT_TABLE: &str = "repo_root";
-
-/// Repository block (IPLD block)
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct RepoBlock {
-    pub(crate) cid: String,
-    pub(crate) repo_rev: String,
-    pub(crate) size: i64,
-    pub(crate) content: Vec<u8>,
-}
-
-pub(crate) const REPO_BLOCK_TABLE: &str = "repo_block";
-
-/// Record information
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct Record {
-    pub(crate) uri: String,
-    pub(crate) cid: String,
-    pub(crate) collection: String,
-    pub(crate) rkey: String,
-    pub(crate) repo_rev: Option<String>,
-    pub(crate) indexed_at: String,
-    pub(crate) takedown_ref: Option<String>,
-    pub(crate) did: String,
-}
-
-pub(crate) const RECORD_TABLE: &str = "record";
-
-/// Blob information
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct Blob {
-    pub(crate) cid: String,
-    pub(crate) mime_type: String,
-    pub(crate) size: i64,
-    pub(crate) temp_key: Option<String>,
-    pub(crate) width: Option<i64>,
-    pub(crate) height: Option<i64>,
-    pub(crate) created_at: String,
-    pub(crate) takedown_ref: Option<String>,
-    pub(crate) did: String,
-}
-
-pub(crate) const BLOB_TABLE: &str = "blob";
-
-/// Record-blob association
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct RecordBlob {
-    pub(crate) blob_cid: String,
-    pub(crate) record_uri: String,
-}
-
-pub(crate) const RECORD_BLOB_TABLE: &str = "record_blob";
-
-/// Backlink between records
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct Backlink {
-    pub(crate) uri: String,
-    pub(crate) path: String,
-    pub(crate) link_to: String,
-}
-
-pub(crate) const BACKLINK_TABLE: &str = "backlink";
-
-/// Account preference
-#[derive(Debug, Clone, sqlx::FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub(crate) struct AccountPref {
-    pub(crate) id: i64,
-    pub(crate) name: String,
-    pub(crate) value_json: String,
-}
-
-pub(crate) const ACCOUNT_PREF_TABLE: &str = "account_pref";
-
-pub(crate) type DatabaseSchema = sqlx::Sqlite;

src/actor_store/mod.rs

···
 mod prepared_write;
 mod record;
 mod repo;
+mod sql_repo;
 
 pub(crate) use actor_store::ActorStore;
 pub(crate) use actor_store_reader::ActorStoreReader;

src/actor_store/preference.rs

···
+//! Preference handling for actor store.
+
+use anyhow::{Context as _, Result, bail};
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+use std::sync::Arc;
+
+use crate::actor_store::db::ActorDb;
+
+/// Constants for preference-related operations
+const FULL_ACCESS_ONLY_PREFS: &[&str] = &["app.bsky.actor.defs#personalDetailsPref"];
+
+/// User preference with type information.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub(crate) struct AccountPreference {
+    /// Type of the preference.
+    pub r#type: String,
+    /// Preference data as JSON.
+    pub value: JsonValue,
+}
+
+/// Handler for preference operations with both read and write capabilities.
+pub(crate) struct PreferenceHandler {
+    /// Database connection.
+    pub db: ActorDb,
+    /// DID of the actor.
+    pub did: String,
+}
+
+impl PreferenceHandler {
+    /// Create a new preference handler.
+    pub(crate) fn new(db: ActorDb, did: String) -> Self {
+        Self { db, did }
+    }
+
+    /// Get preferences for a namespace.
+    pub(crate) async fn get_preferences(
+        &self,
+        namespace: Option<&str>,
+        scope: &str,
+    ) -> Result<Vec<AccountPreference>> {
+        use rsky_pds::schema::pds::account_pref::dsl::*;
+
+        let did = self.did.clone();
+        let namespace_clone = namespace.map(|ns| ns.to_string());
+        let scope_clone = scope.to_string();
+
+        let prefs_res = self
+            .db
+            .run(move |conn| {
+                let prefs = account_pref
+                    .filter(did.eq(&did))
+                    .order(id.asc())
+                    .load::<rsky_pds::models::AccountPref>(conn)
+                    .context("Failed to fetch preferences")?;
+
+                Ok::<Vec<rsky_pds::models::AccountPref>, diesel::result::Error>(prefs)
+            })
+            .await?;
+
+        // Filter preferences based on namespace and scope
+        let filtered_prefs = prefs_res
+            .into_iter()
+            .filter(|pref| {
+                namespace_clone
+                    .as_ref()
+                    .map_or(true, |ns| pref_match_namespace(ns, &pref.name))
+            })
+            .filter(|pref| pref_in_scope(scope, &pref.name))
+            .map(|pref| -> Result<AccountPreference> {
+                let value_json = match pref.value_json {
+                    Some(json) => serde_json::from_str(&json)
+                        .context(format!("Failed to parse preference JSON for {}", pref.name))?,
+                    None => bail!("Preference JSON is null for {}", pref.name),
+                };
+
+                Ok(AccountPreference {
+                    r#type: pref.name,
+                    value: value_json,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        Ok(filtered_prefs)
+    }
+
+    /// Put preferences for a namespace.
+    pub(crate) async fn put_preferences(
+        &self,
+        values: Vec<AccountPreference>,
+        namespace: &str,
+        scope: &str,
+    ) -> Result<()> {
+        // Validate all preferences match the namespace
+        if !values
+            .iter()
+            .all(|value| pref_match_namespace(namespace, &value.r#type))
+        {
+            bail!("Some preferences are not in the {} namespace", namespace);
+        }
+
+        // Validate scope permissions
+        let not_in_scope = values
+            .iter()
+            .filter(|val| !pref_in_scope(scope, &val.r#type))
+            .collect::<Vec<_>>();
+
+        if !not_in_scope.is_empty() {
+            bail!("Do not have authorization to set preferences");
+        }
+
+        let did = self.did.clone();
+        let namespace_str = namespace.to_string();
+        let scope_str = scope.to_string();
+
+        // Convert preferences to serialized form
+        let serialized_prefs = values
+            .into_iter()
+            .map(|pref| -> Result<(String, String)> {
+                let json = serde_json::to_string(&pref.value)
+                    .context("Failed to serialize preference value")?;
+                Ok((pref.r#type, json))
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        // Execute transaction
+        self.db
+            .transaction(move |conn| {
+                use rsky_pds::schema::pds::account_pref::dsl::*;
+
+                // Find all preferences in the namespace
+                let namespace_pattern = format!("{}%", namespace_str);
+                let all_prefs = account_pref
+                    .filter(did.eq(&did))
+                    .filter(name.eq(&namespace_str).or(name.like(&namespace_pattern)))
+                    .load::<rsky_pds::models::AccountPref>(conn)
+                    .context("Failed to fetch preferences")?;
+
+                // Filter to those in scope
+                let all_pref_ids_in_namespace = all_prefs
+                    .iter()
+                    .filter(|pref| pref_match_namespace(&namespace_str, &pref.name))
+                    .filter(|pref| pref_in_scope(&scope_str, &pref.name))
+                    .map(|pref| pref.id)
+                    .collect::<Vec<i32>>();
+
+                // Delete existing preferences in namespace
+                if !all_pref_ids_in_namespace.is_empty() {
+                    diesel::delete(account_pref)
+                        .filter(id.eq_any(all_pref_ids_in_namespace))
+                        .execute(conn)
+                        .context("Failed to delete existing preferences")?;
+                }
+
+                // Insert new preferences
+                if !serialized_prefs.is_empty() {
+                    for (pref_type, pref_json) in serialized_prefs {
+                        diesel::insert_into(account_pref)
+                            .values((
+                                did.eq(&did),
+                                name.eq(&pref_type),
+                                valueJson.eq(Some(&pref_json)),
+                            ))
+                            .execute(conn)
+                            .context("Failed to insert preference")?;
+                    }
+                }
+
+                Ok(())
+            })
+            .await
+    }
+}
+
+/// Check if a preference matches a namespace.
+pub(super) fn pref_match_namespace(namespace: &str, fullname: &str) -> bool {
+    fullname == namespace || fullname.starts_with(&format!("{}.", namespace))
+}
+
+/// Check if a preference is in scope.
+pub(super) fn pref_in_scope(scope: &str, pref_type: &str) -> bool {
+    scope == "access" || !FULL_ACCESS_ONLY_PREFS.contains(&pref_type)
+}

src/actor_store/preference/mod.rs

···
-//! Preference handling for actor store.
-
-mod reader;
-mod transactor;
-
-pub(crate) use reader::PreferenceReader;
-pub(crate) use transactor::PreferenceTransactor;

src/actor_store/preference/reader.rs

···
-//! Reader for preference data in the actor store.
-
-use anyhow::Result;
-
-use super::super::ActorDb;
-
-/// Reader for preference data.
-pub(crate) struct PreferenceReader {
-    /// Database connection.
-    pub db: ActorDb,
-}
-
-/// User preference with type information.
-#[derive(Debug, Clone, serde::Deserialize)]
-pub(crate) struct AccountPreference {
-    /// Type of the preference.
-    pub r#type: String,
-    /// Preference data as JSON.
-    pub value: serde_json::Value,
-}
-
-impl PreferenceReader {
-    /// Create a new preference reader.
-    pub(crate) fn new(db: ActorDb) -> Self {
-        Self { db }
-    }
-
-    /// Get preferences for a namespace.
-    pub(crate) async fn get_preferences(
-        &self,
-        namespace: Option<&str>,
-        scope: &str,
-    ) -> Result<Vec<AccountPreference>> {
-        let prefs_res = sqlx::query!("SELECT * FROM account_pref ORDER BY id")
-            .fetch_all(&self.db.pool)
-            .await?;
-
-        let prefs = prefs_res
-            .into_iter()
-            .filter(|pref| {
-                namespace.map_or(true, |ns| pref_match_namespace(ns, &pref.name))
-                    && pref_in_scope(scope, &pref.name)
-            })
-            .map(|pref| serde_json::from_str(&pref.valueJson).unwrap())
-            .collect();
-
-        Ok(prefs)
-    }
-}
-
-/// Check if a preference matches a namespace.
-pub(super) fn pref_match_namespace(namespace: &str, fullname: &str) -> bool {
-    fullname == namespace || fullname.starts_with(&format!("{}.", namespace))
-}
-
-/// Check if a preference is in scope.
-pub(super) fn pref_in_scope(scope: &str, pref_type: &str) -> bool {
-    scope == "access" || !FULL_ACCESS_ONLY_PREFS.contains(&pref_type)
-}
-
-/// Preferences that require full access.
-pub(super) const FULL_ACCESS_ONLY_PREFS: &[&str] = &["app.bsky.actor.defs#personalDetailsPref"];

src/actor_store/preference/transactor.rs

···
-// src/actor_store/preference/transactor.rs
-use anyhow::{Context as _, Result, bail};
-
-use super::super::ActorDb;
-
-use super::reader::{AccountPreference, PreferenceReader, pref_in_scope, pref_match_namespace};
-
-/// Transactor for preference operations.
-pub(crate) struct PreferenceTransactor {
-    /// Preference reader.
-    pub reader: PreferenceReader,
-}
-
-impl PreferenceTransactor {
-    /// Create a new preference transactor.
-    pub(crate) fn new(db: ActorDb) -> Self {
-        Self {
-            reader: PreferenceReader::new(db),
-        }
-    }
-
-    /// Put preferences for a namespace.
-    pub(crate) async fn put_preferences(
-        &self,
-        values: Vec<AccountPreference>,
-        namespace: &str,
-        scope: &str,
-    ) -> Result<()> {
-        // Validate all preferences match the namespace
-        if !values
-            .iter()
-            .all(|value| pref_match_namespace(namespace, &value.r#type))
-        {
-            bail!("Some preferences are not in the {} namespace", namespace);
-        }
-
-        // Validate scope permissions
-        let not_in_scope = values
-            .iter()
-            .filter(|val| !pref_in_scope(scope, &val.r#type))
-            .collect::<Vec<_>>();
-
-        if !not_in_scope.is_empty() {
-            bail!("Do not have authorization to set preferences");
-        }
-
-        // Get current preferences
-        let mut tx = self
-            .reader
-            .db
-            .pool
-            .begin()
-            .await
-            .context("failed to begin transaction")?;
-
-        // Find all preferences in the namespace
-        let namespace_pattern = format!("{}%", namespace);
-        let all_prefs = sqlx::query!(
-            "SELECT id, name FROM account_pref WHERE name LIKE ? OR name = ?",
-            namespace_pattern,
-            namespace
-        )
-        .fetch_all(&mut *tx)
-        .await
-        .context("failed to fetch preferences")?;
-
-        // Filter to those in scope
-        let all_pref_ids_in_namespace = all_prefs
-            .iter()
-            .filter(|pref| pref_match_namespace(namespace, &pref.name))
-            .filter(|pref| pref_in_scope(scope, &pref.name))
-            .map(|pref| pref.id)
-            .collect::<Vec<i64>>();
-
-        // Delete existing preferences in namespace
-        if !all_pref_ids_in_namespace.is_empty() {
-            let placeholders = std::iter::repeat("?")
-                .take(all_pref_ids_in_namespace.len())
-                .collect::<Vec<_>>()
-                .join(",");
-
-            let query = format!("DELETE FROM account_pref WHERE id IN ({})", placeholders);
-
-            let mut query_builder = sqlx::query(&query);
-            for id in &all_pref_ids_in_namespace {
-                query_builder = query_builder.bind(id);
-            }
-
-            query_builder
-                .execute(&mut *tx)
-                .await
-                .context("failed to delete preferences")?;
-        }
-
-        // Insert new preferences
-        if !values.is_empty() {
-            for pref in values {
-                let value_json = serde_json::to_string(&pref.value)?;
-                sqlx::query!(
-                    "INSERT INTO account_pref (name, valueJson) VALUES (?, ?)",
-                    pref.r#type,
-                    value_json
-                )
-                .execute(&mut *tx)
-                .await
-                .context("failed to insert preference")?;
-            }
-        }
-
-        tx.commit().await.context("failed to commit transaction")?;
-
-        Ok(())
-    }
-}

src/actor_store/prepared_write.rs

···
+use std::str::FromStr;
+
+use cidv10::Cid as CidV10;
 use rsky_repo::types::{
     CommitAction, PreparedBlobRef, PreparedCreateOrUpdate, PreparedDelete, WriteOpAction,
 };
···
         }
     }
 
-    pub fn cid(&self) -> Option<Cid> {
+    pub fn cid(&self) -> Option<CidV10> {
         match self {
-            PreparedWrite::Create(w) => Some(w.cid),
-            PreparedWrite::Update(w) => Some(w.cid),
+            PreparedWrite::Create(w) => Some(CidV10::from_str(w.cid.to_string().as_str()).unwrap()),
+            PreparedWrite::Update(w) => Some(CidV10::from_str(w.cid.to_string().as_str()).unwrap()),
             PreparedWrite::Delete(_) => None,
         }
     }
 
-    pub fn swap_cid(&self) -> &Option<Cid> {
+    pub fn swap_cid(&self) -> Option<CidV10> {
         match self {
-            PreparedWrite::Create(w) => &w.swap_cid,
-            PreparedWrite::Update(w) => &w.swap_cid,
-            PreparedWrite::Delete(w) => &w.swap_cid,
+            PreparedWrite::Create(w) => w
+                .swap_cid
+                .as_ref()
+                .map(|cid| CidV10::from_str(cid.to_string().as_str()).unwrap()),
+            PreparedWrite::Update(w) => w
+                .swap_cid
+                .as_ref()
+                .map(|cid| CidV10::from_str(cid.to_string().as_str()).unwrap()),
+            PreparedWrite::Delete(w) => w
+                .swap_cid
+                .as_ref()
+                .map(|cid| CidV10::from_str(cid.to_string().as_str()).unwrap()),
         }
     }
 

src/actor_store/record.rs

···
+//! Record storage and retrieval for the actor store.
+
+use anyhow::{Context as _, Result, bail};
+use atrium_api::com::atproto::admin::defs::StatusAttr;
+use atrium_repo::Cid;
+use diesel::associations::HasTable;
+use diesel::prelude::*;
+use rsky_pds::models::{Backlink, Record};
+use rsky_pds::schema::pds::repo_block::dsl::repo_block;
+use rsky_pds::schema::pds::{backlink, record};
+use rsky_repo::types::WriteOpAction;
+use rsky_syntax::aturi::AtUri;
+use std::str::FromStr;
+
+use crate::actor_store::blob::BlobStorePlaceholder;
+use crate::actor_store::db::ActorDb;
+
+/// Combined handler for record operations with both read and write capabilities.
+pub(crate) struct RecordHandler {
+    /// Database connection.
+    pub db: ActorDb,
+    /// DID of the actor.
+    pub did: String,
+    /// Blob store for handling blobs.
+    pub blobstore: Option<BlobStorePlaceholder>,
+}
+
+/// Record descriptor containing URI, path, and CID.
+pub(crate) struct RecordDescript {
+    /// Record URI.
+    pub uri: String,
+    /// Record path.
+    pub path: String,
+    /// Record CID.
+    pub cid: Cid,
+}
+
+/// Record data with values.
+#[derive(Debug, Clone)]
+pub(crate) struct RecordData {
+    /// Record URI.
+    pub uri: String,
+    /// Record CID.
+    pub cid: String,
+    /// Record value as JSON.
+    pub value: serde_json::Value,
+    /// When the record was indexed.
+    pub indexedAt: String,
+    /// Reference for takedown, if any.
+    pub takedownRef: Option<String>,
+}
+
+/// Options for listing records in a collection.
+#[derive(Debug, Clone)]
+pub(crate) struct ListRecordsOptions {
+    /// Collection to list records from.
+    pub collection: String,
+    /// Maximum number of records to return.
+    pub limit: i64,
+    /// Whether to reverse the sort order.
+    pub reverse: bool,
+    /// Cursor for pagination.
+    pub cursor: Option<String>,
+    /// Start key (deprecated).
+    pub rkey_start: Option<String>,
+    /// End key (deprecated).
+    pub rkey_end: Option<String>,
+    /// Whether to include soft-deleted records.
+    pub include_soft_deleted: bool,
+}
+
+impl RecordHandler {
+    /// Create a new record handler.
+    pub(crate) fn new(db: ActorDb, did: String) -> Self {
+        Self {
+            db,
+            did,
+            blobstore: None,
+        }
+    }
+
+    /// Create a new record handler with blobstore support.
+    pub(crate) fn new_with_blobstore(
+        db: ActorDb,
+        blobstore: BlobStorePlaceholder,
+        did: String,
+    ) -> Self {
+        Self {
+            db,
+            did,
+            blobstore: Some(blobstore),
+        }
+    }
+
+    /// Count the total number of records.
+    pub(crate) async fn record_count(&self) -> Result<i64> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::record::dsl::*;
+
+                record.filter(did.eq(&did)).count().get_result(conn)
+            })
+            .await
+    }
+
+    /// List all records.
+    pub(crate) async fn list_all(&self) -> Result<Vec<RecordDescript>> {
+        let did = self.did.clone();
+        let mut records = Vec::new();
+        let mut current_cursor = Some("".to_string());
+
+        while let Some(cursor) = current_cursor.take() {
+            let cursor_clone = cursor.clone();
+            let did_clone = did.clone();
+
+            let rows = self
+                .db
+                .run(move |conn| {
+                    use rsky_pds::schema::pds::record::dsl::*;
+
+                    record
+                        .filter(did.eq(&did_clone))
+                        .filter(uri.gt(&cursor_clone))
+                        .order(uri.asc())
+                        .limit(1000)
+                        .select((uri, cid))
+                        .load::<(String, String)>(conn)
+                })
+                .await?;
+
+            for (uri_str, cid_str) in &rows {
+                let uri = uri_str.clone();
+                let parts: Vec<&str> = uri.rsplitn(2, '/').collect();
+                let path = if parts.len() == 2 {
+                    format!("{}/{}", parts[1], parts[0])
+                } else {
+                    uri.clone()
+                };
+
+                match Cid::from_str(&cid_str) {
+                    Ok(cid) => records.push(RecordDescript { uri, path, cid }),
+                    Err(e) => tracing::warn!("Invalid CID in database: {}", e),
+                }
+            }
+
+            if let Some(last) = rows.last() {
+                current_cursor = Some(last.0.clone());
+            } else {
+                break;
+            }
+        }
+
+        Ok(records)
+    }
+
+    /// List all collections in the repository.
+    pub(crate) async fn list_collections(&self) -> Result<Vec<String>> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::record::dsl::*;
+
+                record
+                    .filter(did.eq(&did))
+                    .group_by(collection)
+                    .select(collection)
+                    .load::<String>(conn)
+            })
+            .await
+    }
+
+    /// List records for a specific collection.
+    pub(crate) async fn list_records_for_collection(
+        &self,
+        opts: ListRecordsOptions,
+    ) -> Result<Vec<RecordData>> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                // Start building the query
+                let mut query = record::table
+                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
+                    .filter(record::did.eq(&did))
+                    .filter(record::collection.eq(&opts.collection))
+                    .into_boxed();
+
+                // Handle soft-deleted records
+                if !opts.include_soft_deleted {
+                    query = query.filter(record::takedownRef.is_null());
+                }
+
+                // Handle cursor-based pagination first
+                if let Some(cursor) = &opts.cursor {
+                    if opts.reverse {
+                        query = query.filter(record::rkey.gt(cursor));
+                    } else {
+                        query = query.filter(record::rkey.lt(cursor));
+                    }
+                } else {
+                    // Fall back to deprecated rkey-based pagination
+                    if let Some(start) = &opts.rkey_start {
+                        query = query.filter(record::rkey.gt(start));
+                    }
+                    if let Some(end) = &opts.rkey_end {
+                        query = query.filter(record::rkey.lt(end));
+                    }
+                }
+
+                // Add order and limit
+                if opts.reverse {
+                    query = query.order(record::rkey.asc());
+                } else {
+                    query = query.order(record::rkey.desc());
+                }
+
+                query = query.limit(opts.limit);
+
+                // Execute the query
+                let results = query
+                    .select((
+                        record::uri,
+                        record::cid,
+                        record::indexedAt,
+                        record::takedownRef,
+                        repo_block::content,
+                    ))
+                    .load::<(String, String, String, Option<String>, Vec<u8>)>(conn)?;
+
+                // Convert results to RecordData
+                let records = results
+                    .into_iter()
+                    .map(|(uri, cid, indexedAt, takedownRef, content)| {
+                        let value = serde_json::from_slice(&content)
+                            .with_context(|| format!("Failed to decode record {}", cid))?;
+
+                        Ok(RecordData {
+                            uri,
+                            cid,
+                            value,
+                            indexedAt,
+                            takedownRef,
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+
+                Ok(records)
+            })
+            .await
+    }
+
+    /// Get a specific record by URI.
+    pub(crate) async fn get_record(
+        &self,
+        uri: &AtUri,
+        cid: Option<&str>,
+        include_soft_deleted: bool,
+    ) -> Result<Option<RecordData>> {
+        let did = self.did.clone();
+        let uri_str = uri.to_string();
+        let cid_opt = cid.map(|c| c.to_string());
+
+        self.db
+            .run(move |conn| {
+                let mut query = record::table
+                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
+                    .filter(record::did.eq(&did))
+                    .filter(record::uri.eq(&uri_str))
+                    .into_boxed();
+
+                if !include_soft_deleted {
+                    query = query.filter(record::takedownRef.is_null());
+                }
+
+                if let Some(cid_val) = cid_opt {
+                    query = query.filter(record::cid.eq(cid_val));
+                }
+
+                let result = query
+                    .select((
+                        record::uri,
+                        record::cid,
+                        record::indexedAt,
+                        record::takedownRef,
+                        repo_block::content,
+                    ))
+                    .first::<(String, String, String, Option<String>, Vec<u8>)>(conn)
+                    .optional()?;
+
+                if let Some((uri, cid, indexedAt, takedownRef, content)) = result {
+                    let value = serde_json::from_slice(&content)
+                        .with_context(|| format!("Failed to decode record {}", cid))?;
+
+                    Ok(Some(RecordData {
+                        uri,
+                        cid,
+                        value,
+                        indexedAt,
+                        takedownRef,
+                    }))
+                } else {
+                    Ok(None)
+                }
+            })
+            .await
+    }
+
+    /// Check if a record exists.
+    pub(crate) async fn has_record(
+        &self,
+        uri: &str,
+        cid: Option<&str>,
+        include_soft_deleted: bool,
+    ) -> Result<bool> {
+        let did = self.did.clone();
+        let uri_str = uri.to_string();
+        let cid_opt = cid.map(|c| c.to_string());
+
+        self.db
+            .run(move |conn| {
+                let mut query = record::table
+                    .filter(record::did.eq(&did))
+                    .filter(record::uri.eq(&uri_str))
+                    .into_boxed();
+
+                if !include_soft_deleted {
+                    query = query.filter(record::takedownRef.is_null());
+                }
+
+                if let Some(cid_val) = cid_opt {
+                    query = query.filter(record::cid.eq(cid_val));
+                }
+
+                let exists = query
+                    .select(record::uri)
+                    .first::<String>(conn)
+                    .optional()?
+                    .is_some();
+
+                Ok(exists)
+            })
+            .await
+    }
+
+    /// Get the takedown status of a record.
+    pub(crate) async fn get_record_takedown_status(&self, uri: &str) -> Result<Option<StatusAttr>> {
+        let did = self.did.clone();
+        let uri_str = uri.to_string();
+
+        self.db
+            .run(move |conn| {
+                let result = record::table
+                    .filter(record::did.eq(&did))
+                    .filter(record::uri.eq(&uri_str))
+                    .select(record::takedownRef)
+                    .first::<Option<String>>(conn)
+                    .optional()?;
+
+                match result {
+                    Some(takedown) => match takedown {
+                        Some(takedownRef) => Ok(Some(StatusAttr {
+                            applied: true,
+                            r#ref: Some(takedownRef),
+                        })),
+                        None => Ok(Some(StatusAttr {
+                            applied: false,
+                            r#ref: None,
+                        })),
+                    },
+                    None => Ok(None),
+                }
+            })
+            .await
+    }
+
+    /// Get the current CID for a record URI.
+    pub(crate) async fn get_current_record_cid(&self, uri: &str) -> Result<Option<Cid>> {
+        let did = self.did.clone();
+        let uri_str = uri.to_string();
+
+        self.db
+            .run(move |conn| {
+                let result = record::table
+                    .filter(record::did.eq(&did))
+                    .filter(record::uri.eq(&uri_str))
+                    .select(record::cid)
+                    .first::<String>(conn)
+                    .optional()?;
+
+                match result {
+                    Some(cid_str) => {
+                        let cid = Cid::from_str(&cid_str)?;
+                        Ok(Some(cid))
+                    }
+                    None => Ok(None),
+                }
+            })
+            .await
+    }
+
+    /// Get backlinks for a record.
+    pub(crate) async fn get_record_backlinks(
+        &self,
+        collection: &str,
+        path: &str,
+        linkTo: &str,
+    ) -> Result<Vec<Record>> {
+        let did = self.did.clone();
+        let collection_str = collection.to_string();
+        let path_str = path.to_string();
+        let linkTo_str = linkTo.to_string();
+
+        self.db
+            .run(move |conn| {
+                backlink::table
+                    .inner_join(record::table.on(backlink::uri.eq(record::uri)))
+                    .filter(backlink::path.eq(&path_str))
+                    .filter(backlink::linkTo.eq(&linkTo_str))
+                    .filter(record::collection.eq(&collection_str))
+                    .filter(record::did.eq(&did))
+                    .select(Record::as_select())
+                    .load::<Record>(conn)
+            })
+            .await
+    }
+
+    /// Get backlink conflicts for a record.
+    pub(crate) async fn get_backlink_conflicts(
+        &self,
+        uri: &AtUri,
+        record: &serde_json::Value,
+    ) -> Result<Vec<String>> {
+        let backlinks = get_backlinks(uri, record)?;
+        if backlinks.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let did = self.did.clone();
+        let uri_collection = uri.get_collection().to_string();
+        let mut conflicts = Vec::new();
+
+        for backlink in backlinks {
+            let path_str = backlink.path.clone();
+            let linkTo_str = backlink.linkTo.clone();
+
+            let results = self
+                .db
+                .run(move |conn| {
+                    backlink::table
+                        .inner_join(record::table.on(backlink::uri.eq(record::uri)))
+                        .filter(backlink::path.eq(&path_str))
+                        .filter(backlink::linkTo.eq(&linkTo_str))
+                        .filter(record::collection.eq(&uri_collection))
+                        .filter(record::did.eq(&did))
+                        .select(record::uri)
+                        .load::<String>(conn)
+                })
+                .await?;
+
+            conflicts.extend(results);
+        }
+
+        Ok(conflicts)
+    }
+
+    /// List existing blocks in the repository.
+    pub(crate) async fn list_existing_blocks(&self) -> Result<Vec<Cid>> {
+        let did = self.did.clone();
+        let mut blocks = Vec::new();
+        let mut current_cursor = Some("".to_string());
+
+        while let Some(cursor) = current_cursor.take() {
+            let cursor_clone = cursor.clone();
+            let did_clone = did.clone();
+
+            let rows = self
+                .db
+                .run(move |conn| {
+                    use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                    repo_block
+                        .filter(did.eq(&did_clone))
+                        .filter(cid.gt(&cursor_clone))
+                        .order(cid.asc())
+                        .limit(1000)
+                        .select(cid)
+                        .load::<String>(conn)
+                })
+                .await?;
+
+            for cid_str in &rows {
+                match Cid::from_str(cid_str) {
+                    Ok(cid) => blocks.push(cid),
+                    Err(e) => tracing::warn!("Invalid CID in database: {}", e),
+                }
+            }
+
+            if let Some(last) = rows.last() {
+                current_cursor = Some(last.clone());
+            } else {
+                break;
+            }
+        }
+
+        Ok(blocks)
+    }
+
+    /// Get the profile record for this repository
+    pub(crate) async fn get_profile_record(&self) -> Result<Option<serde_json::Value>> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                let result = record::table
+                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
+                    .filter(record::did.eq(&did))
+                    .filter(record::collection.eq("app.bsky.actor.profile"))
+                    .filter(record::rkey.eq("self"))
+                    .select(repo_block::content)
+                    .first::<Vec<u8>>(conn)
+                    .optional()?;
+
+                if let Some(content) = result {
+                    let value = serde_json::from_slice(&content)
+                        .context("Failed to decode profile record")?;
+                    Ok(Some(value))
+                } else {
+                    Ok(None)
+                }
+            })
+            .await
+    }
+
+    /// Get records created or updated since a specific revision
+    pub(crate) async fn get_records_since_rev(&self, rev: &str) -> Result<Vec<RecordData>> {
+        let did = self.did.clone();
+        let rev_str = rev.to_string();
+
+        // First check if the revision exists
+        let exists = self
+            .db
+            .run({
+                let did_clone = did.clone();
+                let rev_clone = rev_str.clone();
+
+                move |conn| {
+                    record::table
+                        .filter(record::did.eq(&did_clone))
+                        .filter(record::repoRev.le(&rev_clone))
+                        .count()
+                        .get_result::<i64>(conn)
+                        .map(|count| count > 0)
+                }
+            })
+            .await?;
+
+        if !exists {
+            // No records before this revision - possible account migration case
+            return Ok(Vec::new());
+        }
+
+        // Get records since the revision
+        self.db
+            .run(move |conn| {
+                let results = record::table
+                    .inner_join(repo_block::table.on(repo_block::cid.eq(record::cid)))
+                    .filter(record::did.eq(&did))
+                    .filter(record::repoRev.gt(&rev_str))
+                    .order(record::repoRev.asc())
+                    .limit(10)
+                    .select((
+                        record::uri,
+                        record::cid,
+                        record::indexedAt,
+                        repo_block::content,
+                    ))
+                    .load::<(String, String, String, Vec<u8>)>(conn)?;
+
+                let records = results
+                    .into_iter()
+                    .map(|(uri, cid, indexedAt, content)| {
+                        let value = serde_json::from_slice(&content)
+                            .with_context(|| format!("Failed to decode record {}", cid))?;
+
+                        Ok(RecordData {
+                            uri,
+                            cid,
+                            value,
+                            indexedAt,
+                            takedownRef: None, // Not included in the query
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+
+                Ok(records)
+            })
+            .await
+    }
+
+    // Transactor methods
+    // -----------------
+
+    /// Index a record in the database.
+    pub(crate) async fn index_record(
+        &self,
+        uri: AtUri,
+        cid: Cid,
+        record: Option<&serde_json::Value>,
+        action: WriteOpAction,
+        repoRev: &str,
+        timestamp: Option<String>,
+    ) -> Result<()> {
+        let uri_str = uri.to_string();
+        tracing::debug!("Indexing record {}", uri_str);
+
+        if !uri_str.starts_with("at://did:") {
+            return Err(anyhow::anyhow!("Expected indexed URI to contain DID"));
+        }
+
+        let collection = uri.get_collection().to_string();
+        let rkey = uri.get_rkey().to_string();
+
+        if collection.is_empty() {
+            return Err(anyhow::anyhow!(
+                "Expected indexed URI to contain a collection"
+            ));
+        } else if rkey.is_empty() {
+            return Err(anyhow::anyhow!(
+                "Expected indexed URI to contain a record key"
+            ));
+        }
+
+        let cid_str = cid.to_string();
+        let now = timestamp.unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
+        let did = self.did.clone();
+        let repoRev = repoRev.to_string();
+
+        // Create the record for database insertion
+        let record_values = (
+            record::did.eq(&did),
+            record::uri.eq(&uri_str),
+            record::cid.eq(&cid_str),
+            record::collection.eq(&collection),
+            record::rkey.eq(&rkey),
+            record::repoRev.eq(&repoRev),
+            record::indexedAt.eq(&now),
+        );
+
+        self.db
+            .transaction(move |conn| {
+                // Track current version of record
+                diesel::insert_into(record::table)
+                    .values(&record_values)
+                    .on_conflict(record::uri)
+                    .do_update()
+                    .set((
+                        record::cid.eq(&cid_str),
+                        record::repoRev.eq(&repoRev),
+                        record::indexedAt.eq(&now),
+                    ))
+                    .execute(conn)
+                    .context("Failed to insert/update record")?;
+
+                // Maintain backlinks if record is provided
+                if let Some(record_value) = record {
+                    let backlinks = get_backlinks(&uri, record_value)?;
+
+                    if action == WriteOpAction::Update {
+                        // On update, clear old backlinks first
+                        diesel::delete(backlink::table)
+                            .filter(backlink::uri.eq(&uri_str))
+                            .execute(conn)
+                            .context("Failed to delete existing backlinks")?;
+                    }
+
+                    if !backlinks.is_empty() {
+                        // Insert all backlinks at once
+                        let backlink_values: Vec<_> = backlinks
+                            .into_iter()
+                            .map(|backlink| {
+                                (
+                                    backlink::uri.eq(&uri_str),
+                                    backlink::path.eq(&backlink.path),
+                                    backlink::linkTo.eq(&backlink.linkTo),
+                                )
+                            })
+                            .collect();
+
+                        diesel::insert_into(backlink::table)
+                            .values(&backlink_values)
+                            .on_conflict_do_nothing()
+                            .execute(conn)
+                            .context("Failed to insert backlinks")?;
+                    }
+                }
+
+                tracing::info!("Indexed record {}", uri_str);
+                Ok(())
+            })
+            .await
+    }
+
+    /// Delete a record from the database.
+    pub(crate) async fn delete_record(&self, uri: &AtUri) -> Result<()> {
+        let uri_str = uri.to_string();
+        tracing::debug!("Deleting indexed record {}", uri_str);
+
+        self.db
+            .transaction(move |conn| {
+                // Delete from record table
+                diesel::delete(record::table)
+                    .filter(record::uri.eq(&uri_str))
+                    .execute(conn)
+                    .context("Failed to delete record")?;
+
+                // Delete from backlink table
+                diesel::delete(backlink::table)
+                    .filter(backlink::uri.eq(&uri_str))
+                    .execute(conn)
+                    .context("Failed to delete record backlinks")?;
+
+                tracing::info!("Deleted indexed record {}", uri_str);
+                Ok(())
+            })
+            .await
+    }
+
+    /// Remove backlinks for a URI.
+    pub(crate) async fn remove_backlinks_by_uri(&self, uri: &str) -> Result<()> {
+        let uri_str = uri.to_string();
+
+        self.db
+            .run(move |conn| {
+                diesel::delete(backlink::table)
+                    .filter(backlink::uri.eq(&uri_str))
+                    .execute(conn)
+                    .context("Failed to remove backlinks")?;
+
+                Ok(())
+            })
+            .await
+    }
+
+    /// Add backlinks to the database.
+    pub(crate) async fn add_backlinks(&self, backlinks: Vec<Backlink>) -> Result<()> {
+        if backlinks.is_empty() {
+            return Ok(());
+        }
+
+        self.db
+            .run(move |conn| {
+                let backlink_values: Vec<_> = backlinks
+                    .into_iter()
+                    .map(|backlink| {
+                        (
+                            backlink::uri.eq(&backlink.uri),
+                            backlink::path.eq(&backlink.path),
+                            backlink::linkTo.eq(&backlink.linkTo),
+                        )
+                    })
+                    .collect();
+
+                diesel::insert_into(backlink::table)
+                    .values(&backlink_values)
+                    .on_conflict_do_nothing()
+                    .execute(conn)
+                    .context("Failed to add backlinks")?;
+
+                Ok(())
+            })
+            .await
+    }
+
+    /// Update the takedown status of a record.
+    pub(crate) async fn update_record_takedown_status(
+        &self,
+        uri: &AtUri,
+        takedown: StatusAttr,
+    ) -> Result<()> {
+        let uri_str = uri.to_string();
+        let did = self.did.clone();
+        let takedownRef = if takedown.applied {
+            takedown
+                .r#ref
+                .or_else(|| Some(chrono::Utc::now().to_rfc3339()))
+        } else {
+            None
+        };
+
+        self.db
+            .run(move |conn| {
+                diesel::update(record::table)
+                    .filter(record::did.eq(&did))
+                    .filter(record::uri.eq(&uri_str))
+                    .set(record::takedownRef.eq(takedownRef))
+                    .execute(conn)
+                    .context("Failed to update record takedown status")?;
+
+                Ok(())
+            })
+            .await
+    }
+}
+
+/// Extract backlinks from a record.
+pub(super) fn get_backlinks(uri: &AtUri, record: &serde_json::Value) -> Result<Vec<Backlink>> {
+    let mut backlinks = Vec::new();
+
+    // Check for record type
+    if let Some(record_type) = record.get("$type").and_then(|t| t.as_str()) {
+        // Handle follow and block records
+        if record_type == "app.bsky.graph.follow" || record_type == "app.bsky.graph.block" {
+            if let Some(subject) = record.get("subject").and_then(|s| s.as_str()) {
+                // Verify it's a valid DID
+                if subject.starts_with("did:") {
+                    backlinks.push(Backlink {
+                        uri: uri.to_string(),
+                        path: "subject".to_string(),
+                        linkTo: subject.to_string(),
+                    });
+                }
+            }
+        }
+        // Handle like and repost records
+        else if record_type == "app.bsky.feed.like" || record_type == "app.bsky.feed.repost" {
+            if let Some(subject) = record.get("subject") {
+                if let Some(subject_uri) = subject.get("uri").and_then(|u| u.as_str()) {
+                    // Verify it's a valid AT URI
+                    if subject_uri.starts_with("at://") {
+                        backlinks.push(Backlink {
+                            uri: uri.to_string(),
+                            path: "subject.uri".to_string(),
+                            linkTo: subject_uri.to_string(),
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(backlinks)
+}

src/actor_store/record/mod.rs

···
-//! Record storage and retrieval for the actor store.
-
-mod reader;
-mod transactor;
-
-pub(crate) use reader::RecordReader;
-pub(crate) use transactor::RecordTransactor;

src/actor_store/record/reader.rs

···
-//! Reader for record data in the actor store.
-
-use anyhow::{Context as _, Result};
-use atrium_repo::Cid;
-use rsky_syntax::aturi::AtUri;
-use sqlx::Row;
-use std::str::FromStr;
-
-use crate::actor_store::{ActorDb, db::schema::Backlink};
-
-/// Reader for record data.
-pub(crate) struct RecordReader {
-    /// Database connection.
-    pub db: ActorDb,
-}
-
-/// Record descriptor containing URI, path, and CID.
-pub(crate) struct RecordDescript {
-    /// Record URI.
-    pub uri: String,
-    /// Record path.
-    pub path: String,
-    /// Record CID.
-    pub cid: Cid,
-}
-
-/// Record data with values.
-#[derive(Debug, Clone)]
-pub(crate) struct RecordData {
-    /// Record URI.
-    pub uri: String,
-    /// Record CID.
-    pub cid: String,
-    /// Record value as JSON.
-    pub value: serde_json::Value,
-    /// When the record was indexed.
-    pub indexed_at: String,
-    /// Reference for takedown, if any.
-    pub takedown_ref: Option<String>,
-}
-
-/// Options for listing records in a collection.
-#[derive(Debug, Clone)]
-pub(crate) struct ListRecordsOptions {
-    /// Collection to list records from.
-    pub collection: String,
-    /// Maximum number of records to return.
-    pub limit: i64,
-    /// Whether to reverse the sort order.
-    pub reverse: bool,
-    /// Cursor for pagination.
-    pub cursor: Option<String>,
-    /// Start key (deprecated).
-    pub rkey_start: Option<String>,
-    /// End key (deprecated).
-    pub rkey_end: Option<String>,
-    /// Whether to include soft-deleted records.
-    pub include_soft_deleted: bool,
-}
-
-impl RecordReader {
-    /// Create a new record reader.
-    pub(crate) fn new(db: ActorDb) -> Self {
-        Self { db }
-    }
-
-    /// Count the total number of records.
-    pub(crate) async fn record_count(&self) -> Result<i64> {
-        let result = sqlx::query!(r#"SELECT COUNT(*) as count FROM record"#)
-            .fetch_one(&self.db.pool)
-            .await
-            .context("failed to count records")?;
-
-        Ok(result.count)
-    }
-
-    /// List all records.
-    pub(crate) async fn list_all(&self) -> Result<Vec<RecordDescript>> {
-        let mut records = Vec::new();
-        let mut cursor = Some("".to_string());
-
-        while let Some(current_cursor) = cursor.take() {
-            let rows = sqlx::query!(
-                "SELECT uri, cid FROM record WHERE uri > ? ORDER BY uri ASC LIMIT 1000",
-                current_cursor
-            )
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to fetch records")?;
-
-            for row in &rows {
-                let uri = row.uri.clone();
-                let parts: Vec<&str> = uri.rsplitn(2, '/').collect();
-                let path = if parts.len() == 2 {
-                    format!("{}/{}", parts[1], parts[0])
-                } else {
-                    uri.clone()
-                };
-
-                match Cid::from_str(&row.cid) {
-                    Ok(cid) => records.push(RecordDescript { uri, path, cid }),
-                    Err(e) => tracing::warn!("Invalid CID in database: {}", e),
-                }
-            }
-
-            if let Some(last) = rows.last() {
-                cursor = Some(last.uri.clone());
-            }
-        }
-
-        Ok(records)
-    }
-
-    /// List all collections in the repository.
-    pub(crate) async fn list_collections(&self) -> Result<Vec<String>> {
-        let rows = sqlx::query!("SELECT collection FROM record GROUP BY collection")
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to list collections")?;
-
-        Ok(rows.into_iter().map(|row| row.collection).collect())
-    }
-
-    /// List records for a specific collection.
-    pub(crate) async fn list_records_for_collection(
-        &self,
-        opts: ListRecordsOptions,
-    ) -> Result<Vec<RecordData>> {
-        let mut query = sqlx::QueryBuilder::new(
-            "SELECT r.uri, r.cid, r.indexed_at, r.takedown_ref, b.content
-             FROM record r
-             INNER JOIN repo_block b ON b.cid = r.cid
-             WHERE r.collection = ",
-        );
-
-        query.push_bind(&opts.collection);
-
-        if !opts.include_soft_deleted {
-            query.push(" AND r.takedown_ref IS NULL");
-        }
-
-        // Handle cursor-based pagination first
-        if let Some(cursor) = &opts.cursor {
-            if opts.reverse {
-                query.push(" AND r.rkey > ");
-            } else {
-                query.push(" AND r.rkey < ");
-            }
-            query.push_bind(cursor);
-        } else {
-            // Fall back to deprecated rkey-based pagination
-            if let Some(start) = &opts.rkey_start {
-                query.push(" AND r.rkey > ");
-                query.push_bind(start);
-            }
-            if let Some(end) = &opts.rkey_end {
-                query.push(" AND r.rkey < ");
-                query.push_bind(end);
-            }
-        }
-
-        // Add order and limit
-        if opts.reverse {
-            query.push(" ORDER BY r.rkey ASC");
-        } else {
-            query.push(" ORDER BY r.rkey DESC");
-        }
-
-        query.push(" LIMIT ");
-        query.push_bind(opts.limit);
-
-        let rows = query
-            .build()
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to list records")?;
-
-        let mut records = Vec::with_capacity(rows.len());
-        for row in rows {
-            let uri: String = row.get("uri");
-            let cid: String = row.get("cid");
-            let indexed_at: String = row.get("indexed_at");
-            let takedown_ref: Option<String> = row.get("takedown_ref");
-            let content: Vec<u8> = row.get("content");
-
-            let value = serde_json::from_slice(&content)
-                .context(format!("failed to decode record {}", cid))?;
-
-            records.push(RecordData {
-                uri,
-                cid,
-                value,
-                indexed_at,
-                takedown_ref,
-            });
-        }
-
-        Ok(records)
-    }
-
-    /// Get a specific record by URI.
-    pub(crate) async fn get_record(
-        &self,
-        uri: &str,
-        cid: Option<&str>,
-        include_soft_deleted: bool,
-    ) -> Result<Option<RecordData>> {
-        let mut query = sqlx::QueryBuilder::new(
-            "SELECT r.uri, r.cid, r.indexed_at, r.takedown_ref, b.content
-             FROM record r
-             INNER JOIN repo_block b ON b.cid = r.cid
-             WHERE r.uri = ",
-        );
-
-        query.push_bind(uri);
-
-        if !include_soft_deleted {
-            query.push(" AND r.takedown_ref IS NULL");
-        }
-
-        if let Some(cid_str) = cid {
-            query.push(" AND r.cid = ");
-            query.push_bind(cid_str);
-        }
-
-        let row = query
-            .build()
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to fetch record")?;
-
-        if let Some(row) = row {
-            let uri = row.get::<String, _>("uri");
-            let cid = row.get::<String, _>("cid");
-            let indexed_at = row.get::<String, _>("indexed_at");
-            let takedown_ref = row.get::<Option<String>, _>("takedown_ref");
-            let content: Vec<u8> = row.get("content");
-
-            // Convert CBOR to Lexicon record
-            let value = serde_json::from_slice(&content)
-                .context(format!("failed to decode record {}", cid))?;
-
-            Ok(Some(RecordData {
-                uri,
-                cid,
-                value,
-                indexed_at,
-                takedown_ref,
-            }))
-        } else {
-            Ok(None)
-        }
-    }
-
-    /// Check if a record exists.
-    pub(crate) async fn has_record(
-        &self,
-        uri: &str,
-        cid: Option<&str>,
-        include_soft_deleted: bool,
-    ) -> Result<bool> {
-        let mut query = sqlx::QueryBuilder::new("SELECT uri FROM record WHERE uri = ");
-
-        query.push_bind(uri);
-
-        if !include_soft_deleted {
-            query.push(" AND takedown_ref IS NULL");
-        }
-
-        if let Some(cid_str) = cid {
-            query.push(" AND cid = ");
-            query.push_bind(cid_str);
-        }
-
-        let result = query
-            .build()
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to check record existence")?;
-
-        Ok(result.is_some())
-    }
-
-    /// Get the takedown status of a record.
-    pub(crate) async fn get_record_takedown_status(&self, uri: &str) -> Result<Option<StatusAttr>> {
-        let result = sqlx::query!("SELECT takedownRef FROM record WHERE uri = ?", uri)
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to fetch takedown status")?;
-
-        match result {
-            Some(row) => {
-                if let Some(takedown_ref) = row.takedownRef {
-                    Ok(Some(StatusAttr {
-                        applied: true,
-                        r#ref: Some(takedown_ref),
-                    }))
-                } else {
-                    Ok(Some(StatusAttr {
-                        applied: false,
-                        r#ref: None,
-                    }))
-                }
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// Get the current CID for a record URI.
-    pub(crate) async fn get_current_record_cid(&self, uri: &str) -> Result<Option<Cid>> {
-        let result = sqlx::query!("SELECT cid FROM record WHERE uri = ?", uri)
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to fetch record CID")?;
-
-        match result {
-            Some(row) => {
-                let cid = Cid::from_str(&row.cid)?;
-                Ok(Some(cid))
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// Get backlinks for a record.
-    pub(crate) async fn get_record_backlinks(
-        &self,
-        collection: &str,
-        path: &str,
-        link_to: &str,
-    ) -> Result<Vec<Record>> {
-        let rows = sqlx::query!(
-            r#"
-            SELECT r.*
-            FROM record r
-            INNER JOIN backlink b ON b.uri = r.uri
-            WHERE b.path = ?
-            AND b.linkTo = ?
-            AND r.collection = ?
-            "#,
-            path,
-            link_to,
-            collection
-        )
-        .fetch_all(&self.db.pool)
-        .await
-        .context("failed to fetch record backlinks")?;
-
-        let mut records = Vec::with_capacity(rows.len());
-        for row in rows {
-            records.push(Record {
-                uri: row.uri,
-                cid: row.cid,
-                collection: row.collection,
-                rkey: row.rkey,
-                repo_rev: Some(row.repoRev),
-                indexed_at: row.indexedAt,
-                takedown_ref: row.takedownRef,
-            });
-        }
-
-        Ok(records)
-    }
-
-    /// Get backlink conflicts for a record.
-    pub(crate) async fn get_backlink_conflicts(
-        &self,
-        uri: AtUri,
-        record: &serde_json::Value,
-    ) -> Result<Vec<String>> {
-        let backlinks = get_backlinks(&uri, record)?;
-        if backlinks.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        let mut conflicts = Vec::new();
-        for backlink in &backlinks {
-            let uri_collection = &uri.get_collection();
-            let rows = sqlx::query!(
-                r#"
-                SELECT r.uri
-                FROM record r
-                INNER JOIN backlink b ON b.uri = r.uri
-                WHERE b.path = ?
-                AND b.linkTo = ?
-                AND r.collection = ?
-                "#,
-                backlink.path,
-                backlink.link_to,
-                uri_collection
-            )
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to fetch backlink conflicts")?;
-
-            for row in rows {
-                conflicts.push(row.uri);
-            }
-        }
-
-        Ok(conflicts)
-    }
-
-    /// List existing blocks in the repository.
-    pub(crate) async fn list_existing_blocks(&self) -> Result<Vec<Cid>> {
-        let mut blocks = Vec::new();
-        let mut cursor = Some("".to_string());
-
-        while let Some(current_cursor) = cursor.take() {
-            let rows = sqlx::query!(
-                "SELECT cid FROM repo_block WHERE cid > ? ORDER BY cid ASC LIMIT 1000",
-                current_cursor
-            )
-            .fetch_all(&self.db.pool)
-            .await
-            .context("failed to fetch blocks")?;
-
-            for row in &rows {
-                match Cid::from_str(&row.cid) {
-                    Ok(cid) => blocks.push(cid),
-                    Err(e) => tracing::warn!("Invalid CID in database: {}", e),
-                }
-            }
-
-            if let Some(last) = rows.last() {
-                cursor = Some(last.cid.clone());
-            }
-        }
-
-        Ok(blocks)
-    }
-
-    /// Get the profile record for this repository
-    pub(crate) async fn get_profile_record(&self) -> Result<Option<serde_json::Value>> {
-        let row = sqlx::query!(
-            r#"
-            SELECT b.content
-            FROM record r
-            LEFT JOIN repo_block b ON b.cid = r.cid
-            WHERE r.collection = 'app.bsky.actor.profile'
-            AND r.rkey = 'self'
-            LIMIT 1
-            "#
-        )
-        .fetch_optional(&self.db.pool)
-        .await
-        .context("failed to fetch profile record")?;
-
-        if let Some(row) = row {
-            if let Some(content) = row.content {
-                // Convert CBOR to JSON
-                let value =
-                    serde_json::from_slice(&content).context("failed to decode profile record")?;
-                return Ok(Some(value));
-            }
-        }
-
-        Ok(None)
-    }
-
-    /// Get records created or updated since a specific revision
-    pub(crate) async fn get_records_since_rev(&self, rev: &str) -> Result<Vec<RecordData>> {
-        // First check if the revision exists
-        let sanity_check = sqlx::query!(
-            r#"SELECT repoRev FROM record WHERE repoRev <= ? LIMIT 1"#,
-            rev
-        )
-        .fetch_optional(&self.db.pool)
-        .await
-        .context("failed to check revision existence")?;
-
-        if sanity_check.is_none() {
-            // No records before this revision - possible account migration case
-            return Ok(Vec::new());
-        }
-
-        let rows = sqlx::query!(
-            r#"
-            SELECT r.uri, r.cid, r.indexedAt, b.content
-            FROM record r
-            INNER JOIN repo_block b ON b.cid = r.cid
-            WHERE r.repoRev > ?
-            ORDER BY r.repoRev ASC
-            LIMIT 10
-            "#,
-            rev
-        )
-        .fetch_all(&self.db.pool)
-        .await
-        .context("failed to fetch records since revision")?;
-
-        let mut records = Vec::with_capacity(rows.len());
-        for row in rows {
-            let value = serde_json::from_slice(&row.content)
-                .context(format!("failed to decode record {}", row.cid))?;
-
-            records.push(RecordData {
-                uri: row.uri,
-                cid: row.cid,
-                value,
-                indexed_at: row.indexedAt,
-                takedown_ref: None, // Not included in the query
-            });
-        }
-
-        Ok(records)
-    }
-}
-
-/// Database record structure.
-#[derive(Debug, Clone)]
-pub(crate) struct Record {
-    /// Record URI.
-    pub uri: String,
-    /// Record CID.
-    pub cid: String,
-    /// Record collection.
-    pub collection: String,
-    /// Record key.
-    pub rkey: String,
-    /// Repository revision.
-    pub repo_rev: Option<String>,
-    /// When the record was indexed.
-    pub indexed_at: String,
-    /// Reference for takedown, if any.
-    pub takedown_ref: Option<String>,
-}
-
-/// Status attribute for takedowns
-#[derive(Debug, Clone)]
-pub(crate) struct StatusAttr {
-    /// Whether the takedown is applied
-    pub applied: bool,
-    /// Reference for the takedown
-    pub r#ref: Option<String>,
-}
-
-/// Extract backlinks from a record.
-pub(super) fn get_backlinks(uri: &AtUri, record: &serde_json::Value) -> Result<Vec<Backlink>> {
-    let mut backlinks = Vec::new();
-
-    // Check for record type
-    if let Some(record_type) = record.get("$type").and_then(|t| t.as_str()) {
-        // Handle follow and block records
-        if record_type == "app.bsky.graph.follow" || record_type == "app.bsky.graph.block" {
-            if let Some(subject) = record.get("subject").and_then(|s| s.as_str()) {
-                // Verify it's a valid DID
-                if subject.starts_with("did:") {
-                    backlinks.push(Backlink {
-                        uri: uri.to_string(),
-                        path: "subject".to_string(),
-                        link_to: subject.to_string(),
-                    });
-                }
-            }
-        }
-        // Handle like and repost records
-        else if record_type == "app.bsky.feed.like" || record_type == "app.bsky.feed.repost" {
-            if let Some(subject) = record.get("subject") {
-                if let Some(subject_uri) = subject.get("uri").and_then(|u| u.as_str()) {
-                    // Verify it's a valid AT URI
-                    if subject_uri.starts_with("at://") {
-                        backlinks.push(Backlink {
-                            uri: uri.to_string(),
-                            path: "subject.uri".to_string(),
-                            link_to: subject_uri.to_string(),
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(backlinks)
-}

src/actor_store/record/transactor.rs

···
-//! Transactor for record operations in the actor store.
-
-use anyhow::{Context as _, Result};
-use atrium_repo::Cid;
-use rsky_repo::types::WriteOpAction;
-use rsky_syntax::aturi::AtUri;
-
-use crate::actor_store::ActorDb;
-use crate::actor_store::db::schema::Backlink;
-use crate::actor_store::record::reader::{RecordReader, StatusAttr, get_backlinks};
-use crate::repo::types::BlobStore as BlobStore;
-
-/// Transaction handler for record operations.
-pub(crate) struct RecordTransactor {
-    /// The record reader.
-    pub reader: RecordReader,
-    /// The blob store.
-    pub blobstore: BlobStore,
-}
-
-impl RecordTransactor {
-    /// Create a new record transactor.
-    pub(crate) fn new(db: ActorDb, blobstore: BlobStore) -> Self {
-        Self {
-            reader: RecordReader::new(db),
-            blobstore,
-        }
-    }
-
-    /// Index a record in the database.
-    pub(crate) async fn index_record(
-        &self,
-        uri: AtUri,
-        cid: Cid,
-        record: Option<serde_json::Value>,
-        action: WriteOpAction,
-        repo_rev: &str,
-        timestamp: Option<String>,
-    ) -> Result<()> {
-        let uri_str = uri.to_string();
-        tracing::debug!("Indexing record {}", uri_str);
-
-        if !uri_str.starts_with("at://did:") {
-            return Err(anyhow::anyhow!("Expected indexed URI to contain DID"));
-        }
-
-        let collection = uri.get_collection().to_string();
-        let rkey = uri.get_rkey().to_string();
-
-        if collection.is_empty() {
-            return Err(anyhow::anyhow!(
-                "Expected indexed URI to contain a collection"
-            ));
-        } else if rkey.is_empty() {
-            return Err(anyhow::anyhow!(
-                "Expected indexed URI to contain a record key"
-            ));
-        }
-
-        let cid_str = cid.to_string();
-        let now = timestamp.unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
-
-        // Track current version of record
-        _ = sqlx::query!(
-            r#"
-            INSERT INTO record (uri, cid, collection, rkey, repoRev, indexedAt)
-            VALUES (?, ?, ?, ?, ?, ?)
-            ON CONFLICT (uri) DO UPDATE SET
-                cid = ?,
-                repoRev = ?,
-                indexedAt = ?
-            "#,
-            uri_str,
-            cid_str,
-            collection,
-            rkey,
-            repo_rev,
-            now,
-            cid_str,
-            repo_rev,
-            now
-        )
-        .execute(&self.reader.db.pool)
-        .await
-        .context("failed to index record")?;
-
-        // Maintain backlinks if record is provided
-        if let Some(record_value) = record {
-            let backlinks = get_backlinks(&uri, &record_value)?;
-
-            if action == WriteOpAction::Update {
-                // On update, clear old backlinks first
-                self.remove_backlinks_by_uri(&uri_str).await?;
-            }
-
-            if !backlinks.is_empty() {
-                self.add_backlinks(backlinks).await?;
-            }
-        }
-
-        tracing::info!("Indexed record {}", uri_str);
-        Ok(())
-    }
-
-    /// Delete a record from the database.
-    pub(crate) async fn delete_record(&self, uri: &AtUri) -> Result<()> {
-        let uri_str = uri.to_string();
-        tracing::debug!("Deleting indexed record {}", uri_str);
-
-        // Delete the record and its backlinks in a transaction
-        let mut tx = self.reader.db.pool.begin().await?;
-
-        // Delete from record table
-        sqlx::query!("DELETE FROM record WHERE uri = ?", uri_str)
-            .execute(&mut *tx)
-            .await
-            .context("failed to delete record")?;
-
-        // Delete from backlink table
-        sqlx::query!("DELETE FROM backlink WHERE uri = ?", uri_str)
-            .execute(&mut *tx)
-            .await
-            .context("failed to delete record backlinks")?;
-
-        tx.commit().await.context("failed to commit transaction")?;
-
-        tracing::info!("Deleted indexed record {}", uri_str);
-        Ok(())
-    }
-
-    /// Remove backlinks for a URI.
-    pub(crate) async fn remove_backlinks_by_uri(&self, uri: &str) -> Result<()> {
-        sqlx::query!("DELETE FROM backlink WHERE uri = ?", uri)
-            .execute(&self.reader.db.pool)
-            .await
-            .context("failed to remove backlinks")?;
-
-        Ok(())
-    }
-
-    /// Add backlinks to the database.
-    pub(crate) async fn add_backlinks(&self, backlinks: Vec<Backlink>) -> Result<()> {
-        if backlinks.is_empty() {
-            return Ok(());
-        }
-
-        let mut query =
-            sqlx::QueryBuilder::new("INSERT INTO backlink (uri, path, link_to) VALUES ");
-
-        for (i, backlink) in backlinks.iter().enumerate() {
-            if i > 0 {
-                query.push(", ");
-            }
-
-            query
-                .push("(")
-                .push_bind(&backlink.uri)
-                .push(", ")
-                .push_bind(&backlink.path)
-                .push(", ")
-                .push_bind(&backlink.link_to)
-                .push(")");
-        }
-
-        query.push(" ON CONFLICT DO NOTHING");
-
-        query
-            .build()
-            .execute(&self.reader.db.pool)
-            .await
-            .context("failed to add backlinks")?;
-
-        Ok(())
-    }
-
-    /// Update the takedown status of a record.
-    pub(crate) async fn update_record_takedown_status(
-        &self,
-        uri: &AtUri,
-        takedown: StatusAttr,
-    ) -> Result<()> {
-        let uri_str = uri.to_string();
-        let takedown_ref = if takedown.applied {
-            takedown
-                .r#ref
-                .or_else(|| Some(chrono::Utc::now().to_rfc3339()))
-        } else {
-            None
-        };
-
-        sqlx::query!(
-            "UPDATE record SET takedownRef = ? WHERE uri = ?",
-            takedown_ref,
-            uri_str
-        )
-        .execute(&self.reader.db.pool)
-        .await
-        .context("failed to update record takedown status")?;
-
-        Ok(())
-    }
-}

src/actor_store/repo.rs

···
+//! Repository operations for actor store.
+
+use std::str::FromStr as _;
+use std::sync::Arc;
+
+use anyhow::{Context as _, Result};
+use atrium_repo::Cid;
+use cidv10::Cid as CidV10;
+use diesel::prelude::*;
+use rsky_repo::{
+    block_map::BlockMap,
+    cid_set::CidSet,
+    repo::Repo,
+    storage::{readable_blockstore::ReadableBlockstore as _, types::RepoStorage as _},
+    types::{
+        CommitAction, CommitData, CommitDataWithOps, CommitOp, PreparedBlobRef, PreparedWrite,
+        WriteOpAction, write_to_op,
+    },
+    util::format_data_key,
+};
+use rsky_syntax::aturi::AtUri;
+
+use super::{
+    ActorDb,
+    blob::{BackgroundQueue, BlobReader, BlobStorePlaceholder, BlobTransactor},
+    record::RecordHandler,
+};
+use crate::SigningKey;
+
+use crate::actor_store::sql_repo::SqlRepoStorage;
+
+/// Data for sync events.
+pub(crate) struct SyncEventData {
+    /// The CID of the repository root.
+    pub cid: Cid,
+    /// The revision of the repository.
+    pub rev: String,
+    /// The blocks in the repository.
+    pub blocks: BlockMap,
+}
+
+/// Unified repository handler for the actor store with both read and write capabilities.
+pub(crate) struct RepoHandler {
+    /// Actor DID
+    pub did: String,
+    /// Backend storage
+    pub storage: SqlRepoStorage,
+    /// BlobReader for handling blob operations
+    pub blob: BlobReader,
+    /// RecordHandler for handling record operations
+    pub record: RecordHandler,
+    /// BlobTransactor for handling blob writes
+    pub blob_transactor: BlobTransactor,
+    /// RecordHandler for handling record writes
+    pub record_transactor: RecordHandler,
+    /// Signing keypair
+    pub signing_key: Option<Arc<SigningKey>>,
+    /// Background queue for async operations
+    pub background_queue: BackgroundQueue,
+}
+
+impl RepoHandler {
+    /// Create a new repository handler with read/write capabilities.
+    pub(crate) fn new(
+        db: ActorDb,
+        blobstore: BlobStorePlaceholder,
+        did: String,
+        signing_key: Arc<SigningKey>,
+        background_queue: BackgroundQueue,
+    ) -> Self {
+        // Create readers
+        let blob = BlobReader::new(db.clone(), blobstore.clone());
+        let record = RecordHandler::new(db.clone(), did.clone());
+
+        // Create storage backend with current timestamp
+        let now = chrono::Utc::now().to_rfc3339();
+        let storage = SqlRepoStorage::new(did.clone(), db.clone(), Some(now));
+
+        // Create transactors
+        let blob_transactor =
+            BlobTransactor::new(db.clone(), blobstore.clone(), background_queue.clone());
+        let record_transactor = RecordHandler::new(db.clone(), blobstore);
+
+        Self {
+            did,
+            storage,
+            blob,
+            record,
+            blob_transactor,
+            record_transactor,
+            signing_key: Some(signing_key),
+            background_queue,
+        }
+    }
+
+    /// Get event data for synchronization.
+    pub(crate) async fn get_sync_event_data(&self) -> Result<SyncEventData> {
+        let root = self.storage.get_root_detailed().await?;
+        let blocks = self
+            .storage
+            .get_blocks(vec![CidV10::from_str(&root.cid.to_string()).unwrap()])
+            .await?;
+
+        Ok(SyncEventData {
+            cid: root.cid,
+            rev: root.rev,
+            blocks: blocks.blocks,
+        })
+    }
+
+    /// Try to load repository
+    pub(crate) async fn maybe_load_repo(&self) -> Result<Option<Repo>> {
+        match self.storage.get_root().await {
+            Some(cid) => {
+                let repo = Repo::load(&self.storage, cid).await?;
+                Ok(Some(repo))
+            }
+            None => Ok(None),
+        }
+    }
+
+    /// Create a new repository with prepared writes
+    pub(crate) async fn create_repo(
+        &self,
+        writes: Vec<PreparedWrite>,
+    ) -> Result<CommitDataWithOps> {
+        let signing_key = self
+            .signing_key
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("No signing key available for write operations"))?;
+
+        // Convert writes to operations
+        let ops = writes
+            .iter()
+            .map(|w| write_to_op(w))
+            .collect::<Result<Vec<_>>>()?;
+
+        // Format the initial commit
+        let commit = Repo::format_init_commit(&self.storage, &self.did, signing_key, ops).await?;
+
+        // Apply the commit, index the writes, and process blobs in parallel
+        let results = futures::future::join3(
+            self.storage.apply_commit(commit.clone(), Some(true)),
+            self.index_writes(&writes, &commit.rev),
+            self.blob_transactor
+                .process_write_blobs(&commit.rev, writes.clone()),
+        )
+        .await;
+
+        // Check for errors
+        results.0.context("Failed to apply commit")?;
+        results.1.context("Failed to index writes")?;
+        results.2.context("Failed to process blobs")?;
+
+        // Create commit operations
+        let ops = writes
+            .iter()
+            .filter_map(|w| match w {
+                PreparedWrite::Create(c) | PreparedWrite::Update(c) => {
+                    let uri = AtUri::from_str(&c.uri).ok()?;
+                    Some(CommitOp {
+                        action: CommitAction::Create,
+                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
+                        cid: Some(c.cid),
+                        prev: None,
+                    })
+                }
+                PreparedWrite::Delete(_) => None,
+            })
+            .collect();
+
+        Ok(CommitDataWithOps {
+            commit_data: commit,
+            ops,
+            prev_data: None,
+        })
+    }
+
+    /// Process writes to the repository
+    pub(crate) async fn process_writes(
+        &self,
+        writes: Vec<PreparedWrite>,
+        swap_commit_cid: Option<Cid>,
+    ) -> Result<CommitDataWithOps> {
+        // Check write limit
+        if writes.len() > 200 {
+            return Err(anyhow::anyhow!("Too many writes. Max: 200"));
+        }
+
+        // Format the commit
+        let commit = self.format_commit(writes.clone(), swap_commit_cid).await?;
+
+        // Check commit size limit (2MB)
+        if commit.commit_data.relevant_blocks.byte_size()? > 2_000_000 {
+            return Err(anyhow::anyhow!("Too many writes. Max event size: 2MB"));
+        }
+
+        // Apply the commit, index the writes, and process blobs in parallel
+        let results = futures::future::join3(
+            self.storage.apply_commit(commit.commit_data.clone(), None),
+            self.index_writes(&writes, &commit.commit_data.rev),
+            self.blob_transactor
+                .process_write_blobs(&commit.commit_data.rev, writes),
+        )
+        .await;
+
+        // Check for errors
+        results.0.context("Failed to apply commit")?;
+        results.1.context("Failed to index writes")?;
+        results.2.context("Failed to process blobs")?;
+
+        Ok(commit)
+    }
+
+    /// Format a commit for writes
+    pub(crate) async fn format_commit(
+        &self,
+        writes: Vec<PreparedWrite>,
+        swap_commit_cid: Option<Cid>,
+    ) -> Result<CommitDataWithOps> {
+        // Ensure we have a signing key
+        let signing_key = self
+            .signing_key
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("No signing key available for write operations"))?;
+
+        // Get current root
+        let curr_root = self
+            .storage
+            .get_root_detailed()
+            .await
+            .context("Failed to get repository root")?;
+
+        // Check commit swap if requested
+        if let Some(swap) = swap_commit_cid {
+            if curr_root.cid != swap {
+                return Err(anyhow::anyhow!(
+                    "Bad commit swap: current={}, expected={}",
+                    curr_root.cid,
+                    swap
+                ));
+            }
+        }
+
+        // Cache the current revision for better performance
+        self.storage.cache_rev(&curr_root.rev).await?;
+
+        // Prepare collections for tracking changes
+        let mut new_record_cids = Vec::new();
+        let mut del_and_update_uris = Vec::new();
+        let mut commit_ops = Vec::new();
+
+        // Process each write to build operations and gather info
+        for write in &writes {
+            match write {
+                PreparedWrite::Create(w) => {
+                    new_record_cids.push(w.cid);
+                    let uri = AtUri::from_str(&w.uri)?;
+                    commit_ops.push(CommitOp {
+                        action: CommitAction::Create,
+                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
+                        cid: Some(w.cid),
+                        prev: None,
+                    });
+
+                    // Validate swap_cid conditions
+                    if w.swap_cid.is_some() && w.swap_cid != Some(None) {
+                        return Err(anyhow::anyhow!(
+                            "Bad record swap: there should be no current record for a create"
+                        ));
+                    }
+                }
+                PreparedWrite::Update(w) => {
+                    new_record_cids.push(w.cid);
+                    let uri = AtUri::from_str(&w.uri)?;
+                    del_and_update_uris.push(uri.clone());
+
+                    // Get the current record if it exists
+                    let record = self.record.get_record(&uri, None, true).await?;
+                    let curr_record = record.as_ref().map(|r| Cid::from_str(&r.cid).unwrap());
+
+                    commit_ops.push(CommitOp {
+                        action: CommitAction::Update,
+                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
+                        cid: Some(w.cid),
+                        prev: curr_record,
+                    });
+
+                    // Validate swap_cid conditions
+                    if w.swap_cid.is_some() {
+                        if w.swap_cid == Some(None) {
+                            return Err(anyhow::anyhow!(
+                                "Bad record swap: there should be a current record for an update"
+                            ));
+                        }
+
+                        if let Some(Some(swap)) = w.swap_cid {
+                            if curr_record.is_some() && curr_record != Some(swap) {
+                                return Err(anyhow::anyhow!(
+                                    "Bad record swap: current={:?}, expected={}",
+                                    curr_record,
+                                    swap
+                                ));
+                            }
+                        }
+                    }
+                }
+                PreparedWrite::Delete(w) => {
+                    let uri = AtUri::from_str(&w.uri)?;
+                    del_and_update_uris.push(uri.clone());
+
+                    // Get the current record if it exists
+                    let record = self.record.get_record(&uri, None, true).await?;
+                    let curr_record = record.as_ref().map(|r| Cid::from_str(&r.cid).unwrap());
+
+                    commit_ops.push(CommitOp {
+                        action: CommitAction::Delete,
+                        path: format_data_key(uri.get_collection(), uri.get_rkey()),
+                        cid: None,
+                        prev: curr_record,
+                    });
+
+                    // Validate swap_cid conditions
+                    if w.swap_cid.is_some() {
+                        if w.swap_cid == Some(None) {
+                            return Err(anyhow::anyhow!(
+                                "Bad record swap: there should be a current record for a delete"
+                            ));
+                        }
+
+                        if let Some(Some(swap)) = w.swap_cid {
+                            if curr_record.is_some() && curr_record != Some(swap) {
+                                return Err(anyhow::anyhow!(
+                                    "Bad record swap: current={:?}, expected={}",
+                                    curr_record,
+                                    swap
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Load repository
+        let repo = Repo::load(&self.storage, curr_root.cid).await?;
+        let prev_data = repo.commit.data.clone();
+
+        // Convert writes to repo operations
+        let write_ops = writes
+            .iter()
+            .map(|w| write_to_op(w))
+            .collect::<Result<Vec<_>>>()?;
+
+        // Format the commit with the repository
+        let mut commit = repo.format_commit(write_ops, signing_key).await?;
+
+        // Find blocks that would be deleted but are referenced by another record
+        let dupe_record_cids = self
+            .get_duplicate_record_cids(&commit.removed_cids.to_list(), &del_and_update_uris)
+            .await?;
+
+        // Remove duplicates from removed_cids
+        for cid in &dupe_record_cids {
+            commit.removed_cids.delete(*cid);
+        }
+
+        // Find blocks that are relevant to ops but not included in diff
+        let new_record_blocks = commit.relevant_blocks.get_many(&new_record_cids)?;
+        if !new_record_blocks.missing.is_empty() {
+            let missing_blocks = self.storage.get_blocks(&new_record_blocks.missing).await?;
+            commit.relevant_blocks.add_map(missing_blocks.blocks)?;
+        }
+
+        Ok(CommitDataWithOps {
+            commit_data: commit,
+            ops: commit_ops,
+            prev_data: Some(prev_data),
+        })
+    }
+
+    /// Index writes to the database
+    pub(crate) async fn index_writes(&self, writes: &[PreparedWrite], rev: &str) -> Result<()> {
+        let timestamp = chrono::Utc::now().to_rfc3339();
+
+        for write in writes {
+            match write {
+                PreparedWrite::Create(w) => {
+                    let uri = AtUri::from_str(&w.uri)?;
+                    self.record_transactor
+                        .index_record(
+                            uri,
+                            w.cid,
+                            Some(&w.record),
+                            WriteOpAction::Create,
+                            rev,
+                            Some(timestamp.clone()),
+                        )
+                        .await?;
+                }
+                PreparedWrite::Update(w) => {
+                    let uri = AtUri::from_str(&w.uri)?;
+                    self.record_transactor
+                        .index_record(
+                            uri,
+                            w.cid,
+                            Some(&w.record),
+                            WriteOpAction::Update,
+                            rev,
+                            Some(timestamp.clone()),
+                        )
+                        .await?;
+                }
+                PreparedWrite::Delete(w) => {
+                    let uri = AtUri::from_str(&w.uri)?;
+                    self.record_transactor.delete_record(&uri).await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Get record CIDs that are duplicated elsewhere in the repository
+    pub(crate) async fn get_duplicate_record_cids(
+        &self,
+        cids: &[Cid],
+        touched_uris: &[AtUri],
+    ) -> Result<Vec<Cid>> {
+        if touched_uris.is_empty() || cids.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Convert URIs to strings for the query
+        let uri_strings: Vec<String> = touched_uris.iter().map(|u| u.to_string()).collect();
+
+        // Convert CIDs to strings for the query
+        let cid_strings: Vec<String> = cids.iter().map(|c| c.to_string()).collect();
+
+        let did = self.did.clone();
+
+        // Query for records with these CIDs that aren't in the touched URIs
+        let duplicate_cids = self
+            .storage
+            .db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::record::dsl::*;
+
+                record
+                    .filter(did.eq(&did))
+                    .filter(cid.eq_any(&cid_strings))
+                    .filter(uri.ne_all(&uri_strings))
+                    .select(cid)
+                    .load::<String>(conn)
+            })
+            .await?;
+
+        // Convert strings back to CIDs
+        let cids = duplicate_cids
+            .into_iter()
+            .filter_map(|c| Cid::from_str(&c).ok())
+            .collect();
+
+        Ok(cids)
+    }
+}

src/actor_store/repo/mod.rs

···
-//! Repository operations for actor store.
-
-mod reader;
-mod sql_repo_reader;
-mod sql_repo_transactor;
-mod transactor;
-
-pub(crate) use reader::RepoReader;
-pub(crate) use sql_repo_reader::SqlRepoReader;
-pub(crate) use sql_repo_transactor::SqlRepoTransactor;
-pub(crate) use transactor::RepoTransactor;

src/actor_store/repo/reader.rs

···
-//! Repository reader for the actor store.
-
-use anyhow::Result;
-use atrium_repo::Cid;
-use rsky_repo::storage::readable_blockstore::ReadableBlockstore as _;
-
-use super::sql_repo_reader::SqlRepoReader;
-use crate::{
-    actor_store::{ActorDb, blob::BlobReader, record::RecordReader},
-    repo::{block_map::BlockMap, types::BlobStore},
-};
-
-/// Reader for repository data in the actor store.
-pub(crate) struct RepoReader {
-    blob: BlobReader,
-    record: RecordReader,
-    /// The SQL repository reader.
-    storage: SqlRepoReader,
-}
-
-impl RepoReader {
-    /// Create a new repository reader.
-    pub(crate) fn new(db: ActorDb, blobstore: BlobStore) -> Self {
-        let blob = BlobReader::new(db.clone(), blobstore);
-        let record = RecordReader::new(db.clone());
-        let storage = SqlRepoReader::new(db);
-
-        Self {
-            blob,
-            record,
-            storage,
-        }
-    }
-
-    /// Get event data for synchronization.
-    pub(crate) async fn get_sync_event_data(&self) -> Result<SyncEventData> {
-        let root = self.storage.get_root_detailed().await?;
-        let blocks = self.storage.get_blocks(vec![root.cid]).await?;
-
-        Ok(SyncEventData {
-            cid: root.cid,
-            rev: root.rev,
-            blocks: blocks.blocks,
-        })
-    }
-}
-
-/// Data for sync events.
-pub(crate) struct SyncEventData {
-    /// The CID of the repository root.
-    pub cid: Cid,
-    /// The revision of the repository.
-    pub rev: String,
-    /// The blocks in the repository.
-    pub blocks: BlockMap,
-}

src/actor_store/repo/sql_repo_reader.rs

···
-//! SQL-based repository reader.
-
-use anyhow::{Context as _, Result};
-use atrium_repo::{
-    Cid,
-    blockstore::{AsyncBlockStoreRead, Error as BlockstoreError},
-};
-use rsky_repo::storage::readable_blockstore::ReadableBlockstore;
-use sqlx::Row;
-use std::str::FromStr;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-
-use crate::{
-    actor_store::ActorDb,
-    repo::block_map::{BlockMap, BlocksAndMissing, CidSet},
-};
-
-/// SQL-based repository reader.
-pub(crate) struct SqlRepoReader {
-    /// Cache for blocks to avoid redundant database queries.
-    pub cache: Arc<RwLock<BlockMap>>,
-    /// Database connection.
-    pub db: ActorDb,
-}
-
-/// Repository root with CID and revision.
-pub(crate) struct RootInfo {
-    /// CID of the repository root.
-    pub cid: Cid,
-    /// Revision of the repository.
-    pub rev: String,
-}
-
-impl SqlRepoReader {
-    /// Create a new SQL repository reader.
-    pub(crate) fn new(db: ActorDb) -> Self {
-        Self {
-            cache: Arc::new(RwLock::new(BlockMap::new())),
-            db,
-        }
-    }
-    // async getRoot(): Promise<CID> {
-    // async getCarStream(since?: string) {
-    // async *iterateCarBlocks(since?: string): AsyncIterable<CarBlock> {
-    // async getBlockRange(since?: string, cursor?: RevCursor) {
-    // async countBlocks(): Promise<number> {
-    // async destroy(): Promise<void> {
-
-    /// Get the detailed root information.
-    pub(crate) async fn get_root_detailed(&self) -> Result<RootInfo> {
-        let row = sqlx::query!(r#"SELECT cid, rev FROM repo_root"#)
-            .fetch_one(&self.db.pool)
-            .await
-            .context("failed to fetch repo root")?;
-
-        Ok(RootInfo {
-            cid: Cid::from_str(&row.cid)?,
-            rev: row.rev,
-        })
-    }
-}
-
-impl ReadableBlockstore for SqlRepoReader {
-    async fn get_bytes(&self, cid: &Cid) -> Result<Option<Vec<u8>>> {
-        // First check the cache
-        {
-            let cache_guard = self.cache.read().await;
-            if let Some(cached) = cache_guard.get(*cid) {
-                return Ok(Some(cached.clone()));
-            }
-        }
-
-        // Not in cache, query from database
-        let cid_str = cid.to_string();
-
-        let content = sqlx::query!(r#"SELECT content FROM repo_block WHERE cid = ?"#, cid_str,)
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to fetch block content")?
-            .map(|row| row.content);
-
-        // If found, update the cache
-        if let Some(bytes) = &content {
-            let mut cache_guard = self.cache.write().await;
-            cache_guard.set(*cid, bytes.clone());
-        }
-
-        Ok(content)
-    }
-
-    async fn has(&self, cid: &Cid) -> Result<bool> {
-        self.get_bytes(cid).await.map(|bytes| bytes.is_some())
-    }
-
-    /// Get blocks from the database.
-    async fn get_blocks(&self, cids: Vec<Cid>) -> Result<BlocksAndMissing> {
-        let cached = { self.cache.write().await.get_many(cids)? }; // TODO: use read lock?
-
-        if cached.missing.is_empty() {
-            return Ok(cached);
-        }
-
-        let missing = cached.missing.clone();
-        let missing_strings: Vec<String> = missing.iter().map(|c| c.to_string()).collect();
-
-        let mut blocks = BlockMap::new();
-        let mut missing_set = CidSet::new(None);
-        for cid in &missing {
-            missing_set.add(*cid);
-        }
-
-        // Process in chunks to avoid too many parameters
-        for chunk in missing_strings.chunks(500) {
-            let placeholders = std::iter::repeat("?")
-                .take(chunk.len())
-                .collect::<Vec<_>>()
-                .join(",");
-
-            let query = format!(
-                "SELECT cid, content FROM repo_block
-                     WHERE cid IN ({})
-                     ORDER BY cid",
-                placeholders
-            );
-
-            let mut query_builder = sqlx::query(&query);
-            for cid in chunk {
-                query_builder = query_builder.bind(cid);
-            }
-
-            let rows = query_builder
-                .map(|row: sqlx::sqlite::SqliteRow| {
-                    (
-                        row.get::<String, _>("cid"),
-                        row.get::<Vec<u8>, _>("content"),
-                    )
-                })
-                .fetch_all(&self.db.pool)
-                .await?;
-
-            for (cid_str, content) in rows {
-                let cid = Cid::from_str(&cid_str)?;
-                blocks.set(cid, content);
-                missing_set.delete(cid);
-            }
-        }
-
-        // Update cache
-        self.cache.write().await.add_map(blocks.clone())?; // TODO: unnecessary clone?
-
-        // Add cached blocks
-        blocks.add_map(cached.blocks)?;
-
-        Ok(BlocksAndMissing {
-            blocks,
-            missing: missing_set.to_list(),
-        })
-    }
-}
-
-impl AsyncBlockStoreRead for SqlRepoReader {
-    async fn read_block(&mut self, cid: Cid) -> Result<Vec<u8>, BlockstoreError> {
-        let bytes = self
-            .get_bytes(&cid)
-            .await
-            .unwrap()
-            .ok_or(BlockstoreError::CidNotFound)?;
-        Ok(bytes)
-    }
-
-    fn read_block_into(
-        &mut self,
-        cid: Cid,
-        contents: &mut Vec<u8>,
-    ) -> impl Future<Output = Result<(), BlockstoreError>> + Send {
-        async move {
-            let bytes = self
-                .get_bytes(&cid)
-                .await
-                .unwrap()
-                .ok_or(BlockstoreError::CidNotFound)?;
-            contents.clear();
-            contents.extend_from_slice(&bytes);
-            Ok(())
-        }
-    }
-}

src/actor_store/repo/sql_repo_transactor.rs

···
-//! SQL-based repository transactor.
-
-use std::str::FromStr;
-
-use anyhow::Result;
-use atrium_repo::{
-    Cid,
-    blockstore::{AsyncBlockStoreWrite, Error as BlockstoreError},
-};
-use sha2::Digest;
-
-use crate::{
-    actor_store::ActorDb,
-    repo::{block_map::BlockMap, types::CommitData},
-};
-
-use super::sql_repo_reader::{RootInfo, SqlRepoReader};
-
-/// SQL-based repository transactor that extends the reader.
-pub(crate) struct SqlRepoTransactor {
-    /// The inner reader.
-    pub reader: SqlRepoReader,
-    /// Cache for blocks.
-    pub cache: BlockMap,
-    /// Current timestamp.
-    pub now: Option<String>,
-}
-
-impl SqlRepoTransactor {
-    /// Create a new SQL repository transactor.
-    pub(crate) fn new(db: ActorDb, did: String, now: Option<String>) -> Self {
-        Self {
-            reader: SqlRepoReader::new(db, did),
-            cache: BlockMap::new(),
-            now,
-        }
-    }
-
-    /// Get the root CID and revision of the repository.
-    pub(crate) async fn get_root_detailed(&self) -> Result<RootInfo> {
-        let row = sqlx::query!(
-            r#"
-                SELECT cid, rev
-                FROM repo_root
-                WHERE did = ?
-                LIMIT 1
-            "#,
-            self.reader.did
-        )
-        .fetch_one(&self.reader.db.pool)
-        .await?;
-
-        let cid = Cid::from_str(&row.cid)?;
-        Ok(RootInfo { cid, rev: row.rev })
-    }
-
-    /// Proactively cache all blocks from a particular commit.
-    pub(crate) async fn cache_rev(&mut self, rev: &str) -> Result<()> {
-        let rows = sqlx::query!(
-            r#"
-                SELECT cid, content
-                FROM repo_block
-                WHERE repoRev = ?
-                LIMIT 15
-                "#,
-            rev
-        )
-        .fetch_all(&self.reader.db.pool)
-        .await?;
-
-        for row in rows {
-            let cid = Cid::from_str(&row.cid)?;
-            self.cache.set(cid, row.content.clone());
-        }
-        Ok(())
-    }
-
-    /// Apply a commit to the repository.
-    pub(crate) async fn apply_commit(&self, commit: &CommitData, is_create: bool) -> Result<()> {
-        let is_create = is_create || false;
-        let removed_cids_list = commit.removed_cids.to_list();
-
-        // Run these operations in parallel for better performance
-        tokio::try_join!(
-            self.update_root(commit.cid, &commit.rev, is_create),
-            self.put_many(&commit.new_blocks, &commit.rev),
-            self.delete_many(&removed_cids_list)
-        )?;
-
-        Ok(())
-    }
-
-    /// Update the repository root.
-    pub(crate) async fn update_root(&self, cid: Cid, rev: &str, is_create: bool) -> Result<()> {
-        let cid_str = cid.to_string();
-        let did = self.reader.did.clone();
-        let now = self.now.clone();
-
-        if is_create {
-            sqlx::query!(
-                r#"
-                    INSERT INTO repo_root (did, cid, rev, indexedAt)
-                    VALUES (?, ?, ?, ?)
-                    "#,
-                did,
-                cid_str,
-                rev,
-                now
-            )
-            .execute(&self.reader.db.pool)
-            .await?;
-        } else {
-            sqlx::query!(
-                r#"
-                    UPDATE repo_root
-                    SET cid = ?, rev = ?, indexedAt = ?
-                    WHERE did = ?
-                    "#,
-                cid_str,
-                rev,
-                now,
-                did
-            )
-            .execute(&self.reader.db.pool)
-            .await?;
-        }
-
-        Ok(())
-    }
-
-    /// Put a block into the repository.
-    pub(crate) async fn put_block(&self, cid: Cid, block: &[u8], rev: &str) -> Result<()> {
-        let cid_str = cid.to_string();
-
-        let block_len = block.len() as i64;
-        sqlx::query!(
-            r#"
-                INSERT INTO repo_block (cid, repoRev, size, content)
-                VALUES (?, ?, ?, ?)
-                ON CONFLICT DO NOTHING
-                "#,
-            cid_str,
-            rev,
-            block_len,
-            block
-        )
-        .execute(&self.reader.db.pool)
-        .await?;
-
-        Ok(())
-    }
-
-    /// Put many blocks into the repository.
-    pub(crate) async fn put_many(&self, blocks: &BlockMap, rev: &str) -> Result<()> {
-        if blocks.size() == 0 {
-            return Ok(());
-        }
-
-        let did = self.reader.did.clone();
-        let mut batch = Vec::new();
-
-        blocks.to_owned().map.into_iter().for_each(|(cid, bytes)| {
-            batch.push((cid, did.clone(), rev, bytes.0.len() as i64, bytes.0));
-        });
-
-        // Process in chunks to avoid too many parameters
-        for chunk in batch.chunks(50) {
-            let placeholders = chunk
-                .iter()
-                .map(|_| "(?, ?, ?, ?, ?)")
-                .collect::<Vec<_>>()
-                .join(", ");
-
-            let query = format!(
-                "INSERT INTO repo_block (cid, did, repoRev, size, content) VALUES {} ON CONFLICT DO NOTHING",
-                placeholders
-            );
-
-            let mut query_builder = sqlx::query(&query);
-            for (cid, did, rev, size, content) in chunk {
-                query_builder = query_builder
-                    .bind(cid)
-                    .bind(did)
-                    .bind(rev)
-                    .bind(size)
-                    .bind(content);
-            }
-
-            query_builder.execute(&self.reader.db.pool).await?;
-        }
-
-        Ok(())
-    }
-
-    /// Delete many blocks from the repository.
-    pub(crate) async fn delete_many(&self, cids: &[Cid]) -> Result<()> {
-        if cids.is_empty() {
-            return Ok(());
-        }
-
-        let did = self.reader.did.clone();
-        let cid_strings: Vec<String> = cids.iter().map(|c| c.to_string()).collect();
-
-        // Process in chunks to avoid too many parameters
-        for chunk in cid_strings.chunks(500) {
-            let placeholders = std::iter::repeat("?")
-                .take(chunk.len())
-                .collect::<Vec<_>>()
-                .join(",");
-
-            let query = format!(
-                "DELETE FROM repo_block WHERE did = ? AND cid IN ({})",
-                placeholders
-            );
-
-            let mut query_builder = sqlx::query(&query);
-            query_builder = query_builder.bind(&did);
-            for cid in chunk {
-                query_builder = query_builder.bind(cid);
-            }
-
-            query_builder.execute(&self.reader.db.pool).await?;
-        }
-
-        Ok(())
-    }
-}
-
-#[async_trait::async_trait]
-impl AsyncBlockStoreWrite for SqlRepoTransactor {
-    fn write_block(
-        &mut self,
-        codec: u64,
-        hash: u64,
-        contents: &[u8],
-    ) -> impl Future<Output = Result<Cid, BlockstoreError>> + Send {
-        let contents = contents.to_vec();
-        let rev = self.now.clone();
-
-        async move {
-            let digest = match hash {
-                atrium_repo::blockstore::SHA2_256 => sha2::Sha256::digest(&contents),
-                _ => return Err(BlockstoreError::UnsupportedHash(hash)),
-            };
-
-            let multihash = atrium_repo::Multihash::wrap(hash, &digest)
-                .map_err(|_| BlockstoreError::UnsupportedHash(hash))?;
-
-            let cid = Cid::new_v1(codec, multihash);
-            let cid_str = cid.to_string();
-            let contents_len = contents.len() as i64;
-
-            sqlx::query!(
-                r#"
-                    INSERT INTO repo_block (cid, repoRev, size, content)
-                    VALUES (?, ?, ?, ?)
-                    ON CONFLICT DO NOTHING
-                    "#,
-                cid_str,
-                rev,
-                contents_len,
-                contents
-            )
-            .execute(&self.reader.db.pool)
-            .await
-            .map_err(|e| BlockstoreError::Other(Box::new(e)))?;
-
-            self.cache.set(cid, contents);
-            Ok(cid)
-        }
-    }
-}

src/actor_store/repo/transactor.rs

···
-//! Repository transactor for the actor store.
-
-use anyhow::{Context as _, Result};
-use atrium_repo::Cid;
-use rsky_syntax::aturi::AtUri;
-use std::sync::Arc;
-
-use crate::{
-    SigningKey,
-    actor_store::{
-        ActorDb,
-        blob::{BackgroundQueue, BlobTransactor},
-        record::RecordTransactor,
-        repo::{reader::RepoReader, sql_repo_transactor::SqlRepoTransactor},
-        resources::ActorStoreResources,
-    },
-    repo::{
-        Repo,
-        block_map::BlockMap,
-        types::{
-            BlobStore, CommitAction, CommitDataWithOps, CommitOp, PreparedCreate, PreparedWrite,
-            WriteOpAction, format_data_key,
-        },
-    },
-};
-
-/// Repository transactor for the actor store.
-pub(crate) struct RepoTransactor {
-    /// The inner reader.
-    pub reader: RepoReader,
-    /// BlobTransactor for handling blobs.
-    pub blob: BlobTransactor,
-    /// RecordTransactor for handling records.
-    pub record: RecordTransactor,
-    /// SQL repository transactor.
-    pub storage: SqlRepoTransactor,
-}
-
-impl RepoTransactor {
-    /// Create a new repository transactor.
-    pub(crate) fn new(
-        db: ActorDb,
-        blobstore: BlobStore,
-        did: String,
-        signing_key: Arc<SigningKey>,
-        background_queue: BackgroundQueue,
-        now: Option<String>,
-    ) -> Self {
-        // Create a new RepoReader
-        let reader = RepoReader::new(db.clone(), blobstore.clone(), did.clone(), signing_key);
-
-        // Create a new BlobTransactor
-        let blob = BlobTransactor::new(db.clone(), blobstore.clone(), background_queue);
-
-        // Create a new RecordTransactor
-        let record = RecordTransactor::new(db.clone(), blobstore);
-
-        // Create a new SQL repository transactor
-        let storage = SqlRepoTransactor::new(db, did.clone(), now);
-
-        Self {
-            reader,
-            blob,
-            record,
-            storage,
-        }
-    }
-
-    /// Try to load a repository.
-    pub(crate) async fn maybe_load_repo(&self) -> Result<Option<Repo>> {
-        // Query the repository root
-        let root = sqlx::query!("SELECT cid FROM repo_root LIMIT 1")
-            .fetch_optional(&self.db.pool)
-            .await
-            .context("failed to query repo root")?;
-
-        // If found, load the repo
-        if let Some(row) = root {
-            let cid = Cid::try_from(&row.cid)?;
-            let repo = Repo::load(&self.storage, cid).await?;
-            Ok(Some(repo))
-        } else {
-            Ok(None)
-        }
-    }
-
-    /// Create a new repository with the given writes.
-    pub(crate) async fn create_repo(
-        &self,
-        writes: Vec<PreparedCreate>,
-    ) -> Result<CommitDataWithOps> {
-        // Assert we're in a transaction
-        self.db.assert_transaction()?;
-
-        // Convert writes to operations
-        let ops = writes.iter().map(|w| create_write_to_op(w)).collect();
-
-        // Format the initial commit
-        let commit =
-            Repo::format_init_commit(&self.storage, &self.did, &self.signing_key, ops).await?;
-
-        // Apply the commit, index the writes, and process blobs in parallel
-        let results = futures::future::join3(
-            self.storage.apply_commit(&commit, true),
-            self.index_writes(&writes, &commit.rev),
-            self.blob.process_write_blobs(&commit.rev, &writes),
-        )
-        .await;
-
-        // Check for errors in each parallel task
-        results.0?;
-        results.1?;
-        results.2?;
-
-        // Create commit operations
-        let ops = writes
-            .iter()
-            .map(|w| CommitOp {
-                action: CommitAction::Create,
-                path: format_data_key(&w.uri.collection, &w.uri.rkey),
-                cid: Some(w.cid),
-                prev: None,
-            })
-            .collect();
-
-        // Return the commit data with operations
-        Ok(CommitDataWithOps {
-            commit_data: commit,
-            ops,
-            prev_data: None,
-        })
-    }
-
-    /// Process writes to the repository.
-    pub(crate) async fn process_writes(
-        &self,
-        writes: Vec<PreparedWrite>,
-        swap_commit_cid: Option<Cid>,
-    ) -> Result<CommitDataWithOps> {
-        // Assert we're in a transaction
-        self.db.assert_transaction()?;
-
-        // Check write limit
-        if writes.len() > 200 {
-            return Err(anyhow::anyhow!("Too many writes. Max: 200"));
-        }
-
-        // Format the commit
-        let commit = self.format_commit(writes, swap_commit_cid).await?;
-
-        // Check commit size limit (2MB)
-        if commit.commit_data.relevant_blocks.byte_size()? > 2_000_000 {
-            return Err(anyhow::anyhow!("Too many writes. Max event size: 2MB"));
-        }
-
-        // Apply the commit, index the writes, and process blobs in parallel
-        let results = futures::future::join3(
-            self.storage.apply_commit(&commit.commit_data, false),
-            self.index_writes(writes, &commit.commit_data.rev),
-            self.blob
-                .process_write_blobs(&commit.commit_data.rev, writes),
-        )
-        .await;
-
-        // Check for errors in each parallel task
-        results.0?;
-        results.1?;
-        results.2?;
-
-        Ok(commit)
-    }
-
-    /// Format a commit for the given writes.
-    pub(crate) async fn format_commit(
-        &self,
-        writes: Vec<PreparedWrite>,
-        swap_commit: Option<Cid>,
-    ) -> Result<CommitDataWithOps> {
-        // Get the current root
-        let curr_root = self.storage.get_root_detailed().await?;
-        if curr_root.is_none() {
-            return Err(anyhow::anyhow!("No repo root found for {}", self.did));
-        }
-
-        let curr_root = curr_root.unwrap();
-
-        // Check commit swap if requested
-        if let Some(swap) = swap_commit {
-            if curr_root.cid != swap {
-                return Err(anyhow::anyhow!(
-                    "Bad commit swap: current={}, expected={}",
-                    curr_root.cid,
-                    swap
-                ));
-            }
-        }
-
-        // Cache the revision for better performance
-        self.storage.cache_rev(&curr_root.rev).await?;
-
-        // Prepare collections for tracking changes
-        let mut new_record_cids = Vec::new();
-        let mut del_and_update_uris = Vec::new();
-        let mut commit_ops = Vec::new();
-
-        // Process each write
-        for write in writes {
-            let action = &write.action;
-            let uri = &write.uri;
-            let swap_cid = write.swap_cid;
-
-            // Track new record CIDs
-            if *action != WriteOpAction::Delete {
-                new_record_cids.push(write.cid);
-            }
-
-            // Track deleted/updated URIs
-            if *action != WriteOpAction::Create {
-                del_and_update_uris.push(uri.clone());
-            }
-
-            // Get the current record if it exists
-            let record = self.record.get_record(uri, None, true).await?;
-            let curr_record = record.as_ref().map(|r| Cid::try_from(&r.cid).unwrap());
-
-            // Create commit operation
-            let mut op = CommitOp {
-                action: action.clone(),
-                path: format_data_key(&uri.collection, &uri.rkey),
-                cid: if *action == WriteOpAction::Delete {
-                    None
-                } else {
-                    Some(write.cid)
-                },
-                prev: curr_record,
-            };
-
-            commit_ops.push(op);
-
-            // Validate swap_cid conditions
-            if swap_cid.is_some() {
-                match action {
-                    WriteOpAction::Create if swap_cid != Some(None) => {
-                        return Err(anyhow::anyhow!(
-                            "Bad record swap: there should be no current record for a create"
-                        ));
-                    }
-                    WriteOpAction::Update if swap_cid == Some(None) => {
-                        return Err(anyhow::anyhow!(
-                            "Bad record swap: there should be a current record for an update"
-                        ));
-                    }
-                    WriteOpAction::Delete if swap_cid == Some(None) => {
-                        return Err(anyhow::anyhow!(
-                            "Bad record swap: there should be a current record for a delete"
-                        ));
-                    }
-                    _ => {}
-                }
-
-                if let Some(Some(swap)) = swap_cid {
-                    if curr_record.is_some() && curr_record != Some(swap) {
-                        return Err(anyhow::anyhow!(
-                            "Bad record swap: current={:?}, expected={}",
-                            curr_record,
-                            swap
-                        ));
-                    }
-                }
-            }
-        }
-
-        // Load the repo
-        let repo = Repo::load(&self.storage, curr_root.cid).await?;
-        let prev_data = repo.commit.data.clone();
-
-        // Convert writes to ops
-        let write_ops = writes.iter().map(|w| write_to_op(w)).collect();
-
-        // Format the commit
-        let commit = repo.format_commit(write_ops, &self.signing_key).await?;
-
-        // Find blocks that would be deleted but are referenced by another record
-        let dupe_record_cids = self
-            .get_duplicate_record_cids(&commit.removed_cids.to_list(), &del_and_update_uris)
-            .await?;
-
-        // Remove duplicates from removed_cids
-        for cid in &dupe_record_cids {
-            commit.removed_cids.delete(*cid);
-        }
-
-        // Find blocks that are relevant to ops but not included in diff
-        let new_record_blocks = commit.relevant_blocks.get_many(&new_record_cids)?;
-        if !new_record_blocks.missing.is_empty() {
-            let missing_blocks = self
-                .storage
-                .reader
-                .get_blocks(&new_record_blocks.missing)
-                .await?;
-            commit.relevant_blocks.add_map(missing_blocks.blocks)?;
-        }
-
-        Ok(CommitDataWithOps {
-            commit_data: commit,
-            ops: commit_ops,
-            prev_data: Some(prev_data),
-        })
-    }
-
-    /// Index writes to the database.
-    pub(crate) async fn index_writes(&self, writes: &[PreparedWrite], rev: &str) -> Result<()> {
-        // Assert we're in a transaction
-        self.db.assert_transaction()?;
-
-        // Process each write in parallel
-        let futures = writes.iter().map(|write| async move {
-            match write.action {
-                WriteOpAction::Create | WriteOpAction::Update => {
-                    self.record
-                        .index_record(
-                            &write.uri,
-                            &write.cid,
-                            &write.record,
-                            &write.action,
-                            rev,
-                            &self.now,
-                        )
-                        .await
-                }
-                WriteOpAction::Delete => self.record.delete_record(&write.uri).await,
-            }
-        });
-
-        // Wait for all indexing operations to complete
-        futures::future::try_join_all(futures).await?;
-
-        Ok(())
-    }
-
-    /// Get record CIDs that are duplicated elsewhere in the repository.
-    pub(crate) async fn get_duplicate_record_cids(
-        &self,
-        cids: &[Cid],
-        touched_uris: &[AtUri],
-    ) -> Result<Vec<Cid>> {
-        if touched_uris.is_empty() || cids.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        // Convert CIDs and URIs to strings
-        let cid_strs: Vec<String> = cids.iter().map(|c| c.to_string()).collect();
-        let uri_strs: Vec<String> = touched_uris.iter().map(|u| u.to_string()).collect();
-
-        // Query the database for duplicates
-        let rows = sqlx::query!(
-            "SELECT cid FROM record WHERE cid IN (?) AND uri NOT IN (?)",
-            cid_strs.join(","),
-            uri_strs.join(",")
-        )
-        .fetch_all(&self.db.pool)
-        .await
-        .context("failed to query duplicate record CIDs")?;
-
-        // Convert to CIDs
-        let result = rows
-            .into_iter()
-            .map(|row| Cid::try_from(&row.cid))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok(result)
-    }
-}
-
-// Helper functions
-
-/// Convert a PreparedCreate to an operation.
-fn create_write_to_op(write: &PreparedCreate) -> WriteOp {
-    WriteOp {
-        action: WriteOpAction::Create,
-        collection: write.uri.collection.clone(),
-        rkey: write.uri.rkey.clone(),
-        record: write.record.clone(),
-    }
-}
-
-/// Convert a PreparedWrite to an operation.
-fn write_to_op(write: &PreparedWrite) -> WriteOp {
-    match write.action {
-        WriteOpAction::Create => WriteOp {
-            action: WriteOpAction::Create,
-            collection: write.uri.collection.clone(),
-            rkey: write.uri.rkey.clone(),
-            record: write.record.clone(),
-        },
-        WriteOpAction::Update => WriteOp {
-            action: WriteOpAction::Update,
-            collection: write.uri.collection.clone(),
-            rkey: write.uri.rkey.clone(),
-            record: write.record.clone(),
-        },
-        WriteOpAction::Delete => WriteOp {
-            action: WriteOpAction::Delete,
-            collection: write.uri.collection.clone(),
-            rkey: write.uri.rkey.clone(),
-            record: None,
-        },
-    }
-}

src/actor_store/sql_repo.rs

···
+use anyhow::{Context as _, Result};
+use atrium_repo::Cid;
+use atrium_repo::blockstore::{
+    AsyncBlockStoreRead, AsyncBlockStoreWrite, Error as BlockstoreError,
+};
+use diesel::prelude::*;
+use diesel::r2d2::{self, ConnectionManager};
+use diesel::sqlite::SqliteConnection;
+use futures::{StreamExt, TryStreamExt, stream};
+use rsky_pds::models::{RepoBlock, RepoRoot};
+use rsky_repo::block_map::{BlockMap, BlocksAndMissing};
+use rsky_repo::car::blocks_to_car_file;
+use rsky_repo::cid_set::CidSet;
+use rsky_repo::storage::CidAndRev;
+use rsky_repo::storage::RepoRootError::RepoRootNotFoundError;
+use rsky_repo::storage::readable_blockstore::ReadableBlockstore;
+use rsky_repo::storage::types::RepoStorage;
+use rsky_repo::types::CommitData;
+use sha2::{Digest, Sha256};
+use std::future::Future;
+use std::pin::Pin;
+use std::str::FromStr;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+use crate::actor_store::db::ActorDb;
+
+#[derive(Clone, Debug)]
+pub struct SqlRepoStorage {
+    /// In-memory cache for blocks
+    pub cache: Arc<RwLock<BlockMap>>,
+    /// Database connection
+    pub db: ActorDb,
+    /// DID of the actor
+    pub did: String,
+    /// Current timestamp
+    pub now: String,
+}
+
+impl SqlRepoStorage {
+    /// Create a new SQL repository storage
+    pub fn new(did: String, db: ActorDb, now: Option<String>) -> Self {
+        let now = now.unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
+
+        Self {
+            cache: Arc::new(RwLock::new(BlockMap::new())),
+            db,
+            did,
+            now,
+        }
+    }
+
+    /// Get the CAR stream for the repository
+    pub async fn get_car_stream(&self, since: Option<String>) -> Result<Vec<u8>> {
+        match self.get_root().await {
+            None => Err(anyhow::Error::new(RepoRootNotFoundError)),
+            Some(root) => {
+                let mut car = BlockMap::new();
+                let mut cursor: Option<CidAndRev> = None;
+
+                loop {
+                    let blocks = self.get_block_range(&since, &cursor).await?;
+                    if blocks.is_empty() {
+                        break;
+                    }
+
+                    // Add blocks to car
+                    for block in &blocks {
+                        car.set(Cid::from_str(&block.cid)?, block.content.clone());
+                    }
+
+                    if let Some(last_block) = blocks.last() {
+                        cursor = Some(CidAndRev {
+                            cid: Cid::from_str(&last_block.cid)?,
+                            rev: last_block.repoRev.clone(),
+                        });
+                    } else {
+                        break;
+                    }
+                }
+
+                blocks_to_car_file(Some(&root), car).await
+            }
+        }
+    }
+
+    /// Get a range of blocks from the database
+    pub async fn get_block_range(
+        &self,
+        since: &Option<String>,
+        cursor: &Option<CidAndRev>,
+    ) -> Result<Vec<RepoBlock>> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                let mut query = repo_block.filter(did.eq(&did)).limit(500).into_boxed();
+
+                if let Some(c) = cursor {
+                    query = query.filter(
+                        repoRev
+                            .lt(&c.rev)
+                            .or(repoRev.eq(&c.rev).and(cid.lt(&c.cid.to_string()))),
+                    );
+                }
+
+                if let Some(s) = since {
+                    query = query.filter(repoRev.gt(s));
+                }
+
+                query
+                    .order((repoRev.desc(), cid.desc()))
+                    .load::<RepoBlock>(conn)
+            })
+            .await
+    }
+
+    /// Count total blocks for this repository
+    pub async fn count_blocks(&self) -> Result<i64> {
+        let did = self.did.clone();
+
+        self.db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                repo_block.filter(did.eq(&did)).count().get_result(conn)
+            })
+            .await
+    }
+
+    /// Proactively cache blocks from a specific revision
+    pub async fn cache_rev(&mut self, rev: &str) -> Result<()> {
+        let did = self.did.clone();
+        let rev_string = rev.to_string();
+
+        let blocks = self
+            .db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                repo_block
+                    .filter(did.eq(&did))
+                    .filter(repoRev.eq(&rev_string))
+                    .select((cid, content))
+                    .limit(15)
+                    .load::<(String, Vec<u8>)>(conn)
+            })
+            .await?;
+
+        let mut cache_guard = self.cache.write().await;
+        for (cid_str, content) in blocks {
+            let cid = Cid::from_str(&cid_str)?;
+            cache_guard.set(cid, content);
+        }
+
+        Ok(())
+    }
+
+    /// Delete multiple blocks by their CIDs
+    pub async fn delete_many(&self, cids: Vec<Cid>) -> Result<()> {
+        if cids.is_empty() {
+            return Ok(());
+        }
+
+        let did = self.did.clone();
+        let cid_strings: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();
+
+        // Process in chunks to avoid too many parameters
+        for chunk in cid_strings.chunks(100) {
+            let chunk_vec = chunk.to_vec();
+            let did_clone = did.clone();
+
+            self.db
+                .run(move |conn| {
+                    use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                    diesel::delete(repo_block)
+                        .filter(did.eq(&did_clone))
+                        .filter(cid.eq_any(&chunk_vec))
+                        .execute(conn)
+                })
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    /// Get the detailed root information
+    pub async fn get_root_detailed(&self) -> Result<CidAndRev> {
+        let did = self.did.clone();
+
+        let root = self
+            .db
+            .run(move |conn| {
+                use rsky_pds::schema::pds::repo_root::dsl::*;
+
+                repo_root
+                    .filter(did.eq(&did))
+                    .first::<RepoRoot>(conn)
+                    .optional()
+            })
+            .await?;
+
+        match root {
+            Some(r) => Ok(CidAndRev {
+                cid: Cid::from_str(&r.cid)?,
+                rev: r.rev,
+            }),
+            None => Err(anyhow::Error::new(RepoRootNotFoundError)),
+        }
+    }
+}
+
+impl ReadableBlockstore for SqlRepoStorage {
+    fn get_bytes<'a>(
+        &'a self,
+        cid: &'a Cid,
+    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + Sync + 'a>> {
+        let did = self.did.clone();
+        let cid = cid.clone();
+
+        Box::pin(async move {
+            // Check cache first
+            {
+                let cache_guard = self.cache.read().await;
+                if let Some(cached) = cache_guard.get(cid) {
+                    return Ok(Some(cached.clone()));
+                }
+            }
+
+            // Not in cache, query database
+            let cid_str = cid.to_string();
+            let result = self
+                .db
+                .run(move |conn| {
+                    use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                    repo_block
+                        .filter(did.eq(&did))
+                        .filter(cid.eq(&cid_str))
+                        .select(content)
+                        .first::<Vec<u8>>(conn)
+                        .optional()
+                })
+                .await?;
+
+            // Update cache if found
+            if let Some(content) = &result {
+                let mut cache_guard = self.cache.write().await;
+                cache_guard.set(cid, content.clone());
+            }
+
+            Ok(result)
+        })
+    }
+
+    fn has<'a>(
+        &'a self,
+        cid: Cid,
+    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + Sync + 'a>> {
+        Box::pin(async move {
+            let bytes = self.get_bytes(&cid).await?;
+            Ok(bytes.is_some())
+        })
+    }
+
+    fn get_blocks<'a>(
+        &'a self,
+        cids: Vec<Cid>,
+    ) -> Pin<Box<dyn Future<Output = Result<BlocksAndMissing>> + Send + Sync + 'a>> {
+        Box::pin(async move {
+            // Check cache first
+            let cached = {
+                let mut cache_guard = self.cache.write().await;
+                cache_guard.get_many(cids.clone())?
+            };
+
+            if cached.missing.is_empty() {
+                return Ok(cached);
+            }
+
+            // Prepare data structures for missing blocks
+            let missing = CidSet::new(Some(cached.missing.clone()));
+            let missing_strings: Vec<String> =
+                cached.missing.iter().map(|c| c.to_string()).collect();
+            let did = self.did.clone();
+
+            // Create block map for results
+            let mut blocks = BlockMap::new();
+            let mut missing_set = CidSet::new(Some(cached.missing.clone()));
+
+            // Query database in chunks
+            for chunk in missing_strings.chunks(100) {
+                let chunk_vec = chunk.to_vec();
+                let did_clone = did.clone();
+
+                let rows = self
+                    .db
+                    .run(move |conn| {
+                        use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                        repo_block
+                            .filter(did.eq(&did_clone))
+                            .filter(cid.eq_any(&chunk_vec))
+                            .select((cid, content))
+                            .load::<(String, Vec<u8>)>(conn)
+                    })
+                    .await?;
+
+                // Process results
+                for (cid_str, content) in rows {
+                    let block_cid = Cid::from_str(&cid_str)?;
+                    blocks.set(block_cid, content.clone());
+                    missing_set.delete(block_cid);
+
+                    // Update cache
+                    let mut cache_guard = self.cache.write().await;
+                    cache_guard.set(block_cid, content);
+                }
+            }
+
+            // Combine with cached blocks
+            blocks.add_map(cached.blocks)?;
+
+            Ok(BlocksAndMissing {
+                blocks,
+                missing: missing_set.to_list(),
+            })
+        })
+    }
+}
+
+impl RepoStorage for SqlRepoStorage {
+    fn get_root<'a>(&'a self) -> Pin<Box<dyn Future<Output = Option<Cid>> + Send + Sync + 'a>> {
+        Box::pin(async move {
+            match self.get_root_detailed().await {
+                Ok(root) => Some(root.cid),
+                Err(_) => None,
+            }
+        })
+    }
+
+    fn put_block<'a>(
+        &'a self,
+        cid: Cid,
+        bytes: Vec<u8>,
+        rev: String,
+    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
+        let did = self.did.clone();
+        let bytes_clone = bytes.clone();
+
+        Box::pin(async move {
+            let cid_str = cid.to_string();
+            let size = bytes.len() as i32;
+
+            self.db
+                .run(move |conn| {
+                    use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                    diesel::insert_into(repo_block)
+                        .values((
+                            did.eq(&did),
+                            cid.eq(&cid_str),
+                            repoRev.eq(&rev),
+                            size.eq(size),
+                            content.eq(&bytes),
+                        ))
+                        .on_conflict_do_nothing()
+                        .execute(conn)
+                })
+                .await?;
+
+            // Update cache
+            let mut cache_guard = self.cache.write().await;
+            cache_guard.set(cid, bytes_clone);
+
+            Ok(())
+        })
+    }
+
+    fn put_many<'a>(
+        &'a self,
+        to_put: BlockMap,
+        rev: String,
+    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
+        let did = self.did.clone();
+
+        Box::pin(async move {
+            if to_put.size() == 0 {
+                return Ok(());
+            }
+
+            // Prepare blocks for insertion
+            let blocks: Vec<(String, String, String, i32, Vec<u8>)> = to_put
+                .map
+                .iter()
+                .map(|(cid, bytes)| {
+                    (
+                        did.clone(),
+                        cid.to_string(),
+                        rev.clone(),
+                        bytes.0.len() as i32,
+                        bytes.0.clone(),
+                    )
+                })
+                .collect();
+
+            // Process in chunks
+            for chunk in blocks.chunks(50) {
+                let chunk_vec = chunk.to_vec();
+
+                self.db
+                    .run(move |conn| {
+                        use rsky_pds::schema::pds::repo_block::dsl::*;
+
+                        let values: Vec<_> = chunk_vec
+                            .iter()
+                            .map(|(did_val, cid_val, rev_val, size_val, content_val)| {
+                                (
+                                    did.eq(did_val),
+                                    cid.eq(cid_val),
+                                    repoRev.eq(rev_val),
+                                    size.eq(*size_val),
+                                    content.eq(content_val),
+                                )
+                            })
+                            .collect();
+
+                        diesel::insert_into(repo_block)
+                            .values(&values)
+                            .on_conflict_do_nothing()
+                            .execute(conn)
+                    })
+                    .await?;
+            }
+
+            // Update cache with all blocks
+            {
+                let mut cache_guard = self.cache.write().await;
+                for (cid, bytes) in &to_put.map {
+                    cache_guard.set(*cid, bytes.0.clone());
+                }
+            }
+
+            Ok(())
+        })
+    }
+
+    fn update_root<'a>(
+        &'a self,
+        cid: Cid,
+        rev: String,
+        is_create: Option<bool>,
+    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
+        let did = self.did.clone();
+        let now = self.now.clone();
+        let is_create = is_create.unwrap_or(false);
+
+        Box::pin(async move {
+            let cid_str = cid.to_string();
+
+            if is_create {
+                // Insert new root
+                self.db
+                    .run(move |conn| {
+                        use rsky_pds::schema::pds::repo_root::dsl::*;
+
+                        diesel::insert_into(repo_root)
+                            .values((
+                                did.eq(&did),
+                                cid.eq(&cid_str),
+                                rev.eq(&rev),
+                                indexedAt.eq(&now),
+                            ))
+                            .execute(conn)
+                    })
+                    .await?;
+            } else {
+                // Update existing root
+                self.db
+                    .run(move |conn| {
+                        use rsky_pds::schema::pds::repo_root::dsl::*;
+
+                        diesel::update(repo_root)
+                            .filter(did.eq(&did))
+                            .set((cid.eq(&cid_str), rev.eq(&rev), indexedAt.eq(&now)))
+                            .execute(conn)
+                    })
+                    .await?;
+            }
+
+            Ok(())
+        })
+    }
+
+    fn apply_commit<'a>(
+        &'a self,
+        commit: CommitData,
+        is_create: Option<bool>,
+    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'a>> {
+        Box::pin(async move {
+            // Apply commit in three steps
+            self.update_root(commit.cid, commit.rev.clone(), is_create)
+                .await?;
+            self.put_many(commit.new_blocks, commit.rev).await?;
+            self.delete_many(commit.removed_cids.to_list()).await?;
+
+            Ok(())
+        })
+    }
+}
+
+#[async_trait::async_trait]
+impl AsyncBlockStoreRead for SqlRepoStorage {
+    async fn read_block(&mut self, cid: Cid) -> Result<Vec<u8>, BlockstoreError> {
+        let bytes = self
+            .get_bytes(&cid)
+            .await
+            .map_err(|e| BlockstoreError::Other(Box::new(e)))?
+            .ok_or(BlockstoreError::CidNotFound)?;
+
+        Ok(bytes)
+    }
+
+    fn read_block_into(
+        &mut self,
+        cid: Cid,
+        contents: &mut Vec<u8>,
+    ) -> impl Future<Output = Result<(), BlockstoreError>> + Send {
+        async move {
+            let bytes = self.read_block(cid).await?;
+            contents.clear();
+            contents.extend_from_slice(&bytes);
+            Ok(())
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl AsyncBlockStoreWrite for SqlRepoStorage {
+    fn write_block(
+        &mut self,
+        codec: u64,
+        hash: u64,
+        contents: &[u8],
+    ) -> impl Future<Output = Result<Cid, BlockstoreError>> + Send {
+        let contents = contents.to_vec();
+        let rev = self.now.clone();
+
+        async move {
+            // Calculate digest based on hash algorithm
+            let digest = match hash {
+                atrium_repo::blockstore::SHA2_256 => sha2::Sha256::digest(&contents),
+                _ => return Err(BlockstoreError::UnsupportedHash(hash)),
+            };
+
+            // Create multihash
+            let multihash = atrium_repo::Multihash::wrap(hash, &digest)
+                .map_err(|_| BlockstoreError::UnsupportedHash(hash))?;
+
+            // Create CID
+            let cid = Cid::new_v1(codec, multihash);
+
+            // Store the block
+            self.put_block(cid, contents, rev)
+                .await
+                .map_err(|e| BlockstoreError::Other(Box::new(e)))?;
+
+            Ok(cid)
+        }
+    }
+}

src/db/cast.rs

···
-//! Type-safe casting utilities.
-
-use serde::{Serialize, de::DeserializeOwned};
-use std::fmt;
-
-/// Represents an ISO 8601 date string (e.g., "2023-01-01T12:00:00Z").
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DateISO(String);
-
-impl DateISO {
-    /// Converts a `chrono::DateTime<Utc>` to a `DateISO`.
-    pub fn from_date(date: chrono::DateTime<chrono::Utc>) -> Self {
-        Self(date.to_rfc3339())
-    }
-
-    /// Converts a `DateISO` back to a `chrono::DateTime<Utc>`.
-    pub fn to_date(&self) -> Result<chrono::DateTime<chrono::Utc>, chrono::ParseError> {
-        self.0.parse::<chrono::DateTime<chrono::Utc>>()
-    }
-}
-
-impl fmt::Display for DateISO {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-/// Represents a JSON-encoded string.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct JsonEncoded<T: Serialize>(String, std::marker::PhantomData<T>);
-
-impl<T: Serialize> JsonEncoded<T> {
-    /// Encodes a value into a JSON string.
-    pub fn to_json(value: &T) -> Result<Self, serde_json::Error> {
-        let json = serde_json::to_string(value)?;
-        Ok(Self(json, std::marker::PhantomData))
-    }
-
-    /// Decodes a JSON string back into a value.
-    pub fn from_json(json_str: &str) -> Result<T, serde_json::Error>
-    where
-        T: DeserializeOwned,
-    {
-        serde_json::from_str(json_str)
-    }
-
-    /// Returns the underlying JSON string.
-    pub fn as_str(&self) -> &str {
-        &self.0
-    }
-}
-
-impl<T: Serialize> fmt::Display for JsonEncoded<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use chrono::Utc;
-    use serde::{Deserialize, Serialize};
-
-    #[test]
-    fn test_date_iso() {
-        let now = Utc::now();
-        let date_iso = DateISO::from_date(now);
-        let parsed_date = date_iso.to_date().unwrap();
-        assert_eq!(now.to_rfc3339(), parsed_date.to_rfc3339());
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct TestStruct {
-        name: String,
-        value: i32,
-    }
-
-    #[test]
-    fn test_json_encoded() {
-        let test_value = TestStruct {
-            name: "example".to_string(),
-            value: 42,
-        };
-
-        // Encode to JSON
-        let encoded = JsonEncoded::to_json(&test_value).unwrap();
-        assert_eq!(encoded.as_str(), r#"{"name":"example","value":42}"#);
-
-        // Decode from JSON
-        let decoded: TestStruct = JsonEncoded::from_json(encoded.as_str()).unwrap();
-        assert_eq!(decoded, test_value);
-    }
-}

src/db/db.rs

···
-//! Database connection and transaction management.
-
-use sqlx::{
-    Sqlite, Transaction,
-    sqlite::{SqliteConnectOptions, SqlitePool, SqliteQueryResult, SqliteTransactionManager},
-};
-use std::collections::VecDeque;
-use std::str::FromStr;
-use std::sync::{Arc, Mutex};
-use tokio::sync::Mutex as AsyncMutex;
-
-use crate::db::util::retry_sqlite;
-
-/// Default pragmas for SQLite.
-const DEFAULT_PRAGMAS: &[(&str, &str)] = &[
-    // Add default pragmas here if needed, e.g., ("foreign_keys", "ON")
-];
-
-/// Database struct for managing SQLite connections and transactions.
-#[derive(Clone)]
-pub(crate) struct Database {
-    /// SQLite connection pool.
-    pub(crate) pool: SqlitePool,
-    /// Flag indicating if the database is destroyed.
-    pub(crate) destroyed: Arc<Mutex<bool>>,
-    /// Queue of commit hooks.
-    pub(crate) commit_hooks: Arc<AsyncMutex<VecDeque<Box<dyn FnOnce() + Send>>>>,
-}
-
-impl Database {
-    /// Creates a new database instance with the given location and optional pragmas.
-    pub async fn new(location: &str, pragmas: Option<&[(&str, &str)]>) -> sqlx::Result<Self> {
-        let mut options = SqliteConnectOptions::from_str(location)?.create_if_missing(true);
-
-        // Apply default and user-provided pragmas.
-        for &(key, value) in DEFAULT_PRAGMAS.iter().chain(pragmas.unwrap_or(&[])) {
-            options = options.pragma(key.to_string(), value.to_string());
-        }
-
-        let pool = SqlitePool::connect_with(options).await?;
-        Ok(Self {
-            pool,
-            destroyed: Arc::new(Mutex::new(false)),
-            commit_hooks: Arc::new(AsyncMutex::new(VecDeque::new())),
-        })
-    }
-
-    /// Ensures the database is using Write-Ahead Logging (WAL) mode.
-    pub async fn ensure_wal(&self) -> sqlx::Result<()> {
-        let mut conn = self.pool.acquire().await?;
-        sqlx::query("PRAGMA journal_mode = WAL")
-            .execute(&mut *conn)
-            .await?;
-        Ok(())
-    }
-
-    /// Executes a transaction without retry logic.
-    pub async fn transaction_no_retry<F, T>(&self, func: F) -> sqlx::Result<T>
-    where
-        F: FnOnce(&mut Transaction<'_, Sqlite>) -> sqlx::Result<T>,
-    {
-        let mut tx = self.pool.begin().await?;
-        let result = func(&mut tx)?;
-        tx.commit().await?;
-        self.run_commit_hooks().await;
-        Ok(result)
-    }
-
-    /// Executes a transaction with retry logic.
-    pub async fn transaction<F, T>(&self, func: F) -> sqlx::Result<T>
-    where
-        F: FnOnce(&mut Transaction<'_, Sqlite>) -> sqlx::Result<T> + Copy,
-    {
-        retry_sqlite(|| self.transaction_no_retry(func)).await
-    }
-
-    /// Executes a query with retry logic.
-    pub async fn execute_with_retry<F, T>(&self, query: F) -> sqlx::Result<T>
-    where
-        F: Fn() -> std::pin::Pin<Box<dyn futures::Future<Output = sqlx::Result<T>> + Send>> + Copy,
-    {
-        retry_sqlite(|| query()).await
-    }
-
-    /// Adds a commit hook to be executed after a successful transaction.
-    pub async fn on_commit<F>(&self, hook: F)
-    where
-        F: FnOnce() + Send + 'static,
-    {
-        let mut hooks = self.commit_hooks.lock().await;
-        hooks.push_back(Box::new(hook));
-    }
-
-    /// Closes the database connection pool.
-    pub async fn close(&self) -> sqlx::Result<()> {
-        let mut destroyed = self.destroyed.lock().unwrap();
-        if *destroyed {
-            return Ok(());
-        }
-        *destroyed = true;
-        drop(self.pool.clone()); // Drop the pool to close connections.
-        Ok(())
-    }
-
-    /// Runs all commit hooks in the queue.
-    async fn run_commit_hooks(&self) {
-        let mut hooks = self.commit_hooks.lock().await;
-        while let Some(hook) = hooks.pop_front() {
-            hook();
-        }
-    }
-}

src/db/migrator.rs

···
-//! Database migration management.
-
-use sqlx::{SqlitePool, migrate::Migrator};
-use std::path::Path;
-use thiserror::Error;
-
-/// Error type for migration-related issues.
-#[derive(Debug, Error)]
-pub enum MigrationError {
-    #[error("Migration failed: {0}")]
-    MigrationFailed(String),
-    #[error("Unknown failure occurred while migrating")]
-    UnknownFailure,
-}
-
-/// Migrator struct for managing database migrations.
-pub struct DatabaseMigrator {
-    /// SQLx migrator instance.
-    migrator: Migrator,
-    /// SQLite connection pool.
-    db: SqlitePool,
-}
-
-impl DatabaseMigrator {
-    /// Creates a new `DatabaseMigrator` instance.
-    ///
-    /// # Arguments
-    /// - `migrations_path`: Path to the directory containing migration files.
-    /// - `db`: SQLite connection pool.
-    pub async fn new(migrations_path: &Path, db: SqlitePool) -> Self {
-        let migrator = Migrator::new(migrations_path)
-            .await
-            .expect("Failed to initialize migrator");
-        Self { migrator, db }
-    }
-
-    /// Migrates the database to a specific migration or throws an error.
-    ///
-    /// # Arguments
-    /// - `migration`: The target migration name.
-    ///
-    /// # Unimplemented
-    /// This currently runs all migrations instead of a specific one.
-    pub async fn migrate_to_or_throw(&self, _migration: &str) -> Result<(), MigrationError> {
-        // TODO: Implement migration to a specific version
-        // For now, we will just run all migrations
-        let result = self.migrator.run(&self.db).await;
-
-        match result {
-            Ok(_) => Ok(()),
-            Err(err) => Err(MigrationError::MigrationFailed(err.to_string())),
-        }
-    }
-
-    /// Migrates the database to the latest migration or throws an error.
-    pub async fn migrate_to_latest_or_throw(&self) -> Result<(), MigrationError> {
-        let result = self.migrator.run(&self.db).await;
-
-        match result {
-            Ok(_) => Ok(()),
-            Err(err) => Err(MigrationError::MigrationFailed(err.to_string())),
-        }
-    }
-}

src/db/mod.rs

···
-mod cast;
-mod db;
-mod migrator;
-mod pagination;
-mod tables;
-mod util;
+use anyhow::{Context, Result};
+use diesel::connection::SimpleConnection;
+use diesel::prelude::*;
+use diesel::r2d2::{self, ConnectionManager, Pool, PooledConnection};
+use diesel::sqlite::{Sqlite, SqliteConnection};
+use diesel_migrations::{EmbeddedMigrations, MigrationHarness, embed_migrations};
+use std::path::Path;
+use std::sync::Arc;
+use std::time::Duration;
+
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("migrations");
+pub type SqlitePool = Pool<ConnectionManager<SqliteConnection>>;
+pub type SqlitePooledConnection = PooledConnection<ConnectionManager<SqliteConnection>>;
+
+/// Database type for all queries
+pub type DbType = Sqlite;
 
-pub(crate) use db::Database;
+/// Database connection wrapper
+#[derive(Clone, Debug)]
+pub struct DatabaseConnection {
+    pub pool: SqlitePool,
+}
+
+impl DatabaseConnection {
+    /// Create a new database connection with optional pragmas
+    pub async fn new(path: &str, pragmas: Option<&[(&str, &str)]>) -> Result<Self> {
+        // Create the database directory if it doesn't exist
+        if let Some(parent) = Path::new(path).parent() {
+            if !parent.exists() {
+                tokio::fs::create_dir_all(parent)
+                    .await
+                    .context(format!("Failed to create directory: {:?}", parent))?;
+            }
+        }
+
+        // Sanitize the path for connection string
+        let database_url = format!("sqlite:{}", path);
+
+        // Create a connection manager
+        let manager = ConnectionManager::<SqliteConnection>::new(database_url);
+
+        // Create the connection pool with SQLite-specific configurations
+        let pool = r2d2::Pool::builder()
+            .max_size(10)
+            .connection_timeout(Duration::from_secs(30))
+            .test_on_check_out(true)
+            .build(manager)
+            .context("Failed to create connection pool")?;
+
+        // Initialize the database with pragmas
+        if let Some(pragmas) = pragmas {
+            let conn = &mut pool.get().context("Failed to get connection from pool")?;
+
+            // Apply all pragmas
+            for (pragma, value) in pragmas {
+                let sql = format!("PRAGMA {} = {}", pragma, value);
+                conn.batch_execute(&sql)
+                    .context(format!("Failed to set pragma {}", pragma))?;
+            }
+        }
+
+        let db = DatabaseConnection { pool };
+        Ok(db)
+    }
+
+    /// Run migrations on the database
+    pub fn run_migrations(&self) -> Result<()> {
+        let mut conn = self
+            .pool
+            .get()
+            .context("Failed to get connection for migrations")?;
+        conn.run_pending_migrations(MIGRATIONS)
+            .context("Failed to run migrations")?;
+        Ok(())
+    }
+
+    /// Ensure WAL mode is enabled
+    pub async fn ensure_wal(&self) -> Result<()> {
+        let conn = &mut self.pool.get().context("Failed to get connection")?;
+        conn.batch_execute("PRAGMA journal_mode = WAL;")?;
+        conn.batch_execute("PRAGMA synchronous = NORMAL;")?;
+        conn.batch_execute("PRAGMA foreign_keys = ON;")?;
+        Ok(())
+    }
+
+    /// Execute a database operation with retries for busy errors
+    pub async fn run<F, T>(&self, operation: F) -> Result<T>
+    where
+        F: FnOnce(&mut SqliteConnection) -> QueryResult<T> + Send,
+        T: Send + 'static,
+    {
+        let mut retries = 0;
+        let max_retries = 5;
+        let mut last_error = None;
+
+        while retries < max_retries {
+            let mut conn = self.pool.get().context("Failed to get connection")?;
+            match operation(&mut conn) {
+                Ok(result) => return Ok(result),
+                Err(diesel::result::Error::DatabaseError(
+                    diesel::result::DatabaseErrorKind::DatabaseIsLocked,
+                    _,
+                )) => {
+                    retries += 1;
+                    let backoff_ms = 10 * (1 << retries); // Exponential backoff
+                    last_error = Some(diesel::result::Error::DatabaseError(
+                        diesel::result::DatabaseErrorKind::DatabaseIsLocked,
+                        Box::new("Database is locked".to_string()),
+                    ));
+                    tokio::time::sleep(std::time::Duration::from_millis(backoff_ms)).await;
+                }
+                Err(e) => return Err(e.into()),
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "Max retries exceeded: {}",
+            last_error.unwrap_or(diesel::result::Error::RollbackTransaction(Box::new(
+                "Unknown error"
+            )))
+        ))
+    }
+
+    /// Check if currently in a transaction
+    pub fn assert_transaction(&self) -> Result<()> {
+        // SQLite doesn't have a straightforward way to check transaction state
+        // We'll implement a simplified version that just returns Ok for now
+        Ok(())
+    }
+
+    /// Run a transaction with retry logic for busy database errors
+    pub async fn transaction<T, F>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce(&mut SqliteConnection) -> Result<T> + Send,
+        T: Send + 'static,
+    {
+        self.run(|conn| {
+            conn.transaction(|tx| {
+                f(tx).map_err(|e| diesel::result::Error::RollbackTransaction(Box::new(e)))
+            })
+        })
+        .await
+    }
+
+    /// Run a transaction with no retry logic
+    pub async fn transaction_no_retry<T, F>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce(&mut SqliteConnection) -> std::result::Result<T, diesel::result::Error> + Send,
+        T: Send + 'static,
+    {
+        let conn = &mut self
+            .pool
+            .get()
+            .context("Failed to get connection for transaction")?;
+
+        conn.transaction(f)
+            .map_err(|e| anyhow::anyhow!("Transaction error: {:?}", e))
+    }
+}
+
+/// Create a connection pool for SQLite
+pub async fn create_sqlite_pool(database_url: &str) -> Result<SqlitePool> {
+    let manager = ConnectionManager::<SqliteConnection>::new(database_url);
+    let pool = Pool::builder()
+        .max_size(10)
+        .connection_timeout(Duration::from_secs(30))
+        .test_on_check_out(true)
+        .build(manager)
+        .context("Failed to create connection pool")?;
+
+    // Apply recommended SQLite settings
+    let conn = &mut pool.get()?;
+    conn.batch_execute(
+        "PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA foreign_keys = ON;",
+    )?;
+
+    Ok(pool)
+}

src/db/pagination.rs

···
-use std::fmt::Debug;
-
-/// Represents a cursor with primary and secondary parts.
-#[derive(Debug, Clone)]
-pub struct Cursor {
-    pub primary: String,
-    pub secondary: String,
-}
-
-/// Represents a labeled result with primary and secondary parts.
-#[derive(Debug, Clone)]
-pub struct LabeledResult {
-    pub primary: String,
-    pub secondary: String,
-}
-
-/// Trait defining the interface for a keyset-paginated cursor.
-pub trait GenericKeyset<R, LR: Debug> {
-    fn label_result(&self, result: R) -> LR;
-    fn labeled_result_to_cursor(&self, labeled: LR) -> Cursor;
-    fn cursor_to_labeled_result(&self, cursor: Cursor) -> LR;
-
-    fn pack_from_result(&self, results: Vec<R>) -> Option<String> {
-        todo!()
-        // results
-        //     .last()
-        //     .map(|result| self.pack(Some(self.label_result(result.clone()))))
-    }
-
-    fn pack(&self, labeled: Option<LR>) -> Option<String> {
-        labeled.map(|l| self.pack_cursor(self.labeled_result_to_cursor(l)))
-    }
-
-    fn unpack(&self, cursor_str: Option<String>) -> Option<LR> {
-        cursor_str
-            .and_then(|cursor| self.unpack_cursor(cursor))
-            .map(|c| self.cursor_to_labeled_result(c))
-    }
-
-    fn pack_cursor(&self, cursor: Cursor) -> String {
-        format!("{}::{}", cursor.primary, cursor.secondary)
-    }
-
-    fn unpack_cursor(&self, cursor_str: String) -> Option<Cursor> {
-        let parts: Vec<&str> = cursor_str.split("::").collect();
-        if parts.len() == 2 {
-            Some(Cursor {
-                primary: parts[0].to_string(),
-                secondary: parts[1].to_string(),
-            })
-        } else {
-            None
-        }
-    }
-}
-
-/// A concrete implementation of `GenericKeyset` for time and CID-based pagination.
-pub struct TimeCidKeyset;
-
-impl TimeCidKeyset {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl GenericKeyset<CreatedAtCidResult, LabeledResult> for TimeCidKeyset {
-    fn label_result(&self, result: CreatedAtCidResult) -> LabeledResult {
-        LabeledResult {
-            primary: result.created_at,
-            secondary: result.cid,
-        }
-    }
-
-    fn labeled_result_to_cursor(&self, labeled: LabeledResult) -> Cursor {
-        Cursor {
-            primary: labeled.primary,
-            secondary: labeled.secondary,
-        }
-    }
-
-    fn cursor_to_labeled_result(&self, cursor: Cursor) -> LabeledResult {
-        LabeledResult {
-            primary: cursor.primary,
-            secondary: cursor.secondary,
-        }
-    }
-}
-
-/// Represents a database result with created_at and cid fields.
-#[derive(Debug, Clone)]
-pub struct CreatedAtCidResult {
-    pub created_at: String,
-    pub cid: String,
-}
-
-/// Pagination options for queries.
-pub struct PaginationOptions<'a> {
-    pub limit: Option<usize>,
-    pub cursor: Option<String>,
-    pub direction: Option<&'a str>,
-    pub try_index: Option<bool>,
-}
-
-/// Applies pagination to a query.
-pub fn paginate<K>(query: &mut String, opts: PaginationOptions, keyset: &K) -> String
-where
-    K: GenericKeyset<CreatedAtCidResult, LabeledResult>,
-{
-    let PaginationOptions {
-        limit,
-        cursor,
-        direction,
-        try_index,
-    } = opts;
-
-    let direction = direction.unwrap_or("desc");
-    let labeled = cursor.and_then(|c| keyset.unpack(Some(c)));
-    let keyset_sql = labeled.map(|l| get_sql(&l, direction, try_index.unwrap_or(false)));
-
-    if let Some(sql) = keyset_sql {
-        query.push_str(&format!(" WHERE {}", sql));
-    }
-
-    if let Some(l) = limit {
-        query.push_str(&format!(" LIMIT {}", l));
-    }
-
-    query.push_str(&format!(
-        " ORDER BY primary {} secondary {}",
-        direction, direction
-    ));
-
-    query.clone()
-}
-
-/// Generates SQL conditions for pagination.
-fn get_sql(labeled: &LabeledResult, direction: &str, try_index: bool) -> String {
-    if try_index {
-        if direction == "asc" {
-            format!(
-                "(primary, secondary) > ('{}', '{}')",
-                labeled.primary, labeled.secondary
-            )
-        } else {
-            format!(
-                "(primary, secondary) < ('{}', '{}')",
-                labeled.primary, labeled.secondary
-            )
-        }
-    } else {
-        if direction == "asc" {
-            format!(
-                "(primary > '{}' OR (primary = '{}' AND secondary > '{}'))",
-                labeled.primary, labeled.primary, labeled.secondary
-            )
-        } else {
-            format!(
-                "(primary < '{}' OR (primary = '{}' AND secondary < '{}'))",
-                labeled.primary, labeled.primary, labeled.secondary
-            )
-        }
-    }
-}

src/db/tables/mod.rs

···
-mod moderation;

src/db/tables/moderation.rs

···
-//! Moderation-related database table definitions.
-
-use serde::{Deserialize, Serialize};
-use sqlx::FromRow;
-
-/// Table names for moderation-related entities.
-pub const ACTION_TABLE_NAME: &str = "moderation_action";
-pub const ACTION_SUBJECT_BLOB_TABLE_NAME: &str = "moderation_action_subject_blob";
-pub const REPORT_TABLE_NAME: &str = "moderation_report";
-pub const REPORT_RESOLUTION_TABLE_NAME: &str = "moderation_report_resolution";
-
-/// Represents a moderation action.
-#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub struct ModerationAction {
-    pub id: i32, // Auto-generated ID
-    pub action: String,
-    pub subject_type: String,
-    pub subject_did: String,
-    pub subject_uri: Option<String>,
-    pub subject_cid: Option<String>,
-    pub create_label_vals: Option<String>,
-    pub negate_label_vals: Option<String>,
-    pub comment: Option<String>,
-    pub created_at: String,
-    pub created_by: String,
-    pub duration_in_hours: Option<i32>,
-    pub expires_at: Option<String>,
-    pub meta: Option<std::collections::HashMap<String, serde_json::Value>>,
-}
-
-/// Represents a subject blob associated with a moderation action.
-#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub struct ModerationActionSubjectBlob {
-    pub action_id: i32,
-    pub cid: String,
-    pub record_uri: String,
-}
-
-/// Represents a moderation report.
-#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub struct ModerationReport {
-    pub id: i32, // Auto-generated ID
-    pub subject_type: String,
-    pub subject_did: String,
-    pub subject_uri: Option<String>,
-    pub subject_cid: Option<String>,
-    pub reason_type: String,
-    pub reason: Option<String>,
-    pub reported_by_did: String,
-    pub created_at: String,
-}
-
-/// Represents a resolution for a moderation report.
-#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
-#[sqlx(rename_all = "camelCase")]
-pub struct ModerationReportResolution {
-    pub report_id: i32,
-    pub action_id: i32,
-    pub created_at: String,
-    pub created_by: String,
-}
-
-/// Represents a partial database schema for moderation-related tables.
-pub struct PartialDB {
-    pub moderation_action: Vec<ModerationAction>,
-    pub moderation_action_subject_blob: Vec<ModerationActionSubjectBlob>,
-    pub moderation_report: Vec<ModerationReport>,
-    pub moderation_report_resolution: Vec<ModerationReportResolution>,
-}

src/db/util.rs

···
-//! This module contains utility functions and types for working with SQLite databases using SQLx.
-
-use sqlx::Error;
-use std::collections::HashSet;
-
-/// Returns a SQL clause to check if a record is not soft-deleted.
-pub fn not_soft_deleted_clause(alias: &str) -> String {
-    format!(r#"{}."takedownRef" IS NULL"#, alias)
-}
-
-/// Checks if a record is soft-deleted.
-pub fn is_soft_deleted(takedown_ref: Option<&str>) -> bool {
-    takedown_ref.is_some()
-}
-
-/// SQL clause to count all rows.
-pub const COUNT_ALL: &str = "COUNT(*)";
-
-/// SQL clause to count distinct rows based on a reference.
-pub fn count_distinct(ref_col: &str) -> String {
-    format!("COUNT(DISTINCT {})", ref_col)
-}
-
-/// Generates a SQL clause for the `excluded` column in an `ON CONFLICT` clause.
-pub fn excluded(col: &str) -> String {
-    format!("excluded.{}", col)
-}
-
-/// Generates a SQL clause for a large `WHERE IN` clause using a hash lookup.
-/// # DEPRECATED
-/// Use SQLx parameterized queries instead.
-#[deprecated = "Use SQLx parameterized queries instead"]
-pub fn values_list(vals: &[&str]) -> String {
-    let values = vals
-        .iter()
-        .map(|val| format!("('{}')", val))
-        .collect::<Vec<_>>()
-        .join(", ");
-    format!("(VALUES {})", values)
-}
-
-/// Retries an asynchronous SQLite operation with exponential backoff.
-pub async fn retry_sqlite<F, Fut, T>(operation: F) -> Result<T, sqlx::Error>
-where
-    F: Fn() -> Fut,
-    Fut: std::future::Future<Output = Result<T, sqlx::Error>>,
-{
-    let max_retries = 60;
-    let mut attempt = 0;
-
-    while attempt < max_retries {
-        match operation().await {
-            Ok(result) => return Ok(result),
-            Err(err) if is_retryable_sqlite_error(&err) => {
-                if let Some(wait_ms) = get_wait_ms_sqlite(attempt, 5000) {
-                    tokio::time::sleep(std::time::Duration::from_millis(wait_ms)).await;
-                    attempt += 1;
-                } else {
-                    return Err(err);
-                }
-            }
-            Err(err) => return Err(err),
-        }
-    }
-
-    Err(sqlx::Error::Protocol("Max retries exceeded".into()))
-}
-
-/// Checks if an error is retryable for SQLite.
-fn is_retryable_sqlite_error(err: &Error) -> bool {
-    matches!(
-        err,
-        Error::Database(db_err) if {
-            let code = db_err.code().unwrap_or_default().to_string();
-            RETRY_ERRORS.contains(code.as_str())
-        }
-    )
-}
-
-/// Calculates the wait time for retries based on SQLite's backoff strategy.
-fn get_wait_ms_sqlite(attempt: usize, timeout: u64) -> Option<u64> {
-    const DELAYS: [u64; 12] = [1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100];
-    const TOTALS: [u64; 12] = [0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228];
-
-    if attempt >= DELAYS.len() {
-        let delay = DELAYS.last().unwrap();
-        let prior = TOTALS.last().unwrap() + delay * (attempt as u64 - (DELAYS.len() as u64 - 1));
-        if prior + delay > timeout {
-            return None;
-        }
-        Some(*delay)
-    } else {
-        let delay = DELAYS[attempt];
-        let prior = TOTALS[attempt];
-        if prior + delay > timeout {
-            None
-        } else {
-            Some(delay)
-        }
-    }
-}
-
-/// Checks if an error is a unique constraint violation.
-pub fn is_err_unique_violation(err: &Error) -> bool {
-    matches!(
-        err,
-        Error::Database(db_err) if {
-            let code = db_err.code().unwrap_or_default();
-            code == "23505" || code == "SQLITE_CONSTRAINT_UNIQUE"
-        }
-    )
-}
-
-lazy_static::lazy_static! {
-    /// Set of retryable SQLite error codes.
-    static ref RETRY_ERRORS: HashSet<&'static str> = {
-        let mut set = HashSet::new();
-        set.insert("SQLITE_BUSY");
-        set.insert("SQLITE_BUSY_SNAPSHOT");
-        set.insert("SQLITE_BUSY_RECOVERY");
-        set.insert("SQLITE_BUSY_TIMEOUT");
-        set
-    };
-}