@pkcprotocol/pkc-js 0.0.106 → 0.0.108

package/dist/bundled/chunks/{node-D8vvnh-6.js → node-B8rEQ_rA.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { A as doesDomainAddressHaveCapitalLetter, An as CommentUpdateForChallengeVerificationSchema, At as listUpdatingComments, B as hideClassPrivateProps, Br as joinValues, Ct as waitForUpdateInCommunityInstanceWithErrorAndTimeout, D as createAbortError, Dt as findUpdatingComment, Er as logger_default, Et as findStartedCommunity, H as ipnsNameToIpnsOverPubsubTopic, Hr as stringifyPrimitive, Ht as TimeoutError, It as trackUpdatingComment, K as isIpns, Mt as refreshTrackedCommentAliases, Nn as CommentUpdateSchema, O as deepMergeRuntimeFields, Ot as findUpdatingCommunity, St as timestamp, Tn as CommentIpfsSchema, Tr as messages, U as isAbortError, Ut as pTimeout, Vr as parsedType, Vt as require_sha256, W as isIpfsCid, _t as shortifyAddress, a as ChallengeRequestMessageSchema, ar as n$1, at as rejectWhenAbortSignalFires, b as areEquivalentCommunityAddresses, cn as CommunityIpfsSchema, cr as e, dr as r, dt as removeUndefinedValuesRecursively, ft as replaceXWithY, gn as isStringDomain, ht as retryKuboIpfsAdd, jt as listUpdatingCommunities, kr as setErrorMap, kt as listStartedCommunities, lr as e$1, mn as PubsubTopicSchema, ot as rejectWhenCommunityStopsOrAborts, pt as resolveWhenPredicateIsTrue, r as ChallengeMessageSchema, rn as CommunityAnchorSchema, rr as n$2, s as ChallengeVerificationMessageSchema, sr as t$1, t as ChallengeAnswerMessageSchema, vr as require_retry, vt as shortifyCid, wr as PKCError, xt as throwIfAbortSignalAborted, y as version_default, yr as FailedToFetchCommentIpfsFromGatewaysError, yt as sleepUntilTimeoutOrAbort, zt as untrackUpdatingComment } from "./schema-B4n6Xctr.js";
-import { $ as findCommentInPageInstanceRecursively, $n as RpcPublishedAnchorRecordResultSchema, $t as getBufferedPKCAddressFromPublicKey, A as createKuboRpcClient, An as parseJsonWithPKCErrorIfFails, At as verifyChallengeMessage, B as monitorCommunitiesDirectory, Bn as RpcCidParamSchema, Bt as verifyVote, Ct as signCommentModeration, Dn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Dt as signCommunityEdit, En as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, Ft as verifyCommentModeration, G as CommentClientsManager, Gn as RpcExportCommunityModLogsParamSchema, Gt as normalizeCreatePublicationAuthor, Hn as RpcCommunityIdentifierParamSchema, Ht as cleanWireAuthor, I as getDefaultDataPath, In as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, It as verifyCommentPubsubMessage, Jn as RpcExportCommunityResultSchema, Jt as getCommunityNameFromWire, Kn as RpcExportCommunityModLogsResultSchema, Kt as buildRuntimeCommunityFields, Ln as RpcAnchorPublishPreparationResultSchema, Lt as verifyCommentUpdate, Mn as parseRpcCommentEventWithPKCErrorIfItFails, Mt as verifyChallengeVerification, Nn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, Nt as verifyCommentEdit, On as parseDecryptedChallengeVerification, Ot as signVote, Pn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, Pt as verifyCommentIpfs, Q as extractCommunityRuntimeFieldsFromParsedPages, Qn as RpcPublishChallengeAnswersParamSchema, Rn as RpcAuthorNameParamSchema, S as decryptEd25519AesGcm, St as signCommentEdit, Tn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, U as setNativeFunctions$1, Un as RpcCommunityPageParamSchema, Ut as getAuthorNameFromRuntime, Vn as RpcCommentRepliesPageParamSchema, Vt as buildRuntimeAuthor, W as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Wn as RpcEditCommunityParamSchema, Xn as RpcFetchCidResultSchema, Xt as normalizeCommunityInputFromCommunity, Yn as RpcFetchCidParamSchema, Yt as getCommunityPublicKeyFromWire, Zn as RpcPublishAnchorRecordParamSchema, Zt as decode, _ as decodeRpcChallengeRequestPubsubMsg, _r as NAME_RESOLVE_FAILED_RETRY_FLOOR_MS, _t as signChallengeAnswer, an as parseCidStringSchemaWithPKCErrorIfItFails, at as collectCrosspostAuthorsToResolve, b as createSigner, bn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, br as nativeFunctions$2, cn as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ct as PublicationClientsManager, d as LRUCache, dn as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, er as RpcResolveAuthorNameResultSchema, f as RemoteCommunity, fn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, fr as t$2, g as decodeRpcChallengePubsubMsg, gn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, gr as NAME_RESOLVED_TRUE_TTL_MS, gt as cleanUpBeforePublishing, h as decodeRpcChallengeAnswerPubsubMsg, hr as NAME_RESOLVED_FALSE_TTL_MS, it as cloneCrosspostForRuntime, jn as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, kn as parseDecryptedChallengeWithPKCErrorIfItFails, ln as parseCommentIpfsSchemaWithPKCErrorIfItFails, lr as t$3, lt as PKCClientsManager, m as KeyvBetterSqlite3, mt as require_lib$1, n as RpcRemoteCommunity, nn as getPKCAddressFromPublicKeySync, nr as RpcSuccessResultSchema, nt as RepliesPages, o as pkcJsChallenges, or as t$4, pn as parseCommunityAddressWithPKCErrorIfItFails, pr as t$5, pt as PKCTypedEmitter, qn as RpcExportCommunityParamSchema, qt as getCommunityAddressFromRecord, rr as RpcUnsubscribeParamSchema, rt as applyNameResolvedCacheToCrosspost, st as stripNameResolvedFromCrosspost, t as RpcLocalCommunity, tr as RpcSubscriptionIdResultSchema, tt as parseRawPages, u as TrackedInstanceRegistry, ur as n$3, ut as InflightFetchManager, v as decodeRpcChallengeVerificationPubsubMsg, vn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, w as encryptEd25519AesGcm, wn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, x as createAnchorIpnsRecord$1, xn as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, xr as require_undici, xt as signComment, yn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, yt as signChallengeRequest, z as listCommunitiesSync, zn as RpcCancelExportParamSchema, zt as verifyCommunityEdit } from "./rpc-local-community-Bmt73MTy.js";
-import { o as getHeliaDebugContext } from "./util-DUR-gvDQ.js";
+import { $ as shortifyAddress, An as CommentIpfsSchema, Ar as PKCError, At as ChallengeMessageSchema, Ct as untrackUpdatingComment, Dt as pTimeout, E as isIpfsCid, Er as FailedToFetchCommentUpdateFromGatewaysError, Et as TimeoutError, Fn as CommentUpdateForChallengeVerificationSchema, Fr as setErrorMap, H as rejectWhenCommunityStopsOrAborts, J as replaceXWithY, Jr as stringifyPrimitive, Kr as joinValues, Kt as version_default, Mr as logger_default, Mt as ChallengeRequestMessageSchema, O as isIpns, Ot as ChallengeAnswerMessageSchema, Pt as ChallengeVerificationMessageSchema, Rn as CommentUpdateSchema, S as hideClassPrivateProps, T as isAbortError, Tr as FailedToFetchCommentIpfsFromGatewaysError, Tt as require_sha256, V as rejectWhenAbortSignalFires, Y as resolveWhenPredicateIsTrue, Z as retryKuboIpfsAdd, _r as r, at as waitForUpdateInCommunityInstanceWithErrorAndTimeout, b as getPostUpdateTimestampRange, bt as trackUpdatingComment, dn as CommunityIpfsSchema, dr as n$1, dt as findUpdatingComment, et as shortifyCid, f as doesDomainAddressHaveCapitalLetter, ft as findUpdatingCommunity, gt as refreshTrackedCommentAliases, hr as e$1, ht as listUpdatingCommunities, it as timestamp, jr as messages, l as createAbortError, lr as n$2, mr as e, mt as listUpdatingComments, on as CommunityAnchorSchema, pr as t$1, pt as listStartedCommunities, q as removeUndefinedValuesRecursively, qr as parsedType, rt as throwIfAbortSignalAborted, t as areEquivalentCommunityAddresses, tt as sleepUntilTimeoutOrAbort, u as deepMergeRuntimeFields, ut as findStartedCommunity, w as ipnsNameToIpnsOverPubsubTopic, wr as require_retry, wt as untrackUpdatingCommunity, xn as isStringDomain, yn as PubsubTopicSchema } from "./util-C6zDjhpr.js";
+import { $n as getPKCAddressFromPublicKeySync, $t as RpcSubscriptionIdResultSchema, A as extractCommunityRuntimeFieldsFromParsedPages, An as verifyCommentModeration, Ar as NAME_RESOLVED_FALSE_TTL_MS, At as parseRpcCommentEventWithPKCErrorIfItFails, B as stripNameResolvedFromCrosspost, Bn as normalizeCreatePublicationAuthor, Bt as RpcCommunityIdentifierParamSchema, C as RemoteCommunity, Cn as signVote, Cr as t$3, Ct as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, Dn as verifyChallengeVerification, Dr as t$4, Dt as parseDecryptedChallengeWithPKCErrorIfItFails, E as RepliesPages, Er as t$2, Et as parseDecryptedChallengeVerification, F as parseRawPages, Fn as verifyVote, Fr as nativeFunctions$2, Ft as RpcAnchorPublishPreparationResultSchema, Gn as getCommunityNameFromWire, Gt as RpcExportCommunityParamSchema, H as GenericStateClient, Ht as RpcEditCommunityParamSchema, I as applyNameResolvedCacheToCrosspost, In as buildRuntimeAuthor, Ir as require_undici, It as RpcAuthorNameParamSchema, J as decodeRpcChallengeAnswerPubsubMsg, Jn as decode, Jt as RpcFetchCidResultSchema, Kn as getCommunityPublicKeyFromWire, Kt as RpcExportCommunityResultSchema, L as cloneCrosspostForRuntime, Ln as cleanWireAuthor, Lt as RpcCancelExportParamSchema, M as findCommentInPageInstanceRecursively, Mn as verifyCommentUpdate, Mr as NAME_RESOLVE_FAILED_RETRY_FLOOR_MS, Mt as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, N as findCommentInParsedPages, On as verifyCommentEdit, Ot as parseJsonWithPKCErrorIfFails, Pn as verifyCommunityEdit, Pt as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Qt as RpcResolveAuthorNameResultSchema, R as collectCrosspostAuthorsToResolve, Rn as getAuthorNameFromRuntime, Rt as RpcCidParamSchema, S as LRUCache, Sn as signCommunityEdit, St as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, T as KeyvBetterSqlite3, Tn as verifyChallengeMessage, Tt as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, U as InflightFetchManager, Un as buildRuntimeCommunityFields, Ut as RpcExportCommunityModLogsParamSchema, V as PKCClientsManager, Vt as RpcCommunityPageParamSchema, W as InflightResourceTypes, Wn as getCommunityAddressFromRecord, Wt as RpcExportCommunityModLogsResultSchema, X as decodeRpcChallengeRequestPubsubMsg, Xn as getBufferedPKCAddressFromPublicKey, Xt as RpcPublishChallengeAnswersParamSchema, Y as decodeRpcChallengePubsubMsg, Yt as RpcPublishAnchorRecordParamSchema, Z as decodeRpcChallengeVerificationPubsubMsg, Zt as RpcPublishedAnchorRecordResultSchema, _ as pkcJsChallenges, _n as signCommentEdit, _t as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, an as createAnchorIpnsRecord$1, ar as createKuboRpcClient, at as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, br as t$5, cn as encryptEd25519AesGcm, ct as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, dn as cleanUpBeforePublishing, dr as getDefaultDataPath, dt as parseCommunityAddressWithPKCErrorIfItFails, en as RpcSuccessResultSchema, fn as signChallengeAnswer, gn as signComment, gt as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, hr as monitorCommunitiesDirectory, in as createSigner, j as findCommentInPageInstance, jn as verifyCommentPubsubMessage, jr as NAME_RESOLVED_TRUE_TTL_MS, jt as parseRpcCommentUpdateEventWithPKCErrorIfItFails, kn as verifyCommentIpfs, kr as MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE, kt as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, lt as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, mn as signChallengeRequest, mr as listCommunitiesSync, mt as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, n as RpcRemoteCommunity, nn as require_lib$1, nt as parseCidStringSchemaWithPKCErrorIfItFails, on as decryptEd25519AesGcm, ot as parseCommentIpfsSchemaWithPKCErrorIfItFails, q as PKCTypedEmitter, qn as normalizeCommunityInputFromCommunity, qt as RpcFetchCidParamSchema, s as pkcJsPageSorts, t as RpcLocalCommunity, tn as RpcUnsubscribeParamSchema, ut as parseCommentUpdateSchemaWithPKCErrorIfItFails, vn as signCommentModeration, vr as setNativeFunctions$1, vt as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, wr as n$3, wt as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, x as TrackedInstanceRegistry, yr as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, yt as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, zt as RpcCommentRepliesPageParamSchema } from "./rpc-local-community-DHS2R2Vk.js";
+import { s as getHeliaDebugContext } from "./util-B-wz3mKY.js";
 import path from "path";
 import assert from "assert";
 import fs from "fs";
@@ -149,9 +149,228 @@ function t(...t) {
 }
 const n = (e, t) => [...e].sort(t);
 //#endregion
-//#region dist/node/publications/publication.js
+//#region dist/node/publications/publication-clients.js
 var import_retry = /* @__PURE__ */ __toESM(require_retry(), 1);
 var import_lib = require_lib$1();
+var PublicationKuboRpcClient = class extends GenericStateClient {};
+var PublicationKuboPubsubClient = class extends GenericStateClient {};
+var PublicationPKCRpcStateClient = class extends GenericStateClient {};
+//#endregion
+//#region dist/node/publications/publication-client-manager.js
+var PublicationClientsManager = class extends PKCClientsManager {
+	constructor(publication) {
+		super(publication._pkc);
+		this._communityForUpdating = void 0;
+		this._publication = publication;
+		this._initPKCRpcClients();
+		this.handleErrorEventFromCommunity = this.handleErrorEventFromCommunity.bind(this);
+		this.handleIpfsGatewayCommunityState = this.handleIpfsGatewayCommunityState.bind(this);
+		this.handleUpdateEventFromCommunity = this.handleUpdateEventFromCommunity.bind(this);
+		this.handleUpdatingStateChangeEventFromCommunity = this.handleUpdatingStateChangeEventFromCommunity.bind(this);
+	}
+	_initKuboRpcClients() {
+		if (this._pkc.clients.kuboRpcClients) for (const ipfsUrl of t$1(this._pkc.clients.kuboRpcClients)) this.clients.kuboRpcClients = {
+			...this.clients.kuboRpcClients,
+			[ipfsUrl]: new PublicationKuboRpcClient("stopped")
+		};
+	}
+	_initPubsubKuboRpcClients() {
+		for (const pubsubUrl of t$1(this._pkc.clients.pubsubKuboRpcClients)) this.clients.pubsubKuboRpcClients = {
+			...this.clients.pubsubKuboRpcClients,
+			[pubsubUrl]: new PublicationKuboPubsubClient("stopped")
+		};
+	}
+	_initPKCRpcClients() {
+		for (const rpcUrl of t$1(this._pkc.clients.pkcRpcClients)) this.clients.pkcRpcClients = {
+			...this.clients.pkcRpcClients,
+			[rpcUrl]: new PublicationPKCRpcStateClient("stopped")
+		};
+	}
+	emitError(e) {
+		this._publication.emit("error", e);
+	}
+	updateKuboRpcState(newState, kuboRpcClientUrl) {
+		super.updateKuboRpcState(newState, kuboRpcClientUrl);
+	}
+	updateKuboRpcPubsubState(newState, pubsubProvider) {
+		super.updateKuboRpcPubsubState(newState, pubsubProvider);
+	}
+	updateGatewayState(newState, gateway) {
+		super.updateGatewayState(newState, gateway);
+	}
+	_translateCommunityUpdatingStateToPublishingState(newUpdatingState) {
+		const translatedState = {
+			failed: "failed",
+			"fetching-ipfs": "fetching-community-ipfs",
+			"fetching-ipns": "fetching-community-ipns",
+			"resolving-name": "resolving-community-name"
+		}[newUpdatingState];
+		if (translatedState) this._publication._updatePublishingStateWithEmission(translatedState);
+	}
+	handleUpdatingStateChangeEventFromCommunity(newUpdatingState) {
+		this._translateCommunityUpdatingStateToPublishingState(newUpdatingState);
+	}
+	handleUpdateEventFromCommunity(community) {}
+	handleErrorEventFromCommunity(err) {}
+	handleIpfsGatewayCommunityState(communityNewGatewayState, gatewayUrl) {
+		this.updateGatewayState(communityNewGatewayState === "fetching-ipns" ? "fetching-community-ipns" : communityNewGatewayState, gatewayUrl);
+	}
+	handleNameResolverCommunityState(communityNewResolverState, resolverKey) {
+		if (communityNewResolverState === "resolving-author-name") return;
+		this.updateNameResolverState(communityNewResolverState, resolverKey);
+	}
+	handleKuboRpcCommunityState(communityNewKuboRpcState, kuboRpcUrl) {
+		const translatedState = {
+			"fetching-ipns": "fetching-community-ipns",
+			"fetching-ipfs": "fetching-community-ipfs",
+			stopped: "stopped",
+			"publishing-ipns": void 0
+		}[communityNewKuboRpcState];
+		if (translatedState) this.updateKuboRpcState(translatedState, kuboRpcUrl);
+	}
+	handleLibp2pJsClientCommunityState(communityNewLibp2pJsState, libp2pJsClientKey) {
+		const translatedState = {
+			"fetching-ipns": "fetching-community-ipns",
+			"fetching-ipfs": "fetching-community-ipfs",
+			stopped: "stopped",
+			"publishing-ipns": void 0,
+			"waiting-challenge-answers": void 0,
+			"waiting-challenge-requests": void 0,
+			"publishing-challenge": void 0,
+			"publishing-challenge-verification": void 0
+		}[communityNewLibp2pJsState];
+		if (translatedState) this.updateLibp2pJsClientState(translatedState, libp2pJsClientKey);
+	}
+	async _createCommunityInstanceWithStateTranslation() {
+		const directCommunityInstance = findUpdatingCommunity(this._pkc, {
+			publicKey: this._publication.communityPublicKey,
+			name: this._publication.communityName
+		}) || findStartedCommunity(this._pkc, {
+			publicKey: this._publication.communityPublicKey,
+			name: this._publication.communityName
+		});
+		const community = directCommunityInstance || await this._pkc.createCommunity({
+			name: this._publication.communityName,
+			publicKey: this._publication.communityPublicKey
+		}, { abortSignal: this._publication._getCommunityFetchAbortSignal() });
+		this._communityForUpdating = {
+			community,
+			error: this.handleErrorEventFromCommunity.bind(this),
+			update: this.handleUpdateEventFromCommunity.bind(this),
+			updatingstatechange: this.handleUpdatingStateChangeEventFromCommunity.bind(this)
+		};
+		if (this._communityForUpdating.community.clients.ipfsGateways && Object.keys(this._communityForUpdating.community.clients.ipfsGateways).length > 0) {
+			const ipfsGatewayListeners = {};
+			for (const gatewayUrl of Object.keys(this._communityForUpdating.community.clients.ipfsGateways)) {
+				const ipfsStateListener = (communityNewIpfsState) => this.handleIpfsGatewayCommunityState(communityNewIpfsState, gatewayUrl);
+				this._communityForUpdating.community.clients.ipfsGateways[gatewayUrl].on("statechange", ipfsStateListener);
+				ipfsGatewayListeners[gatewayUrl] = ipfsStateListener;
+			}
+			this._communityForUpdating.ipfsGatewayListeners = ipfsGatewayListeners;
+		}
+		if (this._communityForUpdating.community.clients.kuboRpcClients && Object.keys(this._communityForUpdating.community.clients.kuboRpcClients).length > 0) {
+			const kuboRpcListeners = {};
+			for (const kuboRpcUrl of Object.keys(this._communityForUpdating.community.clients.kuboRpcClients)) {
+				const kuboRpcStateListener = (communityNewKuboRpcState) => this.handleKuboRpcCommunityState(communityNewKuboRpcState, kuboRpcUrl);
+				this._communityForUpdating.community.clients.kuboRpcClients[kuboRpcUrl].on("statechange", kuboRpcStateListener);
+				kuboRpcListeners[kuboRpcUrl] = kuboRpcStateListener;
+			}
+			this._communityForUpdating.kuboRpcListeners = kuboRpcListeners;
+		}
+		if (this._communityForUpdating.community.clients.libp2pJsClients && Object.keys(this._communityForUpdating.community.clients.libp2pJsClients).length > 0) {
+			const libp2pJsListeners = {};
+			for (const libp2pJsClientKey of Object.keys(this._communityForUpdating.community.clients.libp2pJsClients)) {
+				const libp2pJsClientStateListener = (communityNewLibp2pJsState) => this.handleLibp2pJsClientCommunityState(communityNewLibp2pJsState, libp2pJsClientKey);
+				this._communityForUpdating.community.clients.libp2pJsClients[libp2pJsClientKey].on("statechange", libp2pJsClientStateListener);
+				libp2pJsListeners[libp2pJsClientKey] = libp2pJsClientStateListener;
+			}
+			this._communityForUpdating.libp2pJsListeners = libp2pJsListeners;
+		}
+		if (this._communityForUpdating.community.clients.nameResolvers && Object.keys(this._communityForUpdating.community.clients.nameResolvers).length > 0) {
+			const nameResolverListeners = {};
+			for (const resolverKey of Object.keys(this._communityForUpdating.community.clients.nameResolvers)) {
+				const resolverStateListener = (communityNewResolverState) => this.handleNameResolverCommunityState(communityNewResolverState, resolverKey);
+				this._communityForUpdating.community.clients.nameResolvers[resolverKey].on("statechange", resolverStateListener);
+				nameResolverListeners[resolverKey] = resolverStateListener;
+			}
+			this._communityForUpdating.nameResolverListeners = nameResolverListeners;
+		}
+		this._communityForUpdating.community.on("update", this._communityForUpdating.update);
+		this._communityForUpdating.community.on("updatingstatechange", this._communityForUpdating.updatingstatechange);
+		this._communityForUpdating.community.on("error", this._communityForUpdating.error);
+		if (directCommunityInstance) directCommunityInstance._numOfListenersForUpdatingInstance++;
+		return this._communityForUpdating;
+	}
+	async cleanUpUpdatingCommunityInstance() {
+		if (!this._communityForUpdating) throw Error("Need to define communityForUpdating first");
+		if (this._communityForUpdating.ipfsGatewayListeners) for (const gatewayUrl of Object.keys(this._communityForUpdating.ipfsGatewayListeners)) {
+			this._communityForUpdating.community.clients.ipfsGateways[gatewayUrl].removeListener("statechange", this._communityForUpdating.ipfsGatewayListeners[gatewayUrl]);
+			this.updateGatewayState("stopped", gatewayUrl);
+		}
+		if (this._communityForUpdating.kuboRpcListeners) for (const kuboRpcUrl of Object.keys(this._communityForUpdating.kuboRpcListeners)) {
+			this._communityForUpdating.community.clients.kuboRpcClients[kuboRpcUrl].removeListener("statechange", this._communityForUpdating.kuboRpcListeners[kuboRpcUrl]);
+			this.updateKuboRpcState("stopped", kuboRpcUrl);
+		}
+		if (this._communityForUpdating.libp2pJsListeners) for (const libp2pJsClientKey of Object.keys(this._communityForUpdating.libp2pJsListeners)) {
+			this._communityForUpdating.community.clients.libp2pJsClients[libp2pJsClientKey].removeListener("statechange", this._communityForUpdating.libp2pJsListeners[libp2pJsClientKey]);
+			this.updateLibp2pJsClientState("stopped", libp2pJsClientKey);
+		}
+		if (this._communityForUpdating.nameResolverListeners) for (const resolverKey of Object.keys(this._communityForUpdating.nameResolverListeners)) {
+			this._communityForUpdating.community.clients.nameResolvers[resolverKey].removeListener("statechange", this._communityForUpdating.nameResolverListeners[resolverKey]);
+			this.updateNameResolverState("stopped", resolverKey);
+		}
+		this._communityForUpdating.community.removeListener("updatingstatechange", this._communityForUpdating.updatingstatechange);
+		this._communityForUpdating.community.removeListener("error", this._communityForUpdating.error);
+		this._communityForUpdating.community.removeListener("update", this._communityForUpdating.update);
+		if (this._communityForUpdating.community._updatingCommunityInstanceWithListeners) await this._communityForUpdating.community.stop();
+		else {
+			this._communityForUpdating.community._numOfListenersForUpdatingInstance--;
+			if (this._communityForUpdating.community._numOfListenersForUpdatingInstance <= 0 && this._communityForUpdating.community.state === "updating") {
+				untrackUpdatingCommunity(this._pkc, this._communityForUpdating.community);
+				await this._communityForUpdating.community.stop();
+			}
+		}
+		this._communityForUpdating = void 0;
+	}
+	async fetchCommunityForPublishingWithCacheGuard() {
+		return this._loadCommunityForPublishingFromNetwork();
+	}
+	async _loadCommunityForPublishingFromNetwork() {
+		const updatingCommunityInstance = await this._createCommunityInstanceWithStateTranslation();
+		let communityIpfs;
+		if (!updatingCommunityInstance.community.raw.communityIpfs) {
+			const timeoutMs = this._pkc._timeouts["community-ipns"];
+			try {
+				await waitForUpdateInCommunityInstanceWithErrorAndTimeout({
+					community: updatingCommunityInstance.community,
+					timeoutMs,
+					abortSignal: this._publication._getCommunityFetchAbortSignal()
+				});
+				communityIpfs = updatingCommunityInstance.community.raw.communityIpfs;
+			} catch (e) {
+				await this.cleanUpUpdatingCommunityInstance();
+				throw e;
+			}
+			await this.cleanUpUpdatingCommunityInstance();
+		} else {
+			communityIpfs = updatingCommunityInstance.community.raw.communityIpfs;
+			await this.cleanUpUpdatingCommunityInstance();
+		}
+		if (!communityIpfs) throw new PKCError("ERR_GET_COMMUNITY_TIMED_OUT", {
+			communityAddress: updatingCommunityInstance.community.address,
+			timeoutMs: this._pkc._timeouts["community-ipns"]
+		});
+		return {
+			address: updatingCommunityInstance.community.address,
+			publicKey: updatingCommunityInstance.community.publicKey,
+			name: updatingCommunityInstance.community.name,
+			encryption: communityIpfs.encryption,
+			pubsubTopic: communityIpfs.pubsubTopic
+		};
+	}
+};
+//#endregion
+//#region dist/node/publications/publication.js
 var Publication = class extends import_lib.TypedEmitter {
 	constructor(pkc) {
 		super();
@@ -1140,6 +1359,968 @@ var Publication = class extends import_lib.TypedEmitter {
 	}
 };
 //#endregion
+//#region dist/node/publications/comment/comment-clients.js
+var CommentLibp2pJsClient = class extends GenericStateClient {};
+var CommentKuboRpcClient = class extends GenericStateClient {};
+var CommentPKCRpcStateClient = class extends GenericStateClient {};
+//#endregion
+//#region dist/node/publications/comment/comment-util.js
+async function loadAllPagesUnderCommunityToFindComment(opts) {
+	const { commentCidToFind, community, signal, postCid, parentCid } = opts;
+	if (!commentCidToFind) throw Error("commentCidToFind should be defined");
+	const log = logger_default("pkc-js:comment:loadAllPagesUnderCommunityToFindComment");
+	const queue = [];
+	const queued = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	const parentCommentCache = /* @__PURE__ */ new Map();
+	const resetTraversalState = () => {
+		queue.length = 0;
+		queued.clear();
+		visited.clear();
+	};
+	const getParentCommentInstance = (parentCid) => {
+		let existing = parentCommentCache.get(parentCid);
+		if (!existing) {
+			existing = community._pkc.getComment({ cid: parentCid });
+			parentCommentCache.set(parentCid, existing);
+		}
+		return existing;
+	};
+	const throwIfAborted = () => {
+		if (!signal?.aborted) return;
+		const abortErr = /* @__PURE__ */ new Error("Aborted");
+		abortErr.name = "AbortError";
+		throw abortErr;
+	};
+	const normalizePage = (page) => {
+		if ("comments" in page && page.comments.length > 0 && "raw" in page.comments[0]) return {
+			comments: page.comments.map((comment) => comment.raw),
+			nextCid: page.nextCid
+		};
+		return page;
+	};
+	const getPageKey = (cid, source, parentCommentCid) => `${source}:${parentCommentCid || ""}:${cid}`;
+	const enqueue = (cid, source, parentCommentCid) => {
+		if (typeof cid !== "string" || cid.length === 0) return;
+		const key = getPageKey(cid, source, parentCommentCid);
+		if (visited.has(key)) return;
+		if (queued.get(key)) return;
+		const entry = {
+			cid,
+			source,
+			parentCommentCid
+		};
+		queued.set(key, entry);
+		queue.push(entry);
+	};
+	const fetchPage = async (cid, source, parentCommentCid) => {
+		throwIfAborted();
+		if (source === "posts") try {
+			return await community.posts.getPage({ cid });
+		} catch (err) {
+			log.trace("posts.getPage failed", {
+				cid,
+				err
+			});
+			return;
+		}
+		else {
+			if (!parentCommentCid) return void 0;
+			try {
+				return await (await getParentCommentInstance(parentCommentCid)).replies.getPage({ cid });
+			} catch (err) {
+				log.trace("replies.getPage failed", {
+					cid,
+					parentCommentCid,
+					err
+				});
+				return;
+			}
+		}
+	};
+	const processReplies = async (replies, parentCommentCid) => {
+		throwIfAborted();
+		if (!replies) return void 0;
+		if (replies.pages) for (const page of Object.values(replies.pages)) {
+			if (!page) continue;
+			const comment = await processPage(page, "replies", parentCommentCid);
+			if (comment) return comment;
+		}
+		if (replies.pageCids) enqueue(replies.pageCids.new || Object.values(replies.pageCids)[0], "replies", parentCommentCid);
+	};
+	const processPage = async (page, source, parentCommentCid) => {
+		throwIfAborted();
+		const pageIpfs = normalizePage(page);
+		for (const pageComment of pageIpfs.comments) {
+			if (pageComment.commentUpdate.cid === commentCidToFind) return pageComment;
+			const childComment = await processReplies(pageComment.commentUpdate.replies, pageComment.commentUpdate.cid);
+			if (childComment) return childComment;
+		}
+		if (pageIpfs.nextCid) enqueue(pageIpfs.nextCid, source, parentCommentCid);
+	};
+	const drainQueue = async (processPageFunc) => {
+		while (queue.length) {
+			throwIfAborted();
+			const { cid, source, parentCommentCid } = queue.shift();
+			const pageKey = getPageKey(cid, source, parentCommentCid);
+			queued.delete(pageKey);
+			if (visited.has(pageKey)) continue;
+			visited.add(pageKey);
+			const page = await fetchPage(cid, source, parentCommentCid);
+			if (!page) continue;
+			const foundComment = await processPageFunc(page, source, parentCommentCid);
+			if (foundComment) return foundComment;
+		}
+	};
+	const processPageForCidOnly = (targetCid) => async (page, source, _parentCommentCid) => {
+		throwIfAborted();
+		const pageIpfs = normalizePage(page);
+		for (const pageComment of pageIpfs.comments) if (pageComment.commentUpdate.cid === targetCid) return pageComment;
+		if (pageIpfs.nextCid) enqueue(pageIpfs.nextCid, source);
+	};
+	const findPostCommentInCommunity = async (targetPostCid) => {
+		const processPostPage = processPageForCidOnly(targetPostCid);
+		for (const page of Object.values(community.posts.pages || {})) {
+			if (!page) continue;
+			const comment = await processPostPage(page, "posts");
+			if (comment) return comment;
+		}
+		enqueue(community.posts.pageCids?.new || Object.values(community.posts.pageCids || {}).find((cid) => typeof cid === "string"), "posts");
+		const foundFromQueue = await drainQueue(processPostPage);
+		if (foundFromQueue) return foundFromQueue;
+	};
+	const searchUnderParent = async (parentCommentCid) => {
+		resetTraversalState();
+		try {
+			const foundFromReplies = await processReplies((await getParentCommentInstance(parentCommentCid)).replies, parentCommentCid);
+			if (foundFromReplies) return foundFromReplies;
+			const foundFromQueue = await drainQueue(processPage);
+			if (foundFromQueue) return foundFromQueue;
+		} catch (err) {
+			log.trace("searchUnderParent failed", {
+				parentCommentCid,
+				err
+			});
+		}
+	};
+	const searchUnderPost = async (postCidToSearch) => {
+		resetTraversalState();
+		const postComment = await findPostCommentInCommunity(postCidToSearch);
+		if (!postComment) return void 0;
+		if (postComment.commentUpdate.cid === commentCidToFind) return postComment;
+		resetTraversalState();
+		const foundFromReplies = await processReplies(postComment.commentUpdate.replies, postCidToSearch);
+		if (foundFromReplies) return foundFromReplies;
+		return await drainQueue(processPage);
+	};
+	if (parentCid) {
+		const foundFromParent = await searchUnderParent(parentCid);
+		if (foundFromParent) return foundFromParent;
+	}
+	if (postCid) {
+		const foundFromPost = await searchUnderPost(postCid);
+		if (foundFromPost) return foundFromPost;
+	}
+	resetTraversalState();
+	for (const page of Object.values(community.posts.pages || {})) {
+		if (!page) continue;
+		const comment = await processPage(page, "posts");
+		if (comment) return comment;
+	}
+	enqueue(community.posts.pageCids?.new || Object.values(community.posts.pageCids || {}).find((cid) => typeof cid === "string"), "posts");
+	return await drainQueue(processPage);
+}
+//#endregion
+//#region dist/node/publications/comment/comment-client-manager.js
+const fetchCommentLogger = logger_default("pkc-js:comment:client-manager:fetchAndVerifyCommentCid");
+var CommentClientsManager = class extends PublicationClientsManager {
+	constructor(comment) {
+		super(comment);
+		this._postForUpdating = void 0;
+		this._comment = comment;
+		this._fetchingUpdateForReplyUsingPageCidsPromise = void 0;
+		this._parentFirstPageCidsAlreadyLoaded = /* @__PURE__ */ new Set();
+		hideClassPrivateProps(this);
+	}
+	_resetFreshHandlerAbortController() {
+		if (this._freshHandlerAbortController) this._freshHandlerAbortController.abort();
+		this._freshHandlerAbortController = new AbortController();
+	}
+	_combinedAbortSignalForRetry() {
+		const signals = [this._comment._getStopAbortSignal(), this._freshHandlerAbortController?.signal].filter((s) => Boolean(s));
+		if (signals.length === 0) return void 0;
+		if (signals.length === 1) return signals[0];
+		return AbortSignal.any(signals);
+	}
+	_initKuboRpcClients() {
+		if (this._pkc.clients.kuboRpcClients) for (const ipfsUrl of t$1(this._pkc.clients.kuboRpcClients)) this.clients.kuboRpcClients = {
+			...this.clients.kuboRpcClients,
+			[ipfsUrl]: new CommentKuboRpcClient("stopped")
+		};
+	}
+	_initLibp2pJsClients() {
+		for (const libp2pJsClientKey of t$1(this._pkc.clients.libp2pJsClients)) this.clients.libp2pJsClients = {
+			...this.clients.libp2pJsClients,
+			[libp2pJsClientKey]: new CommentLibp2pJsClient("stopped")
+		};
+	}
+	_initPKCRpcClients() {
+		for (const rpcUrl of t$1(this._pkc.clients.pkcRpcClients)) this.clients.pkcRpcClients = {
+			...this.clients.pkcRpcClients,
+			[rpcUrl]: new CommentPKCRpcStateClient("stopped")
+		};
+	}
+	updateLibp2pJsClientState(newState, libp2pJsClientKey) {
+		super.updateLibp2pJsClientState(newState, libp2pJsClientKey);
+	}
+	updateKuboRpcState(newState, kuboRpcClientUrl) {
+		super.updateKuboRpcState(newState, kuboRpcClientUrl);
+	}
+	updateGatewayState(newState, ipfsGatewayClientUrl) {
+		super.updateGatewayState(newState, ipfsGatewayClientUrl);
+	}
+	updateKuboRpcPubsubState(newState, pubsubKuboRpcClientUrl) {
+		super.updateKuboRpcPubsubState(newState, pubsubKuboRpcClientUrl);
+	}
+	preResolveNameResolver(opts) {
+		super.preResolveNameResolver(opts);
+		if (this._comment.state === "updating") this._comment._setUpdatingStateWithEmissionIfNewState("resolving-author-name");
+	}
+	_calculatePathForPostCommentUpdate(folderCid, postCid) {
+		return `${folderCid}/` + postCid + "/update";
+	}
+	_bitswapSessionSeedScopeIpnsPubsubTopic() {
+		if (this._communityForUpdating?.community?.ipnsPubsubTopic) return this._communityForUpdating.community.ipnsPubsubTopic;
+		const communityAddress = this._comment.communityAddress;
+		if (communityAddress && isIpns(communityAddress)) return ipnsNameToIpnsOverPubsubTopic(communityAddress);
+	}
+	_updateKuboRpcClientOrHeliaState(newState, kuboRpcOrHelia) {
+		if ("_helia" in kuboRpcOrHelia) this.updateLibp2pJsClientState(newState, kuboRpcOrHelia._libp2pJsClientsOptions.key);
+		else this.updateKuboRpcState(newState, kuboRpcOrHelia.url);
+	}
+	async _fetchPostCommentUpdateIpfsP2P(subIpns, timestampRanges, log) {
+		const attemptedPathsToLoadErrors = {};
+		const kuboRpcOrHelia = this.getDefaultKuboRpcClientOrHelia();
+		if (timestampRanges.some((timestampRange) => {
+			if (!this._comment._commentUpdateIpfsPath) return false;
+			return subIpns.postUpdates[timestampRange] === this._comment._commentUpdateIpfsPath.split("/")[0];
+		})) {
+			log("Comment", this._comment.cid, "last post update range has same folder cid", this._comment._commentUpdateIpfsPath, "will be skipping loading CommentUpdate");
+			return;
+		}
+		this._comment._setUpdatingStateWithEmissionIfNewState("fetching-update-ipfs");
+		for (const timestampRange of timestampRanges) {
+			const folderCid = subIpns.postUpdates[timestampRange];
+			const path = this._calculatePathForPostCommentUpdate(folderCid, this._comment.postCid);
+			this._updateKuboRpcClientOrHeliaState("fetching-update-ipfs", kuboRpcOrHelia);
+			let res;
+			const commentUpdateTimeoutMs = this._pkc._timeouts["comment-update-ipfs"];
+			const abortSignal = this._combinedAbortSignalForRetry();
+			try {
+				res = await this._retryTransientP2PFetch(() => this._fetchCidP2P(path, {
+					maxFileSizeBytes: MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE,
+					timeoutMs: commentUpdateTimeoutMs,
+					abortSignal,
+					bitswapSessionSeedScopeIpnsPubsubTopic: this._bitswapSessionSeedScopeIpnsPubsubTopic()
+				}), {
+					abortSignal,
+					log,
+					context: `post-update ${path}`
+				});
+			} catch (e) {
+				log.trace(`Failed to fetch CommentUpdate from path (${path}) with IPFS P2P. Trying the next timestamp range`);
+				attemptedPathsToLoadErrors[path] = e;
+				continue;
+			} finally {
+				this._updateKuboRpcClientOrHeliaState("stopped", kuboRpcOrHelia);
+			}
+			try {
+				const commentUpdate = parseCommentUpdateSchemaWithPKCErrorIfItFails(parseJsonWithPKCErrorIfFails(res));
+				await this._throwIfCommentUpdateHasInvalidSignature(commentUpdate, subIpns);
+				if (commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) return {
+					commentUpdate,
+					commentUpdateIpfsPath: path
+				};
+				else return void 0;
+			} catch (e) {
+				this._comment._invalidCommentUpdateMfsPaths.add(path);
+				if (e instanceof PKCError) e.details = {
+					...e.details,
+					commentUpdatePath: path,
+					postCid: this._comment.cid
+				};
+				throw e;
+			}
+		}
+		throw new PKCError("ERR_FAILED_TO_FETCH_COMMENT_UPDATE_FROM_ALL_POST_UPDATES_RANGES", {
+			timestampRanges,
+			attemptedPathsToLoadErrors,
+			postCid: this._comment.cid,
+			commentDepth: this._comment.depth
+		});
+	}
+	_shouldWeFetchCommentUpdateFromNextTimestamp(err) {
+		if (!(err instanceof PKCError)) return false;
+		if (err.code === "ERR_COMMENT_UPDATE_SIGNATURE_IS_INVALID" || err.code === "ERR_INVALID_COMMENT_UPDATE_SCHEMA" || err.code === "ERR_OVER_DOWNLOAD_LIMIT" || err.code === "ERR_INVALID_JSON") return false;
+		if (err instanceof FailedToFetchCommentUpdateFromGatewaysError) {
+			for (const gatewayError of Object.values(err.details.gatewayToError)) if (this._shouldWeFetchCommentUpdateFromNextTimestamp(gatewayError)) return true;
+			return false;
+		}
+		return true;
+	}
+	async _throwIfCommentUpdateHasInvalidSignature(commentUpdate, communityIpfs) {
+		if (!this._comment.raw.comment) throw Error("Can't validate comment update when CommentIpfs hasn't been loaded");
+		if (!this._comment.cid) throw Error("can't validate comment update when cid is not defined");
+		if (!this._comment.postCid) throw Error("can't validate comment update when postCid is not defined");
+		const verifyOptions = {
+			update: commentUpdate,
+			resolveAuthorNames: this._pkc.resolveAuthorNames,
+			clientsManager: this,
+			community: {
+				publicKey: getPKCAddressFromPublicKeySync(communityIpfs.signature.publicKey),
+				name: communityIpfs.name,
+				signature: communityIpfs.signature
+			},
+			comment: {
+				...this._comment.raw.comment,
+				cid: this._comment.cid,
+				postCid: this._comment.postCid
+			},
+			validatePages: this._pkc.validatePages,
+			validateUpdateSignature: true,
+			abortSignal: this._comment._getStopAbortSignal()
+		};
+		const signatureValidity = await verifyCommentUpdate(verifyOptions);
+		if (!signatureValidity.valid) throw new PKCError("ERR_COMMENT_UPDATE_SIGNATURE_IS_INVALID", {
+			signatureValidity,
+			verifyOptions
+		});
+	}
+	async _fetchPostCommentUpdateFromGateways(subIpns, timestampRanges, log) {
+		if (timestampRanges.some((timestampRange) => {
+			if (!this._comment._commentUpdateIpfsPath) return false;
+			return subIpns.postUpdates[timestampRange] === this._comment._commentUpdateIpfsPath.split("/")[0];
+		})) {
+			log("Comment", this._comment.cid, "last post update range has same folder cid", this._comment._commentUpdateIpfsPath, "will be skipping loading CommentUpdate");
+			return;
+		}
+		const attemptedPathsToLoadErrors = {};
+		let commentUpdate;
+		const validateCommentFromGateway = async (res) => {
+			if (typeof res.resText !== "string") throw Error("Gateway response has no body");
+			const commentUpdateBeforeSignature = parseCommentUpdateSchemaWithPKCErrorIfItFails(parseJsonWithPKCErrorIfFails(res.resText));
+			await this._throwIfCommentUpdateHasInvalidSignature(commentUpdateBeforeSignature, subIpns);
+			commentUpdate = commentUpdateBeforeSignature;
+		};
+		this._comment._setUpdatingStateWithEmissionIfNewState("fetching-update-ipfs");
+		for (const timestampRange of timestampRanges) {
+			const folderCid = subIpns.postUpdates[timestampRange];
+			const path = this._calculatePathForPostCommentUpdate(folderCid, this._comment.postCid);
+			try {
+				await this.fetchFromMultipleGateways({
+					recordIpfsType: "ipfs",
+					root: folderCid,
+					path: path.replace(`${folderCid}/`, ""),
+					recordPKCType: "comment-update",
+					validateGatewayResponseFunc: validateCommentFromGateway,
+					log,
+					maxFileSizeBytes: MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE,
+					timeoutMs: this._pkc._timeouts["comment-update-ipfs"],
+					abortSignal: this._comment._getStopAbortSignal()
+				});
+				if (!commentUpdate) throw Error("Failed to load comment update from gateways. This is a critical logic error");
+				if (commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) return {
+					commentUpdate,
+					commentUpdateIpfsPath: path
+				};
+				else return void 0;
+			} catch (e) {
+				if (this._shouldWeFetchCommentUpdateFromNextTimestamp(e)) {
+					attemptedPathsToLoadErrors[path] = e;
+					log.trace(`Failed to fetch CommentUpdate from path (${path}) from gateways. Trying the next timestamp range`);
+					continue;
+				} else {
+					this._comment._invalidCommentUpdateMfsPaths.add(path);
+					throw e;
+				}
+			}
+		}
+		throw new PKCError("ERR_FAILED_TO_FETCH_COMMENT_UPDATE_FROM_ALL_POST_UPDATES_RANGES", {
+			timestampRanges,
+			attemptedPathsToLoadErrors,
+			commentCid: this._comment.cid,
+			commentDepth: this._comment.depth
+		});
+	}
+	_useLoadedCommentUpdateIfNewInfo(loadedCommentUpdate, community, log) {
+		if ((this._comment.raw.commentUpdate?.updatedAt || 0) < loadedCommentUpdate.commentUpdate.updatedAt) {
+			log(`${this._comment.depth === 0 ? "Post" : "Reply"} (${this._comment.cid}) received a new CommentUpdate`);
+			this._comment._initCommentUpdate(loadedCommentUpdate.commentUpdate, community);
+			if ("commentUpdateIpfsPath" in loadedCommentUpdate) this._comment._commentUpdateIpfsPath = loadedCommentUpdate.commentUpdateIpfsPath;
+			this._comment._changeCommentStateEmitEventEmitStateChangeEvent({
+				newUpdatingState: "succeeded",
+				event: {
+					name: "update",
+					args: [this._comment]
+				}
+			});
+			return true;
+		} else return false;
+	}
+	async useCommunityPostUpdatesToFetchCommentUpdateForPost(subIpfs) {
+		const log = logger_default("pkc-js:comment:useCommunityPostUpdatesToFetchCommentUpdate");
+		if (!subIpfs.postUpdates) throw new PKCError("ERR_COMMUNITY_HAS_NO_POST_UPDATES", {
+			subIpfs,
+			postCid: this._comment.cid
+		});
+		if (!this._comment.postCid) throw Error("comment.postCid needs to be defined to fetch comment update");
+		const postTimestamp = this._comment.timestamp;
+		if (typeof postTimestamp !== "number") throw Error("Post timestamp is not defined by the time we're fetching from postUpdates");
+		const timestampRanges = getPostUpdateTimestampRange(subIpfs.postUpdates, postTimestamp);
+		if (timestampRanges.length === 0) throw Error("Post has no timestamp range bucket");
+		let newCommentUpdate;
+		try {
+			if (Object.keys(this._pkc.clients.kuboRpcClients).length > 0 || Object.keys(this._pkc.clients.libp2pJsClients).length > 0) newCommentUpdate = await this._fetchPostCommentUpdateIpfsP2P(subIpfs, timestampRanges, log);
+			else newCommentUpdate = await this._fetchPostCommentUpdateFromGateways(subIpfs, timestampRanges, log);
+		} catch (e) {
+			if (e instanceof Error) {
+				if (isAbortError(e)) return;
+				if (this._shouldWeFetchCommentUpdateFromNextTimestamp(e)) {
+					log.trace(`Post`, this._comment.cid, "Failed to load CommentUpdate. Will retry later", e);
+					this._comment._changeCommentStateEmitEventEmitStateChangeEvent({
+						newUpdatingState: "waiting-retry",
+						event: {
+							name: "error",
+							args: [e]
+						}
+					});
+				} else {
+					log.error("Received a non retriable error when attempting to load post commentUpdate. Will be emitting error", this._comment.cid, e);
+					this._comment._changeCommentStateEmitEventEmitStateChangeEvent({
+						newUpdatingState: "failed",
+						event: {
+							name: "error",
+							args: [e]
+						}
+					});
+				}
+			}
+			return;
+		}
+		if (newCommentUpdate) this._useLoadedCommentUpdateIfNewInfo(newCommentUpdate, subIpfs, log);
+		else if (newCommentUpdate === void 0) {
+			log.trace(`Comment`, this._comment.cid, "loaded an old comment update. Ignoring it");
+			this._comment._setUpdatingStateWithEmissionIfNewState("waiting-retry");
+		}
+	}
+	async _fetchRawCommentCidIpfsP2P(cid) {
+		const kuboRpcOrHelia = this.getDefaultKuboRpcClientOrHelia();
+		this._updateKuboRpcClientOrHeliaState("fetching-ipfs", kuboRpcOrHelia);
+		let commentRawString;
+		const commentTimeoutMs = this._pkc._timeouts["comment-ipfs"];
+		try {
+			commentRawString = await this._fetchCidP2P(cid, {
+				maxFileSizeBytes: 1024 * 1024,
+				timeoutMs: commentTimeoutMs,
+				abortSignal: this._comment._getStopAbortSignal(),
+				bitswapSessionSeedScopeIpnsPubsubTopic: this._bitswapSessionSeedScopeIpnsPubsubTopic()
+			});
+		} catch (e) {
+			e.details = {
+				...e.details,
+				commentCid: cid,
+				commentTimeoutMs
+			};
+			throw e;
+		} finally {
+			this._updateKuboRpcClientOrHeliaState("stopped", kuboRpcOrHelia);
+		}
+		return commentRawString;
+	}
+	async _fetchCommentIpfsFromGateways(parentCid) {
+		const log = logger_default("pkc-js:comment:client-manager:_fetchCommentIpfsFromGateways");
+		return (await this.fetchFromMultipleGateways({
+			recordIpfsType: "ipfs",
+			recordPKCType: "comment",
+			root: parentCid,
+			validateGatewayResponseFunc: async () => {},
+			log,
+			maxFileSizeBytes: 1024 * 1024,
+			timeoutMs: this._pkc._timeouts["comment-ipfs"],
+			abortSignal: this._comment._getStopAbortSignal()
+		})).resText;
+	}
+	async _throwIfCommentIpfsIsInvalid(commentIpfs, commentCid) {
+		const verificationOpts = {
+			comment: commentIpfs,
+			resolveAuthorNames: this._pkc.resolveAuthorNames,
+			clientsManager: this,
+			calculatedCommentCid: commentCid,
+			communityPublicKeyFromInstance: this._comment.communityPublicKey,
+			communityNameFromInstance: this._comment.communityName,
+			abortSignal: this._comment._getStopAbortSignal()
+		};
+		const commentIpfsValidation = await verifyCommentIpfs(verificationOpts);
+		if (!commentIpfsValidation.valid) throw new PKCError("ERR_COMMENT_IPFS_SIGNATURE_IS_INVALID", {
+			commentIpfsValidation,
+			verificationOpts
+		});
+	}
+	async _fetchCommentIpfsFromPages() {
+		if (!this._comment.communityAddress) throw Error("Comment communityAddress should be defined");
+		if (!this._comment.cid) throw Error("Comment cid should be defined");
+		const community = await this._pkc.createCommunity({
+			name: this._comment.communityName,
+			publicKey: this._comment.communityPublicKey
+		});
+		const abortController = new AbortController();
+		const abortIfNeeded = async () => {
+			if (!abortController.signal.aborted) abortController.abort();
+			if (community.state === "updating") await community.stop();
+		};
+		const onCommentUpdate = async () => {
+			if (this._comment.raw.comment) await abortIfNeeded();
+		};
+		const onStateChange = async (newState) => {
+			if (newState === "stopped") await abortIfNeeded();
+		};
+		this._comment.on("update", onCommentUpdate);
+		this._comment.on("statechange", onStateChange);
+		if (this._comment.state === "stopped" || this._pkc.destroyed) return;
+		try {
+			if (abortController.signal.aborted) return;
+			await community.update();
+			await new Promise((resolve, reject) => {
+				const abortError = () => {
+					const error = /* @__PURE__ */ new Error("The operation was aborted");
+					error.name = "AbortError";
+					return error;
+				};
+				const cleanup = () => {
+					community.removeListener("update", onUpdate);
+					abortController.signal.removeEventListener("abort", onAbort);
+				};
+				const onAbort = () => {
+					cleanup();
+					reject(abortError());
+				};
+				const onUpdate = async () => {
+					try {
+						if (typeof community.updatedAt === "number") {
+							cleanup();
+							resolve();
+						}
+					} catch (error) {
+						cleanup();
+						reject(error);
+					}
+				};
+				if (abortController.signal.aborted) {
+					reject(abortError());
+					return;
+				}
+				abortController.signal.addEventListener("abort", onAbort);
+				community.on("update", onUpdate);
+				onUpdate();
+			});
+			await community.stop();
+			const commentAfterSearchingAllPages = await loadAllPagesUnderCommunityToFindComment({
+				community,
+				commentCidToFind: this._comment.cid,
+				postCid: this._comment.postCid,
+				parentCid: this._comment.parentCid,
+				signal: abortController.signal
+			});
+			if (commentAfterSearchingAllPages) {
+				if (!this._comment.raw.comment) {
+					this._comment._initIpfsProps(commentAfterSearchingAllPages.comment);
+					this._comment.emit("update", this._comment);
+				}
+				if ((this._comment.updatedAt || 0) < commentAfterSearchingAllPages.commentUpdate.updatedAt) this._comment._initCommentUpdate(commentAfterSearchingAllPages.commentUpdate, community.raw.communityIpfs);
+			}
+		} catch (err) {
+			if (err?.name !== "AbortError") throw err;
+		} finally {
+			this._comment.removeListener("update", onCommentUpdate);
+			this._comment.removeListener("statechange", onStateChange);
+		}
+	}
+	async fetchAndVerifyCommentCid(cid) {
+		const cachedComment = this._pkc._memCaches.commentIpfs.get(cid);
+		if (cachedComment) {
+			fetchCommentLogger.trace("Serving comment CID from cache", cid);
+			return t$4(cachedComment);
+		}
+		const verifiedComment = await this._pkc._inflightFetchManager.withResource(InflightResourceTypes.COMMENT_IPFS, cid, async () => {
+			fetchCommentLogger.trace("Fetching comment CID", cid);
+			let commentRawString;
+			if (Object.keys(this._pkc.clients.kuboRpcClients).length > 0 || Object.keys(this._pkc.clients.libp2pJsClients).length > 0) commentRawString = await this._fetchRawCommentCidIpfsP2P(cid);
+			else commentRawString = await this._fetchCommentIpfsFromGateways(cid);
+			const commentIpfs = parseCommentIpfsSchemaWithPKCErrorIfItFails(parseJsonWithPKCErrorIfFails(commentRawString));
+			await this._throwIfCommentIpfsIsInvalid(commentIpfs, cid);
+			return commentIpfs;
+		});
+		this._pkc._memCaches.commentIpfs.set(cid, verifiedComment);
+		return verifiedComment;
+	}
+	_isPublishing() {
+		return this._comment.state === "publishing";
+	}
+	_findCommentInPagesOfUpdatingCommentsOrCommunity(opts) {
+		if (typeof this._comment.cid !== "string") throw Error("Need to have defined cid");
+		let updateFromCommunity;
+		if (this._comment.communityPublicKey || this._comment.communityName) {
+			const community = findStartedCommunity(this._pkc, {
+				publicKey: this._comment.communityPublicKey,
+				name: this._comment.communityName
+			}) || findUpdatingCommunity(this._pkc, {
+				publicKey: this._comment.communityPublicKey,
+				name: this._comment.communityName
+			}) || opts?.community;
+			if (community) updateFromCommunity = findCommentInPageInstanceRecursively(community.posts, this._comment.cid);
+		} else {
+			for (const community of [...listStartedCommunities(this._pkc), ...listUpdatingCommunities(this._pkc)]) {
+				updateFromCommunity = findCommentInPageInstanceRecursively(community.posts, this._comment.cid);
+				if (updateFromCommunity) break;
+			}
+			if (!updateFromCommunity && opts?.community) updateFromCommunity = findCommentInPageInstanceRecursively(opts.community.posts, this._comment.cid);
+		}
+		const post = this._comment.postCid ? findUpdatingComment(this._pkc, { cid: this._comment.postCid }) : opts?.post;
+		let updateFromPost;
+		if (post) updateFromPost = findCommentInPageInstanceRecursively(post.replies, this._comment.cid);
+		const parent = this._comment.parentCid ? opts?.parent || findUpdatingComment(this._pkc, { cid: this._comment.parentCid }) : void 0;
+		let updateFromParent;
+		if (parent) updateFromParent = parent.replies && findCommentInPageInstance(parent.replies, this._comment.cid);
+		return [
+			updateFromCommunity,
+			updateFromPost,
+			updateFromParent
+		].filter((update) => !!update).sort((a, b) => b.commentUpdate.updatedAt - a.commentUpdate.updatedAt)[0];
+	}
+	async handleUpdateEventFromCommunity(community) {
+		const log = logger_default("pkc-js:comment:update");
+		if (!this._comment.cid) {
+			log("comment.cid is not defined because comment is publishing, waiting until cid is defined");
+			return;
+		}
+		if (this._comment.state === "stopped") {
+			await this._comment.stop();
+			return;
+		}
+		if (!community.raw.communityIpfs) {
+			log("community.raw.communityIpfs is undefined (likely key migration in progress), skipping this update");
+			return;
+		}
+		this._resetFreshHandlerAbortController();
+		if (!this._pkc._pkcRpcClient) this._comment._resolveAuthorNamesInBackground();
+		const postInUpdatingCommunity = this._findCommentInPagesOfUpdatingCommentsOrCommunity({ community });
+		if (postInUpdatingCommunity && postInUpdatingCommunity.commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) {
+			const log = logger_default("pkc-js:comment:update:handleUpdateEventFromCommunity:find-comment-update-in-updating-community-or-comments-pages");
+			this._useLoadedCommentUpdateIfNewInfo({ commentUpdate: postInUpdatingCommunity.commentUpdate }, community.raw.communityIpfs, log);
+		} else try {
+			await this.useCommunityPostUpdatesToFetchCommentUpdateForPost(community.raw.communityIpfs);
+		} catch (e) {
+			if (isAbortError(e)) return;
+			log.error("Failed to use community update to fetch new CommentUpdate", e);
+			this._comment._changeCommentStateEmitEventEmitStateChangeEvent({
+				newUpdatingState: "failed",
+				event: {
+					name: "error",
+					args: [e]
+				}
+			});
+		}
+	}
+	_chooseWhichPagesBasedOnParentAndReplyTimestamp(parentCommentTimestamp) {
+		const replyTimestamp = this._comment.timestamp;
+		const currentTime = Math.floor(Date.now() / 1e3);
+		const replyTimelineSpan = currentTime - parentCommentTimestamp;
+		return (currentTime - Math.max(replyTimestamp, parentCommentTimestamp)) / replyTimelineSpan < .5 ? "new" : "old";
+	}
+	async usePageCidsOfParentToFetchCommentUpdateForReply(postCommentInstance, communityWithSignature) {
+		const log = logger_default("pkc-js:comment:update:usePageCidsOfParentToFetchCommentUpdateForReply");
+		if (!this._comment.cid) throw Error("comment.cid needs to be defined to fetch comment update of reply");
+		if (!this._comment.parentCid) throw Error("comment.parentCid needs to be defined to fetch comment update of reply");
+		const parentCommentInstance = postCommentInstance.cid === this._comment.parentCid ? postCommentInstance : await this._pkc.createComment({ cid: this._comment.parentCid });
+		let startedUpdatingParentComment = false;
+		if (parentCommentInstance.state === "stopped") {
+			await parentCommentInstance.update();
+			startedUpdatingParentComment = true;
+		}
+		await resolveWhenPredicateIsTrue({
+			toUpdate: parentCommentInstance,
+			predicate: () => typeof parentCommentInstance.updatedAt === "number"
+		});
+		if (startedUpdatingParentComment) await parentCommentInstance.stop();
+		if (parentCommentInstance.updatedAt < this._comment.timestamp) return;
+		const replyInPreloadedParentPages = parentCommentInstance.replies && findCommentInPageInstance(parentCommentInstance.replies, this._comment.cid);
+		if (replyInPreloadedParentPages && replyInPreloadedParentPages.commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) {
+			this._useLoadedCommentUpdateIfNewInfo({ commentUpdate: replyInPreloadedParentPages.commentUpdate }, communityWithSignature, log);
+			return;
+		}
+		if (Object.keys(parentCommentInstance.replies.pageCids).length === 0) {
+			if (replyInPreloadedParentPages) {
+				log("Parent comment", this._comment.parentCid, "has no pageCids but reply", this._comment.cid, "found in preloaded pages - using it");
+				this._useLoadedCommentUpdateIfNewInfo({ commentUpdate: replyInPreloadedParentPages.commentUpdate }, communityWithSignature, log);
+				return;
+			}
+			log("Parent comment", this._comment.parentCid, "of reply", this._comment.cid, "does not have any pageCids and reply not in preloaded pages, will wait until another update event by post");
+			this._comment._setUpdatingStateWithEmissionIfNewState("waiting-retry");
+			return;
+		}
+		const pageSortName = this._chooseWhichPagesBasedOnParentAndReplyTimestamp(parentCommentInstance.timestamp);
+		let curPageCid = parentCommentInstance.replies.pageCids[pageSortName];
+		if (!curPageCid) throw Error("Parent comment does not have any new or old pages");
+		if (this._parentFirstPageCidsAlreadyLoaded.has(curPageCid)) {
+			log(`Reply`, this._comment.cid, `:SKIPPING: Page CID ${curPageCid} already loaded parent page cid`);
+			return;
+		}
+		this._comment._setUpdatingStateWithEmissionIfNewState("fetching-update-ipfs");
+		let newCommentUpdate;
+		const pageCidsSearchedForNewUpdate = [];
+		let replyFoundWithoutNewerUpdate = false;
+		while (curPageCid && !newCommentUpdate) {
+			let pageLoaded;
+			try {
+				pageLoaded = await parentCommentInstance.replies.getPage({ cid: curPageCid });
+			} catch (e) {
+				if (isAbortError(e)) throw e;
+				pageCidsSearchedForNewUpdate.push({
+					pageCid: curPageCid,
+					error: e
+				});
+				break;
+			}
+			if (pageCidsSearchedForNewUpdate.length === 0) this._parentFirstPageCidsAlreadyLoaded.add(curPageCid);
+			const replyWithinParentPage = findCommentInParsedPages(pageLoaded, this._comment.cid)?.raw;
+			const replyWithinUpdatingPages = this._findCommentInPagesOfUpdatingCommentsOrCommunity({ parent: parentCommentInstance });
+			pageCidsSearchedForNewUpdate.push({
+				pageCid: curPageCid,
+				replyWithinParentPage: Boolean(replyWithinParentPage),
+				replyWithinUpdatingPages: Boolean(replyWithinUpdatingPages)
+			});
+			if (replyWithinParentPage) {
+				if (replyWithinParentPage.commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) newCommentUpdate = replyWithinParentPage;
+				else replyFoundWithoutNewerUpdate = true;
+				break;
+			} else if (replyWithinUpdatingPages) if (replyWithinUpdatingPages.commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) newCommentUpdate = replyWithinUpdatingPages;
+			else replyFoundWithoutNewerUpdate = true;
+			if (pageSortName === "new" && pageLoaded.comments.find((comment) => comment.timestamp < this._comment.timestamp)) {
+				log("Reply", this._comment.cid, "we found a comment in the page that is older than our reply, stopping search for new comment update");
+				break;
+			} else if (pageSortName === "old" && pageLoaded.comments.find((comment) => comment.timestamp > this._comment.timestamp)) {
+				log("Reply", this._comment.cid, "we found a comment in the page that is newer than our reply, stopping search for old comment update");
+				break;
+			}
+			curPageCid = pageLoaded.nextCid;
+		}
+		log("Searched for new comment update of comment", this._comment.cid, "in the following pageCids of page sort", pageSortName, "of parent comment:", parentCommentInstance.cid, pageCidsSearchedForNewUpdate, "and found", newCommentUpdate ? "a new comment update" : "no new comment update");
+		if (newCommentUpdate) this._useLoadedCommentUpdateIfNewInfo({ commentUpdate: newCommentUpdate.commentUpdate }, communityWithSignature, log);
+		else if (!replyFoundWithoutNewerUpdate) throw new PKCError("ERR_FAILED_TO_FIND_REPLY_COMMENT_UPDATE_WITHIN_PARENT_COMMENT_PAGE_CIDS", {
+			replyCid: this._comment.cid,
+			parentCommentCid: parentCommentInstance.cid,
+			pageSortName,
+			pageCidsSearchedForNewUpdate
+		});
+	}
+	async handleErrorEventFromCommunity(error) {
+		if (this._comment.state === "publishing") return super.handleErrorEventFromCommunity(error);
+		else if (this._communityForUpdating?.community?.updatingState === "failed") {
+			logger_default("pkc-js:comment:update").error(this._comment.depth === 0 ? "Post" : "Reply", this._comment.cid, "received a non retriable error from its community instance. Will stop comment updating", error);
+			this._comment._changeCommentStateEmitEventEmitStateChangeEvent({
+				newUpdatingState: "failed",
+				event: {
+					name: "error",
+					args: [error]
+				}
+			});
+			await this._comment.stop();
+		}
+	}
+	handleIpfsGatewayCommunityState(communityNewGatewayState, gatewayUrl) {
+		if (this._comment.state === "publishing") return super.handleIpfsGatewayCommunityState(communityNewGatewayState, gatewayUrl);
+		else if (communityNewGatewayState === "fetching-ipns") this.updateGatewayState("fetching-community-ipns", gatewayUrl);
+	}
+	_translateCommunityUpdatingStateToCommentUpdatingState(newCommunityUpdatingState) {
+		const translatedCommentUpdatingState = {
+			failed: "failed",
+			"fetching-ipfs": "fetching-community-ipfs",
+			"fetching-ipns": "fetching-community-ipns",
+			"resolving-name": "resolving-community-name",
+			"waiting-retry": "waiting-retry",
+			stopped: "stopped",
+			succeeded: void 0,
+			"publishing-ipns": void 0
+		}[newCommunityUpdatingState];
+		if (translatedCommentUpdatingState) this._comment._setUpdatingStateWithEmissionIfNewState(translatedCommentUpdatingState);
+	}
+	handleUpdatingStateChangeEventFromCommunity(newCommunityUpdatingState) {
+		if (this._comment.state === "publishing") return super.handleUpdatingStateChangeEventFromCommunity(newCommunityUpdatingState);
+		if (this._comment.updatingState === "fetching-update-ipfs") return;
+		this._translateCommunityUpdatingStateToCommentUpdatingState(newCommunityUpdatingState);
+	}
+	handleErrorEventFromPost(error) {
+		this._comment.emit("error", error);
+	}
+	handleUpdatingStateChangeEventFromPost(newState) {
+		const replyState = {
+			failed: "failed",
+			"fetching-community-ipfs": "fetching-community-ipfs",
+			"fetching-community-ipns": "fetching-community-ipns",
+			"resolving-community-name": "resolving-community-name",
+			"waiting-retry": "waiting-retry",
+			stopped: void 0,
+			succeeded: void 0,
+			"fetching-ipfs": void 0,
+			"resolving-author-name": void 0,
+			"fetching-update-ipfs": void 0
+		}[newState];
+		if (replyState) if (this._fetchingUpdateForReplyUsingPageCidsPromise) this._fetchingUpdateForReplyUsingPageCidsPromise.then(() => this._comment._setUpdatingStateWithEmissionIfNewState(replyState));
+		else this._comment._setUpdatingStateWithEmissionIfNewState(replyState);
+	}
+	_handleIpfsGatewayPostState(newState, gatewayUrl) {
+		this.updateGatewayState(newState, gatewayUrl);
+	}
+	_handleKuboRpcPostState(newState, kuboRpcUrl) {
+		this.updateKuboRpcState(newState, kuboRpcUrl);
+	}
+	_handleLibp2pJsClientPostState(newState, libp2pJsClientKey) {
+		this.updateLibp2pJsClientState(newState, libp2pJsClientKey);
+	}
+	_handleNameResolverPostState(newState, resolverKey) {
+		if (newState === "resolving-author-name") return;
+		this.updateNameResolverState(newState, resolverKey);
+	}
+	async handleUpdateEventFromPostToFetchReplyCommentUpdate(postInstance) {
+		if (!this._comment.cid) throw Error("comment.cid should be defined");
+		const log = logger_default("pkc-js:comment:update:handleUpdateEventFromPost");
+		log("Received update event from post", postInstance.cid, "for reply", this._comment.cid, "with depth", this._comment.depth);
+		this._resetFreshHandlerAbortController();
+		if (!this._pkc._pkcRpcClient) this._comment._resolveAuthorNamesInBackground();
+		if (Object.keys(postInstance.replies.pageCids).length === 0 && Object.keys(postInstance.replies.pages).length === 0) {
+			log("Post", postInstance.cid, "has no replies, therefore reply", this._comment.cid, "will wait until another update event by post");
+			this._comment._setUpdatingStateWithEmissionIfNewState("waiting-retry");
+			return;
+		}
+		const replyInPage = this._findCommentInPagesOfUpdatingCommentsOrCommunity({ post: postInstance });
+		const updatingCommunity = findUpdatingCommunity(this._pkc, {
+			publicKey: postInstance.communityPublicKey,
+			name: postInstance.communityName
+		});
+		const startedCommunity = findStartedCommunity(this._pkc, {
+			publicKey: postInstance.communityPublicKey,
+			name: postInstance.communityName
+		});
+		const repliesCommunity = updatingCommunity?.raw?.communityIpfs || startedCommunity?.raw?.communityIpfs || postInstance.replies._community;
+		if (!repliesCommunity.signature) throw Error("repliesCommunity.signature needs to be defined to fetch comment update of reply");
+		if (replyInPage && !this._comment.raw.comment) {
+			this._comment._initIpfsProps(replyInPage.comment);
+			this._comment.emit("update", this._comment);
+		}
+		if (replyInPage && replyInPage.commentUpdate.updatedAt > (this._comment.raw?.commentUpdate?.updatedAt || 0)) {
+			const log = logger_default("pkc-js:comment:update:handleUpdateEventFromPostToFetchReplyCommentUpdate:find-comment-update-in-updating-community-or-comments-pages");
+			this._useLoadedCommentUpdateIfNewInfo({ commentUpdate: replyInPage.commentUpdate }, repliesCommunity, log);
+			return;
+		}
+		if (this._fetchingUpdateForReplyUsingPageCidsPromise) await this._fetchingUpdateForReplyUsingPageCidsPromise;
+		this._fetchingUpdateForReplyUsingPageCidsPromise = this.usePageCidsOfParentToFetchCommentUpdateForReply(postInstance, repliesCommunity).catch((error) => {
+			if (isAbortError(error)) return;
+			log.error("Failed to fetch reply commentUpdate update from parent pages", error);
+			this._comment._changeCommentStateEmitEventEmitStateChangeEvent({
+				newUpdatingState: "failed",
+				event: {
+					name: "error",
+					args: [error]
+				}
+			});
+		}).finally(() => {
+			this._fetchingUpdateForReplyUsingPageCidsPromise = void 0;
+		});
+		await this._fetchingUpdateForReplyUsingPageCidsPromise;
+		this._fetchingUpdateForReplyUsingPageCidsPromise = void 0;
+	}
+	async _createPostInstanceWithStateTranslation() {
+		if (!this._comment.postCid) throw Error("comment.postCid needs to be defined to fetch comment update of reply");
+		const post = findUpdatingComment(this._pkc, { cid: this._comment.postCid }) || await this._pkc.createComment({ cid: this._comment.postCid });
+		this._postForUpdating = {
+			comment: post,
+			error: this.handleErrorEventFromPost.bind(this),
+			update: this.handleUpdateEventFromPostToFetchReplyCommentUpdate.bind(this),
+			updatingstatechange: this.handleUpdatingStateChangeEventFromPost.bind(this)
+		};
+		if (this._postForUpdating.comment.clients.ipfsGateways && Object.keys(this._postForUpdating.comment.clients.ipfsGateways).length > 0) {
+			const ipfsGatewayListeners = {};
+			for (const gatewayUrl of Object.keys(this._postForUpdating.comment.clients.ipfsGateways)) {
+				const ipfsStateListener = (postNewIpfsState) => this._handleIpfsGatewayPostState(postNewIpfsState, gatewayUrl);
+				this._postForUpdating.comment.clients.ipfsGateways[gatewayUrl].on("statechange", ipfsStateListener);
+				ipfsGatewayListeners[gatewayUrl] = ipfsStateListener;
+			}
+			this._postForUpdating.ipfsGatewayListeners = ipfsGatewayListeners;
+		}
+		if (this._postForUpdating.comment.clients.kuboRpcClients && Object.keys(this._postForUpdating.comment.clients.kuboRpcClients).length > 0) {
+			const kuboRpcListeners = {};
+			for (const kuboRpcUrl of Object.keys(this._postForUpdating.comment.clients.kuboRpcClients)) {
+				const kuboRpcStateListener = (postNewKuboRpcState) => this._handleKuboRpcPostState(postNewKuboRpcState, kuboRpcUrl);
+				this._postForUpdating.comment.clients.kuboRpcClients[kuboRpcUrl].on("statechange", kuboRpcStateListener);
+				kuboRpcListeners[kuboRpcUrl] = kuboRpcStateListener;
+			}
+			this._postForUpdating.kuboRpcListeners = kuboRpcListeners;
+		}
+		if (this._postForUpdating.comment.clients.libp2pJsClients && Object.keys(this._postForUpdating.comment.clients.libp2pJsClients).length > 0) {
+			const libp2pJsClientListeners = {};
+			for (const libp2pJsClientKey of Object.keys(this._postForUpdating.comment.clients.libp2pJsClients)) {
+				const libp2pJsStateListener = (postNewLibp2pJsState) => this._handleLibp2pJsClientPostState(postNewLibp2pJsState, libp2pJsClientKey);
+				this._postForUpdating.comment.clients.libp2pJsClients[libp2pJsClientKey].on("statechange", libp2pJsStateListener);
+				libp2pJsClientListeners[libp2pJsClientKey] = libp2pJsStateListener;
+			}
+			this._postForUpdating.libp2pJsClientListeners = libp2pJsClientListeners;
+		}
+		if (this._postForUpdating.comment.clients.nameResolvers && Object.keys(this._postForUpdating.comment.clients.nameResolvers).length > 0) {
+			const nameResolverListeners = {};
+			for (const resolverKey of Object.keys(this._postForUpdating.comment.clients.nameResolvers)) {
+				const resolverStateListener = (postNewResolverState) => this._handleNameResolverPostState(postNewResolverState, resolverKey);
+				this._postForUpdating.comment.clients.nameResolvers[resolverKey].on("statechange", resolverStateListener);
+				nameResolverListeners[resolverKey] = resolverStateListener;
+			}
+			this._postForUpdating.nameResolverListeners = nameResolverListeners;
+		}
+		this._postForUpdating.comment.on("update", this._postForUpdating.update);
+		this._postForUpdating.comment.on("updatingstatechange", this._postForUpdating.updatingstatechange);
+		this._postForUpdating.comment.on("error", this._postForUpdating.error);
+		this._postForUpdating.comment._numOfListenersForUpdatingInstance++;
+		return this._postForUpdating;
+	}
+	async cleanUpUpdatingPostInstance() {
+		if (!this._postForUpdating) return;
+		if (this._postForUpdating.ipfsGatewayListeners) for (const gatewayUrl of Object.keys(this._postForUpdating.ipfsGatewayListeners)) {
+			this._postForUpdating.comment.clients.ipfsGateways[gatewayUrl].removeListener("statechange", this._postForUpdating.ipfsGatewayListeners[gatewayUrl]);
+			this.updateGatewayState("stopped", gatewayUrl);
+		}
+		if (this._postForUpdating.kuboRpcListeners) for (const kuboRpcUrl of Object.keys(this._postForUpdating.kuboRpcListeners)) {
+			this._postForUpdating.comment.clients.kuboRpcClients[kuboRpcUrl].removeListener("statechange", this._postForUpdating.kuboRpcListeners[kuboRpcUrl]);
+			this.updateKuboRpcState("stopped", kuboRpcUrl);
+		}
+		if (this._postForUpdating.libp2pJsClientListeners) for (const libp2pJsClientKey of Object.keys(this._postForUpdating.libp2pJsClientListeners)) {
+			this._postForUpdating.comment.clients.libp2pJsClients[libp2pJsClientKey].removeListener("statechange", this._postForUpdating.libp2pJsClientListeners[libp2pJsClientKey]);
+			this.updateLibp2pJsClientState("stopped", libp2pJsClientKey);
+		}
+		if (this._postForUpdating.nameResolverListeners) for (const resolverKey of Object.keys(this._postForUpdating.nameResolverListeners)) {
+			this._postForUpdating.comment.clients.nameResolvers[resolverKey].removeListener("statechange", this._postForUpdating.nameResolverListeners[resolverKey]);
+			this.updateNameResolverState("stopped", resolverKey);
+		}
+		this._postForUpdating.comment.removeListener("updatingstatechange", this._postForUpdating.updatingstatechange);
+		this._postForUpdating.comment.removeListener("error", this._postForUpdating.error);
+		this._postForUpdating.comment.removeListener("update", this._postForUpdating.update);
+		const postForUpdating = this._postForUpdating.comment;
+		postForUpdating._numOfListenersForUpdatingInstance--;
+		if (postForUpdating._updatingCommentInstance) await postForUpdating.stop();
+		else if (postForUpdating._numOfListenersForUpdatingInstance === 0 && postForUpdating.state !== "stopped") await postForUpdating.stop();
+		else if (postForUpdating._numOfListenersForUpdatingInstance === 0 && postForUpdating.state === "stopped" && postForUpdating.cid && findUpdatingComment(this._pkc, { cid: postForUpdating.cid }) === postForUpdating) untrackUpdatingComment(this._pkc, postForUpdating);
+		this._parentFirstPageCidsAlreadyLoaded.clear();
+		this._postForUpdating = void 0;
+	}
+};
+//#endregion
 //#region dist/node/publications/comment/comment.js
 var import_sha256 = require_sha256();
 var Comment = class extends Publication {
@@ -1227,7 +2408,7 @@ var Comment = class extends Publication {
 		this._initProps(props);
 		const unknownProps = r(t$1(props), t$1(CommentIpfsSchema.shape));
 		if (unknownProps.length > 0) {
-			const unknownPropsWithValues = t$4(props, unknownProps);
+			const unknownPropsWithValues = t$5(props, unknownProps);
 			log(`Found unknown props on loaded CommentIpfs (cid: ${this.cid})`, unknownPropsWithValues, "Full props:", props, "Will set them on the Comment instance");
 			Object.assign(this, unknownPropsWithValues);
 		}
@@ -1323,7 +2504,7 @@ var Comment = class extends Publication {
 			const unknownProps = r(t$1(props), t$1(CommentUpdateSchema.shape));
 			if (unknownProps.length > 0) {
 				log("Found unknown props on CommentUpdate record", unknownProps, "Will set them on Comment instance");
-				Object.assign(this, t$4(props, unknownProps));
+				Object.assign(this, t$5(props, unknownProps));
 			}
 		}
 		this.upvoteCount = props.upvoteCount;
@@ -1393,8 +2574,8 @@ var Comment = class extends Publication {
 		const log = logger_default("pkc-js:comment:publish:_verifyChallengeVerificationCommentProps");
 		if (!this.raw.pubsubMessageToPublish) throw Error("comment._pubsubMsgToPublish should be defined at this point");
 		const keysToCompare = t$1(n$1(this.raw.pubsubMessageToPublish, ["signature", "author"]));
-		const pubsubMsgFromCommentIpfs = t$4(decryptedVerification.comment, keysToCompare);
-		if (!t$3(pubsubMsgFromCommentIpfs, t$4(this.raw.pubsubMessageToPublish, keysToCompare))) {
+		const pubsubMsgFromCommentIpfs = t$5(decryptedVerification.comment, keysToCompare);
+		if (!t$3(pubsubMsgFromCommentIpfs, t$5(this.raw.pubsubMessageToPublish, keysToCompare))) {
 			const error = new PKCError("ERR_COMMUNITY_CHANGED_COMMENT_PUBSUB_PUBLICATION_PROPS", {
 				pubsubMsgFromSub: pubsubMsgFromCommentIpfs,
 				originalPubsubMsg: this.raw.pubsubMessageToPublish
@@ -1499,7 +2680,7 @@ var Comment = class extends Publication {
 		const unknownProps = r(t$1(decryptedVerification.commentUpdate), t$1(CommentUpdateForChallengeVerificationSchema.shape));
 		if (unknownProps.length > 0) {
 			log("Found unknown props on decryptedVerification.commentUpdate record", unknownProps, "Will set them on Comment instance");
-			Object.assign(this, t$4(decryptedVerification.commentUpdate, unknownProps));
+			Object.assign(this, t$5(decryptedVerification.commentUpdate, unknownProps));
 		}
 		this.emit("update", this);
 		if (!this._pkc._pkcRpcClient) this._resolveAuthorNamesInBackground();
@@ -1771,7 +2952,6 @@ var Comment = class extends Publication {
 		const log = logger_default("pkc-js:comment:update:_handleErrorEventFromRpc");
 		const err = args.params.result;
 		log("Received 'error' event from RPC", err);
-		if (err.details?.newUpdatingState) this._setUpdatingStateNoEmission(err.details.newUpdatingState);
 		if (!this._isRetriableLoadingError(err)) {
 			log.error("The RPC transmitted a non retriable error", "for comment", this.cid, "will clean up the subscription", err);
 			this._changeCommentStateEmitEventEmitStateChangeEvent({
@@ -1783,7 +2963,13 @@ var Comment = class extends Publication {
 				}
 			});
 			await this._stopUpdateLoop();
-		} else this.emit("error", err);
+		} else this._changeCommentStateEmitEventEmitStateChangeEvent({
+			newUpdatingState: err.details?.newUpdatingState,
+			event: {
+				name: "error",
+				args: [err]
+			}
+		});
 	}
 	async _updateViaRpc() {
 		const log = logger_default("pkc-js:comment:update:_updateViaRpc");
@@ -6989,7 +8175,10 @@ var PKC$1 = class extends PKCTypedEmitter {
 		this.validatePages = this.parsedPKCOptions.validatePages;
 		this.userAgent = this.parsedPKCOptions.userAgent;
 		this.httpRoutersOptions = this.parsedPKCOptions.httpRoutersOptions;
-		this.settings = { challenges: this.parsedPKCOptions.challenges };
+		this.settings = {
+			challenges: this.parsedPKCOptions.challenges,
+			pageSorts: this.parsedPKCOptions.pageSorts
+		};
 		this.nameResolvers = this.pkcRpcClientsOptions ? void 0 : this.parsedPKCOptions.nameResolvers;
 		this.on("communitieschange", (newCommunities) => {
 			this.communities = newCommunities;
@@ -7065,7 +8254,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-qvcQHRw5.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-BY1wF9W8.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -7186,7 +8375,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		}
 	}
 	async _initMissingFieldsOfPublicationBeforeSigning(pubOptions, log) {
-		const finalOptions = t$5(pubOptions);
+		const finalOptions = t$4(pubOptions);
 		if (!finalOptions.signer) throw Error("User did not provide a signer to create a local publication");
 		let cleanedAuthor = cleanWireAuthor(normalizeCreatePublicationAuthor(finalOptions.author));
 		if (cleanedAuthor) {
@@ -7307,7 +8496,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		}
 		if (!community.raw.communityIpfs) {
 			if (options.signature) {
-				const resParseCommunityIpfs = CommunityIpfsSchema.loose().safeParse(t$4(options, [...options.signature.signedPropertyNames, "signature"]));
+				const resParseCommunityIpfs = CommunityIpfsSchema.loose().safeParse(t$5(options, [...options.signature.signedPropertyNames, "signature"]));
 				if (resParseCommunityIpfs.success) {
 					const cleanedRecord = removeUndefinedValuesRecursively(resParseCommunityIpfs.data);
 					await community.initCommunityIpfsPropsNoMerge(cleanedRecord);
@@ -7344,7 +8533,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-BVWWQKxg.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-B6i3MUzw.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {
@@ -7917,12 +9106,14 @@ PKC.nativeFunctions = {
 PKC.getShortCid = getShortCidValue;
 PKC.getShortAddress = getShortAddressValue;
 PKC.challenges = pkcJsChallenges;
+PKC.pageSorts = pkcJsPageSorts;
 PKC.createAnchorIpnsRecord = createAnchorIpnsRecord$1;
 const setNativeFunctions = PKC.setNativeFunctions;
 const nativeFunctions = PKC.nativeFunctions;
 const getShortCid = PKC.getShortCid;
 const getShortAddress = PKC.getShortAddress;
 const challenges = PKC.challenges;
+const pageSorts = PKC.pageSorts;
 const createAnchorIpnsRecord = PKC.createAnchorIpnsRecord;
 //#endregion
-export { parseRpcPublishAnchorRecordParam as _, getShortCid as a, parseRpcAuthorNameParam as c, parseRpcCommentRepliesPageParam as d, parseRpcCommunityIdentifierParam as f, parseRpcExportCommunityParam as g, parseRpcExportCommunityModLogsParam as h, getShortAddress as i, parseRpcCancelExportParam as l, parseRpcEditCommunityParam as m, challenges as n, nativeFunctions as o, parseRpcCommunityPageParam as p, createAnchorIpnsRecord as r, setNativeFunctions as s, PKC as t, parseRpcCidParam as u, parseRpcPublishChallengeAnswersParam as v, parseRpcUnsubscribeParam as y };
+export { parseRpcExportCommunityParam as _, getShortCid as a, parseRpcUnsubscribeParam as b, setNativeFunctions as c, parseRpcCidParam as d, parseRpcCommentRepliesPageParam as f, parseRpcExportCommunityModLogsParam as g, parseRpcEditCommunityParam as h, getShortAddress as i, parseRpcAuthorNameParam as l, parseRpcCommunityPageParam as m, challenges as n, nativeFunctions as o, parseRpcCommunityIdentifierParam as p, createAnchorIpnsRecord as r, pageSorts as s, PKC as t, parseRpcCancelExportParam as u, parseRpcPublishAnchorRecordParam as v, parseRpcPublishChallengeAnswersParam as y };