@vrtmrz/livesync-commonlib 0.1.43 → 0.2.0

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -1,4 +1,5 @@
 import {
+  NODEINFO_DOCID,
   LOG_LEVEL_NOTICE,
   LOG_LEVEL_VERBOSE,
   DEVICE_ID_PREFERRED,
@@ -26,6 +27,10 @@ import {
   outcomeFromFiniteOpenReplication,
   replicationFailed
 } from "../ReplicatorProvider.js";
+import {
+  forgetJoinedDevice as forgetJoinedDeviceFromStore,
+  projectJoinedDevices
+} from "../joinedDevices.js";
 const MILSTONE_DOCID = "_00000000-milestone.json";
 async function readRemoteMilestone(client) {
   const result = await client.downloadJsonWithResult(MILSTONE_DOCID);
@@ -113,7 +118,8 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
         plugin_version: this.env.services.API.getPluginVersion(),
         vault_name: this.env.services.vault.vaultName(),
         device_name: this.env.services.vault.getVaultName(),
-        progress
+        progress,
+        platform: this.env.services.API.getPlatform()
       },
       async (info) => {
         if (encryptedProof) info.encrypted_id_derivation_proof = encryptedProof;
@@ -584,6 +590,55 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
       throw new Error("Object Storage does not support NFC path identity.");
     }
   }
+  async getOwnJoinedDeviceId() {
+    const nodeInfo = await this.rawDatabase.get(NODEINFO_DOCID);
+    const nodeId = nodeInfo?.nodeid;
+    if (typeof nodeId !== "string" || nodeId.trim().length === 0) {
+      throw new Error("The local node identity is unavailable.");
+    }
+    return nodeId;
+  }
+  async getJoinedDevices(setting) {
+    this.assertLegacyPathIdentity(setting);
+    const trialClient = new JournalSyncCore(
+      setting,
+      this.simpleStore,
+      this.env,
+      new MinioStorageAdapter(setting, this.env)
+    );
+    try {
+      const result = await trialClient.downloadJsonWithResult(MILSTONE_DOCID);
+      if (result.status === JournalStorageReadStatuses.NOT_FOUND) return projectJoinedDevices(void 0);
+      if (result.status === JournalStorageReadStatuses.UNAVAILABLE) throw result.error;
+      return projectJoinedDevices(result.value);
+    } finally {
+      trialClient.dispose();
+    }
+  }
+  async forgetJoinedDevice(setting, deviceId) {
+    this.assertLegacyPathIdentity(setting);
+    const ownDeviceId = await this.getOwnJoinedDeviceId();
+    const trialClient = new JournalSyncCore(
+      setting,
+      this.simpleStore,
+      this.env,
+      new MinioStorageAdapter(setting, this.env)
+    );
+    try {
+      const store = {
+        read: async () => {
+          const result = await trialClient.downloadJsonWithResult(MILSTONE_DOCID);
+          if (result.status === JournalStorageReadStatuses.NOT_FOUND) return void 0;
+          if (result.status === JournalStorageReadStatuses.UNAVAILABLE) throw result.error;
+          return { milestone: result.value, revision: result.revision };
+        },
+        write: async (milestone, revision) => await trialClient.uploadJsonIfUnchanged(MILSTONE_DOCID, milestone, revision)
+      };
+      return await forgetJoinedDeviceFromStore(store, deviceId, ownDeviceId);
+    } finally {
+      trialClient.dispose();
+    }
+  }
   getConnectedDeviceList(setting) {
     return Promise.resolve(false);
   }

package/dist/replication/journal/objectstore/JournalStorageAdapter.d.ts

