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

package/README.md

@@ -28,6 +28,8 @@ The package is ESM-only and declares Node 20 or later. Browser entry points are
 | `@vrtmrz/livesync-commonlib/context`               | Instance-owned events, translation injection, and host-neutral standard-I/O types | Focused, package-tested pre-1.0 contract                                                    |
 | `@vrtmrz/livesync-commonlib/browser`               | Rooted File System Access API storage                                             | Focused, package-tested pre-1.0 contract                                                    |
 | `@vrtmrz/livesync-commonlib/node`                  | Rooted Node storage, Node standard I/O, and selected Node capabilities            | Supported platform façade; keeps Node-only dependencies behind an explicit boundary         |
+| `@vrtmrz/livesync-commonlib/p2p`                   | Host-composed P2P service views and composition helpers                           | Focused, package-tested pre-1.0 contract with a temporary compatibility façade              |
+| `@vrtmrz/livesync-commonlib/replication`           | Provider capabilities, interaction authority, and typed replication outcomes      | Focused, package-tested pre-1.0 host-composition contract                                   |
 | `@vrtmrz/livesync-commonlib/rpc`                   | Existing LiveSync RPC and PouchDB bridge migration                                | Transitional only; not part of the stable Commonlib 1.0 contract                            |
 | `@vrtmrz/livesync-commonlib/remote-configurations` | Multiple-remote profile creation, naming, and selection                           | Focused, package-tested pre-1.0 contract                                                    |
 | `@vrtmrz/livesync-commonlib/settings`              | New-Vault defaults, stored-setting fallbacks, and settings migration results      | Focused, package-tested pre-1.0 contract                                                    |
@@ -40,6 +42,8 @@ The Node and browser entries are platform façades. They keep platform-specific
 
 The RPC entry exists only while the maintained LiveSync P2P composition depends on the current implementation. Its draft wire protocol and PouchDB bridge are not stable Commonlib 1.0 contracts. RPC is planned to move to Fancy Kit as an independently owned rewrite; new Commonlib consumers should not adopt the transitional entry.
 
+The P2P entry exposes eight focused views over one service owner, together with the maintained host-composition helpers. New consumers select only the lifecycle, peer-directory, peer-admission, targeted-transfer, change-relay, configuration-exchange, diagnostic, or connection-probe-admission view which they need. The composition result still carries a deprecated concrete Replicator façade while existing panes migrate; new consumers must not depend on that property or reach through it to a raw room or host.
+
 ## Host context and initialisation
 
 One service context belongs to one independently composed Commonlib client. It owns that client's event hub and translator. Creating a context without options creates a fresh event hub and renders Commonlib's typed canonical English messages. A host may inject a translator to provide another language:
@@ -123,7 +127,7 @@ The package is currently an infrastructure and compatibility boundary. The conte
 
 The accepted replacement direction is an asynchronously created file client with stable `list`, `get`, `put`, `delete`, `watch`, and `close` operations. The operation result, conflict, concurrency, watch checkpoint, retry, and error contracts still require focused decisions and tests before that client can be published.
 
-Package developers should read [the developer guide](docs/development.md). The focused contracts are described in [the storage guide](docs/platform-storage.md), [the standard-I/O guide](docs/platform-standard-io.md), [the settings lifecycle guide](docs/settings-lifecycle.md), [the remote configuration profile guide](docs/remote-configurations.md), and [the conflict-resolution guide](docs/conflict-resolution.md).
+Package developers should read [the developer guide](docs/development.md). The focused contracts are described in [the storage guide](docs/platform-storage.md), [the standard-I/O guide](docs/platform-standard-io.md), [the settings lifecycle guide](docs/settings-lifecycle.md), [the remote configuration profile guide](docs/remote-configurations.md), [the conflict-resolution guide](docs/conflict-resolution.md), and [the P2P transport lifecycle guide](docs/p2p-transport-lifecycle.md).
 
 ## Proven in maintained hosts
 

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

