@vrtmrz/livesync-commonlib 0.1.19-rc.0 → 0.1.20

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -14,7 +14,24 @@ import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { extractObject } from "../../common/utils.js";
 import { clearHandlers } from "../SyncParamsHandler.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
+import {
+  CENTRAL_COMPATIBILITY_ACCEPTED,
+  CENTRAL_COMPATIBILITY_NOT_ASSESSED,
+  CENTRAL_COMPATIBILITY_REJECTION_REASONS,
+  centralCompatibilityRejected,
+  centralCompatibilityRecoveryHint
+} from "../CentralCompatibility.js";
+import {
+  outcomeFromFiniteOpenReplication,
+  replicationFailed
+} from "../ReplicatorProvider.js";
 const MILSTONE_DOCID = "_00000000-milestone.json";
+async function readRemoteMilestone(client) {
+  const result = await client.downloadJsonWithResult(MILSTONE_DOCID);
+  if (result.status === JournalStorageReadStatuses.AVAILABLE) return result.value;
+  if (result.status === JournalStorageReadStatuses.NOT_FOUND) return void 0;
+  throw result.error;
+}
 const currentVersionRange = {
   min: 0,
   max: 2,
@@ -28,11 +45,18 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return this.env.services.keyValueDB.simpleStore;
   }
   _client;
+  /** Whether this instance has entered a Journal transfer since its last close. */
+  hasEnteredReplication = false;
+  /** Transfers whose settlement must be observed by an admitted Stop request. */
+  activeJournalTransfers;
+  /** Shared settlement for repeated Stop requests at the same boundary. */
+  journalTransferStopSettlement;
+  /** Monotonic fence which prevents a preflight crossing a later Stop boundary. */
+  journalTransferStopGeneration = 0;
   async getReplicationPBKDF2Salt(setting, refresh) {
-    return await this.client.getReplicationPBKDF2Salt(refresh);
+    return await this.setupJournalSyncClient(setting).getReplicationPBKDF2Salt(refresh);
   }
-  setupJournalSyncClient() {
-    const settings = this.currentSettings;
+  setupJournalSyncClient(settings = this.currentSettings) {
     if (this._client) {
       this._client.applyNewConfig(settings, this.simpleStore, this.env);
     } else {
@@ -45,13 +69,17 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
     return this._client;
   }
-  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2) {
-    const downloadedMilestone = await this.client.downloadJson(MILSTONE_DOCID);
-    const cPointInfo = await this.client.getCheckpointInfo();
+  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting)) {
+    const milestoneResult = await client.downloadJsonWithResult(MILSTONE_DOCID);
+    if (milestoneResult.status === JournalStorageReadStatuses.UNAVAILABLE) {
+      throw milestoneResult.error;
+    }
+    const downloadedMilestone = milestoneResult.status === JournalStorageReadStatuses.AVAILABLE ? milestoneResult.value : false;
+    const cPointInfo = await client.getCheckpointInfo();
     const progress = [...cPointInfo?.receivedFiles || []].sort().pop() || "";
     return await ensureRemoteIsCompatible(
       downloadedMilestone,
-      this.currentSettings,
+      setting,
       deviceNodeID,
       currentVersionRange2,
       {
@@ -62,7 +90,9 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
         progress
       },
       async (info) => {
-        await this.client.uploadJson(MILSTONE_DOCID, info);
+        if (!await client.uploadJson(MILSTONE_DOCID, info)) {
+          throw new Error("Could not upload remote milestone");
+        }
       }
     );
   }
@@ -74,40 +104,175 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     Logger(`Database updated from ${from} to ${to}`, LOG_LEVEL_NOTICE);
     return Promise.resolve(true);
   }
