@delta-comic/plugin 3.0.0-next.8 → 3.0.0-next.9

package/dist/lib/index.d.mts

@@ -1,116 +1,59 @@
-import { PluginArchiveDB } from "@delta-comic/db";
+import { DELTA_COMIC_PLUGIN_API_VERSION, FormConfigure, FormDefaultValue, FormResult, FormSingleConfigure, FormSingleResult, PluginManifest, PluginManifest as PluginManifest$1, StreamQuery, UniCommentRow, UniContentDownloadProvider, UniContentLayoutComponent, UniContentPage, UniContentPageLike, UniContentType_, UniImage, UniItem, UniItemAuthor, UniItemCardComponent, UniItemRaw, UniItemTranslator, UniResourceProcessInstance, UniResourceType, UniUserCardComponent } from "@delta-comic/model";
 import { App, Component, MaybeRefOrGetter, Raw, Ref } from "vue";
-import { FormConfigure, FormResult, FormSingleConfigure, FormSingleResult, SourcedKeyMap, StreamQuery, UniCommentRow, UniContentDownloadProvider, UniContentLayoutComponent, UniContentPage, UniContentPageLike, UniContentType_, UniImage, UniItem, UniItemAuthor, UniItemCardComponent, UniItemRaw, UniItemTranslator, UniResourceProcessInstance, UniResourceType, UniUserCardComponent } from "@delta-comic/model";
-import { DownloadMessageBind } from "@delta-comic/ui";
-
-//#region lib/configPointer.d.ts
+import { PluginArchiveDB } from "@delta-comic/db";
+//#region lib/api/config.d.ts
 type ConfigDescription = Record<string, Required<Pick<FormSingleConfigure, 'defaultValue'>> & FormSingleConfigure>;
 type UnwrapConfigPointer<T extends ConfigPointer> = T['_type'];
 declare class ConfigPointer<T extends ConfigDescription = ConfigDescription> {
-  pluginName: string;
-  config: T;
-  configName: string;
+  readonly pluginName: string;
+  readonly config: T;
+  readonly configName: string;
   readonly key: symbol;
   readonly _type: T;
   constructor(pluginName: string, config: T, configName: string);
 }
 //#endregion
