diff --git a/src/app/repo/repo.ts b/src/app/repo/repo.ts
index 88ce0c0eb..7c373503e 100644
--- a/src/app/repo/repo.ts
+++ b/src/app/repo/repo.ts
@@ -1,42 +1,149 @@
 // 加载全局缓存
 
-let loadCachePromise: Promise<any> | undefined = undefined;
-let cache: { [key: string]: any } | undefined = undefined;
+let loadCachePromise: Promise<Partial<Record<string, any>>> | undefined = undefined;
+let cache: Partial<Record<string, any>> | undefined = undefined;
 
 // 加载数据到缓存
-function loadCache(): Promise<any> {
+function loadCache(): Promise<Partial<Record<string, any>>> {
   if (cache) {
     return Promise.resolve(cache);
   }
-  if (loadCachePromise) {
-    return loadCachePromise;
+  if (!loadCachePromise) {
+    loadCachePromise = new Promise<Partial<Record<string, any>>>((resolve) => {
+      chrome.storage.local.get((result: Partial<Record<string, any>> | undefined) => {
+        const lastError = chrome.runtime.lastError;
+        if (lastError) {
+          console.error("chrome.runtime.lastError in chrome.storage.local.get:", lastError);
+          // 无视storage API错误，继续执行
+        }
+        cache = result || {};
+        loadCachePromise = undefined;
+        resolve(cache);
+      });
+    });
   }
-  loadCachePromise = new Promise((resolve) => {
-    chrome.storage.local.get((result: { [key: string]: any } | undefined) => {
+  return loadCachePromise;
+}
+
+function saveCacheAndStorage<T>(key: string, value: T): Promise<T> {
+  return Promise.all([
+    loadCache().then((cache) => {
+      cache[key] = value;
+    }),
+    new Promise<void>((resolve) => {
+      chrome.storage.local.set({ [key]: value }, () => {
+        const lastError = chrome.runtime.lastError;
+        if (lastError) {
+          console.error("chrome.runtime.lastError in chrome.storage.local.set:", lastError);
+          // 无视storage API错误，继续执行
+        }
+        resolve();
+      });
+    }),
+  ]).then(() => value);
+}
+
+function saveStorage<T>(key: string, value: T): Promise<T> {
+  return new Promise((resolve) => {
+    chrome.storage.local.set(
+      {
+        [key]: value,
+      },
+      () => {
+        const lastError = chrome.runtime.lastError;
+        if (lastError) {
+          console.error("chrome.runtime.lastError in chrome.storage.local.set:", lastError);
+          // 无视storage API错误，继续执行
+        }
+        resolve(value);
+      }
+    );
+  });
+}
+
+function saveStorageRecord(record: Partial<Record<string, any>>): Promise<void> {
+  return new Promise((resolve) => {
+    chrome.storage.local.set(record, () => {
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        console.error("chrome.runtime.lastError in chrome.storage.local.set:", lastError);
+        // 无视storage API错误，继续执行
+      }
+      resolve();
+    });
+  });
+}
+
+function getCache(key: string): Promise<any> {
+  return loadCache().then((cache) => {
+    if (cache[key]) {
+      return Object.assign({}, cache[key]);
+    }
+    return cache[key];
+  });
+}
+
+function getStorage(key: string): Promise<any> {
+  return new Promise((resolve) => {
+    chrome.storage.local.get(key, (result) => {
       const lastError = chrome.runtime.lastError;
       if (lastError) {
         console.error("chrome.runtime.lastError in chrome.storage.local.get:", lastError);
         // 无视storage API错误，继续执行
       }
-      cache = result;
-      resolve(cache);
+      resolve(result[key]);
     });
   });
-  return loadCachePromise;
 }
 
-function saveCache(key: string, value: any) {
-  loadCache().then(() => {
-    cache![key] = value;
+function getStorageRecord(keys: string[]): Promise<Partial<Record<string, any>>> {
+  return new Promise((resolve) => {
+    chrome.storage.local.get(keys, (result) => {
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        console.error("chrome.runtime.lastError in chrome.storage.local.get:", lastError);
+        // 无视storage API错误，继续执行
+      }
+      resolve(result);
+    });
   });
-  return chrome.storage.local.set({ [key]: value });
 }
 
 function deleteCache(key: string) {
-  loadCache().then(() => {
-    delete cache![key];
+  return loadCache().then((cache) => {
+    delete cache[key];
+  });
+}
+
+function deleteStorage(key: string) {
+  return new Promise<void>((resolve) => {
+    chrome.storage.local.remove(key, () => {
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        console.error("chrome.runtime.lastError in chrome.storage.local.remove:", lastError);
+        // 无视storage API错误，继续执行
+      }
+      resolve();
+    });
+  });
+}
+function deletesStorage(keys: string[]) {
+  return new Promise<void>((resolve, reject) => {
+    chrome.storage.local.remove(keys, () => {
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        console.error("chrome.runtime.lastError in chrome.storage.local.remove:", lastError);
+        // 无视storage API错误，继续执行
+        reject();
+      }
+      resolve();
+    });
+  }).catch(async () => {
+    // fallback
+    for (const key of keys) {
+      await deleteStorage(key);
+    }
   });
-  return chrome.storage.local.remove(key);
 }
 
 export abstract class Repo<T> {
@@ -58,44 +165,41 @@ export abstract class Repo<T> {
   }
 
   protected async _save(key: string, val: T): Promise<T> {
-    return new Promise((resolve) => {
-      const data = {
-        [this.joinKey(key)]: val,
-      };
-      if (this.useCache) {
-        return saveCache(this.joinKey(key), val).then(() => {
-          return resolve(val);
-        });
-      }
-      chrome.storage.local.set(data, () => {
-        const lastError = chrome.runtime.lastError;
-        if (lastError) {
-          console.error("chrome.runtime.lastError in chrome.storage.local.set:", lastError);
-          // 无视storage API错误，继续执行
-        }
-        resolve(val);
-      });
-    });
+    key = this.joinKey(key);
+    if (this.useCache) {
+      return saveCacheAndStorage(key, val);
+    }
+    return saveStorage(key, val);
   }
 
   public get(key: string): Promise<T | undefined> {
+    key = this.joinKey(key);
+    if (this.useCache) {
+      return getCache(key);
+    }
+    return getStorage(key);
+  }
+
+  public gets(keys: string[]): Promise<(T | undefined)[]> {
+    keys = keys.map((key) => this.joinKey(key));
     if (this.useCache) {
       return loadCache().then((cache) => {
-        if (cache[this.joinKey(key)]) {
-          return Object.assign({}, cache[this.joinKey(key)]);
-        }
-        return cache[this.joinKey(key)];
+        return keys.map((key) => {
+          if (cache[key]) {
+            return Object.assign({}, cache[key]);
+          }
+          return cache[key];
+        });
       });
     }
     return new Promise((resolve) => {
-      key = this.joinKey(key);
-      chrome.storage.local.get(key, (result) => {
+      chrome.storage.local.get(keys, (result) => {
         const lastError = chrome.runtime.lastError;
         if (lastError) {
           console.error("chrome.runtime.lastError in chrome.storage.local.get:", lastError);
           // 无视storage API错误，继续执行
         }
-        resolve(result[key]);
+        resolve(keys.map((key) => result[key]));
       });
     });
   }
@@ -123,69 +227,98 @@ export abstract class Repo<T> {
         });
       });
     }
-    const loadData = () => {
-      return new Promise<T[]>((resolve) => {
-        chrome.storage.local.get((result: { [key: string]: T }) => {
-          const lastError = chrome.runtime.lastError;
-          if (lastError) {
-            console.error("chrome.runtime.lastError in chrome.storage.local.get:", lastError);
-            // 无视storage API错误，继续执行
-          }
-          resolve(this.filter(result, filters));
-        });
+    return new Promise<T[]>((resolve) => {
+      chrome.storage.local.get((result: { [key: string]: T }) => {
+        const lastError = chrome.runtime.lastError;
+        if (lastError) {
+          console.error("chrome.runtime.lastError in chrome.storage.local.get:", lastError);
+          // 无视storage API错误，继续执行
+        }
+        resolve(this.filter(result, filters));
       });
-    };
-    return loadData();
+    });
   }
 
   async findOne(filters?: (key: string, value: T) => boolean): Promise<T | undefined> {
-    const list = await this.find(filters);
-    if (list.length > 0) {
-      return list[0];
-    }
-    return undefined;
+    return this.find(filters).then((list) => {
+      if (list.length > 0) {
+        return list[0];
+      }
+      return undefined;
+    });
   }
 
-  public delete(key: string) {
+  public delete(key: string): Promise<void> {
+    key = this.joinKey(key);
     if (this.useCache) {
-      return deleteCache(this.joinKey(key));
+      return Promise.all([deleteCache(key), deleteStorage(key)]).then(() => undefined);
     }
-    return new Promise<void>((resolve) => {
-      chrome.storage.local.remove(this.joinKey(key), () => {
-        const lastError = chrome.runtime.lastError;
-        if (lastError) {
-          console.error("chrome.runtime.lastError in chrome.storage.local.remove:", lastError);
-          // 无视storage API错误，继续执行
+    return deleteStorage(key);
+  }
+
+  public deletes(keys: string[]): Promise<void> {
+    keys = keys.map((key) => this.joinKey(key));
+    if (this.useCache) {
+      return loadCache().then((cache) => {
+        for (const key of keys) {
+          delete cache[key];
         }
-        resolve();
+        return deletesStorage(keys);
       });
-    });
+    }
+    return deletesStorage(keys);
   }
 
+  // 資料不存在時無法更新, 回傳 false
+  // 資料存在時進行Object.assign更新，回傳更新後的資料項目
   update(key: string, val: Partial<T>): Promise<T | false> {
+    key = this.joinKey(key);
     if (this.useCache) {
       return loadCache().then((cache) => {
-        const data = cache[this.joinKey(key)];
+        const data = cache[key] as T;
         if (data) {
           Object.assign(data, val);
-          return saveCache(this.joinKey(key), data).then(() => {
-            return data;
-          });
+          return saveCacheAndStorage(key, data) as Promise<T | false>;
         }
         return false;
       });
     }
-    return new Promise((resolve) => {
-      this.get(key).then((result) => {
-        if (result) {
-          Object.assign(result, val);
-          this._save(key, result).then(() => {
-            resolve(result);
-          });
-        } else {
-          resolve(false);
+    return getStorage(key).then((result) => {
+      if (result) {
+        Object.assign(result, val);
+        return saveStorage(key, result) as T;
+      } else {
+        return false;
+      }
+    });
+  }
+
+  updates(keys: string[], val: Partial<T>): Promise<(T | false)[]> {
+    keys = keys.map((key) => this.joinKey(key));
+    if (this.useCache) {
+      return loadCache().then((cache) =>
+        Promise.all(
+          keys.map((key) => {
+            const data = cache[key] as T;
+            if (data) {
+              Object.assign(data, val);
+              return saveCacheAndStorage(key, data) as Promise<T>;
+            }
+            return false;
+          })
+        )
+      );
+    }
+    return getStorageRecord(keys).then((record) => {
+      const result = keys.map((key) => {
+        const o = record[key];
+        if (o) {
+          Object.assign(o, val);
+          return o as T;
         }
+        return false;
       });
+      return saveStorageRecord(record).then(() => result);
     });
   }
 
diff --git a/src/app/service/offscreen/script.ts b/src/app/service/offscreen/script.ts
index 75e1a1553..0b9425aea 100644
--- a/src/app/service/offscreen/script.ts
+++ b/src/app/service/offscreen/script.ts
@@ -35,17 +35,19 @@ export class ScriptService {
   }
 
   async init() {
-    this.messageQueue.subscribe<TEnableScript>("enableScript", async (data) => {
-      const script = await this.scriptClient.info(data.uuid);
-      if (script.type === SCRIPT_TYPE_NORMAL) {
-        return;
-      }
-      if (data.enable) {
-        // 构造脚本运行资源,发送给沙盒运行
-        enableScript(this.windowMessage, await this.scriptClient.getScriptRunResource(script));
-      } else {
-        // 发送给沙盒停止
-        disableScript(this.windowMessage, script.uuid);
+    this.messageQueue.subscribe<TEnableScript[]>("enableScripts", async (data) => {
+      for (const { uuid, enable } of data) {
+        const script = await this.scriptClient.info(uuid);
+        if (script.type === SCRIPT_TYPE_NORMAL) {
+          continue;
+        }
+        if (enable) {
+          // 构造脚本运行资源,发送给沙盒运行
+          enableScript(this.windowMessage, await this.scriptClient.getScriptRunResourceByUUID(uuid));
+        } else {
+          // 发送给沙盒停止
+          disableScript(this.windowMessage, script.uuid);
+        }
       }
     });
     this.messageQueue.subscribe<TInstallScript>("installScript", async (data) => {
@@ -56,14 +58,16 @@ export class ScriptService {
       // 判断是开启还是关闭
       if (data.script.status === SCRIPT_STATUS_ENABLE) {
         // 构造脚本运行资源,发送给沙盒运行
-        enableScript(this.windowMessage, await this.scriptClient.getScriptRunResource(data.script));
+        enableScript(this.windowMessage, await this.scriptClient.getScriptRunResourceByUUID(data.script.uuid));
       } else {
         // 发送给沙盒停止
         disableScript(this.windowMessage, data.script.uuid);
       }
     });
-    this.messageQueue.subscribe<TDeleteScript>("deleteScript", async (data) => {
-      disableScript(this.windowMessage, data.uuid);
+    this.messageQueue.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
+      for (const { uuid } of data) {
+        await disableScript(this.windowMessage, uuid);
+      }
     });
 
     this.group.on("runScript", this.runScript.bind(this));
diff --git a/src/app/service/queue.ts b/src/app/service/queue.ts
index a73cfc07c..9d591aaec 100644
--- a/src/app/service/queue.ts
+++ b/src/app/service/queue.ts
@@ -1,12 +1,23 @@
-import type { Script, SCRIPT_RUN_STATUS } from "../repo/scripts";
+import type { Script, SCRIPT_RUN_STATUS, SCRIPT_STATUS, SCRIPT_TYPE } from "../repo/scripts";
 import type { InstallSource, ScriptMenuItem } from "./service_worker/types";
 import type { Subscribe } from "../repo/subscribe";
 
-export type TInstallScript = { script: Script; update: boolean; upsertBy?: InstallSource };
+export type TInstallScriptParams = {
+  uuid: string; // 脚本uuid,通过脚本uuid识别唯一脚本
+  type: SCRIPT_TYPE; // 脚本类型 1:普通脚本 2:定时脚本 3:后台脚本
+  status: SCRIPT_STATUS; // 脚本状态 1:启用 2:禁用 3:错误 4:初始化
+  name: string; // 脚本名称
+  namespace: string; // 脚本命名空间
+  origin?: string; // 脚本来源
+  checkUpdateUrl?: string; // 检查更新URL
+  downloadUrl?: string; // 脚本下载URL
+};
+
+export type TInstallScript = { script: TInstallScriptParams; update: boolean; upsertBy?: InstallSource };
 
-export type TDeleteScript = { uuid: string; script: Script };
+export type TDeleteScript = { uuid: string; storageName: string };
 
-export type TSortScript = Script[];
+export type TSortedScript = { uuid: string; sort: number };
 
 export type TInstallSubscribe = { subscribe: Subscribe };
 
diff --git a/src/app/service/service_worker/client.ts b/src/app/service/service_worker/client.ts
index c170a5825..95d3e9212 100644
--- a/src/app/service/service_worker/client.ts
+++ b/src/app/service/service_worker/client.ts
@@ -46,14 +46,22 @@ export class ScriptClient extends Client {
     return this.doThrow("install", { script, code, upsertBy });
   }
 
-  delete(uuid: string) {
-    return this.do("delete", uuid);
+  // delete(uuid: string) {
+  //   return this.do("delete", uuid);
+  // }
+
+  deletes(uuids: string[]) {
+    return this.do("deletes", uuids);
   }
 
   enable(uuid: string, enable: boolean) {
     return this.do("enable", { uuid, enable });
   }
 
+  enables(uuids: string[], enable: boolean) {
+    return this.do("enables", { uuids, enable });
+  }
+
   info(uuid: string): Promise<Script> {
     return this.doThrow("fetchInfo", uuid);
   }
@@ -62,8 +70,12 @@ export class ScriptClient extends Client {
     return this.do("getFilterResult", req);
   }
 
-  getScriptRunResource(script: Script): Promise<ScriptRunResource> {
-    return this.doThrow("getScriptRunResource", script);
+  // getScriptRunResource(script: Script): Promise<ScriptRunResource> {
+  //   return this.doThrow("getScriptRunResource", script);
+  // }
+
+  getScriptRunResourceByUUID(uuid: string): Promise<ScriptRunResource> {
+    return this.doThrow("getScriptRunResourceByUUID", uuid);
   }
 
   excludeUrl(uuid: string, excludePattern: string, remove: boolean) {
@@ -88,6 +100,10 @@ export class ScriptClient extends Client {
     return this.do("sortScript", { active, over });
   }
 
+  pinToTop(uuids: string[]) {
+    return this.do("pinToTop", uuids);
+  }
+
   importByUrl(url: string) {
     return this.do("importByUrl", url);
   }
diff --git a/src/app/service/service_worker/permission_verify.ts b/src/app/service/service_worker/permission_verify.ts
index 9c1f94c57..a34a55f03 100644
--- a/src/app/service/service_worker/permission_verify.ts
+++ b/src/app/service/service_worker/permission_verify.ts
@@ -380,9 +380,11 @@ export default class PermissionVerify {
     this.group.on("updatePermission", this.updatePermission.bind(this));
     this.group.on("resetPermission", this.resetPermission.bind(this));
 
-    this.mq.subscribe<TDeleteScript>("deleteScript", (data) => {
+    this.mq.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
       // 删除脚本的所有权限
-      this.resetPermission(data.script.uuid);
+      for (const { uuid } of data) {
+        await this.resetPermission(uuid);
+      }
     });
   }
 }
diff --git a/src/app/service/service_worker/popup.ts b/src/app/service/service_worker/popup.ts
index f1040fc8b..95ba860ea 100644
--- a/src/app/service/service_worker/popup.ts
+++ b/src/app/service/service_worker/popup.ts
@@ -252,7 +252,12 @@ export class PopupService {
 
   dealBackgroundScriptInstall() {
     // 处理后台脚本
-    this.mq.subscribe<TInstallScript>("installScript", async ({ script }) => {
+    this.mq.subscribe<TInstallScript>("installScript", async (data) => {
+      const uuid = data.script.uuid;
+      const script = await this.scriptDAO.get(uuid);
+      if (!script) {
+        return;
+      }
       if (script.type === SCRIPT_TYPE_NORMAL) {
         return;
       }
@@ -269,41 +274,45 @@ export class PopupService {
         return menu;
       });
     });
-    this.mq.subscribe<TEnableScript>("enableScript", async ({ uuid }) => {
-      const script = await this.scriptDAO.get(uuid);
-      if (!script) {
-        return;
-      }
-      if (script.type === SCRIPT_TYPE_NORMAL) {
-        return;
-      }
-      return this.txUpdateScriptMenu(-1, (menu) => {
-        const index = menu.findIndex((item) => item.uuid === uuid);
-        if (script.status === SCRIPT_STATUS_ENABLE) {
-          // 加入菜单
-          if (index === -1) {
-            const item = this.scriptToMenu(script);
-            menu.push(item);
+    this.mq.subscribe<TEnableScript[]>("enableScripts", async (data): Promise<ScriptMenu[]> => {
+      return this.txUpdateScriptMenu(-1, async (menu) => {
+        for (const { uuid } of data) {
+          const script = await this.scriptDAO.get(uuid);
+          if (!script) {
+            continue;
           }
-        } else {
-          // 移出菜单
-          if (index !== -1) {
-            menu.splice(index, 1);
+          if (script.type === SCRIPT_TYPE_NORMAL) {
+            continue;
+          }
+          const index = menu.findIndex((item) => item.uuid === uuid);
+          if (script.status === SCRIPT_STATUS_ENABLE) {
+            // 加入菜单
+            if (index === -1) {
+              const item = this.scriptToMenu(script);
+              menu.push(item);
+            }
+          } else {
+            // 移出菜单
+            if (index !== -1) {
+              menu.splice(index, 1);
+            }
           }
         }
         return menu;
       });
     });
-    this.mq.subscribe<TDeleteScript>("deleteScript", async ({ uuid }) => {
+    this.mq.subscribe<TDeleteScript[]>("deleteScripts", (data): Promise<ScriptMenu[]> => {
       return this.txUpdateScriptMenu(-1, (menu) => {
-        const index = menu.findIndex((item) => item.uuid === uuid);
-        if (index !== -1) {
-          menu.splice(index, 1);
+        for (const { uuid } of data) {
+          const index = menu.findIndex((item) => item.uuid === uuid);
+          if (index !== -1) {
+            menu.splice(index, 1);
+          }
         }
         return menu;
       });
     });
-    this.mq.subscribe<TScriptRunStatus>("scriptRunStatus", async ({ uuid, runStatus }) => {
+    this.mq.subscribe<TScriptRunStatus>("scriptRunStatus", ({ uuid, runStatus }): Promise<ScriptMenu[]> => {
       return this.txUpdateScriptMenu(-1, (menu) => {
         const scriptMenu = menu.find((item) => item.uuid === uuid);
         if (scriptMenu) {
diff --git a/src/app/service/service_worker/resource.ts b/src/app/service/service_worker/resource.ts
index c13e49889..e55daea35 100644
--- a/src/app/service/service_worker/resource.ts
+++ b/src/app/service/service_worker/resource.ts
@@ -329,25 +329,27 @@ export class ResourceService {
     this.group.on("deleteResource", this.deleteResource.bind(this));
 
     // 删除相关资源
-    this.mq.subscribe<TDeleteScript>("deleteScript", (data) => {
+    this.mq.subscribe<TDeleteScript[]>("deleteScripts", (data) => {
       // 使用事务当锁，避免并发删除导致数据不一致
       cacheInstance.tx("resource_lock", async (_start) => {
-        const resources = await this.resourceDAO.find((key, value) => {
-          return value.link[data.uuid];
-        });
-        for (const res of resources) {
-          // 删除link
-          delete res.link[data.uuid];
+        for (const { uuid } of data) {
+          const resources = await this.resourceDAO.find((key, value) => {
+            return value.link[uuid];
+          });
+          for (const res of resources) {
+            // 删除link
+            delete res.link[uuid];
+          }
+          await Promise.all(
+            resources.map((res) => {
+              if (Object.keys(res.link).length > 0) {
+                return this.resourceDAO.update(res.url, res);
+              }
+              // 如果没有关联脚本了,删除资源
+              return this.resourceDAO.delete(res.url);
+            })
+          );
         }
-        await Promise.all(
-          resources.map((res) => {
-            if (Object.keys(res.link).length > 0) {
-              return this.resourceDAO.update(res.url, res);
-            }
-            // 如果没有关联脚本了,删除资源
-            return this.resourceDAO.delete(res.url);
-          })
-        );
         return true;
       });
     });
diff --git a/src/app/service/service_worker/runtime.ts b/src/app/service/service_worker/runtime.ts
index 592964e85..a096b0142 100644
--- a/src/app/service/service_worker/runtime.ts
+++ b/src/app/service/service_worker/runtime.ts
@@ -6,7 +6,7 @@ import type { Script, SCRIPT_STATUS, ScriptDAO, ScriptRunResource } from "@App/a
 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";
-import type { TDeleteScript, TEnableScript, TInstallScript, TScriptValueUpdate, TSortScript } from "../queue";
+import type { TDeleteScript, TEnableScript, TInstallScript, TScriptValueUpdate, TSortedScript } from "../queue";
 import { type ScriptService } from "./script";
 import { runScript, stopScript } from "../offscreen/client";
 import { getRunAt } from "./utils";
@@ -208,22 +208,24 @@ export class RuntimeService {
     this.group.on("pageLoad", this.pageLoad.bind(this));
 
     // 监听脚本开启
-    this.mq.subscribe<TEnableScript>("enableScript", async (data) => {
-      const script = await this.scriptDAO.getAndCode(data.uuid);
-      if (!script) {
-        this.logger.error("script enable failed, script not found", {
-          uuid: data.uuid,
-        });
-        return;
-      }
-      // 如果是普通脚本, 在service worker中进行注册
-      // 如果是后台脚本, 在offscreen中进行处理
-      if (script.type === SCRIPT_TYPE_NORMAL) {
-        // 加载页面脚本
-        // 不管开没开启都要加载一次脚本信息
-        await this.loadPageScript(script);
-        if (!data.enable) {
-          await this.unregistryPageScript(script.uuid);
+    this.mq.subscribe<TEnableScript[]>("enableScripts", async (data) => {
+      for (const { uuid, enable } of data) {
+        const script = await this.scriptDAO.getAndCode(uuid);
+        if (!script) {
+          this.logger.error("script enable failed, script not found", {
+            uuid: uuid,
+          });
+          continue;
+        }
+        // 如果是普通脚本, 在service worker中进行注册
+        // 如果是后台脚本, 在offscreen中进行处理
+        if (script.type === SCRIPT_TYPE_NORMAL) {
+          // 加载页面脚本
+          // 不管开没开启都要加载一次脚本信息
+          await this.loadPageScript(script);
+          if (!enable) {
+            await this.unregistryPageScript(script.uuid);
+          }
         }
       }
     });
@@ -245,15 +247,17 @@ export class RuntimeService {
     });
 
     // 监听脚本删除
-    this.mq.subscribe<TDeleteScript>("deleteScript", async ({ uuid }) => {
-      await this.unregistryPageScript(uuid);
-      await this.deleteScriptMatch(uuid);
+    this.mq.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
+      for (const { uuid } of data) {
+        await this.unregistryPageScript(uuid);
+        await this.deleteScriptMatch(uuid);
+      }
       // 初始化会把所有的脚本flag注入，所以只用安装和卸载时重新注入flag
       await this.reRegisterInjectScript();
     });
 
     // 监听脚本排序
-    this.mq.subscribe<TSortScript>("sortScript", async (scripts) => {
+    this.mq.subscribe<TSortedScript[]>("sortedScripts", async (scripts) => {
       const uuidSort = Object.fromEntries(scripts.map(({ uuid, sort }) => [uuid, sort]));
       this.scriptMatch.setupSorter(uuidSort);
       // 更新缓存
@@ -272,15 +276,19 @@ export class RuntimeService {
     // 监听offscreen环境初始化, 初始化完成后, 再将后台脚本运行起来
     this.mq.subscribe("preparationOffscreen", () => {
       this.scriptDAO.all().then((list) => {
+        const res = [];
         for (const script of list) {
           if (script.type === SCRIPT_TYPE_NORMAL) {
             continue;
           }
-          this.mq.publish<TEnableScript>("enableScript", {
+          res.push({
             uuid: script.uuid,
             enable: script.status === SCRIPT_STATUS_ENABLE,
           });
         }
+        if (res.length > 0) {
+          this.mq.publish<TEnableScript[]>("enableScripts", res);
+        }
       });
     });
 
diff --git a/src/app/service/service_worker/script.ts b/src/app/service/service_worker/script.ts
index fa1144367..54c0d6cff 100644
--- a/src/app/service/service_worker/script.ts
+++ b/src/app/service/service_worker/script.ts
@@ -9,11 +9,12 @@ import {
   checkSilenceUpdate,
   getBrowserType,
   InfoNotification,
+  getStorageName,
   openInCurrentTab,
   randomMessageFlag,
 } from "@App/pkg/utils/utils";
 import { ltever } from "@App/pkg/utils/semver";
-import type { Script, SCRIPT_RUN_STATUS, ScriptDAO, ScriptRunResource } from "@App/app/repo/scripts";
+import type { SCMetadata, Script, SCRIPT_RUN_STATUS, ScriptDAO, ScriptRunResource } from "@App/app/repo/scripts";
 import { SCRIPT_STATUS_DISABLE, SCRIPT_STATUS_ENABLE, ScriptCodeDAO } from "@App/app/repo/scripts";
 import { type MessageQueue } from "@Packages/message/message_queue";
 import { createScriptInfo, type ScriptInfo, type InstallSource } from "@App/pkg/utils/scriptInstall";
@@ -24,7 +25,14 @@ import { type SystemConfig } from "@App/pkg/config/config";
 import { localePath } from "@App/locales/locales";
 import { arrayMove } from "@dnd-kit/sortable";
 import { DocumentationSite } from "@App/app/const";
-import type { TScriptRunStatus, TDeleteScript, TEnableScript, TInstallScript, TSortScript } from "../queue";
+import type {
+  TScriptRunStatus,
+  TDeleteScript,
+  TEnableScript,
+  TInstallScript,
+  TSortedScript,
+  TInstallScriptParams,
+} from "../queue";
 import { timeoutExecution } from "@App/pkg/utils/timer";
 import { getCombinedMeta, selfMetadataUpdate } from "./utils";
 import type { SearchType } from "./types";
@@ -36,12 +44,12 @@ export class ScriptService {
   scriptCodeDAO: ScriptCodeDAO = new ScriptCodeDAO();
 
   constructor(
-    private systemConfig: SystemConfig,
-    private group: Group,
-    private mq: MessageQueue,
-    private valueService: ValueService,
-    private resourceService: ResourceService,
-    private scriptDAO: ScriptDAO
+    private readonly systemConfig: SystemConfig,
+    private readonly group: Group,
+    private readonly mq: MessageQueue,
+    private readonly valueService: ValueService,
+    private readonly resourceService: ResourceService,
+    private readonly scriptDAO: ScriptDAO
   ) {
     this.logger = LoggerCore.logger().with({ service: "script" });
     this.scriptCodeDAO.enableCache();
@@ -218,6 +226,12 @@ export class ScriptService {
     return cacheInstance.get<[boolean, ScriptInfo]>(cacheKey);
   }
 
+  publishInstallScript(scriptFull: Script, options: any) {
+    const { uuid, type, status, name, namespace, origin, checkUpdateUrl, downloadUrl } = scriptFull;
+    const script = { uuid, type, status, name, namespace, origin, checkUpdateUrl, downloadUrl } as TInstallScriptParams;
+    return this.mq.publish<TInstallScript>("installScript", { script, ...options });
+  }
+
   // 安装脚本
   async installScript(param: { script: Script; code: string; upsertBy: InstallSource }) {
     param.upsertBy = param.upsertBy || "user";
@@ -247,7 +261,7 @@ export class ScriptService {
         // 下载资源
         this.resourceService.checkScriptResource(script).then(() => {
           // 广播一下
-          this.mq.publish<TInstallScript>("installScript", { script, update, upsertBy });
+          this.publishInstallScript(script, { update, upsertBy });
         });
         return { update };
       })
@@ -264,12 +278,48 @@ export class ScriptService {
       logger.error("script not found");
       throw new Error("script not found");
     }
+    const storageName = getStorageName(script);
     return this.scriptDAO
       .delete(uuid)
-      .then(() => {
-        this.scriptCodeDAO.delete(uuid);
+      .then(async () => {
+        await this.scriptCodeDAO.delete(uuid);
+        logger.info("delete success");
+        const data = [{ uuid, storageName }];
+        this.mq.publish<TDeleteScript[]>("deleteScripts", data);
+        return true;
+      })
+      .catch((e) => {
+        logger.error("delete error", Logger.E(e));
+        throw e;
+      });
+  }
+
+  async deleteScripts(uuids: string[]) {
+    const logger = this.logger.with({ uuids });
+    const scripts = await this.scriptDAO.gets(uuids);
+    const uuids2: string[] = [];
+    const storageNames: string[] = [];
+    for (let i = 0, l = uuids.length; i < l; i++) {
+      const script = scripts[i];
+      if (script && script.uuid && script.uuid === uuids[i]) {
+        uuids2.push(script.uuid);
+        storageNames.push(getStorageName(script));
+      }
+    }
+    if (!uuids2.length) {
+      logger.error("scripts not found");
+      throw new Error("scripts not found");
+    }
+    return this.scriptDAO
+      .deletes(uuids2)
+      .then(async () => {
+        await this.scriptCodeDAO.deletes(uuids2);
         logger.info("delete success");
-        this.mq.publish<TDeleteScript>("deleteScript", { uuid, script });
+        const data = uuids2.map((uuid, i) => ({
+          uuid,
+          storageName: storageNames[i],
+        }));
+        this.mq.publish<TDeleteScript[]>("deleteScripts", data);
         return true;
       })
       .catch((e) => {
@@ -279,20 +329,55 @@ export class ScriptService {
   }
 
   async enableScript(param: { uuid: string; enable: boolean }) {
-    const logger = this.logger.with({ uuid: param.uuid, enable: param.enable });
-    const script = await this.scriptDAO.get(param.uuid);
+    const { uuid, enable } = param;
+    const logger = this.logger.with({ uuid, enable });
+    const script = await this.scriptDAO.get(uuid);
     if (!script) {
       logger.error("script not found");
       throw new Error("script not found");
     }
     return this.scriptDAO
-      .update(param.uuid, {
-        status: param.enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE,
+      .update(uuid, {
+        status: enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE,
         updatetime: Date.now(),
       })
       .then(() => {
         logger.info("enable success");
-        this.mq.publish<TEnableScript>("enableScript", { uuid: param.uuid, enable: param.enable });
+        this.mq.publish<TEnableScript[]>("enableScripts", [{ uuid: uuid, enable: enable }]);
+        return {};
+      })
+      .catch((e) => {
+        logger.error("enable error", Logger.E(e));
+        throw e;
+      });
+  }
+
+  async enableScripts(param: { uuids: string[]; enable: boolean }) {
+    const { uuids, enable } = param;
+    const logger = this.logger.with({ uuids, enable });
+    const scripts = await this.scriptDAO.gets(uuids);
+    const uuids2: string[] = [];
+    for (let i = 0, l = uuids.length; i < l; i++) {
+      const script = scripts[i];
+      if (script && script.uuid && script.uuid === uuids[i]) {
+        uuids2.push(script.uuid);
+      }
+    }
+    if (!uuids2.length) {
+      logger.error("scripts not found");
+      throw new Error("scripts not found");
+    }
+    return this.scriptDAO
+      .updates(uuids2, {
+        status: enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE,
+        updatetime: Date.now(),
+      })
+      .then(() => {
+        logger.info("enable success");
+        this.mq.publish<TEnableScript[]>(
+          "enableScripts",
+          uuids2.map((uuid) => ({ uuid, enable }))
+        );
         return {};
       })
       .catch((e) => {
@@ -384,7 +469,13 @@ export class ScriptService {
     return results;
   }
 
-  getScriptRunResource(script: Script) {
+  // getScriptRunResource(script: Script) {
+  //   return this.buildScriptRunResource(script);
+  // }
+
+  async getScriptRunResourceByUUID(uuid: string) {
+    const script = await this.fetchInfo(uuid);
+    if (!script) return null;
     return this.buildScriptRunResource(script);
   }
 
@@ -413,13 +504,13 @@ export class ScriptService {
     });
   }
 
-  // ScriptMenuList 的 excludeUrl - 排除或回復
+  // ScriptMenuList 的 excludeUrl - 排除或回复
   async excludeUrl({ uuid, excludePattern, remove }: { uuid: string; excludePattern: string; remove: boolean }) {
     let script = await this.scriptDAO.get(uuid);
     if (!script) {
       throw new Error("script not found");
     }
-    // 建立Set去掉重覆（如有）
+    // 建立Set去掉重复（如有）
     const excludeSet = new Set(script.selfMetadata?.exclude || script.metadata?.exclude || []);
     if (remove) {
       const deleted = excludeSet.delete(excludePattern);
@@ -435,7 +526,7 @@ export class ScriptService {
       .update(uuid, script)
       .then(() => {
         // 广播一下
-        this.mq.publish<TInstallScript>("installScript", { script, update: true });
+        this.publishInstallScript(script, { update: true });
         return true;
       })
       .catch((e) => {
@@ -449,7 +540,7 @@ export class ScriptService {
     if (!script) {
       throw new Error("script not found");
     }
-    // 建立Set去掉重覆（如有）
+    // 建立Set去掉重复（如有）
     const excludeSet = new Set(exclude || []);
     // 更新 script.selfMetadata.exclude
     script = selfMetadataUpdate(script, "exclude", excludeSet);
@@ -457,7 +548,7 @@ export class ScriptService {
       .update(uuid, script)
       .then(() => {
         // 广播一下
-        this.mq.publish<TInstallScript>("installScript", { script, update: true });
+        this.publishInstallScript(script, { update: true });
         return true;
       })
       .catch((e) => {
@@ -471,7 +562,7 @@ export class ScriptService {
     if (!script) {
       throw new Error("script not found");
     }
-    // 建立Set去掉重覆（如有）
+    // 建立Set去掉重复（如有）
     const matchSet = new Set(match || []);
     // 更新 script.selfMetadata.match
     script = selfMetadataUpdate(script, "match", matchSet);
@@ -479,7 +570,7 @@ export class ScriptService {
       .update(uuid, script)
       .then(() => {
         // 广播一下
-        this.mq.publish<TInstallScript>("installScript", { script, update: true });
+        this.publishInstallScript(script, { update: true });
         return true;
       })
       .catch((e) => {
@@ -488,14 +579,14 @@ export class ScriptService {
       });
   }
 
-  async checkUpdate(uuid_: string, source: "user" | "system") {
-    // 检查更新
-    const script = await this.scriptDAO.get(uuid_);
-    if (!script) {
-      return false;
-    }
-    await this.scriptDAO.update(uuid_, { checktime: Date.now() });
+  async _checkUpdateAvailable(script: {
+    uuid: string;
+    name: string;
+    checkUpdateUrl?: string;
+    metadata: Partial<Record<string, any>>;
+  }): Promise<false | { updateAvailable: true; code: string; metadata: SCMetadata }> {
     const { uuid, name, checkUpdateUrl } = script;
+
     if (!checkUpdateUrl) {
       return false;
     }
@@ -523,10 +614,22 @@ export class ScriptService {
       if (ltever(newVersion, oldVersion, logger)) {
         return false;
       }
+      return { updateAvailable: true, code, metadata };
     } catch (e) {
       logger.error("check update failed", Logger.E(e));
       return false;
     }
+  }
+
+  async checkUpdate(uuid_: string, source: "user" | "system") {
+    // 检查更新
+    const script = await this.scriptDAO.get(uuid_);
+    if (!script || !script.checkUpdateUrl) {
+      return false;
+    }
+    await this.scriptDAO.update(uuid_, { checktime: Date.now() });
+    const res = await this._checkUpdateAvailable(script);
+    if (!res) return false;
     // 进行更新
     this.openUpdatePage(script, source);
     return true;
@@ -575,9 +678,7 @@ export class ScriptService {
       const ret = await this.openUpdateOrInstallPage(uuid, url, source, true, logger);
       if (ret === 2) return; // slience update
       // 打开安装页面
-      chrome.tabs.create({
-        url: `/src/install.html?uuid=${uuid}`,
-      });
+      openInCurrentTab(`/src/install.html?uuid=${uuid}`);
     } catch (e) {
       logger.error("fetch script info failed", Logger.E(e));
     }
@@ -639,18 +740,17 @@ export class ScriptService {
     });
   }
 
-  getAllScripts() {
+  async getAllScripts() {
     // 获取数据并排序
-    return this.scriptDAO.all().then((scripts) => {
-      scripts.sort((a, b) => a.sort - b.sort);
-      for (let i = 0; i < scripts.length; i += 1) {
-        if (scripts[i].sort !== i) {
-          this.scriptDAO.update(scripts[i].uuid, { sort: i });
-          scripts[i].sort = i;
-        }
+    const scripts = await this.scriptDAO.all();
+    scripts.sort((a, b) => a.sort - b.sort);
+    for (let i = 0; i < scripts.length; i += 1) {
+      if (scripts[i].sort !== i) {
+        this.scriptDAO.update(scripts[i].uuid, { sort: i });
+        scripts[i].sort = i;
       }
-      return scripts;
-    });
+    }
+    return scripts;
   }
 
   async sortScript({ active, over }: { active: string; over: string }) {
@@ -666,13 +766,46 @@ export class ScriptService {
       }
     });
     const newSort = arrayMove(scripts, oldIndex, newIndex);
-    for (let i = 0; i < newSort.length; i += 1) {
-      if (newSort[i].sort !== i) {
-        this.scriptDAO.update(newSort[i].uuid, { sort: i, updatetime: Date.now() });
-        newSort[i].sort = i;
+    const updatetime = Date.now();
+    for (let i = 0, l = newSort.length; i < l; i += 1) {
+      const item = newSort[i];
+      if (item.sort !== i) {
+        item.sort = i;
+        await this.scriptDAO.update(item.uuid, { sort: i, updatetime });
+      }
+    }
+    this.mq.publish<TSortedScript[]>(
+      "sortedScripts",
+      newSort.map(({ uuid, sort }) => ({ uuid, sort }))
+    );
+  }
+
+  async pinToTop(uuids: string[]) {
+    const scripts = await this.scriptDAO.all();
+    const m = uuids.length;
+    const oldSorts = new Map<string, number>();
+    for (const script of scripts) {
+      oldSorts.set(script.uuid, script.sort);
+      const idx = uuids.indexOf(script.uuid);
+      if (idx >= 0) {
+        script.sort = idx;
+      } else {
+        script.sort += m;
       }
     }
-    this.mq.publish<TSortScript>("sortScript", newSort);
+    scripts.sort((a, b) => a.sort - b.sort);
+    const updatetime = Date.now();
+    for (let i = 0, l = scripts.length; i < l; i += 1) {
+      const item = scripts[i];
+      item.sort = i;
+      if (item.sort !== oldSorts.get(item.uuid)) {
+        await this.scriptDAO.update(item.uuid, { sort: i, updatetime });
+      }
+    }
+    this.mq.publish<TSortedScript[]>(
+      "sortedScripts",
+      scripts.map(({ uuid, sort }) => ({ uuid, sort }))
+    );
   }
 
   importByUrl(url: string) {
@@ -723,18 +856,22 @@ export class ScriptService {
     this.group.on("getAllScripts", this.getAllScripts.bind(this));
     this.group.on("getInstallInfo", this.getInstallInfo);
     this.group.on("install", this.installScript.bind(this));
-    this.group.on("delete", this.deleteScript.bind(this));
+    // this.group.on("delete", this.deleteScript.bind(this));
+    this.group.on("deletes", this.deleteScripts.bind(this));
     this.group.on("enable", this.enableScript.bind(this));
+    this.group.on("enables", this.enableScripts.bind(this));
     this.group.on("fetchInfo", this.fetchInfo.bind(this));
     this.group.on("updateRunStatus", this.updateRunStatus.bind(this));
     this.group.on("getFilterResult", this.getFilterResult.bind(this));
-    this.group.on("getScriptRunResource", this.getScriptRunResource.bind(this));
+    // this.group.on("getScriptRunResource", this.getScriptRunResource.bind(this));
+    this.group.on("getScriptRunResourceByUUID", this.getScriptRunResourceByUUID.bind(this));
     this.group.on("excludeUrl", this.excludeUrl.bind(this));
     this.group.on("resetMatch", this.resetMatch.bind(this));
     this.group.on("resetExclude", this.resetExclude.bind(this));
     this.group.on("requestCheckUpdate", this.requestCheckUpdate.bind(this));
     this.group.on("isInstalled", this.isInstalled.bind(this));
     this.group.on("sortScript", this.sortScript.bind(this));
+    this.group.on("pinToTop", this.pinToTop.bind(this));
     this.group.on("importByUrl", this.importByUrl.bind(this));
     this.group.on("installByCode", this.installByCode.bind(this));
     this.group.on("setCheckUpdateUrl", this.setCheckUpdateUrl.bind(this));
diff --git a/src/app/service/service_worker/subscribe.ts b/src/app/service/service_worker/subscribe.ts
index 8e043828e..ed55bae57 100644
--- a/src/app/service/service_worker/subscribe.ts
+++ b/src/app/service/service_worker/subscribe.ts
@@ -1,7 +1,7 @@
 import LoggerCore from "@App/app/logger/core";
 import Logger from "@App/app/logger/logger";
 import { ScriptDAO } from "@App/app/repo/scripts";
-import type { Subscribe, SubscribeScript } from "@App/app/repo/subscribe";
+import type { SCMetadata, Subscribe, SubscribeScript } from "@App/app/repo/subscribe";
 import { SUBSCRIBE_STATUS_DISABLE, SUBSCRIBE_STATUS_ENABLE, SubscribeDAO } from "@App/app/repo/subscribe";
 import { type SystemConfig } from "@App/pkg/config/config";
 import { type MessageQueue } from "@Packages/message/message_queue";
@@ -84,7 +84,9 @@ export class SubscribeService {
   }
 
   // 更新订阅的脚本
-  async upsertScript(subscribe: Subscribe) {
+  async upsertScript(url: string) {
+    const subscribe = await this.subscribeDAO.get(url);
+    if (!subscribe) return;
     const logger = this.logger.with({
       url: subscribe.url,
       name: subscribe.name,
@@ -159,22 +161,20 @@ export class SubscribeService {
     return true;
   }
 
-  // 检查更新
-  async checkUpdate(url: string, source: InstallSource) {
-    const subscribe = await this.subscribeDAO.get(url);
-    if (!subscribe) {
-      return false;
-    }
+  async _checkUpdateAvailable(subscribe: {
+    url: string;
+    name: string;
+    checkUpdateUrl?: string;
+    metadata: Partial<Record<string, any>>;
+  }): Promise<false | { updateAvailable: true; code: string; metadata: SCMetadata }> {
+    const { url, name } = subscribe;
     const logger = this.logger.with({
-      url: subscribe.url,
-      name: subscribe.name,
+      url,
+      name,
     });
-    await this.subscribeDAO.update(url, { checktime: Date.now() });
     try {
-      const code = await fetchScriptBody(subscribe.url);
+      const code = await fetchScriptBody(url);
       const metadata = parseMetadata(code);
-      const url = subscribe.url;
-      const uuid = uuidv4();
       if (!metadata) {
         logger.error("parse metadata failed");
         return false;
@@ -192,23 +192,48 @@ export class SubscribeService {
       if (ltever(newVersion, oldVersion, logger)) {
         return false;
       }
-      // 进行更新
-      if (true === (await this.trySilenceUpdate(code, url))) {
-        // slience update
-      } else {
-        const si = [false, createScriptInfo(uuid, code, url, source, metadata)];
-        await cacheInstance.set(`${CACHE_KEY_SCRIPT_INFO}${uuid}`, si);
-        chrome.tabs.create({
-          url: `/src/install.html?uuid=${uuid}`,
-        });
-      }
-      return true;
+      return { updateAvailable: true, code, metadata };
     } catch (e) {
       logger.error("check update failed", Logger.E(e));
       return false;
     }
   }
 
+  // 检查更新
+  async checkUpdate(url: string, source: InstallSource) {
+    const subscribe = await this.subscribeDAO.get(url);
+    if (!subscribe) {
+      return false;
+    }
+    await this.subscribeDAO.update(url, { checktime: Date.now() });
+    const logger = this.logger.with({
+      url: subscribe.url,
+      name: subscribe.name,
+    });
+    const res = await this._checkUpdateAvailable(subscribe);
+    if (res) {
+      const { code, metadata } = res;
+      const { url } = subscribe;
+      const uuid = uuidv4();
+      try {
+        // 进行更新
+        if (true === (await this.trySilenceUpdate(code, url))) {
+          // slience update
+        } else {
+          const si = [false, createScriptInfo(uuid, code, url, source, metadata)];
+          await cacheInstance.set(`${CACHE_KEY_SCRIPT_INFO}${uuid}`, si);
+          chrome.tabs.create({
+            url: `/src/install.html?uuid=${uuid}`,
+          });
+        }
+        return true;
+      } catch (e) {
+        logger.error("check update failed", Logger.E(e));
+        return false;
+      }
+    }
+  }
+
   async trySilenceUpdate(code: string, url: string) {
     const logger = this.logger.with({
       url,
@@ -277,7 +302,7 @@ export class SubscribeService {
     this.group.on("enable", this.enable.bind(this));
 
     this.mq.subscribe<TInstallSubscribe>("installSubscribe", (message) => {
-      this.upsertScript(message.subscribe);
+      this.upsertScript(message.subscribe.url);
     });
 
     // 定时检查更新, 每10分钟检查一次
diff --git a/src/app/service/service_worker/synchronize.ts b/src/app/service/service_worker/synchronize.ts
index 711e5e205..6bd189e82 100644
--- a/src/app/service/service_worker/synchronize.ts
+++ b/src/app/service/service_worker/synchronize.ts
@@ -17,7 +17,7 @@ import { type ValueService } from "./value";
 import { type ResourceService } from "./resource";
 import { createObjectURL } from "../offscreen/client";
 import { type CloudSyncConfig, type SystemConfig } from "@App/pkg/config/config";
-import type { TDeleteScript, TInstallScript } from "../queue";
+import type { TDeleteScript, TInstallScript, TInstallScriptParams } from "../queue";
 import { errorMsg, InfoNotification } from "@App/pkg/utils/utils";
 import { t } from "i18next";
 import ChromeStorage from "@App/pkg/config/chrome_storage";
@@ -54,6 +54,8 @@ type ScriptcatSync = {
   };
 };
 
+type PushScriptParam = TInstallScriptParams;
+
 export class SynchronizeService {
   logger: Logger;
 
@@ -533,7 +535,7 @@ export class SynchronizeService {
   }
 
   // 上传脚本
-  async pushScript(fs: FileSystem, script: Script) {
+  async pushScript(fs: FileSystem, script: PushScriptParam) {
     const filename = `${script.uuid}.user.js`;
     const logger = this.logger.with({
       uuid: script.uuid,
@@ -644,12 +646,14 @@ export class SynchronizeService {
     }
   }
 
-  async scriptDelete(script: { uuid: string }) {
+  async scriptsDelete(data: TDeleteScript[]) {
     // 判断是否开启了同步
     const config = await this.systemConfig.getCloudSync();
     if (config.enable) {
       this.buildFileSystem(config).then(async (fs) => {
-        await this.deleteCloudScript(fs, script.uuid, config.syncDelete);
+        for (const { uuid } of data) {
+          await this.deleteCloudScript(fs, uuid, config.syncDelete);
+        }
       });
     }
   }
@@ -661,6 +665,6 @@ export class SynchronizeService {
     // this.group.on("import", this.openImportWindow.bind(this));
     // 监听脚本变化, 进行同步
     this.mq.subscribe<TInstallScript>("installScript", this.scriptInstall.bind(this));
-    this.mq.subscribe<TDeleteScript>("deleteScript", this.scriptDelete.bind(this));
+    this.mq.subscribe<TDeleteScript[]>("deleteScripts", this.scriptsDelete.bind(this));
   }
 }
diff --git a/src/app/service/service_worker/value.ts b/src/app/service/service_worker/value.ts
index 21d3119c5..67c6aee16 100644
--- a/src/app/service/service_worker/value.ts
+++ b/src/app/service/service_worker/value.ts
@@ -220,16 +220,17 @@ export class ValueService {
     this.group.on("setScriptValue", this.setScriptValue.bind(this));
     this.group.on("setScriptValues", this.setScriptValues.bind(this));
 
-    this.mq.subscribe<TDeleteScript>("deleteScript", async (data) => {
-      const storageName = getStorageName(data.script);
-      // 判断还有没有其他同名storageName
-      const list = await this.scriptDAO.find((_, script) => {
-        return getStorageName(script) === storageName;
-      });
-      if (list.length === 0) {
-        this.valueDAO.delete(storageName).then(() => {
-          this.logger.trace("delete value", { storageName });
+    this.mq.subscribe<TDeleteScript[]>("deleteScripts", async (data) => {
+      for (const { storageName } of data) {
+        // 判断还有没有其他同名storageName
+        const list = await this.scriptDAO.find((_, script) => {
+          return getStorageName(script) === storageName;
         });
+        if (list.length === 0) {
+          this.valueDAO.delete(storageName).then(() => {
+            this.logger.trace("delete value", { storageName });
+          });
+        }
       }
     });
   }
diff --git a/src/pages/components/ScriptMenuList/index.tsx b/src/pages/components/ScriptMenuList/index.tsx
index 1175ce682..ec7a34f04 100644
--- a/src/pages/components/ScriptMenuList/index.tsx
+++ b/src/pages/components/ScriptMenuList/index.tsx
@@ -189,7 +189,7 @@ const ScriptMenuList = React.memo(
 
     const handleDeleteScript = useCallback((uuid: string) => {
       setList((prevList) => prevList.filter((i) => i.uuid !== uuid));
-      scriptClient.delete(uuid).catch((e) => {
+      scriptClient.deletes([uuid]).catch((e) => {
         Message.error(`{t('delete_failed')}: ${e}`);
       });
     }, []);
diff --git a/src/pages/confirm/App.tsx b/src/pages/confirm/App.tsx
index b621a13f5..bfd32f200 100644
--- a/src/pages/confirm/App.tsx
+++ b/src/pages/confirm/App.tsx
@@ -5,7 +5,7 @@ import { useTranslation } from "react-i18next";
 import { permissionClient } from "../store/features/script";
 
 function App() {
-  const uuid = window.location.search.split("=")[1];
+  const uuid = new URLSearchParams(location.search).get("uuid");
   const [confirm, setConfirm] = React.useState<ConfirmParam>();
   const [likeNum, setLikeNum] = React.useState(0);
   const [second, setSecond] = React.useState(30);
@@ -21,6 +21,7 @@ function App() {
   }, 1000);
 
   useEffect(() => {
+    if (!uuid) return;
     window.addEventListener("beforeunload", () => {
       permissionClient.confirm(uuid, {
         allow: false,
@@ -42,6 +43,7 @@ function App() {
 
   const handleConfirm = (allow: boolean, type: number) => {
     return async () => {
+      if (!uuid) return;
       try {
         await permissionClient.confirm(uuid, {
           allow,
diff --git a/src/pages/install/App.tsx b/src/pages/install/App.tsx
index 71d3c54a7..293328e00 100644
--- a/src/pages/install/App.tsx
+++ b/src/pages/install/App.tsx
@@ -52,7 +52,7 @@ function App() {
   const [btnText, setBtnText] = useState<string>("");
   const [scriptCode, setScriptCode] = useState<string>("");
   const [scriptInfo, setScriptInfo] = useState<ScriptInfo>();
-  const [upsertScript, setUpsertScript] = useState<ScriptOrSubscribe>();
+  const [mUpsertScript, setUpsertScript] = useState<ScriptOrSubscribe>();
   const [diffCode, setDiffCode] = useState<string>();
   const [oldScriptVersion, setOldScriptVersion] = useState<string | null>(null);
   const [isUpdate, setIsUpdate] = useState<boolean>(false);
@@ -279,21 +279,21 @@ function App() {
     } else {
       setBtnText(isUpdate ? t("update_script")! : t("install_script"));
     }
-    if (upsertScript) {
-      document.title = `${!isUpdate ? t("install_script") : t("update_script")} - ${i18nName(upsertScript)} - ScriptCat`;
+    if (mUpsertScript) {
+      document.title = `${!isUpdate ? t("install_script") : t("update_script")} - ${i18nName(mUpsertScript)} - ScriptCat`;
     }
-  }, [isUpdate, scriptInfo, upsertScript]);
+  }, [isUpdate, scriptInfo, mUpsertScript]);
 
   // 设置脚本状态
   useEffect(() => {
-    if (upsertScript) {
-      setEnable(upsertScript.status === SCRIPT_STATUS_ENABLE);
+    if (mUpsertScript) {
+      setEnable(mUpsertScript.status === SCRIPT_STATUS_ENABLE);
     }
-  }, [upsertScript]);
+  }, [mUpsertScript]);
 
   const handleInstall = useCallback(
     async (options: { closeAfterInstall?: boolean; noMoreUpdates?: boolean } = {}) => {
-      if (!upsertScript) {
+      if (!mUpsertScript) {
         Message.error(t("script_info_load_failed")!);
         return;
       }
@@ -302,18 +302,17 @@ function App() {
 
       try {
         if (scriptInfo?.userSubscribe) {
-          await subscribeClient.install(upsertScript as Subscribe);
+          await subscribeClient.install(mUpsertScript as Subscribe);
           Message.success(t("subscribe_success")!);
           setBtnText(t("subscribe_success")!);
         } else {
           // 如果选择不再检查更新，可以在这里设置脚本的更新配置
-          if (disableUpdates && upsertScript) {
+          if (disableUpdates && mUpsertScript) {
             // 这里可以设置脚本禁用自动更新的逻辑
-            (upsertScript as Script).checkUpdate = false;
+            (mUpsertScript as Script).checkUpdate = false;
           }
-
           // 故意只安装或执行，不改变显示内容
-          await scriptClient.install(upsertScript as Script, scriptCode);
+          await scriptClient.install(mUpsertScript as Script, scriptCode);
           if (isUpdate) {
             Message.success(t("install.update_success")!);
             setBtnText(t("install.update_success")!);
@@ -333,7 +332,7 @@ function App() {
         Message.error(`${errorMessage}: ${e}`);
       }
     },
-    [upsertScript, scriptInfo, scriptCode, isUpdate]
+    [mUpsertScript, scriptInfo, scriptCode, isUpdate]
   );
 
   const handleStatusChange = useCallback(
@@ -367,7 +366,7 @@ function App() {
     if (this.uuid !== scriptInfo?.uuid) return;
     if (this.fileName !== localFileHandle?.name) return;
     setScriptCode(code);
-    const uuid = (upsertScript as Script)?.uuid;
+    const uuid = (mUpsertScript as Script)?.uuid;
     if (!uuid) {
       throw new Error("uuid is undefined");
     }
@@ -401,7 +400,7 @@ function App() {
       // 如没有安装纪录，将进行安装。
       // 如已经安装，在FileSystemObserver检查更改前，先进行更新。
       const code = `${scriptCode}`;
-      await installOrUpdateScript(upsertScript as Script, code);
+      await installOrUpdateScript(mUpsertScript as Script, code);
       // setScriptCode(`${code}`);
       setDiffCode(`${code}`);
       const ftInfo: FTInfo = {
@@ -448,13 +447,13 @@ function App() {
         <Grid.Col flex={1} className="flex-col p-8px">
           <Space direction="vertical" className="w-full">
             <div>
-              {upsertScript?.metadata.icon && (
+              {mUpsertScript?.metadata.icon && (
                 <Avatar size={32} shape="square" style={{ marginRight: "8px" }}>
-                  <img src={upsertScript.metadata.icon[0]} alt={upsertScript?.name} />
+                  <img src={mUpsertScript.metadata.icon[0]} alt={mUpsertScript?.name} />
                 </Avatar>
               )}
               <Typography.Text bold className="text-size-lg">
-                {upsertScript && i18nName(upsertScript)}
+                {mUpsertScript && i18nName(mUpsertScript)}
                 <Tooltip
                   content={scriptInfo?.userSubscribe ? t("subscribe_source_tooltip") : t("script_status_tooltip")}
                 >
@@ -463,7 +462,7 @@ function App() {
               </Typography.Text>
             </div>
             <div>
-              <Typography.Text bold>{upsertScript && i18nDescription(upsertScript)}</Typography.Text>
+              <Typography.Text bold>{mUpsertScript && i18nDescription(mUpsertScript)}</Typography.Text>
             </div>
             <div>
               <Typography.Text bold>{`${t("author")}: ${metadataLive.author}`}</Typography.Text>
diff --git a/src/pages/options/main.tsx b/src/pages/options/main.tsx
index 068de478a..19928fdcb 100644
--- a/src/pages/options/main.tsx
+++ b/src/pages/options/main.tsx
@@ -12,7 +12,6 @@ import LoggerCore from "@App/app/logger/core.ts";
 import { LoggerDAO } from "@App/app/repo/logger.ts";
 import DBWriter from "@App/app/logger/db_writer.ts";
 import registerEditor from "@App/pkg/utils/monaco-editor";
-import storeSubscribe from "../store/subscribe.ts";
 import migrate from "@App/app/migrate.ts";
 
 migrate();
@@ -27,8 +26,6 @@ const loggerCore = new LoggerCore({
 
 loggerCore.logger().debug("options page start");
 
-storeSubscribe();
-
 const Root = (
   <Provider store={store}>
     <MainLayout className="!flex-row" pageName="options">
diff --git a/src/pages/options/routes/ScriptList.tsx b/src/pages/options/routes/ScriptList.tsx
index 10309ac82..8a2a74807 100644
--- a/src/pages/options/routes/ScriptList.tsx
+++ b/src/pages/options/routes/ScriptList.tsx
@@ -18,6 +18,7 @@ import {
   Typography,
 } from "@arco-design/web-react";
 import { TbWorldWww } from "react-icons/tb";
+import { messageQueue } from "@App/pages/store/global";
 import type { ColumnProps } from "@arco-design/web-react/es/Table";
 import type { ComponentsProps } from "@arco-design/web-react/es/Table/interface";
 import type { Script, UserConfig } from "@App/app/repo/scripts";
@@ -52,6 +53,7 @@ import Text from "@arco-design/web-react/es/Typography/text";
 import type { DragEndEvent } from "@dnd-kit/core";
 import { closestCenter, DndContext, KeyboardSensor, PointerSensor, useSensor, useSensors } from "@dnd-kit/core";
 import {
+  arrayMove,
   SortableContext,
   sortableKeyboardCoordinates,
   useSortable,
@@ -67,27 +69,31 @@ import { semTime } from "@App/pkg/utils/dayjs";
 import { message, systemConfig } from "@App/pages/store/global";
 import { i18nName } from "@App/locales/locales";
 import { ListHomeRender, ScriptIcons } from "./utils";
-import { useAppDispatch, useAppSelector } from "@App/pages/store/hooks";
+import { useAppDispatch } from "@App/pages/store/hooks";
 import type { ScriptLoading } from "@App/pages/store/features/script";
 import {
   requestEnableScript,
-  fetchScriptList,
-  requestDeleteScript,
-  selectScripts,
+  requestDeleteScripts,
   sortScript,
+  pinToTop,
   requestStopScript,
   requestRunScript,
   scriptClient,
-  enableLoading,
-  updateEnableStatus,
   synchronizeClient,
-  batchDeleteScript,
   requestFilterResult,
+  fetchScriptList,
+  fetchScript,
 } from "@App/pages/store/features/script";
 import { ValueClient } from "@App/app/service/service_worker/client";
 import { loadScriptFavicons } from "@App/pages/store/utils";
-import { store } from "@App/pages/store/store";
 import type { SearchType } from "@App/app/service/service_worker/types";
+import type {
+  TDeleteScript,
+  TEnableScript,
+  TInstallScript,
+  TScriptRunStatus,
+  TSortedScript,
+} from "@App/app/service/queue";
 
 type ListType = ScriptLoading;
 type RowCtx = ReturnType<typeof useSortable> | null;
@@ -97,6 +103,7 @@ const SortableRowCtx = createContext<RowCtx>(null);
 interface DraggableContextType {
   sensors: ReturnType<typeof useSensors>;
   scriptList: ScriptLoading[];
+  setScriptList: React.Dispatch<React.SetStateAction<ScriptLoading[]>>;
   dispatch: ReturnType<typeof useAppDispatch>;
 }
 const DraggableContext = createContext<DraggableContextType | null>(null);
@@ -176,11 +183,37 @@ const DragHandle = () => {
   );
 };
 
+const scriptListSortOrder = (
+  scripts: ScriptLoading[],
+  setScriptList: React.Dispatch<React.SetStateAction<ScriptLoading[]>>,
+  { active, over }: { active: string; over: string }
+) => {
+  let oldIndex = -1;
+  let newIndex = -1;
+  scripts.forEach((item, index) => {
+    if (item.uuid === active) {
+      oldIndex = index;
+    } else if (item.uuid === over) {
+      newIndex = index;
+    }
+  });
+  if (oldIndex >= 0 && newIndex >= 0) {
+    const newItems = arrayMove(scripts, oldIndex, newIndex);
+    for (let i = 0, l = newItems.length; i < l; i += 1) {
+      if (newItems[i].sort !== i) {
+        newItems[i].sort = i;
+      }
+    }
+    setScriptList(newItems);
+  }
+  sortScript({ active, over });
+};
+
 const DraggableContainer = React.forwardRef<HTMLTableSectionElement, React.HTMLAttributes<HTMLTableSectionElement>>(
   (props, ref) => {
     const context = useContext(DraggableContext);
     if (!context) return <></>;
-    const { sensors, dispatch, scriptList } = context;
+    const { sensors, scriptList, setScriptList } = context;
     return (
       <DndContext
         sensors={sensors}
@@ -193,7 +226,7 @@ const DraggableContainer = React.forwardRef<HTMLTableSectionElement, React.HTMLA
             return;
           }
           if (active.id !== over.id) {
-            dispatch(sortScript({ active: active.id as string, over: over.id as string }));
+            scriptListSortOrder(scriptList, setScriptList, { active: active.id as string, over: over.id as string });
           }
         }}
       >
@@ -204,6 +237,7 @@ const DraggableContainer = React.forwardRef<HTMLTableSectionElement, React.HTMLA
     );
   }
 );
+
 DraggableContainer.displayName = "DraggableContainer";
 
 const EnableSwitch = React.memo(
@@ -231,7 +265,8 @@ function ScriptList() {
   }>();
   const [cloudScript, setCloudScript] = useState<Script>();
   const dispatch = useAppDispatch();
-  const scriptList = useAppSelector(selectScripts);
+  const [mInitial, setInitial] = useState<boolean>(false);
+  const [scriptList, setScriptList] = useState<ScriptLoading[]>([]);
   const inputRef = useRef<RefInputType>(null);
   const navigate = useNavigate();
   const openUserConfig = useSearchParams()[0].get("userConfig") || "";
@@ -268,19 +303,180 @@ function ScriptList() {
     () => ({
       sensors,
       scriptList,
+      setScriptList,
       dispatch,
     }),
-    [sensors, scriptList, dispatch]
+    [sensors, scriptList, setScriptList, dispatch]
   );
 
-  useEffect(() => {
-    dispatch(fetchScriptList()).then((action) => {
-      if (fetchScriptList.fulfilled.match(action)) {
-        // 在脚本列表加载完成后，加载favicon
-        loadScriptFavicons(action.payload);
+  const doInitial = async () => {
+    setInitial(true);
+    const list = await fetchScriptList();
+    setScriptList(list);
+
+    for await (const { chunkResults } of loadScriptFavicons(list)) {
+      setScriptList((list) => {
+        const scriptMap = new Map<string, ScriptLoading>();
+        for (const s of list) {
+          scriptMap.set(s.uuid, s);
+        }
+        const altered = new Set();
+        for (const item of chunkResults) {
+          const script = scriptMap.get(item.uuid);
+          if (script) {
+            altered.add(item.uuid);
+            script.favorite = item.fav;
+          }
+        }
+        return list.map((entry) => (altered.has(entry.uuid) ? { ...entry } : entry));
+      });
+    }
+  };
+
+  mInitial === false && doInitial();
+
+  const pageApi = {
+    scriptRunStatus(data: TScriptRunStatus) {
+      const { uuid, runStatus } = data;
+      setScriptList((list: ScriptLoading[]) => {
+        for (let i = 0, l = list.length; i < l; i++) {
+          const s = list[i];
+          if (s.uuid === uuid) {
+            s.runStatus = runStatus;
+            list[i] = { ...s };
+            return { ...list };
+          }
+        }
+        return list;
+      });
+    },
+
+    async installScript(message: TInstallScript) {
+      const installedScript = await fetchScript(message.script.uuid);
+      if (!installedScript) return;
+      const installedScriptUUID = installedScript.uuid;
+      if (!installedScriptUUID) return;
+      setScriptList((list: ScriptLoading[]) => {
+        for (let i = 0, l = list.length; i < l; i++) {
+          const s = list[i];
+          if (s.uuid === installedScriptUUID) {
+            Object.assign(s, installedScript);
+            list[i] = { ...s };
+            return { ...list };
+          }
+        }
+        // 放到第一
+        const res = [{ ...installedScript }, ...list];
+        for (let i = 0, l = res.length; i < l; i++) {
+          res[i].sort = i;
+        }
+        return res;
+      });
+    },
+
+    deleteScripts(data: TDeleteScript[]) {
+      const uuids = data.map(({ uuid }) => uuid);
+      const set = new Set(uuids);
+      setScriptList((list: ScriptLoading[]) => {
+        const res = list.filter((s) => !set.has(s.uuid));
+        for (let i = 0, l = res.length; i < l; i++) {
+          res[i].sort = i;
+        }
+        return res;
+      });
+    },
+
+    enableScripts(data: TEnableScript[]) {
+      const map = new Map();
+      for (const { uuid, enable } of data) {
+        map.set(uuid, enable);
+      }
+      setScriptList((list: ScriptLoading[]) =>
+        list.map((script) => {
+          if (map.has(script.uuid)) {
+            const enable = map.get(script.uuid);
+            script.enableLoading = false;
+            script.status = enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE;
+            return { ...script };
+          } else {
+            return script;
+          }
+        })
+      );
+    },
+
+    sortedScripts(data: TSortedScript[]) {
+      setScriptList((list: ScriptLoading[]) => {
+        const listEntries = new Map<string, ScriptLoading>();
+        for (const item of list) {
+          listEntries.set(item.uuid, item);
+        }
+        let j = 0;
+        const res = new Array(data.length);
+        for (const { uuid } of data) {
+          const item = listEntries.get(uuid);
+          if (item) {
+            res[j] = item;
+            item.sort = j;
+            j++;
+          }
+        }
+        res.length = j;
+        return res;
+      });
+    },
+  };
+
+  const subscribeMessageConsumed = new WeakSet();
+  const subscribeMessage = (topic: string, handler: (msg: any) => void) => {
+    return messageQueue.subscribe<any>(topic, (data: any) => {
+      const message = data?.myMessage || data;
+      if (typeof message === "object" && !subscribeMessageConsumed.has(message)) {
+        subscribeMessageConsumed.add(message);
+        handler(message);
       }
     });
-  }, [dispatch]);
+  };
+
+  useEffect(() => {
+    const unhooks = [
+      subscribeMessage("scriptRunStatus", pageApi.scriptRunStatus),
+      subscribeMessage("installScript", pageApi.installScript),
+      subscribeMessage("deleteScripts", pageApi.deleteScripts),
+      subscribeMessage("enableScripts", pageApi.enableScripts),
+      subscribeMessage("sortedScripts", pageApi.sortedScripts),
+    ];
+    return () => {
+      for (const unhook of unhooks) unhook();
+    };
+  });
+
+  const updateScriptList = (data: Partial<Script | ScriptLoading>) => {
+    setScriptList((list) =>
+      list.map((script) => {
+        if (script.uuid === data.uuid) {
+          Object.assign(script, data);
+          return { ...script };
+        } else {
+          return script;
+        }
+      })
+    );
+  };
+
+  const updateEntry = (uuids: string[], data: Partial<Script | ScriptLoading>) => {
+    const set = new Set(uuids);
+    setScriptList((list) =>
+      list.map((script) => {
+        if (set.has(script.uuid)) {
+          Object.assign(script, data);
+          return { ...script };
+        } else {
+          return script;
+        }
+      })
+    );
+  };
 
   const columns: ColumnProps[] = useMemo(
     () =>
@@ -319,8 +515,10 @@ function ScriptList() {
           ],
           onFilter: (value, row) => row.status === value,
           render: (col, item: ScriptLoading) => {
+            const { uuid } = item;
             const onChange = (checked: boolean) => {
-              dispatch(requestEnableScript({ uuid: item.uuid, enable: checked }));
+              updateScriptList({ uuid: uuid, enableLoading: true });
+              requestEnableScript({ uuid: uuid, enable: checked });
             };
             return <EnableSwitch status={item.status} enableLoading={item.enableLoading} onChange={onChange} />;
           },
@@ -350,13 +548,11 @@ function ScriptList() {
                         setFilterKeys([...filterKeys]);
                         return;
                       }
-                      dispatch(requestFilterResult({ type: value, value: filterKeys[0].value }))
-                        .unwrap()
-                        .then((res) => {
-                          if (filterKeys[0].type !== value) return;
-                          setFilterCache(res as any);
-                          setFilterKeys([...filterKeys]);
-                        });
+                      requestFilterResult({ type: value, value: filterKeys[0].value }).then((res) => {
+                        if (filterKeys[0].type !== value) return;
+                        setFilterCache(res as any);
+                        setFilterKeys([...filterKeys]);
+                      });
                     }
                   }}
                 >
@@ -383,13 +579,11 @@ function ScriptList() {
                         setFilterKeys([...filterKeys]);
                         return;
                       }
-                      dispatch(requestFilterResult({ value, type: filterKeys[0].type }))
-                        .unwrap()
-                        .then((res) => {
-                          if (filterKeys[0].value !== value) return;
-                          setFilterCache(res as any);
-                          setFilterKeys([...filterKeys]);
-                        });
+                      requestFilterResult({ value, type: filterKeys[0].type }).then((res) => {
+                        if (filterKeys[0].value !== value) return;
+                        setFilterCache(res as any);
+                        setFilterKeys([...filterKeys]);
+                      });
                     }
                   }}
                   onSearch={() => {
@@ -677,7 +871,9 @@ function ScriptList() {
                   title={t("confirm_delete_script")}
                   icon={<RiDeleteBin5Fill />}
                   onOk={() => {
-                    dispatch(requestDeleteScript(item.uuid));
+                    const { uuid } = item;
+                    updateScriptList({ uuid, actionLoading: true });
+                    requestDeleteScripts([item.uuid]);
                   }}
                 >
                   <Button
@@ -719,7 +915,9 @@ function ScriptList() {
                           id: "script-stop",
                           content: t("stopping_script"),
                         });
-                        await dispatch(requestStopScript(item.uuid)).unwrap();
+                        updateEntry([item.uuid], { actionLoading: true });
+                        await requestStopScript(item.uuid);
+                        updateEntry([item.uuid], { actionLoading: false });
                         Message.success({
                           id: "script-stop",
                           content: t("script_stopped"),
@@ -730,7 +928,9 @@ function ScriptList() {
                           id: "script-run",
                           content: t("starting_script"),
                         });
-                        await dispatch(requestRunScript(item.uuid)).unwrap();
+                        updateEntry([item.uuid], { actionLoading: true });
+                        await requestRunScript(item.uuid);
+                        updateEntry([item.uuid], { actionLoading: false });
                         Message.success({
                           id: "script-run",
                           content: t("script_started"),
@@ -920,13 +1120,9 @@ function ScriptList() {
                     onClick={() => {
                       const enableAction = (enable: boolean) => {
                         const uuids = select.map((item) => item.uuid);
-                        dispatch(enableLoading({ uuids: uuids, loading: true }));
-                        Promise.allSettled(uuids.map((uuid) => scriptClient.enable(uuid, enable))).finally(() => {
-                          dispatch(updateEnableStatus({ uuids: uuids, enable: enable }));
-                          dispatch(enableLoading({ uuids: uuids, loading: false }));
-                        });
+                        updateEntry(uuids, { enableLoading: true });
+                        scriptClient.enables(uuids, enable);
                       };
-                      let l: number | undefined;
                       switch (action) {
                         case "enable":
                           enableAction(true);
@@ -935,10 +1131,8 @@ function ScriptList() {
                           enableAction(false);
                           break;
                         case "export": {
-                          const uuids: string[] = [];
-                          for (const item of select) {
-                            uuids.push(item.uuid);
-                          }
+                          const sortedSelect = [...select].sort((a, b) => a.sort - b.sort);
+                          const uuids = sortedSelect.map((item) => item.uuid);
                           Message.loading({
                             id: "export",
                             content: t("exporting"),
@@ -955,32 +1149,19 @@ function ScriptList() {
                         case "delete":
                           if (confirm(t("list.confirm_delete"))) {
                             const uuids = select.map((item) => item.uuid);
-                            dispatch(batchDeleteScript(uuids));
-                            Promise.allSettled(uuids.map((uuid) => scriptClient.delete(uuid)));
+                            scriptClient.deletes(uuids); // async
                           }
                           break;
                         case "pin_to_top": {
                           // 将选中的脚本置顶
-                          l = select.length;
-                          if (l > 0) {
-                            // 获取当前所有脚本列表
-                            const currentScripts = store.getState().script.scripts;
-                            // 将选中的脚本依次置顶（从后往前，保持选中脚本之间的相对顺序）
-                            for (let i = l - 1; i >= 0; i--) {
-                              const script = select[i];
-                              // 找到脚本当前的位置
-                              const scriptIndex = currentScripts.findIndex((s) => s.uuid === script.uuid);
-                              if (scriptIndex > 0) {
-                                // 如果不是已经在最顶部
-                                // 将脚本置顶（移动到第一个位置）
-                                dispatch(sortScript({ active: script.uuid, over: currentScripts[0].uuid }));
-                              }
-                            }
+                          const sortedSelect = [...select].sort((a, b) => a.sort - b.sort);
+                          const uuids = sortedSelect.map((item) => item.uuid);
+                          pinToTop(uuids).then(() => {
                             Message.success({
                               content: t("scripts_pinned_to_top"),
                               duration: 3000,
                             });
-                          }
+                          });
                           break;
                         }
                         // 批量检查更新
diff --git a/src/pages/options/routes/script/ScriptEditor.tsx b/src/pages/options/routes/script/ScriptEditor.tsx
index d63143a25..e8b12dccf 100644
--- a/src/pages/options/routes/script/ScriptEditor.tsx
+++ b/src/pages/options/routes/script/ScriptEditor.tsx
@@ -995,7 +995,7 @@ function ScriptEditor() {
                           content: t("confirm_delete_script_content", { name: i18nName(script) }),
                           onOk: () => {
                             scriptClient
-                              .delete(script.uuid)
+                              .deletes([script.uuid])
                               .then(() => {
                                 setScriptList((prev) => prev.filter((s) => s.uuid !== script.uuid));
                                 handleDeleteEditor(script.uuid);
diff --git a/src/pages/popup/App.tsx b/src/pages/popup/App.tsx
index 3576b8703..2f169a0d7 100644
--- a/src/pages/popup/App.tsx
+++ b/src/pages/popup/App.tsx
@@ -29,7 +29,6 @@ const CollapseItem = Collapse.Item;
 const iconStyle = {
   marginRight: 8,
   fontSize: 16,
-  transform: "translateY(1px)",
 };
 
 function App() {
@@ -146,35 +145,32 @@ function App() {
     systemConfig.setCheckUpdate(updatedCheckUpdate);
   }, [checkUpdate]);
 
-  const handleMenuClick = useCallback(
-    async (key: string) => {
-      switch (key) {
-        case "newScript":
-          await chrome.storage.local.set({
-            activeTabUrl: { url: currentUrl },
-          });
-          window.open("/src/options.html#/script/editor?target=initial", "_blank");
-          break;
-        case "checkUpdate":
-          await scriptClient.requestCheckUpdate("");
-          window.close();
-          break;
-        case "report_issue": {
-          const browserInfo = `${navigator.userAgent}`;
-          const issueUrl =
-            `https://github.com/scriptscat/scriptcat/issues/new?` +
-            `template=bug_report${isChineseUser() ? "" : "_en"}.yaml&scriptcat-version=${ExtVersion}&` +
-            `browser-version=${encodeURIComponent(browserInfo)}`;
-          window.open(issueUrl, "_blank");
-          break;
-        }
-        default:
-          window.open(key, "_blank");
-          break;
+  const handleMenuClick = async (key: string) => {
+    switch (key) {
+      case "newScript":
+        await chrome.storage.local.set({
+          activeTabUrl: { url: currentUrl },
+        });
+        window.open("/src/options.html#/script/editor?target=initial", "_blank");
+        break;
+      case "checkUpdate":
+        await scriptClient.requestCheckUpdate("");
+        window.close();
+        break;
+      case "report_issue": {
+        const browserInfo = `${navigator.userAgent}`;
+        const issueUrl =
+          `https://github.com/scriptscat/scriptcat/issues/new?` +
+          `template=bug_report${isChineseUser() ? "" : "_en"}.yaml&scriptcat-version=${ExtVersion}&` +
+          `browser-version=${encodeURIComponent(browserInfo)}`;
+        window.open(issueUrl, "_blank");
+        break;
       }
-    },
-    [currentUrl]
-  );
+      default:
+        window.open(key, "_blank");
+        break;
+    }
+  };
 
   return (
     <>
@@ -183,7 +179,9 @@ function App() {
         size="small"
         title={
           <div className="flex justify-between">
-            <span className="text-xl">{"ScriptCat"}</span>
+            <div className="text-xl inline-flex flex-row items-center gap-x-1">
+              <span>{"ScriptCat"}</span>
+            </div>
             <div className="flex flex-row items-center">
               <Switch size="small" className="mr-1" checked={isEnableScript} onChange={handleEnableScriptChange} />
               <Button type="text" icon={<IconSettings />} iconOnly onClick={handleSettingsClick} />
@@ -215,31 +213,37 @@ function App() {
                     }}
                     onClickMenuItem={handleMenuClick}
                   >
-                    <Menu.Item key="newScript">
+                    <Menu.Item key="newScript" className="flex flex-row items-center">
                       <IconPlus style={iconStyle} />
                       {t("create_script")}
                     </Menu.Item>
-                    <Menu.Item key={`https://scriptcat.org/search?domain=${url && url.host}`}>
+                    <Menu.Item
+                      key={`https://scriptcat.org/search?domain=${url && url.host}`}
+                      className="flex flex-row items-center"
+                    >
                       <IconSearch style={iconStyle} />
                       {t("get_script")}
                     </Menu.Item>
-                    <Menu.Item key={"checkUpdate"}>
+                    <Menu.Item key={"checkUpdate"} className="flex flex-row items-center">
                       <IconSync style={iconStyle} />
                       {t("check_update")}
                     </Menu.Item>
-                    <Menu.Item key="report_issue">
+                    <Menu.Item key="report_issue" className="flex flex-row items-center">
                       <IconBug style={iconStyle} />
                       {t("report_issue")}
                     </Menu.Item>
-                    <Menu.Item key={`${DocumentationSite}${localePath}`}>
+                    <Menu.Item key={`${DocumentationSite}${localePath}`} className="flex flex-row items-center">
                       <IconBook style={iconStyle} />
                       {t("project_docs")}
                     </Menu.Item>
-                    <Menu.Item key={isChineseUser() ? "https://bbs.tampermonkey.net.cn/" : Discord}>
+                    <Menu.Item
+                      key={isChineseUser() ? "https://bbs.tampermonkey.net.cn/" : Discord}
+                      className="flex flex-row items-center"
+                    >
                       <RiMessage2Line style={iconStyle} />
                       {t("community")}
                     </Menu.Item>
-                    <Menu.Item key="https://github.com/scriptscat/scriptcat">
+                    <Menu.Item key="https://github.com/scriptscat/scriptcat" className="flex flex-row items-center">
                       <IconGithub style={iconStyle} />
                       {"GitHub"}
                     </Menu.Item>
diff --git a/src/pages/store/features/script.ts b/src/pages/store/features/script.ts
index 02011c818..a4cb84c12 100644
--- a/src/pages/store/features/script.ts
+++ b/src/pages/store/features/script.ts
@@ -1,9 +1,4 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import { createAppSlice } from "../hooks";
-import type { Script, SCRIPT_RUN_STATUS } from "@App/app/repo/scripts";
-import { SCRIPT_STATUS_DISABLE, SCRIPT_STATUS_ENABLE } from "@App/app/repo/scripts";
-import { arrayMove } from "@dnd-kit/sortable";
+import type { Script } from "@App/app/repo/scripts";
 import {
   PermissionClient,
   PopupClient,
@@ -26,35 +21,37 @@ export const valueClient = new ValueClient(message);
 export const resourceClient = new ResourceClient(message);
 export const synchronizeClient = new SynchronizeClient(message);
 
-export const fetchScriptList = createAsyncThunk("script/fetchScriptList", async () => {
+export const fetchScriptList = async () => {
   return await scriptClient.getAllScripts();
-});
+};
+
+export const fetchScript = async (uuid: string) => {
+  return await scriptClient.info(uuid);
+};
 
-export const requestEnableScript = createAsyncThunk(
-  "script/enableScript",
-  async (param: { uuid: string; enable: boolean }) => {
-    return await scriptClient.enable(param.uuid, param.enable);
-  }
-);
+export const requestEnableScript = async (param: { uuid: string; enable: boolean }) => {
+  return await scriptClient.enable(param.uuid, param.enable);
+};
 
-export const requestRunScript = createAsyncThunk("script/runScript", async (uuid: string) => {
+export const requestRunScript = async (uuid: string) => {
   return await runtimeClient.runScript(uuid);
-});
+};
 
-export const requestStopScript = createAsyncThunk("script/stopScript", async (uuid: string) => {
+export const requestStopScript = async (uuid: string) => {
   return await runtimeClient.stopScript(uuid);
-});
+};
 
-export const requestDeleteScript = createAsyncThunk("script/deleteScript", async (uuid: string) => {
-  return await scriptClient.delete(uuid);
-});
+// export const requestDeleteScript = createAsyncThunk("script/deleteScript", async (uuid: string) => {
+//   return await scriptClient.delete(uuid);
+// });
 
-export const requestFilterResult = createAsyncThunk(
-  "script/requestFilterResult",
-  async (req: { type: SearchType; value: string }) => {
-    return await scriptClient.getFilterResult(req);
-  }
-);
+export const requestDeleteScripts = async (uuids: string[]) => {
+  return await scriptClient.deletes(uuids);
+};
+
+export const requestFilterResult = async (req: { type: SearchType; value: string }) => {
+  return await scriptClient.getFilterResult(req);
+};
 
 export type ScriptLoading = Script & {
   enableLoading?: boolean;
@@ -67,126 +64,10 @@ export type ScriptLoading = Script & {
   code?: string; // 用于搜索的脚本代码
 };
 
-const updateScript = (scripts: ScriptLoading[], uuid: string, update: (s: ScriptLoading) => void) => {
-  const script = scripts.find((s) => s.uuid === uuid);
-  if (script) {
-    update(script);
-  }
+export const sortScript = async ({ active, over }: { active: string; over: string }) => {
+  return await scriptClient.sortScript(active, over);
 };
 
-export const scriptSlice = createAppSlice({
-  name: "script",
-  initialState: {
-    scripts: [] as ScriptLoading[],
-  },
-  reducers: {
-    upsertScript: (state, action: PayloadAction<Script>) => {
-      const script = state.scripts.find((s) => s.uuid === action.payload.uuid);
-      if (script) {
-        Object.assign(script, action.payload);
-      } else {
-        // 放到第一
-        state.scripts.splice(0, 0, action.payload);
-      }
-    },
-    batchDeleteScript: (state, action: PayloadAction<string[]>) => {
-      state.scripts = state.scripts.filter((s) => !action.payload.includes(s.uuid));
-    },
-    sortScript: (state, action: PayloadAction<{ active: string; over: string }>) => {
-      let oldIndex = 0;
-      let newIndex = 0;
-      state.scripts.forEach((item, index) => {
-        if (item.uuid === action.payload.active) {
-          oldIndex = index;
-        } else if (item.uuid === action.payload.over) {
-          newIndex = index;
-        }
-      });
-      const newItems = arrayMove(state.scripts, oldIndex, newIndex);
-      state.scripts = newItems;
-      for (let i = 0; i < state.scripts.length; i += 1) {
-        if (state.scripts[i].sort !== i) {
-          state.scripts[i].sort = i;
-        }
-      }
-      scriptClient.sortScript(action.payload.active, action.payload.over);
-    },
-    updateRunStatus: (state, action: PayloadAction<{ uuid: string; runStatus: SCRIPT_RUN_STATUS }>) => {
-      const script = state.scripts.find((s) => s.uuid === action.payload.uuid);
-      if (script) {
-        script.runStatus = action.payload.runStatus;
-      }
-    },
-    updateEnableStatus: (state, action: PayloadAction<{ uuids: string[]; enable: boolean }>) => {
-      state.scripts = state.scripts.map((s) => {
-        if (action.payload.uuids.includes(s.uuid)) {
-          s.status = action.payload.enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE;
-        }
-        return s;
-      });
-    },
-    enableLoading(state, action: PayloadAction<{ uuids: string[]; loading: boolean }>) {
-      state.scripts = state.scripts.map((s) => {
-        if (action.payload.uuids.includes(s.uuid)) {
-          s.enableLoading = action.payload.loading;
-        }
-        return s;
-      });
-    },
-    setScriptFavicon: (state, action: PayloadAction<{ uuid: string; fav: { match: string; icon?: string }[] }[]>) => {
-      const scriptMap = new Map<string, ScriptLoading>();
-      for (const s of state.scripts) {
-        scriptMap.set(s.uuid, s);
-      }
-      for (const item of action.payload) {
-        const script = scriptMap.get(item.uuid);
-        if (script) {
-          script.favorite = item.fav;
-        }
-      }
-    },
-  },
-  extraReducers: (builder) => {
-    builder
-      .addCase(fetchScriptList.fulfilled, (state, action) => {
-        state.scripts = action.payload;
-      })
-      // 处理enableScript
-      .addCase(requestEnableScript.fulfilled, (state, action) => {
-        updateScript(state.scripts, action.meta.arg.uuid, (script) => {
-          script.enableLoading = false;
-          script.status = action.meta.arg.enable ? SCRIPT_STATUS_ENABLE : SCRIPT_STATUS_DISABLE;
-        });
-      })
-      .addCase(requestEnableScript.pending, (state, action) =>
-        updateScript(state.scripts, action.meta.arg.uuid, (s) => (s.enableLoading = true))
-      )
-      // 处理deleteScript
-      .addCase(requestDeleteScript.fulfilled, (state, action) => {
-        state.scripts = state.scripts.filter((s) => s.uuid !== action.meta.arg);
-      })
-      .addCase(requestDeleteScript.pending, (state, action) =>
-        updateScript(state.scripts, action.meta.arg, (s) => (s.actionLoading = true))
-      )
-      // 处理runScript和stopScript
-      .addCase(requestRunScript.pending, (state, action) =>
-        updateScript(state.scripts, action.meta.arg, (s) => (s.actionLoading = true))
-      )
-      .addCase(requestRunScript.fulfilled, (state, action) =>
-        updateScript(state.scripts, action.meta.arg, (s) => (s.actionLoading = false))
-      )
-      .addCase(requestStopScript.pending, (state, action) =>
-        updateScript(state.scripts, action.meta.arg, (s) => (s.actionLoading = true))
-      )
-      .addCase(requestStopScript.fulfilled, (state, action) =>
-        updateScript(state.scripts, action.meta.arg, (s) => (s.actionLoading = false))
-      );
-  },
-  selectors: {
-    selectScripts: (state) => state.scripts,
-  },
-});
-
-export const { sortScript, upsertScript, batchDeleteScript, enableLoading, updateEnableStatus } = scriptSlice.actions;
-
-export const { selectScripts } = scriptSlice.selectors;
+export const pinToTop = async (uuids: string[]) => {
+  return await scriptClient.pinToTop(uuids);
+};
diff --git a/src/pages/store/store.ts b/src/pages/store/store.ts
index 8070d5d60..e5fe0612b 100644
--- a/src/pages/store/store.ts
+++ b/src/pages/store/store.ts
@@ -1,12 +1,11 @@
 import type { Action, ThunkAction } from "@reduxjs/toolkit";
 import { combineSlices, configureStore } from "@reduxjs/toolkit";
 import { setupListeners } from "@reduxjs/toolkit/query";
-import { scriptSlice } from "./features/script";
 import { configSlice } from "./features/config";
 
 // `combineSlices` automatically combines the reducers using
 // their `reducerPath`s, therefore we no longer need to call `combineReducers`.
-const rootReducer = combineSlices(configSlice, scriptSlice);
+const rootReducer = combineSlices(configSlice);
 // Infer the `RootState` type from the root reducer
 export type RootState = ReturnType<typeof rootReducer>;
 
diff --git a/src/pages/store/subscribe.ts b/src/pages/store/subscribe.ts
deleted file mode 100644
index 1be67cad9..000000000
--- a/src/pages/store/subscribe.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { TInstallScript, TDeleteScript, TScriptRunStatus } from "@App/app/service/queue";
-import { messageQueue } from "./global";
-import { store } from "./store";
-import { batchDeleteScript, scriptSlice, upsertScript } from "./features/script";
-
-export default function storeSubscribe() {
-  messageQueue.subscribe<TScriptRunStatus>("scriptRunStatus", (data) => {
-    store.dispatch(scriptSlice.actions.updateRunStatus(data));
-  });
-
-  messageQueue.subscribe<TInstallScript>("installScript", (message) => {
-    store.dispatch(upsertScript(message.script));
-  });
-
-  messageQueue.subscribe<TDeleteScript>("deleteScript", (message) => {
-    store.dispatch(batchDeleteScript([message.uuid]));
-  });
-}
diff --git a/src/pages/store/utils.ts b/src/pages/store/utils.ts
index 0753fc338..61f1c7b57 100644
--- a/src/pages/store/utils.ts
+++ b/src/pages/store/utils.ts
@@ -1,7 +1,5 @@
 import type { Script } from "@App/app/repo/scripts";
 import { extractFavicons } from "@App/pkg/utils/favicon";
-import { store } from "./store";
-import { scriptSlice } from "./features/script";
 import { cacheInstance } from "@App/app/cache";
 import { SystemClient } from "@App/app/service/service_worker/client";
 import { message } from "./global";
@@ -52,7 +50,17 @@ type FavIconResult = {
 };
 
 // 在scriptSlice创建后处理favicon加载，以批次方式处理
-export const loadScriptFavicons = (scripts: Script[]) => {
+export const loadScriptFavicons = async function* (scripts: Script[]) {
+  const stack: any[] = [];
+  const asyncWaiter: { promise?: any; resolve?: any } = {};
+  const createPromise = () => {
+    asyncWaiter.promise = new Promise<{ chunkResults: FavIconResult[]; pendingCount: number }>((resolve) => {
+      asyncWaiter.resolve = resolve;
+    });
+  };
+  createPromise();
+  let pendingCount = scripts.length;
+  if (!pendingCount) return;
   const results: FavIconResult[] = [];
   let waiting = false;
   for (const script of scripts) {
@@ -63,13 +71,22 @@ export const loadScriptFavicons = (scripts: Script[]) => {
       if (!waiting) {
         requestAnimationFrame(() => {
           waiting = false;
-          if (!results.length) return;
           const chunkResults: FavIconResult[] = results.slice(0);
           results.length = 0;
-          store.dispatch(scriptSlice.actions.setScriptFavicon(chunkResults));
+          pendingCount -= chunkResults.length;
+          stack.push({ chunkResults, pendingCount } as { chunkResults: FavIconResult[]; pendingCount: number });
+          asyncWaiter.resolve();
         });
         waiting = true;
       }
     });
   }
+  while (true) {
+    await asyncWaiter.promise;
+    while (stack.length) {
+      yield stack.shift();
+    }
+    if (pendingCount <= 0) break;
+    createPromise();
+  }
 };