+  /**
+   * Run one Replicator-owned Journal transfer after any earlier Stop boundary.
+   *
+   * The client owns transfer mechanics, while this Replicator owns the
+   * settlement required by its active-transfer cancellation contract.
+   */
+  runJournalTransfer(run) {
+    const stopGeneration = this.journalTransferStopGeneration;
+    let resolveTask;
+    let rejectTask;
+    const task = new Promise((resolve, reject) => {
+      resolveTask = resolve;
+      rejectTask = reject;
+    });
+    const activeTransfers = this.activeJournalTransfers ??= /* @__PURE__ */ new Set();
+    activeTransfers.add(task);
+    const release = () => activeTransfers.delete(task);
+    void task.then(release, release);
+    void (async () => {
+      const stopping = this.journalTransferStopSettlement;
+      if (stopping) {
+        await stopping;
+      }
+      return await run(stopGeneration);
+    })().then(resolveTask, rejectTask);
+    return task;
+  }
+  /** Request client cancellation and await the transfers admitted before this Stop boundary. */
   terminateSync() {
-    this.client.requestStop();
+    this.journalTransferStopGeneration += 1;
+    const client = this._client;
+    client?.requestStop();
+    if (this.journalTransferStopSettlement) {
+      return this.journalTransferStopSettlement;
+    }
+    const activeTransfers = [...this.activeJournalTransfers ?? []];
+    if (activeTransfers.length === 0) return Promise.resolve();
+    let settlement;
+    settlement = Promise.allSettled(activeTransfers).then(() => {
+      if (this.journalTransferStopSettlement === settlement) {
+        this.journalTransferStopSettlement = void 0;
+      }
+    });
+    this.journalTransferStopSettlement = settlement;
+    return settlement;
   }
-  async openReplication(setting, _, showResult, ignoreCleanLock = false) {
-    if (!await this.checkReplicationConnectivity(false, ignoreCleanLock, showResult)) return false;
-    await this.client.sync(showResult);
-    return true;
+  async openReplication(setting, _, showResult, ignoreCleanLock = false, recordCompatibilityDecision) {
+    return await this.runJournalTransfer(async (stopGeneration) => {
+      const client = this.setupJournalSyncClient(setting);
+      stopGeneration = this.journalTransferStopGeneration;
+      if (!await this.checkReplicationConnectivity(
+        false,
+        ignoreCleanLock,
+        showResult,
+        setting,
+        client,
+        recordCompatibilityDecision
+      )) {
+        return false;
+      }
+      if (stopGeneration !== this.journalTransferStopGeneration) return false;
+      this.hasEnteredReplication = true;
+      return await client.sync(showResult);
+    });
+  }
+  /**
+   * Run one finite Journal attempt against one settings-bound borrowed client.
+   *
+   * Only a rejection observed by this attempt is projected into recovery;
+   * unavailable storage and later transport failures do not reuse old state.
+   */
+  async openOneShotReplicationWithOutcome(setting, showResult, ignoreCleanLock = false) {
+    let decision = CENTRAL_COMPATIBILITY_NOT_ASSESSED;
+    const recordDecision = (next) => {
+      decision = next;
+    };
+    try {
+      const result = await this.openReplication(setting, false, showResult, ignoreCleanLock, recordDecision);
+      return outcomeFromFiniteOpenReplication(result, centralCompatibilityRecoveryHint(decision));
+    } catch (error) {
+      return replicationFailed(error, centralCompatibilityRecoveryHint(decision));
+    }
+  }
+  async runDirectionalReplication(setting, showingNotice, transfer, recordCompatibilityDecision) {
+    return await this.runJournalTransfer(async (stopGeneration) => {
+      const client = this.setupJournalSyncClient(setting);
+      stopGeneration = this.journalTransferStopGeneration;
+      if (!await this.checkReplicationConnectivity(
+        false,
+        false,
+        !!showingNotice,
+        setting,
+        client,
+        recordCompatibilityDecision
+      )) {
+        return false;
+      }
+      if (stopGeneration !== this.journalTransferStopGeneration) return false;
+      this.hasEnteredReplication = true;
+      return await transfer(client);
+    });
+  }
+  /** Capture only the compatibility decision made by this exact borrowed client. */
+  async runDirectionalReplicationWithOutcome(setting, showingNotice, transfer) {
+    let decision = CENTRAL_COMPATIBILITY_NOT_ASSESSED;
+    const recordDecision = (next) => {
+      decision = next;
+    };
+    try {
+      const result = await this.runDirectionalReplication(setting, showingNotice, transfer, recordDecision);
+      return outcomeFromFiniteOpenReplication(result, centralCompatibilityRecoveryHint(decision));
+    } catch (error) {
+      return replicationFailed(error, centralCompatibilityRecoveryHint(decision));
+    }
   }
   async replicateAllToServer(setting, showingNotice) {
-    if (!await this.checkReplicationConnectivity(false, false, !!showingNotice)) return false;
-    return await this.client.sendLocalJournal(showingNotice);
+    return await this.runDirectionalReplication(
+      setting,
+      showingNotice,
+      (client) => client.sendLocalJournal(showingNotice)
+    );
+  }
+  async replicateAllToServerWithOutcome(setting, showingNotice) {
+    return await this.runDirectionalReplicationWithOutcome(
+      setting,
+      showingNotice,
+      (client) => client.sendLocalJournal(showingNotice)
+    );
   }
   async replicateAllFromServer(setting, showingNotice) {
-    if (!await this.checkReplicationConnectivity(false, false, !!showingNotice)) return false;
-    return await this.client.receiveRemoteJournal(showingNotice);
+    return await this.runDirectionalReplication(
+      setting,
+      showingNotice,
+      (client) => client.receiveRemoteJournal(showingNotice)
+    );
   }
-  async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false) {
-    if (!await this.client.isAvailable()) {
+  async replicateAllFromServerWithOutcome(setting, showingNotice) {
+    return await this.runDirectionalReplicationWithOutcome(
+      setting,
+      showingNotice,
+      (client) => client.receiveRemoteJournal(showingNotice)
+    );
+  }
+  async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordCompatibilityDecision) {
+    recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_NOT_ASSESSED);
+    if (!await client.isAvailable()) {
       return false;
     }
     if (!skipCheck) {
-      await this.client.ensureCheckpointCachesAreFresh();
+      await client.ensureCheckpointCachesAreFresh();
       this.remoteCleaned = false;
       this.remoteLocked = false;
       this.remoteLockedAndDeviceNotAccepted = false;
       this.tweakSettingsMismatched = false;
-      const ensure = await this.ensureBucketIsCompatible(this.nodeid, currentVersionRange);
+      this.preferredTweakValue = void 0;
+      const ensure = await this.ensureBucketIsCompatible(this.nodeid, currentVersionRange, setting, client);
       if (ensure == "INCOMPATIBLE") {
+        recordCompatibilityDecision?.(
+          centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.INCOMPATIBLE_VERSION)
+        );
         Logger(
           "The remote database has no compatibility with the running version. Please upgrade the plugin.",
           LOG_LEVEL_NOTICE
         );
         return false;
       } else if (ensure == "NODE_LOCKED") {
+        recordCompatibilityDecision?.(
+          centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.NODE_LOCKED)
+        );
         Logger(
           "The remote database has been rebuilt or corrupted since we have synchronized last time. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
           LOG_LEVEL_NOTICE
@@ -121,6 +286,9 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
         if (ignoreCleanLock) {
           this.remoteLocked = true;
         } else {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.NODE_CLEANED)
+          );
           Logger(
             "The remote database has been cleaned up. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
             LOG_LEVEL_NOTICE
@@ -132,40 +300,52 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
         }
       } else if (ensure == "OK") {
       } else if (ensure[0] == "MISMATCHED") {
+        recordCompatibilityDecision?.(
+          centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.TWEAK_MISMATCH, ensure[1])
+        );
         Logger(this.translate("liveSyncReplicator.mismatchedTweakDetected"), LOG_LEVEL_NOTICE);
         this.tweakSettingsMismatched = true;
         this.preferredTweakValue = ensure[1];
         return false;
       }
