@pkcprotocol/pkc-js 0.0.92 → 0.0.94

package/dist/bundled/chunks/{node-i4Twbtvv.js → node-C37nDOa8.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $n as n$2, B as isIpfsCid, Bt as pTimeout, Ct as findStartedCommunity, D as deepMergeRuntimeFields, Dt as listUpdatingComments, E as createAbortError, En as CommentUpdateForChallengeVerificationSchema, Et as listStartedCommunities, H as isIpns, Ir as joinValues, It as untrackUpdatingComment, L as hideClassPrivateProps, Lr as parsedType, Nt as trackUpdatingComment, Ot as listUpdatingCommunities, Q as isStringDomain, R as ipnsNameToIpnsOverPubsubTopic, Rr as stringifyPrimitive, Rt as require_sha256, Sr as logger_default, Tr as setErrorMap, Tt as findUpdatingCommunity, a as ChallengeRequestMessageSchema, an as CommunityIpfsSchema, ar as e$1, b as areEquivalentCommunityAddresses, br as PKCError, bt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, ct as removeUndefinedValuesRecursively, dn as PubsubTopicSchema, en as CommunityAnchorSchema, ft as retryKuboIpfsAdd, gt as sleepUntilTimeoutOrAbort, hr as FailedToFetchCommentIpfsFromGatewaysError, ht as shortifyCid, ir as e, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateSchema, kt as refreshTrackedCommentAliases, lt as replaceXWithY, mr as require_retry, mt as shortifyAddress, nt as rejectWhenAbortSignalFires, r as ChallengeMessageSchema, rr as t$1, rt as rejectWhenCommunityStopsOrAborts, s as ChallengeVerificationMessageSchema, sr as r, t as ChallengeAnswerMessageSchema, tr as n$1, ut as resolveWhenPredicateIsTrue, vt as throwIfAbortSignalAborted, wt as findUpdatingComment, xn as CommentIpfsSchema, xr as messages, y as version_default, yt as timestamp, z as isAbortError, zt as TimeoutError } from "./schema-Bbq796q3.js";
-import { $ as RepliesPages, $n as RpcUnsubscribeParamSchema, An as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, At as verifyCommentIpfs, B as setNativeFunctions$1, Bn as RpcEditCommunityParamSchema, Cn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Ct as signCommunityEdit, D as createKuboRpcClient, Dn as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, En as parseJsonWithPKCErrorIfFails, Et as verifyChallengeMessage, Fn as RpcCancelExportParamSchema, Ft as verifyCommunityEdit, Gn as RpcFetchCidParamSchema, Gt as getCommunityPublicKeyFromWire, H as CommentClientsManager, Hn as RpcExportCommunityModLogsResultSchema, Ht as buildRuntimeCommunityFields, I as listCommunitiesSync, In as RpcCidParamSchema, It as verifyVote, Jn as RpcPublishChallengeAnswersParamSchema, Kn as RpcFetchCidResultSchema, Kt as normalizeCommunityInputFromCommunity, L as monitorCommunitiesDirectory, Ln as RpcCommentRepliesPageParamSchema, Lt as buildRuntimeAuthor, Mn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Mt as verifyCommentPubsubMessage, N as getDefaultDataPath, Nn as RpcAnchorPublishPreparationResultSchema, Nt as verifyCommentUpdate, On as parseRpcCommentEventWithPKCErrorIfItFails, Ot as verifyChallengeVerification, Pn as RpcAuthorNameParamSchema, Q as parseRawPages, Qn as RpcSuccessResultSchema, Qt as getPKCAddressFromPublicKeySync, Rn as RpcCommunityIdentifierParamSchema, Rt as cleanWireAuthor, Sn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, Tn as parseDecryptedChallengeWithPKCErrorIfItFails, Un as RpcExportCommunityParamSchema, Ut as getCommunityAddressFromRecord, V as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Vn as RpcExportCommunityModLogsParamSchema, Vt as normalizeCreatePublicationAuthor, Wn as RpcExportCommunityResultSchema, Wt as getCommunityNameFromWire, X as findCommentInPageInstanceRecursively, Xn as RpcResolveAuthorNameResultSchema, Y as extractCommunityRuntimeFieldsFromParsedPages, Yn as RpcPublishedAnchorRecordResultSchema, Yt as getBufferedPKCAddressFromPublicKey, Zn as RpcSubscriptionIdResultSchema, _ as createSigner, _n as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, _t as signComment, an as parseCommentIpfsSchemaWithPKCErrorIfItFails, ar as t$3, at as PublicationClientsManager, bn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, c as LRUCache, cn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, cr as t$2, d as KeyvBetterSqlite3, dt as require_lib$1, et as applyNameResolvedCacheToCrosspost, f as decodeRpcChallengeAnswerPubsubMsg, fn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ft as cleanUpBeforePublishing, gn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, h as decodeRpcChallengeVerificationPubsubMsg, hn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, ht as signChallengeRequest, in as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, it as stripNameResolvedFromCrosspost, jt as verifyCommentModeration, kn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, kt as verifyCommentEdit, l as RemoteCommunity, ln as parseCommunityAddressWithPKCErrorIfItFails, lr as t$5, m as decodeRpcChallengeRequestPubsubMsg, mn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, mr as require_undici, n as RpcRemoteCommunity, nr as t$4, nt as collectCrosspostAuthorsToResolve, o as pkcJsChallenges, or as n$3, ot as PKCClientsManager, p as decodeRpcChallengePubsubMsg, pr as nativeFunctions$2, pt as signChallengeAnswer, qn as RpcPublishAnchorRecordParamSchema, qt as decode, s as TrackedInstanceRegistry, sn as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, st as InflightFetchManager, t as RpcLocalCommunity, tn as parseCidStringSchemaWithPKCErrorIfItFails, tt as cloneCrosspostForRuntime, ut as PKCTypedEmitter, v as createAnchorIpnsRecord$1, vt as signCommentEdit, wn as parseDecryptedChallengeVerification, wt as signVote, x as encryptEd25519AesGcm, xn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, y as decryptEd25519AesGcm, yt as signCommentModeration, zn as RpcCommunityPageParamSchema, zt as getAuthorNameFromRuntime } from "./rpc-local-community-CZSOMq_6.js";
-import { o as getHeliaDebugContext } from "./util-DdrJVp4E.js";
+import { A as doesDomainAddressHaveCapitalLetter, At as listUpdatingCommunities, B as ipnsNameToIpnsOverPubsubTopic, Br as stringifyPrimitive, Bt as require_sha256, Cn as CommentIpfsSchema, Cr as messages, D as createAbortError, Dr as setErrorMap, Dt as findUpdatingCommunity, Et as findUpdatingComment, Ft as trackUpdatingComment, H as isIpfsCid, Ht as pTimeout, O as deepMergeRuntimeFields, On as CommentUpdateForChallengeVerificationSchema, Ot as listStartedCommunities, R as hideClassPrivateProps, Rr as joinValues, Rt as untrackUpdatingComment, Sr as PKCError, St as waitForUpdateInCommunityInstanceWithErrorAndTimeout, Tt as findStartedCommunity, V as isAbortError, Vt as TimeoutError, W as isIpns, _r as FailedToFetchCommentIpfsFromGatewaysError, _t as shortifyCid, a as ChallengeRequestMessageSchema, ar as t$1, at as rejectWhenCommunityStopsOrAborts, b as areEquivalentCommunityAddresses, bt as throwIfAbortSignalAborted, dt as replaceXWithY, et as isStringDomain, ft as resolveWhenPredicateIsTrue, gr as require_retry, gt as shortifyAddress, it as rejectWhenAbortSignalFires, jn as CommentUpdateSchema, jt as refreshTrackedCommentAliases, kt as listUpdatingComments, lr as r, mt as retryKuboIpfsAdd, nn as CommunityAnchorSchema, or as e, pn as PubsubTopicSchema, r as ChallengeMessageSchema, rr as n$1, s as ChallengeVerificationMessageSchema, sn as CommunityIpfsSchema, sr as e$1, t as ChallengeAnswerMessageSchema, tr as n$2, ut as removeUndefinedValuesRecursively, vt as sleepUntilTimeoutOrAbort, wr as logger_default, xt as timestamp, y as version_default, zr as parsedType } from "./schema-5-rYJ-bC.js";
+import { $ as RepliesPages, $n as RpcUnsubscribeParamSchema, An as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, At as verifyCommentIpfs, B as setNativeFunctions$1, Bn as RpcEditCommunityParamSchema, Cn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Ct as signCommunityEdit, D as createKuboRpcClient, Dn as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, En as parseJsonWithPKCErrorIfFails, Et as verifyChallengeMessage, Fn as RpcCancelExportParamSchema, Ft as verifyCommunityEdit, Gn as RpcFetchCidParamSchema, Gt as getCommunityPublicKeyFromWire, H as CommentClientsManager, Hn as RpcExportCommunityModLogsResultSchema, Ht as buildRuntimeCommunityFields, I as listCommunitiesSync, In as RpcCidParamSchema, It as verifyVote, Jn as RpcPublishChallengeAnswersParamSchema, Kn as RpcFetchCidResultSchema, Kt as normalizeCommunityInputFromCommunity, L as monitorCommunitiesDirectory, Ln as RpcCommentRepliesPageParamSchema, Lt as buildRuntimeAuthor, Mn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Mt as verifyCommentPubsubMessage, N as getDefaultDataPath, Nn as RpcAnchorPublishPreparationResultSchema, Nt as verifyCommentUpdate, On as parseRpcCommentEventWithPKCErrorIfItFails, Ot as verifyChallengeVerification, Pn as RpcAuthorNameParamSchema, Q as parseRawPages, Qn as RpcSuccessResultSchema, Qt as getPKCAddressFromPublicKeySync, Rn as RpcCommunityIdentifierParamSchema, Rt as cleanWireAuthor, Sn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, Tn as parseDecryptedChallengeWithPKCErrorIfItFails, Un as RpcExportCommunityParamSchema, Ut as getCommunityAddressFromRecord, V as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Vn as RpcExportCommunityModLogsParamSchema, Vt as normalizeCreatePublicationAuthor, Wn as RpcExportCommunityResultSchema, Wt as getCommunityNameFromWire, X as findCommentInPageInstanceRecursively, Xn as RpcResolveAuthorNameResultSchema, Y as extractCommunityRuntimeFieldsFromParsedPages, Yn as RpcPublishedAnchorRecordResultSchema, Yt as getBufferedPKCAddressFromPublicKey, Zn as RpcSubscriptionIdResultSchema, _ as createSigner, _n as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, _t as signComment, an as parseCommentIpfsSchemaWithPKCErrorIfItFails, ar as t$3, at as PublicationClientsManager, bn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, c as LRUCache, cn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, cr as t$2, d as KeyvBetterSqlite3, dt as require_lib$1, et as applyNameResolvedCacheToCrosspost, f as decodeRpcChallengeAnswerPubsubMsg, fn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ft as cleanUpBeforePublishing, gn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, h as decodeRpcChallengeVerificationPubsubMsg, hn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, ht as signChallengeRequest, in as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, it as stripNameResolvedFromCrosspost, jt as verifyCommentModeration, kn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, kt as verifyCommentEdit, l as RemoteCommunity, ln as parseCommunityAddressWithPKCErrorIfItFails, lr as t$5, m as decodeRpcChallengeRequestPubsubMsg, mn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, mr as require_undici, n as RpcRemoteCommunity, nr as t$4, nt as collectCrosspostAuthorsToResolve, o as pkcJsChallenges, or as n$3, ot as PKCClientsManager, p as decodeRpcChallengePubsubMsg, pr as nativeFunctions$2, pt as signChallengeAnswer, qn as RpcPublishAnchorRecordParamSchema, qt as decode, s as TrackedInstanceRegistry, sn as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, st as InflightFetchManager, t as RpcLocalCommunity, tn as parseCidStringSchemaWithPKCErrorIfItFails, tt as cloneCrosspostForRuntime, ut as PKCTypedEmitter, v as createAnchorIpnsRecord$1, vt as signCommentEdit, wn as parseDecryptedChallengeVerification, wt as signVote, x as encryptEd25519AesGcm, xn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, y as decryptEd25519AesGcm, yt as signCommentModeration, zn as RpcCommunityPageParamSchema, zt as getAuthorNameFromRuntime } from "./rpc-local-community-Dr_-Lb8I.js";
+import { o as getHeliaDebugContext } from "./util-_-fNQNIV.js";
 import path from "path";
 import assert from "assert";
 import fs from "fs";