@@ -8,16 +8,19 @@ export declare const JournalStorageReadStatuses: {
 export type JournalStorageReadResult<T> = {
     status: typeof JournalStorageReadStatuses.AVAILABLE;
     value: T;
+    readonly revision?: string;
 } | {
     status: typeof JournalStorageReadStatuses.NOT_FOUND;
 } | {
     status: typeof JournalStorageReadStatuses.UNAVAILABLE;
     error: unknown;
 };
+export type JournalStorageConditionalWriteResult = "updated" | "conflict" | "unsupported";
 export interface IJournalStorage {
     /** Release transport resources retained by this adapter, when any. */
     dispose?(): void;
     upload(key: string, data: Uint8Array, mime: string): Promise<boolean>;
+    uploadIfUnchanged?(key: string, data: Uint8Array, mime: string, revision: string): Promise<JournalStorageConditionalWriteResult>;
     download(key: string, ignoreCache?: boolean): Promise<Uint8Array | false>;
     downloadWithResult(key: string, ignoreCache?: boolean): Promise<JournalStorageReadResult<Uint8Array>>;
     listFiles(from: string, limit?: number): Promise<string[]>;

package/dist/replication/journal/objectstore/MinioStorageAdapter.d.ts

@@ -1,7 +1,7 @@
 import { S3 } from "@aws-sdk/client-s3";
 import { type BucketSyncSetting } from "../../../common/types.js";
 import type { RemoteDBStatus } from "../../LiveSyncAbstractReplicator.js";
-import { type IJournalStorage, type JournalStorageReadResult } from "./JournalStorageAdapter.js";
+import { type IJournalStorage, type JournalStorageConditionalWriteResult, type JournalStorageReadResult } from "./JournalStorageAdapter.js";
 import type { LiveSyncJournalReplicatorEnv } from "../LiveSyncJournalReplicatorEnv.js";
 export declare class MinioStorageAdapter implements IJournalStorage {
     _instance?: S3;
@@ -15,6 +15,7 @@ export declare class MinioStorageAdapter implements IJournalStorage {
     get customHeaders(): [string, string][];
     _getClient(): S3;
     upload(key: string, data: Uint8Array, mime: string): Promise<boolean>;
+    uploadIfUnchanged(key: string, data: Uint8Array, mime: string, revision: string): Promise<JournalStorageConditionalWriteResult>;
     downloadWithResult(key: string, ignoreCache?: boolean): Promise<JournalStorageReadResult<Uint8Array>>;
     download(key: string, ignoreCache?: boolean): Promise<Uint8Array | false>;
     listFiles(from: string, limit?: number): Promise<string[]>;

package/dist/replication/journal/objectstore/MinioStorageAdapter.js

@@ -119,6 +119,26 @@ class MinioStorageAdapter {
     }
     return false;
   }
+  async uploadIfUnchanged(key, data, mime, revision) {
+    if (revision.trim().length === 0) {
+      throw new TypeError("A non-empty revision is required for a conditional upload");
+    }
+    const client = this._getClient();
+    const cmd = new PutObjectCommand({
+      Bucket: this._settings.bucket,
+      Key: `${this._settings.bucketPrefix}${key}`,
+      Body: data,
+      ContentType: mime,
+      IfMatch: revision
+    });
+    try {
+      await this.runTrackedRequest(() => client.send(cmd));
+      return "updated";
+    } catch (ex) {
+      if (isConditionalWriteConflict(ex)) return "conflict";
+      throw ex;
+    }
+  }
   async downloadWithResult(key, ignoreCache = false) {
     const client = this._getClient();
     const cmd = new GetObjectCommand({
@@ -135,7 +155,8 @@ class MinioStorageAdapter {
         if (r.Body) {
           return {
             status: JournalStorageReadStatuses.AVAILABLE,
-            value: new Uint8Array(await r.Body.transformToByteArray())
+            value: new Uint8Array(await r.Body.transformToByteArray()),
+            ...r.ETag?.trim() ? { revision: r.ETag } : {}
           };
         }
         return {
@@ -227,6 +248,11 @@ class MinioStorageAdapter {
     }
   }
 }
+function isConditionalWriteConflict(error) {
+  if (!error || typeof error !== "object") return false;
+  const { httpStatusCode } = error.$metadata ?? {};
+  return httpStatusCode === 409 || httpStatusCode === 412;
+}
 function isMissingObjectError(error) {
   if (!error || typeof error !== "object") return false;
   const { name, Code, code } = error;

package/dist/replication/trystero/P2PRoomSessionOwner.d.ts

@@ -73,7 +73,7 @@ export declare class P2PRoomSessionOwner implements P2PRoomSessionAccess {
     private hasUsableTurnServer;
     private withRoomOpenDeadline;
     private assertReconciliationCurrent;
-    /** Capture immutable session inputs while keeping policy live. */
+    /** Read the device identity before capturing the current synchronous session inputs. */
     private getEffectiveBinding;
     /** Apply policy which can change without retiring the room session. */
     private reconcileCurrentSessionPolicy;

package/dist/replication/trystero/P2PRoomSessionOwner.js

@@ -70,7 +70,7 @@ class P2PRoomSessionOwner {
     } else if (active && !supportsPathIdentity) {
       Logger("P2P does not support NFC path identity.", LOG_LEVEL_NOTICE);
     }
-    this.fencePreparationForCurrentSettings(enabled);
+    await this.fencePreparationForCurrentSettings(enabled);
     await this.reconcileTransport();
   }
   /**
@@ -89,8 +89,8 @@ class P2PRoomSessionOwner {
     }
     const demand = /* @__PURE__ */ Symbol("p2p-finite-room-demand");
     this.finiteDemands.add(demand);
-    this.fencePreparationForCurrentSettings(true);
     try {
+      await this.fencePreparationForCurrentSettings(true);
       await this.reconcileTransport();
       if (!this.finiteDemands.has(demand)) {
         throw new Error("The P2P room demand was retired before the operation started.");
@@ -143,7 +143,8 @@ class P2PRoomSessionOwner {
         await this.closeTransport();
         return;
       }
-      const binding = this.getEffectiveBinding();
+      const binding = await this.getEffectiveBinding();
+      if (!binding.enabled || !this.hasRoomDemand()) return;
       if (this.current?.host.isServing && this.bindingsMatch(this.activeBinding, binding) && this.connectionSettingsRemainUsable(this.activeBinding?.settings)) {
         this.reconcileCurrentSessionPolicy(this.current);
         Logger("P2P replicator is already open.");
@@ -156,7 +157,7 @@ class P2PRoomSessionOwner {
       const operationGeneration = this.runtimeGeneration;
       try {
         const connectionSettings = await this.prepareConnectionSettings(binding, operationGeneration);
-        this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
+        await this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
         const connectionBinding = { ...binding, settings: connectionSettings };
         candidate = this.createSession(this.buildSessionEnv(connectionBinding));
         if (hasManagedP2PTurnConfiguration(binding.settings)) {
@@ -167,7 +168,7 @@ class P2PRoomSessionOwner {
         if (!candidate.host.isServing) {
           throw new Error("The P2P room did not start serving.");
         }
-        const currentBinding = this.getEffectiveBinding();
+        const currentBinding = await this.getEffectiveBinding();
         if (!currentBinding.enabled || !this.hasRoomDemand() || !this.bindingsMatch(binding, currentBinding) || operationGeneration !== this.runtimeGeneration || !this.connectionSettingsRemainUsable(connectionSettings)) {
           await candidate.retire();
           return;
@@ -243,13 +244,21 @@ class P2PRoomSessionOwner {
     if (expiresAt === void 0) return !managed;
     return Number.isFinite(expiresAt) && expiresAt > Date.now() + P2P_ICE_SERVER_EXPIRY_MARGIN_MS;
   }
-  fencePreparationForCurrentSettings(enabled) {
+  async fencePreparationForCurrentSettings(enabled) {
     if (!enabled) {
       this.invalidatePreparation();
       return;
     }
-    const pendingChanged = this.pendingPreparation !== void 0 && this.pendingPreparation.signature !== this.getEffectiveBinding().signature;
-    if (pendingChanged) this.invalidatePreparation();
+    const pending = this.pendingPreparation;
+    if (!pending) return;
+    if (pending.configurationIdentity !== getP2PReplicatorConfigurationIdentity(this.env.services.setting.currentSettings())) {
+      this.invalidatePreparation();
+      return;
+    }
+    const binding = await this.getEffectiveBinding();
+    if (this.pendingPreparation === pending && pending.signature !== binding.signature) {
+      this.invalidatePreparation();
+    }
   }
   invalidatePreparation() {
     this.runtimeGeneration += 1;
@@ -269,6 +278,7 @@ class P2PRoomSessionOwner {
     const controller = new AbortController();
     const pending = {
       signature: binding.signature,
+      configurationIdentity: getP2PReplicatorConfigurationIdentity(binding.settings),
       controller
     };
     this.pendingPreparation = pending;
@@ -288,7 +298,7 @@ class P2PRoomSessionOwner {
       if (!this.connectionSettingsRemainUsable(connectionSettings)) {
         throw new Error("The prepared managed TURN settings are missing usable ICE servers or expiry.");
       }
-      this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
+      await this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
       return connectionSettings;
     } finally {
       if (this.pendingPreparation === pending) {
@@ -359,23 +369,26 @@ class P2PRoomSessionOwner {
       if (timeout !== void 0) globalThis.clearTimeout(timeout);
     }
   }
-  assertReconciliationCurrent(binding, operationGeneration, connectionSettings) {
+  async assertReconciliationCurrent(binding, operationGeneration, connectionSettings) {
+    if (operationGeneration !== this.runtimeGeneration || !this.hasRoomDemand()) {
+      throw new StaleRoomReconciliationError();
+    }
+    const currentBinding = await this.getEffectiveBinding();
     if (operationGeneration !== this.runtimeGeneration || !this.hasRoomDemand()) {
       throw new StaleRoomReconciliationError();
     }
-    const currentBinding = this.getEffectiveBinding();
     if (!currentBinding.enabled) throw new StaleRoomReconciliationError();
     if (binding && !this.bindingsMatch(binding, currentBinding)) throw new StaleRoomReconciliationError();
     if (connectionSettings && !this.connectionSettingsRemainUsable(connectionSettings)) {
       throw new StaleRoomReconciliationError();
     }
   }
-  /** Capture immutable session inputs while keeping policy live. */
-  getEffectiveBinding() {
+  /** Read the device identity before capturing the current synchronous session inputs. */
+  async getEffectiveBinding() {
+    const deviceName = await this.env.services.config.getValue(SETTING_KEY_P2P_DEVICE_NAME) || this.env.services.vault.getVaultName();
     const settings = omitP2PRuntimeSettings({
       ...this.env.services.setting.currentSettings()
     });
-    const deviceName = this.env.services.config.getSmallConfig(SETTING_KEY_P2P_DEVICE_NAME) || this.env.services.vault.getVaultName();
     const database = this.env.services.database.localDatabase.localDatabase;
     this.automationCoordinator.reconcileIdentity(
       JSON.stringify([

package/dist/serviceModules/Rebuilder.js

@@ -404,7 +404,7 @@ Are you sure you wish to proceed?`;
     await this.suspendReflectingDatabase(!autoResume);
     await this.control.applySettings();
     await this.resetLocalDatabase();
-    this.clearFastFetchCheckpoint();
+    await this.clearFastFetchCheckpoint();
     await delay(1e3);
     if (isRemediationModeActive(this.setting.currentSettings())) {
       this._log(
@@ -470,10 +470,11 @@ Are you sure you wish to proceed?`;
     await this.checkPathIdentitiesBeforeReconstruction(false);
     await checkRemoteFeaturesForInitialSync(remote, authHeader, customHeaders, settings);
     this.appLifecycle.resetIsReady();
-    let checkpoint = this.getFastFetchCheckpoint(remote);
+    let checkpoint = await this.getFastFetchCheckpoint(remote);
     await this.suspendReflectingDatabase();
     await this.control.applySettings();
     let since = checkpoint?.sequence ?? "0";
+    let startsFresh = !checkpoint;
     if (checkpoint) {
       this._log(
         `Resuming fast database fetch from sequence: ${checkpoint.sequence}`,
@@ -497,16 +498,19 @@ Are you sure you wish to proceed?`;
         LOG_LEVEL_NOTICE,
         "fetch-init-resume"
       );
-      this.clearFastFetchCheckpoint();
+      await this.clearFastFetchCheckpoint();
       await this.resetLocalDatabase();
       await delay(1e3);
       localDB = this.database.localDatabase.localDatabase;
       since = "0";
+      startsFresh = true;
     }
     const securitySeed = await this.replicator.createRemoteResource(REMOTE_RESOURCE_KINDS.SECURITY_SEED, settings);
     if (!securitySeed) {
       throw new Error("The selected provider cannot supply a Security Seed for Fast Fetch.");
     }
+    let fastForwardResource;
+    let fastForward;
     try {
       const enc = getConfiguredFunctionsForEncryption(
         settings.passphrase,
@@ -515,6 +519,13 @@ Are you sure you wish to proceed?`;
         () => securitySeed.read(),
         settings.E2EEAlgorithm
       );
+      if (startsFresh && !settings.doNotSuspendOnFetching && (await localDB.info()).doc_count === 0) {
+        fastForwardResource = await this.replicator.createRemoteResource(
+          REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD,
+          this.setting.currentSettings()
+        );
+        fastForward = await fastForwardResource?.prepare();
+      }
       for (let attempt = 0; ; attempt++) {
         try {
           await fetchChangesForInitialSync(
@@ -531,13 +542,17 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
                 "fetch-init-progress"
               );
             },
-            (sequence) => this.saveFastFetchCheckpoint(remote, sequence),
-            customHeaders
+            async (sequence) => {
+              await this.saveFastFetchCheckpoint(remote, sequence);
+              fastForward?.recordCheckpoint(sequence);
+            },
+            customHeaders,
+            fastForward?.recordStoredRevisions
           );
           break;
         } catch (ex) {
           if (!isRetryableStreamingFetchFailure(ex) || attempt >= FAST_FETCH_RETRY_DELAYS.length) throw ex;
-          checkpoint = this.getFastFetchCheckpoint(remote);
+          checkpoint = await this.getFastFetchCheckpoint(remote);
           since = checkpoint?.sequence ?? since;
           this._log(
             `Fast fetch interrupted. Retrying from sequence: ${since}`,
@@ -547,6 +562,13 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
           await delay(FAST_FETCH_RETRY_DELAYS[attempt]);
         }
       }
+      if (fastForward) {
+        const advanced = await fastForward.fastForward();
+        this._log(
+          advanced ? "Advanced the ordinary replication checkpoints through the verified initial Fast Fetch." : "The initial Fast Fetch did not advance ordinary replication checkpoints.",
+          LOG_LEVEL_VERBOSE
+        );
+      }
       const allDocs = await localDB.allDocs({ include_docs: false });
       this._log(
         `Fast database fetch completed. Total documents in local database: ${allDocs.total_rows}`,
@@ -559,9 +581,13 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
           throw new Error("Fast Fetch could not be finalised.");
         }
       }
-      this.clearFastFetchCheckpoint();
+      await this.clearFastFetchCheckpoint();
     } finally {
-      await securitySeed.dispose();
+      try {
+        await fastForwardResource?.dispose();
+      } finally {
+        await securitySeed.dispose();
+      }
     }
   }
   /**
@@ -627,8 +653,8 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
     }
     this.events.emitEvent(EVENT_DATABASE_REBUILT);
   }
-  getFastFetchCheckpoint(remote) {
-    const rawCheckpoint = this.setting.getSmallConfig(FAST_FETCH_CHECKPOINT_KEY);
+  async getFastFetchCheckpoint(remote) {
+    const rawCheckpoint = await this.setting.config.getValue(FAST_FETCH_CHECKPOINT_KEY);
     if (!rawCheckpoint) return void 0;
     try {
       const checkpoint = JSON.parse(rawCheckpoint);
@@ -640,11 +666,11 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
       }
     } catch {
     }
-    this.clearFastFetchCheckpoint();
+    await this.clearFastFetchCheckpoint();
     return void 0;
   }
-  saveFastFetchCheckpoint(remote, sequence) {
-    this.setting.setSmallConfig(
+  async saveFastFetchCheckpoint(remote, sequence) {
+    await this.setting.config.setValue(
       FAST_FETCH_CHECKPOINT_KEY,
       JSON.stringify({
         remote,
@@ -653,8 +679,8 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
       })
     );
   }
-  clearFastFetchCheckpoint() {
-    this.setting.deleteSmallConfig(FAST_FETCH_CHECKPOINT_KEY);
+  async clearFastFetchCheckpoint() {
+    await this.setting.config.delete(FAST_FETCH_CHECKPOINT_KEY);
   }
 }
 export {

package/dist/services/BrowserServices.d.ts

@@ -1,9 +1,9 @@
+import type { IConfigService } from "./base/IService.js";
 import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import { ControlService } from "./base/ControlService.js";
 import type { AppLifecycleService } from "./base/AppLifecycleService.js";
-import type { ConfigService } from "./base/ConfigService.js";
 import type { ReplicatorService } from "./base/ReplicatorService.js";
 import type { UIService } from "./implements/base/UIService.js";
 import type { InjectableAPIService } from "./implements/injectable/InjectableAPIService.js";
@@ -12,7 +12,7 @@ import type { ObsidianLiveSyncSettings } from "../common/types.js";
 export type BrowserServiceHostDependencies<T extends ServiceContext> = {
     API: InjectableAPIService<T>;
     appLifecycle: AppLifecycleService<T>;
-    config: ConfigService<T>;
+    config: IConfigService;
     control: ControlService<T>;
     replicator: ReplicatorService<T>;
 };
@@ -29,6 +29,8 @@ export interface BrowserServiceHost<T extends ServiceContext> {
 export type BrowserServiceHubOptions<T extends ServiceContext> = {
     context?: T;
     host: BrowserServiceHost<T>;
+    /** Exact-key storage selected and owned by the application. */
+    deviceValues: IConfigService;
     openKeyValueDatabase?: KeyValueDatabaseFactory;
     onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;
 };

package/dist/services/BrowserServices.js

@@ -11,7 +11,6 @@ import { InjectableTestService } from "./implements/injectable/InjectableTestSer
 import { InjectableTweakValueService } from "./implements/injectable/InjectableTweakValueService.js";
 import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
-import { ConfigServiceBrowserCompat } from "./implements/browser/ConfigServiceBrowserCompat.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import { BrowserDatabaseService, BrowserKeyValueDBService } from "./implements/browser/BrowserDatabaseService.js";
 import { ControlService } from "./base/ControlService.js";
@@ -34,6 +33,7 @@ class BrowserServiceHub extends InjectableServiceHub {
     const fileProcessing = new InjectableFileProcessingService(context);
     const setting = new InjectableSettingService(context, {
       APIService: API,
+      deviceValues: options.deviceValues,
       onDisplayLanguageChanged: options.onDisplayLanguageChanged
     });
     const appLifecycle = new BrowserAppLifecycleService(context, { settingService: setting });
@@ -60,10 +60,7 @@ class BrowserServiceHub extends InjectableServiceHub {
       setting,
       API
     });
-    const config = new ConfigServiceBrowserCompat(context, {
-      settingService: setting,
-      APIService: API
-    });
+    const config = setting.config;
     const replicator = new InjectableReplicatorService(context, {
       settingService: setting,
       appLifecycleService: appLifecycle,

package/dist/services/HeadlessServices.d.ts

@@ -1,3 +1,4 @@
+import type { IConfigService } from "./base/IService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import type { DatabaseService } from "./base/DatabaseService.js";
@@ -9,6 +10,8 @@ export declare class HeadlessServiceHub<T extends ServiceContext> extends Inject
     constructor(_context: T | undefined, overrideServiceConstructor: {
         /** PouchDB with the adapters required by this headless runtime. */
         pouchDB: PouchDBConstructor;
+        /** Exact-key storage selected and owned by the application. */
+        deviceValues: IConfigService;
         database?: Constructor<DatabaseService<T>>;
         openKeyValueDatabase?: KeyValueDatabaseFactory;
         onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;

package/dist/services/HeadlessServices.js

@@ -11,7 +11,6 @@ import { InjectableTestService } from "./implements/injectable/InjectableTestSer
 import { InjectableTweakValueService } from "./implements/injectable/InjectableTweakValueService.js";
 import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
-import { ConfigServiceBrowserCompat } from "./implements/browser/ConfigServiceBrowserCompat.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import { UIService } from "./implements/base/UIService.js";
 import { HeadlessAPIService } from "./implements/headless/HeadlessAPIService.js";
@@ -56,6 +55,7 @@ class HeadlessServiceHub extends InjectableServiceHub {
     const fileProcessing = new InjectableFileProcessingService(context);
     const setting = new InjectableSettingService(context, {
       APIService: API,
+      deviceValues: overrideServiceConstructor.deviceValues,
       onDisplayLanguageChanged: overrideServiceConstructor.onDisplayLanguageChanged
     });
     const appLifecycle = new HeadlessAppLifecycleService(context, {
@@ -85,10 +85,7 @@ class HeadlessServiceHub extends InjectableServiceHub {
       vault,
       setting
     });
-    const config = new ConfigServiceBrowserCompat(context, {
-      settingService: setting,
-      APIService: API
-    });
+    const config = setting.config;
     const replicator = new InjectableReplicatorService(context, {
       settingService: setting,
       appLifecycleService: appLifecycle,

package/dist/services/ServiceHub.d.ts

@@ -1,5 +1,5 @@
+import type { IConfigService } from "./base/IService.js";
 import type { UIService } from "./implements/base/UIService.js";
-import type { ConfigService } from "./base/ConfigService.js";
 import type { TestService } from "./base/TestService.js";
 import type { VaultService } from "./base/VaultService.js";
 import type { TweakValueService } from "./base/TweakValueService.js";
@@ -34,7 +34,7 @@ export type ServiceInstances<T extends ServiceContext = ServiceContext> = {
     vault?: VaultService<T>;
     test?: TestService<T>;
     ui?: UIService<T>;
-    config?: ConfigService<T>;
+    config?: IConfigService;
     keyValueDB?: KeyValueDBService<T>;
     control?: ControlService<T>;
 };
@@ -56,7 +56,7 @@ export declare abstract class ServiceHub<T extends ServiceContext = ServiceConte
     protected abstract _vault: VaultService<T>;
     protected abstract _test: TestService<T>;
     protected abstract _ui: UIService<T>;
-    protected abstract _config: ConfigService<T>;
+    protected abstract _config: IConfigService;
     protected abstract _keyValueDB: KeyValueDBService<T>;
     protected abstract _control: ControlService<T>;
     protected _injected: ServiceInstances<T>;
@@ -76,7 +76,7 @@ export declare abstract class ServiceHub<T extends ServiceContext = ServiceConte
     get vault(): VaultService<T>;
     get test(): TestService<T>;
     get UI(): UIService<T>;
-    get config(): ConfigService<T>;
+    get config(): IConfigService;
     get keyValueDB(): KeyValueDBService<T>;
     get control(): ControlService<T>;
 }

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";
@@ -17,6 +18,7 @@ import type { RemoteResourceKind, RemoteResourceMap } from "../../replication/Re
 import type { CentralRemoteAdministrationRequest, CentralRemoteAdministrationResult } from "../../replication/CentralRemoteAdministration.js";
 import type { 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";
@@ -312,16 +314,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 +330,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 +367,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.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);