@rxflex/rom 0.0.5 → 0.0.6

package/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rom-node-native"
 description = "Native napi-rs bridge for the ROM Node.js bindings"
-version = "0.0.5"
+version = "0.0.6"
 edition = "2024"
 homepage = "https://github.com/Rxflex/rom"
 license = "MIT"
@@ -16,6 +16,8 @@ crate-type = ["cdylib"]
 napi = "3"
 napi-derive = "3"
 rom-runtime = { path = "../../crates/rom-runtime" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 
 [build-dependencies]
 napi-build = "2"

package/README.md

@@ -27,6 +27,7 @@ import { RomRuntime, hasNativeBinding } from "@rxflex/rom";
 
 const runtime = new RomRuntime({
   href: "https://example.test/",
+  referrer: "https://referrer.example/",
   cors_enabled: false,
   proxy_url: process.env.ROM_PROXY_URL ?? null,
 });
@@ -37,10 +38,14 @@ const snapshot = await runtime.surfaceSnapshot();
 console.log("native:", hasNativeBinding());
 console.log(href);
 console.log(snapshot.fetch);
+
+await runtime.evalAsync("(async () => { globalThis.__romValue = 42; return 'ok'; })()");
+console.log(await runtime.evalAsync("(async () => String(globalThis.__romValue))()"));
 ```
 
 Config keys use the Rust runtime field names, so use snake_case such as `cors_enabled` and `proxy_url`.
 `cors_enabled` is `false` by default.
+When the native addon is loaded, one `RomRuntime` instance keeps JS globals alive across multiple `eval()` and `evalAsync()` calls.
 
 ## Optional native build
 

package/native/lib.rs

@@ -1,7 +1,93 @@
-use napi::Result;
+use napi::{Error, Result};
 use napi_derive::napi;
+use rom_runtime::{RomRuntime, RuntimeConfig};
+use serde::Serialize;
+use serde_json::Value;
+
+fn parse_config(config_json: String) -> Result<RuntimeConfig> {
+    serde_json::from_str(&config_json)
+        .map_err(|error| Error::from_reason(format!("Invalid ROM config JSON: {error}")))
+}
+
+fn to_json<T>(value: &T) -> Result<String>
+where
+    T: Serialize,
+{
+    serde_json::to_string(value)
+        .map_err(|error| Error::from_reason(format!("Failed to serialize ROM value: {error}")))
+}
+
+fn map_runtime_error<T>(result: rom_runtime::Result<T>) -> Result<T> {
+    result.map_err(|error| Error::from_reason(error.to_string()))
+}
 
 #[napi]
 pub fn execute_bridge(request_json: String) -> Result<String> {
     Ok(rom_runtime::execute_bridge_request_json(&request_json))
 }
+
+#[napi]
+pub struct NativeRomRuntime {
+    runtime: RomRuntime,
+}
+
+#[napi]
+impl NativeRomRuntime {
+    #[napi(constructor)]
+    pub fn new(config_json: String) -> Result<Self> {
+        Ok(Self {
+            runtime: map_runtime_error(RomRuntime::new(parse_config(config_json)?))?,
+        })
+    }
+
+    #[napi(js_name = "eval")]
+    pub fn eval(&self, script: String) -> Result<String> {
+        map_runtime_error(self.runtime.eval_as_string(&script))
+            .map(|value| value.to_owned())
+    }
+
+    #[napi(js_name = "evalAsync")]
+    pub fn eval_async(&self, script: String) -> Result<String> {
+        map_runtime_error(self.runtime.eval_async_as_string(&script))
+            .map(|value| value.to_owned())
+    }
+
+    #[napi(js_name = "surfaceSnapshotJson")]
+    pub fn surface_snapshot_json(&self) -> Result<String> {
+        to_json(&map_runtime_error(self.runtime.surface_snapshot())?)
+    }
+
+    #[napi(js_name = "fingerprintProbeJson")]
+    pub fn fingerprint_probe_json(&self) -> Result<String> {
+        to_json(&map_runtime_error(self.runtime.fingerprint_probe())?)
+    }
+
+    #[napi(js_name = "fingerprintJsHarnessJson")]
+    pub fn fingerprint_js_harness_json(&self) -> Result<String> {
+        to_json(&map_runtime_error(self.runtime.run_fingerprintjs_harness())?)
+    }
+
+    #[napi(js_name = "fingerprintJsVersion")]
+    pub fn fingerprint_js_version(&self) -> Result<String> {
+        Ok(self.runtime.fingerprintjs_version().to_owned())
+    }
+
+    #[napi(js_name = "exportCookieStore")]
+    pub fn export_cookie_store(&self) -> Result<String> {
+        map_runtime_error(self.runtime.export_cookie_store())
+            .map(|value| value.to_owned())
+    }
+
+    #[napi(js_name = "evalJson")]
+    pub fn eval_json(&self, script: String, asynchronous: bool) -> Result<String> {
+        let value = if asynchronous {
+            map_runtime_error(self.runtime.eval_async_as_string(&script))?
+        } else {
+            map_runtime_error(self.runtime.eval_as_string(&script))?
+        };
+
+        let parsed: Value = serde_json::from_str(&value)
+            .map_err(|error| Error::from_reason(format!("ROM eval did not return JSON: {error}")))?;
+        to_json(&parsed)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflex/rom",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "type": "module",
   "description": "Node.js wrapper for the ROM browser-like runtime",
   "license": "MIT",

package/scripts/smoke.mjs

@@ -3,6 +3,8 @@ import { RomRuntime, hasNativeBinding } from "../src/index.js";
 async function main() {
   const runtime = new RomRuntime({ href: "https://example.test/" });
   const href = await runtime.evalAsync("(async () => location.href)()");
+  await runtime.evalAsync("(async () => { globalThis.__romSmokeValue = 42; return 'ok'; })()");
+  const persisted = await runtime.evalAsync("(async () => String(globalThis.__romSmokeValue))()");
   const snapshot = await runtime.surfaceSnapshot();
 
   if (!hasNativeBinding()) {
@@ -17,7 +19,11 @@ async function main() {
     throw new Error("Surface snapshot did not expose window.");
   }
 
-  console.log(JSON.stringify({ native: true, href }));
+  if (persisted !== "42") {
+    throw new Error(`Expected persisted global state, got: ${persisted}`);
+  }
+
+  console.log(JSON.stringify({ native: true, href, persisted }));
 }
 
 main().catch((error) => {

package/src/index.d.ts

@@ -1,5 +1,6 @@
 export interface RuntimeConfig {
   href?: string;
+  referrer?: string;
   user_agent?: string;
   app_name?: string;
   platform?: string;
@@ -8,6 +9,9 @@ export interface RuntimeConfig {
   hardware_concurrency?: number;
   device_memory?: number;
   webdriver?: boolean;
+  cors_enabled?: boolean;
+  proxy_url?: string | null;
+  cookie_store?: string | null;
 }
 
 export declare class RomRuntime {

package/src/index.js

@@ -7,6 +7,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..", "..");
 const nativeBridge = loadNativeBridge();
+const NativeRomRuntime = nativeBridge?.NativeRomRuntime ?? null;
 
 function resolveBridgeCommand() {
   if (process.env.ROM_BRIDGE_BIN) {
@@ -44,7 +45,10 @@ function parseBridgeResponse(stdout, stderr, error) {
     throw new Error(response.error || error?.message || "ROM bridge command failed.");
   }
 
-  return response.result;
+  return {
+    result: response.result,
+    state: response.state ?? null,
+  };
 }
 
 function runNativeBridge(command, payload) {
@@ -85,17 +89,92 @@ function runBridge(command, payload) {
   return runNativeBridge(command, payload) ?? runCliBridge(command, payload);
 }
 
+function applyBridgeState(targetConfig, state) {
+  if (!state || typeof state.cookie_store !== "string") {
+    return targetConfig;
+  }
+
+  return {
+    ...targetConfig,
+    cookie_store: state.cookie_store,
+  };
+}
+
 export class RomRuntime {
+  #nativeRuntime = null;
+
   constructor(config = {}) {
     this.config = config;
+    if (typeof NativeRomRuntime === "function") {
+      this.#nativeRuntime = new NativeRomRuntime(JSON.stringify(this.config));
+    }
+  }
+
+  #applyCookieStore(cookieStore) {
+    if (typeof cookieStore !== "string") {
+      return;
+    }
+
+    this.config = {
+      ...this.config,
+      cookie_store: cookieStore,
+    };
+  }
+
+  #syncNativeState() {
+    if (!this.#nativeRuntime || typeof this.#nativeRuntime.exportCookieStore !== "function") {
+      return;
+    }
+
+    this.#applyCookieStore(this.#nativeRuntime.exportCookieStore());
+  }
+
+  async #runNative(method, ...args) {
+    if (!this.#nativeRuntime || typeof this.#nativeRuntime[method] !== "function") {
+      return null;
+    }
+
+    const result = await Promise.resolve(this.#nativeRuntime[method](...args));
+    this.#syncNativeState();
+    return result;
+  }
+
+  async #run(command, payload = {}) {
+    if (this.#nativeRuntime) {
+      if (command === "eval") {
+        return this.#runNative("eval", payload.script);
+      }
+      if (command === "eval-async") {
+        return this.#runNative("evalAsync", payload.script);
+      }
+      if (command === "surface-snapshot") {
+        return JSON.parse(await this.#runNative("surfaceSnapshotJson"));
+      }
+      if (command === "fingerprint-probe") {
+        return JSON.parse(await this.#runNative("fingerprintProbeJson"));
+      }
+      if (command === "fingerprint-js-harness") {
+        return JSON.parse(await this.#runNative("fingerprintJsHarnessJson"));
+      }
+      if (command === "fingerprint-js-version") {
+        return this.#runNative("fingerprintJsVersion");
+      }
+    }
+
+    const response = await runBridge(command, {
+      config: this.config,
+      ...payload,
+    });
+    this.config = applyBridgeState(this.config, response.state);
+    return response.result;
   }
 
   eval(script) {
-    return runBridge("eval", { config: this.config, script });
+    return this.#run("eval", { script });
   }
 
   evalAsync(script) {
-    return runBridge("eval-async", { config: this.config, script });
+    return this.#run("eval-async", { script });
   }
 
   async evalJson(script, { async = true } = {}) {
@@ -104,19 +183,19 @@ export class RomRuntime {
   }
 
   surfaceSnapshot() {
-    return runBridge("surface-snapshot", { config: this.config });
+    return this.#run("surface-snapshot");
   }
 
   fingerprintProbe() {
-    return runBridge("fingerprint-probe", { config: this.config });
+    return this.#run("fingerprint-probe");
   }
 
   runFingerprintJsHarness() {
-    return runBridge("fingerprint-js-harness", { config: this.config });
+    return this.#run("fingerprint-js-harness");
   }
 
   fingerprintJsVersion() {
-    return runBridge("fingerprint-js-version", { config: this.config });
+    return this.#run("fingerprint-js-version");
   }
 }
 

package/src/native.js

@@ -16,13 +16,13 @@ function candidatePaths() {
     candidates.push(process.env.ROM_NATIVE_NODE_BINDING);
   }
 
-  candidates.push(path.join(packageRoot, "rom_node_native.node"));
-
   const prebuildId = detectNativePrebuildId();
   if (prebuildId !== null) {
     candidates.push(path.join(packageRoot, "prebuilds", prebuildId, "rom_node_native.node"));
   }
 
+  candidates.push(path.join(packageRoot, "rom_node_native.node"));
+
   return candidates;
 }