@hesprs/sync-engine-sdk 3.0.0

package/dist/packages/plugin/src/modules/Bootstrap.d.ts

@@ -0,0 +1,85 @@
+import { Stat as Stat$1, TogglableValue } from "../types.js";
+import { BatchOptimizer } from "../fs/interface.js";
+import { DatabaseSync } from "../../../../node_modules/.bun/uni-kv@.._.._uni-kv.tgz/node_modules/uni-kv/dist/interface.js";
+import { Dispatch, On } from "./EventBus.js";
+import { ObsidianLanguageCode, Translate, TranslationResource } from "./I18n.js";
+import { FileTreeTranslations } from "../components/file-tree/index.js";
+import { HeadersEditorTranslations } from "../components/HeadersEditorModal.js";
+import { ModuleEditorTranslations } from "../components/ModuleEditorModal.js";
+import { UnknownModuleTranslations } from "../components/UnknownModuleModal.js";
+import { ControlsSettingTranslations } from "../settings/controls.js";
+import { DevelopmentSettingTranslations } from "../settings/development.js";
+import { FeaturesSettingTranslations } from "../settings/features.js";
+import { FilterSettingTranslations } from "../settings/filter.js";
+import { HeadSettingTranslations } from "../settings/head.js";
+import { MiscellaneousSettingTranslations } from "../settings/miscellaneous.js";
+import { Events, Translations } from "../index.js";
+import { ConflictResolverEntry, DeciderEntry, FsWrapperEntry, LocalRequestMiddlewareEntry, OptimizerEntry, RemoteFsEntry, RemoteListerEntry, RemoteRequestMiddlewareEntry, SettingEntry } from "./Registrar.js";
+import "../fs/index.js";
+import { App } from "obsidian";
+//#region src/modules/Bootstrap.d.ts
+type CustomHeaders = Array<{
+  type: 'plaintext' | 'secret';
+  value: string;
+  key: string;
+}>;
+type ExistingMemoryDB = DatabaseSync<{
+  localContext20000: Stat$1;
+  remoteContext10000: Stat$1;
+  remoteContext20000: Stat$1;
+}, {
+  localContext20000Marker: string;
+  remoteContext10000Marker: string;
+  remoteContext20000Marker: string;
+}>;
+declare class Bootstrap {
+  private readonly ctx;
+  private readonly cleanupCallbacks;
+  private readonly memoryStates;
+  private isCancelled?;
+  private readonly localPool;
+  private readonly remotePool;
+  private localFs?;
+  private remoteFs?;
+  readonly i18n: {
+    bidirectional: string;
+    latestSurvive: string;
+    keepLocal: string;
+    keepRemote: string;
+    renameAndKeepBoth: string;
+    skip: string;
+  } & ControlsSettingTranslations & DevelopmentSettingTranslations & FeaturesSettingTranslations & FilterSettingTranslations & HeadSettingTranslations & MiscellaneousSettingTranslations & HeadersEditorTranslations & UnknownModuleTranslations & ModuleEditorTranslations & FileTreeTranslations;
+  readonly settings: {
+    maxMemoryConsumption: TogglableValue;
+    maxRequestConcurrency: TogglableValue;
+    minRequestInterval: TogglableValue;
+    realtimeSyncFastMode: boolean;
+    asymmetricStorage: boolean;
+    customHeaders: CustomHeaders;
+  };
+  constructor(ctx: {
+    app: App;
+    registerI18n: (code: ObsidianLanguageCode, resource: TranslationResource) => void;
+    on: On<Events>;
+    dispatch: Dispatch<Events>;
+    memoryDB: ExistingMemoryDB;
+    registerDecider: (id: string, entry: DeciderEntry) => void;
+    registerLocalFsWrapper: (entry: FsWrapperEntry) => void;
+    registerRemoteFs: (id: string, entry: RemoteFsEntry) => void;
+    registerRemoteFsWrapper: (entry: FsWrapperEntry) => void;
+    translate: Translate<Translations>;
+    optimizeLocal: BatchOptimizer;
+    optimizeRemote: BatchOptimizer;
+    registerLocalOptimizer: (optimizer: OptimizerEntry) => void;
+    registerRemoteOptimizer: (optimizer: OptimizerEntry) => void;
+    registerRemoteLister: (entry: RemoteListerEntry) => () => boolean;
+    registerSetting: (entry: SettingEntry) => () => boolean;
+    registerConflictResolver: (id: string, entry: ConflictResolverEntry) => void;
+    registerRemoteRequestMiddleware: (entry: RemoteRequestMiddlewareEntry) => void;
+    registerLocalRequestMiddleware: (entry: LocalRequestMiddlewareEntry) => void;
+  });
+  readonly start: () => void;
+  readonly dispose: () => void;
+}
+//#endregion
+export { CustomHeaders, ExistingMemoryDB, Bootstrap as default };

