@vrtmrz/livesync-commonlib 0.1.44 → 0.2.1

package/dist/services/base/ControlService.js

@@ -40,7 +40,9 @@ class ControlService extends ServiceBase {
     await this.services.appLifecycleService.onSuspending();
     await this.services.settingService.onBeforeRealiseSetting();
     this.services.databaseService.localDatabase.refreshSettings();
-    await this.services.fileProcessingService.commitPendingFileEvents();
+    if (!await this.services.fileProcessingService.commitPendingFileEvents()) {
+      throw new Error("Pending local file operations could not be completed before applying settings");
+    }
     await this.services.settingService.onRealiseSetting();
     if (this.services.appLifecycleService.isSuspended()) return;
     await this.services.appLifecycleService.onResuming();
@@ -49,7 +51,8 @@ class ControlService extends ServiceBase {
   }
   async _onLiveSyncUnload() {
     this.context.events.emitEvent(EVENT_PLUGIN_UNLOADED);
-    await this.services.appLifecycleService.onBeforeUnload();
+    const prepared = await this.services.appLifecycleService.onBeforeUnload();
+    if (!prepared) this._log("Unload preparation failed; pending storage work may require recovery", LOG_LEVEL_URGENT);
     await Promise.resolve(this.services.appLifecycleService.onAppUnload());
     cancelAllPeriodicTask();
     cancelAllTasks();
@@ -64,6 +67,7 @@ class ControlService extends ServiceBase {
     this.context.events.emitEvent(EVENT_PLATFORM_UNLOADED);
     this.context.events.offAll();
     this._log(this.context.translate("moduleLiveSyncMain.logUnloadingPlugin"));
+    if (!prepared) throw new Error("Unload preparation failed");
     return;
   }
   /**

package/dist/services/base/FileProcessingService.d.ts

@@ -9,10 +9,16 @@ export declare class FileProcessingService<T extends ServiceContext = ServiceCon
      */
     readonly processFileEvent: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(item: import("../../common/types.js").FileEventItem) => Promise<boolean>>;
     /**
-     * Process a file event item optionally, if any handler is registered.
+     * Dispatch a legacy optional notification, without confirming persistence.
      * i.e., hidden files synchronisation or customisation sync.
      */
     readonly processOptionalFileEvent: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(path: import("../../common/types.js").FilePath) => Promise<boolean>>;
+    /**
+     * Complete optional file operations through the first applicable handler.
+     * Hosts migrate all optional providers together. Once any typed provider is
+     * registered, dispatch uses this contract exclusively.
+     */
+    readonly processOptionalFileEventWithResult?: import("../lib/HandlerUtils.js").FirstHandledFunction<(path: import("../../common/types.js").FilePath, options?: import("./IService.js").OptionalFileEventOptions) => Promise<import("../lib/HandlerUtils.js").HandlerOutcome<void, string>>>;
     /**
      * Commit any pending file events that have been queued for processing.
      */

package/dist/services/base/FileProcessingService.js

@@ -7,10 +7,18 @@ class FileProcessingService extends ServiceBase {
    */
   processFileEvent = handlers().anySuccess("processFileEvent");
   /**
-   * Process a file event item optionally, if any handler is registered.
+   * Dispatch a legacy optional notification, without confirming persistence.
    * i.e., hidden files synchronisation or customisation sync.
    */
   processOptionalFileEvent = handlers().anySuccess("processOptionalFileEvent");
+  /**
+   * Complete optional file operations through the first applicable handler.
+   * Hosts migrate all optional providers together. Once any typed provider is
+   * registered, dispatch uses this contract exclusively.
+   */
+  processOptionalFileEventWithResult = handlers().firstHandled(
+    "processOptionalFileEventWithResult"
+  );
   /**
    * Commit any pending file events that have been queued for processing.
    */

package/dist/services/base/IService.d.ts

@@ -1,3 +1,4 @@
+import type { ValueStore, ValueDeleter } from "@vrtmrz/value-store";
 import type { FetchHttpHandler } from "@smithy/fetch-http-handler";
 import { type LOG_LEVEL } from "octagonal-wheels/common/logger";
 import type { AnyEntry, AUTO_MERGED, CouchDBCredentials, ConfigPassphraseStore, diff_result, DocumentID, EntryDoc, EntryHasPath, FileEventItem, FilePath, FilePathWithPrefix, LoadedEntry, MetaEntry, MISSING_OR_ERROR, ObsidianLiveSyncSettings, RemoteDBSettings, RemotePreferredTweakResult, SettingsMigrationState, TweakAssessment, TweakValues, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
@@ -15,8 +16,9 @@ import type { OwnedCouchDBConnection, RemoteConnectionOpenOptions } from "./Remo
 import type { ActiveReplicatorContext, ContinuousReplicationRequest, ReplicationAttemptFailure, ReplicationFailureRequest, ReplicatorProviderDefinitionMap, ReplicationOutcome, ReplicationReadinessRequirements, UnattendedOneShotRequest, UserInitiatedOneShotRequest } from "../../replication/ReplicatorProvider.js";
 import type { RemoteResourceKind, RemoteResourceMap } from "../../replication/RemoteResource.js";
 import type { CentralRemoteAdministrationRequest, CentralRemoteAdministrationResult } from "../../replication/CentralRemoteAdministration.js";
-import type { MultipleHandlerFunction } from "../lib/HandlerUtils.js";
+import type { HandlerOutcome, MultipleHandlerFunction } from "../lib/HandlerUtils.js";
 import type { VaultScanResult } from "./VaultScanResult.js";
+import type { UICommandRegistry } from "../../uiCommands.js";
 declare global {
     interface OPTIONAL_SYNC_FEATURES {
         DISABLE: "DISABLE";
@@ -95,9 +97,17 @@ export interface IKeyValueDBService {
     openSimpleStore<T>(kind: string): SimpleStore<T>;
     simpleStore: SimpleStore<unknown>;
 }
+/** Options for completing an admitted optional file event. */
+export interface OptionalFileEventOptions {
+    /** Resolves when a finite flush needs this event to finish without its debounce delay. */
+    whenFlushRequested?: Promise<void>;
+}
 export interface IFileProcessingService {
     processFileEvent(item: FileEventItem): Promise<boolean>;
+    /** Legacy notification contract; its boolean does not confirm persistence. */
     processOptionalFileEvent(path: FilePath): Promise<boolean>;
+    /** Complete the actual optional file operation, or explain why it is not completed. */
+    processOptionalFileEventWithResult?(path: FilePath, options?: OptionalFileEventOptions): Promise<HandlerOutcome<void, string>>;
     commitPendingFileEvents(): Promise<boolean>;
     batched: ReactiveSource<number>;
     processing: ReactiveSource<number>;
@@ -312,16 +322,11 @@ export interface ISettingService {
     getSettingsMigrationState(): SettingsMigrationState | undefined;
     getDeviceAndVaultName(): string;
     setDeviceAndVaultName(name: string): void;
-    saveDeviceAndVaultName(): void;
-    /**
-     * Read host-provided, device-local configuration by its exact key.
-     * This storage is not part of the synchronised settings document.
-     */
-    getDeviceLocalConfig(key: string): string | null;
-    /** Store host-provided, device-local configuration by its exact key. */
-    setDeviceLocalConfig(key: string, value: string): void;
-    /** Delete host-provided, device-local configuration by its exact key. */
-    deleteDeviceLocalConfig(key: string): void;
+    saveDeviceAndVaultName(): Promise<void>;
+    /** Exact-key host storage; values are local to this application instance. */
+    readonly deviceValues: ValueStore & ValueDeleter;
+    /** Storage scoped by the current Vault and database suffix. */
+    readonly config: IConfigService;
     onBeforeSaveSettingData(nextSettings: ObsidianLiveSyncSettings, previousSettings: ObsidianLiveSyncSettings): Promise<(Partial<ObsidianLiveSyncSettings> | void)[]>;
     saveSettingData(): Promise<void>;
     /** Save a new configuration wrapper and its device-local key, retaining the protected values. */
@@ -333,9 +338,6 @@ export interface ISettingService {
     onSettingLoaded(settings: ObsidianLiveSyncSettings): Promise<boolean>;
     onSettingChanged(settings: ObsidianLiveSyncSettings): Promise<boolean>;
     onSettingSaved(settings: ObsidianLiveSyncSettings): Promise<boolean>;
-    getSmallConfig(key: string): string | null;
-    setSmallConfig(key: string, value: string): void;
-    deleteSmallConfig(key: string): void;
 }
 export interface ITweakValueService {
     fetchRemotePreferred(trialSetting: RemoteDBSettings): Promise<RemotePreferredTweakResult>;
@@ -373,15 +375,13 @@ export interface ITestService {
     addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void;
 }
 export interface IUIService {
+    readonly commands: UICommandRegistry;
     promptCopyToClipboard(title: string, value: string): Promise<boolean>;
     showMarkdownDialog<T extends string[]>(title: string, contentMD: string, buttons: T): Promise<(typeof buttons)[number] | false>;
     get confirm(): Confirm;
 }
-export interface IConfigService {
-    getSmallConfig(key: string): string | null;
-    setSmallConfig(key: string, value: string): void;
-    deleteSmallConfig(key: string): void;
-}
+/** Asynchronous device configuration selected by the host composition. */
+export type IConfigService = ValueStore & ValueDeleter;
 export interface IServiceHub {
     API: IAPIService;
     path: IPathService;

package/dist/services/base/ReplicatorService.d.ts

@@ -125,5 +125,6 @@ export declare abstract class ReplicatorService<T extends ServiceContext = Servi
         lastSyncPullSeq: number;
         lastSyncPushSeq: number;
         syncStatus: import("../../common/types.js").DatabaseConnectingStatus;
+        couchDB?: import("../../common/models/shared.definition.js").CouchDBReplicationProgress;
     }>;
 }

package/dist/services/base/ReplicatorService.remoteResourceResolver.js

@@ -1,7 +1,7 @@
 import { CAPABILITY_SUPPORT_KINDS } from "../../replication/ProviderCapability.js";
 async function resolveRemoteResource(capabilities, kind, setting) {
   const capability = capabilities[kind];
-  if (capability.kind !== CAPABILITY_SUPPORT_KINDS.SUPPORTED) {
+  if (capability?.kind !== CAPABILITY_SUPPORT_KINDS.SUPPORTED) {
     return void 0;
   }
   return await capability.run(setting);

package/dist/services/base/SettingService.d.ts

@@ -1,3 +1,4 @@
+import { type ValueStore, type ValueDeleter } from "@vrtmrz/value-store";
 import { type ConfigPassphraseStore, type ObsidianLiveSyncSettings, type SettingsMigrationState } from "../../common/types.js";
 import type { IAPIService, ISettingService } from "./IService.js";
 import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
@@ -5,6 +6,8 @@ import { createInstanceLogFunction } from "../lib/logUtils.js";
 import { type PersistedSettings } from "../../common/models/setting.policy.js";
 export interface SettingServiceDependencies {
     APIService: IAPIService;
+    /** Host-owned exact-key storage, created once for this application instance. */
+    deviceValues: ValueStore & ValueDeleter;
     /** Optional host hook for applying the loaded display language to its catalogue. */
     onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;
 }
@@ -12,9 +15,10 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     deviceAndVaultName: string;
     protected APIService: IAPIService;
     private readonly onDisplayLanguageChanged?;
-    protected abstract setItem(key: string, value: string): void;
-    protected abstract getItem(key: string): string;
-    protected abstract deleteItem(key: string): void;
+    /** Exact-key device values, including legacy keys outside the Vault namespace. */
+    readonly deviceValues: ValueStore & ValueDeleter;
+    /** Device values scoped by the current Vault name and database suffix. */
+    readonly config: ValueStore & ValueDeleter;
     _settings: ObsidianLiveSyncSettings;
     get settings(): ObsidianLiveSyncSettings;
     set settings(value: ObsidianLiveSyncSettings);
@@ -43,23 +47,9 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     /**
      * Save the current device and vault name to settings, aside from the main settings.
      */
-    saveDeviceAndVaultName(): void;
-    /**
-     * Read an exact key from the host's device-local configuration store.
-     *
-     * Unlike the main settings document, this state is not synchronised. Callers
-     * which need Vault namespacing should normally use {@link getSmallConfig}.
-     */
-    getDeviceLocalConfig(key: string): string | null;
-    /** Store an exact key in the host's non-synchronised configuration store. */
-    setDeviceLocalConfig(key: string, value: string): void;
-    /** Delete an exact key from the host's non-synchronised configuration store. */
-    deleteDeviceLocalConfig(key: string): void;
+    saveDeviceAndVaultName(): Promise<void>;
     private additionalSuffixOfDatabaseName;
     private getKey;
-    setSmallConfig(key: string, value: string): void;
-    getSmallConfig(key: string): string;
-    deleteSmallConfig(key: string): void;
     /**
      * Save the current settings to storage.
      */

package/dist/services/base/SettingService.js

@@ -1,3 +1,4 @@
+import { createDeletableValueStore } from "@vrtmrz/value-store";
 import {
   ChunkAlgorithmNames,
   LOG_LEVEL_NOTICE,
@@ -42,6 +43,10 @@ class SettingService extends ServiceBase {
   deviceAndVaultName = "";
   APIService;
   onDisplayLanguageChanged;
+  /** Exact-key device values, including legacy keys outside the Vault namespace. */
+  deviceValues;
+  /** Device values scoped by the current Vault name and database suffix. */
+  config;
   _settings;
   get settings() {
     return this._settings;
@@ -59,6 +64,12 @@ class SettingService extends ServiceBase {
   constructor(context, dependencies) {
     super(context);
     this.APIService = dependencies.APIService;
+    this.deviceValues = dependencies.deviceValues;
+    this.config = createDeletableValueStore({
+      get: (key) => this.deviceValues.getValue(this.getKey(key)),
+      set: (key, value) => this.deviceValues.setValue(this.getKey(key), value),
+      delete: (key) => this.deviceValues.delete(this.getKey(key))
+    });
     this.onDisplayLanguageChanged = dependencies.onDisplayLanguageChanged;
     this._log = createInstanceLogFunction("SettingService", this.APIService);
   }
@@ -111,26 +122,9 @@ class SettingService extends ServiceBase {
   /**
    * Save the current device and vault name to settings, aside from the main settings.
    */
-  saveDeviceAndVaultName() {
+  async saveDeviceAndVaultName() {
     const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
-    this.setDeviceLocalConfig(lsKey, this.deviceAndVaultName);
-  }
-  /**
-   * Read an exact key from the host's device-local configuration store.
-   *
-   * Unlike the main settings document, this state is not synchronised. Callers
-   * which need Vault namespacing should normally use {@link getSmallConfig}.
-   */
-  getDeviceLocalConfig(key) {
-    return this.getItem(key);
-  }
-  /** Store an exact key in the host's non-synchronised configuration store. */
-  setDeviceLocalConfig(key, value) {
-    this.setItem(key, value);
-  }
-  /** Delete an exact key from the host's non-synchronised configuration store. */
-  deleteDeviceLocalConfig(key) {
-    this.deleteItem(key);
+    await this.deviceValues.setValue(lsKey, this.deviceAndVaultName);
   }
   additionalSuffixOfDatabaseName() {
     const suffix = this.settings?.additionalSuffixOfDatabaseName;
@@ -145,18 +139,6 @@ class SettingService extends ServiceBase {
     const addSuffix = this.additionalSuffixOfDatabaseName();
     return `${keyMain}${addSuffix}-${key}`;
   }
-  setSmallConfig(key, value) {
-    const dbKey = this.getKey(key);
-    this.setDeviceLocalConfig(dbKey, value);
-  }
-  getSmallConfig(key) {
-    const dbKey = this.getKey(key);
-    return this.getDeviceLocalConfig(dbKey) ?? "";
-  }
-  deleteSmallConfig(key) {
-    const dbKey = this.getKey(key);
-    this.deleteDeviceLocalConfig(dbKey);
-  }
   /**
    * Save the current settings to storage.
    */
@@ -178,7 +160,7 @@ class SettingService extends ServiceBase {
       if (store !== "" && store !== "LOCALSTORAGE" && store !== "ASK_AT_LAUNCH") {
         throw new Error("The configuration passphrase storage mode is unsupported.");
       }
-      const oldLocalKey = this.getDeviceLocalConfig("ls-setting-passphrase");
+      const oldLocalKey = await this.deviceValues.getValue("ls-setting-passphrase");
       const settings = this.cloneSettings(this.settings);
       let targetKey;
       if (store === "LOCALSTORAGE") {
@@ -196,10 +178,10 @@ class SettingService extends ServiceBase {
       const prepared = await this.prepareSettingSave(settings, targetKey);
       const changesLocalKey = store === "LOCALSTORAGE" && targetKey !== oldLocalKey;
       try {
-        if (changesLocalKey) this.setDeviceLocalConfig("ls-setting-passphrase", targetKey);
+        if (changesLocalKey) await this.deviceValues.setValue("ls-setting-passphrase", targetKey);
         await this.writePreparedSettings(prepared);
       } catch (error) {
-        if (changesLocalKey) this.restoreConfigurationPassphrase(oldLocalKey, error);
+        if (changesLocalKey) await this.restoreConfigurationPassphrase(oldLocalKey, error);
         throw error;
       }
       this.settings.configPassphraseStore = store;
@@ -210,10 +192,10 @@ class SettingService extends ServiceBase {
       throw error;
     });
   }
-  restoreConfigurationPassphrase(previous, cause) {
+  async restoreConfigurationPassphrase(previous, cause) {
     try {
-      if (previous) this.setDeviceLocalConfig("ls-setting-passphrase", previous);
-      else this.deleteDeviceLocalConfig("ls-setting-passphrase");
+      if (previous) await this.deviceValues.setValue("ls-setting-passphrase", previous);
+      else await this.deviceValues.delete("ls-setting-passphrase");
     } catch {
       const message = this.context.translate("SettingService.ConfigurationPassphraseRollbackFailed");
       this._log(message, LOG_LEVEL_URGENT);
@@ -344,9 +326,9 @@ class SettingService extends ServiceBase {
     return { persisted, runtime, patch: savedPatch, passphrase: configurationPassphrase };
   }
   async writePreparedSettings(prepared) {
-    this.saveDeviceAndVaultName();
+    await this.saveDeviceAndVaultName();
     if (prepared.runtime.P2P_DevicePeerName?.trim()) {
-      this.setSmallConfig(SETTING_KEY_P2P_DEVICE_NAME, prepared.runtime.P2P_DevicePeerName.trim());
+      await this.config.setValue(SETTING_KEY_P2P_DEVICE_NAME, prepared.runtime.P2P_DevicePeerName.trim());
     }
     await this.saveData(prepared.persisted);
   }
@@ -528,7 +510,7 @@ class SettingService extends ServiceBase {
   getPassphrase(settings) {
     const methods = {
       "": () => Promise.resolve("*"),
-      LOCALSTORAGE: () => Promise.resolve(this.getDeviceLocalConfig("ls-setting-passphrase") ?? false),
+      LOCALSTORAGE: () => this.deviceValues.getValue("ls-setting-passphrase", ""),
       ASK_AT_LAUNCH: () => this.APIService.confirm.askString(
         this.context.translate("SettingService.ConfigurationPassphraseTitle"),
         "passphrase",
@@ -700,7 +682,7 @@ class SettingService extends ServiceBase {
     } else {
       configuredIdKey(settings);
     }
-    const previous = this.getDeviceLocalConfig("ls-setting-passphrase");
+    const previous = await this.deviceValues.getValue("ls-setting-passphrase");
     let candidate = previous || false;
     let retry = false;
     while (true) {
@@ -710,9 +692,9 @@ class SettingService extends ServiceBase {
           if (result.verified) {
             if (candidate !== previous) {
               try {
-                this.setDeviceLocalConfig("ls-setting-passphrase", candidate);
+                await this.deviceValues.setValue("ls-setting-passphrase", candidate);
               } catch (error) {
-                this.restoreConfigurationPassphrase(previous, error);
+                await this.restoreConfigurationPassphrase(previous, error);
                 throw error;
               }
             }
@@ -788,9 +770,9 @@ class SettingService extends ServiceBase {
     }
     const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
     if (this.settings.deviceAndVaultName != "") {
-      if (!this.getDeviceLocalConfig(lsKey)) {
+      if (!await this.deviceValues.getValue(lsKey)) {
         this.setDeviceAndVaultName(this.settings.deviceAndVaultName);
-        this.saveDeviceAndVaultName();
+        await this.saveDeviceAndVaultName();
         this.settings.deviceAndVaultName = "";
       }
     }
@@ -801,7 +783,7 @@ class SettingService extends ServiceBase {
       );
       this.settings.customChunkSize = 0;
     }
-    this.setDeviceAndVaultName(this.getDeviceLocalConfig(lsKey) || "");
+    this.setDeviceAndVaultName(await this.deviceValues.getValue(lsKey) || "");
     if (this.getDeviceAndVaultName() == "") {
       if (this.settings.usePluginSync) {
         this._log("Device name missing. Disabling plug-in sync.", LOG_LEVEL_NOTICE);

package/dist/services/implements/base/SvelteDialog.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigService } from "../../base/ConfigService.js";
+import type { IConfigService } from "../../base/IService.js";
 import type { AppLifecycleService } from "../../base/AppLifecycleService.js";
 import type { ReplicatorService } from "../../base/ReplicatorService.js";
 import type { Confirm } from "../../../interfaces/Confirm.js";
@@ -9,7 +9,7 @@ import type { Constructor } from "../../../common/utils.type.js";
 export type SvelteDialogManagerDependencies<T extends ServiceContext = ServiceContext> = {
     appLifecycle: AppLifecycleService<T>;
     replicator: ReplicatorService<T>;
-    config: ConfigService<T>;
+    config: IConfigService;
     confirm: Confirm;
     control: IControlService;
 };

package/dist/services/implements/base/UIService.d.ts

@@ -1,4 +1,5 @@
 import type { Confirm } from "../../../interfaces/Confirm.js";
+import { UICommandRegistry } from "../../../uiCommands.js";
 import type { ComponentHasResult, SvelteDialogManager } from "./SvelteDialog.js";
 import type { IAPIService, IUIService } from "../../base/IService.js";
 import { ServiceBase, type ServiceContext } from "../../base/ServiceBase.js";
@@ -12,6 +13,7 @@ type DialogParams = {
     dataToCopy: string;
 };
 export declare abstract class UIService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IUIService {
+    readonly commands: UICommandRegistry;
     private _dialogManager;
     protected _APIService: IAPIService;
     abstract get dialogToCopy(): ComponentHasResult<DialogResult, DialogParams>;

package/dist/services/implements/base/UIService.js

@@ -1,9 +1,14 @@
+import { EVENT_PLUGIN_UNLOADED } from "../../../events/coreEvents.js";
+import { UICommandRegistry } from "../../../uiCommands.js";
 import { ServiceBase } from "../../base/ServiceBase.js";
 class UIService extends ServiceBase {
+  commands;
   _dialogManager;
   _APIService;
   constructor(context, dependents) {
     super(context);
+    this.commands = new UICommandRegistry();
+    this.context.events.once(EVENT_PLUGIN_UNLOADED, () => this.commands.dispose());
     this._dialogManager = dependents.dialogManager;
     this._APIService = dependents.APIService;
   }

package/dist/services/implements/injectable/InjectableServiceHub.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigService } from "../../base/ConfigService.js";
+import type { IConfigService } from "../../base/IService.js";
 import { ControlService } from "../../base/ControlService.js";
 import type { KeyValueDBService } from "../../base/KeyValueDBService.js";
 import { PathService } from "../../base/PathService.js";
@@ -35,7 +35,7 @@ export declare class InjectableServiceHub<T extends ServiceContext = ServiceCont
     protected readonly _vault: InjectableVaultService<T>;
     protected readonly _test: InjectableTestService<T>;
     protected readonly _ui: UIService<T>;
-    protected readonly _config: ConfigService<T>;
+    protected readonly _config: IConfigService;
     protected readonly _keyValueDB: KeyValueDBService<T>;
     protected readonly _control: ControlService<T>;
     get API(): InjectableAPIService<T>;
@@ -55,14 +55,14 @@ export declare class InjectableServiceHub<T extends ServiceContext = ServiceCont
     get control(): ControlService<T>;
     get keyValueDB(): KeyValueDBService<T>;
     get UI(): UIService<T>;
-    get config(): ConfigService<T>;
+    get config(): IConfigService;
     constructor(context: T, services: InjectableServiceInstances<T> & {
         setting: SettingService<T>;
         appLifecycle: AppLifecycleServiceBase<T>;
         path: PathService<T>;
         API: InjectableAPIService<T>;
         ui: UIService<T>;
-        config: ConfigService<T>;
+        config: IConfigService;
         database: DatabaseService<T>;
         remote: InjectableRemoteService<T>;
         vault: InjectableVaultService<T>;

package/dist/services/implements/injectable/InjectableServices.d.ts

@@ -1,6 +1,6 @@
+import type { IConfigService } from "../../base/IService.js";
 import { type ServiceInstances } from "../../ServiceHub.js";
 import type { UIService } from "../base/UIService.js";
-import type { ConfigService } from "../../base/ConfigService.js";
 import type { ServiceContext } from "../../base/ServiceBase.js";
 import type { InjectableAPIService } from "./InjectableAPIService.js";
 import type { InjectableDatabaseEventService } from "./InjectableDatabaseEventService.js";
@@ -32,5 +32,5 @@ export type InjectableServiceInstances<T extends ServiceContext> = ServiceInstan
     vault?: InjectableVaultService<T>;
     test?: InjectableTestService<T>;
     ui?: UIService<T>;
-    config?: ConfigService<T>;
+    config?: IConfigService;
 };

package/dist/services/implements/injectable/InjectableSettingService.d.ts

@@ -4,9 +4,6 @@ import type { ObsidianLiveSyncSettings } from "../../../common/types.js";
 import type { PersistedSettings } from "../../../common/models/setting.policy.js";
 export declare class InjectableSettingService<T extends ServiceContext> extends SettingService<T> {
     constructor(context: T, dependencies: SettingServiceDependencies);
-    protected setItem(key: string, value: string): void;
-    protected getItem(key: string): string;
-    protected deleteItem(key: string): void;
     saveData: import("../../lib/HandlerUtils.js").HandlerFunction<(data: PersistedSettings) => Promise<void>, unknown>;
     loadData: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<ObsidianLiveSyncSettings | undefined>, unknown>;
 }

package/dist/services/implements/injectable/InjectableSettingService.js

@@ -2,7 +2,6 @@ import { EVENT_SETTING_SAVED } from "../../../events/coreEvents.js";
 import { SettingService } from "../../base/SettingService.js";
 import { EVENT_REQUEST_RELOAD_SETTING_TAB } from "../../../events/coreEvents.js";
 import { handlers } from "../../lib/HandlerUtils.js";
-import { compatGlobal } from "../../../common/coreEnvFunctions.js";
 class InjectableSettingService extends SettingService {
   constructor(context, dependencies) {
     super(context, dependencies);
@@ -15,16 +14,6 @@ class InjectableSettingService extends SettingService {
       return Promise.resolve(true);
     });
   }
-  setItem(key, value) {
-    return compatGlobal.localStorage.setItem(key, value);
-  }
-  getItem(key) {
-    return compatGlobal.localStorage.getItem(key) ?? "";
-  }
-  deleteItem(key) {
-    compatGlobal.localStorage.removeItem(key);
-  }
-  // override currentSettings = handlers<SettingService<T>>().binder("currentSettings");
   saveData = handlers().binder("saveData");
   loadData = handlers().binder("loadData");
 }

package/dist/services/lib/HandlerUtils.d.ts

@@ -2,6 +2,27 @@
  * A function type that can be used as a handler.
  */
 type HandlerFunc<TArg extends unknown[], TResult> = (...args: TArg) => TResult | Promise<TResult>;
+/**
+ * The outcome of a handler.
+ *
+ * A completed outcome carries a value when `TValue` is not void, and a veto
+ * carries a reason when `TVetoReason` is not void. Not-applicable outcomes
+ * always continue to the next registered handler.
+ */
+export type HandlerOutcome<TValue = void, TVetoReason = void> = {
+    kind: "not-applicable";
+} | ([TValue] extends [void] ? {
+    kind: "completed";
+} : {
+    kind: "completed";
+    value: TValue;
+}) | ([TVetoReason] extends [void] ? {
+    kind: "veto";
+} : {
+    kind: "veto";
+    value: TVetoReason;
+});
+type AnyHandlerOutcome = HandlerOutcome | HandlerOutcome<unknown, unknown>;
 /**
  * A function type that returns a boolean or a Promise of boolean.
  */
@@ -244,6 +265,29 @@ export declare class FirstResultHandler<T extends unknown[], U> extends MultiBin
      */
     invoke(...args: T): Promise<U | false>;
 }
+/**
+ * Invokes registered handlers in priority and registration order until one
+ * completes or vetoes. Each invocation uses a snapshot of registrations.
+ * Callback errors and rejections propagate unchanged, and registrations are
+ * owned by this handler.
+ */
+export declare class FirstHandledHandler<T extends unknown[], U extends AnyHandlerOutcome = HandlerOutcome> extends MultiBinder<HandlerFunc<T, U>> implements InvokableHandler<T, U | {
+    kind: "not-applicable";
+}> {
+    /**
+     * Whether at least one callback is currently registered.
+     */
+    get hasHandlers(): boolean;
+    /**
+     * Invokes handlers until one returns a completed or veto outcome.
+     * @param args The arguments to pass to the handlers.
+     * @returns The first handled outcome, or a not-applicable outcome when no handler applies.
+     * @throws Any synchronous callback error or rejected callback value, unchanged.
+     */
+    invoke(...args: T): Promise<U | {
+        kind: "not-applicable";
+    }>;
+}
 /**
  * A function type that can be used as a handler with assignable functionality.
  */
@@ -297,6 +341,11 @@ export interface MultipleHandlerFunction<TFunc extends (...args: any[]) => U | P
      */
     removeHandler: (callback: TFunc) => void;
 }
+export type FirstHandledFunction<TFunc extends (...args: any[]) => AnyHandlerOutcome | Promise<AnyHandlerOutcome>> = ((...args: Parameters<TFunc>) => Promise<Awaited<ReturnType<TFunc>> | {
+    kind: "not-applicable";
+}>) & Pick<MultipleHandlerFunction<TFunc>, "addHandler" | "removeHandler"> & {
+    readonly hasHandlers: boolean;
+};
 /**
  * A function type that can be used as a value-collecting handler with add/remove functionality.
  */
@@ -351,12 +400,16 @@ export declare function bailFirstFailureWithResultFunction<TFunc extends (...arg
 export declare function allParallelFunction<TFunc extends (...args: any[]) => Promise<boolean>>(name?: string): BooleanMultipleHandlerFunction<TFunc>;
 export declare function anySuccessFunction<TFunc extends (...args: any[]) => Promise<boolean>>(name?: string): BooleanMultipleHandlerFunction<TFunc>;
 export declare function firstResultFunction<TFunc extends (...args: any[]) => Promise<unknown>>(name?: string): MultipleHandlerFunction<TFunc>;
+export declare function firstHandledFunction<TFunc extends (...args: any[]) => AnyHandlerOutcome | Promise<AnyHandlerOutcome>>(name?: string): FirstHandledFunction<TFunc>;
 export declare function dispatchParallelFunction<TFunc extends (...args: any[]) => Promise<unknown[]>>(name?: string): CollectiveHandlerFunction<TFunc>;
 export declare function bindableFunction<TFunc extends (...args: any[]) => any>(name?: string): HandlerFunction<TFunc>;
 export declare function lazyBindableFunction<TFunc extends (...args: any[]) => any>(name?: string): LazyHandlerFunction<TFunc>;
 type FunctionKeys<T> = Extract<{
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T], string>;
+type FirstHandledFunctionKeys<T> = Extract<{
+    [K in keyof T]: [NonNullable<T[K]>] extends [never] ? never : NonNullable<T[K]> extends (...args: any[]) => AnyHandlerOutcome | Promise<AnyHandlerOutcome> ? K : never;
+}[keyof T], string>;
 export declare function handlers<T extends object>(): {
     /**
      * Create a handler that invokes all added handler functions sequentially until one returns false.
@@ -403,6 +456,13 @@ export declare function handlers<T extends object>(): {
      * @returns
      */
     firstResult<K extends FunctionKeys<T>>(name: K): MultipleHandlerFunction<Extract<T[K], (...args: any[]) => Promise<unknown>>>;
+    /**
+     * Create a handler that invokes registered handlers until one completes or vetoes.
+     * Callback errors and rejections propagate unchanged.
+     * @param name The name of the callback on `T`.
+     * @returns A bound handler with a live `hasHandlers` property.
+     */
+    firstHandled<K extends FirstHandledFunctionKeys<T>>(name: K): FirstHandledFunction<Extract<NonNullable<T[K]>, (...args: any[]) => AnyHandlerOutcome | Promise<AnyHandlerOutcome>>>;
     /**
      * Create a handler that invokes all added handler functions in parallel.
      * @param name