@pkcprotocol/pkc-js 0.0.103 → 0.0.105

package/dist/bundled/chunks/{local-community-D0dqj6lQ.js → local-community-h9j5crnN.js}

@@ -1,6 +1,6 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { A as doesDomainAddressHaveCapitalLetter, B as ipnsNameToIpnsOverPubsubTopic, Bn as CommentEditPubsubMessagePublicationSchema, C as calculateStringSizeSameAsIpfsAddCidV0, Cn as CommentIpfsSchema, Cr as messages, Ct as findCommunityInRegistry, E as contentContainsMarkdownVideos, Et as findUpdatingCommunity, F as getErrorCodeFromMessage, Ft as trackUpdatingCommunity, Hn as CommentEditReservedFields, I as getIpnsRecordInLocalKuboNode, It as untrackStartedCommunity, J as isLinkOfImage, Jn as AuthorReservedFields, Jt as CommentModerationPubsubMessagePublicationSchema, K as isLinkOfAnimatedImage, Lr as ZodError, Mt as syncCommunityRegistryEntry, N as genToArray, Nn as CommentUpdateTableRowSchema, Nt as trackStartedCommunity, P as getEquivalentCommunityAddresses, Pn as CommentsTableRowSchema, R as hideClassPrivateProps, Rt as untrackUpdatingCommunity, S as calculateIpfsCidV0, Sr as PKCError, St as writeKuboFilesWithTimeout, T as contentContainsMarkdownImages, Ut as CommunityEditPublicationPubsubReservedFields, Vn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, Vt as pTimeout, Wn as CommentEditsTableRowSchema, X as isLinkOfVideo, Y as isLinkOfMedia, Yt as CommentModerationReservedFields, Z as isLinkValid, Zt as CommentModerationsTableRowSchema, _n as VotePubsubMessagePublicationSchema, _t as sleepUntilTimeoutOrAbort, a as ChallengeRequestMessageSchema, ar as t$6, at as removeBlocksFromKuboNode, b as areEquivalentCommunityAddresses, bn as VoteTablesRowSchema, bt as timestamp, ct as removeNullUndefinedValues, d as DecryptedChallengeRequestSchema, et as pubsubTopicToDhtKey, ft as retryKuboBlockPutPinAndProvidePubsubTopic, gr as require_retry, ir as t$7, jn as CommentUpdateSchema, k as derivePublicationFromChallengeRequest, lr as r$1, mn as isStringDomain, mr as t$3, mt as retryKuboIpfsAddAndProvide, nr as t$8, on as CommunityIpfsSchema, or as e, ot as removeMfsFilesSafely, pr as t$5, q as isLinkOfAudio, r as ChallengeMessageSchema, rr as n$3, s as ChallengeVerificationMessageSchema, sn as CommunitySignedPropertyNames, sr as e$1, t as ChallengeAnswerMessageSchema, tr as n$4, u as DecryptedChallengeRequestPublicationSchema, ur as t$4, vn as VotePubsubReservedFields, vt as statMfsPathSafely, w as contentContainsMarkdownAudio, wn as CommentPubsubMessageReservedFields, wr as logger_default, wt as findStartedCommunity, y as version_default, zt as require_sha256 } from "./schema-MeRr3oiN.js";
-import { $t as getPKCAddressFromPublicKeySync, A as deriveCommentIpfsFromCommentTableRow, At as verifyCommentEdit, B as resolveDbPostsCidRefs, C as encryptEd25519AesGcmPublicKeyBuffer, Ct as signCommunity, D as calculateInlineRepliesBudget, Dn as parseJsonWithPKCErrorIfFails, E as calculateExpectedSignatureSize, Et as verifyChallengeAnswer, F as getThumbnailPropsOfLink, Ft as verifyCommunity, G as POST_REPLIES_SORT_TYPES, Gt as getCommunityNameFromWire, I as importSignerIntoKuboNode, It as verifyCommunityEdit, Jt as decode, K as REPLY_REPLIES_SORT_TYPES, Kt as getCommunityPublicKeyFromWire, Lt as verifyVote, M as deriveDbReplies, Mt as verifyCommentModeration, N as getDefaultCommunityDbConfig, Nt as verifyCommentPubsubMessage, Ot as verifyChallengeRequest, Pt as verifyCommentUpdate, Q as iterateOverPageCidsToFindAllCids, Qt as getPKCAddressFromPublicKey, Rt as buildRuntimeAuthor, St as signCommentUpdateForChallengeVerification, T as backupCommunityDb, Vt as getAuthorNameFromWire, W as POSTS_SORT_TYPES, Yt as encode, Zt as getIpfsKeyFromPrivateKey, _ as SignerWithPublicKeyAddress, _t as signChallengeVerification, a as loadChallengeFileFromCommunityChallengeSettings, ar as r$2, c as TrackedInstanceRegistry, cr as n$5, d as MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS, dr as stringify, en as getPublicKeyFromPrivateKey, f as KeyvBetterSqlite3, fn as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, fr as STORAGE_KEYS, ht as signChallengeMessage, i as getCommunityChallengeFromCommunityChallengeSettings, ir as t$12, j as deriveDbPosts, jt as verifyCommentIpfs, k as deleteOldCommunityInWindows, l as LRUCache, mn as parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails, nr as effectiveMaxCrosspostDepth, o as pkcJsChallenges, or as t$11, pr as require_lodash_merge, pt as cleanUpBeforePublishing, q as TIMEFRAMES_TO_SECONDS, r as getChallengeVerification, rr as t$9, s as createAuthorIdentityMatcher, sr as n$6, t as RpcLocalCommunity, tn as createSchemaRowParser, tr as crosspostChainDepthUpTo, ur as t$10, ut as pLimit, vt as signComment, w as BackupAbortError, wn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, x as decryptEd25519AesGcmPublicKeyBuffer, xt as signCommentUpdate, yt as signCommentEdit, z as moveCommunityDbToDeletedDirectory, zt as cleanWireAuthor } from "./rpc-local-community-C3o1AzHp.js";
+import { A as doesDomainAddressHaveCapitalLetter, Bt as require_sha256, C as calculateStringSizeSameAsIpfsAddCidV0, Cr as PKCError, Ct as writeKuboFilesWithTimeout, Dt as findUpdatingCommunity, E as contentContainsMarkdownVideos, F as getErrorCodeFromMessage, Fn as CommentsTableRowSchema, Gn as CommentEditsTableRowSchema, Hn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema, Ht as pTimeout, I as getIpnsRecordInLocalKuboNode, It as trackUpdatingCommunity, J as isLinkOfAudio, Lt as untrackStartedCommunity, Mn as CommentUpdateSchema, N as genToArray, Nt as syncCommunityRegistryEntry, P as getEquivalentCommunityAddresses, Pn as CommentUpdateTableRowSchema, Pt as trackStartedCommunity, Q as isLinkValid, Qt as CommentModerationsTableRowSchema, Rr as ZodError, S as calculateIpfsCidV0, T as contentContainsMarkdownImages, Tn as CommentPubsubMessageReservedFields, Tr as logger_default, Tt as findStartedCommunity, Un as CommentEditReservedFields, V as ipnsNameToIpnsOverPubsubTopic, Vn as CommentEditPubsubMessagePublicationSchema, Wt as CommunityEditPublicationPubsubReservedFields, X as isLinkOfMedia, Xt as CommentModerationReservedFields, Y as isLinkOfImage, Yn as AuthorReservedFields, Yt as CommentModerationPubsubMessagePublicationSchema, Z as isLinkOfVideo, _r as require_retry, a as ChallengeRequestMessageSchema, ar as t$7, b as areEquivalentCommunityAddresses, cn as CommunitySignedPropertyNames, cr as e$1, d as DecryptedChallengeRequestSchema, dr as t$4, hn as isStringDomain, hr as t$3, ht as retryKuboIpfsAddAndProvide, ir as n$3, k as derivePublicationFromChallengeRequest, lt as removeNullUndefinedValues, mr as t$5, nr as n$4, or as t$6, ot as removeBlocksFromKuboNode, pt as retryKuboBlockPutPinAndProvidePubsubTopic, q as isLinkOfAnimatedImage, r as ChallengeMessageSchema, rr as t$8, s as ChallengeVerificationMessageSchema, sn as CommunityIpfsSchema, sr as e, st as removeMfsFilesSafely, t as ChallengeAnswerMessageSchema, tt as pubsubTopicToDhtKey, u as DecryptedChallengeRequestPublicationSchema, ur as r$1, vn as VotePubsubMessagePublicationSchema, vt as sleepUntilTimeoutOrAbort, w as contentContainsMarkdownAudio, wn as CommentIpfsSchema, wr as messages, wt as findCommunityInRegistry, xn as VoteTablesRowSchema, xt as timestamp, y as version_default, yn as VotePubsubReservedFields, yt as statMfsPathSafely, z as hideClassPrivateProps, zt as untrackUpdatingCommunity } from "./schema-bdQ9ufF9.js";
+import { $t as getIpfsKeyFromPrivateKey, At as verifyChallengeRequest, Bt as buildRuntimeAuthor, C as decryptEd25519AesGcmPublicKeyBuffer, Ct as signCommentUpdate, D as backupCommunityDb, E as BackupAbortError, En as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, F as getDefaultCommunityDbConfig, Ft as verifyCommentPubsubMessage, H as resolveDbPostsCidRefs, It as verifyCommentUpdate, J as REPLY_REPLIES_SORT_TYPES, Jt as getCommunityPublicKeyFromWire, K as POSTS_SORT_TYPES, L as getThumbnailPropsOfLink, Lt as verifyCommunity, M as deriveCommentIpfsFromCommentTableRow, Mt as verifyCommentEdit, N as deriveDbPosts, Nt as verifyCommentIpfs, O as calculateExpectedSignatureSize, Ot as verifyChallengeAnswer, P as deriveDbReplies, Pt as verifyCommentModeration, R as importSignerIntoKuboNode, Rt as verifyCommunityEdit, T as encryptEd25519AesGcmPublicKeyBuffer, Tt as signCommunity, Ut as getAuthorNameFromWire, V as moveCommunityDbToDeletedDirectory, Vt as cleanWireAuthor, Xt as decode, Y as TIMEFRAMES_TO_SECONDS, Zt as encode, _r as STORAGE_KEYS, _t as signChallengeMessage, a as loadChallengeFileFromCommunityChallengeSettings, ar as t$9, bt as signComment, c as authorNameResolveFailureReason, cr as t$11, d as LRUCache, en as getPKCAddressFromPublicKey, et as iterateOverPageCidsToFindAllCids, fr as t$10, ft as pLimit, gn as parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails, ht as cleanUpBeforePublishing, i as getCommunityChallengeFromCommunityChallengeSettings, ir as effectiveMaxCrosspostDepth, j as deleteOldCommunityInWindows, k as calculateInlineRepliesBudget, kn as parseJsonWithPKCErrorIfFails, l as createAuthorIdentityMatcher, lr as n$6, m as KeyvBetterSqlite3, mn as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, nn as getPublicKeyFromPrivateKey, o as pkcJsChallenges, or as t$12, p as MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS, pr as stringify, q as POST_REPLIES_SORT_TYPES, qt as getCommunityNameFromWire, r as getChallengeVerification, rn as createSchemaRowParser, rr as crosspostChainDepthUpTo, s as authorIdentityMatcherForRequest, sr as r$2, t as RpcLocalCommunity, tn as getPKCAddressFromPublicKeySync, u as TrackedInstanceRegistry, ur as n$5, vr as require_lodash_merge, wt as signCommentUpdateForChallengeVerification, xt as signCommentEdit, y as SignerWithPublicKeyAddress, yt as signChallengeVerification, zt as verifyVote } from "./rpc-local-community-CP0JZU-Q.js";
 import { randomFillSync, randomUUID } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import Path from "node:path";
