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>

extensions/glsl/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "zed_glsl"
+version = "0.2.3"
+edition.workspace = true
+publish.workspace = true
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/glsl.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.1.0"

extensions/glsl/LICENSE-APACHE

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

extensions/glsl/extension.toml

@@ -0,0 +1,15 @@
+id = "glsl"
+name = "GLSL"
+description = "GLSL support."
+version = "0.2.3"
+schema_version = 1
+authors = ["Mikayla Maki <mikayla@zed.dev>"]
+repository = "https://github.com/zed-industries/zed"
+
+[language_servers.glsl_analyzer]
+name = "GLSL Analyzer LSP"
+language = "GLSL"
+
+[grammars.glsl]
+repository = "https://github.com/theHamsta/tree-sitter-glsl"
+commit = "31064ce53385150f894a6c72d61b94076adf640a"

extensions/glsl/languages/glsl/brackets.scm

@@ -0,0 +1,8 @@
+("[" @open
+  "]" @close)
+
+("{" @open
+  "}" @close)
+
+("(" @open
+  ")" @close)

extensions/glsl/languages/glsl/config.toml

@@ -0,0 +1,22 @@
+name = "GLSL"
+grammar = "glsl"
+path_suffixes = [
+    # Traditional rasterization pipeline shaders
+    "vert", "frag", "tesc", "tese", "geom",
+    # Compute shaders
+    "comp",
+    # Mesh pipeline shaders
+    "task", "mesh",
+    # Ray tracing pipeline shaders
+    "rgen", "rint", "rahit", "rchit", "rmiss", "rcall",
+    # Other
+    "glsl"
+    ]
+first_line_pattern = '^#version \d+'
+line_comments = ["// "]
+block_comment = { start = "/* ", prefix = "* ", end = "*/", tab_size = 1 }
+brackets = [
+    { start = "{", end = "}", close = true, newline = true },
+    { start = "[", end = "]", close = true, newline = true },
+    { start = "(", end = ")", close = true, newline = true },
+]

extensions/glsl/languages/glsl/highlights.scm