-//#region lib/i18n.d.ts
-interface PluginLocaleMessage {
-  [key: string]: PluginLocaleMessage | string;
-}
-type PluginLocaleMessages = Record<string, PluginLocaleMessage>;
-interface PluginI18nAdapter {
-  setLocaleMessage(locale: string, message: PluginLocaleMessage): void;
-  translate?(key: string, params?: Record<string, number | string>): string;
-}
-declare class PluginI18nRegistry {
-  private adapter?;
-  private baseMessages;
-  private readonly pluginMessages;
-  install(adapter: PluginI18nAdapter, baseMessages: PluginLocaleMessages): void;
-  register(plugin: string, messages: PluginLocaleMessages): void;
-  remove(plugin: string): void;
-  translate(key: string, params?: Record<string, number | string>): string;
-  private compose;
-  private locales;
-  private refresh;
+//#region lib/api/env.d.ts
+type Platform = 'tauri' | 'web';
+interface ConfigEnv {
+  safe: boolean;
+  platform: Platform;
 }
-declare const pluginI18n: PluginI18nRegistry;
-declare const pluginMessageKey: (key: string) => string;
-declare const translatePluginText: (value: string) => string;
-declare namespace share_d_exports {
-  export { Config$7 as Config, InitiativeItem, PopupConfig, ShareToken };
+//#endregion
+//#region lib/api/host.d.ts
+declare module '@delta-comic/utils' {
+  interface SharedFunctions {
+    routeToContent(contentType: UniContentType_, id: string, ep: string, preload?: UniItem): Promise<unknown>;
+    routeToSearch(input: string, source?: [plugin: string, method: string], sort?: string): Promise<unknown>;
+    pushShareToken(token: string): Promise<unknown>;
+  }
 }
-interface Config$7 {
-  initiative: InitiativeItem[];
-  tokenListen: ShareToken[];
+declare namespace remote_d_exports {
+  export { Definition, RemoteModel, TestFunction, TestGroup };
 }
-interface ShareToken {
-  key: string;
+type RemoteModel = TestGroup[];
+interface TestGroup {
   name: string;
-  patten(chipboard: string): boolean;
-  show(chipboard: string): Promise<PopupConfig> | PopupConfig;
+  test: TestFunction;
+  remotes: Definition[];
+  allowNoConnected?: boolean;
 }
-interface PopupConfig {
-  title: string;
-  detail: string;
-  onPositive(): void;
-  onNegative(): void;
-}
-interface InitiativeItem {
-  key: string;
+interface Definition {
   name: string;
-  icon: Component | UniImage;
-  bgColor?: string;
-  call(page: UniContentPage): Promise<{
-    token?: string;
-  } | void>;
-  filter(page: UniContentPage): boolean;
-}
-declare namespace content_d_exports {
-  export { Config$6 as Config };
-}
-type Config$6 = Record<string, {
-  itemCard?: UniItemCardComponent;
-  commentRow?: UniCommentRow;
-  layout?: UniContentLayoutComponent;
-  contentPage?: UniContentPageLike;
-  downloadProvider?: UniContentDownloadProvider;
-  itemTranslator?: UniItemTranslator;
-}>;
-declare namespace subscribe_d_exports {
-  export { Config$5 as Config };
-}
-interface Config$5 {
-  getUpdateList(olds: {
-    author: UniItemAuthor;
-    list: UniItem[];
-  }[], signal: AbortSignal): PromiseLike<{
-    isUpdated: boolean;
-    whichUpdated: UniItemAuthor[];
-  }>;
-  onAdd?(author: UniItemAuthor): any;
-  onRemove?(author: UniItemAuthor): any;
-  fetchAuthorContent: StreamQuery<UniItem, {
-    author: UniItemAuthor;
-  }>;
+  url: string;
+  /**
+   * cover root `test` method
+   */
+  test?: TestFunction;
 }
+type TestFunction = (url: string, signal: AbortSignal) => Promise<void>;
 declare namespace user_d_exports {
-  export { ActionPageItem, Config$4 as Config, UserAction, UserActionPage };
+  export { ActionPageItem, Auth, CallbackResult, Favourites, InjectCode, Method, Selection, UserAction, UserActionPage, UserModel };
 }
-interface Config$4 {
+interface UserModel {
+  auth: Auth;
   edit?: Component;
   card?: UniUserCardComponent;
-  authorIcon?: Record<string, Component>;
-  /**
-   * 1. download
-   * 2. upload (收藏那些云端未收藏的漫画)
-   */
-  syncFavourite?: {
-    download: () => PromiseLike<UniItem[]>;
-    upload: (items: UniItemRaw[]) => PromiseLike<any>;
-  };
   /**
    * 你希望展示的(`userActions`)自己的板块的页面
    */
@@ -118,11 +61,44 @@ interface Config$4 {
   /**
    * 在用户界面，在历史记录那个板块的下方，你希望展示的自己的板块
    */
-  userActions?: Record<string, UserAction>;
+  userActions?: UserAction[];
+  favourites: Favourites;
+}
+interface Auth {
+  selections: Selection[];
+  /**
+   * @returns `string` -> id; `false` -> by user; `true` -> no auth
+   */
+  default: () => Promise<string | boolean>;
+}
+interface Selection {
+  name: string;
+  id: string;
+  call: (by: Method) => Promise<void>;
+}
+type Method = {
+  form<T extends FormConfigure>(form: T): Promise<{ [x in keyof T]: FormSingleResult<T[x]>; }>;
+  /**
+   * @param injectCode 你可以在js调用`callback(...)`来完成鉴权，传值为你给的回调
+   */
+  website<T>(url: string, injectCode: InjectCode): Promise<CallbackResult<T>>;
+};
+interface InjectCode {
+  js: string;
+  css: string;
+}
+interface CallbackResult<T> {
+  callbackValue: T;
+  cookie: string;
+  localStorage: Record<string, string>;
+  sessionStorage: Record<string, string>;
+  href: string;
+  title: string;
 }
 interface UserAction {
   call(author: UniItemAuthor): any;
   name: string;
+  id: string;
   icon?: Component;
 }
 interface UserActionPage {
@@ -144,120 +120,77 @@ type ActionPageItem = {
   icon?: Component;
   value: MaybeRefOrGetter<string | number>;
 };
-declare namespace api_d_exports {
-  export { Config$3 as Config };
+interface Favourites {
+  download: (signal: AbortSignal) => Promise<UniItem[]>;
+  upload: (items: UniItemRaw[], signal: AbortSignal) => Promise<void>;
 }
-interface Config$3 {
-  forks: () => PromiseLike<string[]> | string[];
-  /**
-   * error -> 不可用
-   * other -> 可用并比对时间
-   */
-  test: (fork: string, signal: AbortSignal) => PromiseLike<void>;
-}
-declare namespace otherProgress_d_exports {
-  export { Config$2 as Config, OtherProgressRunnerOptions, runOtherProgress };
-}
-interface Config$2 {
-  /** Run immediately with adjacent async steps; a trailing async group does not block loading. */
-  async?: boolean;
-  call: (setDescription: (description: string) => void) => PromiseLike<any>;
-  name: string;
+declare namespace expose_d_exports {
+  export { ExposeModel };
 }
-interface OtherProgressRunnerOptions {
-  onBackgroundError?: (error: AggregateError) => void;
-  setMeta: (meta: {
-    description: string;
-    name: string;
-  }) => void;
+type ExposeModel = Record<string, any>;
+declare namespace content_d_exports {
+  export { AutoCompleteProvider, Barcode, Category, ContentModel, HotCategory, HotLevelboard, HotPageContent, HotSearchProvider, HotTopButton, ItemProvider, Model, Promotes, Search, SearchAim, SearchMethod, Tabbar };
 }
-declare const runOtherProgress: (progresses: readonly Config$2[], {
-  setMeta,
-  onBackgroundError
-}: OtherProgressRunnerOptions) => Promise<void>;
-declare namespace search_d_exports {
-  export { Barcode, Category, Config$1 as Config, HotLevelboard, HotMainList, HotSearchItem, HotSearchProvider, HotSearchTarget, HotTopButton, ItemProvider, RouteToContent, SearchMethod, Tabbar };
+interface ContentModel {
+  models?: Model[];
+  search?: Search;
+  promotes?: Promotes;
 }
-interface Config$1 {
-  /**
-   * @description
-   * key: id
-   */
-  methods?: Record<string, SearchMethod>;
-  tabbar?: Tabbar[];
-  categories?: Category[];
-  hotPage?: {
-    levelBoard?: HotLevelboard[];
-    topButton?: HotTopButton[];
-    mainListCard?: HotMainList[];
-  };
+interface Model {
+  name: string;
+  ItemCard?: UniItemCardComponent;
+  CommentRow?: UniCommentRow;
+  Layout?: UniContentLayoutComponent;
+  ContentPage?: UniContentPageLike;
+  DownloadProvider?: UniContentDownloadProvider;
+  ItemTranslator?: UniItemTranslator;
+}
+interface Search {
+  methods: SearchMethod[];
   barcode?: Barcode[];
-  /** Search landing-page sections supplied by this plugin. */
-  hotSearch?: HotSearchProvider[];
-  fetchRandomItems?: ItemProvider;
+  getHotSearch: HotSearchProvider;
 }
-type ItemProvider = (signal: AbortSignal) => UniItem[] | PromiseLike<UniItem[]>;
+type HotSearchProvider = (signal: AbortSignal) => Promise<SearchAim[]>;
 interface SearchMethod {
   name: string;
+  id: string;
   sorts: {
-    text: string;
-    value: string;
-  }[];
-  defaultSort: string;
+    options: {
+      label: string;
+      id: string;
+    }[];
+    default: string;
+  };
   fetchSearchResult: StreamQuery<UniItem, {
-    input: string;
-    sort: string;
+    aim: SearchAim;
   }>;
-  getAutoComplete(input: string, signal: AbortSignal): PromiseLike<({
-    text: string;
-    value: string;
-  } | Component)[]>;
-}
-interface HotSearchTarget {
-  /** Search method key declared by the same plugin. */
-  method: string;
-  /** Falls back to the search method's default sort when omitted. */
-  sort?: string;
-}
-interface HotSearchItem {
-  text: string;
-  /** Search input used after selection. Defaults to `text`. */
-  value?: string;
-  badge?: {
-    text: string;
-    tone?: 'accent' | 'warning';
-  };
-  /** Overrides the provider target for this item. */
-  target?: HotSearchTarget;
+  getAutoComplete: AutoCompleteProvider;
 }
-interface HotSearchProvider {
-  title: string;
-  target: HotSearchTarget;
-  fetchItems(signal: AbortSignal): PromiseLike<HotSearchItem[]> | HotSearchItem[];
-}
-interface HotLevelboard {
-  name: string;
-  content: ItemProvider;
+type AutoCompleteProvider = (input: string, signal: AbortSignal) => Promise<SearchAim[] | Component>;
+interface SearchAim {
+  input: string;
+  search: {
+    method: string;
+    sort?: string;
+  };
 }
-interface HotMainList {
+interface Barcode {
   name: string;
-  content: ItemProvider;
-  onClick?(): any;
+  id: string;
+  getTipText: (aim: SearchAim) => string;
+  isMatch: (aim: SearchAim) => boolean;
 }
-interface HotTopButton {
-  name: string;
-  icon: Component;
-  bgColor: string;
-  onClick?(): any;
+interface Promotes {
+  tabbar?: Tabbar[];
+  categories?: Category[];
+  hotPageContent?: HotPageContent;
+  fetchRandomItems?: ItemProvider;
 }
+type ItemProvider = (signal: AbortSignal) => Promise<UniItem[]>;
 interface Category {
   title: string;
   namespace: string;
-  search: {
-    methodId: string;
-    input: string;
-    sort: string;
-  };
+  search: SearchAim;
 }
 interface Tabbar {
   title: string;
@@ -267,124 +200,851 @@ interface Tabbar {
     tabbar: Tabbar;
   }>;
 }
-type RouteToContent = (contentType_: UniContentType_, id: string, ep: string, preload?: UniItem) => PromiseLike<any>;
-interface Barcode {
-  match: (searchText: string) => boolean;
-  /**
-   * 选中后返回路由信息
-   */
-  getContent: (searchText: string, signal: AbortSignal) => PromiseLike<Parameters<RouteToContent>>;
+interface HotPageContent {
+  levelboard?: HotLevelboard[];
+  topButton?: HotTopButton[];
+  categories?: HotCategory[];
+}
+interface HotLevelboard {
   name: string;
+  id: string;
+  content: ItemProvider;
 }
-declare namespace auth_d_exports {
-  export { CallbackResult, Config, InjectCode, Method };
+interface HotCategory {
+  name: string;
+  content: ItemProvider;
 }
-interface Config {
-  signUp: (by: Method) => PromiseLike<any>;
-  logIn: (by: Method) => PromiseLike<any>;
-  passSelect: () => PromiseLike<'signUp' | 'logIn' | false>;
+interface HotTopButton {
+  name: string;
+  icon: Component;
+  bgColor: string;
 }
-type Method = {
-  form<T extends FormConfigure>(form: T): Promise<{ [x in keyof T]: FormSingleResult<T[x]> }>;
-  /**
-   * @param injectCode 你可以在js调用`callback(...)`来完成鉴权，传值为你给的回调
-   */
-  website<T>(url: string, injectCode: InjectCode): Promise<CallbackResult<T>>;
-};
-interface InjectCode {
-  js: string;
-  css: string;
+declare namespace social_d_exports {
+  export { InitiativeItem, Share, SharePopupConfig, ShareToken, SocialModel, Subscribe, SubscribeListProvider };
 }
-interface CallbackResult<T> {
-  callbackValue: T;
-  cookie: string;
-  localStorage: Record<string, string>;
-  sessionStorage: Record<string, string>;
-  href: string;
+interface SocialModel {
+  share?: Share;
+  subscribe?: Subscribe;
+}
+interface Share {
+  initiative?: InitiativeItem[];
+  tokenListen?: ShareToken[];
+}
+interface ShareToken {
+  key: string;
+  name: string;
+  isMatched(chipboard: string): boolean;
+  show(chipboard: string): Promise<SharePopupConfig>;
+}
+interface SharePopupConfig {
   title: string;
+  detail: string;
+  onPositive(): void;
+  onNegative(): void;
+}
+interface InitiativeItem {
+  key: string;
+  name: string;
+  icon: Component | UniImage;
+  bgColor?: string;
+  call(page: UniContentPage): Promise<{
+    token?: string;
+  } | void>;
+  filter(page: UniContentPage): boolean;
+}
+interface Subscribe {
+  getUpdateList: SubscribeListProvider;
+  fetchAuthorContent: StreamQuery<UniItem, {
+    author: UniItemAuthor;
+  }>;
+}
+type SubscribeListProvider = (olds: {
+  author: UniItemAuthor;
+  list: UniItem[];
+}[], signal: AbortSignal) => Promise<{
+  isUpdated: boolean;
+  whichUpdated: UniItemAuthor[];
+}>;
+declare namespace special_d_exports {
+  export { SpecialModel, Step };
+}
+type SpecialModel = Step[];
+interface Step {
+  name: string;
+  call: (setDescription: (description: string) => void) => Promise<void>;
 }
 declare namespace resource_d_exports {
-  export { Content };
+  export { ResourceModel };
 }
-interface Content {
+/** Declarative resource schemes and their pathname processors. */
+interface ResourceModel {
   process?: Record<string, UniResourceProcessInstance>;
   types?: UniResourceType[];
 }
 //#endregion
-//#region lib/plugin/index.d.ts
-interface PluginConfigValues {
-  name: string;
-  content?: Config$6;
-  resource?: Content;
-  api?: Record<string, Config$3>;
-  user?: Config$4;
-  auth?: Config;
-  /** Locale messages are merged in plugin load order; later plugins may override existing keys. */
-  i18n?: PluginLocaleMessages;
-  otherProgress?: Config$2[];
-  search?: Config$1;
-  /**
-   * 插件的配置项需在此处注册
-   * 传入`Store.ConfigPointer`
-   */
-  config?: ConfigPointer[];
-  subscribe?: Record<string, Config$5>;
-  share?: Config$7;
+//#region lib/api/model/index.d.ts
+interface PluginConfigModel {
+  remotes?: RemoteModel;
+  resource?: ResourceModel;
+  user?: UserModel;
+  content?: ContentModel;
+  social?: SocialModel;
+  expose?: ExposeModel;
+  special?: SpecialModel;
 }
-type DefineResult = {
-  api?: Record<string, string | undefined | false>;
-};
-type Platform = 'tauri' | 'web';
-interface PluginConfigHooks {
+//#endregion
+//#region lib/api/hook/content.d.ts
+interface ContentHooks {
+  onSearchBarcodeSubmit(searchAim: SearchAim): void;
+  onHotCategoryClick(category: HotCategory): void;
+  onHotTopButtonClick(button: HotTopButton): void;
+}
+//#endregion
+//#region lib/api/hook/remote.d.ts
+interface RemoteHooks {
+  onRemoteTestDone(group: TestGroup, remote: Definition | false): void;
+}
+//#endregion
+//#region lib/api/hook/social.d.ts
+interface SocialHooks {
+  onSubscribeOne?(author: UniItemAuthor): void;
+  onUnsubscribeOne?(author: UniItemAuthor): void;
+}
+//#endregion
+//#region lib/api/hook/lifecycle.d.ts
+type PluginLifecycleCleanup = () => Promise<void> | void;
+interface LifecycleHooks {
   /** Runs after app.use() registration and before app.mount() for preboot plugins. */
   onPreboot?(context: {
     app: App;
-    platform: Platform;
-    safe: boolean;
-  }): (() => Promise<void> | void) | Promise<(() => Promise<void> | void) | void> | void;
-  /**
-   * 返回值如果不为空，则会await后作为expose暴露
-   */
-  onBooted?(ins: DefineResult): (PromiseLike<object> | object) | void;
+  }): PluginLifecycleCleanup | Promise<PluginLifecycleCleanup | void> | void;
+  onBooted?(): Promise<void> | void;
   /** Runs before a normal plugin is reloaded or the runtime is disposed. */
   onUnload?(): Promise<void> | void;
   /** Runs once before an installed plugin and its persisted files are removed. */
   onUninstall?(): Promise<void> | void;
 }
-type PluginConfig = PluginConfigValues & PluginConfigHooks;
-interface ConfigEnv {
-  safe: boolean;
-  platform: Platform;
+//#endregion
+//#region lib/api/hook/index.d.ts
+type PluginConfigHooks = Partial<RemoteHooks & ContentHooks & SocialHooks & LifecycleHooks>;
+//#endregion
+//#region lib/api/i18n.d.ts
+interface PluginLocaleMessage {
+  [key: string]: PluginLocaleMessage | string;
+}
+type PluginLocaleMessages = Record<string, PluginLocaleMessage>;
+//#endregion
+//#region lib/api/plugin.d.ts
+interface DCPluginConfig {
+  /** Stable plugin id. It must equal the candidate manifest id. */
+  name: string;
+  /** At most one declarative configuration form can be contributed by a plugin. */
+  config?: ConfigPointer;
+  i18n?: PluginLocaleMessages;
+  model?: PluginConfigModel;
+  hooks?: PluginConfigHooks;
 }
-/**
- * 这仅是个辅助定义的函数，没有副作用
- */
-declare const definePlugin: <T extends PluginConfig>(config: T | PluginConfigFactory<T>) => PluginConfigFactory<T>;
-type PluginExpose<T extends PluginConfig> = ReturnType<T['onBooted'] extends (() => object) ? T['onBooted'] : () => void>;
-type PluginConfigFactory<T extends PluginConfig = PluginConfig> = (env: ConfigEnv) => T;
-interface BuiltInPluginDefinition<T extends PluginConfig = PluginConfig> {
-  meta: PluginArchiveDB.Meta;
-  config: PluginConfigFactory<T>;
-  enabledByDefault?: boolean;
-}
-/** Defines a trusted plugin that is bundled with the application. */
-declare const defineInnerPlugin: <T extends PluginConfig>(definition: BuiltInPluginDefinition<T>) => BuiltInPluginDefinition<T>;
-//#endregion
-//#region lib/config.d.ts
+type PluginConfigFactory<T extends DCPluginConfig = DCPluginConfig> = (env: ConfigEnv) => T;
+declare const defineDeltaComicPlugin: <T extends DCPluginConfig>(config: T | PluginConfigFactory<T>) => PluginConfigFactory<T>;
+//#endregion
+//#region lib/kernel/candidate.d.ts
+type PluginOrigin = 'builtin' | 'installed';
+interface PluginManagementCapabilities {
+  readonly canDisable: boolean;
+  readonly canUninstall: boolean;
+  readonly canUpdate: boolean;
+}
+interface LoadedPluginModule {
+  readonly factory: PluginConfigFactory;
+  dispose?(): Promise<void> | void;
+}
+interface PluginCandidate {
+  readonly manifest: PluginManifest$1;
+  readonly origin: PluginOrigin;
+  readonly enabled: boolean;
+  readonly management: PluginManagementCapabilities;
+  load(signal: AbortSignal): Promise<LoadedPluginModule>;
+}
+interface PluginCandidateProvider {
+  readonly id: string;
+  list(signal: AbortSignal): Promise<readonly PluginCandidate[]>;
+}
+interface InternalPluginDefinition {
+  readonly manifest: PluginManifest$1;
+  readonly factory: PluginConfigFactory;
+  readonly canDisable?: boolean;
+  readonly enabledByDefault?: boolean;
+}
+declare const defineInternalPlugin: <T extends InternalPluginDefinition>(definition: T) => T;
+//#endregion
+//#region lib/kernel/scope.d.ts
+type PluginDisposer = () => Promise<void> | void;
+declare class PluginScope {
+  #private;
+  readonly owner: string;
+  constructor(owner: string);
+  get signal(): AbortSignal;
+  get disposed(): boolean;
+  defer(disposer: PluginDisposer): PluginDisposer;
+  dispose(reason?: unknown): Promise<void>;
+}
+//#endregion
+//#region lib/kernel/capability.d.ts
+interface ActivationStepUpdate {
+  readonly description?: string;
+  readonly name?: string;
+}
+interface ActivationContext {
+  readonly owner: string;
+  readonly scope: PluginScope;
+  readonly signal: AbortSignal;
+  report(update: ActivationStepUpdate | string): void;
+}
+interface CapabilityModule {
+  readonly id: string;
+  activate(plugin: DCPluginConfig, context: ActivationContext): Promise<boolean>;
+}
+interface CapabilityDefinition<T> {
+  readonly id: string;
+  select(plugin: DCPluginConfig): T | undefined;
+  activate(model: T, context: ActivationContext): Promise<void> | void;
+}
+declare const defineCapability: <T>(definition: CapabilityDefinition<T>) => CapabilityModule;
+declare class ActivationPipeline {
+  #private;
+  constructor(modules: readonly CapabilityModule[]);
+  activate(plugin: DCPluginConfig, context: ActivationContext): Promise<string[]>;
+}
+//#endregion
+//#region lib/kernel/contribution.d.ts
+interface Contribution<T> {
+  readonly owner: string;
+  readonly id: string;
+  readonly value: T;
+}
+interface ContributionChannel<T> {
+  readonly key: string;
+  readonly __type?: T;
+}
+declare const defineContributionChannel: <T>(key: string) => ContributionChannel<T>;
+declare class ContributionRegistry<T> {
+  #private;
+  get size(): number;
+  get entries(): ReadonlyMap<string, Contribution<T>>;
+  register(owner: string, id: string, value: T): () => boolean;
+  get(owner: string, id: string): Contribution<T> | undefined;
+  byOwner(owner: string): Contribution<T>[];
+  removeOwner(owner: string): void;
+  values(): MapIterator<Contribution<T>>;
+}
+declare class ContributionHub {
+  private readonly registries;
+  channel<T>(channel: ContributionChannel<T>): ContributionRegistry<T>;
+  register<T>(scope: PluginScope, channel: ContributionChannel<T>, id: string, value: T): () => boolean;
+  removeOwner(owner: string): void;
+}
+//#endregion
+//#region lib/kernel/dependency.d.ts
+interface MissingPluginDependency {
+  readonly plugin: string;
+  readonly dependency: string;
+}
+interface PluginDependencyPlan {
+  readonly levels: PluginCandidate[][];
+  readonly missing: MissingPluginDependency[];
+  readonly cycles: string[][];
+}
+declare const findPluginDependencyCycles: (candidates: readonly PluginCandidate[]) => string[][];
+declare const planPluginDependencies: (candidates: readonly PluginCandidate[]) => PluginDependencyPlan;
+//#endregion
+//#region lib/capabilities/services.d.ts
+interface RegisteredPluginConfig {
+  readonly ready: Promise<void>;
+}
+interface PluginConfigRegistry {
+  register(pointer: ConfigPointer): RegisteredPluginConfig;
+  unregister(pointer: ConfigPointer): void;
+}
+interface PluginMessageRegistry {
+  register(plugin: string, messages: PluginLocaleMessages): void;
+  remove(plugin: string): void;
+}
+interface PluginAuthGateway {
+  authenticate(plugin: string, auth: Auth, signal: AbortSignal): Promise<void>;
+}
+interface PluginCapabilityServices {
+  readonly auth?: PluginAuthGateway;
+  readonly app?: App;
+  readonly config: PluginConfigRegistry;
+  readonly contributions: ContributionHub;
+  readonly i18n: PluginMessageRegistry;
+  readonly phase: 'normal' | 'preboot';
+}
+//#endregion
+//#region lib/capabilities/auth.d.ts
+declare const createAuthCapability: (services: PluginCapabilityServices) => CapabilityModule;
+//#endregion
+//#region lib/capabilities/channels.d.ts
+declare const pluginModelChannels: {
+  readonly content: ContributionChannel<ContentModel>;
+  readonly expose: ContributionChannel<ExposeModel>;
+  readonly remote: ContributionChannel<RemoteModel>;
+  readonly resource: ContributionChannel<ResourceModel>;
+  readonly social: ContributionChannel<SocialModel>;
+  readonly special: ContributionChannel<SpecialModel>;
+  readonly user: ContributionChannel<UserModel>;
+};
+//#endregion
+//#region lib/capabilities/config.d.ts
+declare const createConfigCapability: (services: PluginCapabilityServices) => CapabilityModule;
+//#endregion
+//#region lib/capabilities/content.d.ts
+declare const createContentCapability: () => CapabilityModule;
+//#endregion
+//#region lib/capabilities/i18n.d.ts
+declare const createI18nCapability: (services: PluginCapabilityServices) => CapabilityModule;
+//#endregion
+//#region lib/capabilities/lifecycle.d.ts
+declare const createLifecycleCapability: (services: PluginCapabilityServices) => CapabilityModule;
+//#endregion
+//#region lib/capabilities/model.d.ts
+declare const createModelCapability: (services: PluginCapabilityServices) => CapabilityModule;
+//#endregion
+//#region lib/capabilities/remote.d.ts
+interface RemoteSelection {
+  readonly group: TestGroup;
+  readonly latencyMs?: number;
+  readonly remote: Definition | false;
+}
+declare const pluginRemoteSelectionChannel: ContributionChannel<RemoteSelection>;
+declare const createRemoteCapability: (services: PluginCapabilityServices) => CapabilityModule;
+//#endregion
+//#region lib/capabilities/resource.d.ts
+declare const createResourceCapability: () => CapabilityModule;
+//#endregion
+//#region lib/capabilities/special.d.ts
+declare const createSpecialCapability: () => CapabilityModule;
+//#endregion
+//#region lib/capabilities/user.d.ts
+declare const createUserCapability: () => CapabilityModule;
+//#endregion
+//#region lib/capabilities/index.d.ts
+/** Fixed host-owned activation topology. Third-party plugins only provide data to it. */
+declare const createDefaultCapabilities: (services: PluginCapabilityServices) => readonly CapabilityModule[];
+//#endregion
+//#region lib/install/catalog.d.ts
+type PluginCatalogSource = {
+  readonly type: 'github';
+  readonly repository: string;
+} | {
+  readonly type: 'url';
+  readonly url: string;
+};
+interface PluginCatalogRepository {
+  readonly defaultBranch: string;
+  readonly lastCommitAt: string;
+  readonly name: string;
+  readonly owner: string;
+  readonly readmeUrl?: string;
+  readonly url: string;
+}
+interface PluginCatalogRelease {
+  readonly manifestUrl: string | null;
+  readonly publishedAt: string;
+  readonly url: string;
+  readonly version: string;
+}
+interface PluginCatalogListing {
+  readonly authors: readonly string[];
+  readonly id: string;
+  readonly release?: PluginCatalogRelease;
+  readonly repository?: PluginCatalogRepository;
+  readonly source: PluginCatalogSource;
+}
+interface PluginCatalogPageReference {
+  readonly items: number;
+  readonly page: number;
+  readonly path: string;
+}
+interface PluginCatalogIndex {
+  readonly pageSize: number;
+  readonly pages: readonly PluginCatalogPageReference[];
+  readonly totalItems: number;
+  readonly totalPages: number;
+}
+interface PluginCatalogPagination {
+  readonly next: string | null;
+  readonly page: number;
+  readonly pageSize: number;
+  readonly previous: string | null;
+  readonly totalItems: number;
+  readonly totalPages: number;
+}
+interface PluginCatalogPage {
+  readonly items: readonly PluginCatalogListing[];
+  readonly pagination: PluginCatalogPagination;
+}
+interface PluginCatalogResult<T> {
+  readonly cachedAt: string;
+  readonly data: T;
+  readonly stale: boolean;
+}
+/** The narrow catalog port required by an install source resolver. */
+interface PluginInstallCatalog {
+  resolveInstallInput(plugin: string, signal: AbortSignal): Promise<string>;
+}
+/** Host-facing catalog operations used by the marketplace feature. */
+interface PluginCatalog extends PluginInstallCatalog {
+  loadIndex(signal?: AbortSignal): Promise<PluginCatalogResult<PluginCatalogIndex>>;
+  loadManifest(listing: PluginCatalogListing, signal?: AbortSignal): Promise<PluginManifest$1 | undefined>;
+  loadPage(path: string, signal?: AbortSignal): Promise<PluginCatalogResult<PluginCatalogPage>>;
+}
+declare const pluginCatalogInstallInput: (plugin: string) => string;
+declare const pluginCatalogIdFromInstallInput: (input: unknown) => string | undefined;
+//#endregion
+//#region lib/adapters/configStore.d.ts
 type ConfigSave<T extends ConfigPointer = ConfigPointer> = {
   form: UnwrapConfigPointer<T>;
   data: Ref<FormResult<T['config']>>;
   name: string;
   ready: Promise<void>;
 };
+type StoredConfigSave = {
+  data: Ref<Record<string, FormDefaultValue[keyof FormDefaultValue]>>;
+  form: ConfigPointer['config'];
+  name: string;
+  ready: Promise<void>;
+};
+type PluginConfigLoader = <T extends ConfigPointer>(pointer: T) => ConfigSave<T>;
 declare class ConfigStore {
-  readonly form: import("vue").ShallowReactive<Map<symbol, ConfigSave<ConfigPointer<ConfigDescription>>>>;
-  private readonly darkMode;
+  private readonly loadConfig;
+  private readonly entries;
+  private readonly pointers;
   private readonly isSystemDark;
+  constructor(loadConfig?: PluginConfigLoader);
+  get form(): ReadonlyMap<symbol, StoredConfigSave>;
   get isDark(): boolean;
-  constructor();
-  $load<T extends ConfigPointer>(pointer: T): ConfigSave<T>;
-  $loadApp(): ConfigSave<ConfigPointer<{
+  load<T extends ConfigPointer>(pointer: T): ConfigSave<T>;
+  has(pointer: ConfigPointer): boolean;
+  register<T extends ConfigPointer>(pointer: T): ConfigSave<T>;
+  unregister(pointer: ConfigPointer): void;
+}
+//#endregion
+//#region lib/install/contracts.d.ts
+type PluginInstallInput = File | string;
+interface ResolvedPluginSource {
+  readonly file: File;
+  readonly installInput: string;
+  readonly resolverId: string;
+}
+interface PluginSourceResolver {
+  readonly id: string;
+  matches(input: PluginInstallInput): boolean;
+  resolve(input: PluginInstallInput, signal: AbortSignal): Promise<ResolvedPluginSource>;
+}
+interface DecodedPluginPackage {
+  readonly codecId: string;
+  readonly files: ReadonlyMap<string, Uint8Array>;
+  readonly manifest: PluginManifest$1;
+}
+interface PluginPackageCodec {
+  readonly id: string;
+  matches(file: File): boolean;
+  decode(file: File, signal: AbortSignal): Promise<DecodedPluginPackage>;
+}
+interface PluginFileReplacement {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}
+interface PluginFileStore {
+  replace(plugin: string, files: ReadonlyMap<string, Uint8Array>): Promise<PluginFileReplacement>;
+  remove(plugin: string): Promise<void>;
+  read(plugin: string, path: string): Promise<Uint8Array>;
+  createAssetUrl(plugin: string, path: string): Promise<string>;
+  createModuleUrl(plugin: string, path: string): Promise<string>;
+  release(plugin: string): void;
+}
+interface PluginArchiveRepository {
+  find(plugin: string): Promise<PluginArchiveDB.Archive | undefined>;
+  list(): Promise<PluginArchiveDB.Archive[]>;
+  remove(plugin: string): Promise<void>;
+  upsert(archive: PluginArchiveDB.Archive): Promise<void>;
+}
+interface PluginModuleReader {
+  read(plugin: string, manifest: PluginManifest$1, signal: AbortSignal): Promise<LoadedPluginModule>;
+}
+interface PluginInstallProgress {
+  readonly description?: string;
+  readonly phase: 'decode' | 'persist' | 'resolve';
+  readonly progress?: number;
+}
+type PluginInstallReporter = (progress: PluginInstallProgress) => void;
+//#endregion
+//#region lib/install/candidateProvider.d.ts
+/** Normalize persisted archives into the same candidate protocol used by internal plugins. */
+declare class InstalledPluginCandidateProvider implements PluginCandidateProvider {
+  private readonly repository;
+  private readonly reader;
+  readonly id = "installed";
+  constructor(repository: PluginArchiveRepository, reader: PluginModuleReader);
+  list(signal: AbortSignal): Promise<PluginCandidate[]>;
+}
+//#endregion
+//#region lib/install/codec.d.ts
+declare class ZipPackageCodec implements PluginPackageCodec {
+  readonly id = "zip";
+  matches(file: File): boolean;
+  decode(file: File, signal: AbortSignal): Promise<DecodedPluginPackage>;
+}
+declare class DevScriptCodec implements PluginPackageCodec {
+  readonly id = "dev-script";
+  matches(file: File): boolean;
+  decode(file: File, signal: AbortSignal): Promise<DecodedPluginPackage>;
+}
+//#endregion
+//#region lib/install/manifest.d.ts
+declare const safePluginPath: (value: unknown, path: string) => string;
+declare class PluginManifestError extends Error {
+  constructor(message: string);
+}
+declare const parsePluginManifest: (value: unknown) => PluginManifest$1;
+declare const isPluginManifestCompatible: (manifest: PluginManifest$1, coreVersion: string) => boolean;
+//#endregion
+//#region lib/install/moduleReader.d.ts
+declare class StoredPluginModuleReader implements PluginModuleReader {
+  private readonly files;
+  constructor(files: PluginFileStore);
+  read(plugin: string, manifest: PluginManifest, signal: AbortSignal): Promise<LoadedPluginModule>;
+}
+//#endregion
+//#region lib/install/repository.d.ts
+declare class DatabasePluginArchiveRepository implements PluginArchiveRepository {
+  find(plugin: string): Promise<{
+    installerName: string;
+    loaderName: string;
+    pluginName: string;
+    meta: import("@delta-comic/model").PluginManifest;
+    enable: boolean;
+    installInput: string;
+    displayName: string;
+  } | undefined>;
+  list(): Promise<{
+    installerName: string;
+    loaderName: string;
+    pluginName: string;
+    meta: import("@delta-comic/model").PluginManifest;
+    enable: boolean;
+    installInput: string;
+    displayName: string;
+  }[]>;
+  remove(plugin: string): Promise<void>;
+  upsert(archive: PluginArchiveDB.Archive): Promise<void>;
+}
+//#endregion
+//#region lib/install/service.d.ts
+interface PluginInstallServiceOptions {
+  readonly codecs: readonly PluginPackageCodec[];
+  readonly files: PluginFileStore;
+  readonly repository: PluginArchiveRepository;
+  readonly reservedIds?: ReadonlySet<string>;
+  readonly resolvers: readonly PluginSourceResolver[];
+}
+declare class PluginInstallService {
+  private readonly options;
+  constructor(options: PluginInstallServiceOptions);
+  install(input: PluginInstallInput, signal?: AbortSignal, report?: PluginInstallReporter): Promise<{
+    installerName: string;
+    loaderName: string;
+    pluginName: string;
+    meta: import("@delta-comic/model").PluginManifest;
+    enable: boolean;
+    installInput: string;
+    displayName: string;
+  }>;
+  /** Remove archive metadata and files as one compensating transaction. */
+  uninstall(plugin: string): Promise<void>;
+}
+//#endregion
+//#region lib/install/source.d.ts
+declare class LocalFileSourceResolver implements PluginSourceResolver {
+  readonly id = "local-file";
+  matches(input: PluginInstallInput): input is File;
+  resolve(input: PluginInstallInput): Promise<ResolvedPluginSource>;
+}
+declare class HttpSourceResolver implements PluginSourceResolver {
+  readonly id = "http";
+  matches(input: PluginInstallInput): input is string;
+  resolve(input: PluginInstallInput, signal: AbortSignal): Promise<ResolvedPluginSource>;
+}
+interface GitHubSourceResolverOptions {
+  readonly coreVersion: string;
+  readonly token?: string;
+}
+declare class GitHubSourceResolver implements PluginSourceResolver {
+  private readonly options;
+  readonly id = "github";
+  constructor(options: GitHubSourceResolverOptions);
+  matches(input: PluginInstallInput): input is string;
+  resolve(input: PluginInstallInput, signal: AbortSignal): Promise<{
+    file: File;
+    installInput: string;
+    resolverId: string;
+  }>;
+}
+declare class MarketplaceSourceResolver implements PluginSourceResolver {
+  private readonly catalog;
+  private readonly sources;
+  readonly id = "marketplace";
+  constructor(catalog: PluginInstallCatalog, sources: readonly PluginSourceResolver[]);
+  matches(input: PluginInstallInput): input is string;
+  resolve(input: PluginInstallInput, signal: AbortSignal): Promise<{
+    installInput: string;
+    resolverId: string;
+    file: File;
+  }>;
+}
+//#endregion
+//#region lib/adapters/i18n.d.ts
+interface PluginI18nAdapter {
+  setLocaleMessage(locale: string, message: PluginLocaleMessage): void;
+  translate?(key: string, params?: Record<string, number | string>): string;
+}
+declare class PluginI18nRegistry {
+  private adapter?;
+  private baseMessages;
+  private readonly pluginMessages;
+  install(adapter: PluginI18nAdapter, baseMessages: PluginLocaleMessages): void;
+  register(plugin: string, messages: PluginLocaleMessages): void;
+  remove(plugin: string): void;
+  translate(key: string, params?: Record<string, number | string>): string;
+  private compose;
+  private locales;
+  private refresh;
+}
+declare const pluginI18n: PluginI18nRegistry;
+declare const pluginMessageKey: (key: string) => string;
+declare const translatePluginText: (value: string) => string;
+//#endregion
+//#region lib/runtime/store.d.ts
+declare class PluginStore {
+  private readonly translateText;
+  private readonly candidateEntries;
+  private readonly loadingEntries;
+  private readonly pluginEntries;
+  private readonly readyEntries;
+  constructor(translateText?: (value: string) => string);
+  get candidates(): ReadonlyMap<string, PluginCandidate>;
+  get loading(): ReadonlyMap<string, Raw<DCPluginConfig>>;
+  get plugins(): ReadonlyMap<string, Raw<DCPluginConfig>>;
+  get ready(): ReadonlySet<string>;
+  replaceCandidates(candidates: readonly PluginCandidate[]): void;
+  markLoading(plugin: string, config: Raw<DCPluginConfig>): void;
+  markReady(plugin: string): void;
+  markUnloaded(plugin: string): void;
+  isLoaded(plugin: string): boolean;
+  displayName(plugin: string): string;
+  modelEntries<K extends keyof NonNullable<DCPluginConfig['model']>>(key: K): [string, NonNullable<PluginConfigModel[K]>][];
+}
+//#endregion
+//#region lib/runtime/engine.d.ts
+interface PluginLoadingInfo {
+  progress: {
+    errorReason?: string;
+    status: 'done' | 'error' | 'process' | 'wait';
+    stepsIndex: number;
+  };
+  steps: {
+    description: string;
+    name: string;
+  }[];
+}
+interface PluginRuntimeFailure {
+  readonly error: unknown;
+  readonly phase: 'normal' | 'preboot';
+  readonly plugin: string;
+}
+interface PluginRuntimeReport {
+  readonly activated: string[];
+  readonly failures: PluginRuntimeFailure[];
+}
+interface PluginRuntimeOperation {
+  readonly operation: Promise<PluginRuntimeReport>;
+  readonly progress: Ref<Record<string, PluginLoadingInfo>>;
+}
+interface LoadNormalOptions {
+  readonly pluginNames?: readonly string[];
+}
+interface PrebootRecovery {
+  failedAt: number;
+  plugins: string[];
+  reason: string;
+}
+interface PluginRuntimeOptions {
+  readonly capabilities: (phase: 'normal' | 'preboot', app?: App) => readonly CapabilityModule[];
+  readonly environment: () => ConfigEnv;
+  readonly provider: PluginCandidateProvider;
+  readonly remove: (plugin: string) => Promise<void>;
+  readonly store?: PluginStore;
+}
+declare class PluginRuntime {
+  #private;
+  readonly store: PluginStore;
+  constructor(options: PluginRuntimeOptions);
+  get activeNormalPluginNames(): string[];
+  preparePreboot(app: App): Promise<PluginRuntimeReport>;
+  loadNormal(options?: LoadNormalOptions): PluginRuntimeOperation;
+  reloadNormal(options?: LoadNormalOptions): PluginRuntimeOperation;
+  uninstall(plugin: string): Promise<void>;
+  refreshCandidates(): Promise<readonly PluginCandidate[]>;
+  readRecovery(): PrebootRecovery | null;
+  clearRecovery(): void;
+}
+//#endregion
+//#region lib/runtime/providers.d.ts
+interface InternalPluginPreferences {
+  enabled(plugin: string, fallback: boolean): Promise<boolean>;
+  setEnabled(plugin: string, enabled: boolean): Promise<void>;
+}
+declare class LocalInternalPluginPreferences implements InternalPluginPreferences {
+  private readonly storage;
+  private readonly prefix;
+  constructor(storage?: Storage | undefined, prefix?: string);
+  enabled(plugin: string, fallback: boolean): Promise<boolean>;
+  setEnabled(plugin: string, enabled: boolean): Promise<void>;
+}
+declare class InternalPluginCandidateProvider implements PluginCandidateProvider {
+  private readonly definitions;
+  private readonly preferences;
+  readonly id = "internal";
+  constructor(definitions: readonly InternalPluginDefinition[], preferences?: InternalPluginPreferences);
+  list(signal: AbortSignal): Promise<PluginCandidate[]>;
+}
+declare class CompositePluginCandidateProvider implements PluginCandidateProvider {
+  private readonly providers;
+  readonly id = "composite";
+  constructor(providers: readonly PluginCandidateProvider[]);
+  list(signal: AbortSignal): Promise<PluginCandidate[]>;
+}
+//#endregion
+//#region lib/composition.d.ts
+declare const pluginContributions: ContributionHub;
+declare const pluginStore: PluginStore;
+declare const pluginConfigStore: ConfigStore;
+declare const useConfig: () => ConfigStore;
+interface PluginHostServices {
+  readonly auth?: PluginAuthGateway;
+}
+/** Install host-only integrations without exposing UI or platform details to the runtime kernel. */
+declare const configurePluginHost: (services: PluginHostServices) => void;
+declare const pluginCatalog: PluginCatalog;
+declare const pluginInstaller: PluginInstallService;
+declare const pluginRuntime: PluginRuntime;
+declare const installPlugin: (input: File | string) => Promise<{
+  installerName: string;
+  loaderName: string;
+  pluginName: string;
+  meta: import("@delta-comic/model").PluginManifest;
+  enable: boolean;
+  installInput: string;
+  displayName: string;
+}>;
+declare const updatePlugin: (archive: {
+  installInput: string;
+}) => Promise<{
+  installerName: string;
+  loaderName: string;
+  pluginName: string;
+  meta: import("@delta-comic/model").PluginManifest;
+  enable: boolean;
+  installInput: string;
+  displayName: string;
+}>;
+declare const updatePluginByName: (plugin: string) => Promise<{
+  installerName: string;
+  loaderName: string;
+  pluginName: string;
+  meta: import("@delta-comic/model").PluginManifest;
+  enable: boolean;
+  installInput: string;
+  displayName: string;
+}>;
+declare const setPluginEnabled: (plugin: string, enabled: boolean) => Promise<void>;
+declare const setPluginKind: (plugin: string, kind: "normal" | "preboot") => Promise<void>;
+declare const uninstallPlugin: (plugin: string) => Promise<void>;
+declare const resolvePluginIconUrl: (plugin: string | undefined, icon: string | undefined) => Promise<string | undefined>;
+declare const usePluginStore: () => PluginStore;
+//#endregion
+//#region lib/core/config.d.ts
+declare const cfg: ConfigPointer<{
+  recordHistory: {
+    type: "switch";
+    defaultValue: true;
+    info: string;
+  };
+  showAIProject: {
+    type: "switch";
+    defaultValue: true;
+    info: string;
+  };
+  darkMode: {
+    type: "radio";
+    defaultValue: string;
+    info: string;
+    comp: "select";
+    selects: {
+      label: string;
+      value: string;
+    }[];
+  };
+  language: {
+    type: "radio";
+    defaultValue: string;
+    info: string;
+    comp: "select";
+    selects: {
+      label: string;
+      value: string;
+    }[];
+  };
+  easilyTitle: {
+    type: "switch";
+    defaultValue: false;
+    info: string;
+  };
+  githubToken: {
+    type: "string";
+    defaultValue: string;
+    info: string;
+    placeholder: string;
+  };
+  receivePerReleaseUpdate: {
+    type: "switch";
+    defaultValue: false;
+    info: string;
+  };
+  cloudEnabled: {
+    type: "switch";
+    defaultValue: false;
+    info: string;
+  };
+  cloudServerUrl: {
+    type: "string";
+    defaultValue: string;
+    info: string;
+    placeholder: string;
+  };
+  installOverride: {
+    type: "pairs";
+    defaultValue: [];
+    info: string;
+    required: true;
+  };
+}>;
+declare namespace index_d_exports {
+  export { cfg, _default as default };
+}
+declare const _default: PluginConfigFactory<{
+  config: ConfigPointer<{
     recordHistory: {
       type: "switch";
       defaultValue: true;
@@ -448,480 +1108,17 @@ declare class ConfigStore {
       info: string;
       required: true;
     };
-  }>>;
-  $isExistConfig(pointer: ConfigPointer): boolean;
-  $registerConfig<T extends ConfigPointer>(pointer: T): ConfigSave<ConfigPointer<ConfigDescription>>;
-  $unregisterConfig(pointer: ConfigPointer): void;
-}
-declare const useConfig: () => ConfigStore;
-//#endregion
-//#region lib/depends.d.ts
-interface DependDefineConstraint<_T> {}
-type DependDefine<T> = symbol & DependDefineConstraint<T> & {
-  _ts: T;
-};
-declare const exposeSymbol: (name: string) => symbol;
-declare const declareDepType: <T>(name: string) => DependDefine<T>;
-declare class DependencyRegistry {
-  readonly exposes: Map<symbol, unknown>;
-  constructor(exposes?: Map<symbol, unknown>);
-  provide<T>(define: DependDefine<T>, value: T): T;
-  require<T>(define: DependDefine<T>): T;
-  has(define: DependDefine<unknown>): boolean;
-  delete(define: DependDefine<unknown>): boolean;
-  clear(): void;
-}
-type InferDependType<T extends DependDefine<any>> = T['_ts'];
-declare const pluginExposes: Map<symbol, unknown>;
-declare const defaultDependencyRegistry: DependencyRegistry;
-declare const createDependencyRegistry: () => DependencyRegistry;
-declare const provide: <T>(define: DependDefine<T>, value: T) => T;
-declare const require: <T>(define: DependDefine<T>) => T;
-//#endregion
-//#region lib/global.d.ts
-declare class _Global {
-  share: import("vue").ShallowReactive<import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, key: string], InitiativeItem>>>;
-  shareToken: import("vue").ShallowReactive<import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, key: string], ShareToken>>>;
-  userActions: import("vue").ShallowReactive<import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, key: string], UserAction>>>;
-  subscribes: import("vue").ShallowReactive<import("vue").ShallowReactive<SourcedKeyMap<[plugin: string, key: string], Config$5>>>;
-  globalNodes: import("vue").ShallowReactive<Raw<Component>[]>;
-  private readonly globalNodeOwners;
-  private readonly registrationOwners;
-  /**
-   * Associates global registrations made by a plugin with that plugin. The runtime
-   * deliberately loads plugins serially while this ambient scope is active.
-   */
-  withRegistrationOwner<T>(plugin: string, action: () => Promise<T>): Promise<T>;
-  private get registrationOwner();
-  addGlobalNode(component: Raw<Component>, plugin?: string | undefined): Raw<Component>;
-  /** Removes only registrations owned by the requested plugin. */
-  removeOwnedRegistrations(plugin: string): void;
-  tabbar: import("vue").ShallowReactive<Map<string, Tabbar[]>>;
-  addTabbar(plugin: string, ...tabbar: Tabbar[]): void;
-  categories: import("vue").ShallowReactive<Map<string, Category[]>>;
-  addCategories(plugin: string, ...categories: Category[]): void;
-  barcode: import("vue").ShallowReactive<Map<string, Barcode[]>>;
-  addBarcode(plugin: string, ...barcode: Barcode[]): void;
-  hotSearch: import("vue").ShallowReactive<Map<string, HotSearchProvider[]>>;
-  addHotSearch(plugin: string, ...providers: HotSearchProvider[]): void;
-  levelboard: import("vue").ShallowReactive<Map<string, HotLevelboard[]>>;
-  addLevelboard(plugin: string, ...levelboard: HotLevelboard[]): void;
-  topButton: import("vue").ShallowReactive<Map<string, HotTopButton[]>>;
-  addTopButton(plugin: string, ...topButton: HotTopButton[]): void;
-  mainLists: import("vue").ShallowReactive<Map<string, HotMainList[]>>;
-  addMainList(plugin: string, ...mainLists: HotMainList[]): void;
-}
-declare const Global: _Global;
-//#endregion
-//#region lib/manifest.d.ts
-type PluginIconReference = {
-  type: 'local';
-  path: string;
-  fragment: string;
-} | {
-  type: 'remote';
-  url: string;
-};
-/**
- * Accepts a credential-free HTTP(S) URL or a safe path inside the plugin archive.
- * Query strings and fragments are kept for both forms.
- */
-declare const parsePluginIconReference: (value: unknown, path?: string) => PluginIconReference;
-declare class PluginManifestError extends Error {
-  constructor(message: string);
-}
-/**
- * Validates the exact manifest format emitted by the `deltaComic` Vite plugin.
- * The returned value is safe to use as the persisted plugin metadata shape.
- */
-declare const parsePluginManifest: (value: unknown) => PluginArchiveDB.Meta;
-declare const isPluginManifestCompatible: (manifest: PluginArchiveDB.Meta, coreVersion: string) => boolean;
-//#endregion
-//#region lib/marketplace/types.d.ts
-declare const AWESOME_REGISTRY_BASE_URL = "https://raw.githubusercontent.com/delta-comic/awesome-plugins/main/";
-declare const AWESOME_REGISTRY_INDEX_PATH = "registry/index.json";
-declare const AWESOME_REGISTRY_SCHEMA_VERSION: 1;
-interface AwesomeRegistryPageReference {
-  page: number;
-  items: number;
-  path: string;
-}
-interface AwesomeRegistryIndex {
-  schemaVersion: typeof AWESOME_REGISTRY_SCHEMA_VERSION;
-  pageSize: number;
-  totalItems: number;
-  totalPages: number;
-  pages: AwesomeRegistryPageReference[];
-}
-interface AwesomeRegistryPagination {
-  page: number;
-  pageSize: number;
-  totalItems: number;
-  totalPages: number;
-  previous: string | null;
-  next: string | null;
-}
-type AwesomePluginDownload = {
-  type: 'github';
-  repository: string;
-} | {
-  type: 'url';
-  url: string;
-};
-interface AwesomePluginRepository {
-  owner: string;
-  name: string;
-  url: string;
-  defaultBranch: string;
-  lastCommitAt: string;
-  readmeUrl?: string;
-}
-interface AwesomePluginRelease {
-  version: string;
-  url: string;
-  publishedAt: string;
-  manifestUrl: string | null;
-}
-interface AwesomePluginListing {
-  schemaVersion: typeof AWESOME_REGISTRY_SCHEMA_VERSION;
-  id: string;
-  authors: string[];
-  download: AwesomePluginDownload;
-  repository?: AwesomePluginRepository;
-  release?: AwesomePluginRelease;
-}
-interface AwesomeRegistryPage {
-  schemaVersion: typeof AWESOME_REGISTRY_SCHEMA_VERSION;
-  pagination: AwesomeRegistryPagination;
-  items: AwesomePluginListing[];
-}
-interface AwesomeRegistryResult<T> {
-  data: T;
-  cachedAt: string;
-  stale: boolean;
-}
-interface AwesomeMarketplaceEntry {
-  listing: AwesomePluginListing;
-  manifest?: PluginArchiveDB.Meta;
-  manifestError?: string;
-}
-interface MarketplaceStorage {
-  getItem(key: string): string | null;
-  removeItem(key: string): void;
-  setItem(key: string, value: string): void;
-}
-//#endregion
-//#region lib/marketplace/cache.d.ts
-declare class AwesomeRegistryCache {
-  private readonly storage?;
-  private readonly prefix;
-  constructor(storage?: MarketplaceStorage | undefined, prefix?: string);
-  readIndex(): {
-    cachedAt: string;
-    data: AwesomeRegistryIndex;
-  } | undefined;
-  writeIndex(data: AwesomeRegistryIndex): string;
-  readPage(path: string): {
-    cachedAt: string;
-    data: AwesomeRegistryPage;
-  } | undefined;
-  writePage(path: string, data: AwesomeRegistryPage): string;
-  private read;
-  private remove;
-  private write;
-}
-//#endregion
-//#region lib/marketplace/client.d.ts
-interface AwesomeRegistryClientOptions {
-  baseUrl?: string;
-  cache?: AwesomeRegistryCache;
-  requestJson?: (url: string) => Promise<unknown>;
-  storage?: MarketplaceStorage;
-}
-declare class AwesomeRegistryNetworkError extends Error {
-  readonly cause?: unknown;
-  constructor(message: string, cause?: unknown);
-}
-declare class AwesomeRegistryClient {
-  private readonly baseUrl;
-  private readonly cache;
-  private readonly requestJson;
-  constructor(options?: AwesomeRegistryClientOptions);
-  loadIndex(): Promise<AwesomeRegistryResult<AwesomeRegistryIndex>>;
-  loadPage(path: string): Promise<AwesomeRegistryResult<AwesomeRegistryPage>>;
-  findListing(id: string): Promise<AwesomePluginListing>;
-  loadManifest(listing: AwesomePluginListing): Promise<PluginArchiveDB.Meta | undefined>;
-  private load;
-}
-//#endregion
-//#region lib/marketplace/validation.d.ts
-declare class AwesomeRegistryValidationError extends Error {
-  constructor(message: string);
-}
-declare class AwesomeRegistryVersionError extends AwesomeRegistryValidationError {
-  readonly received: unknown;
-  constructor(received: unknown, path: string);
-}
-declare const parseAwesomeRegistryIndex: (value: unknown) => AwesomeRegistryIndex;
-declare const parseAwesomePluginListing: (value: unknown, field?: string) => AwesomePluginListing;
-declare const parseAwesomeRegistryPage: (value: unknown) => AwesomeRegistryPage;
-declare const assertAwesomeRegistryPagePath: (value: string) => string;
-//#endregion
-//#region lib/marketplace/index.d.ts
-declare const marketplaceDownloadToInstallInput: (download: AwesomePluginDownload) => string;
-declare const marketplaceListingInstallId: (listing: AwesomePluginListing) => string;
-declare const marketplaceListingSource: (listing: AwesomePluginListing) => string;
-//#endregion
-//#region lib/pluginIcon.d.ts
-/** Resolves persisted plugin icon metadata into a URL that an `<img>` can consume. */
-declare const resolvePluginIconUrl: (pluginId: string | undefined, icon: string | undefined) => Promise<string | undefined>;
-//#endregion
-//#region lib/driver/store.d.ts
-declare class PluginStore {
-  readonly plugins: import("vue").ShallowReactive<Map<string, Raw<PluginConfig>>>;
-  /** Plugins whose complete boot pipeline has completed successfully. */
-  readonly ready: import("vue").ShallowReactive<Set<string>>;
-  readonly revision: import("vue").ShallowRef<number, number>;
-  private readonly pluginNames;
-  /**
-   * Returns true only when every registered booter has completed successfully.
-   *
-   * `plugins.has()` intentionally is not used here: the config is inserted before
-   * the first booter runs and can therefore describe a partially initialized plugin.
-   */
-  $isLoaded(plugin: string): boolean;
-  /** Starts a new load generation and invalidates the previous readiness state. */
-  $markLoading(plugin: string): void;
-  /** Marks a plugin ready after all booters have completed. */
-  $markReady(plugin: string): void;
-  /** Removes all lifecycle state for a plugin. */
-  $markUnloaded(plugin: string): void;
-  $refreshI18nNames(): Promise<void>;
-  $getI18nName(key: string): string;
-  $upsertArchives(archives: PluginArchiveDB.Archive[]): Promise<void>;
-  $touch(): void;
-}
-declare const pluginStore: PluginStore;
-declare const usePluginStore: () => PluginStore;
-//#endregion
-//#region lib/driver/loadPlan.d.ts
-interface PluginDependencyMissing {
-  pluginName: string;
-  dependencyName: string;
-}
-interface PluginLoadPlan {
-  levels: PluginArchiveDB.Archive[][];
-  missing: PluginDependencyMissing[];
-  cycles: string[][];
-}
-declare const findCyclePaths: (plugins: PluginArchiveDB.Archive[]) => string[][];
-declare const planPluginLoadOrder: (plugins: PluginArchiveDB.Archive[]) => PluginLoadPlan;
-type PluginMessageTranslator = (key: string, params: Record<string, number | string>) => string;
-declare const formatPluginLoadPlanError: (plan: Pick<PluginLoadPlan, 'missing' | 'cycles'>, translate?: PluginMessageTranslator) => string;
-//#endregion
-//#region lib/driver/extensionTypes.d.ts
-interface PluginInstallerDescription {
-  title: string;
-  description: string;
-}
-declare abstract class PluginInstaller {
-  /**
-   * @returns string mean redirect
-   */
-  abstract download(input: string): Promise<File | string>;
-  /**
-   * @returns string mean redirect
-   */
-  abstract update(pluginMeta: PluginArchiveDB.Archive): Promise<File | string>;
-  /**
-   * @returns string mean redirect
-   */
-  abstract fetchPluginMetaFile(input: string): Promise<File | string>;
-  abstract isMatched(input: string): boolean;
-  abstract name: string;
-  abstract description: PluginInstallerDescription;
-}
-declare abstract class PluginLoader {
-  abstract name: string;
-  abstract load(pluginMeta: PluginArchiveDB.Archive): Promise<PluginConfigFactory | undefined>;
-  abstract install(file: File, context?: PluginLoaderInstallContext): Promise<PluginArchiveDB.Meta>;
-  abstract canInstall(file: File): boolean;
-  /** need full download */
-  abstract decodeMeta(file: File): Promise<PluginArchiveDB.Meta>;
-  /** no need full download */
-  abstract decodeMetaFile(file: File): Promise<PluginArchiveDB.Meta | string>;
-  abstract isMetaFile(file: File): boolean;
-}
-interface PluginLoaderInstallContext {
-  report: (progress: PluginLoaderInstallProgress) => void;
-}
-interface PluginLoaderInstallProgress {
-  description?: string;
-  progress?: number;
-}
-type PluginBooterSetMeta = (meta: Partial<{
-  description: string;
-  name: string;
-}> | string) => void;
-declare abstract class PluginBooter {
-  abstract name: string;
-  abstract call(cfg: PluginConfig, setMeta: PluginBooterSetMeta, env: Record<any, any>): Promise<any>;
-}
-declare namespace loader_d_exports {
-  export { BootConfigOptions, PluginBootRollback, PluginLoadingInfo, bootConfig, bootResolvedConfig, createPluginLoadingInfo, ensurePluginLoadingInfo, loadAllPlugins, loadPlugin, loadPluginConfig, loaders, markPluginLoadError };
-}
-declare const loaders: import("vue").ShallowReactive<PluginLoader[]>;
-type PluginBootRollback = (config: PluginConfig | undefined, expectedName: string | undefined) => Promise<void> | void;
-interface BootConfigOptions {
-  expectedName?: string;
-  rollback?: PluginBootRollback;
-}
-declare const createPluginLoadingInfo: () => PluginLoadingInfo;
-declare const ensurePluginLoadingInfo: (info: Ref<Record<string, PluginLoadingInfo>>, pluginName: string) => PluginLoadingInfo;
-declare const markPluginLoadError: (info: Ref<Record<string, PluginLoadingInfo>>, pluginName: string, error: unknown) => void;
-/** 解析 config factory 并启动插件；任何中途失败都保留原始错误并执行回滚。 */
-declare const bootConfig: (configFactory: PluginConfigFactory, info: Ref<Record<string, PluginLoadingInfo>>, options?: BootConfigOptions) => Promise<PluginConfig>;
-declare const bootResolvedConfig: (cfg: ReturnType<PluginConfigFactory>, info: Ref<Record<string, PluginLoadingInfo>>) => Promise<void>;
-declare const loadPluginConfig: (meta: PluginArchiveDB.Archive) => Promise<PluginConfigFactory | undefined>;
-declare const loadPlugin: (meta: PluginArchiveDB.Archive, info: Ref<Record<string, PluginLoadingInfo>>) => Promise<void>;
-type PluginLoadingInfo = {
-  steps: {
-    name: string;
-    description: string;
-  }[];
-  progress: {
-    errorReason?: string;
-    stepsIndex: number;
-    status: 'wait' | 'process' | 'error' | 'done';
-  };
-};
-declare const loadAllPlugins: () => Promise<PluginRuntimeOperation>;
-//#endregion
-//#region lib/driver/runtime.d.ts
-interface PrebootRecovery {
-  failedAt: number;
-  plugins: string[];
-  reason: string;
-}
-interface PluginRuntimeOperation {
-  operation: Promise<void>;
-  progress: Ref<Record<string, PluginLoadingInfo>>;
-}
-interface LoadNormalOptions {
-  pluginNames?: readonly string[];
-}
-declare class PluginRuntime {
-  private readonly active;
-  private readonly activePrebootNames;
-  private readonly prebootCleanups;
-  private readonly preparedPreboot;
-  private readonly startupPluginNames;
-  private readonly startupPrebootNames;
-  private builtInSynchronization?;
-  private enabledPrebootNames;
-  private normalOperation?;
-  private startupSnapshotReady;
-  private prebootActivated;
-  get activeNormalPluginNames(): string[];
-  loadNormal(options?: LoadNormalOptions): PluginRuntimeOperation;
-  reloadNormal(options?: LoadNormalOptions): PluginRuntimeOperation;
-  preparePreboot(app: App): Promise<{
-    reloadRequired: boolean;
-  }>;
-  activatePreboot(progress?: Ref<Record<string, PluginLoadingInfo>, Record<string, PluginLoadingInfo>>): Promise<{
-    reloadRequired: boolean;
   }>;
-  uninstall(pluginName: string): Promise<void>;
-  readRecovery(): PrebootRecovery | null;
-  clearRecovery(): void;
-  private trackNormalOperation;
-  private ensureBuiltInPlugins;
-  private captureStartupSnapshot;
-  private loadKind;
-  private unloadKind;
-  private unloadOne;
-  private failPreboot;
-}
-declare const pluginRuntime: PluginRuntime;
-//#endregion
-//#region lib/driver/runtimePlan.d.ts
-type ClientPluginKind = 'normal' | 'preboot';
-declare const pluginKind: (plugin: PluginArchiveDB.Archive) => ClientPluginKind;
-declare const selectPluginsForPhase: (plugins: PluginArchiveDB.Archive[], kind: ClientPluginKind, startupPrebootNames?: ReadonlySet<string>, activePrebootNames?: ReadonlySet<string>) => PluginArchiveDB.Archive[];
-declare const failedDependencies: (plugin: PluginArchiveDB.Archive, failedPluginNames: ReadonlySet<string>) => string[];
-declare const filterPluginsBySelection: (plugins: PluginArchiveDB.Archive[], pluginNames?: ReadonlySet<string>) => {
-  displayName: string;
-  enable: boolean;
-  installInput: string;
-  installerName: string;
-  loaderName: string;
-  meta: PluginArchiveDB.Meta;
-  pluginName: string;
-}[];
-//#endregion
-//#region lib/driver/builtIn.d.ts
-declare const BUILT_IN_PLUGIN_LOADER = "builtin";
-declare const isBuiltInPluginName: (pluginName: string) => boolean;
-declare const isBuiltInPlugin: (plugin: Pick<PluginArchiveDB.Archive, 'loaderName'>) => boolean;
-declare const builtInDefinitionToArchive: (definition: BuiltInPluginDefinition, enable?: boolean) => PluginArchiveDB.Archive;
-/** Mirrors compile-time definitions into the plugin catalog while preserving their enable state. */
-declare const synchronizeBuiltInPlugins: () => Promise<void>;
-//#endregion
-//#region lib/driver/extensions.d.ts
-interface NamedExtension {
   name: string;
-}
-interface RuntimeExtensionOptions {
-  order?: number;
-}
-declare class OrderedExtensionRegistry<T extends NamedExtension> {
-  private readonly direction;
-  readonly values: import("vue").ShallowReactive<T[]>;
-  private readonly entries;
-  private sequence;
-  constructor(direction: 'ascending' | 'descending');
-  register(extension: T, options?: RuntimeExtensionOptions, owner?: string): () => void;
-  removeOwner(owner: string): void;
-  private refresh;
-}
-declare class PluginRuntimeExtensions {
-  readonly booters: OrderedExtensionRegistry<PluginBooter>;
-  readonly installers: OrderedExtensionRegistry<PluginInstaller>;
-  readonly loaders: OrderedExtensionRegistry<PluginLoader>;
-  private readonly owners;
-  registerBooter(booter: PluginBooter, options?: RuntimeExtensionOptions): () => void;
-  registerInstaller(installer: PluginInstaller, options?: RuntimeExtensionOptions): () => void;
-  registerLoader(loader: PluginLoader, options?: RuntimeExtensionOptions): () => void;
-  removeOwner(owner: string): void;
-  withOwner<T>(owner: string, action: () => Promise<T>): Promise<T>;
-}
-declare const runtimeExtensions: PluginRuntimeExtensions;
-declare const registerBooter: (booter: PluginBooter, options?: RuntimeExtensionOptions) => () => void;
-declare const registerInstaller: (installer: PluginInstaller, options?: RuntimeExtensionOptions) => () => void;
-declare const registerLoader: (loader: PluginLoader, options?: RuntimeExtensionOptions) => () => void;
-declare namespace booter_d_exports {
-  export { bootPlugin, booters };
-}
-declare const booters: import("vue").ShallowReactive<PluginBooter[]>;
-declare const bootPlugin: (cfg: PluginConfig, info: Ref<Record<string, PluginLoadingInfo>>) => Promise<void>;
-declare namespace install_d_exports {
-  export { installDepends, installFilePlugin, installPlugin, installers, uninstallPlugin, updatePlugin };
-}
-declare const installers: import("vue").ShallowReactive<PluginInstaller[]>;
-declare const installDepends: (m: DownloadMessageBind, meta: PluginArchiveDB.Meta, installedPlugins?: Set<string>) => Promise<void>;
-declare const installPlugin: (input: string, __installedPlugins?: Set<string>) => Promise<void>;
-declare const installFilePlugin: (file: File, __installedPlugins?: Set<string>) => Promise<void>;
-declare const updatePlugin: (pluginMeta: PluginArchiveDB.Archive, __installedPlugins?: Set<string>) => Promise<void>;
-declare const uninstallPlugin: (pluginName: string) => Promise<void>;
-//#endregion
-//#region lib/index.d.ts
-declare module '@delta-comic/utils' {
-  interface SharedFunctions {
-    routeToContent(contentType_: UniContentType_, id: string, ep: string, preload?: UniItem): Promise<any>;
-    routeToSearch(input: string, source?: [plugin: string, name: string], sort?: string): Promise<any>;
-    pushShareToken(token: string): Promise<any>;
-  }
-}
+  model: {
+    social: {
+      share: {
+        initiative: InitiativeItem[];
+        tokenListen: ShareToken[];
+      };
+    };
+  };
+}>;
 //#endregion
-export { AWESOME_REGISTRY_BASE_URL, AWESOME_REGISTRY_INDEX_PATH, AWESOME_REGISTRY_SCHEMA_VERSION, type api_d_exports as Api, type auth_d_exports as Auth, AwesomeMarketplaceEntry, AwesomePluginDownload, AwesomePluginListing, AwesomePluginRelease, AwesomePluginRepository, AwesomeRegistryCache, AwesomeRegistryClient, AwesomeRegistryClientOptions, AwesomeRegistryIndex, AwesomeRegistryNetworkError, AwesomeRegistryPage, AwesomeRegistryPageReference, AwesomeRegistryPagination, AwesomeRegistryResult, AwesomeRegistryValidationError, AwesomeRegistryVersionError, BUILT_IN_PLUGIN_LOADER, booter_d_exports as Booter, BuiltInPluginDefinition, ClientPluginKind, ConfigDescription, ConfigEnv, ConfigPointer, ConfigSave, ConfigStore, type content_d_exports as Content, DefineResult, DependDefine, DependencyRegistry, Global, InferDependType, install_d_exports as Install, LoadNormalOptions, loader_d_exports as Loader, MarketplaceStorage, type otherProgress_d_exports as OtherProgress, Platform, PluginBooter, PluginBooterSetMeta, PluginConfig, PluginConfigFactory, PluginConfigHooks, PluginConfigValues, PluginDependencyMissing, PluginExpose, PluginI18nAdapter, PluginI18nRegistry, PluginIconReference, PluginInstaller, PluginInstallerDescription, PluginLoadPlan, PluginLoader, PluginLoaderInstallContext, PluginLoaderInstallProgress, type PluginLoadingInfo, PluginLocaleMessage, PluginLocaleMessages, PluginManifestError, PluginRuntimeExtensions, PluginRuntimeOperation, PluginStore, PrebootRecovery, type resource_d_exports as Resource, RuntimeExtensionOptions, type search_d_exports as Search, type share_d_exports as Share, type subscribe_d_exports as Subscribe, UnwrapConfigPointer, type user_d_exports as User, assertAwesomeRegistryPagePath, builtInDefinitionToArchive, createDependencyRegistry, declareDepType, defaultDependencyRegistry, defineInnerPlugin, definePlugin, exposeSymbol, failedDependencies, filterPluginsBySelection, findCyclePaths, formatPluginLoadPlanError, isBuiltInPlugin, isBuiltInPluginName, isPluginManifestCompatible, marketplaceDownloadToInstallInput, marketplaceListingInstallId, marketplaceListingSource, parseAwesomePluginListing, parseAwesomeRegistryIndex, parseAwesomeRegistryPage, parsePluginIconReference, parsePluginManifest, planPluginLoadOrder, pluginExposes, pluginI18n, pluginKind, pluginMessageKey, pluginRuntime, pluginStore, provide, registerBooter, registerInstaller, registerLoader, require, resolvePluginIconUrl, runtimeExtensions, selectPluginsForPhase, synchronizeBuiltInPlugins, translatePluginText, useConfig, usePluginStore };
+export { type ActionPageItem, ActivationContext, ActivationPipeline, ActivationStepUpdate, type Auth, type AutoCompleteProvider, type Barcode, type CallbackResult, CapabilityDefinition, CapabilityModule, type Category, CompositePluginCandidateProvider, ConfigDescription, ConfigEnv, ConfigPointer, content_d_exports as Content, type ContentHooks, type ContentModel, Contribution, ContributionChannel, ContributionHub, ContributionRegistry, index_d_exports as Core, DCPluginConfig, DELTA_COMIC_PLUGIN_API_VERSION, DatabasePluginArchiveRepository, DecodedPluginPackage, type Definition, DevScriptCodec, expose_d_exports as Expose, type ExposeModel, type Favourites, GitHubSourceResolver, GitHubSourceResolverOptions, type HotCategory, type HotLevelboard, type HotPageContent, type HotSearchProvider, type HotTopButton, HttpSourceResolver, type InitiativeItem, type InjectCode, InstalledPluginCandidateProvider, InternalPluginCandidateProvider, InternalPluginDefinition, InternalPluginPreferences, type ItemProvider, type LifecycleHooks, LoadNormalOptions, LoadedPluginModule, LocalFileSourceResolver, LocalInternalPluginPreferences, MarketplaceSourceResolver, type Method, MissingPluginDependency, type Model, Platform, PluginArchiveRepository, PluginAuthGateway, PluginCandidate, PluginCandidateProvider, PluginCapabilityServices, PluginCatalog, PluginCatalogIndex, PluginCatalogListing, PluginCatalogPage, PluginCatalogPageReference, PluginCatalogPagination, PluginCatalogRelease, PluginCatalogRepository, PluginCatalogResult, PluginCatalogSource, PluginConfigFactory, type PluginConfigHooks, type PluginConfigModel, PluginConfigRegistry, PluginDependencyPlan, PluginDisposer, PluginFileReplacement, PluginFileStore, PluginHostServices, type PluginI18nAdapter, PluginInstallCatalog, PluginInstallInput, PluginInstallProgress, PluginInstallReporter, PluginInstallService, PluginInstallServiceOptions, type PluginLifecycleCleanup, PluginLoadingInfo, PluginLocaleMessage, PluginLocaleMessages, PluginManagementCapabilities, type PluginManifest, PluginManifestError, PluginMessageRegistry, PluginModuleReader, PluginOrigin, PluginPackageCodec, PluginRuntime, PluginRuntimeFailure, PluginRuntimeOperation, PluginRuntimeOptions, PluginRuntimeReport, PluginScope, PluginSourceResolver, PluginStore, PrebootRecovery, type Promotes, RegisteredPluginConfig, remote_d_exports as Remote, type RemoteHooks, type RemoteModel, RemoteSelection, ResolvedPluginSource, resource_d_exports as Resource, type ResourceModel, type Search, type SearchAim, type SearchMethod, type Selection, type Share, type SharePopupConfig, type ShareToken, social_d_exports as Social, type SocialHooks, type SocialModel, special_d_exports as Special, type SpecialModel, type Step, StoredPluginModuleReader, type Subscribe, type SubscribeListProvider, type Tabbar, type TestFunction, type TestGroup, UnwrapConfigPointer, user_d_exports as User, type UserAction, type UserActionPage, type UserModel, ZipPackageCodec, configurePluginHost, createAuthCapability, createConfigCapability, createContentCapability, createDefaultCapabilities, createI18nCapability, createLifecycleCapability, createModelCapability, createRemoteCapability, createResourceCapability, createSpecialCapability, createUserCapability, defineCapability, defineContributionChannel, defineDeltaComicPlugin, defineInternalPlugin, findPluginDependencyCycles, installPlugin, isPluginManifestCompatible, parsePluginManifest, planPluginDependencies, pluginCatalog, pluginCatalogIdFromInstallInput, pluginCatalogInstallInput, pluginConfigStore, pluginContributions, pluginI18n, pluginInstaller, pluginMessageKey, pluginModelChannels, pluginRemoteSelectionChannel, pluginRuntime, pluginStore, resolvePluginIconUrl, safePluginPath, setPluginEnabled, setPluginKind, translatePluginText, uninstallPlugin, updatePlugin, updatePluginByName, useConfig, usePluginStore };
 //# sourceMappingURL=index.d.mts.map