@rejaul/react-native-rust 1.0.2 → 2.0.0

package/dist/react-native-rust-lib.js

@@ -0,0 +1,470 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_native_rust_lib_exports = {};
+__export(react_native_rust_lib_exports, {
+  build: () => build,
+  doctor: () => doctor,
+  generate: () => generate,
+  init: () => init,
+  packageRoot: () => packageRoot,
+  readJson: () => readJson,
+  run: () => run,
+  watch: () => watch
+});
+module.exports = __toCommonJS(react_native_rust_lib_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_codegen = require("./codegen");
+var import_watcher = require("./dev/watcher");
+var import_buildQueue = require("./dev/buildQueue");
+const rustDirectory = "rust";
+const iosTargets = ["aarch64-apple-ios", "aarch64-apple-ios-sim", "x86_64-apple-ios"];
+const androidTargets = [
+  ["arm64-v8a", "aarch64-linux-android"],
+  ["armeabi-v7a", "armv7-linux-androideabi"],
+  ["x86", "i686-linux-android"],
+  ["x86_64", "x86_64-linux-android"]
+];
+function run(command, args, options = {}) {
+  const result = (0, import_node_child_process.spawnSync)(command, args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: "utf8",
+    stdio: options.inherit ? "inherit" : "pipe"
+  });
+  if (result.error) return { ok: false, message: result.error.message };
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      message: (result.stderr || result.stdout || `${command} exited with ${result.status}`).trim()
+    };
+  }
+  return { ok: true, output: (result.stdout || "").trim() };
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`Cannot read ${filePath}: ${error.message}`, { cause: error });
+  }
+}
+function packageRoot() {
+  const root = process.cwd();
+  const manifestPath = import_node_path.default.join(root, "package.json");
+  if (!import_node_fs.default.existsSync(manifestPath)) {
+    throw new Error("Run this command from the root of a React Native library.");
+  }
+  const manifest = readJson(manifestPath);
+  const dependencies = { ...manifest.dependencies, ...manifest.peerDependencies };
+  if (!dependencies["react-native"]) {
+    throw new Error("This package does not declare react-native as a dependency or peer dependency.");
+  }
+  const configPath = import_node_path.default.join(root, "react-native.config.js");
+  if (!import_node_fs.default.existsSync(configPath)) {
+    throw new Error("Missing react-native.config.js. Create the library with the C++ module template.");
+  }
+  const config = import_node_fs.default.readFileSync(configPath, "utf8");
+  const moduleMatch = config.match(/cxxModuleHeaderName\s*:\s*['"]([a-zA-Z0-9_]+)Impl['"]/);
+  if (!moduleMatch || !config.includes("cxxModuleCMakeListsPath")) {
+    throw new Error("The library is not configured as a C++ TurboModule. Choose the C++ module template.");
+  }
+  return { root, manifest, manifestPath, moduleName: moduleMatch[1] };
+}
+function resolveRustRoot(root, manifest) {
+  return import_node_path.default.resolve(root, manifest.reactNativeRust?.rustDir || rustDirectory);
+}
+function readCrateName(rustRoot) {
+  const manifestPath = import_node_path.default.join(rustRoot, "Cargo.toml");
+  const cargoManifest = import_node_fs.default.readFileSync(manifestPath, "utf8");
+  const crateMatch = cargoManifest.match(/^name\s*=\s*"([a-zA-Z0-9_-]+)"/m);
+  if (!crateMatch) throw new Error("Could not read the Rust crate name from rust/Cargo.toml.");
+  return crateMatch[1];
+}
+function init() {
+  const { root, manifest, manifestPath, moduleName } = packageRoot();
+  const rustPath = resolveRustRoot(root, manifest);
+  if (import_node_fs.default.existsSync(rustPath)) {
+    throw new Error(`${import_node_path.default.relative(root, rustPath) || "rust"}/ already exists; no files were changed.`);
+  }
+  const scripts = manifest.scripts || {};
+  if (scripts["rust:test"] || scripts["rust:generate"]) {
+    throw new Error("package.json already defines a rust:test or rust:generate script; no files were changed.");
+  }
+  const projectFiles = {
+    cppHeader: import_node_path.default.join(root, "cpp", `${moduleName}Impl.h`),
+    cppSource: import_node_path.default.join(root, "cpp", `${moduleName}Impl.cpp`),
+    nativeSpec: import_node_path.default.join(root, "src", `Native${moduleName}.ts`),
+    libraryIndex: import_node_path.default.join(root, "src", "index.tsx"),
+    androidCmake: import_node_path.default.join(root, "android", "CMakeLists.txt")
+  };
+  const podspecs = import_node_fs.default.readdirSync(root).filter((fileName) => fileName.endsWith(".podspec"));
+  if (podspecs.length !== 1) throw new Error("Expected exactly one CocoaPods spec file. No files were changed.");
+  projectFiles.podspec = import_node_path.default.join(root, podspecs[0]);
+  if (Object.values(projectFiles).some((filePath) => !import_node_fs.default.existsSync(filePath))) {
+    throw new Error("Expected C++ library template files were not found. No files were changed.");
+  }
+  const contents = Object.fromEntries(Object.entries(projectFiles).map(([key, filePath]) => [
+    key,
+    import_node_fs.default.readFileSync(filePath, "utf8")
+  ]));
+  const targetMatch = contents.androidCmake.match(/add_library\(\s*([a-zA-Z0-9_-]+)\s+STATIC/);
+  if (!targetMatch || !contents.cppHeader.includes("#pragma once")) {
+    throw new Error("The native files do not match the supported C++ TurboModule template. No files were changed.");
+  }
+  const methods = (0, import_codegen.parseSpec)(contents.nativeSpec, import_node_path.default.relative(root, projectFiles.nativeSpec));
+  const crateName = (manifest.name || "react-native-rust").replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9_]+/g, "_");
+  const crateDirName = /^\d/.test(crateName) ? `rust_${crateName.toLowerCase()}` : crateName.toLowerCase();
+  const targetName = targetMatch[1];
+  const linkMatch = contents.androidCmake.match(/target_link_libraries\(\s*([a-zA-Z0-9_-]+)([\s\S]*?)\n\)/);
+  if (!linkMatch || linkMatch[1] !== targetName) {
+    throw new Error("Could not locate the C++ target link block in android/CMakeLists.txt.");
+  }
+  const androidLink = `${linkMatch[0].slice(0, -2)}
+    rust_core
+    log
+    dl
+    m
+)`;
+  const androidRustBuildTarget = (0, import_codegen.resolveOutsideReference)(root, import_node_path.default.join(rustPath, "build", "android"), "rust-build-android");
+  const androidRustBuildPath = (0, import_codegen.toPosixRelative)(import_node_path.default.join(root, "android"), androidRustBuildTarget);
+  const rustImport = `add_library(rust_core STATIC IMPORTED)
+set_target_properties(rust_core PROPERTIES
+    IMPORTED_LOCATION "\${CMAKE_CURRENT_LIST_DIR}/${androidRustBuildPath}/\${ANDROID_ABI}/lib${crateDirName}.a"
+)
+
+`;
+  const androidCmake = contents.androidCmake.replace(linkMatch[0], androidLink).replace(/add_library\(/, `${rustImport}add_library(`);
+  const podspecSource = contents.podspec.match(/^\s*s\.source_files\s*=.*$/m);
+  if (!podspecSource) throw new Error("Could not locate source_files in the CocoaPods spec.");
+  const iosRustBuildPath = (0, import_codegen.toPosixRelative)(root, import_node_path.default.join(rustPath, "build", "ios")).startsWith("..") ? "rust-build-ios" : (0, import_codegen.toPosixRelative)(root, import_node_path.default.join(rustPath, "build", "ios"));
+  const podspec = contents.podspec.replace(
+    podspecSource[0],
+    `${podspecSource[0]}
+  s.vendored_frameworks = "${iosRustBuildPath}/${moduleName}Rust.xcframework"`
+  );
+  const rustFiles = {
+    "Cargo.toml": `[package]
+name = "${crateDirName}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["staticlib", "cdylib"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = "0.2"
+js-sys = "0.3"
+
+[build-dependencies]
+cbindgen = "0.26"
+`,
+    "build.rs": `use std::path::PathBuf;
+
+fn main() {
+    let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let output = PathBuf::from(&crate_dir).join("include/rust_api.h");
+    std::fs::create_dir_all(output.parent().unwrap()).unwrap();
+    cbindgen::generate(&crate_dir)
+        .expect("failed to generate the Rust C header")
+        .write_to_file(output);
+}
+`,
+    "cbindgen.toml": `language = "C++"
+`,
+    "src/ffi.rs": (0, import_codegen.renderRustFfiModule)(),
+    "README.md": `# Rust core
+
+Rust handlers are generated from the TurboModule Spec interface in src/Native${moduleName}.ts. Edit the generated functions under rust/src/api/ and regenerate native glue with npx react-native-rust generate.
+
+Run cargo test --manifest-path rust/Cargo.toml for Rust tests. Build iOS and Android artifacts with npx react-native-rust build ios and npx react-native-rust build android before native app builds. Build the react-native-web WebAssembly package with npx react-native-rust build web (requires wasm-pack and the wasm32-unknown-unknown Rust target).
+`
+  };
+  const updates = (0, import_codegen.renderProjectBindings)(root, moduleName, methods, true, crateDirName, rustPath);
+  updates.set(projectFiles.androidCmake, androidCmake);
+  updates.set(projectFiles.podspec, podspec);
+  const cliManifest = readJson(import_node_path.default.join(__dirname, "..", "package.json"));
+  const cliRoot = import_node_path.default.resolve(__dirname, "..");
+  const cliIsInstalled = cliRoot.split(import_node_path.default.sep).includes("node_modules");
+  const cliDependency = cliIsInstalled ? `^${cliManifest.version}` : `file:${import_node_path.default.relative(root, cliRoot).split(import_node_path.default.sep).join("/") || "."}`;
+  const updatedManifest = {
+    ...manifest,
+    devDependencies: {
+      ...manifest.devDependencies,
+      [cliManifest.name]: manifest.devDependencies?.[cliManifest.name] || cliDependency
+    },
+    scripts: {
+      ...scripts,
+      "rust:test": `cargo test --manifest-path ${(0, import_codegen.toPosixRelative)(root, rustPath)}/Cargo.toml`,
+      "rust:generate": "react-native-rust generate",
+      "rust:build:ios": "react-native-rust build ios",
+      "rust:build:android": "react-native-rust build android",
+      "rust:build:web": "react-native-rust build web"
+    }
+  };
+  const rustIsInsideRoot = !(0, import_codegen.toPosixRelative)(root, rustPath).startsWith("..");
+  if (rustIsInsideRoot) {
+    const packageFiles = Array.isArray(updatedManifest.files) ? [...updatedManifest.files] : [];
+    for (const filePath of ["rust/", "rust/build/", "rust/include/"]) {
+      if (!packageFiles.includes(filePath)) packageFiles.push(filePath);
+    }
+    updatedManifest.files = packageFiles;
+  }
+  updates.set(manifestPath, `${JSON.stringify(updatedManifest, null, 2)}
+`);
+  if (rustIsInsideRoot) {
+    const gitignorePath = import_node_path.default.join(root, ".gitignore");
+    const gitignore = import_node_fs.default.existsSync(gitignorePath) ? import_node_fs.default.readFileSync(gitignorePath, "utf8") : "";
+    const ignoredRustOutputs = ["rust/target/", "rust/build/"].filter((entry) => !gitignore.split(/\r?\n/).includes(entry));
+    if (ignoredRustOutputs.length > 0) {
+      const separator = gitignore.length > 0 && !gitignore.endsWith("\n") ? "\n" : "";
+      updates.set(gitignorePath, `${gitignore}${separator}${ignoredRustOutputs.join("\n")}
+`);
+    }
+  }
+  for (const [relativePath, fileContents] of Object.entries(rustFiles)) {
+    const outputPath = import_node_path.default.join(rustPath, relativePath);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(outputPath), { recursive: true });
+    import_node_fs.default.writeFileSync(outputPath, fileContents);
+  }
+  for (const [filePath, fileContents] of updates) {
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(filePath), { recursive: true });
+    import_node_fs.default.writeFileSync(filePath, fileContents);
+  }
+  console.log(`Generated ${methods.length} Rust handler(s) and native bindings from Spec.`);
+  console.log("Run `npx react-native-rust build ios` or `npx react-native-rust build android` before building the React Native app.");
+}
+function generate() {
+  const { root, manifest, moduleName } = packageRoot();
+  const rustPath = resolveRustRoot(root, manifest);
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(rustPath, "Cargo.toml"))) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  const nativeSpecPath = import_node_path.default.join(root, "src", `Native${moduleName}.ts`);
+  const methods = (0, import_codegen.parseSpec)(import_node_fs.default.readFileSync(nativeSpecPath, "utf8"), import_node_path.default.relative(root, nativeSpecPath));
+  const updates = (0, import_codegen.renderProjectBindings)(root, moduleName, methods, false, readCrateName(rustPath), rustPath);
+  for (const [filePath, fileContents] of updates) {
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(filePath), { recursive: true });
+    import_node_fs.default.writeFileSync(filePath, fileContents);
+  }
+  console.log(`Regenerated Rust, C++, and TypeScript glue for ${methods.length} Spec method(s).`);
+}
+function doctor(target) {
+  const { root, manifest } = packageRoot();
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(resolveRustRoot(root, manifest), "Cargo.toml"))) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  let failed = false;
+  for (const command of ["rustc", "cargo"]) {
+    const result = run(command, ["--version"]);
+    console.log(`${result.ok ? "OK" : "MISSING"} ${command}${result.output ? `: ${result.output}` : ""}`);
+    failed ||= !result.ok;
+  }
+  if (target === "ios") {
+    const xcode = run("xcodebuild", ["-version"]);
+    const lipo = run("lipo", ["-version"]);
+    console.log(`${xcode.ok ? "OK" : "MISSING"} Xcode`);
+    console.log(`${lipo.ok ? "OK" : "MISSING"} lipo`);
+    failed ||= process.platform !== "darwin" || !xcode.ok || !lipo.ok;
+  }
+  if (target === "android") {
+    const ndkPath = process.env.ANDROID_NDK_HOME || process.env.ANDROID_NDK_ROOT;
+    const cargoNdk = run("cargo", ["ndk", "--version"]);
+    console.log(`${ndkPath ? "OK" : "CHECK"} Android NDK path (cargo-ndk can auto-detect Android Studio installs)`);
+    console.log(`${cargoNdk.ok ? "OK" : "MISSING"} cargo-ndk`);
+    failed ||= !cargoNdk.ok;
+  }
+  if (target === "web") {
+    const wasmPack = run("wasm-pack", ["--version"]);
+    const installedTargets = run("rustup", ["target", "list", "--installed"]);
+    const hasWasmTarget = installedTargets.ok && (installedTargets.output || "").includes("wasm32-unknown-unknown");
+    console.log(`${wasmPack.ok ? "OK" : "MISSING"} wasm-pack`);
+    console.log(`${hasWasmTarget ? "OK" : "MISSING"} wasm32-unknown-unknown Rust target (rustup target add wasm32-unknown-unknown)`);
+    failed ||= !wasmPack.ok || !hasWasmTarget;
+  }
+  if (failed) process.exitCode = 1;
+}
+function build(platform) {
+  const { root, manifest, moduleName } = packageRoot();
+  const rustRoot = resolveRustRoot(root, manifest);
+  const manifestPath = import_node_path.default.join(rustRoot, "Cargo.toml");
+  if (!import_node_fs.default.existsSync(manifestPath)) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  const crateName = readCrateName(rustRoot);
+  const releasePath = (target) => import_node_path.default.join(rustRoot, "target", target, "release", `lib${crateName}.a`);
+  (0, import_codegen.resolveOutsideReference)(root, import_node_path.default.join(rustRoot, "build", "android"), "rust-build-android");
+  if (platform === "ios") {
+    for (const target of iosTargets) {
+      const result = run("cargo", ["build", "--release", "--target", target, "--manifest-path", manifestPath], { inherit: true });
+      if (!result.ok) throw new Error(`iOS build failed for ${target}: ${result.message}`);
+    }
+    const buildPath = import_node_path.default.join(rustRoot, "build", "ios");
+    import_node_fs.default.mkdirSync(buildPath, { recursive: true });
+    const simulatorDirectory = import_node_path.default.join(buildPath, "simulator");
+    import_node_fs.default.mkdirSync(simulatorDirectory, { recursive: true });
+    const simulatorArchive = import_node_path.default.join(simulatorDirectory, `lib${crateName}.a`);
+    const lipo = run("lipo", [
+      "-create",
+      releasePath("aarch64-apple-ios-sim"),
+      releasePath("x86_64-apple-ios"),
+      "-output",
+      simulatorArchive
+    ], { inherit: true });
+    if (!lipo.ok) throw new Error(`Could not combine iOS simulator archives: ${lipo.message}`);
+    const frameworkPath = import_node_path.default.join(buildPath, `${moduleName}Rust.xcframework`);
+    import_node_fs.default.rmSync(frameworkPath, { recursive: true, force: true });
+    const xcframework = run("xcodebuild", [
+      "-create-xcframework",
+      "-library",
+      releasePath("aarch64-apple-ios"),
+      "-headers",
+      import_node_path.default.join(rustRoot, "include"),
+      "-library",
+      simulatorArchive,
+      "-headers",
+      import_node_path.default.join(rustRoot, "include"),
+      "-output",
+      frameworkPath
+    ], { inherit: true });
+    if (!xcframework.ok) throw new Error(`Could not create the iOS XCFramework: ${xcframework.message}`);
+    if ((0, import_codegen.toPosixRelative)(root, frameworkPath).startsWith("..")) {
+      const podFrameworkPath = import_node_path.default.join(root, "rust-build-ios", `${moduleName}Rust.xcframework`);
+      import_node_fs.default.rmSync(import_node_path.default.dirname(podFrameworkPath), { recursive: true, force: true });
+      import_node_fs.default.mkdirSync(import_node_path.default.dirname(podFrameworkPath), { recursive: true });
+      import_node_fs.default.cpSync(frameworkPath, podFrameworkPath, { recursive: true });
+    }
+    console.log(`Built ${import_node_path.default.relative(root, frameworkPath)} for ${manifest.name}.`);
+    return;
+  }
+  if (platform === "android") {
+    const result = run("cargo", [
+      "ndk",
+      "-t",
+      "arm64-v8a",
+      "-t",
+      "armeabi-v7a",
+      "-t",
+      "x86",
+      "-t",
+      "x86_64",
+      "build",
+      "--release"
+    ], { inherit: true, cwd: rustRoot });
+    if (!result.ok) throw new Error(`Android build failed: ${result.message}`);
+    for (const [abi, target] of androidTargets) {
+      const outputDirectory = import_node_path.default.join(rustRoot, "build", "android", abi);
+      import_node_fs.default.mkdirSync(outputDirectory, { recursive: true });
+      import_node_fs.default.copyFileSync(releasePath(target), import_node_path.default.join(outputDirectory, `lib${crateName}.a`));
+    }
+    console.log(`Built Android static archives for ${manifest.name}.`);
+    return;
+  }
+  if (platform === "web") {
+    const result = run("wasm-pack", ["build", "--target", "web", "--out-dir", import_node_path.default.join("build", "web", "pkg")], { inherit: true, cwd: rustRoot });
+    if (!result.ok) throw new Error(`Web build failed: ${result.message}`);
+    console.log(`Built ${(0, import_codegen.toPosixRelative)(root, import_node_path.default.join(rustRoot, "build", "web", "pkg"))} for ${manifest.name}.`);
+    return;
+  }
+  throw new Error("Choose a build target: ios, android, or web.");
+}
+function watch(options = {}) {
+  const { root, manifest, moduleName } = packageRoot();
+  const rustRoot = resolveRustRoot(root, manifest);
+  const cargoManifest = import_node_path.default.join(rustRoot, "Cargo.toml");
+  if (!import_node_fs.default.existsSync(cargoManifest)) {
+    throw new Error("Rust is not initialized. Run `npx react-native-rust init` first.");
+  }
+  const log = options.log || console.log;
+  const target = { rustRoot, specPath: import_node_path.default.join(root, "src", `Native${moduleName}.ts`) };
+  let pendingKinds = /* @__PURE__ */ new Set();
+  async function runWatchCycle(kinds) {
+    if (kinds.has("spec")) {
+      log("[RN Rust] Spec changed. Regenerating native bindings...");
+      try {
+        generate();
+        options.onGenerated?.();
+      } catch (error) {
+        log("[RN Rust] Code generation failed.");
+        log("Possible causes:");
+        log("  - invalid Rust API");
+        log("  - unsupported parameter type");
+        log("  - unsupported return type");
+        log("  - invalid annotation/spec");
+        log(`  ${error.message}`);
+        log("[Rust] Waiting for changes...");
+        return;
+      }
+      log("[RN Rust] Native bindings updated.");
+    }
+    log("[Rust] Building...");
+    const start = Date.now();
+    const result = run("cargo", ["build", "--manifest-path", cargoManifest], { inherit: true });
+    const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+    if (!result.ok) {
+      log("[Rust] Build failed.");
+      log("[Rust] Waiting for changes...");
+      return;
+    }
+    log(`[Rust] Build completed in ${elapsed}s`);
+    log("[Rust] Native library updated.");
+    log("[RN Rust] Native code cannot hot-swap into a running app: run `npm run rust:build:ios` / `rust:build:android` / `rust:build:web` and reinstall (or refresh the browser tab, for react-native-web) to load this change.");
+    log("[Rust] Waiting for changes...");
+  }
+  const queue = new import_buildQueue.SingleFlightQueue(() => {
+    const kinds = pendingKinds;
+    pendingKinds = /* @__PURE__ */ new Set();
+    return runWatchCycle(kinds);
+  });
+  const watcher = (0, import_watcher.watchRustProject)({
+    target,
+    log,
+    onChange: (kinds) => {
+      for (const kind of kinds) pendingKinds.add(kind);
+      queue.request();
+    }
+  });
+  log(`[Rust] Watching ${import_node_path.default.relative(process.cwd(), rustRoot) || "rust"}/ and ${import_node_path.default.relative(process.cwd(), target.specPath)}`);
+  log("[Rust] Waiting for changes...");
+  return { stop: () => watcher.close() };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  doctor,
+  generate,
+  init,
+  packageRoot,
+  readJson,
+  run,
+  watch
+});