@@ -8,6 +8,8 @@ import { type P2PConnectionPath } from "./setting.const.js";
 export declare function normaliseP2PMaxWirePayloadBytes(value: unknown): number;
 /** Return a recognised P2P connection path, defaulting legacy values to automatic selection. */
 export declare function normaliseP2PConnectionPath(value: unknown): P2PConnectionPath;
+/** Split the stored comma-separated signalling relay list without changing its entries. */
+export declare function splitP2PRelayUrls(value: string | undefined): string[];
 /** Split the stored comma-separated TURN server list without changing its entries. */
 export declare function splitP2PTurnServerUrls(value: string): string[];
 /**

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

@@ -8,6 +8,10 @@ function normaliseP2PMaxWirePayloadBytes(value) {
 function normaliseP2PConnectionPath(value) {
   return value === P2PConnectionPaths.Relay ? P2PConnectionPaths.Relay : P2PConnectionPaths.Automatic;
 }
+function splitP2PRelayUrls(value) {
+  if (!value) return [];
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
 function splitP2PTurnServerUrls(value) {
   return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 }
@@ -31,5 +35,6 @@ export {
   isValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
   normaliseP2PMaxWirePayloadBytes,
+  splitP2PRelayUrls,
   splitP2PTurnServerUrls
 };

package/dist/interfaces/ServiceModule.d.ts

@@ -42,11 +42,20 @@ export type ServiceFeatureFunctionWithContext<T extends keyof ServiceHub, U exte
  * @param featureFunction The feature function to be wrapped.
  * @returns The same feature function with proper typing.
  * @example
- * const myFeatureDef = createServiceFeature(({ services: { API }, serviceModules: { storageAccess } }) => {
- *   // ...
+ * const useIndexFeature = createServiceFeature((host: NecessaryServices<"appLifecycle", "storageAccess">) => {
+ *   const { appLifecycle } = host.services;
+ *   const { storageAccess } = host.serviceModules;
+ *
+ *   appLifecycle.onLoaded.addHandler(async () => {
+ *     await storageAccess.getFileNames();
+ *     return true;
+ *   });
+ * });
+ *
+ * useIndexFeature({
+ *   services: { context: serviceHub.context, appLifecycle: serviceHub.appLifecycle },
+ *   serviceModules: { storageAccess },
  * });
- * const myFeature = myFeatureDef.bind(null, this); // <- `this` may `ObsidianLiveSyncPlugin` or a custom context object
- * appLifecycle.onLayoutReady(myFeature);
  */
 export declare function createServiceFeature<T extends keyof ServiceHub, U extends keyof ServiceModules, TR>(featureFunction: ServiceFeatureFunction<T, U, TR>): ServiceFeatureFunction<T, U, TR>;
 type ContextFactory<T extends keyof ServiceHub, U extends keyof ServiceModules, C> = (host: NecessaryServices<T, U>) => ServiceFeatureContext<C>;

package/dist/managers/ChunkFetcher.js

@@ -9,6 +9,9 @@ const EVENT_MISSING_CHUNKS = "missingChunks";
 const EVENT_MISSING_CHUNK_REMOTE = "missingChunkRemote";
 const EVENT_CHUNK_FETCHED = "chunkFetched";
 const BATCH_SIZE = 100;
