From 25ba263c7098fbb69fba4ac99349b21277ac63b6 Mon Sep 17 00:00:00 2001
From: cyfung1031 <44498510+cyfung1031@users.noreply.github.com>
Date: Mon, 1 Jun 2026 11:23:04 +0900
Subject: [PATCH 1/5] =?UTF-8?q?[Feature]=20ScriptCat=20=E5=BA=94=E8=83=BD?=
 =?UTF-8?q?=E6=B3=A8=E5=85=A5=20`<script=20type=3D"module">`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/app/service/content/utils.ts        |  4 ++++
 src/app/service/service_worker/utils.ts | 14 ++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/src/app/service/content/utils.ts b/src/app/service/content/utils.ts
index bc7905a0b..cb78ab1ec 100644
--- a/src/app/service/content/utils.ts
+++ b/src/app/service/content/utils.ts
@@ -281,6 +281,10 @@ export function isScriptletUnwrap(metadata: SCMetadata): boolean {
   return metadataBlankOrTrue(metadata, "unwrap");
 }
 
+export function isScriptModule(metadata: SCMetadata): boolean {
+  return metadataBlankOrTrue(metadata, "script-module") && !isInjectIntoContent(metadata);
+}
+
 export function isInjectIntoContent(metadata: SCMetadata): boolean {
   return metadata["inject-into"]?.[0] === "content";
 }