+      recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_ACCEPTED);
     }
     return true;
   }
-  async fetchRemoteChunks(missingChunks, showResult) {
-    return Promise.resolve([]);
-  }
   closeReplication() {
-    this.client.requestStop();
+    const reportClosure = this.hasEnteredReplication;
+    this.hasEnteredReplication = false;
+    const client = this._client;
+    this._client = void 0;
+    client?.dispose();
     this.syncStatus = "CLOSED";
-    Logger("Replication closed");
+    if (reportClosure) {
+      Logger("Replication closed");
+    }
     this.updateInfo();
   }
   async tryResetRemoteDatabase(setting) {
     this.closeReplication();
     try {
-      await this.client.resetBucket();
+      if (!await this.client.resetBucket()) {
+        throw new Error("Could not reset remote bucket");
+      }
       clearHandlers();
       Logger("Remote Bucket Cleared", LOG_LEVEL_NOTICE);
       await this.tryCreateRemoteDatabase(setting);
     } catch (ex) {
       Logger("Something happened on Remote Bucket Clear", LOG_LEVEL_NOTICE);
       Logger(ex, LOG_LEVEL_NOTICE);
+      throw ex;
     }
   }
   async tryCreateRemoteDatabase(setting) {
     this.closeReplication();
     Logger("Remote Database Created or Connected", LOG_LEVEL_NOTICE);
     clearHandlers();
-    await this.ensurePBKDF2Salt(setting, true, false);
+    if (!await this.ensurePBKDF2Salt(setting, true, false)) {
+      throw new Error("Could not ensure PBKDF2 salt (Security Seed)");
+    }
     return await Promise.resolve();
   }
   async markRemoteLocked(setting, locked, lockByClean) {
@@ -180,9 +360,10 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       node_info: {},
       tweak_values: {}
     };
