@pkcprotocol/pkc-js 0.0.83 → 0.0.85

package/dist/bundled/chunks/{local-community-DJM47U8C.js → local-community-BqxmCg5p.js}

@@ -1,6 +1,6 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $ as pubsubTopicToDhtKey, $n as n$3, An as CommentsTableRowSchema, At as trackStartedCommunity, Bn as CommentEditsTableRowSchema, Bt as CommunityEditPublicationPubsubReservedFields, C as contentContainsMarkdownAudio, Ct as findUpdatingCommunity, Dn as CommentUpdateSchema, F as getIpnsRecordInLocalKuboNode, Ft as untrackUpdatingCommunity, G as isLinkOfAudio, Gt as CommentModerationPubsubMessagePublicationSchema, In as CommentEditPubsubMessagePublicationSchema, It as require_sha256, J as isLinkOfVideo, Jt as CommentModerationsTableRowSchema, K as isLinkOfImage, Kt as CommentModerationReservedFields, L as hideClassPrivateProps, Ln as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, M as genToArray, Mt as trackUpdatingCommunity, N as getEquivalentCommunityAddresses, Nr as ZodError, Nt as untrackStartedCommunity, O as derivePublicationFromChallengeRequest, P as getErrorCodeFromMessage, Q as isStringDomain, Qn as t$8, R as ipnsNameToIpnsOverPubsubTopic, Rn as CommentEditReservedFields, S as calculateStringSizeSameAsIpfsAddCidV0, T as contentContainsMarkdownVideos, W as isLinkOfAnimatedImage, Wn as AuthorReservedFields, Y as isLinkValid, Zn as n$4, _t as timestamp, a as ChallengeRequestMessageSchema, ar as r$1, at as removeNullUndefinedValues, b as areEquivalentCommunityAddresses, bn as CommentPubsubMessageReservedFields, br as logger_default, bt as findCommunityInRegistry, d as DecryptedChallengeRequestSchema, dt as retryKuboIpfsAddAndProvide, er as t$7, fr as require_retry, gn as VoteTablesRowSchema, ht as statMfsPathSafely, in as CommunitySignedPropertyNames, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateTableRowSchema, kt as syncCommunityRegistryEntry, lr as t$5, lt as retryKuboBlockPutPinAndProvidePubsubTopic, mn as VotePubsubReservedFields, mt as sleepUntilTimeoutOrAbort, nr as e, nt as removeBlocksFromKuboNode, or as t$4, pn as VotePubsubMessagePublicationSchema, q as isLinkOfMedia, r as ChallengeMessageSchema, rn as CommunityIpfsSchema, rr as e$1, rt as removeMfsFilesSafely, s as ChallengeVerificationMessageSchema, t as ChallengeAnswerMessageSchema, tr as t$6, u as DecryptedChallengeRequestPublicationSchema, ur as t$3, vr as PKCError, w as contentContainsMarkdownImages, x as calculateIpfsCidV0, xt as findStartedCommunity, y as version_default, yn as CommentIpfsSchema, yr as messages, yt as writeKuboFilesWithTimeout } from "./schema-mdv9_FG5.js";
-import { $n as crosspostChainDepthUpTo, $t as createSchemaRowParser, A as deriveDbReplies, At as verifyCommentModeration, C as backupCommunityDb, D as deleteOldCommunityInWindows, Et as verifyChallengeRequest, Ft as verifyVote, G as TIMEFRAMES_TO_SECONDS, H as POSTS_SORT_TYPES, It as buildRuntimeAuthor, Kt as decode, L as moveCommunityDbToDeletedDirectory, Lt as cleanWireAuthor, Mt as verifyCommentUpdate, N as getThumbnailPropsOfLink, Nt as verifyCommunity, O as deriveCommentIpfsFromCommentTableRow, Ot as verifyCommentEdit, P as importSignerIntoKuboNode, Pt as verifyCommunityEdit, Qt as getPublicKeyFromPrivateKey, R as resolveDbPostsCidRefs, S as BackupAbortError, Sn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, T as calculateInlineRepliesBudget, Tn as parseJsonWithPKCErrorIfFails, U as POST_REPLIES_SORT_TYPES, Ut as getCommunityNameFromWire, W as REPLY_REPLIES_SORT_TYPES, Wt as getCommunityPublicKeyFromWire, X as iterateOverPageCidsToFindAllCids, Xt as getPKCAddressFromPublicKey, Yt as getIpfsKeyFromPrivateKey, Zt as getPKCAddressFromPublicKeySync, _t as signCommentEdit, a as pkcJsChallenges, ar as n$6, bt as signCommentUpdateForChallengeVerification, cr as t$10, ct as pLimit, dr as require_lodash_merge, dt as cleanUpBeforePublishing, er as effectiveMaxCrosspostDepth, fn as parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails, gt as signComment, h as SignerWithPublicKeyAddress, ht as signChallengeVerification, i as getCommunityChallengeFromCommunityChallengeSettings, ir as t$11, j as getDefaultCommunityDbConfig, jt as verifyCommentPubsubMessage, k as deriveDbPosts, kt as verifyCommentIpfs, l as MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS, lr as stringify, nr as t$12, o as TrackedInstanceRegistry, or as n$5, pt as signChallengeMessage, qt as encode, r as getChallengeVerification, rr as r$2, s as LRUCache, t as RpcLocalCommunity, tr as t$9, u as KeyvBetterSqlite3, un as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, ur as STORAGE_KEYS, w as calculateExpectedSignatureSize, wt as verifyChallengeAnswer, x as encryptEd25519AesGcmPublicKeyBuffer, xt as signCommunity, y as decryptEd25519AesGcmPublicKeyBuffer, yt as signCommentUpdate, zt as getAuthorNameFromWire } from "./rpc-local-community-a464veDe.js";
+import { $ as pubsubTopicToDhtKey, $n as n$4, Bn as CommentEditReservedFields, C as contentContainsMarkdownAudio, Ct as findStartedCommunity, F as getIpnsRecordInLocalKuboNode, Fr as ZodError, Ft as untrackStartedCommunity, G as isLinkOfAudio, Hn as CommentEditsTableRowSchema, Ht as CommunityEditPublicationPubsubReservedFields, J as isLinkOfVideo, Jt as CommentModerationReservedFields, K as isLinkOfImage, Kn as AuthorReservedFields, L as hideClassPrivateProps, Lt as untrackUpdatingCommunity, M as genToArray, Mn as CommentsTableRowSchema, Mt as trackStartedCommunity, N as getEquivalentCommunityAddresses, O as derivePublicationFromChallengeRequest, P as getErrorCodeFromMessage, Pt as trackUpdatingCommunity, Q as isStringDomain, R as ipnsNameToIpnsOverPubsubTopic, Rn as CommentEditPubsubMessagePublicationSchema, Rt as require_sha256, S as calculateStringSizeSameAsIpfsAddCidV0, Sn as CommentPubsubMessageReservedFields, Sr as logger_default, St as findCommunityInRegistry, T as contentContainsMarkdownVideos, Tt as findUpdatingCommunity, W as isLinkOfAnimatedImage, Xt as CommentModerationsTableRowSchema, Y as isLinkValid, _t as statMfsPathSafely, a as ChallengeRequestMessageSchema, an as CommunityIpfsSchema, ar as e$1, at as removeMfsFilesSafely, b as areEquivalentCommunityAddresses, br as PKCError, cr as t$4, d as DecryptedChallengeRequestSchema, dr as t$5, dt as retryKuboBlockPutPinAndProvidePubsubTopic, er as t$8, fr as t$3, gn as VotePubsubReservedFields, gt as sleepUntilTimeoutOrAbort, hn as VotePubsubMessagePublicationSchema, ir as e, it as removeBlocksFromKuboNode, jn as CommentUpdateTableRowSchema, jt as syncCommunityRegistryEntry, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateSchema, mr as require_retry, nr as t$7, on as CommunitySignedPropertyNames, pt as retryKuboIpfsAddAndProvide, q as isLinkOfMedia, qt as CommentModerationPubsubMessagePublicationSchema, r as ChallengeMessageSchema, rr as t$6, s as ChallengeVerificationMessageSchema, sr as r$1, st as removeNullUndefinedValues, t as ChallengeAnswerMessageSchema, tr as n$3, u as DecryptedChallengeRequestPublicationSchema, vn as VoteTablesRowSchema, w as contentContainsMarkdownImages, x as calculateIpfsCidV0, xn as CommentIpfsSchema, xr as messages, xt as writeKuboFilesWithTimeout, y as version_default, yt as timestamp, zn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema } from "./schema-qhSDu1BU.js";
+import { $t as getPublicKeyFromPrivateKey, A as deriveDbPosts, At as verifyCommentIpfs, Bt as getAuthorNameFromWire, C as BackupAbortError, Cn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Dt as verifyChallengeRequest, E as calculateInlineRepliesBudget, En as parseJsonWithPKCErrorIfFails, F as importSignerIntoKuboNode, Ft as verifyCommunityEdit, G as REPLY_REPLIES_SORT_TYPES, Gt as getCommunityPublicKeyFromWire, It as verifyVote, Jt as encode, K as TIMEFRAMES_TO_SECONDS, Lt as buildRuntimeAuthor, M as getDefaultCommunityDbConfig, Mt as verifyCommentPubsubMessage, Nt as verifyCommentUpdate, O as deleteOldCommunityInWindows, P as getThumbnailPropsOfLink, Pt as verifyCommunity, Qt as getPKCAddressFromPublicKeySync, R as moveCommunityDbToDeletedDirectory, Rt as cleanWireAuthor, S as encryptEd25519AesGcmPublicKeyBuffer, St as signCommunity, T as calculateExpectedSignatureSize, Tt as verifyChallengeAnswer, U as POSTS_SORT_TYPES, W as POST_REPLIES_SORT_TYPES, Wt as getCommunityNameFromWire, Xt as getIpfsKeyFromPrivateKey, Z as iterateOverPageCidsToFindAllCids, Zt as getPKCAddressFromPublicKey, _t as signComment, a as loadChallengeFileFromCommunityChallengeSettings, ar as t$11, b as decryptEd25519AesGcmPublicKeyBuffer, bt as signCommentUpdate, c as LRUCache, d as KeyvBetterSqlite3, dn as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, dr as STORAGE_KEYS, en as createSchemaRowParser, er as crosspostChainDepthUpTo, fr as require_lodash_merge, ft as cleanUpBeforePublishing, g as SignerWithPublicKeyAddress, gt as signChallengeVerification, i as getCommunityChallengeFromCommunityChallengeSettings, ir as r$2, j as deriveDbReplies, jt as verifyCommentModeration, k as deriveCommentIpfsFromCommentTableRow, kt as verifyCommentEdit, lr as t$10, lt as pLimit, mt as signChallengeMessage, nr as t$9, o as pkcJsChallenges, or as n$6, pn as parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails, qt as decode, r as getChallengeVerification, rr as t$12, s as TrackedInstanceRegistry, sr as n$5, t as RpcLocalCommunity, tr as effectiveMaxCrosspostDepth, u as MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS, ur as stringify, vt as signCommentEdit, w as backupCommunityDb, xt as signCommentUpdateForChallengeVerification, z as resolveDbPostsCidRefs } from "./rpc-local-community-o0teUvw_.js";
 import { randomFillSync, randomUUID } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import Path from "node:path";
