@vrtmrz/livesync-commonlib 0.1.23 → 0.1.25

package/dist/API/processSetting.d.ts

@@ -37,5 +37,5 @@ type ErasureProperties = keyof ObsidianLiveSyncSettings;
  * @returns Generated setup URI
  */
 export declare function encodeSettingsToSetupURI(settingString: ObsidianLiveSyncSettings, passphrase: string, removeProperties?: ErasureProperties[], skipDefaultValue?: boolean): Promise<string>;
-export declare function decodeSettingsFromSetupURI(uri: string, passphrase: string): Promise<false | ObsidianLiveSyncSettings>;
+export declare function decodeSettingsFromSetupURI(uri: string, passphrase: string): Promise<false | Omit<ObsidianLiveSyncSettings, "P2P_iceServers" | "P2P_iceServersExpiresAt">>;
 export {};

package/dist/API/processSetting.js

@@ -4,11 +4,13 @@ import { decodeAnyArray, encodeAnyArray } from "octagonal-wheels/object";
 import {
   DEFAULT_SETTINGS,
   KeyIndexOfSettings,
-  LOG_LEVEL_NOTICE
+  LOG_LEVEL_NOTICE,
+  omitP2PRuntimeSettings
 } from "../common/types.js";
 import { decryptString, encryptString } from "../encryption/stringEncryption.js";
 import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
 function encodeSettingsToQRCodeData(settings) {
+  settings = omitP2PRuntimeSettings(settings);
   const fullIndexes = Object.entries(KeyIndexOfSettings);
   let maxIndex = 0;
   for (const [, index] of fullIndexes) {
@@ -48,7 +50,7 @@ function decodeSettingsFromQRCodeData(qr) {
       LOG_LEVEL_VERBOSE
     );
   }
-  return newSettings;
+  return omitP2PRuntimeSettings(newSettings);
 }
 var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
   OutputFormat2[OutputFormat2["SVG"] = 0] = "SVG";
