@vrtmrz/livesync-commonlib 0.1.20 → 0.1.21

package/dist/replication/ReplicatorProvider.d.ts

@@ -68,9 +68,22 @@ export interface UserInitiatedReplicationAuthority {
 export type ReplicationInteraction = NoInteraction | UserInitiatedReplicationAuthority;
 /** Authority carried through a replication request and its failure path. */
 export type InteractionAuthority = ReplicationInteraction;
-/** A request made by an explicitly user-initiated one-shot command. */
+/** Stable host presentation choices for routine OneShot progress. */
+export declare const REPLICATION_PROGRESS_PRESENTATIONS: Readonly<{
+    readonly QUIET: "quiet";
+    readonly NOTICE: "notice";
+}>;
+export type ReplicationProgressPresentation = (typeof REPLICATION_PROGRESS_PRESENTATIONS)[keyof typeof REPLICATION_PROGRESS_PRESENTATIONS];
+/**
+ * A request made by an explicitly user-initiated one-shot command.
+ *
+ * Progress presentation is independent of interaction authority: a quiet
+ * command may still open an authorised peer-selection or failure-recovery
+ * dialogue when the operation requires a decision.
+ */
 export interface UserInitiatedOneShotRequest {
     readonly trigger: "manual";
+    readonly progressPresentation: ReplicationProgressPresentation;
     readonly interaction: InteractionAuthority;
 }
 /** A request made by an automatic finite replication trigger. */
@@ -193,9 +206,9 @@ export interface ReplicationAttemptFailure {
     readonly setting: ObsidianLiveSyncSettings;
     readonly outcome: ReplicationFailed;
 }
-/** Immutable failure source plus the interaction authority of its original request. */
+/** Immutable failure source plus presentation and interaction policy from its original request. */
 export interface ReplicationFailureRequest extends ReplicationAttemptFailure {
-    readonly showMessage: boolean;
+    readonly progressPresentation: ReplicationProgressPresentation;
     readonly interaction: InteractionAuthority;
 }
 /** Return whether one detached setting still belongs to the admitted publication. */

package/dist/replication/ReplicatorProvider.js

@@ -16,6 +16,10 @@ const USER_INITIATED_REPLICATION_AUTHORITY = Object.freeze({
     failureRecovery: true
   })
 });
