tree_sitter_language_pack 1.8.0 → 1.9.0.pre.rc.1

data/ext/ts_pack_core_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:eed307d857d74c9dce2d6a626941327b2f9e3442eaa781b0e2191b8f8b470855
+// alef:hash:a73f3f13c65d02941aef62a37b9b2051ea03b9a31b9017f47182d51888d6138e
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -13,12 +13,15 @@
     clippy::unwrap_or_default,
     clippy::derivable_impls,
     clippy::needless_borrows_for_generic_args,
-    clippy::unnecessary_fallible_conversions
+    clippy::unnecessary_fallible_conversions,
+    clippy::type_complexity,
+    clippy::useless_conversion,
+    clippy::clone_on_copy
 )]
 
 use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
-use std::collections::HashMap;
 use std::sync::Arc;
+use std::sync::Mutex;
 
 fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
     use magnus::IntoValue;
@@ -423,7 +426,7 @@ impl FileMetrics {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::StructureItem")]
 pub struct StructureItem {
@@ -466,6 +469,22 @@ impl magnus::TryConvert for StructureItem {
 
 unsafe impl TryConvertOwned for StructureItem {}
 
+impl Default for StructureItem {
+    fn default() -> Self {
+        Self {
+            kind: Default::default(),
+            name: None,
+            visibility: None,
+            span: Default::default(),
+            children: vec![],
+            decorators: vec![],
+            doc_comment: None,
+            signature: None,
+            body_span: None,
+        }
+    }
+}
+
 impl StructureItem {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -544,7 +563,7 @@ impl StructureItem {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::CommentInfo")]
 pub struct CommentInfo {
@@ -582,6 +601,17 @@ impl magnus::TryConvert for CommentInfo {
 
 unsafe impl TryConvertOwned for CommentInfo {}
 
+impl Default for CommentInfo {
+    fn default() -> Self {
+        Self {
+            text: String::new(),
+            kind: Default::default(),
+            span: Default::default(),
+            associated_node: None,
+        }
+    }
+}
+
 impl CommentInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -624,7 +654,7 @@ impl CommentInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::DocstringInfo")]
 pub struct DocstringInfo {
@@ -663,6 +693,18 @@ impl magnus::TryConvert for DocstringInfo {
 
 unsafe impl TryConvertOwned for DocstringInfo {}
 
+impl Default for DocstringInfo {
+    fn default() -> Self {
+        Self {
+            text: String::new(),
+            format: Default::default(),
+            span: Default::default(),
+            associated_item: None,
+            parsed_sections: vec![],
+        }
+    }
+}
+
 impl DocstringInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -885,7 +927,7 @@ impl ImportInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::ExportInfo")]
 pub struct ExportInfo {
@@ -922,6 +964,16 @@ impl magnus::TryConvert for ExportInfo {
 
 unsafe impl TryConvertOwned for ExportInfo {}
 
+impl Default for ExportInfo {
+    fn default() -> Self {
+        Self {
+            name: String::new(),
+            kind: Default::default(),
+            span: Default::default(),
+        }
+    }
+}
+
 impl ExportInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -957,7 +1009,7 @@ impl ExportInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::SymbolInfo")]
 pub struct SymbolInfo {
@@ -996,6 +1048,18 @@ impl magnus::TryConvert for SymbolInfo {
 
 unsafe impl TryConvertOwned for SymbolInfo {}
 
+impl Default for SymbolInfo {
+    fn default() -> Self {
+        Self {
+            name: String::new(),
+            kind: Default::default(),
+            span: Default::default(),
+            type_annotation: None,
+            doc: None,
+        }
+    }
+}
+
 impl SymbolInfo {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1045,7 +1109,7 @@ impl SymbolInfo {
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "TreeSitterLanguagePack::Diagnostic")]
 pub struct Diagnostic {
@@ -1082,6 +1146,16 @@ impl magnus::TryConvert for Diagnostic {
 
 unsafe impl TryConvertOwned for Diagnostic {}
 
+impl Default for Diagnostic {
+    fn default() -> Self {
+        Self {
+            message: String::new(),
+            severity: Default::default(),
+            span: Default::default(),
+        }
+    }
+}
+
 impl Diagnostic {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -1435,25 +1509,17 @@ impl PackConfig {
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[serde(default)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::ProcessConfig")]
-pub struct ProcessConfig {
-    language: String,
-    structure: bool,
-    imports: bool,
-    exports: bool,
-    comments: bool,
-    docstrings: bool,
-    symbols: bool,
-    diagnostics: bool,
-    chunk_max_size: Option<usize>,
+#[magnus::wrap(class = "TreeSitterLanguagePack::Point")]
+pub struct Point {
+    row: usize,
+    column: usize,
 }
 
-unsafe impl IntoValueFromNative for ProcessConfig {}
+unsafe impl IntoValueFromNative for Point {}
 
-impl magnus::TryConvert for ProcessConfig {
+impl magnus::TryConvert for Point {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&ProcessConfig as magnus::TryConvert>::try_convert(val) {
+        if let Ok(r) = <&Point as magnus::TryConvert>::try_convert(val) {
             return Ok(r.clone());
         }
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
@@ -1462,246 +1528,360 @@ impl magnus::TryConvert for ProcessConfig {
             val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
                 magnus::Error::new(
                     unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into ProcessConfig: {}", e),
+                    format!("no implicit conversion into Point: {}", e),
                 )
             })?
         };
-        serde_json::from_str::<ProcessConfig>(&json_str).map_err(|e| {
+        serde_json::from_str::<Point>(&json_str).map_err(|e| {
             magnus::Error::new(
                 unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize ProcessConfig: {}", e),
+                format!("failed to deserialize Point: {}", e),
             )
         })
     }
 }
 
-unsafe impl TryConvertOwned for ProcessConfig {}
+unsafe impl TryConvertOwned for Point {}
 
-impl Default for ProcessConfig {
-    fn default() -> Self {
-        tree_sitter_language_pack::ProcessConfig::default().into()
+impl Point {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            row: kwargs
+                .get(ruby.to_symbol("row"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            column: kwargs
+                .get(ruby.to_symbol("column"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn row(&self) -> usize {
+        self.row
+    }
+
+    fn column(&self) -> usize {
+        self.column
     }
 }
 
-impl ProcessConfig {
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::ByteRange")]
+pub struct ByteRange {
+    start: usize,
+    end: usize,
+}
+
+unsafe impl IntoValueFromNative for ByteRange {}
+
+impl magnus::TryConvert for ByteRange {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ByteRange as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into ByteRange: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ByteRange>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ByteRange: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ByteRange {}
+
+impl ByteRange {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
         let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            language: kwargs
-                .get(ruby.to_symbol("language"))
-                .and_then(|v| String::try_convert(v).ok())
+            start: kwargs
+                .get(ruby.to_symbol("start"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            end: kwargs
+                .get(ruby.to_symbol("end"))
+                .and_then(|v| usize::try_convert(v).ok())
                 .unwrap_or_default(),
-            structure: kwargs
-                .get(ruby.to_symbol("structure"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            imports: kwargs
-                .get(ruby.to_symbol("imports"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            exports: kwargs
-                .get(ruby.to_symbol("exports"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(true),
-            comments: kwargs
-                .get(ruby.to_symbol("comments"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            docstrings: kwargs
-                .get(ruby.to_symbol("docstrings"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            symbols: kwargs
-                .get(ruby.to_symbol("symbols"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            diagnostics: kwargs
-                .get(ruby.to_symbol("diagnostics"))
-                .and_then(|v| bool::try_convert(v).ok())
-                .unwrap_or(false),
-            chunk_max_size: kwargs
-                .get(ruby.to_symbol("chunk_max_size"))
-                .and_then(|v| usize::try_convert(v).ok()),
         })
     }
 
-    fn language(&self) -> String {
-        self.language.clone()
+    fn start(&self) -> usize {
+        self.start
     }
 
-    fn structure(&self) -> bool {
-        self.structure
+    fn end(&self) -> usize {
+        self.end
     }
+}
 
-    fn imports(&self) -> bool {
-        self.imports
-    }
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Parser")]
+pub struct Parser {
+    inner: Arc<std::sync::Mutex<tree_sitter_language_pack::Parser>>,
+}
 
-    fn exports(&self) -> bool {
-        self.exports
-    }
+unsafe impl IntoValueFromNative for Parser {}
 
-    fn comments(&self) -> bool {
-        self.comments
+impl magnus::TryConvert for Parser {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &Parser = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
     }
+}
 
-    fn docstrings(&self) -> bool {
-        self.docstrings
+unsafe impl TryConvertOwned for Parser {}
+
+impl Parser {
+    fn set_language(&self, name: String) -> Result<(), Error> {
+        self.inner.lock().unwrap().set_language(&name).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        Ok(())
     }
 
-    fn symbols(&self) -> bool {
-        self.symbols
+    fn parse(&self, source: String) -> Option<Tree> {
+        self.inner
+            .lock()
+            .unwrap()
+            .parse(&source)
+            .map(|v| Tree { inner: Arc::new(v) })
     }
 
-    fn diagnostics(&self) -> bool {
-        self.diagnostics
+    fn parse_bytes(&self, source: Vec<u8>) -> Option<Tree> {
+        self.inner
+            .lock()
+            .unwrap()
+            .parse_bytes(&source)
+            .map(|v| Tree { inner: Arc::new(v) })
     }
 
-    fn chunk_max_size(&self) -> Option<usize> {
-        self.chunk_max_size
+    fn reset(&self) -> () {
+        self.inner.lock().unwrap().reset()
     }
+}
 
-    fn with_chunking(&self, max_size: usize) -> ProcessConfig {
-        let core_self = tree_sitter_language_pack::ProcessConfig {
-            language: self.language.clone().into(),
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Tree")]
+pub struct Tree {
+    inner: Arc<tree_sitter_language_pack::Tree>,
+}
 
-            structure: self.structure,
+unsafe impl IntoValueFromNative for Tree {}
 
-            imports: self.imports,
+impl magnus::TryConvert for Tree {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &Tree = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
 
-            exports: self.exports,
+unsafe impl TryConvertOwned for Tree {}
 
-            comments: self.comments,
+impl Tree {
+    fn root_node(&self) -> Node {
+        Node {
+            inner: Arc::new(self.inner.root_node()),
+        }
+    }
 
-            docstrings: self.docstrings,
+    fn walk(&self) -> TreeCursor {
+        TreeCursor {
+            inner: Arc::new(std::sync::Mutex::new(self.inner.walk())),
+        }
+    }
+}
 
-            symbols: self.symbols,
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::Node")]
+pub struct Node {
+    inner: Arc<tree_sitter_language_pack::Node>,
+}
 
-            diagnostics: self.diagnostics,
+unsafe impl IntoValueFromNative for Node {}
 
-            chunk_max_size: self.chunk_max_size,
-        };
-        core_self.with_chunking(max_size).into()
+impl magnus::TryConvert for Node {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &Node = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
     }
+}
 
-    fn all(&self) -> ProcessConfig {
-        let core_self = tree_sitter_language_pack::ProcessConfig {
-            language: self.language.clone().into(),
+unsafe impl TryConvertOwned for Node {}
 
-            structure: self.structure,
+impl Node {
+    fn clone(&self) -> Node {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
 
-            imports: self.imports,
+    fn kind(&self) -> String {
+        self.inner.kind()
+    }
 
-            exports: self.exports,
+    fn kind_id(&self) -> u16 {
+        self.inner.kind_id()
+    }
 
-            comments: self.comments,
+    fn start_byte(&self) -> usize {
+        self.inner.start_byte()
+    }
 
-            docstrings: self.docstrings,
+    fn end_byte(&self) -> usize {
+        self.inner.end_byte()
+    }
 
-            symbols: self.symbols,
+    fn byte_range(&self) -> ByteRange {
+        self.inner.byte_range().into()
+    }
 
-            diagnostics: self.diagnostics,
+    fn start_position(&self) -> Point {
+        self.inner.start_position().into()
+    }
 
-            chunk_max_size: self.chunk_max_size,
-        };
-        core_self.all().into()
+    fn end_position(&self) -> Point {
+        self.inner.end_position().into()
     }
 
-    fn minimal(&self) -> ProcessConfig {
-        let core_self = tree_sitter_language_pack::ProcessConfig {
-            language: self.language.clone().into(),
+    fn is_named(&self) -> bool {
+        self.inner.is_named()
+    }
 
-            structure: self.structure,
+    fn is_error(&self) -> bool {
+        self.inner.is_error()
+    }
 
-            imports: self.imports,
+    fn is_missing(&self) -> bool {
+        self.inner.is_missing()
+    }
 
-            exports: self.exports,
+    fn is_extra(&self) -> bool {
+        self.inner.is_extra()
+    }
 
-            comments: self.comments,
+    fn has_error(&self) -> bool {
+        self.inner.has_error()
+    }
 
-            docstrings: self.docstrings,
+    fn parent(&self) -> Option<Node> {
+        self.inner.parent().map(|v| Node { inner: Arc::new(v) })
+    }
 
-            symbols: self.symbols,
+    fn child(&self, index: u32) -> Option<Node> {
+        self.inner.child(index).map(|v| Node { inner: Arc::new(v) })
+    }
 
-            diagnostics: self.diagnostics,
+    fn child_count(&self) -> usize {
+        self.inner.child_count()
+    }
 
-            chunk_max_size: self.chunk_max_size,
-        };
-        core_self.minimal().into()
+    fn named_child(&self, index: u32) -> Option<Node> {
+        self.inner.named_child(index).map(|v| Node { inner: Arc::new(v) })
+    }
+
+    fn named_child_count(&self) -> usize {
+        self.inner.named_child_count()
+    }
+
+    fn child_by_field_name(&self, name: String) -> Option<Node> {
+        self.inner
+            .child_by_field_name(&name)
+            .map(|v| Node { inner: Arc::new(v) })
+    }
+
+    fn to_sexp(&self) -> String {
+        self.inner.to_sexp()
+    }
+
+    fn walk(&self) -> TreeCursor {
+        TreeCursor {
+            inner: Arc::new(std::sync::Mutex::new(self.inner.walk())),
+        }
     }
 }
 
 #[derive(Clone)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::LanguageRegistry")]
-pub struct LanguageRegistry {
-    inner: Arc<tree_sitter_language_pack::LanguageRegistry>,
+#[magnus::wrap(class = "TreeSitterLanguagePack::TreeCursor")]
+pub struct TreeCursor {
+    inner: Arc<std::sync::Mutex<tree_sitter_language_pack::TreeCursor>>,
 }
 
-unsafe impl IntoValueFromNative for LanguageRegistry {}
+unsafe impl IntoValueFromNative for TreeCursor {}
 
-impl magnus::TryConvert for LanguageRegistry {
+impl magnus::TryConvert for TreeCursor {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &LanguageRegistry = magnus::TryConvert::try_convert(val)?;
+        let r: &TreeCursor = magnus::TryConvert::try_convert(val)?;
         Ok(r.clone())
     }
 }
 
-unsafe impl TryConvertOwned for LanguageRegistry {}
-
-impl LanguageRegistry {
-    fn add_extra_libs_dir(&self, dir: String) -> () {
-        self.inner.add_extra_libs_dir(std::path::PathBuf::from(dir))
-    }
+unsafe impl TryConvertOwned for TreeCursor {}
 
-    fn get_language(&self, name: String) -> Result<Language, Error> {
-        let result = self.inner.get_language(&name).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
-        Ok(Language {
-            inner: Arc::new(result),
-        })
+impl TreeCursor {
+    fn node(&self) -> Node {
+        Node {
+            inner: Arc::new(self.inner.lock().unwrap().node()),
+        }
     }
 
-    fn available_languages(&self) -> Vec<String> {
-        self.inner.available_languages()
+    fn goto_first_child(&self) -> bool {
+        self.inner.lock().unwrap().goto_first_child()
     }
 
-    fn has_language(&self, name: String) -> bool {
-        self.inner.has_language(&name)
+    fn goto_parent(&self) -> bool {
+        self.inner.lock().unwrap().goto_parent()
     }
 
-    fn language_count(&self) -> usize {
-        self.inner.language_count()
+    fn goto_next_sibling(&self) -> bool {
+        self.inner.lock().unwrap().goto_next_sibling()
     }
 
-    fn process(&self, source: String, config: ProcessConfig) -> Result<ProcessResult, Error> {
-        Err(magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            "Not implemented: process",
-        ))
+    fn field_name(&self) -> Option<String> {
+        self.inner.lock().unwrap().field_name()
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::ParserManifest")]
-pub struct ParserManifest {
-    version: String,
-    platforms: HashMap<String, PlatformBundle>,
-    languages: HashMap<String, LanguageInfo>,
-    groups: HashMap<String, Vec<String>>,
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::ProcessConfig")]
+pub struct ProcessConfig {
+    language: String,
+    structure: bool,
+    imports: bool,
+    exports: bool,
+    comments: bool,
+    docstrings: bool,
+    symbols: bool,
+    diagnostics: bool,
+    chunk_max_size: Option<usize>,
 }
 
-unsafe impl IntoValueFromNative for ParserManifest {}
+unsafe impl IntoValueFromNative for ProcessConfig {}
 
-impl magnus::TryConvert for ParserManifest {
+impl magnus::TryConvert for ProcessConfig {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&ParserManifest as magnus::TryConvert>::try_convert(val) {
+        if let Ok(r) = <&ProcessConfig as magnus::TryConvert>::try_convert(val) {
             return Ok(r.clone());
         }
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
@@ -1710,194 +1890,229 @@ impl magnus::TryConvert for ParserManifest {
             val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
                 magnus::Error::new(
                     unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into ParserManifest: {}", e),
+                    format!("no implicit conversion into ProcessConfig: {}", e),
                 )
             })?
         };
-        serde_json::from_str::<ParserManifest>(&json_str).map_err(|e| {
+        serde_json::from_str::<ProcessConfig>(&json_str).map_err(|e| {
             magnus::Error::new(
                 unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize ParserManifest: {}", e),
+                format!("failed to deserialize ProcessConfig: {}", e),
             )
         })
     }
 }
 
-unsafe impl TryConvertOwned for ParserManifest {}
+unsafe impl TryConvertOwned for ProcessConfig {}
 
-impl ParserManifest {
+impl Default for ProcessConfig {
+    fn default() -> Self {
+        tree_sitter_language_pack::ProcessConfig::default().into()
+    }
+}
+
+impl ProcessConfig {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
         let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
-            version: kwargs
-                .get(ruby.to_symbol("version"))
+            language: kwargs
+                .get(ruby.to_symbol("language"))
                 .and_then(|v| String::try_convert(v).ok())
                 .unwrap_or_default(),
-            platforms: kwargs
-                .get(ruby.to_symbol("platforms"))
-                .and_then(|v| <HashMap<String, PlatformBundle>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            languages: kwargs
-                .get(ruby.to_symbol("languages"))
-                .and_then(|v| <HashMap<String, LanguageInfo>>::try_convert(v).ok())
-                .unwrap_or_default(),
-            groups: kwargs
-                .get(ruby.to_symbol("groups"))
-                .and_then(|v| <HashMap<String, Vec<String>>>::try_convert(v).ok())
-                .unwrap_or_default(),
+            structure: kwargs
+                .get(ruby.to_symbol("structure"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            imports: kwargs
+                .get(ruby.to_symbol("imports"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            exports: kwargs
+                .get(ruby.to_symbol("exports"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            comments: kwargs
+                .get(ruby.to_symbol("comments"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            docstrings: kwargs
+                .get(ruby.to_symbol("docstrings"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            symbols: kwargs
+                .get(ruby.to_symbol("symbols"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            diagnostics: kwargs
+                .get(ruby.to_symbol("diagnostics"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            chunk_max_size: kwargs
+                .get(ruby.to_symbol("chunk_max_size"))
+                .and_then(|v| usize::try_convert(v).ok()),
         })
     }
 
-    fn version(&self) -> String {
-        self.version.clone()
+    fn language(&self) -> String {
+        self.language.clone()
     }
 
-    fn platforms(&self) -> HashMap<String, PlatformBundle> {
-        self.platforms.clone()
+    fn structure(&self) -> bool {
+        self.structure
     }
 
-    fn languages(&self) -> HashMap<String, LanguageInfo> {
-        self.languages.clone()
+    fn imports(&self) -> bool {
+        self.imports
     }
 
-    fn groups(&self) -> HashMap<String, Vec<String>> {
-        self.groups.clone()
+    fn exports(&self) -> bool {
+        self.exports
     }
-}
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::PlatformBundle")]
-pub struct PlatformBundle {
-    url: String,
-    sha256: String,
-    size: u64,
-}
+    fn comments(&self) -> bool {
+        self.comments
+    }
 
-unsafe impl IntoValueFromNative for PlatformBundle {}
+    fn docstrings(&self) -> bool {
+        self.docstrings
+    }
 
-impl magnus::TryConvert for PlatformBundle {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&PlatformBundle as magnus::TryConvert>::try_convert(val) {
-            return Ok(r.clone());
-        }
-        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
-            s
-        } else {
-            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
-                magnus::Error::new(
-                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into PlatformBundle: {}", e),
-                )
-            })?
-        };
-        serde_json::from_str::<PlatformBundle>(&json_str).map_err(|e| {
-            magnus::Error::new(
-                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize PlatformBundle: {}", e),
-            )
-        })
+    fn symbols(&self) -> bool {
+        self.symbols
     }
-}
 
-unsafe impl TryConvertOwned for PlatformBundle {}
+    fn diagnostics(&self) -> bool {
+        self.diagnostics
+    }
 
-impl PlatformBundle {
-    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
-        let ruby = unsafe { magnus::Ruby::get_unchecked() };
-        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
-        let (kwargs_opt,) = args.optional;
-        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
-        Ok(Self {
-            url: kwargs
-                .get(ruby.to_symbol("url"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            sha256: kwargs
-                .get(ruby.to_symbol("sha256"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            size: kwargs
-                .get(ruby.to_symbol("size"))
-                .and_then(|v| u64::try_convert(v).ok())
-                .unwrap_or_default(),
-        })
+    fn chunk_max_size(&self) -> Option<usize> {
+        self.chunk_max_size
     }
 
-    fn url(&self) -> String {
-        self.url.clone()
+    fn with_chunking(&self, max_size: usize) -> ProcessConfig {
+        let core_self = tree_sitter_language_pack::ProcessConfig {
+            language: self.language.clone().into(),
+
+            structure: self.structure,
+
+            imports: self.imports,
+
+            exports: self.exports,
+
+            comments: self.comments,
+
+            docstrings: self.docstrings,
+
+            symbols: self.symbols,
+
+            diagnostics: self.diagnostics,
+
+            chunk_max_size: self.chunk_max_size,
+        };
+        core_self.with_chunking(max_size).into()
     }
 
-    fn sha256(&self) -> String {
-        self.sha256.clone()
+    fn all(&self) -> ProcessConfig {
+        let core_self = tree_sitter_language_pack::ProcessConfig {
+            language: self.language.clone().into(),
+
+            structure: self.structure,
+
+            imports: self.imports,
+
+            exports: self.exports,
+
+            comments: self.comments,
+
+            docstrings: self.docstrings,
+
+            symbols: self.symbols,
+
+            diagnostics: self.diagnostics,
+
+            chunk_max_size: self.chunk_max_size,
+        };
+        core_self.all().into()
     }
 
-    fn size(&self) -> u64 {
-        self.size
+    fn minimal(&self) -> ProcessConfig {
+        let core_self = tree_sitter_language_pack::ProcessConfig {
+            language: self.language.clone().into(),
+
+            structure: self.structure,
+
+            imports: self.imports,
+
+            exports: self.exports,
+
+            comments: self.comments,
+
+            docstrings: self.docstrings,
+
+            symbols: self.symbols,
+
+            diagnostics: self.diagnostics,
+
+            chunk_max_size: self.chunk_max_size,
+        };
+        core_self.minimal().into()
     }
 }
 
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::LanguageInfo")]
-pub struct LanguageInfo {
-    group: String,
-    size: u64,
+#[derive(Clone)]
+#[magnus::wrap(class = "TreeSitterLanguagePack::LanguageRegistry")]
+pub struct LanguageRegistry {
+    inner: Arc<tree_sitter_language_pack::LanguageRegistry>,
 }
 
-unsafe impl IntoValueFromNative for LanguageInfo {}
+unsafe impl IntoValueFromNative for LanguageRegistry {}
 
-impl magnus::TryConvert for LanguageInfo {
+impl magnus::TryConvert for LanguageRegistry {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&LanguageInfo as magnus::TryConvert>::try_convert(val) {
-            return Ok(r.clone());
-        }
-        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
-            s
-        } else {
-            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
-                magnus::Error::new(
-                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into LanguageInfo: {}", e),
-                )
-            })?
-        };
-        serde_json::from_str::<LanguageInfo>(&json_str).map_err(|e| {
+        let r: &LanguageRegistry = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for LanguageRegistry {}
+
+impl LanguageRegistry {
+    fn get_language(&self, name: String) -> Result<Language, Error> {
+        let result = self.inner.get_language(&name).map_err(|e| {
             magnus::Error::new(
-                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize LanguageInfo: {}", e),
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
             )
+        })?;
+        Ok(Language {
+            inner: Arc::new(result),
         })
     }
-}
 
-unsafe impl TryConvertOwned for LanguageInfo {}
+    fn available_languages(&self) -> Vec<String> {
+        self.inner.available_languages()
+    }
 
-impl LanguageInfo {
-    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
-        let ruby = unsafe { magnus::Ruby::get_unchecked() };
-        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
-        let (kwargs_opt,) = args.optional;
-        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
-        Ok(Self {
-            group: kwargs
-                .get(ruby.to_symbol("group"))
-                .and_then(|v| String::try_convert(v).ok())
-                .unwrap_or_default(),
-            size: kwargs
-                .get(ruby.to_symbol("size"))
-                .and_then(|v| u64::try_convert(v).ok())
-                .unwrap_or_default(),
-        })
+    fn has_language(&self, name: String) -> bool {
+        self.inner.has_language(&name)
     }
 
-    fn group(&self) -> String {
-        self.group.clone()
+    fn language_count(&self) -> usize {
+        self.inner.language_count()
     }
 
-    fn size(&self) -> u64 {
-        self.size
+    fn process(&self, source: String, config: ProcessConfig) -> Result<ProcessResult, Error> {
+        let config_core: tree_sitter_language_pack::ProcessConfig = config.into();
+        let result = self.inner.process(&source, &config_core).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        Ok(result.into())
     }
 }
 
@@ -1919,45 +2134,10 @@ impl magnus::TryConvert for DownloadManager {
 unsafe impl TryConvertOwned for DownloadManager {}
 
 impl DownloadManager {
-    fn cache_dir(&self) -> String {
-        self.inner.cache_dir().to_string_lossy().to_string()
-    }
-
     fn installed_languages(&self) -> Vec<String> {
         self.inner.installed_languages()
     }
 
-    fn ensure_languages(&self, names: Vec<String>) -> Result<(), Error> {
-        Err(magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            "Not implemented: ensure_languages",
-        ))
-    }
-
-    fn ensure_group(&self, group: String) -> Result<(), Error> {
-        self.inner.ensure_group(&group).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
-        Ok(())
-    }
-
-    fn lib_path(&self, name: String) -> String {
-        self.inner.lib_path(&name).to_string_lossy().to_string()
-    }
-
-    fn fetch_manifest(&self) -> Result<ParserManifest, Error> {
-        let result = self.inner.fetch_manifest().map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
-        Ok(result.into())
-    }
-
     fn download_all_best_effort(&self) -> Result<usize, Error> {
         let result = self.inner.download_all_best_effort().map_err(|e| {
             magnus::Error::new(
@@ -1998,44 +2178,6 @@ unsafe impl TryConvertOwned for Language {}
 
 impl Language {}
 
-#[derive(Clone)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::Parser")]
-pub struct Parser {
-    inner: Arc<tree_sitter_language_pack::Parser>,
-}
-
-unsafe impl IntoValueFromNative for Parser {}
-
-impl magnus::TryConvert for Parser {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &Parser = magnus::TryConvert::try_convert(val)?;
-        Ok(r.clone())
-    }
-}
-
-unsafe impl TryConvertOwned for Parser {}
-
-impl Parser {}
-
-#[derive(Clone)]
-#[magnus::wrap(class = "TreeSitterLanguagePack::Tree")]
-pub struct Tree {
-    inner: Arc<tree_sitter_language_pack::Tree>,
-}
-
-unsafe impl IntoValueFromNative for Tree {}
-
-impl magnus::TryConvert for Tree {
-    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let r: &Tree = magnus::TryConvert::try_convert(val)?;
-        Ok(r.clone())
-    }
-}
-
-unsafe impl TryConvertOwned for Tree {}
-
-impl Tree {}
-
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum StructureKind {
     Function,
@@ -2068,15 +2210,26 @@ impl magnus::IntoValue for StructureKind {
 
 impl magnus::TryConvert for StructureKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into StructureKind: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // If that fails, try treating it as a plain string value and wrap in quotes
         // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&s)
-            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2115,10 +2268,12 @@ impl magnus::IntoValue for CommentKind {
 impl magnus::TryConvert for CommentKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "line" => Ok(CommentKind::Line),
-            "block" => Ok(CommentKind::Block),
-            "doc" => Ok(CommentKind::Doc),
+            "line" | "Line" => Ok(CommentKind::Line),
+            "block" | "Block" => Ok(CommentKind::Block),
+            "doc" | "Doc" => Ok(CommentKind::Doc),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid CommentKind value: {other}"),
@@ -2157,15 +2312,26 @@ impl magnus::IntoValue for DocstringFormat {
 
 impl magnus::TryConvert for DocstringFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into DocstringFormat: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // If that fails, try treating it as a plain string value and wrap in quotes
         // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&s)
-            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2204,10 +2370,12 @@ impl magnus::IntoValue for ExportKind {
 impl magnus::TryConvert for ExportKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "named" => Ok(ExportKind::Named),
-            "default" => Ok(ExportKind::Default),
-            "re_export" => Ok(ExportKind::ReExport),
+            "named" | "Named" => Ok(ExportKind::Named),
+            "default" | "Default" => Ok(ExportKind::Default),
+            "re_export" | "ReExport" => Ok(ExportKind::ReExport),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid ExportKind value: {other}"),
@@ -2249,15 +2417,26 @@ impl magnus::IntoValue for SymbolKind {
 
 impl magnus::TryConvert for SymbolKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"")
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into SymbolKind: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
         // If that fails, try treating it as a plain string value and wrap in quotes
         // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&s)
-            .or_else(|_| serde_json::from_str(&format!("\"{s}\"")))
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
             .or_else(|_| {
                 // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&s) {
+                match serde_json::to_value(&json_str) {
                     Ok(val) => serde_json::from_value(val),
                     Err(e) => Err(e),
                 }
@@ -2296,10 +2475,12 @@ impl magnus::IntoValue for DiagnosticSeverity {
 impl magnus::TryConvert for DiagnosticSeverity {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
         match s.as_str() {
-            "error" => Ok(DiagnosticSeverity::Error),
-            "warning" => Ok(DiagnosticSeverity::Warning),
-            "info" => Ok(DiagnosticSeverity::Info),
+            "error" | "Error" => Ok(DiagnosticSeverity::Error),
+            "warning" | "Warning" => Ok(DiagnosticSeverity::Warning),
+            "info" | "Info" => Ok(DiagnosticSeverity::Info),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid DiagnosticSeverity value: {other}"),
@@ -2355,7 +2536,7 @@ fn get_parser(name: String) -> Result<Parser, Error> {
         )
     })?;
     Ok(Parser {
-        inner: Arc::new(result),
+        inner: Arc::new(std::sync::Mutex::new(result)),
     })
 }
 
@@ -2378,7 +2559,9 @@ fn language_count() -> usize {
 fn process(args: &[magnus::Value]) -> Result<ProcessResult, Error> {
     let args = magnus::scan_args::scan_args::<(String,), (Option<magnus::Value>,), (), (), (), ()>(args)?;
     let (source,) = args.required;
+
     let (config,) = args.optional;
+
     let config_core: tree_sitter_language_pack::ProcessConfig = match config {
         Some(_v) if !_v.is_nil() => {
             let binding_val: ProcessConfig = ProcessConfig::try_convert(_v).map_err(|e| {
@@ -2403,6 +2586,7 @@ fn process(args: &[magnus::Value]) -> Result<ProcessResult, Error> {
 fn init(args: &[magnus::Value]) -> Result<(), Error> {
     let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
     let (config,) = args.optional;
+
     let config_core: tree_sitter_language_pack::PackConfig = match config {
         Some(_v) if !_v.is_nil() => {
             let binding_val: PackConfig = PackConfig::try_convert(_v).map_err(|e| {
@@ -2427,6 +2611,7 @@ fn init(args: &[magnus::Value]) -> Result<(), Error> {
 fn configure(args: &[magnus::Value]) -> Result<(), Error> {
     let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
     let (config,) = args.optional;
+
     let config_core: tree_sitter_language_pack::PackConfig = match config {
         Some(_v) if !_v.is_nil() => {
             let binding_val: PackConfig = PackConfig::try_convert(_v).map_err(|e| {
@@ -2469,6 +2654,16 @@ fn download_all() -> Result<usize, Error> {
     Ok(result)
 }
 
+fn download_group(name: String) -> Result<usize, Error> {
+    let result = tree_sitter_language_pack::download_group(&name).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
 fn manifest_languages() -> Result<Vec<String>, Error> {
     let result = tree_sitter_language_pack::manifest_languages().map_err(|e| {
         magnus::Error::new(
@@ -2608,7 +2803,7 @@ impl From<StructureItem> for tree_sitter_language_pack::StructureItem {
             visibility: val.visibility,
             span: val.span.into(),
             children: val.children.into_iter().map(Into::into).collect(),
-            decorators: val.decorators,
+            decorators: val.decorators.into_iter().collect(),
             doc_comment: val.doc_comment,
             signature: val.signature,
             body_span: val.body_span.map(Into::into),
@@ -2625,7 +2820,7 @@ impl From<tree_sitter_language_pack::StructureItem> for StructureItem {
             visibility: val.visibility,
             span: val.span.into(),
             children: val.children.into_iter().map(Into::into).collect(),
-            decorators: val.decorators,
+            decorators: val.decorators.into_iter().collect(),
             doc_comment: val.doc_comment,
             signature: val.signature,
             body_span: val.body_span.map(Into::into),
@@ -2710,7 +2905,7 @@ impl From<ImportInfo> for tree_sitter_language_pack::ImportInfo {
     fn from(val: ImportInfo) -> Self {
         Self {
             source: val.source,
-            items: val.items,
+            items: val.items.into_iter().collect(),
             alias: val.alias,
             is_wildcard: val.is_wildcard,
             span: val.span.into(),
@@ -2723,7 +2918,7 @@ impl From<tree_sitter_language_pack::ImportInfo> for ImportInfo {
     fn from(val: tree_sitter_language_pack::ImportInfo) -> Self {
         Self {
             source: val.source,
-            items: val.items,
+            items: val.items.into_iter().collect(),
             alias: val.alias,
             is_wildcard: val.is_wildcard,
             span: val.span.into(),
@@ -2836,9 +3031,9 @@ impl From<ChunkContext> for tree_sitter_language_pack::ChunkContext {
             language: val.language,
             chunk_index: val.chunk_index,
             total_chunks: val.total_chunks,
-            node_types: val.node_types,
-            context_path: val.context_path,
-            symbols_defined: val.symbols_defined,
+            node_types: val.node_types.into_iter().collect(),
+            context_path: val.context_path.into_iter().collect(),
+            symbols_defined: val.symbols_defined.into_iter().collect(),
             comments: val.comments.into_iter().map(Into::into).collect(),
             docstrings: val.docstrings.into_iter().map(Into::into).collect(),
             has_error_nodes: val.has_error_nodes,
@@ -2853,9 +3048,9 @@ impl From<tree_sitter_language_pack::ChunkContext> for ChunkContext {
             language: val.language,
             chunk_index: val.chunk_index,
             total_chunks: val.total_chunks,
-            node_types: val.node_types,
-            context_path: val.context_path,
-            symbols_defined: val.symbols_defined,
+            node_types: val.node_types.into_iter().collect(),
+            context_path: val.context_path.into_iter().collect(),
+            symbols_defined: val.symbols_defined.into_iter().collect(),
             comments: val.comments.into_iter().map(Into::into).collect(),
             docstrings: val.docstrings.into_iter().map(Into::into).collect(),
             has_error_nodes: val.has_error_nodes,
@@ -2868,8 +3063,8 @@ impl From<PackConfig> for tree_sitter_language_pack::PackConfig {
     fn from(val: PackConfig) -> Self {
         Self {
             cache_dir: val.cache_dir.map(Into::into),
-            languages: val.languages,
-            groups: val.groups,
+            languages: val.languages.map(|v| v.into_iter().collect()),
+            groups: val.groups.map(|v| v.into_iter().collect()),
         }
     }
 }
@@ -2879,108 +3074,82 @@ impl From<tree_sitter_language_pack::PackConfig> for PackConfig {
     fn from(val: tree_sitter_language_pack::PackConfig) -> Self {
         Self {
             cache_dir: val.cache_dir.map(|p| p.to_string_lossy().to_string()),
-            languages: val.languages,
-            groups: val.groups,
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<ProcessConfig> for tree_sitter_language_pack::ProcessConfig {
-    fn from(val: ProcessConfig) -> Self {
-        Self {
-            language: val.language.into(),
-            structure: val.structure,
-            imports: val.imports,
-            exports: val.exports,
-            comments: val.comments,
-            docstrings: val.docstrings,
-            symbols: val.symbols,
-            diagnostics: val.diagnostics,
-            chunk_max_size: val.chunk_max_size,
-        }
-    }
-}
-
-#[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::ProcessConfig> for ProcessConfig {
-    fn from(val: tree_sitter_language_pack::ProcessConfig) -> Self {
-        Self {
-            language: val.language.to_string(),
-            structure: val.structure,
-            imports: val.imports,
-            exports: val.exports,
-            comments: val.comments,
-            docstrings: val.docstrings,
-            symbols: val.symbols,
-            diagnostics: val.diagnostics,
-            chunk_max_size: val.chunk_max_size,
+            languages: val.languages.map(|v| v.into_iter().collect()),
+            groups: val.groups.map(|v| v.into_iter().collect()),
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<ParserManifest> for tree_sitter_language_pack::download::ParserManifest {
-    fn from(val: ParserManifest) -> Self {
+impl From<Point> for tree_sitter_language_pack::Point {
+    fn from(val: Point) -> Self {
         Self {
-            version: val.version,
-            platforms: val.platforms.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
-            languages: val.languages.into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
-            groups: val.groups.into_iter().collect(),
+            row: val.row,
+            column: val.column,
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::download::ParserManifest> for ParserManifest {
-    fn from(val: tree_sitter_language_pack::download::ParserManifest) -> Self {
+impl From<tree_sitter_language_pack::Point> for Point {
+    fn from(val: tree_sitter_language_pack::Point) -> Self {
         Self {
-            version: val.version,
-            platforms: val.platforms.into_iter().map(|(k, v)| (k, v.into())).collect(),
-            languages: val.languages.into_iter().map(|(k, v)| (k, v.into())).collect(),
-            groups: val.groups.into_iter().collect(),
+            row: val.row,
+            column: val.column,
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<PlatformBundle> for tree_sitter_language_pack::download::PlatformBundle {
-    fn from(val: PlatformBundle) -> Self {
+impl From<ByteRange> for tree_sitter_language_pack::ByteRange {
+    fn from(val: ByteRange) -> Self {
         Self {
-            url: val.url,
-            sha256: val.sha256,
-            size: val.size,
+            start: val.start,
+            end: val.end,
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::download::PlatformBundle> for PlatformBundle {
-    fn from(val: tree_sitter_language_pack::download::PlatformBundle) -> Self {
+impl From<tree_sitter_language_pack::ByteRange> for ByteRange {
+    fn from(val: tree_sitter_language_pack::ByteRange) -> Self {
         Self {
-            url: val.url,
-            sha256: val.sha256,
-            size: val.size,
+            start: val.start,
+            end: val.end,
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<LanguageInfo> for tree_sitter_language_pack::download::LanguageInfo {
-    fn from(val: LanguageInfo) -> Self {
+impl From<ProcessConfig> for tree_sitter_language_pack::ProcessConfig {
+    fn from(val: ProcessConfig) -> Self {
         Self {
-            group: val.group,
-            size: val.size,
+            language: val.language.into(),
+            structure: val.structure,
+            imports: val.imports,
+            exports: val.exports,
+            comments: val.comments,
+            docstrings: val.docstrings,
+            symbols: val.symbols,
+            diagnostics: val.diagnostics,
+            chunk_max_size: val.chunk_max_size,
         }
     }
 }
 
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
-impl From<tree_sitter_language_pack::download::LanguageInfo> for LanguageInfo {
-    fn from(val: tree_sitter_language_pack::download::LanguageInfo) -> Self {
+impl From<tree_sitter_language_pack::ProcessConfig> for ProcessConfig {
+    fn from(val: tree_sitter_language_pack::ProcessConfig) -> Self {
         Self {
-            group: val.group,
-            size: val.size,
+            language: val.language.to_string(),
+            structure: val.structure,
+            imports: val.imports,
+            exports: val.exports,
+            comments: val.comments,
+            docstrings: val.docstrings,
+            symbols: val.symbols,
+            diagnostics: val.diagnostics,
+            chunk_max_size: val.chunk_max_size,
         }
     }
 }
@@ -3150,214 +3319,400 @@ fn error_to_magnus_err(e: tree_sitter_language_pack::error::Error) -> magnus::Er
 fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("TreeSitterLanguagePack")?;
 
+    // Ensure JSON library is loaded for Hash#to_json
+    let _ = ruby.eval::<magnus::Value>("require \"json\"");
+
     let class = module.define_class("Span", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(Span::new, -1))?;
+
     class.define_method("start_byte", method!(Span::start_byte, 0))?;
+
     class.define_method("end_byte", method!(Span::end_byte, 0))?;
+
     class.define_method("start_line", method!(Span::start_line, 0))?;
+
     class.define_method("start_column", method!(Span::start_column, 0))?;
+
     class.define_method("end_line", method!(Span::end_line, 0))?;
+
     class.define_method("end_column", method!(Span::end_column, 0))?;
 
     let class = module.define_class("ProcessResult", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ProcessResult::new, -1))?;
+
     class.define_method("language", method!(ProcessResult::language, 0))?;
+
     class.define_method("metrics", method!(ProcessResult::metrics, 0))?;
+
     class.define_method("structure", method!(ProcessResult::structure, 0))?;
+
     class.define_method("imports", method!(ProcessResult::imports, 0))?;
+
     class.define_method("exports", method!(ProcessResult::exports, 0))?;
+
     class.define_method("comments", method!(ProcessResult::comments, 0))?;
+
     class.define_method("docstrings", method!(ProcessResult::docstrings, 0))?;
+
     class.define_method("symbols", method!(ProcessResult::symbols, 0))?;
+
     class.define_method("diagnostics", method!(ProcessResult::diagnostics, 0))?;
+
     class.define_method("chunks", method!(ProcessResult::chunks, 0))?;
 
     let class = module.define_class("FileMetrics", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(FileMetrics::new, -1))?;
+
     class.define_method("total_lines", method!(FileMetrics::total_lines, 0))?;
+
     class.define_method("code_lines", method!(FileMetrics::code_lines, 0))?;
+
     class.define_method("comment_lines", method!(FileMetrics::comment_lines, 0))?;
+
     class.define_method("blank_lines", method!(FileMetrics::blank_lines, 0))?;
+
     class.define_method("total_bytes", method!(FileMetrics::total_bytes, 0))?;
+
     class.define_method("node_count", method!(FileMetrics::node_count, 0))?;
+
     class.define_method("error_count", method!(FileMetrics::error_count, 0))?;
+
     class.define_method("max_depth", method!(FileMetrics::max_depth, 0))?;
 
     let class = module.define_class("StructureItem", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(StructureItem::new, -1))?;
+
     class.define_method("kind", method!(StructureItem::kind, 0))?;
+
     class.define_method("name", method!(StructureItem::name, 0))?;
+
     class.define_method("visibility", method!(StructureItem::visibility, 0))?;
+
     class.define_method("span", method!(StructureItem::span, 0))?;
+
     class.define_method("children", method!(StructureItem::children, 0))?;
+
     class.define_method("decorators", method!(StructureItem::decorators, 0))?;
+
     class.define_method("doc_comment", method!(StructureItem::doc_comment, 0))?;
+
     class.define_method("signature", method!(StructureItem::signature, 0))?;
+
     class.define_method("body_span", method!(StructureItem::body_span, 0))?;
 
     let class = module.define_class("CommentInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(CommentInfo::new, -1))?;
+
     class.define_method("text", method!(CommentInfo::text, 0))?;
+
     class.define_method("kind", method!(CommentInfo::kind, 0))?;
+
     class.define_method("span", method!(CommentInfo::span, 0))?;
+
     class.define_method("associated_node", method!(CommentInfo::associated_node, 0))?;
 
     let class = module.define_class("DocstringInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocstringInfo::new, -1))?;
+
     class.define_method("text", method!(DocstringInfo::text, 0))?;
+
     class.define_method("format", method!(DocstringInfo::format, 0))?;
+
     class.define_method("span", method!(DocstringInfo::span, 0))?;
+
     class.define_method("associated_item", method!(DocstringInfo::associated_item, 0))?;
+
     class.define_method("parsed_sections", method!(DocstringInfo::parsed_sections, 0))?;
 
     let class = module.define_class("DocSection", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(DocSection::new, -1))?;
+
     class.define_method("kind", method!(DocSection::kind, 0))?;
+
     class.define_method("name", method!(DocSection::name, 0))?;
+
     class.define_method("description", method!(DocSection::description, 0))?;
 
     let class = module.define_class("ImportInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ImportInfo::new, -1))?;
+
     class.define_method("source", method!(ImportInfo::source, 0))?;
+
     class.define_method("items", method!(ImportInfo::items, 0))?;
+
     class.define_method("alias", method!(ImportInfo::alias, 0))?;
+
     class.define_method("is_wildcard", method!(ImportInfo::is_wildcard, 0))?;
+
     class.define_method("span", method!(ImportInfo::span, 0))?;
 
     let class = module.define_class("ExportInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ExportInfo::new, -1))?;
+
     class.define_method("name", method!(ExportInfo::name, 0))?;
+
     class.define_method("kind", method!(ExportInfo::kind, 0))?;
+
     class.define_method("span", method!(ExportInfo::span, 0))?;
 
     let class = module.define_class("SymbolInfo", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(SymbolInfo::new, -1))?;
+
     class.define_method("name", method!(SymbolInfo::name, 0))?;
+
     class.define_method("kind", method!(SymbolInfo::kind, 0))?;
+
     class.define_method("span", method!(SymbolInfo::span, 0))?;
+
     class.define_method("type_annotation", method!(SymbolInfo::type_annotation, 0))?;
+
     class.define_method("doc", method!(SymbolInfo::doc, 0))?;
 
     let class = module.define_class("Diagnostic", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(Diagnostic::new, -1))?;
+
     class.define_method("message", method!(Diagnostic::message, 0))?;
+
     class.define_method("severity", method!(Diagnostic::severity, 0))?;
+
     class.define_method("span", method!(Diagnostic::span, 0))?;
 
     let class = module.define_class("CodeChunk", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(CodeChunk::new, -1))?;
+
     class.define_method("content", method!(CodeChunk::content, 0))?;
+
     class.define_method("start_byte", method!(CodeChunk::start_byte, 0))?;
+
     class.define_method("end_byte", method!(CodeChunk::end_byte, 0))?;
+
     class.define_method("start_line", method!(CodeChunk::start_line, 0))?;
+
     class.define_method("end_line", method!(CodeChunk::end_line, 0))?;
+
     class.define_method("metadata", method!(CodeChunk::metadata, 0))?;
+
     class.define_method("to_s", method!(CodeChunk::to_s, 0))?;
 
     let class = module.define_class("ChunkContext", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ChunkContext::new, -1))?;
+
     class.define_method("language", method!(ChunkContext::language, 0))?;
+
     class.define_method("chunk_index", method!(ChunkContext::chunk_index, 0))?;
+
     class.define_method("total_chunks", method!(ChunkContext::total_chunks, 0))?;
+
     class.define_method("node_types", method!(ChunkContext::node_types, 0))?;
+
     class.define_method("context_path", method!(ChunkContext::context_path, 0))?;
+
     class.define_method("symbols_defined", method!(ChunkContext::symbols_defined, 0))?;
+
     class.define_method("comments", method!(ChunkContext::comments, 0))?;
+
     class.define_method("docstrings", method!(ChunkContext::docstrings, 0))?;
+
     class.define_method("has_error_nodes", method!(ChunkContext::has_error_nodes, 0))?;
 
     let class = module.define_class("PackConfig", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(PackConfig::new, -1))?;
+
     class.define_method("cache_dir", method!(PackConfig::cache_dir, 0))?;
+
     class.define_method("languages", method!(PackConfig::languages, 0))?;
+
     class.define_method("groups", method!(PackConfig::groups, 0))?;
 
+    let class = module.define_class("Point", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(Point::new, -1))?;
+
+    class.define_method("row", method!(Point::row, 0))?;
+
+    class.define_method("column", method!(Point::column, 0))?;
+
+    let class = module.define_class("ByteRange", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ByteRange::new, -1))?;
+
+    class.define_method("start", method!(ByteRange::start, 0))?;
+
+    class.define_method("end", method!(ByteRange::end, 0))?;
+
+    let class = module.define_class("Parser", ruby.class_object())?;
+
+    let class = module.define_class("Tree", ruby.class_object())?;
+
+    class.define_method("root_node", method!(Tree::root_node, 0))?;
+
+    class.define_method("walk", method!(Tree::walk, 0))?;
+
+    let class = module.define_class("Node", ruby.class_object())?;
+
+    class.define_method("clone", method!(Node::clone, 0))?;
+
+    class.define_method("kind", method!(Node::kind, 0))?;
+
+    class.define_method("kind_id", method!(Node::kind_id, 0))?;
+
+    class.define_method("start_byte", method!(Node::start_byte, 0))?;
+
+    class.define_method("end_byte", method!(Node::end_byte, 0))?;
+
+    class.define_method("byte_range", method!(Node::byte_range, 0))?;
+
+    class.define_method("start_position", method!(Node::start_position, 0))?;
+
+    class.define_method("end_position", method!(Node::end_position, 0))?;
+
+    class.define_method("is_named", method!(Node::is_named, 0))?;
+
+    class.define_method("is_error", method!(Node::is_error, 0))?;
+
+    class.define_method("is_missing", method!(Node::is_missing, 0))?;
+
+    class.define_method("is_extra", method!(Node::is_extra, 0))?;
+
+    class.define_method("has_error", method!(Node::has_error, 0))?;
+
+    class.define_method("parent", method!(Node::parent, 0))?;
+
+    class.define_method("child", method!(Node::child, 1))?;
+
+    class.define_method("child_count", method!(Node::child_count, 0))?;
+
+    class.define_method("named_child", method!(Node::named_child, 1))?;
+
+    class.define_method("named_child_count", method!(Node::named_child_count, 0))?;
+
+    class.define_method("child_by_field_name", method!(Node::child_by_field_name, 1))?;
+
+    class.define_method("to_sexp", method!(Node::to_sexp, 0))?;
+
+    class.define_method("walk", method!(Node::walk, 0))?;
+
+    let class = module.define_class("TreeCursor", ruby.class_object())?;
+
+    class.define_method("node", method!(TreeCursor::node, 0))?;
+
+    class.define_method("field_name", method!(TreeCursor::field_name, 0))?;
+
     let class = module.define_class("ProcessConfig", ruby.class_object())?;
+
     class.define_singleton_method("new", function!(ProcessConfig::new, -1))?;
+
     class.define_method("language", method!(ProcessConfig::language, 0))?;
+
     class.define_method("structure", method!(ProcessConfig::structure, 0))?;
+
     class.define_method("imports", method!(ProcessConfig::imports, 0))?;
+
     class.define_method("exports", method!(ProcessConfig::exports, 0))?;
+
     class.define_method("comments", method!(ProcessConfig::comments, 0))?;
+
     class.define_method("docstrings", method!(ProcessConfig::docstrings, 0))?;
+
     class.define_method("symbols", method!(ProcessConfig::symbols, 0))?;
+
     class.define_method("diagnostics", method!(ProcessConfig::diagnostics, 0))?;
+
     class.define_method("chunk_max_size", method!(ProcessConfig::chunk_max_size, 0))?;
+
     class.define_method("with_chunking", method!(ProcessConfig::with_chunking, 1))?;
+
     class.define_method("all", method!(ProcessConfig::all, 0))?;
+
     class.define_method("minimal", method!(ProcessConfig::minimal, 0))?;
 
     let class = module.define_class("LanguageRegistry", ruby.class_object())?;
-    class.define_method("add_extra_libs_dir", method!(LanguageRegistry::add_extra_libs_dir, 1))?;
+
     class.define_method("get_language", method!(LanguageRegistry::get_language, 1))?;
+
     class.define_method("available_languages", method!(LanguageRegistry::available_languages, 0))?;
-    class.define_method("has_language", method!(LanguageRegistry::has_language, 1))?;
-    class.define_method("language_count", method!(LanguageRegistry::language_count, 0))?;
-    class.define_method("process", method!(LanguageRegistry::process, 2))?;
 
-    let class = module.define_class("ParserManifest", ruby.class_object())?;
-    class.define_singleton_method("new", function!(ParserManifest::new, -1))?;
-    class.define_method("version", method!(ParserManifest::version, 0))?;
-    class.define_method("platforms", method!(ParserManifest::platforms, 0))?;
-    class.define_method("languages", method!(ParserManifest::languages, 0))?;
-    class.define_method("groups", method!(ParserManifest::groups, 0))?;
+    class.define_method("has_language", method!(LanguageRegistry::has_language, 1))?;
 
-    let class = module.define_class("PlatformBundle", ruby.class_object())?;
-    class.define_singleton_method("new", function!(PlatformBundle::new, -1))?;
-    class.define_method("url", method!(PlatformBundle::url, 0))?;
-    class.define_method("sha256", method!(PlatformBundle::sha256, 0))?;
-    class.define_method("size", method!(PlatformBundle::size, 0))?;
+    class.define_method("language_count", method!(LanguageRegistry::language_count, 0))?;
 
-    let class = module.define_class("LanguageInfo", ruby.class_object())?;
-    class.define_singleton_method("new", function!(LanguageInfo::new, -1))?;
-    class.define_method("group", method!(LanguageInfo::group, 0))?;
-    class.define_method("size", method!(LanguageInfo::size, 0))?;
+    class.define_method("process", method!(LanguageRegistry::process, 2))?;
 
     let class = module.define_class("DownloadManager", ruby.class_object())?;
-    class.define_method("cache_dir", method!(DownloadManager::cache_dir, 0))?;
+
     class.define_method("installed_languages", method!(DownloadManager::installed_languages, 0))?;
-    class.define_method("ensure_languages", method!(DownloadManager::ensure_languages, 1))?;
-    class.define_method("ensure_group", method!(DownloadManager::ensure_group, 1))?;
-    class.define_method("lib_path", method!(DownloadManager::lib_path, 1))?;
-    class.define_method("fetch_manifest", method!(DownloadManager::fetch_manifest, 0))?;
+
     class.define_method(
         "download_all_best_effort",
         method!(DownloadManager::download_all_best_effort, 0),
     )?;
+
     class.define_method("clean_cache", method!(DownloadManager::clean_cache, 0))?;
 
     let _class = module.define_class("Language", ruby.class_object())?;
 
-    let _class = module.define_class("Parser", ruby.class_object())?;
-
-    let _class = module.define_class("Tree", ruby.class_object())?;
-
     module.define_module_function(
         "detect_language_from_extension",
         function!(detect_language_from_extension, 1),
     )?;
+
     module.define_module_function("detect_language_from_path", function!(detect_language_from_path, 1))?;
+
     module.define_module_function(
         "detect_language_from_content",
         function!(detect_language_from_content, 1),
     )?;
+
     module.define_module_function("get_highlights_query", function!(get_highlights_query, 1))?;
+
     module.define_module_function("get_injections_query", function!(get_injections_query, 1))?;
+
     module.define_module_function("get_locals_query", function!(get_locals_query, 1))?;
+
     module.define_module_function("get_language", function!(get_language, 1))?;
+
     module.define_module_function("get_parser", function!(get_parser, 1))?;
+
     module.define_module_function("detect_language", function!(detect_language, 1))?;
+
     module.define_module_function("available_languages", function!(available_languages, 0))?;
+
     module.define_module_function("has_language", function!(has_language, 1))?;
+
     module.define_module_function("language_count", function!(language_count, 0))?;
+
     module.define_module_function("process", function!(process, -1))?;
+
     module.define_module_function("init", function!(init, -1))?;
+
     module.define_module_function("configure", function!(configure, -1))?;
+
     module.define_module_function("download", function!(download, 1))?;
+
     module.define_module_function("download_all", function!(download_all, 0))?;
+
+    module.define_module_function("download_group", function!(download_group, 1))?;
+
     module.define_module_function("manifest_languages", function!(manifest_languages, 0))?;
+
     module.define_module_function("downloaded_languages", function!(downloaded_languages, 0))?;
+
     module.define_module_function("clean_cache", function!(clean_cache, 0))?;
+
     module.define_module_function("cache_dir", function!(cache_dir, 0))?;
 
     Ok(())