package/dist/react-native-rust.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_react_native_rust_lib = require("./react-native-rust-lib");
+var import_app = require("./app");
+function printHelp() {
+  console.log(`react-native-rust - Rust helper for React Native C++ TurboModule libraries
+
+Usage:
+  react-native-rust create <name>  Create a React Native library and initialize Rust support
+  react-native-rust init             Add Rust support and generate functions from the Spec interface
+  react-native-rust init --app       Add app-local Rust support to a React Native app
+  react-native-rust generate         Regenerate Rust, C++, and TypeScript glue from Spec
+  react-native-rust doctor [target]  Check Rust and optional ios/android/web prerequisites
+  react-native-rust build ios        Build an iOS XCFramework
+  react-native-rust build android    Build Android static archives for supported ABIs
+  react-native-rust build web        Build a WebAssembly package for react-native-web
+  react-native-rust watch            Watch the Spec and rust/ for changes and rebuild automatically
+  react-native-rust --help           Show this help
+
+Create a library first with the C++ module template from:
+  npx create-react-native-library@latest`);
+}
+function createProject(projectName) {
+  if (!projectName || projectName.startsWith("-") || import_node_path.default.basename(projectName) !== projectName) {
+    throw new Error("Usage: react-native-rust create <library-name>");
+  }
+  const projectPath = import_node_path.default.resolve(process.cwd(), projectName);
+  if (import_node_fs.default.existsSync(projectPath)) {
+    throw new Error(`The target directory already exists: ${projectPath}`);
+  }
+  console.log("In the scaffolder prompts, select a TurboModule library using C++.");
+  const scaffold = (0, import_node_child_process.spawnSync)("npx", ["--yes", "create-react-native-library@latest", projectName], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    encoding: "utf8"
+  });
+  if (scaffold.error) throw new Error(`React Native library creation failed: ${scaffold.error.message}`);
+  if (scaffold.status !== 0) throw new Error("React Native library creation failed.");
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(projectPath, "package.json"))) {
+    throw new Error(`The scaffolder did not create ${projectPath}.`);
+  }
+  const initialized = (0, import_node_child_process.spawnSync)(process.execPath, [__filename, "init"], {
+    cwd: projectPath,
+    stdio: "inherit",
+    encoding: "utf8"
+  });
+  if (initialized.error) {
+    throw new Error(`Rust initialization failed in ${projectPath}: ${initialized.error.message}`);
+  }
+  if (initialized.status !== 0) {
+    throw new Error(`Rust initialization failed in ${projectPath}.`);
+  }
+  console.log(`Created ${projectName}. Next run \`cd ${projectName} && yarn install\`.`);
+}
+function main(args) {
+  const [command, option] = args;
+  if (!command || command === "--help" || command === "-h") return printHelp();
+  if (command === "create") return createProject(option);
+  if (command === "init") {
+    if (option === "--app") return (0, import_app.initApp)();
+    if (option) throw new Error("Use `react-native-rust init --app` for an app, or run `react-native-rust init` from a C++ TurboModule library.");
+    return (0, import_react_native_rust_lib.init)();
+  }
+  const appRoot = process.cwd();
+  const appModule = (0, import_app.appModuleRoot)(appRoot);
+  if (command === "generate") {
+    if (!appModule) return (0, import_react_native_rust_lib.generate)();
+    return (0, import_app.inDirectory)(appModule, () => {
+      (0, import_react_native_rust_lib.generate)();
+      (0, import_app.runCodegen)(appRoot, appModule);
+    });
+  }
+  if (command === "doctor") {
+    if (option && option !== "ios" && option !== "android" && option !== "web") {
+      throw new Error("Choose a doctor target: ios, android, or web.");
+    }
+    const target = option;
+    return appModule ? (0, import_app.inDirectory)(appModule, () => (0, import_react_native_rust_lib.doctor)(target)) : (0, import_react_native_rust_lib.doctor)(target);
+  }
+  if (command === "build") {
+    if (!appModule) return (0, import_react_native_rust_lib.build)(option);
+    (0, import_app.runCodegen)(appRoot, appModule);
+    return (0, import_app.inDirectory)(appModule, () => (0, import_react_native_rust_lib.build)(option));
+  }
+  if (command === "watch") {
+    if (appModule) process.chdir(appModule);
+    const handle = (0, import_react_native_rust_lib.watch)(appModule ? { onGenerated: () => (0, import_app.runCodegen)(appRoot, appModule) } : {});
+    const shutdown = (signal) => {
+      console.log(`
+[Rust] Received ${signal}, stopping watcher...`);
+      handle.stop().finally(() => process.exit(0));
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGHUP", () => shutdown("SIGHUP"));
+    return;
+  }
+  throw new Error(`Unknown command: ${command}. Run react-native-rust --help for usage.`);
+}
+try {
+  main(process.argv.slice(2));
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+}

package/dist/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/metro.js

@@ -0,0 +1,2 @@
+// Entry point for `require('@rejaul/react-native-rust/metro')`.
+module.exports = require('./dist/metro.js');