@vrtmrz/livesync-commonlib 0.1.44 → 0.2.0

package/dist/replication/RemoteResource.d.ts

@@ -1,12 +1,16 @@
 import type { RemoteDBSettings, RemotePreferredTweakResult } from "../common/types.js";
+import type { JoinedDevicesSnapshot, ForgetJoinedDeviceResult } from "./joinedDevices.js";
 import type { RemoteDBStatus } from "./LiveSyncAbstractReplicator.js";
 import { type CapabilitySupport } from "./ProviderCapability.js";
+import type { InitialFetchFastForward } from "./couchdb/fastForward.js";
 /** Stable machine identifiers for finite provider-owned remote resources. */
 export declare const REMOTE_RESOURCE_KINDS: Readonly<{
     readonly CONNECTION: "connection";
+    readonly JOINED_DEVICES: "joined-devices";
     readonly PREFERRED_TWEAK: "preferred-tweak";
     readonly SECURITY_SEED: "security-seed";
     readonly SYNCHRONISATION_INFORMATION: "synchronisation-information";
+    readonly INITIAL_FETCH_FAST_FORWARD: "initial-fetch-fast-forward";
 }>;
 export type RemoteResourceKind = (typeof REMOTE_RESOURCE_KINDS)[keyof typeof REMOTE_RESOURCE_KINDS];
 /** Options understood by a provider's finite remote-connection resource. */
@@ -64,22 +68,39 @@ export interface SynchronisationInformationResource {
     check(): Promise<boolean>;
     dispose(): Promise<void>;
 }
+/** Checkpoint handoff owned exclusively by one fresh Fast Fetch. */
+export interface InitialFetchFastForwardResource {
+    prepare(): Promise<InitialFetchFastForward | undefined>;
+    dispose(): Promise<void>;
+}
+/** An owned reader and editor of device records for one remote settings snapshot. */
+export interface JoinedDevicesResource {
+    read(): Promise<JoinedDevicesSnapshot>;
+    forget(deviceId: string): Promise<ForgetJoinedDeviceResult>;
+    dispose(): Promise<void>;
+}
 export type RemoteResourceMap = {
+    readonly [REMOTE_RESOURCE_KINDS.JOINED_DEVICES]: JoinedDevicesResource;
     readonly [REMOTE_RESOURCE_KINDS.CONNECTION]: RemoteConnectionProbe;
     readonly [REMOTE_RESOURCE_KINDS.PREFERRED_TWEAK]: PreferredTweakProbe;
     readonly [REMOTE_RESOURCE_KINDS.SECURITY_SEED]: SecuritySeedResource;
     readonly [REMOTE_RESOURCE_KINDS.SYNCHRONISATION_INFORMATION]: SynchronisationInformationResource;
+    readonly [REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD]: InitialFetchFastForwardResource;
 };
 export type RemoteResourceFactoryMap = {
     readonly [K in RemoteResourceKind]: (setting: RemoteDBSettings) => Promise<RemoteResourceMap[K]>;
 };
-/** Exhaustive resource support catalogue supplied by one provider. */
+/** Resource support catalogue; older hosts may omit the initial-fetch optimisation. */
 export type RemoteResourceCapabilities = {
-    readonly [K in RemoteResourceKind]: CapabilitySupport<RemoteResourceFactoryMap[K]>;
+    readonly [K in Exclude<RemoteResourceKind, typeof REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD>]: CapabilitySupport<RemoteResourceFactoryMap[K]>;
+} & {
+    readonly [REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD]?: CapabilitySupport<RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD]>;
 };
 /** Explicit catalogue for providers which own no finite remote resources. */
 export declare const NO_REMOTE_RESOURCE_CAPABILITIES: RemoteResourceCapabilities;
 export type ConnectionProbeFactory = RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.CONNECTION];
 export type PreferredTweakProbeFactory = RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.PREFERRED_TWEAK];
 export type SecuritySeedResourceFactory = RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.SECURITY_SEED];