+const REPLICATION_PROGRESS_PRESENTATIONS = Object.freeze({
+  QUIET: "quiet",
+  NOTICE: "notice"
+});
 const REPLICATION_COMPLETED = Object.freeze({ status: "completed" });
 const REPLICATION_CANCELLED = Object.freeze({ status: "cancelled" });
 const CENTRAL_REMOTE_REPLICATION_READINESS = Object.freeze({
@@ -74,7 +78,7 @@ function supportedOpenReplicationOneShot() {
       const result = await replicator.openReplication(
         setting,
         false,
-        request.interaction.kind === "permitted" && request.interaction.permissions.failureRecovery,
+        request.progressPresentation === REPLICATION_PROGRESS_PRESENTATIONS.NOTICE,
         false
       );
       return outcomeFromFiniteOpenReplication(result);
@@ -129,6 +133,7 @@ export {
   PEER_REPLICATION_READINESS,
   REPLICATION_CANCELLED,
   REPLICATION_COMPLETED,
+  REPLICATION_PROGRESS_PRESENTATIONS,
   USER_INITIATED_REPLICATION_AUTHORITY,
   defineReplicatorProviderDefinitions,
   isActiveReplicatorContextBoundToSetting,

package/dist/replication/index.d.ts

@@ -1,6 +1,6 @@
-export { CAPABILITY_NOT_APPLICABLE, CAPABILITY_NOT_IMPLEMENTED, CENTRAL_REMOTE_REPLICATION_READINESS, NO_INTERACTION, PEER_REPLICATION_READINESS, REPLICATION_CANCELLED, REPLICATION_COMPLETED, USER_INITIATED_REPLICATION_AUTHORITY, defineReplicatorProviderDefinitions, isReplicationCompleted, outcomeFromContinuousOpenReplication, outcomeFromFiniteOpenReplication, replicationBlocked, replicationFailed, supportedOpenReplicationContinuous, supportedOpenReplicationOneShot, supportedOpenReplicationUnattended, supportedStopActiveTransfer, supportedCapability, } from "./ReplicatorProvider.js";
+export { CAPABILITY_NOT_APPLICABLE, CAPABILITY_NOT_IMPLEMENTED, CENTRAL_REMOTE_REPLICATION_READINESS, NO_INTERACTION, PEER_REPLICATION_READINESS, REPLICATION_CANCELLED, REPLICATION_COMPLETED, REPLICATION_PROGRESS_PRESENTATIONS, USER_INITIATED_REPLICATION_AUTHORITY, defineReplicatorProviderDefinitions, isReplicationCompleted, outcomeFromContinuousOpenReplication, outcomeFromFiniteOpenReplication, replicationBlocked, replicationFailed, supportedOpenReplicationContinuous, supportedOpenReplicationOneShot, supportedOpenReplicationUnattended, supportedStopActiveTransfer, supportedCapability, } from "./ReplicatorProvider.js";
 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, ReplicationReadinessRequirements, ReplicationPartial, ReplicationFailureRequest, ReplicatorConfigurationIdentity, ReplicatorProviderDefinition, ReplicatorProviderDefinitionMap, StopActiveTransferRunner, SupportedCapability, UnattendedOneShotRequest, UnattendedReplicationTrigger, UnattendedOneShotRunner, UserInitiatedOneShotRequest, UserInitiatedReplicationAuthority, UserInitiatedOneShotRunner, } from "./ReplicatorProvider.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";

package/dist/replication/index.js

@@ -6,6 +6,7 @@ import {
   PEER_REPLICATION_READINESS,
   REPLICATION_CANCELLED,
   REPLICATION_COMPLETED,
+  REPLICATION_PROGRESS_PRESENTATIONS,
   USER_INITIATED_REPLICATION_AUTHORITY,
   defineReplicatorProviderDefinitions,
   isReplicationCompleted,
@@ -50,6 +51,7 @@ export {
   REMOTE_RESOURCE_KINDS,
   REPLICATION_CANCELLED,
   REPLICATION_COMPLETED,
+  REPLICATION_PROGRESS_PRESENTATIONS,
   USER_INITIATED_REPLICATION_AUTHORITY,
   applyCentralRemoteAdministrationMutation,
   centralRemoteAdministrationVerificationFailed,

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -6,6 +6,7 @@ import {
   CAPABILITY_NOT_APPLICABLE,
   NO_REMOTE_RESOURCE_CAPABILITIES,
   PEER_REPLICATION_READINESS,
+  REPLICATION_PROGRESS_PRESENTATIONS,
   defineReplicatorProviderDefinitions,
   outcomeFromFiniteOpenReplication,
   replicationBlocked,
@@ -38,7 +39,7 @@ function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFa
       const result = await instance.openReplication(
         setting,
         false,
-        request.interaction.permissions.failureRecovery,
+        request.progressPresentation === REPLICATION_PROGRESS_PRESENTATIONS.NOTICE,
         false
       );
       return outcomeFromFiniteOpenReplication(result);

package/dist/services/base/ReplicationService.js

@@ -11,6 +11,7 @@ import {
   CAPABILITY_SUPPORT_KINDS,
   NO_INTERACTION,
   CENTRAL_REMOTE_REPLICATION_READINESS,
+  REPLICATION_PROGRESS_PRESENTATIONS,
   USER_INITIATED_REPLICATION_AUTHORITY,
   isActiveReplicatorContextBoundToSetting,
   isReplicationCompleted,
@@ -196,6 +197,7 @@ class ReplicationService extends ServiceBase {
   onReplicationFailed = handlers().bailFirstFailure("onReplicationFailed");
   async replicateUserInitiated(request = {
     trigger: "manual",
+    progressPresentation: REPLICATION_PROGRESS_PRESENTATIONS.NOTICE,
     interaction: USER_INITIATED_REPLICATION_AUTHORITY
   }) {
     return await this._typedReplication.runUserInitiated(request);

package/dist/services/base/ReplicationService.typedReplication.d.ts

@@ -29,6 +29,7 @@ export interface TypedReplicationCoordinatorDependencies {
  */
 export declare class TypedReplicationCoordinator {
     private readonly dependencies;
+    private oneShotInProgress;
     constructor(dependencies: TypedReplicationCoordinatorDependencies);
     /**
      * Execute a user-initiated finite role with the request's interaction authority.
@@ -67,6 +68,15 @@ export declare class TypedReplicationCoordinator {
      * not a request to begin new remote work.
      */
     stopActiveTransfer(): Promise<ReplicationOutcome>;
+    /**
+     * Admit one complete typed OneShot attempt for this service instance.
+     *
+     * Ownership is recorded before the operation reaches its first await and is
+     * retained through readiness, provider work, activity settlement, and
+     * failure handling. Later requests are neither queued nor joined: they
+     * settle immediately so repeated UI actions cannot replay after the owner.
+     */
+    private runOneShot;
     private finishFiniteAttempt;
     private acquireContext;
     private acquireReadyContext;

package/dist/services/base/ReplicationService.typedReplication.js

@@ -1,6 +1,7 @@
 import {
   CAPABILITY_SUPPORT_KINDS,
   NO_INTERACTION,
+  REPLICATION_PROGRESS_PRESENTATIONS,
   isActiveReplicatorContextBoundToSetting,
   replicationBlocked,
   replicationFailed
@@ -11,6 +12,7 @@ class TypedReplicationCoordinator {
     this.dependencies = dependencies;
   }
   dependencies;
+  oneShotInProgress = false;
   /**
    * Execute a user-initiated finite role with the request's interaction authority.
    *
@@ -20,23 +22,25 @@ class TypedReplicationCoordinator {
    * activity has settled.
    */
   async runUserInitiated(request) {
-    const showMessage = request.interaction.kind === "permitted" && request.interaction.permissions.failureRecovery;
-    const ready = await this.acquireReadyContext(showMessage);
-    if ("status" in ready) return ready;
-    const capability = ready.provider.userInitiatedOneShot;
-    if (capability.kind !== CAPABILITY_SUPPORT_KINDS.SUPPORTED) {
-      return this.finishFiniteAttempt(replicationBlocked(capability.reason));
-    }
-    const settings = Object.freeze(asCopy(this.dependencies.currentSettings()));
-    return this.finishFiniteAttempt(
-      await this.runAdmittedFiniteActivity(
-        ready,
-        (context) => capability.run(context.replicator, settings, request),
-        settings,
-        request.interaction,
-        showMessage
-      )
-    );
+    return await this.runOneShot(async () => {
+      const showProgress = request.progressPresentation === REPLICATION_PROGRESS_PRESENTATIONS.NOTICE;
+      const ready = await this.acquireReadyContext(showProgress);
+      if ("status" in ready) return ready;
+      const capability = ready.provider.userInitiatedOneShot;
+      if (capability.kind !== CAPABILITY_SUPPORT_KINDS.SUPPORTED) {
+        return this.finishFiniteAttempt(replicationBlocked(capability.reason));
+      }
+      const settings = Object.freeze(asCopy(this.dependencies.currentSettings()));
+      return this.finishFiniteAttempt(
+        await this.runAdmittedFiniteActivity(
+          ready,
+          (context) => capability.run(context.replicator, settings, request),
+          settings,
+          request.interaction,
+          request.progressPresentation
+        )
+      );
+    });
   }
   /**
    * Execute an unattended finite role without granting interaction authority.
@@ -49,22 +53,24 @@ class TypedReplicationCoordinator {
     if (request.interaction.kind !== NO_INTERACTION.kind) {
       return replicationBlocked("interaction-required");
     }
-    const ready = await this.acquireReadyContext(false);
-    if ("status" in ready) return ready;
-    const capability = ready.provider.unattendedOneShot;
-    if (capability.kind !== CAPABILITY_SUPPORT_KINDS.SUPPORTED) {
-      return this.finishFiniteAttempt(replicationBlocked(capability.reason));
-    }
-    const settings = Object.freeze(asCopy(this.dependencies.currentSettings()));
-    return this.finishFiniteAttempt(
-      await this.runAdmittedFiniteActivity(
-        ready,
-        (context) => capability.run(context.replicator, settings, request),
-        settings,
-        NO_INTERACTION,
-        false
-      )
-    );
+    return await this.runOneShot(async () => {
+      const ready = await this.acquireReadyContext(false);
+      if ("status" in ready) return ready;
+      const capability = ready.provider.unattendedOneShot;
+      if (capability.kind !== CAPABILITY_SUPPORT_KINDS.SUPPORTED) {
+        return this.finishFiniteAttempt(replicationBlocked(capability.reason));
+      }
+      const settings = Object.freeze(asCopy(this.dependencies.currentSettings()));
+      return this.finishFiniteAttempt(
+        await this.runAdmittedFiniteActivity(
+          ready,
+          (context) => capability.run(context.replicator, settings, request),
+          settings,
+          NO_INTERACTION,
+          REPLICATION_PROGRESS_PRESENTATIONS.QUIET
+        )
+      );
+    });
   }
   /**
    * Start the provider's continuous role outside finite activity accounting.
@@ -130,6 +136,23 @@ class TypedReplicationCoordinator {
     );
     return admitted ?? replicationBlocked("no-active-replicator");
   }
+  /**
+   * Admit one complete typed OneShot attempt for this service instance.
+   *
+   * Ownership is recorded before the operation reaches its first await and is
+   * retained through readiness, provider work, activity settlement, and
+   * failure handling. Later requests are neither queued nor joined: they
+   * settle immediately so repeated UI actions cannot replay after the owner.
+   */
+  async runOneShot(run) {
+    if (this.oneShotInProgress) return replicationBlocked("replication-in-progress");
+    this.oneShotInProgress = true;
+    try {
+      return await run();
+    } finally {
+      this.oneShotInProgress = false;
+    }
+  }
   finishFiniteAttempt(outcome) {
     this.dependencies.recordFiniteAttempt();
     return outcome;
@@ -164,7 +187,7 @@ class TypedReplicationCoordinator {
    * is rejected instead of running work prepared for an older publication.
    * Failure recovery runs only after the reservation has been released.
    */
-  async runAdmittedFiniteActivity(expectedContext, run, setting, interaction, showMessage) {
+  async runAdmittedFiniteActivity(expectedContext, run, setting, interaction, progressPresentation) {
     const admitted = await this.dependencies.replicatorService.runWithActiveReplicatorContext((context) => {
       if (context !== expectedContext || !isActiveReplicatorContextBoundToSetting(context, setting)) {
         return replicationBlocked("not-ready");
@@ -178,7 +201,7 @@ class TypedReplicationCoordinator {
           context: expectedContext,
           setting,
           outcome: result,
-          showMessage,
+          progressPresentation,
           interaction
         })
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrtmrz/livesync-commonlib",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Shared data, storage, and replication primitives for Self-hosted LiveSync clients.",
   "type": "module",
   "types": "./dist/index.d.ts",