@oh-my-pi/pi-coding-agent 16.1.7 → 16.1.9

package/src/tools/puppeteer/06_stealth_screen.txt

@@ -1,72 +1,260 @@
-// Generate consistent "real" screen dimensions based on viewport
-const width = window.innerWidth;
-const height = window.innerHeight;
-const availWidth = width;
-const availHeight = Math_max(height - 40, 0); // Account for taskbar
-const colorDepth = 24;
-const pixelDepth = 24;
-const devicePixelRatio = window.devicePixelRatio && window.devicePixelRatio > 1 ? window.devicePixelRatio : 1.25;
-
-const defineScreenProp = (prop, value) => {
-  try {
-    Object_defineProperty(window.Screen?.prototype ?? window.screen, prop, {
-      get: () => value,
-      configurable: true,
-      enumerable: true,
+;(() => {
+  if (typeof Window_Proxy !== "function" || typeof Reflect_apply !== "function") return;
+
+  const screenObject = window.screen;
+  if (!screenObject) return;
+
+  const isFiniteNumber = (value) =>
+    typeof value === "number" &&
+    value === value &&
+    value !== Infinity &&
+    value !== -Infinity;
+
+  const readValue = (object, prop, fallback) => {
+    try {
+      const value = object[prop];
+      return value === undefined ? fallback : value;
+    } catch {
+      return fallback;
+    }
+  };
+
+  const finiteNumber = (value, fallback) =>
+    isFiniteNumber(value) ? value : fallback;
+
+  const positiveNumber = (value, fallback) =>
+    isFiniteNumber(value) && value > 0 ? value : fallback;
+
+  const integerNumber = (value, fallback) =>
+    isFiniteNumber(value) ? Math_floor(value) : fallback;
+
+  const positiveInteger = (value, fallback) =>
+    isFiniteNumber(value) && value > 0 ? Math_floor(value) : fallback;
+
+  const findDescriptorOwner = (object, prop) => {
+    let owner = object;
+    while (owner) {
+      let descriptor;
+      try {
+        descriptor = Object_getOwnPropertyDescriptor(owner, prop);
+      } catch {
+        return undefined;
+      }
+      if (descriptor) return [owner, descriptor];
+      try {
+        owner = Object_getPrototypeOf(owner);
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  };
+
+  const patchGetter = (object, prop, getValue) => {
+    const found = findDescriptorOwner(object, prop);
+    if (!found) return false;
+
+    const owner = found[0];
+    const descriptor = found[1];
+    if (descriptor.configurable !== true || typeof descriptor.get !== "function") {
+      return false;
+    }
+
+    const originalGet = descriptor.get;
+    const patchedGet = new Window_Proxy(originalGet, {
+      apply(target, thisArg, args) {
+        const nativeValue = Reflect_apply(target, thisArg, args);
+        return getValue(nativeValue, thisArg);
+      },
     });
-  } catch {}
-};
-
-// Override screen properties
-for (const [prop, descriptor] of Object_entries({
-  width,
-  height,
-  availWidth,
-  availHeight,
-  availLeft: 0,
-  availTop: 0,
-  colorDepth,
-  pixelDepth,
-})) {
-  defineScreenProp(prop, descriptor);
-}
-
-// Ensure outer dimensions match screen for consistency
-const chromeFrameHeight = 85;
-Object_defineProperty(window, "outerWidth", {
-  get: () => window.innerWidth,
-  configurable: true,
-  enumerable: true,
-});
-Object_defineProperty(window, "outerHeight", {
-  get: () => window.innerHeight + chromeFrameHeight,
-  configurable: true,
-  enumerable: true,
-});
-
-if (window.visualViewport) {
-  const defineVvpProp = (prop, value) => {
+    patchToString(patchedGet, "get " + prop);
     try {
-      Object_defineProperty(window.visualViewport, prop, {
-        get: () => value,
-        configurable: true,
-        enumerable: true,
+      Object_defineProperty(owner, prop, {
+        configurable: descriptor.configurable,
+        enumerable: descriptor.enumerable,
+        get: patchedGet,
+        set: descriptor.set,
       });
-    } catch {}
+      return true;
+    } catch {
+      return false;
+    }
   };
 
-  defineVvpProp("width", width);
-  defineVvpProp("height", height);
-  defineVvpProp("scale", 1);
-  defineVvpProp("offsetLeft", 0);
-  defineVvpProp("offsetTop", 0);
-  defineVvpProp("pageLeft", 0);
-  defineVvpProp("pageTop", 0);
-}
-
-// Consistent devicePixelRatio
-Object_defineProperty(window, "devicePixelRatio", {
-  get: () => devicePixelRatio,
-  configurable: true,
-  enumerable: true,
-});
+  const patchStableNumber = (object, prop, value) => {
+    const current = readValue(object, prop, undefined);
+    if (current === value) return;
+    patchGetter(object, prop, () => value);
+  };
+
+  const initialInnerWidth = positiveInteger(readValue(window, "innerWidth", 0), 0);
+  const initialInnerHeight = positiveInteger(readValue(window, "innerHeight", 0), 0);
+  const initialOuterWidth = positiveInteger(
+    readValue(window, "outerWidth", Math_max(initialInnerWidth, 1)),
+    Math_max(initialInnerWidth, 1),
+  );
+  const initialOuterHeight = positiveInteger(
+    readValue(window, "outerHeight", Math_max(initialInnerHeight, 1)),
+    Math_max(initialInnerHeight, 1),
+  );
+  // Real Chrome reserves vertical space for the tab strip + URL bar, so
+  // outerHeight is always taller than innerHeight (~88px on a stock window).
+  // Headless reports outerHeight === innerHeight, which is a well-known tell, so
+  // synthesize a realistic chrome height when the window has no visible chrome.
+  const browserChromeHeight = 88;
+  const targetOuterHeight =
+    initialOuterHeight > initialInnerHeight
+      ? initialOuterHeight
+      : initialInnerHeight + browserChromeHeight;
+  const requiredWidth = Math_max(initialInnerWidth, initialOuterWidth, 1);
+  const requiredHeight = Math_max(initialInnerHeight, initialOuterHeight, targetOuterHeight, 1);
+
+  const screenWidth = Math_max(
+    positiveInteger(readValue(screenObject, "width", requiredWidth), requiredWidth),
+    requiredWidth,
+  );
+  const screenHeight = Math_max(
+    positiveInteger(readValue(screenObject, "height", requiredHeight), requiredHeight),
+    requiredHeight,
+  );
+
+  let screenAvailWidth = positiveInteger(
+    readValue(screenObject, "availWidth", screenWidth),
+    screenWidth,
+  );
+  if (screenAvailWidth < requiredWidth || screenAvailWidth > screenWidth) {
+    screenAvailWidth = screenWidth;
+  }
+
+  let screenAvailHeight = positiveInteger(
+    readValue(screenObject, "availHeight", screenHeight),
+    screenHeight,
+  );
+  if (screenAvailHeight < requiredHeight || screenAvailHeight > screenHeight) {
+    screenAvailHeight = screenHeight;
+  }
+
+  const screenAvailLeft = integerNumber(readValue(screenObject, "availLeft", 0), 0);
+  const screenAvailTop = integerNumber(readValue(screenObject, "availTop", 0), 0);
+  const screenColorDepth = positiveInteger(readValue(screenObject, "colorDepth", 24), 24);
+  const screenPixelDepth = positiveInteger(
+    readValue(screenObject, "pixelDepth", screenColorDepth),
+    screenColorDepth,
+  );
+
+  for (const entry of [
+    ["width", screenWidth],
+    ["height", screenHeight],
+    ["availWidth", screenAvailWidth],
+    ["availHeight", screenAvailHeight],
+    ["availLeft", screenAvailLeft],
+    ["availTop", screenAvailTop],
+    ["colorDepth", screenColorDepth],
+    ["pixelDepth", screenPixelDepth],
+  ]) {
+    patchStableNumber(screenObject, entry[0], entry[1]);
+  }
+
+  const outerWidthNeedsPatch =
+    !isFiniteNumber(readValue(window, "outerWidth", undefined)) ||
+    readValue(window, "outerWidth", 0) <= 0 ||
+    Math_floor(readValue(window, "outerWidth", 0)) < initialInnerWidth;
+  if (outerWidthNeedsPatch) {
+    patchGetter(window, "outerWidth", (nativeValue) =>
+      Math_max(
+        positiveInteger(nativeValue, initialOuterWidth),
+        positiveInteger(readValue(window, "innerWidth", requiredWidth), requiredWidth),
+      ),
+    );
+  }
+
+  const outerHeightNeedsPatch =
+    !isFiniteNumber(readValue(window, "outerHeight", undefined)) ||
+    readValue(window, "outerHeight", 0) <= 0 ||
+    Math_floor(readValue(window, "outerHeight", 0)) <= initialInnerHeight;
+  if (outerHeightNeedsPatch) {
+    patchGetter(window, "outerHeight", (nativeValue) =>
+      Math_max(
+        positiveInteger(nativeValue, initialOuterHeight),
+        positiveInteger(readValue(window, "innerHeight", requiredHeight), requiredHeight) +
+          browserChromeHeight,
+      ),
+    );
+  }
+
+  const initialDevicePixelRatio = positiveNumber(
+    readValue(window, "devicePixelRatio", 1),
+    1,
+  );
+  if (readValue(window, "devicePixelRatio", undefined) !== initialDevicePixelRatio) {
+    patchGetter(window, "devicePixelRatio", () => initialDevicePixelRatio);
+  }
+
+  const visualViewportObject = readValue(window, "visualViewport", null);
+  if (visualViewportObject) {
+    const initialScale = positiveNumber(readValue(visualViewportObject, "scale", 1), 1);
+    if (readValue(visualViewportObject, "scale", undefined) !== initialScale) {
+      patchGetter(visualViewportObject, "scale", (nativeValue) =>
+        positiveNumber(nativeValue, initialScale),
+      );
+    }
+
+    const getViewportScale = () =>
+      positiveNumber(readValue(visualViewportObject, "scale", initialScale), initialScale);
+
+    const getViewportWidthFallback = () =>
+      positiveNumber(readValue(window, "innerWidth", requiredWidth), requiredWidth) /
+      getViewportScale();
+
+    const getViewportHeightFallback = () =>
+      positiveNumber(readValue(window, "innerHeight", requiredHeight), requiredHeight) /
+      getViewportScale();
+
+    if (positiveNumber(readValue(visualViewportObject, "width", 0), 0) <= 0) {
+      patchGetter(visualViewportObject, "width", (nativeValue) =>
+        positiveNumber(nativeValue, getViewportWidthFallback()),
+      );
+    }
+
+    if (positiveNumber(readValue(visualViewportObject, "height", 0), 0) <= 0) {
+      patchGetter(visualViewportObject, "height", (nativeValue) =>
+        positiveNumber(nativeValue, getViewportHeightFallback()),
+      );
+    }
+
+    const getViewportOffsetLeft = () =>
+      finiteNumber(readValue(visualViewportObject, "offsetLeft", 0), 0);
+    const getViewportOffsetTop = () =>
+      finiteNumber(readValue(visualViewportObject, "offsetTop", 0), 0);
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "offsetLeft", undefined))) {
+      patchGetter(visualViewportObject, "offsetLeft", (nativeValue) =>
+        finiteNumber(nativeValue, 0),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "offsetTop", undefined))) {
+      patchGetter(visualViewportObject, "offsetTop", (nativeValue) =>
+        finiteNumber(nativeValue, 0),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "pageLeft", undefined))) {
+      patchGetter(visualViewportObject, "pageLeft", (nativeValue) =>
+        finiteNumber(
+          nativeValue,
+          finiteNumber(readValue(window, "scrollX", 0), 0) + getViewportOffsetLeft(),
+        ),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "pageTop", undefined))) {
+      patchGetter(visualViewportObject, "pageTop", (nativeValue) =>
+        finiteNumber(
+          nativeValue,
+          finiteNumber(readValue(window, "scrollY", 0), 0) + getViewportOffsetTop(),
+        ),
+      );
+    }
+  }
+})();