package/dist/packages/plugin/src/modules/EventBus.d.ts

@@ -0,0 +1,35 @@
+import { General } from "../../test/e2e-utils.js";
+import "../types.js";
+import { Ref } from "../../../../node_modules/.bun/synthkernel@._synthkernel.tgz/node_modules/synthkernel/dist/reactive.js";
+//#region src/modules/EventBus.d.ts
+type Dispatch<O extends object> = <K extends keyof O>(...[key, payload]: undefined extends O[K] ? [K] : [K, O[K]]) => void;
+type On<O extends object> = <K extends keyof O>(key: K, callback: (payload: O[K]) => void) => () => void;
+declare class EventBus {
+  readonly events: {
+    logSync: string;
+    logGeneral: string;
+    errorSync: string;
+    errorGeneral: string;
+  };
+  private readonly cleanupCallbacks;
+  private readonly isIdle;
+  private readonly syncLogs;
+  private readonly generalLogs;
+  constructor();
+  private readonly getThisSync;
+  private readonly putSyncLog;
+  private readonly putGeneralLog;
+  private readonly subscribers;
+  private readonly on;
+  private readonly dispatch;
+  private readonly getLogs;
+  readonly dispose: () => void;
+  readonly root: {
+    dispatch: Dispatch<General>;
+    getLogs: () => string;
+    isIdle: Ref<boolean>;
+    on: On<General>;
+  };
+}
+//#endregion
+export { Dispatch, On, EventBus as default };

package/dist/packages/plugin/src/modules/Extensibility.d.ts

