@pkcprotocol/pkc-js 0.0.116 → 0.0.118

package/dist/bundled/chunks/{local-community-nSmHRx5s.js → local-community-DvEh9Nte.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $t as CommentModerationPubsubMessagePublicationSchema, A as isLinkOfAnimatedImage, An as CommentIpfsSchema, Ar as PKCError, At as ChallengeMessageSchema, Bn as CommentUpdateTableRowSchema, Dn as VoteTablesRowSchema, Dt as pTimeout, F as isLinkValid, Gr as ZodError, Jn as CommentEditPubsubMessagePublicationSchema, Jt as CommunityEditPublicationPubsubReservedFields, K as removeNullUndefinedValues, Kt as version_default, Lt as DecryptedChallengeRequestPublicationSchema, M as isLinkOfImage, Mr as logger_default, Mt as ChallengeRequestMessageSchema, N as isLinkOfMedia, Ot as ChallengeAnswerMessageSchema, P as isLinkOfVideo, Pt as ChallengeVerificationMessageSchema, Q as retryKuboIpfsAddAndProvide, Qn as CommentEditsTableRowSchema, R as pubsubTopicToDhtKey, Rn as CommentUpdateSchema, Rt as DecryptedChallengeRequestSchema, S as hideClassPrivateProps, Sr as t$2, St as untrackStartedCommunity, Tn as VotePubsubReservedFields, Tt as require_sha256, U as removeBlocksFromKuboNode, Vn as CommentsTableRowSchema, W as removeMfsFilesSafely, X as retryKuboBlockPutPinAndProvidePubsubTopic, Xn as CommentEditReservedFields, Yn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, _ as getEquivalentCommunityAddresses, _r as r$1, a as calculateUnixFsDagSizeCidV0, c as contentContainsMarkdownVideos, ct as writeKuboFilesWithTimeout, d as derivePublicationFromChallengeRequest, dn as CommunityIpfsSchema, dr as n$2, en as CommentModerationReservedFields, f as doesDomainAddressHaveCapitalLetter, fn as CommunitySignedPropertyNames, fr as t$5, ft as findUpdatingCommunity, g as genToArray, h as findMalformedUnicodeString, hr as e, i as calculateStringSizeSameAsIpfsAddCidV0, it as timestamp, j as isLinkOfAudio, jn as CommentPubsubMessageReservedFields, jr as messages, lr as n$3, lt as findCommunityInRegistry, mr as e$1, nn as CommentModerationsTableRowSchema, nr as AuthorReservedFields, nt as statMfsPathSafely, o as contentContainsMarkdownAudio, ot as withSortedKeys, pr as t$6, r as calculateIpfsCidV0, s as contentContainsMarkdownImages, st as withSortedKeysDeep, t as areEquivalentCommunityAddresses, tt as sleepUntilTimeoutOrAbort, ur as t$7, ut as findStartedCommunity, v as getErrorCodeFromMessage, vr as t$3, vt as syncCommunityRegistryEntry, w as ipnsNameToIpnsOverPubsubTopic, wn as VotePubsubMessagePublicationSchema, wr as require_retry, wt as untrackUpdatingCommunity, xn as isStringDomain, xr as t$4, xt as trackUpdatingCommunity, y as getIpnsRecordInLocalKuboNode, yt as trackStartedCommunity } from "./util-vJMTa4rC.js";
-import { $n as calculateExpectedSignatureSize, $t as SignerWithPublicKeyAddress, A as iterateOverPageCidsToFindAllCids, An as verifyCommunityEdit, Ar as require_lodash_merge, C as TIMEFRAMES_TO_SECONDS, Cr as t$9, Dn as verifyCommentPubsubMessage, En as verifyCommentModeration, Fn as getAuthorNameFromWire, Gn as encode, H as pLimit, Hn as getCommunityPublicKeyFromWire, J as coerceSchemaRowBoolean, Jn as getPKCAddressFromPublicKey, Ln as crosspostChainDepthUpTo, Mn as buildRuntimeAuthor, Nn as cleanWireAuthor, On as verifyCommentUpdate, Qn as backupCommunityDb, Rn as effectiveMaxCrosspostDepth, Sn as verifyChallengeRequest, Tn as verifyCommentIpfs, Vn as getCommunityNameFromWire, Wn as decode, X as collectSchemaRowCoercions, Xn as getPublicKeyFromPrivateKey, Y as coerceSchemaRowJson, Yn as getPKCAddressFromPublicKeySync, Z as createSchemaRowParser, Zn as BackupAbortError, _ as TrackedInstanceRegistry, _n as signCommunity, _r as t$11, a as generatePagesReportingFailedSorts, an as encryptEd25519AesGcmPublicKeyBuffer, ar as deriveDbReplies, b as MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS, bn as verifyChallengeAnswer, br as n$5, c as resolvePageSortsOrThrow, cr as getThumbnailPropsOfLink, d as getCommunityChallengeFromCommunityChallengeSettings, dn as signChallengeVerification, dt as parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails, er as calculateInlineRepliesBudget, f as loadChallengeFileFromCommunityChallengeSettings, fn as signComment, fr as moveCommunityDbToDeletedDirectory, g as createAuthorIdentityMatcher, gn as signCommentUpdateForChallengeVerification, gr as t$10, h as authorNameResolveFailureReason, hn as signCommentUpdate, i as derivePublicPageSorts, ir as deriveDbPosts, jn as verifyVote, kn as verifyCommunity, kr as STORAGE_KEYS, ln as signChallengeMessage, lr as importSignerIntoKuboNode, lt as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, m as authorIdentityMatcherForRequest, nr as deleteOldCommunityInWindows, o as loadPageSortsForStartedCommunity, on as _validateSignatureOfPKCRecord, or as getDefaultCommunityDbConfig, p as pkcJsChallenges, pn as signCommentEdit, pr as resolveDbPostsCidRefs, qn as getIpfsKeyFromPrivateKey, r as computePageSortsFingerprint, rn as decryptEd25519AesGcmPublicKeyBuffer, rr as deriveCommentIpfsFromCommentTableRow, s as lookupPageSortFactories, sn as cleanUpBeforePublishing, t as RpcLocalCommunity, u as getChallengeVerification, v as LRUCache, vr as r$2, wn as verifyCommentEdit, wr as stringify, wt as parseJsonWithPKCErrorIfFails, x as KeyvBetterSqlite3, xr as n$4, xt as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, yr as t$8 } from "./rpc-local-community-DfJ3wj-p.js";
-import { a as scorePageCommentsWithFile, i as partitionPageCommentsForSort, n as filterRepliesForPageSort, o as stripRepliesFromPageComment, r as orderPageCommentsByScore, t as createDescendantsLookup } from "./page-sort-scoring-Bj73WnwW.js";
+import { $t as CommentModerationPubsubMessagePublicationSchema, A as isLinkOfAnimatedImage, An as CommentIpfsSchema, Ar as PKCError, At as ChallengeMessageSchema, Bn as CommentUpdateTableRowSchema, Dn as VoteTablesRowSchema, Dt as pTimeout, F as isLinkValid, Gr as ZodError, Jn as CommentEditPubsubMessagePublicationSchema, Jt as CommunityEditPublicationPubsubReservedFields, K as removeNullUndefinedValues, Kt as version_default, Lt as DecryptedChallengeRequestPublicationSchema, M as isLinkOfImage, Mr as logger_default, Mt as ChallengeRequestMessageSchema, N as isLinkOfMedia, Ot as ChallengeAnswerMessageSchema, P as isLinkOfVideo, Pt as ChallengeVerificationMessageSchema, Q as retryKuboIpfsAddAndProvide, Qn as CommentEditsTableRowSchema, R as pubsubTopicToDhtKey, Rn as CommentUpdateSchema, Rt as DecryptedChallengeRequestSchema, S as hideClassPrivateProps, Sr as t$2, St as untrackStartedCommunity, Tn as VotePubsubReservedFields, Tt as require_sha256, U as removeBlocksFromKuboNode, Vn as CommentsTableRowSchema, W as removeMfsFilesSafely, X as retryKuboBlockPutPinAndProvidePubsubTopic, Xn as CommentEditReservedFields, Yn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, _ as getEquivalentCommunityAddresses, _r as r$1, a as calculateUnixFsDagSizeCidV0, c as contentContainsMarkdownVideos, ct as writeKuboFilesWithTimeout, d as derivePublicationFromChallengeRequest, dn as CommunityIpfsSchema, dr as n$2, en as CommentModerationReservedFields, f as doesDomainAddressHaveCapitalLetter, fn as CommunitySignedPropertyNames, fr as t$5, ft as findUpdatingCommunity, g as genToArray, h as findMalformedUnicodeString, hr as e, i as calculateStringSizeSameAsIpfsAddCidV0, it as timestamp, j as isLinkOfAudio, jn as CommentPubsubMessageReservedFields, jr as messages, lr as n$3, lt as findCommunityInRegistry, mr as e$1, nn as CommentModerationsTableRowSchema, nr as AuthorReservedFields, nt as statMfsPathSafely, o as contentContainsMarkdownAudio, ot as withSortedKeys, pr as t$6, r as calculateIpfsCidV0, s as contentContainsMarkdownImages, st as withSortedKeysDeep, t as areEquivalentCommunityAddresses, tt as sleepUntilTimeoutOrAbort, ur as t$7, ut as findStartedCommunity, v as getErrorCodeFromMessage, vr as t$3, vt as syncCommunityRegistryEntry, w as ipnsNameToIpnsOverPubsubTopic, wn as VotePubsubMessagePublicationSchema, wr as require_retry, wt as untrackUpdatingCommunity, xn as isStringDomain, xr as t$4, xt as trackUpdatingCommunity, y as getIpnsRecordInLocalKuboNode, yt as trackStartedCommunity } from "./util-DEmcezee.js";
+import { $n as backupCommunityDb, An as verifyCommunity, Ar as STORAGE_KEYS, Cn as verifyChallengeRequest, Dn as verifyCommentModeration, En as verifyCommentIpfs, Gn as decode, Hn as getCommunityNameFromWire, In as getAuthorNameFromWire, Jn as getIpfsKeyFromPrivateKey, Kn as encode, Mn as verifyVote, Nn as buildRuntimeAuthor, On as verifyCommentPubsubMessage, Pn as cleanWireAuthor, Q as createSchemaRowParser, Qn as BackupAbortError, Rn as crosspostChainDepthUpTo, S as KeyvBetterSqlite3, Sr as n$4, St as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Tn as verifyCommentEdit, Tr as stringify, Tt as parseJsonWithPKCErrorIfFails, U as pLimit, Un as getCommunityPublicKeyFromWire, X as coerceSchemaRowJson, Xn as getPKCAddressFromPublicKeySync, Y as coerceSchemaRowBoolean, Yn as getPKCAddressFromPublicKey, Z as collectSchemaRowCoercions, Zn as getPublicKeyFromPrivateKey, _ as createAuthorIdentityMatcher, _n as signCommentUpdateForChallengeVerification, _r as t$10, a as generatePagesReportingFailedSorts, ar as deriveDbPosts, br as t$8, c as resolvePageSortsOrThrow, cn as cleanUpBeforePublishing, d as getChallengeVerification, en as SignerWithPublicKeyAddress, er as calculateExpectedSignatureSize, f as getCommunityChallengeFromCommunityChallengeSettings, fn as signChallengeVerification, ft as parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails, g as authorNameResolveFailureReason, gn as signCommentUpdate, h as authorIdentityMatcherForRequest, i as derivePublicPageSorts, in as decryptEd25519AesGcmPublicKeyBuffer, ir as deriveCommentIpfsFromCommentTableRow, j as iterateOverPageCidsToFindAllCids, jn as verifyCommunityEdit, jr as require_lodash_merge, kn as verifyCommentUpdate, lr as getThumbnailPropsOfLink, m as pkcJsChallenges, mn as signCommentEdit, mr as resolveDbPostsCidRefs, o as loadPageSortsForStartedCommunity, on as encryptEd25519AesGcmPublicKeyBuffer, or as deriveDbReplies, p as loadChallengeFileFromCommunityChallengeSettings, pn as signComment, pr as moveCommunityDbToDeletedDirectory, r as computePageSortsFingerprint, rr as deleteOldCommunityInWindows, s as lookupPageSortFactories, sn as _validateSignatureOfPKCRecord, sr as getDefaultCommunityDbConfig, t as RpcLocalCommunity, tr as calculateInlineRepliesBudget, u as deriveCommunityChallengesOrThrow, un as signChallengeMessage, ur as importSignerIntoKuboNode, ut as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, v as TrackedInstanceRegistry, vn as signCommunity, vr as t$11, w as TIMEFRAMES_TO_SECONDS, wr as t$9, x as MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS, xn as verifyChallengeAnswer, xr as n$5, y as LRUCache, yr as r$2, zn as effectiveMaxCrosspostDepth } from "./rpc-local-community-DqKbZLIy.js";
+import { a as scorePageCommentsWithFile, i as partitionPageCommentsForSort, n as filterRepliesForPageSort, o as stripRepliesFromPageComment, r as orderPageCommentsByScore, t as createDescendantsLookup } from "./page-sort-scoring-C1XYRQ1w.js";
 import { randomFillSync, randomUUID } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
