fix(resolve): follow extension-to-extension dependencies

Parse the `requires=` (GL) and `depends=` (Vulkan) attributes on
<extension> elements, which declare prerequisite extensions.
Previously these attributes were silently discarded during XML
parsing.

ir.rs: add `depends: Vec<String>` to RawExtension.

parse/features.rs: new parse_extension_depends() extracts extension
name tokens from both GL's comma-separated format and Vulkan's
boolean expression format (splits on comma, plus, parentheses).
Version tokens like VK_VERSION_1_1 are included harmlessly — the
resolver skips them since they don't match any extension name.

resolve.rs: new SelectionReason::Dependency variant and fixed-point
dependency-following loop in select_extensions, running after the
initial filter but before --promoted/--predecessors. Transitively
pulls in prerequisite extensions not already selected.

preamble.rs: dependency extensions shown in the summary line and
listed by name alongside promoted/predecessor extensions.

Note: GL extension dependencies are largely absent from gl.xml
(the information exists only in spec prose text, not in machine-
readable attributes). This is a known limitation of the GL XML
registry. Vulkan's `depends=` attribute is more consistently
populated.

Signed-off-by: Steven Noonan <steven@uplinklabs.net>

Author: tycho

src/ir.rs

@@ -203,6 +203,11 @@ pub struct RawExtension {
     pub protect: Vec<String>,
     /// Extension registry number, used for enum offset calculation.
     pub number: Option<u32>,
+    /// Extensions this one depends on (from `requires=` or `depends=` attribute).
+    /// All referenced extension names, regardless of AND/OR semantics in the
+    /// original attribute — if a name appears at all, it's a prerequisite the
+    /// loader should include.
+    pub depends: Vec<String>,
 }
 
 // ---------------------------------------------------------------------------

src/parse/features.rs

@@ -202,6 +202,13 @@ fn parse_extensions(
 
         let number = node.attribute("number").and_then(|s| s.parse().ok());
 
+        // Extension-to-extension dependencies: GL uses `requires=` (comma-
+        // separated), Vulkan uses `depends=` with `+` (AND), `,` (OR), and
+        // parentheses.  We extract every extension-name-looking token from
+        // whichever attribute is present — the resolver needs all prerequisites
+        // regardless of AND/OR semantics.
+        let depends = parse_extension_depends(node);
+
         let requires = node
             .children()
             .filter(|n| n.is_element() && n.tag_name().name() == "require")
@@ -214,6 +221,7 @@ fn parse_extensions(
             requires,
             protect,
             number,
+            depends,
         });
     }
 
@@ -231,6 +239,37 @@ fn parse_extensions(
 
     Ok(extensions)
 }
+// ---------------------------------------------------------------------------
+// Parse extension dependency attributes
+// ---------------------------------------------------------------------------
+
+/// Extract extension dependency names from the `requires=` (GL) or `depends=`
+/// (Vulkan) attribute on an `<extension>` element.
+///
+/// GL uses comma-separated names: `requires="GL_ARB_draw_indirect"`
+/// Vulkan uses a boolean expression: `depends="VK_KHR_foo+VK_KHR_bar,VK_VERSION_1_1"`
+/// with `+` (AND), `,` (OR), and parentheses.
+///
+/// We split on all delimiters and return every token that looks like an
+/// extension name (contains `_` and doesn't start with a digit).  Version
+/// requirements like `VK_VERSION_1_1` are included — the resolver filters
+/// them against the actual extension list.
+fn parse_extension_depends(node: roxmltree::Node<'_, '_>) -> Vec<String> {
+    let attr = node
+        .attribute("depends")
+        .or_else(|| node.attribute("requires"));
+
+    let Some(raw) = attr else {
+        return Vec::new();
+    };
+
+    raw.split(|c: char| c == ',' || c == '+' || c == '(' || c == ')')
+        .map(str::trim)
+        .filter(|s| !s.is_empty() && s.contains('_'))
+        .map(str::to_string)
+        .collect()
+}
+
 // ---------------------------------------------------------------------------
 // Parse <require> and <remove> blocks
 // ---------------------------------------------------------------------------

src/preamble.rs