@@ -1739,6 +1739,77 @@ async function storePublication(community, request, pendingApproval, challengeAg
 	else throw Error("Don't know how to store this publication" + request);
 }
 //#endregion
+//#region dist/node/runtime/node/community/challenges/validate-challenge-settings.js
+const describeChallenge = (communityChallengeSettings) => communityChallengeSettings.name || communityChallengeSettings.path || "unknown challenge";
+const isOptionSet = (value) => value !== void 0 && value !== null;
+function validateChallengeSettingsAgainstChallengeFile({ challengeSettings, challengeFile, challengeIndex }) {
+	const baseDetails = {
+		challengeIndex,
+		challengeName: describeChallenge(challengeSettings)
+	};
+	const { optionInputs } = challengeFile;
+	if (optionInputs) {
+		const declaredOptions = new Set(optionInputs.map((optionInput) => optionInput.option));
+		for (const optionName of Object.keys(challengeSettings.options ?? {})) if (!declaredOptions.has(optionName)) return new PKCError("ERR_CHALLENGE_OPTION_NOT_DECLARED_IN_OPTION_INPUTS", {
+			...baseDetails,
+			offendingOption: optionName,
+			declaredOptions: [...declaredOptions]
+		});
+		for (const optionInput of optionInputs) if (optionInput.required && !isOptionSet(challengeSettings.options?.[optionInput.option])) return new PKCError("ERR_CHALLENGE_REQUIRED_OPTION_MISSING", {
+			...baseDetails,
+			missingOption: optionInput.option
+		});
+		for (const optionName of challengeSettings.publicOptions ?? []) if (!declaredOptions.has(optionName)) return new PKCError("ERR_CHALLENGE_PUBLIC_OPTION_NOT_DECLARED_IN_OPTION_INPUTS", {
+			...baseDetails,
+			offendingOption: optionName,
+			declaredOptions: [...declaredOptions]
+		});
+	}
+	if (challengeFile.validateChallengeSettings) try {
+		challengeFile.validateChallengeSettings({ challengeSettings });
+	} catch (e) {
+		const wrapped = new PKCError("ERR_CHALLENGE_SETTINGS_VALIDATION_FAILED", {
+			...baseDetails,
+			validationError: e instanceof Error ? e.message : String(e)
+		});
+		Object.assign(wrapped, { cause: e });
+		return wrapped;
+	}
+}
+async function collectChallengeSettingsValidationFailures({ challengeSettings, pkc }) {
+	const failures = [];
+	for (const [challengeIndex, communityChallengeSettings] of challengeSettings.entries()) {
+		const error = validateChallengeSettingsAgainstChallengeFile({
+			challengeSettings: communityChallengeSettings,
+			challengeFile: await loadChallengeFileFromCommunityChallengeSettings({
+				communityChallengeSettings,
+				pkc
+			}),
+			challengeIndex
+		});
+		if (error) failures.push({
+			challengeIndex,
+			challengeName: describeChallenge(communityChallengeSettings),
+			error
+		});
+	}
+	return failures;
+}
+async function throwIfChallengeSettingsAreInvalid({ challengeSettings, pkc, communityAddress }) {
+	const failures = await collectChallengeSettingsValidationFailures({
+		challengeSettings,
+		pkc
+	});
+	if (failures.length) throw new PKCError("ERR_CHALLENGE_SETTINGS_VALIDATION_FAILED_FOR_CHALLENGES", {
+		communityAddress,
+		failures: failures.map(({ challengeIndex, challengeName, error }) => ({
+			challengeIndex,
+			challengeName,
+			error
+		}))
+	});
+}
+//#endregion
 //#region dist/node/runtime/node/community/local-community/registry.js
 const processStartedCommunities = new TrackedInstanceRegistry();
 //#endregion