@@ -1660,6 +1660,7 @@ async function collectChallengeSettingsValidationFailures({ challengeSettings, p
 			challengeSettings: communityChallengeSettings,
 			challengeFile: await loadChallengeFileFromCommunityChallengeSettings({
 				communityChallengeSettings,
+				challengeIndex,
 				pkc
 			}),
 			challengeIndex
@@ -2493,8 +2494,9 @@ async function createNewLocalCommunityDb(community) {
 		pkc: community._pkc,
 		communityAddress: community.address
 	});
-	community.challenges = await Promise.all(community.settings.challenges.map(async (cs) => (await getCommunityChallengeFromCommunityChallengeSettings({
+	community.challenges = await Promise.all(community.settings.challenges.map(async (cs, challengeIndex) => (await getCommunityChallengeFromCommunityChallengeSettings({
 		communityChallengeSettings: cs,
+		challengeIndex,
 		pkc: community._pkc
 	})).communityChallenge));
 	community._pageSorts = await resolvePageSortsOrThrow({
@@ -5904,6 +5906,7 @@ async function purgeDisapprovedCommentsOlderThan(community) {
 }
 //#endregion
 //#region dist/node/runtime/node/community/local-community/challenges.js
+const describeMisconfiguredChallenge = (e) => e instanceof PKCError && e.code === "ERR_CHALLENGE_NOT_REGISTERED" ? `challenge "${e.details.challengeName}" is not registered on this node` : e.message;
 function cleanUpChallengeAnswerPromise(community, challengeRequestIdString) {
 	community._challengeAnswerPromises.delete(challengeRequestIdString);
 	community._challengeAnswerResolveReject.delete(challengeRequestIdString);
@@ -6335,7 +6338,7 @@ async function runChallengeExchangeIfNeeded(community, parsed, log) {
 		community.emit("error", e);
 		challengeVerification = {
 			challengeSuccess: false,
-			reason: `One of the community challenges is misconfigured: ${e.message}`
+			reason: `One of the community challenges is misconfigured: ${describeMisconfiguredChallenge(e)}`
 		};
 	}
 	return challengeVerification;
@@ -7354,14 +7357,26 @@ async function syncChallengesWithRegistry(community) {
 	if (!Array.isArray(challengeSettings)) return;
 	let challenges;
 	try {
-		challenges = await Promise.all(challengeSettings.map(async (cs) => (await getCommunityChallengeFromCommunityChallengeSettings({
-			communityChallengeSettings: cs,
-			pkc: community._pkc
-		})).communityChallenge));
+		challenges = await deriveCommunityChallengesOrThrow({
+			challengeSettings,
+			pkc: community._pkc,
+			communityAddress: community.address
+		});
 	} catch (e) {
 		log.error("Could not recompute community.challenges from the registry, keeping the previous ones", community.address, e);
+		const reported = stringify(e.details?.failures?.map((f) => [
+			f.challengeIndex,
+			f.challengeName,
+			f.path,
+			f.error.code
+		]) ?? String(e));
+		if (reported !== community._reportedChallengeLoadFailures) {
+			community._reportedChallengeLoadFailures = reported;
+			community.emit("error", e);
+		}
 		return;
 	}
+	community._reportedChallengeLoadFailures = void 0;
 	if (stringify(challenges) === stringify(community.challenges ?? null)) return;
 	log("community.challenges changed in the registry, republishing", community.address);
 	community.challenges = challenges;
@@ -7821,6 +7836,11 @@ async function start(community) {
 			anchorPublicKey: community.anchor.publicKey,
 			minterAddress: community.signer.address
 		});
+		await deriveCommunityChallengesOrThrow({
+			challengeSettings: community.settings?.challenges ?? [],
+			pkc: community._pkc,
+			communityAddress: community.address
+		});
 		community._setState("started");
 		await community._updateStartedValue();
 		await community._dbHandler.lockCommunityStart();
@@ -7832,6 +7852,11 @@ async function start(community) {
 		await updateInstanceStateWithDbState(community);
 		await community._loadExportsFromKeyv();
 		await setChallengesToDefaultIfNotDefined(community, log);
+		community.challenges = await deriveCommunityChallengesOrThrow({
+			challengeSettings: community.settings.challenges,
+			pkc: community._pkc,
+			communityAddress: community.address
+		});
 		await importCommunitySignerIntoIpfsIfNeeded(community);
 		await providePubsubTopicRoutingCidsIfNeeded(community, true);
 		await reprovideAnchorRecordIfNeeded(community).catch((e) => log.error("Failed to re-provide the anchor record on start", e));
@@ -7840,10 +7865,6 @@ async function start(community) {
 		await community._repinCommentsIPFSIfNeeded();
 		await repinCommentUpdateIfNeeded(community);
 		await community._listenToIncomingRequests();
-		community.challenges = await Promise.all(community.settings.challenges.map(async (cs) => (await getCommunityChallengeFromCommunityChallengeSettings({
-			communityChallengeSettings: cs,
-			pkc: community._pkc
-		})).communityChallenge));
 		await emitChallengeSettingsValidationErrors(community, log);
 		community._pageSorts = void 0;
 		community._pageSortFactories = void 0;
@@ -8172,8 +8193,9 @@ async function parseChallengesToEdit(community, newChallengeSettings) {
 		communityAddress: community.address
 	});
 	return {
-		challenges: await Promise.all(newChallengeSettings.map(async (cs) => (await getCommunityChallengeFromCommunityChallengeSettings({
+		challenges: await Promise.all(newChallengeSettings.map(async (cs, challengeIndex) => (await getCommunityChallengeFromCommunityChallengeSettings({
 			communityChallengeSettings: cs,
+			challengeIndex,
 			pkc: community._pkc
 		})).communityChallenge)),
 		_usingDefaultChallenge: isDefaultChallengeStructure(newChallengeSettings)
@@ -8534,6 +8556,7 @@ var LocalCommunity = class extends RpcLocalCommunity {
 		this._combinedHashOfPendingCommentsCids = (0, import_sha256.sha256)("");
 		this._pageSorts = void 0;
 		this._pageSortFactories = void 0;
+		this._reportedChallengeLoadFailures = void 0;
 		this._publishLoopPromise = void 0;
 		this._updateLoopPromise = void 0;
 		this._firstUpdateAfterStart = true;

package/dist/bundled/chunks/{local-community-Cm4X7RjW.js → local-community-YoJAmva8.js}

@@ -1,2 +1,2 @@
-import { n as createNewLocalCommunityDb, r as updateInstancePropsWithStartedCommunityOrDb, t as LocalCommunity } from "./local-community-nSmHRx5s.js";
+import { n as createNewLocalCommunityDb, r as updateInstancePropsWithStartedCommunityOrDb, t as LocalCommunity } from "./local-community-DvEh9Nte.js";
 export { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb };

package/dist/bundled/chunks/{node-CaeXEQ5O.js → node-CH9-YjYa.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.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-vJMTa4rC.js";
-import { An as verifyCommunityEdit, At as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, B as InflightResourceTypes, Bn as getCommunityAddressFromRecord, Bt as RpcExportCommunityModLogsResultSchema, Cn as verifyChallengeVerification, Cr as t$4, Ct as parseDecryptedChallengeWithPKCErrorIfItFails, D as findCommentInPageInstance, Dn as verifyCommentPubsubMessage, Dr as NAME_RESOLVED_TRUE_TTL_MS, Dt as parseRpcCommentUpdateEventWithPKCErrorIfItFails, E as extractCommunityRuntimeFieldsFromParsedPages, En as verifyCommentModeration, Er as NAME_RESOLVED_FALSE_TTL_MS, Et as parseRpcCommentEventWithPKCErrorIfItFails, Ft as RpcCommentRepliesPageParamSchema, G as decodeRpcChallengePubsubMsg, Gt as RpcPublishAnchorRecordParamSchema, Hn as getCommunityPublicKeyFromWire, Ht as RpcExportCommunityResultSchema, I as stripNameResolvedFromCrosspost, In as normalizeCreatePublicationAuthor, It as RpcCommunityIdentifierParamSchema, Jt as RpcResolveAuthorNameResultSchema, K as decodeRpcChallengeRequestPubsubMsg, Kn as getBufferedPKCAddressFromPublicKey, Kt as RpcPublishChallengeAnswersParamSchema, L as PKCClientsManager, Lt as RpcCommunityPageParamSchema, M as applyNameResolvedCacheToCrosspost, Mn as buildRuntimeAuthor, Mr as require_undici, Mt as RpcAuthorNameParamSchema, N as cloneCrosspostForRuntime, Nn as cleanWireAuthor, Nt as RpcCancelExportParamSchema, O as findCommentInPageInstanceRecursively, On as verifyCommentUpdate, Or as NAME_RESOLVE_FAILED_RETRY_FLOOR_MS, Ot as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, P as collectCrosspostAuthorsToResolve, Pn as getAuthorNameFromRuntime, Pt as RpcCidParamSchema, Q as parseCidStringSchemaWithPKCErrorIfItFails, Qt as require_lib$1, R as GenericStateClient, Rt as RpcEditCommunityParamSchema, S as RepliesPages, Sr as t$2, St as parseDecryptedChallengeVerification, Tn as verifyCommentIpfs, Tr as MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE, Tt as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, U as PKCTypedEmitter, Un as normalizeCommunityInputFromCommunity, Ut as RpcFetchCidParamSchema, Vn as getCommunityNameFromWire, Vt as RpcExportCommunityParamSchema, W as decodeRpcChallengeAnswerPubsubMsg, Wn as decode, Wt as RpcFetchCidResultSchema, Xt as RpcSuccessResultSchema, Yn as getPKCAddressFromPublicKeySync, Yt as RpcSubscriptionIdResultSchema, Zt as RpcUnsubscribeParamSchema, _ as TrackedInstanceRegistry, at as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, br as n$3, bt as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, cn as signChallengeAnswer, dr as monitorCommunitiesDirectory, en as createSigner, fn as signComment, ft as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, gr as t$5, hr as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, ht as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, in as encryptEd25519AesGcm, it as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, j as parseRawPages, jn as verifyVote, jr as nativeFunctions$2, jt as RpcAnchorPublishPreparationResultSchema, k as findCommentInParsedPages, l as pkcJsPageSorts, mn as signCommentModeration, mr as setNativeFunctions$1, mt as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, n as RpcRemoteCommunity, nn as decryptEd25519AesGcm, nt as parseCommentIpfsSchemaWithPKCErrorIfItFails, ot as parseCommentUpdateSchemaWithPKCErrorIfItFails, p as pkcJsChallenges, pn as signCommentEdit, pt as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, q as decodeRpcChallengeVerificationPubsubMsg, qt as RpcPublishedAnchorRecordResultSchema, sn as cleanUpBeforePublishing, sr as getDefaultDataPath, st as parseCommunityAddressWithPKCErrorIfItFails, t as RpcLocalCommunity, tn as createAnchorIpnsRecord$1, tr as createKuboRpcClient, tt as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, un as signChallengeRequest, ur as listCommunitiesSync, ut as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, v as LRUCache, vn as signCommunityEdit, vt as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, wn as verifyCommentEdit, wt as parseJsonWithPKCErrorIfFails, x as KeyvBetterSqlite3, xn as verifyChallengeMessage, xt as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, y as RemoteCommunity, yn as signVote, yr as t$3, yt as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, z as InflightFetchManager, zn as buildRuntimeCommunityFields, zt as RpcExportCommunityModLogsParamSchema } from "./rpc-local-community-DfJ3wj-p.js";
-import { s as getHeliaDebugContext } from "./util-DkyQHyK7.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-DEmcezee.js";
+import { $ as parseCidStringSchemaWithPKCErrorIfItFails, $t as require_lib$1, A as findCommentInParsedPages, B as InflightFetchManager, Bn as buildRuntimeCommunityFields, Bt as RpcExportCommunityModLogsParamSchema, C as RepliesPages, Cr as t$2, Ct as parseDecryptedChallengeVerification, D as extractCommunityRuntimeFieldsFromParsedPages, Dn as verifyCommentModeration, Dr as NAME_RESOLVED_FALSE_TTL_MS, Dt as parseRpcCommentEventWithPKCErrorIfItFails, En as verifyCommentIpfs, Er as MAX_FILE_SIZE_BYTES_FOR_COMMENT_UPDATE, 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, 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, Mr as nativeFunctions$2, Mt as RpcAnchorPublishPreparationResultSchema, N as applyNameResolvedCacheToCrosspost, Nn as buildRuntimeAuthor, Nr as require_undici, Nt as RpcAuthorNameParamSchema, O as findCommentInPageInstance, On as verifyCommentPubsubMessage, Or as NAME_RESOLVED_TRUE_TTL_MS, Ot as parseRpcCommentUpdateEventWithPKCErrorIfItFails, P as cloneCrosspostForRuntime, Pn as cleanWireAuthor, Pt as RpcCancelExportParamSchema, Qt as RpcUnsubscribeParamSchema, R as PKCClientsManager, Rt as RpcCommunityPageParamSchema, S as KeyvBetterSqlite3, Sn as verifyChallengeMessage, St as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Tn as verifyCommentEdit, 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 t$5, an as encryptEd25519AesGcm, at as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, b as RemoteCommunity, bn as signVote, br as t$3, 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 tryToDeleteCommunitiesThatFailedToBeDeletedBefore, gt as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, hn as signCommentModeration, hr as setNativeFunctions$1, ht as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, jn as verifyCommunityEdit, jt as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, k as findCommentInPageInstanceRecursively, kn as verifyCommentUpdate, kr as NAME_RESOLVE_FAILED_RETRY_FLOOR_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, wn as verifyChallengeVerification, wr as t$4, wt as parseDecryptedChallengeWithPKCErrorIfItFails, xr as n$3, xt as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, y as LRUCache, yn as signCommunityEdit, yt as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, z as GenericStateClient, zt as RpcEditCommunityParamSchema } from "./rpc-local-community-DqKbZLIy.js";
+import { s as getHeliaDebugContext } from "./util-CpoO437x.js";
 import path from "path";
 import assert from "assert";
 import fs from "fs";
@@ -3439,10 +3439,26 @@ const log = logger_default("pkc-js:PKCRpcClient");
 const WEBSOCKET_READY_STATE_CLOSED = 3;
 const DESTROY_SOCKET_CLOSE_TIMEOUT_MS = 5e3;
 const scheduleMacrotask = setTimeout.bind(globalThis);
+function isRpcSubscriptionNotification(message) {
+	if (typeof message !== "object" || message === null || !("params" in message)) return false;
+	const params = message.params;
+	if (typeof params !== "object" || params === null) return false;
+	const { subscription, event } = params;
+	return typeof subscription === "number" && subscription > 0 && typeof event === "string";
+}
 var PKCRpcClient = class extends import_lib.TypedEmitter {
 	constructor(rpcServerUrl) {
 		super();
 		this._pendingSubscriptionMsgs = {};
+		this._serverIdByLocalId = /* @__PURE__ */ new Map();
+		this._localIdByServerId = /* @__PURE__ */ new Map();
+		this._resubscribeCalls = /* @__PURE__ */ new Map();
+		this._publishSubscriptionIds = /* @__PURE__ */ new Set();
+		this._hasConnectedBefore = false;
+		this._socketsWithNotificationHandler = /* @__PURE__ */ new WeakSet();
+		this._reconnectBaseIntervalMs = 1e3;
+		this._reconnectMaxIntervalMs = 3e4;
+		this._reconnectIntervalMs = this._reconnectBaseIntervalMs;
 		assert(rpcServerUrl, "pkc.pkcRpcClientsOptions needs to be defined to create a new rpc client");
 		this._websocketServerUrl = rpcServerUrl;
 		this._timeoutSeconds = 20;
@@ -3475,26 +3491,24 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		let lastWebsocketError;
 		if (!(this._webSocketClient instanceof Client)) {
 			this.setState("connecting");
-			this._webSocketClient = new Client(this._websocketServerUrl);
-			log("Created a new WebSocket instance with url " + this._websocketServerUrl);
-			this._webSocketClient.socket.on("message", (jsonMessage) => {
-				const message = JSON.parse(jsonMessage);
-				const subscriptionId = message?.params?.subscription;
-				if (subscriptionId) {
-					this._initSubscriptionEvent(subscriptionId);
-					if (message?.params?.event === "error") {
-						message.params.result = this._deserializeRpcError(message.params.result);
-						delete message.params.result.stack;
-					}
-					if (this._subscriptionEvents[subscriptionId].listenerCount(message?.params?.event) === 0) this._pendingSubscriptionMsgs[subscriptionId].push(message);
-					else this._subscriptionEvents[subscriptionId].emit(message?.params?.event, message);
-				}
+			this._webSocketClient = new Client(this._websocketServerUrl, {
+				reconnect_interval: this._reconnectIntervalMs,
+				max_reconnects: 0
 			});
+			log("Created a new WebSocket instance with url " + this._websocketServerUrl);
+			this._attachNotificationHandler();
 			this._webSocketClient.on("open", () => {
 				log("Connected to RPC server", this._websocketServerUrl);
+				this._attachNotificationHandler();
+				this._reconnectIntervalMs = this._reconnectBaseIntervalMs;
+				this._webSocketClient.setReconnectInterval(this._reconnectIntervalMs);
+				const isReconnect = this._hasConnectedBefore;
+				this._hasConnectedBefore = true;
 				this.setState("connected");
+				if (isReconnect) this._resubscribeAllAfterReconnect();
 			});
 			this._webSocketClient.on("error", (error) => {
+				this._backOffReconnectInterval();
 				lastWebsocketError = error;
 				if (this._destroyRequested) {
 					log("Ignoring websocket error emitted after destroy request", error);
@@ -3507,12 +3521,17 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 					this.setState("failed");
 					return;
 				}
-				this.emit("error", error);
+				try {
+					this.emit("error", error);
+				} catch (emitError) {
+					log.error("No listener received the RPC websocket error", this._websocketServerUrl, emitError);
+				}
 			});
 			this._webSocketClient.on("close", () => {
 				if (!this._destroyRequested) log.error("connection with web socket has been closed", this._websocketServerUrl);
 				this._openConnectionPromise = void 0;
 				this.setState("stopped");
+				if (!this._destroyRequested) this._failPublicationsLostWithConnection();
 			});
 			const originalWebsocketCall = this._webSocketClient.call.bind(this._webSocketClient);
 			this._webSocketClient.call = async (...args) => {
@@ -3577,9 +3596,14 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 			log.error("Failed to unsubscribe to subscription ID", subscriptionId, e);
 			cleanupSubscriptionLocally(subscriptionId);
 		}
+		this._resubscribeCalls.clear();
+		this._publishSubscriptionIds.clear();
+		this._serverIdByLocalId.clear();
+		this._localIdByServerId.clear();
 		try {
 			if (this._webSocketClient instanceof Client) {
 				this._webSocketClient.setAutoReconnect(false);
+				clearTimeout(this._webSocketClient.reconnect_timer_id);
 				const socketClosed = this._waitForSocketClose();
 				this._webSocketClient.close();
 				await socketClosed;
@@ -3607,11 +3631,123 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		else return this._subscriptionEvents[subscriptionId];
 	}
 	async unsubscribe(subscriptionId) {
-		await this._webSocketClient.call("unsubscribe", [{ subscriptionId }]);
+		const liveOnServer = this.state === "connected" && (this._resubscribeCalls.has(subscriptionId) || this._publishSubscriptionIds.has(subscriptionId));
+		const serverSubscriptionId = this._serverIdByLocalId.get(subscriptionId) ?? subscriptionId;
+		this._resubscribeCalls.delete(subscriptionId);
+		this._publishSubscriptionIds.delete(subscriptionId);
+		if (liveOnServer) await this._webSocketClient.call("unsubscribe", [{ subscriptionId: serverSubscriptionId }]);
+		this._serverIdByLocalId.delete(subscriptionId);
+		this._localIdByServerId.delete(serverSubscriptionId);
 		if (this._subscriptionEvents[subscriptionId]) this._subscriptionEvents[subscriptionId].removeAllListeners();
 		delete this._subscriptionEvents[subscriptionId];
 		delete this._pendingSubscriptionMsgs[subscriptionId];
 	}
+	_attachNotificationHandler() {
+		const socket = this._webSocketClient.socket;
+		if (!socket || this._socketsWithNotificationHandler.has(socket)) return;
+		this._socketsWithNotificationHandler.add(socket);
+		socket.on("message", (jsonMessage) => {
+			const message = JSON.parse(jsonMessage);
+			if (!isRpcSubscriptionNotification(message)) return;
+			const serverSubscriptionId = message.params.subscription;
+			const subscriptionId = this._localIdByServerId.get(serverSubscriptionId) ?? serverSubscriptionId;
+			message.params.subscription = subscriptionId;
+			this._dispatchNotification(subscriptionId, message);
+		});
+	}
+	_dispatchNotification(subscriptionId, message) {
+		this._initSubscriptionEvent(subscriptionId);
+		if (message.params.event === "error" && !(message.params.result instanceof Error)) {
+			const error = this._deserializeRpcError(message.params.result);
+			delete error.stack;
+			message.params.result = error;
+		}
+		if (this._subscriptionEvents[subscriptionId].listenerCount(message.params.event) === 0) this._pendingSubscriptionMsgs[subscriptionId].push(message);
+		else this._subscriptionEvents[subscriptionId].emit(message.params.event, message);
+	}
+	_backOffReconnectInterval() {
+		if (!(this._webSocketClient instanceof Client)) return;
+		this._reconnectIntervalMs = Math.min(this._reconnectIntervalMs * 2, this._reconnectMaxIntervalMs);
+		this._webSocketClient.setReconnectInterval(this._reconnectIntervalMs);
+	}
+	async _subscribe(method, params, onReconnect, resubscribeMethod = method) {
+		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call(method, params));
+		this._initSubscriptionEvent(res.subscriptionId);
+		if (onReconnect === "resubscribe") this._resubscribeCalls.set(res.subscriptionId, {
+			method: resubscribeMethod,
+			params
+		});
+		else this._publishSubscriptionIds.add(res.subscriptionId);
+		return res;
+	}
+	_resubscribeAllAfterReconnect() {
+		for (const subscriptionId of [...this._resubscribeCalls.keys()]) this._resubscribe(subscriptionId).catch((error) => {
+			if (this._destroyRequested) return;
+			if (error?.code === "ERR_RPC_COMMUNITY_NOT_RUNNING") {
+				log("Not re-establishing start(), the community was stopped on purpose", subscriptionId);
+				this._resubscribeCalls.delete(subscriptionId);
+				this._dispatchNotification(subscriptionId, { params: {
+					event: "startedstatechange",
+					subscription: subscriptionId,
+					result: { state: "stopped" }
+				} });
+				return;
+			}
+			log.error("Failed to re-subscribe after reconnecting to the RPC server", subscriptionId, error);
+			this._dispatchNotification(subscriptionId, { params: {
+				event: "error",
+				subscription: subscriptionId,
+				result: error
+			} });
+		});
+	}
+	async _resubscribe(subscriptionId) {
+		const call = this._resubscribeCalls.get(subscriptionId);
+		if (!call || this._destroyRequested) return;
+		const { subscriptionId: serverSubscriptionId } = parseRpcSubscriptionIdResult(await this._webSocketClient.call(call.method, call.params));
+		const earlyMessages = serverSubscriptionId === subscriptionId ? [] : this._pendingSubscriptionMsgs[serverSubscriptionId] ?? [];
+		if (serverSubscriptionId !== subscriptionId) {
+			delete this._pendingSubscriptionMsgs[serverSubscriptionId];
+			delete this._subscriptionEvents[serverSubscriptionId];
+		}
+		if (this._resubscribeCalls.get(subscriptionId) !== call || this._destroyRequested) {
+			if (!this._destroyRequested) await this._webSocketClient.call("unsubscribe", [{ subscriptionId: serverSubscriptionId }]).catch((error) => {
+				log.error("Failed to unsubscribe a subscription re-issued after it was unsubscribed", error);
+			});
+			return;
+		}
+		const previousServerSubscriptionId = this._serverIdByLocalId.get(subscriptionId);
+		if (previousServerSubscriptionId !== void 0) this._localIdByServerId.delete(previousServerSubscriptionId);
+		this._serverIdByLocalId.set(subscriptionId, serverSubscriptionId);
+		this._localIdByServerId.set(serverSubscriptionId, subscriptionId);
+		log("Re-subscribed after reconnecting", call.method, {
+			subscriptionId,
+			serverSubscriptionId
+		});
+		for (const message of earlyMessages) {
+			message.params.subscription = subscriptionId;
+			this._dispatchNotification(subscriptionId, message);
+		}
+	}
+	_failPublicationsLostWithConnection() {
+		for (const subscriptionId of [...this._publishSubscriptionIds]) {
+			this._publishSubscriptionIds.delete(subscriptionId);
+			const error = new PKCError("ERR_RPC_PUBLICATION_LOST_WITH_CONNECTION", {
+				rpcServerUrl: this._websocketServerUrl,
+				publishThrowError: true
+			});
+			this._dispatchNotification(subscriptionId, { params: {
+				event: "publishingstatechange",
+				subscription: subscriptionId,
+				result: { state: "failed" }
+			} });
+			this._dispatchNotification(subscriptionId, { params: {
+				event: "error",
+				subscription: subscriptionId,
+				result: error
+			} });
+		}
+	}
 	_deserializeRpcError(errorPayload) {
 		if (!errorPayload || typeof errorPayload !== "object") {
 			const genericError = /* @__PURE__ */ new Error("Received malformed RPC error payload");
@@ -3687,7 +3823,7 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		while (pendingMessages.length > 0) {
 			if (!shouldDeliver()) return;
 			const message = pendingMessages.shift();
-			this._subscriptionEvents[subscriptionId].emit(message?.params?.event, message);
+			this._subscriptionEvents[subscriptionId].emit(message.params.event, message);
 		}
 		delete this._pendingSubscriptionMsgs[subscriptionId];
 	}
@@ -3717,9 +3853,7 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 	}
 	async startCommunity(communityIdentifier) {
 		const parsedStartCommunityArgs = parseRpcCommunityIdentifierParam(communityIdentifier);
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("startCommunity", [parsedStartCommunityArgs]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("startCommunity", [parsedStartCommunityArgs], "resubscribe", "startedCommunitySubscribe");
 	}
 	async stopCommunity(communityIdentifier) {
 		const parsedStopCommunityArgs = parseRpcCommunityIdentifierParam(communityIdentifier);
@@ -3747,40 +3881,26 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 	}
 	async communityUpdateSubscribe(communityIdentifier) {
 		const parsedCommunityUpdateArgs = parseRpcCommunityIdentifierParam(communityIdentifier);
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("communityUpdateSubscribe", [parsedCommunityUpdateArgs]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("communityUpdateSubscribe", [parsedCommunityUpdateArgs], "resubscribe");
 	}
 	async publishComment(commentProps) {
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("publishComment", [commentProps]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("publishComment", [commentProps], "fail");
 	}
 	async publishCommentEdit(commentEditProps) {
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("publishCommentEdit", [commentEditProps]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("publishCommentEdit", [commentEditProps], "fail");
 	}
 	async publishCommentModeration(commentModProps) {
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("publishCommentModeration", [commentModProps]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("publishCommentModeration", [commentModProps], "fail");
 	}
 	async publishVote(voteProps) {
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("publishVote", [voteProps]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("publishVote", [voteProps], "fail");
 	}
 	async publishCommunityEdit(communityEdit) {
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("publishCommunityEdit", [communityEdit]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("publishCommunityEdit", [communityEdit], "fail");
 	}
 	async commentUpdateSubscribe(args) {
 		const parsedCommentUpdateArgs = parseRpcCidParam(args);
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("commentUpdateSubscribe", [parsedCommentUpdateArgs]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("commentUpdateSubscribe", [parsedCommentUpdateArgs], "resubscribe");
 	}
 	async publishChallengeAnswers(args) {
 		return parseRpcSuccessResult(await this._webSocketClient.call("publishChallengeAnswers", [args]));
@@ -3790,16 +3910,14 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 		return parseRpcResolveAuthorNameResult(await this._webSocketClient.call("resolveAuthorName", [resolveAuthorNameArgs]));
 	}
 	async initalizeCommunitieschangeEvent() {
-		const { subscriptionId } = parseRpcSubscriptionIdResult(await this._webSocketClient.call("communitiesSubscribe", []));
-		this._initSubscriptionEvent(subscriptionId);
+		const { subscriptionId } = await this._subscribe("communitiesSubscribe", [], "resubscribe");
 		this.getSubscription(subscriptionId).on("communitieschange", (res) => {
 			this.emit("communitieschange", res.params.result.communities);
 		});
 		this.emitAllPendingMessages(subscriptionId);
 	}
 	async initalizeSettingschangeEvent() {
-		const { subscriptionId } = parseRpcSubscriptionIdResult(await this._webSocketClient.call("settingsSubscribe", []));
-		this._initSubscriptionEvent(subscriptionId);
+		const { subscriptionId } = await this._subscribe("settingsSubscribe", [], "resubscribe");
 		this.getSubscription(subscriptionId).on("settingschange", (res) => {
 			this.emit("settingschange", res.params.result);
 		});
@@ -3830,9 +3948,7 @@ var PKCRpcClient = class extends import_lib.TypedEmitter {
 	}
 	async exportsSubscribe(args) {
 		const parsedArgs = parseRpcCommunityIdentifierParam(args);
-		const res = parseRpcSubscriptionIdResult(await this._webSocketClient.call("exportsSubscribe", [parsedArgs]));
-		this._initSubscriptionEvent(res.subscriptionId);
-		return res;
+		return await this._subscribe("exportsSubscribe", [parsedArgs], "resubscribe");
 	}
 	async cancelExport(args) {
 		const parsedArgs = parseRpcCancelExportParam(args);
@@ -8254,7 +8370,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-BvltkMx7.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-DMzV8Gsa.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -8533,7 +8649,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-Cm4X7RjW.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-YoJAmva8.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {

package/dist/bundled/chunks/{page-sort-scoring-Bj73WnwW.js → page-sort-scoring-C1XYRQ1w.js}

@@ -1,4 +1,4 @@
-import { _ as getEquivalentCommunityAddresses, vn as PageSortFileSchema } from "./util-vJMTa4rC.js";
+import { _ as getEquivalentCommunityAddresses, vn as PageSortFileSchema } from "./util-DEmcezee.js";
 //#region dist/node/pages/page-sort-scoring.js
 function validatePageSortFile(rawFile) {
 	const validated = PageSortFileSchema.parse(rawFile);