vineyard

public

Star0

Fork 0

Watch0

1 commit 1 branch 0 tags 0 releases64.9 KiB

Commit `25d14e49ab68`

tarball

atagen <boss@atagen.co>2026-09-24 11:13 UTC

18 files changed+5952-0

init

Added file: .gitignore+6

@@ -0,0 +1,6 @@

1+target/

2+/result

3+*.sqlite

4+*.sqlite-shm

5+*.sqlite-wal

6+*.sqlite.lock

Added file: Cargo.lock+2047 additions@@ -0,0 +1,2047 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bech32"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbd3e1070bbdf4cd88a75264e18e8a26f7cb5c6949eadf0ceb85fb159cf08f8"
+
+[[package]]
+name = "bip39"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90dbd31c98227229239363921e60fcf5e558e43ec69094d46fc4996f08d1d5bc"
+dependencies = [
+ "bitcoin_hashes 0.14.101",
+ "serde",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "bitcoin-consensus-encoding"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6712f9c6fd6785b3b270884e57c441c403dc5d7e19ca45368c97c7a1de3000ec"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative 1.3.0",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d573f4cf32996a8dce612e4348cece65a241f1882ed594047c9ba348e8869fa5"
+
+[[package]]
+name = "bitcoin-io"
+version = "0.1.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb5de036369d1ac59d3c1819ebc4d850f89466f5401c571a285b6ed564a4cb78"
+dependencies = [
+ "bitcoin-consensus-encoding",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bca4c7abb40c8817d77403c880988cfd484f23ab2365726afb2f798363e2c4a2"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative 0.2.3",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5304e53726dbe5f93141535e102ed97b5bf4714fbecefdda8f9fb98d7fdaff0e"
+dependencies = [
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals",
+ "hex-conservative 1.3.0",
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "cc"
+version = "1.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3eb0f42d6c360dc3f8a821f6bf2fdea7f72bfd36b3076eb0e6d1e9e0752fff4"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
+dependencies = [
+ "aead",
+ "chacha20",
+ "cipher",
+ "poly1305",
+ "zeroize",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+ "zeroize",
+]
+
+[[package]]
+name = "clap"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "faster-hex"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"
+dependencies = [
+ "heapless",
+ "serde",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
+
+[[package]]
+name = "futures-task"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
+
+[[package]]
+name = "futures-util"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
+dependencies = [
+ "futures-core",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+]
+
+[[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "hashlink"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824e001ac4f3012dd16a264bec811403a67ca9deb6c102fc5049b32c4574b35f"
+dependencies = [
+ "hashbrown 0.16.1",
+]
+
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3fef046dca3ca91ee1408a8c1b80ab777e80a4d308d1bf4e7adb3fcb047e08"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hex-conservative"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271e0d19bcb473b6675739a2b536076b24a082316cb5199ad918edce10c599e8"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "http"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "bytes",
+ "http",
+ "http-body",
+ "hyper",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "js-sys"
+version = "0.3.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95b4103cffefa72eb8428cb6b47d6627161e51c2739fc5e3b734584157bc642a"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "litemap"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
+
+[[package]]
+name = "log"
+version = "0.4.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "mio"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "nostr"
+version = "0.45.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38ca5c25a6df8d4d78fdf39b42792438f6ce22b4809ccbfdb27582ed9ca45407"
+dependencies = [
+ "base64",
+ "bech32",
+ "bip39",
+ "bitcoin_hashes 1.2.0",
+ "cbc",
+ "chacha20",
+ "chacha20poly1305",
+ "faster-hex",
+ "opaquerr",
+ "rand 0.10.2",
+ "secp256k1",
+ "serde",
+ "serde_json",
+ "unicode-normalization",
+ "universal-time",
+ "url",
+ "zeroize",
+]
+
+[[package]]
+name = "nostr-database"
+version = "0.45.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "309950383c9854ca413d195705400e78b1376aedc48f3256754a86c609c047e8"
+dependencies = [
+ "nostr",
+ "opaquerr",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "opaquerr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f933a4265d5cdad61d19bbdfc972ea5726d56cd8d3d57b8f2d3c365dd42bee9"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
+
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
+dependencies = [
+ "getrandom 0.4.3",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rsqlite-vfs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1c93dd1c9683b438c392c492109cb702b8090b2bfc8fed6f6e4eb4523f17af3"
+dependencies = [
+ "bitflags",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+ "sqlite-wasm-rs",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+dependencies = [
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "secp256k1"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+dependencies = [
+ "bitcoin_hashes 0.14.101",
+ "rand 0.8.8",
+ "secp256k1-sys",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
+
+[[package]]
+name = "socket2"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "sqlite-wasm-rs"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc3efc0da82635d7e1ced0053bbbfa8c7ab9645d0bf36ceb4f7127bb85315d75"
+dependencies = [
+ "cc",
+ "js-sys",
+ "rsqlite-vfs",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
+
+[[package]]
+name = "tokio"
+version = "1.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c85f2c3ef0b1cd58b36682f4b17aaa995f0e5db534d85692b4903abce21f67"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_write",
+ "winnow",
+]
+
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.5",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror",
+ "utf-8",
+]
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "universal-time"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47a939edecc3c5a7b83c02e5f6b3c31d2bc69eabcc9a87ab12c6d37ee6dbc856"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vineyard"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "fs2",
+ "futures-util",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "nostr",
+ "nostr-database",
+ "rusqlite",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-tungstenite",
+ "tokio-util",
+ "toml",
+ "tracing",
+ "tracing-subscriber",
+ "url",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.9",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "writeable"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
+
+[[package]]
+name = "yoke"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33811428bee40dbceb6d545e95754741d17a6aef9a4849f0fd62e2ba4f412a78"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

Added file: Cargo.toml+68 additions@@ -0,0 +1,68 @@
+[package]
+name = "vineyard"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+description = "a persistent nostr relay for git forges"
+publish = false
+
+[dependencies]
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+futures-util = "0.3"
+fs2 = "0.4"
+http-body-util = "0.1"
+hyper = { version = "1", features = ["server", "http1"] }
+hyper-util = { version = "0.1", features = ["tokio"] }
+nostr = "=0.45.5"
+nostr-database = "=0.45.2"
+rusqlite = { version = "0.38", features = ["bundled"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "signal", "net", "sync", "time", "io-util"] }
+tokio-util = { version = "0.7", features = ["rt"] }
+tokio-tungstenite = { version = "0.28", features = ["rustls-tls-webpki-roots"] }
+toml = "0.8"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+url = "2"
+
+[lints.clippy]
+cargo = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+
+blanket_clippy_restriction_lints = "allow"
+restriction = { level = "warn", priority = -1 }
+
+arbitrary_source_item_ordering = "allow"
+arithmetic_side_effects = "allow"
+decimal_literal_representation = "allow"
+else_if_without_else = "allow"
+error_impl_error = "allow"
+exhaustive_enums = "allow"
+exhaustive_structs = "allow"
+field_scoped_visibility_modifiers = "allow"
+implicit_return = "allow"
+indexing_slicing = "allow"
+integer_division = "allow"
+integer_division_remainder_used = "allow"
+missing_trait_methods = "allow"
+missing_docs_in_private_items = "allow"
+missing_errors_doc = "allow"
+missing_inline_in_public_items = "allow"
+missing_panics_doc = "allow"
+module_name_repetitions = "allow"
+multiple_crate_versions = "allow"
+question_mark_used = "allow"
+ref_patterns = "allow"
+pub_with_shorthand = "allow"
+separated_literal_suffix = "allow"
+single_call_fn = "allow"
+std_instead_of_alloc = "allow"
+std_instead_of_core = "allow"
+tests_outside_test_module = "allow"
+
+[profile.release]
+lto = "thin"
+strip = true

Added file: README.md+108 additions@@ -0,0 +1,108 @@
+# vineyard
+
+a nostr federation companion for brewery
+
+public repository discovery and signed event exchange between forges
+git hosting and signing keys stay with brewery
+
+## run
+
+copy `vineyard.example.toml` and replace `forge_pubkeys` with brewery's public key
+database paths are relative to the config file
+
+```sh
+nix build
+result/bin/vineyard check-config --config vineyard.toml
+result/bin/vineyard serve --config vineyard.toml
+```
+
+put tls termination in front of the loopback listener
+forward websocket upgrades at the path in `public_url`
+`/healthz` checks database access
+request `application/nostr+json` at the websocket path for relay information
+
+## nixos
+
+import `nixosModules.vineyard` and configure the service
+
+```nix
+services.vineyard = {
+  enable = true;
+  publicUrl = "wss://relay.example.org/";
+  forgePubkeys = [ "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" ];
+  peers = [ { url = "wss://peer.example.org/"; } ];
+};
+```
+
+the module runs vineyard under a dynamic user and stores data in `/var/lib/vineyard`
+
+## peers
+
+add one or more bootstrap relays to connect your forge to the network
+
+```toml
+[[peers]]
+url = "wss://peer.example.org/"
+query_limit = 500
+```
+
+use a query limit no larger than the peer supports
+peers must accept forge events without nip42 authentication
+remote repository announcements retain their signer's identity
+brewery publishes its signed nip 65 relay list
+peer relay lists are persisted and joined automatically
+discovered peers are bounded by `max_discovered_peers`
+discovered peers require wss and public dns addresses by default
+set `allow_private_discovery` only for trusted private networks or local development
+
+delivery progress and failed-event retries persist in sqlite
+incoming history uses a seven-day overlap
+set a peer's `rescan_from` to an older unix timestamp for manual recovery
+single-second history overflow stops replay without advancing its checkpoint
+
+## brewery
+
+build brewery with its `federation` feature or nix package option
+
+```sh
+export BREWERY_FEDERATION=1
+export BREWERY_NOSTR_RELAYS=wss://relay.example.org/
+export BREWERY_PUBLIC_URL=https://git.example.org
+brewery repo issue-mode alice/widget users_and_tokens
+brewery repo patch-mode alice/widget tokens
+```
+
+repositories must be public
+brewery retains git hosting and verifies openpgp binding proofs
+the companion brewery changes persist replay progress in `federation.inbox.json`
+set `BREWERY_FEDERATION_RESCAN_FROM` to a unix timestamp for an older rescan
+
+## limits
+
+defaults are in `vineyard.example.toml`
+merged history is bounded by `max_query_bytes`
+queries without an explicit limit fail when history exceeds the result cap
+`max_repositories` bounds the shared repository directory
+slow subscribers disconnect and must replay
+peer limits use the direct socket address, so a proxy shares one allowance
+
+the database budget limits sqlite pages, not total disk usage
+leave space for the wal and backups
+accepted events are not evicted to make room
+
+## backup
+
+stop vineyard before copying its config and database
+preserve any accompanying sqlite wal file
+restore with the same forge public keys
+
+use the companion brewery backup command to retain `nostr.key` and federation state
+keep the restored key private and restore a custom key path before starting brewery
+a new forge key changes every repository's nostr address
+
+## development
+
+```sh
+nix develop
+nix flake check
+```

Added file: flake.lock+27 additions@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1787360063,
+        "narHash": "sha256-dt4WdcvsA8/RCe+VZZwqU0X+XMM3wBbGCWA0/sFWzGo=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "2c423e03bbafcff28bfadc6781a4a8257f205cb5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "2c423e03bbafcff28bfadc6781a4a8257f205cb5",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

Added file: flake.nix+38 additions@@ -0,0 +1,38 @@
+{
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/2c423e03bbafcff28bfadc6781a4a8257f205cb5";
+  outputs = { self, nixpkgs }: let
+    systems = [ "x86_64-linux" "aarch64-linux" ];
+    forAllSystems = nixpkgs.lib.genAttrs systems;
+    packageFor = system: let
+      pkgs = nixpkgs.legacyPackages.${system};
+    in pkgs.rustPlatform.buildRustPackage {
+      pname = "vineyard";
+      version = "0.1.0";
+      src = pkgs.lib.cleanSourceWith {
+        src = ./.;
+        filter = path: type:
+          pkgs.lib.cleanSourceFilter path type
+          && !(type == "directory" && builtins.elem (builtins.baseNameOf path) [ "target" ".jj" ".git" ]);
+      };
+      cargoLock.lockFile = ./Cargo.lock;
+      doCheck = true;
+    };
+  in {
+    nixosModules.default = import ./nix/module.nix self;
+    nixosModules.vineyard = self.nixosModules.default;
+    packages = forAllSystems (system: {
+      default = packageFor system;
+      vineyard = packageFor system;
+    });
+    checks = forAllSystems (system: {
+      vineyard = packageFor system;
+    });
+    devShells = forAllSystems (system: let
+      pkgs = nixpkgs.legacyPackages.${system};
+    in {
+      default = pkgs.mkShell {
+        packages = with pkgs; [ cargo rustc rustfmt clippy pkg-config ];
+      };
+    });
+  };
+}

Added file: nix/module.nix+128 additions@@ -0,0 +1,128 @@
+self: { config, lib, pkgs, ... }:
+let
+  cfg = config.services.vineyard;
+  toml = pkgs.formats.toml { };
+  peerToml = peer: {
+    url = peer.url;
+    query_limit = peer.queryLimit;
+  } // lib.optionalAttrs (peer.rescanFrom != null) {
+    rescan_from = peer.rescanFrom;
+  };
+  configFile = toml.generate "vineyard.toml" {
+    listen = cfg.listen;
+    public_url = cfg.publicUrl;
+    database = "/var/lib/vineyard/events.sqlite";
+    forge_pubkeys = cfg.forgePubkeys;
+    peers = map peerToml cfg.peers;
+    allow_private_discovery = cfg.allowPrivateDiscovery;
+    limits = cfg.limits;
+  };
+  port = lib.strings.toIntBase10 (lib.last (lib.splitString ":" cfg.listen));
+in
+{
+  options.services.vineyard = {
+    enable = lib.mkEnableOption "vineyard";
+    package = lib.mkOption {
+      type = lib.types.package;
+      default = self.packages.${pkgs.stdenv.hostPlatform.system}.default;
+      description = "vineyard package to run";
+    };
+    listen = lib.mkOption {
+      type = lib.types.str;
+      default = "127.0.0.1:7777";
+      description = "address and port for vineyard to listen on";
+    };
+    publicUrl = lib.mkOption {
+      type = lib.types.str;
+      default = "";
+      description = "public websocket url for vineyard";
+    };
+    forgePubkeys = lib.mkOption {
+      type = lib.types.listOf lib.types.str;
+      default = [ ];
+      description = "locally hosted forge public keys in hex";
+    };
+    peers = lib.mkOption {
+      type = lib.types.listOf (lib.types.submodule {
+        options = {
+          url = lib.mkOption {
+            type = lib.types.str;
+            description = "peer relay url";
+          };
+          queryLimit = lib.mkOption {
+            type = lib.types.ints.positive;
+            default = 500;
+            description = "peer query limit";
+          };
+          rescanFrom = lib.mkOption {
+            type = lib.types.nullOr lib.types.ints.unsigned;
+            default = null;
+            description = "peer rescan timestamp";
+          };
+        };
+      });
+      default = [ ];
+      description = "peer relays for event exchange";
+    };
+    allowPrivateDiscovery = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = "allow discovered relays on private networks";
+    };
+    limits = lib.mkOption {
+      type = lib.types.attrsOf lib.types.int;
+      default = { };
+      description = "relay limit overrides";
+    };
+    openFirewall = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = "open firewall for listen port";
+    };
+  };
+  config = lib.mkIf cfg.enable {
+    assertions = [
+      {
+        assertion = cfg.publicUrl != "";
+        message = "publicUrl must be set";
+      }
+      {
+        assertion = cfg.forgePubkeys != [ ];
+        message = "forgePubkeys must not be empty";
+      }
+    ];
+    networking.firewall.allowedTCPPorts = lib.optionals cfg.openFirewall [ port ];
+    systemd.services.vineyard = {
+      description = "vineyard nostr relay";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network-online.target" ];
+      wants = [ "network-online.target" ];
+      serviceConfig = {
+        ExecStartPre = "${cfg.package}/bin/vineyard check-config --config ${configFile}";
+        ExecStart = "${cfg.package}/bin/vineyard serve --config ${configFile}";
+        DynamicUser = true;
+        StateDirectory = "vineyard";
+        StateDirectoryMode = "0700";
+        WorkingDirectory = "/var/lib/vineyard";
+        UMask = "0077";
+        Restart = "on-failure";
+        RestartSec = "5";
+        NoNewPrivileges = true;
+        ProtectSystem = "strict";
+        ProtectHome = true;
+        PrivateTmp = true;
+        PrivateDevices = true;
+        ProtectKernelTunables = true;
+        ProtectKernelModules = true;
+        ProtectControlGroups = true;
+        RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" "AF_NETLINK" ];
+        RestrictNamespaces = true;
+        LockPersonality = true;
+        RestrictRealtime = true;
+        RestrictSUIDSGID = true;
+        RemoveIPC = true;
+        CapabilityBoundingSet = "";
+      };
+    };
+  };
+}

Added file: src/config.rs+315 additions@@ -0,0 +1,315 @@
+use std::collections::HashSet;
+use std::fs::read_to_string;
+use std::net::SocketAddr;
+use std::path::{Path, PathBuf};
+
+use nostr::key::PublicKey;
+use serde::Deserialize;
+use tokio::sync::Semaphore;
+
+fn default_listen() -> SocketAddr {
+    SocketAddr::from(([127, 0, 0, 1], 7777))
+}
+
+fn default_database() -> PathBuf {
+    PathBuf::from("vineyard.sqlite")
+}
+
+const fn default_max_connections() -> usize {
+    32
+}
+
+const fn default_max_connections_per_ip() -> usize {
+    8
+}
+
+const fn default_max_subscriptions() -> usize {
+    16
+}
+
+const fn default_max_event_bytes() -> usize {
+    2_096_896
+}
+
+const fn default_max_message_bytes() -> usize {
+    2_097_152
+}
+
+const fn default_max_tags() -> usize {
+    128
+}
+
+const fn default_max_filters() -> usize {
+    8
+}
+
+const fn default_max_filter_bytes() -> usize {
+    32_768
+}
+
+const fn default_max_query_results() -> usize {
+    500
+}
+
+const fn default_max_repositories() -> usize {
+    4096
+}
+
+const fn default_max_discovered_peers() -> usize {
+    32
+}
+
+const fn default_max_query_bytes() -> usize {
+    16_777_216
+}
+
+const fn default_events_per_minute() -> u32 {
+    120
+}
+
+const fn default_queries_per_minute() -> u32 {
+    120
+}
+
+const fn default_max_database_bytes() -> u64 {
+    1_073_741_824
+}
+
+const fn default_min_free_bytes() -> u64 {
+    67_108_864
+}
+
+const fn default_write_timeout_seconds() -> u64 {
+    10
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Config {
+    #[serde(default = "default_listen")]
+    pub listen: SocketAddr,
+    pub public_url: String,
+    #[serde(default = "default_database")]
+    pub database: PathBuf,
+    pub forge_pubkeys: Vec<String>,
+    #[serde(default)]
+    pub peers: Vec<Peer>,
+    #[serde(default)]
+    pub allow_private_discovery: bool,
+    #[serde(default)]
+    pub limits: Limits,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Peer {
+    pub url: String,
+    #[serde(default = "default_max_query_results")]
+    pub query_limit: usize,
+    pub rescan_from: Option<u64>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Limits {
+    #[serde(default = "default_max_repositories")]
+    pub max_repositories: usize,
+    #[serde(default = "default_max_discovered_peers")]
+    pub max_discovered_peers: usize,
+    #[serde(default = "default_max_connections")]
+    pub max_connections: usize,
+    #[serde(default = "default_max_connections_per_ip")]
+    pub max_connections_per_ip: usize,
+    #[serde(default = "default_max_subscriptions")]
+    pub max_subscriptions: usize,
+    #[serde(default = "default_max_event_bytes")]
+    pub max_event_bytes: usize,
+    #[serde(default = "default_max_message_bytes")]
+    pub max_message_bytes: usize,
+    #[serde(default = "default_max_tags")]
+    pub max_tags: usize,
+    #[serde(default = "default_max_filters")]
+    pub max_filters: usize,
+    #[serde(default = "default_max_filter_bytes")]
+    pub max_filter_bytes: usize,
+    #[serde(default = "default_max_query_results")]
+    pub max_query_results: usize,
+    #[serde(default = "default_max_query_bytes")]
+    pub max_query_bytes: usize,
+    #[serde(default = "default_events_per_minute")]
+    pub events_per_minute: u32,
+    #[serde(default = "default_queries_per_minute")]
+    pub queries_per_minute: u32,
+    #[serde(default = "default_max_database_bytes")]
+    pub max_database_bytes: u64,
+    #[serde(default = "default_min_free_bytes")]
+    pub min_free_bytes: u64,
+    #[serde(default = "default_write_timeout_seconds")]
+    pub write_timeout_seconds: u64,
+}
+
+impl Default for Limits {
+    fn default() -> Self {
+        Self {
+            max_repositories: default_max_repositories(),
+            max_discovered_peers: default_max_discovered_peers(),
+            max_connections: default_max_connections(),
+            max_connections_per_ip: default_max_connections_per_ip(),
+            max_subscriptions: default_max_subscriptions(),
+            max_event_bytes: default_max_event_bytes(),
+            max_message_bytes: default_max_message_bytes(),
+            max_tags: default_max_tags(),
+            max_filters: default_max_filters(),
+            max_filter_bytes: default_max_filter_bytes(),
+            max_query_results: default_max_query_results(),
+            max_query_bytes: default_max_query_bytes(),
+            events_per_minute: default_events_per_minute(),
+            queries_per_minute: default_queries_per_minute(),
+            max_database_bytes: default_max_database_bytes(),
+            min_free_bytes: default_min_free_bytes(),
+            write_timeout_seconds: default_write_timeout_seconds(),
+        }
+    }
+}
+
+impl Config {
+    pub fn load(path: &Path) -> anyhow::Result<Self> {
+        let text = read_to_string(path).map_err(|error| {
+            anyhow::anyhow!("failed to read config {}: {error}", path.display())
+        })?;
+        let mut cfg: Self = toml::from_str(&text).map_err(|error| {
+            anyhow::anyhow!("failed to parse config {}: {error}", path.display())
+        })?;
+        if cfg.database.is_relative() {
+            if let Some(parent) = path.parent() {
+                if !parent.as_os_str().is_empty() {
+                    cfg.database = parent.join(&cfg.database);
+                }
+            }
+        }
+        cfg.validate()?;
+        Ok(cfg)
+    }
+
+    pub fn validate(&self) -> anyhow::Result<()> {
+        let url = relay_url(&self.public_url)
+            .ok_or_else(|| anyhow::anyhow!("invalid public_url {}", self.public_url))?;
+        self.forge_keys()?;
+        if self.peers.len() > 16 {
+            anyhow::bail!("at most 16 peer relays are supported");
+        }
+        let mut peers = HashSet::new();
+        for peer in &self.peers {
+            let peer_url = relay_url(&peer.url).ok_or_else(|| {
+                anyhow::anyhow!(
+                    "peer urls must be ws or wss without credentials, queries or fragments"
+                )
+            })?;
+            if peer_url == url || !peers.insert(peer_url) {
+                anyhow::bail!("peer urls must be unique and distinct from public_url");
+            }
+            if !(2..10000).contains(&peer.query_limit) {
+                anyhow::bail!("peer query_limit must be between 2 and 9999");
+            }
+        }
+        if self.limits.max_connections == 0
+            || self.limits.max_connections_per_ip == 0
+            || self.limits.max_subscriptions == 0
+            || self.limits.max_event_bytes == 0
+            || self.limits.max_message_bytes == 0
+            || self.limits.max_tags == 0
+            || self.limits.max_filters == 0
+            || self.limits.max_filter_bytes == 0
+            || self.limits.max_query_results == 0
+            || self.limits.max_query_bytes == 0
+            || self.limits.events_per_minute == 0
+            || self.limits.queries_per_minute == 0
+            || self.limits.max_database_bytes == 0
+            || self.limits.min_free_bytes == 0
+            || self.limits.write_timeout_seconds == 0
+        {
+            anyhow::bail!("limits must all be positive");
+        }
+        if self.limits.max_connections_per_ip > self.limits.max_connections {
+            anyhow::bail!("max_connections_per_ip must not exceed max_connections");
+        }
+        let min_message = self
+            .limits
+            .max_event_bytes
+            .checked_add(256)
+            .ok_or_else(|| anyhow::anyhow!("max_event_bytes too large"))?;
+        if min_message > self.limits.max_message_bytes {
+            anyhow::bail!("max_message_bytes must fit max_event_bytes plus 256 bytes of overhead");
+        }
+        if self.limits.max_event_bytes > self.limits.max_query_bytes {
+            anyhow::bail!("max_query_bytes must fit one maximum size event");
+        }
+        if self.limits.max_repositories == 0 || self.limits.max_repositories >= 10000 {
+            anyhow::bail!("max_repositories must be between 1 and 9999");
+        }
+        if self.limits.max_discovered_peers == 0 || self.limits.max_discovered_peers > 256 {
+            anyhow::bail!("max_discovered_peers must be between 1 and 256");
+        }
+        if self.limits.max_query_results >= 10000 {
+            anyhow::bail!("max_query_results must be below 10000");
+        }
+        if self.limits.max_connections > Semaphore::MAX_PERMITS {
+            anyhow::bail!("max_connections exceeds the semaphore limit");
+        }
+        self.limits
+            .max_filter_bytes
+            .checked_mul(self.limits.max_subscriptions)
+            .ok_or_else(|| anyhow::anyhow!("subscription byte budget is too large"))?;
+        if self.websocket_path()? == "/healthz" {
+            anyhow::bail!("public_url must not use the health endpoint");
+        }
+        Ok(())
+    }
+
+    pub fn forge_keys(&self) -> anyhow::Result<HashSet<PublicKey>> {
+        if self.forge_pubkeys.is_empty() {
+            anyhow::bail!("forge_pubkeys must not be empty");
+        }
+        let mut set = HashSet::new();
+        for raw in &self.forge_pubkeys {
+            let trimmed = raw.trim();
+            if trimmed.len() != 64 || !trimmed.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+                anyhow::bail!("invalid forge public key: {raw}");
+            }
+            let key: PublicKey = trimmed
+                .parse()
+                .map_err(|error| anyhow::anyhow!("invalid forge public key {raw}: {error}"))?;
+            if !set.insert(key) {
+                anyhow::bail!("duplicate forge public key: {raw}");
+            }
+        }
+        Ok(set)
+    }
+
+    pub fn websocket_path(&self) -> anyhow::Result<String> {
+        let url = url::Url::parse(&self.public_url)
+            .map_err(|error| anyhow::anyhow!("invalid public_url {}: {error}", self.public_url))?;
+        let path = url.path();
+        if path.is_empty() {
+            Ok("/".to_owned())
+        } else if path.starts_with('/') {
+            Ok(path.to_owned())
+        } else {
+            Ok(format!("/{path}"))
+        }
+    }
+}
+
+pub(crate) fn relay_url(raw: &str) -> Option<url::Url> {
+    let url = url::Url::parse(raw).ok()?;
+    if !matches!(url.scheme(), "ws" | "wss")
+        || url.host_str().is_none()
+        || !url.username().is_empty()
+        || url.password().is_some()
+        || url.query().is_some()
+        || url.fragment().is_some()
+    {
+        return None;
+    }
+    Some(url)
+}

Added file: src/federation.rs+650 additions@@ -0,0 +1,650 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use anyhow::{Context as _, Result, bail};
+use futures_util::{SinkExt as _, StreamExt as _};
+use nostr::event::{Event, Kind};
+use nostr::filter::{Filter, MatchEventOptions};
+use nostr::key::PublicKey;
+use nostr::message::MachineReadablePrefix;
+use nostr_database::{NostrDatabase as _, RejectedReason, SaveEventStatus};
+use serde_json::{Value, json};
+use tokio::net::{TcpStream, lookup_host};
+use tokio::time::{Instant, sleep, timeout, timeout_at};
+use tokio_tungstenite::tungstenite::{Message, protocol::WebSocketConfig};
+use tokio_tungstenite::{
+    MaybeTlsStream, WebSocketStream, client_async_tls_with_config, connect_async_with_config,
+};
+use tokio_util::sync::CancellationToken;
+use tokio_util::task::TaskTracker;
+
+use crate::config::{Config, Peer, relay_url};
+use crate::policy::{Policy, WritePolicyResult, coordinate};
+use crate::relay::Relay;
+use crate::store::Store;
+
+const KINDS: [u16; 10] = [5, 1617, 1621, 1630, 1631, 1632, 10002, 30382, 30617, 30618];
+const OVERLAP: u64 = 7 * 24 * 60 * 60;
+const RESPONSE_TIMEOUT: Duration = Duration::from_secs(30);
+type Socket = WebSocketStream<MaybeTlsStream<TcpStream>>;
+
+#[derive(Clone)]
+struct Link {
+    peer: Peer,
+    config: Arc<Config>,
+    store: Arc<Store>,
+    relay: Relay,
+    policy: Policy,
+    discovered: bool,
+    stop: CancellationToken,
+}
+
+struct Connection {
+    socket: Socket,
+    stop: CancellationToken,
+    write_timeout: Duration,
+    request_sequence: u64,
+}
+
+pub fn spawn(
+    config: Arc<Config>,
+    store: Arc<Store>,
+    relay: Relay,
+    policy: Policy,
+    task_tracker: &TaskTracker,
+    stop: CancellationToken,
+) {
+    let tasks = task_tracker.clone();
+    task_tracker
+        .clone()
+        .spawn(manage(config, store, relay, policy, tasks, stop));
+}
+
+async fn manage(
+    config: Arc<Config>,
+    store: Arc<Store>,
+    relay: Relay,
+    policy: Policy,
+    tasks: TaskTracker,
+    stop: CancellationToken,
+) {
+    let mut active = HashMap::<String, CancellationToken>::new();
+    loop {
+        let mut desired = BTreeMap::new();
+        for configured_peer in &config.peers {
+            let mut normalized_peer = configured_peer.clone();
+            let Some(url) = relay_url(&normalized_peer.url) else {
+                continue;
+            };
+            normalized_peer.url = url.to_string();
+            desired.insert(normalized_peer.url.clone(), (normalized_peer, false));
+        }
+        match store
+            .journal
+            .discovered(config.limits.max_discovered_peers)
+            .await
+        {
+            Ok(urls) => {
+                for raw in urls {
+                    if let Some(peer) = discovered_peer(&config, &raw) {
+                        desired.entry(peer.url.clone()).or_insert((peer, true));
+                    }
+                }
+            }
+            Err(error) => tracing::error!(%error, "loading discovered peers failed"),
+        }
+
+        active.retain(|url, peer_stop| {
+            if desired.contains_key(url) {
+                true
+            } else {
+                peer_stop.cancel();
+                false
+            }
+        });
+        for (url, (peer, discovered)) in desired {
+            if active.contains_key(&url) {
+                continue;
+            }
+            let peer_stop = stop.child_token();
+            let link = Link {
+                peer,
+                config: Arc::clone(&config),
+                store: Arc::clone(&store),
+                relay: relay.clone(),
+                policy: policy.clone(),
+                discovered,
+                stop: peer_stop.clone(),
+            };
+            tasks.spawn(run(link.clone(), true));
+            tasks.spawn(run(link, false));
+            active.insert(url, peer_stop);
+        }
+
+        tokio::select! {
+            () = stop.cancelled() => break,
+            () = sleep(Duration::from_secs(10)) => {}
+        }
+    }
+    for peer_stop in active.into_values() {
+        peer_stop.cancel();
+    }
+}
+
+fn discovered_peer(config: &Config, raw: &str) -> Option<Peer> {
+    let url = relay_url(raw)?;
+    if (!config.allow_private_discovery && url.scheme() != "wss")
+        || url == relay_url(&config.public_url)?
+    {
+        return None;
+    }
+    Some(Peer {
+        url: url.to_string(),
+        query_limit: config.limits.max_query_results,
+        rescan_from: None,
+    })
+}
+
+async fn run(link: Link, outbound: bool) {
+    let direction = if outbound { "outbound" } else { "inbound" };
+    let mut backoff = 5;
+    while !link.stop.is_cancelled() {
+        let started = Instant::now();
+        let result = if outbound {
+            publish(&link).await
+        } else {
+            subscribe(&link).await
+        };
+        if link.stop.is_cancelled() {
+            break;
+        }
+        if let Err(error) = result {
+            tracing::warn!(peer = %link.peer.url, %direction, %error, "peer connection interrupted");
+        }
+        if started.elapsed() > Duration::from_secs(60) {
+            backoff = 5;
+        }
+        tokio::select! {
+            () = link.stop.cancelled() => break,
+            () = sleep(Duration::from_secs(backoff)) => {},
+        }
+        backoff = (backoff * 2).min(60);
+    }
+}
+
+impl Connection {
+    async fn open(link: &Link) -> Result<Self> {
+        let config = WebSocketConfig::default()
+            .max_message_size(Some(link.config.limits.max_message_bytes))
+            .max_frame_size(Some(link.config.limits.max_message_bytes));
+        let connected = async {
+            if link.discovered {
+                connect_discovered(link, config).await
+            } else {
+                connect_async_with_config(&link.peer.url, Some(config), false)
+                    .await
+                    .map(|(socket, _)| socket)
+                    .map_err(Into::into)
+            }
+        };
+        let socket = tokio::select! {
+            () = link.stop.cancelled() => bail!("stopping"),
+            result = timeout(RESPONSE_TIMEOUT, connected) => {
+                result.context("peer connection timed out")??
+            }
+        };
+        Ok(Self {
+            socket,
+            stop: link.stop.clone(),
+            write_timeout: Duration::from_secs(link.config.limits.write_timeout_seconds),
+            request_sequence: 0,
+        })
+    }
+
+    async fn send(&mut self, value: Value) -> Result<()> {
+        self.send_message(Message::Text(value.to_string().into()))
+            .await
+    }
+
+    async fn send_message(&mut self, message: Message) -> Result<()> {
+        tokio::select! {
+            () = self.stop.cancelled() => bail!("stopping"),
+            result = timeout(self.write_timeout, self.socket.send(message)) => {
+                result.context("peer write timed out")??;
+                Ok(())
+            }
+        }
+    }
+
+    async fn next(&mut self, deadline: Instant) -> Result<Option<Value>> {
+        loop {
+            let message = tokio::select! {
+                () = self.stop.cancelled() => bail!("stopping"),
+                result = timeout_at(deadline, self.socket.next()) => match result {
+                    Err(_) => return Ok(None),
+                    Ok(Some(message)) => message?,
+                    Ok(None) => bail!("peer disconnected"),
+                }
+            };
+            match message {
+                Message::Text(text) => return Ok(Some(serde_json::from_str(&text)?)),
+                Message::Ping(payload) => self.send_message(Message::Pong(payload)).await?,
+                Message::Close(_) => bail!("peer closed the connection"),
+                Message::Binary(_) | Message::Pong(_) | Message::Frame(_) => {}
+            }
+        }
+    }
+}
+
+async fn connect_discovered(link: &Link, config: WebSocketConfig) -> Result<Socket> {
+    let url = url::Url::parse(&link.peer.url)?;
+    let host = url.host_str().context("discovered peer has no host")?;
+    let port = url
+        .port_or_known_default()
+        .context("discovered peer has no port")?;
+    let mut last_error = None;
+    for address in lookup_host((host, port)).await? {
+        if !link.config.allow_private_discovery && !public_ip(address.ip()) {
+            continue;
+        }
+        match TcpStream::connect(address).await {
+            Ok(stream) => {
+                return client_async_tls_with_config(&link.peer.url, stream, Some(config), None)
+                    .await
+                    .map(|(socket, _)| socket)
+                    .map_err(Into::into);
+            }
+            Err(error) => last_error = Some(error),
+        }
+    }
+    match last_error {
+        Some(error) => Err(error.into()),
+        None => bail!("discovered peer did not resolve to an allowed address"),
+    }
+}
+
+fn public_ip(address: IpAddr) -> bool {
+    match address {
+        IpAddr::V4(ipv4) => public_ipv4(ipv4),
+        IpAddr::V6(ipv6) => public_ipv6(ipv6),
+    }
+}
+
+fn public_ipv4(ip: Ipv4Addr) -> bool {
+    let [first, second, _, _] = ip.octets();
+    !(ip.is_private()
+        || ip.is_loopback()
+        || ip.is_link_local()
+        || ip.is_broadcast()
+        || ip.is_documentation()
+        || ip.is_unspecified()
+        || ip.is_multicast()
+        || first == 0
+        || (first == 100 && (64..=127).contains(&second))
+        || (first == 198 && matches!(second, 18 | 19)))
+}
+
+fn public_ipv6(ip: Ipv6Addr) -> bool {
+    if let Some(ipv4) = ip.to_ipv4_mapped() {
+        return public_ipv4(ipv4);
+    }
+    let segments = ip.segments();
+    !(ip.is_loopback()
+        || ip.is_unspecified()
+        || ip.is_unique_local()
+        || ip.is_unicast_link_local()
+        || ip.is_multicast()
+        || (segments[0] == 0x2001 && segments[1] == 0x0db8))
+}
+
+async fn publish(link: &Link) -> Result<()> {
+    let mut connection = Connection::open(link).await?;
+    let mut announced = HashSet::new();
+    loop {
+        let pending = link.store.journal.pending(&link.peer.url, 32).await?;
+        if pending.is_empty() {
+            connection
+                .next(Instant::now() + Duration::from_secs(1))
+                .await?;
+            continue;
+        }
+        for (sequence, id) in pending {
+            if announced.len() >= link.config.limits.max_repositories {
+                announced.clear();
+            }
+            if let Some(event) = link.store.event_by_id(&id).await? {
+                let repository_event = repository_coordinate(&event).is_some();
+                if let Some(announcement) = announcement_for(link, &event).await? {
+                    if announced.insert(announcement.id) {
+                        if let Some(error) = publish_event(&mut connection, &announcement).await? {
+                            announced.remove(&announcement.id);
+                            defer(link, sequence, &error).await?;
+                            continue;
+                        }
+                    }
+                } else if repository_event {
+                    link.store
+                        .journal
+                        .acknowledge(&link.peer.url, sequence)
+                        .await?;
+                    continue;
+                }
+                if let Some(error) = publish_event(&mut connection, &event).await? {
+                    if link.store.event_by_id(&id).await?.is_some() {
+                        defer(link, sequence, &error).await?;
+                        continue;
+                    }
+                } else if event.kind == Kind::from(30617) {
+                    announced.insert(event.id);
+                }
+            }
+            link.store
+                .journal
+                .acknowledge(&link.peer.url, sequence)
+                .await?;
+        }
+    }
+}
+
+async fn defer(link: &Link, sequence: u64, error: &str) -> Result<()> {
+    let retry_at = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() + 300;
+    link.store
+        .journal
+        .defer(&link.peer.url, sequence, error, retry_at)
+        .await?;
+    tracing::warn!(peer = %link.peer.url, sequence, %error, "peer delivery deferred");
+    Ok(())
+}
+
+async fn publish_event(connection: &mut Connection, event: &Event) -> Result<Option<String>> {
+    tokio::select! {
+        () = connection.stop.cancelled() => bail!("stopping"),
+        () = sleep(Duration::from_secs(1)) => {},
+    }
+    connection.send(json!(["EVENT", event])).await?;
+    let id = event.id.to_hex();
+    let deadline = Instant::now() + RESPONSE_TIMEOUT;
+    loop {
+        let frame = connection
+            .next(deadline)
+            .await?
+            .context("peer acknowledgement timed out")?;
+        if frame[0] == "OK" && frame[1].as_str() == Some(&id) {
+            let reason = frame[3].as_str().unwrap_or("peer rejected event");
+            return Ok(if frame[2] == true || reason.starts_with("duplicate:") {
+                None
+            } else {
+                Some(reason.chars().take(512).collect())
+            });
+        }
+    }
+}
+
+async fn announcement_for(link: &Link, event: &Event) -> Result<Option<Event>> {
+    let Some((author, identifier)) = repository_coordinate(event) else {
+        return Ok(None);
+    };
+    Ok(link
+        .store
+        .query(
+            Filter::new()
+                .kind(Kind::from(30617))
+                .author(author)
+                .identifier(identifier)
+                .limit(1),
+        )
+        .await?
+        .into_iter()
+        .next())
+}
+
+fn repository_coordinate(event: &Event) -> Option<(PublicKey, String)> {
+    if event.kind == Kind::from(30618) {
+        event
+            .tags
+            .identifier()
+            .map(|identifier| (event.pubkey, identifier))
+    } else if matches!(event.kind.as_u16(), 1617 | 1621 | 1630..=1632) {
+        event.tags.iter().find_map(|tag| {
+            let values = tag.as_slice();
+            if values.first().map(String::as_str) != Some("a") {
+                return None;
+            }
+            let (kind, author, identifier) = coordinate(values.get(1)?)?;
+            if kind != 30617 {
+                return None;
+            }
+            Some((author, identifier.to_owned()))
+        })
+    } else {
+        None
+    }
+}
+
+async fn import(link: &Link, value: Value) -> Result<()> {
+    let event: Event = serde_json::from_value(value)?;
+    if event.verify().is_err() {
+        tracing::debug!(peer = %link.peer.url, event = %event.id, "ignored invalid peer event");
+        return Ok(());
+    }
+    match link.policy.admit_peer(&event).await {
+        WritePolicyResult::Accept => {}
+        WritePolicyResult::Respond { status: true, .. } => return Ok(()),
+        WritePolicyResult::Respond {
+            prefix: MachineReadablePrefix::Error | MachineReadablePrefix::RateLimited,
+            message,
+            ..
+        } => bail!("peer import paused by {message}"),
+        WritePolicyResult::Respond { message, .. } => {
+            tracing::debug!(peer = %link.peer.url, event = %event.id, %message, "ignored out of scope peer event");
+            return Ok(());
+        }
+    }
+    match link.relay.add_event(event).await? {
+        SaveEventStatus::Success
+        | SaveEventStatus::Rejected(
+            RejectedReason::Duplicate
+            | RejectedReason::Deleted
+            | RejectedReason::Expired
+            | RejectedReason::Replaced
+            | RejectedReason::InvalidDelete
+            | RejectedReason::Vanished,
+        ) => Ok(()),
+        status @ SaveEventStatus::Rejected(_) => {
+            bail!("peer event was not stored with status {status:?}")
+        }
+    }
+}
+
+async fn subscribe(link: &Link) -> Result<()> {
+    let mut connection = Connection::open(link).await?;
+    connection
+        .send(json!(["REQ", "live", {"kinds": KINDS, "limit": 0_u8}]))
+        .await?;
+    let deadline = Instant::now() + RESPONSE_TIMEOUT;
+    loop {
+        let frame = connection
+            .next(deadline)
+            .await?
+            .context("live subscription timed out")?;
+        if frame[0] == "EOSE" && frame[1] == "live" {
+            break;
+        }
+        handle_live(link, frame).await?;
+    }
+    let mut completed = HashSet::new();
+    let mut next_replay = Instant::now();
+    loop {
+        let replay_all = Instant::now() >= next_replay;
+        let until = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
+        for (scope, filter) in [
+            ("announcements".to_owned(), json!({"kinds": [30_617_u16]})),
+            ("bindings".to_owned(), json!({"kinds": [30_382_u16]})),
+            ("relays".to_owned(), json!({"kinds": [10_002_u16]})),
+        ] {
+            if replay_all || !completed.contains(&scope) {
+                replay(link, &mut connection, &scope, filter, until).await?;
+                completed.insert(scope);
+            }
+        }
+        let mut active_scopes = HashSet::from([
+            "announcements".to_owned(),
+            "bindings".to_owned(),
+            "relays".to_owned(),
+        ]);
+        for (author, identifier) in link
+            .store
+            .journal
+            .repositories(link.config.limits.max_repositories)
+            .await?
+        {
+            let address = format!("30617:{author}:{identifier}");
+            for (scope, filter) in [
+                (
+                    format!("state:{address}"),
+                    json!({"kinds": [30_618_u16], "authors": [author], "#d": [identifier]}),
+                ),
+                (
+                    format!("contributions:{address}"),
+                    json!({"kinds": [1_617_u16, 1_621_u16, 1_630_u16, 1_631_u16, 1_632_u16], "#a": [address]}),
+                ),
+            ] {
+                active_scopes.insert(scope.clone());
+                if replay_all || !completed.contains(&scope) {
+                    replay(link, &mut connection, &scope, filter, until).await?;
+                    completed.insert(scope);
+                }
+            }
+        }
+        completed.retain(|scope| active_scopes.contains(scope));
+        if replay_all {
+            replay(
+                link,
+                &mut connection,
+                "deletions",
+                json!({"kinds": [5_u16]}),
+                until,
+            )
+            .await?;
+            next_replay = Instant::now() + Duration::from_secs(300);
+        }
+        let refresh = Instant::now() + Duration::from_secs(30);
+        while let Some(frame) = connection.next(refresh).await? {
+            handle_live(link, frame).await?;
+        }
+    }
+}
+
+async fn handle_live(link: &Link, frame: Value) -> Result<()> {
+    if frame[1] != "live" {
+        return Ok(());
+    }
+    match frame[0].as_str() {
+        Some("EVENT") => import(link, frame[2].clone()).await,
+        Some("CLOSED") => bail!("peer closed live subscription with {}", frame[2]),
+        _ => Ok(()),
+    }
+}
+
+async fn replay(
+    link: &Link,
+    connection: &mut Connection,
+    scope: &str,
+    filter: Value,
+    until: u64,
+) -> Result<()> {
+    let checkpoint = link
+        .store
+        .journal
+        .checkpoint(&link.peer.url, scope)
+        .await?
+        .unwrap_or(0);
+    let overlap_start = checkpoint.saturating_sub(OVERLAP);
+    let replay_start = link
+        .peer
+        .rescan_from
+        .map_or(overlap_start, |from| from.min(overlap_start));
+    let mut ranges = vec![(replay_start.min(until), until)];
+    while let Some((since, range_until)) = ranges.pop() {
+        if replay_range(link, connection, filter.clone(), since, range_until).await? {
+            link.store
+                .journal
+                .advance(&link.peer.url, scope, range_until)
+                .await?;
+        } else {
+            if since == range_until {
+                bail!(
+                    "recovery required for {scope} at {since}, one second exceeds the peer history limit"
+                );
+            }
+            let middle = since + (range_until - since) / 2;
+            ranges.push((middle + 1, range_until));
+            ranges.push((since, middle));
+        }
+    }
+    Ok(())
+}
+
+async fn replay_range(
+    link: &Link,
+    connection: &mut Connection,
+    mut filter: Value,
+    since: u64,
+    until: u64,
+) -> Result<bool> {
+    let pause = Instant::now() + Duration::from_secs(1);
+    while let Some(frame) = connection.next(pause).await? {
+        handle_live(link, frame).await?;
+    }
+    filter["since"] = json!(since);
+    filter["until"] = json!(until);
+    filter["limit"] = json!(link.peer.query_limit);
+    let matching: Filter = serde_json::from_value(filter.clone())?;
+    connection.request_sequence += 1;
+    let subscription = format!("history-{}", connection.request_sequence);
+    connection
+        .send(json!(["REQ", subscription, filter]))
+        .await?;
+    let deadline = Instant::now() + RESPONSE_TIMEOUT;
+    let mut received = HashSet::new();
+    let complete = loop {
+        let frame = connection
+            .next(deadline)
+            .await?
+            .context("peer history timed out")?;
+        if frame[1] != subscription {
+            handle_live(link, frame).await?;
+            continue;
+        }
+        match frame[0].as_str() {
+            Some("EVENT") => {
+                let event: Event = serde_json::from_value(frame[2].clone())?;
+                if !matching.match_event(&event, MatchEventOptions::new()) {
+                    bail!("peer returned an event outside the requested history");
+                }
+                received.insert(event.id);
+                import(link, frame[2].clone()).await?;
+                if received.len() >= link.peer.query_limit {
+                    break false;
+                }
+            }
+            Some("EOSE") => break true,
+            Some("CLOSED") => {
+                let message = frame[2].as_str().unwrap_or_default();
+                if (message.starts_with("rate-limited:") || message.starts_with("error:"))
+                    && (message.contains("byte limit")
+                        || message.contains("result limit")
+                        || message.contains("too many results"))
+                {
+                    break false;
+                }
+                bail!("peer closed history with {message}");
+            }
+            _ => {}
+        }
+    };
+    connection.send(json!(["CLOSE", subscription])).await?;
+    Ok(complete)
+}

Added file: src/journal.rs+1028 additions@@ -0,0 +1,1028 @@
+use std::cmp::Ordering;
+use std::collections::{BTreeSet, HashSet};
+use std::error::Error;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use anyhow::{Context as _, Result};
+use nostr::event::{Event, EventId, Kind, Signature, Tags};
+use nostr::filter::Filter;
+use nostr::key::PublicKey;
+use nostr::types::Timestamp;
+use nostr_database::{DatabaseEventStatus, RejectedReason, SaveEventStatus};
+use rusqlite::{
+    Connection, OptionalExtension as _, Params, Row, Transaction, params, params_from_iter,
+};
+use tokio::sync::{Mutex, MutexGuard};
+use tokio::task::spawn_blocking;
+
+use crate::config::relay_url;
+use crate::query::EventQuery;
+
+const SCHEMA: &str = "
+CREATE TABLE IF NOT EXISTS events(
+    id BLOB PRIMARY KEY NOT NULL CHECK(length(id) = 32),
+    pubkey BLOB NOT NULL CHECK(length(pubkey) = 32),
+    created_at INTEGER NOT NULL CHECK(created_at > 0),
+    kind INTEGER NOT NULL CHECK(kind BETWEEN 0 AND 65535),
+    content TEXT NOT NULL,
+    tags JSONB NOT NULL,
+    sig BLOB NOT NULL CHECK(length(sig) = 64)
+) WITHOUT ROWID;
+
+CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_events_pubkey_created_at ON events(pubkey, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_events_pubkey_kind_created_at
+ON events(pubkey, kind, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_events_kind_created_at ON events(kind, created_at DESC);
+
+DROP INDEX IF EXISTS idx_events_pubkey;
+DROP INDEX IF EXISTS idx_events_kind;
+
+CREATE TABLE IF NOT EXISTS event_tags(
+    event_id BLOB NOT NULL CHECK(length(event_id) = 32),
+    tag_name TEXT NOT NULL CHECK(length(tag_name) = 1),
+    tag_value TEXT NOT NULL,
+    FOREIGN KEY(event_id) REFERENCES events(id) ON DELETE CASCADE,
+    PRIMARY KEY(tag_name, tag_value, event_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_tags_event_id ON event_tags(event_id);
+
+CREATE TABLE IF NOT EXISTS deleted_ids(
+    event_id BLOB PRIMARY KEY NOT NULL CHECK(length(event_id) = 32)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS deleted_coordinates(
+    pubkey BLOB NOT NULL CHECK(length(pubkey) = 32),
+    kind INTEGER NOT NULL CHECK(kind BETWEEN 0 AND 65535),
+    identifier TEXT NOT NULL,
+    deleted_at INTEGER NOT NULL CHECK(deleted_at > 0),
+    PRIMARY KEY(pubkey, kind, identifier)
+) WITHOUT ROWID;
+
+DROP TRIGGER IF EXISTS sanctum_deleted_after_insert;
+DROP TABLE IF EXISTS sanctum_deleted_events;
+
+CREATE TABLE IF NOT EXISTS vineyard_delivery(
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    event_id BLOB NOT NULL UNIQUE REFERENCES events(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS vineyard_peers(
+    peer TEXT PRIMARY KEY,
+    delivered INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS vineyard_checkpoints(
+    peer TEXT,
+    scope TEXT,
+    until INTEGER NOT NULL,
+    PRIMARY KEY(peer, scope)
+);
+
+CREATE TABLE IF NOT EXISTS vineyard_retries(
+    peer TEXT,
+    sequence INTEGER REFERENCES vineyard_delivery(sequence) ON DELETE CASCADE,
+    retry_at INTEGER,
+    error TEXT,
+    PRIMARY KEY(peer, sequence)
+);
+
+CREATE TABLE IF NOT EXISTS vineyard_discovered_peers(
+    signer BLOB,
+    url TEXT,
+    discovered_at INTEGER,
+    PRIMARY KEY(signer, url)
+) WITHOUT ROWID;
+
+CREATE INDEX IF NOT EXISTS vineyard_retries_due
+ON vineyard_retries(peer, retry_at, sequence);
+
+CREATE INDEX IF NOT EXISTS vineyard_discovered_urls
+ON vineyard_discovered_peers(url);
+
+CREATE TRIGGER IF NOT EXISTS vineyard_delivery_after_insert
+AFTER INSERT ON events
+BEGIN
+    INSERT OR IGNORE INTO vineyard_delivery(event_id) VALUES (NEW.id);
+END;
+
+";
+
+const BACKFILL_DELIVERY: &str = "
+INSERT INTO vineyard_delivery(event_id)
+SELECT event.id
+FROM events AS event
+LEFT JOIN vineyard_delivery AS delivery ON delivery.event_id = event.id
+WHERE delivery.event_id IS NULL
+ORDER BY
+    CASE WHEN event.kind = 30617 THEN 0 ELSE 1 END,
+    event.created_at,
+    event.id
+";
+
+const DISCOVERED_RELAY_TAGS: &str = "
+SELECT event.pubkey, json_extract(tag.value, '$[1]'), event.created_at
+FROM events AS event, json_each(event.tags) AS tag
+WHERE event.kind = 10002
+  AND json_extract(tag.value, '$[0]') = 'r'
+  AND typeof(json_extract(tag.value, '$[1]')) = 'text'
+ORDER BY event.created_at DESC, event.id
+";
+
+const DUE_DELIVERIES: &str = "
+SELECT delivery.sequence, delivery.event_id
+FROM vineyard_delivery AS delivery
+JOIN vineyard_retries AS retry ON retry.sequence = delivery.sequence
+WHERE retry.peer = ?1 AND retry.retry_at <= ?2
+ORDER BY delivery.sequence
+LIMIT ?3
+";
+
+const NEW_DELIVERIES: &str = "
+SELECT sequence, event_id
+FROM vineyard_delivery
+WHERE sequence > ?1
+ORDER BY sequence
+LIMIT ?2
+";
+
+const REPOSITORIES: &str = "
+SELECT lower(hex(event.pubkey)), tag.tag_value, event.tags
+FROM events AS event
+JOIN event_tags AS tag ON event.id = tag.event_id
+WHERE event.kind = 30617 AND tag.tag_name = 'd'
+ORDER BY 1, 2, event.created_at DESC, event.id
+";
+
+type Delivery = (u64, EventId);
+
+#[derive(Debug, Clone)]
+pub struct Journal {
+    connection: Arc<Mutex<Connection>>,
+    writes: Arc<Mutex<()>>,
+}
+
+struct StoredEvent {
+    id: Vec<u8>,
+    pubkey: Vec<u8>,
+    created_at: i64,
+    kind: i64,
+    content: String,
+    tags: String,
+    signature: Vec<u8>,
+}
+
+impl Journal {
+    pub async fn open(
+        path: PathBuf,
+        max_database_bytes: u64,
+        max_discovered_peers: usize,
+        excluded_peers: Vec<String>,
+        writes: Arc<Mutex<()>>,
+    ) -> Result<Self> {
+        let connection = spawn_blocking(move || {
+            open_connection(
+                &path,
+                max_database_bytes,
+                max_discovered_peers,
+                &excluded_peers,
+            )
+        })
+        .await
+        .context("journal task panicked")??;
+
+        Ok(Self {
+            connection: Arc::new(Mutex::new(connection)),
+            writes,
+        })
+    }
+
+    pub async fn pending(&self, peer: &str, limit: usize) -> Result<Vec<Delivery>> {
+        let peer_url = peer.to_owned();
+        self.run(move |connection| pending_deliveries(connection, &peer_url, limit))
+            .await
+    }
+
+    pub async fn acknowledge(&self, peer: &str, sequence: u64) -> Result<()> {
+        let peer_url = peer.to_owned();
+        self.write(move |connection| acknowledge_delivery(connection, &peer_url, sequence))
+            .await
+    }
+
+    pub async fn defer(&self, peer: &str, sequence: u64, error: &str, retry_at: u64) -> Result<()> {
+        let peer_url = peer.to_owned();
+        let message = error.chars().take(512).collect::<String>();
+        self.write(move |connection| {
+            defer_delivery(connection, &peer_url, sequence, &message, retry_at)
+        })
+        .await
+    }
+
+    pub async fn checkpoint(&self, peer: &str, scope: &str) -> Result<Option<u64>> {
+        let peer_url = peer.to_owned();
+        let scope_name = scope.to_owned();
+        self.run(move |connection| read_checkpoint(connection, &peer_url, &scope_name))
+            .await
+    }
+
+    pub async fn advance(&self, peer: &str, scope: &str, until: u64) -> Result<()> {
+        let peer_url = peer.to_owned();
+        let scope_name = scope.to_owned();
+        self.write(move |connection| write_checkpoint(connection, &peer_url, &scope_name, until))
+            .await
+    }
+
+    pub async fn repositories(&self, limit: usize) -> Result<Vec<(String, String)>> {
+        self.run(move |connection| list_repositories(connection, limit))
+            .await
+    }
+
+    pub async fn healthy(&self) -> bool {
+        self.run(|connection| Ok(connection.query_row("SELECT 1", [], |_| Ok(()))?))
+            .await
+            .is_ok()
+    }
+
+    pub async fn save_locked(
+        &self,
+        event: Event,
+        _write: &MutexGuard<'_, ()>,
+    ) -> Result<SaveEventStatus> {
+        self.run(move |connection| save_event(connection, &event))
+            .await
+    }
+
+    pub async fn status(&self, event_id: EventId) -> Result<DatabaseEventStatus> {
+        self.run(move |connection| event_status(connection, &event_id))
+            .await
+    }
+
+    pub async fn event(&self, event_id: EventId) -> Result<Option<Event>> {
+        self.run(move |connection| event_by_id(connection, &event_id))
+            .await
+    }
+
+    pub async fn count(&self, filter: Filter) -> Result<usize> {
+        self.run(move |connection| Ok(query_events(connection, &filter, usize::MAX)?.len()))
+            .await
+    }
+
+    pub async fn query(&self, filter: Filter, max_bytes: usize) -> Result<BTreeSet<Event>> {
+        self.run(move |connection| query_events(connection, &filter, max_bytes))
+            .await
+    }
+
+    pub async fn replace_discovered_locked(
+        &self,
+        signer: PublicKey,
+        urls: Vec<String>,
+        max: usize,
+        _write: &MutexGuard<'_, ()>,
+    ) -> Result<()> {
+        let signer_bytes = signer.as_bytes().to_vec();
+        self.run(move |connection| replace_discovered(connection, &signer_bytes, urls, max))
+            .await
+    }
+
+    pub async fn discovered(&self, limit: usize) -> Result<Vec<String>> {
+        self.run(move |connection| list_discovered(connection, limit))
+            .await
+    }
+
+    pub async fn forget_discovered(&self, urls: Vec<String>) -> Result<()> {
+        self.write(move |connection| forget_discovered(connection, urls))
+            .await
+    }
+
+    async fn write<T, F>(&self, operation: F) -> Result<T>
+    where
+        T: Send + 'static,
+        F: FnOnce(&mut Connection) -> Result<T> + Send + 'static,
+    {
+        let _write = self.writes.lock().await;
+        self.run(operation).await
+    }
+
+    async fn run<T, F>(&self, operation: F) -> Result<T>
+    where
+        T: Send + 'static,
+        F: FnOnce(&mut Connection) -> Result<T> + Send + 'static,
+    {
+        let shared_connection = Arc::clone(&self.connection);
+        let mut connection = shared_connection.lock_owned().await;
+        spawn_blocking(move || operation(&mut connection))
+            .await
+            .context("journal task panicked")?
+    }
+}
+
+fn open_connection(
+    path: &Path,
+    max_database_bytes: u64,
+    max_discovered_peers: usize,
+    excluded_peers: &[String],
+) -> Result<Connection> {
+    let mut connection =
+        Connection::open(path).with_context(|| format!("opening journal {}", path.display()))?;
+    configure(&connection, max_database_bytes)?;
+    migrate(&mut connection, max_discovered_peers, excluded_peers)?;
+    Ok(connection)
+}
+
+fn pending_deliveries(connection: &Connection, peer: &str, limit: usize) -> Result<Vec<Delivery>> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+
+    let retry_limit = limit / 2;
+    let mut pending = if retry_limit == 0 {
+        Vec::new()
+    } else {
+        read_deliveries(
+            connection,
+            DUE_DELIVERIES,
+            params![peer, unix_seconds(), integer(retry_limit)?],
+        )?
+    };
+
+    let remaining = limit - pending.len();
+    if remaining == 0 {
+        return Ok(pending);
+    }
+
+    let delivered = read_delivered(connection, peer)?;
+    pending.extend(read_deliveries(
+        connection,
+        NEW_DELIVERIES,
+        params![delivered, integer(remaining)?],
+    )?);
+    Ok(pending)
+}
+
+fn read_deliveries<P>(connection: &Connection, sql: &str, parameters: P) -> Result<Vec<Delivery>>
+where
+    P: Params,
+{
+    let mut statement = connection.prepare(sql)?;
+    let mut rows = statement.query(parameters)?;
+    let mut deliveries = Vec::new();
+
+    while let Some(row) = rows.next()? {
+        let sequence = row.get::<_, i64>(0)?;
+        let event_id = row.get::<_, Vec<u8>>(1)?;
+        deliveries.push((
+            u64::try_from(sequence).context("negative delivery sequence")?,
+            EventId::from_slice(&event_id)
+                .map_err(|error| anyhow::anyhow!("invalid event id {error}"))?,
+        ));
+    }
+
+    Ok(deliveries)
+}
+
+fn read_delivered(connection: &Connection, peer: &str) -> Result<i64> {
+    Ok(connection
+        .query_row(
+            "SELECT delivered FROM vineyard_peers WHERE peer = ?1",
+            [peer],
+            |row| row.get(0),
+        )
+        .optional()?
+        .unwrap_or(0))
+}
+
+fn acknowledge_delivery(connection: &mut Connection, peer: &str, sequence: u64) -> Result<()> {
+    let stored_sequence = integer(sequence)?;
+    let transaction = connection.transaction()?;
+    transaction.execute(
+        "DELETE FROM vineyard_retries WHERE peer = ?1 AND sequence = ?2",
+        params![peer, stored_sequence],
+    )?;
+    advance_delivery(&transaction, peer, stored_sequence)?;
+    transaction.commit()?;
+    Ok(())
+}
+
+fn defer_delivery(
+    connection: &mut Connection,
+    peer: &str,
+    sequence: u64,
+    error: &str,
+    retry_at: u64,
+) -> Result<()> {
+    let stored_sequence = integer(sequence)?;
+    let stored_retry_at = integer(retry_at)?;
+    let transaction = connection.transaction()?;
+    advance_delivery(&transaction, peer, stored_sequence)?;
+    transaction.execute(
+        "
+            INSERT INTO vineyard_retries(peer, sequence, retry_at, error)
+            VALUES (?1, ?2, ?3, ?4)
+            ON CONFLICT(peer, sequence) DO UPDATE SET
+                retry_at = excluded.retry_at,
+                error = excluded.error
+            ",
+        params![peer, stored_sequence, stored_retry_at, error],
+    )?;
+    transaction.commit()?;
+    Ok(())
+}
+
+fn read_checkpoint(connection: &Connection, peer: &str, scope: &str) -> Result<Option<u64>> {
+    let checkpoint = connection
+        .query_row(
+            "SELECT until FROM vineyard_checkpoints WHERE peer = ?1 AND scope = ?2",
+            params![peer, scope],
+            |row| row.get::<_, i64>(0),
+        )
+        .optional()?;
+
+    checkpoint
+        .map(|value| u64::try_from(value).context("negative checkpoint"))
+        .transpose()
+}
+
+fn write_checkpoint(connection: &Connection, peer: &str, scope: &str, until: u64) -> Result<()> {
+    connection.execute(
+        "
+            INSERT INTO vineyard_checkpoints(peer, scope, until)
+            VALUES (?1, ?2, ?3)
+            ON CONFLICT(peer, scope) DO UPDATE SET
+                until = max(vineyard_checkpoints.until, excluded.until)
+            ",
+        params![peer, scope, integer(until)?],
+    )?;
+    Ok(())
+}
+
+fn list_repositories(connection: &Connection, limit: usize) -> Result<Vec<(String, String)>> {
+    let mut statement = connection.prepare(REPOSITORIES)?;
+    let mut rows = statement.query([])?;
+    let mut repositories = Vec::new();
+    let mut seen = BTreeSet::new();
+    while let Some(row) = rows.next()? {
+        let tags = serde_json::from_str::<Tags>(&row.get::<_, String>(2)?)?;
+        if tags
+            .expiration()
+            .is_some_and(|expiration| expiration < Timestamp::now())
+        {
+            continue;
+        }
+        let repository = (row.get(0)?, row.get(1)?);
+        if !seen.insert(repository.clone()) {
+            continue;
+        }
+        repositories.push(repository);
+        if repositories.len() == limit {
+            break;
+        }
+    }
+    Ok(repositories)
+}
+
+fn event_status(connection: &Connection, event_id: &EventId) -> Result<DatabaseEventStatus> {
+    let deleted = connection.query_row(
+        "SELECT EXISTS(SELECT 1 FROM deleted_ids WHERE event_id = ?1)",
+        [event_id.as_bytes().as_slice()],
+        |row| row.get::<_, bool>(0),
+    )?;
+    if deleted {
+        return Ok(DatabaseEventStatus::Deleted);
+    }
+    let saved = connection.query_row(
+        "SELECT EXISTS(SELECT 1 FROM events WHERE id = ?1)",
+        [event_id.as_bytes().as_slice()],
+        |row| row.get::<_, bool>(0),
+    )?;
+    Ok(if saved {
+        DatabaseEventStatus::Saved
+    } else {
+        DatabaseEventStatus::NotExistent
+    })
+}
+
+fn event_by_id(connection: &Connection, event_id: &EventId) -> Result<Option<Event>> {
+    connection
+        .query_row(
+            "
+            SELECT id, pubkey, created_at, kind, content, tags, sig
+            FROM events
+            WHERE id = ?1
+            ",
+            [event_id.as_bytes().as_slice()],
+            StoredEvent::read,
+        )
+        .optional()?
+        .map(StoredEvent::into_event)
+        .transpose()
+}
+
+fn save_event(connection: &mut Connection, event: &Event) -> Result<SaveEventStatus> {
+    if event.kind.is_ephemeral() {
+        return Ok(SaveEventStatus::Rejected(RejectedReason::Ephemeral));
+    }
+
+    let transaction = connection.transaction()?;
+    if event_exists(&transaction, &event.id)? {
+        return Ok(SaveEventStatus::Rejected(RejectedReason::Duplicate));
+    }
+    if event_deleted(&transaction, &event.id)? || coordinate_deleted(&transaction, event)? {
+        return Ok(SaveEventStatus::Rejected(RejectedReason::Deleted));
+    }
+    if replacement_rejected(&transaction, event)? {
+        return Ok(SaveEventStatus::Rejected(RejectedReason::Replaced));
+    }
+    if event.kind == Kind::EventDeletion && !apply_deletion(&transaction, event)? {
+        return Ok(SaveEventStatus::Rejected(RejectedReason::InvalidDelete));
+    }
+
+    transaction.execute(
+        "
+        INSERT INTO events(id, pubkey, created_at, kind, content, tags, sig)
+        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+        ",
+        params![
+            event.id.as_bytes().as_slice(),
+            event.pubkey.as_bytes().as_slice(),
+            integer(event.created_at.as_secs())?,
+            i64::from(event.kind.as_u16()),
+            &event.content,
+            serde_json::to_string(&event.tags)?,
+            event.sig.as_bytes().as_slice(),
+        ],
+    )?;
+    for tag in event.tags.iter() {
+        let (Some(name), Some(value)) = (tag.single_letter_tag(), tag.content()) else {
+            continue;
+        };
+        transaction.execute(
+            "
+            INSERT OR IGNORE INTO event_tags(event_id, tag_name, tag_value)
+            VALUES (?1, ?2, ?3)
+            ",
+            params![event.id.as_bytes().as_slice(), name.to_string(), value],
+        )?;
+    }
+    transaction.commit()?;
+    Ok(SaveEventStatus::Success)
+}
+
+fn event_exists(transaction: &Transaction<'_>, event_id: &EventId) -> Result<bool> {
+    Ok(transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM events WHERE id = ?1)",
+        [event_id.as_bytes().as_slice()],
+        |row| row.get(0),
+    )?)
+}
+
+fn event_deleted(transaction: &Transaction<'_>, event_id: &EventId) -> Result<bool> {
+    Ok(transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM deleted_ids WHERE event_id = ?1)",
+        [event_id.as_bytes().as_slice()],
+        |row| row.get(0),
+    )?)
+}
+
+fn coordinate_deleted(transaction: &Transaction<'_>, event: &Event) -> Result<bool> {
+    let Some(coordinate) = event.coordinate() else {
+        return Ok(false);
+    };
+    let deleted_at = transaction
+        .query_row(
+            "
+            SELECT deleted_at
+            FROM deleted_coordinates
+            WHERE pubkey = ?1 AND kind = ?2 AND identifier = ?3
+            ",
+            params![
+                coordinate.public_key.as_bytes().as_slice(),
+                i64::from(coordinate.kind.as_u16()),
+                coordinate.identifier,
+            ],
+            |row| row.get::<_, i64>(0),
+        )
+        .optional()?;
+    Ok(deleted_at.is_some_and(|stored_deleted_at| {
+        u64::try_from(stored_deleted_at).map_or(true, |value| event.created_at.as_secs() <= value)
+    }))
+}
+
+fn replacement_rejected(transaction: &Transaction<'_>, event: &Event) -> Result<bool> {
+    let existing = if event.kind.is_replaceable() {
+        transaction
+            .query_row(
+                "
+                SELECT id, created_at
+                FROM events
+                WHERE pubkey = ?1 AND kind = ?2
+                LIMIT 1
+                ",
+                params![
+                    event.pubkey.as_bytes().as_slice(),
+                    i64::from(event.kind.as_u16()),
+                ],
+                |row| Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, i64>(1)?)),
+            )
+            .optional()?
+    } else if event.kind.is_addressable() {
+        let Some(identifier) = event.tags.identifier() else {
+            return Ok(false);
+        };
+        transaction
+            .query_row(
+                "
+                SELECT event.id, event.created_at
+                FROM events AS event
+                JOIN event_tags AS tag ON tag.event_id = event.id
+                WHERE event.pubkey = ?1
+                  AND event.kind = ?2
+                  AND tag.tag_name = 'd'
+                  AND tag.tag_value = ?3
+                LIMIT 1
+                ",
+                params![
+                    event.pubkey.as_bytes().as_slice(),
+                    i64::from(event.kind.as_u16()),
+                    identifier,
+                ],
+                |row| Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, i64>(1)?)),
+            )
+            .optional()?
+    } else {
+        return Ok(false);
+    };
+
+    let Some((stored_id, stored_at)) = existing else {
+        return Ok(false);
+    };
+    let incoming_at = integer(event.created_at.as_secs())?;
+    match stored_at.cmp(&incoming_at) {
+        Ordering::Greater => Ok(true),
+        Ordering::Equal if stored_id.as_slice() < event.id.as_bytes().as_slice() => Ok(true),
+        Ordering::Equal | Ordering::Less => {
+            transaction.execute("DELETE FROM events WHERE id = ?1", [stored_id])?;
+            Ok(false)
+        }
+    }
+}
+
+fn apply_deletion(transaction: &Transaction<'_>, event: &Event) -> Result<bool> {
+    for event_id in event.tags.event_ids() {
+        let owner = transaction
+            .query_row(
+                "SELECT pubkey FROM events WHERE id = ?1",
+                [event_id.as_bytes().as_slice()],
+                |row| row.get::<_, Vec<u8>>(0),
+            )
+            .optional()?;
+        if owner.is_some_and(|saved_owner| saved_owner.as_slice() != event.pubkey.as_bytes()) {
+            return Ok(false);
+        }
+        transaction.execute(
+            "INSERT OR IGNORE INTO deleted_ids(event_id) VALUES (?1)",
+            [event_id.as_bytes().as_slice()],
+        )?;
+        transaction.execute(
+            "DELETE FROM events WHERE id = ?1 AND pubkey = ?2",
+            params![
+                event_id.as_bytes().as_slice(),
+                event.pubkey.as_bytes().as_slice(),
+            ],
+        )?;
+    }
+
+    for coordinate in event.tags.coordinates() {
+        if coordinate.public_key != event.pubkey {
+            return Ok(false);
+        }
+        transaction.execute(
+            "
+            INSERT INTO deleted_coordinates(pubkey, kind, identifier, deleted_at)
+            VALUES (?1, ?2, ?3, ?4)
+            ON CONFLICT(pubkey, kind, identifier) DO UPDATE SET
+                deleted_at = max(deleted_coordinates.deleted_at, excluded.deleted_at)
+            ",
+            params![
+                coordinate.public_key.as_bytes().as_slice(),
+                i64::from(coordinate.kind.as_u16()),
+                &coordinate.identifier,
+                integer(event.created_at.as_secs())?,
+            ],
+        )?;
+        if coordinate.kind.is_replaceable() {
+            transaction.execute(
+                "
+                DELETE FROM events
+                WHERE pubkey = ?1 AND kind = ?2 AND created_at <= ?3
+                ",
+                params![
+                    coordinate.public_key.as_bytes().as_slice(),
+                    i64::from(coordinate.kind.as_u16()),
+                    integer(event.created_at.as_secs())?,
+                ],
+            )?;
+        } else {
+            transaction.execute(
+                "
+                DELETE FROM events
+                WHERE id IN (
+                    SELECT stored.id
+                    FROM events AS stored
+                    JOIN event_tags AS tag ON tag.event_id = stored.id
+                    WHERE stored.pubkey = ?1
+                      AND stored.kind = ?2
+                      AND stored.created_at <= ?3
+                      AND tag.tag_name = 'd'
+                      AND tag.tag_value = ?4
+                )
+                ",
+                params![
+                    coordinate.public_key.as_bytes().as_slice(),
+                    i64::from(coordinate.kind.as_u16()),
+                    integer(event.created_at.as_secs())?,
+                    &coordinate.identifier,
+                ],
+            )?;
+        }
+    }
+    Ok(true)
+}
+
+fn query_events(
+    connection: &Connection,
+    filter: &Filter,
+    max_bytes: usize,
+) -> Result<BTreeSet<Event>> {
+    let query = EventQuery::new(filter)?;
+    if query.limit == 0 {
+        return Ok(BTreeSet::new());
+    }
+    let mut statement = connection.prepare(&query.sql)?;
+    let mut rows = statement.query(params_from_iter(query.parameters))?;
+    let mut events = BTreeSet::new();
+    let mut bytes = 0_usize;
+
+    while let Some(row) = rows.next()? {
+        let event = StoredEvent::read(row)?.into_event()?;
+        if event.is_expired() {
+            continue;
+        }
+        bytes = bytes
+            .checked_add(event.as_json().len())
+            .context("history byte count overflow")?;
+        if bytes > max_bytes {
+            anyhow::bail!("history byte limit exceeded");
+        }
+        events.insert(event);
+        if events.len() == query.limit {
+            break;
+        }
+    }
+
+    Ok(events)
+}
+
+fn replace_discovered(
+    connection: &mut Connection,
+    signer: &[u8],
+    urls: Vec<String>,
+    max: usize,
+) -> Result<()> {
+    let transaction = connection.transaction()?;
+    transaction.execute(
+        "DELETE FROM vineyard_discovered_peers WHERE signer = ?1",
+        [signer],
+    )?;
+    let stored_count = transaction.query_row(
+        "SELECT count(DISTINCT url) FROM vineyard_discovered_peers",
+        [],
+        |row| row.get::<_, i64>(0),
+    )?;
+    let count = usize::try_from(stored_count).context("negative discovered peer count")?;
+
+    for url in urls.into_iter().take(max.saturating_sub(count)) {
+        transaction.execute(
+            "
+                INSERT OR IGNORE INTO vineyard_discovered_peers(signer, url, discovered_at)
+                VALUES (?1, ?2, unixepoch())
+                ",
+            params![signer, url],
+        )?;
+    }
+
+    transaction.commit()?;
+    Ok(())
+}
+
+fn list_discovered(connection: &Connection, limit: usize) -> Result<Vec<String>> {
+    let mut statement = connection
+        .prepare("SELECT DISTINCT url FROM vineyard_discovered_peers ORDER BY url LIMIT ?1")?;
+    let mut rows = statement.query([integer(limit)?])?;
+    let mut urls = Vec::new();
+    while let Some(row) = rows.next()? {
+        urls.push(row.get(0)?);
+    }
+    Ok(urls)
+}
+
+fn forget_discovered(connection: &mut Connection, urls: Vec<String>) -> Result<()> {
+    let transaction = connection.transaction()?;
+    for url in urls {
+        transaction.execute(
+            "DELETE FROM vineyard_discovered_peers WHERE url = ?1",
+            [url],
+        )?;
+    }
+    transaction.commit()?;
+    Ok(())
+}
+
+impl StoredEvent {
+    fn read(row: &Row<'_>) -> rusqlite::Result<Self> {
+        Ok(Self {
+            id: row.get(0)?,
+            pubkey: row.get(1)?,
+            created_at: row.get(2)?,
+            kind: row.get(3)?,
+            content: row.get(4)?,
+            tags: row.get(5)?,
+            signature: row.get(6)?,
+        })
+    }
+
+    fn into_event(self) -> Result<Event> {
+        let id = EventId::from_slice(&self.id).context("invalid stored event id")?;
+        let pubkey = PublicKey::from_slice(&self.pubkey).context("invalid stored public key")?;
+        let created_at: Timestamp = self
+            .created_at
+            .try_into()
+            .context("invalid event timestamp")?;
+        let kind = Kind::from_u16(self.kind.try_into().context("invalid stored event kind")?);
+        let tags: Tags = serde_json::from_str(&self.tags).context("invalid stored event tags")?;
+        let signature =
+            Signature::from_slice(&self.signature).context("invalid stored event signature")?;
+        Ok(Event::new(
+            id,
+            pubkey,
+            created_at,
+            kind,
+            tags,
+            self.content,
+            signature,
+        ))
+    }
+}
+
+fn configure(connection: &Connection, max_database_bytes: u64) -> Result<()> {
+    connection.busy_timeout(Duration::from_secs(5))?;
+    connection.pragma_update(None, "journal_mode", "WAL")?;
+    let journal_mode: String =
+        connection.pragma_query_value(None, "journal_mode", |row| row.get(0))?;
+    if !journal_mode.eq_ignore_ascii_case("wal") {
+        anyhow::bail!("journal mode is not wal");
+    }
+
+    connection.pragma_update(None, "synchronous", "FULL")?;
+    connection.pragma_update(None, "foreign_keys", "ON")?;
+
+    let stored_page_size =
+        connection.query_row("PRAGMA page_size", [], |row| row.get::<_, i64>(0))?;
+    let page_size = u64::try_from(stored_page_size).context("invalid database page size")?;
+    let page_budget = max_database_bytes / page_size;
+    if page_budget == 0 {
+        anyhow::bail!("database budget is smaller than one page");
+    }
+    let max_pages = integer(page_budget)?;
+    let page_count = connection.query_row("PRAGMA page_count", [], |row| row.get::<_, i64>(0))?;
+    if page_count > max_pages {
+        anyhow::bail!("database exceeds size budget");
+    }
+    connection.pragma_update(None, "max_page_count", max_pages)?;
+    Ok(())
+}
+
+fn migrate(
+    connection: &mut Connection,
+    max_discovered_peers: usize,
+    excluded_peers: &[String],
+) -> Result<()> {
+    let transaction = connection.transaction()?;
+    migrate_legacy_tables(&transaction)?;
+    transaction.execute_batch(SCHEMA)?;
+    transaction.execute(BACKFILL_DELIVERY, [])?;
+    transaction.commit()?;
+    backfill_discovered(connection, max_discovered_peers, excluded_peers)?;
+    Ok(())
+}
+
+fn migrate_legacy_tables(transaction: &Transaction<'_>) -> Result<()> {
+    for (old, new) in [
+        ("sanctum_delivery", "vineyard_delivery"),
+        ("sanctum_peers", "vineyard_peers"),
+        ("sanctum_checkpoints", "vineyard_checkpoints"),
+        ("sanctum_retries", "vineyard_retries"),
+        ("sanctum_discovered_peers", "vineyard_discovered_peers"),
+    ] {
+        let old_exists = table_exists(transaction, old)?;
+        let new_exists = table_exists(transaction, new)?;
+        if old_exists && new_exists {
+            anyhow::bail!("database contains both {old} and {new}");
+        }
+        if old_exists {
+            transaction.execute_batch(&format!("ALTER TABLE {old} RENAME TO {new}"))?;
+        }
+    }
+    transaction.execute_batch(
+        "
+        DROP TRIGGER IF EXISTS sanctum_delivery_after_insert;
+        DROP INDEX IF EXISTS sanctum_retries_due;
+        DROP INDEX IF EXISTS sanctum_discovered_urls;
+        ",
+    )?;
+    Ok(())
+}
+
+fn table_exists(transaction: &Transaction<'_>, name: &str) -> Result<bool> {
+    Ok(transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?1)",
+        [name],
+        |row| row.get(0),
+    )?)
+}
+
+fn backfill_discovered(
+    connection: &mut Connection,
+    max_discovered_peers: usize,
+    excluded_peers: &[String],
+) -> Result<()> {
+    let excluded = excluded_peers.iter().cloned().collect::<HashSet<_>>();
+    let relay_tags = {
+        let mut statement = connection.prepare(DISCOVERED_RELAY_TAGS)?;
+        let mut rows = statement.query([])?;
+        let mut relay_tags = Vec::new();
+        while let Some(row) = rows.next()? {
+            relay_tags.push((
+                row.get::<_, Vec<u8>>(0)?,
+                row.get::<_, String>(1)?,
+                row.get::<_, i64>(2)?,
+            ));
+        }
+        relay_tags
+    };
+
+    let transaction = connection.transaction()?;
+    transaction.execute("DELETE FROM vineyard_discovered_peers", [])?;
+    let mut urls = HashSet::new();
+    for (signer, raw_url, discovered_at) in relay_tags {
+        let Some(url) = relay_url(&raw_url).map(|url| url.to_string()) else {
+            continue;
+        };
+        if excluded.contains(&url) || (!urls.contains(&url) && urls.len() >= max_discovered_peers) {
+            continue;
+        }
+        urls.insert(url.clone());
+        transaction.execute(
+            "
+            INSERT OR IGNORE INTO vineyard_discovered_peers(signer, url, discovered_at)
+            VALUES (?1, ?2, ?3)
+            ",
+            params![signer, url, discovered_at],
+        )?;
+    }
+    transaction.commit()?;
+    Ok(())
+}
+
+fn advance_delivery(transaction: &Transaction<'_>, peer: &str, sequence: i64) -> Result<()> {
+    transaction.execute(
+        "
+        INSERT INTO vineyard_peers(peer, delivered)
+        VALUES (?1, ?2)
+        ON CONFLICT(peer) DO UPDATE SET
+            delivered = max(vineyard_peers.delivered, excluded.delivered)
+        ",
+        params![peer, sequence],
+    )?;
+    Ok(())
+}
+
+fn integer<T>(value: T) -> Result<i64>
+where
+    T: TryInto<i64>,
+    T::Error: Error + Send + Sync + 'static,
+{
+    value
+        .try_into()
+        .context("value exceeds sqlite integer range")
+}
+
+fn unix_seconds() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |duration| {
+            i64::try_from(duration.as_secs()).unwrap_or(i64::MAX)
+        })
+}

Added file: src/lib.rs+8

@@ -0,0 +1,8 @@

1+pub mod config;

2+mod federation;

3+mod journal;

4+pub mod policy;

5+mod query;

6+mod relay;

7+pub mod server;

8+pub mod store;

Added file: src/main.rs+61 additions@@ -0,0 +1,61 @@
+use std::io::{Write as _, stdout};
+use std::path::PathBuf;
+
+use anyhow::Context as _;
+use clap::{Parser, Subcommand};
+use tokio::signal::ctrl_c;
+#[cfg(unix)]
+use tokio::signal::unix::{SignalKind, signal};
+use vineyard::config::Config;
+use vineyard::server::spawn;
+
+#[derive(Parser)]
+#[command(version, about = "a persistent nostr relay for git forges")]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    Serve {
+        #[arg(long, default_value = "vineyard.toml")]
+        config: PathBuf,
+    },
+    CheckConfig {
+        #[arg(long, default_value = "vineyard.toml")]
+        config: PathBuf,
+    },
+}
+
+#[tokio::main(worker_threads = 2)]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "vineyard=info".into()),
+        )
+        .init();
+    match Cli::parse().command {
+        Command::CheckConfig { config } => {
+            Config::load(&config)?;
+            writeln!(stdout().lock(), "configuration is valid")?;
+        }
+        Command::Serve { config } => {
+            let relay = spawn(Config::load(&config)?).await?;
+            #[cfg(unix)]
+            {
+                let mut terminate =
+                    signal(SignalKind::terminate()).context("installing termination handler")?;
+                tokio::select! {
+                    result = ctrl_c() => result?,
+                    _ = terminate.recv() => {},
+                }
+            }
+            #[cfg(not(unix))]
+            ctrl_c().await?;
+            relay.shutdown().await?;
+        }
+    }
+    Ok(())
+}

