@pkcprotocol/pkc-js 0.0.124 → 0.0.126

package/dist/bundled/chunks/{node-BWOsSCO-.js → node-agDtcKUp.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $ as shortifyAddress, At as ChallengeMessageSchema, Ct as untrackUpdatingComment, Dr as FailedToFetchCommentUpdateFromGatewaysError, Dt as pTimeout, E as isIpfsCid, Er as FailedToFetchCommentIpfsFromGatewaysError, Et as TimeoutError, H as rejectWhenCommunityStopsOrAborts, In as CommentUpdateForChallengeVerificationSchema, Ir as setErrorMap, J as replaceXWithY, Jr as parsedType, Kt as version_default, Mr as messages, Mt as ChallengeRequestMessageSchema, Nr as logger_default, O as isIpns, Ot as ChallengeAnswerMessageSchema, Pt as ChallengeVerificationMessageSchema, S as hideClassPrivateProps, Sn as isStringDomain, T as isAbortError, Tr as require_retry, Tt as require_sha256, V as rejectWhenAbortSignalFires, Y as resolveWhenPredicateIsTrue, Yr as stringifyPrimitive, Z as retryKuboIpfsAdd, at as waitForUpdateInCommunityInstanceWithErrorAndTimeout, b as getPostUpdateTimestampRange, bt as trackUpdatingComment, dn as CommunityIpfsSchema, dt as findUpdatingComment, et as shortifyCid, f as doesDomainAddressHaveCapitalLetter, fr as n$1, ft as findUpdatingCommunity, gr as e$1, gt as refreshTrackedCommentAliases, hr as e, ht as listUpdatingCommunities, it as timestamp, jn as CommentIpfsSchema, jr as PKCError, l as createAbortError, mr as t$1, mt as listUpdatingComments, on as CommunityAnchorSchema, pt as listStartedCommunities, q as removeUndefinedValuesRecursively, qr as joinValues, rt as throwIfAbortSignalAborted, t as areEquivalentCommunityAddresses, tt as sleepUntilTimeoutOrAbort, u as deepMergeRuntimeFields, ur as n$2, ut as findStartedCommunity, vr as r, w as ipnsNameToIpnsOverPubsubTopic, wt as untrackUpdatingCommunity, yn as PubsubTopicSchema, zn as CommentUpdateSchema } from "./util-Bd4vp_w6.js";
-import { $ as parseCidStringSchemaWithPKCErrorIfItFails, $t as require_lib$1, A as findCommentInParsedPages, Ar as NAME_RESOLVE_FAILED_RETRY_FLOOR_MS, B as InflightFetchManager, Bn as buildRuntimeCommunityFields, Bt as RpcExportCommunityModLogsParamSchema, C as RepliesPages, Ct as parseDecryptedChallengeVerification, D as extractCommunityRuntimeFieldsFromParsedPages, Dn as verifyCommentModeration, Dr as MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE, Dt as parseRpcCommentEventWithPKCErrorIfItFails, En as verifyCommentIpfs, Et as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, F as collectCrosspostAuthorsToResolve, Fn as getAuthorNameFromRuntime, Ft as RpcCidParamSchema, G as decodeRpcChallengeAnswerPubsubMsg, Gn as decode, Gt as RpcFetchCidResultSchema, Hn as getCommunityNameFromWire, Ht as RpcExportCommunityParamSchema, In as getAuthorNameFromWire, It as RpcCommentRepliesPageParamSchema, J as decodeRpcChallengeVerificationPubsubMsg, Jt as RpcPublishedAnchorRecordResultSchema, K as decodeRpcChallengePubsubMsg, Kt as RpcPublishAnchorRecordParamSchema, L as stripNameResolvedFromCrosspost, Ln as normalizeCreatePublicationAuthor, Lt as RpcCommunityIdentifierParamSchema, M as parseRawPages, Mn as verifyVote, Mt as RpcAnchorPublishPreparationResultSchema, N as applyNameResolvedCacheToCrosspost, Nn as buildRuntimeAuthor, Nr as nativeFunctions$2, Nt as RpcAuthorNameParamSchema, O as findCommentInPageInstance, On as verifyCommentPubsubMessage, Or as NAME_RESOLVED_FALSE_TTL_MS, Ot as parseRpcCommentUpdateEventWithPKCErrorIfItFails, P as cloneCrosspostForRuntime, Pn as cleanWireAuthor, Pr as require_undici, Pt as RpcCancelExportParamSchema, Qt as RpcUnsubscribeParamSchema, R as PKCClientsManager, Rt as RpcCommunityPageParamSchema, S as KeyvBetterSqlite3, Sn as verifyChallengeMessage, Sr as n$3, St as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Tn as verifyCommentEdit, Tr as t$4, Tt as parseJsonWithPKCErrorIfFails, Un as getCommunityPublicKeyFromWire, Ut as RpcExportCommunityResultSchema, V as InflightResourceTypes, Vn as getCommunityAddressFromRecord, Vt as RpcExportCommunityModLogsResultSchema, W as PKCTypedEmitter, Wn as normalizeCommunityInputFromCommunity, Wt as RpcFetchCidParamSchema, Xn as getPKCAddressFromPublicKeySync, Xt as RpcSubscriptionIdResultSchema, Yt as RpcResolveAuthorNameResultSchema, Zt as RpcSuccessResultSchema, _r as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, an as encryptEd25519AesGcm, at as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, b as RemoteCommunity, bn as signVote, bt as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, cn as cleanUpBeforePublishing, cr as getDefaultDataPath, ct as parseCommunityAddressWithPKCErrorIfItFails, dn as signChallengeRequest, dr as listCommunitiesSync, dt as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, fr as monitorCommunitiesDirectory, gr as setNativeFunctions$1, gt as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, hn as signCommentModeration, ht as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, jn as verifyCommunityEdit, jt as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, k as findCommentInPageInstanceRecursively, kn as verifyCommentUpdate, kr as NAME_RESOLVED_TRUE_TTL_MS, kt as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, l as pkcJsPageSorts, ln as signChallengeAnswer, m as pkcJsChallenges, mn as signCommentEdit, mt as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, n as RpcRemoteCommunity, nn as createAnchorIpnsRecord$1, nr as createKuboRpcClient, nt as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ot as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, pn as signComment, pt as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, q as decodeRpcChallengeRequestPubsubMsg, qn as getBufferedPKCAddressFromPublicKey, qt as RpcPublishChallengeAnswersParamSchema, rn as decryptEd25519AesGcm, rt as parseCommentIpfsSchemaWithPKCErrorIfItFails, st as parseCommentUpdateSchemaWithPKCErrorIfItFails, t as RpcLocalCommunity, tn as createSigner, v as TrackedInstanceRegistry, vr as t$5, wn as verifyChallengeVerification, wr as t$2, wt as parseDecryptedChallengeWithPKCErrorIfItFails, xr as t$3, xt as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, y as LRUCache, yn as signCommunityEdit, yt as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, z as GenericStateClient, zt as RpcEditCommunityParamSchema } from "./rpc-local-community-D8wgBsuD.js";
-import { s as getHeliaDebugContext } from "./util-IESnqTnj.js";
+import { $ as retryKuboIpfsAddAndProvide, At as ChallengeAnswerMessageSchema, C as hideClassPrivateProps, D as isIpfsCid, Dt as require_sha256, E as isAbortError, Et as untrackUpdatingCommunity, H as rejectWhenAbortSignalFires, Hr as setErrorMap, It as ChallengeVerificationMessageSchema, J as removeUndefinedValuesRecursively, Jt as version_default, Lr as PKCError, Mr as FailedToFetchCommentIpfsFromGatewaysError, Mt as ChallengeMessageSchema, Nn as CommentIpfsSchema, Nr as FailedToFetchCommentUpdateFromGatewaysError, Ot as TimeoutError, Pt as ChallengeRequestMessageSchema, Q as retryKuboIpfsAdd, Rn as CommentUpdateForChallengeVerificationSchema, Rr as messages, Sr as e$1, St as trackUpdatingComment, T as ipnsNameToIpnsOverPubsubTopic, Tt as untrackUpdatingComment, U as rejectWhenCommunityStopsOrAborts, Vn as CommentUpdateSchema, X as resolveWhenPredicateIsTrue, Y as replaceXWithY, _t as listUpdatingCommunities, a as calculateStringSizeSameAsIpfsAddCidV0Sync, at as timestamp, br as t$1, cn as CommunityAnchorSchema, d as deepMergeRuntimeFields, dt as findStartedCommunity, et as shortifyAddress, ft as findUpdatingComment, gr as n$2, gt as listUpdatingComments, ht as listStartedCommunities, i as calculateStringSizeSameAsIpfsAddCidV0, it as throwIfAbortSignalAborted, jr as require_retry, k as isIpns, kt as pTimeout, ni as en_default, nt as sleepUntilTimeoutOrAbort, ot as waitForUpdateInCommunityInstanceWithErrorAndTimeout, p as doesDomainAddressHaveCapitalLetter, pn as CommunityIpfsSchema, pt as findUpdatingCommunity, r as calculateIpfsCidV0, t as areEquivalentCommunityAddresses, tt as shortifyCid, u as createAbortError, vr as n$1, vt as refreshTrackedCommentAliases, wn as isStringDomain, wr as r, x as getPostUpdateTimestampRange, xn as PubsubTopicSchema, xr as e, zr as logger_default } from "./util-PGPkG-gU.js";
+import { $ as parseCidStringSchemaWithPKCErrorIfItFails, $n as getCommunityNameFromWire, $t as RpcPublishedAnchorRecordResultSchema, A as findCommentInParsedPages, At as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, B as InflightFetchManager, Bn as verifyVote, Br as NAME_RESOLVED_TRUE_TTL_MS, Bt as RpcEditCommunityParamSchema, C as RepliesPages, Cr as monitorCommunitiesDirectory, Ct as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, D as extractCommunityRuntimeFieldsFromParsedPages, Dn as signVote, Dr as setNativeFunctions$1, Dt as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, En as signCommunityList, Et as parseJsonWithPKCErrorIfFails, F as collectCrosspostAuthorsToResolve, Fn as verifyCommentPubsubMessage, Fr as t$2, Ft as RpcCancelExportParamSchema, G as decodeRpcChallengeAnswerPubsubMsg, Gn as normalizeCreatePublicationAuthor, Gr as require_undici, Gt as RpcFetchCidParamSchema, Hn as cleanWireAuthor, Ht as RpcExportCommunityModLogsResultSchema, In as verifyCommentUpdate, Ir as t$4, It as RpcCidParamSchema, J as decodeRpcChallengeVerificationPubsubMsg, Jn as MAX_COMMUNITY_LIST_SIZE_BYTES, Jt as RpcFetchCommunityListResultSchema, K as decodeRpcChallengePubsubMsg, Kn as CreateCommunityListWithCidOptionsSchema, Kt as RpcFetchCidResultSchema, L as stripNameResolvedFromCrosspost, Lt as RpcCommentRepliesPageParamSchema, M as parseRawPages, Mn as verifyCommentEdit, Mr as t$3, Mt as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, N as applyNameResolvedCacheToCrosspost, Nn as verifyCommentIpfs, Nr as n$3, Nt as RpcAnchorPublishPreparationResultSchema, O as findCommentInPageInstance, Or as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Ot as parseRpcCommentEventWithPKCErrorIfItFails, P as cloneCrosspostForRuntime, Pn as verifyCommentModeration, Pt as RpcAuthorNameParamSchema, Qn as getCommunityAddressFromRecord, Qt as RpcPublishCommunityListResultSchema, R as PKCClientsManager, Rn as verifyCommunityEdit, Rr as MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE, Rt as RpcCommunityIdentifierParamSchema, Sr as listCommunitiesSync, St as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, Tn as signCommunityEdit, Tt as parseDecryptedChallengeWithPKCErrorIfItFails, Un as getAuthorNameFromRuntime, Ut as RpcExportCommunityParamSchema, V as InflightResourceTypes, Vn as buildRuntimeAuthor, Vr as NAME_RESOLVE_FAILED_RETRY_FLOOR_MS, Vt as RpcExportCommunityModLogsParamSchema, W as PKCTypedEmitter, Wn as getAuthorNameFromWire, Wr as nativeFunctions$2, Wt as RpcExportCommunityResultSchema, Xt as RpcPublishChallengeAnswersParamSchema, Yt as RpcPublishAnchorRecordParamSchema, Zn as buildRuntimeCommunityFields, Zt as RpcPublishCommunityListParamSchema, _n as signChallengeRequest, _t as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, an as require_lib$1, at as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, b as KeyvBetterSqlite3, bn as signCommentEdit, bt as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, cn as createAnchorIpnsRecord$1, ct as parseCommunityAddressWithPKCErrorIfItFails, dn as encryptEd25519AesGcm, dt as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, en as RpcResolveAuthorNameResultSchema, er as getCommunityPublicKeyFromWire, gt as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, hn as signChallengeAnswer, ht as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, in as findCommunityRecordNameMismatch, ir as getBufferedPKCAddressFromPublicKey, jn as verifyChallengeVerification, k as findCommentInPageInstanceRecursively, kn as verifyChallengeMessage, kr as t$5, kt as parseRpcCommentUpdateEventWithPKCErrorIfItFails, l as pkcJsPageSorts, ln as decryptEd25519AesGcm, m as pkcJsChallenges, mn as cleanUpBeforePublishing, mt as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, n as RpcRemoteCommunity, nn as RpcSuccessResultSchema, nr as decode, nt as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ot as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, pr as createKuboRpcClient, pt as parseCommunityListSchemaWithPKCErrorIfItFails, q as decodeRpcChallengeRequestPubsubMsg, qn as CreateNewCommunityListOptionsSchema, qt as RpcFetchCommunityListParamSchema, rn as RpcUnsubscribeParamSchema, rt as parseCommentIpfsSchemaWithPKCErrorIfItFails, sn as createSigner, sr as getPKCAddressFromPublicKeySync, st as parseCommentUpdateSchemaWithPKCErrorIfItFails, t as RpcLocalCommunity, tn as RpcSubscriptionIdResultSchema, tr as normalizeCommunityInputFromCommunity, v as TrackedInstanceRegistry, wt as parseDecryptedChallengeVerification, x as RemoteCommunity, xn as signCommentModeration, xt as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, y as LRUCache, yn as signComment, yr as getDefaultDataPath, z as GenericStateClient, zn as verifyCommunityList, zr as NAME_RESOLVED_FALSE_TTL_MS, zt as RpcCommunityPageParamSchema } from "./rpc-local-community-DOcUqswi.js";
+import { s as getHeliaDebugContext } from "./util-DNYbha6W.js";
 import path from "path";
 import assert from "assert";
 import fs from "fs";
