diff --git a/src/app/service/service_worker/popup.ts b/src/app/service/service_worker/popup.ts
index 100408485..04cb9b529 100644
--- a/src/app/service/service_worker/popup.ts
+++ b/src/app/service/service_worker/popup.ts
@@ -340,7 +340,7 @@ export class PopupService {
   async getPopupData(req: GetPopupDataReq): Promise<GetPopupDataRes> {
     const { url, tabId } = req;
     const [matchingResult, runScripts, backScriptList] = await Promise.all([
-      this.runtime.getPageScriptMatchingResultByUrl(url, true, true),
+      this.runtime.getPopupPageScriptMatchingResultByUrl(url),
       this.getScriptMenu(tabId),
       this.getScriptMenu(-1),
     ]);
diff --git a/src/app/service/service_worker/runtime.test.ts b/src/app/service/service_worker/runtime.test.ts
index 0e29cc5bb..09b481f3f 100644
--- a/src/app/service/service_worker/runtime.test.ts
+++ b/src/app/service/service_worker/runtime.test.ts
@@ -3,7 +3,12 @@ import { RuntimeService } from "./runtime";
 import { vi, describe, it, expect, beforeEach, type MockedFunction } from "vitest";
 import { randomUUID } from "crypto";
 import type { Script, ScriptRunResource } from "@App/app/repo/scripts";
-import { SCRIPT_STATUS_DISABLE, SCRIPT_STATUS_ENABLE, SCRIPT_TYPE_NORMAL } from "@App/app/repo/scripts";
+import {
+  SCRIPT_STATUS_DISABLE,
+  SCRIPT_STATUS_ENABLE,
+  SCRIPT_TYPE_BACKGROUND,
+  SCRIPT_TYPE_NORMAL,
+} from "@App/app/repo/scripts";
 import { getCombinedMeta } from "./utils";
 import type { SystemConfig } from "@App/pkg/config/config";
 import type { Group } from "@Packages/message/server";
@@ -16,10 +21,11 @@ import type { ScriptDAO } from "@App/app/repo/scripts";
 import { LocalStorageDAO } from "@App/app/repo/localStorage";
 import type { MessageConnect, TMessage } from "@Packages/message/types";
 import { obtainBlackList } from "@App/pkg/utils/utils";
+import type { CompiledResource, Resource } from "@App/app/repo/resource";
 
 initTestEnv();
 
-describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹配", () => {
+describe("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹配", () => {
   let runtime: RuntimeService;
   let mockSystemConfig: {
     getBlacklist: MockedFunction<() => string>;
@@ -27,6 +33,20 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
   let mockScriptService: {
     buildScriptRunResource: MockedFunction<(script: Script, scriptFlag?: string) => ScriptRunResource>;
   };
+  let mockValueService: {
+    getScriptValue: MockedFunction<(script: Script) => Promise<Record<string, any>>>;
+  };
+  let mockResourceService: {
+    getScriptResources: MockedFunction<(script: Script, load: boolean) => Promise<Record<string, any>>>;
+    updateResource: MockedFunction<(uuid: string, url: string, type: any) => Promise<any>>;
+  };
+  let mockScriptDAO: {
+    all: MockedFunction<() => Promise<Script[]>>;
+    gets: MockedFunction<(uuids: string[]) => Promise<(Script | undefined)[]>>;
+    scriptCodeDAO: {
+      get: MockedFunction<(uuid: string) => Promise<{ uuid: string; code: string } | undefined>>;
+    };
+  };
 
   // 测试数据创建工具函数
   const createMockScript = (overrides: Partial<Script> = {}): Script => ({
@@ -63,6 +83,59 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
     };
   };
 
+  const createUserScriptCode = (script: Script, body = "console.log('test');") =>
+    [
+      "// ==UserScript==",
+      `// @name ${script.name}`,
+      `// @namespace ${script.namespace}`,
+      ...(script.metadata.match || []).map((item) => `// @match ${item}`),
+      ...(script.metadata.include || []).map((item) => `// @include ${item}`),
+      "// ==/UserScript==",
+      body,
+    ].join("\n");
+
+  const createCompiledResourceAsync = async (
+    script: Script,
+    scriptRunResource: ScriptRunResource
+  ): Promise<CompiledResource> => {
+    const matchInfo = await runtime.applyScriptMatchInfo(scriptRunResource);
+    expect(matchInfo).toBeDefined();
+    return {
+      name: script.name,
+      flag: scriptRunResource.flag,
+      uuid: script.uuid,
+      require: [],
+      matches: script.metadata.match || ["https://www.example.com/*"],
+      includeGlobs: [],
+      excludeMatches: [],
+      excludeGlobs: [],
+      allFrames: !script.metadata.noframes,
+      world: script.metadata["inject-into"]?.[0] === "content" ? "USER_SCRIPT" : "MAIN",
+      runAt: "",
+      scriptUrlPatterns: matchInfo!.scriptUrlPatterns,
+      originalUrlPatterns:
+        matchInfo!.originalUrlPatterns === matchInfo!.scriptUrlPatterns ? null : matchInfo!.originalUrlPatterns,
+    };
+  };
+
+  const createTextResource = (url: string, content: string, sha512: string): Resource => ({
+    url,
+    content,
+    base64: "base64",
+    hash: {
+      md5: "",
+      sha1: "",
+      sha256: "",
+      sha384: "",
+      sha512,
+    },
+    type: "require",
+    link: {},
+    contentType: "text/javascript",
+    createtime: 1,
+    updatetime: 1,
+  });
+
   beforeEach(() => {
     // 创建所有必需的mock对象
     mockSystemConfig = {
@@ -72,6 +145,20 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
     mockScriptService = {
       buildScriptRunResource: vi.fn(),
     };
+    mockValueService = {
+      getScriptValue: vi.fn(),
+    };
+    mockResourceService = {
+      getScriptResources: vi.fn(),
+      updateResource: vi.fn(),
+    };
+    mockScriptDAO = {
+      all: vi.fn().mockResolvedValue([]),
+      gets: vi.fn().mockResolvedValue([]),
+      scriptCodeDAO: {
+        get: vi.fn(),
+      },
+    };
 
     const mockGroup = {
       use: vi.fn().mockReturnThis(),
@@ -89,11 +176,6 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
     const mockMessageQueue = {
       group: vi.fn().mockReturnValue(mockGroup),
     } as unknown as IMessageQueue;
-    const mockValueService = {} as ValueService;
-    const mockResourceService = {} as ResourceService;
-    const mockScriptDAO = {
-      all: vi.fn().mockResolvedValue([]),
-    } as unknown as ScriptDAO;
     const mockLocalStorageDAO = new LocalStorageDAO();
 
     runtime = new RuntimeService(
@@ -101,10 +183,10 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
       mockGroup,
       mockSender,
       mockMessageQueue,
-      mockValueService,
+      mockValueService as unknown as ValueService,
       mockScriptService as unknown as ScriptService,
-      mockResourceService,
-      mockScriptDAO,
+      mockResourceService as unknown as ResourceService,
+      mockScriptDAO as unknown as ScriptDAO,
       mockLocalStorageDAO
     );
   });
@@ -338,12 +420,471 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
     });
   });
 
-  describe.concurrent("黑名單測試", async () => {
-    it.concurrent("黑名單測試 A", async () => {
+  describe("getScriptsForTab cache", () => {
+    it("应该复用静态脚本信息，只在每次页面加载时刷新 value", async () => {
+      const script = createMockScript({
+        uuid: "cache-script",
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+        updatetime: 100,
+      });
+      const scriptRunResource = createScriptRunResource(script);
+      const matchInfo = await runtime.applyScriptMatchInfo(scriptRunResource);
+      expect(matchInfo).toBeDefined();
+
+      const compiledResource = {
+        name: script.name,
+        flag: scriptRunResource.flag,
+        uuid: script.uuid,
+        require: [],
+        matches: ["https://www.example.com/*"],
+        includeGlobs: [],
+        excludeMatches: [],
+        excludeGlobs: [],
+        allFrames: true,
+        world: "MAIN",
+        runAt: "",
+        scriptUrlPatterns: matchInfo!.scriptUrlPatterns,
+        originalUrlPatterns: null,
+      };
+      const compiledResourceDAO = {
+        gets: vi.fn().mockResolvedValue([compiledResource]),
+      };
+      runtime.compiledResourceDAO = compiledResourceDAO as any;
+
+      mockScriptDAO.gets.mockResolvedValue([script]);
+      mockScriptDAO.scriptCodeDAO.get.mockResolvedValue({
+        uuid: script.uuid,
+        code: [
+          "// ==UserScript==",
+          "// @name test-script",
+          "// @namespace test-namespace",
+          "// @match https://www.example.com/*",
+          "// ==/UserScript==",
+          "console.log('cached');",
+        ].join("\n"),
+      });
+      mockResourceService.getScriptResources.mockResolvedValue({});
+      mockValueService.getScriptValue.mockResolvedValueOnce({ count: 1 }).mockResolvedValueOnce({ count: 2 });
+
+      const first = await runtime.getScriptsForTab({
+        url: "https://www.example.com/path",
+        tabId: 1,
+        frameId: 0,
+      });
+      const second = await runtime.getScriptsForTab({
+        url: "https://www.example.com/path",
+        tabId: 1,
+        frameId: 0,
+      });
+
+      expect(first?.injectScriptList[0].value).toEqual({ count: 1 });
+      expect(second?.injectScriptList[0].value).toEqual({ count: 2 });
+      expect(second?.injectScriptList[0].metadataStr).toContain("@name test-script");
+      expect(runtime.pageLoadCaches.has(script.uuid)).toBe(true);
+      expect(compiledResourceDAO.gets).toHaveBeenCalledTimes(1);
+      expect(mockResourceService.getScriptResources).toHaveBeenCalledTimes(1);
+      expect(mockScriptDAO.scriptCodeDAO.get).toHaveBeenCalledTimes(1);
+      expect(mockValueService.getScriptValue).toHaveBeenCalledTimes(2);
+    });
+
+    it("应该在全局停用、黑名单、没有匹配脚本时直接返回 null", async () => {
+      runtime.isLoadScripts = false;
+      expect(
+        await runtime.getScriptsForTab({
+          url: "https://www.example.com/path",
+          tabId: 1,
+          frameId: 0,
+        })
+      ).toBeNull();
+
+      runtime.isLoadScripts = true;
+      runtime.blacklist = obtainBlackList("*://www.example.com/*");
+      runtime.loadBlacklist();
+      expect(
+        await runtime.getScriptsForTab({
+          url: "https://www.example.com/path",
+          tabId: 1,
+          frameId: 0,
+        })
+      ).toBeNull();
+
+      runtime.blacklist = [];
+      runtime.loadBlacklist();
+      expect(
+        await runtime.getScriptsForTab({
+          url: "https://not-matched.example/path",
+          tabId: 1,
+          frameId: 0,
+        })
+      ).toBeNull();
+      expect(mockScriptDAO.gets).not.toHaveBeenCalled();
+    });
+
+    it("应该按运行条件过滤脚本，并按 inject-into 拆分 inject/content 列表且保留顺序", async () => {
+      const injectScript = createMockScript({
+        uuid: "script-inject",
+        sort: 1,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+      const contentScript = createMockScript({
+        uuid: "script-content",
+        sort: 2,
+        metadata: {
+          match: ["https://www.example.com/*"],
+          "inject-into": ["content"],
+        },
+      });
+      const noframesScript = createMockScript({
+        uuid: "script-noframes",
+        sort: 3,
+        metadata: {
+          match: ["https://www.example.com/*"],
+          noframes: [""],
+        },
+      });
+      const incognitoOnlyScript = createMockScript({
+        uuid: "script-incognito",
+        sort: 4,
+        metadata: {
+          match: ["https://www.example.com/*"],
+          "run-in": ["incognito-tabs"],
+        },
+      });
+
+      const scripts = [injectScript, contentScript, noframesScript, incognitoOnlyScript];
+      const runResources = scripts.map(createScriptRunResource);
+      const compiledResources = await Promise.all(
+        scripts.map((script, index) => createCompiledResourceAsync(script, runResources[index]))
+      );
+      runtime.compiledResourceDAO = {
+        gets: vi.fn().mockResolvedValue(compiledResources),
+      } as any;
+      mockScriptDAO.gets.mockResolvedValue(scripts);
+      mockScriptDAO.scriptCodeDAO.get.mockImplementation(async (uuid) => {
+        const script = scripts.find((item) => item.uuid === uuid);
+        return script ? { uuid, code: createUserScriptCode(script) } : undefined;
+      });
+      mockResourceService.getScriptResources.mockResolvedValue({});
+      mockValueService.getScriptValue.mockResolvedValue({});
+
+      const result = await runtime.getScriptsForTab({
+        url: "https://www.example.com/path",
+        tabId: 1,
+        frameId: 1,
+      });
+
+      expect(result?.injectScriptList.map((script) => script.uuid)).toEqual(["script-inject"]);
+      expect(result?.contentScriptList.map((script) => script.uuid)).toEqual(["script-content"]);
+      expect(result?.scriptmenus.map((script) => script.uuid)).toEqual(["script-inject", "script-content"]);
+    });
+
+    it("应该在脚本更新时间变化后丢弃旧 page-load cache 并重建静态信息", async () => {
+      const oldScript = createMockScript({
+        uuid: "cache-invalidated",
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+        updatetime: 100,
+      });
+      const newScript = {
+        ...oldScript,
+        updatetime: 200,
+      };
+      const oldRunResource = createScriptRunResource(oldScript);
+      const _newRunResource = createScriptRunResource(newScript);
+      const oldCompiled = await createCompiledResourceAsync(oldScript, oldRunResource);
+      const newCompiled = {
+        ...oldCompiled,
+        name: newScript.name,
+      };
+      const compiledResourceDAO = {
+        gets: vi.fn().mockResolvedValueOnce([oldCompiled]).mockResolvedValueOnce([newCompiled]),
+      };
+      runtime.compiledResourceDAO = compiledResourceDAO as any;
+      mockScriptDAO.gets.mockResolvedValueOnce([oldScript]).mockResolvedValueOnce([newScript]);
+      mockScriptDAO.scriptCodeDAO.get
+        .mockResolvedValueOnce({
+          uuid: oldScript.uuid,
+          code: createUserScriptCode(oldScript, "console.log('old');"),
+        })
+        .mockResolvedValueOnce({
+          uuid: newScript.uuid,
+          code: createUserScriptCode(newScript, "console.log('new');"),
+        });
+      mockResourceService.getScriptResources.mockResolvedValue({});
+      mockValueService.getScriptValue.mockResolvedValue({});
+
+      await runtime.getScriptsForTab({
+        url: "https://www.example.com/path",
+        tabId: 1,
+        frameId: 0,
+      });
+      await runtime.getScriptsForTab({
+        url: "https://www.example.com/path",
+        tabId: 1,
+        frameId: 0,
+      });
+
+      expect(compiledResourceDAO.gets).toHaveBeenCalledTimes(2);
+      expect(mockResourceService.getScriptResources).toHaveBeenCalledTimes(2);
+      expect(mockScriptDAO.scriptCodeDAO.get).toHaveBeenCalledTimes(2);
+      expect(runtime.pageLoadCaches.get(oldScript.uuid)?.code).toContain("console.log('new');");
+    });
+
+    it("应该在本地 file resource 改变时更新缓存资源并刷新已注册 userScript", async () => {
+      const resourceUrl = "file:///tmp/local.js";
+      const script = createMockScript({
+        uuid: "local-resource-script",
+        metadata: {
+          match: ["https://www.example.com/*"],
+          require: [resourceUrl],
+        },
+        updatetime: 100,
+      });
+      const scriptRunResource = createScriptRunResource(script);
+      const compiledResource = await createCompiledResourceAsync(script, scriptRunResource);
+      runtime.compiledResourceDAO = {
+        gets: vi.fn().mockResolvedValue([compiledResource]),
+      } as any;
+      mockScriptDAO.gets.mockResolvedValue([script]);
+      mockScriptDAO.scriptCodeDAO.get.mockResolvedValue({
+        uuid: script.uuid,
+        code: createUserScriptCode(script, "console.log('with local resource');"),
+      });
+      mockResourceService.getScriptResources.mockResolvedValue({
+        [resourceUrl]: createTextResource(resourceUrl, "console.log('old resource');", "old-sha"),
+      });
+      mockResourceService.updateResource.mockResolvedValue(
+        createTextResource(resourceUrl, "console.log('new resource');", "new-sha")
+      );
+      mockValueService.getScriptValue.mockResolvedValue({});
+
+      const getScripts = vi.fn().mockResolvedValue([{ id: script.uuid, js: [{ code: "old registered code" }] }]);
+      const update = vi.fn().mockResolvedValue(undefined);
+      vi.spyOn(chrome.userScripts, "getScripts").mockImplementation(getScripts as any);
+      vi.spyOn(chrome.userScripts, "update").mockImplementation(update as any);
+
+      const result = await runtime.getScriptsForTab({
+        url: "https://www.example.com/path",
+        tabId: 1,
+        frameId: 0,
+      });
+
+      expect(result?.injectScriptList[0].resource[resourceUrl].content).toBe("console.log('new resource');");
+      expect(result?.injectScriptList[0].resource[resourceUrl].base64).toBeUndefined();
+      expect(update).toHaveBeenCalledTimes(1);
+      expect(update.mock.calls[0][0][0].id).toBe(script.uuid);
+      const updatedCode = update.mock.calls[0][0][0].js[0].code;
+      expect(updatedCode).toContain("console.log('new resource');");
+      expect(updatedCode).not.toContain("console.log('old resource');");
+      expect(runtime.pageLoadCaches.get(script.uuid)?.localResources[0].sha512).toBe("new-sha");
+    });
+  });
+
+  describe("getPopupPageScriptMatchingResultByUrl", () => {
+    it("应该按需匹配 disabled 脚本，且不写入 runtime disabled matcher 或 page-load cache", async () => {
+      const disabledScript = createMockScript({
+        uuid: "disabled-effective",
+        status: SCRIPT_STATUS_DISABLE,
+        sort: 1,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+      const disabledExcludedScript = createMockScript({
+        uuid: "disabled-excluded",
+        status: SCRIPT_STATUS_DISABLE,
+        sort: 2,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+        selfMetadata: {
+          exclude: ["https://www.example.com/*"],
+        },
+      });
+
+      mockScriptDAO.all.mockResolvedValue([disabledScript, disabledExcludedScript]);
+      expect(runtime.getPageScriptMatchingResultByUrl("https://www.example.com/path", true, true).size).toBe(0);
+
+      const result = await runtime.getPopupPageScriptMatchingResultByUrl("https://www.example.com/path");
+
+      expect(result.get(disabledScript.uuid)).toEqual({
+        uuid: disabledScript.uuid,
+        effective: true,
+      });
+      expect(result.get(disabledExcludedScript.uuid)).toEqual({
+        uuid: disabledExcludedScript.uuid,
+        effective: false,
+      });
+      expect(runtime.getPageScriptMatchingResultByUrl("https://www.example.com/path", true, true).size).toBe(0);
+      expect(runtime.pageLoadCaches.size).toBe(0);
+    });
+
+    it("应该缓存 Popup disabled matcher，重复打开 Popup 时不重复扫描全部脚本", async () => {
+      const disabledScript = createMockScript({
+        uuid: "disabled-cached",
+        status: SCRIPT_STATUS_DISABLE,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+
+      mockScriptDAO.all.mockResolvedValue([disabledScript]);
+
+      const first = await runtime.getPopupPageScriptMatchingResultByUrl("https://www.example.com/path");
+      const second = await runtime.getPopupPageScriptMatchingResultByUrl("https://www.example.com/other");
+
+      expect(first.get(disabledScript.uuid)?.effective).toBe(true);
+      expect(second.get(disabledScript.uuid)?.effective).toBe(true);
+      expect(mockScriptDAO.all).toHaveBeenCalledTimes(1);
+    });
+
+    it("应该在 runtime cache 被清理后重建 Popup disabled matcher", async () => {
+      const oldDisabledScript = createMockScript({
+        uuid: "disabled-old",
+        status: SCRIPT_STATUS_DISABLE,
+        metadata: {
+          match: ["https://old.example.com/*"],
+        },
+      });
+      const newDisabledScript = createMockScript({
+        uuid: "disabled-new",
+        status: SCRIPT_STATUS_DISABLE,
+        metadata: {
+          match: ["https://new.example.com/*"],
+        },
+      });
+
+      mockScriptDAO.all.mockResolvedValueOnce([oldDisabledScript]).mockResolvedValueOnce([newDisabledScript]);
+
+      expect(
+        (await runtime.getPopupPageScriptMatchingResultByUrl("https://old.example.com/path")).has("disabled-old")
+      ).toBe(true);
+      runtime.deleteScriptRuntimeCache(oldDisabledScript.uuid);
+      const result = await runtime.getPopupPageScriptMatchingResultByUrl("https://new.example.com/path");
+
+      expect(result.has("disabled-old")).toBe(false);
+      expect(result.get("disabled-new")?.effective).toBe(true);
+      expect(mockScriptDAO.all).toHaveBeenCalledTimes(2);
+    });
+
+    it("应该合并 enabled matcher 与按需 disabled 匹配，并保留 effective / non-effective 状态", async () => {
+      const enabledScript = createMockScript({
+        uuid: "enabled-effective",
+        sort: 1,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+      const enabledExcludedScript = createMockScript({
+        uuid: "enabled-excluded",
+        sort: 2,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+        selfMetadata: {
+          exclude: ["https://www.example.com/*"],
+        },
+      });
+      const disabledScript = createMockScript({
+        uuid: "disabled-effective",
+        status: SCRIPT_STATUS_DISABLE,
+        sort: 3,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+
+      await runtime.applyScriptMatchInfo(createScriptRunResource(enabledScript));
+      await runtime.applyScriptMatchInfo(createScriptRunResource(enabledExcludedScript));
+      mockScriptDAO.all.mockResolvedValue([enabledScript, enabledExcludedScript, disabledScript]);
+
+      const result = await runtime.getPopupPageScriptMatchingResultByUrl("https://www.example.com/path");
+
+      expect([...result.keys()]).toEqual(["enabled-effective", "enabled-excluded", "disabled-effective"]);
+      expect(result.get(enabledScript.uuid)?.effective).toBe(true);
+      expect(result.get(enabledExcludedScript.uuid)?.effective).toBe(false);
+      expect(result.get(disabledScript.uuid)?.effective).toBe(true);
+    });
+
+    it("应该忽略非普通脚本、enabled 脚本和没有匹配规则的 disabled 脚本按需扫描", async () => {
+      const backgroundScript = createMockScript({
+        uuid: "background-disabled",
+        type: SCRIPT_TYPE_BACKGROUND,
+        status: SCRIPT_STATUS_DISABLE,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+      const enabledScriptNotInMatcher = createMockScript({
+        uuid: "enabled-not-in-runtime-matcher",
+        status: SCRIPT_STATUS_ENABLE,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+      const disabledWithoutRules = createMockScript({
+        uuid: "disabled-without-rules",
+        status: SCRIPT_STATUS_DISABLE,
+        metadata: {},
+      });
+      const disabledMatched = createMockScript({
+        uuid: "disabled-matched",
+        status: SCRIPT_STATUS_DISABLE,
+        metadata: {
+          include: ["*://www.example.com/*"],
+        },
+      });
+
+      mockScriptDAO.all.mockResolvedValue([
+        backgroundScript,
+        enabledScriptNotInMatcher,
+        disabledWithoutRules,
+        disabledMatched,
+      ]);
+
+      const result = await runtime.getPopupPageScriptMatchingResultByUrl("https://www.example.com/path");
+
+      expect([...result.keys()]).toEqual(["disabled-matched"]);
+      expect(mockScriptDAO.all).toHaveBeenCalledTimes(1);
+    });
+
+    it("应该按 disabled 脚本 sort 顺序返回按需匹配结果", async () => {
+      const laterScript = createMockScript({
+        uuid: "sort-later",
+        status: SCRIPT_STATUS_DISABLE,
+        sort: 20,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+      const earlierScript = createMockScript({
+        uuid: "sort-earlier",
+        status: SCRIPT_STATUS_DISABLE,
+        sort: 10,
+        metadata: {
+          match: ["https://www.example.com/*"],
+        },
+      });
+
+      mockScriptDAO.all.mockResolvedValue([laterScript, earlierScript]);
+
+      const result = await runtime.getPopupPageScriptMatchingResultByUrl("https://www.example.com/path");
+
+      expect([...result.keys()]).toEqual(["sort-earlier", "sort-later"]);
+    });
+  });
+
+  describe.concurrent("黑名单测试", async () => {
+    it.concurrent("黑名单测试 A", async () => {
       // Arrange
       const blacklistString = "*://www.blacklisted.com/*";
       mockSystemConfig.getBlacklist.mockReturnValue(blacklistString);
-      runtime.blacklist = obtainBlackList(blacklistString); //  this.systemConfig.addListener("blacklist", ... ) 裡自動更新 blacklist
+      runtime.blacklist = obtainBlackList(blacklistString); //  this.systemConfig.addListener("blacklist", ... ) 里自动更新 blacklist
       runtime.loadBlacklist();
       expect(runtime.blackMatch?.rulesMap?.size || 0).toBe(1);
       expect(runtime.blackMatch?.rulesMap.get("BK")?.length || 0).toBe(1);
@@ -361,11 +902,11 @@ describe.concurrent("RuntimeService - getPageScriptMatchingResultByUrl 脚本匹
       expect(blacklistResult).toBe(true);
     });
 
-    it.concurrent("黑名單測試 B", async () => {
+    it.concurrent("黑名单测试 B", async () => {
       // Arrange
       const blacklistString = "*://www.blacklisted.com/*\nhttps://*.google.com/*";
       mockSystemConfig.getBlacklist.mockReturnValue(blacklistString);
-      runtime.blacklist = obtainBlackList(blacklistString); //  this.systemConfig.addListener("blacklist", ... ) 裡自動更新 blacklist
+      runtime.blacklist = obtainBlackList(blacklistString); //  this.systemConfig.addListener("blacklist", ... ) 里自动更新 blacklist
       runtime.loadBlacklist();
       expect(runtime.blackMatch?.rulesMap?.size || 0).toBe(1);
       expect(runtime.blackMatch?.rulesMap.get("BK")?.length || 0).toBe(2);
diff --git a/src/app/service/service_worker/runtime.ts b/src/app/service/service_worker/runtime.ts
index 8ea36659e..9a9ad684a 100644
--- a/src/app/service/service_worker/runtime.ts
+++ b/src/app/service/service_worker/runtime.ts
@@ -3,7 +3,7 @@ import type { IMessageQueue } from "@Packages/message/message_queue";
 import type { Group, IGetSender } from "@Packages/message/server";
 import type { ExtMessageSender, MessageSend } from "@Packages/message/types";
 import type { TClientPageLoadInfo } from "@App/app/repo/scripts";
-import type { Script, ScriptDAO, ScriptRunResource, ScriptSite, TScriptInfo } from "@App/app/repo/scripts";
+import type { Script, ScriptDAO, ScriptRunResource, ScriptSite, TScriptInfo, UserConfig } from "@App/app/repo/scripts";
 import { SCRIPT_STATUS_DISABLE, SCRIPT_STATUS_ENABLE, SCRIPT_TYPE_NORMAL } from "@App/app/repo/scripts";
 import { type ValueService } from "./value";
 import GMApi, { GMExternalDependencies } from "./gm_api/gm_api";
@@ -46,8 +46,8 @@ import { initLocalesPromise, localePath } from "@App/locales/locales";
 import { DocumentationSite } from "@App/app/const";
 import { extractUrlPatterns, RuleType, type URLRuleEntry } from "@App/pkg/utils/url_matcher";
 import { parseUserConfig } from "@App/pkg/utils/yaml";
-import type { CompiledResource, ResourceType } from "@App/app/repo/resource";
-import { CompiledResourceDAO } from "@App/app/repo/resource";
+import type { CompiledResource, Resource, ResourceType } from "@App/app/repo/resource";
+import { CompiledResourceDAO, CompiledResourceNamespace } from "@App/app/repo/resource";
 import { setOnTabURLChanged } from "./url_monitor";
 import { scriptToMenu, type TPopupPageLoadInfo } from "./popup_scriptmenu";
 
@@ -82,10 +82,42 @@ export type TScriptsForTab = {
   scriptmenus: ScriptMenu[];
 } | null;
 
+type TCodeCache = {
+  code: string;
+  metadataStr: string;
+  userConfigStr: string;
+  userConfig: UserConfig | null;
+  scriptCacheKey: string;
+};
+
+type TLocalResourceCache = {
+  resourceKey: string;
+  url: string;
+  type: ResourceType;
+  sha512: string;
+};
+
+type TRuntimeResource = { base64?: string } & Omit<Resource, "base64">;
+
+type TPageLoadScriptCache = {
+  scriptCacheKey: string;
+  scriptUrlPatterns: URLRuleEntry[];
+  originalUrlPatterns: URLRuleEntry[] | null;
+  code: string;
+  metadataStr: string;
+  userConfigStr: string;
+  userConfig: UserConfig | null;
+  resource: Record<string, TRuntimeResource>;
+  localResources: TLocalResourceCache[];
+};
+
 export class RuntimeService {
   scriptMatchEnable: UrlMatch<string> = new UrlMatch<string>();
   scriptMatchDisable: UrlMatch<string> = new UrlMatch<string>();
   blackMatch: UrlMatch<string> = new UrlMatch<string>();
+  private readonly codeCacheMap = new Map<string, TCodeCache>();
+  public readonly pageLoadCaches = new Map<string, TPageLoadScriptCache>();
+  private popupDisabledScriptMatchCache: UrlMatch<string> | null = null;
 
   logger: Logger;
 
@@ -245,7 +277,10 @@ export class RuntimeService {
 
   createMatchInfoEntry(
     scriptRes: ScriptRunResource,
-    o: { scriptUrlPatterns: URLRuleEntry[]; originalUrlPatterns: URLRuleEntry[] | null }
+    o: {
+      scriptUrlPatterns: URLRuleEntry[];
+      originalUrlPatterns: URLRuleEntry[] | null;
+    }
   ) {
     // 优化性能，将不需要的信息去掉
     // 而且可能会超过缓存的存储限制
@@ -261,16 +296,16 @@ export class RuntimeService {
   }
 
   async waitInit() {
-    const [cRuntimeStartFlag, compiledResources, allScripts] = await Promise.all([
+    const [cRuntimeStartFlag, compiledResourceNamespace, allScripts] = await Promise.all([
       cacheInstance.get<boolean>("runtimeStartFlag"),
-      this.compiledResourceDAO.all(),
+      cacheInstance.get<string>("compiledResourceNamespace"),
       this.scriptDAO.all(),
     ]);
 
     const unregisterScriptIds = [] as string[];
-    // 没有 CompiledResources 表示这是 没有启用脚本 或 代码有改变需要重新安装。
-    // 这个情况会把所有有效脚本跟Inject&Content脚本先取消注册。后续载入时会重新以新代码注册。
-    const cleanUpPreviousRegister = !compiledResources.length;
+    // CompiledResourceNamespace 改变表示注册资料结构或注入代码可能已变。
+    // 这个情况会把有效脚本跟 Inject/Content 脚本先取消注册，后续载入时再重新注册。
+    const cleanUpPreviousRegister = compiledResourceNamespace !== CompiledResourceNamespace;
     this.initialCompiledResourcePromise = Promise.all(
       allScripts.map(async (script) => {
         const uuid = script.uuid;
@@ -285,7 +320,7 @@ export class RuntimeService {
           if (uuid) unregisterScriptIds.push(uuid);
         }
 
-        if (isNormalScript) {
+        if (isNormalScript && enable) {
           let compiledResource = await this.compiledResourceDAO.get(uuid);
           if (!compiledResource) {
             const ret = await this.buildAndSaveCompiledResourceFromScript(script, false);
@@ -324,6 +359,9 @@ export class RuntimeService {
     if (!cRuntimeStartFlag) {
       await cacheInstance.set<boolean>("runtimeStartFlag", true);
     }
+    if (cleanUpPreviousRegister) {
+      await cacheInstance.set<string>("compiledResourceNamespace", CompiledResourceNamespace);
+    }
 
     let count = 0;
     try {
@@ -348,6 +386,16 @@ export class RuntimeService {
     await this.loadPageScript(script, apiScript!);
   }
 
+  deleteScriptRuntimeCache(uuid: string) {
+    this.pageLoadCaches.delete(uuid);
+    this.codeCacheMap.delete(uuid);
+    this.clearPopupDisabledScriptMatchCache();
+  }
+
+  private clearPopupDisabledScriptMatchCache() {
+    this.popupDisabledScriptMatchCache = null;
+  }
+
   init() {
     // 启动gm api
     const permission = new PermissionVerify(this.group.group("permission"), this.mq);
@@ -371,6 +419,7 @@ export class RuntimeService {
     this.mq.subscribe<TEnableScript[]>("enableScripts", async (data) => {
       const unregisteyUuids = [] as string[];
       for (const { uuid, enable } of data) {
+        this.deleteScriptRuntimeCache(uuid);
         const script = await this.scriptDAO.get(uuid);
         if (!script) {
           this.logger.error("script enable failed, script not found", {
@@ -402,6 +451,7 @@ export class RuntimeService {
 
     // 监听脚本安装
     this.mq.subscribe<TInstallScript>("installScript", async (data) => {
+      this.deleteScriptRuntimeCache(data.script.uuid);
       const script = await this.scriptDAO.get(data.script.uuid);
       if (!script) {
         this.logger.error("script install failed, script not found", {
@@ -414,9 +464,6 @@ export class RuntimeService {
         const enable = script.status === SCRIPT_STATUS_ENABLE;
         if (enable) {
           await this.updateResourceOnScriptChange(script);
-        } else {
-          // 还是要建立 CompiledResoure, 否则 Popup 看不到 Script
-          await this.buildAndSaveCompiledResourceFromScript(script, false);
         }
       }
     });
@@ -426,6 +473,7 @@ export class RuntimeService {
       const unregisteyUuids = [] as string[];
       for (const { uuid } of data) {
         unregisteyUuids.push(uuid);
+        this.deleteScriptRuntimeCache(uuid);
         this.scriptMatchEnable.clearRules(uuid);
         this.scriptMatchEnable.clearRules(`${uuid}${ORIGINAL_URLMATCH_SUFFIX}`);
         this.scriptMatchDisable.clearRules(uuid);
@@ -439,6 +487,7 @@ export class RuntimeService {
       const uuidSort = Object.fromEntries(scripts.map(({ uuid, sort }) => [uuid, sort]));
       this.scriptMatchEnable.setupSorter(uuidSort);
       this.scriptMatchDisable.setupSorter(uuidSort);
+      this.clearPopupDisabledScriptMatchCache();
     });
 
     // 监听offscreen环境初始化, 初始化完成后, 再将后台脚本运行起来
@@ -1032,6 +1081,52 @@ export class RuntimeService {
     return ret;
   }
 
+  async getPopupPageScriptMatchingResultByUrl(url: string) {
+    const ret = this.getPageScriptMatchingResultByUrl(url, false, true);
+    const disabledMatch = await this.getPopupDisabledScriptMatch();
+
+    for (const e of disabledMatch.urlMatch(url)) {
+      const uuid = e.endsWith(ORIGINAL_URLMATCH_SUFFIX) ? e.slice(0, -ORIGINAL_URLMATCH_SUFFIX.length) : e;
+      const o = ret.get(uuid) || { uuid, effective: false };
+      if (e === uuid) {
+        o.effective = true;
+      }
+      ret.set(uuid, o);
+    }
+    return ret;
+  }
+
+  private async getPopupDisabledScriptMatch() {
+    if (this.popupDisabledScriptMatchCache) {
+      return this.popupDisabledScriptMatchCache;
+    }
+    const disabledMatch = new UrlMatch<string>();
+    const uuidSort: Record<string, number> = {};
+    const scripts = await this.scriptDAO.all();
+    for (const script of scripts) {
+      if (script.type !== SCRIPT_TYPE_NORMAL || script.status !== SCRIPT_STATUS_DISABLE) {
+        continue;
+      }
+
+      const scriptRes = buildScriptRunResourceBasic(script);
+      const patterns = scriptURLPatternResults(scriptRes);
+      if (!patterns) continue;
+
+      const uuid = script.uuid;
+      const uuidOri = `${uuid}${ORIGINAL_URLMATCH_SUFFIX}`;
+      uuidSort[uuid] = script.sort;
+      uuidSort[uuidOri] = script.sort;
+      disabledMatch.addRules(uuid, patterns.scriptUrlPatterns);
+      if (patterns.originalUrlPatterns !== patterns.scriptUrlPatterns) {
+        disabledMatch.addRules(uuidOri, patterns.originalUrlPatterns);
+      }
+    }
+
+    disabledMatch.setupSorter(uuidSort);
+    this.popupDisabledScriptMatchCache = disabledMatch;
+    return disabledMatch;
+  }
+
   async updateSites() {
     if (this.sitesLoaded.size === 0 || this.updateSitesBusy) return;
     this.updateSitesBusy = true;
@@ -1103,158 +1198,71 @@ export class RuntimeService {
     // 该网址没有任何脚本匹配，包括排除匹配
     if (!matchingResult.size) return null;
 
-    const enableScriptList = [] as (ScriptLoadInfo & { scriptUrlPatterns: URLRuleEntry[] })[];
-
     const uuids = [...matchingResult.keys()];
+    const enableScriptListByIndex = new Array<(ScriptLoadInfo & { scriptUrlPatterns: URLRuleEntry[] }) | undefined>(
+      uuids.length
+    );
+    const cacheMisses = [] as {
+      index: number;
+      script: Script;
+      scriptRes: ScriptRunResource;
+      scriptCacheKey: string;
+    }[];
 
-    const [scripts, compiledResources] = await Promise.all([
-      this.scriptDAO.gets(uuids),
-      this.compiledResourceDAO.gets(uuids),
-    ]);
-
-    const resourceChecks = {} as { [uuid: string]: Record<string, [string, ResourceType]> };
+    const scripts = await this.scriptDAO.gets(uuids);
 
     for (let idx = 0, l = uuids.length; idx < l; idx++) {
-      const uuid = uuids[idx];
       const script = scripts[idx];
-      const compiledResource = compiledResources[idx];
-
-      if (!script || !compiledResource) continue;
-      const scriptRes_ = buildScriptRunResourceBasic(script);
-      const { scriptUrlPatterns, originalUrlPatterns } = compiledResource;
-
-      for (const [_key, res] of Object.entries(scriptRes_.resource)) {
-        if (res.url.startsWith("file:///")) {
-          const resourceCheck =
-            resourceChecks[uuid] || (resourceChecks[uuid] = {} as Record<string, [string, ResourceType]>);
-          resourceCheck[res.url] = [res.hash.sha512, res.type];
-        }
-      }
-
-      // 物件部份内容预设为空
-      const scriptRes = {
-        ...scriptRes_,
-        scriptUrlPatterns: scriptUrlPatterns,
-        originalUrlPatterns: originalUrlPatterns === null ? scriptUrlPatterns : originalUrlPatterns,
-        code: "",
-        value: {},
-        resource: {},
-        metadataStr: "",
-        userConfigStr: "",
-      };
+      if (!script) continue;
 
-      // 判断脚本是否开启
-      if (scriptRes.status === SCRIPT_STATUS_DISABLE) {
+      const scriptRes = buildScriptRunResourceBasic(script);
+      if (this.shouldSkipPageLoadScript(scriptRes, frameId)) {
         continue;
       }
-      // 判断注入页面类型
-      if (scriptRes.metadata["run-in"]) {
-        const runIn = scriptRes.metadata["run-in"][0];
-        if (runIn !== "all") {
-          // 判断插件运行环境
-          const contextType = chrome.extension.inIncognitoContext ? "incognito-tabs" : "normal-tabs";
-          if (runIn !== contextType) {
-            continue;
-          }
-        }
+
+      const scriptCacheKey = this.getPageLoadScriptCacheKey(scriptRes);
+      const cache = this.getPageLoadScriptCache(script.uuid, scriptCacheKey);
+      if (cache) {
+        enableScriptListByIndex[idx] = this.createPageLoadScriptInfo(scriptRes, cache);
+      } else {
+        cacheMisses.push({ index: idx, script, scriptRes, scriptCacheKey });
       }
-      // 如果是iframe,判断是否允许在iframe里运行
-      if (frameId) {
-        if (scriptRes.metadata.noframes) {
-          continue;
+    }
+
+    if (cacheMisses.length) {
+      const compiledResources = await this.compiledResourceDAO.gets(cacheMisses.map(({ script }) => script.uuid));
+      for (let idx = 0, l = cacheMisses.length; idx < l; idx++) {
+        const { index, script, scriptRes, scriptCacheKey } = cacheMisses[idx];
+        let compiledResource = compiledResources[idx];
+        if (!compiledResource || !compiledResource.scriptUrlPatterns?.length) {
+          const ret = await this.buildAndSaveCompiledResourceFromScript(script, false);
+          compiledResource = ret?.compiledResource;
         }
+        if (!compiledResource?.scriptUrlPatterns?.length) continue;
+
+        const cache = await this.buildPageLoadScriptCache(scriptRes, compiledResource, scriptCacheKey);
+        this.pageLoadCaches.set(script.uuid, cache);
+        enableScriptListByIndex[index] = this.createPageLoadScriptInfo(scriptRes, cache);
       }
-      enableScriptList.push(scriptRes);
     }
 
+    const enableScriptList = enableScriptListByIndex.filter((script) => !!script) as (ScriptLoadInfo & {
+      scriptUrlPatterns: URLRuleEntry[];
+    })[];
+
     // 没有任何启用脚本
     if (!enableScriptList.length) return null;
 
     const scriptCodes = {} as Record<string, string>;
-    // 更新资源使用了file协议的脚本
-    const scriptsWithUpdatedResources = new Map<string, ScriptLoadInfo>();
-    for (const scriptRes of enableScriptList) {
-      const uuid = scriptRes.uuid;
-      const resourceCheck = resourceChecks[uuid];
-      if (resourceCheck) {
-        let resourceUpdated = false;
-        for (const [url, [sha512, type]] of Object.entries(resourceCheck)) {
-          const resourceList = scriptRes.metadata[type];
-          if (!resourceList) continue;
-          const updatedResource = await this.resource.updateResource(scriptRes.uuid, url, type);
-          if (updatedResource.hash?.sha512 !== sha512) {
-            for (const uri of resourceList) {
-              /** 资源键名 */
-              let resourceKey = uri;
-              /** 文件路径 */
-              let path: string | null = uri;
-              if (type === "resource") {
-                // @resource xxx https://...
-                const split = uri.split(/\s+/);
-                if (split.length === 2) {
-                  resourceKey = split[0];
-                  path = split[1].trim();
-                } else {
-                  path = null;
-                }
-              }
-              if (path === url) {
-                const r = scriptRes.resource[resourceKey];
-                if (r) {
-                  resourceUpdated = true;
-                  r.content = updatedResource.content;
-                  r.contentType = updatedResource.contentType;
-                  r.createtime = updatedResource.createtime;
-                  r.hash = updatedResource.hash;
-                  r.link = updatedResource.link;
-                  r.type = updatedResource.type;
-                  r.updatetime = updatedResource.updatetime;
-                }
-              }
-            }
-          }
-        }
-        if (resourceUpdated) {
-          scriptsWithUpdatedResources.set(scriptRes.uuid, scriptRes);
-          scriptCodes[scriptRes.uuid] = scriptRes.code || "";
-        }
-      }
-    }
+    const scriptsWithUpdatedResources = await this.refreshLocalResourcesForPageLoad(enableScriptList, scriptCodes);
 
-    const { value, resource, scriptDAO } = this;
     await Promise.all(
-      enableScriptList.flatMap((script) => [
-        // 加载value
-        value.getScriptValue(script!).then((value) => {
+      enableScriptList.map((script) =>
+        // 加载value；value 不进入 page-load cache，每次都取最新值
+        this.value.getScriptValue(script).then((value) => {
           script.value = value;
-        }),
-        // 加载resource
-        resource.getScriptResources(script, false).then((resource) => {
-          script.resource = resource;
-          for (const name of Object.keys(resource)) {
-            const res = script.resource[name];
-            // 删除base64以节省资源
-            // 如果有content就删除base64
-            if (res.content) {
-              res.base64 = undefined;
-            }
-          }
-        }),
-        // 加载code相关的信息
-        scriptDAO.scriptCodeDAO.get(script.uuid).then((code) => {
-          if (code) {
-            const metadataStr = getMetadataStr(code.code) || "";
-            const userConfigStr = getUserConfigStr(code.code) || "";
-            const userConfig = parseUserConfig(userConfigStr);
-            script.metadataStr = metadataStr;
-            script.userConfigStr = userConfigStr;
-            script.userConfig = userConfig;
-            if (scriptCodes[script.uuid] === "") {
-              scriptCodes[script.uuid] = code.code;
-            }
-          }
-        }),
-      ])
+        })
+      )
     );
 
     if (scriptsWithUpdatedResources.size) {
@@ -1326,6 +1334,204 @@ export class RuntimeService {
     } satisfies TScriptsForTab;
   }
 
+  private shouldSkipPageLoadScript(scriptRes: ScriptRunResource, frameId: number | undefined) {
+    // 判断脚本是否开启
+    if (scriptRes.status === SCRIPT_STATUS_DISABLE) {
+      return true;
+    }
+    // 判断注入页面类型
+    if (scriptRes.metadata["run-in"]) {
+      const runIn = scriptRes.metadata["run-in"][0];
+      if (runIn !== "all") {
+        // 判断插件运行环境
+        const contextType = chrome.extension.inIncognitoContext ? "incognito-tabs" : "normal-tabs";
+        if (runIn !== contextType) {
+          return true;
+        }
+      }
+    }
+    // 如果是iframe,判断是否允许在iframe里运行
+    if (frameId && scriptRes.metadata.noframes) {
+      return true;
+    }
+    return false;
+  }
+
+  private getPageLoadScriptCacheKey(scriptRes: ScriptRunResource) {
+    return JSON.stringify({
+      metadata: scriptRes.metadata,
+      originalMetadata: scriptRes.originalMetadata,
+      selfMetadata: scriptRes.selfMetadata || {},
+      status: scriptRes.status,
+      type: scriptRes.type,
+      updatetime: scriptRes.updatetime || 0,
+    });
+  }
+
+  private getScriptCodeCacheKey(script: Script) {
+    return `${script.createtime || 0}:${script.updatetime || 0}`;
+  }
+
+  private getPageLoadScriptCache(uuid: string, scriptCacheKey: string) {
+    const cache = this.pageLoadCaches.get(uuid);
+    if (!cache) return undefined;
+    if (cache.scriptCacheKey !== scriptCacheKey || !cache.scriptUrlPatterns?.length) {
+      this.pageLoadCaches.delete(uuid);
+      return undefined;
+    }
+    return cache;
+  }
+
+  private createPageLoadScriptInfo(scriptRes: ScriptRunResource, cache: TPageLoadScriptCache) {
+    return {
+      ...scriptRes,
+      scriptUrlPatterns: cache.scriptUrlPatterns,
+      originalUrlPatterns: cache.originalUrlPatterns === null ? cache.scriptUrlPatterns : cache.originalUrlPatterns,
+      code: "",
+      value: {},
+      resource: cache.resource,
+      metadataStr: cache.metadataStr,
+      userConfigStr: cache.userConfigStr,
+      userConfig: cache.userConfig || undefined,
+    } as ScriptLoadInfo & { scriptUrlPatterns: URLRuleEntry[] };
+  }
+
+  private cloneRuntimeResource(resource: Resource) {
+    const ret = { ...resource } as TRuntimeResource;
+    // 删除base64以节省资源；如果有content就删除base64
+    if (ret.content) {
+      ret.base64 = undefined;
+    }
+    return ret;
+  }
+
+  private cloneRuntimeResources(resources: Record<string, Resource>) {
+    const ret = {} as Record<string, TRuntimeResource>;
+    for (const [name, resource] of Object.entries(resources)) {
+      ret[name] = this.cloneRuntimeResource(resource);
+    }
+    return ret;
+  }
+
+  private getLocalResourceCacheList(scriptRes: ScriptRunResource, resources: Record<string, TRuntimeResource>) {
+    const ret: TLocalResourceCache[] = [];
+    const collect = (type: ResourceType) => {
+      for (const uri of scriptRes.metadata[type] || []) {
+        let resourceKey = uri;
+        let path: string | null = uri;
+        if (type === "resource") {
+          // @resource xxx file:///...
+          const split = uri.split(/\s+/);
+          if (split.length === 2) {
+            resourceKey = split[0];
+            path = split[1].trim();
+          } else {
+            path = null;
+          }
+        }
+        if (path?.startsWith("file:///")) {
+          ret.push({
+            resourceKey,
+            url: path,
+            type,
+            sha512: resources[resourceKey]?.hash?.sha512 || "",
+          });
+        }
+      }
+    };
+    collect("require");
+    collect("require-css");
+    collect("resource");
+    return ret;
+  }
+
+  private async buildPageLoadScriptCache(
+    scriptRes: ScriptRunResource,
+    compiledResource: CompiledResource,
+    scriptCacheKey: string
+  ): Promise<TPageLoadScriptCache> {
+    const [resources, codeInfo] = await Promise.all([
+      this.resource.getScriptResources(scriptRes, false).then((resources) => this.cloneRuntimeResources(resources)),
+      this.getScriptInfoForCode(scriptRes),
+    ]);
+    return {
+      scriptCacheKey,
+      scriptUrlPatterns: compiledResource.scriptUrlPatterns,
+      originalUrlPatterns: compiledResource.originalUrlPatterns,
+      code: codeInfo.code,
+      metadataStr: codeInfo.metadataStr,
+      userConfigStr: codeInfo.userConfigStr,
+      userConfig: codeInfo.userConfig,
+      resource: resources,
+      localResources: this.getLocalResourceCacheList(scriptRes, resources),
+    };
+  }
+
+  private async refreshLocalResourcesForPageLoad(
+    enableScriptList: (ScriptLoadInfo & {
+      scriptUrlPatterns: URLRuleEntry[];
+    })[],
+    scriptCodes: Record<string, string>
+  ) {
+    const scriptsWithUpdatedResources = new Map<string, ScriptLoadInfo>();
+    for (const scriptRes of enableScriptList) {
+      const cache = this.pageLoadCaches.get(scriptRes.uuid);
+      if (!cache?.localResources.length) continue;
+
+      let resourceUpdated = false;
+      for (const localResource of cache.localResources) {
+        let updatedResource: Resource;
+        try {
+          updatedResource = await this.resource.updateResource(scriptRes.uuid, localResource.url, localResource.type);
+        } catch (e) {
+          this.logger.error(
+            "update local resource on page load failed",
+            { uuid: scriptRes.uuid, url: localResource.url },
+            Logger.E(e)
+          );
+          continue;
+        }
+        const nextSha512 = updatedResource.hash?.sha512 || "";
+        if (nextSha512 === localResource.sha512) continue;
+
+        localResource.sha512 = nextSha512;
+        const runtimeResource = this.cloneRuntimeResource(updatedResource);
+        cache.resource[localResource.resourceKey] = runtimeResource;
+        scriptRes.resource[localResource.resourceKey] = runtimeResource;
+        resourceUpdated = true;
+      }
+
+      if (resourceUpdated) {
+        scriptsWithUpdatedResources.set(scriptRes.uuid, scriptRes);
+        scriptCodes[scriptRes.uuid] = cache.code;
+      }
+    }
+    return scriptsWithUpdatedResources;
+  }
+
+  private async getScriptInfoForCode(script: Script): Promise<TCodeCache> {
+    const scriptCacheKey = this.getScriptCodeCacheKey(script);
+    const cached = this.codeCacheMap.get(script.uuid);
+    if (cached?.scriptCacheKey === scriptCacheKey) {
+      return cached;
+    }
+
+    const code = await this.scriptDAO.scriptCodeDAO.get(script.uuid);
+    const codeText = code?.code || "";
+    const metadataStr = code ? getMetadataStr(codeText) || "" : "";
+    const userConfigStr = code ? getUserConfigStr(codeText) || "" : "";
+    const userConfig = userConfigStr ? parseUserConfig(userConfigStr) || null : null;
+    const ret = {
+      scriptCacheKey,
+      code: codeText,
+      metadataStr,
+      userConfigStr,
+      userConfig,
+    };
+    this.codeCacheMap.set(script.uuid, ret);
+    return ret;
+  }
+
   // 停止脚本
   async stopScript(uuid: string) {
     return await stopScript(this.msgSender, uuid);