maarcadetweet: initial commit

AT Protocol PDS + AppView + Tauri Desktop Client, 160-char post limit.

- PDS (Rust + axum + sqlx)
  - Auth: createAccount, createSession, refreshSession
  - Records: createRecord, deleteRecord (race-safe via SELECT FOR UPDATE)
  - Feed: feed.like.create, feed.repost.create
  - Sync: getRepo, getBlocks, getLatestCommit, getRecord (with MST proof), listRepos
  - Identity: resolveHandle
  - MST: spec-conformant (at-mst crate, 27 tests)
  - Repo: signed commits, TID counter (monotonic, 4096 wrap safe)

- AppView (Rust + axum + sqlx)
  - Jetstream consumer (WebSocket, exponential backoff, 38k+ events indexed)
  - REST API: timeline/home (graph-aware), profile, search, post (with thread hydration)
  - Handle-sync worker (did:plc + did:web)
  - JSONB embed storage + thread columns (migration 0003)
  - Like/repost counter cache (migration 0004)

- Tauri 2 + Svelte 5 Desktop Client
  - System tray (Show/Compose/Quit menu)
  - OS notifications (tauri-plugin-notification)
  - Auto-update (tauri-plugin-updater, placeholder endpoint)
  - Window-state (tauri-plugin-window-state)
  - 160-char compose with live counter
  - Image/Link embed rendering
  - LocalStorage-persisted like state
  - Timeline with poll (prepend new posts)
  - Custom TitleBar (transparent, no decorations)
  - Orange/IBM Plex Mono maarcade design

Tests: 231 Rust + 9 vitest = 240 passed.

crates/at-mst/examples/probe.rs

@@ -0,0 +1,73 @@
+use at_mst::Mst;
+use at_crypto::cid::cid_for_cbor;
+
+fn cid_for_str(s: &str) -> cid::Cid {
+    let bytes = format!("rec:{s}");
+    cid_for_cbor(bytes.as_bytes()).expect("cid_for_cbor")
+}
+
+fn main() {
+    let keys = vec!["alpha", "bravo", "charlie", "delta", "echo", "foxtrot"];
+    let values: Vec<_> = keys.iter().map(|k| cid_for_str(k)).collect();
+
+    let mut forward = Mst::new();
+    for (k, v) in keys.iter().zip(values.iter()) {
+        forward = forward.put(k.to_string(), *v, None).unwrap();
+    }
+
+    let mut backward = Mst::new();
+    for (k, v) in keys.iter().rev().zip(values.iter().rev()) {
+        backward = backward.put(k.to_string(), *v, None).unwrap();
+    }
+
+    println!("forward  root: {:?}", forward.root_cid());
+    println!("backward root: {:?}", backward.root_cid());
+    println!("forward  blocks: {}", forward.blocks().len());
+    println!("backward blocks: {}", backward.blocks().len());
+
+    let f_set: std::collections::BTreeSet<_> = forward.blocks().keys().copied().collect();
+    let b_set: std::collections::BTreeSet<_> = backward.blocks().keys().copied().collect();
+    println!("forward == backward blocks: {}", f_set == b_set);
+    println!("forward - backward: {:?}", f_set.difference(&b_set).collect::<Vec<_>>());
+    println!("backward - forward: {:?}", b_set.difference(&f_set).collect::<Vec<_>>());
+
+    // 100 random keys
+    let mut rng_keys: Vec<String> = (0..100).map(|i| format!("k/{i:05}")).collect();
+    let mut a = Mst::new();
+    let mut b = Mst::new();
+    for k in &rng_keys {
+        a = a.put(k.clone(), cid_for_str(k), None).unwrap();
+    }
+    rng_keys.reverse();
+    for k in &rng_keys {
+        b = b.put(k.clone(), cid_for_str(k), None).unwrap();
+    }
+    println!("\n100 keys:");
+    println!("a root: {:?}", a.root_cid());
+    println!("b root: {:?}", b.root_cid());
+    let a_set: std::collections::BTreeSet<_> = a.blocks().keys().copied().collect();
+    let b_set: std::collections::BTreeSet<_> = b.blocks().keys().copied().collect();
+    println!("a == b blocks: {}", a_set == b_set);
+    println!("a - b: {}", a_set.difference(&b_set).count());
+    println!("b - a: {}", b_set.difference(&a_set).count());
+
+    // deeper test: deliberately insert things that have layer > 0
+    // find a key with leading zeros in sha256
+    use at_crypto::cid::sha256;
+    for n in 1..1000 {
+        let key = format!("k{n}");
+        let h = sha256(key.as_bytes());
+        if h[0] == 0 && h[1] == 0 {
+            println!("k{}: 2 leading zero bytes -> layer 8, capped to 1 or 2", n);
+            break;
+        }
+    }
+    for n in 1..1000 {
+        let key = format!("k{n}");
+        let h = sha256(key.as_bytes());
+        if h[0] < 4 {
+            println!("k{}: leading byte 0x{:02x} -> layer {}", n, h[0], h[0].leading_zeros()/2);
+            break;
+        }
+    }
+}