Nomad changes

packages/dart/rust/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "kreuzberg-dart"
+version = "5.0.0-rc.3"
+edition = "2024"
+license = "Elastic-2.0"
+
+[package.metadata.cargo-machete]
+# Umbrella + sibling crates are pulled in so flutter_rust_bridge can resolve
+# every referenced type, but the generated Rust wrapper only `use`s a subset.
+ignored = ["kreuzberg"]
+
+[lib]
+crate-type = ["cdylib", "staticlib"]
+
+[dependencies]
+flutter_rust_bridge = "=2.12.0"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["rt-multi-thread", "sync"] }
+async-trait = "0.1"
+
+[target.'cfg(not(all(target_os = "android", target_arch = "x86_64")))'.dependencies]
+kreuzberg = { path = "../../../crates/kreuzberg", features = ["full"] }
+
+[target.'cfg(all(target_os = "android", target_arch = "x86_64"))'.dependencies]
+kreuzberg = { path = "../../../crates/kreuzberg", default-features = false, features = ["android-target"] }
+
+[lints.rust]
+# flutter_rust_bridge uses #[cfg(frb_expand)] internally during macro expansion.
+# Declare it as a known cfg so rustc does not emit unexpected_cfgs warnings.
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(frb_expand)'] }

packages/dart/rust/build.rs

