mioku 0.9.8 → 1.0.0

package/dist/index.d.ts

@@ -1,8 +1,864 @@
-import * as mioki0 from "mioki";
-import { MiokiContext, MiokiContext as MiokiContext$1, MiokiPlugin } from "mioki";
+import fs from "node:fs";
+import path from "node:path";
+import * as consola_utils0 from "consola/utils";
+import { box, colorize, colors, stripAnsi } from "consola/utils";
+import { BinaryLike, BinaryToTextEncoding } from "node:crypto";
+import * as node_cron0 from "node-cron";
+import { TaskContext } from "node-cron";
+import mriLib from "mri";
+import { Low } from "lowdb";
+import { string2argv } from "string2argv";
+import prettyMs from "pretty-ms";
+import { filesize } from "filesize";
+import dayjs from "dayjs";
+import dedent from "dedent";
+import { ConsolaInstance } from "consola/core";
+import { Jiti } from "jiti";
+import * as crypto0 from "crypto";
 import { EventMap } from "napcat-sdk";
 
+//#region src/logger/types.d.ts
+/** 日志级别，从 silent 到 trace 逐渐详细 */
+type LogLevel = 'silent' | 'error' | 'warn' | 'log' | 'info' | 'debug' | 'trace';
+/** 日志器接口：按级别输出，可派生带标签或作用域的子 logger */
+interface Logger {
+  readonly level: LogLevel;
+  error(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  log(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  trace(...args: unknown[]): void;
+  withTag(tag: string): Logger;
+  child(scope: Record<string, unknown>): Logger;
+}
+//#endregion
+//#region src/logger/index.d.ts
+/** 创建挂在根 logger 下的日志器，输出统一落盘到本次运行的日志文件 */
+declare const createMiokuLogger: (options?: {
+  tag?: string;
+  level?: LogLevel;
+  scope?: Record<string, unknown>;
+}) => Logger;
+/** 全局根 logger */
+declare const rootLogger: Logger;
+/** 运行时调整日志级别，并写回 mioku 配置 */
+declare const applyLogLevel: (level: LogLevel) => void;
+//#endregion
+//#region src/adapter/capability.d.ts
+/** 能力：一个可被适配器实现、被插件调用的操作契约（如 `message.send`） */
+interface Capability<I, O> {
+  readonly name: string;
+  readonly version: number;
+  /** 能力唯一标识，同名同版本的实现只能注册一份 */
+  readonly token: symbol;
+}
+/** 定义一个能力，`I` 为请求类型，`O` 为返回类型 */
+declare const defineCapability: <I, O>(name: string, version?: number) => Capability<I, O>;
+/** 目标上没有注册该能力时抛出的错误 */
+declare class UnsupportedCapabilityError extends Error {
+  readonly capability: string;
+  constructor(capability: string);
+}
+//# sourceMappingURL=capability.d.ts.map
+//#endregion
+//#region src/adapter/registry.d.ts
+interface CapabilityHandler<I, O> {
+  readonly capability: Capability<I, O>;
+  readonly target: CapabilityTarget;
+  readonly handler: (input: I) => Promise<O>;
+}
+/** 能力注册表：按目标（适配器/bot/资源）登记能力的实现，供调用方查找 */
+declare class CapabilityRegistry {
+  #private;
+  /** 注册一个能力的实现，返回取消注册函数 */
+  register<I, O>(capability: Capability<I, O>, target: CapabilityTarget, handler: (input: I) => Promise<O>): () => void;
+  /** 目标是否支持该能力 */
+  supports<I, O>(target: CapabilityTarget, capability: Capability<I, O>): boolean;
+  /** 在目标上调用能力，未注册时抛 `UnsupportedCapabilityError` */
+  invoke<I, O>(target: CapabilityTarget, capability: Capability<I, O>, input: I): Promise<O>;
+  clear(): void;
+}
+//# sourceMappingURL=registry.d.ts.map
+//#endregion
+//#region src/adapter/message.d.ts
+/** 消息段的附件：图片/文件/音视频的资源引用 */
+interface Attachment {
+  readonly id?: string;
+  readonly url?: string;
+  readonly file?: string;
+  readonly data?: Uint8Array;
+  readonly mime?: string;
+  readonly size?: number;
+  readonly name?: string;
+}
+/** 消息段：一段消息的最小单元，如文本、@、图片 */
+interface MessageSegment {
+  readonly type: string;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly attachment?: Attachment;
+  isText(): boolean;
+  toString(): string;
+}
+interface SerializedMessageSegment {
+  readonly type: string;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly attachment?: Attachment;
+}
+/** 消息：消息段的只读数组，带文本提取与按类型过滤的便捷方法 */
+interface Message extends ReadonlyArray<MessageSegment> {
+  readonly raw_message?: string;
+  toString(): string;
+  text(): string;
+  filterByType<T extends MessageSegment = MessageSegment>(type: string): T[];
+  toJSON(): SerializedMessageSegment[];
+}
+/** 发送消息的入参：字符串、单段或段的数组都可以 */
+type MessageInput = string | Message | MessageSegment | readonly (string | MessageSegment)[];
+type PlatformId = string | number;
+declare const toId: (value: PlatformId) => string;
+/** 消息发送目标：群或私聊等会话的定位信息 */
+interface MessageTarget {
+  readonly type: string;
+  readonly id?: PlatformId;
+  readonly parent_id?: PlatformId;
+  readonly user_id?: PlatformId;
+  readonly group_id?: PlatformId;
+}
+interface SentMessage {
+  readonly message_id?: string;
+  readonly sent_at?: number;
+}
+interface ReplyOptions {
+  readonly quote?: boolean;
+}
+type ReplyArg = boolean | ReplyOptions;
+/** 会话引用：用于定位一段会话（含父会话） */
+interface ConversationRef {
+  readonly type: string;
+  readonly id: string;
+  readonly parent_id?: string;
+}
+declare class MessageSegmentImpl implements MessageSegment {
+  readonly type: string;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly attachment: Attachment | undefined;
+  constructor(type: string, data: Record<string, unknown>, attachment?: Attachment);
+  isText(): boolean;
+  toString(): string;
+}
+declare const createMessage: (segments: readonly MessageSegment[], rawMessage?: string) => Message;
+/** 消息段构造器：按类型快速生成消息段 */
+declare const segment: {
+  readonly text: (text: string) => MessageSegment;
+  readonly at: (target: PlatformId) => MessageSegment;
+  /** `file` 为 URL 或本地路径；传 Buffer 会转成 base64 发送 */
+  readonly image: (file: string | Buffer, options?: {
+    local?: boolean;
+  } & Attachment) => MessageSegment;
+  readonly reply: (messageId: PlatformId) => MessageSegment;
+  readonly video: (file: string | Buffer, options?: {
+    local?: boolean;
+  }) => MessageSegment;
+  readonly record: (file: string | Buffer, options?: {
+    local?: boolean;
+  }) => MessageSegment;
+  readonly file: (file: string | Buffer, options?: {
+    local?: boolean;
+    name?: string;
+  }) => MessageSegment;
+  readonly face: (id: string | number) => MessageSegment;
+  readonly forward: (id: string) => MessageSegment;
+  readonly node: (options: {
+    user_id: PlatformId;
+    nickname: string;
+    content: MessageInput;
+  }) => MessageSegment;
+  readonly json: (data: Record<string, unknown> | string) => MessageSegment;
+  readonly raw: (type: string, data: Record<string, unknown>, attachment?: Attachment) => MessageSegment;
+};
+declare const isMessage: (value: unknown) => value is Message;
+/** 取消息中的第一个 @ 目标 */
+declare const atOf: (message: Message) => string | undefined;
+declare const isSegment: (value: unknown) => value is MessageSegment;
+/** 把任意 `MessageInput` 规范化为 `Message` */
+declare const asMessage: (input: MessageInput) => Message;
+//# sourceMappingURL=message.d.ts.map
+//#endregion
+//#region src/capabilities/member.d.ts
+/** 群成员信息 */
+interface MemberInfo {
+  readonly user_id: string;
+  readonly nickname?: string;
+  /** 群名片 */
+  readonly card?: string;
+  readonly role?: 'owner' | 'admin' | 'member' | (string & {});
+  /** 入群时间 */
+  readonly join_time?: number;
+  /** 最后一次发言时间 */
+  readonly last_sent_time?: number;
+  readonly [key: string]: unknown;
+}
+/** 禁言成员的请求参数 */
+interface MemberBanRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+  /** 禁言时长（秒），0 = 解除禁言 */
+  readonly duration: number;
+}
+/** 将成员移出群聊的请求参数 */
+interface MemberKickRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+  /** 是否拒绝该成员后续的加群申请 */
+  readonly reject_add_request?: boolean;
+}
+/** 设置成员群名片的请求参数 */
+interface MemberSetCardRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+  readonly card: string;
+}
+/** 设置或取消群管理员的请求参数 */
+interface MemberSetAdminRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+  readonly enable: boolean;
+}
+/** 查询群成员信息的请求参数 */
+interface MemberGetInfoRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+}
+/** 戳一戳群成员的请求参数 */
+interface MemberPokeRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+}
+/** 设置成员专属头衔的请求参数 */
+interface MemberSetTitleRequest {
+  readonly group_id: PlatformId;
+  readonly user_id: PlatformId;
+  readonly title: string;
+}
+/** 禁言群成员 */
+declare const memberBan: Capability<MemberBanRequest, void>;
+/** 将成员移出群聊 */
+declare const memberKick: Capability<MemberKickRequest, void>;
+/** 设置成员群名片 */
+declare const memberSetCard: Capability<MemberSetCardRequest, void>;
+/** 设置或取消管理员 */
+declare const memberSetAdmin: Capability<MemberSetAdminRequest, void>;
+/** 获取群成员信息 */
+declare const memberGetInfo: Capability<MemberGetInfoRequest, MemberInfo>;
+/** 戳一戳群成员 */
+declare const memberPoke: Capability<MemberPokeRequest, void>;
+/** 设置成员专属头衔 */
+declare const memberSetTitle: Capability<MemberSetTitleRequest, void>;
+//# sourceMappingURL=member.d.ts.map
+//#endregion
+//#region src/capabilities/group.d.ts
+/** 群信息 */
+interface GroupInfo {
+  readonly group_id: string;
+  readonly group_name?: string;
+  readonly member_count?: number;
+  readonly max_member_count?: number;
+  readonly [key: string]: unknown;
+}
+/** 获取群信息的请求参数 */
+interface GroupGetInfoRequest {
+  readonly group_id: PlatformId;
+}
+/** 获取群成员列表的请求参数 */
+interface GroupGetMembersRequest {
+  readonly group_id: PlatformId;
+}
+/** 退出群聊的请求参数 */
+interface GroupLeaveRequest {
+  readonly group_id: PlatformId;
+  /** 是否解散群 */
+  readonly is_dismiss?: boolean;
+}
+/** 修改群名的请求参数 */
+interface GroupSetNameRequest {
+  readonly group_id: PlatformId;
+  readonly group_name: string;
+}
+/** 设置群头像的请求参数 */
+interface GroupSetPortraitRequest {
+  readonly group_id: PlatformId;
+  /** 图片 URL 或本地路径 */
+  readonly file: string;
+}
+/** 全员禁言的请求参数 */
+interface GroupSetWholeBanRequest {
+  readonly group_id: PlatformId;
+  readonly enable: boolean;
+}
+/** 获取群列表的请求参数 */
+interface GroupGetListRequest {}
+/** 获取群信息 */
+declare const groupGetInfo: Capability<GroupGetInfoRequest, GroupInfo>;
+/** 获取群成员列表 */
+declare const groupGetMembers: Capability<GroupGetMembersRequest, MemberInfo[]>;
+/** 退出群聊 */
+declare const groupLeave: Capability<GroupLeaveRequest, void>;
+/** 修改群名 */
+declare const groupSetName: Capability<GroupSetNameRequest, void>;
+/** 全员禁言 */
+declare const groupSetWholeBan: Capability<GroupSetWholeBanRequest, void>;
+/** 设置群头像 */
+declare const groupSetPortrait: Capability<GroupSetPortraitRequest, void>;
+/** 获取群列表 */
+declare const groupGetList: Capability<GroupGetListRequest, GroupInfo[]>;
+/** 群操作句柄：绑定某个群的快捷操作 */
+interface Group {
+  readonly group_id: string;
+  readonly group_name?: string;
+  sendMsg(message: MessageInput): Promise<SentMessage>;
+  getInfo(): Promise<GroupInfo | null>;
+  getList(): Promise<GroupInfo[]>;
+  getMemberList(): Promise<MemberInfo[]>;
+  getMemberInfo(userId: PlatformId): Promise<MemberInfo | null>;
+  /** 禁言成员，duration 单位为秒，0 表示解除 */
+  ban(userId: PlatformId, duration: number): Promise<void>;
+  kick(userId: PlatformId, rejectAddRequest?: boolean): Promise<void>;
+  setCard(userId: PlatformId, card: string): Promise<void>;
+  setAdmin(userId: PlatformId, enable: boolean): Promise<void>;
+  recall(messageId: PlatformId): Promise<void>;
+  /** 退出群聊，isDismiss 为 true 时解散群 */
+  leave(isDismiss?: boolean): Promise<void>;
+  setName(groupName: string): Promise<void>;
+  setPortrait(file: string): Promise<void>;
+}
+/** 为指定群创建操作句柄 */
+declare const createGroupRef: (bot: Bot, group_id: PlatformId, group_name?: string) => Group;
+//# sourceMappingURL=group.d.ts.map
+//#endregion
+//#region src/capabilities/friend.d.ts
+/** 好友信息 */
+interface FriendInfo {
+  readonly user_id: string;
+  readonly nickname?: string;
+  readonly remark?: string;
+  readonly [key: string]: unknown;
+}
+/** 获取好友信息的请求参数 */
+interface FriendGetInfoRequest {
+  readonly user_id: PlatformId;
+}
+/** 删除好友的请求参数 */
+interface FriendDeleteRequest {
+  readonly user_id: PlatformId;
+}
+/** 获取好友列表的请求参数 */
+interface FriendGetListRequest {}
+/** 获取好友信息 */
+declare const friendGetInfo: Capability<FriendGetInfoRequest, FriendInfo>;
+/** 删除好友 */
+declare const friendDelete: Capability<FriendDeleteRequest, void>;
+/** 获取好友列表 */
+declare const friendGetList: Capability<FriendGetListRequest, FriendInfo[]>;
+/** 好友操作句柄：绑定某个好友的快捷操作 */
+interface Friend {
+  readonly user_id: string;
+  readonly nickname?: string;
+  sendMsg(message: MessageInput): Promise<SentMessage>;
+  getInfo(): Promise<FriendInfo | null>;
+  getList(): Promise<FriendInfo[]>;
+  delete(): Promise<void>;
+}
+/** 为指定好友创建操作句柄 */
+declare const createFriendRef: (bot: Bot, user_id: PlatformId, nickname?: string) => Friend;
+//# sourceMappingURL=friend.d.ts.map
+//#endregion
+//#region src/adapter/event.d.ts
+/** 事件的全局标识：来自哪个适配器、哪个 bot、哪类事件 */
+interface EventIdentity {
+  readonly adapter: string;
+  readonly bot_id?: string;
+  readonly source_id?: string;
+  readonly event_type: string;
+  readonly message_id?: string;
+  readonly timestamp?: number;
+  readonly native_event_id?: string;
+  readonly fingerprint?: string;
+}
+/** 所有事件的公共基础结构 */
+interface EventBase {
+  /** 事件大类：message / notice / request / meta_event / adapter */
+  readonly kind: string;
+  /** 事件类型，如 `message`、`notice.group.poke` */
+  readonly type: string;
+  /** 该事件可匹配的路由列表，由 `buildRoutes` 生成 */
+  readonly routes: readonly string[];
+  readonly identity: EventIdentity;
+  readonly self_id?: string;
+  readonly bot?: Bot;
+  readonly time?: number;
+  readonly raw?: unknown;
+}
+/** 与具体 bot 绑定的事件（含 message / notice / request / meta_event） */
+interface BotEventBase extends EventBase {
+  readonly self_id: string;
+  readonly bot: Bot;
+}
+interface SenderInfo {
+  readonly user_id?: string;
+  readonly nickname?: string;
+  readonly card?: string;
+  readonly role?: 'owner' | 'admin' | 'member' | (string & {});
+}
+/** 消息事件：私聊与群聊消息 */
+interface MessageEvent extends BotEventBase {
+  readonly kind: 'message';
+  readonly message_type: 'private' | 'group' | 'channel' | 'thread' | 'direct' | (string & {});
+  readonly sub_type?: string;
+  readonly user_id?: string;
+  readonly group_id?: string;
+  readonly group_name?: string;
+  readonly message_id?: string;
+  readonly raw_message?: string;
+  readonly quote_id?: string;
+  readonly sender?: SenderInfo;
+  readonly group?: Group;
+  readonly friend?: Friend;
+  readonly conversation?: ConversationRef;
+  readonly message: Message;
+  readonly is_to_me?: boolean;
+  readonly at?: string;
+  /** 回复这条消息 */
+  reply(message: MessageInput, options?: boolean | ReplyOptions): Promise<SentMessage>;
+  recall(): Promise<void>;
+}
+/** 通知事件：群成员变动、戳一戳等 */
+interface NoticeEvent extends BotEventBase {
+  readonly kind: 'notice';
+  readonly notice_type?: string;
+  readonly sub_type?: string;
+  readonly user_id?: string;
+  readonly group_id?: string;
+  readonly operator_id?: string;
+}
+/** 请求事件：加群/好友申请，可 approve 或 reject */
+interface RequestEvent extends BotEventBase {
+  readonly kind: 'request';
+  readonly request_type?: string;
+  readonly sub_type?: string;
+  readonly user_id?: string;
+  readonly group_id?: string;
+  readonly flag?: string;
+  readonly comment?: string;
+  approve(): Promise<void>;
+  reject(reason?: string): Promise<void>;
+}
+/** 生命周期元事件 */
+interface MetaEvent extends BotEventBase {
+  readonly kind: 'meta_event';
+  readonly meta_event_type?: string;
+  readonly sub_type?: string;
+}
+/** 适配器自定义事件：不归属以上四类时使用 */
+interface AdapterEvent extends EventBase {
+  readonly kind: 'adapter';
+  readonly payload: unknown;
+}
+type Event = MessageEvent | NoticeEvent | RequestEvent | MetaEvent | AdapterEvent;
+type BotEvent = MessageEvent | NoticeEvent | RequestEvent | MetaEvent;
+declare const isMessageEvent: (e: Event) => e is MessageEvent;
+declare const isNoticeEvent: (e: Event) => e is NoticeEvent;
+declare const isRequestEvent: (e: Event) => e is RequestEvent;
+declare const isMetaEvent: (e: Event) => e is MetaEvent;
+declare const isAdapterEvent: (e: Event) => e is AdapterEvent;
+declare const isBotEvent: (e: Event) => e is BotEvent;
+interface EventFactoryOptions<T extends MessageEvent | NoticeEvent | RequestEvent | MetaEvent | AdapterEvent> {
+  readonly routes: readonly string[];
+  readonly identity: EventIdentity;
+  readonly bot?: Bot;
+  readonly self_id?: string;
+  readonly time?: number;
+  readonly raw?: unknown;
+}
+/**
+ * 根据平台信息生成层级路由列表。
+ * 例如 `buildRoutes("onebotv11", "message", "group")` 会生成
+ * `onebotv11:message.group`、`onebotv11:message`、`onebotv11`、`message.group`、`message` 等，
+ * 监听任意一层都能收到该事件。
+ */
+declare const buildRoutes: (adapter: string, ...parts: (string | undefined | null)[]) => string[];
+//#endregion
+//#region src/capabilities/message.d.ts
+/** 发送消息的请求参数 */
+interface MessageSendRequest {
+  readonly target: MessageTarget;
+  readonly message: MessageInput;
+}
+/** 撤回消息的请求参数 */
+interface MessageRecallRequest {
+  readonly message_id: PlatformId;
+}
+/** 获取单条消息的请求参数 */
+interface MessageGetRequest {
+  readonly message_id: PlatformId;
+}
+/** 获取到的消息详情 */
+interface MessageGetResult {
+  readonly message_id: string;
+  readonly message: Message;
+  readonly raw_message?: string;
+  readonly time?: number;
+  readonly user_id?: string;
+  readonly [key: string]: unknown;
+}
+/** 合并转发消息里的一条子消息 */
+interface ForwardNode {
+  readonly user_id?: string;
+  readonly nickname?: string;
+  readonly time?: number;
+  readonly message: Message;
+}
+/** 获取合并转发消息内容的请求参数 */
+interface MessageGetForwardRequest {
+  readonly message_id: PlatformId;
+}
+/** 构造合并转发消息的单个节点 */
+interface ForwardSendNode {
+  readonly user_id: PlatformId;
+  readonly nickname: string;
+  readonly content: MessageInput;
+}
+/** 合并转发消息的外显样式 */
+interface ForwardSendOptions {
+  /** 卡片来源显示文本 */
+  readonly source?: string;
+  /** 卡片外显的摘要条目 */
+  readonly news?: ReadonlyArray<{
+    text: string;
+  }>;
+  /** 卡片底部的总摘要 */
+  readonly summary?: string;
+}
+/** 发送合并转发消息的请求参数 */
+interface ForwardSendRequest extends ForwardSendOptions {
+  readonly target: MessageTarget;
+  readonly nodes: readonly ForwardSendNode[];
+}
+/** 发送消息 */
+declare const messageSend: Capability<MessageSendRequest, SentMessage>;
+/** 撤回消息 */
+declare const messageRecall: Capability<MessageRecallRequest, void>;
+/** 获取单条消息 */
+declare const messageGet: Capability<MessageGetRequest, MessageGetResult>;
+/** 获取合并转发消息的内容 */
+declare const messageGetForward: Capability<MessageGetForwardRequest, ForwardNode[]>;
+/** 发送合并转发消息 */
+declare const forwardSend: Capability<ForwardSendRequest, SentMessage>;
+//# sourceMappingURL=message.d.ts.map
+//#endregion
+//#region src/capabilities/conversation.d.ts
+/** 历史消息记录 */
+interface HistoryMessage {
+  readonly message_id: string;
+  readonly time?: number;
+  readonly user_id?: string;
+  readonly nickname?: string;
+  readonly message: Message;
+}
+/** 拉取会话历史消息的请求参数 */
+interface ConversationGetHistoryRequest {
+  readonly target: MessageTarget;
+  /** 从这个消息 id 之前开始取（不含该条） */
+  readonly before?: PlatformId;
+  readonly limit?: number;
+  /** 适配器私有扩展参数透传 */
+  readonly extra?: Record<string, unknown>;
+}
+/** 拉取会话的历史消息 */
+declare const conversationGetHistory: Capability<ConversationGetHistoryRequest, HistoryMessage[]>;
+//# sourceMappingURL=conversation.d.ts.map
+//#endregion
+//#region src/capabilities/profile.d.ts
+/** 修改 bot 自身资料的请求参数 */
+interface ProfileSetRequest {
+  readonly nickname?: string;
+  /** 个性签名 */
+  readonly personal_note?: string;
+  /** 性别编码，具体取值由适配器定义 */
+  readonly sex?: number;
+  readonly [key: string]: unknown;
+}
+/** 设置 bot 头像的请求参数 */
+interface AvatarSetRequest {
+  /** 图片 URL 或本地路径 */
+  readonly file: string;
+}
+/** 修改 bot 自身资料 */
+declare const profileSet: Capability<ProfileSetRequest, void>;
+/** 设置 bot 头像 */
+declare const avatarSet: Capability<AvatarSetRequest, void>;
+//# sourceMappingURL=profile.d.ts.map
+//#endregion
+//#region src/capabilities/system.d.ts
+/** bot 登录状态信息 */
+interface BotStatusResult {
+  readonly online: boolean;
+  readonly app_name?: string;
+  readonly app_version?: string;
+  readonly protocol_version?: string;
+  readonly [key: string]: unknown;
+}
+/** 查询 bot 登录状态 */
+declare const botStatus: Capability<Record<string, never>, BotStatusResult>;
+//# sourceMappingURL=system.d.ts.map
+//#endregion
+//#region src/adapter/bot.d.ts
+/**
+ * Bot 接口：所有平台 bot 的统一操作面。
+ * 除 `bot_id` / `adapter` / `sendMessage` / `sendApi` / `as` 外，
+ * 其余方法由框架按能力自动绑定（见 `bindCapabilities`）。
+ */
+interface BotBase {
+  readonly bot_id: string;
+  readonly adapter: string;
+  readonly nickname?: string;
+  readonly online: boolean;
+  readonly connected_at?: number;
+  sendMessage(target: MessageTarget, message: MessageInput): Promise<SentMessage>;
+  sendGroupMsg(group_id: PlatformId, message: MessageInput): Promise<SentMessage>;
+  sendPrivateMsg(user_id: PlatformId, message: MessageInput): Promise<SentMessage>;
+  recallMessage(message_id: PlatformId): Promise<void>;
+  getMessage(message_id: PlatformId): Promise<MessageGetResult | null>;
+  getForwardMessage(message_id: PlatformId): Promise<ForwardNode[]>;
+  sendForward(target: MessageTarget, nodes: readonly ForwardSendNode[], options?: ForwardSendOptions): Promise<SentMessage>;
+  getGroupInfo(group_id: PlatformId): Promise<GroupInfo | null>;
+  getGroupList(): Promise<GroupInfo[]>;
+  getGroupMembers(group_id: PlatformId): Promise<MemberInfo[]>;
+  getMemberInfo(group_id: PlatformId, user_id: PlatformId): Promise<MemberInfo | null>;
+  /** duration 单位为秒，0 = 解除禁言 */
+  banMember(group_id: PlatformId, user_id: PlatformId, duration: number): Promise<void>;
+  /** reject_add_request 为 true 时同时拒绝该成员后续的加群申请 */
+  kickMember(group_id: PlatformId, user_id: PlatformId, reject_add_request?: boolean): Promise<void>;
+  setMemberCard(group_id: PlatformId, user_id: PlatformId, card: string): Promise<void>;
+  setMemberAdmin(group_id: PlatformId, user_id: PlatformId, enable: boolean): Promise<void>;
+  setMemberTitle(group_id: PlatformId, user_id: PlatformId, title: string): Promise<void>;
+  pokeMember(group_id: PlatformId, user_id: PlatformId): Promise<void>;
+  setGroupName(group_id: PlatformId, group_name: string): Promise<void>;
+  setGroupWholeBan(group_id: PlatformId, enable: boolean): Promise<void>;
+  setGroupPortrait(group_id: PlatformId, file: string): Promise<void>;
+  /** is_dismiss 为 true 时解散群（仅群主可用） */
+  leaveGroup(group_id: PlatformId, is_dismiss?: boolean): Promise<void>;
+  getFriendInfo(user_id: PlatformId): Promise<FriendInfo | null>;
+  getFriendList(): Promise<FriendInfo[]>;
+  deleteFriend(user_id: PlatformId): Promise<void>;
+  setProfile(profile: ProfileSetRequest): Promise<void>;
+  /** file 为本地路径或 URL */
+  setAvatar(file: string): Promise<void>;
+  /** 拉取会话历史，`before` 为上一页的消息 id */
+  getHistory(target: MessageTarget, before?: string, limit?: number, extra?: Record<string, unknown>): Promise<HistoryMessage[]>;
+  getStatus(): Promise<BotStatusResult>;
+  /** 直接调用平台原生 API（action 为平台动作名） */
+  sendApi<T = unknown>(action: string, params?: Record<string, unknown>): Promise<T>;
+  /** 按目标类型断言 bot，用于访问平台特有方法 */
+  as<T extends object = Record<string, unknown>>(): T;
+}
+type BotProvidedKeys = "bot_id" | "adapter" | "nickname" | "online" | "connected_at" | "sendMessage" | "sendApi" | "as";
+type BotAutoFilled = Exclude<keyof BotBase, BotProvidedKeys>;
+type AdapterBotBase<B extends BotBase> = Omit<B, BotAutoFilled> & Partial<Pick<B, BotAutoFilled>>;
+interface AdapterBotMap {}
+type Bot = AdapterBotMap[keyof AdapterBotMap] extends never ? BotBase : AdapterBotMap[keyof AdapterBotMap];
+interface BotContext {
+  readonly bot: Bot;
+  unregister(): void;
+}
+/**
+ * 把能力注册表中的实现绑定为 bot 的方法。
+ * 适配器在 `start()` 里对自己创建的 bot 调用一次，
+ * 插件拿到的 bot 就带上了完整操作面。
+ */
+declare const bindCapabilities: <B extends object>(bot: B, registry: CapabilityRegistry) => B & BotBase;
+//# sourceMappingURL=bot.d.ts.map
+//#endregion
+//#region src/driver/types.d.ts
+/** 一条已建立的 WebSocket 连接 */
+interface WebSocketConnection {
+  readonly id: string;
+  readonly url: string;
+  readonly readyState: 'connecting' | 'open' | 'closing' | 'closed';
+  send(data: string | Uint8Array): Promise<void>;
+  close(code?: number, reason?: string): Promise<void>;
+  /** 监听消息，返回取消监听的函数 */
+  onMessage(handler: (data: string | Uint8Array) => void): () => void;
+  /** 监听连接关闭，返回取消监听的函数 */
+  onClose(handler: (event: {
+    code: number;
+    reason: string;
+  }) => void): () => void;
+  /** 监听连接错误，返回取消监听的函数 */
+  onError(handler: (err: Error) => void): () => void;
+}
+/** 建立 WebSocket 连接的选项 */
+interface WebSocketConnectOptions {
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly protocols?: readonly string[];
+  readonly signal?: AbortSignal;
+  /** 连接超时时间（毫秒） */
+  readonly connectTimeout?: number;
+}
+/** WebSocket 客户端 */
+interface WebSocketClient {
+  connect(url: string, options?: WebSocketConnectOptions): Promise<WebSocketConnection>;
+}
+/** HTTP 请求参数 */
+interface HttpRequestOptions {
+  readonly method: string;
+  readonly url: string;
+  readonly headers?: Readonly<Record<string, string>>;
+  /** 请求体：字符串、二进制或对象（对象按 JSON 发送） */
+  readonly body?: string | Uint8Array | Readonly<Record<string, unknown>>;
+  /** 超时时间（毫秒） */
+  readonly timeout?: number;
+  readonly signal?: AbortSignal;
+}
+/** HTTP 响应 */
+interface HttpResponse {
+  readonly status: number;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body: Uint8Array;
+  text(): string;
+  json<T = unknown>(): T;
+  arrayBuffer(): ArrayBuffer;
+}
+/** HTTP 客户端 */
+interface HttpClient {
+  request(options: HttpRequestOptions): Promise<HttpResponse>;
+}
+/** 驱动：为适配器提供统一的 HTTP 与 WebSocket 能力 */
+interface Driver {
+  readonly name: string;
+  readonly http: HttpClient;
+  readonly websocket: WebSocketClient;
+  /** 关闭驱动：中止进行中的请求并断开所有连接 */
+  shutdown(): Promise<void>;
+}
+/** 驱动已关闭后发起请求时抛出的错误 */
+declare class DriverShutdownError extends Error {
+  constructor(message?: string);
+}
+/** WebSocket 连接超时时抛出的错误 */
+declare class WebSocketConnectTimeoutError extends Error {
+  constructor(url: string, timeout: number);
+}
+/** HTTP 请求失败时抛出的错误 */
+declare class HttpRequestError extends Error {
+  /** HTTP 状态码，网络错误或超时时为 0 */
+  readonly status: number;
+  constructor(message: string, status: number);
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/driver/default.d.ts
+/** 创建默认驱动的选项 */
+interface CreateDriverOptions {
+  /** HTTP 请求的默认超时（毫秒） */
+  readonly requestTimeout?: number;
+  /** WebSocket 连接的默认超时（毫秒） */
+  readonly connectTimeout?: number;
+}
+/** 创建内置默认驱动：基于全局 fetch 与 WebSocket 实现 */
+declare const createDefaultDriver: (options?: CreateDriverOptions) => Driver;
+//# sourceMappingURL=default.d.ts.map
+//#endregion
+//#region src/adapter/types.d.ts
+/** 能力的作用目标：按适配器 / bot / 具体资源定位能力实现 */
+interface CapabilityTarget {
+  readonly adapter: string;
+  readonly bot_id?: string;
+  readonly resource_id?: string;
+}
+/** 适配器定义：适配器包导出的核心对象，`defineAdapter()` 的返回值 */
+interface AdapterDefinition<TConfig = unknown> {
+  readonly name: string;
+  readonly version: string;
+  /** 框架与适配器的 API 约定版本，不匹配会拒绝加载 */
+  readonly apiVersion: number;
+  readonly create: (options: AdapterFactoryOptions<TConfig>) => Adapter | Promise<Adapter>;
+  readonly validateConfig?: (config: unknown) => TConfig;
+}
+interface AdapterFactoryOptions<TConfig = unknown> {
+  readonly config: TConfig;
+  readonly logger: Logger;
+}
+/** 适配器启动后拿到的上下文：注册 bot、能力、网关与资源，派发事件 */
+interface AdapterContext {
+  registerBot(bot: Bot): BotContext;
+  unregisterBot(bot_id: string): void;
+  getDriver(): Driver;
+  registerCapability<I, O>(capability: Capability<I, O>, target: CapabilityTarget, handler: (input: I) => Promise<O>): () => void;
+  getCapabilityRegistry(): CapabilityRegistry;
+  registerGateway(gateway: AdapterGateway): () => void;
+  registerResource(resource: AdapterResource): () => void;
+  dispatch(event: Event): Promise<void>;
+  emitLifecycle(event: BotLifecycleEvent): Promise<void>;
+  /**
+   * 订阅框架事件总线上的事件
+   * 返回取消订阅函数
+   */
+  listen(route: string, handler: (event: Event) => void | Promise<void>): () => void;
+}
+/** 适配器实例：start 时建立连接并注册资源，stop 时释放 */
+interface Adapter {
+  readonly name: string;
+  readonly version: string;
+  start(context: AdapterContext): Promise<void> | void;
+  stop(reason?: string): Promise<void> | void;
+}
+/** 网关：适配器内部的一个独立连接单元（如一条 WebSocket 连接） */
+interface AdapterGateway {
+  readonly name: string;
+  start(): Promise<void> | void;
+  stop(reason?: string): Promise<void> | void;
+}
+/** 资源的归属范围：适配器级 / 网关级 / bot 级 */
+type AdapterResourceScope = "adapter" | "gateway" | "bot";
+/** 适配器声明的可释放资源，随适配器关闭一并清理 */
+interface AdapterResource {
+  readonly name: string;
+  readonly scope: AdapterResourceScope;
+  readonly gateway?: string;
+  readonly bot_id?: string;
+  dispose(reason?: string): void | Promise<void>;
+}
+interface BotLifecycleEvent {
+  readonly type: "bot:connected" | "bot:disconnected";
+  readonly bot: Bot;
+  readonly reason?: string;
+}
+declare const defineAdapter: <TConfig>(definition: AdapterDefinition<TConfig>) => AdapterDefinition<TConfig>;
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/services/registry.d.ts
+/** 按名称索引的服务注册表 */
+interface MiokuServices {
+  [key: string]: unknown;
+}
+/** 全局服务注册表实例，已加载的服务都注册在这里 */
+declare const servicesRegistry: Record<string, unknown>;
+/** 按名称取服务，不存在时返回 undefined */
+
+/**
+ * 注册服务并返回移除该服务的函数。
+ * cover 为 false 且同名服务已存在时跳过注册。
+ */
+declare const setService: <T = unknown>(name: string, value: T, cover?: boolean) => () => void;
+/** setService 的别名 */
+declare const addService: <T = unknown>(name: string, value: T, cover?: boolean) => (() => void);
+/** 惰性创建服务的工厂函数 */
+type ServiceFactory<T> = () => T;
+//# sourceMappingURL=registry.d.ts.map
+//#endregion
 //#region src/types.d.ts
+/** 框架服务的最小形态：init 负责初始化，api 是对外暴露的接口对象 */
 interface MiokuService {
   name: string;
   version: string;
@@ -11,21 +867,23 @@ interface MiokuService {
   api: Record<string, any>;
   dispose?(): Promise<void>;
 }
+/** package.json 的 `mioku` 字段中控制框架行为的运行时配置 */
 interface MiokuRuntimeConfig {
   plugins?: string[];
   plugins_dir?: string;
   services_dir?: string;
   [key: string]: unknown;
 }
+/** 宽松的 package.json 结构，用于读取插件的元信息 */
 interface PackageJsonLike {
   name?: string;
   version?: string;
   description?: string;
-  keywords?: string[];
-  mioki?: MiokuRuntimeConfig;
-  mioku?: PluginPackageConfig;
+  keywords?: readonly string[];
+  mioku?: unknown;
   dependencies?: Record<string, string>;
 }
+/** 已加载插件的元信息，供内置 core 插件与帮助系统使用 */
 interface PluginMetadata {
   name: string;
   version: string;
@@ -34,6 +892,7 @@ interface PluginMetadata {
   packageJson: PackageJsonLike;
   config: PluginPackageConfig;
 }
+/** 已发现服务的元信息 */
 interface ServiceMetadata {
   name: string;
   version: string;
@@ -41,11 +900,14 @@ interface ServiceMetadata {
   path: string;
   packageJson: PackageJsonLike;
 }
+/** 插件 package.json 中 `mioku` 字段的解析结果 */
 interface PluginPackageConfig {
+  /** 插件依赖的服务名，如 `ai`、`config` */
   services?: string[];
   help?: PluginHelp;
   accessHooks?: AccessHook[];
 }
+/** 插件的帮助信息，框架会自动收集并注册到帮助服务 */
 interface PluginHelp {
   title: string;
   description: string;
@@ -68,7 +930,9 @@ type SkillPermissionRole = "master" | "owner" | "admin" | "member";
 declare function normalizeSkillPermissionRole(role: unknown): SkillPermissionRole;
 interface AccessHook {
   id: string;
+  /** 匹配文本的正则（字符串形式，如 `/^\.help$/`），用于在事件层面拦截/放行 */
   match?: string;
+  /** 命中的事件路由，如 `notice.group.poke` */
   event?: string;
   description?: string;
 }
@@ -80,25 +944,30 @@ interface AccessScopeConfig {
   plugins?: Record<string, AccessRuleEntry>;
   commands?: Record<string, Record<string, AccessRuleEntry>>;
 }
+/** 访问控制配置：按全局 / 群 / 用户三级对插件与指令放行或拦截 */
 interface AccessControlConfig {
   version: 1;
   global: AccessScopeConfig;
   groups: Record<string, AccessScopeConfig>;
   users: Record<string, AccessScopeConfig>;
 }
+/** 配置服务：插件的配置文件统一注册、读取与热更新 */
 interface ConfigService {
   registerConfig(pluginName: string, configName: string, initialConfig: any): Promise<boolean>;
   updateConfig(pluginName: string, configName: string, updates: any): Promise<boolean>;
   getConfig(pluginName: string, configName: string): Promise<any>;
   getPluginConfigs(pluginName: string): Promise<Record<string, any>>;
+  /** 订阅配置变化，返回取消订阅函数 */
   onConfigChange(pluginName: string, configName: string, callback: (newConfig: any) => void): () => void;
 }
+/** 截图服务：把 HTML / Markdown / URL 渲染成图片 */
 interface ScreenshotService {
   screenshot(html: string, options?: any): Promise<string>;
   screenshotMarkdown(markdownContent: string, options?: any): Promise<string>;
   screenshotFromUrl(url: string, options?: any): Promise<string>;
   cleanupTemp(olderThanMs?: number): Promise<number>;
 }
+/** 帮助服务：插件的帮助信息注册与查询 */
 interface HelpService {
   registerHelp(pluginName: string, help: PluginHelp): void;
   getHelp(pluginName: string): PluginHelp | undefined;
@@ -112,6 +981,7 @@ interface WebUIService {
     packageManager: string;
   };
 }
+/** AI 工具：暴露给模型的函数，供模型在对话中调用 */
 interface AITool {
   name: string;
   description: string;
@@ -122,6 +992,7 @@ interface AITool {
   };
   handler: (args: any, event?: any) => Promise<any> | any;
 }
+/** AI 技能：一组工具的组合，可按权限开放给不同角色的用户 */
 interface AISkill {
   name: string;
   description: string;
@@ -132,6 +1003,7 @@ interface TextMessage {
   role: "system" | "user" | "assistant";
   content: string;
 }
+/** 多模态消息内容：文本或图片 URL */
 interface MultimodalContentItem {
   type: "text" | "image_url";
   text?: string;
@@ -144,6 +1016,7 @@ interface MultimodalMessage {
   role: "system" | "user" | "assistant";
   content: string | MultimodalContentItem[];
 }
+/** 一次工具调用的记录（名称、参数与结果） */
 interface ToolCallRecord {
   name: string;
   arguments: any;
@@ -153,6 +1026,7 @@ interface SessionToolDefinition {
   name: string;
   tool: AITool;
 }
+/** 模型补全请求的完整选项 */
 interface CompleteOptions {
   model?: string;
   messages: any[];
@@ -160,6 +1034,7 @@ interface CompleteOptions {
   max_tokens?: number;
   stream?: boolean;
   tools?: any[];
+  /** 会话内可执行的工具（自动进入工具循环） */
   executableTools?: SessionToolDefinition[];
   executableToolsProvider?: () => SessionToolDefinition[];
   maxIterations?: number;
@@ -182,8 +1057,16 @@ interface CompleteResponse {
   allToolCalls?: ToolCallRecord[];
 }
 type AIProtocol = "openai-chat" | "openai-response" | "anthropic" | "gemini";
+/** 模型能力标记：文本 / 视觉 / 工具调用 / 推理 */
 type AIModelCapability = "text" | "vision" | "tool-use" | "reasoning";
+/** 思考等级，部分推理模型支持从 off 到 max 逐级调节 */
+type AIThinkingLevel = "off" | "low" | "medium" | "high" | "xhigh" | "max";
+declare const AI_THINKING_LEVELS: AIThinkingLevel[];
+declare const AI_GEMINI_THINKING_LEVELS: AIThinkingLevel[];
+declare function normalizeAIThinkingLevel(value: unknown, protocol?: AIProtocol): AIThinkingLevel | undefined;
+/** 模型角色：主对话 / 干活 / 看图 */
 type AIModelRole = "main" | "working" | "vision";
+/** 一个模型提供商的连接配置 */
 interface AIProviderConfig {
   id: string;
   name: string;
@@ -193,6 +1076,7 @@ interface AIProviderConfig {
   enabled: boolean;
   headers?: Record<string, string>;
 }
+/** 模型描述：归属于某个提供商，带能力与上下文窗口信息 */
 interface AIModelDescriptor {
   id: string;
   providerId: string;
@@ -202,6 +1086,7 @@ interface AIModelDescriptor {
   contextWindow?: number;
   maxOutputTokens?: number;
   isCustom?: boolean;
+  thinkingLevel?: AIThinkingLevel;
 }
 interface AIInstanceInfo {
   name: string;
@@ -209,6 +1094,7 @@ interface AIInstanceInfo {
   modelId: string;
   role?: AIModelRole;
 }
+/** AI 实例：一个绑定到具体提供商与模型的调用句柄 */
 interface AIInstance {
   generateText(options: {
     prompt?: string;
@@ -239,6 +1125,7 @@ interface AIInstance {
   getAllPrompts(): Record<string, string>;
   removePrompt(name: string): boolean;
 }
+/** AI 服务：实例 / 提供商 / 模型 / 技能的统一管理入口 */
 interface AIService {
   create(options: {
     name: string;
@@ -280,6 +1167,8 @@ interface AIService {
     capabilities?: AIModelCapability[];
   }): AIModelDescriptor;
   removeCustomModel?(modelFullId: string): boolean;
+  removeModel?(modelFullId: string): boolean;
+  setModelThinkingLevel?(modelFullId: string, level: AIThinkingLevel | undefined): boolean;
   getRoleBindings?(): Record<AIModelRole, string | undefined>;
   setRoleBinding?(role: AIModelRole, modelFullId: string | undefined): boolean;
   getInstanceByRole?(role: AIModelRole): AIInstance | undefined;
@@ -301,11 +1190,13 @@ interface AIService {
   cleanupUsageStats?(retentionMs?: number): number;
   finalizeUsage?(usageId: string, finalization: AIUsageFinalization): boolean;
 }
+/** 聊天运行时：让插件复用 chat 插件的"发通知 / 收集信息"能力 */
 interface ChatRuntime {
   generateNotice(options: ChatRuntimeNoticeOptions): Promise<ChatRuntimeResult>;
   requestInformation(options: ChatRuntimeInformationRequestOptions): Promise<ChatRuntimeResult>;
 }
 declare const TOOL_RESULT_FOLLOWUP_KEY = "__miokuFollowup";
+/** 工具结果附带的内容：文本与图片/视频引用 */
 interface ToolResultFollowup {
   text: string;
   images?: Array<{
@@ -340,6 +1231,7 @@ type ChatRuntimeBaseOptions = ChatRuntimeSource & {
 type ChatRuntimeNoticeOptions = ChatRuntimeBaseOptions & {
   instruction: string;
 };
+/** 让 AI 按给定 JSON Schema 收集并返回结构化信息 */
 type ChatRuntimeInformationRequestOptions = ChatRuntimeBaseOptions & {
   task: string;
   schema: {
@@ -484,123 +1376,948 @@ interface AIUsageSummary {
 }
 //# sourceMappingURL=types.d.ts.map
 //#endregion
-//#region src/core/plugin-manager.d.ts
-declare class PluginManager {
-  private plugins;
-  static getInstance(): PluginManager;
-  discoverPlugins(miokuConfig?: MiokuRuntimeConfig): Promise<PluginMetadata[]>;
-  private loadPluginMetadata;
-  collectRequiredServices(): Set<string>;
-  getPluginMetadata(name: string): PluginMetadata | undefined;
-  getAllMetadata(): PluginMetadata[];
-  reset(): void;
-}
-declare const _default: PluginManager;
-//#endregion
-//#region src/core/service-manager.d.ts
+//#region src/services/manager.d.ts
+/** 服务管理器：扫描、加载本地与 npm 服务，并把服务 API 暴露到注册表 */
 declare class ServiceManager {
-  private services;
   private serviceMetadata;
+  private loaded;
   static getInstance(): ServiceManager;
+  /** 扫描本地 services/ 目录与 node_modules 下的 mioku-service-* 包，返回全部服务元数据 */
   discoverServices(miokuConfig?: MiokuRuntimeConfig): Promise<ServiceMetadata[]>;
   private loadServiceMetadata;
-  checkMissingServices(required: Set<string>): Promise<string[]>;
-  loadAllServices(ctx: MiokiContext$1): Promise<void>;
+  getMetadata(name: string): ServiceMetadata | undefined;
+  getAllMetadata(): ServiceMetadata[];
+  /** 依次加载所有已发现的服务，成功的会注册进服务注册表 */
+  loadAllServices(ctx?: MiokuContext): Promise<void>;
   private loadService;
-  registerBuiltinService(name: string, service: MiokuService): void;
-  getService(name: string): MiokuService | undefined;
+  /** 按加载的相反顺序卸载全部服务，并从注册表移除 */
   disposeAll(): Promise<void>;
-  reset(): void;
+  reset(): Promise<void>;
 }
-declare const _default$1: ServiceManager;
-//#endregion
-//#region src/core/plugin-artifact-registry.d.ts
-declare function registerPluginArtifacts(ctx: MiokiContext$1): Promise<void>;
-//# sourceMappingURL=plugin-artifact-registry.d.ts.map
+declare const _default: ServiceManager;
 //#endregion
-//#region src/core/service-config.d.ts
+//#region src/services/config.d.ts
+/** 注册服务配置：文件不存在时把 defaults 写入磁盘 */
 declare function registerServiceConfig(serviceName: string, configName: string, defaults: Record<string, unknown>): Promise<void>;
+/** 读取服务配置，文件不存在或解析失败时返回空对象 */
 declare function getServiceConfig(serviceName: string, configName: string): Promise<Record<string, unknown>>;
+/** 覆盖写入服务配置 */
 declare function updateServiceConfig(serviceName: string, configName: string, value: Record<string, unknown>): Promise<void>;
+/** 读取服务的全部配置文件，按配置名索引 */
 declare function getServiceConfigs(serviceName: string): Promise<Record<string, Record<string, unknown>>>;
+/** 删除服务配置，文件不存在时返回 false */
 declare function deleteServiceConfig(serviceName: string, configName: string): Promise<boolean>;
-//# sourceMappingURL=service-config.d.ts.map
+//# sourceMappingURL=config.d.ts.map
 //#endregion
-//#region src/core/service.d.ts
+//#region src/services/define.d.ts
+/** 服务引用的类型安全句柄，泛型参数对应该服务的实际类型 */
 interface ServiceRef<T> {
   readonly id: string;
 }
+/** 声明一个服务引用，只记录 id，不查询注册表 */
 declare function defineService<T>(id: string): ServiceRef<T>;
-declare function getService<T>(ctx: MiokiContext$1, ref: ServiceRef<T>): T | undefined;
-declare function requireService<T>(ctx: MiokiContext$1, ref: ServiceRef<T>): T;
-declare function hasService<T>(ctx: MiokiContext$1, ref: ServiceRef<T>): boolean;
-//# sourceMappingURL=service.d.ts.map
+/** 从上下文取服务，未注册时返回 undefined */
+declare function getService<T>(ctx: MiokuContext, ref: ServiceRef<T>): T | undefined;
+/** 从上下文取服务，未注册时抛错 */
+declare function requireService<T>(ctx: MiokuContext, ref: ServiceRef<T>): T;
+/** 判断服务是否已注册 */
+declare function hasService<T>(ctx: MiokuContext, ref: ServiceRef<T>): boolean;
+//# sourceMappingURL=define.d.ts.map
 //#endregion
-//#region src/core/services.d.ts
+//#region src/services/builtin.d.ts
+/** 框架内置服务的引用集合 */
 declare const Services: {
   readonly AI: ServiceRef<AIService>;
   readonly Config: ServiceRef<ConfigService>;
   readonly Screenshot: ServiceRef<ScreenshotService>;
   readonly Help: ServiceRef<HelpService>;
 };
+/** 全部内置服务引用的联合类型 */
 type BuiltinServiceRef = typeof Services.AI | typeof Services.Config | typeof Services.Screenshot | typeof Services.Help;
-//# sourceMappingURL=services.d.ts.map
+//# sourceMappingURL=builtin.d.ts.map
+//#endregion
+//#region src/actions.d.ts
+/** 群发通知的选项 */
+interface NoticeOptions {
+  /** 相邻两个目标之间的发送间隔（毫秒），默认 1000 */
+  readonly delay?: number;
+  /** 统一覆盖发送目标，默认按名单逐个生成 */
+  readonly target?: MessageTarget;
+}
+/** 通过指定 bot 发送一条消息 */
+declare const sendMessage: (bot: Bot, target: MessageTarget, message: MessageInput) => Promise<unknown>;
+/** 向多个群发送同一条消息 */
+declare const noticeGroups: (bots: readonly Bot[], groupIds: readonly (string | number)[], message: MessageInput, options?: NoticeOptions) => Promise<void>;
+/** 向多个好友私聊发送同一条消息 */
+declare const noticeFriends: (bots: readonly Bot[], userIds: readonly (string | number)[], message: MessageInput, options?: NoticeOptions) => Promise<void>;
+/** 通知所有 owner，可通过 options.target 统一改发到别的目标 */
+declare const noticeOwners: (bots: readonly Bot[], owners: readonly string[], message: MessageInput, options?: NoticeOptions) => Promise<void>;
+/** 通知所有管理员，行为与 noticeOwners 一致 */
+declare const noticeAdmins: (bots: readonly Bot[], admins: readonly string[], message: MessageInput, options?: NoticeOptions) => Promise<void>;
+//# sourceMappingURL=actions.d.ts.map
+//#endregion
+//#region src/utils.d.ts
+declare const ChromeUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/131.0.0.0";
+type Noop = () => void;
+type AnyFunc = (...args: any[]) => any;
+type PureObject<T = unknown> = Record<PropertyKey, T>;
+type Arrayable<T> = T | T[];
+type Awaitable<T> = T | Promise<T>;
+type Gettable<T> = T | (() => T);
+interface HasMessage {
+  readonly message: Message;
+}
+interface CreateCmdOptions {
+  prefix?: string;
+  onPrefix?(): void;
+}
+/** 解析命令行字符串：返回命令、位置参数与 `--xxx` 选项 */
+declare const createCmd: (cmdStr: string, options?: CreateCmdOptions) => {
+  cmd: string | undefined;
+  params: string[];
+  options: Record<string, unknown>;
+};
+/** 在指定路径创建并读取一个 lowdb JSON 数据库 */
+declare const createDB: <T extends object = object>(filename: string, options?: {
+  defaultData?: T;
+  compress?: boolean;
+}) => Promise<Low<T>>;
+/** 在插件目录下创建并读取一个 JSON 数据存储（默认 `data.json`） */
+declare const createStore: <T extends object = object>(defaultData: T, options?: {
+  __dirname?: string;
+  importMeta?: ImportMeta;
+  compress?: boolean;
+  filename?: string;
+}) => Promise<Low<T>>;
+declare const md5: (text: BinaryLike, encoding?: BinaryToTextEncoding | "buffer") => string | Buffer;
+declare const unique: <T>(array: T[]) => T[];
+declare const toArray: <T>(value: T | T[]) => T[];
+declare const wait: (ms: number) => Promise<void>;
+declare const localeDate: (ts?: number | string | Date, options?: {
+  locale?: string;
+  timeZone?: string;
+}) => string;
+declare const localeTime: (ts?: number | string | Date, options?: {
+  locale?: string;
+  timeZone?: string;
+  seconds?: boolean;
+}) => string;
+declare const randomInt: (min: number, max: number, ...hashArgs: unknown[]) => number;
+declare const randomItem: <T>(array: readonly T[], ...hashArgs: unknown[]) => T;
+declare const randomItems: <T>(array: readonly T[], count: number, ...hashArgs: unknown[]) => T[];
+declare const randomId: () => string;
+declare const uuid: () => string;
+declare const clamp: (n: number, min: number, max: number) => number;
+declare const noNullish: <T>(val: T | null | undefined) => val is T;
+declare const isDefined: <T = unknown>(val?: T) => val is T;
+declare const isFunction: <T extends AnyFunc = AnyFunc>(val: unknown) => val is T;
+declare const isNumber: (val: unknown) => val is number;
+declare const isBoolean: (val: unknown) => val is boolean;
+declare const isString: (val: unknown) => val is string;
+declare const isObject: (val: unknown) => val is Record<string, unknown>;
+declare const localNum: (num: number, locale?: string) => string;
+declare const base64Encode: (str: string | number | Buffer) => string;
+declare const base64Decode: (str: string, type?: "buffer" | BufferEncoding) => string | Buffer;
+declare const qs: (obj: Record<number | string, unknown>) => string;
+declare const stringifyError: (error: unknown) => string;
+declare const formatDuration: (ms: number) => string;
+declare const getTerminalInput: (inputTip?: string) => Promise<string>;
+declare const getGTk: (pskey: string) => number;
+type MatchHandler<T extends HasMessage> = (matches: RegExpMatchArray, event: T) => unknown | Promise<unknown>;
+type MatchValue = string | number | boolean | Message | MessageSegment | readonly (string | MessageSegment)[];
+/**
+ * 关键词匹配路由：pattern 的键支持正则（`/.../`）、通配符（`*`）与纯文本，
+ * 命中后执行对应的处理函数或直接回复静态内容。
+ */
+declare const match: <T extends HasMessage>(event: T, pattern: Record<string, MatchHandler<T> | MatchValue>, quote?: boolean) => Promise<{
+  message_id: string;
+} | null>;
+declare const text: (source: HasMessage | Message, options?: {
+  trim?: boolean | "whole" | "each";
+}) => string;
+declare const find: <T extends (Message["length"] extends 0 ? never : Message[number])>(source: HasMessage | Message, type: string) => T | undefined;
+declare const filter: <T extends (Message["length"] extends 0 ? never : Message[number])>(source: HasMessage | Message, type: string) => T[];
+//#endregion
+//#region src/config.d.ts
+/** package.json 中 mioku 字段的结构 */
+interface MiokuConfig {
+  /** 指令前缀，缺省为 "." */
+  prefix?: string;
+  owners: string[];
+  admins: string[];
+  plugins: string[];
+  plugins_dir?: string;
+  log_level?: LogLevel;
+  /** 启动完成后是否私聊通知第一位 owner */
+  online_push?: boolean;
+  /** 出错时是否推送给 owner */
+  error_push?: boolean;
+  /** 谁可以查询运行状态：所有人或仅管理员 */
+  status_permission?: 'all' | 'admin-only';
+  adapters?: Record<string, unknown>;
+  napcat?: unknown;
+}
+/** package.json 的宽松形状，只约定 mioku 字段 */
+interface BotConfigJson {
+  mioku?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+/** 当前机器人根目录，包一层对象以便整体重定向 */
+declare const BOT_CWD: {
+  value: string;
+};
+/** 重设机器人根目录，之后 package.json 的读写都基于它 */
+declare const setBotCwd: (root: string) => void;
+/** 读取机器人根目录的 package.json */
+declare const readPackageJson: () => BotConfigJson;
+/** 写回机器人根目录的 package.json */
+declare const writePackageJson: (pkg: BotConfigJson) => void;
+/** 把 owners 配置规整为字符串数组，非数组时返回空 */
+declare const normalizeOwners: (input: unknown) => string[];
+/** 同 normalizeOwners，规整管理员名单 */
+declare const normalizeAdmins: (input: unknown) => string[];
+/** 同 normalizeOwners，规整插件列表 */
+declare const normalizePlugins: (input: unknown) => string[];
+/** 从 package.json 读取 mioku 配置并补全默认值 */
+declare const readMiokuConfig: () => MiokuConfig;
+/** 运行时使用的配置，字段与 MiokuConfig 相同 */
+interface RuntimeMiokuConfig extends MiokuConfig {}
+/** 全局运行时配置，模块加载时初始化 */
+declare let botConfig: RuntimeMiokuConfig;
+/** 重新读取 package.json 并替换全局配置 */
+declare const reloadMiokuConfig: () => RuntimeMiokuConfig;
+/** 控制是否允许把配置改动写回 package.json */
+declare const setWritableConfig: (value: boolean) => void;
+/** 在 draft 里直接修改配置；writable 开启时改动会落盘到 package.json */
+declare const updateMiokuConfig: (draft: (config: RuntimeMiokuConfig) => void | Promise<void>) => Promise<void>;
+/** 判断是否为 owner */
+declare const isOwner: (id: string) => boolean;
+/** 判断是否为管理员 */
+declare const isAdmin: (id: string) => boolean;
+/** 判断是否为 owner 或管理员 */
+declare const isOwnerOrAdmin: (id: string) => boolean;
+/** isOwnerOrAdmin 的别名 */
+declare const hasRight: (id: string) => boolean;
+//# sourceMappingURL=config.d.ts.map
+//#endregion
+//#region src/runtime/bus.d.ts
+type EventHandler<E extends Event = Event> = (event: E) => void | Promise<void>;
+interface Registration {
+  readonly id: number;
+  readonly route: string;
+  readonly source: string;
+  readonly handler: EventHandler<Event>;
+  readonly priority: number;
+  readonly order: number;
+  disposed: boolean;
+}
+interface BusStats {
+  readonly registered: number;
+  readonly dispatched: number;
+}
+/**
+ * 事件总线：按路由把事件分发给所有匹配的监听器。
+ * 支持 `*` 通配符，同一优先级按注册顺序执行，不同优先级按数值升序。
+ */
+declare class EventBus {
+  #private;
+  setLogger(logger: ((level: 'error' | 'warn' | 'info', message: string, detail?: unknown) => void) | null): void;
+  /** 注册事件监听，返回取消注册函数 */
+  register<E extends Event = Event>(route: string, handler: EventHandler<E>, options?: {
+    source?: string;
+    priority?: number;
+  }): () => void;
+  clear(): void;
+  /** 派发一个事件给所有匹配的监听器，单个监听器出错不影响其他监听器 */
+  dispatch(event: Event): Promise<void>;
+  stats(): BusStats;
+}
+//# sourceMappingURL=bus.d.ts.map
+//#endregion
+//#region src/runtime/bots.d.ts
+/** Bot 注册表：登记已连接的 bot，按 bot_id 查询 */
+declare class BotRegistry {
+  #private;
+  /** 登记一个 bot，返回可注销的上下文 */
+  register(bot: Bot): BotContext;
+  has(key: string): boolean;
+  unregister(bot_id: string, adapter: string): boolean;
+  /** 按 bot_id 取 bot（只按 id 匹配，不限适配器） */
+  pick<T extends Bot = Bot>(bot_id: string | number): T | undefined;
+  all<T extends Bot = Bot>(): readonly T[];
+  size(): number;
+  clear(): void;
+}
+//# sourceMappingURL=bots.d.ts.map
+
+//#endregion
+//#region src/runtime/mioku-context.d.ts
+/** 插件管理器：插件列表查询与运行时启停 */
+interface PluginManager {
+  list(): Array<{
+    name: string;
+    type: 'builtin' | 'external';
+    version?: string;
+  }>;
+  localPlugins(): string[];
+  enable(name: string): Promise<void>;
+  disable(name: string): Promise<void>;
+  reload(name: string): Promise<void>;
+}
+interface ContextOptions {
+  readonly pluginName: string;
+  readonly bus: EventBus;
+  readonly bots: BotRegistry;
+  readonly driver: Driver;
+  readonly capabilities: CapabilityRegistry;
+  readonly config: MiokuConfig;
+  readonly logger: Logger;
+  readonly priority: number;
+  readonly getAdapter: <T extends Adapter = Adapter>(name: string) => T | undefined;
+  readonly listAdapters: () => readonly Adapter[];
+  readonly onUpdateConfig: (updater: (config: MiokuConfig) => void | Promise<void>) => Promise<void>;
+  readonly pluginManager: PluginManager;
+}
+/** 从事件对象中提取发送者 id（支持裸 id / user_id / sender.user_id） */
+declare const toUserId: (value: unknown) => string | undefined;
+declare const isEventOwner: (event: unknown) => boolean;
+declare const isEventAdmin: (event: unknown) => boolean;
+declare const isEventOwnerOrAdmin: (event: unknown) => boolean;
+declare const hasEventRight: (event: unknown) => boolean;
+type SemanticRoute<R extends string> = R extends `${string}:${infer Rest}` ? Rest : R;
+type EventKindOfSemanticRoute<R extends string> = R extends `message${string}` ? MessageEvent : R extends `notice${string}` ? NoticeEvent : R extends `request${string}` ? RequestEvent : R extends `meta_event${string}` ? MetaEvent : Event;
+type EventKindOfRoute<R extends string> = EventKindOfSemanticRoute<SemanticRoute<R>>;
+type AdapterBotOf<Name extends string> = Name extends keyof AdapterBotMap ? AdapterBotMap[Name] extends Bot ? AdapterBotMap[Name] : Bot : Bot;
+type BotOfRoute<R extends string> = R extends `${infer Adapter}:${string}` ? AdapterBotOf<Adapter> : Bot;
+type BindRouteBot<E, B extends Bot> = E extends {
+  bot: Bot;
+  self_id: string;
+} ? Omit<E, 'bot' | 'self_id'> & {
+  bot: B;
+  self_id: B['bot_id'];
+} : E;
+type RouteEventOf<R extends string> = BindRouteBot<EventKindOfRoute<R>, BotOfRoute<R>>;
+type RouteEvent<R extends string | readonly string[]> = R extends readonly string[] ? RouteEventOf<R[number]> : RouteEventOf<Extract<R, string>>;
+declare const CTX_UTILS: {
+  readonly localeDate: (ts?: number | string | Date, options?: {
+    locale?: string;
+    timeZone?: string;
+  }) => string;
+  readonly localeTime: (ts?: number | string | Date, options?: {
+    locale?: string;
+    timeZone?: string;
+    seconds?: boolean;
+  }) => string;
+  readonly randomInt: (min: number, max: number, ...hashArgs: unknown[]) => number;
+  readonly randomItem: <T>(array: readonly T[], ...hashArgs: unknown[]) => T;
+  readonly randomItems: <T>(array: readonly T[], count: number, ...hashArgs: unknown[]) => T[];
+  readonly randomId: () => string;
+  readonly uuid: () => string;
+  readonly wait: (ms: number) => Promise<void>;
+  readonly toArray: <T>(value: T | T[]) => T[];
+  readonly unique: <T>(array: T[]) => T[];
+  readonly clamp: (n: number, min: number, max: number) => number;
+  readonly noNullish: <T>(val: T | null | undefined) => val is T;
+  readonly isDefined: <T = unknown>(val?: T) => val is T;
+  readonly isFunction: <T extends AnyFunc = AnyFunc>(val: unknown) => val is T;
+  readonly isNumber: (val: unknown) => val is number;
+  readonly isBoolean: (val: unknown) => val is boolean;
+  readonly isString: (val: unknown) => val is string;
+  readonly isObject: (val: unknown) => val is Record<string, unknown>;
+  readonly localNum: (num: number, locale?: string) => string;
+  readonly formatDuration: (ms: number) => string;
+  readonly md5: (text: crypto0.BinaryLike, encoding?: crypto0.BinaryToTextEncoding | "buffer") => string | Buffer;
+  readonly base64Encode: (str: string | number | Buffer) => string;
+  readonly base64Decode: (str: string, type?: "buffer" | BufferEncoding) => string | Buffer;
+  readonly qs: (obj: Record<number | string, unknown>) => string;
+  readonly stringifyError: (error: unknown) => string;
+  readonly getTerminalInput: (inputTip?: string) => Promise<string>;
+  readonly find: <T extends (Message["length"] extends 0 ? never : Message[number])>(source: HasMessage | Message, type: string) => T | undefined;
+  readonly filter: <T extends (Message["length"] extends 0 ? never : Message[number])>(source: HasMessage | Message, type: string) => T[];
+  readonly prettyMs: typeof prettyMs;
+  readonly filesize: typeof filesize;
+  readonly dayjs: typeof dayjs;
+  readonly path: path.PlatformPath;
+  readonly fs: typeof fs;
+  readonly colors: Record<"reset" | "bold" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright", consola_utils0.ColorFunction>;
+};
+type CtxUtils = typeof CTX_UTILS;
+/**
+ * 插件上下文：插件 `setup(ctx)` 收到的对象。
+ * 事件监听、定时任务、配置、日志、Bot 操作与工具函数都挂在上面，
+ * 同时混入了 `utils` 中的常用工具（dayjs、fs、path、randomInt 等）。
+ */
+declare class MiokuContext {
+  #private;
+  constructor(options: ContextOptions);
+  get pluginName(): string;
+  /** 第一个已连接的 bot（多数单 bot 场景直接用这个） */
+  get bot(): Bot | undefined;
+  /** 所有已连接的 bot */
+  get bots(): readonly Bot[];
+  get self_id(): string | undefined;
+  /** 按 bot_id 取指定 bot */
+  pickBot<T extends Bot = Bot>(bot_id: string | number): T | undefined;
+  /**
+   * 获取事件引用回复的消息内容。
+   * 返回 null 表示没有引用、拿不到对应 bot 或消息已失效。
+   */
+  getQuoteMsg(event: {
+    quote_id?: string | null;
+    bot?: Bot;
+    self_id?: string;
+  }): Promise<MessageGetResult | null>;
+  /** 按名称取适配器实例 */
+  getAdapter<T extends Adapter = Adapter>(name: string): T | undefined;
+  /** 所有已加载的适配器实例（含当前没有 bot 连接的） */
+  get adapters(): readonly Adapter[];
+  /**
+   * 注册事件监听。route 支持层级路由，如 `message`、`message.group`、
+   * `onebotv11:message`；返回取消监听函数。
+   */
+  handle<R extends string | readonly string[]>(route: R, handler: (event: RouteEvent<R>) => void | Promise<void>): () => void;
+  /** 注册 cron 定时任务，插件卸载时自动停止 */
+  cron(expression: string, handler: CronHandler): ScheduledTask;
+  /** 监听 bot 连接 / 断开 */
+  onBot<K extends 'connected' | 'disconnected'>(type: K, handler: (event: K extends 'connected' ? {
+    bot: Bot;
+  } : BotLifecycleEvent) => void | Promise<void>): () => void;
+  getDriver(): Driver;
+  /** 当前框架配置（只读） */
+  get config(): Readonly<MiokuConfig>;
+  /** 修改框架配置（owners、admins、plugins 等） */
+  updateConfig(updater: (config: MiokuConfig) => void | Promise<void>): Promise<void>;
+  get logger(): Logger;
+  get plugins(): PluginManager;
+  get services(): MiokuServices;
+  /** 注册一个运行时服务供其他插件取用，返回注销函数 */
+  addService<T = unknown>(name: string, value: T, cover?: boolean): () => void;
+  get capabilities(): CapabilityRegistry;
+  get buses(): EventBus;
+  get segment(): typeof segment;
+  /** 按模式匹配消息文本（支持正则/字符串/关键词数组） */
+  match<T extends HasMessage>(event: T, pattern: Parameters<typeof match>[1], quote?: boolean): ReturnType<typeof match>;
+  /** 解析命令行字符串为 命令 + 参数 + 选项 */
+  createCmd(cmdStr: string, options?: CreateCmdOptions): ReturnType<typeof createCmd>;
+  /** 在插件目录下创建一个 JSON 数据存储 */
+  createStore<T extends object = object>(defaultData: T, options?: {
+    __dirname?: string;
+    importMeta?: ImportMeta;
+    compress?: boolean;
+    filename?: string;
+  }): ReturnType<typeof createStore<T>>;
+  /** 在指定路径创建一个 lowdb 数据库文件 */
+  createDB<T extends object = object>(filename: string, options?: {
+    defaultData?: T;
+    compress?: boolean;
+  }): ReturnType<typeof createDB<T>>;
+  /** 提取事件消息的纯文本 */
+  text(source: HasMessage | Message, options?: {
+    trim?: boolean | 'whole' | 'each';
+  }): string;
+  /** 向多个群发送消息 */
+  noticeGroups(groupIds: readonly string[], message: MessageInput, options?: NoticeOptions): Promise<void>;
+  /** 向多个好友发送消息 */
+  noticeFriends(userIds: readonly string[], message: MessageInput, options?: NoticeOptions): Promise<void>;
+  /** 向所有主人发送消息 */
+  noticeOwners(message: MessageInput, options?: NoticeOptions): Promise<void>;
+  /** 向所有管理员发送消息 */
+  noticeAdmins(message: MessageInput, options?: NoticeOptions): Promise<void>;
+  isGroupMsg(event: unknown): boolean;
+  isPrivateMsg(event: unknown): boolean;
+  /** 事件发送者是否为主人 */
+  isOwner(event: unknown): boolean;
+  /** 事件发送者是否为管理员 */
+  isAdmin(event: unknown): boolean;
+  isOwnerOrAdmin(event: unknown): boolean;
+  hasRight(event: unknown): boolean;
+  dispose(): Promise<void>;
+}
+interface MiokuContext extends CtxUtils {}
+//#endregion
+//#region src/plugin/plugin.d.ts
+/** 插件卸载时执行的清理函数 */
+type PluginCleanup = () => void | Promise<void>;
+/** bot 上线 / 下线时的回调 */
+type BotHandler = (event: BotLifecycleEvent) => void | Promise<void>;
+/** 定时任务回调 */
+type CronHandler = (ctx: MiokuContext, task: TaskContext) => void | Promise<void>;
+/** 定时任务实例，来自 node-cron */
+type ScheduledTask = node_cron0.ScheduledTask;
+/** 插件定义 */
+interface MiokuPlugin {
+  name: string;
+  version?: string;
+  /** 加载顺序，数值越小越先加载 */
+  priority?: number;
+  description?: string;
+  /** 依赖的其他插件名 */
+  dependencies?: string[];
+  /** 插件入口，可返回清理函数供卸载时调用 */
+  setup?(ctx: MiokuContext): void | Promise<void | PluginCleanup> | PluginCleanup;
+}
+/** 定义一个插件，仅提供类型约束 */
+declare const definePlugin: <T extends MiokuPlugin>(plugin: T) => T;
+//# sourceMappingURL=plugin.d.ts.map
+//#endregion
+//#region src/runtime/context.d.ts
+declare class AdapterRegistrationConflictError extends Error {
+  constructor(key: string);
+}
+interface RuntimeAdapterState {
+  readonly definition: AdapterDefinition<unknown>;
+  instance: Adapter | null;
+  context: AdapterContextImpl | null;
+  gateways: AdapterGateway[] | null;
+  resources: AdapterResource[] | null;
+  started: boolean;
+}
+declare class AdapterContextImpl implements AdapterContext {
+  #private;
+  constructor(options: {
+    state: RuntimeAdapterState;
+    bots: BotRegistry;
+    bus: EventBus;
+    driver: Driver;
+    capabilities: CapabilityRegistry;
+    logger: Logger;
+    emit: (event: BotLifecycleEvent) => Promise<void>;
+  });
+  registerBot(bot: Bot): BotContext;
+  unregisterBot(bot_id: string): void;
+  getDriver(): Driver;
+  registerCapability<I, O>(capability: Capability<I, O>, target: CapabilityTarget, handler: (input: I) => Promise<O>): () => void;
+  getCapabilityRegistry(): CapabilityRegistry;
+  registerGateway(gateway: AdapterGateway): () => void;
+  waitForStarts(): Promise<void>;
+  registerResource(resource: AdapterResource): () => void;
+  dispatch(event: Event): Promise<void>;
+  listen(route: string, handler: (event: Event) => void | Promise<void>): () => void;
+  emitLifecycle(event: BotLifecycleEvent): Promise<void>;
+  get adapterName(): string;
+}
+//# sourceMappingURL=context.d.ts.map
+//#endregion
+//#region src/runtime/lifecycle.d.ts
+/** 框架生命周期事件表：bot 连接、适配器启停、运行时就绪/关闭 */
+interface LifecycleEventMap {
+  'bot:connected': {
+    bot: Bot;
+  };
+  'bot:disconnected': {
+    bot: Bot;
+    reason?: string;
+  };
+  'adapter:registered': {
+    name: string;
+  };
+  'adapter:started': {
+    name: string;
+  };
+  'adapter:stopped': {
+    name: string;
+    reason?: string;
+  };
+  'runtime:ready': void;
+  'runtime:shutdown': {
+    reason?: string;
+  };
+}
+type LifecycleEvent = { [K in keyof LifecycleEventMap]: LifecycleEventMap[K] extends void ? {
+  type: K;
+} : {
+  type: K;
+  payload: LifecycleEventMap[K];
+} }[keyof LifecycleEventMap];
+type LifecycleHandler<K extends keyof LifecycleEventMap> = (payload: LifecycleEventMap[K]) => void | Promise<void>;
+interface LifecycleListener {
+  off(): void;
+}
+//# sourceMappingURL=lifecycle.d.ts.map
+//#endregion
+//#region src/runtime/runtime.d.ts
+interface CreateRuntimeOptions {
+  readonly cwd: string;
+  readonly logger: Logger;
+  readonly builtinPlugins?: readonly MiokuPlugin[];
+  readonly driverFactory?: () => Driver;
+}
+interface AdapterStartResult {
+  readonly name: string;
+  readonly adapter: Adapter;
+}
+declare const setBuiltinPlugins: (plugins: readonly MiokuPlugin[]) => void;
+declare const getBuiltinPlugins: () => readonly MiokuPlugin[];
+declare class MiokuRuntime {
+  #private;
+  constructor(options: CreateRuntimeOptions);
+  get cwd(): string;
+  get logger(): Logger;
+  get driver(): Driver;
+  get bus(): EventBus;
+  get bots(): readonly Bot[];
+  get adapters(): readonly Adapter[];
+  getAdapter<T extends Adapter = Adapter>(name: string): T | undefined;
+  pickBot<T extends Bot = Bot>(bot_id: string | number): T | undefined;
+  listPlugins(): Array<{
+    name: string;
+    type: "builtin" | "external";
+    version?: string;
+  }>;
+  enablePlugin(name: string): Promise<void>;
+  disablePlugin(name: string): Promise<void>;
+  reloadPlugin(name: string): Promise<void>;
+  start(): Promise<void>;
+  shutdown(reason?: string): Promise<void>;
+}
+declare const createRuntime: (options: CreateRuntimeOptions) => MiokuRuntime;
+//#endregion
+//#region src/runtime/types.d.ts
+/**
+ * 适配器上报的实例计数：只报事实，展示文案与排版由 core 决定。
+ * 缺省的字段表示该平台没有这个概念或暂时取不到。
+ */
+interface AdapterStatusStats {
+  /** 好友 / 私聊联系人数 */
+  readonly friends?: number;
+  /** 群 / 频道数 */
+  readonly groups?: number;
+  /** 已发送消息数 */
+  readonly sent?: number;
+  /** 已接收消息数 */
+  readonly received?: number;
+}
+/**
+ * 适配器状态上报。
+ * 带 `bot_id` 表示这是某个具体实例的状态，缺省则视为整个适配器的状态。
+ */
+interface AdapterStatus {
+  readonly adapter: string;
+  readonly bot_id?: string;
+  /** 实现名称，如 NapCat / Lagrange，由平台自报 */
+  readonly impl?: string;
+  /** 实现版本，如 OneBot 实现端的 app_version */
+  readonly version?: string;
+  readonly stats?: AdapterStatusStats;
+  /** 原始数据，仅供插件读取，core 不展示 */
+  readonly data: Readonly<Record<string, unknown>>;
+}
+//# sourceMappingURL=types.d.ts.map
 //#endregion
-//#region src/core/data-paths.d.ts
+//#region src/loader/package.d.ts
+interface PackageJson {
+  readonly name?: string;
+  readonly version?: string;
+  readonly description?: string;
+  readonly main?: string;
+  readonly module?: string;
+  readonly exports?: unknown;
+  readonly dependencies?: Readonly<Record<string, string>>;
+  readonly devDependencies?: Readonly<Record<string, string>>;
+  readonly optionalDependencies?: Readonly<Record<string, string>>;
+  readonly peerDependencies?: Readonly<Record<string, string>>;
+  readonly keywords?: readonly string[];
+  readonly mioku?: unknown;
+}
+interface PackageCandidate {
+  readonly name: string;
+  readonly resolvedPath: string;
+  readonly packageJson: PackageJson;
+}
+interface AdapterCandidate {
+  readonly name: string;
+  readonly packageName: string;
+  readonly resolvedPath: string;
+  readonly packageJson: PackageJson;
+  readonly apiVersion: number;
+  readonly entry?: string;
+  readonly description?: string;
+}
+interface PluginCandidate {
+  readonly name: string;
+  readonly packageName: string;
+  readonly resolvedPath: string;
+  readonly packageJson: PackageJson;
+  readonly apiVersion: number;
+  readonly priority?: number;
+  readonly entry?: string;
+  readonly description?: string;
+  readonly config: PluginPackageConfig;
+}
+declare const readPackageJsonSafe: (dir: string) => PackageJson | null;
+declare const resolveEntry: (dir: string, pkg: PackageJson, override?: string) => string | null;
+declare const discoverAdapterCandidates: (cwd: string, appPackageJson: PackageJson) => readonly AdapterCandidate[];
+declare const discoverPluginCandidates: (cwd: string, appPackageJson: PackageJson) => readonly PluginCandidate[];
+declare const resolveLocalPluginPath: (cwd: string, pluginsDir: string, name: string) => string | null;
+declare const resolveLocalPluginEntry: (dir: string) => string | null;
+declare const findLocalPlugins: (cwd: string, pluginsDir: string) => readonly {
+  name: string;
+  absPath: string;
+}[];
+interface LoadedAdapterDefinition {
+  readonly candidate: AdapterCandidate;
+  readonly definition: AdapterDefinition<unknown>;
+}
+interface LoadedPluginDefinition {
+  readonly candidate: PluginCandidate | {
+    name: string;
+    resolvedPath: string;
+    entry: string;
+    packageJson: PackageJson;
+  };
+  readonly module: unknown;
+}
+//# sourceMappingURL=package.d.ts.map
+//#endregion
+//#region src/loader/adapter.d.ts
+declare const createImportContext: (cwd: string) => Jiti;
+declare const loadAdapterDefinition: (jiti: Jiti, candidate: AdapterCandidate) => Promise<LoadedAdapterDefinition>;
+//# sourceMappingURL=adapter.d.ts.map
+//#endregion
+//#region src/loader/plugin.d.ts
+declare const isMiokuPlugin: (value: unknown) => value is MiokuPlugin;
+declare const loadNpmPlugin: (jiti: Jiti, candidate: PluginCandidate) => Promise<MiokuPlugin>;
+declare const loadLocalPlugin: (jiti: Jiti, name: string, resolvedPath: string) => Promise<MiokuPlugin>;
+//# sourceMappingURL=plugin.d.ts.map
+//#endregion
+//#region src/start.d.ts
+/** startRuntime 的启动选项 */
+interface StartOptions {
+  cwd?: string;
+  logger?: Logger;
+  builtinPlugins?: readonly MiokuPlugin[];
+}
+/** 启动 mioku 运行时：加载服务、拉起适配器与插件，返回用于优雅停机的 stop */
+declare const startRuntime: (options?: StartOptions) => Promise<{
+  stop: (reason?: string) => Promise<void>;
+}>;
+//# sourceMappingURL=start.d.ts.map
+//#endregion
+//#region src/builtin/core/adapters.d.ts
+interface StatusProviderContext {
+  readonly bot: Bot;
+}
+type StatusProvider = (context: StatusProviderContext) => Promise<AdapterStatus> | AdapterStatus;
+/** 注册目标*/
+type StatusProviderTarget = string | {
+  readonly adapter: string;
+  readonly bot_id?: string;
+};
+/**
+ * 注册适配器状态上报
+ */
+declare const registerStatusProvider: (target: StatusProviderTarget, provider: StatusProvider) => (() => void);
+/** 单个已连接实例 */
+interface AdapterInstanceStatus {
+  readonly bot_id: string;
+  readonly nickname: string;
+  readonly online: boolean;
+  readonly connected_at?: number;
+  readonly impl?: string;
+  readonly version?: string;
+  readonly stats: AdapterStatusStats;
+  readonly data: Readonly<Record<string, unknown>>;
+}
+/** 单个适配器及其实例 */
+interface AdapterReportEntry {
+  readonly name: string;
+  /** 适配器包版本 */
+  readonly version?: string;
+  readonly loaded: boolean;
+  readonly instances: readonly AdapterInstanceStatus[];
+}
+interface AdapterReport {
+  readonly adapters: readonly AdapterReportEntry[];
+  readonly totalInstances: number;
+}
+interface BuildAdapterReportOptions {
+  readonly bots: readonly Bot[];
+  readonly adapters: readonly {
+    readonly name: string;
+    readonly version?: string;
+  }[];
+}
+/** 逐个 bot 查询状态 */
+declare const buildAdapterReport: (options: BuildAdapterReportOptions) => Promise<AdapterReport>;
+declare const collectBotStats: (report: AdapterReport) => Map<string, AdapterStatusStats>;
+declare const formatAdapterReport: (report: AdapterReport) => string;
+//# sourceMappingURL=adapters.d.ts.map
+//#endregion
+//#region src/builtin/core/status.d.ts
+declare const SystemMap: Record<string, string>;
+declare const ArchMap: Record<string, string>;
+interface BotStatus {
+  bot_id: string;
+  nickname: string;
+  online: boolean;
+  adapter: string;
+  friends?: number;
+  groups?: number;
+  send?: number;
+  receive?: number;
+}
+interface MiokuStatus {
+  bots: readonly BotStatus[];
+  plugins: {
+    enabled: number;
+    total: number;
+  };
+  stats: {
+    uptime: number;
+  };
+  versions: {
+    node: string;
+    mioku: string;
+  };
+  system: {
+    name: string;
+    version: string;
+    arch: string;
+  };
+  memory: {
+    used: number;
+    total: number;
+    percent: number;
+    rss: {
+      used: number;
+      percent: number;
+    };
+  };
+  disk: {
+    total: number;
+    used: number;
+    free: number;
+    percent: number;
+  };
+  cpu: {
+    name: string;
+    count: number;
+    percent: number;
+  };
+}
+interface MiokuCoreServiceContrib {
+  getMiokuStatus(): Promise<MiokuStatus>;
+  formatMiokuStatus(status: MiokuStatus): Promise<string>;
+  getAdapterReport(): Promise<AdapterReport>;
+}
+interface BuildStatusOptions {
+  readonly bots: readonly Bot[];
+  /** 各 bot 的计数，由 core 从适配器上报里取好后传入，键为 `adapter:bot_id` */
+  readonly botStats?: ReadonlyMap<string, AdapterStatusStats>;
+  readonly enabledPlugins: number;
+  readonly totalPlugins: number;
+  readonly systemInfoProvider?: () => Promise<{
+    distro: string;
+    release: string;
+  }>;
+}
+declare const buildMiokuStatus: (options: BuildStatusOptions) => Promise<MiokuStatus>;
+declare const formatMiokuStatus: (status: MiokuStatus) => Promise<string>;
+//# sourceMappingURL=status.d.ts.map
+//#endregion
+//#region src/builtin/core/index.d.ts
+declare const CORE_PLUGINS: string[];
+declare const formatMiokuStatusFn: (status: MiokuStatus) => Promise<string>;
+//#endregion
+//#region src/builtin/index.d.ts
+declare const BUILTIN_PLUGINS: readonly MiokuPlugin[];
+//#endregion
+//#region src/compat/connected-bots.d.ts
+/** 当前已连接的全部 bot，按 `adapter:bot_id` 索引 */
+declare const connectedBots: Map<string, Bot>;
+/** 生成 bot 在连接表中的键：`adapter:bot_id` */
+declare const connectedBotKey: (adapter: string, bot_id: string) => string;
+/** 兼容旧版 API 的别名：过去的 NapCat 扩展类型现在就是通用 Bot */
+type ExtendedNapCat = Bot;
+//# sourceMappingURL=connected-bots.d.ts.map
+//#endregion
+//#region src/runtime/plugin-artifacts.d.ts
+declare function registerPluginArtifacts(ctx?: MiokuContext): Promise<void>;
+//# sourceMappingURL=plugin-artifacts.d.ts.map
+//#endregion
+//#region src/runtime/plugin-metadata.d.ts
+declare const setPluginMetadata: (meta: PluginMetadata) => void;
+declare const removePluginMetadata: (name: string) => void;
+declare const getPluginMetadata: (name: string) => PluginMetadata | undefined;
+declare const getPluginMetadataList: () => PluginMetadata[];
+declare const resetPluginMetadata: () => void;
+//# sourceMappingURL=plugin-metadata.d.ts.map
+//#endregion
+//#region src/internal/data-paths.d.ts
+/** 插件数据目录：`data/<pluginName>/` */
 declare function getPluginDataDir(pluginName: string): string;
+/** 服务数据目录：`data/<serviceName>/` */
 declare function getServiceDataDir(serviceName: string): string;
+/** 全局数据目录：`data/` */
 declare function getDataDir(): string;
+/** 插件配置目录：`config/<pluginName>/` */
 declare function getPluginConfigDir(pluginName: string): string;
+/** 服务配置目录：`config/service/<serviceName>/` */
 declare function getServiceConfigDir(serviceName: string): string;
+/** 全局配置目录：`config/` */
 declare function getConfigDir(): string;
+/** 确保插件数据目录存在，返回目录路径 */
 declare function ensureDataDir(pluginName: string): string;
 //# sourceMappingURL=data-paths.d.ts.map
 //#endregion
-//#region src/core/plugin-runtime-state.d.ts
+//#region src/runtime/plugin-state.d.ts
+/** 插件运行时状态引用：跨重载安全的读写句柄 */
 interface PluginStateRef<T> {
   readonly name: string;
   get(): T;
   set(next: T): void;
   reset(): void;
 }
+/** 定义一个具名状态引用，插件重载后仍能读回旧值 */
 declare function defineState<T>(name: string, initial: T): PluginStateRef<T>;
 declare function hasPluginState(name: string): boolean;
+/** 取插件的运行时状态对象，不存在时自动创建空对象 */
 declare function getPluginRuntimeState<T = Record<string, any>>(name: string): T;
+/** 合并写入插件运行时状态 */
 declare function setPluginRuntimeState<T>(name: string, state: T): void;
 declare function resetPluginRuntimeState(name: string): void;
 declare function getAllPluginRuntimeStates(): Record<string, unknown>;
-//# sourceMappingURL=plugin-runtime-state.d.ts.map
+//# sourceMappingURL=plugin-state.d.ts.map
 //#endregion
-//#region src/core/exec.d.ts
+//#region src/internal/exec.d.ts
+/** 在 PATH 及常见安装目录中解析命令的完整路径，结果带缓存 */
 declare function resolveCommand(command: string): string | null;
 interface SpawnPlan {
   file: string;
   args: string[];
   windowsVerbatimArguments?: boolean;
 }
+/** 生成跨平台的 spawn 参数，Windows 下 .cmd/.bat 会改经 cmd.exe 执行 */
 declare function buildSpawnPlan(command: string, args: string[]): SpawnPlan;
 interface RunCommandResult {
   stdout: string;
   stderr: string;
   code: number;
 }
+/** 执行命令并收集 stdout/stderr 与退出码，失败不抛异常 */
 declare function runCommand(command: string, args: string[], options?: {
   cwd?: string;
   env?: NodeJS.ProcessEnv;
 }): Promise<RunCommandResult>;
+/** 同步执行命令并继承当前终端的输入输出，非零退出码时抛错 */
 declare function runCommandInherit(command: string, args: string[], options?: {
   cwd?: string;
 }): void;
+/** 判断命令是否可用 */
 declare function commandExists(command: string): boolean;
 //# sourceMappingURL=exec.d.ts.map
+
 //#endregion
 //#region src/index.d.ts
-declare function definePlugin<T extends mioki0.MiokiPlugin>(plugin: T): T;
 interface MiokuStartOptions {
   cwd?: string;
+  logger?: Logger;
+  builtinPlugins?: readonly MiokuPlugin[];
 }
-declare function start(options?: MiokuStartOptions): Promise<void>;
+declare function start(options?: MiokuStartOptions): Promise<{
+  stop: (reason?: string) => Promise<void>;
+}>;
 declare const version: string;
 //#endregion
-export { type AIInstance, type AIInstanceInfo, type AIModelCapability, type AIModelDescriptor, type AIModelRole, type AIProtocol, type AIProviderConfig, type AIService, type AISkill, type AITool, type AIUsageBotOption, type AIUsageBreakdown, type AIUsageContext, type AIUsageFinalization, type AIUsageRange, type AIUsageScope, type AIUsageSummary, type AccessAction, type AccessControlConfig, type AccessHook, type AccessRuleEntry, type AccessScopeConfig, type BuiltinServiceRef, type ChatRuntime, type ChatRuntimeBaseOptions, type ChatRuntimeCollectedInfo, type ChatRuntimeGroupTarget, type ChatRuntimeInformationRequestOptions, type ChatRuntimeNoticeOptions, type ChatRuntimePrivateTarget, type ChatRuntimePromptInjection, type ChatRuntimeResult, type ChatRuntimeSource, type CommandRole, type CompleteOptions, type CompleteResponse, type ConfigService, type EventMap, type HelpService, type MiokiContext, type MiokiPlugin, type MiokuRuntimeConfig, type MiokuService, MiokuStartOptions, type MultimodalContentItem, type MultimodalMessage, type PackageJsonLike, type PluginHelp, type PluginMetadata, type PluginPackageConfig, type PluginStateRef, type RunCommandResult, type ScreenshotService, type ServiceMetadata, type ServiceRef, Services, type SessionToolDefinition, type SkillPermissionRole, type SpawnPlan, TOOL_RESULT_FOLLOWUP_KEY, type TextMessage, type ToolCallRecord, type ToolResultFollowup, type WebUIService, buildSpawnPlan, commandExists, definePlugin, defineService, defineState, deleteServiceConfig, ensureDataDir, getAllPluginRuntimeStates, getConfigDir, getDataDir, getPluginConfigDir, getPluginDataDir, getPluginRuntimeState, getService, getServiceConfig, getServiceConfigDir, getServiceConfigs, getServiceDataDir, hasPluginState, hasService, normalizeSkillPermissionRole, _default as pluginManager, registerPluginArtifacts, registerServiceConfig, requireService, resetPluginRuntimeState, resolveCommand, runCommand, runCommandInherit, _default$1 as serviceManager, setPluginRuntimeState, start, updateServiceConfig, version };
+export { type AIInstance, type AIInstanceInfo, type AIModelCapability, type AIModelDescriptor, type AIModelRole, type AIProtocol, type AIProviderConfig, type AIService, type AISkill, type AIThinkingLevel, type AITool, type AIUsageBotOption, type AIUsageBreakdown, type AIUsageContext, type AIUsageFinalization, type AIUsageRange, type AIUsageScope, type AIUsageSummary, AI_GEMINI_THINKING_LEVELS, AI_THINKING_LEVELS, type AccessAction, type AccessControlConfig, type AccessHook, type AccessRuleEntry, type AccessScopeConfig, Adapter, AdapterBotBase, AdapterBotMap, AdapterCandidate, AdapterContext, AdapterContextImpl, AdapterDefinition, AdapterEvent, AdapterFactoryOptions, AdapterGateway, AdapterInstanceStatus, AdapterRegistrationConflictError, AdapterReport, AdapterReportEntry, AdapterResource, AdapterResourceScope, AdapterStartResult, type AdapterStatus, type AdapterStatusStats, AnyFunc, ArchMap, Arrayable, type Attachment, AvatarSetRequest, Awaitable, BOT_CWD, BUILTIN_PLUGINS, Bot, BotAutoFilled, BotBase, BotConfigJson, BotContext, BotEvent, BotEventBase, BotHandler, BotLifecycleEvent, BotProvidedKeys, BotRegistry, BotStatus, BotStatusResult, BuildAdapterReportOptions, BuildStatusOptions, type BuiltinServiceRef, BusStats, CORE_PLUGINS, Capability, CapabilityHandler, CapabilityRegistry, CapabilityTarget, type ChatRuntime, type ChatRuntimeBaseOptions, type ChatRuntimeCollectedInfo, type ChatRuntimeGroupTarget, type ChatRuntimeInformationRequestOptions, type ChatRuntimeNoticeOptions, type ChatRuntimePrivateTarget, type ChatRuntimePromptInjection, type ChatRuntimeResult, type ChatRuntimeSource, ChromeUA, type CommandRole, type CompleteOptions, type CompleteResponse, type ConfigService, type ConsolaInstance, ContextOptions, ConversationGetHistoryRequest, type ConversationRef, CreateCmdOptions, CreateDriverOptions, CreateRuntimeOptions, CronHandler, Driver, DriverShutdownError, Event, EventBase, EventBus, EventFactoryOptions, EventHandler, EventIdentity, EventKindOfRoute, type EventMap, ExtendedNapCat, ForwardNode, ForwardSendNode, ForwardSendOptions, ForwardSendRequest, Friend, FriendDeleteRequest, FriendGetInfoRequest, FriendGetListRequest, FriendInfo, Gettable, Group, GroupGetInfoRequest, GroupGetListRequest, GroupGetMembersRequest, GroupInfo, GroupLeaveRequest, GroupSetNameRequest, GroupSetPortraitRequest, GroupSetWholeBanRequest, HasMessage, type HelpService, HistoryMessage, HttpClient, HttpRequestError, HttpRequestOptions, HttpResponse, LifecycleEvent, LifecycleEventMap, LifecycleHandler, LifecycleListener, LoadedAdapterDefinition, LoadedPluginDefinition, type LogLevel, type Logger, MatchHandler, MatchValue, MemberBanRequest, MemberGetInfoRequest, MemberInfo, MemberKickRequest, MemberPokeRequest, MemberSetAdminRequest, MemberSetCardRequest, MemberSetTitleRequest, type Message, MessageEvent, MessageGetForwardRequest, MessageGetRequest, MessageGetResult, type MessageInput, MessageRecallRequest, MessageSegment, MessageSegmentImpl, MessageSendRequest, type MessageTarget, MetaEvent, MiokuConfig, type MiokuContext, MiokuCoreServiceContrib, type MiokuPlugin, MiokuRuntime, type MiokuRuntimeConfig, type MiokuService, MiokuServices, MiokuStartOptions, type MiokuStatus, type MultimodalContentItem, type MultimodalMessage, Noop, NoticeEvent, NoticeOptions, PackageCandidate, PackageJson, type PackageJsonLike, PlatformId, PluginCandidate, PluginCleanup, type PluginHelp, PluginManager, type PluginMetadata, type PluginPackageConfig, type PluginStateRef, ProfileSetRequest, PureObject, Registration, ReplyArg, type ReplyOptions, RequestEvent, RouteEvent, type RunCommandResult, RuntimeAdapterState, RuntimeMiokuConfig, ScheduledTask, type ScreenshotService, SenderInfo, type SentMessage, SerializedMessageSegment, ServiceFactory, ServiceManager, type ServiceMetadata, type ServiceRef, Services, type SessionToolDefinition, type SkillPermissionRole, type SpawnPlan, StartOptions, type StatusProvider, StatusProviderContext, StatusProviderTarget, SystemMap, TOOL_RESULT_FOLLOWUP_KEY, type TextMessage, type ToolCallRecord, type ToolResultFollowup, UnsupportedCapabilityError, WebSocketClient, WebSocketConnectOptions, WebSocketConnectTimeoutError, WebSocketConnection, type WebUIService, addService, applyLogLevel, asMessage, atOf, avatarSet, base64Decode, base64Encode, bindCapabilities, botConfig, botStatus, box, buildAdapterReport, buildMiokuStatus, buildRoutes, buildSpawnPlan, clamp, collectBotStats, colorize, colors, commandExists, connectedBotKey, connectedBots, conversationGetHistory, createCmd, createDB, createDefaultDriver, createFriendRef, createGroupRef, createImportContext, createMessage, createMiokuLogger, createRuntime, createStore, dayjs, dedent, defineAdapter, defineCapability, definePlugin, defineService, defineState, deleteServiceConfig, discoverAdapterCandidates, discoverPluginCandidates, ensureDataDir, filesize, filter, find, findLocalPlugins, formatAdapterReport, formatDuration, formatMiokuStatus, formatMiokuStatusFn, forwardSend, friendDelete, friendGetInfo, friendGetList, fs, getAllPluginRuntimeStates, getBuiltinPlugins, getConfigDir, getDataDir, getGTk, getPluginConfigDir, getPluginDataDir, getPluginMetadata, getPluginMetadataList, getPluginRuntimeState, getService, getServiceConfig, getServiceConfigDir, getServiceConfigs, getServiceDataDir, getTerminalInput, groupGetInfo, groupGetList, groupGetMembers, groupLeave, groupSetName, groupSetPortrait, groupSetWholeBan, hasEventRight, hasPluginState, hasRight, hasService, isAdapterEvent, isAdmin, isBoolean, isBotEvent, isDefined, isEventAdmin, isEventOwner, isEventOwnerOrAdmin, isFunction, isMessage, isMessageEvent, isMetaEvent, isMiokuPlugin, isNoticeEvent, isNumber, isObject, isOwner, isOwnerOrAdmin, isRequestEvent, isSegment, isString, loadAdapterDefinition, loadLocalPlugin, loadNpmPlugin, localNum, localeDate, localeTime, rootLogger as logger, match, md5, memberBan, memberGetInfo, memberKick, memberPoke, memberSetAdmin, memberSetCard, memberSetTitle, messageGet, messageGetForward, messageRecall, messageSend, mriLib as mri, noNullish, normalizeAIThinkingLevel, normalizeAdmins, normalizeOwners, normalizePlugins, normalizeSkillPermissionRole, noticeAdmins, noticeFriends, noticeGroups, noticeOwners, path, prettyMs, profileSet, qs, randomId, randomInt, randomItem, randomItems, readMiokuConfig, readPackageJson, readPackageJsonSafe, registerPluginArtifacts, registerServiceConfig, registerStatusProvider, reloadMiokuConfig, removePluginMetadata, requireService, resetPluginMetadata, resetPluginRuntimeState, resolveCommand, resolveEntry, resolveLocalPluginEntry, resolveLocalPluginPath, rootLogger, runCommand, runCommandInherit, segment, sendMessage, _default as serviceManager, servicesRegistry, setBotCwd, setBuiltinPlugins, setPluginMetadata, setPluginRuntimeState, setService, setWritableConfig, start, startRuntime, string2argv, stringifyError, stripAnsi, text, toArray, toId, toUserId, unique, updateMiokuConfig, updateServiceConfig, uuid, version, wait, writePackageJson };
 //# sourceMappingURL=index.d.ts.map