@vrtmrz/livesync-commonlib 0.1.22 → 0.1.24

package/dist/common/models/fileaccess.type.d.ts

@@ -53,6 +53,8 @@ export type FileEventArgs = {
     file: UXFileInfoStub | UXInternalFileInfoStub;
     cache?: CacheData;
     oldPath?: string;
+    /** The destination of a rename converted to DELETE after target filtering. */
+    renameTarget?: string;
     ctx?: unknown;
 };
 export type FileEventItem = {

package/dist/common/models/tweak.compatibility.d.ts

@@ -0,0 +1,34 @@
+import { type TweakReconstruction, type TweakValues } from "./tweak.definition.js";
+export type TweakAssessmentRelation = "equal" | "different" | "unadvertised";
+export interface TweakAssessmentValue {
+    readonly present: boolean;
+    readonly rawValue: TweakValues[keyof TweakValues];
+    readonly effectiveValue: TweakValues[keyof TweakValues];
+}
+export interface TweakAssessmentEntry {
+    readonly key: keyof TweakValues;
+    readonly current: TweakAssessmentValue;
+    readonly preferred: TweakAssessmentValue;
+    readonly relation: TweakAssessmentRelation;
+}
+export interface TweakTransitionReason {
+    readonly key: keyof TweakValues;
+    readonly reconstruction: Exclude<TweakReconstruction, "none">;
+}
+export interface TweakTransition {
+    readonly changes: Readonly<TweakValues>;
+    readonly reconstruction: TweakReconstruction;
+    readonly reasons: readonly TweakTransitionReason[];
+}
+export interface TweakAssessment {
+    readonly alignment: "matched" | "mismatched";
+    readonly representationDiffers: boolean;
+    readonly entries: readonly TweakAssessmentEntry[];
+    readonly adoptPreferred: TweakTransition;
+    readonly adoptCurrent: TweakTransition;
+    readonly onlyCompatibleLossyDifferences: boolean;
+    readonly currentValues: Readonly<TweakValues>;
+    readonly preferredValues: Readonly<TweakValues>;
+}
+/** Assess the semantic and stored-representation relationship between two tweak snapshots. */
+export declare function assessTweakCompatibility(current: Readonly<TweakValues>, preferred: Readonly<TweakValues>): TweakAssessment;

package/dist/common/models/tweak.compatibility.js

@@ -0,0 +1,110 @@
+import {
+  TweakCompatibilityRules,
+  TweakValuesTemplate
+} from "./tweak.definition.js";
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function snapshotTweakValues(values) {
+  const snapshot = {};
+  for (const key of Object.keys(TweakValuesTemplate)) {
+    if (hasOwn(values, key)) snapshot[key] = values[key];
+  }
+  return Object.freeze(snapshot);
+}
+function assessedValue(values, key, knownDefault) {
+  const present = hasOwn(values, key);
+  const rawValue = values[key];
+  const effectiveValue = rawValue === void 0 ? knownDefault : rawValue;
+  return Object.freeze({ present, rawValue, effectiveValue });
+}
+function highestReconstruction(current, next) {
+  if (current === "required" || next === "required") return "required";
+  return "recommended";
+}
+function reconstructionForTransition(key, from, to) {
+  const rule = TweakCompatibilityRules.find((candidate) => candidate.key === key);
+  if (!rule) return "none";
+  let reconstruction = rule.reconstruction;
+  const extensibleRule = rule;
+  for (const pattern of extensibleRule.specificPatterns ?? []) {
+    const matchesFrom = hasOwn(pattern, "from") && pattern.from === from;
+    const matchesTo = hasOwn(pattern, "to") && pattern.to === to;
+    if (matchesFrom || matchesTo) {
+      reconstruction = highestReconstruction(reconstruction, pattern.reconstruction);
+    }
+  }
+  return reconstruction;
+}
+function transition(entries, sourceSide, targetSide) {
+  const changes = {};
+  const reasons = [];
+  let reconstruction = "none";
+  for (const entry of entries) {
+    const source = entry[sourceSide];
+    const target = entry[targetSide];
+    const sourceAdvertised = source.present && source.rawValue !== void 0;
+    const targetAdvertised = target.present && target.rawValue !== void 0;
+    const effectiveValueDiffers = source.effectiveValue !== target.effectiveValue;
+    const shouldFillMissingTarget = !targetAdvertised && sourceAdvertised;
+    if (source.effectiveValue === void 0 || !effectiveValueDiffers && !shouldFillMissingTarget) continue;
+    changes[entry.key] = source.effectiveValue;
+    if (entry.relation === "equal") continue;
+    const effect = reconstructionForTransition(entry.key, target.effectiveValue, source.effectiveValue);
+    if (effect === "none") continue;
+    const reason = Object.freeze({
+      key: entry.key,
+      reconstruction: effect
+    });
+    reasons.push(reason);
+    reconstruction = highestReconstruction(reconstruction, reason.reconstruction);
+  }
+  return Object.freeze({
+    changes: Object.freeze(changes),
+    reconstruction,
+    reasons: Object.freeze(reasons)
+  });
+}
+function assessTweakCompatibility(current, preferred) {
+  const currentValues = snapshotTweakValues(current);
+  const preferredValues = snapshotTweakValues(preferred);
+  let representationDiffers = false;
+  const entries = TweakCompatibilityRules.map((rule) => {
+    const knownDefault = "knownDefault" in rule ? rule.knownDefault : void 0;
+    const currentValue = assessedValue(currentValues, rule.key, knownDefault);
+    const preferredValue = assessedValue(preferredValues, rule.key, knownDefault);
+    const currentAdvertised = currentValue.present && currentValue.rawValue !== void 0;
+    const preferredAdvertised = preferredValue.present && preferredValue.rawValue !== void 0;
+    let relation;
+    if ((!currentAdvertised || !preferredAdvertised) && knownDefault === void 0) {
+      relation = "unadvertised";
+    } else {
+      relation = currentValue.effectiveValue === preferredValue.effectiveValue ? "equal" : "different";
+    }
+    if (currentValue.present !== preferredValue.present || currentValue.rawValue !== preferredValue.rawValue) {
+      representationDiffers = true;
+    }
+    return Object.freeze({
+      key: rule.key,
+      current: currentValue,
+      preferred: preferredValue,
+      relation
+    });
+  });
+  const frozenEntries = Object.freeze(entries);
+  const differences = frozenEntries.filter(({ relation }) => relation === "different");
+  const compatibleLossyKeys = new Set(
+    TweakCompatibilityRules.filter((rule) => "compatibleLossyOrder" in rule).map(({ key }) => key)
+  );
+  return Object.freeze({
+    alignment: differences.length === 0 ? "matched" : "mismatched",
+    representationDiffers,
+    entries: frozenEntries,
+    adoptPreferred: transition(frozenEntries, "preferred", "current"),
+    adoptCurrent: transition(frozenEntries, "current", "preferred"),
+    onlyCompatibleLossyDifferences: differences.length > 0 && differences.every(({ key }) => compatibleLossyKeys.has(key)) && !frozenEntries.some(({ relation }) => relation === "unadvertised"),
+    currentValues,
+    preferredValues
+  });
+}
+export {
+  assessTweakCompatibility
+};

package/dist/common/models/tweak.definition.d.ts

@@ -1,5 +1,91 @@
 import type { ObsidianLiveSyncSettings } from "./setting.type.js";
-export declare const TweakValuesShouldMatchedTemplate: Partial<ObsidianLiveSyncSettings>;
+export type TweakReconstruction = "none" | "recommended" | "required";
+/**
+ * Single source for tweak comparison semantics and the maintained legacy
+ * compatibility projections below.
+ */
+export declare const TweakCompatibilityRules: readonly [{
+    readonly key: "minimumChunkSize";
+    readonly templateValue: 20;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "longLineThreshold";
+    readonly templateValue: 250;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "encrypt";
+    readonly templateValue: false;
+    readonly reconstruction: "required";
+}, {
+    readonly key: "usePathObfuscation";
+    readonly templateValue: false;
+    readonly reconstruction: "required";
+}, {
+    readonly key: "enableCompression";
+    readonly templateValue: false;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "useEden";
+    readonly templateValue: false;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "customChunkSize";
+    readonly templateValue: 0;
+    readonly reconstruction: "recommended";
+    readonly compatibleLossyOrder: 1;
+}, {
+    readonly key: "useDynamicIterationCount";
+    readonly templateValue: false;
+    readonly reconstruction: "required";
+}, {
+    readonly key: "hashAlg";
+    readonly templateValue: "xxhash64";
+    readonly reconstruction: "recommended";
+    readonly compatibleLossyOrder: 0;
+}, {
+    readonly key: "enableChunkSplitterV2";
+    readonly templateValue: false;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "maxChunksInEden";
+    readonly templateValue: 10;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "maxTotalLengthInEden";
+    readonly templateValue: 1024;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "maxAgeInEden";
+    readonly templateValue: 10;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "usePluginSyncV2";
+    readonly templateValue: false;
+    readonly reconstruction: "none";
+    readonly knownDefault: false;
+}, {
+    readonly key: "handleFilenameCaseSensitive";
+    readonly templateValue: false;
+    readonly reconstruction: "required";
+    readonly knownDefault: false;
+}, {
+    readonly key: "useSegmenter";
+    readonly templateValue: false;
+    readonly reconstruction: "none";
+}, {
+    readonly key: "E2EEAlgorithm";
+    readonly templateValue: "v2";
+    readonly reconstruction: "none";
+    readonly knownDefault: import("./setting.type.js").E2EEAlgorithm;
+}, {
+    readonly key: "chunkSplitterVersion";
+    readonly templateValue: "v3-rabin-karp";
+    readonly reconstruction: "recommended";
+    readonly knownDefault: import("./setting.type.js").ChunkSplitterVersion;
+    readonly compatibleLossyOrder: 2;
+}];
+export type TweakComparedKey = (typeof TweakCompatibilityRules)[number]["key"];
+export declare const TweakValuesShouldMatchedTemplate: Pick<ObsidianLiveSyncSettings, TweakComparedKey>;
 type TweakKeys = keyof TweakValues;
 export declare const IncompatibleChanges: TweakKeys[];
 export declare const CompatibleButLossyChanges: TweakKeys[];
@@ -19,6 +105,24 @@ export declare const TweakValuesRecommendedTemplate: Partial<ObsidianLiveSyncSet
 export declare const TweakValuesDefault: Partial<ObsidianLiveSyncSettings>;
 export declare const TweakValuesTemplate: {
     tweakModified: number;
+    usePluginSyncV2: boolean;
+    encrypt: boolean;
+    usePathObfuscation: boolean;
+    E2EEAlgorithm: import("./setting.type.js").E2EEAlgorithm;
+    hashAlg: import("./setting.type.js").HashAlgorithm;
+    minimumChunkSize: number;
+    customChunkSize: number;
+    longLineThreshold: number;
+    useSegmenter: boolean;
+    enableChunkSplitterV2: boolean;
+    chunkSplitterVersion: import("./setting.type.js").ChunkSplitterVersion;
+    useEden: boolean;
+    maxChunksInEden: number;
+    maxTotalLengthInEden: number;
+    maxAgeInEden: number;
+    useDynamicIterationCount: boolean;
+    enableCompression: boolean;
+    handleFilenameCaseSensitive: boolean;
     liveSync?: boolean;
     syncOnSave?: boolean;
     syncOnStart?: boolean;
@@ -72,7 +176,6 @@ export declare const TweakValuesTemplate: {
     autoSweepPluginsPeriodic?: boolean;
     notifyPluginOrSettingUpdated?: boolean;
     deviceAndVaultName?: string;
-    usePluginSyncV2?: boolean;
     usePluginEtc?: boolean;
     pluginSyncExtendedSetting?: Record<import("./setting.type.js").PluginSyncSettingEntry["key"], import("./setting.type.js").PluginSyncSettingEntry>;
     useAdvancedMode?: boolean;
@@ -124,34 +227,18 @@ export declare const TweakValuesTemplate: {
     bucketPrefix?: string;
     forcePathStyle?: boolean;
     remoteType?: import("./setting.type.js").RemoteType;
-    encrypt?: boolean;
     passphrase?: string;
-    usePathObfuscation?: boolean;
-    E2EEAlgorithm?: import("./setting.type.js").E2EEAlgorithm;
-    hashAlg?: import("./setting.type.js").HashAlgorithm;
-    minimumChunkSize?: number;
-    customChunkSize?: number;
-    longLineThreshold?: number;
-    useSegmenter?: boolean;
-    enableChunkSplitterV2?: boolean;
     doNotUseFixedRevisionForChunks?: boolean;
-    chunkSplitterVersion?: import("./setting.type.js").ChunkSplitterVersion;
-    useEden?: boolean;
-    maxChunksInEden?: number;
-    maxTotalLengthInEden?: number;
-    maxAgeInEden?: number;
     checkIntegrityOnSave?: boolean;
     useHistory?: boolean;
     disableRequestURI?: boolean;
     sendChunksBulk?: boolean;
     sendChunksBulkMaxSize?: number;
-    useDynamicIterationCount?: boolean;
     doNotPaceReplication?: boolean;
     readChunksOnline?: boolean;
     useOnlyLocalChunk?: boolean;
     concurrencyOfReadChunksOnline?: number;
     minimumIntervalOfReadChunksOnline?: number;
-    enableCompression?: boolean;
     batch_size?: number;
     batches_limit?: number;
     ignoreVersionCheck?: boolean;
@@ -160,7 +247,6 @@ export declare const TweakValuesTemplate: {
     hashCacheMaxCount?: number;
     hashCacheMaxAmount?: number;
     permitEmptyPassphrase?: boolean;
-    handleFilenameCaseSensitive?: boolean;
     checkConflictOnlyOnOpen?: boolean;
     showMergeDialogOnlyOnActive?: boolean;
     additionalSuffixOfDatabaseName?: string | undefined;

package/dist/common/models/tweak.definition.js

@@ -1,33 +1,63 @@
 import { ChunkAlgorithms, E2EEAlgorithms } from "./setting.const.js";
 import { DEFAULT_SETTINGS } from "./setting.const.defaults.js";
-const TweakValuesShouldMatchedTemplate = {
-  minimumChunkSize: 20,
-  longLineThreshold: 250,
-  encrypt: false,
-  usePathObfuscation: false,
-  enableCompression: false,
-  useEden: false,
-  customChunkSize: 0,
-  useDynamicIterationCount: false,
-  hashAlg: "xxhash64",
-  enableChunkSplitterV2: false,
-  maxChunksInEden: 10,
-  maxTotalLengthInEden: 1024,
-  maxAgeInEden: 10,
-  usePluginSyncV2: false,
-  handleFilenameCaseSensitive: false,
-  useSegmenter: false,
-  E2EEAlgorithm: E2EEAlgorithms.V2,
-  chunkSplitterVersion: ChunkAlgorithms.RabinKarp
-};
+const TweakCompatibilityRules = Object.freeze([
+  { key: "minimumChunkSize", templateValue: 20, reconstruction: "none" },
+  { key: "longLineThreshold", templateValue: 250, reconstruction: "none" },
+  { key: "encrypt", templateValue: false, reconstruction: "required" },
+  { key: "usePathObfuscation", templateValue: false, reconstruction: "required" },
+  { key: "enableCompression", templateValue: false, reconstruction: "none" },
+  { key: "useEden", templateValue: false, reconstruction: "none" },
+  { key: "customChunkSize", templateValue: 0, reconstruction: "recommended", compatibleLossyOrder: 1 },
+  { key: "useDynamicIterationCount", templateValue: false, reconstruction: "required" },
+  { key: "hashAlg", templateValue: "xxhash64", reconstruction: "recommended", compatibleLossyOrder: 0 },
+  { key: "enableChunkSplitterV2", templateValue: false, reconstruction: "none" },
+  { key: "maxChunksInEden", templateValue: 10, reconstruction: "none" },
+  { key: "maxTotalLengthInEden", templateValue: 1024, reconstruction: "none" },
+  { key: "maxAgeInEden", templateValue: 10, reconstruction: "none" },
+  {
+    key: "usePluginSyncV2",
+    templateValue: false,
+    reconstruction: "none",
+    knownDefault: false
+  },
+  {
+    key: "handleFilenameCaseSensitive",
+    templateValue: false,
+    reconstruction: "required",
+    knownDefault: false
+  },
+  { key: "useSegmenter", templateValue: false, reconstruction: "none" },
+  {
+    key: "E2EEAlgorithm",
+    templateValue: E2EEAlgorithms.V2,
+    reconstruction: "none",
+    knownDefault: DEFAULT_SETTINGS.E2EEAlgorithm
+  },
+  {
+    key: "chunkSplitterVersion",
+    templateValue: ChunkAlgorithms.RabinKarp,
+    reconstruction: "recommended",
+    knownDefault: DEFAULT_SETTINGS.chunkSplitterVersion,
+    compatibleLossyOrder: 2
+  }
+]);
+const TweakValuesShouldMatchedTemplate = Object.fromEntries(
+  TweakCompatibilityRules.map(({ key, templateValue }) => [key, templateValue])
+);
 const IncompatibleChanges = [
-  "encrypt",
-  "usePathObfuscation",
-  "useDynamicIterationCount",
-  "handleFilenameCaseSensitive"
+  ...TweakCompatibilityRules.filter(({ reconstruction }) => reconstruction === "required").map(({ key }) => key)
 ];
-const CompatibleButLossyChanges = ["hashAlg", "customChunkSize", "chunkSplitterVersion"];
-const IncompatibleChangesInSpecificPattern = [];
+const CompatibleButLossyChanges = TweakCompatibilityRules.filter(
+  (rule) => "compatibleLossyOrder" in rule
+).slice().sort((left, right) => left.compatibleLossyOrder - right.compatibleLossyOrder).map(({ key }) => key);
+const IncompatibleChangesInSpecificPattern = TweakCompatibilityRules.flatMap(
+  (rule) => (rule.specificPatterns ?? []).map((pattern) => ({
+    key: rule.key,
+    ...Object.prototype.hasOwnProperty.call(pattern, "from") ? { from: pattern.from } : {},
+    ...Object.prototype.hasOwnProperty.call(pattern, "to") ? { to: pattern.to } : {},
+    ...pattern.reconstruction === "recommended" ? { isRecommendation: true } : {}
+  }))
+);
 const TweakValuesRecommendedTemplate = {
   useIgnoreFiles: false,
   useCustomRequestHandler: false,
@@ -49,9 +79,11 @@ const TweakValuesRecommendedTemplate = {
   chunkSplitterVersion: ChunkAlgorithms.RabinKarp
 };
 const TweakValuesDefault = {
-  usePluginSyncV2: false,
-  E2EEAlgorithm: DEFAULT_SETTINGS.E2EEAlgorithm,
-  chunkSplitterVersion: DEFAULT_SETTINGS.chunkSplitterVersion,
+  ...Object.fromEntries(
+    TweakCompatibilityRules.filter((rule) => "knownDefault" in rule && rule.key !== "handleFilenameCaseSensitive").map(
+      ({ key, knownDefault }) => [key, knownDefault]
+    )
+  ),
   tweakModified: DEFAULT_SETTINGS.tweakModified
 };
 const TweakValuesTemplate = {
@@ -77,6 +109,7 @@ export {
   IncompatibleChangesInSpecificPattern,
   RemotePreferredTweakNotConfiguredReasons,
   RemotePreferredTweakStatuses,
+  TweakCompatibilityRules,
   TweakValuesDefault,
   TweakValuesRecommendedTemplate,
   TweakValuesShouldMatchedTemplate,

package/dist/common/types.d.ts

@@ -23,6 +23,8 @@ import { configurationNames, LEVEL_ADVANCED, LEVEL_POWER_USER, LEVEL_EDGE_CASE,
 import type { CustomRegExpSource, CustomRegExpSourceList, ParsedCustomRegExp, Prettify } from "./models/shared.type.util.js";
 import { ProtocolVersions, type ProtocolVersion, DOCID_SYNC_PARAMETERS, DOCID_JOURNAL_SYNC_PARAMETERS, type SyncParameters, DEFAULT_SYNC_PARAMETERS } from "./models/sync.definition.js";
 import { TweakValuesShouldMatchedTemplate, IncompatibleChanges, CompatibleButLossyChanges, IncompatibleChangesInSpecificPattern, TweakValuesRecommendedTemplate, TweakValuesDefault, TweakValuesTemplate, type TweakValues, DEVICE_ID_PREFERRED, RemotePreferredTweakStatuses, type RemotePreferredTweakStatus, RemotePreferredTweakNotConfiguredReasons, type RemotePreferredTweakNotConfiguredReason, type RemotePreferredTweakResult } from "./models/tweak.definition.js";
+import type { TweakAssessment, TweakAssessmentEntry, TweakAssessmentRelation, TweakAssessmentValue, TweakTransition, TweakTransitionReason } from "./models/tweak.compatibility.js";
+import type { TweakReconstruction } from "./models/tweak.definition.js";
 import type { diff_result_leaf, dmp_result, diff_result, DIFF_CHECK_RESULT_AUTO, diff_check_result } from "./models/diff.definition.js";
 import { PREFIXMD_LOGFILE, PREFIXMD_LOGFILE_UC, FlagFilesOriginal, FlagFilesHumanReadable, FLAGMD_REDFLAG, FLAGMD_REDFLAG2, FLAGMD_REDFLAG2_HR, FLAGMD_REDFLAG3, FLAGMD_REDFLAG3_HR } from "./models/redflag.const.js";
 import { DatabaseConnectingStatuses, type DatabaseConnectingStatus } from "./models/shared.definition.js";
@@ -69,6 +71,7 @@ export { confName };
 export { confDesc };
 export { TweakValuesTemplate };
 export type { TweakValues };
+export type { TweakAssessment, TweakAssessmentEntry, TweakAssessmentRelation, TweakAssessmentValue, TweakReconstruction, TweakTransition, TweakTransitionReason, };
 export { DEVICE_ID_PREFERRED };
 export { RemotePreferredTweakStatuses };
 export type { RemotePreferredTweakStatus };

package/dist/managers/StorageEventManager.js

@@ -166,6 +166,7 @@ class StorageEventManagerBase extends StorageEventManager {
         args: {
           file,
           oldPath: type === "RENAME" ? oldPath : void 0,
+          ...param.type === "RENAME" && type === "DELETE" ? { renameTarget: param.file.path } : {},
           cache,
           ctx
         },

package/dist/pouchdb/LiveSyncDBFunctions.d.ts

@@ -1,4 +1,4 @@
-import { type EntryDoc, type EntryMilestoneInfo, type RemoteDBSettings, type ChunkVersionRange, type TweakValues, type DeviceInfo } from "../common/types.js";
+import { type EntryDoc, type EntryMilestoneInfo, type RemoteDBSettings, type ChunkVersionRange, type TweakValues, type DeviceInfo, type TweakAssessment } from "../common/types.js";
 export type ENSURE_DB_RESULT = "OK" | "INCOMPATIBLE" | "LOCKED" | "NODE_LOCKED" | "NODE_CLEANED" | ["MISMATCHED", TweakValues];
 /**
  * Ensures that the remote database is compatible with the current device.
@@ -10,5 +10,5 @@ export type ENSURE_DB_RESULT = "OK" | "INCOMPATIBLE" | "LOCKED" | "NODE_LOCKED"
  * @param updateCallback - The callback function to update the remote milestone.
  * @returns A promise that resolves to the result of ensuring compatibility.
  */
-export declare function ensureRemoteIsCompatible(infoSrc: EntryMilestoneInfo | false, setting: RemoteDBSettings, deviceNodeID: string, currentVersionRange: ChunkVersionRange, nodeDeviceInfo: DeviceInfo, updateCallback: (info: EntryMilestoneInfo) => Promise<void>): Promise<ENSURE_DB_RESULT>;
-export declare function ensureDatabaseIsCompatible(db: PouchDB.Database<EntryDoc>, setting: RemoteDBSettings, deviceNodeID: string, currentVersionRange: ChunkVersionRange, nodeDeviceInfo: DeviceInfo): Promise<ENSURE_DB_RESULT>;
+export declare function ensureRemoteIsCompatible(infoSrc: EntryMilestoneInfo | false, setting: RemoteDBSettings, deviceNodeID: string, currentVersionRange: ChunkVersionRange, nodeDeviceInfo: DeviceInfo, updateCallback: (info: EntryMilestoneInfo) => Promise<void>, recordTweakAssessment?: (assessment: TweakAssessment) => void): Promise<ENSURE_DB_RESULT>;
+export declare function ensureDatabaseIsCompatible(db: PouchDB.Database<EntryDoc>, setting: RemoteDBSettings, deviceNodeID: string, currentVersionRange: ChunkVersionRange, nodeDeviceInfo: DeviceInfo, recordTweakAssessment?: (assessment: TweakAssessment) => void): Promise<ENSURE_DB_RESULT>;

package/dist/pouchdb/LiveSyncDBFunctions.js

@@ -1,12 +1,11 @@
 import {
   MILESTONE_DOCID as MILESTONE_DOC_ID,
-  TweakValuesShouldMatchedTemplate,
   TweakValuesTemplate,
-  DEVICE_ID_PREFERRED,
-  TweakValuesDefault
+  DEVICE_ID_PREFERRED
 } from "../common/types.js";
 import { extractObject, isObjectDifferent, resolveWithIgnoreKnownError } from "../common/utils.js";
-async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo, updateCallback) {
+import { assessTweakCompatibility } from "../common/models/tweak.compatibility.js";
+async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo, updateCallback, recordTweakAssessment) {
   const now = Date.now();
   const baseMilestone = {
     _id: MILESTONE_DOC_ID,
@@ -83,15 +82,9 @@ async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentV
   if (!setting.disableCheckingConfigMismatch) {
     const preferred_tweak = remoteMilestone.tweak_values?.[DEVICE_ID_PREFERRED] ?? currentTweakValues;
     const current_tweak = currentTweakValues;
-    const preferred_should_matched = extractObject(TweakValuesShouldMatchedTemplate, {
-      ...TweakValuesDefault,
-      ...preferred_tweak
-    });
-    const current_should_matched = extractObject(TweakValuesShouldMatchedTemplate, {
-      ...TweakValuesDefault,
-      ...current_tweak
-    });
-    if (isObjectDifferent(preferred_should_matched, current_should_matched, true)) {
+    const tweakAssessment = assessTweakCompatibility(current_tweak, preferred_tweak);
+    recordTweakAssessment?.(tweakAssessment);
+    if (tweakAssessment.alignment === "mismatched") {
       return ["MISMATCHED", preferred_tweak];
     }
   }
@@ -106,7 +99,7 @@ async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentV
   }
   return "OK";
 }
-async function ensureDatabaseIsCompatible(db, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo) {
+async function ensureDatabaseIsCompatible(db, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo, recordTweakAssessment) {
   const remoteMilestone = await resolveWithIgnoreKnownError(
     db.get(MILESTONE_DOC_ID),
     false
@@ -119,7 +112,8 @@ async function ensureDatabaseIsCompatible(db, setting, deviceNodeID, currentVers
     nodeDeviceInfo,
     async (info) => {
       await db.put(info);
-    }
+    },
+    recordTweakAssessment
   );
   return ret;
 }

package/dist/replication/CentralCompatibility.d.ts

@@ -1,4 +1,4 @@
-import type { TweakValues } from "../common/types.js";
+import type { TweakAssessment, TweakValues } from "../common/types.js";
 /** Stable machine states for one central-remote compatibility assessment. */
 export declare const CENTRAL_COMPATIBILITY_STATUSES: Readonly<{
     readonly NOT_ASSESSED: "not-assessed";
@@ -23,6 +23,7 @@ export interface CentralCompatibilityRejected {
     readonly status: typeof CENTRAL_COMPATIBILITY_STATUSES.REJECTED;
     readonly reason: CentralCompatibilityRejectionReason;
     readonly preferredTweakValue?: Readonly<TweakValues>;
+    readonly tweakAssessment?: TweakAssessment;
 }
 /** Immutable result produced by one provider-local compatibility assessment. */
 export type CentralCompatibilityDecision = typeof CENTRAL_COMPATIBILITY_NOT_ASSESSED | typeof CENTRAL_COMPATIBILITY_ACCEPTED | CentralCompatibilityRejected;
@@ -32,7 +33,8 @@ export type CentralCompatibilityDecisionRecorder = (decision: CentralCompatibili
 export interface CentralCompatibilityRecoveryHint {
     readonly reason: CentralCompatibilityRejectionReason;
     readonly preferredTweakValue?: Readonly<TweakValues>;
+    readonly tweakAssessment?: TweakAssessment;
 }
-export declare function centralCompatibilityRejected(reason: CentralCompatibilityRejectionReason, preferredTweakValue?: TweakValues): CentralCompatibilityRejected;
+export declare function centralCompatibilityRejected(reason: CentralCompatibilityRejectionReason, preferredTweakValue?: Readonly<TweakValues>, tweakAssessment?: TweakAssessment): CentralCompatibilityRejected;
 /** Project only a rejected decision into the generic replication failure path. */
 export declare function centralCompatibilityRecoveryHint(decision: CentralCompatibilityDecision): CentralCompatibilityRecoveryHint | undefined;

package/dist/replication/CentralCompatibility.js

@@ -15,18 +15,20 @@ const CENTRAL_COMPATIBILITY_NOT_ASSESSED = Object.freeze({
 const CENTRAL_COMPATIBILITY_ACCEPTED = Object.freeze({
   status: CENTRAL_COMPATIBILITY_STATUSES.ACCEPTED
 });
-function centralCompatibilityRejected(reason, preferredTweakValue) {
+function centralCompatibilityRejected(reason, preferredTweakValue, tweakAssessment) {
   return Object.freeze({
     status: CENTRAL_COMPATIBILITY_STATUSES.REJECTED,
     reason,
-    ...preferredTweakValue === void 0 ? {} : { preferredTweakValue: Object.freeze({ ...preferredTweakValue }) }
+    ...preferredTweakValue === void 0 ? {} : { preferredTweakValue: Object.freeze({ ...preferredTweakValue }) },
+    ...tweakAssessment === void 0 ? {} : { tweakAssessment }
   });
 }
 function centralCompatibilityRecoveryHint(decision) {
   if (decision.status !== CENTRAL_COMPATIBILITY_STATUSES.REJECTED) return void 0;
   return Object.freeze({
     reason: decision.reason,
-    ...decision.preferredTweakValue === void 0 ? {} : { preferredTweakValue: decision.preferredTweakValue }
+    ...decision.preferredTweakValue === void 0 ? {} : { preferredTweakValue: decision.preferredTweakValue },
+    ...decision.tweakAssessment === void 0 ? {} : { tweakAssessment: decision.tweakAssessment }
   });
 }
 export {

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -903,12 +903,16 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           device_name: this.env.services.vault.getVaultName(),
           progress
         };
+        let tweakAssessment;
         const ensure = await ensureDatabaseIsCompatible(
           dbRet.db,
           setting,
           this.nodeid,
           currentVersionRange,
-          info
+          info,
+          (assessment) => {
+            tweakAssessment = assessment;
+          }
         );
         if (ensure == "INCOMPATIBLE") {
           recordCompatibilityDecision?.(
@@ -951,7 +955,11 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         } else if (ensure == "OK") {
         } else if (ensure[0] == "MISMATCHED") {
           recordCompatibilityDecision?.(
-            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.TWEAK_MISMATCH, ensure[1])
+            centralCompatibilityRejected(
+              CENTRAL_COMPATIBILITY_REJECTION_REASONS.TWEAK_MISMATCH,
+              ensure[1],
+              tweakAssessment
+            )
           );
           Logger(this.translate("liveSyncReplicator.mismatchedTweakDetected"), LOG_LEVEL_NOTICE);
           this.tweakSettingsMismatched = true;

package/dist/replication/journal/LiveSyncJournalReplicator.d.ts

@@ -1,4 +1,4 @@
-import { type RemoteDBSettings, type ChunkVersionRange, type NodeData, type RemotePreferredTweakResult } from "../../common/types.js";
+import { type RemoteDBSettings, type ChunkVersionRange, type NodeData, type RemotePreferredTweakResult, type TweakAssessment } from "../../common/types.js";
 import { JournalSyncCore } from "./JournalSyncCore.js";
 import { LiveSyncAbstractReplicator, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
 import { type ENSURE_DB_RESULT } from "../../pouchdb/LiveSyncDBFunctions.js";
@@ -22,7 +22,7 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
     private journalTransferStopGeneration;
     getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
     setupJournalSyncClient(settings?: RemoteDBSettings): JournalSyncCore;
-    ensureBucketIsCompatible(deviceNodeID: string, currentVersionRange: ChunkVersionRange, setting?: RemoteDBSettings, client?: Pick<JournalSyncCore, "downloadJsonWithResult" | "getCheckpointInfo" | "uploadJson">): Promise<ENSURE_DB_RESULT>;
+    ensureBucketIsCompatible(deviceNodeID: string, currentVersionRange: ChunkVersionRange, setting?: RemoteDBSettings, client?: Pick<JournalSyncCore, "downloadJsonWithResult" | "getCheckpointInfo" | "uploadJson">, recordTweakAssessment?: (assessment: TweakAssessment) => void): Promise<ENSURE_DB_RESULT>;
     constructor(env: LiveSyncJournalReplicatorEnv);
     migrate(from: number, to: number): Promise<boolean>;
     /**