@react-native-native/nativ-fabric 0.1.0

package/metro/compilers/static-compiler.js

@@ -0,0 +1,1118 @@
+/**
+ * static-compiler.js — Production build: generates bridges + compiles Rust.
+ *
+ * iOS (CocoaPods :before_compile):
+ *   Three fixed-name files in --output dir:
+ *     - nativ_bridges.mm    — all C++/ObjC++ bridges + Swift/Rust C registration
+ *     - nativ_bridges.swift — all Swift source + @_cdecl wrappers
+ *     - libnativ_user.a     — unified Rust static library
+ *
+ * Android (Gradle pre-build):
+ *   Per-file bridges + Kotlin wrappers in .nativ/generated/
+ *
+ * Invoked by:
+ *   - CocoaPods script phase: node static-compiler.js --platform ios --root $ROOT --output $DIR
+ *   - Gradle pre-build task:  node static-compiler.js --platform android --root $ROOT
+ */
+
+const path = require("path");
+const fs = require("fs");
+const { execSync } = require("child_process");
+
+// Reuse existing extractors
+const {
+  extractCppExports,
+  isCppComponent,
+  extractCppComponentProps,
+} = require("../extractors/cpp-ast-extractor");
+// extractRustExports used via lazy require in buildRustStatic
+const { extractSwiftExports } = require("./swift-compiler");
+const { extractKotlinExports } = require("../extractors/kotlin-extractor");
+
+// Reuse existing bridge generators (Android per-file path)
+const { generateBridge } = require("./dylib-compiler");
+
+// ─── CLI ───────────────────────────────────────────────────────────────
+
+// Skip in Debug builds — all native code loads via Metro dylibs
+if (process.env.CONFIGURATION === "Debug") {
+  console.log("[nativ] Debug build — skipping static compilation");
+  process.exit(0);
+}
+
+const args = process.argv.slice(2);
+const platformIdx = args.indexOf("--platform");
+const platform = platformIdx >= 0 ? args[platformIdx + 1] : "ios";
+const projectRoot = args.includes("--root")
+  ? args[args.indexOf("--root") + 1]
+  : process.cwd();
+const outputDir = args.includes("--output")
+  ? args[args.indexOf("--output") + 1]
+  : null;
+
+const isIOS = platform === "ios";
+const isAndroid = platform === "android";
+
+// iOS: output is the bridges directory (three fixed files)
+// Android: output is .nativ/generated/ with subdirectories
+const genDir = path.join(projectRoot, ".nativ/generated");
+let bridgeDir, releaseDir;
+if (isIOS) {
+  bridgeDir = outputDir || path.join(projectRoot, ".nativ/bridges");
+  releaseDir = bridgeDir; // libnativ_user.a goes alongside bridges
+} else {
+  bridgeDir = path.join(genDir, "bridges/android");
+  releaseDir = path.join(genDir, "release");
+}
+fs.mkdirSync(bridgeDir, { recursive: true });
+if (isAndroid) fs.mkdirSync(releaseDir, { recursive: true });
+
+console.log(
+  `[nativ] Static compiler: platform=${platform}, root=${projectRoot}`,
+);
+
+// ─── Scan for user native files ────────────────────────────────────────
+
+function findUserFiles(exts) {
+  const results = [];
+  const ignore = [
+    "node_modules",
+    ".nativ",
+    "modules",
+    "ios",
+    "android",
+    "vendor",
+  ];
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (ignore.includes(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (exts.some((ext) => entry.name.endsWith(ext))) {
+        results.push(full);
+      }
+    }
+  }
+  walk(projectRoot);
+  return results;
+}
+
+// ─── iOS: combined bridge generation ──────────────────────────────────
+// All bridges go into two files: nativ_bridges.mm + nativ_bridges.swift
+
+function buildCombinedIOSBridges() {
+  const mmSections = [];
+
+  // Shared .mm preamble
+  mmSections.push(`// Auto-generated by React Native Native — do not edit
+// Combined production bridges for all native modules
+
+#include <string>
+#include <cstdlib>
+#include <dispatch/dispatch.h>
+
+// Forward declarations
+extern "C" {
+typedef const char* (*NativSyncFn)(const char*);
+typedef void (*NativAsyncFn)(const char*, void (*)(const char*), void (*)(const char*, const char*));
+typedef void (*NativRenderFn)(void*, float, float, void*, void*);
+void nativ_register_sync(const char*, const char*, NativSyncFn);
+void nativ_register_async(const char*, const char*, NativAsyncFn);
+void nativ_register_render(const char*, NativRenderFn);
+}
+
+// JSON helpers
+${generateJsonHelpers()}
+`);
+
+  // ── C++/ObjC++ modules ─────────────────────────────────────
+  const cppFiles = findUserFiles([".cpp", ".cc", ".mm"]);
+  for (const filepath of cppFiles) {
+    if (isCppComponent(filepath)) {
+      mmSections.push(generateCppComponentSection(filepath));
+    } else {
+      const exports = extractCppExports(filepath, []);
+      if (exports.length === 0) continue;
+      const rel = path.relative(projectRoot, filepath);
+      const moduleId = rel
+        .replace(/\.(cpp|cc|mm)$/, "")
+        .replace(/[\/\\]/g, "_")
+        .replace(/[^a-zA-Z0-9_]/g, "_");
+      mmSections.push(generateCppModuleSection(filepath, exports, moduleId));
+    }
+  }
+
+  // ── Swift modules ──────────────────────────────────────────
+  const swiftFiles = findUserFiles([".swift"]);
+  const swiftBodies = [];
+  const swiftWrappers = [];
+
+  for (const filepath of swiftFiles) {
+    const name = path.basename(filepath, ".swift");
+    const moduleId = name.toLowerCase();
+    const src = fs.readFileSync(filepath, "utf8");
+    const isComp =
+      src.includes("@nativ_component") || src.includes("nativ::component");
+
+    if (isComp) {
+      // Component: generate render bridge in Swift, C registration in .mm
+      mmSections.push(generateSwiftComponentRegistration(moduleId));
+      const { swiftCode } = generateSwiftComponentBridge(
+        filepath,
+        src,
+        name,
+        moduleId,
+      );
+      swiftBodies.push(swiftCode);
+      console.log(`[nativ] Bridge: ${moduleId} (Swift component)`);
+    } else {
+      const exports = extractSwiftExports(filepath);
+
+      if (exports.length === 0) {
+        // No annotations — include as helper file (available to annotated files)
+        swiftBodies.push(`// From: ${name}.swift\n${stripAnnotations(src)}`);
+        console.log(`[nativ] Swift helper: ${name}.swift`);
+        continue;
+      }
+
+      // C registration in .mm
+      mmSections.push(generateSwiftFunctionRegistration(exports, moduleId));
+
+      // User source (imports kept) + @_cdecl wrappers
+      swiftBodies.push(`// From: ${name}.swift\n${stripAnnotations(src)}`);
+      swiftWrappers.push(
+        ...exports.map((fn) => generateSwiftCdeclWrapper(fn)),
+      );
+      console.log(
+        `[nativ] Bridge: ${moduleId} (${exports.length} Swift functions)`,
+      );
+    }
+  }
+
+  // ── Write nativ_bridges.mm ─────────────────────────────────
+  const mmContent = mmSections.join("\n");
+  fs.writeFileSync(path.join(bridgeDir, "nativ_bridges.mm"), mmContent);
+  console.log(
+    `[nativ] Wrote nativ_bridges.mm (${(mmContent.length / 1024).toFixed(1)}KB)`,
+  );
+
+  // ── Write nativ_bridges.swift ──────────────────────────────
+  const swiftContent = [
+    "// Auto-generated by React Native Native — do not edit",
+    "",
+    ...swiftBodies,
+    "",
+    ...swiftWrappers,
+    "",
+  ].join("\n");
+  fs.writeFileSync(path.join(bridgeDir, "nativ_bridges.swift"), swiftContent);
+  console.log(
+    `[nativ] Wrote nativ_bridges.swift (${(swiftContent.length / 1024).toFixed(1)}KB)`,
+  );
+}
+
+// ─── Helpers: JSON parse/escape (emitted once in combined .mm) ────────
+
+function generateJsonHelpers() {
+  return String.raw`static std::string _jsonEscapeString(const std::string& s) {
+  std::string buf = "\"";
+  for (unsigned char c : s) {
+    if (c == '"') buf += "\\\"";
+    else if (c == '\\') buf += "\\\\";
+    else if (c == '\n') buf += "\\n";
+    else if (c == '\r') buf += "\\r";
+    else if (c == '\t') buf += "\\t";
+    else if (c >= 0x20) buf += (char)c;
+  }
+  buf += "\"";
+  return buf;
+}
+
+static double _parseNumber(const char* &p) {
+  while (*p == ' ' || *p == ',' || *p == '[') p++;
+  char* end; double v = strtod(p, &end); p = end; return v;
+}
+
+static std::string _parseString(const char* &p) {
+  while (*p && *p != '"') p++; if (*p == '"') p++;
+  std::string s; while (*p && *p != '"') {
+    if (*p == '\\' && *(p+1)) { p++; s += *p; } else { s += *p; } p++; }
+  if (*p == '"') p++; return s;
+}`;
+}
+
+// ─── Helpers: per-module C++ bridge code ──────────────────────────────
+
+function generateCppModuleSection(filepath, exports, moduleId) {
+  const lines = [];
+
+  lines.push(`// ─── C++ module: ${moduleId} ────────────────────────────`);
+  lines.push(`#include "${path.resolve(filepath)}"`);
+  lines.push("");
+  lines.push("extern \"C\" {");
+
+  for (const fn of exports) {
+    lines.push(...generateCppFnWrapper(fn, moduleId));
+    lines.push("");
+  }
+
+  // Constructor
+  lines.push("__attribute__((constructor, used))");
+  lines.push(`static void nativ_cpp_register_${moduleId}() {`);
+  for (const fn of exports) {
+    if (fn.async) {
+      lines.push(
+        `  nativ_register_async("${moduleId}", "${fn.name}", nativ_cpp_async_${moduleId}_${fn.name});`,
+      );
+    } else {
+      lines.push(
+        `  nativ_register_sync("${moduleId}", "${fn.name}", nativ_cpp_${moduleId}_${fn.name});`,
+      );
+    }
+  }
+  lines.push("}");
+  lines.push("} // extern \"C\"");
+  lines.push("");
+
+  console.log(`[nativ] Bridge: ${moduleId} (${exports.length} C++ functions)`);
+  return lines.join("\n");
+}
+
+function generateCppFnWrapper(fn, moduleId) {
+  const lines = [];
+  const retBase = fn.ret
+    .replace(/const\s+/, "")
+    .replace(/\s*&\s*$/, "")
+    .trim();
+
+  if (fn.async) {
+    lines.push(
+      `static void nativ_cpp_async_${moduleId}_${fn.name}(const char* argsJson, void (*resolve)(const char*), void (*reject)(const char*, const char*)) {`,
+    );
+    lines.push(...generateArgParsing(fn.args));
+    lines.push("  try {");
+    const call = `${fn.name}(${fn.args.map((a) => a.name).join(", ")})`;
+    if (retBase === "void") {
+      lines.push(`    ${call};`);
+      lines.push('    resolve("null");');
+    } else if (retBase === "std::string") {
+      lines.push(`    auto result = ${call};`);
+      lines.push("    resolve(_jsonEscapeString(result).c_str());");
+    } else {
+      lines.push(`    auto result = ${call};`);
+      lines.push("    std::string buf = std::to_string(result);");
+      lines.push("    resolve(buf.c_str());");
+    }
+    lines.push("  } catch (const std::exception& e) {");
+    lines.push('    reject("NATIVE_ERROR", e.what());');
+    lines.push("  } catch (...) {");
+    lines.push('    reject("NATIVE_ERROR", "Unknown error");');
+    lines.push("  }");
+    lines.push("}");
+    return lines;
+  }
+
+  lines.push(
+    `static const char* nativ_cpp_${moduleId}_${fn.name}(const char* argsJson) {`,
+  );
+  lines.push(...generateArgParsing(fn.args));
+
+  const call = `${fn.name}(${fn.args.map((a) => a.name).join(", ")})`;
+
+  if (fn.mainThread) {
+    lines.push("  static thread_local std::string buf;");
+    lines.push("  __block std::string _result;");
+    lines.push("  dispatch_sync(dispatch_get_main_queue(), ^{");
+    lines.push(`    auto result = ${call};`);
+    if (retBase === "std::string") {
+      lines.push("    _result = _jsonEscapeString(result);");
+    } else {
+      lines.push("    _result = std::to_string(result);");
+    }
+    lines.push("  });");
+    lines.push("  buf = _result;");
+    lines.push("  return buf.c_str();");
+  } else {
+    lines.push(`  auto result = ${call};`);
+    lines.push("  static thread_local std::string buf;");
+    if (retBase === "std::string") {
+      lines.push("  buf = _jsonEscapeString(result);");
+    } else {
+      lines.push("  buf = std::to_string(result);");
+    }
+    lines.push("  return buf.c_str();");
+  }
+
+  lines.push("}");
+  return lines;
+}
+
+function generateArgParsing(fnArgs) {
+  const lines = [];
+  lines.push("  const char* p = argsJson;");
+  lines.push("  while (*p && *p != '[') p++; if (*p == '[') p++;");
+  for (const arg of fnArgs) {
+    const t = arg.type
+      .replace(/const\s+/, "")
+      .replace(/\s*&\s*$/, "")
+      .trim();
+    if (t === "std::string") {
+      lines.push(`  std::string ${arg.name} = _parseString(p);`);
+    } else {
+      lines.push(`  ${arg.type} ${arg.name} = (${arg.type})_parseNumber(p);`);
+    }
+  }
+  return lines;
+}
+
+// ─── Helpers: C++ component bridge ───────────────────────────────────
+
+function generateCppComponentSection(filepath) {
+  const baseName = path
+    .basename(filepath)
+    .replace(/\.(cpp|cc|mm)$/, "")
+    .toLowerCase();
+  const cppProps = extractCppComponentProps(filepath);
+  const propsTypeName = (() => {
+    const src = fs.readFileSync(filepath, "utf8");
+    const m = src.match(/NATIV_COMPONENT\s*\(\s*(\w+)\s*,\s*(\w+)\s*\)/);
+    return m ? m[2] : null;
+  })();
+
+  const propExtractions = (cppProps || [])
+    .map((p) => {
+      if (p.cppType === "std::string")
+        return `  props.${p.name} = _nativ_get_string(rt, obj, "${p.jsName}", props.${p.name});`;
+      if (["double", "float", "int"].includes(p.cppType))
+        return `  props.${p.name} = _nativ_get_number(rt, obj, "${p.jsName}", props.${p.name});`;
+      if (p.cppType === "bool")
+        return `  props.${p.name} = _nativ_get_bool(rt, obj, "${p.jsName}", props.${p.name});`;
+      return "";
+    })
+    .join("\n");
+
+  const renderFnName = `nativ_${baseName}_render`;
+
+  console.log(`[nativ] Bridge: ${baseName} (C++ component)`);
+
+  return `// ─── C++ component: ${baseName} ─────────────────────────
+#include "${path.resolve(filepath)}"
+
+extern "C"
+void ${renderFnName}(void* view, float width, float height,
+                   void* jsi_runtime, void* jsi_props) {
+  void* rt = jsi_runtime;
+  void* obj = jsi_props;
+${propsTypeName ? `  ${propsTypeName} props;\n${propExtractions}\n  mount(view, width, height, props);` : "  mount(view, width, height);"}
+}
+`;
+}
+
+// ─── Helpers: Swift registration in .mm ──────────────────────────────
+
+function generateSwiftFunctionRegistration(exports, moduleId) {
+  const declarations = exports
+    .map(
+      (fn) =>
+        `extern const char* ${fn.cdeclName}(const char*);`,
+    )
+    .join("\n");
+  const registrations = exports
+    .map(
+      (fn) =>
+        `  nativ_register_sync("${moduleId}", "${fn.name}", ${fn.cdeclName});`,
+    )
+    .join("\n");
+
+  return `// ─── Swift module: ${moduleId} ──────────────────────────
+extern "C" {
+${declarations}
+
+__attribute__((constructor, used))
+static void nativ_register_${moduleId}() {
+${registrations}
+}
+} // extern "C"
+`;
+}
+
+function generateSwiftComponentRegistration(moduleId) {
+  const renderFnName = `nativ_${moduleId}_render`;
+  return `// ─── Swift component: ${moduleId} ──────────────────────
+extern "C" {
+extern void ${renderFnName}(void*, float, float, void*, void*);
+
+__attribute__((constructor, used))
+static void nativ_register_${moduleId}() {
+  nativ_register_render("nativ.${moduleId}", ${renderFnName});
+}
+} // extern "C"
+`;
+}
+
+// ─── Helpers: Swift @_cdecl wrappers ─────────────────────────────────
+
+function generateSwiftCdeclWrapper(fn) {
+  const retType = fn.ret || "Void";
+  const argPassthrough = fn.args.map((a) => a.name).join(", ");
+
+  let resultExpr;
+  if (retType === "String")
+    resultExpr = `return UnsafePointer(strdup("\\"" + result + "\\"")!)`;
+  else if (retType === "Bool")
+    resultExpr = `return UnsafePointer(strdup(result ? "true" : "false")!)`;
+  else if (retType === "Void")
+    resultExpr = `return UnsafePointer(strdup("null")!)`;
+  else resultExpr = `return UnsafePointer(strdup(String(result))!)`;
+
+  if (fn.mainThread) {
+    return `
+@_cdecl("${fn.cdeclName}")
+func _nativ_${fn.name}(_ argsJson: UnsafePointer<CChar>) -> UnsafePointer<CChar> {
+    var ptr: UnsafePointer<CChar>!
+    DispatchQueue.main.sync {
+        let result = ${fn.name}(${argPassthrough})
+        ptr = ${resultExpr.replace("return ", "")}
+    }
+    return ptr
+}`;
+  }
+
+  return `
+@_cdecl("${fn.cdeclName}")
+func _nativ_${fn.name}(_ argsJson: UnsafePointer<CChar>) -> UnsafePointer<CChar> {
+    let result = ${fn.name}(${argPassthrough})
+    ${resultExpr}
+}`;
+}
+
+// ─── Helpers: Swift component bridge ─────────────────────────────────
+
+function generateSwiftComponentBridge(_filepath, src, name, moduleId) {
+  const structMatch = src.match(
+    /\/\/\s*@nativ_component\s*\n\s*struct\s+(\w+)\s*:\s*View\s*\{([\s\S]*?)var\s+body\s*:\s*some\s+View/,
+  );
+  const structName = structMatch ? structMatch[1] : name;
+  const propsBlock = structMatch ? structMatch[2] : "";
+  // Parse fields
+  const props = [];
+  for (const line of propsBlock.split("\n")) {
+    const m = line.trim().match(/(?:let|var)\s+(\w+)\s*:\s*(\w+)/);
+    if (m && m[1] !== "body") {
+      props.push({ name: m[1], type: m[2] });
+    }
+  }
+
+  const renderFnName = `nativ_${moduleId}_render`;
+  const propExtractions = props
+    .map((p) => {
+      if (p.type === "String")
+        return `    let ${p.name} = String(cString: nativ_jsi_get_string(runtime, props, "${p.name}"))`;
+      if (
+        p.type === "Double" ||
+        p.type === "Float" ||
+        p.type === "CGFloat"
+      )
+        return `    let ${p.name} = ${p.type}(nativ_jsi_get_number(runtime, props, "${p.name}"))`;
+      if (p.type === "Int")
+        return `    let ${p.name} = Int(nativ_jsi_get_number(runtime, props, "${p.name}"))`;
+      if (p.type === "Bool")
+        return `    let ${p.name} = nativ_jsi_has_prop(runtime, props, "${p.name}") != 0 && nativ_jsi_get_number(runtime, props, "${p.name}") != 0`;
+      if (p.type === "Color")
+        return `    let ${p.name}: Color = {
+        let hex = String(cString: nativ_jsi_get_string(runtime, props, "${p.name}"))
+        let scanner = Scanner(string: hex.hasPrefix("#") ? String(hex.dropFirst()) : hex)
+        var rgb: UInt64 = 0; scanner.scanHexInt64(&rgb)
+        return Color(red: Double((rgb >> 16) & 0xFF) / 255, green: Double((rgb >> 8) & 0xFF) / 255, blue: Double(rgb & 0xFF) / 255)
+    }()`;
+      return `    let ${p.name} = String(cString: nativ_jsi_get_string(runtime, props, "${p.name}")) // unsupported type: ${p.type}`;
+    })
+    .join("\n");
+
+  const initArgs = props
+    .map((p) => `${p.name}: ${p.name}`)
+    .join(", ");
+
+  const swiftCode = `// From: ${name}.swift
+${stripAnnotations(src)}
+
+@_cdecl("${renderFnName}")
+func ${renderFnName}(
+    _ view: UnsafeMutableRawPointer,
+    _ width: Float, _ height: Float,
+    _ runtime: UnsafeMutableRawPointer?,
+    _ props: UnsafeMutableRawPointer?
+) {
+    let parentView = Unmanaged<UIView>.fromOpaque(view).takeUnretainedValue()
+
+${propExtractions}
+
+    let swiftUIView = ${structName}(${initArgs})
+    let hostingController = UIHostingController(rootView: swiftUIView)
+    hostingController.view.frame = CGRect(x: 0, y: 0, width: CGFloat(width), height: CGFloat(height))
+    hostingController.view.backgroundColor = .clear
+
+    objc_setAssociatedObject(parentView, "nativHosting", hostingController, .OBJC_ASSOCIATION_RETAIN)
+    parentView.addSubview(hostingController.view)
+}
+
+// JSI C API — resolved at link time from NativFabric
+@_silgen_name("nativ_jsi_get_string")
+func nativ_jsi_get_string(_ rt: UnsafeMutableRawPointer?, _ obj: UnsafeMutableRawPointer?, _ name: UnsafePointer<CChar>) -> UnsafePointer<CChar>
+
+@_silgen_name("nativ_jsi_get_number")
+func nativ_jsi_get_number(_ rt: UnsafeMutableRawPointer?, _ obj: UnsafeMutableRawPointer?, _ name: UnsafePointer<CChar>) -> Double
+
+@_silgen_name("nativ_jsi_has_prop")
+func nativ_jsi_has_prop(_ rt: UnsafeMutableRawPointer?, _ obj: UnsafeMutableRawPointer?, _ name: UnsafePointer<CChar>) -> Int32
+`;
+
+  return { swiftCode };
+}
+
+// ─── Helpers: Swift source handling ──────────────────────────────────
+
+function stripAnnotations(src) {
+  return src
+    .replace(/\/\/\s*@nativ_export\s*\([^)]*\)\s*\n/g, "")
+    .replace(/\/\/\s*@nativ_component\s*\n/g, "");
+}
+
+// ─── Android: per-file C++ bridges (unchanged) ──────────────────────
+
+function buildCppBridges() {
+  const exts = isIOS ? [".cpp", ".cc", ".mm"] : [".cpp", ".cc"];
+  const cppFiles = findUserFiles(exts);
+  if (cppFiles.length === 0) return;
+
+  for (const filepath of cppFiles) {
+    if (isCppComponent(filepath)) {
+      const baseName = path
+        .basename(filepath)
+        .replace(/\.(cpp|cc|mm)$/, "")
+        .toLowerCase();
+      const componentId = `nativ.${baseName}`;
+      const cppProps = extractCppComponentProps(filepath);
+      const propsTypeName = (() => {
+        const src = fs.readFileSync(filepath, "utf8");
+        const m = src.match(/NATIV_COMPONENT\s*\(\s*(\w+)\s*,\s*(\w+)\s*\)/);
+        return m ? m[2] : null;
+      })();
+
+      const propExtractions = (cppProps || [])
+        .map((p) => {
+          if (p.cppType === "std::string")
+            return `  props.${p.name} = _nativ_get_string(rt, obj, "${p.jsName}", props.${p.name});`;
+          if (["double", "float", "int"].includes(p.cppType))
+            return `  props.${p.name} = _nativ_get_number(rt, obj, "${p.jsName}", props.${p.name});`;
+          if (p.cppType === "bool")
+            return `  props.${p.name} = _nativ_get_bool(rt, obj, "${p.jsName}", props.${p.name});`;
+          return "";
+        })
+        .join("\n");
+
+      const renderFnName = `nativ_${baseName}_render`;
+      const bridgeSrc = `
+// Auto-generated production component bridge for ${baseName}
+#include "${path.resolve(filepath)}"
+
+extern "C"
+void ${renderFnName}(void* view, float width, float height,
+                   void* jsi_runtime, void* jsi_props) {
+  void* rt = jsi_runtime;
+  void* obj = jsi_props;
+${propsTypeName ? `  ${propsTypeName} props;\n${propExtractions}\n  mount(view, width, height, props);` : "  mount(view, width, height);"}
+}
+
+extern "C" {
+  typedef void (*NativRenderFn)(void*, float, float, void*, void*);
+  void nativ_register_render(const char*, NativRenderFn);
+}
+
+__attribute__((constructor, used))
+static void register_${baseName}() {
+  nativ_register_render("${componentId}", ${renderFnName});
+}
+`;
+      const ext = filepath.endsWith(".mm") ? "mm" : "cpp";
+      fs.writeFileSync(
+        path.join(bridgeDir, `nativ_${baseName}_bridge.${ext}`),
+        bridgeSrc,
+      );
+      console.log(`[nativ] Bridge: ${baseName} (component)`);
+    } else {
+      const exports = extractCppExports(filepath, []);
+      if (exports.length === 0) continue;
+
+      const rel = path.relative(projectRoot, filepath);
+      const moduleId = rel
+        .replace(/\.(cpp|cc|mm)$/, "")
+        .replace(/[\/\\]/g, "_")
+        .replace(/[^a-zA-Z0-9_]/g, "_");
+      const bridgeSrc = generateBridge(exports, moduleId);
+      const userInclude = `#include "${path.resolve(filepath)}"\n\n`;
+      const ext = filepath.endsWith(".mm") ? "mm" : "cpp";
+      fs.writeFileSync(
+        path.join(bridgeDir, `${moduleId}_bridge.${ext}`),
+        userInclude + bridgeSrc,
+      );
+      console.log(`[nativ] Bridge: ${moduleId} (${exports.length} functions)`);
+    }
+  }
+}
+
+// ─── Rust: single unified static library ───────────────────────────────
+
+function buildRustStatic() {
+  const rsFiles = findUserFiles([".rs"]);
+  if (rsFiles.length === 0) return;
+
+  const abiTargets = isAndroid
+    ? [
+        {
+          abi: "arm64-v8a",
+          rust: "aarch64-linux-android",
+          linkerPrefix: "aarch64-linux-android",
+        },
+        {
+          abi: "armeabi-v7a",
+          rust: "armv7-linux-androideabi",
+          linkerPrefix: "armv7a-linux-androideabi",
+        },
+        {
+          abi: "x86_64",
+          rust: "x86_64-linux-android",
+          linkerPrefix: "x86_64-linux-android",
+        },
+      ]
+    : [{ abi: "arm64", rust: "aarch64-apple-ios" }];
+
+  // Check if all outputs are up to date
+  const outputPaths = abiTargets.map((t) => {
+    const dir = isAndroid ? path.join(releaseDir, t.abi) : releaseDir;
+    return path.join(dir, "libnativ_user.a");
+  });
+  const allUpToDate = outputPaths.every((p) => {
+    if (!fs.existsSync(p)) return false;
+    const stat = fs.statSync(p);
+    if (stat.size < 100) return false; // stub archive — must rebuild
+    return rsFiles.every((f) => fs.statSync(f).mtimeMs < stat.mtimeMs);
+  });
+  if (allUpToDate) {
+    console.log(`[nativ] Rust: all targets up to date, skipping`);
+    return;
+  }
+
+  const {
+    generateFunctionWrapper,
+    generateComponentWrapper,
+  } = require("./rust-compiler");
+  const {
+    extractRustExports: _extractRust,
+  } = require("../extractors/rust-extractor");
+
+  const buildBase = path.join(projectRoot, ".nativ/build");
+  const unifiedDir = path.join(buildBase, "nativ_unified");
+  fs.mkdirSync(path.join(unifiedDir, "src"), { recursive: true });
+
+  // Forward deps from root Cargo.toml
+  let rootDeps = "";
+  try {
+    const rootToml = fs.readFileSync(
+      path.join(projectRoot, "Cargo.toml"),
+      "utf8",
+    );
+    const depsSection = rootToml.match(
+      /\[dependencies\]([\s\S]*?)(?:\n\[|\n*$)/,
+    );
+    if (depsSection) {
+      rootDeps = depsSection[1].replace(/path\s*=\s*"([^"]+)"/g, (_, p) => {
+        const absPath = path.resolve(projectRoot, p);
+        const relPath = path.relative(unifiedDir, absPath);
+        return `path = "${relPath}"`;
+      });
+    }
+  } catch {}
+
+  fs.writeFileSync(
+    path.join(unifiedDir, "Cargo.toml"),
+    `[package]
+name = "nativ-user"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["staticlib"]
+
+[workspace]
+
+[dependencies]
+${rootDeps}
+
+[profile.release]
+opt-level = "z"
+lto = true
+`,
+  );
+
+  const modules = [];
+  for (const filepath of rsFiles) {
+    const { functions, isComponent } = _extractRust(filepath);
+    if (!isComponent && functions.length === 0) continue;
+
+    const name = path.basename(filepath, ".rs").toLowerCase();
+    const userSrc = fs.readFileSync(filepath, "utf8");
+
+    let moduleSrc;
+    if (isComponent) {
+      moduleSrc = generateComponentWrapper(userSrc, name, { unified: true });
+    } else {
+      moduleSrc = generateFunctionWrapper(userSrc, functions, name, {
+        unified: true,
+      });
+    }
+    fs.writeFileSync(path.join(unifiedDir, "src", `${name}.rs`), moduleSrc);
+    modules.push(name);
+  }
+
+  if (modules.length === 0) {
+    console.log("[nativ] Rust: no exported modules found");
+    return;
+  }
+
+  const libRs = [
+    "// Auto-generated by React Native Native — do not edit",
+    "#![allow(unused, non_snake_case, unused_unsafe)]",
+    "",
+    "pub use nativ_core::prelude::*;",
+    "",
+    ...modules.map((m) => `pub mod ${m};`),
+    "",
+  ].join("\n");
+  fs.writeFileSync(path.join(unifiedDir, "src/lib.rs"), libRs);
+
+  const sharedTarget = path.join(buildBase, "cargo-target");
+
+  // Resolve NDK toolchain for Android
+  let ndkBinDir = null;
+  if (isAndroid) {
+    const androidHome =
+      process.env.ANDROID_HOME ||
+      path.join(process.env.HOME, "Library/Android/sdk");
+    const ndkDir = path.join(androidHome, "ndk");
+    try {
+      const versions = fs.readdirSync(ndkDir).sort();
+      if (versions.length > 0) {
+        const toolchain = path.join(
+          ndkDir,
+          versions[versions.length - 1],
+          "toolchains/llvm/prebuilt",
+        );
+        const hosts = fs.readdirSync(toolchain);
+        if (hosts.length > 0)
+          ndkBinDir = path.join(toolchain, hosts[0], "bin");
+      }
+    } catch {}
+    if (!ndkBinDir) {
+      console.error(
+        "[nativ] Android NDK not found — cannot build Rust for Android",
+      );
+      return;
+    }
+  }
+
+  for (const { abi, rust: target, linkerPrefix } of abiTargets) {
+    const outDir = isAndroid ? path.join(releaseDir, abi) : releaseDir;
+    fs.mkdirSync(outDir, { recursive: true });
+    const outputLib = path.join(outDir, "libnativ_user.a");
+
+    const home = process.env.HOME || require("os").homedir();
+    const cargoPath = fs.existsSync(path.join(home, ".cargo/bin/cargo"))
+      ? path.join(home, ".cargo/bin/cargo")
+      : "cargo";
+
+    const cmd = [
+      cargoPath,
+      "build",
+      "--release",
+      "--manifest-path",
+      path.join(unifiedDir, "Cargo.toml"),
+      `--target=${target}`,
+      "--lib",
+    ];
+
+    const env = { ...process.env, CARGO_TARGET_DIR: sharedTarget };
+    if (isIOS) {
+      env.RUSTFLAGS =
+        "--cfg unified -C link-arg=-undefined -C link-arg=dynamic_lookup";
+    }
+    if (isAndroid) {
+      const envKey = `CARGO_TARGET_${target.toUpperCase().replace(/-/g, "_")}_LINKER`;
+      env[envKey] = path.join(ndkBinDir, `${linkerPrefix}24-clang`);
+      env.RUSTFLAGS = "--cfg unified -C link-arg=-llog";
+    }
+
+    console.log(
+      `[nativ] Compiling Rust (${modules.length} modules, ${abi} → ${target})...`,
+    );
+    try {
+      execSync(cmd.join(" "), { stdio: "pipe", encoding: "utf8", env });
+    } catch (err) {
+      console.error(`[nativ] Rust compile failed for ${abi}`);
+      console.error((err.stderr || "").slice(0, 3000));
+      continue;
+    }
+
+    const builtLib = path.join(sharedTarget, target, "release/libnativ_user.a");
+    if (fs.existsSync(builtLib)) {
+      fs.copyFileSync(builtLib, outputLib);
+      const size = fs.statSync(outputLib).size;
+      console.log(
+        `[nativ] Built ${abi}/libnativ_user.a (${(size / 1024).toFixed(1)}KB)`,
+      );
+    } else {
+      console.error(`[nativ] libnativ_user.a not found at ${builtLib}`);
+    }
+  }
+}
+
+// ─── Kotlin wrapper generation (Android only) ──────────────────────────
+
+function buildKotlinSources() {
+  if (!isAndroid) return [];
+  const ktFiles = findUserFiles([".kt"]);
+  if (ktFiles.length === 0) return [];
+
+  const ktSrcDir = path.join(genDir, "kotlin-src/com/nativfabric/generated");
+  fs.mkdirSync(ktSrcDir, { recursive: true });
+  const registeredModules = [];
+
+  for (const filepath of ktFiles) {
+    const { functions, isComponent } = extractKotlinExports(filepath);
+    const baseName = path.basename(filepath, ".kt");
+    const moduleId = baseName.toLowerCase();
+    const className = `NativModule_${moduleId}`;
+    const userSrc = fs.readFileSync(filepath, "utf8");
+
+    if (isComponent) {
+      const cleanSrc = userSrc
+        .replace(/\/\/\s*@nativ_component\s*\n/g, "")
+        .replace(/^package\s+[^\n]+\n/m, "")
+        .replace(/^import\s+[^\n]+\n/gm, "");
+      const userImports = [...userSrc.matchAll(/^(import\s+[^\n]+)\n/gm)].map(
+        (m) => m[1],
+      );
+      const isCompose = userSrc.includes("@Composable");
+
+      if (isCompose) {
+        const compFnMatch = cleanSrc.match(
+          /@Composable\s+fun\s+(\w+)\s*\(([^)]*)\)/,
+        );
+        const compFnName = compFnMatch ? compFnMatch[1] : baseName;
+        const compParams =
+          compFnMatch && compFnMatch[2] ? compFnMatch[2].trim() : "";
+
+        let compCall;
+        if (compParams) {
+          const compArgs = compParams
+            .split(",")
+            .map((p) => p.trim())
+            .filter(Boolean);
+          const argExprs = compArgs
+            .map((p) => {
+              const m = p.match(/(\w+)\s*:\s*(.+)/);
+              if (!m) return null;
+              const [, pName, pType] = m;
+              const t = pType.trim();
+              if (t === "String")
+                return `                ${pName} = props["${pName}"] as? String ?: ""`;
+              if (t === "Int")
+                return `                ${pName} = (props["${pName}"] as? Number)?.toInt() ?: 0`;
+              if (t === "Float" || t === "Double")
+                return `                ${pName} = (props["${pName}"] as? Number)?.toDouble() ?: 0.0`;
+              if (t === "Boolean")
+                return `                ${pName} = props["${pName}"] as? Boolean ?: false`;
+              if (t.includes("->"))
+                return `                ${pName} = {}`;
+              return `                ${pName} = props["${pName}"]`;
+            })
+            .filter(Boolean);
+          compCall = `            ${compFnName}(\n${argExprs.join(",\n")}\n            )`;
+        } else {
+          compCall = `            ${compFnName}()`;
+        }
+
+        const wrapper = [
+          `package com.nativfabric.generated`,
+          "",
+          "import android.view.ViewGroup",
+          "import android.widget.FrameLayout",
+          "import androidx.compose.runtime.*",
+          "import androidx.compose.ui.platform.ComposeView",
+          ...userImports,
+          "",
+          cleanSrc,
+          "",
+          `object ${className} {`,
+          "    @JvmStatic",
+          "    fun render(parent: ViewGroup, props: Map<String, Any?>) {",
+          "        val composeView = ComposeView(parent.context)",
+          "        composeView.setContent {",
+          compCall,
+          "        }",
+          "        parent.addView(composeView, FrameLayout.LayoutParams(",
+          "            FrameLayout.LayoutParams.MATCH_PARENT,",
+          "            FrameLayout.LayoutParams.MATCH_PARENT))",
+          "    }",
+          "}",
+        ].join("\n");
+        fs.writeFileSync(path.join(ktSrcDir, `${className}.kt`), wrapper);
+      } else {
+        const fnMatch = cleanSrc.match(/fun\s+(\w+)\s*\(\s*parent\s*:/);
+        const fnName = fnMatch ? fnMatch[1] : baseName;
+        const wrapper = [
+          `package com.nativfabric.generated`,
+          "",
+          ...userImports,
+          "",
+          cleanSrc,
+          "",
+          `object ${className} {`,
+          "    @JvmStatic",
+          "    fun render(parent: android.view.ViewGroup, props: Map<String, Any?>) {",
+          `        ${fnName}(parent, props)`,
+          "    }",
+          "}",
+        ].join("\n");
+        fs.writeFileSync(path.join(ktSrcDir, `${className}.kt`), wrapper);
+      }
+      registeredModules.push(moduleId);
+      console.log(`[nativ] Kotlin wrapper: ${moduleId} (component)`);
+    } else if (functions.length > 0) {
+      const cleanSrc = userSrc
+        .replace(/\/\/\s*@nativ_export\s*\([^)]*\)\s*\n/g, "")
+        .replace(/^package\s+[^\n]+\n/m, "");
+
+      const lines = [
+        `package com.nativfabric.generated`,
+        "",
+        cleanSrc,
+        "",
+        `private fun _parseArgs(json: String): List<String> {`,
+        `    val s = json.trim().removePrefix("[").removeSuffix("]")`,
+        `    if (s.isBlank()) return emptyList()`,
+        `    val result = mutableListOf<String>()`,
+        `    var i = 0; var inStr = false; var esc = false; val buf = StringBuilder()`,
+        `    while (i < s.length) { val c = s[i]; when {`,
+        `        esc -> { buf.append(c); esc = false }; c == '\\\\' -> esc = true`,
+        `        c == '"' -> inStr = !inStr; c == ',' && !inStr -> { result.add(buf.toString().trim()); buf.clear() }`,
+        `        else -> buf.append(c) }; i++ }`,
+        `    if (buf.isNotEmpty()) result.add(buf.toString().trim()); return result }`,
+        "",
+        `object ${className} {`,
+        "    @JvmStatic",
+        "    fun dispatch(fnName: String, argsJson: String): String {",
+        "        val args = _parseArgs(argsJson)",
+        "        return when (fnName) {",
+      ];
+      for (const fn of functions) {
+        const argExprs = fn.args.map((a, i) => {
+          switch (a.type) {
+            case "Int":
+              return `args[${i}].toInt()`;
+            case "Long":
+              return `args[${i}].toLong()`;
+            case "Float":
+              return `args[${i}].toFloat()`;
+            case "Double":
+              return `args[${i}].toDouble()`;
+            case "Boolean":
+              return `args[${i}].toBoolean()`;
+            default:
+              return `args[${i}]`;
+          }
+        });
+        const call = `${fn.name}(${argExprs.join(", ")})`;
+        if (fn.ret === "String")
+          lines.push(`            "${fn.name}" -> "\\"" + ${call} + "\\""`);
+        else if (fn.ret === "Unit")
+          lines.push(`            "${fn.name}" -> { ${call}; "null" }`);
+        else lines.push(`            "${fn.name}" -> ${call}.toString()`);
+      }
+      lines.push('            else -> "null"', "        }", "    }", "}");
+      fs.writeFileSync(
+        path.join(ktSrcDir, `${className}.kt`),
+        lines.join("\n"),
+      );
+      registeredModules.push(moduleId);
+      console.log(
+        `[nativ] Kotlin wrapper: ${moduleId} (${functions.length} functions)`,
+      );
+    }
+  }
+  return registeredModules;
+}
+
+// ─── Run ───────────────────────────────────────────────────────────────
+
+const t0 = Date.now();
+
+if (isIOS) {
+  buildCombinedIOSBridges();
+  buildRustStatic();
+} else {
+  buildCppBridges();
+  buildRustStatic();
+  const kotlinModules = buildKotlinSources();
+
+  // Kotlin registry
+  if (kotlinModules && kotlinModules.length > 0) {
+    const ktSrcDir = path.join(
+      genDir,
+      "kotlin-src/com/nativfabric/generated",
+    );
+    const registrations = kotlinModules
+      .map((moduleId) => {
+        const className = `NativModule_${moduleId}`;
+        return `        try {
+            val clazz = Class.forName("com.nativfabric.generated.${className}")
+            try {
+                val dispatch = clazz.getMethod("dispatch", String::class.java, String::class.java)
+                com.nativfabric.NativRuntime.registerKotlinDispatch("${moduleId}", dispatch)
+            } catch (_: NoSuchMethodException) {}
+            try {
+                val render = clazz.getMethod("render", android.view.ViewGroup::class.java, Map::class.java)
+                com.nativfabric.NativRuntime.registerKotlinRenderer("nativ.${moduleId}", render)
+            } catch (_: NoSuchMethodException) {}
+        } catch (e: Exception) {
+            android.util.Log.w("NativRegistry", "Module ${moduleId}: \${e.message}")
+        }`;
+      })
+      .join("\n");
+
+    fs.writeFileSync(
+      path.join(ktSrcDir, "NativModuleRegistry.kt"),
+      `package com.nativfabric.generated
+
+object NativModuleRegistry {
+    init {
+${registrations}
+    }
+
+    fun ensure() {} // Called to trigger class loading
+}
+`,
+    );
+    console.log(`[nativ] Kotlin registry: ${kotlinModules.length} modules`);
+  }
+}
+
+console.log(`[nativ] Static compilation done in ${Date.now() - t0}ms`);