@@ -831,8 +831,14 @@ async function publishIdempotentDuplicateVerification(community, request, challe
 	delete community._challengeExchangesFromLocalPublishers[challengeRequestId.toString()];
 	cleanUpChallengeAnswerPromise(community, challengeRequestId.toString());
 }
-async function storePublicationAndEncryptForChallengeVerification(community, request, pendingApproval, challengeAggregate) {
-	const commentAfterAddingToIpfs = await storePublication(community, request, pendingApproval, challengeAggregate);
+async function storePublicationAndEncryptForChallengeVerification({ community, request, pendingApproval, challengeAggregate, authorIdentityMatcher }) {
+	const commentAfterAddingToIpfs = await storePublication({
+		community,
+		request,
+		pendingApproval,
+		challengeAggregate,
+		authorIdentityMatcher
+	});
 	if (!commentAfterAddingToIpfs) return void 0;
 	const authorSignerAddress = await getPKCAddressFromPublicKey(commentAfterAddingToIpfs.comment.signature.publicKey);
 	const authorDomain = getAuthorNameFromWire(commentAfterAddingToIpfs.comment.author);
@@ -864,14 +870,20 @@ async function storePublicationAndEncryptForChallengeVerification(community, req
 		encrypted
 	};
 }
-async function publishChallengeVerification(community, challengeResult, request, pendingApproval, challengeAggregate) {
+async function publishChallengeVerification({ community, challengeResult, request, pendingApproval, challengeAggregate, authorIdentityMatcher }) {
 	const log = logger_default("pkc-js:local-community:_publishChallengeVerification");
 	if (!challengeResult.challengeSuccess) return publishFailedChallengeVerification(community, challengeResult, request.challengeRequestId);
 	else {
 		let failureReason;
 		let toEncrypt;
 		try {
-			toEncrypt = await storePublicationAndEncryptForChallengeVerification(community, request, pendingApproval, challengeAggregate);
+			toEncrypt = await storePublicationAndEncryptForChallengeVerification({
+				community,
+				request,
+				pendingApproval,
+				challengeAggregate,
+				authorIdentityMatcher
+			});
 		} catch (e) {
 			const error = e;
 			if (DUPLICATE_PUBLICATION_ERRORS.has(error.message)) {
@@ -1034,7 +1046,17 @@ async function validatePublicationOrRespondWithFailure({ community, decryptedReq
 		request: decryptedRequestMsg,
 		authorCommunity: communityAuthor
 	});
-	const publicationInvalidityReason = await checkPublicationValidity(community, decryptedRequestMsg, publication, communityAuthor);
+	const authorIdentityMatcher = createAuthorIdentityMatcher({
+		community,
+		publication
+	});
+	const publicationInvalidityReason = await checkPublicationValidity({
+		community,
+		request: decryptedRequestMsg,
+		publication,
+		authorCommunity: communityAuthor,
+		authorIdentityMatcher
+	});
 	if (publicationInvalidityReason) {
 		if (DUPLICATE_PUBLICATION_ERRORS.has(publicationInvalidityReason)) {
 			const sig = publication.signature.signature;
@@ -1055,11 +1077,12 @@ async function validatePublicationOrRespondWithFailure({ community, decryptedReq
 		decryptedRequestMsg,
 		decryptedRequestWithCommunityAuthor,
 		publication,
-		communityAuthor
+		communityAuthor,
+		authorIdentityMatcher
 	};
 }
 async function runChallengeExchangeIfNeeded(community, parsed, log) {
-	const { decryptedRequestWithCommunityAuthor } = parsed;
+	const { decryptedRequestWithCommunityAuthor, authorIdentityMatcher } = parsed;
 	const answerPromiseKey = decryptedRequestWithCommunityAuthor.challengeRequestId.toString();
 	const getChallengeAnswers = async (challenges) => {
 		await publishChallenges(community, challenges, decryptedRequestWithCommunityAuthor);
@@ -1087,7 +1110,8 @@ async function runChallengeExchangeIfNeeded(community, parsed, log) {
 		challengeVerification = await getChallengeVerification({
 			challengeRequestMessage: decryptedRequestWithCommunityAuthor,
 			community,
-			getChallengeAnswers
+			getChallengeAnswers,
+			authorIdentityMatcher
 		});
 	} catch (e) {
 		if (e instanceof PKCError && e.code === "ERR_COMMUNITY_TIMED_OUT_WAITING_FOR_CHALLENGE_ANSWER") {
@@ -1114,11 +1138,18 @@ async function runVerificationAndStorePublication(community, parsed, challengeVe
 		aggregatedCommentUpdate: challengeVerification.aggregatedCommentUpdate,
 		aggregatedReason: challengeVerification.aggregatedReason
 	};
-	await publishChallengeVerification(community, {
-		challengeSuccess: challengeVerification.challengeSuccess,
-		challengeErrors: challengeVerification.challengeErrors,
-		reason: challengeVerification.reason ?? challengeVerification.aggregatedReason
-	}, parsed.decryptedRequestMsg, challengeVerification.pendingApproval, aggregate);
+	await publishChallengeVerification({
+		community,
+		challengeResult: {
+			challengeSuccess: challengeVerification.challengeSuccess,
+			challengeErrors: challengeVerification.challengeErrors,
+			reason: challengeVerification.reason ?? challengeVerification.aggregatedReason
+		},
+		request: parsed.decryptedRequestMsg,
+		pendingApproval: challengeVerification.pendingApproval,
+		challengeAggregate: aggregate,
+		authorIdentityMatcher: challengeVerification.postAnswerAuthorIdentityMatcher ?? parsed.authorIdentityMatcher
+	});
 }
 async function handleChallengeRequest(community, request, isLocalPublisher) {
 	const log = logger_default("pkc-js:local-community:handleChallengeRequest");
@@ -1262,14 +1293,11 @@ async function handleChallengeExchange(community, pubsubMsg) {
 function isFlairInAllowedList(flair, allowedFlairs) {
 	return allowedFlairs.some((allowed) => t$11(allowed, flair));
 }
-async function isPublicationAuthorPartOfRoles(community, publication, rolesToCheckAgainst) {
-	if (!community.roles) return false;
+async function matchPublicationAuthorAgainstRoles({ community, rolesToCheckAgainst, authorIdentityMatcher }) {
+	if (!community.roles) return { matched: false };
 	const roleKeys = Object.keys(community.roles).filter((roleKey) => rolesToCheckAgainst.includes(community.roles[roleKey].role));
-	if (roleKeys.length === 0) return false;
-	return createAuthorIdentityMatcher({
-		community,
-		publication
-	}).matchesAnyIdentity(roleKeys);
+	if (roleKeys.length === 0) return { matched: false };
+	return authorIdentityMatcher.matchesAnyIdentity(roleKeys);
 }
 async function respondWithErrorIfSignatureOfPublicationIsInvalid(community, request) {
 	let validity;
@@ -1336,12 +1364,12 @@ async function checkAuthorIdentity(community, publication, log) {
 				cache: { maxAge: 1800 }
 			}));
 		} catch (e) {
-			log("Rejecting publication with unresolvable author domain", authorName, e);
-			return messages.ERR_FAILED_TO_RESOLVE_AUTHOR_DOMAIN;
+			log("Rejecting publication with unresolvable author name", authorName, e instanceof PKCError ? e.code : void 0, e);
+			return authorNameResolveFailureReason({ error: e });
 		}
 		if (resolvedAddress === null) {
-			log("Rejecting publication: author domain could not be resolved", authorName);
-			return messages.ERR_FAILED_TO_RESOLVE_AUTHOR_DOMAIN;
+			log("Rejecting publication: author name has no record", authorName);
+			return authorNameResolveFailureReason({ error: null });
 		}
 		const signerAddress = await getPKCAddressFromPublicKey(publication.signature.publicKey);
 		if (resolvedAddress !== signerAddress) {
@@ -1350,7 +1378,7 @@ async function checkAuthorIdentity(community, publication, log) {
 		}
 	}
 }
-async function checkParentAndPostState(community, request, publication) {
+async function checkParentAndPostState(community, request, publication, authorIdentityMatcher) {
 	if ("commentCid" in publication || "parentCid" in publication) {
 		const parentCid = publication.parentCid || publication.commentCid;
 		if (typeof parentCid !== "string") return messages.ERR_COMMUNITY_PUBLICATION_PARENT_CID_NOT_DEFINED;
@@ -1362,11 +1390,19 @@ async function checkParentAndPostState(community, request, publication) {
 		if (postFlags.removed && !request.commentModeration) return messages.ERR_COMMUNITY_PUBLICATION_POST_HAS_BEEN_REMOVED;
 		if (community._dbHandler.queryAuthorEditDeleted(parent.postCid)?.deleted && !request.commentModeration) return messages.ERR_COMMUNITY_PUBLICATION_POST_HAS_BEEN_DELETED;
 		if (postFlags.locked && !request.commentModeration) {
-			if (!(!request.vote && await isPublicationAuthorPartOfRoles(community, publication, [
-				"owner",
-				"admin",
-				"moderator"
-			]))) return messages.ERR_COMMUNITY_PUBLICATION_POST_IS_LOCKED;
+			const lockBypass = request.vote ? { matched: false } : await matchPublicationAuthorAgainstRoles({
+				community,
+				rolesToCheckAgainst: [
+					"owner",
+					"admin",
+					"moderator"
+				],
+				authorIdentityMatcher
+			});
+			if (!lockBypass.matched) {
+				if (lockBypass.nameFailure) return lockBypass.nameFailure.reason;
+				return messages.ERR_COMMUNITY_PUBLICATION_POST_IS_LOCKED;
+			}
 		}
 		if (postFlags.archived && !request.commentModeration) return messages.ERR_COMMUNITY_PUBLICATION_POST_IS_ARCHIVED;
 		if (parent.timestamp > publication.timestamp) return messages.ERR_COMMUNITY_COMMENT_TIMESTAMP_IS_EARLIER_THAN_PARENT;
@@ -1451,16 +1487,24 @@ async function checkVotePublication(community, request) {
 	const voteAuthorSignerAddress = await getPKCAddressFromPublicKey(votePublication.signature.publicKey);
 	if (!community._dbHandler.queryVote(commentToVoteOn.cid, voteAuthorSignerAddress) && votePublication.vote === 0) return messages.ERR_THERE_IS_NO_PREVIOUS_VOTE_TO_CANCEL;
 }
-async function checkCommentModerationPublication(community, request) {
+async function checkCommentModerationPublication(community, request, authorIdentityMatcher) {
 	if (!request.commentModeration) return void 0;
 	const commentModerationPublication = request.commentModeration;
 	if (r$2(CommentModerationReservedFields, t$6(commentModerationPublication)).length > 0) return messages.ERR_COMMENT_MODERATION_HAS_RESERVED_FIELD;
-	const isAuthorMod = await isPublicationAuthorPartOfRoles(community, commentModerationPublication, [
-		"owner",
-		"moderator",
-		"admin"
-	]);
-	if (!isAuthorMod) return messages.ERR_COMMENT_MODERATION_ATTEMPTED_WITHOUT_BEING_MODERATOR;
+	const modMatch = await matchPublicationAuthorAgainstRoles({
+		community,
+		rolesToCheckAgainst: [
+			"owner",
+			"moderator",
+			"admin"
+		],
+		authorIdentityMatcher
+	});
+	const isAuthorMod = modMatch.matched;
+	if (!isAuthorMod) {
+		if (modMatch.nameFailure) return modMatch.nameFailure.reason;
+		return messages.ERR_COMMENT_MODERATION_ATTEMPTED_WITHOUT_BEING_MODERATOR;
+	}
 	const commentToBeEdited = community._dbHandler.queryComment(commentModerationPublication.commentCid);
 	if (!commentToBeEdited) return messages.ERR_COMMENT_MODERATION_NO_COMMENT_TO_EDIT;
 	if (isAuthorMod && commentModerationPublication.commentModeration.locked && commentToBeEdited.depth !== 0) return messages.ERR_COMMUNITY_COMMENT_MOD_CAN_NOT_LOCK_REPLY;
@@ -1469,14 +1513,30 @@ async function checkCommentModerationPublication(community, request) {
 	if (community._dbHandler.hasCommentModerationWithSignatureEncoded(commentModerationPublication.signature.signature)) return messages.ERR_DUPLICATE_COMMENT_MODERATION;
 	if ("approved" in commentModerationPublication.commentModeration && !commentToBeEdited.pendingApproval) return messages.ERR_MOD_ATTEMPTING_TO_APPROVE_OR_DISAPPROVE_COMMENT_THAT_IS_NOT_PENDING;
 }
-async function checkCommunityEditPublication(community, request) {
+async function checkCommunityEditPublication(community, request, authorIdentityMatcher) {
 	if (!request.communityEdit) return void 0;
 	const communityEdit = request.communityEdit;
 	if (r$2(CommunityEditPublicationPubsubReservedFields, t$6(communityEdit)).length > 0) return messages.ERR_COMMUNITY_EDIT_HAS_RESERVED_FIELD;
 	if (communityEdit.communityEdit.roles || communityEdit.communityEdit.address || communityEdit.communityEdit.name) {
-		if (!await isPublicationAuthorPartOfRoles(community, communityEdit, ["owner"])) return messages.ERR_COMMUNITY_EDIT_ATTEMPTED_TO_MODIFY_OWNER_EXCLUSIVE_PROPS;
+		const ownerMatch = await matchPublicationAuthorAgainstRoles({
+			community,
+			rolesToCheckAgainst: ["owner"],
+			authorIdentityMatcher
+		});
+		if (!ownerMatch.matched) {
+			if (ownerMatch.nameFailure) return ownerMatch.nameFailure.reason;
+			return messages.ERR_COMMUNITY_EDIT_ATTEMPTED_TO_MODIFY_OWNER_EXCLUSIVE_PROPS;
+		}
+	}
+	const ownerOrAdminMatch = await matchPublicationAuthorAgainstRoles({
+		community,
+		rolesToCheckAgainst: ["owner", "admin"],
+		authorIdentityMatcher
+	});
+	if (!ownerOrAdminMatch.matched) {
+		if (ownerOrAdminMatch.nameFailure) return ownerOrAdminMatch.nameFailure.reason;
+		return messages.ERR_COMMUNITY_EDIT_ATTEMPTED_TO_MODIFY_COMMUNITY_WITHOUT_BEING_OWNER_OR_ADMIN;
 	}
-	if (!await isPublicationAuthorPartOfRoles(community, communityEdit, ["owner", "admin"])) return messages.ERR_COMMUNITY_EDIT_ATTEMPTED_TO_MODIFY_COMMUNITY_WITHOUT_BEING_OWNER_OR_ADMIN;
 	const allowedCommunityEditKeys = [...t$6(CommunityIpfsSchema.shape), "address"];
 	if (r$1(t$6(communityEdit.communityEdit), allowedCommunityEditKeys).length > 0) return messages.ERR_COMMUNITY_EDIT_ATTEMPTED_TO_NON_PUBLIC_PROPS;
 }
@@ -1502,22 +1562,26 @@ async function checkCommentEditPublication(community, request) {
 		for (const flair of commentEditPublication.flairs) if (!isFlairInAllowedList(flair, allowedPostFlairs)) return messages.ERR_POST_FLAIR_NOT_IN_ALLOWED_FLAIRS;
 	}
 }
-async function checkPublicationValidity(community, request, publication, authorCommunity) {
+async function checkPublicationValidity({ community, request, publication, authorCommunity, authorIdentityMatcher: sharedAuthorIdentityMatcher }) {
+	const authorIdentityMatcher = sharedAuthorIdentityMatcher ?? authorIdentityMatcherForRequest({
+		community,
+		request
+	});
 	const log = logger_default("pkc-js:local-community:handleChallengeRequest:checkPublicationValidity");
 	const wireResult = await checkWireFormatAndCommunityAuthor(community, publication, authorCommunity);
 	if (wireResult) return wireResult;
 	const authorResult = await checkAuthorIdentity(community, publication, log);
 	if (authorResult) return authorResult;
-	const parentResult = await checkParentAndPostState(community, request, publication);
+	const parentResult = await checkParentAndPostState(community, request, publication, authorIdentityMatcher);
 	if (parentResult) return parentResult;
 	if (Buffer.byteLength(JSON.stringify(publication)) / 1e3 > 40) return messages.ERR_REQUEST_PUBLICATION_OVER_ALLOWED_SIZE;
 	const commentResult = await checkCommentPublication(community, request);
 	if (commentResult) return commentResult;
 	const voteResult = await checkVotePublication(community, request);
 	if (voteResult) return voteResult;
-	const modResult = await checkCommentModerationPublication(community, request);
+	const modResult = await checkCommentModerationPublication(community, request, authorIdentityMatcher);
 	if (modResult) return modResult;
-	const communityEditResult = await checkCommunityEditPublication(community, request);
+	const communityEditResult = await checkCommunityEditPublication(community, request, authorIdentityMatcher);
 	if (communityEditResult) return communityEditResult;
 	const commentEditResult = await checkCommentEditPublication(community, request);
 	if (commentEditResult) return commentEditResult;
@@ -1571,14 +1635,26 @@ async function resolveAliasPrivateKeyForCommentPublication(community, opts) {
 		return (await community._pkc.createSigner()).privateKey;
 	} else throw Error(`Unsupported pseudonymityMode (${opts.mode})`);
 }
-async function prepareCommentWithAnonymity(community, originalComment) {
+async function prepareCommentWithAnonymity({ community, originalComment, authorIdentityMatcher = createAuthorIdentityMatcher({
+	community,
+	publication: originalComment
+}) }) {
 	const mode = community.features?.pseudonymityMode;
 	if (!mode) return { publication: originalComment };
-	if (await isPublicationAuthorPartOfRoles(community, originalComment, [
-		"owner",
-		"admin",
-		"moderator"
-	])) return { publication: originalComment };
+	const modMatch = await matchPublicationAuthorAgainstRoles({
+		community,
+		rolesToCheckAgainst: [
+			"owner",
+			"admin",
+			"moderator"
+		],
+		authorIdentityMatcher
+	});
+	if (modMatch.matched) return { publication: originalComment };
+	if (modMatch.nameFailure) throw new PKCError(getErrorCodeFromMessage(modMatch.nameFailure.reason), {
+		comment: originalComment,
+		nameFailureError: modMatch.nameFailure.error
+	});
 	const originalAuthorPublicKey = originalComment.signature.publicKey;
 	const postCid = originalComment.postCid;
 	const aliasPrivateKey = await resolveAliasPrivateKeyForCommentPublication(community, {
@@ -1831,13 +1907,20 @@ async function storeComment(community, opts) {
 		cid: commentCid
 	};
 }
-async function storePublication(community, request, pendingApproval, challengeAggregate) {
+async function storePublication({ community, request, pendingApproval, challengeAggregate, authorIdentityMatcher }) {
 	if (request.vote) return storeVote(community, request.vote, request.challengeRequestId);
 	else if (request.commentEdit) return storeCommentEdit(community, await prepareCommentEditWithAlias(community, request.commentEdit), request.challengeRequestId);
 	else if (request.commentModeration) return storeCommentModeration(community, request.commentModeration, request.challengeRequestId);
 	else if (request.comment) {
 		const originalCommentSignatureEncoded = request.comment.signature.signature;
-		const { publication, anonymity } = await prepareCommentWithAnonymity(community, request.comment);
+		const { publication, anonymity } = await prepareCommentWithAnonymity({
+			community,
+			originalComment: request.comment,
+			authorIdentityMatcher: authorIdentityMatcher ?? authorIdentityMatcherForRequest({
+				community,
+				request
+			})
+		});
 		const storedComment = await storeComment(community, {
 			commentPubsub: publication,
 			pendingApproval,
@@ -7231,16 +7314,21 @@ async function parseRolesToEdit(community, newRawRoles) {
 		if (roleValue === void 0 || roleValue === null) continue;
 		if (isStringDomain(roleAddress)) {
 			let resolved;
+			let resolveError;
 			try {
 				({resolvedAuthorName: resolved} = await community._clientsManager.resolveAuthorNameIfNeeded({
 					authorName: roleAddress,
 					abortSignal: AbortSignal.timeout(community._pkc._timeouts["resolve-author-name"]),
 					cache: { maxAge: 0 }
 				}));
-			} catch {
+			} catch (e) {
 				resolved = null;
+				resolveError = e;
 			}
-			if (!resolved) throw new PKCError("ERR_ROLE_ADDRESS_NAME_COULD_NOT_BE_RESOLVED", { roleAddress });
+			if (!resolved) throw new PKCError("ERR_ROLE_ADDRESS_NAME_COULD_NOT_BE_RESOLVED", {
+				roleAddress,
+				resolveError
+			});
 		}
 	}
 	return t$8(newRawRoles, (val, key) => val === void 0 || val === null);
@@ -7853,7 +7941,11 @@ var LocalCommunity = class extends RpcLocalCommunity {
 		return repinCommentsIPFSIfNeeded(this);
 	}
 	async storePublication(request, pendingApproval) {
-		return storePublication(this, request, pendingApproval);
+		return storePublication({
+			community: this,
+			request,
+			pendingApproval
+		});
 	}
 	async updateCommunityIpnsIfNeeded(args) {
 		return updateCommunityIpnsIfNeeded(this, args.commentUpdateRowsToPublishToIpfs);
@@ -7883,13 +7975,20 @@ var LocalCommunity = class extends RpcLocalCommunity {
 		return purgeDisapprovedCommentsOlderThan(this);
 	}
 	async _publishChallengeVerification(challengeResult, request) {
-		return publishChallengeVerification(this, challengeResult, request);
+		return publishChallengeVerification({
+			community: this,
+			challengeResult,
+			request
+		});
 	}
 	async _publishIdempotentDuplicateVerification(...args) {
 		return publishIdempotentDuplicateVerification(this, ...args);
 	}
-	async _checkPublicationValidity(...args) {
-		return checkPublicationValidity(this, ...args);
+	async _checkPublicationValidity(args) {
+		return checkPublicationValidity({
+			...args,
+			community: this
+		});
 	}
 	_calculateLocalMfsPathForCommentUpdate(...args) {
 		return calculateLocalMfsPathForCommentUpdate(this, ...args);

package/dist/bundled/chunks/{node--l7gxhms.js → node-Czo2D65i.js}

@@ -1,7 +1,7 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { A as doesDomainAddressHaveCapitalLetter, At as refreshTrackedCommentAliases, B as ipnsNameToIpnsOverPubsubTopic, Br as stringifyPrimitive, Bt as TimeoutError, Cn as CommentIpfsSchema, Cr as messages, D as createAbortError, Dr as setErrorMap, Dt as listStartedCommunities, Et as findUpdatingCommunity, H as isIpfsCid, Lt as untrackUpdatingComment, O as deepMergeRuntimeFields, On as CommentUpdateForChallengeVerificationSchema, Ot as listUpdatingComments, Pt as trackUpdatingComment, R as hideClassPrivateProps, Rr as joinValues, Sr as PKCError, Tt as findUpdatingComment, V as isAbortError, Vt as pTimeout, W as isIpns, _r as FailedToFetchCommentIpfsFromGatewaysError, _t as sleepUntilTimeoutOrAbort, a as ChallengeRequestMessageSchema, ar as t$1, b as areEquivalentCommunityAddresses, bt as timestamp, dt as resolveWhenPredicateIsTrue, fn as PubsubTopicSchema, gr as require_retry, gt as shortifyCid, ht as shortifyAddress, it as rejectWhenCommunityStopsOrAborts, jn as CommentUpdateSchema, kt as listUpdatingCommunities, lr as r, lt as removeUndefinedValuesRecursively, mn as isStringDomain, on as CommunityIpfsSchema, or as e, pt as retryKuboIpfsAdd, r as ChallengeMessageSchema, rr as n$1, rt as rejectWhenAbortSignalFires, s as ChallengeVerificationMessageSchema, sr as e$1, t as ChallengeAnswerMessageSchema, tn as CommunityAnchorSchema, tr as n$2, ut as replaceXWithY, wr as logger_default, wt as findStartedCommunity, xt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, y as version_default, yt as throwIfAbortSignalAborted, zr as parsedType, zt as require_sha256 } from "./schema-MeRr3oiN.js";
-import { $ as parseRawPages, $n as RpcSuccessResultSchema, $t as getPKCAddressFromPublicKeySync, An as parseRpcCommentUpdateEventWithPKCErrorIfItFails, At as verifyCommentEdit, Bn as RpcCommunityPageParamSchema, Bt as getAuthorNameFromRuntime, Cn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, Dn as parseJsonWithPKCErrorIfFails, Dt as verifyChallengeMessage, En as parseDecryptedChallengeWithPKCErrorIfItFails, Fn as RpcAuthorNameParamSchema, Gn as RpcExportCommunityResultSchema, Gt as getCommunityNameFromWire, H as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Hn as RpcExportCommunityModLogsParamSchema, Ht as normalizeCreatePublicationAuthor, In as RpcCancelExportParamSchema, It as verifyCommunityEdit, Jn as RpcPublishAnchorRecordParamSchema, Jt as decode, Kn as RpcFetchCidParamSchema, Kt as getCommunityPublicKeyFromWire, L as listCommunitiesSync, Ln as RpcCidParamSchema, Lt as verifyVote, Mt as verifyCommentModeration, Nn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Nt as verifyCommentPubsubMessage, O as createKuboRpcClient, On as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, P as getDefaultDataPath, Pn as RpcAnchorPublishPreparationResultSchema, Pt as verifyCommentUpdate, Qn as RpcSubscriptionIdResultSchema, R as monitorCommunitiesDirectory, Rn as RpcCommentRepliesPageParamSchema, Rt as buildRuntimeAuthor, S as encryptEd25519AesGcm, Sn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, Tn as parseDecryptedChallengeVerification, Tt as signVote, U as CommentClientsManager, Un as RpcExportCommunityModLogsResultSchema, Ut as buildRuntimeCommunityFields, V as setNativeFunctions$1, Vn as RpcEditCommunityParamSchema, Wn as RpcExportCommunityParamSchema, Wt as getCommunityAddressFromRecord, X as extractCommunityRuntimeFieldsFromParsedPages, Xn as RpcPublishedAnchorRecordResultSchema, Xt as getBufferedPKCAddressFromPublicKey, Yn as RpcPublishChallengeAnswersParamSchema, Z as findCommentInPageInstanceRecursively, Zn as RpcResolveAuthorNameResultSchema, _n as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, an as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, at as stripNameResolvedFromCrosspost, b as decryptEd25519AesGcm, bt as signCommentModeration, c as TrackedInstanceRegistry, cn as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ct as InflightFetchManager, dt as PKCTypedEmitter, er as RpcUnsubscribeParamSchema, et as RepliesPages, f as KeyvBetterSqlite3, ft as require_lib$1, g as decodeRpcChallengeVerificationPubsubMsg, gn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, gt as signChallengeRequest, h as decodeRpcChallengeRequestPubsubMsg, hn as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, hr as require_undici, jn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, jt as verifyCommentIpfs, kn as parseRpcCommentEventWithPKCErrorIfItFails, kt as verifyChallengeVerification, l as LRUCache, ln as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, lr as t$2, m as decodeRpcChallengePubsubMsg, mr as nativeFunctions$2, mt as signChallengeAnswer, n as RpcRemoteCommunity, nn as parseCidStringSchemaWithPKCErrorIfItFails, nt as cloneCrosspostForRuntime, o as pkcJsChallenges, on as parseCommentIpfsSchemaWithPKCErrorIfItFails, or as t$3, ot as PublicationClientsManager, p as decodeRpcChallengeAnswerPubsubMsg, pn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, pt as cleanUpBeforePublishing, qn as RpcFetchCidResultSchema, qt as normalizeCommunityInputFromCommunity, rr as t$4, rt as collectCrosspostAuthorsToResolve, sr as n$3, st as PKCClientsManager, t as RpcLocalCommunity, tt as applyNameResolvedCacheToCrosspost, u as RemoteCommunity, un as parseCommunityAddressWithPKCErrorIfItFails, ur as t$5, v as createSigner, vn as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, vt as signComment, wn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, wt as signCommunityEdit, xn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, y as createAnchorIpnsRecord$1, yt as signCommentEdit, zn as RpcCommunityIdentifierParamSchema, zt as cleanWireAuthor } from "./rpc-local-community-C3o1AzHp.js";
-import { o as getHeliaDebugContext } from "./util-CjRKlVEE.js";
+import { A as doesDomainAddressHaveCapitalLetter, At as listUpdatingCommunities, Br as parsedType, Bt as require_sha256, Cr as PKCError, D as createAbortError, Dt as findUpdatingCommunity, Et as findUpdatingComment, Ft as trackUpdatingComment, G as isIpns, H as isAbortError, Ht as pTimeout, Mn as CommentUpdateSchema, O as deepMergeRuntimeFields, Or as setErrorMap, Ot as listStartedCommunities, Rt as untrackUpdatingComment, St as waitForUpdateInCommunityInstanceWithErrorAndTimeout, Tr as logger_default, Tt as findStartedCommunity, U as isIpfsCid, V as ipnsNameToIpnsOverPubsubTopic, Vr as stringifyPrimitive, Vt as TimeoutError, _r as require_retry, _t as shortifyCid, a as ChallengeRequestMessageSchema, at as rejectWhenCommunityStopsOrAborts, b as areEquivalentCommunityAddresses, bt as throwIfAbortSignalAborted, cr as e$1, dt as replaceXWithY, ft as resolveWhenPredicateIsTrue, gt as shortifyAddress, hn as isStringDomain, ir as n$1, it as rejectWhenAbortSignalFires, jt as refreshTrackedCommentAliases, kn as CommentUpdateForChallengeVerificationSchema, kt as listUpdatingComments, mt as retryKuboIpfsAdd, nn as CommunityAnchorSchema, nr as n$2, or as t$1, pn as PubsubTopicSchema, r as ChallengeMessageSchema, s as ChallengeVerificationMessageSchema, sn as CommunityIpfsSchema, sr as e, t as ChallengeAnswerMessageSchema, ur as r, ut as removeUndefinedValuesRecursively, vr as FailedToFetchCommentIpfsFromGatewaysError, vt as sleepUntilTimeoutOrAbort, wn as CommentIpfsSchema, wr as messages, xt as timestamp, y as version_default, z as hideClassPrivateProps, zr as joinValues } from "./schema-bdQ9ufF9.js";
+import { $ as findCommentInPageInstanceRecursively, $n as RpcResolveAuthorNameResultSchema, A as createKuboRpcClient, An as parsePKCUserOptionsSchemaWithPKCErrorIfItFails, B as monitorCommunitiesDirectory, Bn as RpcCommentRepliesPageParamSchema, Bt as buildRuntimeAuthor, Cn as parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, Dn as parseDecryptedChallengeVerification, Dt as signVote, En as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, Et as signCommunityEdit, Fn as parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails, Ft as verifyCommentPubsubMessage, G as CommentClientsManager, Gn as RpcExportCommunityModLogsResultSchema, Gt as buildRuntimeCommunityFields, Hn as RpcCommunityPageParamSchema, Ht as getAuthorNameFromRuntime, I as getDefaultDataPath, In as RpcAnchorPublishPreparationResultSchema, It as verifyCommentUpdate, Jn as RpcFetchCidParamSchema, Jt as getCommunityPublicKeyFromWire, Kn as RpcExportCommunityParamSchema, Kt as getCommunityAddressFromRecord, Ln as RpcAuthorNameParamSchema, Mn as parseRpcCommentUpdateEventWithPKCErrorIfItFails, Mt as verifyCommentEdit, Nn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, Nt as verifyCommentIpfs, On as parseDecryptedChallengeWithPKCErrorIfItFails, Pt as verifyCommentModeration, Q as extractCommunityRuntimeFieldsFromParsedPages, Qn as RpcPublishedAnchorRecordResultSchema, Qt as getBufferedPKCAddressFromPublicKey, Rn as RpcCancelExportParamSchema, Rt as verifyCommunityEdit, S as decryptEd25519AesGcm, St as signCommentModeration, Tn as parseCreateVoteOptionsSchemaWithPKCErrorIfItFails, U as setNativeFunctions$1, Un as RpcEditCommunityParamSchema, Vn as RpcCommunityIdentifierParamSchema, Vt as cleanWireAuthor, W as tryToDeleteCommunitiesThatFailedToBeDeletedBefore, Wn as RpcExportCommunityModLogsParamSchema, Wt as normalizeCreatePublicationAuthor, Xn as RpcPublishAnchorRecordParamSchema, Xt as decode, Yn as RpcFetchCidResultSchema, Yt as normalizeCommunityInputFromCommunity, Zn as RpcPublishChallengeAnswersParamSchema, _ as decodeRpcChallengeRequestPubsubMsg, _n as parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails, ar as t$4, at as collectCrosspostAuthorsToResolve, b as createSigner, bn as parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails, br as require_undici, bt as signComment, cn as parseCommentIpfsSchemaWithPKCErrorIfItFails, cr as t$3, ct as PublicationClientsManager, d as LRUCache, dn as parseCommentPubsubMessagePublicationWithPKCErrorIfItFails, dr as t$2, er as RpcSubscriptionIdResultSchema, f as RemoteCommunity, fn as parseCommunityAddressWithPKCErrorIfItFails, fr as t$5, g as decodeRpcChallengePubsubMsg, gr as NAME_RESOLVE_FAILED_RETRY_FLOOR_MS, gt as signChallengeAnswer, h as decodeRpcChallengeAnswerPubsubMsg, hn as parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, hr as NAME_RESOLVED_TRUE_TTL_MS, ht as cleanUpBeforePublishing, in as parseCidStringSchemaWithPKCErrorIfItFails, it as cloneCrosspostForRuntime, jn as parseRpcCommentEventWithPKCErrorIfItFails, jt as verifyChallengeVerification, kn as parseJsonWithPKCErrorIfFails, kt as verifyChallengeMessage, lr as n$3, lt as PKCClientsManager, m as KeyvBetterSqlite3, mr as NAME_RESOLVED_FALSE_TTL_MS, mt as require_lib$1, n as RpcRemoteCommunity, nr as RpcUnsubscribeParamSchema, nt as RepliesPages, o as pkcJsChallenges, pt as PKCTypedEmitter, qn as RpcExportCommunityResultSchema, qt as getCommunityNameFromWire, rt as applyNameResolvedCacheToCrosspost, sn as parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails, st as stripNameResolvedFromCrosspost, t as RpcLocalCommunity, tn as getPKCAddressFromPublicKeySync, tr as RpcSuccessResultSchema, tt as parseRawPages, u as TrackedInstanceRegistry, un as parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails, ut as InflightFetchManager, v as decodeRpcChallengeVerificationPubsubMsg, vn as parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails, vt as signChallengeRequest, w as encryptEd25519AesGcm, wn as parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails, x as createAnchorIpnsRecord$1, xt as signCommentEdit, yn as parseCreateCommentOptionsSchemaWithPKCErrorIfItFails, yr as nativeFunctions$2, z as listCommunitiesSync, zn as RpcCidParamSchema, zt as verifyVote } from "./rpc-local-community-CP0JZU-Q.js";
+import { o as getHeliaDebugContext } from "./util-CEpMupHn.js";
 import path from "path";
 import assert from "assert";
 import fs from "fs";
@@ -1249,7 +1249,7 @@ var Comment = class extends Publication {
 	_resolveAuthorNamesInBackground() {
 		if (!this._pkc.resolveAuthorNames) return;
 		const domain = getAuthorNameFromRuntime(this.author);
-		const ownAuthor = domain && typeof this.author.nameResolved !== "boolean" ? [{
+		const ownAuthor = domain ? [{
 			authorName: domain,
 			signaturePublicKey: this.signature.publicKey
 		}] : [];
@@ -1258,7 +1258,7 @@ var Comment = class extends Publication {
 			if (!page) continue;
 			for (const comment of page.comments) {
 				const commentDomain = getAuthorNameFromRuntime(comment.author);
-				if (commentDomain && typeof comment.author.nameResolved !== "boolean") replyAuthors.push({
+				if (commentDomain) replyAuthors.push({
 					authorName: commentDomain,
 					signaturePublicKey: comment.signature.publicKey
 				});
@@ -6937,6 +6937,10 @@ var PKC$1 = class extends PKCTypedEmitter {
 		this._publishingPublications = /* @__PURE__ */ new Set();
 		this.destroyed = false;
 		this._storageLRUs = {};
+		this._nameResolvedFalseTtlMs = NAME_RESOLVED_FALSE_TTL_MS;
+		this._nameResolvedTrueTtlMs = NAME_RESOLVED_TRUE_TTL_MS;
+		this._nameResolveFailedRetryFloorMs = NAME_RESOLVE_FAILED_RETRY_FLOOR_MS;
+		this._authorNameResolvesInFlight = /* @__PURE__ */ new Set();
 		this._timeouts = {
 			"community-ipns": 300 * 1e3,
 			"community-ipfs": 60 * 1e3,
@@ -7016,7 +7020,14 @@ var PKC$1 = class extends PKCTypedEmitter {
 			}),
 			pageCidToSortTypes: new LRUCache({ max: 5e3 }),
 			pagesMaxSize: new LRUCache({ max: 5e4 }),
-			nameResolvedCache: new LRUCache({ max: 5e3 })
+			nameResolvedCache: new LRUCache({
+				max: 5e3,
+				ttl: NAME_RESOLVED_TRUE_TTL_MS
+			}),
+			nameResolveFailedCache: new LRUCache({
+				max: 5e3,
+				ttl: NAME_RESOLVE_FAILED_RETRY_FLOOR_MS
+			})
 		};
 	}
 	async _initKuboRpcClientsIfNeeded() {
@@ -7054,7 +7065,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-BqRIFXGX.js");
+		const { createLibp2pJsClientOrUseExistingOne } = await import("./helia-for-pkc-DanrSDp0.js");
 		for (const clientOptions of this.libp2pJsClientsOptions) {
 			const heliaNode = await createLibp2pJsClientOrUseExistingOne({
 				...clientOptions,
@@ -7333,7 +7344,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-mF7g4deD.js");
+		const { LocalCommunity, createNewLocalCommunityDb, updateInstancePropsWithStartedCommunityOrDb } = await import("./local-community-Bsj3T9vI.js");
 		const isLocalCommunity = (await listCommunitiesSync(this)).includes(options.address);
 		const community = new LocalCommunity(this);
 		if (isLocalCommunity) {