feat(compression): zstd capability negotiation

Tunnel-node advertises zstd support via zc:1 in response when client
sends ops+zc (uncompressed with capability flag). Client re-enables
zops when it sees the advertisement — allows automatic recovery after
initial fallback (e.g. Apps Script updated after tunnel-node).

Tunnel only sends zr when request had zops — old clients never see
compressed responses.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: yyoyoian-pixel

src/domain_fronter.rs

@@ -546,6 +546,8 @@ pub struct BatchTunnelResponse {
     pub e: Option<String>,
     #[serde(default)]
     pub zr: Option<String>,
+    #[serde(default)]
+    pub zc: Option<u8>,
 }
 
 impl DomainFronter {
@@ -3276,6 +3278,10 @@ impl DomainFronter {
                         }
                     }
                 }
+                if resp.zc.is_some() && self.zstd_unsupported.load(Ordering::Relaxed) {
+                    tracing::info!("tunnel-node advertised zstd capability, re-enabling compressed batches");
+                    self.zstd_unsupported.store(false, Ordering::Relaxed);
+                }
                 Ok(resp)
             }
             Err(e) => {

tunnel-node/src/main.rs

@@ -777,7 +777,8 @@ async fn handle_batch(
         }
     };
 
-    let client_zstd = req.zops.is_some() || req.zc.is_some();
+    let had_zops = req.zops.is_some();
+    let client_zstd = had_zops || req.zc.is_some();
     let ops: Vec<BatchOp> = if let Some(zops_b64) = req.zops {
         match B64.decode(&zops_b64) {
             Ok(compressed) => match zstd::decode_all(compressed.as_slice()) {
@@ -1251,7 +1252,8 @@ async fn handle_batch(
     results.sort_by_key(|(i, _)| *i);
     let r_vec: Vec<TunnelResponse> = results.into_iter().map(|(_, r)| r).collect();
 
-    let json = if client_zstd {
+    let json = if had_zops {
+        // Client sent compressed request → compressed response
         let r_json = serde_json::to_vec(&r_vec).unwrap_or_default();
         match zstd::encode_all(r_json.as_slice(), 3) {
             Ok(compressed) => {
@@ -1260,6 +1262,10 @@ async fn handle_batch(
             }
             Err(_) => serde_json::to_vec(&BatchResponse { r: r_vec }).unwrap_or_default(),
         }
+    } else if client_zstd {
+        // Client sent uncompressed ops but advertised zstd capability →
+        // respond with normal r + zc:1 so client knows it can switch to zops
+        serde_json::to_vec(&serde_json::json!({"r": r_vec, "zc": 1})).unwrap_or_default()
     } else {
         serde_json::to_vec(&BatchResponse { r: r_vec }).unwrap_or_default()
     };