+export type InitialFetchFastForwardResourceFactory = RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD];
 export type SynchronisationInformationResourceFactory = RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.SYNCHRONISATION_INFORMATION];
+export type JoinedDevicesResourceFactory = RemoteResourceFactoryMap[typeof REMOTE_RESOURCE_KINDS.JOINED_DEVICES];

package/dist/replication/RemoteResource.js

@@ -1,15 +1,19 @@
 import { CAPABILITY_NOT_APPLICABLE } from "./ProviderCapability.js";
 const REMOTE_RESOURCE_KINDS = Object.freeze({
   CONNECTION: "connection",
+  JOINED_DEVICES: "joined-devices",
   PREFERRED_TWEAK: "preferred-tweak",
   SECURITY_SEED: "security-seed",
-  SYNCHRONISATION_INFORMATION: "synchronisation-information"
+  SYNCHRONISATION_INFORMATION: "synchronisation-information",
+  INITIAL_FETCH_FAST_FORWARD: "initial-fetch-fast-forward"
 });
 const NO_REMOTE_RESOURCE_CAPABILITIES = Object.freeze({
   [REMOTE_RESOURCE_KINDS.CONNECTION]: CAPABILITY_NOT_APPLICABLE,
+  [REMOTE_RESOURCE_KINDS.JOINED_DEVICES]: CAPABILITY_NOT_APPLICABLE,
   [REMOTE_RESOURCE_KINDS.PREFERRED_TWEAK]: CAPABILITY_NOT_APPLICABLE,
   [REMOTE_RESOURCE_KINDS.SECURITY_SEED]: CAPABILITY_NOT_APPLICABLE,
-  [REMOTE_RESOURCE_KINDS.SYNCHRONISATION_INFORMATION]: CAPABILITY_NOT_APPLICABLE
+  [REMOTE_RESOURCE_KINDS.SYNCHRONISATION_INFORMATION]: CAPABILITY_NOT_APPLICABLE,
+  [REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD]: CAPABILITY_NOT_APPLICABLE
 });
 export {
   NO_REMOTE_RESOURCE_CAPABILITIES,

package/dist/replication/couchdb/LiveSyncReplicator.d.ts

@@ -1,9 +1,11 @@
 import { type EntryDoc, type RemoteDBSettings, type EntryLeaf, type SyncParameters, type DatabaseEntry, type NodeData, type RemotePreferredTweakResult } from "../../common/types.js";
+import type { InitialFetchFastForwardResource } from "../RemoteResource.js";
 import { LiveSyncAbstractReplicator, type LiveSyncReplicatorEnv, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
 import type { OwnedCouchDBConnection, RemoteConnectionOpenOptions } from "../../services/base/RemoteConnection.js";
 import type { IPathService } from "../../services/base/IService.js";
 import { type CentralCompatibilityDecisionRecorder } from "../CentralCompatibility.js";
 import { type ReplicationOutcome } from "../ReplicatorProvider.js";
+import { type ForgetJoinedDeviceResult, type JoinedDevicesSnapshot } from "../joinedDevices.js";
 export type { OwnedCouchDBConnection, RemoteConnectionOpenOptions } from "../../services/base/RemoteConnection.js";
 /**
  * Compatibility constructor environment for the CouchDB Replicator facade.
@@ -45,6 +47,8 @@ export declare class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicato
     private continuousStopRequested;
     isMobile(): boolean;
     constructor(env: LiveSyncCouchDBReplicatorEnv);
+    /** Own the checkpoint handoff for one fresh, suspended Fast Fetch only. */
+    createInitialFetchFastForwardResource(setting: RemoteDBSettings): InitialFetchFastForwardResource;
     getInitialSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;
     getSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;
     putSyncParameters(setting: RemoteDBSettings, params: SyncParameters): Promise<boolean>;
@@ -152,6 +156,10 @@ export declare class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicato
     compactRemote(setting: RemoteDBSettings): Promise<boolean>;
     getRemoteStatus(setting: RemoteDBSettings): Promise<RemoteDBStatus | false>;
     countCompromisedChunks(setting?: RemoteDBSettings): Promise<number | boolean>;
+    private connectForJoinedDevices;
+    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/couchdb/LiveSyncReplicator.js

@@ -1,6 +1,7 @@
 import {
   VER,
   MILESTONE_DOCID,
+  NODEINFO_DOCID,
   REPLICATION_BUSY_TIMEOUT,
   LOG_LEVEL_INFO,
   LOG_LEVEL_NOTICE,
@@ -26,6 +27,7 @@ import { requiredRemoteFeatures, usesEncryptedInternalMetadata } from "../../pou
 import { assessRemoteDocumentIds } from "../../pouchdb/remoteIdCompatibility.js";
 import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
 import { preprocessOutgoing } from "../../pouchdb/encryption.js";
+import { prepareInitialFetchFastForward } from "./fastForward.js";
 import { ensureDatabaseIsCompatible, getEffectiveTweakValues } from "../../pouchdb/LiveSyncDBFunctions.js";
 import {
   LiveSyncAbstractReplicator
@@ -54,6 +56,10 @@ import {
   replicationBlocked,
   replicationFailed
 } from "../ReplicatorProvider.js";
+import {
+  forgetJoinedDevice as forgetJoinedDeviceFromStore,
+  projectJoinedDevices
+} from "../joinedDevices.js";
 const currentVersionRange = {
   min: 0,
   max: 2400,
@@ -123,6 +129,59 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
     super(env);
     this.env = env;
   }
+  /** Own the checkpoint handoff for one fresh, suspended Fast Fetch only. */
+  createInitialFetchFastForwardResource(setting) {
+    const snapshot = { ...setting };
+    const identity = (value) => JSON.stringify([
+      value.couchDB_URI,
+      value.couchDB_DBNAME,
+      value.couchDB_USER,
+      value.couchDB_PASSWORD,
+      value.couchDB_CustomHeaders,
+      value.useJWT,
+      value.jwtAlgorithm,
+      value.jwtKey,
+      value.jwtExpDuration,
+      value.jwtKid,
+      value.jwtSub,
+      value.encrypt,
+      value.passphrase,
+      value.E2EEAlgorithm,
+      value.enableCompression,
+      value.pathNormalizationVersion,
+      value.readChunksOnline,
+      value.useRequestAPI
+    ]);
+    const binding = identity(snapshot);
+    let connection;
+    let prepared = false;
+    let disposed = false;
+    return {
+      prepare: async () => {
+        if (prepared || disposed) return void 0;
+        prepared = true;
+        if (this.currentSettings.doNotSuspendOnFetching || snapshot.useRequestAPI) return void 0;
+        const local = this.rawDatabase;
+        const isCurrent = () => !disposed && this.rawDatabase === local && this.currentSettings.suspendFileWatching && this.currentSettings.suspendParseReplicationResult && identity(this.currentSettings) === binding;
+        if (!isCurrent()) return void 0;
+        const openedConnection = await this.openOwnedConnection(snapshot);
+        if (disposed) {
+          await openedConnection.close();
+          return void 0;
+        }
+        connection = openedConnection;
+        return await prepareInitialFetchFastForward(local, connection.db, {
+          push: {},
+          ...snapshot.readChunksOnline ? { pull: { ...selectorOnDemandPull } } : {}
+        }, isCurrent);
+      },
+      dispose: async () => {
+        if (disposed) return;
+        disposed = true;
+        if (connection) await connection.close();
+      }
+    };
+  }
   getInitialSyncParameters(setting) {
     return Promise.resolve({
       ...DEFAULT_SYNC_PARAMETERS,
@@ -925,7 +984,8 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           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()
         };
         let tweakAssessment;
         const ensure = await ensureDatabaseIsCompatible(
@@ -1608,6 +1668,77 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     }
     return await this.withRemoteConnection(dbRet, countCompromisedChunks);
   }
+  async connectForJoinedDevices(setting) {
+    let result;
+    try {
+      result = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), false);
+    } catch {
+      throw new Error("Could not connect to remote CouchDB for joined-device management.");
+    }
+    if (typeof result === "string") {
+      throw new Error("Could not connect to remote CouchDB for joined-device management.");
+    }
+    return result;
+  }
+  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) {
+    const connection = await this.connectForJoinedDevices(setting);
+    return await this.withRemoteConnection(connection, async (db) => {
+      let milestone;
+      try {
+        milestone = await db.get(MILESTONE_DOCID);
+      } catch (ex) {
+        if (!isErrorOfMissingDoc(ex)) throw ex;
+      }
+      return projectJoinedDevices(milestone);
+    });
+  }
+  async forgetJoinedDevice(setting, deviceId) {
+    const ownDeviceId = await this.getOwnJoinedDeviceId();
+    const connection = await this.connectForJoinedDevices(setting);
+    return await this.withRemoteConnection(connection, async (db) => {
+      const store = {
+        read: async () => {
+          let milestone;
+          try {
+            milestone = await db.get(MILESTONE_DOCID);
+          } catch (ex) {
+            if (isErrorOfMissingDoc(ex)) return void 0;
+            throw ex;
+          }
+          return { milestone, revision: milestone._rev };
+        },
+        write: async (milestone, revision) => {
+          try {
+            await db.put({ ...milestone, _rev: revision });
+          } catch (ex) {
+            if (ex && typeof ex === "object" && ex.status === 409) {
+              return "conflict";
+            }
+            throw ex;
+          }
+          let verifiedMilestone;
+          try {
+            verifiedMilestone = await db.get(MILESTONE_DOCID);
+          } catch {
+            throw new Error("Could not verify joined-device removal.");
+          }
+          if (projectJoinedDevices(verifiedMilestone).devices.some((device) => device.id === deviceId)) {
+            throw new Error("Could not verify joined-device removal.");
+          }
+          return "updated";
+        }
+      };
+      return await forgetJoinedDeviceFromStore(store, deviceId, ownDeviceId);
+    });
+  }
   async getConnectedDeviceList(setting = this.currentSettings) {
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
     if (typeof dbRet === "string") {

package/dist/replication/couchdb/fastForward.d.ts

@@ -0,0 +1,19 @@
+import type { EntryDoc } from "../../common/types.js";
+type Sequence = string | number;
+/** Evidence retained only for the currently running, fresh Fast Fetch. */
+export interface InitialFetchFastForward {
+    recordStoredRevisions(revisions: readonly {
+        id: string;
+        rev: string;
+    }[]): void;
+    recordCheckpoint(sequence: Sequence): void;
+    fastForward(): Promise<boolean>;
+}
+/**
+ * Prepare ordinary checkpoint pairs before a fresh import into an empty database.
+ * The importer must remain the sole writer until fastForward settles.
+ * The remote database must remain in place throughout the import and handoff:
+ * PouchDB's HTTP ID identifies a server and database name, not its incarnation.
+ */
+export declare function prepareInitialFetchFastForward(localDatabase: PouchDB.Database<EntryDoc>, remoteDatabase: PouchDB.Database<EntryDoc>, options: PouchDB.Replication.SyncOptions, isCurrent: () => boolean): Promise<InitialFetchFastForward | undefined>;
+export {};

package/dist/replication/couchdb/fastForward.js

@@ -0,0 +1,119 @@
+import generateReplicationId from "pouchdb-generate-replication-id";
+import Checkpointer from "pouchdb-checkpointer";
+import { uuid } from "pouchdb-utils";
+const MAX_TRACKED_REVISIONS = 1e5;
+async function prepareInitialFetchFastForward(localDatabase, remoteDatabase, options, isCurrent) {
+  const local = localDatabase;
+  const remote = remoteDatabase;
+  if ((await local.info()).doc_count !== 0 || !isCurrent()) return void 0;
+  const localId = await local.id();
+  const remoteId = await remote.id();
+  const pairs = [
+    { source: local, target: remote, options: { ...options, ...options.push } },
+    { source: remote, target: local, options: { ...options, ...options.pull } }
+  ];
+  const checkpoints = [];
+  for (const pair of pairs) {
+    const id = await generateReplicationId(pair.source, pair.target, pair.options);
+    for (const database of [local, remote]) {
+      try {
+        await database.get(id);
+        return void 0;
+      } catch (error) {
+        if (error.status !== 404) throw error;
+      }
+    }
+    const session = uuid();
+    await new Checkpointer(pair.source, pair.target, id, { cancelled: false }).writeCheckpoint(0, session);
+    checkpoints.push({
+      id,
+      session,
+      localRevision: (await local.get(id))._rev,
+      remoteRevision: (await remote.get(id))._rev
+    });
+  }
+  const imported = /* @__PURE__ */ new Set();
+  let withinBudget = true;
+  let lastSequence;
+  let consumed = false;
+  const key = (id, rev) => JSON.stringify([id, rev]);
+  return {
+    recordStoredRevisions(revisions) {
+      if (!withinBudget) return;
+      for (const revision of revisions) {
+        imported.add(key(revision.id, revision.rev));
+        if (imported.size > MAX_TRACKED_REVISIONS) {
+          imported.clear();
+          withinBudget = false;
+          return;
+        }
+      }
+    },
+    recordCheckpoint(sequence) {
+      lastSequence = sequence;
+    },
+    async fastForward() {
+      if (consumed) return false;
+      consumed = true;
+      if (!withinBudget || lastSequence === void 0 || !isCurrent()) return false;
+      if (await local.id() !== localId || await remote.id() !== remoteId) return false;
+      const localSequence = (await local.info()).update_seq;
+      let since = 0;
+      while (true) {
+        const changes = await local.changes({
+          since,
+          limit: 1e3,
+          style: "all_docs",
+          return_docs: true
+        });
+        for (const change of changes.results) {
+          for (const revision of change.changes) {
+            if (!imported.has(key(change.id, revision.rev))) return false;
+          }
+        }
+        if (changes.results.length < 1e3) break;
+        since = changes.last_seq;
+      }
+      if (!isCurrent() || (await local.info()).update_seq !== localSequence) return false;
+      const guard = (database, id, expectedRevision, session) => ({
+        adapter: database.adapter,
+        async get(requestedId) {
+          let document;
+          try {
+            document = await database.get(requestedId);
+          } catch (cause) {
+            throw new Error("The initial-fetch checkpoint is no longer available.", { cause });
+          }
+          if (requestedId !== id || document._rev !== expectedRevision || document.session_id !== session) {
+            throw new Error("The initial-fetch checkpoint changed before fast-forwarding.");
+          }
+          return document;
+        },
+        async put(document) {
+          if (document._id !== id || document._rev !== expectedRevision) {
+            throw new Error("The initial-fetch checkpoint no longer matches its import.");
+          }
+          const response = await database.put(document);
+          expectedRevision = response.rev;
+          return response;
+        }
+      });
+      for (const [index, checkpoint] of checkpoints.entries()) {
+        if (!isCurrent() || (await local.info()).update_seq !== localSequence) return false;
+        const guardedLocal = guard(local, checkpoint.id, checkpoint.localRevision, checkpoint.session);
+        const guardedRemote = guard(remote, checkpoint.id, checkpoint.remoteRevision, checkpoint.session);
+        const source = index === 0 ? guardedLocal : guardedRemote;
+        const target = index === 0 ? guardedRemote : guardedLocal;
+        await new Checkpointer(source, target, checkpoint.id, { cancelled: false }).writeCheckpoint(
+          index === 0 ? localSequence : lastSequence,
+          checkpoint.session
+        );
+      }
+      imported.clear();
+      return true;
+    }
+  };
+}
+export {
+  prepareInitialFetchFastForward
+};

package/dist/replication/index.d.ts

@@ -3,10 +3,12 @@ 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";

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[];