@@ -0,0 +1,96 @@
+import { General } from "../../test/e2e-utils.js";
+import "../types.js";
+import { DatabaseAsync } from "../../../../node_modules/.bun/uni-kv@.._.._uni-kv.tgz/node_modules/uni-kv/dist/interface.js";
+import { Ref } from "../../../../node_modules/.bun/synthkernel@._synthkernel.tgz/node_modules/synthkernel/dist/reactive.js";
+import { Dispatch } from "./EventBus.js";
+import { Translate } from "./I18n.js";
+import "../../../../index.js";
+import { Context, Events, Translations } from "../index.js";
+import { App } from "obsidian";
+//#region src/modules/Extensibility.d.ts
+type ModuleInstance = {
+  moduleSettings: object;
+  dispose?: () => void;
+  start?: () => void;
+};
+type ModuleCtor = new (ctx: object) => ModuleInstance;
+type ModuleMeta = {
+  id: string;
+  name: string;
+  version: string;
+  description: string;
+  main: string;
+  icon?: string;
+  minPluginVersion?: string;
+  integrity: string;
+};
+type AugmentedModuleMeta = ModuleMeta & {
+  enabled: boolean;
+  source: string;
+  icon: string;
+};
+declare class Extensibility {
+  private readonly ctx;
+  private readonly moduleDir;
+  private readonly sourceCache;
+  private readonly discoveredModules;
+  private readonly loadedModules;
+  private readonly moduleStore;
+  private autoUpdateTimeout?;
+  readonly settings: {
+    moduleSources: Array<string>;
+    moduleAutoUpdate: boolean;
+    modules: Record<string, object>;
+  };
+  readonly i18n: {
+    failedToLoadModule: string;
+    failedToDownloadModule: string;
+    failedToFetchSource: string;
+  };
+  readonly events: {
+    moduleLoaded: string;
+    moduleUnloaded: string;
+  };
+  constructor(ctx: {
+    app: App;
+    __addModule__: Context['__addModule__'];
+    __getModule__: Context['__getModule__'];
+    dispatch: Dispatch<Events>;
+    translate: Translate<Translations>;
+    allModules: Set<General>;
+    isIdle: Ref<boolean>;
+    saveSettings: () => Promise<void>;
+    indexedDB: DatabaseAsync<Record<string, AugmentedModuleMeta>>;
+  });
+  readonly start: () => void;
+  private readonly createOperationFactory;
+  private readonly loadAllModules;
+  private readonly loadModule;
+  private readonly unloadModule;
+  private readonly downloadModule;
+  private readonly deleteModule;
+  private readonly fetchSources;
+  private readonly updateModules;
+  private readonly updateModuleMeta;
+  private readonly enableModule;
+  private readonly disableModule;
+  private readonly getModulePath;
+  private readonly parseModulePath;
+  readonly dispose: () => void;
+  readonly root: {
+    deleteModule: (id: string) => Promise<void>;
+    disableModule: (id: string) => void;
+    discoveredModules: Map<string, AugmentedModuleMeta>;
+    downloadModule: (meta: AugmentedModuleMeta, waitIdle?: boolean) => Promise<void>;
+    enableModule: (id: string) => Promise<void>;
+    fetchSources: (manual?: boolean) => Promise<AugmentedModuleMeta[]>;
+    loadAllModules: () => Promise<void>;
+    loadModule: (meta: AugmentedModuleMeta, start?: boolean, module?: string) => Promise<void>;
+    loadedModules: Map<string, ModuleCtor>;
+    unloadModule: (id: string) => void;
+    updateModuleMeta: (meta: AugmentedModuleMeta) => Promise<void>;
+    updateModules: () => Promise<void>;
+  };
+}
+//#endregion
+export { AugmentedModuleMeta, ModuleCtor, ModuleInstance, ModuleMeta, Extensibility as default };

package/dist/packages/plugin/src/modules/I18n.d.ts

@@ -0,0 +1,22 @@
+import { General } from "../../test/e2e-utils.js";
+import "../types.js";
+//#region src/modules/I18n.d.ts
+type ObsidianLanguageCode = 'en' | 'af' | 'am' | 'ar' | 'az' | 'be' | 'bg' | 'bn' | 'ca' | 'cs' | 'da' | 'de' | 'dv' | 'el' | 'en-GB' | 'eo' | 'es' | 'eu' | 'fa' | 'fi' | 'fr' | 'ga' | 'gl' | 'he' | 'hi' | 'hr' | 'hu' | 'id' | 'it' | 'ja' | 'ka' | 'kh' | 'kn' | 'ko' | 'ky' | 'la' | 'lt' | 'lv' | 'ml' | 'ms' | 'nan-TW' | 'ne' | 'nl' | 'nn' | 'no' | 'oc' | 'or' | 'pl' | 'pt' | 'pt-BR' | 'ro' | 'ru' | 'sa' | 'si' | 'sk' | 'sl' | 'sq' | 'sr' | 'sv' | 'sw' | 'ta' | 'te' | 'th' | 'tl' | 'tr' | 'tt' | 'uk' | 'ur' | 'uz' | 'vi' | 'zh' | 'zh-TW';
+type Primitive = string | number | boolean | null | undefined;
+type Fragment<A = undefined> = (frag: DocumentFragment, args: A) => void;
+type TranslationResource = Record<string, string | Fragment<General>>;
+type InterpolationValues = Record<string, Primitive>;
+type TranslateParams<R extends Fragment<General> | string> = R extends Fragment<infer A> ? ([undefined] extends [A] ? [] : [A]) : [] | [InterpolationValues];
+type Translate<O extends TranslationResource> = <K extends keyof O>(key: K, ...args: TranslateParams<O[K]>) => O[K] extends string ? string : DocumentFragment;
+declare class I18n {
+  private readonly targetLangs;
+  readonly i18n: {};
+  private readonly registerI18n;
+  private readonly translate;
+  root: {
+    registerI18n: (code: ObsidianLanguageCode, resource: TranslationResource) => void;
+    translate: Translate<General>;
+  };
+}
+//#endregion
+export { Fragment, InterpolationValues, ObsidianLanguageCode, Translate, TranslationResource, I18n as default };

