@rejaul/react-native-rust 1.0.2 → 1.1.1

package/README.md

@@ -4,11 +4,21 @@ Generate Rust functions and native bindings from a React Native TurboModule Type
 
 The CLI currently targets the **C++ TurboModule** template created by [`create-react-native-library`](https://www.npmjs.com/package/create-react-native-library).
 
+## Screenshots
+
+The generated [`react-native-awesome-library-example`](react-native-awesome-library-example) app calling every generated method and rendering its live Rust result, on all three platforms:
+
+| Android | iOS | Web |
+| --- | --- | --- |
+| ![Android screenshot](doc/screenshots/android.png) | ![iOS screenshot](doc/screenshots/ios.png) | ![Web screenshot](doc/screenshots/web.png) |
+
 ## Contents
 
+- [Screenshots](#screenshots)
 - [Requirements](#requirements)
 - [Create a library](#create-a-library)
 - [Add Rust functions](#add-rust-functions)
+- [Use Rust in an app](#use-rust-in-an-app)
 - [Build and run](#build-and-run)
 - [Supported types](#supported-types)
 - [Publish](#publish)
@@ -24,6 +34,7 @@ The CLI currently targets the **C++ TurboModule** template created by [`create-r
 - Rust stable (`rustup`, `cargo`).
 - Android builds: Android SDK/NDK and `cargo-ndk`.
 - iOS builds: macOS, Xcode command-line tools, and the Rust Apple targets.
+- Web builds (`react-native-web`): [`wasm-pack`](https://rustwasm.github.io/wasm-pack/) and the `wasm32-unknown-unknown` Rust target (`rustup target add wasm32-unknown-unknown`).
 
 ## Create a library
 
@@ -42,10 +53,10 @@ cd react-native-awesome-library
 yarn install
 ```
 
-To run the CLI from its source checkout before publishing, use the checkout's path from the desired parent folder:
+To run the CLI from its source checkout before publishing, build it once (`npm run build` from the checkout root), then invoke the compiled output by path from the desired parent folder:
 
 ```sh
-node /path/to/rust_to_cpp/bin/react-native-rust.js create react-native-awesome-library
+node /path/to/rust_to_cpp/dist/react-native-rust.js create react-native-awesome-library
 ```
 
 To add Rust support to an existing C++ TurboModule library, install the CLI and initialize it from that library's root:
@@ -89,6 +100,40 @@ Run Rust tests with:
 yarn rust:test
 ```
 
+## Use Rust in an app
+
+For app-specific Rust code, run the CLI from the root of an existing React Native Community CLI app that has both `android/` and `ios/` folders:
+
+```sh
+npx react-native-rust init --app
+npm install
+```
+
+The command creates a private local TurboModule package in `native/rust-module/`, adds it to the app as a local dependency, and generates its C++ bridge and Rust crate. It does not publish a separate library. App-local mode currently supports C++ TurboModule apps with both Android and iOS projects.
+
+Edit `native/rust-module/src/NativeRustApp.ts` to declare methods, then implement their generated handlers under `native/rust-module/rust/src/api/`. From the app root, regenerate the bindings and React Native Codegen output with:
+
+```sh
+npm run rust:generate
+```
+
+Build the Rust archive for the target platform, then build and launch the React Native app:
+
+```sh
+npm run rust:build:android
+npx react-native run-android
+```
+
+For iOS, build the XCFramework, install Pods, then launch the app:
+
+```sh
+npm run rust:build:ios
+cd ios && pod install && cd ..
+npx react-native run-ios
+```
+
+The generated module is app-local and can be used from the app's JavaScript imports. The root `example/` project in this repository exercises this workflow.
+
 ## Build and run
 
 Run these commands from the library root. Generate TurboModule Codegen output with `yarn prepare` before building the host app.
@@ -150,6 +195,30 @@ Rust outputs are written under `rust/build/` and included in the generated libra
 
 The example screen in `example/src/App.tsx` exercises the supported scalar, JSON, Promise, and callback signatures.
 
+### Web
+
+Install `wasm-pack` and the `wasm32-unknown-unknown` target once:
+
+```sh
+cargo install wasm-pack
+rustup target add wasm32-unknown-unknown
+```
+
+Build the WebAssembly package:
+
+```sh
+yarn rust:build:web
+```
+
+This compiles `rust/` to `rust/build/web/pkg/` with `wasm-pack build --target web`, reusing the same `rust/src/api/<method>.rs` handlers as native — no separate implementation is needed. It replaces the generated `src/rust-generated.tsx` module (used by web bundlers that don't understand Metro's `.native.` file convention, such as Vite or webpack) with a real, WASM-backed implementation instead of the "not supported on native platforms" stub used before this module exists. Call and await its exported `initRustWeb()` once before using any generated function on web, since loading a `.wasm` file is asynchronous:
+
+```ts
+import { initRustWeb, multiply } from 'react-native-awesome-library';
+
+await initRustWeb();
+multiply(3, 7); // 21
+```
+
 ## Supported types
 
 The generator supports these TypeScript-to-Rust/C++ mappings:
@@ -169,6 +238,8 @@ Arrays and `UnsafeObject` values cross the native boundary as JSON, so their con
 
 Typed object structs, optional or rest parameters, destructured parameters, generic methods, and overloads are not supported. Unsupported signatures fail before generated files are changed.
 
+The same mappings apply on `react-native-web`: values cross as JSON strings via `wasm-bindgen` instead of the JSI C++ bridge, and callback parameters are passed as a JS function. See [Web](#web) for the build step and the async `initRustWeb()` call it requires.
+
 ## Publish
 
 Before publishing a generated React Native library, generate its TypeScript/native outputs and build the Rust artifacts for the platforms you intend to ship:
@@ -177,6 +248,7 @@ Before publishing a generated React Native library, generate its TypeScript/nati
 yarn prepare
 yarn rust:build:ios
 yarn rust:build:android
+yarn rust:build:web
 npm pack --dry-run
 ```
 
@@ -196,6 +268,8 @@ Pushing a version tag such as `v1.0.2` runs [`.github/workflows/publish.yml`](.g
 - Android CMake cannot find `android/generated/jni`: run `yarn prepare` from the library root.
 - Android CMake cannot find a Rust `.a` archive: run `yarn rust:build:android` before launching the example.
 - iOS reports a missing Rust XCFramework: run `yarn rust:build:ios`, then `pod install` in `example/ios`.
+- `wasm-pack: command not found`: install it with `cargo install wasm-pack`, or run `react-native-rust doctor web` to check both prerequisites.
+- The web app throws "Call and await initRustWeb()...": await `initRustWeb()` once before calling any other generated function; loading the `.wasm` file is asynchronous even though the generated calls are not.
 - A React Native type is reported as unsupported: check the mappings and signature restrictions in [Supported types](#supported-types).
 
 ## Contributing

package/dist/app.js

@@ -0,0 +1,271 @@
+"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 app_exports = {};
+__export(app_exports, {
+  appModuleRoot: () => appModuleRoot,
+  inDirectory: () => inDirectory,
+  initApp: () => initApp,
+  runCodegen: () => runCodegen
+});
+module.exports = __toCommonJS(app_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_react_native_rust_lib = require("./react-native-rust-lib");
+const moduleDirectory = import_node_path.default.join("native", "rust-module");
+const moduleName = "RustApp";
+const packageName = "rust-app-native-module";
+function writeFiles(root, files) {
+  for (const [relativePath, contents] of Object.entries(files)) {
+    const outputPath = import_node_path.default.join(root, relativePath);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(outputPath), { recursive: true });
+    import_node_fs.default.writeFileSync(outputPath, contents);
+  }
+}
+function scaffoldFiles(appName) {
+  const javaPackageName = appName.replace(/([a-z0-9])([A-Z])/g, "$1.$2").replace(/[^a-zA-Z0-9]+/g, ".").replace(/^\.+|\.+$/g, "").toLowerCase() || "com.rustapp";
+  return {
+    "package.json": `${JSON.stringify({
+      name: packageName,
+      version: "0.0.1",
+      description: "App-local Rust TurboModule",
+      main: "src/index.tsx",
+      "react-native": "src/index.tsx",
+      types: "src/index.tsx",
+      files: ["src/", "cpp/", "android/", "ios/", "*.podspec", "react-native.config.js", "rust/"],
+      peerDependencies: { react: "*", "react-native": ">=0.76" },
+      codegenConfig: {
+        name: `${moduleName}Spec`,
+        type: "modules",
+        jsSrcsDir: "src",
+        outputDir: { ios: "ios/generated", android: "android/generated" },
+        android: { javaPackageName },
+        includesGeneratedCode: true
+      }
+    }, null, 2)}
+`,
+    "react-native.config.js": `module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        cmakeListsPath: 'generated/jni/CMakeLists.txt',
+        cxxModuleCMakeListsModuleName: '${packageName}',
+        cxxModuleCMakeListsPath: 'CMakeLists.txt',
+        cxxModuleHeaderName: '${moduleName}Impl',
+      },
+    },
+  },
+};
+`,
+    [`${moduleName}.podspec`]: `Pod::Spec.new do |s|
+  s.name = "${moduleName}"
+  s.version = "0.0.1"
+  s.summary = "App-local Rust TurboModule"
+  s.homepage = "https://example.invalid"
+  s.license = "MIT"
+  s.author = "Local app"
+  s.source = { :git => "https://example.invalid" }
+  s.platforms = { :ios => min_ios_version_supported }
+  s.source_files = "cpp/**/*.{hpp,cpp,c,h}", "ios/**/*.{h,m,mm}", "ios/generated/*.{h,cpp,mm}"
+  s.vendored_frameworks = "rust/build/ios/${moduleName}Rust.xcframework"
+  install_modules_dependencies(s)
+end
+`,
+    ".gitignore": "node_modules/\nrust/target/\nrust/build/\n",
+    "src/NativeRustApp.ts": `import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  multiply(a: number, b: number): number;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('${moduleName}');
+`,
+    "src/index.tsx": "export * from './rust-generated';\n",
+    "cpp/RustAppImpl.h": `#pragma once
+
+#include <${moduleName}SpecJSI.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+class ${moduleName}Impl : public Native${moduleName}CxxSpec<${moduleName}Impl> {
+public:
+  ${moduleName}Impl(std::shared_ptr<CallInvoker> jsInvoker);
+  double multiply(jsi::Runtime& rt, double a, double b);
+};
+
+}
+`,
+    "cpp/RustAppImpl.cpp": `#include "RustAppImpl.h"
+
+namespace facebook::react {
+
+${moduleName}Impl::${moduleName}Impl(std::shared_ptr<CallInvoker> jsInvoker)
+  : Native${moduleName}CxxSpec(std::move(jsInvoker)) {}
+
+double ${moduleName}Impl::multiply(jsi::Runtime&, double a, double b) {
+  return a * b;
+}
+
+}
+`,
+    "android/CMakeLists.txt": `cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+add_library(
+  ${packageName}
+  STATIC
+  ../cpp/${moduleName}Impl.cpp
+)
+
+set_target_properties(
+  ${packageName} PROPERTIES
+  CXX_STANDARD 20
+  CXX_STANDARD_REQUIRED ON
+  CXX_EXTENSIONS OFF
+)
+
+target_include_directories(${packageName} PUBLIC ../cpp)
+
+target_link_libraries(
+  ${packageName}
+  jsi
+  reactnative
+  react_codegen_${moduleName}Spec
+)
+`,
+    "ios/OnLoad.mm": `#import <Foundation/Foundation.h>
+#import "${moduleName}Impl.h"
+#import <ReactCommon/CxxTurboModuleUtils.h>
+
+@interface ${moduleName}OnLoad : NSObject
+@end
+
+@implementation ${moduleName}OnLoad
+
+using namespace facebook::react;
+
++ (void)load
+{
+  registerCxxModuleToGlobalModuleMap(
+    std::string(${moduleName}Impl::kModuleName),
+    [](std::shared_ptr<CallInvoker> jsInvoker) {
+      return std::make_shared<${moduleName}Impl>(jsInvoker);
+    }
+  );
+}
+
+@end
+`
+  };
+}
+function appModuleRoot(appRoot = process.cwd()) {
+  const moduleRoot = import_node_path.default.join(appRoot, moduleDirectory);
+  return import_node_fs.default.existsSync(import_node_path.default.join(moduleRoot, "rust", "Cargo.toml")) ? moduleRoot : null;
+}
+function inDirectory(directory, callback) {
+  const previousDirectory = process.cwd();
+  process.chdir(directory);
+  try {
+    return callback();
+  } finally {
+    process.chdir(previousDirectory);
+  }
+}
+function runCodegen(appRoot, moduleRoot) {
+  const script = import_node_path.default.join(appRoot, "node_modules", "react-native", "scripts", "generate-codegen-artifacts.js");
+  if (!import_node_fs.default.existsSync(script)) {
+    throw new Error("React Native dependencies are missing. Install the app dependencies, then run `react-native-rust generate`.");
+  }
+  const result = (0, import_node_child_process.spawnSync)(process.execPath, [script, "-p", moduleRoot, "-t", "all", "-s", "library"], {
+    cwd: appRoot,
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`React Native Codegen failed: ${(result.stderr || result.stdout || result.error?.message || "").trim()}`);
+  }
+}
+function initApp() {
+  const appRoot = process.cwd();
+  const appManifestPath = import_node_path.default.join(appRoot, "package.json");
+  if (!import_node_fs.default.existsSync(appManifestPath)) throw new Error("Run `react-native-rust init --app` from a React Native app root.");
+  const appManifest = (0, import_react_native_rust_lib.readJson)(appManifestPath);
+  if (!(appManifest.dependencies || {})["react-native"]) throw new Error("This project does not declare react-native as a dependency.");
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(appRoot, "android")) || !import_node_fs.default.existsSync(import_node_path.default.join(appRoot, "ios"))) {
+    throw new Error("App-local Rust currently requires both Android and iOS native project folders.");
+  }
+  const moduleRoot = import_node_path.default.join(appRoot, moduleDirectory);
+  if (import_node_fs.default.existsSync(moduleRoot)) throw new Error(`${moduleDirectory} already exists; no files were changed.`);
+  import_node_fs.default.mkdirSync(moduleRoot, { recursive: true });
+  try {
+    writeFiles(moduleRoot, scaffoldFiles(appManifest.name || "rust-app"));
+    inDirectory(moduleRoot, import_react_native_rust_lib.init);
+    const cliManifest = (0, import_react_native_rust_lib.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(appRoot, cliRoot).split(import_node_path.default.sep).join("/") || "."}`;
+    const moduleManifestPath = import_node_path.default.join(moduleRoot, "package.json");
+    const moduleManifest = (0, import_react_native_rust_lib.readJson)(moduleManifestPath);
+    delete moduleManifest.devDependencies?.[cliManifest.name];
+    import_node_fs.default.writeFileSync(moduleManifestPath, `${JSON.stringify(moduleManifest, null, 2)}
+`);
+    appManifest.dependencies = {
+      ...appManifest.dependencies,
+      [packageName]: `file:./${moduleDirectory.split(import_node_path.default.sep).join("/")}`
+    };
+    appManifest.devDependencies = {
+      ...appManifest.devDependencies,
+      [cliManifest.name]: appManifest.devDependencies?.[cliManifest.name] || cliDependency
+    };
+    appManifest.scripts = {
+      ...appManifest.scripts,
+      "rust:generate": "react-native-rust generate",
+      "rust:build:ios": "react-native-rust build ios",
+      "rust:build:android": "react-native-rust build android",
+      "rust:test": `cargo test --manifest-path ${moduleDirectory.split(import_node_path.default.sep).join("/")}/rust/Cargo.toml`
+    };
+    runCodegen(appRoot, moduleRoot);
+    import_node_fs.default.writeFileSync(appManifestPath, `${JSON.stringify(appManifest, null, 2)}
+`);
+  } catch (error) {
+    import_node_fs.default.rmSync(moduleRoot, { recursive: true, force: true });
+    throw error;
+  }
+  console.log(`Created app-local Rust TurboModule in ${import_node_path.default.relative(appRoot, moduleRoot)}.`);
+  console.log("Install app dependencies, then run `npm run rust:build:android` or `npm run rust:build:ios`.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appModuleRoot,
+  inDirectory,
+  initApp,
+  runCodegen
+});

package/dist/codegen/constants.js

@@ -0,0 +1,168 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  HEADER_END: () => HEADER_END,
+  HEADER_START: () => HEADER_START,
+  SOURCE_END: () => SOURCE_END,
+  SOURCE_START: () => SOURCE_START,
+  cppKeywords: () => cppKeywords,
+  rustKeywords: () => rustKeywords,
+  supportedTypes: () => supportedTypes,
+  ts: () => import_typescript.default
+});
+module.exports = __toCommonJS(constants_exports);
+var import_typescript = __toESM(require("typescript"));
+const HEADER_START = "// react-native-rust:generated-methods:start";
+const HEADER_END = "// react-native-rust:generated-methods:end";
+const SOURCE_START = "// react-native-rust:generated-methods:start";
+const SOURCE_END = "// react-native-rust:generated-methods:end";
+const rustKeywords = /* @__PURE__ */ new Set([
+  "as",
+  "async",
+  "await",
+  "break",
+  "const",
+  "continue",
+  "crate",
+  "dyn",
+  "else",
+  "enum",
+  "extern",
+  "false",
+  "fn",
+  "for",
+  "if",
+  "impl",
+  "in",
+  "let",
+  "loop",
+  "match",
+  "mod",
+  "move",
+  "mut",
+  "pub",
+  "ref",
+  "return",
+  "self",
+  "Self",
+  "static",
+  "struct",
+  "super",
+  "trait",
+  "true",
+  "type",
+  "unsafe",
+  "use",
+  "where",
+  "while"
+]);
+const cppKeywords = /* @__PURE__ */ new Set([
+  "alignas",
+  "alignof",
+  "and",
+  "asm",
+  "auto",
+  "bool",
+  "break",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "explicit",
+  "export",
+  "extern",
+  "false",
+  "float",
+  "for",
+  "friend",
+  "goto",
+  "if",
+  "inline",
+  "int",
+  "long",
+  "namespace",
+  "new",
+  "noexcept",
+  "not",
+  "nullptr",
+  "operator",
+  "or",
+  "private",
+  "protected",
+  "public",
+  "register",
+  "return",
+  "short",
+  "signed",
+  "sizeof",
+  "static",
+  "struct",
+  "switch",
+  "template",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "typename",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "xor"
+]);
+const supportedTypes = /* @__PURE__ */ new Map([
+  [import_typescript.default.SyntaxKind.NumberKeyword, { kind: "number", typescript: "number", rust: "f64", cpp: "double", defaultValue: "0.0" }],
+  [import_typescript.default.SyntaxKind.BooleanKeyword, { kind: "boolean", typescript: "boolean", rust: "bool", cpp: "bool", defaultValue: "false" }],
+  [import_typescript.default.SyntaxKind.StringKeyword, { kind: "json", typescript: "string", rust: "String", cpp: "jsi::String", defaultValue: "String::new()" }],
+  [import_typescript.default.SyntaxKind.VoidKeyword, { kind: "void", typescript: "void", rust: "()", cpp: "void", defaultValue: null }]
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HEADER_END,
+  HEADER_START,
+  SOURCE_END,
+  SOURCE_START,
+  cppKeywords,
+  rustKeywords,
+  supportedTypes,
+  ts
+});

package/dist/codegen/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codegen_exports = {};
+__export(codegen_exports, {
+  parseSpec: () => import_spec.parseSpec,
+  renderProjectBindings: () => import_project.renderProjectBindings,
+  renderRustFfiModule: () => import_renderers.renderRustFfiModule
+});
+module.exports = __toCommonJS(codegen_exports);
+var import_spec = require("./spec");
+var import_renderers = require("./renderers");
+var import_project = require("./project");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSpec,
+  renderProjectBindings,
+  renderRustFfiModule
+});