Added file: src/policy.rs+450 additions@@ -0,0 +1,450 @@
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
+use std::net::{IpAddr, SocketAddr};
+use std::sync::{Arc, Mutex, PoisonError};
+use std::time::{Duration, Instant};
+
+use nostr::event::{Event, EventId, Kind};
+use nostr::filter::Filter;
+use nostr::key::PublicKey;
+use nostr::message::MachineReadablePrefix;
+use nostr::nips::nip65::extract_relay_list;
+use nostr::types::Timestamp;
+use nostr_database::{DatabaseEventStatus, NostrDatabase, error::Error};
+use serde::Deserialize;
+
+use crate::config::{Config, Limits};
+
+#[derive(Debug)]
+struct Usage {
+    window: Instant,
+    events: u32,
+    queries: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct Policy {
+    database: Arc<dyn NostrDatabase>,
+    limits: Limits,
+    forge_keys: HashSet<PublicKey>,
+    peers: Arc<Mutex<HashMap<IpAddr, Usage>>>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Binding {
+    version: u64,
+    action: String,
+    fingerprint: String,
+    certificate: Option<String>,
+    signature: Option<String>,
+}
+
+pub(crate) enum WritePolicyResult {
+    Accept,
+    Respond {
+        prefix: MachineReadablePrefix,
+        message: Cow<'static, str>,
+        status: bool,
+    },
+}
+
+impl WritePolicyResult {
+    const fn accepted(prefix: MachineReadablePrefix, message: &'static str) -> Self {
+        Self::Respond {
+            prefix,
+            message: Cow::Borrowed(message),
+            status: true,
+        }
+    }
+
+    const fn reject(prefix: MachineReadablePrefix, message: &'static str) -> Self {
+        Self::Respond {
+            prefix,
+            message: Cow::Borrowed(message),
+            status: false,
+        }
+    }
+}
+
+pub(crate) enum QueryPolicyResult {
+    Accept,
+    Reject {
+        prefix: MachineReadablePrefix,
+        message: Cow<'static, str>,
+    },
+}
+
+impl QueryPolicyResult {
+    const fn reject(prefix: MachineReadablePrefix, message: &'static str) -> Self {
+        Self::Reject {
+            prefix,
+            message: Cow::Borrowed(message),
+        }
+    }
+}
+
+impl Policy {
+    pub fn new(database: Arc<dyn NostrDatabase>, config: &Config) -> anyhow::Result<Self> {
+        config.validate()?;
+        Ok(Self {
+            database,
+            limits: config.limits.clone(),
+            forge_keys: config.forge_keys()?,
+            peers: Arc::new(Mutex::new(HashMap::new())),
+        })
+    }
+
+    fn charge(&self, ip: IpAddr, publish: bool) -> bool {
+        let mut peers = self.peers.lock().unwrap_or_else(PoisonError::into_inner);
+        peers.retain(|_, usage| usage.window.elapsed() < Duration::from_secs(60));
+        if peers.len() >= 4096 && !peers.contains_key(&ip) {
+            return false;
+        }
+        let usage = peers.entry(ip).or_insert_with(|| Usage {
+            window: Instant::now(),
+            events: 0,
+            queries: 0,
+        });
+        let (count, limit) = if publish {
+            (&mut usage.events, self.limits.events_per_minute)
+        } else {
+            (&mut usage.queries, self.limits.queries_per_minute)
+        };
+        if *count >= limit {
+            return false;
+        }
+        *count += 1;
+        drop(peers);
+        true
+    }
+
+    pub(crate) async fn admit_event(
+        &self,
+        event: &Event,
+        address: &SocketAddr,
+    ) -> WritePolicyResult {
+        if !self.charge(address.ip(), true) {
+            return WritePolicyResult::reject(
+                MachineReadablePrefix::RateLimited,
+                "publish rate exceeded",
+            );
+        }
+        self.admit(event).await.unwrap_or_else(|error| {
+            tracing::error!(%error, "event admission database failure");
+            WritePolicyResult::reject(MachineReadablePrefix::Error, "database unavailable")
+        })
+    }
+
+    pub(crate) async fn admit_peer(&self, event: &Event) -> WritePolicyResult {
+        match self.admit(event).await {
+            Ok(result) => result,
+            Err(error) => {
+                tracing::error!(%error, "event admission database failure");
+                WritePolicyResult::reject(MachineReadablePrefix::Error, "database unavailable")
+            }
+        }
+    }
+
+    pub(crate) async fn admit_query(
+        &self,
+        filter: &Filter,
+        address: &SocketAddr,
+    ) -> QueryPolicyResult {
+        if !self.charge(address.ip(), false) {
+            return QueryPolicyResult::reject(
+                MachineReadablePrefix::RateLimited,
+                "query rate exceeded",
+            );
+        }
+        if filter.as_json().len() > self.limits.max_filter_bytes {
+            return QueryPolicyResult::reject(
+                MachineReadablePrefix::RateLimited,
+                "filter byte limit exceeded",
+            );
+        }
+        if filter.search.is_some() {
+            return QueryPolicyResult::reject(
+                MachineReadablePrefix::Unsupported,
+                "search is not supported",
+            );
+        }
+        if let Some(limit) = filter.limit {
+            return if limit > self.limits.max_query_results {
+                QueryPolicyResult::reject(
+                    MachineReadablePrefix::RateLimited,
+                    "query result limit exceeded",
+                )
+            } else {
+                QueryPolicyResult::Accept
+            };
+        }
+        match self
+            .database
+            .count(filter.clone().limit(self.limits.max_query_results + 1))
+            .await
+        {
+            Ok(count) if count <= self.limits.max_query_results => QueryPolicyResult::Accept,
+            Ok(_) => QueryPolicyResult::reject(
+                MachineReadablePrefix::RateLimited,
+                "history result limit exceeded",
+            ),
+            Err(error) => {
+                tracing::error!(%error, "query admission database failure");
+                QueryPolicyResult::reject(MachineReadablePrefix::Error, "database unavailable")
+            }
+        }
+    }
+
+    async fn admit(&self, event: &Event) -> Result<WritePolicyResult, Error> {
+        if let Some(result) = self.check_event(event) {
+            return Ok(result);
+        }
+        match self.database.check_id(&event.id).await? {
+            DatabaseEventStatus::Saved => {
+                return Ok(WritePolicyResult::accepted(
+                    MachineReadablePrefix::Duplicate,
+                    "already stored",
+                ));
+            }
+            DatabaseEventStatus::Deleted => return Ok(blocked("event is deleted")),
+            DatabaseEventStatus::NotExistent => {}
+        }
+        self.admit_kind(event).await
+    }
+
+    fn check_event(&self, event: &Event) -> Option<WritePolicyResult> {
+        if event.as_json().len() > self.limits.max_event_bytes
+            || event.tags.len() > self.limits.max_tags
+        {
+            return Some(blocked("event exceeds size or tag limit"));
+        }
+        if event.created_at.as_secs() == 0
+            || event.created_at.as_secs() > Timestamp::now().as_secs().saturating_add(900)
+        {
+            return Some(blocked("event timestamp is outside the supported range"));
+        }
+        if event.is_expired() || event.is_protected() {
+            return Some(blocked("expired or protected events are not accepted"));
+        }
+        None
+    }
+
+    async fn admit_kind(&self, event: &Event) -> Result<WritePolicyResult, Error> {
+        match event.kind.as_u16() {
+            10002 => {
+                if !self.forge_keys.contains(&event.pubkey)
+                    && !self.registered_forge(event.pubkey).await?
+                {
+                    return Ok(blocked("relay list signer has no registered repository"));
+                }
+                let relay_tags = event
+                    .tags
+                    .iter()
+                    .filter(|tag| tag.as_slice().first().is_some_and(|name| name == "r"))
+                    .count();
+                if relay_tags > 16 || extract_relay_list(event).count() != relay_tags {
+                    return Ok(blocked("relay list is invalid or too large"));
+                }
+            }
+            30617 => {
+                let Some(identifier) = identifier(event) else {
+                    return Ok(blocked("one valid repository identifier is required"));
+                };
+                if !self.registered(event.pubkey, identifier).await? {
+                    let count = self
+                        .database
+                        .query(
+                            Filter::new()
+                                .kind(Kind::from(30617))
+                                .limit(self.limits.max_repositories + 1),
+                        )
+                        .await?
+                        .len();
+                    if count >= self.limits.max_repositories {
+                        return Ok(WritePolicyResult::reject(
+                            MachineReadablePrefix::RateLimited,
+                            "repository directory is full",
+                        ));
+                    }
+                }
+            }
+            30618 => {
+                let Some(identifier) = identifier(event) else {
+                    return Ok(blocked("one valid repository identifier is required"));
+                };
+                if !self.registered(event.pubkey, identifier).await? {
+                    return Ok(blocked("repository is not registered"));
+                }
+            }
+            1617 | 1621 | 1630..=1632 => {
+                let mut addresses = 0_usize;
+                for tag in event
+                    .tags
+                    .iter()
+                    .filter(|tag| tag.as_slice().first().is_some_and(|name| name == "a"))
+                {
+                    let Some((kind, author, identifier)) =
+                        tag.as_slice().get(1).and_then(|value| coordinate(value))
+                    else {
+                        return Ok(blocked("invalid repository address"));
+                    };
+                    if kind != 30617 || !self.registered(author, identifier).await? {
+                        return Ok(blocked("repository is not registered"));
+                    }
+                    if matches!(event.kind.as_u16(), 1630..=1632) && author != event.pubkey {
+                        return Ok(blocked("status signer does not own the repository"));
+                    }
+                    addresses += 1;
+                }
+                if addresses != 1 {
+                    return Ok(blocked("exactly one repository address is required"));
+                }
+            }
+            30382 => {
+                if !valid_binding(event) {
+                    return Ok(blocked("invalid openpgp binding envelope"));
+                }
+            }
+            5 => return self.deletion(event).await,
+            _ => {
+                return Ok(WritePolicyResult::reject(
+                    MachineReadablePrefix::Unsupported,
+                    "event kind is not supported",
+                ));
+            }
+        }
+        Ok(WritePolicyResult::Accept)
+    }
+
+    async fn registered(&self, author: PublicKey, identifier: &str) -> Result<bool, Error> {
+        Ok(self
+            .database
+            .query(
+                Filter::new()
+                    .kind(Kind::from(30617))
+                    .author(author)
+                    .identifier(identifier)
+                    .limit(1),
+            )
+            .await?
+            .iter()
+            .any(|event| !event.is_expired()))
+    }
+
+    async fn registered_forge(&self, author: PublicKey) -> Result<bool, Error> {
+        Ok(self
+            .database
+            .query(
+                Filter::new()
+                    .kind(Kind::from(30617))
+                    .author(author)
+                    .limit(1),
+            )
+            .await?
+            .iter()
+            .any(|event| !event.is_expired()))
+    }
+
+    async fn deletion(&self, event: &Event) -> Result<WritePolicyResult, Error> {
+        let mut targets = 0_usize;
+        for tag in event.tags.iter() {
+            let values = tag.as_slice();
+            match values.first().map(String::as_str) {
+                Some("e") => {
+                    let Some(id) = values
+                        .get(1)
+                        .filter(|id| id.len() == 64)
+                        .and_then(|id| id.parse::<EventId>().ok())
+                    else {
+                        return Ok(blocked("invalid deletion target"));
+                    };
+                    if let Some(target) = self.database.event_by_id(&id).await? {
+                        if target.pubkey != event.pubkey || target.kind == Kind::EventDeletion {
+                            return Ok(blocked("deletion target is not removable by this author"));
+                        }
+                    }
+                    targets += 1;
+                }
+                Some("a") => {
+                    let Some((kind, author, _)) = values.get(1).and_then(|value| coordinate(value))
+                    else {
+                        return Ok(blocked("invalid deletion address"));
+                    };
+                    if author != event.pubkey || !matches!(kind, 30617 | 30618 | 30382) {
+                        return Ok(blocked("deletion address is not owned by this author"));
+                    }
+                    targets += 1;
+                }
+                _ => {}
+            }
+        }
+        Ok(if targets == 0 {
+            blocked("deletion target is required")
+        } else {
+            WritePolicyResult::Accept
+        })
+    }
+}
+
+const fn blocked(message: &'static str) -> WritePolicyResult {
+    WritePolicyResult::reject(MachineReadablePrefix::Blocked, message)
+}
+
+fn valid_identifier(identifier: &str) -> bool {
+    !identifier.is_empty() && identifier.len() <= 512 && !identifier.chars().any(char::is_control)
+}
+
+fn identifier(event: &Event) -> Option<&str> {
+    let mut tags = event
+        .tags
+        .iter()
+        .filter(|tag| tag.as_slice().first().is_some_and(|name| name == "d"));
+    let tag = tags.next()?.as_slice();
+    if tags.next().is_some() || tag.len() != 2 || !valid_identifier(&tag[1]) {
+        return None;
+    }
+    Some(&tag[1])
+}
+
+pub(crate) fn coordinate(value: &str) -> Option<(u16, PublicKey, &str)> {
+    let mut parts = value.splitn(3, ':');
+    let kind = parts.next()?.parse().ok()?;
+    let author_hex = parts.next()?;
+    if author_hex.len() != 64 || !author_hex.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+        return None;
+    }
+    let author = author_hex.parse().ok()?;
+    let identifier = parts.next()?;
+    valid_identifier(identifier).then_some((kind, author, identifier))
+}
+
+fn valid_binding(event: &Event) -> bool {
+    if event.content.len() > 192 * 1024 {
+        return false;
+    }
+    let Ok(body) = serde_json::from_str::<Binding>(&event.content) else {
+        return false;
+    };
+    if body.version != 1
+        || !matches!(body.fingerprint.len(), 40 | 64)
+        || !body
+            .fingerprint
+            .bytes()
+            .all(|byte| byte.is_ascii_hexdigit())
+        || identifier(event) != Some(body.fingerprint.as_str())
+    {
+        return false;
+    }
+    match body.action.as_str() {
+        "bind" => {
+            body.certificate
+                .is_some_and(|certificate| !certificate.trim().is_empty())
+                && body
+                    .signature
+                    .is_some_and(|signature| !signature.trim().is_empty())
+        }
+        "revoke" => body.certificate.is_none() && body.signature.is_none(),
+        _ => false,
+    }
+}

Added file: src/query.rs+131 additions@@ -0,0 +1,131 @@
+use anyhow::{Context as _, Result};
+use nostr::filter::Filter;
+use rusqlite::types::Value;
+
+const DEFAULT_LIMIT: usize = 10_000;
+
+const SELECT_EVENTS: &str = "
+SELECT e.id, e.pubkey, e.created_at, e.kind, e.content, e.tags, e.sig
+FROM events AS e
+WHERE 1 = 1
+";
+
+const TAG_VALUES: &str = "
+ AND EXISTS (
+    SELECT 1
+    FROM event_tags AS tag
+    WHERE tag.event_id = e.id
+      AND tag.tag_name = ?
+      AND tag.tag_value IN (
+";
+
+pub struct EventQuery {
+    pub(crate) sql: String,
+    pub(crate) parameters: Vec<Value>,
+    pub(crate) limit: usize,
+}
+
+impl EventQuery {
+    pub(crate) fn new(filter: &Filter) -> Result<Self> {
+        if filter.search.is_some() {
+            anyhow::bail!("search is not supported");
+        }
+
+        let mut query = Self {
+            sql: SELECT_EVENTS.to_owned(),
+            parameters: Vec::new(),
+            limit: filter.limit.unwrap_or(DEFAULT_LIMIT),
+        };
+
+        if let Some(ids) = filter.ids.as_ref() {
+            query.add_values(
+                "e.id",
+                ids.iter()
+                    .map(|id| Value::Blob(id.as_bytes().to_vec()))
+                    .collect(),
+            );
+        }
+        if let Some(authors) = filter.authors.as_ref() {
+            query.add_values(
+                "e.pubkey",
+                authors
+                    .iter()
+                    .map(|author| Value::Blob(author.as_bytes().to_vec()))
+                    .collect(),
+            );
+        }
+        if let Some(kinds) = filter.kinds.as_ref() {
+            query.add_values(
+                "e.kind",
+                kinds
+                    .iter()
+                    .map(|kind| Value::Integer(i64::from(kind.as_u16())))
+                    .collect(),
+            );
+        }
+        if let Some(since) = filter.since {
+            query.add_condition(
+                "e.created_at >= ?",
+                Value::Integer(timestamp(since.as_secs())?),
+            );
+        }
+        if let Some(until) = filter.until {
+            query.add_condition(
+                "e.created_at <= ?",
+                Value::Integer(timestamp(until.as_secs())?),
+            );
+        }
+        for (tag, values) in &filter.generic_tags {
+            if values.is_empty() {
+                query.exclude_all();
+                break;
+            }
+            query.sql.push_str(TAG_VALUES);
+            query.parameters.push(Value::Text(tag.to_string()));
+            query.add_placeholders(values.len());
+            query.sql.push_str("))");
+            query
+                .parameters
+                .extend(values.iter().cloned().map(Value::Text));
+        }
+
+        query.sql.push_str(" ORDER BY e.created_at DESC, e.id");
+        Ok(query)
+    }
+
+    fn add_values(&mut self, column: &str, values: Vec<Value>) {
+        if values.is_empty() {
+            self.exclude_all();
+            return;
+        }
+        self.sql.push_str(" AND ");
+        self.sql.push_str(column);
+        self.sql.push_str(" IN (");
+        self.add_placeholders(values.len());
+        self.sql.push(')');
+        self.parameters.extend(values);
+    }
+
+    fn add_condition(&mut self, condition: &str, value: Value) {
+        self.sql.push_str(" AND ");
+        self.sql.push_str(condition);
+        self.parameters.push(value);
+    }
+
+    fn add_placeholders(&mut self, count: usize) {
+        for index in 0..count {
+            if index > 0 {
+                self.sql.push_str(", ");
+            }
+            self.sql.push('?');
+        }
+    }
+
+    fn exclude_all(&mut self) {
+        self.sql.push_str(" AND 0");
+    }
+}
+
+fn timestamp(value: u64) -> Result<i64> {
+    value.try_into().context("timestamp exceeds sqlite range")
+}

Added file: src/relay.rs+319 additions@@ -0,0 +1,319 @@
+use std::collections::{BTreeSet, HashMap};
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{Context as _, Result};
+use futures_util::{Sink, SinkExt as _, StreamExt as _};
+use nostr::event::Event;
+use nostr::filter::{Filter, MatchEventOptions};
+use nostr_database::{NostrDatabase as _, RejectedReason, SaveEventStatus};
+use serde_json::{Value, json};
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::sync::broadcast;
+use tokio::time::timeout;
+use tokio_tungstenite::WebSocketStream;
+use tokio_tungstenite::tungstenite::{
+    Error as WebSocketError, Message,
+    protocol::{Role, WebSocketConfig},
+};
+use tokio_util::sync::CancellationToken;
+
+use crate::config::Limits;
+use crate::policy::{Policy, QueryPolicyResult, WritePolicyResult};
+use crate::store::Store;
+
+#[derive(Clone)]
+pub struct Relay {
+    store: Arc<Store>,
+    policy: Policy,
+    limits: Limits,
+    events: broadcast::Sender<Event>,
+    stop: CancellationToken,
+}
+
+struct Subscription {
+    filters: Vec<Filter>,
+    bytes: usize,
+}
+
+#[derive(Default)]
+struct Session {
+    subscriptions: HashMap<String, Subscription>,
+}
+
+impl Relay {
+    pub(crate) fn new(
+        store: Arc<Store>,
+        policy: Policy,
+        limits: Limits,
+        stop: CancellationToken,
+    ) -> Self {
+        let (events, _) = broadcast::channel(limits.max_connections.max(32));
+        Self {
+            store,
+            policy,
+            limits,
+            events,
+            stop,
+        }
+    }
+
+    pub(crate) async fn add_event(&self, event: Event) -> Result<SaveEventStatus> {
+        event.verify().context("invalid event")?;
+        let status = self.store.save_event(&event).await?;
+        if status.is_success() {
+            match self.events.send(event) {
+                Ok(_) | Err(_) => {}
+            }
+        }
+        Ok(status)
+    }
+
+    pub(crate) async fn take_connection<S>(&self, stream: S, address: SocketAddr) -> Result<()>
+    where
+        S: AsyncRead + AsyncWrite + Unpin,
+    {
+        let websocket = WebSocketStream::from_raw_socket(
+            stream,
+            Role::Server,
+            Some(
+                WebSocketConfig::default()
+                    .max_message_size(Some(self.limits.max_message_bytes))
+                    .max_frame_size(Some(self.limits.max_message_bytes)),
+            ),
+        )
+        .await;
+        let (mut sink, mut source) = websocket.split();
+        let mut events = self.events.subscribe();
+        let mut session = Session::default();
+
+        loop {
+            tokio::select! {
+                biased;
+                () = self.stop.cancelled() => return Ok(()),
+                received = source.next() => {
+                    let Some(message) = received else { return Ok(()); };
+                    match message? {
+                        Message::Text(text) => {
+                            for response in self.handle_text(&mut session, address, &text).await {
+                                self.send(&mut sink, response).await?;
+                            }
+                        }
+                        Message::Ping(payload) => {
+                            self.send_message(&mut sink, Message::Pong(payload)).await?;
+                        }
+                        Message::Close(_) => return Ok(()),
+                        Message::Binary(_) | Message::Pong(_) | Message::Frame(_) => {}
+                    }
+                }
+                received = events.recv() => {
+                    let event = received.context("live event stream lagged")?;
+                    let ids = session.subscriptions.iter()
+                        .filter(|entry| entry.1.filters.iter().any(|filter| filter.match_event(&event, MatchEventOptions::new())))
+                        .map(|entry| entry.0.clone())
+                        .collect::<Vec<_>>();
+                    for id in ids {
+                        self.send(&mut sink, json!(["EVENT", id, event])).await?;
+                    }
+                }
+            }
+        }
+    }
+
+    async fn send<S>(&self, sink: &mut S, value: Value) -> Result<()>
+    where
+        S: Sink<Message, Error = WebSocketError> + Unpin,
+    {
+        self.send_message(sink, Message::Text(value.to_string().into()))
+            .await
+    }
+
+    async fn send_message<S>(&self, sink: &mut S, message: Message) -> Result<()>
+    where
+        S: Sink<Message, Error = WebSocketError> + Unpin,
+    {
+        timeout(
+            Duration::from_secs(self.limits.write_timeout_seconds),
+            sink.send(message),
+        )
+        .await
+        .context("websocket write timed out")??;
+        Ok(())
+    }
+
+    async fn handle_text(
+        &self,
+        session: &mut Session,
+        address: SocketAddr,
+        text: &str,
+    ) -> Vec<Value> {
+        let Ok(value) = serde_json::from_str::<Value>(text) else {
+            return vec![json!(["NOTICE", "invalid json"])];
+        };
+        let Some(frame) = value.as_array() else {
+            return vec![json!(["NOTICE", "message must be an array"])];
+        };
+        match frame.first().and_then(Value::as_str) {
+            Some("EVENT") => vec![self.handle_event(frame, address).await],
+            Some("REQ") => self.handle_req(session, frame, address, text.len()).await,
+            Some("CLOSE") => {
+                if let Some(id) = frame.get(1).and_then(Value::as_str) {
+                    session.subscriptions.remove(id);
+                }
+                Vec::new()
+            }
+            _ => vec![json!(["NOTICE", "unsupported message"])],
+        }
+    }
+
+    async fn handle_event(&self, frame: &[Value], address: SocketAddr) -> Value {
+        let Some(value) = frame.get(1) else {
+            return json!(["NOTICE", "EVENT requires an event"]);
+        };
+        let id = value
+            .get("id")
+            .and_then(Value::as_str)
+            .unwrap_or_default()
+            .to_owned();
+        let Ok(event) = serde_json::from_value::<Event>(value.clone()) else {
+            return json!(["OK", id, false, "invalid: malformed event"]);
+        };
+        if event.verify().is_err() {
+            return json!(["OK", event.id, false, "invalid: bad id or signature"]);
+        }
+        match self.policy.admit_event(&event, &address).await {
+            WritePolicyResult::Accept => {}
+            WritePolicyResult::Respond {
+                prefix,
+                message,
+                status,
+            } => return json!(["OK", event.id, status, format!("{prefix}: {message}")]),
+        }
+        let event_id = event.id;
+        match self.add_event(event).await {
+            Ok(SaveEventStatus::Success) => json!(["OK", event_id, true, ""]),
+            Ok(SaveEventStatus::Rejected(RejectedReason::Duplicate)) => {
+                json!(["OK", event_id, true, "duplicate: already stored"])
+            }
+            Ok(SaveEventStatus::Rejected(reason)) => {
+                json!(["OK", event_id, false, format!("blocked: {reason:?}")])
+            }
+            Err(error) => {
+                tracing::error!(event = %event_id, %error, "event storage failed");
+                json!(["OK", event_id, false, "error: database unavailable"])
+            }
+        }
+    }
+
+    async fn handle_req(
+        &self,
+        session: &mut Session,
+        frame: &[Value],
+        address: SocketAddr,
+        request_bytes: usize,
+    ) -> Vec<Value> {
+        let Some(id) = frame.get(1).and_then(Value::as_str) else {
+            return vec![json!(["NOTICE", "REQ requires a subscription id"])];
+        };
+        if id.len() > 64 {
+            return vec![closed(id, "blocked: subscription id is too long")];
+        }
+        if frame.len() < 3 {
+            return vec![closed(id, "blocked: REQ requires a filter")];
+        }
+        if frame.len() - 2 > self.limits.max_filters {
+            return vec![closed(id, "rate-limited: too many filters")];
+        }
+        if session.subscriptions.len() >= self.limits.max_subscriptions
+            && !session.subscriptions.contains_key(id)
+        {
+            return vec![closed(id, "rate-limited: too many subscriptions")];
+        }
+        let old_bytes = session.subscriptions.get(id).map_or(0, |entry| entry.bytes);
+        let active_bytes = session
+            .subscriptions
+            .values()
+            .map(|entry| entry.bytes)
+            .sum::<usize>()
+            .saturating_sub(old_bytes);
+        let max_subscription_bytes = self
+            .limits
+            .max_filter_bytes
+            .saturating_mul(self.limits.max_subscriptions);
+        if active_bytes.saturating_add(request_bytes) > max_subscription_bytes {
+            return vec![closed(id, "rate-limited: subscription byte limit exceeded")];
+        }
+
+        let mut filters = Vec::with_capacity(frame.len() - 2);
+        for value in &frame[2..] {
+            let Ok(filter) = serde_json::from_value::<Filter>(value.clone()) else {
+                return vec![closed(id, "blocked: invalid filter")];
+            };
+            match self.policy.admit_query(&filter, &address).await {
+                QueryPolicyResult::Accept => filters.push(filter),
+                QueryPolicyResult::Reject { prefix, message } => {
+                    return vec![closed(id, &format!("{prefix}: {message}"))];
+                }
+            }
+        }
+
+        let mut events = BTreeSet::new();
+        for filter in &filters {
+            let implicit = filter.limit.is_none();
+            let limit = filter.limit.unwrap_or(self.limits.max_query_results);
+            let mut query = filter.clone();
+            query.limit = Some(if implicit {
+                limit.saturating_add(1)
+            } else {
+                limit
+            });
+            let found = match self.store.query(query).await {
+                Ok(found) => found,
+                Err(error) => {
+                    let message = if error.to_string().contains("history byte limit exceeded") {
+                        "rate-limited: history byte limit exceeded"
+                    } else {
+                        tracing::error!(%error, "history query failed");
+                        "error: database unavailable"
+                    };
+                    return vec![closed(id, message)];
+                }
+            };
+            if implicit && found.len() > limit {
+                return vec![closed(id, "rate-limited: history result limit exceeded")];
+            }
+            events.extend(found);
+            if events.len() > self.limits.max_query_results {
+                return vec![closed(id, "rate-limited: too many results")];
+            }
+        }
+        let bytes = events
+            .iter()
+            .map(|event| event.as_json().len())
+            .sum::<usize>();
+        if bytes > self.limits.max_query_bytes {
+            return vec![closed(id, "rate-limited: history byte limit exceeded")];
+        }
+
+        let mut response = Vec::with_capacity(events.len() + 1);
+        for event in events {
+            if !event.is_expired() {
+                response.push(json!(["EVENT", id, event]));
+            }
+        }
+        response.push(json!(["EOSE", id]));
+        session.subscriptions.insert(
+            id.to_owned(),
+            Subscription {
+                filters,
+                bytes: request_bytes,
+            },
+        );
+        response
+    }
+}
+
+fn closed(id: &str, message: &str) -> Value {
+    json!(["CLOSED", id, message])
+}

Added file: src/server.rs+299 additions@@ -0,0 +1,299 @@
+use std::collections::HashMap;
+use std::convert::Infallible;
+use std::net::{IpAddr, SocketAddr};
+use std::sync::{Arc, Mutex, PoisonError};
+use std::time::Duration;
+
+use anyhow::Context as _;
+use http_body_util::Full;
+use hyper::body::{Bytes, Incoming};
+use hyper::header::{ACCEPT, ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE, HeaderValue, UPGRADE};
+use hyper::server::conn::http1::Builder as Http1Builder;
+use hyper::service::service_fn;
+use hyper::upgrade::on as upgrade;
+use hyper::{Method, Request, Response, StatusCode};
+use hyper_util::rt::{TokioIo, TokioTimer};
+use nostr_database::NostrDatabase;
+use serde_json::json;
+use tokio::net::TcpListener;
+use tokio::sync::{OwnedSemaphorePermit, Semaphore};
+use tokio::task::{JoinHandle, spawn as spawn_task};
+use tokio::time::timeout;
+use tokio_tungstenite::tungstenite::handshake::server::create_response;
+use tokio_util::sync::CancellationToken;
+use tokio_util::task::TaskTracker;
+
+use crate::config::Config;
+use crate::federation::spawn as spawn_federation;
+use crate::policy::Policy;
+use crate::relay::Relay;
+use crate::store::Store;
+
+type Body = Full<Bytes>;
+
+struct ConnectionLease {
+    ip: IpAddr,
+    peers: Arc<Mutex<HashMap<IpAddr, usize>>>,
+    _permit: OwnedSemaphorePermit,
+}
+
+impl Drop for ConnectionLease {
+    fn drop(&mut self) {
+        let mut peers = self.peers.lock().unwrap_or_else(PoisonError::into_inner);
+        if let Some(count) = peers.get_mut(&self.ip) {
+            *count -= 1;
+            if *count == 0 {
+                peers.remove(&self.ip);
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+struct HttpState {
+    relay: Relay,
+    store: Arc<Store>,
+    config: Arc<Config>,
+    websocket_path: String,
+    tasks: TaskTracker,
+    stop: CancellationToken,
+}
+
+pub struct RunningRelay {
+    address: SocketAddr,
+    path: String,
+    state: HttpState,
+    listener: JoinHandle<anyhow::Result<()>>,
+}
+
+impl RunningRelay {
+    #[must_use]
+    pub fn url(&self) -> String {
+        format!("ws://{}{}", self.address, self.path)
+    }
+
+    pub async fn shutdown(self) -> anyhow::Result<()> {
+        self.state.stop.cancel();
+        self.listener.await.context("joining listener")??;
+        self.state.tasks.close();
+        timeout(Duration::from_secs(30), self.state.tasks.wait())
+            .await
+            .context("relay connections did not drain")?;
+        Ok(())
+    }
+}
+
+pub async fn spawn(config: Config) -> anyhow::Result<RunningRelay> {
+    config.validate()?;
+    let store = Store::open(&config).await?;
+    let policy_database: Arc<dyn NostrDatabase> = Arc::<Store>::clone(&store);
+    let policy = Policy::new(policy_database, &config)?;
+    let listener = TcpListener::bind(config.listen)
+        .await
+        .context("binding relay listener")?;
+    let address = listener.local_addr()?;
+    let path = config.websocket_path()?;
+    let stop = CancellationToken::new();
+    let relay = Relay::new(
+        Arc::clone(&store),
+        policy.clone(),
+        config.limits.clone(),
+        stop.clone(),
+    );
+    let state = HttpState {
+        relay,
+        store,
+        config: Arc::new(config),
+        websocket_path: path.clone(),
+        tasks: TaskTracker::new(),
+        stop,
+    };
+    let task_state = state.clone();
+    spawn_federation(
+        Arc::clone(&state.config),
+        Arc::clone(&state.store),
+        state.relay.clone(),
+        policy,
+        &state.tasks,
+        state.stop.clone(),
+    );
+    let listener_task = spawn_task(async move { accept_connections(listener, task_state).await });
+    tracing::info!(%address, %path, "relay is listening");
+    Ok(RunningRelay {
+        address,
+        path,
+        state,
+        listener: listener_task,
+    })
+}
+
+async fn accept_connections(listener: TcpListener, state: HttpState) -> anyhow::Result<()> {
+    let slots = Arc::new(Semaphore::new(state.config.limits.max_connections));
+    let peers = Arc::new(Mutex::new(HashMap::<IpAddr, usize>::new()));
+    loop {
+        let (stream, address) = tokio::select! {
+            biased;
+            () = state.stop.cancelled() => return Ok(()),
+            accepted = listener.accept() => accepted?,
+        };
+        let Ok(permit) = Arc::clone(&slots).try_acquire_owned() else {
+            continue;
+        };
+        let mut peer_counts = peers.lock().unwrap_or_else(PoisonError::into_inner);
+        let count = peer_counts.entry(address.ip()).or_default();
+        if *count >= state.config.limits.max_connections_per_ip {
+            continue;
+        }
+        *count += 1;
+        drop(peer_counts);
+        let lease = Arc::new(ConnectionLease {
+            ip: address.ip(),
+            peers: Arc::clone(&peers),
+            _permit: permit,
+        });
+        let handler_state = state.clone();
+        let stop = state.stop.clone();
+        state.tasks.spawn(async move {
+            let handler = service_fn(move |request| {
+                handle_request(
+                    request,
+                    address,
+                    handler_state.clone(),
+                    Arc::clone(&lease),
+                )
+            });
+            let mut builder = Http1Builder::new();
+            builder.timer(TokioTimer::new()).header_read_timeout(Duration::from_secs(10));
+            let connection = builder.serve_connection(TokioIo::new(stream), handler).with_upgrades();
+            tokio::pin!(connection);
+            tokio::select! {
+                result = &mut connection => {
+                    if let Err(error) = result { tracing::debug!(%address, %error, "http connection ended"); }
+                }
+                () = stop.cancelled() => {}
+            }
+        });
+    }
+}
+
+async fn handle_request(
+    mut request: Request<Incoming>,
+    address: SocketAddr,
+    state: HttpState,
+    lease: Arc<ConnectionLease>,
+) -> Result<Response<Body>, Infallible> {
+    if state.stop.is_cancelled() {
+        return Ok(response(
+            StatusCode::SERVICE_UNAVAILABLE,
+            "text/plain",
+            "relay is stopping",
+        ));
+    }
+    if request.method() != Method::GET {
+        return Ok(response(
+            StatusCode::METHOD_NOT_ALLOWED,
+            "text/plain",
+            "GET required",
+        ));
+    }
+    if request.uri().path() == "/healthz" {
+        let healthy = timeout(Duration::from_secs(2), state.store.healthy())
+            .await
+            .unwrap_or(false);
+        return Ok(response(
+            if healthy {
+                StatusCode::OK
+            } else {
+                StatusCode::SERVICE_UNAVAILABLE
+            },
+            "text/plain",
+            if healthy {
+                "ok"
+            } else {
+                "database unavailable"
+            },
+        ));
+    }
+    if request.uri().path() != state.websocket_path {
+        return Ok(response(StatusCode::NOT_FOUND, "text/plain", "not found"));
+    }
+    if !request.headers().contains_key(UPGRADE) {
+        let wants_information = request
+            .headers()
+            .get(ACCEPT)
+            .and_then(|value| value.to_str().ok())
+            .is_some_and(|value| {
+                value.split(',').any(|media_type| {
+                    media_type.trim().split(';').next() == Some("application/nostr+json")
+                })
+            });
+        return Ok(if wants_information {
+            response(
+                StatusCode::OK,
+                "application/nostr+json",
+                &information(&state.config),
+            )
+        } else {
+            response(
+                StatusCode::OK,
+                "text/plain",
+                "vineyard\na persistent nostr relay for git forges\n",
+            )
+        });
+    }
+    let upgrade = upgrade(&mut request);
+    let Ok(handshake) = create_response(&request.map(|_body| ())) else {
+        return Ok(response(
+            StatusCode::BAD_REQUEST,
+            "text/plain",
+            "invalid WebSocket handshake",
+        ));
+    };
+    let relay = state.relay.clone();
+    state.tasks.spawn(async move {
+        let _lease = lease;
+        if let Ok(Ok(stream)) = timeout(Duration::from_secs(10), upgrade).await {
+            if let Err(error) = relay.take_connection(TokioIo::new(stream), address).await {
+                tracing::debug!(%address, %error, "websocket connection ended");
+            }
+        } else {
+            tracing::debug!(%address, "websocket upgrade did not complete");
+        }
+    });
+    Ok(handshake.map(|()| Full::new(Bytes::new())))
+}
+
+fn response(status: StatusCode, content_type: &str, body: &str) -> Response<Body> {
+    let mut response = Response::new(Full::new(Bytes::copy_from_slice(body.as_bytes())));
+    *response.status_mut() = status;
+    if let Ok(value) = HeaderValue::from_str(content_type) {
+        response.headers_mut().insert(CONTENT_TYPE, value);
+    }
+    response
+        .headers_mut()
+        .insert(ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
+    response
+}
+
+fn information(config: &Config) -> String {
+    json!({
+        "name": "vineyard",
+        "description": "a persistent nostr relay for git forges",
+        "software": "vineyard",
+        "version": env!("CARGO_PKG_VERSION"),
+        "supported_nips": [1, 9, 11, 34, 65],
+        "forge_pubkeys": config.forge_pubkeys,
+        "limitation": {
+            "max_message_length": config.limits.max_message_bytes,
+            "max_event_tags": config.limits.max_tags,
+            "max_subscriptions": config.limits.max_subscriptions,
+            "max_filters": config.limits.max_filters,
+            "max_limit": config.limits.max_query_results,
+            "max_subid_length": 64,
+            "auth_required": false,
+            "payment_required": false,
+            "restricted_writes": true
+        }
+    })
+    .to_string()
+}

Added file: src/store.rs+244 additions@@ -0,0 +1,244 @@
+use std::collections::{BTreeSet, HashSet};
+use std::fs::{File, OpenOptions, create_dir_all};
+use std::future::Future;
+use std::io::Error as IoError;
+use std::iter::once;
+use std::path::PathBuf;
+use std::pin::Pin;
+use std::sync::Arc;
+
+use anyhow::Context as _;
+use fs2::FileExt as _;
+use nostr::event::{Event, EventId, Kind};
+use nostr::filter::Filter;
+use nostr::nips::nip65::extract_relay_list;
+use nostr_database::error::Error;
+use nostr_database::{DatabaseEventStatus, Features, NostrDatabase, SaveEventStatus};
+use tokio::sync::Mutex;
+
+use crate::config::{Config, relay_url};
+use crate::journal::Journal;
+
+type DatabaseFuture<'database, T> =
+    Pin<Box<dyn Future<Output = Result<T, Error>> + Send + 'database>>;
+
+#[derive(Debug)]
+pub struct Store {
+    pub(crate) journal: Journal,
+    path: PathBuf,
+    min_free_bytes: u64,
+    max_query_bytes: usize,
+    max_repositories: usize,
+    max_discovered_peers: usize,
+    excluded_peers: HashSet<String>,
+    writer: Arc<Mutex<()>>,
+    _lock: File,
+}
+
+impl Store {
+    pub async fn open(config: &Config) -> anyhow::Result<Arc<Self>> {
+        if let Some(parent) = config
+            .database
+            .parent()
+            .filter(|parent| !parent.as_os_str().is_empty())
+        {
+            create_dir_all(parent).context("creating database directory")?;
+        }
+        let mut lock_name = config.database.as_os_str().to_os_string();
+        lock_name.push(".lock");
+        let mut lock_options = OpenOptions::new();
+        lock_options
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(false);
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::OpenOptionsExt as _;
+            lock_options.mode(0o600)
+        };
+        let lock = lock_options
+            .open(PathBuf::from(lock_name))
+            .context("opening database lock")?;
+        lock.try_lock_exclusive()
+            .context("database is already in use")?;
+
+        let excluded_peers = once(&config.public_url)
+            .chain(config.peers.iter().map(|peer| &peer.url))
+            .map(|url| relay_url(url).map(|parsed| parsed.to_string()))
+            .collect::<Option<HashSet<_>>>()
+            .context("validated relay url became invalid")?;
+        let writer = Arc::new(Mutex::new(()));
+        let journal = Journal::open(
+            config.database.clone(),
+            config.limits.max_database_bytes,
+            config
+                .limits
+                .max_discovered_peers
+                .saturating_add(excluded_peers.len()),
+            excluded_peers.iter().cloned().collect(),
+            Arc::clone(&writer),
+        )
+        .await?;
+        journal
+            .forget_discovered(excluded_peers.iter().cloned().collect())
+            .await?;
+        tracing::info!(path = %config.database.display(), "opened event database");
+        Ok(Arc::new(Self {
+            journal,
+            path: config.database.clone(),
+            min_free_bytes: config.limits.min_free_bytes,
+            max_query_bytes: config.limits.max_query_bytes,
+            max_repositories: config.limits.max_repositories,
+            max_discovered_peers: config.limits.max_discovered_peers,
+            excluded_peers,
+            writer,
+            _lock: lock,
+        }))
+    }
+
+    pub async fn healthy(&self) -> bool {
+        self.journal.healthy().await
+    }
+
+    async fn query_events(&self, filter: Filter) -> Result<BTreeSet<Event>, Error> {
+        self.journal
+            .query(filter, self.max_query_bytes)
+            .await
+            .map_err(storage_error)
+    }
+}
+
+fn storage_error(error: anyhow::Error) -> Error {
+    Error::storage(IoError::other(error))
+}
+
+impl NostrDatabase for Store {
+    fn backend(&self) -> &'static str {
+        "vineyard-sqlite"
+    }
+
+    fn features(&self) -> Features {
+        Features {
+            persistent: true,
+            event_expiration: false,
+            full_text_search: false,
+            request_to_vanish: false,
+        }
+    }
+
+    fn save_event<'database>(
+        &'database self,
+        event: &'database Event,
+    ) -> DatabaseFuture<'database, SaveEventStatus> {
+        Box::pin(async move {
+            let writer = self.writer.lock().await;
+            if event.kind.as_u16() == 30617 {
+                if let Some(identifier) = event.tags.identifier() {
+                    let registered = self
+                        .query_events(
+                            Filter::new()
+                                .kind(event.kind)
+                                .author(event.pubkey)
+                                .identifier(identifier)
+                                .limit(1),
+                        )
+                        .await?
+                        .len();
+                    if registered == 0
+                        && self
+                            .query_events(
+                                Filter::new()
+                                    .kind(event.kind)
+                                    .limit(self.max_repositories + 1),
+                            )
+                            .await?
+                            .len()
+                            >= self.max_repositories
+                    {
+                        return Err(Error::storage(IoError::other(
+                            "repository directory is full",
+                        )));
+                    }
+                }
+            }
+            if self.journal.status(event.id).await.map_err(storage_error)?
+                != DatabaseEventStatus::Saved
+            {
+                let free = fs2::available_space(&self.path).map_err(Error::io)?;
+                let event_bytes = u64::try_from(event.as_json().len())
+                    .map_err(|error| Error::storage(IoError::other(error.to_string())))?;
+                if free < self.min_free_bytes.saturating_add(event_bytes) {
+                    return Err(Error::storage(IoError::other("storage reserve reached")));
+                }
+            }
+            let status = self
+                .journal
+                .save_locked(event.clone(), &writer)
+                .await
+                .map_err(storage_error)?;
+            if status.is_success() && event.kind == Kind::RelayList {
+                let urls = extract_relay_list(event)
+                    .map(|(url, _)| url.to_string())
+                    .filter(|url| !self.excluded_peers.contains(url))
+                    .collect();
+                if let Err(error) = self
+                    .journal
+                    .replace_discovered_locked(
+                        event.pubkey,
+                        urls,
+                        self.max_discovered_peers,
+                        &writer,
+                    )
+                    .await
+                {
+                    tracing::error!(event = %event.id, %error, "saving discovered peers failed");
+                }
+            }
+            drop(writer);
+            Ok(status)
+        })
+    }
+
+    fn check_id<'database>(
+        &'database self,
+        event_id: &'database EventId,
+    ) -> DatabaseFuture<'database, DatabaseEventStatus> {
+        let requested_id = *event_id;
+        Box::pin(async move {
+            self.journal
+                .status(requested_id)
+                .await
+                .map_err(storage_error)
+        })
+    }
+
+    fn event_by_id<'database>(
+        &'database self,
+        event_id: &'database EventId,
+    ) -> DatabaseFuture<'database, Option<Event>> {
+        let requested_id = *event_id;
+        Box::pin(async move {
+            self.journal
+                .event(requested_id)
+                .await
+                .map_err(storage_error)
+        })
+    }
+
+    fn count(&self, filter: Filter) -> DatabaseFuture<'_, usize> {
+        Box::pin(async move { self.journal.count(filter).await.map_err(storage_error) })
+    }
+
+    fn query(&self, filter: Filter) -> DatabaseFuture<'_, BTreeSet<Event>> {
+        Box::pin(self.query_events(filter))
+    }
+
+    fn delete(&self, _filter: Filter) -> DatabaseFuture<'_, ()> {
+        Box::pin(async { Err(Error::unsupported("use signed deletion requests")) })
+    }
+
+    fn wipe(&self) -> DatabaseFuture<'_, ()> {
+        Box::pin(async { Err(Error::unsupported("database wipe is disabled")) })
+    }
+}

Added file: vineyard.example.toml+25 additions@@ -0,0 +1,25 @@
+public_url = "wss://relay.example.org/"
+listen = "127.0.0.1:7777"
+database = "vineyard.sqlite"
+forge_pubkeys = ["79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"]
+peers = []
+allow_private_discovery = false
+
+[limits]
+max_repositories = 4096
+max_discovered_peers = 32
+max_connections = 32
+max_connections_per_ip = 8
+max_subscriptions = 16
+max_event_bytes = 2096896
+max_message_bytes = 2097152
+max_tags = 128
+max_filters = 8
+max_filter_bytes = 32768
+max_query_results = 500
+max_query_bytes = 16777216
+events_per_minute = 120
+queries_per_minute = 120
+max_database_bytes = 1073741824
+min_free_bytes = 67108864
+write_timeout_seconds = 10

vineyard

Commit 25d14e49ab68

Commit `25d14e49ab68`