@vrtmrz/livesync-commonlib 0.1.44 → 0.2.1

package/dist/replication/index.d.ts

@@ -3,10 +3,13 @@ export type { ReplicatorInstance } from "./ReplicatorInstance.js";
 export type { ActiveReplicatorContext, CapabilitySupport, ContinuousReplicationRequest, ContinuousReplicationTrigger, ContinuousRunner, InteractionAuthority, InteractionPermissions, NotApplicableCapability, NotImplementedCapability, NoInteraction, PermittedInteractionPermissions, ReplicationBlockReason, ReplicationAttemptFailure, ReplicationCancelled, ReplicationCompleted, ReplicationFailed, ReplicationInteraction, ReplicationOutcome, ReplicationProgressPresentation, ReplicationReadinessRequirements, ReplicationPartial, ReplicationFailureRequest, ReplicatorConfigurationIdentity, ReplicatorProviderDefinition, ReplicatorProviderDefinitionMap, StopActiveTransferRunner, SupportedCapability, UnattendedOneShotRequest, UnattendedReplicationTrigger, UnattendedOneShotRunner, UserInitiatedOneShotRequest, UserInitiatedReplicationAuthority, UserInitiatedOneShotRunner, } from "./ReplicatorProvider.js";
 export { CAPABILITY_SUPPORT_KINDS, CAPABILITY_UNAVAILABLE_REASONS } from "./ProviderCapability.js";
 export { NO_REMOTE_RESOURCE_CAPABILITIES, REMOTE_RESOURCE_KINDS } from "./RemoteResource.js";
-export type { ConnectionProbeFactory, PreferredTweakProbe, PreferredTweakProbeFactory, RemoteConnectionProbe, RemoteConnectionProbeOptions, RemoteConnectionProbeResult, RemoteResourceCapabilities, RemoteResourceFactoryMap, RemoteResourceKind, RemoteResourceMap, SecuritySeedResource, SecuritySeedResourceFactory, SynchronisationInformationResource, SynchronisationInformationResourceFactory, } from "./RemoteResource.js";
+export type { InitialFetchFastForwardResource, InitialFetchFastForwardResourceFactory, ConnectionProbeFactory, JoinedDevicesResource, JoinedDevicesResourceFactory, PreferredTweakProbe, PreferredTweakProbeFactory, RemoteConnectionProbe, RemoteConnectionProbeOptions, RemoteConnectionProbeResult, RemoteResourceCapabilities, RemoteResourceFactoryMap, RemoteResourceKind, RemoteResourceMap, SecuritySeedResource, SecuritySeedResourceFactory, SynchronisationInformationResource, SynchronisationInformationResourceFactory, } from "./RemoteResource.js";
+export type { InitialFetchFastForward } from "./couchdb/fastForward.js";
 export { CENTRAL_REMOTE_ADMINISTRATION_ACTIONS, CENTRAL_REMOTE_ADMINISTRATION_FAILURE_REASONS, CENTRAL_REMOTE_ADMINISTRATION_OBSERVATION_KINDS, CENTRAL_REMOTE_ADMINISTRATION_RESULT_STATUSES, applyCentralRemoteAdministrationMutation, isCentralRemoteAdministrationVerified, milestoneSatisfiesCentralRemoteAdministration, centralRemoteAdministrationVerificationFailed, centralRemoteAdministrationVerified, } from "./CentralRemoteAdministration.js";
 export type { MilestoneCentralRemoteAdministrationObservation, CentralRemoteAdministrationAction, CentralRemoteAdministrationFailureReason, CentralRemoteAdministrationObservation, CentralRemoteAdministrationRequest, CentralRemoteAdministrationReplicator, CentralRemoteAdministrationResult, CentralRemoteAdministrationRunner, CentralRemoteAdministrationVerificationFailed, CentralRemoteAdministrationVerified, } from "./CentralRemoteAdministration.js";
 export { CENTRAL_COMPATIBILITY_REJECTION_REASONS } from "./CentralCompatibility.js";
 export type { CentralCompatibilityRecoveryHint, CentralCompatibilityRejectionReason } from "./CentralCompatibility.js";
 export { assessRemoteFeatureDocument, describeRemoteFeatureRejection, ENCRYPTED_INTERNAL_METADATA_FEATURE, NFC_PATH_IDENTITY_FEATURE, REMOTE_FEATURE_GENERATION, usesEncryptedInternalMetadata, } from "../pouchdb/remoteFeatureCompatibility.js";
 export type { RemoteFeatureAssessment } from "../pouchdb/remoteFeatureCompatibility.js";
+export type { JoinedDevice, JoinedDevicesSnapshot, ForgetJoinedDeviceResult } from "./joinedDevices.js";
+export type { ReplicationStatics, CouchDBReplicationPhase, CouchDBReplicationProgress, ReplicationCheckpointProgress, } from "../common/models/shared.definition.js";