diff --git a/src/app/service/service_worker/utils.ts b/src/app/service/service_worker/utils.ts
index 2f141befb..0f3596ac1 100644
--- a/src/app/service/service_worker/utils.ts
+++ b/src/app/service/service_worker/utils.ts
@@ -11,6 +11,7 @@ import {
   isEarlyStartScript,
   isInjectIntoContent,
   isScriptletUnwrap,
+  isScriptModule,
 } from "../content/utils";
 import {
   extractUrlPatterns,
@@ -195,6 +196,19 @@ export function compileInjectionCode(
   if (isScriptletUnwrap(scriptRes.metadata)) {
     scriptInjectCode = compileScriptletCode(scriptRes, scriptCode, scriptUrlPatterns);
   } else {
+    if (isScriptModule(scriptRes.metadata)) {
+      const wId = `__${Date.now().toString(36)}_${(Math.random() + 1).toString(36).substring(2)}`;
+      const st = JSON.stringify(
+        `const {GM, top, parent, window, unsafeWindow, globalThis} = document.${wId}; delete document.${wId};\n${scriptCode}`
+      );
+      const p = (c: string) => {
+        const jsScript = document.createElement("script");
+        jsScript.type = "module";
+        jsScript.textContent = c;
+        (document.body || document.head || document.documentElement).appendChild(jsScript);
+      };
+      scriptCode = `document.${wId} = {GM, top, parent, window, globalThis: window, unsafeWindow: typeof unsafeWindow !== "undefined" ? unsafeWindow : undefined};(${p})(${st});`;
+    }
     scriptCode = compileScriptCode(scriptRes, scriptCode);
     if (isEarlyStartScript(scriptRes.metadata)) {
       scriptInjectCode = compilePreInjectScript(parseScriptLoadInfo(scriptRes, scriptUrlPatterns), scriptCode);

From 67f31668da19742bceceb3579e3a4da9c4ac8675 Mon Sep 17 00:00:00 2001
From: cyfung1031 <44498510+cyfung1031@users.noreply.github.com>
Date: Fri, 17 Jul 2026 21:46:38 +0900
Subject: [PATCH 2/5] =?UTF-8?q?test:=20=E8=A1=A5=E5=85=85=20@script-module?=
 =?UTF-8?q?=20=E5=8A=9F=E8=83=BD=E7=9A=84=20vitest=20=E4=B8=8E=20e2e=20?=
 =?UTF-8?q?=E6=B5=8B=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

单元测试覆盖 isScriptModule 判断逻辑（含与 @inject-into content 互斥）
及 compileInjectionCode 对 script-module 脚本的编译路径（含 early-start
组合场景）；新增 e2e 用例通过实际浏览器验证注入的确是真正的
<script type="module">（顶层 this 为 undefined、document.currentScript
为 null、顶层声明不挂载到 window），且 GM.* API 与既有沙盒 window/
unsafeWindow 语义保持一致。

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 e2e/gm-api.spec.ts                           | 21 ++++-
 example/tests/script_module_e2e_test.js      | 82 ++++++++++++++++++++
 src/app/service/content/utils.test.ts        | 27 +++++++
 src/app/service/service_worker/utils.test.ts | 60 ++++++++++++++
 4 files changed, 189 insertions(+), 1 deletion(-)
 create mode 100644 example/tests/script_module_e2e_test.js

diff --git a/e2e/gm-api.spec.ts b/e2e/gm-api.spec.ts
index 9e30f5ddc..a017a5194 100644
--- a/e2e/gm-api.spec.ts
+++ b/e2e/gm-api.spec.ts
@@ -212,7 +212,7 @@ function patchTargetMatchCode(code: string, targetUrl: string): string {
   const url = new URL(targetUrl);
   const targetPattern = `${url.protocol}//${url.hostname}/*${url.search}`;
   return code.replace(
-    /^\/\/\s*@match\s+.*\?(gm_api_sync|gm_api_async|inject_content|WINDOW_MESSAGE_TEST_SC|SANDBOX_TEST_SC|unwrap_e2e_test)$/gm,
+    /^\/\/\s*@match\s+.*\?(gm_api_sync|gm_api_async|inject_content|WINDOW_MESSAGE_TEST_SC|SANDBOX_TEST_SC|unwrap_e2e_test|script_module_e2e_test)$/gm,
     `// @match        ${targetPattern}`
   );
 }
@@ -375,6 +375,25 @@ test.describe("GM API", () => {
     expect(passed, "No test results found - script may not have run").toBeGreaterThan(0);
   });
 
+  test("@script-module tests (script_module_e2e_test.js)", async ({ context, extensionId }) => {
+    // @script-module 以 <script type="module"> 直接注入页面 DOM，会受页面自身 CSP 限制
+    // （见 PR 描述的限制3），因此使用无 CSP 头的普通 mock 站点，而非 cspOrigin。
+    const { passed, failed, logs } = await runTestScript(
+      context,
+      extensionId,
+      "script_module_e2e_test.js",
+      `${gmApiMockServer.origin}/?script_module_e2e_test`,
+      60_000
+    );
+
+    console.log(`[script_module_e2e_test] passed=${passed}, failed=${failed}`);
+    if (failed !== 0) {
+      console.log("[script_module_e2e_test] logs:", logs.join("\n"));
+    }
+    expect(failed, "Some @script-module tests failed").toBe(0);
+    expect(passed, "No test results found - script may not have run").toBeGreaterThan(0);
+  });
+
   test("WindowMessage Transport Test (window_message_test.js)", async ({ context, extensionId }) => {
     const { passed, failed, logs } = await runTestScript(
       context,
diff --git a/example/tests/script_module_e2e_test.js b/example/tests/script_module_e2e_test.js
new file mode 100644
index 000000000..9bf17ae38
--- /dev/null
+++ b/example/tests/script_module_e2e_test.js
@@ -0,0 +1,82 @@
+// ==UserScript==
+// @name         @script-module E2E Test
+// @namespace    https://docs.scriptcat.org/
+// @version      1.0.0
+// @description  E2E 测试 @script-module 功能（以 <script type="module"> 注入）
+// @author       ScriptCat
+// @match        https://content-security-policy.com/?script_module_e2e_test
+// @grant        GM.getValue
+// @grant        GM.setValue
+// @script-module
+// ==/UserScript==
+
+// module 顶层的 this 应为 undefined（普通 <script> 顶层 this 为 window），
+// 必须在模块顶层（而非函数内）读取才能反映真实的执行上下文
+const __sc_module_top_level_this_is_undefined = typeof this === "undefined";
+
+// module 顶层的 const 声明不会挂载到 window 上（与普通注入脚本的顶层 var 不同）
+const __sc_module_e2e_marker = true;
+
+(async function () {
+  "use strict";
+
+  console.log("%c=== @script-module E2E 测试开始 ===", "color: blue; font-size: 16px; font-weight: bold;");
+
+  let testResults = {
+    passed: 0,
+    failed: 0,
+    total: 0,
+  };
+
+  async function test(name, fn) {
+    testResults.total++;
+    try {
+      await fn();
+      testResults.passed++;
+      console.log("%c✓ " + name, "color: green;");
+      return true;
+    } catch (error) {
+      testResults.failed++;
+      console.error("%c✗ " + name, "color: red;", error);
+      return false;
+    }
+  }
+
+  function assert(expected, actual, message) {
+    if (expected !== actual) {
+      const valueInfo = "期望 " + JSON.stringify(expected) + ", 实际 " + JSON.stringify(actual);
+      const error = message ? message + " - " + valueInfo : "断言失败: " + valueInfo;
+      throw new Error(error);
+    }
+  }
+
+  await test("module 顶层 this 为 undefined", async () => {
+    assert(true, __sc_module_top_level_this_is_undefined, "module 顶层 this 应为 undefined");
+  });
+
+  await test("document.currentScript 在 module 内为 null", async () => {
+    assert(null, document.currentScript, "module 脚本的 document.currentScript 应为 null");
+  });
+
+  await test("module 顶层声明不会挂载到 window", async () => {
+    assert("undefined", typeof window.__sc_module_e2e_marker, "module 顶层变量不应出现在 window 上");
+  });
+
+  // 与其他 GM 脚本一致：window 为沙盒 window（与页面隔离），unsafeWindow 才是真实页面 window
+  // 参见 window_message_test.js 中同样的约定
+  await test("window 为沙盒 window，与 unsafeWindow（真实页面 window）不同", async () => {
+    assert(true, window !== unsafeWindow, "window 不应等于 unsafeWindow");
+    assert(document, unsafeWindow.document, "unsafeWindow.document 应等于真实 document");
+  });
+
+  await test("GM.setValue / GM.getValue 正常工作", async () => {
+    await GM.setValue("script_module_e2e_key", "script_module_e2e_value");
+    const v = await GM.getValue("script_module_e2e_key");
+    assert("script_module_e2e_value", v, "GM.getValue 应读取到刚写入的值");
+  });
+
+  console.log("\n%c=== 测试结果总结 ===", "color: blue; font-size: 16px; font-weight: bold;");
+  console.log("总测试数: " + testResults.total);
+  console.log("%c通过: " + testResults.passed, "color: green; font-weight: bold;");
+  console.log("%c失败: " + testResults.failed, "color: red; font-weight: bold;");
+})();
diff --git a/src/app/service/content/utils.test.ts b/src/app/service/content/utils.test.ts
index e4bf62ed9..13b4973b4 100644
--- a/src/app/service/content/utils.test.ts
+++ b/src/app/service/content/utils.test.ts
@@ -5,6 +5,7 @@ import {
   compileInjectScript,
   compileScriptletCode,
   isScriptletUnwrap,
+  isScriptModule,
   addStyle,
   addStyleSheet,
 } from "./utils";
@@ -563,6 +564,32 @@ describe("utils", () => {
     });
   });
 
+  describe.concurrent("isScriptModule", () => {
+    it.concurrent("@script-module 为空值时返回 true", () => {
+      expect(isScriptModule({ "script-module": [""] })).toBe(true);
+    });
+
+    it.concurrent("@script-module 为 true 时返回 true", () => {
+      expect(isScriptModule({ "script-module": ["true"] })).toBe(true);
+    });
+
+    it.concurrent("没有 @script-module 时返回 false", () => {
+      expect(isScriptModule({})).toBe(false);
+    });
+
+    it.concurrent("@script-module 为 false 时返回 false", () => {
+      expect(isScriptModule({ "script-module": ["false"] })).toBe(false);
+    });
+
+    it.concurrent("@script-module 与 @inject-into content 同时存在时返回 false", () => {
+      expect(isScriptModule({ "script-module": [""], "inject-into": ["content"] })).toBe(false);
+    });
+
+    it.concurrent("@script-module 与 @inject-into page 同时存在时返回 true", () => {
+      expect(isScriptModule({ "script-module": [""], "inject-into": ["page"] })).toBe(true);
+    });
+  });
+
   describe.concurrent("compileScriptletCode", () => {
     const createMockScriptRes = (
       overrides: Partial<ScriptRunResource> = {},
diff --git a/src/app/service/service_worker/utils.test.ts b/src/app/service/service_worker/utils.test.ts
index 5f935d6e6..b6508fd5d 100644
--- a/src/app/service/service_worker/utils.test.ts
+++ b/src/app/service/service_worker/utils.test.ts
@@ -348,4 +348,64 @@ describe.concurrent("compileInjectionCode", () => {
     // 使用 compileInjectScript 包裹（window[flag] = function(){...}）
     expect(result).toContain("window['#-test-uuid']");
   });
+
+  it.concurrent("script-module 脚本注入 <script type=module> 并透过 document 暴露沙盒变量", () => {
+    const scriptRes = createMockScriptRes({
+      metadata: { "script-module": [""] },
+    });
+    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
+    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
+
+    // 仍然走普通编译路径的沙箱封装（module 包装是在沙箱之内注入）
+    expect(result).toContain("with(arguments[0]||this.$)");
+    expect(result).toContain("return(async function(){");
+    expect(result).toContain("window['#-test-uuid']");
+
+    // 生成 <script type="module"> 并挂载到 document
+    expect(result).toContain('jsScript.type = "module"');
+    expect(result).toContain('document.createElement("script")');
+    expect(result).toMatch(
+      /\(document\.body \|\| document\.head \|\| document\.documentElement\)\.appendChild\(jsScript\)/
+    );
+
+    // 通过临时 document 属性传递沙盒变量给 module script，并在读取后删除
+    expect(result).toMatch(
+      /document\.__[a-z0-9]+_[a-z0-9]+\s*=\s*\{GM, top, parent, window, globalThis: window, unsafeWindow:/
+    );
+    expect(result).toMatch(
+      /const \{GM, top, parent, window, unsafeWindow, globalThis\} = document\.__[a-z0-9]+_[a-z0-9]+; delete document\.__[a-z0-9]+_[a-z0-9]+;/
+    );
+
+    // 原始脚本代码被内嵌到注入的 module 字符串中
+    expect(result).toContain(scriptRes.code);
+  });
+
+  it.concurrent("script-module 与 inject-into content 同时存在时不生效", () => {
+    const scriptRes = createMockScriptRes({
+      metadata: { "script-module": [""], "inject-into": ["content"] },
+    });
+    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
+    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
+
+    // 不生成 module script 包装
+    expect(result).not.toContain('jsScript.type = "module"');
+    expect(result).not.toContain('document.createElement("script")');
+    // 仍走普通编译路径
+    expect(result).toContain("with(arguments[0]||this.$)");
+    expect(result).toContain("window['#-test-uuid']");
+  });
+
+  it.concurrent("script-module 脚本搭配 early-start 时走预注入编译路径", () => {
+    const scriptRes = createMockScriptRes({
+      metadata: { "script-module": [""], "early-start": [""], "run-at": ["document-start"] },
+    });
+    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
+    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
+
+    // early-start 编译路径特征：window[flag] = function(){...} 且带 performance 事件派发
+    expect(result).toContain("window['#-test-uuid'] = function(){");
+    expect(result).toContain("performance.dispatchEvent");
+    // module script 包装仍然生效
+    expect(result).toContain('jsScript.type = "module"');
+  });
 });

From e2202d056228f73065da7e69ddb0d2499ef64b1f Mon Sep 17 00:00:00 2001
From: cyfung1031 <44498510+cyfung1031@users.noreply.github.com>
Date: Fri, 17 Jul 2026 21:55:08 +0900
Subject: [PATCH 3/5] =?UTF-8?q?test:=20e2e=20=E8=A1=A5=E5=85=85=E9=AA=8C?=
 =?UTF-8?q?=E8=AF=81=20@script-module=20=E8=84=9A=E6=9C=AC=E5=86=85?=
 =?UTF-8?q?=E7=9C=9F=E6=AD=A3=E7=9A=84=20ES=20module=20import=20=E8=A1=8C?=
 =?UTF-8?q?=E4=B8=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

新增 mock server 路由 /module-lib.js 提供一个真实的可 export 模块；
script_module_e2e_test.js 在脚本顶层用静态 `import { addNumbers,
MODULE_LIB_MARKER } from "/module-lib.js"` 引入并调用/校验其值。
普通（非 module）<script> 遇到 import 语句会直接抛出 SyntaxError 导致
整份脚本无法执行，因此该用例能确认注入的确是可被浏览器当作 ES module
解析执行的 <script type="module">，而不只是语法特征匹配。

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 e2e/gm-api.spec.ts                      | 10 ++++++++++
 example/tests/script_module_e2e_test.js |  9 +++++++++
 2 files changed, 19 insertions(+)

diff --git a/e2e/gm-api.spec.ts b/e2e/gm-api.spec.ts
index a017a5194..ddde20a68 100644
--- a/e2e/gm-api.spec.ts
+++ b/e2e/gm-api.spec.ts
@@ -154,6 +154,16 @@ async function startGMApiMockServer(): Promise<GMApiMockServer> {
       return;
     }
 
+    if (url.pathname === "/module-lib.js") {
+      // 供 script_module_e2e_test.js 静态 `import ... from` 使用，验证注入的确是可被浏览器
+      // 当作 ES module 解析执行的 <script type="module">（普通 script 遇到 import 会直接语法报错）
+      res.writeHead(200, { "Content-Type": "text/javascript; charset=utf-8" });
+      res.end(
+        'export function addNumbers(a, b) { return a + b; }\nexport const MODULE_LIB_MARKER = "script-module-e2e-import-ok";\n'
+      );
+      return;
+    }
+
     const bytesMatch = url.pathname.match(/^\/bytes\/(\d+)$/);
     if (bytesMatch) {
       const size = Number(bytesMatch[1]);
diff --git a/example/tests/script_module_e2e_test.js b/example/tests/script_module_e2e_test.js
index 9bf17ae38..501fd0a01 100644
--- a/example/tests/script_module_e2e_test.js
+++ b/example/tests/script_module_e2e_test.js
@@ -10,6 +10,10 @@
 // @script-module
 // ==/UserScript==
 
+// 真正的 ES module 才能使用静态 `import ... from`；普通 <script>（非 module）遇到此语法
+// 会直接抛出 SyntaxError，导致整份脚本都无法执行。以此验证注入的确是 <script type="module">
+import { addNumbers, MODULE_LIB_MARKER } from "/module-lib.js";
+
 // module 顶层的 this 应为 undefined（普通 <script> 顶层 this 为 window），
 // 必须在模块顶层（而非函数内）读取才能反映真实的执行上下文
 const __sc_module_top_level_this_is_undefined = typeof this === "undefined";
@@ -69,6 +73,11 @@ const __sc_module_e2e_marker = true;
     assert(document, unsafeWindow.document, "unsafeWindow.document 应等于真实 document");
   });
 
+  await test("静态 import 的模块（/module-lib.js）被正确加载并可用", async () => {
+    assert("script-module-e2e-import-ok", MODULE_LIB_MARKER, "导入的常量值应与 module-lib.js 导出的一致");
+    assert(7, addNumbers(3, 4), "导入的函数应可正常调用");
+  });
+
   await test("GM.setValue / GM.getValue 正常工作", async () => {
     await GM.setValue("script_module_e2e_key", "script_module_e2e_value");
     const v = await GM.getValue("script_module_e2e_key");

From a9eaabbf5823bc2455e8adb1f5432790ea466968 Mon Sep 17 00:00:00 2001
From: cyfung1031 <44498510+cyfung1031@users.noreply.github.com>
Date: Fri, 17 Jul 2026 23:24:54 +0900
Subject: [PATCH 4/5] =?UTF-8?q?=F0=9F=90=9B=20=E4=BF=AE=E5=A4=8D=20@script?=
 =?UTF-8?q?-module=20=E6=9D=83=E9=99=90=E5=AF=B9=E8=B1=A1=E6=9A=B4?=
 =?UTF-8?q?=E9=9C=B2=E4=B8=8E=E7=BC=93=E5=AD=98=E6=81=A2=E5=A4=8D=E8=B7=AF?=
 =?UTF-8?q?=E5=BE=84=E7=BC=BA=E5=A4=B1=20module=20=E5=8C=85=E8=A3=85?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

review 指出 @script-module 曾把 GM/window/unsafeWindow 等经由页面共享的
document.<随机属性> 传给注入的 <script type="module">，页面可 hook
document.createElement/appendChild 在临时属性被删除前窃取具备权限的 GM
对象。在浏览器能力支持 module 复用沙盒 Proxy 之前，改为：

- isScriptModule() 在代码层面强制要求 @grant none，并排除 @require（module
  无法访问外层 classic-script 的词法变量）与 early-start（GM_info 的
  isIncognito/sandboxMode/userAgentData 可能尚未补齐，且无法像沙盒 Proxy
  那样以同一对象引用事后回填），而不仅在文档中说明限制。
- wrapScriptModuleCode() 不再写入 document/window 等页面共享对象，仅把
  序列化后的 GM.info（纯 JSON 数据，无 GM_* 权限方法）内嵌进 module 源码，
  并为 import 解析失败/被页面 CSP 拦截等场景挂上可观测的 error 处理。
- restoreJSCodeFromCompiledResource() 补上同一层 module 包装：此前扩展重启
  或重新注册脚本后，走缓存恢复路径会退回 classic-script 编译，静态
  import/export 随之失效。

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 example/tests/script_module_e2e_test.js       | 26 +++---
 src/app/service/content/utils.test.ts         | 82 +++++++++++++++++--
 src/app/service/content/utils.ts              | 40 ++++++++-
 .../service/service_worker/runtime.test.ts    | 68 +++++++++++++++
 src/app/service/service_worker/runtime.ts     |  9 +-
 src/app/service/service_worker/utils.test.ts  | 50 +++++++----
 src/app/service/service_worker/utils.ts       | 13 +--
 7 files changed, 242 insertions(+), 46 deletions(-)

diff --git a/example/tests/script_module_e2e_test.js b/example/tests/script_module_e2e_test.js
index 501fd0a01..909f275e9 100644
--- a/example/tests/script_module_e2e_test.js
+++ b/example/tests/script_module_e2e_test.js
@@ -5,11 +5,15 @@
 // @description  E2E 测试 @script-module 功能（以 <script type="module"> 注入）
 // @author       ScriptCat
 // @match        https://content-security-policy.com/?script_module_e2e_test
-// @grant        GM.getValue
-// @grant        GM.setValue
+// @grant        none
 // @script-module
 // ==/UserScript==
 
+// 首版限制：@script-module 强制要求 @grant none。module 无法复用外层 with(arguments[0])
+// 沙盒 Proxy，若允许真实 GM_* 权限方法随之注入，页面 hook document.createElement/appendChild
+// 即可在临时挂载点被删除前窃取具备权限的 GM 对象。因此 GM.getValue / GM.setValue 等在
+// @script-module 下不可用，GM 只暴露一份序列化后的 GM.info（纯数据，无权限方法）。
+
 // 真正的 ES module 才能使用静态 `import ... from`；普通 <script>（非 module）遇到此语法
 // 会直接抛出 SyntaxError，导致整份脚本都无法执行。以此验证注入的确是 <script type="module">
 import { addNumbers, MODULE_LIB_MARKER } from "/module-lib.js";
@@ -66,11 +70,10 @@ const __sc_module_e2e_marker = true;
     assert("undefined", typeof window.__sc_module_e2e_marker, "module 顶层变量不应出现在 window 上");
   });
 
-  // 与其他 GM 脚本一致：window 为沙盒 window（与页面隔离），unsafeWindow 才是真实页面 window
-  // 参见 window_message_test.js 中同样的约定
-  await test("window 为沙盒 window，与 unsafeWindow（真实页面 window）不同", async () => {
-    assert(true, window !== unsafeWindow, "window 不应等于 unsafeWindow");
-    assert(document, unsafeWindow.document, "unsafeWindow.document 应等于真实 document");
+  // @script-module 强制 @grant none：module 与真实页面运行在同一全局对象上，
+  // 不像其他有权限的脚本那样存在沙盒 window，因此 window 与 unsafeWindow 应指向同一个对象
+  await test("@grant none 下 window 与 unsafeWindow 为同一对象（无沙盒隔离）", async () => {
+    assert(true, typeof unsafeWindow === "undefined" || unsafeWindow === window, "不应存在独立的沙盒 window");
   });
 
   await test("静态 import 的模块（/module-lib.js）被正确加载并可用", async () => {
@@ -78,10 +81,11 @@ const __sc_module_e2e_marker = true;
     assert(7, addNumbers(3, 4), "导入的函数应可正常调用");
   });
 
-  await test("GM.setValue / GM.getValue 正常工作", async () => {
-    await GM.setValue("script_module_e2e_key", "script_module_e2e_value");
-    const v = await GM.getValue("script_module_e2e_key");
-    assert("script_module_e2e_value", v, "GM.getValue 应读取到刚写入的值");
+  await test("@grant none 下 module 只能拿到 GM.info（无权限方法），验证 GM 权限对象不会暴露给 module", async () => {
+    assert("object", typeof GM.info, "GM.info 应为对象");
+    assert("undefined", typeof GM.getValue, "GM.getValue 不应存在——@script-module 强制 @grant none");
+    assert("undefined", typeof GM.setValue, "GM.setValue 不应存在——@script-module 强制 @grant none");
+    assert("undefined", typeof GM_getValue, "全局 GM_getValue 不应存在——module 不应拿到任何 GM_* 权限方法");
   });
 
   console.log("\n%c=== 测试结果总结 ===", "color: blue; font-size: 16px; font-weight: bold;");
diff --git a/src/app/service/content/utils.test.ts b/src/app/service/content/utils.test.ts
index 13b4973b4..f632854b8 100644
--- a/src/app/service/content/utils.test.ts
+++ b/src/app/service/content/utils.test.ts
@@ -6,6 +6,8 @@ import {
   compileScriptletCode,
   isScriptletUnwrap,
   isScriptModule,
+  isGrantNone,
+  wrapScriptModuleCode,
   addStyle,
   addStyleSheet,
 } from "./utils";
@@ -565,28 +567,92 @@ describe("utils", () => {
   });
 
   describe.concurrent("isScriptModule", () => {
-    it.concurrent("@script-module 为空值时返回 true", () => {
-      expect(isScriptModule({ "script-module": [""] })).toBe(true);
+    it.concurrent("@script-module 为空值 + @grant none 时返回 true", () => {
+      expect(isScriptModule({ "script-module": [""], grant: ["none"] })).toBe(true);
     });
 
-    it.concurrent("@script-module 为 true 时返回 true", () => {
-      expect(isScriptModule({ "script-module": ["true"] })).toBe(true);
+    it.concurrent("@script-module 为 true + @grant none 时返回 true", () => {
+      expect(isScriptModule({ "script-module": ["true"], grant: ["none"] })).toBe(true);
     });
 
     it.concurrent("没有 @script-module 时返回 false", () => {
-      expect(isScriptModule({})).toBe(false);
+      expect(isScriptModule({ grant: ["none"] })).toBe(false);
     });
 
     it.concurrent("@script-module 为 false 时返回 false", () => {
-      expect(isScriptModule({ "script-module": ["false"] })).toBe(false);
+      expect(isScriptModule({ "script-module": ["false"], grant: ["none"] })).toBe(false);
     });
 
     it.concurrent("@script-module 与 @inject-into content 同时存在时返回 false", () => {
-      expect(isScriptModule({ "script-module": [""], "inject-into": ["content"] })).toBe(false);
+      expect(isScriptModule({ "script-module": [""], grant: ["none"], "inject-into": ["content"] })).toBe(false);
     });
 
     it.concurrent("@script-module 与 @inject-into page 同时存在时返回 true", () => {
-      expect(isScriptModule({ "script-module": [""], "inject-into": ["page"] })).toBe(true);
+      expect(isScriptModule({ "script-module": [""], grant: ["none"], "inject-into": ["page"] })).toBe(true);
+    });
+
+    it.concurrent("没有 @grant none 时返回 false（阻止 GM 权限对象暴露给 module）", () => {
+      expect(isScriptModule({ "script-module": [""] })).toBe(false);
+      expect(isScriptModule({ "script-module": [""], grant: ["GM.getValue"] })).toBe(false);
+      expect(isScriptModule({ "script-module": [""], grant: ["GM.getValue", "none"] })).toBe(true);
+    });
+
+    it.concurrent("搭配 @require 时返回 false（module 无法访问外层 classic-script 的词法变量）", () => {
+      expect(isScriptModule({ "script-module": [""], grant: ["none"], require: ["https://example.com/a.js"] })).toBe(
+        false
+      );
+    });
+
+    it.concurrent("搭配 early-start（document-start）时返回 false", () => {
+      expect(
+        isScriptModule({
+          "script-module": [""],
+          grant: ["none"],
+          "early-start": [""],
+          "run-at": ["document-start"],
+        })
+      ).toBe(false);
+    });
+  });
+
+  describe.concurrent("isGrantNone", () => {
+    it.concurrent("grant 数组包含 none 时返回 true", () => {
+      expect(isGrantNone({ grant: ["none"] })).toBe(true);
+      expect(isGrantNone({ grant: ["GM.getValue", "none"] })).toBe(true);
+    });
+
+    it.concurrent("没有 grant 或 grant 不含 none 时返回 false", () => {
+      expect(isGrantNone({})).toBe(false);
+      expect(isGrantNone({ grant: ["GM.getValue"] })).toBe(false);
+    });
+  });
+
+  describe.concurrent("wrapScriptModuleCode", () => {
+    it.concurrent("不写入 document/window 等页面共享对象，仅通过序列化的 GM.info 传递上下文", () => {
+      const result = wrapScriptModuleCode("console.log('hi')", "Test Script");
+
+      // 不得出现任何 document.<临时属性> 赋值——这正是被 review 指出的、可被页面 hook
+      // createElement/appendChild 窃取 GM 权限对象的手法
+      expect(result).not.toMatch(/document\s*\.\s*__/);
+      expect(result).not.toMatch(/document\s*\[\s*["'`]__/);
+
+      // 仍然创建并挂载 <script type="module">
+      expect(result).toContain('jsScript.type = "module"');
+      expect(result).toContain('document.createElement("script")');
+      expect(result).toMatch(
+        /\(document\.body \|\| document\.head \|\| document\.documentElement\)\.appendChild\(jsScript\)/
+      );
+
+      // module 只能拿到序列化后的 GM.info（纯数据），没有任何 GM_* 权限方法可供窃取
+      expect(result).toContain("Object.freeze({ info: Object.freeze(");
+      expect(result).toContain("JSON.stringify(GM_info)");
+
+      // 原始脚本代码被内嵌（JSON 字符串形式）
+      expect(result).toContain(JSON.stringify("console.log('hi')"));
+
+      // 注入失败（import 解析失败 / 被页面 CSP 拦截）时有可观测的错误处理
+      expect(result).toContain('jsScript.addEventListener("error"');
+      expect(result).toContain(JSON.stringify("Test Script"));
     });
   });
 
diff --git a/src/app/service/content/utils.ts b/src/app/service/content/utils.ts
index cb78ab1ec..8390b4aef 100644
--- a/src/app/service/content/utils.ts
+++ b/src/app/service/content/utils.ts
@@ -281,8 +281,46 @@ export function isScriptletUnwrap(metadata: SCMetadata): boolean {
   return metadataBlankOrTrue(metadata, "unwrap");
 }
 
+// @script-module 必须新建独立的 <script type="module">，无法复用外层 with(arguments[0]) 沙盒 Proxy，
+// 因此模块内只能拿到一份序列化后的 GM.info 快照（纯 JSON 数据，不含任何 GM_* 权限方法）。
+// 在浏览器能力允许模块脚本复用沙盒 Proxy、安全地传递权限对象之前，首版强制要求 @grant none，
+// 避免页面 hook document.createElement/appendChild 时窃取具备权限的 GM 对象。
+// 同理排除 @require（module 无法访问外层 classic-script 的词法变量）与 early-start
+// （document-start 时 GM_info 的 isIncognito/sandboxMode/userAgentData 可能尚未从后台补齐，
+// 而 module 只能拿到一次性快照，事后无法像沙盒 Proxy 那样以同一对象引用回填）。
 export function isScriptModule(metadata: SCMetadata): boolean {
-  return metadataBlankOrTrue(metadata, "script-module") && !isInjectIntoContent(metadata);
+  return (
+    metadataBlankOrTrue(metadata, "script-module") &&
+    !isInjectIntoContent(metadata) &&
+    isGrantNone(metadata) &&
+    !isEarlyStartScript(metadata) &&
+    !(Array.isArray(metadata.require) && metadata.require.length > 0)
+  );
+}
+
+export function isGrantNone(metadata: SCMetadata): boolean {
+  const grants = metadata.grant;
+  return Array.isArray(grants) && grants.includes("none");
+}
+
+/**
+ * 将脚本代码包装为通过独立 <script type="module"> 标签注入的形式。
+ * 仅通过序列化的 GM.info（纯 JSON 数据）向 module 传递上下文，不写入 document/window 等
+ * 页面共享对象，避免页面 hook createElement/appendChild 时取得具备权限的 GM 对象。
+ * @see {@link isScriptModule}
+ */
+export function wrapScriptModuleCode(scriptCode: string, scriptName: string): string {
+  const bakedScriptCode = JSON.stringify(scriptCode);
+  const bakedScriptName = JSON.stringify(scriptName);
+  return [
+    "(function(){",
+    'var jsScript = document.createElement("script");',
+    'jsScript.type = "module";',
+    `jsScript.textContent = "const GM = Object.freeze({ info: Object.freeze(" + JSON.stringify(GM_info) + ") });\\n" + ${bakedScriptCode};`,
+    `jsScript.addEventListener("error", function(e){ console.error("[ScriptCat] @script-module " + ${bakedScriptName} + " 执行失败（可能是 import 解析失败或被页面 CSP 拦截）", e); });`,
+    "(document.body || document.head || document.documentElement).appendChild(jsScript);",
+    "})();",
+  ].join("\n");
 }
 
 export function isInjectIntoContent(metadata: SCMetadata): boolean {
diff --git a/src/app/service/service_worker/runtime.test.ts b/src/app/service/service_worker/runtime.test.ts
index 47f0d8365..d1aeb82fd 100644
--- a/src/app/service/service_worker/runtime.test.ts
+++ b/src/app/service/service_worker/runtime.test.ts
@@ -343,6 +343,74 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
     });
   });
 
+  describe.concurrent("restoreJSCodeFromCompiledResource 缓存恢复路径与首次编译路径的一致性", () => {
+    it.concurrent(
+      "@script-module + @grant none 脚本：缓存恢复路径也应套用 module 包装，而非退回 classic-script 编译",
+      async () => {
+        const { runtime, mockScriptService } = createRuntimeTestContext();
+        (mockScriptService as any).scriptCodeDAO = {
+          get: vi.fn().mockResolvedValue({ code: "import x from './x.js'; console.log(x);" }),
+        };
+
+        const script = createMockScript({
+          metadata: { "script-module": [""], grant: ["none"], match: ["https://www.example.com/*"] },
+        });
+        const compiledResource: CompiledResource = {
+          name: script.name,
+          flag: "#-" + script.uuid,
+          uuid: script.uuid,
+          require: [],
+          matches: ["https://www.example.com/*"],
+          includeGlobs: [],
+          excludeMatches: [],
+          excludeGlobs: [],
+          allFrames: false,
+          world: "MAIN",
+          runAt: "document-idle",
+          scriptUrlPatterns: [],
+          originalUrlPatterns: null,
+        };
+
+        const code = await runtime.restoreJSCodeFromCompiledResource(script, compiledResource);
+
+        expect(code).toContain('jsScript.type = "module"');
+        expect(code).toContain("Object.freeze({ info: Object.freeze(");
+        // 不得通过 document 临时属性传递 GM 权限对象
+        expect(code).not.toMatch(/document\s*\.\s*__/);
+      }
+    );
+
+    it.concurrent("普通脚本（非 script-module）：缓存恢复路径不应套用 module 包装", async () => {
+      const { runtime, mockScriptService } = createRuntimeTestContext();
+      (mockScriptService as any).scriptCodeDAO = {
+        get: vi.fn().mockResolvedValue({ code: "console.log('normal');" }),
+      };
+
+      const script = createMockScript({
+        metadata: { match: ["https://www.example.com/*"] },
+      });
+      const compiledResource: CompiledResource = {
+        name: script.name,
+        flag: "#-" + script.uuid,
+        uuid: script.uuid,
+        require: [],
+        matches: ["https://www.example.com/*"],
+        includeGlobs: [],
+        excludeMatches: [],
+        excludeGlobs: [],
+        allFrames: false,
+        world: "MAIN",
+        runAt: "document-idle",
+        scriptUrlPatterns: [],
+        originalUrlPatterns: null,
+      };
+
+      const code = await runtime.restoreJSCodeFromCompiledResource(script, compiledResource);
+
+      expect(code).not.toContain('jsScript.type = "module"');
+    });
+  });
+
   describe("redo matcher cache behavior", () => {
     it("安装或排序更新后，已缓存 URL 的下一次匹配顺序应立即反映新 sort", async () => {
       const { runtime } = createRuntimeTestContext();
diff --git a/src/app/service/service_worker/runtime.ts b/src/app/service/service_worker/runtime.ts
index 55b7e0be6..949e6004d 100644
--- a/src/app/service/service_worker/runtime.ts
+++ b/src/app/service/service_worker/runtime.ts
@@ -41,7 +41,9 @@ import {
   isEarlyStartScript,
   isInjectIntoContent,
   isScriptletUnwrap,
+  isScriptModule,
   trimScriptInfo,
+  wrapScriptModuleCode,
 } from "../content/utils";
 import LoggerCore from "@App/app/logger/core";
 import PermissionVerify from "./permission_verify";
@@ -935,11 +937,16 @@ export class RuntimeService {
       }
     }
 
+    let code = originalCode?.code || "";
+    if (isScriptModule(script.metadata)) {
+      code = wrapScriptModuleCode(code, result.name);
+    }
+
     return compileInjectScriptByFlag(
       result.flag,
       compileScriptCodeByResource({
         name: result.name,
-        code: originalCode?.code || "",
+        code,
         require,
         isContextMenu: isContextMenuScript(script.metadata),
       })
diff --git a/src/app/service/service_worker/utils.test.ts b/src/app/service/service_worker/utils.test.ts
index b6508fd5d..86a408004 100644
--- a/src/app/service/service_worker/utils.test.ts
+++ b/src/app/service/service_worker/utils.test.ts
@@ -349,9 +349,9 @@ describe.concurrent("compileInjectionCode", () => {
     expect(result).toContain("window['#-test-uuid']");
   });
 
-  it.concurrent("script-module 脚本注入 <script type=module> 并透过 document 暴露沙盒变量", () => {
+  it.concurrent("script-module + grant none 脚本注入 <script type=module>，不暴露任何 GM 权限对象", () => {
     const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""] },
+      metadata: { "script-module": [""], grant: ["none"] },
     });
     const patterns = extractUrlPatterns(["@match https://example.com/*"]);
     const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
@@ -368,21 +368,32 @@ describe.concurrent("compileInjectionCode", () => {
       /\(document\.body \|\| document\.head \|\| document\.documentElement\)\.appendChild\(jsScript\)/
     );
 
-    // 通过临时 document 属性传递沙盒变量给 module script，并在读取后删除
-    expect(result).toMatch(
-      /document\.__[a-z0-9]+_[a-z0-9]+\s*=\s*\{GM, top, parent, window, globalThis: window, unsafeWindow:/
-    );
-    expect(result).toMatch(
-      /const \{GM, top, parent, window, unsafeWindow, globalThis\} = document\.__[a-z0-9]+_[a-z0-9]+; delete document\.__[a-z0-9]+_[a-z0-9]+;/
-    );
+    // 不得通过 document/window 等页面共享对象传递任何 GM 权限对象——
+    // module 只能拿到序列化的 GM.info（纯数据，无 GM_* 权限方法）
+    expect(result).not.toMatch(/document\s*\.\s*__/);
+    expect(result).toContain("Object.freeze({ info: Object.freeze(");
+    expect(result).toContain("JSON.stringify(GM_info)");
 
     // 原始脚本代码被内嵌到注入的 module 字符串中
     expect(result).toContain(scriptRes.code);
   });
 
+  it.concurrent("script-module 缺少 @grant none 时不生效（回退普通编译路径，避免暴露 GM 权限对象）", () => {
+    const scriptRes = createMockScriptRes({
+      metadata: { "script-module": [""], grant: ["GM.getValue"] },
+    });
+    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
+    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
+
+    expect(result).not.toContain('jsScript.type = "module"');
+    expect(result).not.toContain('document.createElement("script")');
+    expect(result).toContain("with(arguments[0]||this.$)");
+    expect(result).toContain("window['#-test-uuid']");
+  });
+
   it.concurrent("script-module 与 inject-into content 同时存在时不生效", () => {
     const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], "inject-into": ["content"] },
+      metadata: { "script-module": [""], grant: ["none"], "inject-into": ["content"] },
     });
     const patterns = extractUrlPatterns(["@match https://example.com/*"]);
     const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
@@ -395,9 +406,20 @@ describe.concurrent("compileInjectionCode", () => {
     expect(result).toContain("window['#-test-uuid']");
   });
 
-  it.concurrent("script-module 脚本搭配 early-start 时走预注入编译路径", () => {
+  it.concurrent("script-module 搭配 @require 时不生效（module 无法访问外层词法变量）", () => {
     const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], "early-start": [""], "run-at": ["document-start"] },
+      metadata: { "script-module": [""], grant: ["none"], require: ["https://example.com/lib.js"] },
+    });
+    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
+    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
+
+    expect(result).not.toContain('jsScript.type = "module"');
+    expect(result).toContain("with(arguments[0]||this.$)");
+  });
+
+  it.concurrent("script-module 搭配 early-start 时不生效（回退预注入编译路径，不生成 module 包装）", () => {
+    const scriptRes = createMockScriptRes({
+      metadata: { "script-module": [""], grant: ["none"], "early-start": [""], "run-at": ["document-start"] },
     });
     const patterns = extractUrlPatterns(["@match https://example.com/*"]);
     const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
@@ -405,7 +427,7 @@ describe.concurrent("compileInjectionCode", () => {
     // early-start 编译路径特征：window[flag] = function(){...} 且带 performance 事件派发
     expect(result).toContain("window['#-test-uuid'] = function(){");
     expect(result).toContain("performance.dispatchEvent");
-    // module script 包装仍然生效
-    expect(result).toContain('jsScript.type = "module"');
+    // module script 包装未生效——script-module 与 early-start 互斥
+    expect(result).not.toContain('jsScript.type = "module"');
   });
 });
diff --git a/src/app/service/service_worker/utils.ts b/src/app/service/service_worker/utils.ts
index 0f3596ac1..d9cae079f 100644
--- a/src/app/service/service_worker/utils.ts
+++ b/src/app/service/service_worker/utils.ts
@@ -12,6 +12,7 @@ import {
   isInjectIntoContent,
   isScriptletUnwrap,
   isScriptModule,
+  wrapScriptModuleCode,
 } from "../content/utils";
 import {
   extractUrlPatterns,
@@ -197,17 +198,7 @@ export function compileInjectionCode(
     scriptInjectCode = compileScriptletCode(scriptRes, scriptCode, scriptUrlPatterns);
   } else {
     if (isScriptModule(scriptRes.metadata)) {
-      const wId = `__${Date.now().toString(36)}_${(Math.random() + 1).toString(36).substring(2)}`;
-      const st = JSON.stringify(
-        `const {GM, top, parent, window, unsafeWindow, globalThis} = document.${wId}; delete document.${wId};\n${scriptCode}`
-      );
-      const p = (c: string) => {
-        const jsScript = document.createElement("script");
-        jsScript.type = "module";
-        jsScript.textContent = c;
-        (document.body || document.head || document.documentElement).appendChild(jsScript);
-      };
-      scriptCode = `document.${wId} = {GM, top, parent, window, globalThis: window, unsafeWindow: typeof unsafeWindow !== "undefined" ? unsafeWindow : undefined};(${p})(${st});`;
+      scriptCode = wrapScriptModuleCode(scriptCode, scriptRes.name);
     }
     scriptCode = compileScriptCode(scriptRes, scriptCode);
     if (isEarlyStartScript(scriptRes.metadata)) {

From 4b51374b92bece1bf2d634f07c9ea0da8e1f3deb Mon Sep 17 00:00:00 2001
From: cyfung1031 <44498510+cyfung1031@users.noreply.github.com>
Date: Fri, 17 Jul 2026 23:41:31 +0900
Subject: [PATCH 5/5] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20=E5=9B=9E=E9=80=80=20@?=
 =?UTF-8?q?script-module=20=E7=9A=84=20@grant=20none=20=E5=BC=BA=E5=88=B6?=
 =?UTF-8?q?=E9=99=90=E5=88=B6=EF=BC=8C=E6=81=A2=E5=A4=8D=E5=AE=8C=E6=95=B4?=
 =?UTF-8?q?=20GM.*=20=E8=83=BD=E5=8A=9B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

上一 commit 把 @script-module 限制为仅 @grant none 并只暴露序列化的
GM.info，这会让该功能失去意义——ESM + GM.* 同时可用本来就是这个功能的核心
诉求，而非仅支持静态 import。

恢复原有的 document.<临时属性> 转交机制：module 拿到的 GM 就是按 @grant
实际授予的能力对象（本项目按设计只暴露 GM 而非旧式 GM_* 全局，二者本无需
在 ESM 模式下都支持），window/unsafeWindow/top/parent/globalThis 同上。
early-start 组合同样恢复支持（GM_info 与外层沙盒共享同一对象引用，后续
补齐 isIncognito 等字段时 module 侧能同步看到）。

仅保留两处改动：
- @require 与 @script-module 互斥仍然拒绝——这是 module 无法访问外层
  classic-script 词法变量的客观限制，与本次回退的权限范围无关。
- wrapScriptModuleCode() 新增的 error 事件监听保留，用于在 import 解析
  失败或被页面 CSP 拦截时输出可定位到脚本名的 console.error。

restoreJSCodeFromCompiledResource() 的缓存恢复路径修复（此前该路径完全
跳过 module 包装）不受本次回退影响，继续生效。

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 example/tests/script_module_e2e_test.js       | 26 +++---
 src/app/service/content/utils.test.ts         | 67 +++++---------
 src/app/service/content/utils.ts              | 29 +++---
 .../service/service_worker/runtime.test.ts    | 67 +++++++-------
 src/app/service/service_worker/utils.test.ts  | 90 +++++++++----------
 5 files changed, 122 insertions(+), 157 deletions(-)

diff --git a/example/tests/script_module_e2e_test.js b/example/tests/script_module_e2e_test.js
index 909f275e9..501fd0a01 100644
--- a/example/tests/script_module_e2e_test.js
+++ b/example/tests/script_module_e2e_test.js
@@ -5,15 +5,11 @@
 // @description  E2E 测试 @script-module 功能（以 <script type="module"> 注入）
 // @author       ScriptCat
 // @match        https://content-security-policy.com/?script_module_e2e_test
-// @grant        none
+// @grant        GM.getValue
+// @grant        GM.setValue
 // @script-module
 // ==/UserScript==
 
-// 首版限制：@script-module 强制要求 @grant none。module 无法复用外层 with(arguments[0])
-// 沙盒 Proxy，若允许真实 GM_* 权限方法随之注入，页面 hook document.createElement/appendChild
-// 即可在临时挂载点被删除前窃取具备权限的 GM 对象。因此 GM.getValue / GM.setValue 等在
-// @script-module 下不可用，GM 只暴露一份序列化后的 GM.info（纯数据，无权限方法）。
-
 // 真正的 ES module 才能使用静态 `import ... from`；普通 <script>（非 module）遇到此语法
 // 会直接抛出 SyntaxError，导致整份脚本都无法执行。以此验证注入的确是 <script type="module">
 import { addNumbers, MODULE_LIB_MARKER } from "/module-lib.js";
@@ -70,10 +66,11 @@ const __sc_module_e2e_marker = true;
     assert("undefined", typeof window.__sc_module_e2e_marker, "module 顶层变量不应出现在 window 上");
   });
 
-  // @script-module 强制 @grant none：module 与真实页面运行在同一全局对象上，
-  // 不像其他有权限的脚本那样存在沙盒 window，因此 window 与 unsafeWindow 应指向同一个对象
-  await test("@grant none 下 window 与 unsafeWindow 为同一对象（无沙盒隔离）", async () => {
-    assert(true, typeof unsafeWindow === "undefined" || unsafeWindow === window, "不应存在独立的沙盒 window");
+  // 与其他 GM 脚本一致：window 为沙盒 window（与页面隔离），unsafeWindow 才是真实页面 window
+  // 参见 window_message_test.js 中同样的约定
+  await test("window 为沙盒 window，与 unsafeWindow（真实页面 window）不同", async () => {
+    assert(true, window !== unsafeWindow, "window 不应等于 unsafeWindow");
+    assert(document, unsafeWindow.document, "unsafeWindow.document 应等于真实 document");
   });
 
   await test("静态 import 的模块（/module-lib.js）被正确加载并可用", async () => {
@@ -81,11 +78,10 @@ const __sc_module_e2e_marker = true;
     assert(7, addNumbers(3, 4), "导入的函数应可正常调用");
   });
 
-  await test("@grant none 下 module 只能拿到 GM.info（无权限方法），验证 GM 权限对象不会暴露给 module", async () => {
-    assert("object", typeof GM.info, "GM.info 应为对象");
-    assert("undefined", typeof GM.getValue, "GM.getValue 不应存在——@script-module 强制 @grant none");
-    assert("undefined", typeof GM.setValue, "GM.setValue 不应存在——@script-module 强制 @grant none");
-    assert("undefined", typeof GM_getValue, "全局 GM_getValue 不应存在——module 不应拿到任何 GM_* 权限方法");
+  await test("GM.setValue / GM.getValue 正常工作", async () => {
+    await GM.setValue("script_module_e2e_key", "script_module_e2e_value");
+    const v = await GM.getValue("script_module_e2e_key");
+    assert("script_module_e2e_value", v, "GM.getValue 应读取到刚写入的值");
   });
 
   console.log("\n%c=== 测试结果总结 ===", "color: blue; font-size: 16px; font-weight: bold;");
diff --git a/src/app/service/content/utils.test.ts b/src/app/service/content/utils.test.ts
index f632854b8..5f70d3073 100644
--- a/src/app/service/content/utils.test.ts
+++ b/src/app/service/content/utils.test.ts
@@ -6,7 +6,6 @@ import {
   compileScriptletCode,
   isScriptletUnwrap,
   isScriptModule,
-  isGrantNone,
   wrapScriptModuleCode,
   addStyle,
   addStyleSheet,
@@ -567,88 +566,70 @@ describe("utils", () => {
   });
 
   describe.concurrent("isScriptModule", () => {
-    it.concurrent("@script-module 为空值 + @grant none 时返回 true", () => {
-      expect(isScriptModule({ "script-module": [""], grant: ["none"] })).toBe(true);
+    it.concurrent("@script-module 为空值时返回 true", () => {
+      expect(isScriptModule({ "script-module": [""] })).toBe(true);
     });
 
-    it.concurrent("@script-module 为 true + @grant none 时返回 true", () => {
-      expect(isScriptModule({ "script-module": ["true"], grant: ["none"] })).toBe(true);
+    it.concurrent("@script-module 为 true 时返回 true", () => {
+      expect(isScriptModule({ "script-module": ["true"] })).toBe(true);
     });
 
     it.concurrent("没有 @script-module 时返回 false", () => {
-      expect(isScriptModule({ grant: ["none"] })).toBe(false);
+      expect(isScriptModule({})).toBe(false);
     });
 
     it.concurrent("@script-module 为 false 时返回 false", () => {
-      expect(isScriptModule({ "script-module": ["false"], grant: ["none"] })).toBe(false);
+      expect(isScriptModule({ "script-module": ["false"] })).toBe(false);
     });
 
     it.concurrent("@script-module 与 @inject-into content 同时存在时返回 false", () => {
-      expect(isScriptModule({ "script-module": [""], grant: ["none"], "inject-into": ["content"] })).toBe(false);
+      expect(isScriptModule({ "script-module": [""], "inject-into": ["content"] })).toBe(false);
     });
 
     it.concurrent("@script-module 与 @inject-into page 同时存在时返回 true", () => {
-      expect(isScriptModule({ "script-module": [""], grant: ["none"], "inject-into": ["page"] })).toBe(true);
+      expect(isScriptModule({ "script-module": [""], "inject-into": ["page"] })).toBe(true);
     });
 
-    it.concurrent("没有 @grant none 时返回 false（阻止 GM 权限对象暴露给 module）", () => {
-      expect(isScriptModule({ "script-module": [""] })).toBe(false);
-      expect(isScriptModule({ "script-module": [""], grant: ["GM.getValue"] })).toBe(false);
-      expect(isScriptModule({ "script-module": [""], grant: ["GM.getValue", "none"] })).toBe(true);
+    it.concurrent("搭配真实 @grant 时仍返回 true（module 支持完整 GM.* 能力，不限于 @grant none）", () => {
+      expect(isScriptModule({ "script-module": [""], grant: ["GM.getValue", "GM.setValue"] })).toBe(true);
     });
 
     it.concurrent("搭配 @require 时返回 false（module 无法访问外层 classic-script 的词法变量）", () => {
-      expect(isScriptModule({ "script-module": [""], grant: ["none"], require: ["https://example.com/a.js"] })).toBe(
-        false
-      );
+      expect(isScriptModule({ "script-module": [""], require: ["https://example.com/a.js"] })).toBe(false);
     });
 
-    it.concurrent("搭配 early-start（document-start）时返回 false", () => {
+    it.concurrent("搭配 early-start（document-start）时仍返回 true", () => {
       expect(
         isScriptModule({
           "script-module": [""],
-          grant: ["none"],
           "early-start": [""],
           "run-at": ["document-start"],
         })
-      ).toBe(false);
-    });
-  });
-
-  describe.concurrent("isGrantNone", () => {
-    it.concurrent("grant 数组包含 none 时返回 true", () => {
-      expect(isGrantNone({ grant: ["none"] })).toBe(true);
-      expect(isGrantNone({ grant: ["GM.getValue", "none"] })).toBe(true);
-    });
-
-    it.concurrent("没有 grant 或 grant 不含 none 时返回 false", () => {
-      expect(isGrantNone({})).toBe(false);
-      expect(isGrantNone({ grant: ["GM.getValue"] })).toBe(false);
+      ).toBe(true);
     });
   });
 
   describe.concurrent("wrapScriptModuleCode", () => {
-    it.concurrent("不写入 document/window 等页面共享对象，仅通过序列化的 GM.info 传递上下文", () => {
+    it.concurrent("透过临时 document 属性传递 GM（含实际授予的能力）/window/unsafeWindow 等，并在读取后删除", () => {
       const result = wrapScriptModuleCode("console.log('hi')", "Test Script");
 
-      // 不得出现任何 document.<临时属性> 赋值——这正是被 review 指出的、可被页面 hook
-      // createElement/appendChild 窃取 GM 权限对象的手法
-      expect(result).not.toMatch(/document\s*\.\s*__/);
-      expect(result).not.toMatch(/document\s*\[\s*["'`]__/);
-
-      // 仍然创建并挂载 <script type="module">
+      // 生成 <script type="module"> 并挂载到 document
       expect(result).toContain('jsScript.type = "module"');
       expect(result).toContain('document.createElement("script")');
       expect(result).toMatch(
         /\(document\.body \|\| document\.head \|\| document\.documentElement\)\.appendChild\(jsScript\)/
       );
 
-      // module 只能拿到序列化后的 GM.info（纯数据），没有任何 GM_* 权限方法可供窃取
-      expect(result).toContain("Object.freeze({ info: Object.freeze(");
-      expect(result).toContain("JSON.stringify(GM_info)");
+      // 通过临时 document 属性传递沙盒变量给 module script，并在读取后删除
+      expect(result).toMatch(
+        /document\.__[a-z0-9]+_[a-z0-9]+\s*=\s*\{GM, top, parent, window, globalThis: window, unsafeWindow:/
+      );
+      expect(result).toMatch(
+        /const \{GM, top, parent, window, unsafeWindow, globalThis\} = document\.__[a-z0-9]+_[a-z0-9]+; delete document\.__[a-z0-9]+_[a-z0-9]+;/
+      );
 
-      // 原始脚本代码被内嵌（JSON 字符串形式）
-      expect(result).toContain(JSON.stringify("console.log('hi')"));
+      // 原始脚本代码被内嵌到注入的 module 字符串中
+      expect(result).toContain("console.log('hi')");
 
       // 注入失败（import 解析失败 / 被页面 CSP 拦截）时有可观测的错误处理
       expect(result).toContain('jsScript.addEventListener("error"');
diff --git a/src/app/service/content/utils.ts b/src/app/service/content/utils.ts
index 8390b4aef..eddfa733a 100644
--- a/src/app/service/content/utils.ts
+++ b/src/app/service/content/utils.ts
@@ -282,41 +282,36 @@ export function isScriptletUnwrap(metadata: SCMetadata): boolean {
 }
 
 // @script-module 必须新建独立的 <script type="module">，无法复用外层 with(arguments[0]) 沙盒 Proxy，
-// 因此模块内只能拿到一份序列化后的 GM.info 快照（纯 JSON 数据，不含任何 GM_* 权限方法）。
-// 在浏览器能力允许模块脚本复用沙盒 Proxy、安全地传递权限对象之前，首版强制要求 @grant none，
-// 避免页面 hook document.createElement/appendChild 时窃取具备权限的 GM 对象。
-// 同理排除 @require（module 无法访问外层 classic-script 的词法变量）与 early-start
-// （document-start 时 GM_info 的 isIncognito/sandboxMode/userAgentData 可能尚未从后台补齐，
-// 而 module 只能拿到一次性快照，事后无法像沙盒 Proxy 那样以同一对象引用回填）。
+// 因此通过临时的 document 属性把 GM（按 @grant 授予的实际能力）、window、unsafeWindow 等
+// 转交给新建的 module；module 读取后立即删除该属性。
+// 排除 @require：其内容在外层 classic-script 作用域执行，module 无法访问那些词法变量，
+// 组合使用会静默产生 require 内容对 module 不可见的错误行为，因此在此明确拒绝而非放任。
 export function isScriptModule(metadata: SCMetadata): boolean {
   return (
     metadataBlankOrTrue(metadata, "script-module") &&
     !isInjectIntoContent(metadata) &&
-    isGrantNone(metadata) &&
-    !isEarlyStartScript(metadata) &&
     !(Array.isArray(metadata.require) && metadata.require.length > 0)
   );
 }
 
-export function isGrantNone(metadata: SCMetadata): boolean {
-  const grants = metadata.grant;
-  return Array.isArray(grants) && grants.includes("none");
-}
-
 /**
  * 将脚本代码包装为通过独立 <script type="module"> 标签注入的形式。
- * 仅通过序列化的 GM.info（纯 JSON 数据）向 module 传递上下文，不写入 document/window 等
- * 页面共享对象，避免页面 hook createElement/appendChild 时取得具备权限的 GM 对象。
+ * 通过临时的 document 属性把当前脚本的 GM（按 @grant 授予的实际能力）、window、unsafeWindow、
+ * top、parent、globalThis 转交给新建的 module，module 读取后立即删除该属性。
  * @see {@link isScriptModule}
  */
 export function wrapScriptModuleCode(scriptCode: string, scriptName: string): string {
-  const bakedScriptCode = JSON.stringify(scriptCode);
+  const wId = `__${Date.now().toString(36)}_${(Math.random() + 1).toString(36).substring(2)}`;
   const bakedScriptName = JSON.stringify(scriptName);
+  const moduleSource = JSON.stringify(
+    `const {GM, top, parent, window, unsafeWindow, globalThis} = document.${wId}; delete document.${wId};\n${scriptCode}`
+  );
   return [
     "(function(){",
+    `document.${wId} = {GM, top, parent, window, globalThis: window, unsafeWindow: typeof unsafeWindow !== "undefined" ? unsafeWindow : undefined};`,
     'var jsScript = document.createElement("script");',
     'jsScript.type = "module";',
-    `jsScript.textContent = "const GM = Object.freeze({ info: Object.freeze(" + JSON.stringify(GM_info) + ") });\\n" + ${bakedScriptCode};`,
+    `jsScript.textContent = ${moduleSource};`,
     `jsScript.addEventListener("error", function(e){ console.error("[ScriptCat] @script-module " + ${bakedScriptName} + " 执行失败（可能是 import 解析失败或被页面 CSP 拦截）", e); });`,
     "(document.body || document.head || document.documentElement).appendChild(jsScript);",
     "})();",
diff --git a/src/app/service/service_worker/runtime.test.ts b/src/app/service/service_worker/runtime.test.ts
index d1aeb82fd..5b70a1df4 100644
--- a/src/app/service/service_worker/runtime.test.ts
+++ b/src/app/service/service_worker/runtime.test.ts
@@ -344,41 +344,38 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
   });
 
   describe.concurrent("restoreJSCodeFromCompiledResource 缓存恢复路径与首次编译路径的一致性", () => {
-    it.concurrent(
-      "@script-module + @grant none 脚本：缓存恢复路径也应套用 module 包装，而非退回 classic-script 编译",
-      async () => {
-        const { runtime, mockScriptService } = createRuntimeTestContext();
-        (mockScriptService as any).scriptCodeDAO = {
-          get: vi.fn().mockResolvedValue({ code: "import x from './x.js'; console.log(x);" }),
-        };
-
-        const script = createMockScript({
-          metadata: { "script-module": [""], grant: ["none"], match: ["https://www.example.com/*"] },
-        });
-        const compiledResource: CompiledResource = {
-          name: script.name,
-          flag: "#-" + script.uuid,
-          uuid: script.uuid,
-          require: [],
-          matches: ["https://www.example.com/*"],
-          includeGlobs: [],
-          excludeMatches: [],
-          excludeGlobs: [],
-          allFrames: false,
-          world: "MAIN",
-          runAt: "document-idle",
-          scriptUrlPatterns: [],
-          originalUrlPatterns: null,
-        };
-
-        const code = await runtime.restoreJSCodeFromCompiledResource(script, compiledResource);
-
-        expect(code).toContain('jsScript.type = "module"');
-        expect(code).toContain("Object.freeze({ info: Object.freeze(");
-        // 不得通过 document 临时属性传递 GM 权限对象
-        expect(code).not.toMatch(/document\s*\.\s*__/);
-      }
-    );
+    it.concurrent("@script-module 脚本：缓存恢复路径也应套用 module 包装，而非退回 classic-script 编译", async () => {
+      const { runtime, mockScriptService } = createRuntimeTestContext();
+      (mockScriptService as any).scriptCodeDAO = {
+        get: vi.fn().mockResolvedValue({ code: "import x from './x.js'; console.log(x);" }),
+      };
+
+      const script = createMockScript({
+        metadata: { "script-module": [""], grant: ["GM.getValue"], match: ["https://www.example.com/*"] },
+      });
+      const compiledResource: CompiledResource = {
+        name: script.name,
+        flag: "#-" + script.uuid,
+        uuid: script.uuid,
+        require: [],
+        matches: ["https://www.example.com/*"],
+        includeGlobs: [],
+        excludeMatches: [],
+        excludeGlobs: [],
+        allFrames: false,
+        world: "MAIN",
+        runAt: "document-idle",
+        scriptUrlPatterns: [],
+        originalUrlPatterns: null,
+      };
+
+      const code = await runtime.restoreJSCodeFromCompiledResource(script, compiledResource);
+
+      expect(code).toContain('jsScript.type = "module"');
+      expect(code).toMatch(
+        /document\.__[a-z0-9]+_[a-z0-9]+\s*=\s*\{GM, top, parent, window, globalThis: window, unsafeWindow:/
+      );
+    });
 
     it.concurrent("普通脚本（非 script-module）：缓存恢复路径不应套用 module 包装", async () => {
       const { runtime, mockScriptService } = createRuntimeTestContext();
diff --git a/src/app/service/service_worker/utils.test.ts b/src/app/service/service_worker/utils.test.ts
index 86a408004..d84cb9cdb 100644
--- a/src/app/service/service_worker/utils.test.ts
+++ b/src/app/service/service_worker/utils.test.ts
@@ -349,51 +349,47 @@ describe.concurrent("compileInjectionCode", () => {
     expect(result).toContain("window['#-test-uuid']");
   });
 
-  it.concurrent("script-module + grant none 脚本注入 <script type=module>，不暴露任何 GM 权限对象", () => {
-    const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], grant: ["none"] },
-    });
-    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
-    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
-
-    // 仍然走普通编译路径的沙箱封装（module 包装是在沙箱之内注入）
-    expect(result).toContain("with(arguments[0]||this.$)");
-    expect(result).toContain("return(async function(){");
-    expect(result).toContain("window['#-test-uuid']");
-
-    // 生成 <script type="module"> 并挂载到 document
-    expect(result).toContain('jsScript.type = "module"');
-    expect(result).toContain('document.createElement("script")');
-    expect(result).toMatch(
-      /\(document\.body \|\| document\.head \|\| document\.documentElement\)\.appendChild\(jsScript\)/
-    );
-
-    // 不得通过 document/window 等页面共享对象传递任何 GM 权限对象——
-    // module 只能拿到序列化的 GM.info（纯数据，无 GM_* 权限方法）
-    expect(result).not.toMatch(/document\s*\.\s*__/);
-    expect(result).toContain("Object.freeze({ info: Object.freeze(");
-    expect(result).toContain("JSON.stringify(GM_info)");
-
-    // 原始脚本代码被内嵌到注入的 module 字符串中
-    expect(result).toContain(scriptRes.code);
-  });
-
-  it.concurrent("script-module 缺少 @grant none 时不生效（回退普通编译路径，避免暴露 GM 权限对象）", () => {
-    const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], grant: ["GM.getValue"] },
-    });
-    const patterns = extractUrlPatterns(["@match https://example.com/*"]);
-    const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
-
-    expect(result).not.toContain('jsScript.type = "module"');
-    expect(result).not.toContain('document.createElement("script")');
-    expect(result).toContain("with(arguments[0]||this.$)");
-    expect(result).toContain("window['#-test-uuid']");
-  });
+  it.concurrent(
+    "script-module 脚本注入 <script type=module> 并透过 document 暴露沙盒变量（含真实授予的 GM 能力）",
+    () => {
+      const scriptRes = createMockScriptRes({
+        metadata: { "script-module": [""], grant: ["GM.getValue", "GM.setValue"] },
+      });
+      const patterns = extractUrlPatterns(["@match https://example.com/*"]);
+      const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
+
+      // 仍然走普通编译路径的沙箱封装（module 包装是在沙箱之内注入），
+      // 这意味着 module 拿到的 GM 与外层沙盒授予的能力（本例为 GM.getValue/GM.setValue）一致
+      expect(result).toContain("with(arguments[0]||this.$)");
+      expect(result).toContain("return(async function(){");
+      expect(result).toContain("window['#-test-uuid']");
+
+      // 生成 <script type="module"> 并挂载到 document
+      expect(result).toContain('jsScript.type = "module"');
+      expect(result).toContain('document.createElement("script")');
+      expect(result).toMatch(
+        /\(document\.body \|\| document\.head \|\| document\.documentElement\)\.appendChild\(jsScript\)/
+      );
+
+      // 通过临时 document 属性传递沙盒变量给 module script，并在读取后删除
+      expect(result).toMatch(
+        /document\.__[a-z0-9]+_[a-z0-9]+\s*=\s*\{GM, top, parent, window, globalThis: window, unsafeWindow:/
+      );
+      expect(result).toMatch(
+        /const \{GM, top, parent, window, unsafeWindow, globalThis\} = document\.__[a-z0-9]+_[a-z0-9]+; delete document\.__[a-z0-9]+_[a-z0-9]+;/
+      );
+
+      // 原始脚本代码被内嵌到注入的 module 字符串中
+      expect(result).toContain(scriptRes.code);
+
+      // import 失败/被页面 CSP 拦截时有可观测的错误处理
+      expect(result).toContain('jsScript.addEventListener("error"');
+    }
+  );
 
   it.concurrent("script-module 与 inject-into content 同时存在时不生效", () => {
     const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], grant: ["none"], "inject-into": ["content"] },
+      metadata: { "script-module": [""], "inject-into": ["content"] },
     });
     const patterns = extractUrlPatterns(["@match https://example.com/*"]);
     const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
@@ -408,7 +404,7 @@ describe.concurrent("compileInjectionCode", () => {
 
   it.concurrent("script-module 搭配 @require 时不生效（module 无法访问外层词法变量）", () => {
     const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], grant: ["none"], require: ["https://example.com/lib.js"] },
+      metadata: { "script-module": [""], require: ["https://example.com/lib.js"] },
     });
     const patterns = extractUrlPatterns(["@match https://example.com/*"]);
     const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
@@ -417,9 +413,9 @@ describe.concurrent("compileInjectionCode", () => {
     expect(result).toContain("with(arguments[0]||this.$)");
   });
 
-  it.concurrent("script-module 搭配 early-start 时不生效（回退预注入编译路径，不生成 module 包装）", () => {
+  it.concurrent("script-module 脚本搭配 early-start 时走预注入编译路径", () => {
     const scriptRes = createMockScriptRes({
-      metadata: { "script-module": [""], grant: ["none"], "early-start": [""], "run-at": ["document-start"] },
+      metadata: { "script-module": [""], "early-start": [""], "run-at": ["document-start"] },
     });
     const patterns = extractUrlPatterns(["@match https://example.com/*"]);
     const result = compileInjectionCode(scriptRes, scriptRes.code, patterns);
@@ -427,7 +423,7 @@ describe.concurrent("compileInjectionCode", () => {
     // early-start 编译路径特征：window[flag] = function(){...} 且带 performance 事件派发
     expect(result).toContain("window['#-test-uuid'] = function(){");
     expect(result).toContain("performance.dispatchEvent");
-    // module script 包装未生效——script-module 与 early-start 互斥
-    expect(result).not.toContain('jsScript.type = "module"');
+    // module script 包装仍然生效
+    expect(result).toContain('jsScript.type = "module"');
   });
 });