global: snapshot

crates/brk_bindgen/src/generators/javascript/tree.rs

@@ -6,8 +6,9 @@ use std::fmt::Write;
 use brk_types::TreeNode;
 
 use crate::{
-    ClientMetadata, Endpoint, PatternField, child_type_name, get_first_leaf_name, get_node_fields,
-    get_pattern_instance_base, infer_accumulated_name, prepare_tree_node, to_camel_case,
+    ClientMetadata, Endpoint, JavaScriptSyntax, PatternField, child_type_name, generate_leaf_field,
+    get_first_leaf_name, get_node_fields, get_pattern_instance_base, infer_accumulated_name,
+    prepare_tree_node, to_camel_case,
 };
 
 use super::api::generate_api_methods;
@@ -142,33 +143,24 @@ fn generate_tree_initializer(
 ) {
     let indent_str = "  ".repeat(indent);
 
+    let syntax = JavaScriptSyntax;
     if let TreeNode::Branch(children) = node {
-        for (i, (child_name, child_node)) in children.iter().enumerate() {
-            let field_name = to_camel_case(child_name);
-            let comma = if i < children.len() - 1 { "," } else { "" };
-
+        for (child_name, child_node) in children.iter() {
             match child_node {
                 TreeNode::Leaf(leaf) => {
-                    let accessor = metadata
-                        .find_index_set_pattern(leaf.indexes())
-                        .unwrap_or_else(|| {
-                            panic!(
-                                "Metric '{}' has no matching index pattern. All metrics must be indexed.",
-                                leaf.name()
-                            )
-                        });
-                    writeln!(
+                    // Use shared helper for leaf fields
+                    generate_leaf_field(
                         output,
-                        "{}{}: create{}(this, '{}'){}",
-                        indent_str,
-                        field_name,
-                        accessor.name,
-                        leaf.name(),
-                        comma
-                    )
-                    .unwrap();
+                        &syntax,
+                        "this",
+                        child_name,
+                        leaf,
+                        metadata,
+                        &indent_str,
+                    );
                 }
                 TreeNode::Branch(grandchildren) => {
+                    let field_name = to_camel_case(child_name);
                     let child_fields = get_node_fields(grandchildren, pattern_lookup);
                     // Only use pattern factory if pattern is parameterizable
                     let pattern_name = pattern_lookup
@@ -179,8 +171,8 @@ fn generate_tree_initializer(
                         let arg = get_pattern_instance_base(child_node);
                         writeln!(
                             output,
-                            "{}{}: create{}(this, '{}'){}",
-                            indent_str, field_name, pattern_name, arg, comma
+                            "{}{}: create{}(this, '{}'),",
+                            indent_str, field_name, pattern_name, arg
                         )
                         .unwrap();
                     } else {
@@ -195,7 +187,7 @@ fn generate_tree_initializer(
                             pattern_lookup,
                             metadata,
                         );
-                        writeln!(output, "{}}}{}", indent_str, comma).unwrap();
+                        writeln!(output, "{}}},", indent_str).unwrap();
                     }
                 }
             }

crates/brk_bindgen/src/generators/python/tree.rs

@@ -6,8 +6,8 @@ use std::fmt::Write;
 use brk_types::TreeNode;
 
 use crate::{
-    ClientMetadata, PatternField, child_type_name, get_node_fields, get_pattern_instance_base,
-    prepare_tree_node, to_snake_case,
+    ClientMetadata, PatternField, PythonSyntax, child_type_name, generate_leaf_field,
+    get_node_fields, get_pattern_instance_base, prepare_tree_node, to_snake_case,
 };
 
 use super::client::field_type_with_generic;
@@ -50,7 +50,8 @@ fn generate_tree_class(
     )
     .unwrap();
 
-    for ((field, child_fields_opt), (_child_name, child_node)) in
+    let syntax = PythonSyntax;
+    for ((field, child_fields_opt), (child_name, child_node)) in
         ctx.fields_with_child_info.iter().zip(ctx.children.iter())
     {
         // Look up type parameter for generic patterns
@@ -72,14 +73,8 @@ fn generate_tree_class(
             )
             .unwrap();
         } else if let TreeNode::Leaf(leaf) = child_node {
-            // Leaf node: use actual metric name
-            let accessor = metadata.find_index_set_pattern(&field.indexes).unwrap();
-            writeln!(
-                output,
-                "        self.{}: {} = {}(client, '{}')",
-                field_name_py, py_type, accessor.name, leaf.name()
-            )
-            .unwrap();
+            // Leaf node: use shared helper
+            generate_leaf_field(output, &syntax, "client", child_name, leaf, metadata, "        ");
         } else if field.is_branch() {
             // Non-parameterizable pattern or regular branch: generate inline class
             let inline_class = child_type_name(name, &field.name);

crates/brk_bindgen/src/generators/python/types.rs

@@ -295,13 +295,14 @@ pub fn schema_to_python_type_ctx(schema: &Value, current_type: Option<&str>) ->
     "Any".to_string()
 }
 
-/// Convert JS-style type to Python type (e.g., "Txid[]" -> "List[Txid]", "number" -> "int")
+/// Convert JS-style type to Python type (e.g., "Txid[]" -> "List[Txid]", "integer" -> "int")
 pub fn js_type_to_python(js_type: &str) -> String {
     if let Some(inner) = js_type.strip_suffix("[]") {
         format!("List[{}]", js_type_to_python(inner))
     } else {
         match js_type {
-            "number" => "int".to_string(),
+            "integer" => "int".to_string(),
+            "number" => "float".to_string(),
             "boolean" => "bool".to_string(),
             "string" => "str".to_string(),
             "null" => "None".to_string(),

crates/brk_bindgen/src/generators/rust/client.rs

@@ -162,12 +162,12 @@ impl<T: DeserializeOwned> Endpoint<T> {{
     }}
 
     /// Fetch all data points for this metric/index.
-    pub fn get(&self) -> Result<Vec<T>> {{
+    pub fn get(&self) -> Result<MetricData<T>> {{
         self.client.get(&self.path())
     }}
 
     /// Fetch data points within a range.
-    pub fn range(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<T>> {{
+    pub fn range(&self, from: Option<i64>, to: Option<i64>) -> Result<MetricData<T>> {{
         let mut params = Vec::new();
         if let Some(f) = from {{ params.push(format!("from={{}}", f)); }}
         if let Some(t) = to {{ params.push(format!("to={{}}", t)); }}

crates/brk_bindgen/src/generators/rust/tree.rs

@@ -7,8 +7,8 @@ use brk_types::TreeNode;
 
 use crate::{
     ClientMetadata, LanguageSyntax, PatternField, RustSyntax, child_type_name,
-    generate_tree_node_field, get_node_fields, get_pattern_instance_base, prepare_tree_node,
-    to_snake_case,
+    generate_leaf_field, generate_tree_node_field, get_node_fields, get_pattern_instance_base,
+    prepare_tree_node, to_snake_case,
 };
 
 use super::client::field_type_with_generic;
@@ -100,16 +100,21 @@ fn generate_tree_node(
                 field_name, child_struct, path_expr
             )
             .unwrap();
-        } else {
-            // Leaf field
-            generate_tree_node_field(
+        } else if let TreeNode::Leaf(leaf) = child_node {
+            // Leaf field - use shared helper
+            generate_leaf_field(
                 output,
                 &syntax,
-                field_info,
+                "client.clone()",
+                child_name,
+                leaf,
                 metadata,
                 "            ",
-                child_name,
-                None,
+            );
+        } else {
+            panic!(
+                "Field '{}' is a leaf with no TreeNode::Leaf. This shouldn't happen.",
+                field_info.name
             );
         }
     }

crates/brk_bindgen/src/generators/rust/types.rs

@@ -7,6 +7,7 @@ pub fn js_type_to_rust(js_type: &str) -> String {
     } else {
         match js_type {
             "string" => "String".to_string(),
+            "integer" => "i64".to_string(),
             "number" => "f64".to_string(),
             "boolean" => "bool".to_string(),
             "*" => "serde_json::Value".to_string(),