+    const client = this.setupJournalSyncClient(setting);
     const remoteMilestone = {
       ...defInitPoint,
-      ...await this.client.downloadJson(MILSTONE_DOCID) || {}
+      ...await readRemoteMilestone(client) ?? {}
     };
     remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
     remoteMilestone.accepted_nodes = [this.nodeid];
@@ -193,7 +374,9 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     } else {
       Logger("Unlock remote bucket to prevent data corruption", LOG_LEVEL_NOTICE);
     }
-    await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+    if (!await client.uploadJson(MILSTONE_DOCID, remoteMilestone)) {
+      throw new Error("Could not upload remote milestone");
+    }
   }
   async markRemoteResolved(setting) {
     const defInitPoint = {
@@ -206,14 +389,17 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       node_info: {},
       tweak_values: {}
     };
+    const client = this.setupJournalSyncClient(setting);
     const remoteMilestone = {
       ...defInitPoint,
-      ...await this.client.downloadJson(MILSTONE_DOCID) || {}
+      ...await readRemoteMilestone(client) ?? {}
     };
     remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
     remoteMilestone.accepted_nodes = Array.from(/* @__PURE__ */ new Set([...remoteMilestone.accepted_nodes, this.nodeid]));
     Logger("Mark this device as 'resolved'.", LOG_LEVEL_NOTICE);
-    await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+    if (!await client.uploadJson(MILSTONE_DOCID, remoteMilestone)) {
+      throw new Error("Could not upload remote milestone");
+    }
   }
   async tryConnectRemote(setting, showResult = true) {
     const endpoint = setting.endpoint;
@@ -227,6 +413,8 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
 ${ex.message}`, LOG_LEVEL_NOTICE);
       Logger(ex, LOG_LEVEL_NOTICE);
       return false;
+    } finally {
+      testClient.dispose();
     }
   }
   async resetRemoteTweakSettings(setting) {
@@ -244,54 +432,74 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async setPreferredRemoteTweakSettings(setting) {
+    const trialClient = new JournalSyncCore(
+      setting,
+      this.simpleStore,
+      this.env,
+      new MinioStorageAdapter(setting, this.env)
+    );
     try {
-      const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
+      const remoteMilestone = await trialClient.downloadJson(MILSTONE_DOCID);
       if (!remoteMilestone) {
         throw new Error("Missing remote milestone");
       }
       remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = extractObject(TweakValuesTemplate, {
         ...setting
       });
-      Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
-      await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+      Logger(`Preferred tweak values have been registered`, LOG_LEVEL_VERBOSE);
+      if (!await trialClient.uploadJson(MILSTONE_DOCID, remoteMilestone)) {
+        throw new Error("Could not upload remote milestone");
+      }
     } catch (ex) {
-      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      Logger(`Could not update remote preferred tweak values`, LOG_LEVEL_NOTICE);
       throw ex;
+    } finally {
+      trialClient.dispose();
     }
   }
-  async getRemotePreferredTweakValues(_setting) {
-    const result = await this.client.downloadJsonWithResult(MILSTONE_DOCID);
-    if (result.status === JournalStorageReadStatuses.NOT_FOUND) {
-      return {
-        status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
-        reason: RemotePreferredTweakNotConfiguredReasons.MILESTONE_MISSING
-      };
-    }
-    if (result.status === JournalStorageReadStatuses.UNAVAILABLE) {
-      return {
-        status: RemotePreferredTweakStatuses.UNAVAILABLE,
-        error: result.error
-      };
-    }
-    const preferred = result.value.tweak_values?.[DEVICE_ID_PREFERRED];
-    if (!preferred) {
+  async getRemotePreferredTweakValues(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 {
+          status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
+          reason: RemotePreferredTweakNotConfiguredReasons.MILESTONE_MISSING
+        };
+      }
+      if (result.status === JournalStorageReadStatuses.UNAVAILABLE) {
+        return {
+          status: RemotePreferredTweakStatuses.UNAVAILABLE,
+          error: result.error
+        };
+      }
+      const preferred = result.value.tweak_values?.[DEVICE_ID_PREFERRED];
+      if (!preferred) {
+        return {
+          status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
+          reason: RemotePreferredTweakNotConfiguredReasons.PREFERRED_VALUES_MISSING
+        };
+      }
       return {
-        status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
-        reason: RemotePreferredTweakNotConfiguredReasons.PREFERRED_VALUES_MISSING
+        status: RemotePreferredTweakStatuses.AVAILABLE,
+        values: preferred
       };
+    } finally {
+      trialClient.dispose();
     }
-    return {
-      status: RemotePreferredTweakStatuses.AVAILABLE,
-      values: preferred
-    };
   }
   async getRemoteStatus(setting) {
     const testClient = new MinioStorageAdapter(setting, this.env);
-    return await testClient.getUsage();
-  }
-  countCompromisedChunks() {
-    Logger(`Bucket Sync Replicator cannot count compromised chunks`, LOG_LEVEL_VERBOSE);
-    return Promise.resolve(0);
+    try {
+      return await testClient.getUsage();
+    } finally {
+      testClient.dispose();
+    }
   }
   getConnectedDeviceList(setting) {
     return Promise.resolve(false);

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

@@ -1,3 +1,11 @@
 import type { LiveSyncReplicatorEnv } from "../LiveSyncAbstractReplicator.js";
+/**
+ * Compatibility name for the Journal Replicator constructor environment.
+ *
+ * Journal currently adds no requirements to {@link LiveSyncReplicatorEnv}.
+ * The distinct exported interface preserves the existing constructor contract
+ * and an extension point; shared host composition should depend on the base
+ * environment unless it specifically constructs a Journal Replicator.
+ */
 export interface LiveSyncJournalReplicatorEnv extends LiveSyncReplicatorEnv {
 }

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

@@ -15,6 +15,8 @@ export type JournalStorageReadResult<T> = {
     error: unknown;
 };
 export interface IJournalStorage {
+    /** Release transport resources retained by this adapter, when any. */
+    dispose?(): void;
     upload(key: string, data: Uint8Array, mime: string): Promise<boolean>;
     download(key: string, ignoreCache?: boolean): Promise<Uint8Array | false>;
     downloadWithResult(key: string, ignoreCache?: boolean): Promise<JournalStorageReadResult<Uint8Array>>;

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

@@ -10,6 +10,8 @@ export declare class MinioStorageAdapter implements IJournalStorage {
     constructor(settings: BucketSyncSetting, env: LiveSyncJournalReplicatorEnv);
     private runTrackedRequest;
     applyNewConfig(settings: BucketSyncSetting): void;
+    /** Release the SDK client owned by this adapter. Repeated calls are safe. */
+    dispose(): void;
     get customHeaders(): [string, string][];
     _getClient(): S3;
     upload(key: string, data: Uint8Array, mime: string): Promise<boolean>;

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

@@ -28,8 +28,14 @@ class MinioStorageAdapter {
     return await runWithTrackedPhysicalRequest(this._env.services.API, task);
   }
   applyNewConfig(settings) {
+    this.dispose();
     this._settings = settings;
+  }
+  /** Release the SDK client owned by this adapter. Repeated calls are safe. */
+  dispose() {
+    const instance = this._instance;
     this._instance = void 0;
+    instance?.destroy();
   }
   get customHeaders() {
     return this._settings.bucketCustomHeaders.length == 0 ? [] : Object.entries(parseHeaderValues(this._settings.bucketCustomHeaders));
@@ -118,7 +124,10 @@ class MinioStorageAdapter {
     const cmd = new GetObjectCommand({
       Bucket: this._settings.bucket,
       Key: `${this._settings.bucketPrefix}${key}`,
-      ...ignoreCache ? { ResponseCacheControl: "no-cache" } : {}
+      // The SDK serialises this response override as a signed query parameter.
+      // Control-object reads use `no-store`: `no-cache` may retain the old
+      // response and serve it after a successful PUT in the same renderer.
+      ...ignoreCache ? { ResponseCacheControl: "no-store" } : {}
     });
     try {
       return await this.runTrackedRequest(async () => {

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

@@ -1,8 +1,9 @@
 import { type RemoteDBSettings, type EntryLeaf, type RemotePreferredTweakResult, type LOG_LEVEL, type NodeData } from "../../common/types.js";
 import { LiveSyncAbstractReplicator, type LiveSyncReplicatorEnv, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
 import { TrysteroReplicator } from "./TrysteroReplicator.js";
-import { P2PHost, type AcceptanceDecision, type RevokeAcceptanceDecision } from "./TrysteroReplicatorP2PServer.js";
+import { type AcceptanceDecision, type RevokeAcceptanceDecision } from "./TrysteroReplicatorP2PServer.js";
 import type { Advertisement } from "./types.js";
+import { type P2PRoomSessionAccess } from "./P2PRoomSessionOwner.js";
 export interface LiveSyncTrysteroReplicatorEnv extends LiveSyncReplicatorEnv {
     /**
      * Injected by the host platform (e.g. Obsidian) to show a UI for peer selection.
@@ -16,60 +17,31 @@ export interface LiveSyncTrysteroReplicatorEnv extends LiveSyncReplicatorEnv {
     openRebuildUI?: (showResult: boolean) => Promise<boolean | void>;
 }
 export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
-    private _p2pHost?;
-    private _replicator?;
-    private _lifecycleOperation;
-    private _shouldBeOpen;
-    private _activeTransportCompatibilitySignature?;
+    private readonly sessionOwner;
+    /** Peer lifecycle is fenced inside the room session rather than this facade. */
+    readonly handlesPeerEventsWithinSession = true;
     get openReplicationUI(): (showResult: boolean) => Promise<boolean | void>;
     get rawReplicator(): TrysteroReplicator;
-    get rawHost(): P2PHost;
+    get rawHost(): import("./TrysteroReplicatorP2PServer.js").TrysteroReplicatorP2PServer;
     getReplicationPBKDF2Salt(_setting: RemoteDBSettings, _refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
     terminateSync(): void;
-    private _buildEnv;
-    private _enqueueLifecycleOperation;
-    /**
-     * Capture settings which are fixed when the active P2P transport joins its room.
-     * A later open request can remain idempotent only while these effective values match.
-     */
-    private _getTransportCompatibilitySignature;
-    /** Close and forget the transport without changing the requested lifecycle state. */
-    private _closeTransport;
     open(): Promise<void>;
     close(): Promise<void>;
     closeReplication(): void;
-    get server(): P2PHost;
+    get server(): import("./TrysteroReplicatorP2PServer.js").TrysteroReplicatorP2PServer;
     get knownAdvertisements(): Advertisement[];
     enableBroadcastChanges(): void;
     disableBroadcastChanges(): void;
     requestStatus(): void;
     onNewPeer(peer: Advertisement): Promise<void>;
     onPeerLeaved(peerId: string): void;
-    replicateFromCommand(showResult?: boolean): Promise<void>;
-    replicateFrom(peerId: string, showNotice?: boolean, skipOrdinaryReplicationPolicy?: boolean): Promise<{
-        error: any;
-        ok?: undefined;
-    } | {
-        ok: boolean;
-        error?: undefined;
-    }>;
-    requestSynchroniseToPeer(peerId: string): Promise<{
-        error: any;
-        ok?: undefined;
-    } | {
-        ok: boolean;
-        error?: undefined;
-    }>;
+    replicateFromCommand(showResult?: boolean): Promise<boolean>;
+    replicateFrom(peerId: string, showNotice?: boolean, skipOrdinaryReplicationPolicy?: boolean): Promise<import("./TrysteroReplicator.js").P2PReplicationResult>;
+    requestSynchroniseToPeer(peerId: string): Promise<import("./TrysteroReplicator.js").P2PReplicationResult>;
     getRemoteConfig(peerId: string): Promise<false | import("../../common/types.js").ObsidianLiveSyncSettings>;
     watchPeer(peerId: string): void;
     unwatchPeer(peerId: string): void;
-    sync(peerId: string, showNotice?: boolean): Promise<{
-        error: any;
-        ok?: undefined;
-    } | {
-        ok: boolean;
-        error?: undefined;
-    }>;
+    sync(peerId: string, showNotice?: boolean): Promise<import("./TrysteroReplicator.js").P2PReplicationResult>;
     setOnSetup(): void;
     clearOnSetup(): void;
     makeDecision(decision: AcceptanceDecision): Promise<void>;
@@ -96,5 +68,5 @@ export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicat
         accepted_nodes: string[];
     }>;
     env: LiveSyncTrysteroReplicatorEnv;
-    constructor(env: LiveSyncTrysteroReplicatorEnv);
+    constructor(env: LiveSyncTrysteroReplicatorEnv, sessionOwner?: P2PRoomSessionAccess);
 }