@vrtmrz/livesync-commonlib 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/rpc/transports/trysteroRoomEvents.js

@@ -0,0 +1,34 @@
+const subscribersByRoom = /* @__PURE__ */ new WeakMap();
+function getSubscribers(room) {
+  const existing = subscribersByRoom.get(room);
+  if (existing) return existing;
+  const subscribers = {
+    join: /* @__PURE__ */ new Set(),
+    leave: /* @__PURE__ */ new Set()
+  };
+  subscribersByRoom.set(room, subscribers);
+  room.onPeerJoin = (peerId) => {
+    for (const handler of [...subscribers.join]) handler(peerId);
+  };
+  room.onPeerLeave = (peerId) => {
+    for (const handler of [...subscribers.leave]) handler(peerId);
+  };
+  return subscribers;
+}
+function subscribeTrysteroPeerEvents(room, handlers) {
+  const subscribers = getSubscribers(room);
+  if (handlers.onJoin) subscribers.join.add(handlers.onJoin);
+  if (handlers.onLeave) subscribers.leave.add(handlers.onLeave);
+  return () => {
+    if (handlers.onJoin) subscribers.join.delete(handlers.onJoin);
+    if (handlers.onLeave) subscribers.leave.delete(handlers.onLeave);
+    if (subscribers.join.size === 0 && subscribers.leave.size === 0) {
+      room.onPeerJoin = null;
+      room.onPeerLeave = null;
+      subscribersByRoom.delete(room);
+    }
+  };
+}
+export {
+  subscribeTrysteroPeerEvents
+};

package/dist/serviceFeatures/remoteConfig.d.ts

@@ -1,5 +1,6 @@
 import { type LOG_LEVEL } from "../common/logger.js";
-import type { ObsidianLiveSyncSettings } from "../common/models/setting.type.js";
+import { type RemoteConfigurationResult } from "../common/ConnectionString.js";
+import type { ObsidianLiveSyncSettings, RemoteConfiguration } from "../common/models/setting.type.js";
 import type { NecessaryServices } from "../interfaces/ServiceModule.js";
 export type RemoteConfigHost = NecessaryServices<"setting" | "UI" | "replication" | "control" | "appLifecycle" | "API", never>;
 export declare function migrateLegacyRemoteConfigurationsInPlace(settings: ObsidianLiveSyncSettings, log?: (message: string, level?: LOG_LEVEL) => void): boolean;
