@peerbit/shared-log 13.2.24 → 13.2.26

package/src/replicator-liveness.ts

@@ -0,0 +1,439 @@
+import type { PublicSignKey } from "@peerbit/crypto";
+import { logger as loggerFn } from "@peerbit/logger";
+import { waitForSubscribers } from "@peerbit/pubsub";
+import type { RPC } from "@peerbit/rpc";
+import {
+	ACK_CONTROL_PRIORITY,
+	AcknowledgeDelivery,
+} from "@peerbit/stream-interface";
+import { isNotStartedError } from "./errors.js";
+import type { TransportMessage } from "./message.js";
+import type { PeerSession } from "./peer-session.js";
+import { ReplicationPingMessage } from "./replication.js";
+
+const logger = loggerFn("peerbit:shared-log");
+
+// In sparse topologies (browser/relay), peers can learn about replicators via broadcast
+// replication announcements without having a direct connection that emits unsubscribe
+// on abrupt churn. Probe conservatively so a single missed ACK does not evict a
+// healthy replicator, and rely on replication-info refresh to recover membership.
+const REPLICATOR_LIVENESS_SWEEP_INTERVAL_MS = 2_000;
+const REPLICATOR_LIVENESS_IDLE_THRESHOLD_MS = 8_000;
+const REPLICATOR_LIVENESS_PROBE_FAILURES_TO_EVICT = 2;
+
+export type ReplicatorLivenessDeps = {
+	isClosed: () => boolean;
+	getCloseSignal: () => AbortSignal;
+	getReplicationLifecycleController: () => AbortController | undefined;
+	isReplicationLifecycleActive: (
+		controller: AbortController | undefined,
+	) => boolean;
+	getSelfHash: () => string;
+	getUniqueReplicators: () => Set<string>;
+	// Stage 3: probes capture the peer's PeerSession (the opaque
+	// subscription-epoch token) and check currency through the registry.
+	getPeerSession: (peerHash: string) => PeerSession | null;
+	isPeerSessionCurrent: (
+		peerHash: string,
+		session: PeerSession | null,
+	) => boolean;
+	resolvePublicKeyFromHash: (
+		hash: string,
+	) => Promise<PublicSignKey | undefined>;
+	removeReplicator: (
+		key: PublicSignKey | string,
+		options?: {
+			noEvent?: boolean;
+			onRemoved?: (state: { wasReplicator: boolean }) => void;
+			replicationLifecycleController?: AbortController;
+			shouldRemove?: () => boolean;
+			subscriptionEpoch?: PeerSession | null;
+		},
+	) => Promise<boolean>;
+	getRpc: () => RPC<TransportMessage, TransportMessage>;
+	getPendingReplicatorLeaveByPeer: () => Set<string>;
+	dispatchReplicatorLeave: (publicKey: PublicSignKey) => void;
+	isBlockedPeer: (hash: string) => boolean;
+	scheduleReplicationInfoRequests: (
+		peer: PublicSignKey,
+		replicationLifecycleController: AbortController,
+	) => void;
+	getTopicSubscribers: (
+		topic: string,
+	) => Promise<PublicSignKey[] | undefined>;
+	// Late-bound through the SharedLog instance so tests can override the
+	// presence check on the log while probes are in flight.
+	confirmReplicatorSubscriberPresence: (peerHash: string) => Promise<boolean>;
+	getNode: () => Parameters<typeof waitForSubscribers>[0];
+	getWaitForReplicatorTimeout: () => number;
+	// Owner-routed dispatch so monitor stubs/spies keep intercepting
+	// sweep-driven probes and activity marks.
+	probeReplicatorLiveness: (peerHash: string) => Promise<void> | void;
+	markReplicatorActivity: (peerHash: string, now?: number) => void;
+};
+
+export class ReplicatorLivenessMonitor {
+	_replicatorLivenessSweepRunning!: boolean;
+	_replicatorLivenessTimer?: ReturnType<typeof setInterval>;
+	_replicatorLivenessTargets!: string[];
+	_replicatorLivenessTargetsSize!: number;
+	_replicatorLivenessCursor!: number;
+	_replicatorLivenessFailures!: Map<string, number>;
+	_replicatorLastActivityAt!: Map<string, number>;
+
+	constructor(private readonly deps: ReplicatorLivenessDeps) {
+		this._replicatorLivenessSweepRunning = false;
+		this._replicatorLivenessTargets = [];
+		this._replicatorLivenessTargetsSize = 0;
+		this._replicatorLivenessCursor = 0;
+		this._replicatorLivenessFailures = new Map();
+		this._replicatorLastActivityAt = new Map();
+	}
+
+	resetForOpen(): void {
+		this._replicatorLivenessSweepRunning = false;
+		this._replicatorLivenessTimer = undefined;
+		this._replicatorLivenessTargets = [];
+		this._replicatorLivenessTargetsSize = 0;
+		this._replicatorLivenessCursor = 0;
+		this._replicatorLivenessFailures = new Map();
+		this._replicatorLastActivityAt = new Map();
+	}
+
+	startReplicatorLivenessSweep() {
+		if (this._replicatorLivenessTimer) {
+			return;
+		}
+		this._replicatorLivenessTimer = setInterval(() => {
+			void this.runReplicatorLivenessSweep();
+		}, REPLICATOR_LIVENESS_SWEEP_INTERVAL_MS);
+		this._replicatorLivenessTimer.unref?.();
+	}
+
+	stopReplicatorLivenessSweep() {
+		if (this._replicatorLivenessTimer) {
+			clearInterval(this._replicatorLivenessTimer);
+			this._replicatorLivenessTimer = undefined;
+		}
+		this._replicatorLivenessSweepRunning = false;
+		this._replicatorLivenessTargets = [];
+		this._replicatorLivenessTargetsSize = 0;
+		this._replicatorLivenessCursor = 0;
+		this._replicatorLivenessFailures.clear();
+		this._replicatorLastActivityAt.clear();
+	}
+
+	private rebuildReplicatorLivenessTargets() {
+		const selfHash = this.deps.getSelfHash();
+		this._replicatorLivenessTargets = [
+			...this.deps.getUniqueReplicators(),
+		].filter((hash) => hash !== selfHash);
+		this._replicatorLivenessTargetsSize = this.deps.getUniqueReplicators().size;
+		if (
+			this._replicatorLivenessCursor >= this._replicatorLivenessTargets.length
+		) {
+			this._replicatorLivenessCursor = 0;
+		}
+	}
+
+	private getReplicatorLivenessTargets() {
+		const selfHash = this.deps.getSelfHash();
+		const uniqueReplicators = this.deps.getUniqueReplicators();
+		const expected =
+			uniqueReplicators.size - (uniqueReplicators.has(selfHash) ? 1 : 0);
+
+		if (this._replicatorLivenessTargets.length > 0) {
+			// Keep the cursor stable, but purge stale hashes (membership can change while
+			// the total size stays constant).
+			this._replicatorLivenessTargets = this._replicatorLivenessTargets.filter(
+				(hash) => hash !== selfHash && uniqueReplicators.has(hash),
+			);
+		}
+
+		if (
+			this._replicatorLivenessTargetsSize !== uniqueReplicators.size ||
+			this._replicatorLivenessTargets.length !== expected
+		) {
+			this.rebuildReplicatorLivenessTargets();
+		}
+
+		return this._replicatorLivenessTargets;
+	}
+
+	markReplicatorActivity(peerHash: string, now = Date.now()) {
+		this._replicatorLastActivityAt.set(peerHash, now);
+		// Any recent authenticated activity is positive liveness evidence. Reset the
+		// consecutive miss streak immediately, including while an eviction is
+		// waiting in the per-peer mutation lane.
+		if (Date.now() - now < REPLICATOR_LIVENESS_IDLE_THRESHOLD_MS) {
+			this._replicatorLivenessFailures.delete(peerHash);
+		}
+	}
+
+	private hasRecentReplicatorActivity(peerHash: string, now = Date.now()) {
+		const lastActivityAt = this._replicatorLastActivityAt.get(peerHash);
+		if (
+			lastActivityAt != null &&
+			now - lastActivityAt < REPLICATOR_LIVENESS_IDLE_THRESHOLD_MS
+		) {
+			this._replicatorLivenessFailures.delete(peerHash);
+			return true;
+		}
+		return false;
+	}
+
+	private async evictReplicatorFromLiveness(
+		peerHash: string,
+		publicKey: PublicSignKey,
+		replicationLifecycleController: AbortController,
+		subscriptionEpoch: PeerSession | null,
+		observedActivityAt: number | undefined,
+	) {
+		try {
+			await this.deps.removeReplicator(publicKey, {
+				noEvent: true,
+				replicationLifecycleController,
+				shouldRemove: () =>
+					this._replicatorLastActivityAt.get(peerHash) === observedActivityAt,
+				subscriptionEpoch,
+				onRemoved: ({ wasReplicator }) => {
+					if (wasReplicator) {
+						this.deps.getPendingReplicatorLeaveByPeer().add(peerHash);
+					}
+					// A newer subscription/lifecycle may have started while the admitted
+					// removal was completing. Its reconnect barrier owns all later effects.
+					if (
+						!this.deps.isReplicationLifecycleActive(
+							replicationLifecycleController,
+						) ||
+						!this.deps.isPeerSessionCurrent(peerHash, subscriptionEpoch)
+					) {
+						return;
+					}
+					if (
+						this.deps.getPendingReplicatorLeaveByPeer().delete(peerHash)
+					) {
+						this.deps.dispatchReplicatorLeave(publicKey);
+					}
+
+					if (!this.deps.isBlockedPeer(peerHash)) {
+						this.deps.scheduleReplicationInfoRequests(
+							publicKey,
+							replicationLifecycleController,
+						);
+					}
+					this._replicatorLivenessTargetsSize = -1;
+				},
+			});
+		} catch (error) {
+			if (!isNotStartedError(error as Error)) {
+				throw error;
+			}
+		}
+	}
+
+	async runReplicatorLivenessSweep() {
+		const replicationLifecycleController =
+			this.deps.getReplicationLifecycleController();
+		if (
+			this.deps.isClosed() ||
+			this.deps.getCloseSignal().aborted ||
+			!this.deps.isReplicationLifecycleActive(replicationLifecycleController)
+		) {
+			return;
+		}
+		if (this._replicatorLivenessSweepRunning) {
+			return;
+		}
+
+		const targets = this.getReplicatorLivenessTargets();
+		if (targets.length === 0) {
+			return;
+		}
+
+		this._replicatorLivenessSweepRunning = true;
+		try {
+			if (this._replicatorLivenessCursor >= targets.length) {
+				this._replicatorLivenessCursor = 0;
+			}
+			const peerHash = targets[this._replicatorLivenessCursor]!;
+			this._replicatorLivenessCursor =
+				(this._replicatorLivenessCursor + 1) % targets.length;
+			await this.deps.probeReplicatorLiveness(peerHash);
+		} catch (error) {
+			if (!isNotStartedError(error as Error)) {
+				logger.error((error as any)?.toString?.() ?? String(error));
+			}
+		} finally {
+			if (
+				this.deps.getReplicationLifecycleController() ===
+				replicationLifecycleController
+			) {
+				this._replicatorLivenessSweepRunning = false;
+			}
+		}
+	}
+
+	async probeReplicatorLiveness(peerHash: string) {
+		const replicationLifecycleController =
+			this.deps.getReplicationLifecycleController();
+		if (
+			this.deps.isClosed() ||
+			this.deps.getCloseSignal().aborted ||
+			!replicationLifecycleController ||
+			!this.deps.isReplicationLifecycleActive(replicationLifecycleController)
+		) {
+			return;
+		}
+		const subscriptionEpoch = this.deps.getPeerSession(peerHash);
+		const ownsProbe = () =>
+			this.deps.isReplicationLifecycleActive(replicationLifecycleController) &&
+			this.deps.isPeerSessionCurrent(peerHash, subscriptionEpoch);
+		if (!this.deps.getUniqueReplicators().has(peerHash)) {
+			this._replicatorLivenessFailures.delete(peerHash);
+			return;
+		}
+		if (this.hasRecentReplicatorActivity(peerHash)) {
+			return;
+		}
+		const observedActivityAt = this._replicatorLastActivityAt.get(peerHash);
+
+		const publicKey = await this.deps.resolvePublicKeyFromHash(peerHash);
+		if (!ownsProbe()) {
+			return;
+		}
+		if (this.hasRecentReplicatorActivity(peerHash)) {
+			return;
+		}
+		if (!publicKey) {
+			try {
+				await this.deps.removeReplicator(peerHash, {
+					noEvent: true,
+					replicationLifecycleController,
+					shouldRemove: () =>
+						this._replicatorLastActivityAt.get(peerHash) === observedActivityAt,
+					subscriptionEpoch,
+					onRemoved: () => {
+						if (!ownsProbe()) {
+							return;
+						}
+						this._replicatorLivenessTargetsSize = -1;
+					},
+				});
+			} catch (error) {
+				if (!isNotStartedError(error as Error)) {
+					throw error;
+				}
+			}
+			return;
+		}
+
+		try {
+			// Explicit ping (ACKed) instead of RequestReplicationInfoMessage to avoid
+			// triggering large segment snapshots just to prove liveness.
+			await this.deps.getRpc().send(new ReplicationPingMessage(), {
+				mode: new AcknowledgeDelivery({ redundancy: 1, to: [publicKey] }),
+				priority: ACK_CONTROL_PRIORITY,
+				responsePriority: ACK_CONTROL_PRIORITY,
+			});
+			if (!ownsProbe()) {
+				return;
+			}
+			this.deps.markReplicatorActivity(peerHash);
+			this._replicatorLivenessFailures.delete(peerHash);
+			return;
+		} catch (error) {
+			if (isNotStartedError(error as Error)) {
+				return;
+			}
+		}
+		if (!ownsProbe()) {
+			return;
+		}
+		if (this.hasRecentReplicatorActivity(peerHash)) {
+			return;
+		}
+
+		// Relay-backed prod paths can keep a peer subscribed/reachable even if an
+		// ACKed liveness ping gets delayed or dropped under load. Treat observed
+		// topic presence as a positive liveness signal before evicting the peer.
+		if (await this.deps.confirmReplicatorSubscriberPresence(peerHash)) {
+			if (!ownsProbe()) {
+				return;
+			}
+			this.deps.markReplicatorActivity(peerHash);
+			this._replicatorLivenessFailures.delete(peerHash);
+			return;
+		}
+		if (!ownsProbe()) {
+			return;
+		}
+		if (this.hasRecentReplicatorActivity(peerHash)) {
+			return;
+		}
+
+		const failures = (this._replicatorLivenessFailures.get(peerHash) ?? 0) + 1;
+		this._replicatorLivenessFailures.set(peerHash, failures);
+		this.deps.scheduleReplicationInfoRequests(
+			publicKey,
+			replicationLifecycleController,
+		);
+
+		if (failures < REPLICATOR_LIVENESS_PROBE_FAILURES_TO_EVICT) {
+			return;
+		}
+		if (!ownsProbe() || !this.deps.getUniqueReplicators().has(peerHash)) {
+			this._replicatorLivenessFailures.delete(peerHash);
+			return;
+		}
+
+		await this.evictReplicatorFromLiveness(
+			peerHash,
+			publicKey,
+			replicationLifecycleController,
+			subscriptionEpoch,
+			observedActivityAt,
+		);
+	}
+
+	async confirmReplicatorSubscriberPresence(peerHash: string) {
+		try {
+			const subscribers = await this.deps.getTopicSubscribers(
+				this.deps.getRpc().topic,
+			);
+			if (
+				subscribers?.some((subscriber) => subscriber.hashcode() === peerHash)
+			) {
+				return true;
+			}
+		} catch (error) {
+			if (isNotStartedError(error as Error)) {
+				return false;
+			}
+		}
+
+		try {
+			await waitForSubscribers(
+				this.deps.getNode(),
+				peerHash,
+				this.deps.getRpc().topic,
+				{
+					signal: this.deps.getCloseSignal(),
+					timeout: Math.max(
+						1_000,
+						Math.min(
+							5_000,
+							Math.floor(this.deps.getWaitForReplicatorTimeout() / 4),
+						),
+					),
+				},
+			);
+			return true;
+		} catch (error) {
+			if (isNotStartedError(error as Error)) {
+				return false;
+			}
+			return false;
+		}
+	}
+}