@@ -30,9 +30,10 @@ pub fn build_preamble(fs: &FeatureSet, command_line: &str) -> String {
         lines.push(" *".to_string());
         lines.push(format!(" * {}", extension_summary(fs)));
 
-        // List implicitly-included extensions (promoted, predecessor) so the
-        // user can see what was pulled in automatically.
+        // List implicitly-included extensions (dependency, promoted, predecessor)
+        // so the user can see what was pulled in automatically.
         for (label, reason) in &[
+            ("dependency", SelectionReason::Dependency),
             ("promoted", SelectionReason::Promoted),
             ("predecessor", SelectionReason::Predecessor),
         ] {
@@ -50,7 +51,7 @@ pub fn build_preamble(fs: &FeatureSet, command_line: &str) -> String {
 
     // ---- gloam license ----
     lines.push(" *".to_string());
-    lines.push(format!(" * gloam Copyright (c) {year} Steven Noonan"));
+    lines.push(format!(" * Copyright (c) {year} Steven Noonan"));
     lines.push(" * SPDX-License-Identifier: MIT".to_string());
 
     // ---- Khronos ----
@@ -93,6 +94,7 @@ fn extension_summary(fs: &FeatureSet) -> String {
     let n_all = count(SelectionReason::AllExtensions);
     let n_explicit = count(SelectionReason::Explicit);
     let n_mandatory = count(SelectionReason::Mandatory);
+    let n_dependency = count(SelectionReason::Dependency);
     let n_promoted = count(SelectionReason::Promoted);
     let n_predecessor = count(SelectionReason::Predecessor);
 
@@ -108,6 +110,9 @@ fn extension_summary(fs: &FeatureSet) -> String {
     if n_mandatory > 0 {
         parts.push(format!("{n_mandatory} mandatory"));
     }
+    if n_dependency > 0 {
+        parts.push(format!("{n_dependency} dependency"));
+    }
     if n_promoted > 0 {
         parts.push(format!("{n_promoted} promoted"));
     }
@@ -316,6 +321,30 @@ mod tests {
         assert!(p.contains("predecessor: GL_ARB_parallel_shader_compile"));
     }
 
+    #[test]
+    fn preamble_lists_dependency_extensions() {
+        let mut fs = stub_fs("gl");
+        fs.extensions = vec![
+            stub_ext("GL_ARB_multi_draw_indirect", SelectionReason::Explicit),
+            stub_ext("GL_ARB_draw_indirect", SelectionReason::Dependency),
+        ];
+        let p = build_preamble(&fs, "gloam --api gl:core=3.3 c");
+        assert!(p.contains("dependency: GL_ARB_draw_indirect"));
+    }
+
+    #[test]
+    fn summary_with_dependencies() {
+        let mut fs = stub_fs("gl");
+        fs.extensions = vec![
+            stub_ext("GL_ARB_multi_draw_indirect", SelectionReason::Explicit),
+            stub_ext("GL_ARB_draw_indirect", SelectionReason::Dependency),
+        ];
+        assert_eq!(
+            extension_summary(&fs),
+            "Extensions: 1 explicit, 1 dependency (2 total)"
+        );
+    }
+
     #[test]
     fn preamble_no_extension_section_when_empty() {
         let fs = stub_fs("vk");

src/resolve.rs

@@ -707,6 +707,9 @@ pub enum SelectionReason {
     AllExtensions,
     /// WGL mandatory extensions (always required for WGL to function).
     Mandatory,
+    /// Auto-included because a selected extension declares it as a dependency
+    /// (via the `requires=` or `depends=` XML attribute).
+    Dependency,
     /// Auto-included because its commands were promoted into a requested core version.
     Promoted,
     /// Auto-included as a predecessor of an already-selected extension.
@@ -777,6 +780,53 @@ fn select_extensions<'a>(
         })
         .collect();
 
+    // Build an extension name → index lookup for dependency resolution.
+    let ext_by_name: HashMap<&str, usize> = raw
+        .extensions
+        .iter()
+        .enumerate()
+        .map(|(i, e)| (e.name.as_str(), i))
+        .collect();
+
+    // Dependency-following pass: walk the `depends` field of each selected
+    // extension and pull in any prerequisite extensions not already selected.
+    // Fixed-point loop because dependencies can be transitive — pulling in
+    // extension A may require extension B which requires extension C.
+    // Runs before --promoted and --predecessors so that dependency-pulled
+    // extensions' commands are visible to those passes.
+    loop {
+        let already: HashSet<&str> = selected.iter().map(|e| e.raw.name.as_str()).collect();
+        let prev_len = selected.len();
+
+        // Collect unique dependency names from all currently selected extensions.
+        let needed: HashSet<&str> = selected
+            .iter()
+            .flat_map(|e| e.raw.depends.iter().map(String::as_str))
+            .filter(|dep| {
+                !already.contains(dep)
+                    && ext_by_name.contains_key(dep)
+                    // Only pull in extensions that support a requested API.
+                    && raw.extensions[ext_by_name[dep]]
+                        .supported
+                        .iter()
+                        .any(|s| api_set.contains(s.as_str()))
+            })
+            .collect();
+
+        for dep_name in needed {
+            if let Some(&idx) = ext_by_name.get(dep_name) {
+                selected.push(SelectedExt {
+                    raw: &raw.extensions[idx],
+                    reason: SelectionReason::Dependency,
+                });
+            }
+        }
+
+        if selected.len() == prev_len {
+            break;
+        }
+    }
+
     // Build the bidirectional alias maps once — they're used by both the
     // --promoted and --predecessors passes.
     let cmd_to_alias: HashMap<&str, &str> = if want_promoted || want_predecessors {