@@ -0,0 +1,129 @@
+[
+  "break"
+  "case"
+  "const"
+  "continue"
+  "default"
+  "do"
+  "else"
+  "enum"
+  "extern"
+  "for"
+  "if"
+  "inline"
+  "return"
+  "sizeof"
+  "static"
+  "struct"
+  "switch"
+  "typedef"
+  "union"
+  "volatile"
+  "while"
+  "#define"
+  "#elif"
+  "#else"
+  "#endif"
+  "#if"
+  "#ifdef"
+  "#ifndef"
+  "#include"
+  (preproc_directive)
+] @keyword
+
+[
+  "--"
+  "-"
+  "-="
+  "->"
+  "="
+  "!="
+  "*"
+  "&"
+  "&&"
+  "+"
+  "++"
+  "+="
+  "<"
+  "=="
+  ">"
+  "||"
+  "."
+  ";"
+] @operator
+
+[
+  (string_literal)
+  (system_lib_string)
+] @string
+
+(null) @constant.builtin
+
+[
+  (number_literal)
+  (char_literal)
+] @number
+
+(identifier) @variable
+
+(field_identifier) @property
+
+(statement_identifier) @label
+
+[
+  (type_identifier)
+  (primitive_type)
+  (sized_type_specifier)
+] @type
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function))
+
+(function_declarator
+  declarator: (identifier) @function)
+
+(preproc_function_def
+  name: (identifier) @function.special)
+
+((identifier) @constant
+  (#match? @constant "^[A-Z][A-Z\\d_]*$"))
+
+(comment) @comment
+
+[
+  "in"
+  "out"
+  "inout"
+  "uniform"
+  "shared"
+  "layout"
+  "attribute"
+  "varying"
+  "buffer"
+  "coherent"
+  "readonly"
+  "writeonly"
+  "precision"
+  "highp"
+  "mediump"
+  "lowp"
+  "centroid"
+  "sample"
+  "patch"
+  "smooth"
+  "flat"
+  "noperspective"
+  "invariant"
+  "precise"
+] @type.qualifier
+
+"subroutine" @keyword.function
+
+(extension_storage_class) @storageclass
+
+((identifier) @variable.builtin
+  (#match? @variable.builtin "^gl_"))

extensions/glsl/languages/glsl/injections.scm

@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))

extensions/glsl/src/glsl.rs

@@ -0,0 +1,131 @@
+use std::fs;
+use zed::settings::LspSettings;
+use zed_extension_api::{self as zed, LanguageServerId, Result, serde_json};
+
+struct GlslExtension {
+    cached_binary_path: Option<String>,
+}
+
+impl GlslExtension {
+    fn language_server_binary_path(
+        &mut self,
+        language_server_id: &LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<String> {
+        if let Some(path) = worktree.which("glsl_analyzer") {
+            return Ok(path);
+        }
+
+        if let Some(path) = &self.cached_binary_path
+            && fs::metadata(path).is_ok_and(|stat| stat.is_file())
+        {
+            return Ok(path.clone());
+        }
+
+        zed::set_language_server_installation_status(
+            language_server_id,
+            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
+        );
+        let release = zed::latest_github_release(
+            "nolanderc/glsl_analyzer",
+            zed::GithubReleaseOptions {
+                require_assets: true,
+                pre_release: false,
+            },
+        )?;
+
+        let (platform, arch) = zed::current_platform();
+        let asset_name = format!(
+            "{arch}-{os}.zip",
+            arch = match arch {
+                zed::Architecture::Aarch64 => "aarch64",
+                zed::Architecture::X86 => "x86",
+                zed::Architecture::X8664 => "x86_64",
+            },
+            os = match platform {
+                zed::Os::Mac => "macos",
+                zed::Os::Linux => "linux-musl",
+                zed::Os::Windows => "windows",
+            }
+        );
+
+        let asset = release
+            .assets
+            .iter()
+            .find(|asset| asset.name == asset_name)
+            .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
+
+        let version_dir = format!("glsl_analyzer-{}", release.version);
+        fs::create_dir_all(&version_dir)
+            .map_err(|err| format!("failed to create directory '{version_dir}': {err}"))?;
+        let binary_path = format!("{version_dir}/bin/glsl_analyzer");
+
+        if !fs::metadata(&binary_path).is_ok_and(|stat| stat.is_file()) {
+            zed::set_language_server_installation_status(
+                language_server_id,
+                &zed::LanguageServerInstallationStatus::Downloading,
+            );
+
+            zed::download_file(
+                &asset.download_url,
+                &version_dir,
+                match platform {
+                    zed::Os::Mac | zed::Os::Linux => zed::DownloadedFileType::Zip,
+                    zed::Os::Windows => zed::DownloadedFileType::Zip,
+                },
+            )
+            .map_err(|e| format!("failed to download file: {e}"))?;
+
+            zed::make_file_executable(&binary_path)?;
+
+            let entries =
+                fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
+            for entry in entries {
+                let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
+                if entry.file_name().to_str() != Some(&version_dir) {
+                    fs::remove_dir_all(entry.path()).ok();
+                }
+            }
+        }
+
+        self.cached_binary_path = Some(binary_path.clone());
+        Ok(binary_path)
+    }
+}
+
+impl zed::Extension for GlslExtension {
+    fn new() -> Self {
+        Self {
+            cached_binary_path: None,
+        }
+    }
+
+    fn language_server_command(
+        &mut self,
+        language_server_id: &zed::LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<zed::Command> {
+        Ok(zed::Command {
+            command: self.language_server_binary_path(language_server_id, worktree)?,
+            args: vec![],
+            env: Default::default(),
+        })
+    }
+
+    fn language_server_workspace_configuration(
+        &mut self,
+        _language_server_id: &zed::LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<Option<serde_json::Value>> {
+        let settings = LspSettings::for_worktree("glsl_analyzer", worktree)
+            .ok()
+            .and_then(|lsp_settings| lsp_settings.settings)
+            .unwrap_or_default();
+
+        Ok(Some(serde_json::json!({
+            "glsl_analyzer": settings
+        })))
+    }
+}
+
+zed::register_extension!(GlslExtension);