logiguard fork: GPUI xdg-activation keyboard-focus serial fix

Single-commit orphan branch: full zed-industries/zed @ 8c74db0 source tree
with a 3-file patch applied (no upstream history).

Patch (crates/gpui_linux/src/linux/wayland/):
  - serial.rs: add SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; add latest_serial_of()
  - window.rs: activate() uses keyboard-enter serial (Mutter focus gate)

Mutter honors window activation only when the token carries the keyboard-
focus serial from wl_keyboard.enter; GPUI used a stale mouse-press serial.
See docs/tray-window-focus-wayland.md in logiguard.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/sqlez_macros/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "sqlez_macros"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/sqlez_macros.rs"
+proc-macro = true
+doctest = false
+
+[dependencies]
+sqlez.workspace = true
+sqlformat.workspace = true
+syn.workspace = true

crates/sqlez_macros/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/sqlez_macros/src/sqlez_macros.rs

@@ -0,0 +1,102 @@
+use proc_macro::{Delimiter, Span, TokenStream, TokenTree};
+use syn::Error;
+
+#[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
+static SQLITE: std::sync::LazyLock<sqlez::thread_safe_connection::ThreadSafeConnection> =
+    std::sync::LazyLock::new(|| {
+        sqlez::thread_safe_connection::ThreadSafeConnection::new(
+            ":memory:",
+            false,
+            None,
+            Some(sqlez::thread_safe_connection::locking_queue()),
+        )
+    });
+
+#[proc_macro]
+pub fn sql(tokens: TokenStream) -> TokenStream {
+    let (spans, sql) = make_sql(tokens);
+
+    #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
+    let error = SQLITE.sql_has_syntax_error(sql.trim());
+
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    let error: Option<(String, usize)> = None;
+
+    let formatted_sql = sqlformat::format(&sql, &sqlformat::QueryParams::None, Default::default());
+
+    if let Some((error, error_offset)) = error {
+        create_error(spans, error_offset, error, &formatted_sql)
+    } else {
+        format!("r#\"{}\"#", &formatted_sql).parse().unwrap()
+    }
+}
+
+fn create_error(
+    spans: Vec<(usize, Span)>,
+    error_offset: usize,
+    error: String,
+    formatted_sql: &String,
+) -> TokenStream {
+    let error_span = spans
+        .into_iter()
+        .skip_while(|(offset, _)| offset <= &error_offset)
+        .map(|(_, span)| span)
+        .next()
+        .unwrap_or_else(Span::call_site);
+    let error_text = format!("Sql Error: {}\nFor Query: {}", error, formatted_sql);
+    TokenStream::from(Error::new(error_span.into(), error_text).into_compile_error())
+}
+
+fn make_sql(tokens: TokenStream) -> (Vec<(usize, Span)>, String) {
+    let mut sql_tokens = vec![];
+    flatten_stream(tokens, &mut sql_tokens);
+    // Lookup of spans by offset at the end of the token
+    let mut spans: Vec<(usize, Span)> = Vec::new();
+    let mut sql = String::new();
+    for (token_text, span) in sql_tokens {
+        sql.push_str(&token_text);
+        spans.push((sql.len(), span));
+    }
+    (spans, sql)
+}
+
+/// This method exists to normalize the representation of groups
+/// to always include spaces between tokens. This is why we don't use the usual .to_string().
+/// This allows our token search in token_at_offset to resolve
+/// ambiguity of '(tokens)' vs. '( token )', due to sqlite requiring byte offsets
+fn flatten_stream(tokens: TokenStream, result: &mut Vec<(String, Span)>) {
+    for token_tree in tokens.into_iter() {
+        match token_tree {
+            TokenTree::Group(group) => {
+                // push open delimiter
+                result.push((open_delimiter(group.delimiter()), group.span()));
+                // recurse
+                flatten_stream(group.stream(), result);
+                // push close delimiter
+                result.push((close_delimiter(group.delimiter()), group.span()));
+            }
+            TokenTree::Ident(ident) => {
+                result.push((format!("{} ", ident), ident.span()));
+            }
+            leaf_tree => result.push((leaf_tree.to_string(), leaf_tree.span())),
+        }
+    }
+}
+
+fn open_delimiter(delimiter: Delimiter) -> String {
+    match delimiter {
+        Delimiter::Parenthesis => "( ".to_string(),
+        Delimiter::Brace => "[ ".to_string(),
+        Delimiter::Bracket => "{ ".to_string(),
+        Delimiter::None => "".to_string(),
+    }
+}
+
+fn close_delimiter(delimiter: Delimiter) -> String {
+    match delimiter {
+        Delimiter::Parenthesis => " ) ".to_string(),
+        Delimiter::Brace => " ] ".to_string(),
+        Delimiter::Bracket => " } ".to_string(),
+        Delimiter::None => "".to_string(),
+    }
+}