package/dist/packages/plugin/src/modules/ModulesModal.d.ts

@@ -0,0 +1,49 @@
+import { Translate } from "./I18n.js";
+import { AugmentedModuleMeta } from "./Extensibility.js";
+import { ModuleManagementTranslations } from "../components/module-management/index.js";
+import { SourceEditorTranslations } from "../components/SourceEditorModal.js";
+import { App, Modal } from "obsidian";
+//#region src/modules/ModulesModal.d.ts
+type ModulesModalTranslations = ModuleManagementTranslations & SourceEditorTranslations & {
+  searchModules: string;
+  editSources: string;
+  moduleManagement: string;
+  showInstalledOnly: string;
+  configurations: string;
+};
+declare class ModulesModal extends Modal {
+  private readonly ctx;
+  private readonly t;
+  private readonly modalCleanup;
+  private sourceEditorModal?;
+  private showInstalledOnly;
+  constructor(ctx: {
+    app: App;
+    translate: Translate<ModulesModalTranslations>;
+    saveSettings: () => Promise<void>;
+    fetchSources: (manual?: boolean) => Promise<Array<AugmentedModuleMeta>>;
+    discoveredModules: Map<string, AugmentedModuleMeta>;
+    loadedModules: Map<string, unknown>;
+    downloadModule: (meta: AugmentedModuleMeta) => Promise<void>;
+    deleteModule: (id: string) => Promise<void>;
+    loadModule: (meta: AugmentedModuleMeta, start?: boolean) => Promise<void>;
+    unloadModule: (id: string) => void;
+    enableModule: (id: string) => Promise<void>;
+    disableModule: (id: string) => void;
+    updateModuleMeta: (meta: AugmentedModuleMeta) => Promise<void>;
+  });
+  readonly i18n: ModulesModalTranslations;
+  readonly settings: {
+    moduleSources: Array<string>;
+  };
+  root: {
+    closeModuleManagement: () => void;
+    openModuleManagement: () => void;
+  };
+  onOpen(): void;
+  onClose(): void;
+  private readonly openSourceEditorModal;
+  dispose(): void;
+}
+//#endregion
+export { ModulesModal as default };

package/dist/packages/plugin/src/modules/Observability.d.ts

