reverse-skills-max: initial public release (restored, redacted, hardened)

vendor-new/xbsReverseSkill/web-reverse-env/scripts/build-worker-module.js

@@ -0,0 +1,195 @@
+const { scaffoldModule } = require("./scaffold-module");
+
+function normalizeWorkerSeed(seed = {}) {
+  const workerSeed = seed.worker && typeof seed.worker === "object" ? seed.worker : seed;
+  return {
+    scriptBaseUrl: workerSeed.scriptBaseUrl || "https://example.invalid/assets/",
+    inlineScripts: Object.assign({}, workerSeed.inlineScripts || {}),
+    sharedWorkerName: workerSeed.sharedWorkerName || "env-shared-worker",
+    broadcastChannels: Array.isArray(workerSeed.broadcastChannels)
+      ? workerSeed.broadcastChannels.slice()
+      : ["env-sync"],
+  };
+}
+
+function renderWorkerPatch(seed) {
+  const serializedSeed = JSON.stringify(seed, null, 2);
+  return `(
+function installWorkerModule(globalObject) {
+  const seed = ${serializedSeed};
+  const protector = globalObject.__envNativeProtector || null;
+  const sharedChannels = Object.create(null);
+
+  function applyEventTarget(target) {
+    target._listeners = Object.create(null);
+    target.addEventListener = function addEventListener(type, listener) {
+      if (!this._listeners[type]) this._listeners[type] = [];
+      this._listeners[type].push(listener);
+    };
+    target.removeEventListener = function removeEventListener(type, listener) {
+      const list = this._listeners[type] || [];
+      this._listeners[type] = list.filter(function filterItem(item) {
+        return item !== listener;
+      });
+    };
+    target.dispatchEvent = function dispatchEvent(event) {
+      const list = (this._listeners[event.type] || []).slice();
+      for (const listener of list) listener.call(this, event);
+      const handler = this["on" + event.type];
+      if (typeof handler === "function") handler.call(this, event);
+      return true;
+    };
+  }
+
+  function createMessageEvent(data) {
+    return { type: "message", data: data };
+  }
+
+  function MessagePort() {
+    applyEventTarget(this);
+    this._entangledPort = null;
+    this._started = false;
+  }
+
+  MessagePort.prototype.postMessage = function postMessage(data) {
+    if (this._entangledPort) this._entangledPort.dispatchEvent(createMessageEvent(data));
+  };
+  MessagePort.prototype.start = function start() {
+    this._started = true;
+  };
+  MessagePort.prototype.close = function close() {
+    this._entangledPort = null;
+    this._started = false;
+  };
+
+  function createMessageChannel() {
+    const port1 = new MessagePort();
+    const port2 = new MessagePort();
+    port1._entangledPort = port2;
+    port2._entangledPort = port1;
+    return { port1: port1, port2: port2 };
+  }
+
+  function Worker(scriptUrl) {
+    applyEventTarget(this);
+    this.scriptURL = scriptUrl || "";
+    this.baseUrl = seed.scriptBaseUrl;
+    this.inlineSource = seed.inlineScripts[scriptUrl] || "";
+  }
+
+  Worker.prototype.postMessage = function postMessage(data) {
+    this.dispatchEvent(createMessageEvent(data));
+  };
+  Worker.prototype.terminate = function terminate() {
+    this._terminated = true;
+  };
+
+  function SharedWorker(scriptUrl, name) {
+    applyEventTarget(this);
+    this.scriptURL = scriptUrl || "";
+    this.name = name || seed.sharedWorkerName;
+    const channel = createMessageChannel();
+    this.port = channel.port1;
+    this._workerPort = channel.port2;
+  }
+
+  function BroadcastChannel(name) {
+    applyEventTarget(this);
+    this.name = name || "";
+    if (!sharedChannels[this.name]) sharedChannels[this.name] = [];
+    sharedChannels[this.name].push(this);
+  }
+
+  BroadcastChannel.prototype.postMessage = function postMessage(data) {
+    const peers = sharedChannels[this.name] || [];
+    for (const peer of peers) {
+      if (peer !== this) peer.dispatchEvent(createMessageEvent(data));
+    }
+  };
+  BroadcastChannel.prototype.close = function close() {
+    const peers = sharedChannels[this.name] || [];
+    sharedChannels[this.name] = peers.filter(function filterPeer(item) {
+      return item !== this;
+    }, this);
+  };
+
+  if (protector && protector.repairFunctionMeta) {
+    protector.repairFunctionMeta(MessagePort, { name: "MessagePort", length: 0 });
+    protector.repairFunctionMeta(Worker, { name: "Worker", length: 1 });
+    protector.repairFunctionMeta(SharedWorker, { name: "SharedWorker", length: 2 });
+    protector.repairFunctionMeta(BroadcastChannel, { name: "BroadcastChannel", length: 1 });
+  }
+  if (protector && protector.protectFunction) {
+    protector.protectFunction(MessagePort, "MessagePort");
+    protector.protectFunction(Worker, "Worker");
+    protector.protectFunction(SharedWorker, "SharedWorker");
+    protector.protectFunction(BroadcastChannel, "BroadcastChannel");
+  }
+
+  Object.defineProperty(globalObject, "MessagePort", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: MessagePort
+  });
+  Object.defineProperty(globalObject, "MessageChannel", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: function MessageChannel() {
+      return createMessageChannel();
+    }
+  });
+  Object.defineProperty(globalObject, "Worker", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: Worker
+  });
+  Object.defineProperty(globalObject, "SharedWorker", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: SharedWorker
+  });
+  Object.defineProperty(globalObject, "BroadcastChannel", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: BroadcastChannel
+  });
+
+  return { Worker: Worker, SharedWorker: SharedWorker, BroadcastChannel: BroadcastChannel };
+})(typeof globalThis !== "undefined" ? globalThis : window);
+`;
+}
+
+function buildWorkerModule(seed = {}) {
+  const module = scaffoldModule("worker-module");
+  const normalizedSeed = normalizeWorkerSeed(seed);
+
+  module.patchPlan = [
+    "补出 Worker/SharedWorker/MessagePort/MessageChannel/BroadcastChannel 构造器。",
+    "用最小事件系统模拟 postMessage/onmessage 通路。",
+    "把 worker 脚本路径、inline source、广播频道名称外置为种子，而不是写死在补丁里。",
+  ];
+  module.patchCode = renderWorkerPatch(normalizedSeed);
+  module.runtimeState = { worker: normalizedSeed };
+  module.validation = [
+    "检查 typeof Worker/SharedWorker/BroadcastChannel === 'function'。",
+    "执行 new Worker('/worker.js').postMessage({ping:1})，确认 message 事件能被触发。",
+    "执行 new SharedWorker('/shared.js').port.postMessage('x')，确认端口存在。",
+    "执行两个同名 BroadcastChannel 互发消息，确认消息广播通路正常。",
+  ];
+  module.residualRisk = [
+    "这里只模拟消息通路，不提供真实线程、importScripts、URL.createObjectURL 等完整能力。",
+    "若目标站点依赖 Worker 全局作用域、自定义事件循环或二进制消息通路，仍需继续扩展。",
+  ];
+
+  return module;
+}
+
+module.exports = {
+  buildWorkerModule,
+  normalizeWorkerSeed,
+};