package/src/tools/puppeteer/07_stealth_fonts.txt

@@ -47,7 +47,6 @@ const commonFonts = [
   "Wingdings 3",
   "Apple Color Emoji",
   "Apple SD Gothic Neo",
-  "Helvetica Neue",
   "Hoefler Text",
   "Menlo",
   "Monaco",
@@ -56,32 +55,31 @@ const commonFonts = [
   "SF Pro Text",
 ];
 
-// Override queryLocalFonts if present (Local Font Access API)
 if ("queryLocalFonts" in window) {
+  const queryLocalFonts = async function queryLocalFonts() {
+    return commonFonts.map((family) => ({
+      family,
+      fullName: family,
+      postscriptName: family.replace(/\s+/g, ""),
+      style: "Regular",
+      blob: () => Promise_resolve(new Window_Blob([])),
+    }));
+  };
+  patchToString(queryLocalFonts, "queryLocalFonts");
   Object_defineProperty(window, "queryLocalFonts", {
-    value: async () => {
-      return commonFonts.map((family) => ({
-        family,
-        fullName: family,
-        postscriptName: family.replace(/\s+/g, ""),
-        style: "Regular",
-        blob: () => Promise_resolve(new Window_Blob([])),
-      }));
-    },
+    value: queryLocalFonts,
     writable: true,
     configurable: true,
     enumerable: true,
   });
 }
 
-// Hide fonts-unique tracking via canvas
 const originalGetContext = HTMLCanvasElement.prototype.getContext;
-HTMLCanvasElement.prototype.getContext = function (type, options) {
+const patchedGetContext = function getContext(type, options) {
   const ctx = originalGetContext.call(this, type, options);
   if (ctx && type === "2d") {
     const originalFillText = ctx.fillText;
-    ctx.fillText = function (text, x, y, maxWidth) {
-      // Add tiny imperceptible noise to text rendering
+    const patchedFillText = function fillText(text, x, y, maxWidth) {
       const noiseX = (Math_random() - 0.5) * 0.02;
       const noiseY = (Math_random() - 0.5) * 0.02;
       return originalFillText.call(
@@ -92,6 +90,10 @@ HTMLCanvasElement.prototype.getContext = function (type, options) {
         maxWidth,
       );
     };
+    patchToString(patchedFillText, "fillText");
+    ctx.fillText = patchedFillText;
   }
   return ctx;
 };
+patchToString(patchedGetContext, "getContext");
+HTMLCanvasElement.prototype.getContext = patchedGetContext;

package/src/tools/puppeteer/08_stealth_audio.txt

@@ -1,32 +1,45 @@
-// Spoof AudioContext latency values to look like real hardware
-const spoofLatency = (proto) => {
-  Object_defineProperty(proto, "baseLatency", {
-    get: () => 0.005, // ~5ms typical for real hardware
-    configurable: true,
-    enumerable: true,
-  });
-  Object_defineProperty(proto, "outputLatency", {
-    get: () => 0.01, // ~10ms typical
+// Spoof AudioContext latency values to look like real hardware.
+const audioLatencyAccessors = {
+  get baseLatency() {
+    return 0.005;
+  },
+  get outputLatency() {
+    return 0.01;
+  },
+  get sampleRate() {
+    return 48000;
+  },
+};
+
+const defineAudioGetter = (proto, name) => {
+  const descriptor = Object_getOwnPropertyDescriptor(audioLatencyAccessors, name);
+  if (!descriptor || !descriptor.get) return;
+  patchToString(descriptor.get, "get " + name);
+  Object_defineProperty(proto, name, {
+    get: descriptor.get,
     configurable: true,
     enumerable: true,
   });
 };
 
+const spoofLatency = (proto) => {
+  defineAudioGetter(proto, "baseLatency");
+  defineAudioGetter(proto, "outputLatency");
+};
+
 if (window.AudioContext) {
   spoofLatency(AudioContext.prototype);
 }
+
 if (window.OfflineAudioContext) {
-  // For offline context, add subtle randomness to prevent deterministic fingerprints
   const OriginalOfflineAudioContext = window.OfflineAudioContext;
-  window.OfflineAudioContext = class extends OriginalOfflineAudioContext {
+  const PatchedOfflineAudioContext = class OfflineAudioContext extends OriginalOfflineAudioContext {
     constructor(numberOfChannels, length, sampleRate) {
       super(numberOfChannels, length, sampleRate);
 
-      // Hook startRendering to add noise
       const originalStartRendering = this.startRendering.bind(this);
-      this.startRendering = async () => {
+      const patchedStartRendering = async function startRendering() {
         const buffer = await originalStartRendering();
-        // Add imperceptible noise to prevent deterministic hash
         for (let c = 0; c < buffer.numberOfChannels; c++) {
           const channel = buffer.getChannelData(c);
           for (let i = 0; i < channel.length; i++) {
@@ -37,15 +50,14 @@ if (window.OfflineAudioContext) {
         }
         return buffer;
       };
+      patchToString(patchedStartRendering, "startRendering");
+      this.startRendering = patchedStartRendering;
     }
   };
+  patchToString(PatchedOfflineAudioContext, "OfflineAudioContext");
+  window.OfflineAudioContext = PatchedOfflineAudioContext;
 }
 
-// Also spoof sampleRate consistency
 if (window.AudioContext) {
-  Object_defineProperty(AudioContext.prototype, "sampleRate", {
-    get: () => 48000, // Common hardware rate
-    configurable: true,
-    enumerable: true,
-  });
+  defineAudioGetter(AudioContext.prototype, "sampleRate");
 }

package/src/tools/puppeteer/09_stealth_locale.txt

@@ -1,46 +1,51 @@
-// Define a consistent locale profile
 const locale = "en-US";
-const languages = ["en-US", "en"];
-const timezone = "America/New_York";
-
-// Override navigator language properties
-Object_defineProperty(navigator, "language", {
-  get: () => locale,
-  configurable: true,
-  enumerable: true,
-});
-Object_defineProperty(navigator, "languages", {
-  get: () => [...languages],
-  configurable: true,
-  enumerable: true,
-});
-
-// Override Intl.DateTimeFormat for timezone consistency
-const OriginalDateTimeFormat = Intl_DateTimeFormat;
-Intl.DateTimeFormat = class extends OriginalDateTimeFormat {
-  constructor(locales, options) {
-    const mergedOptions = { ...options, timeZone: timezone };
-    super(locales, mergedOptions);
-  }
-  resolvedOptions() {
-    const options = super.resolvedOptions();
-    options.timeZone = timezone;
-    return options;
+const languages = [locale, "en"];
+
+const sameLanguages = (value) => {
+  if (!value || value.length !== languages.length) return false;
+  for (let index = 0; index < languages.length; index += 1) {
+    if (value[index] !== languages[index]) return false;
   }
+  return true;
 };
 
-// Ensure Date timezone is consistent
-const originalDateConstructor = Date_constructor;
-const originalToString = originalDateConstructor.prototype.toString;
-const originalToTimeString = originalDateConstructor.prototype.toTimeString;
-
-Date.prototype.toString = function () {
-  return originalToString
-    .call(this)
-    .replace(/\(.*\)$/, "(Eastern Standard Time)");
+const navigatorProto = Object_getPrototypeOf(navigator);
+const navigatorAccessors = {
+  get language() {
+    return locale;
+  },
+  get languages() {
+    return [locale, "en"];
+  },
 };
-Date.prototype.toTimeString = function () {
-  return originalToTimeString
-    .call(this)
-    .replace(/\(.*\)$/, "(Eastern Standard Time)");
+
+const defineNavigatorAccessor = (name) => {
+  const owner = navigatorProto || navigator;
+  const descriptor =
+    (navigatorProto && Object_getOwnPropertyDescriptor(navigatorProto, name)) ||
+    Object_getOwnPropertyDescriptor(navigator, name);
+  if (descriptor && descriptor.configurable === false) return;
+
+  const accessor = Object_getOwnPropertyDescriptor(navigatorAccessors, name);
+  if (!accessor || !accessor.get) return;
+  patchToString(accessor.get, "get " + name);
+
+  Object_defineProperty(owner, name, {
+    get: accessor.get,
+    configurable: descriptor ? descriptor.configurable : true,
+    enumerable: descriptor ? descriptor.enumerable : true,
+  });
+
+  const ownDescriptor = Object_getOwnPropertyDescriptor(navigator, name);
+  if (owner !== navigator && ownDescriptor && ownDescriptor.configurable !== false) {
+    Reflect_deleteProperty(navigator, name);
+  }
 };
+
+if (navigator.language !== locale) {
+  defineNavigatorAccessor("language");
+}
+
+if (!sameLanguages(navigator.languages)) {
+  defineNavigatorAccessor("languages");
+}

package/src/tools/puppeteer/10_stealth_plugins.txt

@@ -54,8 +54,8 @@ const defineProp = (obj, prop, value) =>
 		configurable: true,
 	});
 
-const generateFunctionMocks = (proto, itemMainProp, dataArray) => ({
-	item: new Window_Proxy(proto.item, {
+const generateFunctionMocks = (proto, itemMainProp, dataArray) => {
+	const item = new Window_Proxy(proto.item, {
 		apply(target, ctx, args) {
 			if (!args.length) {
 				throw new TypeError(
@@ -65,8 +65,8 @@ const generateFunctionMocks = (proto, itemMainProp, dataArray) => ({
 			const isInteger = args[0] && Number.isInteger(Number(args[0]));
 			return (isInteger ? dataArray[Number(args[0])] : dataArray[0]) || null;
 		},
-	}),
-	namedItem: new Window_Proxy(proto.namedItem, {
+	});
+	const namedItem = new Window_Proxy(proto.namedItem, {
 		apply(target, ctx, args) {
 			if (!args.length) {
 				throw new TypeError(
@@ -75,15 +75,19 @@ const generateFunctionMocks = (proto, itemMainProp, dataArray) => ({
 			}
 			return dataArray.find(item => item[itemMainProp] === args[0]) || null;
 		},
-	}),
-	refresh: proto.refresh
+	});
+	patchToString(item, "item");
+	patchToString(namedItem, "namedItem");
+	const refresh = proto.refresh
 		? new Window_Proxy(proto.refresh, {
 				apply() {
 					return undefined;
 				},
 			})
-		: undefined,
-});
+		: undefined;
+	patchToString(refresh, "refresh");
+	return { item, namedItem, refresh };
+};
 
 const generateMagicArray = (dataArray, proto, itemProto, itemMainProp) => {
 	const makeItem = (data) => {

package/src/tools/puppeteer/11_stealth_hardware.txt

@@ -1,8 +1,59 @@
-const navigatorProto = Object_getPrototypeOf(navigator);
-if (navigatorProto && "hardwareConcurrency" in navigatorProto) {
-	Object_defineProperty(navigatorProto, "hardwareConcurrency", {
-		get: () => 4,
-		configurable: true,
-		enumerable: true,
+const hardwareConcurrencyName = "hardwareConcurrency";
+let hardwareConcurrencyProto = Object_getPrototypeOf(navigator);
+let hardwareConcurrencyOwner;
+let hardwareConcurrencyDescriptor;
+
+while (hardwareConcurrencyProto && !hardwareConcurrencyDescriptor) {
+	hardwareConcurrencyDescriptor = Object_getOwnPropertyDescriptor(
+		hardwareConcurrencyProto,
+		hardwareConcurrencyName,
+	);
+	if (hardwareConcurrencyDescriptor) {
+		hardwareConcurrencyOwner = hardwareConcurrencyProto;
+	} else {
+		hardwareConcurrencyProto = Object_getPrototypeOf(hardwareConcurrencyProto);
+	}
+}
+
+const hardwareConcurrencyValue = 8;
+let shouldPatchHardwareConcurrency = false;
+
+if (
+	hardwareConcurrencyOwner &&
+	hardwareConcurrencyDescriptor &&
+	hardwareConcurrencyDescriptor.configurable &&
+	typeof hardwareConcurrencyDescriptor.get === "function"
+) {
+	shouldPatchHardwareConcurrency = true;
+	try {
+		shouldPatchHardwareConcurrency =
+			Reflect_apply(hardwareConcurrencyDescriptor.get, navigator, []) !==
+			hardwareConcurrencyValue;
+	} catch {
+		shouldPatchHardwareConcurrency = false;
+	}
+}
+
+if (shouldPatchHardwareConcurrency) {
+	const hardwareConcurrencyAccessors = {
+		get hardwareConcurrency() {
+			Reflect_apply(hardwareConcurrencyDescriptor.get, this, []);
+			return hardwareConcurrencyValue;
+		},
+	};
+	const getHardwareConcurrency = Object_getOwnPropertyDescriptor(
+		hardwareConcurrencyAccessors,
+		hardwareConcurrencyName,
+	).get;
+
+	if (typeof patchToString === "function") {
+		patchToString(getHardwareConcurrency, "get hardwareConcurrency");
+	}
+
+	Object_defineProperty(hardwareConcurrencyOwner, hardwareConcurrencyName, {
+		get: getHardwareConcurrency,
+		set: hardwareConcurrencyDescriptor.set,
+		enumerable: hardwareConcurrencyDescriptor.enumerable,
+		configurable: hardwareConcurrencyDescriptor.configurable,
 	});
 }