@delta-comic/plugin 2.1.0 → 3.0.0-next.4

package/dist/lib/index.d.mts

@@ -0,0 +1,927 @@
+import { PluginArchiveDB } from "@delta-comic/db";
+import { App, Component, MaybeRefOrGetter, Raw, Ref } from "vue";
+import { FormConfigure, FormResult, FormSingleConfigure, FormSingleResult, SourcedKeyMap, StreamQuery, uni } from "@delta-comic/model";
+import { DownloadMessageBind } from "@delta-comic/ui";
+
+//#region lib/configPointer.d.ts
+type ConfigDescription = Record<string, Required<Pick<FormSingleConfigure, 'defaultValue'>> & FormSingleConfigure>;
+declare class ConfigPointer<T extends ConfigDescription = ConfigDescription> {
+  pluginName: string;
+  config: T;
+  configName: string;
+  readonly key: symbol;
+  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;
+}
+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 };
+}
+interface Config$7 {
+  initiative: InitiativeItem[];
+  tokenListen: ShareToken[];
+}
+interface ShareToken {
+  key: string;
+  name: string;
+  patten(chipboard: string): boolean;
+  show(chipboard: string): Promise<PopupConfig> | PopupConfig;
+}
+interface PopupConfig {
+  title: string;
+  detail: string;
+  onPositive(): void;
+  onNegative(): void;
+}
+interface InitiativeItem {
+  key: string;
+  name: string;
+  icon: Component | uni.image.Image;
+  bgColor?: string;
+  call(page: uni.content.ContentPage): Promise<{
+    token?: string;
+  } | void>;
+  filter(page: uni.content.ContentPage): boolean;
+}
+declare namespace content_d_exports {
+  export { Config$6 as Config };
+}
+type Config$6 = Record<string, {
+  itemCard?: uni.item.ItemCardComponent;
+  commentRow?: uni.comment.CommentRow;
+  layout?: uni.content.LayoutComponent;
+  contentPage?: uni.content.ContentPageLike;
+  downloadProvider?: uni.download.ContentDownloadProvider;
+  itemTranslator?: uni.item.ItemTranslator;
+}>;
+declare namespace subscribe_d_exports {
+  export { Config$5 as Config };
+}
+interface Config$5 {
+  getUpdateList(olds: {
+    author: uni.item.Author;
+    list: uni.item.Item[];
+  }[], signal: AbortSignal): PromiseLike<{
+    isUpdated: boolean;
+    whichUpdated: uni.item.Author[];
+  }>;
+  onAdd?(author: uni.item.Author): any;
+  onRemove?(author: uni.item.Author): any;
+  fetchAuthorContent: StreamQuery<uni.item.Item, {
+    author: uni.item.Author;
+  }>;
+}
+declare namespace user_d_exports {
+  export { ActionPageItem, Config$4 as Config, UserAction, UserActionPage };
+}
+interface Config$4 {
+  edit?: Component;
+  card?: uni.user.UserCardComponent;
+  authorIcon?: Record<string, Component>;
+  /**
+   * 1. download
+   * 2. upload (收藏那些云端未收藏的漫画)
+   */
+  syncFavourite?: {
+    download: () => PromiseLike<uni.item.Item[]>;
+    upload: (items: uni.item.RawItem[]) => PromiseLike<any>;
+  };
+  /**
+   * 你希望展示的(`userActions`)自己的板块的页面
+   */
+  userActionPages?: UserActionPage[];
+  /**
+   * 在用户界面，在历史记录那个板块的下方，你希望展示的自己的板块
+   */
+  userActions?: Record<string, UserAction>;
+}
+interface UserAction {
+  call(author: uni.item.Author): any;
+  name: string;
+  icon?: Component;
+}
+interface UserActionPage {
+  title?: string;
+  items: ActionPageItem[];
+  clickPage?: Component;
+  clickText?: string;
+}
+type ActionPageItem = {
+  name: string;
+  key: string;
+  type: 'button';
+  icon: Component;
+  page: Component;
+} | {
+  name: string;
+  key: string;
+  type: 'statistic';
+  icon?: Component;
+  value: MaybeRefOrGetter<string | number>;
+};
+declare namespace api_d_exports {
+  export { Config$3 as Config };
+}
+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;
+}
+interface OtherProgressRunnerOptions {
+  onBackgroundError?: (error: AggregateError) => void;
+  setMeta: (meta: {
+    description: string;
+    name: string;
+  }) => void;
+}
+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 Config$1 {
+  /**
+   * @description
+   * key: id
+   */
+  methods?: Record<string, SearchMethod>;
+  tabbar?: Tabbar[];
+  categories?: Category[];
+  hotPage?: {
+    levelBoard?: HotLevelboard[];
+    topButton?: HotTopButton[];
+    mainListCard?: HotMainList[];
+  };
+  barcode?: Barcode[];
+  /** Search landing-page sections supplied by this plugin. */
+  hotSearch?: HotSearchProvider[];
+  fetchRandomItems?: ItemProvider;
+}
+type ItemProvider = (signal: AbortSignal) => uni.item.Item[] | PromiseLike<uni.item.Item[]>;
+interface SearchMethod {
+  name: string;
+  sorts: {
+    text: string;
+    value: string;
+  }[];
+  defaultSort: string;
+  fetchSearchResult: StreamQuery<uni.item.Item, {
+    input: string;
+    sort: string;
+  }>;
+  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;
+}
+interface HotSearchProvider {
+  title: string;
+  target: HotSearchTarget;
+  fetchItems(signal: AbortSignal): PromiseLike<HotSearchItem[]> | HotSearchItem[];
+}
+interface HotLevelboard {
+  name: string;
+  content: ItemProvider;
+}
+interface HotMainList {
+  name: string;
+  content: ItemProvider;
+  onClick?(): any;
+}
+interface HotTopButton {
+  name: string;
+  icon: Component;
+  bgColor: string;
+  onClick?(): any;
+}
+interface Category {
+  title: string;
+  namespace: string;
+  search: {
+    methodId: string;
+    input: string;
+    sort: string;
+  };
+}
+interface Tabbar {
+  title: string;
+  id: string;
+  comp: Component<{
+    isActive: boolean;
+    tabbar: Tabbar;
+  }>;
+}
+type RouteToContent = (contentType_: uni.content.ContentType_, id: string, ep: string, preload?: uni.item.Item) => PromiseLike<any>;
+interface Barcode {
+  match: (searchText: string) => boolean;
+  /**
+   * 选中后返回路由信息
+   */
+  getContent: (searchText: string, signal: AbortSignal) => PromiseLike<Parameters<RouteToContent>>;
+  name: string;
+}
+declare namespace auth_d_exports {
+  export { CallbackResult, Config, InjectCode, Method };
+}
+interface Config {
+  signUp: (by: Method) => PromiseLike<any>;
+  logIn: (by: Method) => PromiseLike<any>;
+  passSelect: () => PromiseLike<'signUp' | 'logIn' | false>;
+}
+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;
+}
+declare namespace resource_d_exports {
+  export { Content };
+}
+interface Content {
+  process?: Record<string, uni.resource.ProcessInstance>;
+  types?: uni.resource.ResourceType[];
+}
+//#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;
+}
+type DefineResult = {
+  api?: Record<string, string | undefined | false>;
+};
+type Platform = 'tauri' | 'web';
+interface PluginConfigHooks {
+  /** 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;
+  /** 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;
+}
+/**
+ * 这仅是个辅助定义的函数，没有副作用
+ */
+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 ConfigSave<T> = {
+  form: ConfigDescription;
+  data: Ref<T>;
+  name: string;
+  ready: Promise<void>;
+};
+declare class ConfigStore {
+  readonly form: import("vue").ShallowReactive<Map<symbol, ConfigSave<any>>>;
+  private readonly darkMode;
+  private readonly isSystemDark;
+  get isDark(): boolean;
+  constructor();
+  $load<T extends ConfigPointer>(pointer: T): ConfigSave<FormResult<T['config']>>;
+  $loadApp(): ConfigSave<FormResult<{
+    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;
+    };
+  }>>;
+  $isExistConfig(pointer: ConfigPointer): boolean;
+  $registerConfig(pointer: ConfigPointer): ConfigSave<any>;
+  /** @deprecated Use `$registerConfig`. */
+  $resignerConfig(pointer: ConfigPointer): ConfigSave<any>;
+  $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_: uni.content.ContentType_, id: string, ep: string, preload?: uni.item.Item): Promise<any>;
+    routeToSearch(input: string, source?: [plugin: string, name: string], sort?: string): Promise<any>;
+    pushShareToken(token: string): Promise<any>;
+  }
+}
+//#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, 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 };
+//# sourceMappingURL=index.d.mts.map