package/src/sync/dispatch-lifecycle.ts

@@ -0,0 +1,230 @@
+// Shared dispatch-lifecycle registry for the sync module (stage-4 sync
+// unification). The simple and rateless synchronizers used to carry
+// near-verbatim copies of the capture/abort/finish/dispose/isActive
+// lifecycle machinery; this registry hosts the shared mechanics and keeps
+// the two deliberate behavioral deltas as injected strategies:
+//
+// - target activity: the simple synchronizer compares the target's dispatch
+//   EPOCH identity, the rateless synchronizer checks SET MEMBERSHIP of the
+//   target lifecycle in the active-target registry. The strategy is always
+//   injected (`isTargetCurrent`), never defaulted.
+// - retention: disposal is deferred while `hasRetainedWork` is true — a
+//   retained-work counter for the simple synchronizer, a per-target
+//   retainedByProcess/responseLeases scan for the rateless one.
+//
+// Lifecycle objects are constructed by the callers (they carry
+// caller-specific fields such as epochs, batches and retained-work
+// counters); the registry owns the per-target active sets, the listener
+// add/remove pairing and the dispose gating.
+
+export interface DispatchTargetLifecycleBase<LC> {
+	lifecycle: LC;
+	target: string;
+	controller: AbortController;
+}
+
+export interface DispatchLifecycleBase<TL> {
+	ownershipLifecycleController: AbortController;
+	callerSignal?: AbortSignal;
+	controller: AbortController;
+	targets: Map<string, TL>;
+	onOwnerOrCallerAbort: () => void;
+	dispatchFinished: boolean;
+	disposed: boolean;
+}
+
+export type DispatchLifecycleRegistryDeps<
+	LC extends DispatchLifecycleBase<TL>,
+	TL extends DispatchTargetLifecycleBase<LC>,
+> = {
+	isClosed: () => boolean;
+	currentOwnershipLifecycleController: () => AbortController;
+	// Retention hook: disposal is deferred while this is true.
+	hasRetainedWork: (lifecycle: LC) => boolean;
+	// Target-activity strategy (epoch identity vs set membership).
+	isTargetCurrent: (targetLifecycle: TL) => boolean;
+	// Side effects on target abort (the simple synchronizer removes the
+	// target's pending response batches here).
+	onTargetAborted?: (targetLifecycle: TL) => void;
+};
+
+export class DispatchLifecycleRegistry<
+	LC extends DispatchLifecycleBase<TL>,
+	TL extends DispatchTargetLifecycleBase<LC>,
+> {
+	readonly activeTargets: Map<string, Set<TL>> = new Map();
+
+	constructor(private readonly deps: DispatchLifecycleRegistryDeps<LC, TL>) {}
+
+	// Registers the caller-constructed lifecycle: creates the per-target
+	// lifecycles (the factory may skip a target or abort it right after
+	// registration via `onTargetRegistered`), pairs the owner/caller abort
+	// listeners and performs the initial staleness abort exactly like both
+	// former capture implementations.
+	register(
+		lifecycle: LC,
+		targets: string[],
+		createTargetLifecycle: (lifecycle: LC, target: string) => TL | undefined,
+		onTargetRegistered?: (targetLifecycle: TL) => void,
+	): void {
+		for (const target of [...new Set(targets)]) {
+			const targetLifecycle = createTargetLifecycle(lifecycle, target);
+			if (!targetLifecycle) {
+				continue;
+			}
+			lifecycle.targets.set(target, targetLifecycle);
+			let activeForTarget = this.activeTargets.get(target);
+			if (!activeForTarget) {
+				activeForTarget = new Set();
+				this.activeTargets.set(target, activeForTarget);
+			}
+			activeForTarget.add(targetLifecycle);
+			onTargetRegistered?.(targetLifecycle);
+		}
+
+		lifecycle.ownershipLifecycleController.signal.addEventListener(
+			"abort",
+			lifecycle.onOwnerOrCallerAbort,
+			{ once: true },
+		);
+		if (
+			lifecycle.callerSignal &&
+			lifecycle.callerSignal !== lifecycle.ownershipLifecycleController.signal
+		) {
+			lifecycle.callerSignal.addEventListener(
+				"abort",
+				lifecycle.onOwnerOrCallerAbort,
+				{ once: true },
+			);
+		}
+		if (
+			this.deps.isClosed() ||
+			lifecycle.ownershipLifecycleController !==
+				this.deps.currentOwnershipLifecycleController() ||
+			lifecycle.ownershipLifecycleController.signal.aborted ||
+			lifecycle.callerSignal?.aborted
+		) {
+			lifecycle.onOwnerOrCallerAbort();
+		}
+	}
+
+	abortTarget(targetLifecycle: TL, reason?: unknown): void {
+		if (!targetLifecycle.controller.signal.aborted) {
+			targetLifecycle.controller.abort(reason);
+		}
+		this.deps.onTargetAborted?.(targetLifecycle);
+		this.maybeDispose(targetLifecycle.lifecycle);
+	}
+
+	abortLifecycle(lifecycle: LC, reason?: unknown): void {
+		if (!lifecycle.controller.signal.aborted) {
+			lifecycle.controller.abort(reason);
+		}
+		for (const targetLifecycle of lifecycle.targets.values()) {
+			this.abortTarget(targetLifecycle, reason);
+		}
+		this.maybeDispose(lifecycle);
+	}
+
+	finish(lifecycle: LC): void {
+		lifecycle.dispatchFinished = true;
+		this.maybeDispose(lifecycle);
+	}
+
+	maybeDispose(lifecycle: LC): void {
+		if (
+			lifecycle.disposed ||
+			!lifecycle.dispatchFinished ||
+			this.deps.hasRetainedWork(lifecycle)
+		) {
+			return;
+		}
+		lifecycle.disposed = true;
+		lifecycle.ownershipLifecycleController.signal.removeEventListener(
+			"abort",
+			lifecycle.onOwnerOrCallerAbort,
+		);
+		if (
+			lifecycle.callerSignal &&
+			lifecycle.callerSignal !== lifecycle.ownershipLifecycleController.signal
+		) {
+			lifecycle.callerSignal.removeEventListener(
+				"abort",
+				lifecycle.onOwnerOrCallerAbort,
+			);
+		}
+		for (const targetLifecycle of lifecycle.targets.values()) {
+			const activeForTarget = this.activeTargets.get(targetLifecycle.target);
+			activeForTarget?.delete(targetLifecycle);
+			if (activeForTarget?.size === 0) {
+				this.activeTargets.delete(targetLifecycle.target);
+			}
+		}
+	}
+
+	isLifecycleActive(lifecycle: LC, target?: string): boolean {
+		if (
+			this.deps.isClosed() ||
+			lifecycle.disposed ||
+			lifecycle.ownershipLifecycleController !==
+				this.deps.currentOwnershipLifecycleController() ||
+			lifecycle.ownershipLifecycleController.signal.aborted ||
+			lifecycle.callerSignal?.aborted ||
+			lifecycle.controller.signal.aborted
+		) {
+			return false;
+		}
+		if (target === undefined) {
+			return true;
+		}
+		const targetLifecycle = lifecycle.targets.get(target);
+		return (
+			targetLifecycle !== undefined &&
+			!targetLifecycle.controller.signal.aborted &&
+			this.deps.isTargetCurrent(targetLifecycle)
+		);
+	}
+
+	getSignal(lifecycle: LC, target: string): AbortSignal {
+		return (
+			lifecycle.targets.get(target)?.controller.signal ??
+			lifecycle.controller.signal
+		);
+	}
+}
+
+// The shared ownership-generation identity check: a captured ownership
+// controller is current while the synchronizer is open, the controller is
+// still THE controller (identity, not just non-aborted) and it has not been
+// aborted.
+export const isOwnershipGenerationActive = (properties: {
+	closed: boolean;
+	ownershipLifecycleController: AbortController;
+	currentOwnershipLifecycleController: AbortController;
+}): boolean =>
+	!properties.closed &&
+	properties.ownershipLifecycleController ===
+		properties.currentOwnershipLifecycleController &&
+	!properties.ownershipLifecycleController.signal.aborted;
+
+// The shared tracked-session identity check (the pattern the host-side
+// instance lifecycle drained the index.ts fences into): a session is active
+// while nothing cancelled or aborted it, its ownership generation is still
+// current, and the session registry still maps its id to THIS session
+// object.
+export const isTrackedSessionActive = <TSession>(properties: {
+	closed: boolean;
+	cancelled: boolean;
+	sessionController: AbortController;
+	ownershipLifecycleController: AbortController;
+	currentOwnershipLifecycleController: AbortController;
+	session: TSession;
+	registered: TSession | undefined;
+}): boolean =>
+	!properties.closed &&
+	!properties.cancelled &&
+	!properties.sessionController.signal.aborted &&
+	!properties.ownershipLifecycleController.signal.aborted &&
+	properties.ownershipLifecycleController ===
+		properties.currentOwnershipLifecycleController &&
+	properties.registered === properties.session;