package/dist/replication/joinedDevices.d.ts

@@ -0,0 +1,25 @@
+import { type EntryMilestoneInfo } from "../common/types.js";
+export interface JoinedDevice {
+    readonly id: string;
+    readonly accepted: boolean;
+    readonly platform?: string;
+    readonly pluginVersion?: string;
+    readonly appVersion?: string;
+    readonly lastConnected?: number;
+}
+export interface JoinedDevicesSnapshot {
+    readonly milestonePresent: boolean;
+    readonly locked: boolean;
+    readonly cleaned: boolean;
+    readonly devices: readonly JoinedDevice[];
+}
+export declare function projectJoinedDevices(milestone: EntryMilestoneInfo | undefined): JoinedDevicesSnapshot;
+export type ForgetJoinedDeviceResult = "forgotten" | "not-found" | "conflict" | "unsupported";
+export interface JoinedDevicesStore {
+    read(): Promise<{
+        milestone: EntryMilestoneInfo;
+        revision?: string;
+    } | undefined>;
+    write(milestone: EntryMilestoneInfo, revision: string): Promise<"updated" | "conflict" | "unsupported">;
+}
+export declare function forgetJoinedDevice(store: JoinedDevicesStore, deviceId: string, ownDeviceId: string): Promise<ForgetJoinedDeviceResult>;

package/dist/replication/joinedDevices.js

