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

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,
 	});
 }

package/src/tools/puppeteer/12_stealth_codecs.txt

@@ -15,25 +15,27 @@ const parseInput = (arg) => {
 };
 
 const originalCanPlayType = HTMLMediaElement.prototype.canPlayType;
+const proxiedCanPlayType = new Window_Proxy(originalCanPlayType, {
+	apply(target, ctx, args) {
+		if (!args || !args.length) {
+			return Reflect_apply(target, ctx, args);
+		}
+		const { mime, codecs } = parseInput(args[0]);
+		if (mime === "video/mp4" && codecs.includes("avc1.42E01E")) {
+			return "probably";
+		}
+		if (mime === "audio/x-m4a" && !codecs.length) {
+			return "maybe";
+		}
+		if (mime === "audio/aac" && !codecs.length) {
+			return "probably";
+		}
+		return Reflect_apply(target, ctx, args);
+	},
+});
+patchToString(proxiedCanPlayType, "canPlayType");
 Object_defineProperty(HTMLMediaElement.prototype, "canPlayType", {
-	value: new Window_Proxy(originalCanPlayType, {
-		apply(target, ctx, args) {
-			if (!args || !args.length) {
-				return Reflect_apply(target, ctx, args);
-			}
-			const { mime, codecs } = parseInput(args[0]);
-			if (mime === "video/mp4" && codecs.includes("avc1.42E01E")) {
-				return "probably";
-			}
-			if (mime === "audio/x-m4a" && !codecs.length) {
-				return "maybe";
-			}
-			if (mime === "audio/aac" && !codecs.length) {
-				return "probably";
-			}
-				return Reflect_apply(target, ctx, args);
-		},
-	}),
+	value: proxiedCanPlayType,
 	writable: true,
 	configurable: true,
 	enumerable: true,

package/src/tools/puppeteer/13_stealth_worker.txt

@@ -1,52 +1,214 @@
 const patchWorkerConstructor = (name, OriginalWorker) => {
 	if (typeof OriginalWorker !== "function") return;
 
-	const buildWrappedUrl = (scriptURL, options) => {
-		const ua = navigator.userAgent;
-		const platform = navigator.platform;
-		const uaData = navigator.userAgentData && typeof navigator.userAgentData.toJSON === "function"
-			? navigator.userAgentData.toJSON()
-			: navigator.userAgentData;
-
-		const preludeLines = [
-			"try {",
-			`const ua = ${JSON.stringify(ua)};`,
-			`const platform = ${JSON.stringify(platform)};`,
-			"Object_defineProperty(self.navigator, 'userAgent', { get: () => ua, configurable: true });",
-			"Object_defineProperty(self.navigator, 'platform', { get: () => platform, configurable: true });",
-		];
-
-		if (uaData) {
-			preludeLines.push(`const uaData = ${JSON.stringify(uaData)};`);
-			preludeLines.push(
-				"Object_defineProperty(self.navigator, 'userAgentData', { get: () => uaData, configurable: true });",
-			);
+	const windowDescriptor = Object_getOwnPropertyDescriptor(window, name);
+	if (windowDescriptor && windowDescriptor.configurable === false) return;
+
+	const NativeURL = window.URL;
+	const URL_createObjectURL = NativeURL && NativeURL.createObjectURL;
+	const URL_revokeObjectURL = NativeURL && NativeURL.revokeObjectURL;
+	if (
+		typeof NativeURL !== "function" ||
+		typeof URL_createObjectURL !== "function" ||
+		typeof URL_revokeObjectURL !== "function"
+	) {
+		return;
+	}
+
+	const sharedWorkerUrls = name === "SharedWorker" ? new Map() : undefined;
+
+	const revokeUrl = (url) => {
+		try {
+			Reflect_apply(URL_revokeObjectURL, NativeURL, [url]);
+		} catch {}
+	};
+
+	const scheduleWorkerUrlRevoke = (worker, url) => {
+		let revoked = false;
+		const revokeOnce = () => {
+			if (revoked) return;
+			revoked = true;
+			revokeUrl(url);
+		};
+		try {
+			if (typeof worker.addEventListener === "function") {
+				Reflect_apply(worker.addEventListener, worker, ["error", revokeOnce, { once: true }]);
+			}
+		} catch {}
+		Window_setTimeout(revokeOnce, 1000);
+	};
+
+	if (sharedWorkerUrls) {
+		try {
+			window.addEventListener("pagehide", (event) => {
+				if (event && event.persisted) return;
+				for (const url of sharedWorkerUrls.values()) {
+					revokeUrl(url);
+				}
+				sharedWorkerUrls.clear();
+			});
+		} catch {}
+	}
+
+	const canWrapArguments = (args) => {
+		if (!args || args.length !== 1) {
+			return name === "SharedWorker" && args && args.length === 2 && typeof args[1] === "string";
+		}
+		return true;
+	};
+
+	const resolveWorkerUrl = (scriptURL) => {
+		const baseUrl = document.baseURI || window.location.href;
+		const scriptUrlString =
+			typeof scriptURL === "string"
+				? scriptURL
+				: scriptURL instanceof NativeURL
+					? scriptURL.href
+					: undefined;
+		if (scriptUrlString === undefined) return undefined;
+		let absoluteUrl;
+		try {
+			absoluteUrl = new NativeURL(scriptUrlString, baseUrl);
+		} catch {
+			return undefined;
+		}
+		if (absoluteUrl.origin !== window.location.origin) return undefined;
+		if (absoluteUrl.protocol !== "http:" && absoluteUrl.protocol !== "https:") return undefined;
+		if (absoluteUrl.username || absoluteUrl.password) return undefined;
+		return absoluteUrl.href;
+	};
+
+	const buildWorkerPrelude = () => {
+		const values = [];
+		const addNavigatorString = (prop) => {
+			try {
+				const value = navigator[prop];
+				if (typeof value === "string") values.push([prop, value]);
+			} catch {}
+		};
+		addNavigatorString("userAgent");
+		addNavigatorString("platform");
+		if (!values.length) return "";
+
+		return `(() => {
+	try {
+		const values = ${JSON.stringify(values)};
+		const nav = self.navigator;
+		if (!nav) return;
+		const defineProperty = Object.defineProperty;
+		const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+		const getPrototypeOf = Object.getPrototypeOf;
+		const Reflect_apply = Reflect.apply;
+		const nativeFunctionToString = Function.prototype.toString;
+		const nativeSources = new WeakMap();
+		const WeakMap_get = WeakMap.prototype.get;
+		const WeakMap_has = WeakMap.prototype.has;
+		const WeakMap_set = WeakMap.prototype.set;
+		const rememberNative = (fn, source) => {
+			if (typeof fn === "function") Reflect_apply(WeakMap_set, nativeSources, [fn, source]);
+			return fn;
+		};
+		const findDescriptor = (prop) => {
+			let owner = nav;
+			while (owner) {
+				const descriptor = getOwnPropertyDescriptor(owner, prop);
+				if (descriptor) return [owner, descriptor];
+				owner = getPrototypeOf(owner);
+			}
+			return [getPrototypeOf(nav) || nav, undefined];
+		};
+		let patched = false;
+		for (let i = 0; i < values.length; i += 1) {
+			const prop = values[i][0];
+			const value = values[i][1];
+			try {
+				if (nav[prop] === value) continue;
+			} catch (_) {}
+			const found = findDescriptor(prop);
+			const owner = found[0];
+			const descriptor = found[1];
+			if (!owner || (descriptor && descriptor.configurable === false)) continue;
+			const getterDescriptor = getOwnPropertyDescriptor({ get [prop]() { return value; } }, prop);
+			const getter = getterDescriptor && getterDescriptor.get;
+			if (typeof getter !== "function") continue;
+			rememberNative(getter, "function get " + prop + "() { [native code] }");
+			defineProperty(owner, prop, {
+				get: getter,
+				enumerable: descriptor ? descriptor.enumerable : true,
+				configurable: true,
+			});
+			patched = true;
 		}
+		if (!patched) return;
+		const toStringDescriptor = getOwnPropertyDescriptor(Function.prototype, "toString");
+		if (toStringDescriptor && toStringDescriptor.configurable === false) return;
+		const functionToString = new Proxy(nativeFunctionToString, {
+			apply(target, thisArg, args) {
+				if (Reflect_apply(WeakMap_has, nativeSources, [thisArg])) return Reflect_apply(WeakMap_get, nativeSources, [thisArg]);
+				return Reflect_apply(target, thisArg, args);
+			},
+		});
+		rememberNative(functionToString, "function toString() { [native code] }");
+		defineProperty(Function.prototype, "toString", {
+			value: functionToString,
+			writable: toStringDescriptor ? toStringDescriptor.writable : true,
+			configurable: toStringDescriptor ? toStringDescriptor.configurable : true,
+			enumerable: toStringDescriptor ? toStringDescriptor.enumerable : false,
+		});
+	} catch (_) {}
+})();`;
+	};
 
-		preludeLines.push("} catch (e) {};");
-		const prelude = preludeLines.join("\n");
-		const importLine = options?.type === "module"
-			? `import ${JSON.stringify(String(scriptURL))};`
-			: `importScripts(${JSON.stringify(String(scriptURL))});`;
-		const blob = new Window_Blob([prelude, "\n", importLine], { type: "application/javascript" });
-		const url = URL.createObjectURL(blob);
-		return url;
+	const buildWrappedUrl = (scriptURL) => {
+		const originalUrl = resolveWorkerUrl(scriptURL);
+		if (!originalUrl) return undefined;
+		if (sharedWorkerUrls) {
+			const cachedUrl = sharedWorkerUrls.get(originalUrl);
+			if (cachedUrl) return { url: cachedUrl, cacheKey: originalUrl };
+		}
+
+		const prelude = buildWorkerPrelude();
+		if (!prelude) return undefined;
+
+		try {
+			const blob = new Window_Blob(
+				[prelude, "\n", `importScripts(${JSON.stringify(originalUrl)});`],
+				{ type: "application/javascript" },
+			);
+			const url = Reflect_apply(URL_createObjectURL, NativeURL, [blob]);
+			if (sharedWorkerUrls) sharedWorkerUrls.set(originalUrl, url);
+			return { url, cacheKey: sharedWorkerUrls ? originalUrl : undefined };
+		} catch {
+			return undefined;
+		}
 	};
 
 	const handler = {
-		construct(target, args) {
+		construct(target, args, newTarget) {
+			if (!canWrapArguments(args)) {
+				return Reflect_construct(target, args || [], newTarget);
+			}
+
+			const wrapped = buildWrappedUrl(args[0]);
+			if (!wrapped) {
+				return Reflect_construct(target, args || [], newTarget);
+			}
+
+			const wrappedArgs = [wrapped.url];
+			for (let i = 1; i < args.length; i += 1) {
+				wrappedArgs[i] = args[i];
+			}
+
 			try {
-				const scriptURL = args?.[0];
-				const options = args?.[1];
-				if (!scriptURL) {
-					return new target(...(args || []));
+				const worker = Reflect_construct(target, wrappedArgs, newTarget);
+				if (!sharedWorkerUrls) {
+					scheduleWorkerUrlRevoke(worker, wrapped.url);
 				}
-				const wrappedUrl = buildWrappedUrl(scriptURL, options);
-				const worker = new target(wrappedUrl, options);
-				URL.revokeObjectURL(wrappedUrl);
 				return worker;
 			} catch {
-				return new target(...(args || []));
+				if (wrapped.cacheKey && sharedWorkerUrls) sharedWorkerUrls.delete(wrapped.cacheKey);
+				revokeUrl(wrapped.url);
+				return Reflect_construct(target, args || [], newTarget);
 			}
 		},
 		apply(target, thisArg, args) {
@@ -55,16 +217,15 @@ const patchWorkerConstructor = (name, OriginalWorker) => {
 	};
 
 	const proxied = new Window_Proxy(OriginalWorker, handler);
+	patchToString(proxied, name);
 	Object_defineProperty(window, name, {
 		value: proxied,
-		writable: true,
-		configurable: true,
-	});
-	Object_defineProperty(window[name], "toString", {
-		value: Function_toString.bind(OriginalWorker),
-		writable: false,
-		configurable: true,
-		enumerable: false,
+		writable:
+			windowDescriptor && "writable" in windowDescriptor
+				? windowDescriptor.writable
+				: true,
+		configurable: windowDescriptor ? windowDescriptor.configurable : true,
+		enumerable: windowDescriptor ? windowDescriptor.enumerable : false,
 	});
 };