Add baml.fs.read_dir, mkdir, baml.glob namespace, and fix parser string literal bug

baml_language/crates/baml_builtins2/baml_std/baml/ns_fs/fs.baml

@@ -61,3 +61,22 @@ function write(path: string, content: string) -> int throws root.errors.Io {
 function write_bytes(path: string, content: uint8array) -> int throws root.errors.Io {
   $rust_io_function
 }
+
+class DirEntry {
+  name string
+  is_dir bool
+  is_file bool
+  is_symlink bool
+}
+
+class MkdirOptions {
+  recursive bool
+}
+
+function read_dir(path: string) -> DirEntry[] throws root.errors.Io {
+  $rust_io_function
+}
+
+function mkdir(path: string, options: MkdirOptions) -> null throws root.errors.Io {
+  $rust_io_function
+}

baml_language/crates/baml_builtins2/baml_std/baml/ns_glob/glob.baml

@@ -0,0 +1,24 @@
+class ScanOptions {
+  cwd string?
+  dot bool?
+  absolute bool?
+  follow_symlinks bool?
+  throw_error_on_broken_symlink bool?
+  only_files bool?
+}
+
+class Glob {
+  _handle $rust_type
+
+  function scan(self, root: string | ScanOptions) -> string[] throws root.errors.Io {
+    $rust_io_function
+  }
+
+  function matches(self, path: string) -> bool throws root.errors.Io {
+    $rust_io_function
+  }
+}
+
+function new(pattern: string) -> Glob throws root.errors.Io {
+  $rust_io_function
+}

baml_language/crates/baml_builtins2/src/lib.rs

@@ -90,6 +90,7 @@ pub const ALL: &[BuiltinFile] = &[
     builtin!("baml", "ns_math/math.baml"),
     builtin!("baml", "ns_sys/sys.baml"),
     builtin!("baml", "ns_fs/fs.baml"),
+    builtin!("baml", "ns_glob/glob.baml"),
     builtin!("baml", "ns_net/net.baml"),
     builtin!("baml", "ns_media/media.baml"),
     builtin!("baml", "ns_unstable/unstable.baml"),

baml_language/crates/baml_builtins2_codegen/src/codegen_io.rs

@@ -1422,6 +1422,44 @@ fn emit_one_namespace_trait(
     }
 }
 
+/// Generate the `.into_result(...)` call for a given return type.
+///
+/// - Scalar types implementing `AsBexExternalValue` use `.into_result(op)`.
+/// - `List(Named(...))` uses `.into_result_mapped(op, |v| ...)` because
+///   `Vec<ClassName>` does not implement `AsBexExternalValue` (orphan rules
+///   prevent it in the generated crate).
+fn emit_into_result_call(
+    return_type: &BamlType,
+    variant_ident: &syn::Ident,
+    call_expr: &TokenStream,
+    class_ns_map: &BTreeMap<String, String>,
+    paths: &CodegenPaths,
+) -> TokenStream {
+    if let BamlType::List(inner) = return_type {
+        if let BamlType::Named(name) = inner.as_ref() {
+            if let Some(ns) = class_ns_map.get(name.as_str()) {
+                let owned = &paths.owned;
+                let ns_ident = format_ident!("{}", ns);
+                let name_ident = format_ident!("{}", name);
+                return quote! {
+                    #call_expr
+                        .into_result_mapped(SysOp::#variant_ident, |v| {
+                            BexExternalValue::Array {
+                                element_type: baml_type::Ty::unknown(),
+                                items: v.into_iter()
+                                    .map(|item| <#owned::#ns_ident::#name_ident as AsBexExternalValue>::into_bex_external_value(item))
+                                    .collect(),
+                            }
+                        })
+                };
+            }
+        }
+    }
+    quote! {
+        #call_expr.into_result(SysOp::#variant_ident)
+    }
+}
+
 fn emit_free_fn_glue(
     builtin: &NativeBuiltin,
     ns_trait_ident: &syn::Ident,
@@ -1433,6 +1471,16 @@ fn emit_free_fn_glue(
     let clean_ident = format_ident!("{}", io_method_name(builtin));
 
     if builtin.params.is_empty() {
+        let call_expr = quote! {
+            #ns_trait_ident::#clean_ident(self, heap, call_id, ctx)
+        };
+        let into_result = emit_into_result_call(
+            &builtin.return_type,
+            &variant_ident,
+            &call_expr,
+            class_ns_map,
+            paths,
+        );
         return quote! {
             fn #glue_ident<'a>(
                 &self,
@@ -1442,7 +1490,7 @@ fn emit_free_fn_glue(
                 ctx: &SysOpContext,
                 call_id: CallId,
             ) -> SysOpResult {
-                #ns_trait_ident::#clean_ident(self, heap, call_id, ctx).into_result(SysOp::#variant_ident)
+                #into_result
             }
         };
     }
@@ -1487,6 +1535,17 @@ fn emit_free_fn_glue(
         quote! { Ok::<_, AccessError>((#(#param_idents),*)) }
     };
 
+    let call_expr = quote! {
+        #ns_trait_ident::#clean_ident(self, heap, call_id, #(#param_idents,)* ctx)
+    };
+    let into_result = emit_into_result_call(
+        &builtin.return_type,
+        &variant_ident,
+        &call_expr,
+        class_ns_map,
+        paths,
+    );
+
     quote! {
         fn #glue_ident<'a>(
             &self,
@@ -1506,8 +1565,7 @@ fn emit_free_fn_glue(
 
             match __extraction {
                 Ok(#ok_pattern) => {
-                    #ns_trait_ident::#clean_ident(self, heap, call_id, #(#param_idents,)* ctx)
-                        .into_result(SysOp::#variant_ident)
+                    #into_result
                 }
                 Err(e) => SysOpResult::Ready(Err(OpError::new(
                     SysOp::#variant_ident,
@@ -2064,8 +2122,7 @@ fn emit_result_conversion(
         },
         BamlType::Null => quote! { Ok(()) },
         BamlType::Optional(inner) => {
-            // Create a temporary builtin with the inner type to recurse.
-            let inner_conv = emit_result_conversion_simple(inner, class_ns_map, paths);
+            let inner_conv = emit_result_conversion_inner(inner, class_ns_map, paths);
             quote! {
                 match __val {
                     BexExternalValue::Null => Ok(None),
@@ -2110,49 +2167,140 @@ fn emit_result_conversion(
                 }
             }
         },
+        BamlType::List(inner) => {
+            let inner_conv = emit_result_conversion_inner(inner, class_ns_map, paths);
+            quote! {
+                match __val {
+                    BexExternalValue::Array { items, .. } => {
+                        items.into_iter()
+                            .map(|__val| { #inner_conv })
+                            .collect::<Result<Vec<_>, _>>()
+                    }
+                    other => Err(RuntimeIoError::Other(
+                        format!("expected array, got {}", other.type_name()),
+                    )),
+                }
+            }
+        }
         _ => quote! { Ok(__val) },
     }
 }
 
-/// Simplified result conversion for inner types (used in Optional).
-fn emit_result_conversion_simple(
+/// Per-element result conversion for list inner types.
+/// Used by the `BamlType::List` arm of `emit_result_conversion`.
+fn emit_result_conversion_inner(
     ty: &BamlType,
-    _class_ns_map: &BTreeMap<String, String>,
-    _paths: &CodegenPaths,
+    class_ns_map: &BTreeMap<String, String>,
+    paths: &CodegenPaths,
 ) -> TokenStream {
     match ty {
         BamlType::String => quote! {
             match __val {
                 BexExternalValue::String(s) => Ok(s),
                 other => Err(RuntimeIoError::Other(
-                    format!("expected string, got {}", other.type_name()),
+                    format!("expected string in list, got {}", other.type_name()),
                 )),
             }
         },
         BamlType::Int => quote! {
             match __val {
                 BexExternalValue::Int(v) => Ok(v),
                 other => Err(RuntimeIoError::Other(
-                    format!("expected int, got {}", other.type_name()),
+                    format!("expected int in list, got {}", other.type_name()),
+                )),
+            }
+        },
+        BamlType::Bool => quote! {
+            match __val {
+                BexExternalValue::Bool(v) => Ok(v),
+                other => Err(RuntimeIoError::Other(
+                    format!("expected bool in list, got {}", other.type_name()),
                 )),
             }
         },
         BamlType::Float => quote! {
             match __val {
                 BexExternalValue::Float(v) => Ok(v),
                 other => Err(RuntimeIoError::Other(
-                    format!("expected float, got {}", other.type_name()),
+                    format!("expected float in list, got {}", other.type_name()),
                 )),
             }
         },
-        BamlType::Bool => quote! {
+        BamlType::Uint8Array => quote! {
             match __val {
-                BexExternalValue::Bool(v) => Ok(v),
+                BexExternalValue::Uint8Array(v) => Ok(v),
                 other => Err(RuntimeIoError::Other(
-                    format!("expected bool, got {}", other.type_name()),
+                    format!("expected uint8array in list, got {}", other.type_name()),
                 )),
             }
         },
+        BamlType::Optional(inner) => {
+            let inner_conv = emit_result_conversion_inner(inner, class_ns_map, paths);
+            quote! {
+                match __val {
+                    BexExternalValue::Null => Ok(None),
+                    other => {
+                        let __val = other;
+                        Ok(Some({ #inner_conv }?))
+                    }
+                }
+            }
+        }
+        BamlType::List(inner) => {
+            let inner_conv = emit_result_conversion_inner(inner, class_ns_map, paths);
+            quote! {
+                match __val {
+                    BexExternalValue::Array { items, .. } => {
+                        items.into_iter()
+                            .map(|__val| { #inner_conv })
+                            .collect::<Result<Vec<_>, _>>()
+                    }
+                    other => Err(RuntimeIoError::Other(
+                        format!("expected array in list, got {}", other.type_name()),
+                    )),
+                }
+            }
+        }
+        BamlType::Map(key, value) if matches!(key.as_ref(), BamlType::String) => {
+            let value_conv = emit_result_conversion_inner(value, class_ns_map, paths);
+            quote! {
+                match __val {
+                    BexExternalValue::Map { entries, .. } => {
+                        entries.into_iter()
+                            .map(|(__key, __val)| Ok((__key, { #value_conv }?)))
+                            .collect::<Result<indexmap::IndexMap<_, _>, _>>()
+                    }
+                    other => Err(RuntimeIoError::Other(
+                        format!("expected map in list, got {}", other.type_name()),
+                    )),
+                }
+            }
+        }
+        BamlType::Named(name) => match name.as_str() {
+            "type" => quote! {
+                match __val {
+                    BexExternalValue::Adt(
+                        bex_external_types::BexExternalAdt::Type(ty),
+                    ) => Ok(ty),
+                    other => Err(RuntimeIoError::Other(
+                        format!("expected type in list, got {}", other.type_name()),
+                    )),
+                }
+            },
+            _ => {
+                if let Some(ns) = class_ns_map.get(name.as_str()) {
+                    let owned = &paths.owned;
+                    let ns_ident = format_ident!("{}", ns);
+                    let name_ident = format_ident!("{}", name);
+                    quote! {
+                        #owned::#ns_ident::#name_ident::from_external(__val)
+                            .map_err(|e| RuntimeIoError::Other(format!("{e:?}")))
+                    }
+                } else {
+                    quote! { Ok(__val) }
+                }
+            }
+        },
         _ => quote! { Ok(__val) },
     }
 }