@@ -10,108 +10,6 @@ import { CID } from "multiformats/cid";
 import { of } from "typestub-ipfs-only-hash";
 import EventEmitter from "events";
 import { Client } from "rpc-websockets";
-//#region node_modules/zod/v4/locales/en.js
-const error = () => {
-	const Sizable = {
-		string: {
-			unit: "characters",
-			verb: "to have"
-		},
-		file: {
-			unit: "bytes",
-			verb: "to have"
-		},
-		array: {
-			unit: "items",
-			verb: "to have"
-		},
-		set: {
-			unit: "items",
-			verb: "to have"
-		},
-		map: {
-			unit: "entries",
-			verb: "to have"
-		}
-	};
-	function getSizing(origin) {
-		return Sizable[origin] ?? null;
-	}
-	const FormatDictionary = {
-		regex: "input",
-		email: "email address",
-		url: "URL",
-		emoji: "emoji",
-		uuid: "UUID",
-		uuidv4: "UUIDv4",
-		uuidv6: "UUIDv6",
-		nanoid: "nanoid",
-		guid: "GUID",
-		cuid: "cuid",
-		cuid2: "cuid2",
-		ulid: "ULID",
-		xid: "XID",
-		ksuid: "KSUID",
-		datetime: "ISO datetime",
-		date: "ISO date",
-		time: "ISO time",
-		duration: "ISO duration",
-		ipv4: "IPv4 address",
-		ipv6: "IPv6 address",
-		mac: "MAC address",
-		cidrv4: "IPv4 range",
-		cidrv6: "IPv6 range",
-		base64: "base64-encoded string",
-		base64url: "base64url-encoded string",
-		json_string: "JSON string",
-		e164: "E.164 number",
-		jwt: "JWT",
-		template_literal: "input"
-	};
-	const TypeDictionary = { nan: "NaN" };
-	return (issue) => {
-		switch (issue.code) {
-			case "invalid_type": {
-				const expected = TypeDictionary[issue.expected] ?? issue.expected;
-				const receivedType = parsedType(issue.input);
-				return `Invalid input: expected ${expected}, received ${TypeDictionary[receivedType] ?? receivedType}`;
-			}
-			case "invalid_value":
-				if (issue.values.length === 1) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
-				return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
-			case "too_big": {
-				const adj = issue.inclusive ? "<=" : "<";
-				const sizing = getSizing(issue.origin);
-				if (sizing) return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
-				return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
-			}
-			case "too_small": {
-				const adj = issue.inclusive ? ">=" : ">";
-				const sizing = getSizing(issue.origin);
-				if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
-				return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
-			}
-			case "invalid_format": {
-				const _issue = issue;
-				if (_issue.format === "starts_with") return `Invalid string: must start with "${_issue.prefix}"`;
-				if (_issue.format === "ends_with") return `Invalid string: must end with "${_issue.suffix}"`;
-				if (_issue.format === "includes") return `Invalid string: must include "${_issue.includes}"`;
-				if (_issue.format === "regex") return `Invalid string: must match pattern ${_issue.pattern}`;
-				return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
-			}
-			case "not_multiple_of": return `Invalid number: must be a multiple of ${issue.divisor}`;
-			case "unrecognized_keys": return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
-			case "invalid_key": return `Invalid key in ${issue.origin}`;
-			case "invalid_union": return "Invalid input";
-			case "invalid_element": return `Invalid value in ${issue.origin}`;
-			default: return `Invalid input`;
-		}
-	};
-};
-function en_default() {
-	return { localeError: error() };
-}
-//#endregion
 //#region dist/node/zod-error-map.js
 const defaultLocaleError = en_default().localeError;
 const friendlyErrorMap = (rawIssue) => {
@@ -241,18 +139,20 @@ var PublicationClientsManager = class extends PKCClientsManager {
 		}[communityNewLibp2pJsState];
 		if (translatedState) this.updateLibp2pJsClientState(translatedState, libp2pJsClientKey);
 	}