@@ -276,12 +276,13 @@ var Publication = class extends import_lib.TypedEmitter {
 			}
 		});
 		if (this._rpcPublishSubscriptionId) {
+			const subscriptionId = this._rpcPublishSubscriptionId;
+			this._rpcPublishSubscriptionId = void 0;
 			try {
-				await this._pkc._pkcRpcClient.unsubscribe(this._rpcPublishSubscriptionId);
+				await this._pkc._pkcRpcClient.unsubscribe(subscriptionId);
 			} catch (e) {
 				log.error("Failed to unsubscribe from publication publish", e);
 			}
-			this._rpcPublishSubscriptionId = void 0;
 		}
 	}
 	async _handleIncomingChallengePubsubMessage(msg) {
@@ -486,10 +487,13 @@ var Publication = class extends import_lib.TypedEmitter {
 	async publishChallengeAnswers({ challengeAnswers }) {
 		const log = logger_default("pkc-js:publication:publishChallengeAnswers");
 		const toEncryptAnswers = parseDecryptedChallengeAnswerWithPKCErrorIfItFails({ challengeAnswers });
-		if (this._pkc._pkcRpcClient && typeof this._rpcPublishSubscriptionId === "number") return this._pkc._pkcRpcClient.publishChallengeAnswers({
-			subscriptionId: this._rpcPublishSubscriptionId,
-			challengeAnswers: toEncryptAnswers.challengeAnswers
-		});
+		if (this._pkc._pkcRpcClient) {
+			if (typeof this._rpcPublishSubscriptionId !== "number") throw new PKCError("ERR_RPC_CLIENT_NO_ACTIVE_PUBLISH_SUBSCRIPTION", { publishingState: this.publishingState });
+			return this._pkc._pkcRpcClient.publishChallengeAnswers({
+				subscriptionId: this._rpcPublishSubscriptionId,
+				challengeAnswers: toEncryptAnswers.challengeAnswers
+			});
+		}
 		const challengeExchangesWithChallenge = Object.values(this._challengeExchanges).filter((exchange) => exchange.challenge);
 		if (challengeExchangesWithChallenge.length === 0) throw Error("No challenge exchanges with challenge");
 		if (challengeExchangesWithChallenge.length > 1) throw Error("We should only have one challenge exchange with challenge");
@@ -704,14 +708,15 @@ var Publication = class extends import_lib.TypedEmitter {
 		this._unregisterFromPkcOncePublishWorkSettles();
 		this._setStateWithEmission("stopped");
 		if (this._rpcPublishSubscriptionId) {
+			const subscriptionId = this._rpcPublishSubscriptionId;
+			this._rpcPublishSubscriptionId = void 0;
 			try {
-				await this._pkc._pkcRpcClient.unsubscribe(this._rpcPublishSubscriptionId);
+				await this._pkc._pkcRpcClient.unsubscribe(subscriptionId);
 			} catch (e) {
 				log.error("Failed to unsubscribe from publication publish", e);
 			}
-			this._rpcPublishSubscriptionId = void 0;
 			this._setRpcClientState("stopped");
-		} else if (typeof this._community?.pubsubTopic === "string") {
+		} else if (!this._pkc._pkcRpcClient && typeof this._community?.pubsubTopic === "string") {
 			await this._clientsManager.pubsubUnsubscribe(this._community.pubsubTopic, this._handleChallengeExchange);
 			Object.values(this._challengeExchanges).forEach((exchange) => this._updatePubsubState("stopped", exchange.providerUrl));
 		}
@@ -787,8 +792,17 @@ var Publication = class extends import_lib.TypedEmitter {
 			communityEdit: rpcClient.publishCommunityEdit
 		}[this.getType()].bind(rpcClient)(this.toJSONPubsubRequestToEncrypt());
 		this._rpcPublishSubscriptionId = subscriptionId;
-		this._pkc._pkcRpcClient.getSubscription(this._rpcPublishSubscriptionId).on("challengerequest", this._handleIncomingChallengeRequestFromRpc.bind(this)).on("challenge", this._handleIncomingChallengeFromRpc.bind(this)).on("challengeanswer", this._handleIncomingChallengeAnswerFromRpc.bind(this)).on("challengeverification", this._handleIncomingChallengeVerificationFromRpc.bind(this)).on("publishingstatechange", this._handleIncomingPublishingStateFromRpc.bind(this)).on("statechange", this._handleIncomingStateFromRpc.bind(this)).on("error", this._handleIncomingErrorFromRpc.bind(this));
-		this._pkc._pkcRpcClient.emitAllPendingMessages(this._rpcPublishSubscriptionId);
+		rpcClient.attachSubscriptionHandlersDeferred({
+			subscriptionId,
+			isStale: () => this._rpcPublishSubscriptionId !== subscriptionId,
+			attach: (subscription) => subscription.on("challengerequest", this._handleIncomingChallengeRequestFromRpc.bind(this)).on("challenge", this._handleIncomingChallengeFromRpc.bind(this)).on("challengeanswer", this._handleIncomingChallengeAnswerFromRpc.bind(this)).on("challengeverification", this._handleIncomingChallengeVerificationFromRpc.bind(this)).on("publishingstatechange", this._handleIncomingPublishingStateFromRpc.bind(this)).on("statechange", this._handleIncomingStateFromRpc.bind(this)).on("error", this._handleIncomingErrorFromRpc.bind(this)),
+			replayErrorContainment: {
+				entityName: "publication",
+				log: logger_default("pkc-js:publication:publish:_publishWithRpc"),
+				emitError: (error) => this.emit("error", error),
+				stop: () => this.stop()
+			}
+		});
 	}
 	_changePublicationStateEmitEventEmitStateChangeEvent(opts) {
 		const shouldEmitStateChange = opts.newState && opts.newState !== this.state;
@@ -1764,8 +1778,18 @@ var Comment = class extends Publication {
 			throw e;
 		}
 		this._setStateWithEmission("updating");
-		this._pkc._pkcRpcClient.getSubscription(this._updateRpcSubscriptionId).on("update", this._handleUpdateEventFromRpc.bind(this)).on("comment", this._handleCommentEventFromRpc.bind(this)).on("runtimeupdate", this._handleRuntimeUpdateEventFromRpc.bind(this)).on("updatingstatechange", this._handleUpdatingStateChangeFromRpc.bind(this)).on("statechange", this._handleStateChangeFromRpc.bind(this)).on("error", this._handleErrorEventFromRpc.bind(this));
-		this._pkc._pkcRpcClient.emitAllPendingMessages(this._updateRpcSubscriptionId);
+		const subscriptionId = this._updateRpcSubscriptionId;
+		this._pkc._pkcRpcClient.attachSubscriptionHandlersDeferred({
+			subscriptionId,
+			isStale: () => this._updateRpcSubscriptionId !== subscriptionId,
+			attach: (subscription) => subscription.on("update", this._handleUpdateEventFromRpc.bind(this)).on("comment", this._handleCommentEventFromRpc.bind(this)).on("runtimeupdate", this._handleRuntimeUpdateEventFromRpc.bind(this)).on("updatingstatechange", this._handleUpdatingStateChangeFromRpc.bind(this)).on("statechange", this._handleStateChangeFromRpc.bind(this)).on("error", this._handleErrorEventFromRpc.bind(this)),
+			replayErrorContainment: {
+				entityName: "comment",
+				log,
+				emitError: (error) => this.emit("error", error),
+				stop: () => this.stop()
+			}
+		});
 	}
 	_useUpdatePropsFromUpdatingStartedCommunityIfPossible() {
 		if (!this.cid) throw Error("Need to have comment.cid defined");
@@ -1912,12 +1936,13 @@ var Comment = class extends Publication {
 		if (!this.cid) return;
 		this._commentIpfsloadingOperation?.stop();
 		if (this._updateRpcSubscriptionId) {
+			const subscriptionId = this._updateRpcSubscriptionId;
+			this._updateRpcSubscriptionId = void 0;
 			try {
-				await this._pkc._pkcRpcClient.unsubscribe(this._updateRpcSubscriptionId);
+				await this._pkc._pkcRpcClient.unsubscribe(subscriptionId);
 			} catch (e) {
 				log.error("Failed to unsubscribe from commentUpdate", e);
 			}
-			this._updateRpcSubscriptionId = void 0;
 			this._setRpcClientState("stopped");
 			untrackUpdatingComment(this._pkc, this);
 		}
@@ -2196,6 +2221,9 @@ const parseRpcExportCommunityModLogsResult = (result) => RpcExportCommunityModLo
 //#endregion
 //#region dist/node/clients/rpc-client/pkc-rpc-client.js
 const log = logger_default("pkc-js:PKCRpcClient");
+const WEBSOCKET_READY_STATE_CLOSED = 3;
+const DESTROY_SOCKET_CLOSE_TIMEOUT_MS = 5e3;
+const scheduleMacrotask = setTimeout.bind(globalThis);
 var PKCRpcClient = class extends import_lib.TypedEmitter {
 	constructor(rpcServerUrl) {
 		super();
@@ -2267,7 +2295,7 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 				this.emit("error", error);
 			});
 			this._webSocketClient.on("close", () => {
-				log.error("connection with web socket has been closed", this._websocketServerUrl);
+				if (!this._destroyRequested) log.error("connection with web socket has been closed", this._websocketServerUrl);
 				this._openConnectionPromise = void 0;
 				this.setState("stopped");
 			});
@@ -2337,7 +2365,10 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		try {
 			if (this._webSocketClient instanceof Client) {
 				this._webSocketClient.setAutoReconnect(false);
+				const socketClosed = this._waitForSocketClose();
 				this._webSocketClient.close();
+				await socketClosed;
+				log("Closed websocket connection to", this._websocketServerUrl);
 			}
 		} catch (e) {
 			log.error("Failed to close websocket", e);
@@ -2345,6 +2376,16 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		this._openConnectionPromise = void 0;
 		this.setState("stopped");
 	}
+	async _waitForSocketClose() {
+		const socket = this._webSocketClient.socket;
+		if (!socket || socket.readyState === WEBSOCKET_READY_STATE_CLOSED) return;
+		const closed = new Promise((resolve) => socket.addEventListener("close", () => resolve(), { once: true }));
+		try {
+			await pTimeout(closed, { milliseconds: DESTROY_SOCKET_CLOSE_TIMEOUT_MS });
+		} catch {
+			log.error("Websocket did not close within", DESTROY_SOCKET_CLOSE_TIMEOUT_MS, "ms of destroy()", this._websocketServerUrl);
+		}
+	}
 	toJSON() {}
 	getSubscription(subscriptionId) {
 		if (!this._subscriptionEvents[subscriptionId]) throw Error(`No subscription to RPC with id (${subscriptionId})`);
@@ -2400,7 +2441,43 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 	_assignAdditionalProps(target, rest) {
 		if (rest && Object.keys(rest).length > 0) Object.assign(target, rest);
 	}
+	subscriptionActive(subscriptionId) {
+		return Boolean(this._subscriptionEvents[subscriptionId]);
+	}
+	attachSubscriptionHandlersDeferred(opts) {
+		scheduleMacrotask(() => {
+			const ownsSubscription = () => !opts.isStale() && this.subscriptionActive(opts.subscriptionId);
+			if (!ownsSubscription()) return;
+			try {
+				opts.attach(this.getSubscription(opts.subscriptionId));
+				this._emitPendingMessagesWhile(opts.subscriptionId, ownsSubscription);
+			} catch (e) {
+				this._containReplayError(e, opts.replayErrorContainment);
+			}
+		}, 0);
+	}
+	_containReplayError(e, containment) {
+		const { entityName, log: siteLog, emitError, stop } = containment;
+		siteLog.error(`Error thrown while replaying buffered subscribe-time notifications, stopping the ${entityName}`, e);
+		try {
+			emitError(e instanceof Error ? e : new Error(String(e)));
+		} catch (emitFailure) {
+			siteLog.error("No listener received the replay error", emitFailure);
+		}
+		stop().catch((stopError) => siteLog.error(`Failed to stop the ${entityName} after a replay error`, stopError));
+	}
+	_emitPendingMessagesWhile(subscriptionId, shouldDeliver) {
+		const pendingMessages = this._pendingSubscriptionMsgs[subscriptionId];
+		if (!pendingMessages) return;
+		while (pendingMessages.length > 0) {
+			if (!shouldDeliver()) return;
+			const message = pendingMessages.shift();
+			this._subscriptionEvents[subscriptionId].emit(message?.params?.event, message);
+		}
+		delete this._pendingSubscriptionMsgs[subscriptionId];
+	}
 	emitAllPendingMessages(subscriptionId) {
+		if (!this._pendingSubscriptionMsgs[subscriptionId]) return;
 		this._pendingSubscriptionMsgs[subscriptionId].forEach((message) => this._subscriptionEvents[subscriptionId].emit(message?.params?.event, message));
 		delete this._pendingSubscriptionMsgs[subscriptionId];
 	}
@@ -6948,7 +7025,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		this.clients.libp2pJsClients = {};
 		if (!this.libp2pJsClientsOptions) return;
 		if (!this.httpRoutersOptions) throw Error("httpRoutersOptions is required for libp2pJsClient");
-		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-COFAbh3C.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-Bj-Zb4JN.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -7227,7 +7304,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		const log = logger_default("pkc-js:pkc:createLocalCommunity");
 		log.trace("Received community options to create a local community instance:", options);
 		if (!this._canCreateNewLocalCommunity()) throw new PKCError("ERR_CAN_NOT_CREATE_A_LOCAL_COMMUNITY", { pkcOptions: this._userPKCOptions });
-		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-CyA7I22X.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-BrMLMEmt.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {

package/dist/bundled/chunks/{rpc-local-community-CZSOMq_6.js → rpc-local-community-Dr_-Lb8I.js}

@@ -1,5 +1,5 @@
 import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $ as pubsubTopicToDhtKey, $n as n$10, $t as ChallengeFileSchema, A as extractNetworkErrorDetails, An as CommentUpdateSignedPropertyNames, Ar as literal, At as refreshTrackedCommunityAliases, B as isIpfsCid, Bt as pTimeout, Cn as CommentPubsubMessageWithFlexibleAuthorRefinementSchema, Cr as require_supports_color, Ct as findStartedCommunity, D as deepMergeRuntimeFields, Dn as CommentUpdateForChallengeVerificationSignedPropertyNames, Dr as array, E as createAbortError, Er as _enum, Et as listStartedCommunities, Fn as ModQueuePageIpfsSchema, Ft as untrackStartedCommunity, Gn as AuthorCommentIpfsReservedFields, Gt as CreateCommunityEditPublicationOptionsWithRefinementSchema, H as isIpns, I as getPostUpdateTimestampRange, In as PageIpfsSchema, It as untrackUpdatingComment, Jn as CidPathSchema, Kt as CommentModerationChallengeRequestToEncryptSchema, L as hideClassPrivateProps, Ln as CommentEditChallengeRequestToEncryptSchema, Lt as untrackUpdatingCommunity, Mr as object, Mt as trackStartedCommunity, Nn as CreateCommentOptionsWithRefinementSchema, Nr as record, O as derivePublicationFromChallengeRequest, On as CommentUpdateReservedFields, Or as boolean, Ot as listUpdatingCommunities, Pn as GetPageParamSchema, Pr as string, Pt as trackUpdatingCommunity, Q as isStringDomain, Qn as CreateSignerSchema, Qt as ChallengeFileFactorySchema, R as ipnsNameToIpnsOverPubsubTopic, Rt as require_sha256$1, Sr as logger_default, Tn as CommentUpdateChallengeReservedFieldNames, Tt as findUpdatingCommunity, U as isIpnsPath, Un as CreateCommentEditOptionsWithRefinementSchema, Ut as CommunityEditPublicationSignedPropertyNames, V as isIpfsPath, Vn as CommentEditSignedPropertyNames, Vt as CommunityEditPublicationChallengeRequestToEncryptSchema, Wn as AuthorAddressSchema, Wt as CommunityEditPubsubMessagePublicationSchema, X as isRequestPubsubPublicationOfPost, Xn as CommunityAddressSchema, Xt as CommentModerationsTableRowSchema, Yn as CidStringSchema, Yt as CommentModerationSignedPropertyNames, Z as isRequestPubsubPublicationOfReply, Zn as CommunityAuthorChallengeReservedFieldNames, Zt as CreateCommentModerationOptionsWithRefinementSchema, _ as PKCUserOptionBaseSchema, _n as VoteSignedPropertyNames, _r as FailedToFetchCommunityFromGatewaysError, an as CommunityIpfsSchema, ar as e$5, b as areEquivalentCommunityAddresses, bn as CommentIpfsReservedFields, br as PKCError, bt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, c as ChallengeVerificationMessageSignedPropertyNames, cn as CreateRemoteCommunityFunctionArgumentSchema, cr as t$12, dr as t$10, f as DecryptedChallengeSchema, fn as RpcRemoteCommunityUpdateEventResultSchema, fr as t$9, g as PKCParsedOptionsSchema, gr as FailedToFetchCommentUpdateFromGatewaysError, gt as sleepUntilTimeoutOrAbort, h as NameResolverSerializedSchema, hn as VotePubsubMessagePublicationSchema, hr as FailedToFetchCommentIpfsFromGatewaysError, ht as shortifyCid, i as ChallengeMessageSignedPropertyNames, in as CommunityIpfsReservedFields, ir as e$6, j as fetchAndValidateIpnsRecordFromGateway, jr as number, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateSchema, kr as custom, l as DecryptedChallengeAnswerSchema, ln as CreateRpcCommunityFunctionArgumentSchema, lr as n$8, m as NameResolveCacheOptionsSchema, mn as VoteChallengeRequestToEncryptSchema, mr as require_retry$1, mt as shortifyAddress, n as ChallengeAnswerMessageSignedPropertyNames, nn as CommunityEditOptionsSchema, o as ChallengeRequestMessageSignedPropertyNames, on as CommunitySignedPropertyNames, or as t$11, ot as removeNullUndefinedEmptyObjectsValuesRecursively, p as DecryptedChallengeVerificationSchema, pn as CreateVoteUserOptionsWithRefinementSchema, pr as e$4, qn as ChallengeAnswersSchema, qt as CommentModerationPubsubMessagePublicationSchema, rn as CommunityExportRecordsSchema, rr as t$13, sn as CreateNewLocalCommunityUserOptionsSchema, sr as r$8, tn as CommunityChallengeSettingSchema, tr as n$9, tt as raceAgainstAbort, un as ExportCommunityModLogsOptionsSchema, ur as r$7, ut as resolveWhenPredicateIsTrue, v as PKCUserOptionsSchema, vr as FailedToFetchGenericIpfsFromGatewaysError, vt as throwIfAbortSignalAborted, wn as CommentSignedPropertyNames, wr as require_ms$1, wt as findUpdatingComment, x as calculateIpfsCidV0, xn as CommentIpfsSchema, xr as messages, yn as CommentChallengeRequestToEncryptSchema, yr as FailedToFetchPageIpfsFromGatewaysError, yt as timestamp, z as isAbortError, zn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema } from "./schema-Bbq796q3.js";
+import { $ as isRequestPubsubPublicationOfReply, $n as CommunityAuthorChallengeReservedFieldNames, $t as CreateCommentModerationOptionsWithRefinementSchema, A as doesDomainAddressHaveCapitalLetter, An as CommentUpdateReservedFields, Ar as boolean, At as listUpdatingCommunities, B as ipnsNameToIpnsOverPubsubTopic, Bt as require_sha256$1, Cn as CommentIpfsSchema, Cr as messages, D as createAbortError, Dn as CommentUpdateChallengeReservedFieldNames, Dt as findUpdatingCommunity, En as CommentSignedPropertyNames, Er as require_ms$1, Et as findUpdatingComment, Fn as CreateCommentOptionsWithRefinementSchema, Fr as record, G as isIpnsPath, Gn as CreateCommentEditOptionsWithRefinementSchema, Gt as CommunityEditPublicationSignedPropertyNames, H as isIpfsCid, Ht as pTimeout, In as GetPageParamSchema, Ir as string, It as trackUpdatingCommunity, Jt as CommentModerationChallengeRequestToEncryptSchema, Kn as AuthorAddressSchema, Kt as CommunityEditPubsubMessagePublicationSchema, L as getPostUpdateTimestampRange, Ln as ModQueuePageIpfsSchema, Lt as untrackStartedCommunity, M as fetchAndValidateIpnsRecordFromGateway, Mn as CommentUpdateSignedPropertyNames, Mr as literal, Mt as refreshTrackedCommunityAliases, Nr as number, O as deepMergeRuntimeFields, Or as _enum, Ot as listStartedCommunities, Pr as object, Pt as trackStartedCommunity, Q as isRequestPubsubPublicationOfPost, Qn as CommunityAddressSchema, Qt as CommentModerationsTableRowSchema, R as hideClassPrivateProps, Rn as PageIpfsSchema, Rt as untrackUpdatingComment, S as calculateIpfsCidV0, Sn as CommentIpfsReservedFields, Sr as PKCError, St as waitForUpdateInCommunityInstanceWithErrorAndTimeout, Tn as CommentPubsubMessageWithFlexibleAuthorRefinementSchema, Tr as require_supports_color, Tt as findStartedCommunity, U as isIpfsPath, Un as CommentEditSignedPropertyNames, Ut as CommunityEditPublicationChallengeRequestToEncryptSchema, V as isAbortError, Vn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, W as isIpns, Xn as CidPathSchema, Yn as ChallengeAnswersSchema, Yt as CommentModerationPubsubMessagePublicationSchema, Zn as CidStringSchema, Zt as CommentModerationSignedPropertyNames, _ as PKCUserOptionBaseSchema, _n as VotePubsubMessagePublicationSchema, _r as FailedToFetchCommentIpfsFromGatewaysError, _t as shortifyCid, an as CommunityExportRecordsSchema, ar as t$13, b as areEquivalentCommunityAddresses, br as FailedToFetchGenericIpfsFromGatewaysError, bt as throwIfAbortSignalAborted, c as ChallengeVerificationMessageSignedPropertyNames, cn as CommunitySignedPropertyNames, cr as t$11, ct as removeNullUndefinedEmptyObjectsValuesRecursively, dn as CreateRpcCommunityFunctionArgumentSchema, dr as n$8, en as ChallengeFileFactorySchema, er as CreateSignerSchema, et as isStringDomain, f as DecryptedChallengeSchema, fn as ExportCommunityModLogsOptionsSchema, fr as r$7, ft as resolveWhenPredicateIsTrue, g as PKCParsedOptionsSchema, gn as VoteChallengeRequestToEncryptSchema, gr as require_retry$1, gt as shortifyAddress, h as NameResolverSerializedSchema, hn as CreateVoteUserOptionsWithRefinementSchema, hr as e$4, i as ChallengeMessageSignedPropertyNames, in as CommunityEditOptionsSchema, j as extractNetworkErrorDetails, jn as CommentUpdateSchema, jr as custom, k as derivePublicationFromChallengeRequest, kn as CommentUpdateForChallengeVerificationSignedPropertyNames, kr as array, l as DecryptedChallengeAnswerSchema, ln as CreateNewLocalCommunityUserOptionsSchema, lr as r$8, m as NameResolveCacheOptionsSchema, mn as RpcRemoteCommunityUpdateEventResultSchema, mr as t$9, n as ChallengeAnswerMessageSignedPropertyNames, o as ChallengeRequestMessageSignedPropertyNames, on as CommunityIpfsReservedFields, or as e$6, p as DecryptedChallengeVerificationSchema, pr as t$10, qn as AuthorCommentIpfsReservedFields, qt as CreateCommunityEditPublicationOptionsWithRefinementSchema, rn as CommunityChallengeSettingSchema, rr as n$9, rt as raceAgainstAbort, sn as CommunityIpfsSchema, sr as e$5, tn as ChallengeFileSchema, tr as n$10, tt as pubsubTopicToDhtKey, un as CreateRemoteCommunityFunctionArgumentSchema, ur as t$12, v as PKCUserOptionsSchema, vr as FailedToFetchCommentUpdateFromGatewaysError, vt as sleepUntilTimeoutOrAbort, wr as logger_default, xn as CommentChallengeRequestToEncryptSchema, xr as FailedToFetchPageIpfsFromGatewaysError, xt as timestamp, yn as VoteSignedPropertyNames, yr as FailedToFetchCommunityFromGatewaysError, z as interruptibleSleep, zn as CommentEditChallengeRequestToEncryptSchema, zt as untrackUpdatingCommunity } from "./schema-5-rYJ-bC.js";
 import { t as all } from "./src-CYIMjhjK.js";
 import { createHash } from "node:crypto";
 import { pathToFileURL } from "node:url";
@@ -92191,7 +92191,7 @@ const RpcExportCommunityModLogsResultSchema = object({ moderations: array(Commen
 //#endregion
 //#region dist/node/rpc/src/schema.js
 const WsServerClassOptions = object({
-	port: number().int().positive().optional(),
+	port: number().int().nonnegative().optional(),
 	server: custom().optional()
 });
 const CreatePKCWsServerOptionsSchema = object({
@@ -125415,12 +125415,18 @@ function selectWinningGatewayCommunity(opts) {
 //#endregion
 //#region dist/node/community/community-client-manager.js
 const MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS = 1024 * 1024;
+const FORCED_IPNS_NETWORK_REVALIDATION_MIN_INTERVAL_MS = 3e4;
 var CommunityClientsManager = class extends PKCClientsManager {
 	constructor(community) {
 		super(community._pkc);
 		this._suppressUpdatingStateForNameResolution = 0;
 		this._ipnsLoadingOperation = void 0;
 		this._updateCidsAlreadyLoaded = new LimitedSet(30);
+		this._subscribedIpnsArrivalTopics = /* @__PURE__ */ new Set();
+		this._pendingIpnsArrivalCids = /* @__PURE__ */ new Set();
+		this._pendingIpnsArrivalHopTargets = /* @__PURE__ */ new Set();
+		this._nextResolveRevalidatesNetwork = false;
+		this._lastForcedIpnsNetworkRevalidationAtMs = 0;
 		this._community = community;
 		this._initPKCRpcClients();
 		hideClassPrivateProps(this);
@@ -125583,20 +125589,127 @@ var CommunityClientsManager = class extends PKCClientsManager {
 	async startUpdatingLoop() {
 		const log = logger_default("pkc-js:remote-community:update");
 		this._community._createStopAbortController();
-		const updateInterval = Object.keys(this._pkc.clients.kuboRpcClients).length > 0 || Object.keys(this._pkc.clients.libp2pJsClients).length > 0 ? 1e3 : this._pkc.updateInterval;
+		const areWeConnectedToKuboOrHelia = Object.keys(this._pkc.clients.kuboRpcClients).length > 0 || Object.keys(this._pkc.clients.libp2pJsClients).length > 0;
+		const defaultIpfsClient = areWeConnectedToKuboOrHelia ? this.getDefaultKuboRpcClientOrHelia() : void 0;
+		const defaultLibp2pJsClient = defaultIpfsClient && "_helia" in defaultIpfsClient ? defaultIpfsClient : void 0;
+		if (defaultLibp2pJsClient) {
+			try {
+				this._syncIpnsArrivalSubscriptions(defaultLibp2pJsClient);
+			} catch (e) {
+				log.error(`Failed to arm IPNS record arrival subscriptions of community ${this._community.address} before its first update`, e);
+			}
+			this._lastForcedIpnsNetworkRevalidationAtMs = Date.now();
+		}
 		while (this._community.state === "updating" && !this._community._getStopAbortSignal()?.aborted) try {
 			await this.updateOnce();
 		} catch (e) {
 			log.error(`Failed to update community ${this._community.address} for this iteration, will retry later`, e);
 		} finally {
-			await sleepUntilTimeoutOrAbort(updateInterval, this._community._getStopAbortSignal());
+			if (defaultLibp2pJsClient) {
+				try {
+					this._syncIpnsArrivalSubscriptions(defaultLibp2pJsClient);
+				} catch (e) {
+					log.error(`Failed to sync IPNS record arrival subscriptions of community ${this._community.address}`, e);
+				}
+				const safetyNetMs = this._pkc.updateInterval * (.75 + Math.random() * .5);
+				await this._sleepUntilIpnsArrivalOrTimeoutOrAbort({
+					ms: safetyNetMs,
+					signal: this._community._getStopAbortSignal()
+				});
+			} else await sleepUntilTimeoutOrAbort(areWeConnectedToKuboOrHelia ? 1e3 : this._pkc.updateInterval, this._community._getStopAbortSignal());
 		}
+		this._clearIpnsArrivalSubscriptions();
 		this._community._clearStopAbortController();
 		log("Community", this._community.address, "is no longer updating");
 	}
 	async stopUpdatingLoop() {
 		this._ipnsLoadingOperation?.stop();
 		this._updateCidsAlreadyLoaded.clear();
+		this._clearIpnsArrivalSubscriptions();
+	}
+	_onIpnsRecordArrival(arrival) {
+		const value = arrival.record.value;
+		if (isIpfsPath(value)) {
+			const cid = value.split("/")[2];
+			if (this._updateCidsAlreadyLoaded.has(cid) || this._community.updateCid === cid) return;
+			this._pendingIpnsArrivalCids.add(cid);
+		} else if (isIpnsPath(value)) {
+			const hopTarget = value.split("/")[2];
+			if (this._community.ipnsHops?.includes(hopTarget)) return;
+			this._pendingIpnsArrivalHopTargets.add(hopTarget);
+		} else return;
+		this._wakeUpdateLoopForIpnsArrival?.();
+	}
+	_consumePendingIpnsArrivals() {
+		for (const cid of this._pendingIpnsArrivalCids) if (this._updateCidsAlreadyLoaded.has(cid) || this._community.updateCid === cid) this._pendingIpnsArrivalCids.delete(cid);
+		for (const hopTarget of this._pendingIpnsArrivalHopTargets) if (this._community.ipnsHops?.includes(hopTarget)) this._pendingIpnsArrivalHopTargets.delete(hopTarget);
+		if (this._pendingIpnsArrivalCids.size === 0 && this._pendingIpnsArrivalHopTargets.size === 0) return false;
+		this._pendingIpnsArrivalCids.clear();
+		this._pendingIpnsArrivalHopTargets.clear();
+		return true;
+	}
+	_syncIpnsArrivalSubscriptions(client) {
+		if (!this._ipnsArrivalListener) this._ipnsArrivalListener = (arrival) => this._onIpnsRecordArrival(arrival);
+		this._ipnsArrivalClient = client;
+		const preResolveIpnsName = this._community.ipnsName ?? this._pinnedIpnsName() ?? (!isStringDomain(this._community.address) ? this._community.address : void 0);
+		const ipnsNamesToWatch = this._community.ipnsHops?.length ? this._community.ipnsHops : preResolveIpnsName ? [preResolveIpnsName] : [];
+		const desiredTopics = new Set(ipnsNamesToWatch.map(ipnsNameToIpnsOverPubsubTopic));
+		for (const topic of this._subscribedIpnsArrivalTopics) if (!desiredTopics.has(topic)) {
+			client.heliaWithKuboRpcClientFunctions.ipnsRecordArrivals.unsubscribe({
+				pubsubTopic: topic,
+				listener: this._ipnsArrivalListener
+			});
+			this._subscribedIpnsArrivalTopics.delete(topic);
+		}
+		for (const topic of desiredTopics) if (!this._subscribedIpnsArrivalTopics.has(topic)) {
+			client.heliaWithKuboRpcClientFunctions.ipnsRecordArrivals.subscribe({
+				pubsubTopic: topic,
+				listener: this._ipnsArrivalListener
+			});
+			this._subscribedIpnsArrivalTopics.add(topic);
+		}
+	}
+	_resyncIpnsArrivalSubscriptionsIfArmed() {
+		if (!this._ipnsArrivalClient) return;
+		try {
+			this._syncIpnsArrivalSubscriptions(this._ipnsArrivalClient);
+		} catch (e) {
+			logger_default("pkc-js:remote-community:update").error(`Failed to sync IPNS record arrival subscriptions of community ${this._community.address}`, e);
+		}
+	}
+	_clearIpnsArrivalSubscriptions() {
+		if (this._ipnsArrivalClient && this._ipnsArrivalListener) for (const topic of this._subscribedIpnsArrivalTopics) this._ipnsArrivalClient.heliaWithKuboRpcClientFunctions.ipnsRecordArrivals.unsubscribe({
+			pubsubTopic: topic,
+			listener: this._ipnsArrivalListener
+		});
+		this._subscribedIpnsArrivalTopics.clear();
+		this._ipnsArrivalClient = void 0;
+		this._pendingIpnsArrivalCids.clear();
+		this._pendingIpnsArrivalHopTargets.clear();
+		this._nextResolveRevalidatesNetwork = false;
+	}
+	async _sleepUntilIpnsArrivalOrTimeoutOrAbort({ ms, signal }) {
+		if (this._consumePendingIpnsArrivals()) {
+			this._nextResolveRevalidatesNetwork = false;
+			return;
+		}
+		const { promise, wake } = interruptibleSleep({
+			ms,
+			signal
+		});
+		let wokenByArrival = false;
+		const wakeForArrival = () => {
+			wokenByArrival = true;
+			wake();
+		};
+		this._wakeUpdateLoopForIpnsArrival = wakeForArrival;
+		await promise;
+		if (this._wakeUpdateLoopForIpnsArrival === wakeForArrival) this._wakeUpdateLoopForIpnsArrival = void 0;
+		if (wokenByArrival) {
+			this._pendingIpnsArrivalCids.clear();
+			this._pendingIpnsArrivalHopTargets.clear();
+		}
+		this._nextResolveRevalidatesNetwork = !wokenByArrival && Date.now() - this._lastForcedIpnsNetworkRevalidationAtMs >= FORCED_IPNS_NETWORK_REVALIDATION_MIN_INTERVAL_MS;
 	}
 	async _resolveCommunityNameWithoutUpdatingState({ communityName, abortSignal, cache }) {
 		this._suppressUpdatingStateForNameResolution++;
@@ -125618,6 +125731,25 @@ var CommunityClientsManager = class extends PKCClientsManager {
 		if (this._community.publicKey) chainKeys.delete(this._community.publicKey);
 		return [...chainKeys];
 	}
+	_applyKeyMigration({ communityName, newPublicKey }) {
+		logger_default("pkc-js:community-client-manager:_applyKeyMigration")("Key migration detected for", communityName, "old:", this._community.publicKey, "new:", newPublicKey);
+		const previousPublicKey = this._community.publicKey;
+		const error = new PKCError("ERR_COMMUNITY_NAME_RESOLVES_TO_DIFFERENT_PUBLIC_KEY", {
+			communityName,
+			previousPublicKey,
+			newPublicKey
+		});
+		this._community._clearDataForKeyMigration(newPublicKey);
+		this._updateCidsAlreadyLoaded.clear();
+		this._community.nameResolved = true;
+		this._pendingIpnsArrivalCids.clear();
+		this._pendingIpnsArrivalHopTargets.clear();
+		this._resyncIpnsArrivalSubscriptionsIfArmed();
+		this._community._abortStopOperations("Key migration: name resolved to different public key");
+		this._community._createStopAbortController();
+		this._community.emit("update", this._community);
+		this._community.emit("error", error);
+	}
 	_resolveNameInBackground(name) {
 		const log = logger_default("pkc-js:community-client-manager:_resolveNameInBackground");
 		const setNameResolvedAndEmitUpdate = (newNameResolved) => {
@@ -125636,20 +125768,10 @@ var CommunityClientsManager = class extends PKCClientsManager {
 					setNameResolvedAndEmitUpdate(false);
 					return;
 				}
-				log("Key migration detected for", name, "old:", this._community.publicKey, "new:", resolved);
-				const previousPublicKey = this._community.publicKey;
-				const error = new PKCError("ERR_COMMUNITY_NAME_RESOLVES_TO_DIFFERENT_PUBLIC_KEY", {
+				this._applyKeyMigration({
 					communityName: name,
-					previousPublicKey,
 					newPublicKey: resolved
 				});
-				this._community._clearDataForKeyMigration(resolved);
-				this._updateCidsAlreadyLoaded.clear();
-				this._community.nameResolved = true;
-				this._community._abortStopOperations("Key migration: name resolved to different public key");
-				this._community._createStopAbortController();
-				this._community.emit("update", this._community);
-				this._community.emit("error", error);
 			} else if (resolved) setNameResolvedAndEmitUpdate(true);
 			if (!resolved && this._community.name) setNameResolvedAndEmitUpdate(false);
 		}).catch((e) => {
@@ -125681,13 +125803,18 @@ var CommunityClientsManager = class extends PKCClientsManager {
 			abortSignal: this._community._getStopAbortSignal()
 		});
 	}
+	_pinnedIpnsName() {
+		const isDomain = isStringDomain(this._community.address);
+		const hasAnchorClaim = Boolean(this._community.anchor);
+		if (this._community.publicKey && (isDomain || hasAnchorClaim || !isDomain && this._community.name && this._community.nameResolved === true)) return this._community.publicKey;
+	}
 	async fetchNewUpdateForCommunity(communityAddress) {
 		return this._withInflightCommunityFetch(communityAddress, async () => {
 			let ipnsName;
 			const isDomain = isStringDomain(communityAddress);
-			const hasAnchorClaim = Boolean(this._community.anchor);
-			if (this._community.publicKey && (isDomain || hasAnchorClaim || !isDomain && this._community.name && this._community.nameResolved === true)) {
-				ipnsName = this._community.publicKey;
+			const pinnedIpnsName = this._pinnedIpnsName();
+			if (pinnedIpnsName) {
+				ipnsName = pinnedIpnsName;
 				if (isDomain) this._resolveNameInBackground(communityAddress);
 			} else ipnsName = await this.resolveCommunityNameIfNeeded({
 				communityName: communityAddress,
@@ -125701,6 +125828,7 @@ var CommunityClientsManager = class extends PKCClientsManager {
 				this._community.ipnsHops = [ipnsName];
 				this._community.ipnsPubsubTopic = ipnsNameToIpnsOverPubsubTopic(ipnsName);
 				this._community.ipnsPubsubTopicRoutingCid = pubsubTopicToDhtKey(this._community.ipnsPubsubTopic);
+				this._resyncIpnsArrivalSubscriptionsIfArmed();
 			}
 			if (this._community.updateCid) this._updateCidsAlreadyLoaded.add(this._community.updateCid);
 			this._community._setUpdatingStateWithEventEmissionIfNewState("fetching-ipns");
@@ -125742,9 +125870,13 @@ var CommunityClientsManager = class extends PKCClientsManager {
 		const kuboRpcOrHelia = this.getDefaultKuboRpcClientOrHelia();
 		if ("_helia" in kuboRpcOrHelia) this.updateLibp2pJsClientState("fetching-ipns", kuboRpcOrHelia._libp2pJsClientsOptions.key);
 		else this.updateKuboRpcState("fetching-ipns", kuboRpcOrHelia.url);
+		const forceNetworkRevalidation = this._nextResolveRevalidatesNetwork;
+		this._nextResolveRevalidatesNetwork = false;
+		if (forceNetworkRevalidation) this._lastForcedIpnsNetworkRevalidationAtMs = Date.now();
 		const { cid: latestCommunityCid, ipnsHops } = await this.resolveIpnsToCidP2P(ipnsName, {
 			timeoutMs: this._pkc._timeouts["community-ipns"],
-			abortSignal: this._community._getStopAbortSignal()
+			abortSignal: this._community._getStopAbortSignal(),
+			...forceNetworkRevalidation ? { nocache: true } : {}
 		});
 		this._community.ipnsHops = ipnsHops;
 		ipnsHops[ipnsHops.length - 1];
@@ -126387,6 +126519,7 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 		this.pubsubTopicRoutingCid = void 0;
 		this.publicKey = newPublicKey;
 		this.ipnsName = newPublicKey;
+		this.ipnsHops = [newPublicKey];
 		this.ipnsPubsubTopic = ipnsNameToIpnsOverPubsubTopic(newPublicKey);
 		this.ipnsPubsubTopicRoutingCid = pubsubTopicToDhtKey(this.ipnsPubsubTopic);
 		this._assertHasIdentity();
@@ -129652,11 +129785,12 @@ var RpcRemoteCommunity = class extends RemoteCommunity {
 	async _initRpcUpdateSubscription() {
 		const log = logger_default("pkc-js:rpc-remote-community:_initRpcUpdateSubscription");
 		this._setState("updating");
+		let subscriptionId;
 		try {
-			const { subscriptionId } = await this._pkc._pkcRpcClient.communityUpdateSubscribe({
+			({subscriptionId} = await this._pkc._pkcRpcClient.communityUpdateSubscribe({
 				name: this.name,
 				publicKey: this.publicKey
-			});
+			}));
 			this._updateRpcSubscriptionId = subscriptionId;
 		} catch (e) {
 			log.error("Failed to receive communityUpdate from RPC due to error", e);
@@ -129664,8 +129798,17 @@ var RpcRemoteCommunity = class extends RemoteCommunity {
 			this._setUpdatingStateWithEventEmissionIfNewState("failed");
 			throw e;
 		}
-		this._pkc._pkcRpcClient.getSubscription(this._updateRpcSubscriptionId).on("update", this._processUpdateEventFromRpcUpdate.bind(this)).on("updatingstatechange", this._handleUpdatingStateChangeFromRpcUpdate.bind(this)).on("error", this._handleRpcErrorEvent.bind(this));
-		this._pkc._pkcRpcClient.emitAllPendingMessages(this._updateRpcSubscriptionId);
+		this._pkc._pkcRpcClient.attachSubscriptionHandlersDeferred({
+			subscriptionId,
+			isStale: () => this._updateRpcSubscriptionId !== subscriptionId,
+			attach: (subscription) => subscription.on("update", this._processUpdateEventFromRpcUpdate.bind(this)).on("updatingstatechange", this._handleUpdatingStateChangeFromRpcUpdate.bind(this)).on("error", this._handleRpcErrorEvent.bind(this)),
+			replayErrorContainment: {
+				entityName: "community",
+				log,
+				emitError: (error) => this.emit("error", error),
+				stop: () => this.stop()
+			}
+		});
 	}
 	async _createAndSubscribeToNewUpdatingCommunity(updatingCommunity) {
 		const log = logger_default("pkc-js:rpc-remote-community:_createNewUpdatingCommunity");
@@ -129730,12 +129873,13 @@ var RpcRemoteCommunity = class extends RemoteCommunity {
 		if (this._updatingRpcCommunityInstanceWithListeners) await this._cleanupMirroringUpdatingCommunity();
 		else {
 			if (this._updateRpcSubscriptionId) {
+				const subscriptionId = this._updateRpcSubscriptionId;
+				this._updateRpcSubscriptionId = void 0;
 				try {
-					await this._pkc._pkcRpcClient.unsubscribe(this._updateRpcSubscriptionId);
+					await this._pkc._pkcRpcClient.unsubscribe(subscriptionId);
 				} catch (e) {
 					log.error("Failed to unsubscribe from communityUpdate", e);
 				}
-				this._updateRpcSubscriptionId = void 0;
 				log.trace(`Stopped the update of remote community (${this.address}) via RPC`);
 			}
 			untrackUpdatingCommunity(this._pkc, this);
@@ -129926,19 +130070,29 @@ var RpcLocalCommunity = class extends RpcRemoteCommunity {
 		}
 		trackStartedCommunity(this._pkc, this);
 		this.started = true;
-		this._pkc._pkcRpcClient.getSubscription(this._startRpcSubscriptionId).on("update", this._handleRpcUpdateEventFromStart.bind(this)).on("startedstatechange", this._handleRpcStartedStateChangeEvent.bind(this)).on("challengerequest", this._handleRpcChallengeRequestEvent.bind(this)).on("challenge", this._handleRpcChallengeEvent.bind(this)).on("challengeanswer", this._handleRpcChallengeAnswerEvent.bind(this)).on("challengeverification", this._handleRpcChallengeVerificationEvent.bind(this)).on("error", this._handleRpcErrorEvent.bind(this));
-		this._pkc._pkcRpcClient.emitAllPendingMessages(this._startRpcSubscriptionId);
+		const subscriptionId = this._startRpcSubscriptionId;
+		this._pkc._pkcRpcClient.attachSubscriptionHandlersDeferred({
+			subscriptionId,
+			isStale: () => this._startRpcSubscriptionId !== subscriptionId,
+			attach: (subscription) => subscription.on("update", this._handleRpcUpdateEventFromStart.bind(this)).on("startedstatechange", this._handleRpcStartedStateChangeEvent.bind(this)).on("challengerequest", this._handleRpcChallengeRequestEvent.bind(this)).on("challenge", this._handleRpcChallengeEvent.bind(this)).on("challengeanswer", this._handleRpcChallengeAnswerEvent.bind(this)).on("challengeverification", this._handleRpcChallengeVerificationEvent.bind(this)).on("error", this._handleRpcErrorEvent.bind(this)),
+			replayErrorContainment: {
+				entityName: "community",
+				log,
+				emitError: (error) => this.emit("error", error),
+				stop: () => this.stopWithoutRpcCall()
+			}
+		});
 	}
-	async _cleanUpRpcConnection(log) {
-		if (this._startRpcSubscriptionId) try {
-			await this._pkc._pkcRpcClient.unsubscribe(this._startRpcSubscriptionId);
+	async _cleanUpRpcConnection(log, subscriptionId = this._startRpcSubscriptionId) {
+		this._startRpcSubscriptionId = void 0;
+		if (subscriptionId) try {
+			await this._pkc._pkcRpcClient.unsubscribe(subscriptionId);
 		} catch (e) {
 			log.error("Failed to unsubscribe from communityStart", e);
 		}
 		this._setStartedStateWithEmission("stopped");
 		this._setRpcClientStateWithEmission("stopped");
 		this.started = false;
-		this._startRpcSubscriptionId = void 0;
 		log(`Stopped the running of local community (${this.address}) via RPC`);
 		this._setState("stopped");
 	}
@@ -129972,6 +130126,8 @@ var RpcLocalCommunity = class extends RpcRemoteCommunity {
 		if (this.state === "updating") return super.stop();
 		else if (this.state === "started") {
 			const log = logger_default("pkc-js:rpc-local-community:stop");
+			const subscriptionId = this._startRpcSubscriptionId;
+			this._startRpcSubscriptionId = void 0;
 			try {
 				await this._pkc._pkcRpcClient.stopCommunity({
 					name: this.name,
@@ -129980,7 +130136,7 @@ var RpcLocalCommunity = class extends RpcRemoteCommunity {
 			} catch (e) {
 				log.error("RPC client received an error when asking rpc server to stop community", e);
 			}
-			await this._cleanUpRpcConnection(log);
+			await this._cleanUpRpcConnection(log, subscriptionId);
 			untrackStartedCommunity(this._pkc, this);
 		}
 	}