@rejaul/react-native-rust 1.0.2 → 2.0.0

package/dist/codegen/project.js

@@ -0,0 +1,221 @@
+"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 project_exports = {};
+__export(project_exports, {
+  hasDefaultMultiplyBody: () => hasDefaultMultiplyBody,
+  normalizeSignature: () => normalizeSignature,
+  renderProjectBindings: () => renderProjectBindings,
+  replaceMarkedRegion: () => replaceMarkedRegion,
+  replaceTemplateMethod: () => replaceTemplateMethod,
+  resolveOutsideReference: () => resolveOutsideReference,
+  toPosixRelative: () => toPosixRelative,
+  updateCppFile: () => updateCppFile,
+  validateExistingHandler: () => validateExistingHandler
+});
+module.exports = __toCommonJS(project_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_constants = require("./constants");
+var import_renderers = require("./renderers");
+function toPosixRelative(from, to) {
+  return import_node_path.default.relative(from, to).split(import_node_path.default.sep).join("/");
+}
+function resolveOutsideReference(root, targetDir, linkName) {
+  if (!toPosixRelative(root, targetDir).startsWith("..")) return targetDir;
+  const linkPath = import_node_path.default.join(root, linkName);
+  import_node_fs.default.rmSync(linkPath, { force: true });
+  import_node_fs.default.symlinkSync(toPosixRelative(root, targetDir), linkPath);
+  return linkPath;
+}
+function replaceMarkedRegion(source, startMarker, endMarker, generated) {
+  const start = source.indexOf(startMarker);
+  const end = source.indexOf(endMarker);
+  if (start < 0 || end < start) return null;
+  const block = `${startMarker}
+${generated}
+${endMarker}`;
+  return `${source.slice(0, start)}${block}${source.slice(end + endMarker.length)}`;
+}
+function replaceTemplateMethod(source, markerStart, markerEnd, generated, methodNeedle) {
+  const functionIndex = source.indexOf(methodNeedle);
+  if (functionIndex < 0) throw new Error(`Could not locate C++ template method "${methodNeedle}".`);
+  const lineStart = source.lastIndexOf("\n", functionIndex) + 1;
+  const bodyStart = source.indexOf("{", functionIndex);
+  if (bodyStart < 0) throw new Error(`Could not locate the body for C++ method "${methodNeedle}".`);
+  let depth = 0;
+  let bodyEnd = -1;
+  for (let index = bodyStart; index < source.length; index += 1) {
+    if (source[index] === "{") depth += 1;
+    if (source[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        bodyEnd = index + 1;
+        break;
+      }
+    }
+  }
+  if (bodyEnd < 0) throw new Error(`Could not find the end of C++ method "${methodNeedle}".`);
+  const block = `${markerStart}
+${generated}
+${markerEnd}`;
+  return `${source.slice(0, lineStart)}${block}${source.slice(bodyEnd)}`;
+}
+function hasDefaultMultiplyBody(source, moduleName) {
+  const methodIndex = source.indexOf(`${moduleName}Impl::multiply(`);
+  if (methodIndex < 0) return false;
+  const bodyStart = source.indexOf("{", methodIndex);
+  if (bodyStart < 0) return false;
+  let depth = 0;
+  for (let index = bodyStart; index < source.length; index += 1) {
+    if (source[index] === "{") depth += 1;
+    if (source[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return source.slice(bodyStart + 1, index).replace(/\s+/g, "") === "returna*b;";
+      }
+    }
+  }
+  return false;
+}
+function updateCppFile(source, markers, generated, templateMethod, methodNeedle, rustHeaderPath) {
+  let updated = source;
+  if (rustHeaderPath && !updated.includes(`#include "${rustHeaderPath}"`)) {
+    if (!updated.includes("#pragma once")) throw new Error("Unsupported C++ module header template.");
+    updated = updated.replace("#pragma once", `#pragma once
+
+#include "${rustHeaderPath}"`);
+  }
+  const marked = replaceMarkedRegion(updated, markers[0], markers[1], generated);
+  if (marked !== null) return marked;
+  if (updated.includes(markers[0]) || updated.includes(markers[1])) {
+    throw new Error("Incomplete react-native-rust generated markers found in C++ source.");
+  }
+  if (!templateMethod) throw new Error("C++ generated markers are missing; refusing to overwrite the module.");
+  if (methodNeedle.endsWith(";")) {
+    const count = updated.split(methodNeedle).length - 1;
+    if (count !== 1) throw new Error("Could not uniquely locate the C++ template method declaration.");
+    return updated.replace(methodNeedle, `${markers[0]}
+${generated}
+${markers[1]}`);
+  }
+  return replaceTemplateMethod(updated, markers[0], markers[1], generated, methodNeedle);
+}
+function normalizeSignature(text) {
+  return text.replace(/\s+/g, "").replace(/,\)/g, ")");
+}
+function validateExistingHandler(filePath, method) {
+  const contents = import_node_fs.default.readFileSync(filePath, "utf8");
+  const signaturePattern = new RegExp(`pub\\s+fn\\s+${method.rustName}\\s*\\(([^)]*)\\)\\s*->\\s*([^\\{]+)\\{`);
+  const match = contents.match(signaturePattern);
+  const args = method.params.map((param) => {
+    if (param.kind !== "callback") return `${param.name}: ${param.rust}`;
+    const callbackTypes = param.params.map((callbackParam) => callbackParam.rust).join(", ");
+    return `${param.name}: &mut dyn FnMut(${callbackTypes})`;
+  }).join(", ");
+  const returnType = method.returnType.promise ? `Result<${method.returnType.rust}, String>` : method.returnType.rust;
+  const expected = `${method.rustName}(${args}) -> ${returnType}`;
+  const expectedSignature = `pub fn ${expected} {`;
+  if (normalizeSignature(contents).includes(normalizeSignature(expectedSignature))) return;
+  if (!match || normalizeSignature(match[0].replace(/^pub\s+fn\s+/, "").replace(/\{\s*$/, "")) !== normalizeSignature(expected)) {
+    throw new Error(`Rust handler ${import_node_path.default.relative(process.cwd(), filePath)} does not match the TypeScript Spec. Update its signature before regenerating.`);
+  }
+}
+function renderProjectBindings(root, moduleName, methods, initialize, crateName, rustRoot = import_node_path.default.join(root, "rust")) {
+  const headerPath = import_node_path.default.join(root, "cpp", `${moduleName}Impl.h`);
+  const sourcePath = import_node_path.default.join(root, "cpp", `${moduleName}Impl.cpp`);
+  const header = import_node_fs.default.readFileSync(headerPath, "utf8");
+  const source = import_node_fs.default.readFileSync(sourcePath, "utf8");
+  if (initialize && !hasDefaultMultiplyBody(source, moduleName)) {
+    throw new Error("The C++ multiply demo was customized; move its logic into Rust before running init. No files were changed.");
+  }
+  const cpp = (0, import_renderers.renderCppMethods)(methods, moduleName);
+  const generatedIncludes = cpp.source.match(/^#include .+$/gm) || [];
+  const cppSource = cpp.source.replace(/^#include .+\n/gm, "");
+  const headerTemplateMethod = "double multiply(jsi::Runtime& rt, double a, double b);";
+  const sourceTemplateMethod = `${moduleName}Impl::multiply(`;
+  const rustIncludeTarget = resolveOutsideReference(root, import_node_path.default.join(rustRoot, "include"), "rust-include");
+  const rustHeaderPath = `${toPosixRelative(import_node_path.default.join(root, "cpp"), rustIncludeTarget)}/rust_api.h`;
+  const updatedHeader = updateCppFile(header, [import_constants.HEADER_START, import_constants.HEADER_END], cpp.header, initialize, headerTemplateMethod, rustHeaderPath);
+  let updatedSource = updateCppFile(source, [import_constants.SOURCE_START, import_constants.SOURCE_END], cppSource, initialize, sourceTemplateMethod);
+  if (generatedIncludes.length > 0) {
+    const namespaceIndex = updatedSource.indexOf("\nnamespace facebook::react {");
+    if (namespaceIndex < 0) throw new Error("Could not locate the C++ namespace for generated includes.");
+    const missingIncludes = generatedIncludes.filter((include) => !updatedSource.includes(include));
+    if (missingIncludes.length > 0) {
+      const insertionPoint = namespaceIndex + 1;
+      updatedSource = `${updatedSource.slice(0, insertionPoint)}${missingIncludes.join("\n")}
+${updatedSource.slice(insertionPoint)}`;
+    }
+  }
+  const rustDirectory = import_node_path.default.join(rustRoot, "src");
+  const moduleList = (0, import_renderers.renderRustModuleList)(methods);
+  const updates = /* @__PURE__ */ new Map([
+    [headerPath, updatedHeader],
+    [sourcePath, updatedSource],
+    [import_node_path.default.join(rustDirectory, "lib.rs"), (0, import_renderers.renderRustExports)(methods)],
+    [import_node_path.default.join(rustDirectory, "api", "mod.rs"), moduleList],
+    [import_node_path.default.join(rustDirectory, "wasm.rs"), (0, import_renderers.renderRustWasmModule)(methods)]
+  ]);
+  for (const method of methods) {
+    const handlerPath = import_node_path.default.join(rustDirectory, "api", `${method.rustName}.rs`);
+    if (import_node_fs.default.existsSync(handlerPath)) validateExistingHandler(handlerPath, method);
+    else updates.set(handlerPath, (0, import_renderers.renderRustHandler)(method));
+  }
+  const wasmPkgTarget = resolveOutsideReference(root, import_node_path.default.join(rustRoot, "build", "web", "pkg"), "rust-build-web-pkg");
+  const wasmPkgPath = toPosixRelative(import_node_path.default.join(root, "src"), wasmPkgTarget);
+  const wrappers = (0, import_renderers.renderWrappers)(methods, moduleName, crateName, wasmPkgPath);
+  const generatedModulePath = import_node_path.default.join(root, "src", "rust-generated");
+  updates.set(`${generatedModulePath}.tsx`, wrappers.web);
+  updates.set(`${generatedModulePath}.native.tsx`, wrappers.native);
+  const indexPath = import_node_path.default.join(root, "src", "index.tsx");
+  let index = import_node_fs.default.readFileSync(indexPath, "utf8");
+  for (const method of methods) {
+    const oldExport = new RegExp(`^export\\s*\\{\\s*${method.name}\\s*\\}\\s*from\\s*['"]\\./${method.name}['"];?\\s*$`, "m");
+    index = index.replace(oldExport, "");
+  }
+  if (!index.includes("export * from './rust-generated';")) {
+    index = `${index.trimEnd()}
+export * from './rust-generated';
+`;
+  }
+  updates.set(indexPath, index);
+  return updates;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasDefaultMultiplyBody,
+  normalizeSignature,
+  renderProjectBindings,
+  replaceMarkedRegion,
+  replaceTemplateMethod,
+  resolveOutsideReference,
+  toPosixRelative,
+  updateCppFile,
+  validateExistingHandler
+});

package/{bin → dist}/codegen/renderers.js

@@ -1,3 +1,33 @@
+"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 renderers_exports = {};
+__export(renderers_exports, {
+  renderCppHelpers: () => renderCppHelpers,
+  renderCppMethods: () => renderCppMethods,
+  renderRustExports: () => renderRustExports,
+  renderRustFfiModule: () => renderRustFfiModule,
+  renderRustHandler: () => renderRustHandler,
+  renderRustModuleList: () => renderRustModuleList,
+  renderRustWasmModule: () => renderRustWasmModule,
+  renderWrappers: () => renderWrappers
+});
+module.exports = __toCommonJS(renderers_exports);
 function renderRustFfiModule() {
   return `use serde::de::DeserializeOwned;
 use serde::Serialize;
@@ -76,69 +106,111 @@ pub extern "C" fn rnrs_buffer_free(buffer: RustBuffer) {
 }
 `;
 }
-
 function renderRustExports(methods) {
-  const lines = ['mod api;', 'mod ffi;', 'pub use ffi::{rnrs_buffer_free, RustBuffer, RustCallback, RustSlice};', ''];
+  const lines = [
+    "mod api;",
+    "mod ffi;",
+    '#[cfg(target_arch = "wasm32")]',
+    "mod wasm;",
+    "pub use ffi::{rnrs_buffer_free, RustBuffer, RustCallback, RustSlice};",
+    ""
+  ];
   for (const method of methods) {
-    const abiParams = method.params.map((param) => `${param.name}: ffi::${param.kind === 'callback' ? 'RustCallback' : 'RustSlice'}`).join(', ');
-    lines.push('#[no_mangle]');
+    const abiParams = method.params.map((param) => `${param.name}: ffi::${param.kind === "callback" ? "RustCallback" : "RustSlice"}`).join(", ");
+    lines.push('#[cfg(not(target_arch = "wasm32"))]');
+    lines.push("#[no_mangle]");
     lines.push(`pub extern "C" fn ${method.symbol}(${abiParams}) -> ffi::RustBuffer {`);
-    lines.push('    ffi::catch_json(|| {');
-
+    lines.push("    ffi::catch_json(|| {");
     for (const param of method.params) {
-      if (param.kind !== 'callback') {
+      if (param.kind !== "callback") {
         lines.push(`        let ${param.name}: ${param.rust} = unsafe { ffi::decode_json(${param.name}) }?;`);
         continue;
       }
-      const callbackParams = param.params.map((callbackParam) => `${callbackParam.name}: ${callbackParam.rust}`).join(', ');
-      const callbackValues = param.params.map((callbackParam) => callbackParam.name).join(', ');
-      const payload = callbackValues.length === 0 ? 'Vec::<u8>::new()' : `serde_json::to_vec(&(${callbackValues}${param.params.length === 1 ? ',' : ''})).unwrap_or_default()`;
+      const callbackParams = param.params.map((callbackParam) => `${callbackParam.name}: ${callbackParam.rust}`).join(", ");
+      const callbackValues = param.params.map((callbackParam) => callbackParam.name).join(", ");
+      const payload = callbackValues.length === 0 ? "Vec::<u8>::new()" : `serde_json::to_vec(&(${callbackValues}${param.params.length === 1 ? "," : ""})).unwrap_or_default()`;
       lines.push(`        let mut ${param.name}_callback = |${callbackParams}| {`);
       lines.push(`            let payload = ${payload};`);
       lines.push(`            let slice = ffi::RustSlice { data: payload.as_ptr(), len: payload.len() };`);
       lines.push(`            unsafe { (${param.name}.invoke)(${param.name}.context, slice); }`);
-      lines.push('        };');
+      lines.push("        };");
     }
-
-    const callArgs = method.params.map((param) => param.kind === 'callback' ? `&mut ${param.name}_callback` : param.name).join(', ');
+    const callArgs = method.params.map((param) => param.kind === "callback" ? `&mut ${param.name}_callback` : param.name).join(", ");
     const call = `api::${method.rustName}::${method.rustName}(${callArgs})`;
     if (method.returnType.promise) {
       lines.push(`        ${call}`);
-    } else if (method.returnType.kind === 'void') {
+    } else if (method.returnType.kind === "void") {
       lines.push(`        ${call};`);
-      lines.push('        Ok(())');
+      lines.push("        Ok(())");
     } else {
       lines.push(`        Ok(${call})`);
     }
-    lines.push('    })', '}', '');
+    lines.push("    })", "}", "");
   }
-  return lines.join('\n');
+  return lines.join("\n");
 }
-
 function renderRustHandler(method) {
   const params = method.params.map((param) => {
-    if (param.kind === 'callback') {
-      const callbackTypes = param.params.map((callbackParam) => callbackParam.rust).join(', ');
+    if (param.kind === "callback") {
+      const callbackTypes = param.params.map((callbackParam) => callbackParam.rust).join(", ");
       return `${param.name}: &mut dyn FnMut(${callbackTypes})`;
     }
     return `${param.name}: ${param.rust}`;
-  }).join(', ');
+  }).join(", ");
   const returnType = method.returnType.promise ? `Result<${method.returnType.rust}, String>` : method.returnType.rust;
   const lines = [`// TODO: Replace the generated placeholder with the method implementation.`, `pub fn ${method.rustName}(${params}) -> ${returnType} {`];
   for (const param of method.params) {
-    if (param.kind === 'callback') lines.push(`    let _ = &mut ${param.name};`);
-    else lines.push(`    let _ = ${param.name};`);
+    lines.push(`    let _ = ${param.name};`);
   }
   if (method.returnType.promise) lines.push(`    Ok(${method.returnType.defaultValue})`);
   else if (method.returnType.defaultValue !== null) lines.push(`    ${method.returnType.defaultValue}`);
-  lines.push('}', '');
-  return lines.join('\n');
+  lines.push("}", "");
+  return lines.join("\n");
 }
-
 function renderRustModuleList(methods) {
-  return `${methods.map((method) => `pub(crate) mod ${method.rustName};`).join('\n')}\n`;
+  return `${methods.map((method) => `pub(crate) mod ${method.rustName};`).join("\n")}
+`;
+}
+function renderRustWasmModule(methods) {
+  const lines = ["use wasm_bindgen::prelude::*;", ""];
+  for (const method of methods) {
+    const wasmParams = method.params.map((param) => param.kind === "callback" ? `${param.name}: &js_sys::Function` : `${param.name}_json: &str`).join(", ");
+    const isVoidSync = method.returnType.kind === "void" && !method.returnType.promise;
+    const wasmReturn = isVoidSync ? "Result<(), JsValue>" : "Result<String, JsValue>";
+    lines.push("#[wasm_bindgen]");
+    lines.push(`pub fn ${method.symbol}(${wasmParams}) -> ${wasmReturn} {`);
+    for (const param of method.params) {
+      if (param.kind === "callback") continue;
+      lines.push(`    let ${param.name}: ${param.rust} = serde_json::from_str(${param.name}_json).map_err(|error| JsValue::from_str(&error.to_string()))?;`);
+    }
+    for (const param of method.params) {
+      if (param.kind !== "callback") continue;
+      const callbackParams = param.params.map((callbackParam) => `${callbackParam.name}: ${callbackParam.rust}`).join(", ");
+      const callbackValues = param.params.map((callbackParam) => callbackParam.name).join(", ");
+      const encode = callbackValues.length === 0 ? 'String::from("[]")' : `serde_json::to_string(&(${callbackValues}${param.params.length === 1 ? "," : ""})).unwrap_or_default()`;
+      lines.push(`    let mut ${param.name}_callback = |${callbackParams}| {`);
+      lines.push(`        let payload = ${encode};`);
+      lines.push(`        let _ = ${param.name}.call1(&JsValue::NULL, &JsValue::from_str(&payload));`);
+      lines.push("    };");
+    }
+    const callArgs = method.params.map((param) => param.kind === "callback" ? `&mut ${param.name}_callback` : param.name).join(", ");
+    const call = `crate::api::${method.rustName}::${method.rustName}(${callArgs})`;
+    if (method.returnType.promise) {
+      lines.push(`    let result = ${call};`);
+      lines.push("    result");
+      lines.push("        .map_err(|error| JsValue::from_str(&error))");
+      lines.push("        .and_then(|value| serde_json::to_string(&value).map_err(|error| JsValue::from_str(&error.to_string())))");
+    } else if (isVoidSync) {
+      lines.push(`    ${call};`);
+      lines.push("    Ok(())");
+    } else {
+      lines.push(`    let value = ${call};`);
+      lines.push("    serde_json::to_string(&value).map_err(|error| JsValue::from_str(&error.to_string()))");
+    }
+    lines.push("}", "");
+  }
+  return lines.join("\n");
 }
-
 function renderCppHelpers() {
   return `#include <exception>
 #include <string>
@@ -243,24 +315,25 @@ static jsi::Value rnrsMakePromise(
   return promiseConstructor.callAsConstructor(runtime, std::move(executor));
 }`;
 }
-
 function renderCppMethods(methods, moduleName) {
   const cppArgName = (index) => `rnrsArg${index}`;
-  const cppType = (method) => method.returnType.promise ? 'jsi::Value' : method.returnType.cpp;
+  const cppType = (method) => method.returnType.promise ? "jsi::Value" : method.returnType.cpp;
   const declarations = methods.map((method) => {
     const params = method.params.map((param, index) => `${param.cpp} ${cppArgName(index)}`);
-    return `  ${cppType(method)} ${method.name}(jsi::Runtime& rnrsRuntime${params.length ? `, ${params.join(', ')}` : ''});`;
+    return `  ${cppType(method)} ${method.name}(jsi::Runtime& rnrsRuntime${params.length ? `, ${params.join(", ")}` : ""});`;
   });
-
   const definitions = methods.map((method) => {
     const params = method.params.map((param, index) => `${param.cpp} ${cppArgName(index)}`);
-    const signature = `${cppType(method)} ${moduleName}Impl::${method.name}(\n  jsi::Runtime& rnrsRuntime${params.length ? `,\n  ${params.join(',\n  ')}` : ''}\n)`;
+    const signature = `${cppType(method)} ${moduleName}Impl::${method.name}(
+  jsi::Runtime& rnrsRuntime${params.length ? `,
+  ${params.join(",\n  ")}` : ""}
+)`;
     const jsonArgs = [];
     const callbackArgs = [];
     const setup = [];
     method.params.forEach((param, index) => {
       const name = cppArgName(index);
-      if (param.kind === 'callback') {
+      if (param.kind === "callback") {
         const context = `rnrsCallbackContext${index}`;
         const bridge = `rnrsCallbackBridge${index}`;
         setup.push(`  RustCallbackContext ${context}{&rnrsRuntime, &${name}, nullptr};`);
@@ -274,84 +347,128 @@ function renderCppMethods(methods, moduleName) {
       setup.push(`  RustSlice ${slice}{reinterpret_cast<const uint8_t*>(${json}.data()), ${json}.size()};`);
       jsonArgs.push({ json, slice });
     });
-
-    const ffiArgs = method.params.map((param, index) => (
-      param.kind === 'callback' ? `rnrsCallbackBridge${index}` : `rnrsSlice${index}`
-    ));
+    const ffiArgs = method.params.map((param, index) => param.kind === "callback" ? `rnrsCallbackBridge${index}` : `rnrsSlice${index}`);
     if (method.returnType.promise) {
       const captures = jsonArgs.map(({ json }) => `${json} = std::move(${json})`);
       const workerLines = [];
       method.params.forEach((param, index) => {
-        if (param.kind !== 'callback') {
+        if (param.kind !== "callback") {
           const json = `rnrsJson${index}`;
           workerLines.push(`    RustSlice rnrsSlice${index}{reinterpret_cast<const uint8_t*>(${json}.data()), ${json}.size()};`);
         }
       });
-      workerLines.push(`    return ${method.symbol}(${ffiArgs.join(', ')});`);
-      return [signature + ' {', ...setup, `  return rnrsMakePromise(rnrsRuntime, jsInvoker_, [${captures.join(', ')}]() mutable {`, ...workerLines, '  });', '}'].join('\n');
+      workerLines.push(`    return ${method.symbol}(${ffiArgs.join(", ")});`);
+      return [signature + " {", ...setup, `  return rnrsMakePromise(rnrsRuntime, jsInvoker_, [${captures.join(", ")}]() mutable {`, ...workerLines, "  });", "}"].join("\n");
     }
-
-    const call = `auto rnrsResult = ${method.symbol}(${ffiArgs.join(', ')});`;
+    const call = `auto rnrsResult = ${method.symbol}(${ffiArgs.join(", ")});`;
     const callbackErrorChecks = callbackArgs.map(({ context }) => `  if (${context}.exception) { rnrs_buffer_free(rnrsResult); std::rethrow_exception(${context}.exception); }`);
-    const decoded = 'auto rnrsValue = rnrsFromRust(rnrsRuntime, rnrsResult);';
+    const decoded = "auto rnrsValue = rnrsFromRust(rnrsRuntime, rnrsResult);";
     let resultLine;
     switch (method.returnType.kind) {
-      case 'void': resultLine = '  (void)rnrsValue;\n  return;'; break;
-      case 'number': resultLine = '  return rnrsValue.asNumber();'; break;
-      case 'boolean': resultLine = '  return rnrsValue.asBool();'; break;
-      case 'string': resultLine = '  return rnrsValue.asString(rnrsRuntime);'; break;
-      case 'array': resultLine = '  return rnrsValue.asObject(rnrsRuntime).asArray(rnrsRuntime);'; break;
-      case 'json':
-        if (method.returnType.cpp === 'jsi::String') resultLine = '  return rnrsValue.asString(rnrsRuntime);';
-        else if (method.returnType.cpp === 'jsi::Array') resultLine = '  return rnrsValue.asObject(rnrsRuntime).asArray(rnrsRuntime);';
-        else resultLine = '  return rnrsValue.asObject(rnrsRuntime);';
+      case "void":
+        resultLine = "  (void)rnrsValue;\n  return;";
+        break;
+      case "number":
+        resultLine = "  return rnrsValue.asNumber();";
+        break;
+      case "boolean":
+        resultLine = "  return rnrsValue.asBool();";
+        break;
+      case "json":
+        if (method.returnType.cpp === "jsi::String") resultLine = "  return rnrsValue.asString(rnrsRuntime);";
+        else if (method.returnType.cpp === "jsi::Array") resultLine = "  return rnrsValue.asObject(rnrsRuntime).asArray(rnrsRuntime);";
+        else resultLine = "  return rnrsValue.asObject(rnrsRuntime);";
         break;
-      default: throw new Error(`No C++ return conversion for ${method.returnType.kind}.`);
+      default:
+        throw new Error(`No C++ return conversion for ${method.returnType.kind}.`);
     }
-    return [signature + ' {', ...setup, `  ${call}`, ...callbackErrorChecks, `  ${decoded}`, resultLine, '}'].join('\n');
+    return [signature + " {", ...setup, `  ${call}`, ...callbackErrorChecks, `  ${decoded}`, resultLine, "}"].join("\n");
   });
   return {
-    header: declarations.join('\n'),
-    source: `${renderCppHelpers()}\n\n${definitions.join('\n\n')}`,
+    header: declarations.join("\n"),
+    source: `${renderCppHelpers()}
+
+${definitions.join("\n\n")}`
   };
 }
-
-function renderWrappers(methods, moduleName) {
-  const nativeLines = [`import ${moduleName} from './Native${moduleName}';`, ''];
-  const fallbackLines = [];
-  const usesUnsafeObject = methods.some((method) => (
-    method.returnType.typescript.includes('UnsafeObject')
-    || method.params.some((param) => param.typescript.includes('UnsafeObject'))
-  ));
+function renderWrappers(methods, moduleName, crateName, wasmPkgPath = "../rust/build/web/pkg") {
+  const nativeLines = [
+    `import ${moduleName} from './Native${moduleName}';`,
+    "",
+    "/** No-op on native, where methods are always ready to call; matches the web module's async init so callers don't need to branch on platform. */",
+    "export function initRustWeb(): Promise<void> {",
+    "  return Promise.resolve();",
+    "}",
+    ""
+  ];
+  const webLines = [
+    `import wasmInit, * as rnrsWasm from '${wasmPkgPath}/${crateName}.js';`,
+    "",
+    "let rnrsWasmReady = false;",
+    "let rnrsWasmInit: Promise<void> | null = null;",
+    "",
+    "/** Loads the compiled Rust WebAssembly module. Call and await this once before using this module on web. */",
+    "export function initRustWeb(wasmUrl?: string | URL): Promise<void> {",
+    "  if (!rnrsWasmInit) {",
+    "    rnrsWasmInit = wasmInit(wasmUrl).then(() => { rnrsWasmReady = true; });",
+    "  }",
+    "  return rnrsWasmInit;",
+    "}",
+    "",
+    "function rnrsRequireWasm(): void {",
+    `  if (!rnrsWasmReady) throw new Error('Call and await initRustWeb() before using ${moduleName} on web.');`,
+    "}",
+    ""
+  ];
+  const usesUnsafeObject = methods.some((method) => method.returnType.typescript.includes("UnsafeObject") || method.params.some((param) => param.typescript.includes("UnsafeObject")));
   if (usesUnsafeObject) {
-    const codegenTypesDeclaration = 'declare namespace CodegenTypes { type UnsafeObject = object; }';
+    const codegenTypesDeclaration = "declare namespace CodegenTypes { type UnsafeObject = object; }";
     nativeLines.unshift(codegenTypesDeclaration);
-    fallbackLines.push(codegenTypesDeclaration, '');
+    webLines.unshift(codegenTypesDeclaration, "");
   }
   for (const method of methods) {
-    const tsParams = method.params.map((param) => `${param.name}: ${param.typescript}`).join(', ');
-    const args = method.params.map((param) => param.name).join(', ');
+    const tsParams = method.params.map((param) => `${param.name}: ${param.typescript}`).join(", ");
+    const args = method.params.map((param) => param.name).join(", ");
     const nativeCall = `${moduleName}.${method.name}(${args})`;
     nativeLines.push(`export function ${method.name}(${tsParams}): ${method.returnType.typescript} {`);
-    nativeLines.push(method.returnType.typescript === 'void' ? `  ${nativeCall};` : `  return ${nativeCall};`);
-    nativeLines.push('}', '');
-
-    const fallbackParams = method.params.map((param) => `_${param.name}: ${param.typescript}`).join(', ');
-    fallbackLines.push(`export function ${method.name}(${fallbackParams}): ${method.returnType.typescript} {`);
-    fallbackLines.push("  throw new Error('This method is only supported on native platforms.');", '}', '');
+    nativeLines.push(method.returnType.typescript === "void" ? `  ${nativeCall};` : `  return ${nativeCall};`);
+    nativeLines.push("}", "");
+    const wasmArgs = method.params.map((param) => param.kind === "callback" ? `(rnrsPayload: string) => { const rnrsArgs = JSON.parse(rnrsPayload); (${param.name} as (...rnrsCallbackArgs: any[]) => void)(...rnrsArgs); }` : `JSON.stringify(${param.name})`).join(", ");
+    const wasmCall = `rnrsWasm.${method.symbol}(${wasmArgs})`;
+    webLines.push(`export function ${method.name}(${tsParams}): ${method.returnType.typescript} {`);
+    webLines.push("  rnrsRequireWasm();");
+    if (method.returnType.promise) {
+      webLines.push("  try {");
+      if (method.returnType.kind === "void") {
+        webLines.push(`    ${wasmCall};`);
+        webLines.push("    return Promise.resolve();");
+      } else {
+        webLines.push(`    const rnrsResult = ${wasmCall};`);
+        webLines.push("    return Promise.resolve(JSON.parse(rnrsResult));");
+      }
+      webLines.push("  } catch (error) {");
+      webLines.push("    return Promise.reject(error instanceof Error ? error.message : String(error));");
+      webLines.push("  }");
+    } else if (method.returnType.kind === "void") {
+      webLines.push(`  ${wasmCall};`);
+    } else {
+      webLines.push(`  return JSON.parse(${wasmCall});`);
+    }
+    webLines.push("}", "");
   }
   return {
-    native: nativeLines.join('\n'),
-    fallback: fallbackLines.join('\n'),
+    native: nativeLines.join("\n"),
+    web: webLines.join("\n")
   };
 }
-
-module.exports = {
-  renderRustFfiModule,
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderCppHelpers,
+  renderCppMethods,
   renderRustExports,
+  renderRustFfiModule,
   renderRustHandler,
   renderRustModuleList,
-  renderCppHelpers,
-  renderCppMethods,
-  renderWrappers,
-};
+  renderRustWasmModule,
+  renderWrappers
+});