@@ -8,6 +9,41 @@ export declare function migrateLegacyRemoteConfigurationsInPlace(settings: Obsid
  * @returns A unique string identifier.
  */
 export declare function createRemoteConfigurationId(): string;
+export type SerializableRemoteConfigurationType = Exclude<RemoteConfigurationResult["type"], "webdav">;
+export interface UpsertRemoteConfigurationOptions {
+    /**
+     * Reuse this identifier to update a known profile. Omit it to allocate a new opaque identifier.
+     */
+    id?: string;
+    /**
+     * User-visible name. Omit it to derive a descriptive name from the connection settings.
+     */
+    name?: string;
+    /**
+     * Select this profile as the main remote and project it onto the compatibility fields.
+     */
+    activate?: boolean;
+    /**
+     * Select this profile for P2P features without changing the main remote selection.
+     */
+    activateForP2P?: boolean;
+}
+/**
+ * Suggest a concise display name from a serialisable remote configuration.
+ *
+ * The name is presentation only. Callers must continue to use the profile ID for identity and
+ * `activeConfigurationId` for the selected main remote.
+ */
+export declare function suggestRemoteConfigurationName(configuration: RemoteConfigurationResult): string;
+/**
+ * Create or update a multiple-remote profile from the corresponding compatibility fields.
+ *
+ * This mutates `settings`. Passing an existing `id` intentionally replaces that profile; omitting
+ * it always allocates a new opaque ID and preserves all existing profiles. Generated display names
+ * are made unique for readability, but names never act as identifiers. The stored connection URI is
+ * plaintext at this boundary; `SettingService` applies configured at-rest encryption when saving it.
+ */
+export declare function upsertRemoteConfigurationInPlace(settings: ObsidianLiveSyncSettings, type: SerializableRemoteConfigurationType, options?: UpsertRemoteConfigurationOptions): RemoteConfiguration;
 /**
  * Keep compatibility for users who were already using P2P as their main active remote.
  */

package/dist/serviceFeatures/remoteConfig.js

@@ -51,6 +51,94 @@ function migrateLegacyRemoteConfigurationsInPlace(settings, log) {
 function createRemoteConfigurationId() {
   return `remote-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
+function toRemoteConfigurationResult(type, settings) {
+  if (type === "couchdb") {
+    return { type, settings };
+  }
+  if (type === "s3") {
+    return { type, settings };
+  }
+  return { type, settings };
+}
+function suggestRemoteConfigurationName(configuration) {
+  if (configuration.type === "couchdb") {
+    try {
+      const host = new URL(configuration.settings.couchDB_URI).host;
+      return host ? `CouchDB ${host}` : "CouchDB remote";
+    } catch {
+      return "CouchDB remote";
+    }
+  }
+  if (configuration.type === "s3") {
+    const bucket = configuration.settings.bucket.trim();
+    if (bucket) {
+      return `S3 ${bucket}`;
+    }
+    try {
+      const host = new URL(configuration.settings.endpoint).host;
+      return host ? `S3 ${host}` : "Object Storage remote";
+    } catch {
+      return "Object Storage remote";
+    }
+  }
+  if (configuration.type === "p2p") {
+    const room = configuration.settings.P2P_roomID.trim();
+    return room ? `P2P ${room}` : "P2P remote";
+  }
+  return "Remote configuration";
+}
+function allocateRemoteConfigurationId(configurations) {
+  let id = createRemoteConfigurationId();
+  while (configurations[id]) {
+    id = createRemoteConfigurationId();
+  }
+  return id;
+}
+function allocateRemoteConfigurationName(configurations, baseName, updatingId) {
+  const usedNames = new Set(
+    Object.values(configurations).filter((configuration) => configuration.id !== updatingId).map((configuration) => configuration.name)
+  );
+  if (!usedNames.has(baseName)) {
+    return baseName;
+  }
+  let suffix = 2;
+  while (usedNames.has(`${baseName} (${suffix})`)) {
+    suffix += 1;
+  }
+  return `${baseName} (${suffix})`;
+}
+function upsertRemoteConfigurationInPlace(settings, type, options = {}) {
+  if (options.activateForP2P && type !== "p2p") {
+    throw new Error("Only a P2P remote configuration can be selected for P2P features.");
+  }
+  const configurations = settings.remoteConfigurations ?? {};
+  const requestedId = options.id?.trim();
+  const id = requestedId || allocateRemoteConfigurationId(configurations);
+  const existing = configurations[id];
+  const serialisable = toRemoteConfigurationResult(type, settings);
+  const suggestedName = suggestRemoteConfigurationName(serialisable);
+  const requestedName = options.name?.trim();
+  const name = requestedName || existing?.name || allocateRemoteConfigurationName(configurations, suggestedName, existing?.id);
+  const configuration = {
+    id,
+    name,
+    uri: ConnectionStringParser.serialize(serialisable),
+    isEncrypted: false
+  };
+  settings.remoteConfigurations ??= configurations;
+  configurations[id] = configuration;
+  if (options.activate) {
+    if (!activateRemoteConfiguration(settings, id)) {
+      throw new Error(`Failed to activate remote configuration '${id}'.`);
+    }
+  }
+  if (options.activateForP2P) {
+    if (!activateP2PRemoteConfiguration(settings, id)) {
+      throw new Error(`Failed to activate P2P remote configuration '${id}'.`);
+    }
+  }
+  return configuration;
+}
 function migrateP2PActiveRemoteConfigurationIdInPlace(settings) {
   if ((settings.P2P_ActiveRemoteConfigurationId ?? "").trim() !== "") {
     return false;
@@ -242,6 +330,8 @@ export {
   migrateLegacyRemoteConfigurationsInPlace,
   migrateP2PActiveRemoteConfigurationIdInPlace,
   migrateToMultipleRemoteConfigurations,
+  suggestRemoteConfigurationName,
+  upsertRemoteConfigurationInPlace,
   useRemoteConfiguration,
   useRemoteConfigurationMigration
 };

package/dist/serviceModules/Rebuilder.d.ts

@@ -60,8 +60,9 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     $rebuildEverything(): Promise<void>;
     $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
     $fetchLocalDBFast(autoResume: boolean): Promise<void>;
-    scheduleRebuild(): Promise<void>;
-    scheduleFetch(): Promise<void>;
+    private scheduleInitialisation;
+    scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     private _tryResetRemoteDatabase;
     private _onResetLocalDatabase;
     suspendAllSync(): Promise<void>;

package/dist/serviceModules/Rebuilder.js

@@ -134,23 +134,35 @@ Please enable them from the settings screen after setup is complete.`,
   $fetchLocalDBFast(autoResume) {
     return this.fetchLocalDBFast(autoResume);
   }
-  async scheduleRebuild() {
+  async scheduleInitialisation(flag, prepareBeforeRestart) {
     try {
-      await this.storageAccess.writeFileAuto(FlagFilesHumanReadable.REBUILD_ALL, "");
+      await this.storageAccess.writeFileAuto(flag, "");
     } catch (ex) {
-      this._log(`Could not create ${FlagFilesHumanReadable.REBUILD_ALL}`, LOG_LEVEL_NOTICE);
+      this._log(`Could not create ${flag}`, LOG_LEVEL_NOTICE);
       this._log(ex, LOG_LEVEL_VERBOSE);
+      return false;
     }
-    this.appLifecycle.performRestart();
-  }
-  async scheduleFetch() {
+    this.appLifecycle.setSuspended(true);
     try {
-      await this.storageAccess.writeFileAuto(FlagFilesHumanReadable.FETCH_ALL, "");
+      await prepareBeforeRestart?.();
     } catch (ex) {
-      this._log(`Could not create ${FlagFilesHumanReadable.FETCH_ALL}`, LOG_LEVEL_NOTICE);
-      this._log(ex, LOG_LEVEL_VERBOSE);
+      try {
+        await this.storageAccess.delete(flag, true);
+      } catch (cleanupError) {
+        this._log(`Could not remove ${flag} after restart preparation failed`, LOG_LEVEL_NOTICE);
+        this._log(cleanupError, LOG_LEVEL_VERBOSE);
+      }
+      this.appLifecycle.setSuspended(false);
+      throw ex;
     }
     this.appLifecycle.performRestart();
+    return true;
+  }
+  scheduleRebuild(prepareBeforeRestart) {
+    return this.scheduleInitialisation(FlagFilesHumanReadable.REBUILD_ALL, prepareBeforeRestart);
+  }
+  scheduleFetch(prepareBeforeRestart) {
+    return this.scheduleInitialisation(FlagFilesHumanReadable.FETCH_ALL, prepareBeforeRestart);
   }
   async _tryResetRemoteDatabase() {
     const currentReplicator = this.replicator.getActiveReplicator();

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

@@ -1,6 +1,6 @@
 import type { FetchHttpHandler } from "@smithy/fetch-http-handler";
 import { type LOG_LEVEL } from "octagonal-wheels/common/logger";
-import type { AnyEntry, AUTO_MERGED, CouchDBCredentials, diff_result, DocumentID, EntryDoc, EntryHasPath, FileEventItem, FilePath, FilePathWithPrefix, LoadedEntry, MetaEntry, MISSING_OR_ERROR, ObsidianLiveSyncSettings, RemoteDBSettings, TweakValues, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
+import type { AnyEntry, AUTO_MERGED, CouchDBCredentials, diff_result, DocumentID, EntryDoc, EntryHasPath, FileEventItem, FilePath, FilePathWithPrefix, LoadedEntry, MetaEntry, MISSING_OR_ERROR, ObsidianLiveSyncSettings, RemoteDBSettings, SettingsMigrationState, TweakValues, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
 import type { LiveSyncLocalDB } from "../../pouchdb/LiveSyncLocalDB.js";
 import type { LiveSyncAbstractReplicator } from "../../replication/LiveSyncAbstractReplicator.js";
 import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
@@ -117,6 +117,7 @@ export interface IReplicationService {
     processVirtualDocument(docs: PouchDB.Core.ExistingDocument<EntryDoc>): Promise<boolean>;
     onBeforeReplicate(showMessage: boolean): Promise<boolean>;
     checkConnectionFailure(): Promise<boolean | "CHECKAGAIN" | undefined>;
+    /** Lightweight, idempotent policy checks which every replication entry point may invoke. */
     onCheckReplicationReady(showMessage: boolean): Promise<boolean>;
     isReplicationReady(showMessage: boolean): Promise<boolean>;
     performReplication(showMessage?: boolean): Promise<boolean | void>;
@@ -197,9 +198,19 @@ export interface ISettingService {
     decryptSettings(settings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings>;
     adjustSettings(settings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings>;
     loadSettings(): Promise<void>;
+    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;
     onBeforeSaveSettingData(nextSettings: ObsidianLiveSyncSettings, previousSettings: ObsidianLiveSyncSettings): Promise<(Partial<ObsidianLiveSyncSettings> | void)[]>;
     saveSettingData(): Promise<void>;
     currentSettings(): ObsidianLiveSyncSettings;

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

@@ -49,7 +49,9 @@ export declare abstract class ReplicationService<T extends ServiceContext = Serv
      */
     readonly onBeforeReplicate: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showMessage: boolean) => Promise<boolean>>;
     /**
-     *
+     * Lightweight, repeatable policy checks shared by every replication entry point.
+     * Handlers must remain idempotent because a high-level replication may cross
+     * more than one entry point before work begins.
      */
     readonly onCheckReplicationReady: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showMessage: boolean) => Promise<boolean>>;
     /**

package/dist/services/base/ReplicationService.js

@@ -60,7 +60,9 @@ class ReplicationService extends ServiceBase {
    */
   onBeforeReplicate = handlers().bailFirstFailure("onBeforeReplicate");
   /**
-   *
+   * Lightweight, repeatable policy checks shared by every replication entry point.
+   * Handlers must remain idempotent because a high-level replication may cross
+   * more than one entry point before work begins.
    */
   onCheckReplicationReady = handlers().bailFirstFailure("onCheckReplicationReady");
   /**
@@ -72,6 +74,9 @@ class ReplicationService extends ServiceBase {
       this._log(`Not ready`);
       return false;
     }
+    if (!await this.onCheckReplicationReady(showMessage)) {
+      return false;
+    }
     const currentSettings = this.settingService.currentSettings();
     if (isLockAcquired("cleanup")) {
       this._log(this.context.translate("Replicator.Message.Cleaned"), LOG_LEVEL_NOTICE);

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

@@ -1,4 +1,4 @@
-import { type ObsidianLiveSyncSettings } from "../../common/types.js";
+import { type ObsidianLiveSyncSettings, type SettingsMigrationState } from "../../common/types.js";
 import type { IAPIService, ISettingService } from "./IService.js";
 import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
 import { createInstanceLogFunction } from "../lib/logUtils.js";
@@ -17,6 +17,8 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     protected abstract saveData(setting: ObsidianLiveSyncSettings): Promise<void>;
     protected abstract loadData(): Promise<ObsidianLiveSyncSettings | undefined>;
     private _lastPersistedSettings?;
+    private _settingsMigrationState?;
+    getSettingsMigrationState(): SettingsMigrationState | undefined;
     _log: ReturnType<typeof createInstanceLogFunction>;
     constructor(context: T, dependencies: SettingServiceDependencies);
     /**
@@ -37,6 +39,17 @@ 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;
     private additionalSuffixOfDatabaseName;
     private getKey;
     setSmallConfig(key: string, value: string): void;

package/dist/services/base/SettingService.js

@@ -1,11 +1,11 @@
 import {
   ChunkAlgorithmNames,
-  DEFAULT_SETTINGS,
   LOG_LEVEL_NOTICE,
   LOG_LEVEL_URGENT,
   LOG_LEVEL_VERBOSE,
   SALT_OF_PASSPHRASE,
-  SETTING_KEY_P2P_DEVICE_NAME
+  SETTING_KEY_P2P_DEVICE_NAME,
+  prepareSettingsForLoad
 } from "../../common/types.js";
 import { handlers } from "../lib/HandlerUtils.js";
 import { ServiceBase } from "./ServiceBase.js";
@@ -31,6 +31,10 @@ class SettingService extends ServiceBase {
     this._settings = value;
   }
   _lastPersistedSettings;
+  _settingsMigrationState;
+  getSettingsMigrationState() {
+    return this._settingsMigrationState;
+  }
   _log;
   constructor(context, dependencies) {
     super(context);
@@ -88,7 +92,24 @@ class SettingService extends ServiceBase {
    */
   saveDeviceAndVaultName() {
     const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
-    this.setItem(lsKey, this.deviceAndVaultName);
+    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);
   }
   additionalSuffixOfDatabaseName() {
     const suffix = this.settings?.additionalSuffixOfDatabaseName;
@@ -105,15 +126,15 @@ class SettingService extends ServiceBase {
   }
   setSmallConfig(key, value) {
     const dbKey = this.getKey(key);
-    this.setItem(dbKey, value);
+    this.setDeviceLocalConfig(dbKey, value);
   }
   getSmallConfig(key) {
     const dbKey = this.getKey(key);
-    return this.getItem(dbKey);
+    return this.getDeviceLocalConfig(dbKey) ?? "";
   }
   deleteSmallConfig(key) {
     const dbKey = this.getKey(key);
-    this.deleteItem(dbKey);
+    this.deleteDeviceLocalConfig(dbKey);
   }
   /**
    * Save the current settings to storage.
@@ -332,7 +353,7 @@ class SettingService extends ServiceBase {
   getPassphrase(settings) {
     const methods = {
       "": () => Promise.resolve("*"),
-      LOCALSTORAGE: () => Promise.resolve(this.getItem("ls-setting-passphrase") ?? false),
+      LOCALSTORAGE: () => Promise.resolve(this.getDeviceLocalConfig("ls-setting-passphrase") ?? false),
       ASK_AT_LAUNCH: () => this.APIService.confirm.askString("Passphrase", "passphrase", "")
     };
     const method = settings.configPassphraseStore;
@@ -445,10 +466,12 @@ class SettingService extends ServiceBase {
     return settings;
   }
   async loadSettings() {
-    const settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+    const prepared = prepareSettingsForLoad(await this.loadData());
+    const { settings, ...migrationState } = prepared;
+    this._settingsMigrationState = migrationState;
     const hadRemoteConfigurations = Object.keys(settings.remoteConfigurations ?? {}).length > 0;
     if (typeof settings.isConfigured == "undefined") {
-      if (JSON.stringify(settings) !== JSON.stringify(DEFAULT_SETTINGS)) {
+      if (!prepared.isNewVault) {
         settings.isConfigured = true;
       } else {
         const appId = this.APIService.getAppID();
@@ -493,7 +516,7 @@ class SettingService extends ServiceBase {
     }
     const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
     if (this.settings.deviceAndVaultName != "") {
-      if (!this.getItem(lsKey)) {
+      if (!this.getDeviceLocalConfig(lsKey)) {
         this.setDeviceAndVaultName(this.settings.deviceAndVaultName);
         this.saveDeviceAndVaultName();
         this.settings.deviceAndVaultName = "";
@@ -506,14 +529,14 @@ class SettingService extends ServiceBase {
       );
       this.settings.customChunkSize = 0;
     }
-    this.setDeviceAndVaultName(this.getItem(lsKey) || "");
+    this.setDeviceAndVaultName(this.getDeviceLocalConfig(lsKey) || "");
     if (this.getDeviceAndVaultName() == "") {
       if (this.settings.usePluginSync) {
         this._log("Device name missing. Disabling plug-in sync.", LOG_LEVEL_NOTICE);
         this.settings.usePluginSync = false;
       }
     }
-    if (migratedLegacyRemoteConfigurations || migratedP2PActiveRemoteConfiguration) {
+    if (!prepared.isFromFutureSchema && (prepared.changed || migratedLegacyRemoteConfigurations || migratedP2PActiveRemoteConfiguration)) {
       await this.saveSettingData();
     }
     this._lastPersistedSettings = this.cloneSettings(this.settings);

package/dist/services/implements/headless/HeadlessAPIService.d.ts

@@ -22,7 +22,7 @@ export declare class HeadlessConfirm implements Confirm {
         defaultAction: T[number];
         timeout?: number;
     }): Promise<T[number] | false>;
-    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void): void;
+    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void, durationMs?: number): void;
     confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false>;
 }
 export declare class HeadlessAPIService<T extends ServiceContext> extends InjectableAPIService<T> {

package/dist/services/implements/headless/HeadlessAPIService.js

@@ -23,7 +23,7 @@ class HeadlessConfirm {
     console.error(`[Headless] ${opt.title ?? "Confirm"}: ${message} \u2192 ${String(opt.defaultAction)}`);
     return Promise.resolve(opt.defaultAction);
   }
-  askInPopup(key, dialogText, anchorCallback) {
+  askInPopup(key, dialogText, anchorCallback, durationMs) {
     console.error(`[Headless] Popup (${key}): ${dialogText}`);
   }
   confirmWithMessage(title, contentMd, buttons, defaultAction, timeout) {

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

@@ -1,14 +1,14 @@
 import type { ServiceContext } from "../../base/ServiceBase.js";
 import { TweakValueService } from "../../base/TweakValueService.js";
 export declare class InjectableTweakValueService<T extends ServiceContext> extends TweakValueService<T> {
-    fetchRemotePreferred: import("../../lib/HandlerUtils.js").HandlerFunction<(trialSetting: import("../../../common/types.js").RemoteDBSettings) => Promise<import("../../../common/types.js").TweakValues | false>, unknown>;
+    fetchRemotePreferred: import("../../lib/HandlerUtils.js").HandlerFunction<(trialSetting: import("../../../settings.js").RemoteDBSettings) => Promise<import("../../../common/types.js").TweakValues | false>, unknown>;
     checkAndAskResolvingMismatched: import("../../lib/HandlerUtils.js").HandlerFunction<(preferred: Partial<import("../../../common/types.js").TweakValues>) => Promise<[import("../../../common/types.js").TweakValues | boolean, boolean]>, unknown>;
     askResolvingMismatched: import("../../lib/HandlerUtils.js").HandlerFunction<(preferredSource: import("../../../common/types.js").TweakValues) => Promise<"OK" | "CHECKAGAIN" | "IGNORE">, unknown>;
-    checkAndAskUseRemoteConfiguration: import("../../lib/HandlerUtils.js").HandlerFunction<(settings: import("../../../common/types.js").RemoteDBSettings) => Promise<{
+    checkAndAskUseRemoteConfiguration: import("../../lib/HandlerUtils.js").HandlerFunction<(settings: import("../../../settings.js").RemoteDBSettings) => Promise<{
         result: false | import("../../../common/types.js").TweakValues;
         requireFetch: boolean;
     }>, unknown>;
-    askUseRemoteConfiguration: import("../../lib/HandlerUtils.js").HandlerFunction<(trialSetting: import("../../../common/types.js").RemoteDBSettings, preferred: import("../../../common/types.js").TweakValues) => Promise<{
+    askUseRemoteConfiguration: import("../../lib/HandlerUtils.js").HandlerFunction<(trialSetting: import("../../../settings.js").RemoteDBSettings, preferred: import("../../../common/types.js").TweakValues) => Promise<{
         result: false | import("../../../common/types.js").TweakValues;
         requireFetch: boolean;
     }>, unknown>;

package/dist/settings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Settings defaults and migration contracts shared by maintained hosts.
+ *
+ * @packageDocumentation
+ */
+export { DEFAULT_SETTINGS, NEW_VAULT_SETTINGS, P2P_DEFAULT_SETTINGS, SETTINGS_SCHEMA_DEFAULTS, createNewVaultSettings, } from "./common/models/setting.const.defaults.js";
+export { PREFERRED_BASE, PREFERRED_JOURNAL_SYNC, PREFERRED_SETTING_CLOUDANT, PREFERRED_SETTING_SELF_HOSTED, } from "./common/models/setting.const.preferred.js";
+export { CURRENT_SETTING_VERSION } from "./common/models/setting.const.js";
+export { prepareSettingsForLoad, SettingsMigrationReviewCodes, type PreparedSettings, type SettingsMigrationReviewCode, type SettingsMigrationReviewReason, type SettingsMigrationState, } from "./common/models/setting.lifecycle.js";
+export type { ObsidianLiveSyncSettings, RemoteDBSettings, RemoteTypeSettings, } from "./common/models/setting.type.js";

package/dist/settings.js

@@ -0,0 +1,32 @@
+import {
+  DEFAULT_SETTINGS,
+  NEW_VAULT_SETTINGS,
+  P2P_DEFAULT_SETTINGS,
+  SETTINGS_SCHEMA_DEFAULTS,
+  createNewVaultSettings
+} from "./common/models/setting.const.defaults.js";
+import {
+  PREFERRED_BASE,
+  PREFERRED_JOURNAL_SYNC,
+  PREFERRED_SETTING_CLOUDANT,
+  PREFERRED_SETTING_SELF_HOSTED
+} from "./common/models/setting.const.preferred.js";
+import { CURRENT_SETTING_VERSION } from "./common/models/setting.const.js";
+import {
+  prepareSettingsForLoad,
+  SettingsMigrationReviewCodes
+} from "./common/models/setting.lifecycle.js";
+export {
+  CURRENT_SETTING_VERSION,
+  DEFAULT_SETTINGS,
+  NEW_VAULT_SETTINGS,
+  P2P_DEFAULT_SETTINGS,
+  PREFERRED_BASE,
+  PREFERRED_JOURNAL_SYNC,
+  PREFERRED_SETTING_CLOUDANT,
+  PREFERRED_SETTING_SELF_HOSTED,
+  SETTINGS_SCHEMA_DEFAULTS,
+  SettingsMigrationReviewCodes,
+  createNewVaultSettings,
+  prepareSettingsForLoad
+};