@@ -99,8 +101,11 @@ const necessaryErasureProperties = [
 ];
 async function encodeSettingsToSetupURI(settingString, passphrase, removeProperties = ["pluginSyncExtendedSetting"], skipDefaultValue = false) {
   const setting = {
-    ...settingString
+    ...omitP2PRuntimeSettings(settingString)
   };
+  delete setting.P2P_managedType;
+  delete setting.P2P_managedId;
+  delete setting.P2P_managedToken;
   if (skipDefaultValue) {
     const keys = Object.keys(setting);
     for (const k of keys) {
@@ -123,10 +128,9 @@ async function decodeSettingsFromSetupURI(uri, passphrase) {
   const encryptedSetting = uri.substring(configURIBase.length);
   const decrypted = await decryptString(decodeURIComponent(encryptedSetting), passphrase);
   try {
-    return JSON.parse(decrypted);
-  } catch (e) {
+    return omitP2PRuntimeSettings(JSON.parse(decrypted));
+  } catch {
     Logger(`Failed to parse settings from decrypted data`, LOG_LEVEL_NOTICE);
-    Logger(e, LOG_LEVEL_VERBOSE);
     return false;
   }
 }

package/dist/common/ConnectionString.js

@@ -1,9 +1,12 @@
-import { normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes } from "./models/setting.p2p.js";
+import {
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes
+} from "./models/setting.p2p.js";
 const PROXY_SCHEME = "https";
 function parseSlsUri(uriString) {
   const match = uriString.match(/^sls\+([^:]+):(.*)$/);
   if (!match) {
-    throw new Error(`Unsupported URI: ${uriString}`);
+    throw new Error("Unsupported URI");
   }
   const subscheme = match[1];
   const rest = match[2];
@@ -20,7 +23,7 @@ class ConnectionStringParser {
   static parse(uriString) {
     const match = uriString.match(/^sls\+([^:]+):/);
     if (!match) {
-      throw new Error(`Unsupported URI: ${uriString}`);
+      throw new Error("Unsupported URI");
     }
     const subscheme = match[1];
     if (subscheme === "p2p") {
@@ -43,7 +46,7 @@ class ConnectionStringParser {
           settings: this.parseS3(url)
         };
       default:
-        throw new Error(`Unsupported protocol: sls+${subscheme}`);
+        throw new Error("Unsupported protocol");
     }
   }
   /**
@@ -126,9 +129,7 @@ class ConnectionStringParser {
   }
   static parseP2P(uriString) {
     const match = uriString.match(/^sls\+p2p:\/\/([^?#]+)(?:\?([^#]*))?(?:#(.*))?$/);
-    if (!match) {
-      throw new Error(`Invalid P2P URI: ${uriString}`);
-    }
+    if (!match) throw new Error("Invalid P2P URI");
     const authority = match[1];
     const queryString = match[2] || "";
     let userinfo = "";
@@ -158,7 +159,10 @@ class ConnectionStringParser {
       P2P_turnUsername: searchParams.get("turnUser") || "",
       P2P_turnCredential: searchParams.get("turnPass") || "",
       P2P_maxWirePayloadBytes: normaliseP2PMaxWirePayloadBytes(Number(searchParams.get("maxWirePayloadBytes"))),
-      P2P_connectionPath: normaliseP2PConnectionPath(searchParams.get("connectionPath"))
+      P2P_connectionPath: normaliseP2PConnectionPath(searchParams.get("connectionPath")),
+      P2P_managedType: searchParams.get("managedType") || void 0,
+      P2P_managedId: searchParams.get("managedId") || void 0,
+      P2P_managedToken: searchParams.get("token") || void 0
     };
   }
   static serializeP2P(settings) {
@@ -176,6 +180,9 @@ class ConnectionStringParser {
       String(normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes))
     );
     searchParams.set("connectionPath", normaliseP2PConnectionPath(settings.P2P_connectionPath));
+    if (settings.P2P_managedType) searchParams.set("managedType", settings.P2P_managedType);
+    if (settings.P2P_managedId) searchParams.set("managedId", settings.P2P_managedId);
+    if (settings.P2P_managedToken) searchParams.set("token", settings.P2P_managedToken);
     const credentials = settings.P2P_passphrase ? `:${encodeURIComponent(settings.P2P_passphrase)}@` : "";
     const host = encodeURIComponent(settings.P2P_roomID);
     const query = searchParams.toString() ? `?${searchParams.toString()}` : "";

package/dist/common/models/setting.const.qr.js

@@ -159,6 +159,11 @@ const KeyIndexOfSettings = {
   P2P_turnServers: 150,
   P2P_turnUsername: 151,
   P2P_turnCredential: 152,
+  P2P_managedType: -1,
+  P2P_managedId: -1,
+  P2P_managedToken: -1,
+  P2P_iceServers: -1,
+  P2P_iceServersExpiresAt: -1,
   syncInternalFileOverwritePatterns: 153,
   useOnlyLocalChunk: 154,
   maxMTimeForReflectEvents: 155,

package/dist/common/models/setting.lifecycle.js

@@ -4,6 +4,7 @@ import {
   SETTING_VERSION_INITIAL,
   SETTING_VERSION_SUPPORT_CASE_INSENSITIVE
 } from "./setting.const.js";
+import { omitP2PRuntimeSettings } from "./setting.p2p.js";
 const SettingsMigrationReviewCodes = {
   LegacyUpdatePending: "legacy-update-review-pending",
   FutureSchema: "settings-schema-newer-than-runtime",
@@ -22,18 +23,19 @@ const SETTINGS_MIGRATIONS = [
   }
 ];
 function cloneSettings(source, fallbacks) {
+  const persistableSource = omitP2PRuntimeSettings(source);
   return {
     ...fallbacks,
-    ...source,
+    ...persistableSource,
     remoteConfigurations: Object.fromEntries(
-      Object.entries(source.remoteConfigurations ?? fallbacks.remoteConfigurations).map(([id, config]) => [
+      Object.entries(persistableSource.remoteConfigurations ?? fallbacks.remoteConfigurations).map(([id, config]) => [
         id,
         { ...config }
       ])
     ),
     pluginSyncExtendedSetting: {
       ...fallbacks.pluginSyncExtendedSetting,
-      ...source.pluginSyncExtendedSetting
+      ...persistableSource.pluginSyncExtendedSetting
     }
   };
 }

package/dist/common/models/setting.p2p.d.ts

@@ -1,4 +1,14 @@
 import { type P2PConnectionPath } from "./setting.const.js";
+import type { P2PConnectionInfo, P2PSyncSetting } from "./setting.type.js";
+/** Report whether the selected P2P settings request host-managed TURN credentials. */
+export declare function hasManagedP2PTurnConfiguration(settings: Partial<Pick<P2PConnectionInfo, "P2P_managedType">>): boolean;
+/** Remove connection-only ICE credentials before settings cross a serialisation boundary. */
+export declare function omitP2PRuntimeSettings<T extends Partial<P2PSyncSetting>>(settings: T): Omit<T, "P2P_iceServers" | "P2P_iceServersExpiresAt">;
+/**
+ * Report whether a P2P profile has a usable manual TURN endpoint or requests
+ * host-managed TURN credentials. STUN-only profiles remain false.
+ */
+export declare function hasP2PTurnConfiguration(settings: Partial<Pick<P2PConnectionInfo, "P2P_turnServers" | "P2P_managedType">>): boolean;
 /**
  * Return a safe outgoing RPC wire-payload bound for Trystero.
  *

package/dist/common/models/setting.p2p.js

@@ -1,4 +1,14 @@
 import { P2PConnectionPaths, P2PMessageSizePresets } from "./setting.const.js";
+function hasManagedP2PTurnConfiguration(settings) {
+  return typeof settings.P2P_managedType === "string" && settings.P2P_managedType.trim().length > 0;
+}
+function omitP2PRuntimeSettings(settings) {
+  const { P2P_iceServers: _iceServers, P2P_iceServersExpiresAt: _expiresAt, ...persistable } = settings;
+  return persistable;
+}
+function hasP2PTurnConfiguration(settings) {
+  return hasManagedP2PTurnConfiguration(settings) || typeof settings.P2P_turnServers === "string" && hasValidP2PTurnServerUrl(settings.P2P_turnServers);
+}
 function normaliseP2PMaxWirePayloadBytes(value) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < P2PMessageSizePresets.MaximumCompatibility || value > P2PMessageSizePresets.Standard) {
     return P2PMessageSizePresets.Standard;
@@ -31,10 +41,13 @@ function hasValidP2PTurnServerUrl(value) {
   return splitP2PTurnServerUrls(value).some(isValidP2PTurnServerUrl);
 }
 export {
+  hasManagedP2PTurnConfiguration,
+  hasP2PTurnConfiguration,
   hasValidP2PTurnServerUrl,
   isValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
   normaliseP2PMaxWirePayloadBytes,
+  omitP2PRuntimeSettings,
   splitP2PRelayUrls,
   splitP2PTurnServerUrls
 };

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

@@ -528,6 +528,12 @@ export interface P2PConnectionInfo {
      * The TURN credential (password, secret, etc...) for the P2P connection.
      */
     P2P_turnCredential: string;
+    /** Host-defined managed TURN provider type. */
+    P2P_managedType?: string;
+    /** Host-defined managed TURN provider identifier. */
+    P2P_managedId?: string;
+    /** Host-defined managed TURN provider token. */
+    P2P_managedToken?: string;
     /**
      * Maximum serialised RPC wire payload sent through Trystero before
      * Commonlib splits it. Applies to outgoing messages.
@@ -552,6 +558,10 @@ export interface P2PSyncSetting extends P2PConnectionInfo {
     P2P_AutoAcceptingPeers: string;
     P2P_AutoDenyingPeers: string;
     P2P_IsHeadless?: boolean;
+    /** ICE servers prepared for one room connection. Never persist or share this value. */
+    P2P_iceServers?: readonly RTCIceServer[];
+    /** Absolute Unix timestamp in milliseconds for the prepared ICE servers. */
+    P2P_iceServersExpiresAt?: number;
 }
 /**
  * Interface representing the settings for a remote type.

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;
@@ -175,6 +261,8 @@ export declare const TweakValuesTemplate: {
     P2P_AutoAcceptingPeers?: string;
     P2P_AutoDenyingPeers?: string;
     P2P_IsHeadless?: boolean;
+    P2P_iceServers?: readonly RTCIceServer[];
+    P2P_iceServersExpiresAt?: number;
     P2P_Enabled?: boolean;
     P2P_relays?: string;
     P2P_roomID?: string;
@@ -186,6 +274,9 @@ export declare const TweakValuesTemplate: {
     P2P_turnServers?: string;
     P2P_turnUsername?: string;
     P2P_turnCredential?: string;
+    P2P_managedType?: string;
+    P2P_managedId?: string;
+    P2P_managedToken?: string;
     P2P_maxWirePayloadBytes?: number;
     P2P_connectionPath?: import("./setting.const.js").P2PConnectionPath;
     P2P_useDiagRTC?: boolean;