@react-native-quickjs/quickjs 1.0.0-alpha.0

package/scripts/setup/edits.js

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) Ammar Ahmed.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * The build-config edits that move an app between Hermes and QuickJS, written
+ * once. `install` applies them, `revert` undoes them, `doctor` reports them,
+ * and the Expo plugin runs the same functions inside Expo's own mods.
+ *
+ * Each edit is:
+ *
+ *   label         what to call the file in output
+ *   findFile      absolute path in a project, or null if the project has none
+ *   isApplied     is this file already configured for QuickJS?
+ *   addQuickJS    returns the edited source, or null (see below)
+ *   removeQuickJS the inverse
+ *   manualSteps   what to tell someone when the functions return null
+ *
+ * Returning null means "this file does not look the way I expect". That is not
+ * an error to throw -- the file has been customised, and the caller prints
+ * manualSteps instead of guessing.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE = '@react-native-quickjs/quickjs';
+const KOTLIN_IMPORT = 'import com.reactnativequickjs.quickjs.QuickJSInstance';
+const SWIFT_IMPORT = 'import ReactNativeQuickJS';
+const PODFILE_REQUIRE = `require_relative '../node_modules/${PACKAGE}/scripts/react_native_quickjs_pods.rb'`;
+const GRADLE_APPLY = `apply from: file("../../node_modules/${PACKAGE}/android/quickjs.gradle")`;
+
+const SKIP_DIRECTORIES = new Set(['build', 'node_modules', 'Pods']);
+
+/** The first file called `fileName` anywhere under `directory`. */
+function findFileNamed(directory, fileName, depth = 7) {
+  if (depth < 0 || !fs.existsSync(directory)) return null;
+
+  const subdirectories = [];
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (SKIP_DIRECTORIES.has(entry.name)) continue;
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) subdirectories.push(fullPath);
+    else if (entry.name === fileName) return fullPath;
+  }
+
+  for (const subdirectory of subdirectories) {
+    const found = findFileNamed(subdirectory, fileName, depth - 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+/** Index of the `)` that closes the call whose `(` is at `openParen`. */
+function closingParenIndex(source, openParen) {
+  let depth = 0;
+  for (let i = openParen; i < source.length; i++) {
+    if (source[i] === '(') depth++;
+    else if (source[i] === ')' && --depth === 0) return i;
+  }
+  return -1;
+}
+
+/** The source with `importLine` added after the last import, or null. */
+function withImportAdded(source, importLine) {
+  if (source.includes(importLine)) return source;
+
+  const imports = [...source.matchAll(/^import .*$/gm)];
+  if (imports.length === 0) return null;
+
+  const lastImport = imports[imports.length - 1];
+  const insertAt = lastImport.index + lastImport[0].length;
+  return source.slice(0, insertAt) + '\n' + importLine + source.slice(insertAt);
+}
+
+/**
+ * The source without `line`, and without the blank line that followed it.
+ * A plain string match, so there is no regular expression to escape.
+ */
+function withLineRemoved(source, line) {
+  return source.includes(line + '\n\n')
+    ? source.replace(line + '\n\n', '')
+    : source.replace(line + '\n', '');
+}
+
+/** The indentation of the first line at or after `index`. */
+function indentAt(source, index, fallback) {
+  const match = /^([ \t]+)\S/.exec(source.slice(index));
+  return match ? match[1] : fallback;
+}
+
+const edits = [
+  {
+    label: 'android/gradle.properties',
+    findFile: (project) => path.join(project, 'android', 'gradle.properties'),
+    isApplied: (source) => /^[ \t]*hermesEnabled[ \t]*=[ \t]*false[ \t]*$/m.test(source),
+
+    addQuickJS: (source) =>
+      /^[ \t]*hermesEnabled[ \t]*=/m.test(source)
+        ? source.replace(/^([ \t]*hermesEnabled[ \t]*=[ \t]*).*$/m, '$1false')
+        : `${source.replace(/\s*$/, '')}\n\nhermesEnabled=false\n`,
+
+    removeQuickJS: (source) =>
+      source.replace(/^([ \t]*hermesEnabled[ \t]*=[ \t]*).*$/m, '$1true'),
+
+    manualSteps: ['Set hermesEnabled=false in android/gradle.properties'],
+  },
+
+  {
+    // The template picks Hermes or JavaScriptCore here, and hermesEnabled=false
+    // is what sends it down the JavaScriptCore branch. An app on QuickJS wants
+    // neither, so the whole block goes.
+    label: 'android/app/build.gradle',
+    findFile: (project) => path.join(project, 'android', 'app', 'build.gradle'),
+    isApplied: (source) =>
+      !/hermes-android|implementation jscFlavor/.test(source) && source.includes(GRADLE_APPLY),
+
+    // `def jscFlavor` is left alone. It declares the coordinate; the dependency
+    // this removes is what pulled libjsc.so into the app, and leaving the
+    // declaration keeps revert able to put the block back unchanged.
+    addQuickJS(source) {
+      const withoutEngines = source.replace(
+        /[ \t]*if \([ \t]*hermesEnabled\.toBoolean\(\)[ \t]*\) \{[\s\S]*?\n[ \t]*\}[ \t]*\n/,
+        ''
+      );
+      // The block being absent is fine on its own -- a rerun, or an app that
+      // never had it. Absent while the dependencies are still declared means
+      // the file has been rewritten into a shape this does not recognise.
+      if (withoutEngines === source && /hermes-android|implementation jscFlavor/.test(source)) {
+        return null;
+      }
+
+      // Appended, not inserted: quickjs.gradle configures the `react` extension
+      // and the app's variants, so it has to run after the plugins that create
+      // them, and the end of the file is the only place guaranteed to be after
+      // all of them.
+      return withoutEngines.includes(GRADLE_APPLY)
+        ? withoutEngines
+        : `${withoutEngines.replace(/\s*$/, '')}\n\n${GRADLE_APPLY}\n`;
+    },
+
+    removeQuickJS(source) {
+      const reactAndroid = /([ \t]*)implementation\("com\.facebook\.react:react-android"\)\n/;
+      if (!reactAndroid.test(source)) return null;
+
+      // The apply line is the last line of the file, so removing it leaves the
+      // blank line that separated it behind.
+      const withoutApply = withLineRemoved(source, GRADLE_APPLY).replace(/\n+$/, '\n');
+
+      return withoutApply.replace(
+        reactAndroid,
+        (line, indent) =>
+          `${line}\n${indent}if (hermesEnabled.toBoolean()) {\n` +
+          `${indent}    implementation("com.facebook.react:hermes-android")\n` +
+          `${indent}} else {\n` +
+          `${indent}    implementation jscFlavor\n` +
+          `${indent}}\n`
+      );
+    },
+
+    manualSteps: [
+      'In android/app/build.gradle, delete the dependencies block that picks',
+      'between com.facebook.react:hermes-android and jscFlavor, and add this',
+      'as the last line of the file:',
+      `  ${GRADLE_APPLY}`,
+    ],
+  },
+
+  {
+    label: 'MainApplication.kt',
+    findFile: (project) =>
+      findFileNamed(path.join(project, 'android', 'app', 'src'), 'MainApplication.kt'),
+    isApplied: (source) => source.includes('QuickJSInstance('),
+
+    addQuickJS(source) {
+      const withImport = withImportAdded(source, KOTLIN_IMPORT);
+      if (!withImport) return null;
+
+      const call = /getDefaultReactHost\(\n/.exec(withImport);
+      if (!call) return null;
+
+      // Added as the first argument rather than the last. Kotlin named
+      // arguments may be given in any order, and the first one's indentation
+      // is the only one readable without matching parens through the nested
+      // PackageList lambda.
+      const firstArgument = call.index + call[0].length;
+      const indent = indentAt(withImport, firstArgument, '      ');
+
+      return (
+        withImport.slice(0, firstArgument) +
+        `${indent}jsRuntimeFactory = QuickJSInstance(),\n` +
+        withImport.slice(firstArgument)
+      );
+    },
+
+    removeQuickJS: (source) =>
+      withLineRemoved(source, KOTLIN_IMPORT).replace(
+        /^[ \t]*jsRuntimeFactory = QuickJSInstance\(\),?[ \t]*\n/m,
+        ''
+      ),
+
+    manualSteps: [
+      'In MainApplication.kt add:',
+      `  ${KOTLIN_IMPORT}`,
+      'and pass jsRuntimeFactory = QuickJSInstance() to getDefaultReactHost().',
+    ],
+  },
+
+  {
+    label: 'ios/Podfile',
+    findFile: (project) => path.join(project, 'ios', 'Podfile'),
+    isApplied: (source) => source.includes('use_quickjs!'),
+
+    addQuickJS(source) {
+      // Every anchor is checked before anything is written, so a Podfile this
+      // does not recognise is left alone rather than half configured.
+      const hasPlatform = /^platform :ios/m.test(source);
+      const useReactNative = /^([ \t]*)use_react_native!\(/m.exec(source);
+      const postInstall = source.indexOf('react_native_post_install(');
+      if (!hasPlatform || !useReactNative || postInstall === -1) return null;
+
+      const withRequire = source.includes(PODFILE_REQUIRE)
+        ? source
+        : source.replace(/^platform :ios/m, `${PODFILE_REQUIRE}\n\nplatform :ios`);
+
+      // use_quickjs! only sets environment flags, but everything after it reads
+      // them. use_native_modules! evaluates every autolinked podspec, and
+      // use_expo_modules! resolves Expo's modules against the prebuilt React
+      // Native this is about to turn off -- both of which run before
+      // use_react_native!. So it goes before whichever comes first.
+      const anchor =
+        /^([ \t]*)(use_native_modules!|use_expo_modules!|use_react_native!\()/m.exec(withRequire);
+      if (!anchor) return null;
+
+      const withUseQuickJS =
+        withRequire.slice(0, anchor.index) +
+        `${anchor[1]}use_quickjs!\n\n` +
+        withRequire.slice(anchor.index);
+
+      // The hook must follow React Native's own, which writes the USE_HERMES
+      // build setting this overwrites.
+      const call = withUseQuickJS.indexOf('react_native_post_install(');
+      const closing = closingParenIndex(withUseQuickJS, withUseQuickJS.indexOf('(', call));
+      if (closing === -1) return null;
+
+      const endOfLine = withUseQuickJS.indexOf('\n', closing);
+      const indent = /\n([ \t]*)$/.exec(withUseQuickJS.slice(0, call));
+
+      return (
+        withUseQuickJS.slice(0, endOfLine + 1) +
+        `\n${indent ? indent[1] : '    '}react_native_quickjs_post_install(installer)\n` +
+        withUseQuickJS.slice(endOfLine + 1)
+      );
+    },
+
+    removeQuickJS: (source) =>
+      withLineRemoved(source, PODFILE_REQUIRE)
+        .replace(/^[ \t]*use_quickjs!\n\n?/m, '')
+        .replace(/\n?[ \t]*react_native_quickjs_post_install\(installer\)\n/, '\n'),
+
+    manualSteps: [
+      'In ios/Podfile add, before use_expo_modules! or use_react_native!:',
+      `  ${PODFILE_REQUIRE}`,
+      '  use_quickjs!',
+      'and react_native_quickjs_post_install(installer) after react_native_post_install.',
+    ],
+  },
+
+  {
+    label: 'AppDelegate.swift',
+    findFile: (project) => findFileNamed(path.join(project, 'ios'), 'AppDelegate.swift'),
+    isApplied: (source) => source.includes('jsrt_create_quickjs_factory'),
+
+    addQuickJS(source) {
+      const withImport = withImportAdded(source, SWIFT_IMPORT);
+      if (!withImport) return null;
+
+      // Expo names its own subclass ExpoReactNativeFactoryDelegate, so the
+      // class this overrides is matched by suffix rather than by exact name.
+      const delegateClass =
+        /class\s+\w+\s*:\s*\w*ReactNativeFactoryDelegate\s*\{/.exec(withImport);
+      if (!delegateClass) return null;
+
+      const classBody = delegateClass.index + delegateClass[0].length;
+      return (
+        withImport.slice(0, classBody) +
+        '\n  override func createJSRuntimeFactory() -> JSRuntimeFactoryRef {\n' +
+        '    jsrt_create_quickjs_factory()\n' +
+        '  }\n' +
+        withImport.slice(classBody)
+      );
+    },
+
+    removeQuickJS: (source) =>
+      withLineRemoved(source, SWIFT_IMPORT).replace(
+        /\n[ \t]*override func createJSRuntimeFactory\(\)[^\n]*\{\n[ \t]*jsrt_create_quickjs_factory\(\)\n[ \t]*\}\n/,
+        '\n'
+      ),
+
+    manualSteps: [
+      'In AppDelegate.swift add:',
+      `  ${SWIFT_IMPORT}`,
+      'and override createJSRuntimeFactory() to return jsrt_create_quickjs_factory().',
+    ],
+  },
+];
+
+module.exports = { edits };

package/scripts/setup/run.js

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Ammar Ahmed.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * install, revert and doctor. All three walk the same table in edits.js.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { edits } = require('./edits');
+
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const DIM = '\x1b[2m';
+const OFF = '\x1b[0m';
+
+function resolveProjectDirectory(argv) {
+  const at = argv.indexOf('--project');
+  const dir = at === -1 ? process.cwd() : path.resolve(argv[at + 1] || '.');
+  if (!fs.existsSync(path.join(dir, 'package.json'))) {
+    console.error(`\nNo package.json in ${dir}. Run this from a React Native app.\n`);
+    process.exit(1);
+  }
+  return dir;
+}
+
+/**
+ * @param {'addQuickJS'|'removeQuickJS'} direction
+ * @returns {number} exit code
+ */
+function applyEdits(direction, argv) {
+  const project = resolveProjectDirectory(argv);
+  const dryRun = argv.includes('--dry-run');
+  const manual = [];
+  let changed = 0;
+
+  console.log('');
+  for (const edit of edits) {
+    const file = edit.findFile(project);
+    if (!file || !fs.existsSync(file)) {
+      console.log(`  ${DIM}skipped${OFF}  ${edit.label} ${DIM}(not in this project)${OFF}`);
+      continue;
+    }
+
+    const before = fs.readFileSync(file, 'utf8');
+    const satisfied = direction === 'addQuickJS' ? edit.isApplied(before) : !edit.isApplied(before);
+    if (satisfied) {
+      console.log(`  ${DIM}already${OFF}  ${edit.label}`);
+      continue;
+    }
+
+    const after = edit[direction](before);
+    if (after == null || after === before) {
+      console.log(`  ${YELLOW}by hand${OFF}  ${edit.label}`);
+      manual.push([edit.label, edit.manualSteps]);
+      continue;
+    }
+
+    if (!dryRun) fs.writeFileSync(file, after);
+    console.log(`  ${GREEN}${dryRun ? 'would' : 'wrote'}${OFF}    ${edit.label}`);
+    changed++;
+  }
+
+  for (const [label, lines] of manual) {
+    console.log(`\n${YELLOW}${label}${OFF} could not be edited automatically:`);
+    for (const line of lines) console.log(`  ${line}`);
+  }
+
+  if (changed && !dryRun && direction === 'addQuickJS') {
+    console.log(`\nNext: cd ios && pod install\n`);
+  } else {
+    console.log('');
+  }
+  return manual.length ? 1 : 0;
+}
+
+function doctor(argv) {
+  const project = resolveProjectDirectory(argv);
+  let notConfigured = 0;
+  let found = 0;
+
+  console.log('');
+  for (const edit of edits) {
+    const file = edit.findFile(project);
+    if (!file || !fs.existsSync(file)) {
+      console.log(`  ${DIM}—${OFF}  ${edit.label} ${DIM}(not in this project)${OFF}`);
+      continue;
+    }
+    found++;
+    if (edit.isApplied(fs.readFileSync(file, 'utf8'))) {
+      console.log(`  ${GREEN}✓${OFF}  ${edit.label}`);
+    } else {
+      console.log(`  ${RED}✗${OFF}  ${edit.label}`);
+      notConfigured++;
+    }
+  }
+
+  if (!found) {
+    console.log(`\nNo React Native app found in ${project}\nUse --project <path> to point at one.\n`);
+    return 1;
+  }
+
+  console.log(
+    notConfigured
+      ? `\n${notConfigured} of ${edits.length} not configured for QuickJS. ` +
+          `Run: npx react-native-quickjs install\n`
+      : `\nConfigured to run on QuickJS.\n`
+  );
+  return notConfigured ? 1 : 0;
+}
+
+module.exports = {
+  install: (argv) => applyEdits('addQuickJS', argv),
+  revert: (argv) => applyEdits('removeQuickJS', argv),
+  doctor,
+};

package/src/bytecode/QuickJSBytecode.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Ammar Ahmed.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "QuickJSBytecode.h"
+
+#include <cstring>
+
+namespace qjs {
+
+uint32_t bytecodeFormatVersion(const uint8_t *data) {
+  const uint8_t *version = data + kBytecodeMagicSize;
+  return static_cast<uint32_t>(version[0]) |
+         (static_cast<uint32_t>(version[1]) << 8) |
+         (static_cast<uint32_t>(version[2]) << 16) |
+         (static_cast<uint32_t>(version[3]) << 24);
+}
+
+bool isBytecodeContainer(const uint8_t *data, size_t size) {
+  if (data == nullptr || size < kBytecodeHeaderSize) {
+    return false;
+  }
+  if (std::memcmp(data, kBytecodeMagic, kBytecodeMagicSize) != 0) {
+    return false;
+  }
+  return bytecodeFormatVersion(data) == kBytecodeFormatVersion;
+}
+
+bool isHermesBytecode(const uint8_t *data, size_t size) {
+  // hermes::hbc::MAGIC, from BCGen/HBC/BytecodeFileFormat.h. Read a byte at a
+  // time: the buffer has no alignment guarantee.
+  static constexpr uint64_t kHermesMagic = 0x1F1903C103BC1FC6ULL;
+
+  if (data == nullptr || size < sizeof(uint64_t)) {
+    return false;
+  }
+
+  uint64_t magic = 0;
+  for (size_t i = 0; i < sizeof(uint64_t); i++) {
+    magic |= static_cast<uint64_t>(data[i]) << (8 * i);
+  }
+
+  // ~MAGIC marks a delta bundle, equally unexecutable here.
+  return magic == kHermesMagic || magic == ~kHermesMagic;
+}
+
+}  // namespace qjs

package/src/bytecode/QuickJSBytecode.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Ammar Ahmed.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace qjs {
+
+/**
+ * Precompiled bytecode container, written by tools/bytecode/qjsc.c.
+ *
+ *     [8 bytes magic "NSBCNGS\0"][4 bytes format version, little-endian]
+ *     [JS_WriteObject payload]
+ *
+ * A JS_WriteObject payload has no strong leading magic of its own, so it is
+ * wrapped to make detection unambiguous. The magic is specific to quickjs-ng;
+ * bytecode from Bellard's quickjs is not interchangeable.
+ */
+inline constexpr char kBytecodeMagic[8] = {'N', 'S', 'B', 'C',
+                                           'N', 'G', 'S', '\0'};
+inline constexpr size_t kBytecodeMagicSize = sizeof(kBytecodeMagic);
+inline constexpr size_t kBytecodeHeaderSize = kBytecodeMagicSize + 4;
+inline constexpr uint32_t kBytecodeFormatVersion = 1;
+
+/// True if `data` opens a container this runtime can execute. An unrecognised
+/// format version reads as false, so a stale artifact is treated as source
+/// rather than mis-parsed as bytecode.
+bool isBytecodeContainer(const uint8_t *data, size_t size);
+
+/// Only meaningful when `size >= kBytecodeHeaderSize`.
+uint32_t bytecodeFormatVersion(const uint8_t *data);
+
+/**
+ * True if `data` is a Hermes bytecode bundle.
+ *
+ * Detected only to name it. An app that sets `hermesEnabled=true` in Gradle to
+ * satisfy a library that expects Hermes also makes `BundleHermesCTask` run
+ * `hermesc`, so the shipped bundle becomes Hermes bytecode. Unrecognised, it
+ * falls through to the parser as binary and surfaces as an unintelligible
+ * syntax error at byte zero.
+ */
+bool isHermesBytecode(const uint8_t *data, size_t size);
+
+}  // namespace qjs

package/src/module/QuickJSCompat.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Ammar Ahmed.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "QuickJSCompat.h"
+
+namespace qjs {
+
+namespace jsi = facebook::jsi;
+
+/*
+ * React Native detects engine capabilities by looking for
+ * `global.HermesInternal`. That is not a capability protocol -- it is a check
+ * for one specific engine -- so every other engine silently gets the fallback
+ * path. There are three uses in React Native 0.85:
+ *
+ *   Libraries/Core/polyfillPromise.js:25
+ *     if (global?.HermesInternal?.hasPromise?.()) { native Promise }
+ *     else { polyfillGlobal('Promise', ...) }
+ *   Libraries/Core/polyfillPromise.js:32
+ *     enablePromiseRejectionTracker(...), in __DEV__ only
+ *   Libraries/Core/Devtools/parseErrorStack.js:51
+ *     branches on it to choose a stack-trace parser
+ *
+ * Without this shim every app replaces quickjs's native Promise with
+ * `promise@7.3.1`, a JavaScript implementation on top of setImmediate.
+ * Measured here: constructing and chaining costs 1205 ns through the polyfill
+ * against 775 ns native, and every `await` in the app pays it.
+ *
+ * The third use is the one that could bite, since declaring the object reroutes
+ * stack parsing to parseHermesStack. Its frame pattern is
+ *
+ *     /^ {4}at (.+?)(?: \((native)\)?| \((address at )?(.*?):(\d+):(\d+)\))$/
+ *
+ * and quickjs emits exactly that shape, `    at inner (/path/file.js:1:29)`,
+ * including the `(native)` form. Checked against real quickjs stacks: every
+ * frame parses with the captures the Hermes parser expects.
+ *
+ * The honest cost is outside React Native core, where third-party libraries use
+ * the same object as an "am I on Hermes" test, sometimes to work around a
+ * Hermes bug we do not have. That is why this is a config flag rather than
+ * unconditional, and why getRuntimeProperties() below tells the truth about
+ * which engine this is.
+ */
+void installReactNativeCompat(jsi::Runtime &runtime) {
+  auto hermesInternal = jsi::Object(runtime);
+
+  hermesInternal.setProperty(
+      runtime, "hasPromise",
+      jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forAscii(runtime, "hasPromise"), 0,
+          [](jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t) {
+            return jsi::Value(true);
+          }));
+
+  // Accepting and ignoring the options is deliberate: unhandled-rejection
+  // reporting belongs to the host, which installs its own tracker through
+  // JS_SetHostPromiseRejectionTracker. Throwing "not implemented" here would
+  // break every development build for a feature the host already owns.
+  hermesInternal.setProperty(
+      runtime, "enablePromiseRejectionTracker",
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(runtime, "enablePromiseRejectionTracker"),
+          1,
+          [](jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t) {
+            return jsi::Value::undefined();
+          }));
+
+  hermesInternal.setProperty(
+      runtime, "getRuntimeProperties",
+      jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forAscii(runtime, "getRuntimeProperties"),
+          0,
+          [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) {
+            auto props = jsi::Object(rt);
+            props.setProperty(
+                rt, "OSS Release Version",
+                jsi::String::createFromAscii(rt, "quickjs-ng"));
+            props.setProperty(
+                rt, "Engine", jsi::String::createFromAscii(rt, "QuickJS"));
+            props.setProperty(rt, "isHermes", jsi::Value(false));
+            return jsi::Value(std::move(props));
+          }));
+
+  runtime.global().setProperty(runtime, "HermesInternal", hermesInternal);
+}
+
+}  // namespace qjs

package/src/module/QuickJSCompat.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Ammar Ahmed.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace qjs {
+
+/// Installs the `HermesInternal` object React Native probes for. See the
+/// implementation for what it costs to omit and why claiming the name is safe.
+/// Controlled by QuickJSRuntimeConfig::reactNativeCompat.
+void installReactNativeCompat(facebook::jsi::Runtime &runtime);
+
+}  // namespace qjs