@rxflex/rom 0.0.1 → 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.1"
+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
 
@@ -48,7 +53,15 @@ Config keys use the Rust runtime field names, so use snake_case such as `cors_en
 npm run build:native
 ```
 
-`npm pack` and `npm publish` now run the native release build automatically via `prepack`, and the produced `rom_node_native.node` is included in the published tarball for the platform that performed the publish.
+Local `npm pack` and `npm publish` still build the native addon for the current platform via `prepack`.
+Tagged GitHub releases assemble multi-platform prebuilds and publish a single npm package that includes:
+
+- `linux-x64-gnu`
+- `win32-x64-msvc`
+- `darwin-x64`
+- `darwin-arm64`
+
+At runtime the loader picks the matching binary from `prebuilds/<platform>/rom_node_native.node`.
 
 ## Common methods
 

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.1",
+  "version": "0.0.6",
   "type": "module",
   "description": "Node.js wrapper for the ROM browser-like runtime",
   "license": "MIT",
@@ -27,6 +27,7 @@
     "prepack": "node ./scripts/build-native.mjs --release",
     "build:native": "node ./scripts/build-native.mjs --release",
     "build:native:debug": "node ./scripts/build-native.mjs",
+    "stage:prebuilds": "node ./scripts/stage-prebuilds.mjs",
     "smoke": "node ./scripts/smoke.mjs",
     "pack:check": "npm pack --dry-run"
   },
@@ -36,7 +37,7 @@
   "types": "./src/index.d.ts",
   "files": [
     "README.md",
-    "rom_node_native.node",
+    "prebuilds",
     "src",
     "scripts",
     "native",

package/scripts/build-native.mjs

@@ -2,14 +2,18 @@ import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
+import { detectNativePrebuildId } from "../src/platform.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageRoot = path.resolve(__dirname, "..");
-const profile = process.argv.includes("--release") ? "release" : "debug";
+const args = process.argv.slice(2);
+const profile = args.includes("--release") ? "release" : "debug";
 const targetDir = process.env.CARGO_TARGET_DIR || path.join(packageRoot, "target");
 const artifactDir = path.join(targetDir, profile);
-const outputPath = path.join(packageRoot, "rom_node_native.node");
+const outputPath =
+  readOptionValue(args, "--output") ||
+  defaultOutputPath();
 
 const cargoArgs = ["build", "--manifest-path", "Cargo.toml"];
 if (profile === "release") {
@@ -42,3 +46,27 @@ if (!existsSync(artifactPath)) {
 mkdirSync(path.dirname(outputPath), { recursive: true });
 copyFileSync(artifactPath, outputPath);
 console.log(`Built ${outputPath}`);
+
+function readOptionValue(argv, optionName) {
+  const index = argv.indexOf(optionName);
+  if (index === -1) {
+    return null;
+  }
+
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    console.error(`Missing value for ${optionName}`);
+    process.exit(1);
+  }
+
+  return path.resolve(packageRoot, value);
+}
+
+function defaultOutputPath() {
+  const prebuildId = detectNativePrebuildId();
+  if (prebuildId === null) {
+    return path.join(packageRoot, "rom_node_native.node");
+  }
+
+  return path.join(packageRoot, "prebuilds", prebuildId, "rom_node_native.node");
+}

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/scripts/stage-prebuilds.mjs

@@ -0,0 +1,47 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const args = process.argv.slice(2);
+const sourceRoot =
+  readOptionValue(args, "--source") || path.join(packageRoot, "release-inputs", "prebuilds");
+const outputRoot =
+  readOptionValue(args, "--output") || path.join(packageRoot, "prebuilds");
+
+if (!existsSync(sourceRoot)) {
+  console.error(`Prebuild source directory not found: ${sourceRoot}`);
+  process.exit(1);
+}
+
+rmSync(outputRoot, { recursive: true, force: true });
+mkdirSync(outputRoot, { recursive: true });
+
+for (const entry of readdirSync(sourceRoot, { withFileTypes: true })) {
+  if (!entry.isDirectory()) {
+    continue;
+  }
+
+  const sourceDir = path.join(sourceRoot, entry.name);
+  const outputDir = path.join(outputRoot, entry.name);
+  cpSync(sourceDir, outputDir, { recursive: true });
+}
+
+console.log(`Staged prebuilds from ${sourceRoot} to ${outputRoot}`);
+
+function readOptionValue(argv, optionName) {
+  const index = argv.indexOf(optionName);
+  if (index === -1) {
+    return null;
+  }
+
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    console.error(`Missing value for ${optionName}`);
+    process.exit(1);
+  }
+
+  return path.resolve(packageRoot, value);
+}

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

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import { detectNativePrebuildId } from "./platform.js";
 
 const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
@@ -15,7 +16,13 @@ function candidatePaths() {
     candidates.push(process.env.ROM_NATIVE_NODE_BINDING);
   }
 
+  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;
 }
 

package/src/platform.js

@@ -0,0 +1,31 @@
+import process from "node:process";
+
+export function detectNativePrebuildId() {
+  if (process.platform === "linux" && process.arch === "x64") {
+    if (detectLinuxLibcFlavor() !== "gnu") {
+      return null;
+    }
+    return "linux-x64-gnu";
+  }
+
+  if (process.platform === "win32" && process.arch === "x64") {
+    return "win32-x64-msvc";
+  }
+
+  if (process.platform === "darwin" && process.arch === "x64") {
+    return "darwin-x64";
+  }
+
+  if (process.platform === "darwin" && process.arch === "arm64") {
+    return "darwin-arm64";
+  }
+
+  return null;
+}
+
+function detectLinuxLibcFlavor() {
+  const report = process.report?.getReport?.();
+  const glibcVersion =
+    report?.header?.glibcVersionRuntime ?? report?.header?.glibcVersionCompiler ?? null;
+  return glibcVersion ? "gnu" : "musl";
+}