diff --git a/src/app/migrate.ts b/src/app/migrate.ts
index 63244e79e..1f02a2500 100644
--- a/src/app/migrate.ts
+++ b/src/app/migrate.ts
@@ -267,25 +267,43 @@ export function migrateChromeStorage() {
         );
       },
     },
+    {
+      version: 2,
+      upgrade: async () => {
+        const scriptCodeDAO = new ScriptCodeDAO();
+        // 从 chrome.storage.local 读取所有旧代码
+        const scriptCodes = await scriptCodeDAO.all();
+        // 仅写入 OPFS，避免写放大（不通过 save() 回写 chrome.storage.local）
+        await Promise.all(scriptCodes.map(async (scriptCode) => scriptCodeDAO.saveToOPFS(scriptCode)));
+      },
+    },
   ];
   const localstorageDAO = new LocalStorageDAO();
   localstorageDAO.get("migrations").then(async (item) => {
-    const migrations = item?.value || [];
+    const migrations: number[] = item?.value || [];
     for (let i = 0; i < migrationList.length; i++) {
       const m = migrationList[i];
-      if (!migrations.includes(m.version)) {
-        try {
-          await m.upgrade();
-          migrations.push(m.version);
-        } catch (e) {
-          throw new Error(`Chrome storage migration v${m.version} failed: ${e}`);
-        }
+      if (migrations.includes(m.version)) {
+        continue;
+      }
+      // 保证顺序：前一个版本必须已完成
+      if (i > 0 && !migrations.includes(migrationList[i - 1].version)) {
+        throw new Error(
+          `Chrome storage migration v${m.version} skipped: v${migrationList[i - 1].version} not completed`
+        );
+      }
+      try {
+        await m.upgrade();
+        migrations.push(m.version);
+        // 每步成功后立即持久化，避免 SW 挂起导致进度丢失
+        await localstorageDAO.save({
+          key: "migrations",
+          value: migrations,
+        });
+      } catch (e) {
+        throw new Error(`Chrome storage migration v${m.version} failed: ${e}`);
       }
     }
-    localstorageDAO.save({
-      key: "migrations",
-      value: migrations,
-    });
   });
 }
 
diff --git a/src/app/repo/scripts.test.ts b/src/app/repo/scripts.test.ts
index 54f040456..657e67812 100644
--- a/src/app/repo/scripts.test.ts
+++ b/src/app/repo/scripts.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import {
   ScriptDAO,
+  ScriptCodeDAO,
   type Script,
   SCRIPT_TYPE_NORMAL,
   SCRIPT_STATUS_ENABLE,
@@ -152,3 +153,71 @@ describe("ScriptDAO.searchExistingScript", () => {
     expect(found[0]).toBeUndefined();
   });
 });
+
+describe("ScriptCodeDAO", () => {
+  let dao: ScriptCodeDAO;
+
+  beforeEach(async () => {
+    await chrome.storage.local.clear();
+    (globalThis as any).__clearOPFSMock?.();
+    dao = new ScriptCodeDAO();
+  });
+
+  it("save 后 get 应该从 OPFS 读取", async () => {
+    await dao.save({ uuid: "test-1", code: "alert('hello');" });
+    const result = await dao.get("test-1");
+    expect(result).toBeDefined();
+    expect(result!.code).toBe("alert('hello');");
+  });
+
+  it("get 不存在的脚本应返回 undefined", async () => {
+    const result = await dao.get("nonexistent");
+    expect(result).toBeUndefined();
+  });
+
+  it("OPFS 不存在时应 fallback 到 chrome.storage.local", async () => {
+    await chrome.storage.local.set({ "scriptCode:old-script": { uuid: "old-script", code: "old code" } });
+    const result = await dao.get("old-script");
+    expect(result).toBeDefined();
+    expect(result!.code).toBe("old code");
+  });
+
+  it("fallback 读取后应懒迁移到 OPFS", async () => {
+    await chrome.storage.local.set({ "scriptCode:lazy": { uuid: "lazy", code: "lazy code" } });
+    await dao.get("lazy");
+    // 等待懒迁移的异步写入完成
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await chrome.storage.local.clear();
+    const dao2 = new ScriptCodeDAO();
+    const result = await dao2.get("lazy");
+    expect(result).toBeDefined();
+    expect(result!.code).toBe("lazy code");
+  });
+
+  it("delete 应同时删除 OPFS 和 chrome.storage.local", async () => {
+    await dao.save({ uuid: "del-test", code: "to delete" });
+    await dao.delete("del-test");
+    const result = await dao.get("del-test");
+    expect(result).toBeUndefined();
+  });
+
+  it("gets 应批量获取", async () => {
+    await dao.save({ uuid: "a", code: "code-a" });
+    await dao.save({ uuid: "b", code: "code-b" });
+    const results = await dao.gets(["a", "b", "c"]);
+    expect(results[0]?.code).toBe("code-a");
+    expect(results[1]?.code).toBe("code-b");
+    expect(results[2]).toBeUndefined();
+  });
+
+  it("saveToOPFS 仅写 OPFS 不写 chrome.storage.local", async () => {
+    await dao.saveToOPFS({ uuid: "opfs-only", code: "opfs code" });
+    const storageResult = await new Promise<any>((resolve) => {
+      chrome.storage.local.get("scriptCode:opfs-only", resolve);
+    });
+    expect(storageResult["scriptCode:opfs-only"]).toBeUndefined();
+    const result = await dao.get("opfs-only");
+    expect(result).toBeDefined();
+    expect(result!.code).toBe("opfs code");
+  });
+});
diff --git a/src/app/repo/scripts.ts b/src/app/repo/scripts.ts
index 6fcc2b86f..0ea510495 100644
--- a/src/app/repo/scripts.ts
+++ b/src/app/repo/scripts.ts
@@ -78,7 +78,7 @@ export interface Script {
   checktime: number; // 脚本检查更新时间戳
   lastruntime?: number; // 脚本最后一次运行时间戳
   nextruntime?: number; // 脚本下一次运行时间戳
-  ignoreVersion?: string; // 忽略單一版本的更新檢查
+  ignoreVersion?: string; // 忽略单一版本的更新检查
 }
 
 // 分开存储脚本代码