+function canFetchRemoteChunks(replicator) {
+  return "fetchRemoteChunks" in replicator && typeof replicator.fetchRemoteChunks === "function";
+}
 class ChunkFetcher {
   options;
   get chunkManager() {
@@ -169,6 +172,13 @@ class ChunkFetcher {
         Logger("No active replicator was found to request missing chunks.");
         return;
       }
+      if (!canFetchRemoteChunks(replicator)) {
+        Logger("The active replicator does not support fetching individual remote chunks.");
+        for (const chunkID of requestIDs) {
+          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+        }
+        return;
+      }
       const fetched = await replicator.fetchRemoteChunks(requestIDs, false);
       this.touchClaims(requestIDs);
       if (!fetched) {

package/dist/p2p/P2PService.d.ts

@@ -0,0 +1,123 @@
+import type { ObsidianLiveSyncSettings } from "../common/types.js";
+import type { ReplicatorInstance } from "../replication/ReplicatorInstance.js";
+import type { DiagRTCPeerConnectionMetrics } from "../rpc/transports/DiagRTCPeerConnections.types.js";
+import { LiveSyncTrysteroReplicator, type LiveSyncTrysteroReplicatorEnv } from "../replication/trystero/LiveSyncTrysteroReplicator.js";
+import type { P2PReplicationResult } from "../replication/trystero/TrysteroReplicator.js";
+import type { AcceptanceDecision, RevokeAcceptanceDecision } from "../replication/trystero/TrysteroReplicatorP2PServer.js";
+import type { Advertisement } from "../replication/trystero/types.js";
+import { type ReplicationOutcome } from "../replication/ReplicatorProvider.js";
+import type { P2PConnectionProbeAdmission } from "../replication/trystero/P2PConnectionProbeAdmission.js";
+export { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "../replication/trystero/P2PConnectionProbeAdmission.js";
+export type { P2PConnectionProbeAdmission, P2PConnectionProbeAdmissionResult, P2PConnectionProbeSettings, } from "../replication/trystero/P2PConnectionProbeAdmission.js";
+/** Candidate details projected from browser RTC statistics. */
+export interface P2PCandidateSummary {
+    readonly id: string;
+    readonly candidateType: string;
+    readonly protocol: string;
+    readonly relayProtocol: string;
+}
+/**
+ * Current peer-connection metrics without a raw RTC report or peer handle.
+ *
+ * Missing numeric values use the existing `unknown` sentinel so maintained
+ * diagnostic output can distinguish absence from zero.
+ */
+export interface P2PPeerConnectionMetrics {
+    readonly selectedPairPresent: boolean;
+    readonly selectedPairId: string;
+    readonly state: string;
+    readonly currentRoundTripTime: number | "unknown";
+    readonly totalRoundTripTime: number | "unknown";
+    readonly requestsSent: number | "unknown";
+    readonly responsesReceived: number | "unknown";
+    readonly packetsDiscardedOnSend: number | "unknown";
+    readonly bytesSent: number | "unknown";
+    readonly bytesReceived: number | "unknown";
+    readonly localCandidate?: P2PCandidateSummary;
+    readonly remoteCandidate?: P2PCandidateSummary;
+}
+/** Project low-level RTC statistics into the focused P2P diagnostic contract. */
+export declare function projectP2PPeerConnectionMetrics(metrics: DiagRTCPeerConnectionMetrics): P2PPeerConnectionMetrics;
+/** Observes and explicitly controls the room transport owned by the P2P service. */
+export interface P2PTransportLifecycle {
+    readonly isConnected: boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+/** Supplies a current peer snapshot without exposing the underlying room. */
+export interface P2PPeerDirectory {
+    getPeers(): readonly Advertisement[];
+}
+/** Administers temporary and persisted peer acceptance decisions. */
+export interface P2PPeerAdmission {
+    makeDecision(decision: AcceptanceDecision): Promise<void>;
+    revokeDecision(decision: RevokeAcceptanceDecision): Promise<void>;
+}
+/** Performs finite transfer operations against an explicitly selected peer. */
+export interface P2PTargetedTransfer {
+    pullFromPeer(peerId: string, options?: {
+        readonly showNotice?: boolean;
+        readonly skipOrdinaryReplicationPolicy?: boolean;
+    }): Promise<P2PReplicationResult>;
+    requestPushToPeer(peerId: string): Promise<P2PReplicationResult>;
+    synchroniseWithPeer(peerId: string, showNotice?: boolean): Promise<P2PReplicationResult>;
+    /** Synchronise the persisted target set without interactive peer selection. */
+    synchroniseConfiguredTargets(): Promise<ReplicationOutcome>;
+}
+/** Controls watch and broadcast behaviour attached to the current room session. */
+export interface P2PChangeRelay {
+    watchPeer(peerId: string): void;
+    unwatchPeer(peerId: string): void;
+    enableBroadcastChanges(): void;
+    disableBroadcastChanges(): void;
+}
+/** Exchanges configuration with one explicitly selected peer. */
+export interface P2PConfigurationExchange {
+    getRemoteConfiguration(peerId: string): Promise<ObsidianLiveSyncSettings | false>;
+}
+/** Supplies transport diagnostics without exposing a room or peer connection. */
+export interface P2PDiagnostics {
+    requestStatus(): void;
+    getPeerConnectionMetrics(peerId: string): Promise<P2PPeerConnectionMetrics | undefined>;
+}
+/** Focused contract views backed by one private P2P service context. */
+export interface P2PServiceViews {
+    readonly transportLifecycle: P2PTransportLifecycle;
+    readonly connectionProbe: P2PConnectionProbeAdmission;
+    readonly peerDirectory: P2PPeerDirectory;
+    readonly peerAdmission: P2PPeerAdmission;
+    readonly targetedTransfer: P2PTargetedTransfer;
+    readonly changeRelay: P2PChangeRelay;
+    readonly configurationExchange: P2PConfigurationExchange;
+    readonly diagnostics: P2PDiagnostics;
+}
+/**
+ * Host-only lifecycle operations which are deliberately absent from ordinary
+ * P2P capability views.
+ */
+export interface P2PServiceLifecycle {
+    requestStatus(): void;
+    openAfterDatabaseRebuild(): Promise<void>;
+    closeForLifecycle(): Promise<void>;
+    /** Reconcile the automatic room demand; the room owner also reapplies current room-local policy. */
+    reconcileAutoStart(settings: Pick<ObsidianLiveSyncSettings, "P2P_Enabled" | "P2P_AutoStart">): Promise<void>;
+    scheduleAutoStart(delayMs?: number): void;
+}
+/** Host composition result. Ordinary consumers receive only `views`. */
+export interface P2PServiceComposition {
+    /** Deprecated compatibility surface for consumers which still require it. */
+    readonly compatibilityReplicator: LiveSyncTrysteroReplicator;
+    /** Stable capability projections over the private service context. */
+    readonly views: P2PServiceViews;
+    /** Host lifecycle operations which are not ordinary P2P capabilities. */
+    readonly lifecycle: P2PServiceLifecycle;
+    /** Create a non-owning adapter for the active Replicator selection. */
+    createActiveReplicator(): ReplicatorInstance;
+}
+/**
+ * Compose stable capability views over one private P2P service context.
+ *
+ * `P2PRoomSessionOwner` remains the resource owner. The returned composition
+ * object is host wiring, not a capability façade for ordinary consumers.
+ */
+export declare function createP2PService(env: LiveSyncTrysteroReplicatorEnv): P2PServiceComposition;

package/dist/p2p/P2PService.js

@@ -0,0 +1,271 @@
+import { getPeerConnectionStats } from "../rpc/transports/DiagRTCPeerConnections.utils.js";
+import {
+  LiveSyncTrysteroReplicator
+} from "../replication/trystero/LiveSyncTrysteroReplicator.js";
+import { P2PRoomSessionOwner } from "../replication/trystero/P2PRoomSessionOwner.js";
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+import {
+  REPLICATION_CANCELLED,
+  REPLICATION_COMPLETED,
+  replicationBlocked,
+  replicationFailed
+} from "../replication/ReplicatorProvider.js";
+import { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "../replication/trystero/P2PConnectionProbeAdmission.js";
+function getReportValue(report, key) {
+  const value = report?.[key];
+  return typeof value === "string" || typeof value === "number" ? String(value) : "unknown";
+}
+function isUnknownRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function projectCandidate(reports, candidateId) {
+  if (candidateId === "unknown") return void 0;
+  const report = reports.filter(isUnknownRecord).find((value) => value.id === candidateId);
+  if (!report) return void 0;
+  return {
+    id: candidateId,
+    candidateType: getReportValue(report, "candidateType"),
+    protocol: getReportValue(report, "protocol"),
+    relayProtocol: getReportValue(report, "relayProtocol")
+  };
+}
+function projectP2PPeerConnectionMetrics(metrics) {
+  return {
+    selectedPairPresent: metrics.selectedPair !== void 0,
+    selectedPairId: metrics.selectedPairId,
+    state: metrics.state,
+    currentRoundTripTime: metrics.currentRoundTripTime,
+    totalRoundTripTime: metrics.totalRoundTripTime,
+    requestsSent: metrics.requestsSent,
+    responsesReceived: metrics.responsesReceived,
+    packetsDiscardedOnSend: metrics.packetsDiscardedOnSend,
+    bytesSent: metrics.bytesSent,
+    bytesReceived: metrics.bytesReceived,
+    localCandidate: projectCandidate(metrics.reports, metrics.localCandidateId),
+    remoteCandidate: projectCandidate(metrics.reports, metrics.remoteCandidateId)
+  };
+}
+function connect(owner, state) {
+  state.explicitDisconnectVeto = false;
+  state.lifecycleClosed = false;
+  return owner.setPersistentDemand("explicit", true);
+}
+function clearDelayedAutoStart(state) {
+  if (state.delayedAutoStart !== void 0) {
+    compatGlobal.clearTimeout(state.delayedAutoStart);
+    state.delayedAutoStart = void 0;
+  }
+}
+function cancelDelayedAutomation(owner, state) {
+  state.lifecycleGeneration += 1;
+  owner.beginAutomationLifecycle();
+  clearDelayedAutoStart(state);
+}
+function disconnect(owner, state) {
+  state.explicitDisconnectVeto = true;
+  cancelDelayedAutomation(owner, state);
+  return owner.close();
+}
+function openAfterDatabaseRebuild(owner, state) {
+  state.lifecycleClosed = false;
+  return owner.setPersistentDemand("rebuild-continuation", true);
+}
+function closeForLifecycle(owner, state) {
+  state.lifecycleClosed = true;
+  cancelDelayedAutomation(owner, state);
+  return owner.close();
+}
+function reconcileAutoStart(context, settings) {
+  if (!settings.P2P_Enabled || !settings.P2P_AutoStart) {
+    return context.roomSessionOwner.setPersistentDemand("automatic", false);
+  }
+  if (context.state.explicitDisconnectVeto || context.state.lifecycleClosed) return Promise.resolve();
+  return context.roomSessionOwner.setPersistentDemand("automatic", true);
+}
+function scheduleAutoStart(context, delayMs = 100) {
+  clearDelayedAutoStart(context.state);
+  context.state.lifecycleClosed = false;
+  const generation = context.state.lifecycleGeneration;
+  context.state.delayedAutoStart = compatGlobal.setTimeout(() => {
+    context.state.delayedAutoStart = void 0;
+    if (generation !== context.state.lifecycleGeneration) return;
+    void reconcileAutoStart(context, context.env.services.setting.currentSettings());
+  }, delayMs);
+}
+function runWithFiniteRoomDemand(context, task) {
+  if (context.state.explicitDisconnectVeto) {
+    return Promise.reject(new Error("The P2P room was explicitly disconnected."));
+  }
+  if (context.state.lifecycleClosed) return Promise.reject(new Error("The P2P room is not ready."));
+  return context.roomSessionOwner.runWithFiniteDemand(task);
+}
+async function synchroniseConfiguredTargets(context) {
+  if (context.state.explicitDisconnectVeto || context.state.lifecycleClosed) return replicationBlocked("not-ready");
+  try {
+    const result = await context.roomSessionOwner.runWithFiniteDemand(
+      (session) => session.runFiniteOperation((signal) => session.replicator.replicateFromCommand(false, void 0, signal))
+    );
+    if (result.status === "completed") return REPLICATION_COMPLETED;
+    if (result.status === "cancelled") return REPLICATION_CANCELLED;
+    if (result.status === "blocked") return replicationBlocked(result.reason);
+    return {
+      status: "partial",
+      detail: { kind: "p2p-configured-targets", targets: result.targets }
+    };
+  } catch (error) {
+    return replicationFailed(error);
+  }
+}
+function pullFromPeer(context, peerId, options = {}) {
+  return runWithFiniteRoomDemand(
+    context,
+    (session) => context.env.services.replicator.runFiniteReplicationActivity(
+      () => session.replicator.replicateFrom(
+        peerId,
+        options.showNotice ?? false,
+        false,
+        options.skipOrdinaryReplicationPolicy ?? false
+      ),
+      { label: "replication" }
+    )
+  );
+}
+function requestPushToPeer(context, peerId) {
+  return runWithFiniteRoomDemand(
+    context,
+    (session) => context.env.services.replicator.runBoundedRemoteActivity(
+      () => session.replicator.requestSynchroniseToPeer(peerId),
+      { label: "replication" }
+    )
+  );
+}
+function synchroniseWithPeer(context, peerId, showNotice = false) {
+  return runWithFiniteRoomDemand(
+    context,
+    (session) => context.env.services.replicator.runFiniteReplicationActivity(
+      () => session.replicator.sync(peerId, showNotice),
+      { label: "replication" }
+    )
+  );
+}
+async function getPeerConnectionMetrics(context, peerId) {
+  const peerConnection = context.compatibilityReplicator.rawHost?.room?.getPeers()[peerId];
+  if (!peerConnection) return void 0;
+  const metrics = await getPeerConnectionStats(`p2p-service-${peerId}`, peerConnection);
+  return metrics ? projectP2PPeerConnectionMetrics(metrics) : void 0;
+}
+function createCompatibilitySessionAccess(owner, state) {
+  return {
+    get currentSession() {
+      return owner.currentSession;
+    },
+    get isConnected() {
+      return owner.isConnected;
+    },
+    cancelActiveTransfers: () => owner.cancelActiveTransfers(),
+    open: () => connect(owner, state),
+    close: () => disconnect(owner, state)
+  };
+}
+function createServiceViews(context) {
+  const transportLifecycle = {
+    get isConnected() {
+      return context.roomSessionOwner.isConnected;
+    },
+    connect: () => connect(context.roomSessionOwner, context.state),
+    disconnect: () => disconnect(context.roomSessionOwner, context.state)
+  };
+  const connectionProbe = {
+    run: (trialSettings, runOwnedTrial) => context.roomSessionOwner.runConnectionProbe(trialSettings, runOwnedTrial)
+  };
+  const peerDirectory = {
+    getPeers: () => context.compatibilityReplicator.knownAdvertisements
+  };
+  const peerAdmission = {
+    makeDecision: (decision) => context.compatibilityReplicator.makeDecision(decision),
+    revokeDecision: (decision) => context.compatibilityReplicator.revokeDecision(decision)
+  };
+  const targetedTransfer = {
+    pullFromPeer: (peerId, options) => pullFromPeer(context, peerId, options),
+    requestPushToPeer: (peerId) => requestPushToPeer(context, peerId),
+    synchroniseWithPeer: (peerId, showNotice) => synchroniseWithPeer(context, peerId, showNotice),
+    synchroniseConfiguredTargets: () => synchroniseConfiguredTargets(context)
+  };
+  const changeRelay = {
+    watchPeer: (peerId) => context.compatibilityReplicator.watchPeer(peerId),
+    unwatchPeer: (peerId) => context.compatibilityReplicator.unwatchPeer(peerId),
+    enableBroadcastChanges: () => context.compatibilityReplicator.enableBroadcastChanges(),
+    disableBroadcastChanges: () => context.compatibilityReplicator.disableBroadcastChanges()
+  };
+  const configurationExchange = {
+    getRemoteConfiguration: (peerId) => context.compatibilityReplicator.getRemoteConfig(peerId)
+  };
+  const diagnostics = {
+    requestStatus: () => context.compatibilityReplicator.requestStatus(),
+    getPeerConnectionMetrics: (peerId) => getPeerConnectionMetrics(context, peerId)
+  };
+  return {
+    transportLifecycle,
+    connectionProbe,
+    peerDirectory,
+    peerAdmission,
+    targetedTransfer,
+    changeRelay,
+    configurationExchange,
+    diagnostics
+  };
+}
+function createServiceLifecycle(context) {
+  return {
+    requestStatus: () => context.compatibilityReplicator.requestStatus(),
+    openAfterDatabaseRebuild: () => openAfterDatabaseRebuild(context.roomSessionOwner, context.state),
+    closeForLifecycle: () => closeForLifecycle(context.roomSessionOwner, context.state),
+    reconcileAutoStart: (settings) => reconcileAutoStart(context, settings),
+    scheduleAutoStart: (delayMs) => scheduleAutoStart(context, delayMs)
+  };
+}
+function createP2PService(env) {
+  const roomSessionOwner = new P2PRoomSessionOwner(env);
+  const state = {
+    explicitDisconnectVeto: false,
+    lifecycleClosed: false,
+    lifecycleGeneration: 0,
+    delayedAutoStart: void 0
+  };
+  const compatibilityReplicator = new LiveSyncTrysteroReplicator(
+    env,
+    createCompatibilitySessionAccess(roomSessionOwner, state)
+  );
+  const context = { env, roomSessionOwner, compatibilityReplicator, state };
+  return {
+    compatibilityReplicator,
+    views: createServiceViews(context),
+    lifecycle: createServiceLifecycle(context),
+    createActiveReplicator: () => new P2PActiveReplicatorAdapter(compatibilityReplicator)
+  };
+}
+class P2PActiveReplicatorAdapter {
+  constructor(delegate) {
+    this.delegate = delegate;
+  }
+  delegate;
+  initializeDatabaseForReplication() {
+    return this.delegate.initializeDatabaseForReplication();
+  }
+  terminateSync() {
+    this.delegate.terminateSync();
+  }
+  openReplication(setting, keepAlive, showResult, ignoreCleanLock) {
+    return this.delegate.openReplication(setting, keepAlive, showResult, ignoreCleanLock);
+  }
+  replicateAllFromServer(setting, showingNotice) {
+    return this.delegate.replicateAllFromServer(setting, showingNotice);
+  }
+  closeReplication() {
+  }
+}
+export {
+  ACTIVE_P2P_RELAY_BINDING_CONFLICT,
+  createP2PService,
+  projectP2PPeerConnectionMetrics
+};

package/dist/p2p/index.d.ts

@@ -0,0 +1,8 @@
+export type { P2PCandidateSummary, P2PChangeRelay, P2PConfigurationExchange, P2PDiagnostics, P2PPeerConnectionMetrics, P2PPeerAdmission, P2PPeerDirectory, P2PServiceViews, P2PTargetedTransfer, P2PTransportLifecycle, P2PConnectionProbeAdmission, P2PConnectionProbeAdmissionResult, P2PConnectionProbeSettings, } from "./P2PService.js";
+export { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "./P2PService.js";
+export { useP2PReplicatorCommands } from "../replication/trystero/useP2PReplicatorCommands.js";
+export { useP2PReplicatorFeature } from "../replication/trystero/useP2PReplicatorFeature.js";
+export type { OpenRebuildUIFactory, OpenReplicationUIFactory, } from "../replication/trystero/useP2PReplicatorFeature.js";
+export type { UseP2PReplicatorResult } from "../replication/trystero/UseP2PReplicatorResult.js";
+export type { P2PReplicationResult } from "../replication/trystero/TrysteroReplicator.js";
+export type { Advertisement } from "../replication/trystero/types.js";

package/dist/p2p/index.js

@@ -0,0 +1,8 @@
+import { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "./P2PService.js";
+import { useP2PReplicatorCommands } from "../replication/trystero/useP2PReplicatorCommands.js";
+import { useP2PReplicatorFeature } from "../replication/trystero/useP2PReplicatorFeature.js";
+export {
+  ACTIVE_P2P_RELAY_BINDING_CONFLICT,
+  useP2PReplicatorCommands,
+  useP2PReplicatorFeature
+};

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -49,12 +49,15 @@ export declare class LiveSyncLocalDB {
     refreshSettings(): void;
     offRemoteChunkFetchedHandler?: ReturnType<LiveSyncEventHub["onEvent"]>;
     private databaseCloseCleanup?;
+    /** Share owner retirement across every close path for one physical database lifetime. */
+    private activeReplicationClose?;
     private databaseUnloadNotification?;
     constructor(dbname: string, env: LiveSyncLocalDBEnv);
     /** Notify dependent services at most once for each physical database lifecycle. */
     private notifyDatabaseUnload;
     onunload(): void;
     close(): Promise<void>;
+    private closeActiveReplication;
     private teardownDatabaseDependencies;
     private rollbackFailedInitialisation;
     onNewLeaf(chunk: EntryLeaf): void;

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -44,6 +44,8 @@ class LiveSyncLocalDB {
   }
   offRemoteChunkFetchedHandler;
   databaseCloseCleanup;
+  /** Share owner retirement across every close path for one physical database lifetime. */
+  activeReplicationClose;
   databaseUnloadNotification;
   constructor(dbname, env) {
     this.auth = {
@@ -72,8 +74,10 @@ class LiveSyncLocalDB {
     this.isReady = false;
     this.offRemoteChunkFetchedHandler?.();
     this.offRemoteChunkFetchedHandler = void 0;
+    await this.closeActiveReplication();
     if (this.localDatabase != null) {
       const database = this.localDatabase;
+      await this.env.services.databaseEvents.onCloseDatabase(this);
       await database.close();
       if (this.databaseCloseCleanup?.database === database) {
         await this.databaseCloseCleanup.promise;
@@ -85,9 +89,24 @@ class LiveSyncLocalDB {
     this._managers = void 0;
     await this.notifyDatabaseUnload();
   }
+  async closeActiveReplication() {
+    if (this.activeReplicationClose) {
+      return await this.activeReplicationClose;
+    }
+    const closeOperation = this.env.services.replicator.onCloseActiveReplication();
+    this.activeReplicationClose = closeOperation;
+    try {
+      return await closeOperation;
+    } catch (error) {
+      if (this.activeReplicationClose === closeOperation) {
+        this.activeReplicationClose = void 0;
+      }
+      throw error;
+    }
+  }
   async teardownDatabaseDependencies(managers) {
     try {
-      await Promise.resolve(this.env.services.replicator.getActiveReplicator()?.closeReplication());
+      await this.closeActiveReplication();
     } catch (error) {
       this._log("Failed to close replication while tearing down the local database.", LOG_LEVEL_VERBOSE);
       this._log(error, LOG_LEVEL_VERBOSE);
@@ -147,6 +166,7 @@ class LiveSyncLocalDB {
         deterministic_revs: true
       }
     );
+    this.activeReplicationClose = void 0;
     this.databaseUnloadNotification = void 0;
     const manager = new LiveSyncManagers({
       database: this.localDatabase,
@@ -292,12 +312,12 @@ class LiveSyncLocalDB {
   }
   async resetDatabase() {
     this.isReady = false;
-    await this.managers.teardownManagers();
-    this.env.services.replicator.getActiveReplicator()?.closeReplication();
+    await this.closeActiveReplication();
     if (!await this.env.services.databaseEvents.onResetDatabase(this)) {
       Logger("Database reset has been prevented or failed on some modules.", LOG_LEVEL_NOTICE);
       return false;
     }
+    await this.managers.teardownManagers();
     Logger("Database closed for reset Database.");
     await this.localDatabase.destroy();
     this.localDatabase = null;