hermes-test 0.2.0

package/src/polyfills.js

@@ -0,0 +1,334 @@
+// Hermes runtime polyfills for hermes-test
+// These run before any bundled code (injected via esbuild banner).
+// Hermes lacks these APIs since they normally come from the RN native runtime.
+
+// React checks process.env.NODE_ENV at load time
+if (typeof globalThis.process === 'undefined') {
+  globalThis.process = { env: { NODE_ENV: 'test', JEST_WORKER_ID: '1' } };
+} else if (!globalThis.process.env) {
+  globalThis.process.env = { NODE_ENV: 'test', JEST_WORKER_ID: '1' };
+} else {
+  // Always set JEST_WORKER_ID so RTK Query apiBaseQuery uses the mock domain (apiMockDomain)
+  // rather than the real AWS domain. Runs before any bundled module-level code.
+  if (!globalThis.process.env.JEST_WORKER_ID) {
+    globalThis.process.env.JEST_WORKER_ID = '1';
+  }
+}
+
+// process.nextTick — many Node.js-style tests use this
+if (typeof globalThis.process.nextTick === 'undefined') {
+  globalThis.process.nextTick = function(fn) {
+    Promise.resolve().then(fn);
+  };
+}
+
+// Object.fromEntries — ES2019, may not exist in older Hermes builds
+if (typeof Object.fromEntries === 'undefined') {
+  Object.fromEntries = function(iterable) {
+    var obj = {};
+    if (iterable && typeof iterable[Symbol.iterator] === 'function') {
+      var iter = iterable[Symbol.iterator]();
+      var next;
+      while (!(next = iter.next()).done) {
+        obj[next.value[0]] = next.value[1];
+      }
+    } else if (iterable && typeof iterable.forEach === 'function') {
+      iterable.forEach(function(pair) { obj[pair[0]] = pair[1]; });
+    }
+    return obj;
+  };
+}
+
+// crypto.getRandomValues — needed by uuid and other crypto-dependent libs
+if (typeof globalThis.crypto === 'undefined') {
+  globalThis.crypto = {};
+}
+if (typeof globalThis.crypto.getRandomValues === 'undefined') {
+  globalThis.crypto.getRandomValues = function(arr) {
+    for (var i = 0; i < arr.length; i++) {
+      arr[i] = Math.floor(Math.random() * 256);
+    }
+    return arr;
+  };
+}
+
+// MessageChannel polyfill — React 19's scheduler uses it for async work
+if (typeof globalThis.MessageChannel === 'undefined') {
+  globalThis.MessageChannel = function() {
+    var cb = null;
+    this.port1 = { onmessage: null };
+    this.port2 = {
+      postMessage: function() {
+        if (cb) { var fn = cb; cb = null; fn({ data: undefined }); }
+      }
+    };
+    var self = this;
+    Object.defineProperty(this.port1, 'onmessage', {
+      set: function(fn) { cb = fn; },
+      get: function() { return cb; }
+    });
+  };
+}
+
+// Timer polyfills — React scheduler needs these
+(function() {
+  var queue = [];
+  var timerIdCounter = 1;
+  var timers = {};
+
+  if (typeof globalThis.setImmediate === 'undefined') {
+    globalThis.setImmediate = function(fn) { queue.push(fn); };
+  }
+
+  // Flush all async work: Hermes microtask queue (promises) + our polyfill queues (timers).
+  // The C++ bridge installs a native __HT_drain that calls Hermes's drainMicrotasks().
+  // We wrap it to also flush our setImmediate/setTimeout polyfill queues.
+  var nativeDrain = globalThis.__HT_drain || function() {};
+  globalThis.__HT_drain = function() {
+    // 1. Drain Hermes's internal promise/microtask queue
+    nativeDrain();
+    // 2. Flush our setImmediate queue
+    var limit = 1000;
+    while (queue.length > 0 && limit-- > 0) { queue.shift()(); }
+    // 3. Flush pending timers
+    var ids = Object.keys(timers);
+    for (var i = 0; i < ids.length; i++) {
+      var t = timers[ids[i]];
+      if (t) { delete timers[ids[i]]; t(); }
+    }
+    // 4. Drain again (timer callbacks may have queued more microtasks)
+    nativeDrain();
+  };
+
+  if (typeof globalThis.setTimeout === 'undefined') {
+    globalThis.setTimeout = function(fn, delay) {
+      var id = timerIdCounter++;
+      if (!delay || delay <= 0) {
+        queue.push(fn);
+      } else {
+        timers[id] = fn;
+      }
+      return id;
+    };
+  }
+
+  if (typeof globalThis.clearTimeout === 'undefined') {
+    globalThis.clearTimeout = function(id) { delete timers[id]; };
+  }
+
+  if (typeof globalThis.console === 'undefined') {
+    globalThis.console = {
+      log: function() {},
+      warn: function() {},
+      error: function() {},
+      info: function() {},
+      debug: function() {},
+    };
+  }
+})();
+
+// Web API polyfills — needed for RTK Query's fetchBaseQuery
+(function() {
+  // AbortController / AbortSignal
+  if (typeof globalThis.AbortController === 'undefined') {
+    function AbortSignal() { this.aborted = false; this._listeners = []; }
+    AbortSignal.prototype.addEventListener = function(type, fn) { this._listeners.push(fn); };
+    AbortSignal.prototype.removeEventListener = function(type, fn) {
+      this._listeners = this._listeners.filter(function(f) { return f !== fn; });
+    };
+
+    function AbortController() { this.signal = new AbortSignal(); }
+    AbortController.prototype.abort = function() {
+      this.signal.aborted = true;
+      for (var i = 0; i < this.signal._listeners.length; i++) {
+        try { this.signal._listeners[i](); } catch(e) {}
+      }
+    };
+
+    globalThis.AbortController = AbortController;
+    globalThis.AbortSignal = AbortSignal;
+  }
+
+  // Headers
+  if (typeof globalThis.Headers === 'undefined') {
+    function Headers(init) {
+      this._map = {};
+      if (init) {
+        if (typeof init.forEach === 'function') {
+          init.forEach(function(v, k) { this._map[k.toLowerCase()] = v; }.bind(this));
+        } else {
+          var keys = Object.keys(init);
+          for (var i = 0; i < keys.length; i++) {
+            this._map[keys[i].toLowerCase()] = init[keys[i]];
+          }
+        }
+      }
+    }
+    Headers.prototype.get = function(k) { return this._map[k.toLowerCase()] || null; };
+    Headers.prototype.has = function(k) { return k.toLowerCase() in this._map; };
+    Headers.prototype.set = function(k, v) { this._map[k.toLowerCase()] = v; };
+    Headers.prototype.append = function(k, v) {
+      k = k.toLowerCase();
+      this._map[k] = this._map[k] ? this._map[k] + ', ' + v : v;
+    };
+    Headers.prototype.delete = function(k) { delete this._map[k.toLowerCase()]; };
+    Headers.prototype.forEach = function(fn) {
+      var keys = Object.keys(this._map);
+      for (var i = 0; i < keys.length; i++) fn(this._map[keys[i]], keys[i], this);
+    };
+    Headers.prototype.entries = function() { return Object.entries(this._map); };
+    globalThis.Headers = Headers;
+  }
+
+  // URLSearchParams — always install BEFORE URL: native Hermes version may not parse correctly
+  {
+    function URLSearchParams(init) {
+      this._params = [];
+      if (typeof init === 'string') {
+        init = init.replace(/^\?/, '');
+        var pairs = init.split('&');
+        for (var i = 0; i < pairs.length; i++) {
+          if (!pairs[i]) continue;
+          var kv = pairs[i].split('=');
+          this._params.push([decodeURIComponent(kv[0]), decodeURIComponent(kv.slice(1).join('='))]);
+        }
+      } else if (init && typeof init === 'object') {
+        if (Array.isArray(init)) {
+          // Array of [key, value] pairs
+          for (var i = 0; i < init.length; i++) {
+            this._params.push([String(init[i][0]), String(init[i][1])]);
+          }
+        } else if (typeof init[Symbol.iterator] === 'function') {
+          // Iterable (e.g. another URLSearchParams instance)
+          var iter = init[Symbol.iterator]();
+          var next;
+          while (!(next = iter.next()).done) {
+            this._params.push([String(next.value[0]), String(next.value[1])]);
+          }
+        } else if (typeof init.forEach === 'function') {
+          // URLSearchParams-like with forEach(value, key)
+          init.forEach(function(v, k) { this._params.push([String(k), String(v)]); }.bind(this));
+        } else {
+          // Plain object: { key: value }
+          var keys = Object.keys(init);
+          for (var i = 0; i < keys.length; i++) {
+            this._params.push([keys[i], String(init[keys[i]])]);
+          }
+        }
+      }
+    }
+    URLSearchParams.prototype.get = function(k) {
+      for (var i = 0; i < this._params.length; i++) {
+        if (this._params[i][0] === k) return this._params[i][1];
+      }
+      return null;
+    };
+    URLSearchParams.prototype.has = function(k) {
+      for (var i = 0; i < this._params.length; i++) {
+        if (this._params[i][0] === k) return true;
+      }
+      return false;
+    };
+    URLSearchParams.prototype.set = function(k, v) {
+      for (var i = 0; i < this._params.length; i++) {
+        if (this._params[i][0] === k) { this._params[i][1] = String(v); return; }
+      }
+      this._params.push([k, String(v)]);
+    };
+    URLSearchParams.prototype.append = function(k, v) { this._params.push([k, String(v)]); };
+    URLSearchParams.prototype['delete'] = function(k) {
+      this._params = this._params.filter(function(p) { return p[0] !== k; });
+    };
+    URLSearchParams.prototype.entries = function() {
+      var params = this._params;
+      var i = 0;
+      return { next: function() {
+        if (i < params.length) return { value: [params[i][0], params[i++][1]], done: false };
+        return { value: undefined, done: true };
+      }};
+    };
+    URLSearchParams.prototype.keys = function() {
+      var params = this._params;
+      var i = 0;
+      return { next: function() {
+        if (i < params.length) return { value: params[i++][0], done: false };
+        return { value: undefined, done: true };
+      }};
+    };
+    URLSearchParams.prototype.values = function() {
+      var params = this._params;
+      var i = 0;
+      return { next: function() {
+        if (i < params.length) return { value: params[i++][1], done: false };
+        return { value: undefined, done: true };
+      }};
+    };
+    URLSearchParams.prototype.forEach = function(fn, thisArg) {
+      for (var i = 0; i < this._params.length; i++) {
+        fn.call(thisArg, this._params[i][1], this._params[i][0], this);
+      }
+    };
+    URLSearchParams.prototype.toString = function() {
+      return this._params.map(function(p) { return encodeURIComponent(p[0]) + '=' + encodeURIComponent(p[1]); }).join('&');
+    };
+    URLSearchParams.prototype[Symbol.iterator] = URLSearchParams.prototype.entries;
+    globalThis.URLSearchParams = URLSearchParams;
+  }
+
+  // URL — always install: Hermes has a built-in URL that doesn't parse searchParams correctly
+  {
+    function URL(url, base) {
+      if (base && url.indexOf('://') === -1) {
+        url = base.replace(/\/$/, '') + '/' + url.replace(/^\//, '');
+      }
+      this.href = url;
+      var match = url.match(/^(https?:)\/\/([^/:?#]+)(:\d+)?(\/[^?#]*)?(\?[^#]*)?(#.*)?$/);
+      if (match) {
+        this.protocol = match[1];
+        this.hostname = match[2];
+        this.port = match[3] ? match[3].slice(1) : '';
+        this.pathname = match[4] || '/';
+        this.search = match[5] || '';
+        this.hash = match[6] || '';
+        this.host = this.hostname + (this.port ? ':' + this.port : '');
+        this.origin = this.protocol + '//' + this.host;
+      } else {
+        this.protocol = ''; this.hostname = ''; this.port = '';
+        this.pathname = url; this.search = ''; this.hash = '';
+        this.host = ''; this.origin = '';
+      }
+      this.searchParams = new globalThis.URLSearchParams(this.search);
+    }
+    URL.prototype.toString = function() { return this.href; };
+    globalThis.URL = URL;
+  }
+
+  // Request (minimal — RTK Query checks typeof Request)
+  if (typeof globalThis.Request === 'undefined') {
+    globalThis.Request = function Request(url, init) {
+      this.url = typeof url === 'string' ? url : url.href;
+      this.method = (init && init.method) || 'GET';
+      this.headers = new globalThis.Headers(init && init.headers);
+      this.body = init && init.body;
+    };
+  }
+
+  // Stub fetch (mockFetch will override with handler-based implementation)
+  if (typeof globalThis.fetch === 'undefined') {
+    globalThis.fetch = function() {
+      return Promise.reject(new Error('fetch not configured — use mockFetch() to register handlers'));
+    };
+  }
+
+  // Response (minimal)
+  if (typeof globalThis.Response === 'undefined') {
+    globalThis.Response = function Response(body, init) {
+      this.body = body;
+      this.status = (init && init.status) || 200;
+      this.ok = this.status >= 200 && this.status < 300;
+      this.headers = new globalThis.Headers(init && init.headers);
+    };
+    globalThis.Response.prototype.json = function() { return Promise.resolve(JSON.parse(this.body)); };
+    globalThis.Response.prototype.text = function() { return Promise.resolve(String(this.body)); };
+  }
+})();

package/src/shims/async-storage.js

@@ -0,0 +1,54 @@
+// In-memory AsyncStorage shim for hermes-test.
+// Provides a fresh store per test file. Data persists within a file,
+// resets between files via __HT_resetAsyncStorage().
+
+var _store = {};
+
+var AsyncStorage = {
+  getItem: function(key) {
+    var val = _store[key] !== undefined ? _store[key] : null;
+    return Promise.resolve(val);
+  },
+  setItem: function(key, value) {
+    _store[key] = value;
+    return Promise.resolve();
+  },
+  removeItem: function(key) {
+    delete _store[key];
+    return Promise.resolve();
+  },
+  multiRemove: function(keys) {
+    for (var i = 0; i < keys.length; i++) {
+      delete _store[keys[i]];
+    }
+    return Promise.resolve();
+  },
+  multiGet: function(keys) {
+    var result = [];
+    for (var i = 0; i < keys.length; i++) {
+      result.push([keys[i], _store[keys[i]] !== undefined ? _store[keys[i]] : null]);
+    }
+    return Promise.resolve(result);
+  },
+  multiSet: function(pairs) {
+    for (var i = 0; i < pairs.length; i++) {
+      _store[pairs[i][0]] = pairs[i][1];
+    }
+    return Promise.resolve();
+  },
+  getAllKeys: function() {
+    return Promise.resolve(Object.keys(_store));
+  },
+  clear: function() {
+    _store = {};
+    return Promise.resolve();
+  },
+};
+
+// Reset hook — called between test files by the harness
+globalThis.__HT_resetAsyncStorage = function() {
+  _store = {};
+};
+
+module.exports = AsyncStorage;
+module.exports.default = AsyncStorage;

package/src/shims/react-i18next.js

@@ -0,0 +1,20 @@
+// Built-in react-i18next shim for hermes-test.
+// Identity translation: t('key') returns 'key'.
+// Covers useTranslation, withTranslation, Trans, initReactI18next.
+
+var t = function(key) { return key; };
+var i18n = {
+  language: 'en',
+  changeLanguage: function() { return Promise.resolve(); },
+  use: function() { return i18n; },
+  init: function() { return Promise.resolve(); },
+};
+
+module.exports = {
+  useTranslation: function() { return { t: t, i18n: i18n, ready: true }; },
+  withTranslation: function() { return function(component) { return component; }; },
+  Trans: function(props) { return props.children || null; },
+  Translation: function(props) { return props.children(t, { i18n: i18n }); },
+  initReactI18next: { type: '3rdParty', init: function() {} },
+  I18nextProvider: function(props) { return props.children; },
+};

package/src/shims/react-native-launch-arguments.js

@@ -0,0 +1,8 @@
+// Built-in react-native-launch-arguments shim for hermes-test.
+// Returns empty launch arguments — native module not available in test environment.
+
+module.exports = {
+  LaunchArguments: {
+    value: function() { return {}; },
+  },
+};

package/src/shims/react-native.js

@@ -0,0 +1,168 @@
+// Default react-native shim for hermes-test.
+// Provides stub implementations of commonly used RN APIs.
+// Users can override via hermes-test.config.json "shims" or mockModule().
+
+var noop = function() {};
+var noopReturn = function(x) { return x; };
+
+module.exports = {
+  // Platform
+  Platform: {
+    OS: 'ios',
+    Version: 19,
+    select: function(obj) { return obj.ios !== undefined ? obj.ios : obj.default; },
+    isPad: false,
+    isTVOS: false,
+    isTV: false,
+  },
+
+  // StyleSheet
+  StyleSheet: {
+    create: function(styles) { return styles; },
+    flatten: function(style) {
+      if (!style) return {};
+      if (Array.isArray(style)) {
+        var result = {};
+        for (var i = 0; i < style.length; i++) {
+          if (style[i]) Object.assign(result, style[i]);
+        }
+        return result;
+      }
+      return style;
+    },
+    absoluteFill: { position: 'absolute', left: 0, right: 0, top: 0, bottom: 0 },
+    absoluteFillObject: { position: 'absolute', left: 0, right: 0, top: 0, bottom: 0 },
+    hairlineWidth: 1,
+  },
+
+  // Dimensions
+  Dimensions: {
+    get: function() { return { width: 375, height: 812, scale: 3, fontScale: 1 }; },
+    addEventListener: function() { return { remove: noop }; },
+    removeEventListener: noop,
+  },
+
+  // PixelRatio
+  PixelRatio: {
+    get: function() { return 3; },
+    getFontScale: function() { return 1; },
+    getPixelSizeForLayoutSize: function(size) { return size * 3; },
+    roundToNearestPixel: function(size) { return Math.round(size * 3) / 3; },
+  },
+
+  // AppState
+  AppState: {
+    currentState: 'active',
+    addEventListener: function(event, cb) {
+      return { remove: noop };
+    },
+    removeEventListener: noop,
+  },
+
+  // Alert
+  Alert: {
+    alert: noop,
+    prompt: noop,
+  },
+
+  // Linking
+  Linking: {
+    openURL: function() { return Promise.resolve(); },
+    canOpenURL: function() { return Promise.resolve(true); },
+    getInitialURL: function() { return Promise.resolve(null); },
+    addEventListener: function() { return { remove: noop }; },
+    removeEventListener: noop,
+  },
+
+  // Keyboard
+  Keyboard: {
+    dismiss: noop,
+    addListener: function() { return { remove: noop }; },
+    removeListener: noop,
+    removeAllListeners: noop,
+  },
+
+  // Animated
+  Animated: {
+    Value: function(val) {
+      this._value = val;
+      this.setValue = function(v) { this._value = v; };
+      this.interpolate = function() { return new module.exports.Animated.Value(0); };
+      this.addListener = function() { return { remove: noop }; };
+      this.removeListener = noop;
+      this.removeAllListeners = noop;
+      this.stopAnimation = function(cb) { if (cb) cb(this._value); };
+    },
+    ValueXY: function() {
+      this.x = new module.exports.Animated.Value(0);
+      this.y = new module.exports.Animated.Value(0);
+      this.setValue = noop;
+      this.getLayout = function() { return { left: this.x, top: this.y }; };
+    },
+    timing: function() { return { start: function(cb) { if (cb) cb({ finished: true }); } }; },
+    spring: function() { return { start: function(cb) { if (cb) cb({ finished: true }); } }; },
+    decay: function() { return { start: function(cb) { if (cb) cb({ finished: true }); } }; },
+    parallel: function() { return { start: function(cb) { if (cb) cb({ finished: true }); } }; },
+    sequence: function() { return { start: function(cb) { if (cb) cb({ finished: true }); } }; },
+    stagger: function() { return { start: function(cb) { if (cb) cb({ finished: true }); } }; },
+    loop: function() { return { start: noop, stop: noop }; },
+    event: function() { return noop; },
+    createAnimatedComponent: noopReturn,
+    View: 'Animated.View',
+    Text: 'Animated.Text',
+    Image: 'Animated.Image',
+    ScrollView: 'Animated.ScrollView',
+    FlatList: 'Animated.FlatList',
+  },
+
+  // Hooks
+  useWindowDimensions: function() { return { width: 375, height: 812, scale: 3, fontScale: 1 }; },
+  useColorScheme: function() { return 'light'; },
+
+  // Components (string stubs — not rendered in test)
+  View: 'View',
+  Text: 'Text',
+  Image: 'Image',
+  ScrollView: 'ScrollView',
+  FlatList: 'FlatList',
+  SectionList: 'SectionList',
+  TouchableOpacity: 'TouchableOpacity',
+  TouchableHighlight: 'TouchableHighlight',
+  TouchableWithoutFeedback: 'TouchableWithoutFeedback',
+  Pressable: 'Pressable',
+  TextInput: 'TextInput',
+  Switch: 'Switch',
+  ActivityIndicator: 'ActivityIndicator',
+  Modal: 'Modal',
+  SafeAreaView: 'SafeAreaView',
+  StatusBar: 'StatusBar',
+  KeyboardAvoidingView: 'KeyboardAvoidingView',
+
+  // I18nManager
+  I18nManager: {
+    isRTL: false,
+    allowRTL: noop,
+    forceRTL: noop,
+  },
+
+  // Appearance
+  Appearance: {
+    getColorScheme: function() { return 'light'; },
+    addChangeListener: function() { return { remove: noop }; },
+  },
+
+  // NativeModules fallback
+  NativeModules: {},
+  NativeEventEmitter: function() {
+    this.addListener = function() { return { remove: noop }; };
+    this.removeListener = noop;
+    this.removeAllListeners = noop;
+  },
+
+  // AccessibilityInfo
+  AccessibilityInfo: {
+    isScreenReaderEnabled: function() { return Promise.resolve(false); },
+    addEventListener: function() { return { remove: noop }; },
+    announceForAccessibility: noop,
+  },
+};

package/src/shims/react-redux.js

@@ -0,0 +1,12 @@
+// hermes-test shim for react-redux
+//
+// Transparent wrapper that ensures single-instance resolution.
+// Re-exports Provider, useSelector, useDispatch, connect, etc.
+// unchanged. Prevents dual-instance issues where React context
+// from one copy can't be read by hooks from another copy.
+//
+// Usage in hermes-test.config.json:
+//   "shims": { "react-redux": "hermes-test/shims/react-redux" }
+
+var real = require('@__ht_real_pkg/react-redux');
+module.exports = real;

package/src/shims/react.js

@@ -0,0 +1,16 @@
+// Shim for react inside the harness bundle.
+// react-reconciler imports 'react' — this shim delegates to globalThis.__HT_React.
+// The Proxy ensures late-binding: properties are read at access time, not import time.
+var handler = {
+  get: function(_, prop) {
+    if (prop === Symbol.toPrimitive || prop === 'then') return undefined;
+    var R = globalThis.__HT_React;
+    return R ? R[prop] : undefined;
+  },
+  set: function(_, prop, value) {
+    var R = globalThis.__HT_React;
+    if (R) R[prop] = value;
+    return true;
+  }
+};
+module.exports = new Proxy({}, handler);

package/src/shims/reduxjs-toolkit.js

@@ -0,0 +1,11 @@
+// hermes-test shim for @reduxjs/toolkit
+//
+// Transparent wrapper that ensures single-instance resolution.
+// Re-exports everything unchanged — createSlice, configureStore,
+// createAsyncThunk, createSelector, etc. all work as normal.
+//
+// Usage in hermes-test.config.json:
+//   "shims": { "@reduxjs/toolkit": "hermes-test/shims/reduxjs-toolkit" }
+
+var real = require('@__ht_real_pkg/@reduxjs/toolkit');
+module.exports = real;

package/src/shims/rtk-query.js

@@ -0,0 +1,44 @@
+// hermes-test shim for @reduxjs/toolkit/query/react
+//
+// Fixes the dual-instance problem: when split bundles or shadow wrappers
+// cause createApi() to be called twice with the same config, only one
+// API instance is created. injectEndpoints() mutations always hit the
+// canonical instance, so the store and endpoint modules stay in sync.
+//
+// Usage in hermes-test.config.json:
+//   "shims": { "@reduxjs/toolkit/query/react": "hermes-test/shims/rtk-query" }
+
+var real = require('@__ht_real_pkg/@reduxjs/toolkit/query/react');
+
+// Singleton cache keyed by reducerPath — prevents dual-instance from
+// split bundles or shadow wrapper re-entrancy
+var _apiCache = {};
+
+// Proxy delegates everything to the real module with late binding.
+// This avoids eagerly copying ESM live bindings that may not be initialized yet.
+var handler = {
+  get: function(target, prop) {
+    if (prop === 'createApi') {
+      return function createApi(opts) {
+        var key = opts && opts.reducerPath || 'api';
+        if (_apiCache[key]) return _apiCache[key];
+        var api = real.createApi(opts);
+        _apiCache[key] = api;
+        return api;
+      };
+    }
+    return real[prop];
+  },
+  ownKeys: function() {
+    try { return Object.getOwnPropertyNames(real); } catch(e) { return []; }
+  },
+  getOwnPropertyDescriptor: function(target, prop) {
+    try {
+      var d = Object.getOwnPropertyDescriptor(real, prop);
+      if (d) return { configurable: true, enumerable: d.enumerable, writable: true, value: d.get ? d.get() : d.value };
+    } catch(e) {}
+    return { configurable: true, enumerable: false, writable: true, value: undefined };
+  }
+};
+
+module.exports = new Proxy({}, handler);