-	async _createCommunityInstanceWithStateTranslation() {
+	async _createCommunityInstanceWithStateTranslation(opts) {
+		const communityName = opts?.byPublicKey && this._publication.communityPublicKey ? void 0 : this._publication.communityName;
 		const directCommunityInstance = findUpdatingCommunity(this._pkc, {
 			publicKey: this._publication.communityPublicKey,
-			name: this._publication.communityName
+			name: communityName
 		}) || findStartedCommunity(this._pkc, {
 			publicKey: this._publication.communityPublicKey,
-			name: this._publication.communityName
+			name: communityName
 		});
 		const community = directCommunityInstance || await this._pkc.createCommunity({
-			name: this._publication.communityName,
+			name: communityName,
 			publicKey: this._publication.communityPublicKey
 		}, { abortSignal: this._publication._getCommunityFetchAbortSignal() });
+		if (!directCommunityInstance && !communityName && this._publication.communityName && community instanceof RemoteCommunity) community._nameToResolveBeforeFirstRecord = this._publication.communityName;
 		this._communityForUpdating = {
 			community,
 			error: this.handleErrorEventFromCommunity.bind(this),
@@ -301,8 +201,8 @@ var PublicationClientsManager = class extends PKCClientsManager {
 		if (directCommunityInstance) directCommunityInstance._numOfListenersForUpdatingInstance++;
 		return this._communityForUpdating;
 	}
-	async cleanUpUpdatingCommunityInstance() {
-		if (!this._communityForUpdating) throw Error("Need to define communityForUpdating first");
+	_detachCommunityStateListeners() {
+		if (!this._communityForUpdating) return;
 		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);
@@ -320,6 +220,14 @@ var PublicationClientsManager = class extends PKCClientsManager {
 			this.updateNameResolverState("stopped", resolverKey);
 		}
 		this._communityForUpdating.community.removeListener("updatingstatechange", this._communityForUpdating.updatingstatechange);
+		this._communityForUpdating.ipfsGatewayListeners = void 0;
+		this._communityForUpdating.kuboRpcListeners = void 0;
+		this._communityForUpdating.libp2pJsListeners = void 0;
+		this._communityForUpdating.nameResolverListeners = void 0;
+	}
+	async cleanUpUpdatingCommunityInstance() {
+		if (!this._communityForUpdating) throw Error("Need to define communityForUpdating first");
+		this._detachCommunityStateListeners();
 		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();
@@ -340,6 +248,12 @@ var PublicationClientsManager = class extends PKCClientsManager {
 		let communityIpfs;
 		if (!updatingCommunityInstance.community.raw.communityIpfs) {
 			const timeoutMs = this._pkc._timeouts["community-ipns"];
+			const detachOnRecord = () => {
+				if (!updatingCommunityInstance.community.raw.communityIpfs) return;
+				updatingCommunityInstance.community.removeListener("update", detachOnRecord);
+				this._detachCommunityStateListeners();
+			};
+			updatingCommunityInstance.community.on("update", detachOnRecord);
 			try {
 				await waitForUpdateInCommunityInstanceWithErrorAndTimeout({
 					community: updatingCommunityInstance.community,
@@ -350,6 +264,8 @@ var PublicationClientsManager = class extends PKCClientsManager {
 			} catch (e) {
 				await this.cleanUpUpdatingCommunityInstance();
 				throw e;
+			} finally {
+				updatingCommunityInstance.community.removeListener("update", detachOnRecord);
 			}
 			await this.cleanUpUpdatingCommunityInstance();
 		} else {
@@ -360,6 +276,12 @@ var PublicationClientsManager = class extends PKCClientsManager {
 			communityAddress: updatingCommunityInstance.community.address,
 			timeoutMs: this._pkc._timeouts["community-ipns"]
 		});
+		const nameMismatch = findCommunityRecordNameMismatch({
+			requestedName: this._publication.communityName,
+			record: communityIpfs,
+			communityPublicKey: updatingCommunityInstance.community.publicKey
+		});
+		if (nameMismatch) throw nameMismatch;
 		return {
 			address: updatingCommunityInstance.community.address,
 			publicKey: updatingCommunityInstance.community.publicKey,
@@ -889,6 +811,11 @@ var Publication = class extends import_lib.TypedEmitter {
 			name: this.communityName
 		});
 		const subIpfs = subInstance?.raw.communityIpfs;
+		if (subIpfs && findCommunityRecordNameMismatch({
+			requestedName: this.communityName,
+			record: subIpfs,
+			communityPublicKey: subInstance.publicKey
+		})) return void 0;
 		if (subIpfs && subInstance.publicKey) return {
 			address: subInstance.address,
 			publicKey: subInstance.publicKey,
@@ -909,7 +836,10 @@ var Publication = class extends import_lib.TypedEmitter {
 					abortSignal: this._getCommunityFetchAbortSignal()
 				}).catch((e) => {
 					if (e?.code === "ERR_GET_COMMUNITY_ABORTED") log("Stopped the background refresh of the community cache", this.communityAddress);
-					else log.error("Failed to update cache of community", this.communityAddress, e);
+					else {
+						if (e?.code === "ERR_COMMUNITY_RECORD_NAME_DOES_NOT_MATCH_REQUESTED_NAME") this._pkc._memCaches.communityForPublishing.delete(this.communityAddress);
+						log.error("Failed to update cache of community", this.communityAddress, e);
+					}
 				}).finally(() => {
 					if (this._backgroundCommunityRefresh === refresh) this._backgroundCommunityRefresh = void 0;
 				});
@@ -1605,6 +1535,22 @@ var CommentClientsManager = class extends PublicationClientsManager {
 	_calculatePathForPostCommentUpdate(folderCid, postCid) {
 		return `${folderCid}/` + postCid + "/update";
 	}
+	_logIgnoredNotNewerPostCommentUpdate(log, path, loaded) {
+		const held = this._comment.raw.commentUpdate;
+		log.trace(`Comment ${this._comment.cid} ignored the CommentUpdate at ${path} as not newer than the one it holds`, {
+			loaded: {
+				updatedAt: loaded.updatedAt,
+				replyCount: loaded.replyCount,
+				pageCids: Object.keys(loaded.replies?.pageCids ?? {})
+			},
+			held: {
+				updatedAt: held?.updatedAt,
+				replyCount: held?.replyCount,
+				pageCids: Object.keys(held?.replies?.pageCids ?? {}),
+				lastPostUpdatesPath: this._comment._commentUpdateIpfsPath
+			}
+		});
+	}
 	_bitswapSessionSeedScopeIpnsPubsubTopic() {
 		if (this._communityForUpdating?.community?.ipnsPubsubTopic) return this._communityForUpdating.community.ipnsPubsubTopic;
 		const communityAddress = this._comment.communityAddress;
@@ -1657,7 +1603,8 @@ var CommentClientsManager = class extends PublicationClientsManager {
 					commentUpdate,
 					commentUpdateIpfsPath: path
 				};
-				else return void 0;
+				this._logIgnoredNotNewerPostCommentUpdate(log, path, commentUpdate);
+				return;
 			} catch (e) {
 				this._comment._invalidCommentUpdateMfsPaths.add(path);
 				if (e instanceof PKCError) e.details = {
@@ -1749,7 +1696,8 @@ var CommentClientsManager = class extends PublicationClientsManager {
 					commentUpdate,
 					commentUpdateIpfsPath: path
 				};
-				else return void 0;
+				this._logIgnoredNotNewerPostCommentUpdate(log, path, commentUpdate);
+				return;
 			} catch (e) {
 				if (this._shouldWeFetchCommentUpdateFromNextTimestamp(e)) {
 					attemptedPathsToLoadErrors[path] = e;
@@ -2833,7 +2781,7 @@ var Comment = class extends Publication {
 		logger_default("pkc-js:comment:update:startCommentUpdateCommunitySubscription");
 		if (this.state === "stopped") return;
 		if (this.depth === 0) {
-			if (!this._communityForUpdating) this._communityForUpdating = await this._clientsManager._createCommunityInstanceWithStateTranslation();
+			if (!this._communityForUpdating) this._communityForUpdating = await this._clientsManager._createCommunityInstanceWithStateTranslation({ byPublicKey: true });
 			if (this.state !== "updating") return;
 			if (this._communityForUpdating.community.state === "stopped") await this._communityForUpdating.community.update();
 			if (this.state !== "updating") return;
@@ -3158,7 +3106,10 @@ var Comment = class extends Publication {
 		const existingUpdatingComment = findUpdatingComment(this._pkc, { cid: this.cid });
 		if (existingUpdatingComment) if (existingUpdatingComment === this) if (this._pkc._pkcRpcClient) await this._updateViaRpc();
 		else this.loadCommentIpfsAndStartCommentUpdateSubscription().catch((e) => log.error("Failed to update comment", e));
-		else this._useUpdatingCommentFromPKC(existingUpdatingComment);
+		else {
+			log("Comment", this.cid, "will mirror the existing pkc._updatingComments entry, its state is", existingUpdatingComment.state, "updatingState", existingUpdatingComment.updatingState, "updatedAt", existingUpdatingComment.updatedAt);
+			this._useUpdatingCommentFromPKC(existingUpdatingComment);
+		}
 		else await this._setUpNewUpdatingCommentInstance();
 		if (this.raw.comment || this.raw.commentUpdate) this.emit("update", this);
 	}
@@ -3444,6 +3395,10 @@ const parseRpcSubscriptionIdResult = (result) => RpcSubscriptionIdResultSchema.l
 const parseRpcPublishAnchorRecordParam = (params) => RpcPublishAnchorRecordParamSchema.loose().parse(params);
 const parseRpcAnchorPublishPreparationResult = (result) => RpcAnchorPublishPreparationResultSchema.loose().parse(result);
 const parseRpcPublishedAnchorRecordResult = (result) => RpcPublishedAnchorRecordResultSchema.loose().parse(result);
+const parseRpcPublishCommunityListParam = (params) => RpcPublishCommunityListParamSchema.loose().parse(params);
+const parseRpcPublishCommunityListResult = (result) => RpcPublishCommunityListResultSchema.loose().parse(result);
+const parseRpcFetchCommunityListParam = (params) => RpcFetchCommunityListParamSchema.loose().parse(params);
+const parseRpcFetchCommunityListResult = (result) => RpcFetchCommunityListResultSchema.loose().parse(result);
 const parseRpcExportCommunityParam = (params) => RpcExportCommunityParamSchema.loose().parse(params);
 const parseRpcCancelExportParam = (params) => RpcCancelExportParamSchema.loose().parse(params);
 const parseRpcExportCommunityResult = (result) => RpcExportCommunityResultSchema.loose().parse(result);
@@ -3561,7 +3516,7 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 						})
 					});
 				} catch (e) {
-					const typedError = e;
+					const typedError = e instanceof Error ? e : this._deserializeRpcError(e);
 					typedError.details = {
 						...typedError.details,
 						rpcArgs: args,
@@ -3943,6 +3898,14 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		const parsedFetchCidArgs = parseRpcFetchCidParam(args);
 		return parseRpcFetchCidResult(await this._webSocketClient.call("fetchCid", [parsedFetchCidArgs]));
 	}
+	async publishCommunityList(args) {
+		const parsedArgs = parseRpcPublishCommunityListParam(args);
+		return parseRpcPublishCommunityListResult(await this._webSocketClient.call("publishCommunityList", [parsedArgs]));
+	}
+	async fetchCommunityList(args) {
+		const parsedArgs = parseRpcFetchCommunityListParam(args);
+		return parseRpcFetchCommunityListResult(await this._webSocketClient.call("fetchCommunityList", [parsedArgs]));
+	}
 	async setSettings(settings) {
 		const parsedSettings = parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails(settings);
 		return parseRpcSuccessResult(await this._webSocketClient.call("setSettings", [parsedSettings]));
@@ -8244,6 +8207,325 @@ var CommunityEdit = class extends Publication {
 	}
 };
 //#endregion
+//#region dist/node/community-list/community-list.js
+var CommunityList = class extends import_lib.TypedEmitter {
+	constructor(pkc) {
+		super();
+		this.state = "stopped";
+		this.raw = {};
+		this._pkc = pkc;
+		this.on("error", (...args) => this.listenerCount("error") === 1 && this._pkc.emit("error", ...args));
+	}
+	_initWithCidOnly(cid) {
+		this.cid = cid;
+		this.shortCid = shortifyCid(cid);
+	}
+	_initUnsignedProps({ signer, ...props }) {
+		this.signer = signer;
+		this._unsignedProps = props;
+		this.title = props.title;
+		this.description = props.description;
+		this.timestamp = props.timestamp;
+		this.protocolVersion = props.protocolVersion;
+		this.communities = props.communities.map((entry) => this._buildRuntimeEntry(entry));
+		this.author = this._buildRuntimeAuthor(props.author, signer.publicKey);
+	}
+	_buildRuntimeEntry(entry) {
+		const address = entry.name || entry.publicKey;
+		return {
+			...entry,
+			address,
+			shortAddress: shortifyAddress(address)
+		};
+	}
+	_buildRuntimeAuthor(wireAuthor, signaturePublicKey) {
+		const runtimeAuthor = buildRuntimeAuthor({
+			author: wireAuthor,
+			signaturePublicKey
+		});
+		return {
+			...runtimeAuthor,
+			shortAddress: shortifyAddress(runtimeAuthor.address)
+		};
+	}
+	_initFromWireRecord(record, cid) {
+		this.raw.communityList = record;
+		this.cid = cid;
+		this.shortCid = shortifyCid(cid);
+		this.title = record.title;
+		this.description = record.description;
+		this.timestamp = record.timestamp;
+		this.protocolVersion = record.protocolVersion;
+		this.signature = record.signature;
+		this.communities = record.communities.map((entry) => this._buildRuntimeEntry(entry));
+		const previousNameResolved = this.author?.nameResolved;
+		this.author = this._buildRuntimeAuthor(record.author, record.signature.publicKey);
+		if (typeof previousNameResolved === "boolean") this.author.nameResolved = previousNameResolved;
+		else this._setAuthorNameResolvedFromCache();
+	}
+	_setAuthorNameResolvedFromCache() {
+		const authorDomain = this._authorDomainToSettle();
+		if (!authorDomain || !this.author) return;
+		const cached = this._pkc._memCaches.nameResolvedCache.get(this._nameResolvedCacheKey(authorDomain));
+		if (typeof cached === "boolean") this.author.nameResolved = cached;
+	}
+	toJSON() {
+		return {
+			...this.raw.communityList ?? this._unsignedProps,
+			...this.author ? { author: this.author } : void 0,
+			...this.communities ? { communities: this.communities } : void 0,
+			cid: this.cid,
+			shortCid: this.shortCid
+		};
+	}
+	_setState(newState) {
+		if (this.state === newState) return;
+		this.state = newState;
+		this.emit("statechange", newState);
+	}
+	_throwIfPublishAborted(signal) {
+		if (signal.aborted) throw new PKCError("ERR_COMMUNITY_LIST_PUBLISH_ABORTED", { cid: this.cid });
+	}
+	async publish() {
+		const log = logger_default("pkc-js:community-list:publish");
+		if (!this.signer || !this._unsignedProps) throw new PKCError("ERR_COMMUNITY_LIST_HAS_NO_SIGNER", { cid: this.cid });
+		if (this.state === "publishing") throw new PKCError("ERR_COMMUNITY_LIST_ALREADY_PUBLISHING", {});
+		if (this.state === "updating") throw new PKCError("ERR_COMMUNITY_LIST_ALREADY_UPDATING", {});
+		this._setState("publishing");
+		this._stopAbortController = new AbortController();
+		const signal = this._stopAbortController.signal;
+		try {
+			const cleanedProps = cleanUpBeforePublishing(this._unsignedProps);
+			const signature = await signCommunityList({
+				communityList: cleanedProps,
+				signer: this.signer,
+				pkc: this._pkc
+			});
+			const record = {
+				...cleanedProps,
+				signature
+			};
+			parseCommunityListSchemaWithPKCErrorIfItFails(record);
+			const recordString = JSON.stringify(record);
+			const sizeBytes = await calculateStringSizeSameAsIpfsAddCidV0(recordString);
+			if (sizeBytes > 2097152) throw new PKCError("ERR_COMMUNITY_LIST_OVER_ALLOWED_SIZE", {
+				sizeBytes,
+				maxSizeBytes: MAX_COMMUNITY_LIST_SIZE_BYTES
+			});
+			this._throwIfPublishAborted(signal);
+			let cid;
+			if (this._pkc._pkcRpcClient) {
+				const res = await this._pkc._pkcRpcClient.publishCommunityList({ communityListRawString: recordString });
+				const expectedCid = await calculateIpfsCidV0(recordString);
+				if (res.cid !== expectedCid) throw new PKCError("ERR_ADDED_COMMUNITY_LIST_TO_IPFS_BUT_GOT_DIFFERENT_CID", {
+					expectedCid,
+					cidFromRpcServer: res.cid
+				});
+				cid = res.cid;
+			} else {
+				const addRes = await retryKuboIpfsAddAndProvide({
+					ipfsClient: this._pkc._clientsManager.getDefaultKuboRpcClient()._client,
+					log,
+					content: recordString,
+					addOptions: { pin: true },
+					provideInBackground: true
+				});
+				cid = String(addRes.cid);
+			}
+			this._throwIfPublishAborted(signal);
+			this._initFromWireRecord(record, cid);
+			log(`Published CommunityList (${cid}) with ${record.communities.length} entries`);
+			return cid;
+		} finally {
+			if (this._stopAbortController?.signal === signal) this._setState("stopped");
+		}
+	}
+	async update() {
+		if (this.state === "updating") return;
+		if (this.state === "publishing") throw new PKCError("ERR_COMMUNITY_LIST_ALREADY_PUBLISHING", {});
+		if (!this.cid) throw new PKCError("ERR_COMMUNITY_LIST_HAS_NO_CID", {});
+		this._setState("updating");
+		this._stopAbortController = new AbortController();
+		const signal = this._stopAbortController.signal;
+		this._pkc._updatingCommunityLists.add(this);
+		this._runUpdateLoop(signal);
+	}
+	async _runUpdateLoop(signal) {
+		const log = logger_default("pkc-js:community-list:update");
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		if (signal.aborted) return;
+		try {
+			if (!this.raw.communityList) await this._loadCommunityListIpfsWithRetries(signal);
+			else this.emit("update", this);
+			if (signal.aborted) return;
+			await this._settleAuthorNameResolvedIfNeeded(signal);
+			if (!signal.aborted) await this.stop();
+		} catch (e) {
+			if (signal.aborted) return;
+			log.error(`Failed to update CommunityList (${this.cid})`, e);
+			this.emit("error", e);
+			await this.stop();
+		}
+	}
+	_isNonRetriableError(e) {
+		const { code, details } = e ?? {};
+		if (code === "ERR_FAILED_TO_FETCH_GENERIC_IPFS_FROM_GATEWAYS") {
+			const gatewayErrors = Object.values(details?.gatewayToError ?? {});
+			return gatewayErrors.length > 0 && gatewayErrors.every((gatewayError) => this._isNonRetriableError(gatewayError));
+		}
+		return typeof code === "string" && [
+			"ERR_INVALID_JSON",
+			"ERR_INVALID_COMMUNITY_LIST_SCHEMA",
+			"ERR_COMMUNITY_LIST_SIGNATURE_IS_INVALID",
+			"ERR_OVER_DOWNLOAD_LIMIT",
+			"ERR_CALCULATED_CID_DOES_NOT_MATCH"
+		].includes(code);
+	}
+	async _loadCommunityListIpfsWithRetries(outerSignal) {
+		if (this.raw.communityList) return;
+		const cid = this.cid;
+		if (!cid) throw new PKCError("ERR_COMMUNITY_LIST_HAS_NO_CID", {});
+		const abortController = new AbortController();
+		const operation = import_retry.operation({
+			forever: true,
+			factor: 2
+		});
+		this._loadingAbortController = abortController;
+		this._loadingOperation = operation;
+		const signal = abortController.signal;
+		const onOuterAbort = () => abortController.abort(outerSignal?.reason);
+		outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
+		try {
+			const record = await new Promise((resolve, reject) => {
+				const rejectOnAbort = () => reject(signal.reason || /* @__PURE__ */ new Error("Aborted loading CommunityList"));
+				signal.addEventListener("abort", rejectOnAbort, { once: true });
+				operation.attempt(async () => {
+					if (signal.aborted) return rejectOnAbort();
+					try {
+						resolve(await this._fetchAndVerifyOnce(cid, signal));
+					} catch (e) {
+						if (signal.aborted || this._isNonRetriableError(e)) return reject(e);
+						this.emit("error", e);
+						operation.retry(e);
+					}
+				});
+			});
+			if (signal.aborted) return;
+			this._initFromWireRecord(record, cid);
+			this.emit("update", this);
+		} finally {
+			operation.stop();
+			outerSignal?.removeEventListener("abort", onOuterAbort);
+			if (this._loadingOperation === operation) this._loadingOperation = void 0;
+			if (this._loadingAbortController === abortController) this._loadingAbortController = void 0;
+		}
+	}
+	async _fetchAndVerifyOnce(cid, signal) {
+		let rawString;
+		if (this._pkc._pkcRpcClient) {
+			rawString = (await this._pkc._pkcRpcClient.fetchCommunityList({ cid })).communityListRawString;
+			const sizeBytes = calculateStringSizeSameAsIpfsAddCidV0Sync(rawString);
+			if (sizeBytes > 2097152) throw new PKCError("ERR_OVER_DOWNLOAD_LIMIT", {
+				cid,
+				sizeBytes,
+				maxSizeBytes: MAX_COMMUNITY_LIST_SIZE_BYTES
+			});
+			const calculatedCid = await calculateIpfsCidV0(rawString);
+			if (calculatedCid !== cid) throw new PKCError("ERR_CALCULATED_CID_DOES_NOT_MATCH", {
+				calculatedCid,
+				cid
+			});
+		} else rawString = await this._pkc._clientsManager.fetchCid(cid, {
+			maxFileSizeBytes: MAX_COMMUNITY_LIST_SIZE_BYTES,
+			abortSignal: signal
+		});
+		const record = parseCommunityListSchemaWithPKCErrorIfItFails(parseJsonWithPKCErrorIfFails(rawString));
+		const validity = await verifyCommunityList({ communityList: record });
+		if (!validity.valid) throw new PKCError("ERR_COMMUNITY_LIST_SIGNATURE_IS_INVALID", {
+			validity,
+			cid
+		});
+		return record;
+	}
+	_authorDomainToSettle() {
+		const wireAuthorName = this.raw.communityList?.author?.name;
+		if (typeof wireAuthorName !== "string" || !isStringDomain(wireAuthorName)) return void 0;
+		return wireAuthorName;
+	}
+	_nameResolvedCacheKey(authorDomain) {
+		return (0, import_sha256.sha256)(authorDomain + this.raw.communityList.signature.publicKey);
+	}
+	async _resolveAuthorNameVerdictOnce(authorDomain) {
+		const cache = this._pkc._memCaches.nameResolvedCache;
+		const cacheKey = this._nameResolvedCacheKey(authorDomain);
+		const cached = cache.get(cacheKey);
+		if (typeof cached === "boolean") return cached;
+		try {
+			const { resolvedAuthorName } = await this._pkc.resolveAuthorName({ name: authorDomain });
+			const ttlOf = (verdict) => verdict ? this._pkc._nameResolvedTrueTtlMs : this._pkc._nameResolvedFalseTtlMs;
+			if (typeof resolvedAuthorName !== "string") {
+				cache.set(cacheKey, false, { ttl: ttlOf(false) });
+				return false;
+			}
+			const verdict = resolvedAuthorName === getPKCAddressFromPublicKeySync(this.raw.communityList.signature.publicKey);
+			cache.set(cacheKey, verdict, { ttl: ttlOf(verdict) });
+			return verdict;
+		} catch (e) {
+			const code = e?.code;
+			if (code === "ERR_RESOLVED_TEXT_RECORD_TO_NON_IPNS") {
+				cache.set(cacheKey, false, { ttl: this._pkc._nameResolvedFalseTtlMs });
+				return false;
+			}
+			if (code === "ERR_NO_RESOLVER_FOR_NAME") return false;
+			return;
+		}
+	}
+	_kickOffBackgroundAuthorNameResolution() {
+		const log = logger_default("pkc-js:community-list:resolve-author-name");
+		const authorDomain = this._authorDomainToSettle();
+		if (!authorDomain || !this._pkc.resolveAuthorNames) return;
+		this._resolveAuthorNameVerdictOnce(authorDomain).catch((e) => log.error("Failed background author name resolution", authorDomain, e));
+	}
+	async _settleAuthorNameResolvedIfNeeded(signal) {
+		const authorDomain = this._authorDomainToSettle();
+		if (!authorDomain || !this.author || !this._pkc.resolveAuthorNames) return;
+		let attempt = 0;
+		while (!signal.aborted) {
+			const verdict = await this._resolveAuthorNameVerdictOnce(authorDomain);
+			if (signal.aborted) return;
+			if (typeof verdict === "boolean") {
+				this.author.nameResolved = verdict;
+				this.emit("update", this);
+				return;
+			}
+			attempt++;
+			await this._delayWithAbort(Math.min(1e3 * 2 ** attempt, 6e4), signal);
+		}
+	}
+	async _delayWithAbort(ms, signal) {
+		if (signal.aborted) return;
+		await new Promise((resolve) => {
+			const timeout = setTimeout(() => {
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			}, ms);
+			const onAbort = () => {
+				clearTimeout(timeout);
+				resolve();
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		});
+	}
+	async stop() {
+		this._pkc._updatingCommunityLists.delete(this);
+		this._stopAbortController?.abort();
+		this._loadingAbortController?.abort();
+		this._loadingOperation?.stop();
+		if (this.state === "stopped") return;
+		this._setState("stopped");
+	}
+};
+//#endregion
 //#region dist/node/pkc/pkc.js
 var PKC$1 = class extends PKCTypedEmitter {
 	constructor(options) {
@@ -8253,6 +8535,7 @@ var PKC$1 = class extends PKCTypedEmitter {
 		this._updatingComments = new TrackedInstanceRegistry();
 		this._startedCommunities = new TrackedInstanceRegistry();
 		this._publishingPublications = /* @__PURE__ */ new Set();
+		this._updatingCommunityLists = /* @__PURE__ */ new Set();
 		this.destroyed = false;
 		this._storageLRUs = {};
 		this._nameResolvedFalseTtlMs = NAME_RESOLVED_FALSE_TTL_MS;
@@ -8386,7 +8669,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-DfpR6JSl.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-vQZvQcs_.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -8506,6 +8789,88 @@ var PKC$1 = class extends PKCTypedEmitter {
 			await comment.stop();
 		}
 	}
+	async createCommunityList(options) {
+		if (options && typeof options === "object" && "cid" in options) {
+			const parseRes = CreateCommunityListWithCidOptionsSchema.safeParse(options);
+			if (!parseRes.success) throw new PKCError("ERR_INVALID_CREATE_COMMUNITY_LIST_OPTIONS_SCHEMA", {
+				zodError: parseRes.error,
+				options
+			});
+			const communityList = new CommunityList(this);
+			communityList._initWithCidOnly(parseRes.data.cid);
+			return communityList;
+		}
+		const parseRes = CreateNewCommunityListOptionsSchema.safeParse(options);
+		if (!parseRes.success) throw new PKCError("ERR_INVALID_CREATE_COMMUNITY_LIST_OPTIONS_SCHEMA", {
+			zodError: parseRes.error,
+			options
+		});
+		const parsedOptions = parseRes.data;
+		const signer = await this.createSigner(parsedOptions.signer);
+		const cleanedAuthor = cleanWireAuthor(normalizeCreatePublicationAuthor(parsedOptions.author));
+		const communityList = new CommunityList(this);
+		communityList._initUnsignedProps({
+			signer,
+			title: parsedOptions.title,
+			description: parsedOptions.description,
+			author: cleanedAuthor,
+			communities: parsedOptions.communities,
+			timestamp: typeof parsedOptions.timestamp === "number" ? parsedOptions.timestamp : timestamp(),
+			protocolVersion: parsedOptions.protocolVersion || version_default.PROTOCOL_VERSION
+		});
+		return communityList;
+	}
+	async getCommunityList(getCommunityListArgs) {
+		const { abortSignal, ...cidArgs } = getCommunityListArgs;
+		const parseRes = CreateCommunityListWithCidOptionsSchema.safeParse(cidArgs);
+		if (!parseRes.success) throw new PKCError("ERR_INVALID_CREATE_COMMUNITY_LIST_OPTIONS_SCHEMA", {
+			zodError: parseRes.error,
+			getCommunityListArgs
+		});
+		const cid = parseRes.data.cid;
+		if (abortSignal?.aborted) throw new PKCError("ERR_GET_COMMUNITY_LIST_ABORTED", {
+			cid,
+			abortReason: abortSignal.reason
+		});
+		const communityList = await this.createCommunityList(parseRes.data);
+		let lastUpdateError;
+		const errorListener = (err) => lastUpdateError = err;
+		communityList.on("error", errorListener);
+		let abortError;
+		let abortReject;
+		const abortListener = () => {
+			abortError = new PKCError("ERR_GET_COMMUNITY_LIST_ABORTED", {
+				cid,
+				abortReason: abortSignal?.reason,
+				lastUpdateError
+			});
+			abortReject?.(abortError);
+		};
+		const abortPromise = new Promise((_, reject) => {
+			abortReject = reject;
+		});
+		abortPromise.catch(() => {});
+		abortSignal?.addEventListener("abort", abortListener);
+		const timeoutMs = this._timeouts["generic-ipfs"];
+		const timeoutError = new TimeoutError(`pkc.getCommunityList({cid: ${cid}}) timed out after ${timeoutMs}ms`);
+		try {
+			await pTimeout(Promise.race([communityList._loadCommunityListIpfsWithRetries(abortSignal), abortPromise]), {
+				milliseconds: timeoutMs,
+				message: timeoutError
+			});
+			if (!communityList.signature) throw Error("Failed to load CommunityList");
+			communityList._kickOffBackgroundAuthorNameResolution();
+			return communityList;
+		} catch (e) {
+			if (abortError) throw abortError;
+			if (e === timeoutError && lastUpdateError) throw lastUpdateError;
+			throw e;
+		} finally {
+			abortSignal?.removeEventListener("abort", abortListener);
+			communityList.removeListener("error", errorListener);
+			await communityList.stop();
+		}
+	}
 	async _initMissingFieldsOfPublicationBeforeSigning(pubOptions, log) {
 		const finalOptions = t$4(pubOptions);
 		if (!finalOptions.signer) throw Error("User did not provide a signer to create a local publication");
@@ -8668,7 +9033,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-CQ9M4cEY.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-dcM1R3k5.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {
@@ -9053,6 +9418,8 @@ var PKC$1 = class extends PKCTypedEmitter {
 		await Promise.all([...this._publishingPublications].map((publication) => publication.stop().catch((e) => log.error("Error stopping publication during destroy", e))));
 		this._publishingPublications.clear();
 		for (const comment of listUpdatingComments(this)) await comment.stop();
+		for (const communityList of [...this._updatingCommunityLists]) await communityList.stop().catch((e) => log.error("Error stopping CommunityList during destroy", e));
+		this._updatingCommunityLists.clear();
 		for (const community of listUpdatingCommunities(this)) await community.stop();
 		await Promise.all(listStartedCommunities(this).map((community) => community.stop()));
 		if (this._communityFsWatchAbort) this._communityFsWatchAbort.abort();
@@ -9251,4 +9618,4 @@ const challenges = PKC.challenges;
 const pageSorts = PKC.pageSorts;
 const createAnchorIpnsRecord = PKC.createAnchorIpnsRecord;
 //#endregion
-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 };
+export { parseRpcUnsubscribeParam as S, parseRpcExportCommunityParam as _, getShortCid as a, parseRpcPublishChallengeAnswersParam 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, parseRpcFetchCommunityListParam as v, parseRpcPublishCommunityListParam as x, parseRpcPublishAnchorRecordParam as y };