@@ -0,0 +1,123 @@
+import { DEVICE_ID_PREFERRED } from "../common/types.js";
+function projectJoinedDevices(milestone) {
+  if (milestone === void 0) {
+    return { milestonePresent: false, locked: false, cleaned: false, devices: [] };
+  }
+  const source = milestone;
+  const nodeInfo = asRecord(source.node_info);
+  const acceptedNodes = Array.isArray(source.accepted_nodes) ? source.accepted_nodes.filter((id) => typeof id === "string") : [];
+  const accepted = new Set(acceptedNodes);
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of acceptedNodes) {
+    if (id !== DEVICE_ID_PREFERRED) ids.add(id);
+  }
+  addRecordKeys(ids, source.node_info);
+  addRecordKeys(ids, source.node_chunk_info);
+  addRecordKeys(ids, source.tweak_values);
+  const devices = [...ids].filter((id) => id !== DEVICE_ID_PREFERRED).sort().map((id) => {
+    const nodeData = nodeInfo && hasOwn(nodeInfo, id) ? asRecord(nodeInfo[id]) : void 0;
+    const platform = readString(nodeData, "platform");
+    const pluginVersion = readString(nodeData, "plugin_version");
+    const appVersion = readString(nodeData, "app_version");
+    const lastConnected = readTimestamp(nodeData?.last_connected);
+    return {
+      id,
+      accepted: accepted.has(id),
+      ...platform === void 0 ? {} : { platform },
+      ...pluginVersion === void 0 ? {} : { pluginVersion },
+      ...appVersion === void 0 ? {} : { appVersion },
+      ...lastConnected === void 0 ? {} : { lastConnected }
+    };
+  });
+  return {
+    milestonePresent: true,
+    locked: source.locked === true,
+    cleaned: source.cleaned === true,
+    devices
+  };
+}
+const MAX_CONFLICT_RETRIES = 3;
+async function forgetJoinedDevice(store, deviceId, ownDeviceId) {
+  if (ownDeviceId.length === 0) {
+    throw new Error("The current device ID must not be empty");
+  }
+  if (deviceId.length === 0) {
+    throw new Error("The device ID must not be empty");
+  }
+  if (deviceId === DEVICE_ID_PREFERRED) {
+    throw new Error("The preferred-device marker cannot be forgotten");
+  }
+  if (deviceId === ownDeviceId) {
+    throw new Error("The current device cannot be forgotten");
+  }
+  let conflictRetries = 0;
+  while (true) {
+    const current = await store.read();
+    if (current === void 0 || !hasDevice(current.milestone, deviceId)) {
+      return "not-found";
+    }
+    if (typeof current.revision !== "string") {
+      return "unsupported";
+    }
+    const updatedMilestone = removeDevice(current.milestone, deviceId);
+    const result = await store.write(updatedMilestone, current.revision);
+    if (result === "updated") return "forgotten";
+    if (result === "unsupported") return "unsupported";
+    if (conflictRetries >= MAX_CONFLICT_RETRIES) return "conflict";
+    conflictRetries++;
+  }
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function addRecordKeys(ids, value) {
+  const record = asRecord(value);
+  if (!record) return;
+  for (const id of Object.keys(record)) {
+    if (id !== DEVICE_ID_PREFERRED) ids.add(id);
+  }
+}
+function readString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function hasDevice(milestone, deviceId) {
+  const source = milestone;
+  const accepted = Array.isArray(source.accepted_nodes) && source.accepted_nodes.includes(deviceId);
+  return accepted || hasMapKey(source.node_info, deviceId) || hasMapKey(source.node_chunk_info, deviceId) || hasMapKey(source.tweak_values, deviceId);
+}
+function hasMapKey(value, deviceId) {
+  const record = asRecord(value);
+  return record !== void 0 && hasOwn(record, deviceId);
+}
+function removeDevice(milestone, deviceId) {
+  const source = milestone;
+  const updated = { ...source };
+  for (const key of ["node_info", "node_chunk_info", "tweak_values"]) {
+    if (hasOwn(source, key)) {
+      updated[key] = removeMapKey(source[key], deviceId);
+    }
+  }
+  if (hasOwn(source, "accepted_nodes") && Array.isArray(source.accepted_nodes)) {
+    updated.accepted_nodes = source.accepted_nodes.filter((id) => id !== deviceId);
+  }
+  return updated;
+}
+function removeMapKey(value, deviceId) {
+  const record = asRecord(value);
+  if (!record) return value;
+  const updated = { ...record };
+  delete updated[deviceId];
+  return updated;
+}
+export {
+  forgetJoinedDevice,
+  projectJoinedDevices
+};

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

@@ -3,7 +3,7 @@ import type { ReplicationCallback, ReplicationStat } from "../LiveSyncAbstractRe
 import { type SimpleStore } from "../../common/utils.js";
 import { type CheckPointInfo } from "./JournalSyncTypes.js";
 import type { LiveSyncJournalReplicatorEnv } from "./LiveSyncJournalReplicatorEnv.js";
-import { type IJournalStorage, type JournalStorageReadResult } from "./objectstore/JournalStorageAdapter.js";
+import { type IJournalStorage, type JournalStorageConditionalWriteResult, type JournalStorageReadResult } from "./objectstore/JournalStorageAdapter.js";
 type ProcessingEntry = PouchDB.Core.PutDocument<EntryDoc> & PouchDB.Core.GetMeta;
 export declare class JournalSyncCore {
     _settings: BucketSyncSetting;
@@ -24,6 +24,7 @@ export declare class JournalSyncCore {
     constructor(settings: BucketSyncSetting, store: SimpleStore<CheckPointInfo>, env: LiveSyncJournalReplicatorEnv, storage: IJournalStorage);
     downloadJson<T>(key: string): Promise<T | false>;
     downloadJsonWithResult<T>(key: string): Promise<JournalStorageReadResult<T>>;
+    uploadJsonIfUnchanged<T>(key: string, body: T, revision: string): Promise<JournalStorageConditionalWriteResult>;
     uploadJson<T>(key: string, body: T): Promise<boolean>;
     applyNewConfig(settings: BucketSyncSetting, store: SimpleStore<CheckPointInfo>, env: LiveSyncJournalReplicatorEnv): void;
     updateInfo(info: Partial<ReplicationStat>): void;

package/dist/replication/journal/JournalSyncCore.js

@@ -127,7 +127,8 @@ class JournalSyncCore {
     try {
       return {
         status: JournalStorageReadStatuses.AVAILABLE,
-        value: JSON.parse(new TextDecoder().decode(result.value))
+        value: JSON.parse(new TextDecoder().decode(result.value)),
+        ...result.revision === void 0 ? {} : { revision: result.revision }
       };
     } catch (ex) {
       Logger(`Could not parse downloaded json ${key}`);
@@ -138,6 +139,15 @@ class JournalSyncCore {
       };
     }
   }
+  async uploadJsonIfUnchanged(key, body, revision) {
+    if (revision.trim().length === 0) {
+      throw new TypeError("A non-empty revision is required for a conditional upload");
+    }
+    const uploadIfUnchanged = this.storage.uploadIfUnchanged;
+    if (!uploadIfUnchanged) return "unsupported";
+    const data = new TextEncoder().encode(JSON.stringify(body));
+    return await uploadIfUnchanged.call(this.storage, key, data, "application/json", revision);
+  }
   async uploadJson(key, body) {
     try {
       const data = new TextEncoder().encode(JSON.stringify(body));

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

@@ -7,6 +7,7 @@ import type { SimpleStore } from "../../common/utils.js";
 import type { LiveSyncJournalReplicatorEnv } from "./LiveSyncJournalReplicatorEnv.js";
 import { type CentralCompatibilityDecisionRecorder } from "../CentralCompatibility.js";
 import { type ReplicationOutcome } from "../ReplicatorProvider.js";
+import { type ForgetJoinedDeviceResult, type JoinedDevicesSnapshot } from "../joinedDevices.js";
 export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     env: LiveSyncJournalReplicatorEnv;
     get client(): JournalSyncCore;
@@ -63,6 +64,9 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
     getRemoteStatus(setting: RemoteDBSettings): Promise<false | RemoteDBStatus>;
     private supportsLegacyPathIdentity;
     private assertLegacyPathIdentity;
+    private getOwnJoinedDeviceId;
+    getJoinedDevices(setting: RemoteDBSettings): Promise<JoinedDevicesSnapshot>;
+    forgetJoinedDevice(setting: RemoteDBSettings, deviceId: string): Promise<ForgetJoinedDeviceResult>;
     getConnectedDeviceList(setting?: RemoteDBSettings): Promise<false | {
         node_info: Record<string, NodeData>;
         accepted_nodes: string[];

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/replication/trystero/TrysteroReplicator.d.ts

@@ -144,6 +144,7 @@ export declare class TrysteroReplicator {
         idDerivationVersion: 0 | 1;
         idDerivationProof: string;
         liveSync?: boolean;
+        batchSaveInLiveSync?: boolean;
         syncOnSave?: boolean;
         syncOnStart?: boolean;
         syncOnFileOpen?: boolean;
@@ -332,6 +333,7 @@ export declare class TrysteroReplicator {
             idDerivationVersion: 0 | 1;
             idDerivationProof: string;
             liveSync?: boolean;
+            batchSaveInLiveSync?: boolean;
             syncOnSave?: boolean;
             syncOnStart?: boolean;
             syncOnFileOpen?: boolean;

package/dist/serviceFeatures/offlineScanner.js

@@ -360,8 +360,7 @@ async function syncFileBetweenDBandStorage(host, log, file, doc) {
     case BASE_IS_NEW:
       if (!host.services.vault.isFileSizeTooLarge(file.stat.size)) {
         log("STORAGE -> DB :" + file.path);
-        await host.serviceModules.fileHandler.storeFileToDB(file);
-        return FilePairProcessResults.COMPLETED;
+        return await host.serviceModules.fileHandler.storeFileToDB(file) ? FilePairProcessResults.COMPLETED : FilePairProcessResults.FAILED;
       } else {
         log(
           `STORAGE -> DB : ${file.path} has been skipped due to file size exceeding the limit`,
@@ -390,11 +389,22 @@ async function syncFileBetweenDBandStorage(host, log, file, doc) {
         return FilePairProcessResults.SKIPPED;
       }
     case EVEN:
-      if (doc._rev) {
-        await host.serviceModules.fileHandler.tryRecordUntrackedFileRevision(file, doc._rev);
+      if (host.services.vault.isFileSizeTooLarge(file.stat.size) || host.services.vault.isFileSizeTooLarge(doc.size)) {
+        log(`STORAGE ? DB : ${file.path} has been skipped due to file size exceeding the limit`, LOG_LEVEL_NOTICE);
+        return FilePairProcessResults.SKIPPED;
+      }
+      if (doc._rev && await host.serviceModules.fileHandler.tryRecordUntrackedFileRevision(file, doc._rev)) {
+        log("STORAGE == DB :" + file.path, LOG_LEVEL_DEBUG);
+        return FilePairProcessResults.COMPLETED;
+      }
+      log("STORAGE ? DB :" + file.path + " Checking content", LOG_LEVEL_DEBUG);
+      try {
+        return await host.serviceModules.fileHandler.storeFileToDB(file, false, false, { revalidateStorage: true }) ? FilePairProcessResults.COMPLETED : FilePairProcessResults.FAILED;
+      } catch (error) {
+        log(`STORAGE ? DB : Could not reconcile ${file.path}`, LOG_LEVEL_NOTICE);
+        log(error, LOG_LEVEL_VERBOSE);
+        return FilePairProcessResults.FAILED;
       }
-      log("STORAGE == DB :" + file.path, LOG_LEVEL_DEBUG);
-      return FilePairProcessResults.COMPLETED;
     default:
       log("STORAGE ?? DB :" + file.path + " Something got weird");
       return FilePairProcessResults.FAILED;
@@ -501,7 +511,9 @@ async function collectDatabaseFiles(host, settings, log, showingNotice) {
 async function updateToDatabase(host, log, logLevel, file) {
   if (!host.services.vault.isFileSizeTooLarge(file.stat.size)) {
     const path = file.path;
-    await host.serviceModules.fileHandler.storeFileToDB(file);
+    if (!await host.serviceModules.fileHandler.storeFileToDB(file)) {
+      return FilePairProcessResults.FAILED;
+    }
     host.services.context.events.emitEvent("event-file-changed", { file: path, automated: true });
     return FilePairProcessResults.COMPLETED;
   } else {