@@ -0,0 +1,58 @@
+import { Progress } from "../types.js";
+import { Ref } from "../../../../node_modules/.bun/synthkernel@._synthkernel.tgz/node_modules/synthkernel/dist/reactive.js";
+import { Dispatch, On } from "./EventBus.js";
+import { Translate } from "./I18n.js";
+import { SyncTerminateReason, TaskInfo } from "./Sync.js";
+import { Events, Translations } from "../index.js";
+import { App, Command, IconName } from "obsidian";
+//#region src/modules/Observability.d.ts
+type SyncStage = 'none' | 'walkingRemote' | 'awaitingConfirmation' | 'executing' | 'completed' | 'completedNoop' | 'cancelled' | 'failed';
+type AddRibbonIcon = (icon: IconName, title: string, callback: (evt: MouseEvent) => void) => HTMLElement;
+declare class Observability {
+  private readonly ctx;
+  private lastSyncTime;
+  private readonly sinceLastSyncText;
+  private readonly syncStage;
+  private readonly walkProgress;
+  private readonly executionProgress;
+  private readonly cleanupCallbacks;
+  private readonly t;
+  private readonly progressText;
+  readonly settings: {
+    noticeStatusOnMobile: boolean;
+  };
+  readonly i18n: {
+    startSync: string;
+    startNonInteractiveSync: string;
+    stopSync: string;
+    showProgress: string;
+    exportLogsToFile: string;
+    exportLogsFailed: string;
+    idle: string;
+  };
+  constructor(ctx: {
+    addStatusBarItem: () => HTMLElement;
+    on: On<Events>;
+    translate: Translate<Translations>;
+    isIdle: Ref<boolean>;
+    dispatch: Dispatch<Events>;
+    requestSync: (trigger: string) => Promise<SyncTerminateReason>;
+    showProgress: () => void;
+    addCommand: (command: Command) => Command;
+    addRibbonIcon: AddRibbonIcon;
+    getLogs: () => string;
+    app: App;
+  });
+  readonly start: () => void;
+  private readonly setupCommands;
+  private readonly exportLogs;
+  readonly dispose: () => void;
+  root: {
+    executionProgress: Ref<Progress<TaskInfo>>;
+    exportLogs: () => Promise<void>;
+    syncStage: Ref<SyncStage>;
+    walkProgress: Ref<Progress>;
+  };
+}
+//#endregion
+export { AddRibbonIcon, SyncStage, Observability as default };

package/dist/packages/plugin/src/modules/ProgressModal.d.ts

@@ -0,0 +1,66 @@
+import { Progress } from "../types.js";
+import { Ref } from "../../../../node_modules/.bun/synthkernel@._synthkernel.tgz/node_modules/synthkernel/dist/reactive.js";
+import { Dispatch, On } from "./EventBus.js";
+import { Translate } from "./I18n.js";
+import { BaseTask, TaskNames } from "../sync/tasks/interface.js";
+import RemoveLocal from "../sync/tasks/RemoveLocal.js";
+import "../sync/index.js";
+import { TaskInfo } from "./Sync.js";
+import { SyncStage } from "./Observability.js";
+import { Events, Translations } from "../index.js";
+import { App, Modal } from "obsidian";
+//#region src/modules/ProgressModal.d.ts
+type DeleteConfirmReturn = {
+  delete: Array<RemoveLocal>;
+  reupload: Array<RemoveLocal>;
+};
+declare class ProgressModal extends Modal {
+  private readonly ctx;
+  private readonly moduleCleanupCallbacks;
+  private readonly t;
+  private opening;
+  private readonly modalCleanupCallbacks;
+  private readonly dispatch;
+  private description?;
+  private detailContainer?;
+  private controls?;
+  constructor(ctx: {
+    app: App;
+    translate: Translate<Translations>;
+    on: On<Events>;
+    dispatch: Dispatch<Events>;
+    syncStage: Ref<SyncStage>;
+    walkProgress: Ref<Progress>;
+    executionProgress: Ref<Progress<TaskInfo>>;
+  });
+  readonly events: {
+    tasksConfirmed: Array<BaseTask>;
+    deleteConfirmed: DeleteConfirmReturn;
+  };
+  readonly i18n: {
+    syncProgress: string;
+    completed: string;
+    failedTasksDescription: string;
+    confirmDeleteDescription: string;
+    confirmTasksDescription: string;
+    hide: string;
+    confirm: string;
+    cancel: string;
+    done: string;
+    stopSync: string;
+  } & Record<TaskNames | SyncStage, string>;
+  private readonly renderHideStop;
+  private readonly renderConfirmCancel;
+  private readonly renderDone;
+  private readonly showDetails;
+  private readonly hideDetails;
+  onOpen(): void;
+  root: {
+    hideProgress: () => void;
+    showProgress: () => void;
+  };
+  onClose(): void;
+  dispose(): void;
+}
+//#endregion
+export { DeleteConfirmReturn, ProgressModal as default };