@@ -6091,6 +6162,11 @@ async function createNewLocalCommunityDb(community) {
 		...community.settings,
 		purgeDisapprovedCommentsOlderThan: 121e4
 	};
+	await throwIfChallengeSettingsAreInvalid({
+		challengeSettings: community.settings.challenges,
+		pkc: community._pkc,
+		communityAddress: community.address
+	});
 	community.challenges = await Promise.all(community.settings.challenges.map(async (cs) => (await getCommunityChallengeFromCommunityChallengeSettings({
 		communityChallengeSettings: cs,
 		pkc: community._pkc
@@ -6633,6 +6709,29 @@ async function initBeforeStarting(community) {
 	});
 	await community._dbHandler.initDbIfNeeded();
 }
+async function emitChallengeSettingsValidationErrors(community, log) {
+	let failures;
+	try {
+		failures = await collectChallengeSettingsValidationFailures({
+			challengeSettings: community.settings?.challenges ?? [],
+			pkc: community._pkc
+		});
+	} catch (e) {
+		log.error("Failed to validate settings.challenges on start", community.address, e);
+		community.emit("error", e);
+		return;
+	}
+	for (const { error, challengeIndex, challengeName } of failures) {
+		error.details = {
+			...error.details,
+			challengeIndex,
+			challengeName,
+			communityAddress: community.address
+		};
+		log.error("Invalid challenge settings on start", community.address, error);
+		community.emit("error", error);
+	}
+}
 async function start(community) {
 	const log = logger_default("pkc-js:local-community:start");
 	if (community.state === "updating") throw new PKCError("ERR_NEED_TO_STOP_UPDATING_COMMUNITY_BEFORE_STARTING", { address: community.address });
@@ -6680,6 +6779,7 @@ async function start(community) {
 			communityChallengeSettings: cs,
 			pkc: community._pkc
 		})).communityChallenge));