@@ -0,0 +1,172 @@
+use std::path::Path;
+
+fn main() {
+    // Re-run whenever any Rust source changes.
+    println!("cargo:rerun-if-changed=src");
+
+    // Optional FRB codegen: regenerate flutter_rust_bridge artifacts when the
+    // tool is on PATH. Missing tool is not fatal — committed generated sources
+    // are checked in, and CI environments without FRB still build cleanly.
+    match std::process::Command::new("flutter_rust_bridge_codegen")
+        .args(["generate", "--config-file", "flutter_rust_bridge.yaml"])
+        .status()
+    {
+        Ok(status) if status.success() => {
+            // FRB v2.12+ emits `use` lists in an order rustfmt 2024 edition rewrites
+            // (e.g. `{transform_result_dco, Lifetimeable, Lockable}` →
+            // `{Lifetimeable, Lockable, transform_result_dco}`). Run rustfmt against
+            // the generated file so committed output is fmt-clean and `cargo fmt --check`
+            // stays green in CI.
+            match std::process::Command::new("rustfmt")
+                .args(["--edition", "2024", "src/frb_generated.rs"])
+                .status()
+            {
+                Ok(s) if s.success() => {}
+                Ok(s) => println!("cargo:warning=rustfmt on src/frb_generated.rs exited {s}"),
+                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                    println!(
+                        "cargo:warning=rustfmt not on PATH — skipping post-FRB format. Install rustfmt via rustup to keep generated bridge sources fmt-clean."
+                    );
+                }
+                Err(err) => println!("cargo:warning=failed to spawn rustfmt: {err}"),
+            }
+
+            // Patch the generated Dart entrypoint so the published package resolves
+            // its native library from its own installed location.
+            patch_published_loader();
+        }
+        Ok(status) => panic!("flutter_rust_bridge_codegen generate failed (exit code: {status})"),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+            println!(
+                "cargo:warning=flutter_rust_bridge_codegen not on PATH — skipping codegen. Install via `dart pub global activate flutter_rust_bridge_codegen` to regenerate FRB artifacts at build time."
+            );
+        }
+        Err(err) => panic!("failed to spawn flutter_rust_bridge_codegen: {err}"),
+    }
+}
+
+const FRB_GENERATED_DART: &str = "../lib/src/kreuzberg_bridge_generated/frb_generated.dart";
+const LOADER_MARKER: &str = "_alefResolveExternalLibrary";
+const FRB_INIT_PROLOGUE: &str = "  /// Initialize flutter_rust_bridge\n  static Future<void> init({\n    RustLibApi? api,\n    BaseHandler? handler,\n    ExternalLibrary? externalLibrary,\n    bool forceSameCodegenVersion = true,\n  }) async {\n";
+const FRB_INIT_REPLACEMENT: &str = r#"  /// Resolve the prebuilt native library from this package's own installed
+  /// location so the load works from any working directory and under hardened
+  /// runtimes. Returns `null` to defer to flutter_rust_bridge's default loader.
+  ///
+  /// Published pub.dev packages stage natives under `lib/src/native/<rid>/`
+  /// (e.g. `macos-arm64`, `linux-x64`). For local FRB-dev builds the dylib is
+  /// emitted into `lib/src/kreuzberg_bridge_generated/`; that
+  /// path is searched as a fallback.
+  static Future<ExternalLibrary?> _alefResolveExternalLibrary() async {
+    try {
+      final packageRoot =
+          await Isolate.resolvePackageUri(Uri.parse('package:kreuzberg/kreuzberg.dart'));
+      if (packageRoot == null) return null;
+      final libNames = _alefHostLibNames();
+      final searchDirs = <Uri>[
+        if (_alefHostRid() != null) packageRoot.resolve('src/native/${_alefHostRid()}/'),
+        packageRoot.resolve('src/kreuzberg_bridge_generated/'),
+      ];
+      for (final dir in searchDirs) {
+        for (final name in libNames) {
+          final libPath = dir.resolve(name).toFilePath();
+          if (File(libPath).existsSync()) {
+            return ExternalLibrary.open(libPath);
+          }
+        }
+      }
+    } catch (_) {
+      // Fall through to the default loader on any resolution failure.
+    }
+    return null;
+  }
+
+  /// Map the host platform to the pub.dev native staging RID. Returns `null`
+  /// for unrecognized host triples so the FRB-dev fallback path runs instead.
+  static String? _alefHostRid() {
+    final abi = Abi.current();
+    if (abi == Abi.macosArm64) return 'macos-arm64';
+    if (abi == Abi.macosX64) return 'macos-x64';
+    if (abi == Abi.linuxArm64) return 'linux-arm64';
+    if (abi == Abi.linuxX64) return 'linux-x64';
+    if (abi == Abi.windowsArm64) return 'windows-arm64';
+    if (abi == Abi.windowsX64) return 'windows-x64';
+    return null;
+  }
+
+  static List<String> _alefHostLibNames() {
+    // The Dart-binding Rust crate is `{stem}-dart` (per the cargo manifest
+    // template), which produces a cdylib named `lib{stem}_dart.{ext}` on Unix
+    // and `{stem}_dart.dll` on Windows.
+    if (Platform.isMacOS) return const ['libkreuzberg_dart.dylib'];
+    if (Platform.isWindows) return const ['kreuzberg_dart.dll'];
+    return const ['libkreuzberg_dart.so'];
+  }
+
+  /// Initialize flutter_rust_bridge
+  static Future<void> init({
+    RustLibApi? api,
+    BaseHandler? handler,
+    ExternalLibrary? externalLibrary,
+    bool forceSameCodegenVersion = true,
+  }) async {
+    externalLibrary ??= await _alefResolveExternalLibrary();
+"#;
+
+/// Inject the published-package native-library loader into `frb_generated.dart`.
+/// Idempotent: a no-op when the marker is already present or the FRB entrypoint
+/// signature is absent.
+fn patch_published_loader() {
+    let path = Path::new(FRB_GENERATED_DART);
+    let Ok(source) = std::fs::read_to_string(path) else {
+        println!(
+            "cargo:warning=published-loader patch skipped: {} not found",
+            FRB_GENERATED_DART
+        );
+        return;
+    };
+    if source.contains(LOADER_MARKER) {
+        return;
+    }
+    if !source.contains(FRB_INIT_PROLOGUE) {
+        println!("cargo:warning=published-loader patch skipped: FRB init prologue not found");
+        return;
+    }
+
+    let mut patched = source.replacen(FRB_INIT_PROLOGUE, FRB_INIT_REPLACEMENT, 1);
+
+    // Ensure the helper's `File`/`Isolate`/`Abi` dependencies are imported.
+    for (probe, line) in [
+        ("import 'dart:io';", "import 'dart:io';\n"),
+        ("import 'dart:isolate';", "import 'dart:isolate';\n"),
+        ("import 'dart:ffi';", "import 'dart:ffi';\n"),
+    ] {
+        if patched.contains(probe) {
+            continue;
+        }
+        if let Some(pos) = patched.find("\nimport ") {
+            patched.insert_str(pos + 1, line);
+        } else {
+            patched.insert_str(0, line);
+        }
+    }
+
+    if patched != source {
+        if let Err(err) = std::fs::write(path, &patched) {
+            println!("cargo:warning=failed to write published-loader patch: {err}");
+            return;
+        }
+        match std::process::Command::new("dart")
+            .args(["format", FRB_GENERATED_DART])
+            .status()
+        {
+            Ok(s) if s.success() => {}
+            Ok(s) => println!("cargo:warning=dart format on {} exited {}", FRB_GENERATED_DART, s),
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                println!(
+                    "cargo:warning=dart not on PATH — skipping post-patch format. Install Dart SDK to keep generated FRB Dart sources fmt-clean."
+                );
+            }
+            Err(err) => println!("cargo:warning=failed to spawn dart format: {err}"),
+        }
+    }
+}

packages/dart/rust/flutter_rust_bridge.yaml

@@ -0,0 +1,4 @@
+rust_root: .
+rust_input: crate
+dart_output: ../lib/src/kreuzberg_bridge_generated
+add_mod_to_lib: false