package/dist/packages/plugin/src/modules/Registrar.d.ts

@@ -0,0 +1,147 @@
+import { General } from "../../test/e2e-utils.js";
+import { Binary, MaybePromise, RecordStat, Stat as Stat$1 } from "../types.js";
+import { BatchOptimizer, Fs, ListReporter, RootFs } from "../fs/interface.js";
+import { StoreAsync } from "../../../../node_modules/.bun/uni-kv@.._.._uni-kv.tgz/node_modules/uni-kv/dist/interface.js";
+import { On } from "./EventBus.js";
+import { RecordStore } from "./Storage.js";
+import { ConflictResolver } from "../sync/tasks/interface.js";
+import { Decider } from "../sync/decision/interface.js";
+import "../sync/index.js";
+import { Events } from "../index.js";
+import { VaultRequest } from "../fs/vault/request.js";
+import "../fs/index.js";
+import { App, Plugin, RequestUrlParam } from "obsidian";
+//#region src/modules/Registrar.d.ts
+type RejectableWrapper<T> = (value: T) => T | undefined;
+type OrderedWrapperEntry<T> = {
+  priority: number;
+  apply: RejectableWrapper<T>;
+};
+type RemoteRequestMiddlewareEntry = OrderedWrapperEntry<Request>;
+type LocalRequestMiddlewareEntry = OrderedWrapperEntry<VaultRequest>;
+type FsWrapperEntry = OrderedWrapperEntry<Fs>;
+type CheckConnectionResult = {
+  success: true;
+} | {
+  success: false;
+  reason: string;
+};
+type RemoteFsEntry = {
+  instantiate: (request: Request) => RootFs;
+  prettyName: () => string;
+  checkConnection: (request: Request) => MaybePromise<CheckConnectionResult>;
+};
+type DeciderEntry = {
+  decider: Decider;
+  prettyName: () => string;
+};
+type ConflictResolverEntry = {
+  prettyName: () => string;
+  resolver: ConflictResolver;
+};
+type GeneralFn = (...args: ReadonlyArray<General>) => unknown;
+type RejectableApply<F extends GeneralFn> = (...input: Parameters<F>) => ReturnType<F> | undefined;
+type OrderedApplyEntry<F extends GeneralFn> = {
+  apply: RejectableApply<F>;
+  priority: number;
+};
+type RemoteLister = (info: Infras & {
+  trigger: string;
+  reporter: ListReporter;
+}) => MaybePromise<Array<Stat$1>>;
+type RemoteListerEntry = OrderedApplyEntry<RemoteLister>;
+type OptimizerEntry = OrderedApplyEntry<BatchOptimizer>;
+type SettingEntry = {
+  priority: number;
+  apply: (el: HTMLElement) => void;
+};
+type RequestParam = Omit<RequestUrlParam, 'body'> & {
+  body?: string | Binary;
+};
+type RequestResponse = {
+  text: () => string;
+  bytes: () => Binary;
+  json: () => General;
+  headers: Record<string, string>;
+  status: number;
+};
+type Request = (params: RequestParam | string) => Promise<RequestResponse>;
+type Infras = {
+  localFs: Fs;
+  remoteFs: Fs;
+  record: RecordStore;
+};
+declare class Registrar {
+  private readonly ctx;
+  private settingTab?;
+  private readonly cleanupCallbacks;
+  private readonly localFsWrapperRegistry;
+  private readonly remoteFsWrapperRegistry;
+  private readonly localOptimizerRegistry;
+  private readonly remoteOptimizerRegistry;
+  private readonly remoteListerRegistry;
+  private readonly settingRegistry;
+  private readonly remoteRequestMiddlewareRegistry;
+  private readonly localRequestMiddlewareRegistry;
+  private readonly remoteFsRegistry;
+  private readonly deciderRegistry;
+  private readonly conflictResolverRegistry;
+  readonly settings: {
+    remoteFs: string;
+    decider: string;
+    conflictResolver: string;
+  };
+  constructor(ctx: {
+    app: App;
+    on: On<Events>;
+    getRecordStore: (namespace?: string) => StoreAsync<RecordStat>;
+  });
+  private readonly getVaultRequest;
+  private readonly createLocalFs;
+  private readonly createRemoteFs;
+  private readonly getRequest;
+  private readonly getCheckConnection;
+  private readonly getDecider;
+  private readonly optimizeLocal;
+  private readonly optimizeRemote;
+  private readonly listRemote;
+  private readonly getConflictResolver;
+  private readonly getNamespace;
+  private readonly initializeSync;
+  private readonly addSettingTab;
+  private readonly rerenderSettingTab;
+  root: {
+    addSettingTab: (plugin: Plugin) => void;
+    conflictResolverRegistry: Map<string, ConflictResolverEntry>;
+    createLocalFs: () => Fs;
+    createRemoteFs: (remoteFs?: string) => RootFs;
+    deciderRegistry: Map<string, DeciderEntry>;
+    getCheckConnection: (remoteFs?: string) => () => MaybePromise<CheckConnectionResult>;
+    getConflictResolver: () => ConflictResolver;
+    getDecider: () => Decider;
+    getNamespace: (localFs?: Fs, remoteFs?: Fs) => string;
+    getRequest: () => Request;
+    getVaultRequest: () => VaultRequest;
+    initializeSync: () => Infras;
+    listRemote: RemoteLister;
+    optimizeLocal: BatchOptimizer;
+    optimizeRemote: BatchOptimizer;
+    registerConflictResolver: (key: string, entry: ConflictResolverEntry) => () => boolean;
+    registerCss: (css: string) => () => void;
+    registerDecider: (key: string, entry: DeciderEntry) => () => boolean;
+    registerLocalFsWrapper: (entry: FsWrapperEntry) => () => boolean;
+    registerLocalOptimizer: (entry: OptimizerEntry) => () => boolean;
+    registerLocalRequestMiddleware: (entry: LocalRequestMiddlewareEntry) => () => boolean;
+    registerRemoteFs: (key: string, entry: RemoteFsEntry) => () => boolean;
+    registerRemoteFsWrapper: (entry: FsWrapperEntry) => () => boolean;
+    registerRemoteLister: (entry: RemoteListerEntry) => () => boolean;
+    registerRemoteOptimizer: (entry: OptimizerEntry) => () => boolean;
+    registerRemoteRequestMiddleware: (entry: RemoteRequestMiddlewareEntry) => () => boolean;
+    registerSetting: (entry: SettingEntry) => () => boolean;
+    remoteFsRegistry: Map<string, RemoteFsEntry>;
+    rerenderSettingTab: () => void | undefined;
+  };
+  readonly dispose: () => void;
+}
+//#endregion
+export { CheckConnectionResult, ConflictResolverEntry, DeciderEntry, FsWrapperEntry, Infras, LocalRequestMiddlewareEntry, OptimizerEntry, RemoteFsEntry, RemoteLister, RemoteListerEntry, RemoteRequestMiddlewareEntry, Request, RequestParam, RequestResponse, SettingEntry, Registrar as default };