+		await emitChallengeSettingsValidationErrors(community, log);
 	} catch (e) {
 		await community.stop();
 		e.details = {
@@ -6991,6 +7091,11 @@ async function parseRolesToEdit(community, newRawRoles) {
 	return t$8(newRawRoles, (val, key) => val === void 0 || val === null);
 }
 async function parseChallengesToEdit(community, newChallengeSettings) {
+	await throwIfChallengeSettingsAreInvalid({
+		challengeSettings: newChallengeSettings,
+		pkc: community._pkc,
+		communityAddress: community.address
+	});
 	return {
 		challenges: await Promise.all(newChallengeSettings.map(async (cs) => (await getCommunityChallengeFromCommunityChallengeSettings({
 			communityChallengeSettings: cs,

package/dist/bundled/chunks/{local-community-B_Yg8LQH.js → local-community-D4SjlAKS.js}

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

package/dist/bundled/chunks/{node-lb4SvdBh.js → node-C2DKW30L.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $n as n$1, B as isIpfsCid, Cr as setErrorMap, Ct as findUpdatingCommunity, D as deepMergeRuntimeFields, Dn as CommentUpdateSchema, Dt as refreshTrackedCommentAliases, E as createAbortError, Et as listUpdatingCommunities, Fr as parsedType, H as isIpns, Ir as stringifyPrimitive, It as require_sha256, L as hideClassPrivateProps, Lt as TimeoutError, Pr as joinValues, Pt as untrackUpdatingComment, Q as isStringDomain, Qt as CommunityAnchorSchema, R as ipnsNameToIpnsOverPubsubTopic, Rt as pTimeout, St as findUpdatingComment, Tt as listUpdatingComments, Zn as n$2, _t as timestamp, a as ChallengeRequestMessageSchema, ar as r, b as areEquivalentCommunityAddresses, br as logger_default, ct as resolveWhenPredicateIsTrue, fr as require_retry, ft as shortifyAddress, jt as trackUpdatingComment, k as doesDomainAddressHaveCapitalLetter, ln as PubsubTopicSchema, mt as sleepUntilTimeoutOrAbort, nr as e, ot as removeUndefinedValuesRecursively, pr as FailedToFetchCommentIpfsFromGatewaysError, pt as shortifyCid, r as ChallengeMessageSchema, rn as CommunityIpfsSchema, rr as e$1, s as ChallengeVerificationMessageSchema, st as replaceXWithY, t as ChallengeAnswerMessageSchema, tr as t$1, ut as retryKuboIpfsAdd, vr as PKCError, vt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, wn as CommentUpdateForChallengeVerificationSchema, wt as listStartedCommunities, xt as findStartedCommunity, y as version_default, yn as CommentIpfsSchema, yr as messages, z as isAbortError } from "./schema-mdv9_FG5.js";
-import { $ as applyNameResolvedCacheToCrosspost, At as verifyCommentModeration, B as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Bn as RpcExportCommunityModLogsParamSchema, Bt as normalizeCreatePublicationAuthor, Cn as parseDecryptedChallengeVerification, Ct as signVote, Dn as parseRpcCommentEventWithPKCErrorIfItFails, Dt as verifyChallengeVerification, E as createKuboRpcClient, En as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, F as listCommunitiesSync, Fn as RpcCidParamSchema, Ft as verifyVote, Gn as RpcFetchCidResultSchema, Gt as normalizeCommunityInputFromCommunity, Hn as RpcExportCommunityParamSchema, Ht as getCommunityAddressFromRecord, I as monitorCommunitiesDirectory, In as RpcCommentRepliesPageParamSchema, It as buildRuntimeAuthor, J as extractCommunityRuntimeFieldsFromParsedPages, Jn as RpcPublishedAnchorRecordResultSchema, Jt as getBufferedPKCAddressFromPublicKey, Kn as RpcPublishAnchorRecordParamSchema, Kt as decode, Ln as RpcCommunityIdentifierParamSchema, Lt as cleanWireAuthor, M as getDefaultDataPath, Mn as RpcAnchorPublishPreparationResultSchema, Mt as verifyCommentUpdate, Nn as RpcAuthorNameParamSchema, On as parseRpcCommentUpdateEventWithPKCErrorIfItFails, Ot as verifyCommentEdit, Pn as RpcCancelExportParamSchema, Pt as verifyCommunityEdit, Q as RepliesPages, Qn as RpcUnsubscribeParamSchema, Rn as RpcCommunityPageParamSchema, Rt as getAuthorNameFromRuntime, Sn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, St as signCommunityEdit, Tn as parseJsonWithPKCErrorIfFails, Tt as verifyChallengeMessage, Un as RpcExportCommunityResultSchema, Ut as getCommunityNameFromWire, V as CommentClientsManager, Vn as RpcExportCommunityModLogsResultSchema, Vt as buildRuntimeCommunityFields, Wn as RpcFetchCidParamSchema, Wt as getCommunityPublicKeyFromWire, Xn as RpcSubscriptionIdResultSchema, Y as findCommentInPageInstanceRecursively, Yn as RpcResolveAuthorNameResultSchema, Z as parseRawPages, Zn as RpcSuccessResultSchema, Zt as getPKCAddressFromPublicKeySync, _ as createAnchorIpnsRecord$1, _t as signCommentEdit, a as pkcJsChallenges, ar as n$3, at as PKCClientsManager, b as encryptEd25519AesGcm, bn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, c as RemoteCommunity, cn as parseCommunityAddressWithPKCErrorIfItFails, cr as t$5, d as decodeRpcChallengeAnswerPubsubMsg, dn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, dt as cleanUpBeforePublishing, en as parseCidStringSchemaWithPKCErrorIfItFails, et as cloneCrosspostForRuntime, f as decodeRpcChallengePubsubMsg, fr as nativeFunctions$2, ft as signChallengeAnswer, g as createSigner, gn as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, gt as signComment, hn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, in as parseCommentIpfsSchemaWithPKCErrorIfItFails, ir as t$3, it as PublicationClientsManager, jn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, jt as verifyCommentPubsubMessage, kn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, kt as verifyCommentIpfs, lt as PKCTypedEmitter, m as decodeRpcChallengeVerificationPubsubMsg, mn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, mt as signChallengeRequest, n as RpcRemoteCommunity, o as TrackedInstanceRegistry, on as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ot as InflightFetchManager, p as decodeRpcChallengeRequestPubsubMsg, pn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, pr as require_undici, qn as RpcPublishChallengeAnswersParamSchema, rn as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, rt as stripNameResolvedFromCrosspost, s as LRUCache, sn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, sr as t$2, t as RpcLocalCommunity, tr as t$4, tt as collectCrosspostAuthorsToResolve, u as KeyvBetterSqlite3, ut as require_lib$1, v as decryptEd25519AesGcm, vt as signCommentModeration, wn as parseDecryptedChallengeWithPKCErrorIfItFails, xn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, yn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, z as setNativeFunctions$1, zn as RpcEditCommunityParamSchema } from "./rpc-local-community-a464veDe.js";
-import { o as getHeliaDebugContext } from "./util-y9-A9BnM.js";
+import { $n as n$2, B as isIpfsCid, Bt as pTimeout, Ct as findStartedCommunity, D as deepMergeRuntimeFields, Dt as listUpdatingComments, E as createAbortError, En as CommentUpdateForChallengeVerificationSchema, Et as listStartedCommunities, H as isIpns, Ir as joinValues, It as untrackUpdatingComment, L as hideClassPrivateProps, Lr as parsedType, Nt as trackUpdatingComment, Ot as listUpdatingCommunities, Q as isStringDomain, R as ipnsNameToIpnsOverPubsubTopic, Rr as stringifyPrimitive, Rt as require_sha256, Sr as logger_default, Tr as setErrorMap, Tt as findUpdatingCommunity, a as ChallengeRequestMessageSchema, an as CommunityIpfsSchema, ar as e$1, b as areEquivalentCommunityAddresses, br as PKCError, bt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, ct as removeUndefinedValuesRecursively, dn as PubsubTopicSchema, en as CommunityAnchorSchema, ft as retryKuboIpfsAdd, gt as sleepUntilTimeoutOrAbort, hr as FailedToFetchCommentIpfsFromGatewaysError, ht as shortifyCid, ir as e, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateSchema, kt as refreshTrackedCommentAliases, lt as replaceXWithY, mr as require_retry, mt as shortifyAddress, nt as rejectWhenAbortSignalFires, r as ChallengeMessageSchema, rr as t$1, rt as rejectWhenCommunityStopsOrAborts, s as ChallengeVerificationMessageSchema, sr as r, t as ChallengeAnswerMessageSchema, tr as n$1, ut as resolveWhenPredicateIsTrue, vt as throwIfAbortSignalAborted, wt as findUpdatingComment, xn as CommentIpfsSchema, xr as messages, y as version_default, yt as timestamp, z as isAbortError, zt as TimeoutError } from "./schema-qhSDu1BU.js";
+import { $ as RepliesPages, $n as RpcUnsubscribeParamSchema, An as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, At as verifyCommentIpfs, B as setNativeFunctions$1, Bn as RpcEditCommunityParamSchema, Cn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Ct as signCommunityEdit, D as createKuboRpcClient, Dn as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, En as parseJsonWithPKCErrorIfFails, Et as verifyChallengeMessage, Fn as RpcCancelExportParamSchema, Ft as verifyCommunityEdit, Gn as RpcFetchCidParamSchema, Gt as getCommunityPublicKeyFromWire, H as CommentClientsManager, Hn as RpcExportCommunityModLogsResultSchema, Ht as buildRuntimeCommunityFields, I as listCommunitiesSync, In as RpcCidParamSchema, It as verifyVote, Jn as RpcPublishChallengeAnswersParamSchema, Kn as RpcFetchCidResultSchema, Kt as normalizeCommunityInputFromCommunity, L as monitorCommunitiesDirectory, Ln as RpcCommentRepliesPageParamSchema, Lt as buildRuntimeAuthor, Mn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Mt as verifyCommentPubsubMessage, N as getDefaultDataPath, Nn as RpcAnchorPublishPreparationResultSchema, Nt as verifyCommentUpdate, On as parseRpcCommentEventWithPKCErrorIfItFails, Ot as verifyChallengeVerification, Pn as RpcAuthorNameParamSchema, Q as parseRawPages, Qn as RpcSuccessResultSchema, Qt as getPKCAddressFromPublicKeySync, Rn as RpcCommunityIdentifierParamSchema, Rt as cleanWireAuthor, Sn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, Tn as parseDecryptedChallengeWithPKCErrorIfItFails, Un as RpcExportCommunityParamSchema, Ut as getCommunityAddressFromRecord, V as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Vn as RpcExportCommunityModLogsParamSchema, Vt as normalizeCreatePublicationAuthor, Wn as RpcExportCommunityResultSchema, Wt as getCommunityNameFromWire, X as findCommentInPageInstanceRecursively, Xn as RpcResolveAuthorNameResultSchema, Y as extractCommunityRuntimeFieldsFromParsedPages, Yn as RpcPublishedAnchorRecordResultSchema, Yt as getBufferedPKCAddressFromPublicKey, Zn as RpcSubscriptionIdResultSchema, _ as createSigner, _n as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, _t as signComment, an as parseCommentIpfsSchemaWithPKCErrorIfItFails, ar as t$3, at as PublicationClientsManager, bn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, c as LRUCache, cn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, cr as t$2, d as KeyvBetterSqlite3, dt as require_lib$1, et as applyNameResolvedCacheToCrosspost, f as decodeRpcChallengeAnswerPubsubMsg, fn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ft as cleanUpBeforePublishing, gn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, h as decodeRpcChallengeVerificationPubsubMsg, hn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, ht as signChallengeRequest, in as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, it as stripNameResolvedFromCrosspost, jt as verifyCommentModeration, kn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, kt as verifyCommentEdit, l as RemoteCommunity, ln as parseCommunityAddressWithPKCErrorIfItFails, lr as t$5, m as decodeRpcChallengeRequestPubsubMsg, mn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, mr as require_undici, n as RpcRemoteCommunity, nr as t$4, nt as collectCrosspostAuthorsToResolve, o as pkcJsChallenges, or as n$3, ot as PKCClientsManager, p as decodeRpcChallengePubsubMsg, pr as nativeFunctions$2, pt as signChallengeAnswer, qn as RpcPublishAnchorRecordParamSchema, qt as decode, s as TrackedInstanceRegistry, sn as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, st as InflightFetchManager, t as RpcLocalCommunity, tn as parseCidStringSchemaWithPKCErrorIfItFails, tt as cloneCrosspostForRuntime, ut as PKCTypedEmitter, v as createAnchorIpnsRecord$1, vt as signCommentEdit, wn as parseDecryptedChallengeVerification, wt as signVote, x as encryptEd25519AesGcm, xn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, y as decryptEd25519AesGcm, yt as signCommentModeration, zn as RpcCommunityPageParamSchema, zt as getAuthorNameFromRuntime } from "./rpc-local-community-o0teUvw_.js";
+import { o as getHeliaDebugContext } from "./util-BVGNNIgn.js";
 import path from "path";
 import assert from "assert";
 import fs from "fs";
@@ -612,6 +612,17 @@ var Publication = class extends import_lib.TypedEmitter {
 		if (typeof encryptionPublicKey !== "string") throw Error("Failed to load the encryption public key of community");
 		return getPKCAddressFromPublicKeySync(encryptionPublicKey);
 	}
+	_getCommunityFetchAbortSignal() {
+		if (!this._communityFetchAbortSignal) {
+			this._communityFetchAbortController = new AbortController();
+			this._communityFetchAbortSignal = AbortSignal.any([this._communityFetchAbortController.signal, this._pkc._getDestroyAbortSignal()]);
+		}
+		return this._communityFetchAbortSignal;
+	}
+	_resetCommunityFetchAbortSignal() {
+		this._communityFetchAbortController = void 0;
+		this._communityFetchAbortSignal = void 0;
+	}
 	_getCommunityCache() {
 		const cached = this._pkc._memCaches.communityForPublishing.get(this.communityAddress, { allowStale: true });
 		if (cached) return cached;
@@ -639,8 +650,12 @@ var Publication = class extends import_lib.TypedEmitter {
 				log("The cache of community is stale, we will use the cached and update in the background");
 				const refresh = this._pkc.getCommunity({
 					publicKey: this.communityPublicKey,
-					name: this.communityName
-				}).catch((e) => log.error("Failed to update cache of community", this.communityAddress, e)).finally(() => {
+					name: this.communityName,
+					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);
+				}).finally(() => {
 					if (this._backgroundCommunityRefresh === refresh) this._backgroundCommunityRefresh = void 0;
 				});
 				this._backgroundCommunityRefresh = refresh;
@@ -649,6 +664,10 @@ var Publication = class extends import_lib.TypedEmitter {
 		} else return this._clientsManager.fetchCommunityForPublishingWithCacheGuard();
 	}
 	async stop() {
+		this._communityFetchAbortController?.abort(new PKCError("ERR_GET_COMMUNITY_ABORTED", {
+			publicationType: this.getType(),
+			communityAddress: this.communityAddress
+		}));
 		try {
 			await this._postSucessOrFailurePublishing();
 		} finally {
@@ -985,6 +1004,7 @@ var Publication = class extends import_lib.TypedEmitter {
 	}
 	async publish() {
 		this._validatePublicationFields();
+		if (this._getCommunityFetchAbortSignal().aborted) this._resetCommunityFetchAbortSignal();
 		this._pkc._publishingPublications.add(this);
 		try {
 			return await this._publishAfterRegistering();
@@ -6928,7 +6948,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-BtjQ8rfd.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-C5Oe_ZSx.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -6987,32 +7007,63 @@ var PKC$1 = class extends PKCTypedEmitter {
 		hideClassPrivateProps(this);
 	}
 	async getCommunity(getCommunityArgs) {
-		if (!getCommunityArgs.address && !getCommunityArgs.name && !getCommunityArgs.publicKey) throw new Error("At least one of address, name, or publicKey must be provided");
-		const community = await this.createCommunity(getCommunityArgs);
+		const { abortSignal, ...communityIdentifier } = getCommunityArgs;
+		if (!communityIdentifier.address && !communityIdentifier.name && !communityIdentifier.publicKey) throw new Error("At least one of address, name, or publicKey must be provided");
+		if (abortSignal?.aborted) throw new PKCError("ERR_GET_COMMUNITY_ABORTED", {
+			communityIdentifier,
+			abortReason: abortSignal.reason
+		});
+		const community = await this.createCommunity(communityIdentifier, { abortSignal });
 		if (typeof community.createdAt === "number") return community;
 		const timeoutMs = this._timeouts["community-ipns"];
-		await waitForUpdateInCommunityInstanceWithErrorAndTimeout(community, timeoutMs);
+		await waitForUpdateInCommunityInstanceWithErrorAndTimeout({
+			community,
+			timeoutMs,
+			abortSignal
+		});
 		return community;
 	}
-	async getComment(cid) {
+	async getComment(getCommentArgs) {
 		logger_default("pkc-js:pkc:getComment");
-		const parsedGetCommentArgs = parseRpcCidParam(cid);
+		const { abortSignal, ...cidArgs } = getCommentArgs;
+		const parsedGetCommentArgs = parseRpcCidParam(cidArgs);
+		if (abortSignal?.aborted) throw new PKCError("ERR_GET_COMMENT_ABORTED", {
+			getCommentArgs: parsedGetCommentArgs,
+			abortReason: abortSignal.reason
+		});
 		const comment = await this.createComment(parsedGetCommentArgs);
 		let lastUpdateError;
 		const errorListener = (err) => lastUpdateError = err;
 		comment.on("error", errorListener);
+		let abortError;
+		let abortReject;
+		const abortListener = () => {
+			abortError = new PKCError("ERR_GET_COMMENT_ABORTED", {
+				getCommentArgs: parsedGetCommentArgs,
+				abortReason: abortSignal?.reason,
+				lastUpdateError
+			});
+			abortReject?.(abortError);
+		};
+		const abortPromise = new Promise((_, reject) => {
+			abortReject = reject;
+		});
+		abortPromise.catch(() => {});
+		abortSignal?.addEventListener("abort", abortListener);
 		const commentTimeout = this._timeouts["comment-ipfs"];
 		try {
-			await pTimeout(comment._attemptInfintelyToLoadCommentIpfs(), {
+			await pTimeout(Promise.race([comment._attemptInfintelyToLoadCommentIpfs(), abortPromise]), {
 				milliseconds: commentTimeout,
 				message: lastUpdateError || new TimeoutError(`pkc.getComment({cid: ${parsedGetCommentArgs}}) timed out after ${commentTimeout}ms`)
 			});
 			if (!comment.signature) throw Error("Failed to load CommentIpfs");
 			return comment;
 		} catch (e) {
+			if (abortError) throw abortError;
 			if (lastUpdateError) throw lastUpdateError;
 			throw e;
 		} finally {
+			abortSignal?.removeEventListener("abort", abortListener);
 			comment.removeListener("error", errorListener);
 			await comment.stop();
 		}
@@ -7176,7 +7227,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-B_Yg8LQH.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-D4SjlAKS.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {
@@ -7199,8 +7250,9 @@ var PKC$1 = class extends PKCTypedEmitter {
 		if (this.communities.includes(jsonfied.address)) return this._createLocalCommunity(jsonfied);
 		else return this._createRemoteCommunityInstance(jsonfied);
 	}
-	async createCommunity(options = {}) {
+	async createCommunity(options = {}, opts) {
 		const log = logger_default("pkc-js:pkc:createCommunity");
+		throwIfAbortSignalAborted(opts?.abortSignal);
 		if ("clients" in options) return this._createCommunityInstanceFromJsonifiedCommunity(options);
 		const parsedOptions = options;
 		log.trace("Received options: ", parsedOptions);
@@ -7532,9 +7584,16 @@ var PKC$1 = class extends PKCTypedEmitter {
 		return this._storageLRUs[opts.cacheName];
 	}
 	_getDestroyAbortSignal() {
-		if (!this._destroyAbortController) this._destroyAbortController = new AbortController();
+		if (!this._destroyAbortController) {
+			this._destroyAbortController = new AbortController();
+			if (this.destroyed) this._destroyAbortController.abort(new PKCError("ERR_PKC_IS_DESTROYED"));
+		}
 		return this._destroyAbortController.signal;
 	}
+	_combineWithDestroyAbortSignal(abortSignal) {
+		const destroySignal = this._getDestroyAbortSignal();
+		return abortSignal ? AbortSignal.any([abortSignal, destroySignal]) : destroySignal;
+	}
 	async destroy() {
 		const log = logger_default("pkc-js:pkc:destroy");
 		if (this.destroyed) return;
@@ -7624,9 +7683,22 @@ var PKCWithRpcClient = class extends PKC$1 {
 		await super.destroy();
 		await this._pkcRpcClient.destroy();
 	}
-	async getComment(commentCid) {
-		const parsedArgs = parseRpcCidParam(commentCid);
-		const commentIpfs = await this._pkcRpcClient.getComment(parsedArgs);
+	async getComment(getCommentArgs) {
+		const { abortSignal, ...cidArgs } = getCommentArgs;
+		const parsedArgs = parseRpcCidParam(cidArgs);
+		const cancellation = rejectWhenAbortSignalFires({
+			abortSignal: this._combineWithDestroyAbortSignal(abortSignal),
+			error: () => new PKCError("ERR_GET_COMMENT_ABORTED", {
+				getCommentArgs: parsedArgs,
+				abortReason: abortSignal?.reason
+			})
+		});
+		let commentIpfs;
+		try {
+			commentIpfs = await Promise.race([this._pkcRpcClient.getComment(parsedArgs), cancellation.promise]);
+		} finally {
+			cancellation.cleanup();
+		}
 		return this.createComment({
 			...parsedArgs,
 			raw: {
@@ -7639,8 +7711,9 @@ var PKCWithRpcClient = class extends PKC$1 {
 		if (!getCommunityArgs.address && !getCommunityArgs.name && !getCommunityArgs.publicKey) throw new Error("At least one of address, name, or publicKey must be provided");
 		return super.getCommunity(getCommunityArgs);
 	}
-	async createCommunity(options = {}) {
+	async createCommunity(options = {}, opts) {
 		const log = logger_default("pkc-js:pkc-with-rpc-client:createCommunity");
+		throwIfAbortSignalAborted(opts?.abortSignal);
 		const parsedRpcOptions = "clients" in options ? options : parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails(options);
 		log.trace("Received community options to create a community instance over RPC:", options);
 		const hasIdentifier = "address" in parsedRpcOptions && typeof parsedRpcOptions.address === "string" || "name" in parsedRpcOptions && typeof parsedRpcOptions.name === "string" || "publicKey" in parsedRpcOptions && typeof parsedRpcOptions.publicKey === "string";
@@ -7663,9 +7736,24 @@ var PKCWithRpcClient = class extends PKC$1 {
 				const updatePromise = new Promise((resolve) => community.once("update", resolve));
 				let error;
 				const errorPromise = new Promise((resolve) => community.once("error", (err) => resolve(error = err)));
-				await community._createAndSubscribeToNewUpdatingCommunity(community);
-				await community.update();
-				await Promise.race([updatePromise, errorPromise]);
+				const cancellation = rejectWhenCommunityStopsOrAborts({
+					community,
+					abortSignal: this._combineWithDestroyAbortSignal(opts?.abortSignal)
+				});
+				try {
+					await Promise.race([community._createAndSubscribeToNewUpdatingCommunity(community), cancellation.promise]);
+					await Promise.race([community.update(), cancellation.promise]);
+					await Promise.race([
+						updatePromise,
+						errorPromise,
+						cancellation.promise
+					]);
+				} catch (e) {
+					await community.stop().catch((stopErr) => log.error("Failed to stop a cancelled community instance", stopErr));
+					throw e;
+				} finally {
+					cancellation.cleanup();
+				}
 				await community.stop();
 				if (error) throw error;
 				await community._attachExportsSubscription();