Please address the comments from this code review:
## Overall Comments
- Consider splitting this massive refactor into smaller, focused PRs (e.g. handler consolidation, plugin manager setup, utility extraction) to simplify review and reduce the risk of regressions.
- In vite.config.ts the comment still says “只有大于1kb的文件才会被压缩” but the threshold is now 10240 (10 KB) — please update the comment accordingly.
- The inline `filterCallback` definitions in each message handler share nearly identical permission logic—extracting them into a shared helper would cut down on boilerplate and improve maintainability.

## Individual Comments

### Comment 1
<location> `packages/core/src/core/karin/command.ts:209` </location>
<code_context>
+  let regCache = formatReg(reg)
+  let optCache = Object.freeze(formatOptions(options))
+  let logCache = Object.freeze(createLogger(options.log, true))
+  let fncCache = Object.freeze(formatFnc<T>(second, options) as MessageCallback<keyof MessageEventMap>)
+
+  const result: CommandCache = {
</code_context>

<issue_to_address>
Freezing functions is not necessary and may be misleading.

`Object.freeze` does not add meaningful immutability to functions and may cause confusion. Recommend removing it from function objects like `fncCache`.
</issue_to_address>

### Comment 2
<location> `packages/core/src/core/karin/base.ts:78` </location>
<code_context>
+ * @param absPath 调用者
+ * @returns 返回插件文件属性
+ */
+export const createPluginFileProperties = (absPath: string): PluginCacheKeyFile => {
+  return {
+    absPath: formatPath(absPath),
</code_context>

<issue_to_address>
formatPath is applied to path.basename, which may be unnecessary.

Since `basename` returns just the filename, normalizing slashes with `formatPath` may be redundant. Please confirm if this is required.
</issue_to_address>

### Comment 3
<location> `packages/core/src/types/server/plugins.ts:91` </location>
<code_context>
   /** 插件名称 `文件夹根目录名称` */
   name: string
   /** 插件类型 */
-  type: KarinPluginAppsType
+  type: Omit<PluginPackageType, 'apps'> | 'app'
   /** 插件版本 App类型为空 */
   version: string
</code_context>

<issue_to_address>
Type field now uses 'app' instead of 'apps', which may cause confusion.

This inconsistency with the rest of the codebase could cause confusion or matching errors. Please standardize the value used for the `type` field.
</issue_to_address>

### Comment 4
<location> `packages/core/src/event/utils/permission.ts:56` </location>
<code_context>
+    perm: CommandCache['register']['options']['permission'],
+    authFailMsg: CommandCache['register']['options']['authFailMsg']
+  ): boolean => {
+    if (!perm || perm === 'all') {
+      return true
+    }
</code_context>

<issue_to_address>
Default permission fallback may allow unintended access.

If a permission is missing or set to 'all', access is granted to all users. This could lead to unintended exposure if a plugin author omits the permission. Consider using a more restrictive default.
</issue_to_address>

### Comment 5
<location> `packages/core/src/event/utils/permission.ts:99` </location>
<code_context>
-
-  /** 计算插件处理时间 */
-  const start = Date.now()
-  if (ctx.isGroup) {
-    const result = await eventCallEmit.group(ctx, plugin)
-    if (!result) return false
</code_context>

<issue_to_address>
Group and guild permission checks are duplicated.

Refactor the shared permission logic to a common function to simplify maintenance and reduce code duplication.
</issue_to_address>

### Comment 6
<location> `packages/core/src/core/karin/command.ts:196` </location>
<code_context>
  * @returns 返回插件对象
  */
-export const command: CommandType = <T extends keyof MessageEventMap = keyof MessageEventMap> (
+export const command: Callbacks = <T extends keyof MessageEventMap = keyof MessageEventMap> (
   reg: string | RegExp,
-  second: string | Elements | Elements[] | CmdFnc<T>,
</code_context>

<issue_to_address>
Consider extracting the repeated plugin cache wiring logic into a reusable helper function to simplify and shrink the `command` implementation.

Here’s one way to drastically reduce the boilerplate in `command` by pulling out the common “plugin‐cache” wiring into a tiny helper.  All of your nested getters, freezing, and register/unregister calls move into that helper, and `command` simply passes its specific bits (reg ↔ fnc ↔ options, plus your register/unregister functions):

```ts
// util/buildCache.ts
type GetterMap<C,R> = {
  type: string
  getPkg: (ctx: C) => any
  getFile: (ctx: C) => any
  getApp:  (ctx: C) => Record<'id'|'log'|'name', any>
  getReg:  (ctx: C) => R['register']
  getCtl:  (ctx: C, res: R) => R['control']
  onInit?: (ctx: C, res: R) => void
}
export function buildCache<C, R extends {register:any, control:any}>(ctx: C, map: GetterMap<C,R>): R {
  const res = {} as R
  Object.defineProperties(res, {
    type: { get: () => map.type },
    pkg:  { get: () => map.getPkg(ctx) },
    file: { get: () => map.getFile(ctx) },
    app:  { get: () => map.getApp(ctx) },
    register: { get: () => map.getReg(ctx) },
    control:  { get: () => map.getCtl(ctx, res) },
  })
  map.onInit?.(ctx, res)
  return res
}
```

Then your `command` shrinks to:

```ts
import { buildCache } from './util/buildCache'
export const command: Callbacks = <T extends keyof MessageEventMap>(
  reg: string|RegExp,
  second: MessageCallback<T>|MessageSegment,
  options: Options<T>|StringOptions<T> = {}
): CommandCache => {
  // --- your existing setup ---
  const caller = system.getCaller(import.meta.url)!
  const pkgName = manager.getPackageName(caller)!
  const id = createID()
  let regCache = formatReg(reg)
  let optCache = Object.freeze(formatOptions(options))
  let fncCache = Object.freeze(formatFnc(second, options) as MessageCallback<any>)
  let logCache = Object.freeze(createLogger(options.log, true))

  return buildCache(
    { caller, pkgName, id, regCache, optCache, fncCache, logCache },
    {
      type: 'command',
      getPkg:    ctx => manager.getPluginPackageDetail(ctx.pkgName),
      getFile:   ctx => manager.getFileCache(ctx.caller),
      getApp:    ctx => ({ id: ctx.id, log: ctx.logCache, name: ctx.optCache.name }),
      getReg:    ctx => ({ reg: ctx.regCache, fnc: ctx.fncCache, options: ctx.optCache }),
      getCtl:    (ctx, res) => ({
        setReg:    r => ctx.regCache = formatReg(r),
        setFnc:    f => ctx.fncCache = Object.freeze(f),
        setOptions(o) {
          ctx.optCache = Object.freeze(formatOptions(o))
          ctx.logCache = Object.freeze(createLogger(o.log, true))
          ctx.fncCache = Object.freeze(formatFnc(second, o) as any)
        },
        remove:    () => register.unregisterCommand(res.app.id),
      }),
      onInit:    (ctx, res) => register.registerCommand(res),
    }
  )
}
```

Benefits:

- All the nested `get pkg/file/app/register/control` logic lives once in `buildCache`.
- `command` only specifies how to derive those five pieces plus your init hook.
- Future plugin types (e.g. events, hooks, classes) can reuse the same helper with their own mappings.
</issue_to_address>

### Comment 7
<location> `packages/core/src/core/karin/button.ts:80` </location>
<code_context>
  * @param fnc - 函数
+ * @param options - 选项
  */
 export const button = (
   reg: RegExp | string,
-  fnc: Button['fnc'],
</code_context>

<issue_to_address>
Consider extracting the common plugin construction logic into a reusable factory function to simplify and unify plugin creation.

```suggestion
// plugins/base.ts
import { system, types } from '@/utils'
import * as manager from './manager'
import * as registerFns from './register'
import { createID, createLogger } from './util'

export interface PluginBuilderConfig<TOpts, TCache> {
  type: string
  formatOptions: (opts: TOpts) => any
  formatReg?: (reg: string | RegExp) => RegExp
  register: (cache: TCache) => void
  unregister: (id: string) => void
}

export function makePlugin<TOpts, TCache extends { control: { remove(): void }, register: any }>(
  cfg: PluginBuilderConfig<TOpts, TCache>
) {
  return (reg: string | RegExp, fnc: any, options: TOpts): TCache => {
    if (!reg) throw new Error(`[${cfg.type}]: missing reg`)
    if (!fnc) throw new Error(`[${cfg.type}]: missing fnc`)

    const caller = system.getCaller(import.meta.url)!
    const pkgName = manager.getPackageName(caller)!
    const id = createID()

    let regCache = cfg.formatReg ? cfg.formatReg(reg) : (reg instanceof RegExp ? reg : new RegExp(reg))
    let fncCache = fnc
    let optCache = Object.freeze(cfg.formatOptions(options))
    const logCache = Object.freeze(createLogger((options as any).log, true))

    const base: any = {
      get type() { return cfg.type },
      get pkg() {
        if (!pkgName) throw new Error(`use only in standard modules: ${caller}`)
        return manager.getPluginPackageDetail(pkgName)!
      },
      get file() { return manager.getFileCache(caller)! },
      get app() {
        return {
          get id() { return id },
          get type() { return cfg.type },
          get log() { return logCache },
          get name() { return optCache.name }
        }
      },
      get register() {
        return {
          get reg() { return regCache },
          get fnc() { return fncCache },
          get options() { return optCache },
        }
      },
      get control() {
        return {
          setReg(r: string | RegExp) { regCache = cfg.formatReg ? cfg.formatReg(r) : (r instanceof RegExp ? r : new RegExp(r)) },
          setFnc(f: any) { fncCache = f },
          setOptions(o: TOpts) { optCache = cfg.formatOptions(o) },
          remove() { cfg.unregister(id) },
        }
      }
    }

    const cache = base as TCache
    cfg.register(cache)
    return cache
  }
}

// plugins/button.ts
import { makePlugin } from './base'
import type { ButtonOptions, ButtonCache } from './types'
import { formatOptions, formatReg } from './formatters'
import { registerButton, unregisterButton } from './register'

export const button = makePlugin<ButtonOptions, ButtonCache>({
  type: 'button',
  formatOptions,
  formatReg,
  register: registerButton,
  unregister: unregisterButton
})
```

Steps to apply:
1. Extract common builder logic into `makePlugin` (shown in `plugins/base.ts`).
2. Define per-plugin `formatOptions` and optionally `formatReg`/`formatters`.
3. Wire up `button` by calling `makePlugin`, passing `registerButton`/`unregisterButton`.
4. Remove the verbose `button` implementation and replace with the above.

This collapses duplicated getters and control methods into a single factory, reducing maintenance surface without losing functionality.
</issue_to_address>

### Comment 8
<location> `packages/core/src/core/karin/accept.ts:85` </location>
<code_context>
+  let optCache = Object.freeze(formatOptions(options))
+  const logCache = Object.freeze(createLogger(options.log, true))
+
+  const cache: AcceptCache = {
+    get type (): typeof type {
+      return type
</code_context>

<issue_to_address>
Consider extracting the repeated plugin cache, getters, and control logic into a shared factory function to reduce boilerplate across plugins.

Below is one way to trim out almost all of the duplicated “cache + getters + control + register” boilerplate into a single, shared factory. Everything stays 100% the same on the outside, but every plugin just calls this helper:

```ts
// plugins/registerUtil.ts
import { createID, createLogger } from './util'
import * as manager from './manager'

export type PluginConfig<
  Opts,
  RegInfo,
  Cache extends { register: RegInfo; control: any }
> = {
  type: string
  formatOptions: (opts: Opts) => any
  buildRegisterInfo: (
    opts: ReturnType<PluginConfig<Opts, RegInfo, Cache>['formatOptions']>,
    fnc: (...args: any[]) => any
  ) => RegInfo
  registerFn: (cache: Cache) => void
}

export function createPlugin<Opts, RegInfo, Cache extends { register: RegInfo }>(
  cfg: PluginConfig<Opts, RegInfo, Cache>
) {
  return <T extends any>(
    eventOrFnc: T,
    maybeFnc?: (...args: any[]) => any,
    opts: Opts = {} as Opts
  ): Cache => {
    const caller = manager.getCaller(import.meta.url)
    const pkgName = manager.getPackageName(caller)
    const id = createID()
    const type = cfg.type
    // 1) format, 2) build register, 3) build the shared cache shape
    const optCache = Object.freeze(cfg.formatOptions(opts))
    const regInfo = Object.freeze(
      cfg.buildRegisterInfo(optCache, maybeFnc as any)
    )
    const cache = {
      get type() { return type },
      get pkg() {
        if (!pkgName) throw new Error(`请在符合标准规范的文件中使用此方法: ${caller}`)
        return manager.getPluginPackageDetail(pkgName)!
      },
      get file() { return manager.getFileCache(caller) },
      get app() {
        return {
          id,
          type,
          log: createLogger(optCache.log, true),
          name: optCache.name
        }
      },
      get register() { return regInfo },
      get control() {
        return {
          setEvent(e: any) { regInfo.event = e },
          setFnc(f: any) { regInfo.fnc = f },
          setOptions(o: any) { /* re-format and reassign */ },
          remove() { cfg.registerFn(cache as Cache) }
        }
      }
    } as unknown as Cache

    cfg.registerFn(cache)
    return cache
  }
}
```

Then your `accept.ts` becomes:

```ts
import { types } from '@/utils'
import { createPlugin } from '../plugins/registerUtil'
import * as register from '../plugins/register'
import type { NoticeAndRequest } from '@/plugins/types'
import type { FNC } from './util'
import type { AcceptOptions } from './options'

const formatOptions = (o: AcceptOptions) => ({
  event: types.string(o.event, 'notice'),
  adapter: types.array(o.adapter, []),
  dsbAdapter: types.array(o.dsbAdapter, types.array(o.notAdapter, [])),
  priority: types.number(o.rank, types.number(o.priority, 10000)),
  name: types.string(o.name, 'accept'),
  log: types.bool(o.log, true),
})

export interface AcceptRegInfo {
  event: keyof NoticeAndRequest
  fnc: FNC<NoticeAndRequest[keyof NoticeAndRequest]>
  options: ReturnType<typeof formatOptions>
}

export const accept = createPlugin<
  AcceptOptions,
  AcceptRegInfo,
  { register: AcceptRegInfo; control: any }
>({
  type: 'accept',
  formatOptions,
  buildRegisterInfo: (opts, fnc) => ({
    event: opts.event,
    fnc,
    options: opts,
  }),
  registerFn: register.registerAccept,
})
```

This way:

- every plugin (accept/notice/request/…​) calls the *same* `createPlugin` helper  
- all the getters, ID/Logger wiring, `control.*` and `registerFn` call live in one place  
- each plugin file is ~20 LOC instead of ~150  
- functionality is unchanged and fully type-safe
</issue_to_address>

### Comment 9
<location> `packages/core/src/core/karin/handler.ts:81` </location>
<code_context>
+  let optCache = Object.freeze(formatOptions(options))
+  const logCache = Object.freeze(createLogger(options.log, true))
+
+  const cache: HandlerCache = {
+    get type (): typeof type {
+      return type
</code_context>

<issue_to_address>
Consider extracting the repeated plugin cache logic into a reusable factory function to simplify the handler implementation.

Consider extracting the shared “plugin‐cache” boilerplate into a small factory. You’ll end up with a ~20 LOC utility and your `handler()` can collapse to a handful of lines:

```ts
// pluginFactory.ts
import { system, types } from '@/utils'
import * as manager from '../../plugins/manager'

export interface PluginFactoryParams<R, O, C> {
  type: string
  callerUrl: string
  options: O
  formatOptions(o: O): C['register']['options']
  registerPayload: R
  registerFn(cache: C): void
  unregisterFn(id: string): void
  createID(): string
  createLogger?(logOpt: boolean): ReturnType<typeof console.log>
}

export function createPluginCache<R, O, C extends { register: { options: any } }>(
  params: PluginFactoryParams<R, O, C>
): C {
  const {
    type,
    callerUrl,
    options,
    formatOptions,
    registerPayload,
    createID,
    registerFn,
    unregisterFn,
    unregisterFn: remove,
    createLogger,
  } = params

  const caller = system.getCaller(callerUrl)!
  const pkgName = manager.getPackageName(caller)!
  const id = createID()
  let reg = { ...registerPayload }
  let opt = Object.freeze(formatOptions(options))
  const logger = createLogger ? Object.freeze(createLogger(opt.log)) : null

  const cache = {
    get type () { return type },
    get pkg () { return manager.getPluginPackageDetail(pkgName) },
    get file() { return manager.getFileCache(caller) },
    get app() {
      return { id, type, log: logger, name: opt.name }
    },
    get register() {
      return { ...reg, options: opt }
    },
    get control() {
      return {
        setKey(k: any) { reg = { ...reg, key: k } },
        setFnc(f: any) { reg = { ...reg, fnc: f } },
        setOptions(o: O) { opt = Object.freeze(formatOptions(o)) },
        remove() { unregisterFn(id) },
      }
    },
  } as unknown as C

  registerFn(cache)
  return cache
}
```

```ts
// handler.ts
import { createPluginCache } from './pluginFactory'
import { createID, createLogger } from './util'
import * as register from '../../plugins/register'
import type { HandlerCache, HandlerOptions } from './types'

const formatOptions = (opts: HandlerOptions) => ({ /*...*/ })

export function handler(
  key: string,
  fnc: HandlerCache['register']['fnc'],
  options: HandlerOptions = {}
): HandlerCache {
  if (!key || !fnc) throw new Error('[handler]: missing key or fnc')
  return createPluginCache<
    HandlerCache['register'],
    HandlerOptions,
    HandlerCache
  >({
    type: 'handler',
    callerUrl: import.meta.url,
    options,
    formatOptions,
    registerPayload: { key, fnc },
    registerFn: register.registerHandler,
    unregisterFn: register.unregisterHandler,
    createID,
    createLogger: opts => createLogger(opts.log, true),
  })
}
```

This collapses the ~100 LOC of getters + controls into a single reusable factory, while preserving all behavior.
</issue_to_address>

### Comment 10
<location> `packages/core/src/core/karin/base.ts:30` </location>
<code_context>
+}
+
+/** 插件缓存文件属性类型 */
+export interface PluginCacheKeyFile {
+  /** 绝对路径 */
+  absPath: string
</code_context>

<issue_to_address>
Consider removing the manual PluginCacheKeyFile interface and property getters by computing values at creation and using ReturnType for type safety.

Here are two small tweaks that keep all the new functionality but collapse some of the boilerplate around `PluginCacheKeyFile`:

1.  Compute `basename`/`dirname` once at creation (no need for getters).
2.  Use `ReturnType` to avoid repeating the interface.

```ts
// before you had to keep PluginCacheKeyFile in sync…
export const createPluginFileProperties = (absPath: string) => {
  const formatted = formatPath(absPath)
  return {
    absPath: formatted,
    basename: formatPath(path.basename(absPath)),
    dirname:  formatPath(path.dirname(absPath)),
  }
}
// …and an interface PluginCacheKeyFile

// instead, drop the manual interface:
export type PluginCacheKeyFile = ReturnType<typeof createPluginFileProperties>
```

Then in `PluginCache` you still get full type safety:

```ts
export interface PluginCache {
  type: pluginTypes
  app: PluginCacheKeyApp
  file: PluginCacheKeyFile
  pkg: PluginCacheKeyPkg
  register: unknown
  control: unknown
}
```

This removes the getter boilerplate and the duplicated interface while preserving all existing behavior.
</issue_to_address>

### Comment 11
<location> `packages/core/src/core/karin/class.ts:356` </location>
<code_context>
+ * @param file 文件路径
+ * @param Cls 类
+ */
+export const loadClass = (
+  pkgName: string,
+  file: string,
</code_context>

<issue_to_address>
Consider refactoring the 'loadClass' function by extracting CommandCache and control API construction into separate factory functions to reduce file size and improve maintainability.

```markdown
You can dramatically shrink `loadClass` and keep all functionality by moving the “build a CommandCache” and “build its control API” bits into two small factories. For example:

```ts
// src/plugins/class/command-factory.ts
import { createID } from '@/core/karin/util';
import { formatReg, createLogger, formatFnc } from './util';
import type { Plugin, FormatOptions, CommandCache } from './types';
import * as manager from '../../plugins/manager';
import * as register from '../../plugins/register';

export function createClassCommand(
  pkgName: string,
  file: string,
  plugin: Plugin,
  rule: FormatOptions['rule'][number],
  options: FormatOptions,
  ids: string[],
): CommandCache | void {
  if (typeof rule.fnc === 'string' && !(plugin as any)[rule.fnc]) {
    console.warn(`[loadClass][${pkgName}] missing method ${rule.fnc} on ${file}`);
    return;
  }

  const id = createID();
  ids.push(id);
  let regCache = formatReg(rule.reg);
  let fncCache = formatFnc(rule.fnc, plugin);
  let ruleOpts = rule;

  const result: CommandCache = {
    type: 'class',
    get pkg()   { return manager.getPluginPackageDetail(pkgName)!; },
    get file()  { return manager.getFileCache(file); },
    get app()   {
      return { id, type: 'class', log: rule.log, name: rule.name };
    },
    get register() {
      return {
        get reg()     { return regCache; },
        get fnc()     { return fncCache; },
        get options() { return ruleOpts; },
        get instance(){ return plugin; },
        get ids()     { return ids; },
      };
    },
    get control() {
      return {
        setReg: (r) => { regCache = formatReg(r); },
        setFnc: (f) => { fncCache = formatFnc(f, plugin); },
        setRule: (r) => {
          const formatted = formatOptions({ ...options, rule: [r] });
          ruleOpts    = formatted.rule[0];
          regCache    = formatReg(ruleOpts.reg);
        },
        addRule: (newRule) => {
          const { rule: [added] } = formatOptions({ ...options, rule: [newRule] });
          options.rule.push(added);
          const cmd = createClassCommand(pkgName, file, plugin, added, options, ids);
          if (cmd) register.registerCommand(cmd);
        },
        remove: () => register.unregisterCommand(id),
      };
    },
  };

  Object.freeze(result.app.id);
  return result;
}
```

Then your `loadClass` collapses to:

```ts
// src/plugins/class/load-class.ts
import { formatOptions } from './util';
import { createClassCommand } from './command-factory';
import type { Plugin } from './types';
import * as register from '../../plugins/register';

export const loadClass = (pkgName: string, file: string, Cls: unknown) => {
  if (!isClass<Plugin>(Cls)) return;
  const plugin = new (Cls as any)();
  if (!plugin._options) return;

  const opts = formatOptions(plugin._options);
  opts.exportName = plugin.constructor.name;

  const ids: string[] = [];
  for (const rule of opts.rule) {
    const cmd = createClassCommand(pkgName, file, plugin, rule, opts, ids);
    if (cmd) register.registerCommand(cmd);
  }
};
```

This splits concerns into two ~80-line files instead of one 500-line blob, while preserving every getter/setter and runtime check.
</issue_to_address>

### Comment 12
<location> `packages/core/src/plugins/register.ts:23` </location>
<code_context>
+ * 注册命令插件
+ * @param command 命令
+ */
+export const registerCommand = (command: CommandCache) => {
+  manager.cache.command.push(command)
+  manager.cache.count.command++
</code_context>

<issue_to_address>
Consider refactoring the repeated register and unregister logic into generic factory functions to reduce duplication and centralize custom behavior.

Here’s one possible way to collapse all of the nearly‐identical register/unregister blocks into two small factories plus a tiny bit of custom logic only where needed (handlers & tasks).  All existing functionality stays the same:

```ts
// at top of file
type CacheListKey = 'command' | 'accept' | 'button' | 'task';
type CountKey    = CacheListKey;

interface HasAppAndFile {
  app: { id: string };
  file: { absPath: string };
}

// generic factory for simple lists
function makeListHandlers<K extends CacheListKey, T extends HasAppAndFile>(
  listKey: K,
  countKey: CountKey,
  cleanup?: (item: T) => void
) {
  return {
    register(item: T) {
      (manager.cache[listKey] as T[]).push(item);
      manager.cache.count[countKey]++;
    },
    unregister(target: string) {
      target = _formatPath(target);
      const arr = manager.cache[listKey] as T[];
      const idx = arr.findIndex(v => v.app.id === target || v.file.absPath === target);
      if (idx === -1) return;

      if (cleanup) cleanup(arr[idx]);
      arr.splice(idx, 1);
      manager.cache.count[countKey]--;
    }
  };
}

// use it for command/accept/button
const { register: registerCommand, unregister: unregisterCommand } =
  makeListHandlers<'command', CommandCache>('command', 'command');

const { register: registerAccept, unregister: unregisterAccept } =
  makeListHandlers<'accept', AcceptCache>('accept', 'accept');

const { register: registerButton, unregister: unregisterButton } =
  makeListHandlers<'button', ButtonCache>('button', 'button');

// tasks need to cancel
const { register: registerTask, unregister: unregisterTask } =
  makeListHandlers<'task', TaskCache>(
    'task',
    'task',
    task => {
      if (task.register.schedule?.cancel) {
        task.register.schedule.cancel();
      }
    }
  );
```

For handlers (which live in a map of arrays instead of a flat list), we do the same pattern but iterate keys:

```ts
function makeMapHandlers<T extends HasAppAndFile & { register: { key: string } }>(
  mapKey: 'handler',
  countKey: 'handler'
) {
  return {
    register(item: T) {
      const map = manager.cache[mapKey];
      if (!map[item.register.key]) {
        map[item.register.key] = [];
        manager.cache.count[countKey].key++;
      }
      map[item.register.key].push(item);
      manager.cache.count[countKey].fnc++;
    },
    unregister(target: string) {
      target = _formatPath(target);
      const map = manager.cache[mapKey];
      Object.keys(map).forEach(k => {
        const before = map[k].length;
        map[k] = map[k].filter(v => v.app.id !== target && v.file.absPath !== target);
        const removed = before - map[k].length;
        manager.cache.count[countKey].fnc -= removed;
      });
    }
  };
}

export const { register: registerHandler, unregister: unregisterHandler } =
  makeMapHandlers<HandlerCache>('handler', 'handler');
```

You can now delete all of the duplicated `registerX` / `unregisterX` blocks, and keep only these 3 factories + your existing `unregisterApp`, `unregisterPackage`, `sort`, etc.
</issue_to_address>

### Comment 13
<location> `packages/core/src/event/utils/dispatch/message.ts:86` </location>
<code_context>
+ * @param config 好友配置
+ * @param print 打印日志回调函数
+ */
+const callback = async (
+  ctx: FriendMessage | DirectMessage | GroupMessage | GuildMessage | GroupTempMessage,
+  plugin: CommandCache,
</code_context>

<issue_to_address>
Consider refactoring the repetitive context checks and permission logic in the callback function into data-driven helpers to keep the function concise and focused.

```suggestion
You can collapse the repetitive context‐checks and permission logic into small, data-driven helpers. This keeps `callback` short and focused:

1. Define your context hooks in one place:
```ts
// at top
const contextHooks: Array<{
  matches: (ctx: any) => boolean;
  emit: typeof eventCallEmit.friend | typeof eventCallEmit.direct /*…etc*/;
}> = [
  { matches: (ctx) => ctx.isFriend,   emit: eventCallEmit.friend },
  { matches: (ctx) => ctx.isDirect,   emit: eventCallEmit.direct },
  { matches: (ctx) => ctx.isGroup,    emit: eventCallEmit.group },
  { matches: (ctx) => ctx.isGuild,    emit: eventCallEmit.guild },
  { matches: (ctx) => ctx.isGroupTemp,emit: eventCallEmit.groupTemp },
]
```

2. Replace the big `if/else` block with a loop:
```ts
// inside callback():
for (const { matches, emit } of contextHooks) {
  if (matches(ctx)) {
    const ok = await emit(ctx, plugin)
    if (!ok) return false
    break
  }
}
// then the generic message hook
if (!(await eventCallEmit.message(ctx, plugin))) return false
```

3. Merge both permission checks:
```ts
// inside try { … } before calling plugin.register.fnc
const checkPerm = ctx.isPrivate
  ? utils.permission.checkPrivate
  : utils.permission.checkGroup

if (!checkPerm(ctx, plugin.register.options.permission, plugin.register.options.authFailMsg)) {
  return false
}
```

With these changes, `callback` no longer needs deep nesting—each concern is a 3–4 line step, keeping it concise and readable without altering any behavior.
</issue_to_address>

### Comment 14
<location> `packages/core/src/event/utils/initializer.ts:29` </location>
<code_context>
-export const initTips = (
-  ctx: Notice | Request
-) => {
-  switch (ctx.subEvent) {
-    case 'friendPoke':
-      ctx.tips = `戳一戳: ${ctx.content.operatorId} ${ctx.content.action || '戳了戳'} ${ctx.content.targetId}`
</code_context>

<issue_to_address>
Consider replacing the large switch statements for event tips with lookup tables mapping subEvents to generator functions.

```suggestion
// Extract both maps at the top of your module:
const noticeTipGenerators: Record<string, (ctx: Notice) => string> = {
  friendPoke: ({ content }) =>
    `戳一戳: ${content.operatorId} ${content.action || '戳了戳'} ${content.targetId}`,
  receiveLike: ({ content }) => `收到点赞: ${content.count}`,
  friendRecall: ({ content }) => `撤回消息: ${content.messageId}`,
  // …add the rest of your subEvents here
}

const requestTipGenerators: Record<string, (ctx: Request) => string> = {
  groupInvite: ({ content }) =>
    `群邀请: ${content.inviterId} 邀请Bot加入群 ${content.groupId}，flag: ${content.flag}`,
  friendApply: ({ content }) =>
    `好友申请: ${content.applierId} 申请添加Bot为好友，验证信息: ${content.comment || '无'}`,
  // …add the rest of your subEvents here
}

const defaultTip = (rawEvent: any) => `未知子事件: ${JSON.stringify(rawEvent)}`

// Then simplify the methods:
export const initializer = {
  notice: (ctx: Notice): void => {
    const gen = noticeTipGenerators[ctx.subEvent] ?? ((c: Notice) => defaultTip(c.rawEvent))
    ctx.tips = gen(ctx)
  },

  request: (ctx: Request): void => {
    const gen = requestTipGenerators[ctx.subEvent] ?? ((c: Request) => defaultTip(c.rawEvent))
    ctx.tips = gen(ctx)
  },

  // …other methods unchanged
}
```

- Replace the big `switch` blocks with two small lookup tables.
- Keep the same functionality by falling back to `defaultTip` when no key matches.
- This makes adding/removing subEvents much easier and reduces cyclomatic complexity.
</issue_to_address>