package/dist/packages/plugin/src/modules/Scheduler.d.ts

@@ -0,0 +1,43 @@
+import { GlobMatchRule, TogglableValue } from "../types.js";
+import { Ref } from "../../../../node_modules/.bun/synthkernel@._synthkernel.tgz/node_modules/synthkernel/dist/reactive.js";
+import { SyncTerminateReason } from "./Sync.js";
+import { SyncStage } from "./Observability.js";
+import { App, EventRef } from "obsidian";
+//#region src/modules/Scheduler.d.ts
+declare class Scheduler {
+  private readonly ctx;
+  private readonly pendingRequests;
+  private isScheduling;
+  private realtimeSyncTimer?;
+  private scheduledSyncTimer?;
+  private startupSyncTimer?;
+  constructor(ctx: {
+    syncStage: Ref<SyncStage>;
+    executeSync: (trigger: string) => Promise<SyncTerminateReason>;
+    registerEvent: (ref: EventRef) => void;
+    app: App;
+    isIdle: Ref<boolean>;
+  });
+  settings: {
+    startupSync: TogglableValue;
+    scheduledSync: TogglableValue;
+    realtimeSync: TogglableValue;
+    exclusionRules: Array<GlobMatchRule>;
+    inclusionRules: Array<GlobMatchRule>;
+  };
+  private readonly requestSync;
+  start: () => void;
+  dispose: () => void;
+  private readonly startScheduledSync;
+  private readonly stopScheduledSync;
+  private readonly onChange;
+  private readonly scheduleFlush;
+  private readonly flush;
+  root: {
+    requestSync: (trigger: string) => Promise<SyncTerminateReason>;
+    startScheduledSync: () => void;
+    stopScheduledSync: () => void;
+  };
+}
+//#endregion
+export { Scheduler as default };