@@ -147,33 +147,18 @@ export type TClientPageLoadInfo =
   | { ok: false };
 
 export class ScriptDAO extends Repo<Script> {
-  scriptCodeDAO: ScriptCodeDAO = new ScriptCodeDAO();
-
   constructor() {
     super("script");
   }
 
   enableCache(): void {
     super.enableCache();
-    this.scriptCodeDAO.enableCache();
   }
 
   public save(val: Script) {
     return super._save(val.uuid, val);
   }
 
-  findByUUID(uuid: string) {
-    return this.get(uuid);
-  }
-
-  async getAndCode(uuid: string): Promise<ScriptAndCode | undefined> {
-    const [script, code] = await Promise.all([this.get(uuid), this.scriptCodeDAO.get(uuid)]);
-    if (!script || !code) {
-      return undefined;
-    }
-    return Object.assign(script, code);
-  }
-
   public findByName(name: string) {
     return this.findOne((key, value) => {
       return value.name === name;
@@ -235,7 +220,7 @@ export class ScriptDAO extends Repo<Script> {
         if (val1.length < 2) {
           return val1[0] === val2[0];
         }
-        // 無視次序
+        // 无视次序
         const s = new Set([...val1, ...val2]);
         if (s.size !== val1.length) return false;
         return true;
@@ -243,14 +228,14 @@ export class ScriptDAO extends Repo<Script> {
       return val1 === val2;
     };
     const isScriptInfoEqual = (script1: Script, script2: Script) => {
-      // @author, @copyright, @license 應該不會改
+      // @author, @copyright, @license 应该不会改
       if (!valEqual(script1.metadata.author, script2.metadata.author)) return false;
       if (!valEqual(script1.metadata.copyright, script2.metadata.copyright)) return false;
       if (!valEqual(script1.metadata.license, script2.metadata.license)) return false;
-      // @grant, @connect 應該不會改
+      // @grant, @connect 应该不会改
       if (!valEqual(script1.metadata.grant, script2.metadata.grant)) return false;
       if (!valEqual(script1.metadata.connect, script2.metadata.connect)) return false;
-      // @match @include 應該不會改
+      // @match @include 应该不会改
       if (!valEqual(script1.metadata.match, script2.metadata.match)) return false;
       if (!valEqual(script1.metadata.include, script2.metadata.include)) return false;
       return true;
@@ -293,16 +278,148 @@ export class ScriptDAO extends Repo<Script> {
 }
 
 // 为了防止脚本代码数据量过大,单独存储脚本代码
-export class ScriptCodeDAO extends Repo<ScriptCode> {
-  constructor() {
-    super("scriptCode");
+// 内部使用 OPFS 优先存储，fallback 到 chrome.storage.local（过渡期间）
+export class ScriptCodeDAO {
+  private static readonly LEGACY_PREFIX = "scriptCode:";
+  private _dirHandlePromise: Promise<FileSystemDirectoryHandle> | null = null;
+
+  private getDirHandle(): Promise<FileSystemDirectoryHandle> {
+    if (!this._dirHandlePromise) {
+      this._dirHandlePromise = navigator.storage
+        .getDirectory()
+        .then((opfsRoot) => opfsRoot.getDirectoryHandle("script_codes", { create: true }));
+    }
+    return this._dirHandlePromise;
   }
 
-  findByUUID(uuid: string) {
-    return this.get(uuid);
+  // 仅写入 OPFS，供迁移使用，避免写放大
+  public async saveToOPFS(val: ScriptCode): Promise<void> {
+    const folder = await this.getDirHandle();
+    const handle = await folder.getFileHandle(`${val.uuid}.user.js`, { create: true });
+    const writable = await handle.createWritable({ keepExistingData: false });
+    await writable.write(val.code);
+    await writable.close();
   }
 
-  public save(val: ScriptCode) {
-    return super._save(val.uuid, val);
+  public async save(val: ScriptCode): Promise<ScriptCode> {
+    // 写入 OPFS（失败不影响 chrome.storage.local）
+    try {
+      await this.saveToOPFS(val);
+    } catch {
+      // OPFS 写入失败，忽略
+    }
+    // 过渡期间同步写入 chrome.storage.local
+    await this.legacySave(val);
+    return val;
+  }
+
+  public async get(key: string): Promise<ScriptCode | undefined> {
+    // 优先从 OPFS 读取
+    try {
+      const folder = await this.getDirHandle();
+      const handle = await folder.getFileHandle(`${key}.user.js`, { create: false });
+      const code = await handle.getFile().then((f) => f.text());
+      return { uuid: key, code };
+    } catch {
+      // OPFS 没有，fallback 到 chrome.storage.local
+    }
+    const result = await this.legacyGet(key);
+    if (result) {
+      // 懒迁移：写入 OPFS
+      this.saveToOPFS(result).catch(() => {});
+    }
+    return result;
+  }
+
+  public async gets(keys: string[]): Promise<(ScriptCode | undefined)[]> {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+
+  public async delete(key: string): Promise<void> {
+    // 删除 OPFS
+    try {
+      const folder = await this.getDirHandle();
+      await folder.removeEntry(`${key}.user.js`);
+    } catch {
+      // 忽略删除失败
+    }
+    // 过渡期间同步删除 chrome.storage.local
+    await this.legacyDelete([key]);
+  }
+
+  public async deletes(keys: string[]): Promise<void> {
+    // 删除 OPFS
+    try {
+      const folder = await this.getDirHandle();
+      await Promise.all(
+        keys.map(async (key) => {
+          try {
+            await folder.removeEntry(`${key}.user.js`);
+          } catch {
+            // 忽略
+          }
+        })
+      );
+    } catch {
+      // 忽略
+    }
+    // 过渡期间同步删除 chrome.storage.local
+    await this.legacyDelete(keys);
+  }
+
+  // --- 过渡期间 chrome.storage.local 操作，过渡结束后删除 ---
+
+  // 从 chrome.storage.local 读取所有脚本代码（仅迁移使用）
+  public all(): Promise<ScriptCode[]> {
+    return new Promise((resolve) => {
+      chrome.storage.local.get(null, (items) => {
+        if (chrome.runtime.lastError) {
+          console.error("chrome.storage.local.get error:", chrome.runtime.lastError);
+        }
+        const result: ScriptCode[] = [];
+        for (const key in items) {
+          if (key.startsWith(ScriptCodeDAO.LEGACY_PREFIX)) {
+            result.push(items[key]);
+          }
+        }
+        resolve(result);
+      });
+    });
+  }
+
+  private legacySave(val: ScriptCode): Promise<void> {
+    const key = ScriptCodeDAO.LEGACY_PREFIX + val.uuid;
+    return new Promise((resolve) => {
+      chrome.storage.local.set({ [key]: val }, () => {
+        if (chrome.runtime.lastError) {
+          console.error("chrome.storage.local.set error:", chrome.runtime.lastError);
+        }
+        resolve();
+      });
+    });
+  }
+
+  private legacyGet(key: string): Promise<ScriptCode | undefined> {
+    const storageKey = ScriptCodeDAO.LEGACY_PREFIX + key;
+    return new Promise((resolve) => {
+      chrome.storage.local.get(storageKey, (items) => {
+        if (chrome.runtime.lastError) {
+          console.error("chrome.storage.local.get error:", chrome.runtime.lastError);
+        }
+        resolve(items[storageKey]);
+      });
+    });
+  }
+
+  private legacyDelete(keys: string[]): Promise<void> {
+    const storageKeys = keys.map((key) => ScriptCodeDAO.LEGACY_PREFIX + key);
+    return new Promise((resolve) => {
+      chrome.storage.local.remove(storageKeys, () => {
+        if (chrome.runtime.lastError) {
+          console.error("chrome.storage.local.remove error:", chrome.runtime.lastError);
+        }
+        resolve();
+      });
+    });
   }
 }
diff --git a/src/app/service/service_worker/runtime.ts b/src/app/service/service_worker/runtime.ts
index 8ddc0dc00..3e1cdd72c 100644
--- a/src/app/service/service_worker/runtime.ts
+++ b/src/app/service/service_worker/runtime.ts
@@ -2,7 +2,7 @@ import type { EmitEventRequest, ScriptLoadInfo, ScriptMatchInfo, ScriptMenu } fr
 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 { ScriptCodeDAO, type TClientPageLoadInfo } from "@App/app/repo/scripts";
 import type { Script, ScriptDAO, ScriptRunResource, ScriptSite, TScriptInfo } 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";
@@ -128,6 +128,7 @@ export class RuntimeService {
   initialCompiledResourcePromise: Promise<any> | undefined;
 
   compiledResourceDAO: CompiledResourceDAO = new CompiledResourceDAO();
+  private readonly scriptCodeDAO: ScriptCodeDAO = new ScriptCodeDAO();
 
   constructor(
     private systemConfig: SystemConfig,
@@ -1245,7 +1246,7 @@ export class RuntimeService {
       }
     }
 
-    const { value, resource, scriptDAO } = this;
+    const { value, resource, scriptCodeDAO } = this;
     await Promise.all(
       enableScriptList.flatMap((script) => [
         // 加载value
@@ -1265,7 +1266,7 @@ export class RuntimeService {
           }
         }),
         // 加载code相关的信息
-        scriptDAO.scriptCodeDAO.get(script.uuid).then((code) => {
+        scriptCodeDAO.get(script.uuid).then((code) => {
           if (code) {
             const metadataStr = getMetadataStr(code.code) || "";
             const userConfigStr = getUserConfigStr(code.code) || "";
diff --git a/src/app/service/service_worker/script.ts b/src/app/service/service_worker/script.ts
index ca6b6da2b..1b9d286f8 100644
--- a/src/app/service/service_worker/script.ts
+++ b/src/app/service/service_worker/script.ts
@@ -83,7 +83,7 @@ export class ScriptService {
     private readonly scriptDAO: ScriptDAO
   ) {
     this.logger = LoggerCore.logger().with({ service: "script" });
-    this.scriptCodeDAO.enableCache();
+    // this.scriptCodeDAO.enableCache();
     this.scriptUpdateCheck = new ScriptUpdateCheck(systemConfig, group, mq, valueService, resourceService, scriptDAO);
   }
 
diff --git a/src/app/service/service_worker/synchronize.ts b/src/app/service/service_worker/synchronize.ts
index 9d2c00a7f..c8794ca9a 100644
--- a/src/app/service/service_worker/synchronize.ts
+++ b/src/app/service/service_worker/synchronize.ts
@@ -5,8 +5,8 @@ import {
   type Script,
   SCRIPT_STATUS_DISABLE,
   SCRIPT_STATUS_ENABLE,
+  ScriptCodeDAO,
   type ScriptDAO,
-  type ScriptCodeDAO,
 } from "@App/app/repo/scripts";
 import BackupExport from "@App/pkg/backup/export";
 import type { BackupData, ResourceBackup, ScriptBackupData, ScriptOptions, ValueStorage } from "@App/pkg/backup/struct";
@@ -69,7 +69,7 @@ type PushScriptParam = TInstallScriptParams;
 export class SynchronizeService {
   logger: Logger;
 
-  scriptCodeDAO: ScriptCodeDAO;
+  readonly scriptCodeDAO: ScriptCodeDAO = new ScriptCodeDAO();
 
   storage: ChromeStorage = new ChromeStorage("sync", false);
 
@@ -84,7 +84,6 @@ export class SynchronizeService {
     private scriptDAO: ScriptDAO
   ) {
     this.logger = LoggerCore.logger().with({ service: "synchronize" });
-    this.scriptCodeDAO = this.scriptDAO.scriptCodeDAO;
   }
 
   // 生成备份文件到文件系统
diff --git a/src/pages/components/CloudScriptPlan/index.tsx b/src/pages/components/CloudScriptPlan/index.tsx
index c74710b88..760476e59 100644
--- a/src/pages/components/CloudScriptPlan/index.tsx
+++ b/src/pages/components/CloudScriptPlan/index.tsx
@@ -123,7 +123,7 @@ const CloudScriptPlan: React.FC<{
             zip: zipFile,
             ...params,
           });
-          const code = await new ScriptCodeDAO().findByUUID(script.uuid);
+          const code = await new ScriptCodeDAO().get(script.uuid);
           if (!code) {
             Message.error(t("invalid_script_code"));
             return;
diff --git a/src/pages/options/routes/script/ScriptEditor.tsx b/src/pages/options/routes/script/ScriptEditor.tsx
index 2cb856004..551086965 100644
--- a/src/pages/options/routes/script/ScriptEditor.tsx
+++ b/src/pages/options/routes/script/ScriptEditor.tsx
@@ -273,7 +273,7 @@ function ScriptEditor() {
         // 如果不在，从数据库读取
         const script = scriptList.find((s) => s.uuid === uuid);
         if (script) {
-          const code = await scriptCodeDAO.findByUUID(uuid);
+          const code = await scriptCodeDAO.get(uuid);
           const newEditor: EditorState = {
             script,
             code: code?.code || "",
diff --git a/tests/opfs_mock.ts b/tests/opfs_mock.ts
new file mode 100644
index 000000000..6e421474e
--- /dev/null
+++ b/tests/opfs_mock.ts
@@ -0,0 +1,74 @@
+// OPFS mock - 内存中模拟 FileSystem API
+const opfsMockStorage: Record<string, Record<string, string>> = {};
+
+class MockFileSystemWritableFileStream {
+  private _dirName: string;
+  private _fileName: string;
+  constructor(dirName: string, fileName: string) {
+    this._dirName = dirName;
+    this._fileName = fileName;
+  }
+  async write(data: string) {
+    if (!opfsMockStorage[this._dirName]) opfsMockStorage[this._dirName] = {};
+    opfsMockStorage[this._dirName][this._fileName] = data;
+  }
+  async close() {}
+}
+
+class MockFileSystemFileHandle {
+  private _dirName: string;
+  private _fileName: string;
+  constructor(dirName: string, fileName: string) {
+    this._dirName = dirName;
+    this._fileName = fileName;
+  }
+  async createWritable(_opts?: { keepExistingData: boolean }) {
+    return new MockFileSystemWritableFileStream(this._dirName, this._fileName);
+  }
+  async getFile() {
+    const content = opfsMockStorage[this._dirName]?.[this._fileName] ?? "";
+    return { text: async () => content };
+  }
+}
+
+class MockFileSystemDirectoryHandle {
+  private _name: string;
+  constructor(name: string) {
+    this._name = name;
+  }
+  async getDirectoryHandle(name: string, opts?: { create: boolean }) {
+    if (!opts?.create && !opfsMockStorage[name]) {
+      throw new DOMException("NotFoundError");
+    }
+    if (opts?.create && !opfsMockStorage[name]) {
+      opfsMockStorage[name] = {};
+    }
+    return new MockFileSystemDirectoryHandle(name);
+  }
+  async getFileHandle(name: string, opts?: { create: boolean }) {
+    if (!opts?.create && !opfsMockStorage[this._name]?.[name]) {
+      throw new DOMException("NotFoundError");
+    }
+    return new MockFileSystemFileHandle(this._name, name);
+  }
+  async removeEntry(name: string) {
+    if (opfsMockStorage[this._name]) {
+      delete opfsMockStorage[this._name][name];
+    }
+  }
+}
+
+export function installOPFSMock() {
+  Object.defineProperty(navigator, "storage", {
+    value: {
+      getDirectory: async () => new MockFileSystemDirectoryHandle("opfs-root"),
+    },
+    writable: true,
+  });
+}
+
+export function clearOPFSMock() {
+  for (const key of Object.keys(opfsMockStorage)) {
+    delete opfsMockStorage[key];
+  }
+}
diff --git a/tests/vitest.setup.ts b/tests/vitest.setup.ts
index 8dcc95fc4..e47e55dec 100644
--- a/tests/vitest.setup.ts
+++ b/tests/vitest.setup.ts
@@ -262,3 +262,10 @@ vi.stubGlobal("define", "特殊关键字不能穿透沙盒");
 if (!URL.createObjectURL) URL.createObjectURL = undefined;
 //@ts-expect-error
 if (!URL.revokeObjectURL) URL.revokeObjectURL = undefined;
+
+import { installOPFSMock, clearOPFSMock } from "./opfs_mock";
+
+installOPFSMock();
+
+// 导出清理函数供测试使用
+(globalThis as any).__clearOPFSMock = clearOPFSMock;