package/dist/packages/plugin/src/modules/Storage.d.ts

@@ -0,0 +1,54 @@
+import { General } from "../../test/e2e-utils.js";
+import { RecordStat } from "../types.js";
+import { DatabaseAsync, GetResult, StoreAsync, StoreOperations } from "../../../../node_modules/.bun/uni-kv@.._.._uni-kv.tgz/node_modules/uni-kv/dist/interface.js";
+//#region src/modules/Storage.d.ts
+type RecordStore = StoreAsync<RecordStat>;
+declare class Storage {
+  private readonly ctx;
+  private readonly memoryDB;
+  private readonly indexedDB;
+  constructor(ctx: {
+    getNamespace: () => string;
+  });
+  private readonly getRecordStore;
+  private readonly deleteRecordStore;
+  private readonly clearRecordStores;
+  private readonly recordStoreExists;
+  readonly root: {
+    clearRecordStores: () => Promise<void>;
+    deleteRecordStore: (namespace?: string) => Promise<void>;
+    getRecordStore: (namespace?: string) => {
+      get(key: string): Promise<RecordStat | undefined>;
+      set(key: string, value: RecordStat): Promise<void>;
+      delete(key: string): Promise<void>;
+      clear(): Promise<void>;
+      keys(): Promise<string[]>;
+      values(): Promise<RecordStat[]>;
+      entries(): Promise<[string, RecordStat][]>;
+      batch(operations: StoreOperations<RecordStat>[]): Promise<GetResult<RecordStat>[]>;
+    };
+    indexedDB: DatabaseAsync<General, General>;
+    memoryDB: {
+      getStore<K extends string | number | symbol>(name: K): {
+        get(key: string): any;
+        set(key: string, value: any): void;
+        delete(key: string): void;
+        clear(): void;
+        keys(): string[];
+        values(): any[];
+        entries(): [string, any][];
+        batch(operations: StoreOperations<any>[]): GetResult<any>[];
+      };
+      getStoreNames(): string[];
+      deleteStore(name: string): void;
+      clearStores(): void;
+      getMeta<T extends string | number | symbol>(key: T): any;
+      setMeta<T extends string | number | symbol>(key: T, value: any): void;
+      dispose(): void;
+    };
+    recordStoreExists: (namespace?: string) => Promise<boolean>;
+  };
+  readonly dispose: () => void;
+}
+//#endregion
+export { RecordStore, Storage as default };