@pkcprotocol/pkc-js 0.0.84 → 0.0.86

package/dist/bundled/chunks/{rpc-local-community-r51cTBYd.js → rpc-local-community-Cpw9_Nuo.js}

@@ -1,5 +1,5 @@
 import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "./chunk-2rV9d50f.js";
-import { $ as pubsubTopicToDhtKey, $n as n$10, $t as ChallengeFileSchema, A as extractNetworkErrorDetails, An as CommentUpdateSignedPropertyNames, Ar as literal, At as refreshTrackedCommunityAliases, B as isIpfsCid, Bt as pTimeout, Cn as CommentPubsubMessageWithFlexibleAuthorRefinementSchema, Cr as require_supports_color, Ct as findStartedCommunity, D as deepMergeRuntimeFields, Dn as CommentUpdateForChallengeVerificationSignedPropertyNames, Dr as array, E as createAbortError, Er as _enum, Et as listStartedCommunities, Fn as ModQueuePageIpfsSchema, Ft as untrackStartedCommunity, Gn as AuthorCommentIpfsReservedFields, Gt as CreateCommunityEditPublicationOptionsWithRefinementSchema, H as isIpns, I as getPostUpdateTimestampRange, In as PageIpfsSchema, It as untrackUpdatingComment, Jn as CidPathSchema, Kt as CommentModerationChallengeRequestToEncryptSchema, L as hideClassPrivateProps, Ln as CommentEditChallengeRequestToEncryptSchema, Lt as untrackUpdatingCommunity, Mr as object, Mt as trackStartedCommunity, Nn as CreateCommentOptionsWithRefinementSchema, Nr as record, O as derivePublicationFromChallengeRequest, On as CommentUpdateReservedFields, Or as boolean, Ot as listUpdatingCommunities, Pn as GetPageParamSchema, Pr as string, Pt as trackUpdatingCommunity, Q as isStringDomain, Qn as CreateSignerSchema, Qt as ChallengeFileFactorySchema, R as ipnsNameToIpnsOverPubsubTopic, Rt as require_sha256$1, Sr as logger_default, Tn as CommentUpdateChallengeReservedFieldNames, Tt as findUpdatingCommunity, U as isIpnsPath, Un as CreateCommentEditOptionsWithRefinementSchema, Ut as CommunityEditPublicationSignedPropertyNames, V as isIpfsPath, Vn as CommentEditSignedPropertyNames, Vt as CommunityEditPublicationChallengeRequestToEncryptSchema, Wn as AuthorAddressSchema, Wt as CommunityEditPubsubMessagePublicationSchema, X as isRequestPubsubPublicationOfPost, Xn as CommunityAddressSchema, Xt as CommentModerationsTableRowSchema, Yn as CidStringSchema, Yt as CommentModerationSignedPropertyNames, Z as isRequestPubsubPublicationOfReply, Zn as CommunityAuthorChallengeReservedFieldNames, Zt as CreateCommentModerationOptionsWithRefinementSchema, _ as PKCUserOptionBaseSchema, _n as VoteSignedPropertyNames, _r as FailedToFetchCommunityFromGatewaysError, an as CommunityIpfsSchema, ar as e$5, b as areEquivalentCommunityAddresses, bn as CommentIpfsReservedFields, br as PKCError, bt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, c as ChallengeVerificationMessageSignedPropertyNames, cn as CreateRemoteCommunityFunctionArgumentSchema, cr as t$12, dr as t$10, f as DecryptedChallengeSchema, fn as RpcRemoteCommunityUpdateEventResultSchema, fr as t$9, g as PKCParsedOptionsSchema, gr as FailedToFetchCommentUpdateFromGatewaysError, gt as sleepUntilTimeoutOrAbort, h as NameResolverSerializedSchema, hn as VotePubsubMessagePublicationSchema, hr as FailedToFetchCommentIpfsFromGatewaysError, ht as shortifyCid, i as ChallengeMessageSignedPropertyNames, in as CommunityIpfsReservedFields, ir as e$6, j as fetchAndValidateIpnsRecordFromGateway, jr as number, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateSchema, kr as custom, l as DecryptedChallengeAnswerSchema, ln as CreateRpcCommunityFunctionArgumentSchema, lr as n$8, m as NameResolveCacheOptionsSchema, mn as VoteChallengeRequestToEncryptSchema, mr as require_retry$1, mt as shortifyAddress, n as ChallengeAnswerMessageSignedPropertyNames, nn as CommunityEditOptionsSchema, o as ChallengeRequestMessageSignedPropertyNames, on as CommunitySignedPropertyNames, or as t$11, ot as removeNullUndefinedEmptyObjectsValuesRecursively, p as DecryptedChallengeVerificationSchema, pn as CreateVoteUserOptionsWithRefinementSchema, pr as e$4, qn as ChallengeAnswersSchema, qt as CommentModerationPubsubMessagePublicationSchema, rn as CommunityExportRecordsSchema, rr as t$13, sn as CreateNewLocalCommunityUserOptionsSchema, sr as r$8, tn as CommunityChallengeSettingSchema, tr as n$9, tt as raceAgainstAbort, un as ExportCommunityModLogsOptionsSchema, ur as r$7, ut as resolveWhenPredicateIsTrue, v as PKCUserOptionsSchema, vr as FailedToFetchGenericIpfsFromGatewaysError, vt as throwIfAbortSignalAborted, wn as CommentSignedPropertyNames, wr as require_ms$1, wt as findUpdatingComment, x as calculateIpfsCidV0, xn as CommentIpfsSchema, xr as messages, yn as CommentChallengeRequestToEncryptSchema, yr as FailedToFetchPageIpfsFromGatewaysError, yt as timestamp, z as isAbortError, zn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema } from "./schema-AXrL86Q4.js";
+import { $ as pubsubTopicToDhtKey, $n as n$10, $t as ChallengeFileSchema, A as extractNetworkErrorDetails, An as CommentUpdateSignedPropertyNames, Ar as literal, At as refreshTrackedCommunityAliases, B as isIpfsCid, Bt as pTimeout, Cn as CommentPubsubMessageWithFlexibleAuthorRefinementSchema, Cr as require_supports_color, Ct as findStartedCommunity, D as deepMergeRuntimeFields, Dn as CommentUpdateForChallengeVerificationSignedPropertyNames, Dr as array, E as createAbortError, Er as _enum, Et as listStartedCommunities, Fn as ModQueuePageIpfsSchema, Ft as untrackStartedCommunity, Gn as AuthorCommentIpfsReservedFields, Gt as CreateCommunityEditPublicationOptionsWithRefinementSchema, H as isIpns, I as getPostUpdateTimestampRange, In as PageIpfsSchema, It as untrackUpdatingComment, Jn as CidPathSchema, Kt as CommentModerationChallengeRequestToEncryptSchema, L as hideClassPrivateProps, Ln as CommentEditChallengeRequestToEncryptSchema, Lt as untrackUpdatingCommunity, Mr as object, Mt as trackStartedCommunity, Nn as CreateCommentOptionsWithRefinementSchema, Nr as record, O as derivePublicationFromChallengeRequest, On as CommentUpdateReservedFields, Or as boolean, Ot as listUpdatingCommunities, Pn as GetPageParamSchema, Pr as string, Pt as trackUpdatingCommunity, Q as isStringDomain, Qn as CreateSignerSchema, Qt as ChallengeFileFactorySchema, R as ipnsNameToIpnsOverPubsubTopic, Rt as require_sha256$1, Sr as logger_default, Tn as CommentUpdateChallengeReservedFieldNames, Tt as findUpdatingCommunity, U as isIpnsPath, Un as CreateCommentEditOptionsWithRefinementSchema, Ut as CommunityEditPublicationSignedPropertyNames, V as isIpfsPath, Vn as CommentEditSignedPropertyNames, Vt as CommunityEditPublicationChallengeRequestToEncryptSchema, Wn as AuthorAddressSchema, Wt as CommunityEditPubsubMessagePublicationSchema, X as isRequestPubsubPublicationOfPost, Xn as CommunityAddressSchema, Xt as CommentModerationsTableRowSchema, Yn as CidStringSchema, Yt as CommentModerationSignedPropertyNames, Z as isRequestPubsubPublicationOfReply, Zn as CommunityAuthorChallengeReservedFieldNames, Zt as CreateCommentModerationOptionsWithRefinementSchema, _ as PKCUserOptionBaseSchema, _n as VoteSignedPropertyNames, _r as FailedToFetchCommunityFromGatewaysError, an as CommunityIpfsSchema, ar as e$5, b as areEquivalentCommunityAddresses, bn as CommentIpfsReservedFields, br as PKCError, bt as waitForUpdateInCommunityInstanceWithErrorAndTimeout, c as ChallengeVerificationMessageSignedPropertyNames, cn as CreateRemoteCommunityFunctionArgumentSchema, cr as t$12, dr as t$10, f as DecryptedChallengeSchema, fn as RpcRemoteCommunityUpdateEventResultSchema, fr as t$9, g as PKCParsedOptionsSchema, gr as FailedToFetchCommentUpdateFromGatewaysError, gt as sleepUntilTimeoutOrAbort, h as NameResolverSerializedSchema, hn as VotePubsubMessagePublicationSchema, hr as FailedToFetchCommentIpfsFromGatewaysError, ht as shortifyCid, i as ChallengeMessageSignedPropertyNames, in as CommunityIpfsReservedFields, ir as e$6, j as fetchAndValidateIpnsRecordFromGateway, jr as number, k as doesDomainAddressHaveCapitalLetter, kn as CommentUpdateSchema, kr as custom, l as DecryptedChallengeAnswerSchema, ln as CreateRpcCommunityFunctionArgumentSchema, lr as n$8, m as NameResolveCacheOptionsSchema, mn as VoteChallengeRequestToEncryptSchema, mr as require_retry$1, mt as shortifyAddress, n as ChallengeAnswerMessageSignedPropertyNames, nn as CommunityEditOptionsSchema, o as ChallengeRequestMessageSignedPropertyNames, on as CommunitySignedPropertyNames, or as t$11, ot as removeNullUndefinedEmptyObjectsValuesRecursively, p as DecryptedChallengeVerificationSchema, pn as CreateVoteUserOptionsWithRefinementSchema, pr as e$4, qn as ChallengeAnswersSchema, qt as CommentModerationPubsubMessagePublicationSchema, rn as CommunityExportRecordsSchema, rr as t$13, sn as CreateNewLocalCommunityUserOptionsSchema, sr as r$8, tn as CommunityChallengeSettingSchema, tr as n$9, tt as raceAgainstAbort, un as ExportCommunityModLogsOptionsSchema, ur as r$7, ut as resolveWhenPredicateIsTrue, v as PKCUserOptionsSchema, vr as FailedToFetchGenericIpfsFromGatewaysError, vt as throwIfAbortSignalAborted, wn as CommentSignedPropertyNames, wr as require_ms$1, wt as findUpdatingComment, x as calculateIpfsCidV0, xn as CommentIpfsSchema, xr as messages, yn as CommentChallengeRequestToEncryptSchema, yr as FailedToFetchPageIpfsFromGatewaysError, yt as timestamp, z as isAbortError, zn as CommentEditPubsubMessagePublicationWithFlexibleAuthorSchema } from "./schema-BT0023M6.js";
 import { t as all } from "./src-CYIMjhjK.js";
 import { createHash } from "node:crypto";
 import { pathToFileURL } from "node:url";
@@ -91779,7 +91779,10 @@ const CreatePKCWsServerOptionsSchema = object({
 const SetNewSettingsPKCWsServerSchema = object({ pkcOptions: PKCUserOptionBaseSchema.extend({ nameResolvers: NameResolverSerializedSchema.array().optional() }).loose() });
 const PKCWsServerSettingsSerializedSchema = object({
 	pkcOptions: PKCParsedOptionsSchema.loose(),
-	challenges: record(string(), ChallengeFileSchema.omit({ getChallenge: true }))
+	challenges: record(string(), ChallengeFileSchema.omit({
+		getChallenge: true,
+		validateChallengeSettings: true
+	}))
 });
 //#endregion
 //#region dist/node/schema/schema-util.js
@@ -125711,6 +125714,7 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 		this.raw = {};
 		this._updatingCommunityInstanceWithListeners = void 0;
 		this._numOfListenersForUpdatingInstance = 0;
+		this._pendingWarmStartKeyMigration = void 0;
 		this._pkc = pkc;
 		this._setState("stopped");
 		this._updatingState = "stopped";
@@ -126066,14 +126070,24 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 		return true;
 	}
 	_setCommunityIpfsPropsFromUpdatingCommunitiesIfPossible() {
-		const log = logger_default("pkc-js:comment:_setCommunityIpfsPropsFromUpdatingCommunitiesIfPossible");
+		const log = logger_default("pkc-js:remote-community:_setCommunityIpfsPropsFromUpdatingCommunitiesIfPossible");
 		const updatingCommunity = findUpdatingCommunity(this._pkc, {
 			publicKey: this.publicKey,
 			name: this.name
 		});
 		if (updatingCommunity?.raw?.communityIpfs && (this.updatedAt || 0) < updatingCommunity.raw.communityIpfs.updatedAt) {
+			if (this.publicKey && updatingCommunity.publicKey && this.publicKey !== updatingCommunity.publicKey) {
+				this._pendingWarmStartKeyMigration = {
+					previousPublicKey: this.publicKey,
+					newPublicKey: updatingCommunity.publicKey
+				};
+				log.trace(`New Remote Community instance`, this.address, `skipped warm start from pkc._updatingCommunities[${this.address}]: tracked instance is keyed to`, updatingCommunity.publicKey, `while the caller requested`, this.publicKey, `- deferring key-migration announcement to update()`);
+				return;
+			}
+			const nameResolvedBeforeAdoption = this.nameResolved;
 			this.initCommunityIpfsPropsNoMerge(updatingCommunity.raw.communityIpfs);
 			this.updateCid = updatingCommunity.updateCid;
+			this._adoptMirroredNameResolved(updatingCommunity, nameResolvedBeforeAdoption);
 			log.trace(`New Remote Community instance`, this.address, `will use CommunityIpfs from pkc._updatingCommunities[${this.address}] with updatedAt`, this.updatedAt, "that's", timestamp() - this.updatedAt, "seconds old");
 			this.emit("update", this);
 		}
@@ -126083,14 +126097,8 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 			if (typeof source.nameResolved === "boolean") this.nameResolved = source.nameResolved;
 		} else this.nameResolved = nameResolvedBeforeMirror;
 	}
-	async _initCommunityInstanceWithListeners() {
-		const trackedUpdatingCommunity = findUpdatingCommunity(this._pkc, {
-			publicKey: this.publicKey,
-			name: this.name
-		});
-		if (!trackedUpdatingCommunity) throw Error("should be defined at this stage");
+	_initCommunityInstanceWithListeners(communityInstance) {
 		const log = logger_default("pkc-js:remote-community:update");
-		const communityInstance = trackedUpdatingCommunity;
 		return {
 			community: communityInstance,
 			update: () => {
@@ -126118,28 +126126,25 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 	}
 	async fetchLatestCommunityOrSubscribeToEvent() {
 		const log = logger_default("pkc-js:remote-community:update:updateOnce");
-		if (!findUpdatingCommunity(this._pkc, {
+		let communityInstance = findUpdatingCommunity(this._pkc, {
 			publicKey: this.publicKey,
 			name: this.name
-		})) {
+		});
+		if (!communityInstance) {
 			const createOpts = this.publicKey && isStringDomain(this.address) ? {
 				name: this.address,
 				publicKey: this.publicKey
 			} : { address: this.address };
 			const updatingCommunity = await this._pkc.createCommunity(createOpts);
-			trackUpdatingCommunity(this._pkc, updatingCommunity);
+			communityInstance = trackUpdatingCommunity(this._pkc, updatingCommunity);
 			log("Creating a new entry for this._pkc._updatingCommunities", this.address);
 		}
-		const communityInstance = findUpdatingCommunity(this._pkc, {
-			publicKey: this.publicKey,
-			name: this.name
-		});
-		if (!communityInstance) throw Error("should be defined at this stage");
 		if (communityInstance === this) {
 			this._clientsManager.startUpdatingLoop().catch((err) => log.error("Failed to start update loop of community", err));
-			return;
+			return false;
 		}
-		this._updatingCommunityInstanceWithListeners = await this._initCommunityInstanceWithListeners();
+		if (!this._pkc._updatingCommunities.has(communityInstance)) throw Error(`Updating community instance (${communityInstance.address}) was untracked before listeners could be attached`);
+		this._updatingCommunityInstanceWithListeners = this._initCommunityInstanceWithListeners(communityInstance);
 		this._updatingCommunityInstanceWithListeners.community.on("update", this._updatingCommunityInstanceWithListeners.update);
 		this._updatingCommunityInstanceWithListeners.community.on("updatingstatechange", this._updatingCommunityInstanceWithListeners.updatingstatechange);
 		this._updatingCommunityInstanceWithListeners.community.on("error", this._updatingCommunityInstanceWithListeners.error);
@@ -126151,13 +126156,34 @@ var RemoteCommunity = class extends import_lib$1.TypedEmitter {
 			this._updatingCommunityInstanceWithListeners.community._setState("updating");
 			this._updatingCommunityInstanceWithListeners.community._clientsManager.startUpdatingLoop().catch((err) => log.error("Failed to start update loop of community", err));
 		}
+		if (communityInstance.raw.communityIpfs && (this.updatedAt ?? 0) < communityInstance.raw.communityIpfs.updatedAt && this._updatingCommunityInstanceWithListeners) {
+			this._updatingCommunityInstanceWithListeners.update(communityInstance);
+			return true;
+		}
+		return false;
+	}
+	_announcePendingWarmStartKeyMigrationIfAny() {
+		if (!this._pendingWarmStartKeyMigration) return;
+		const { previousPublicKey, newPublicKey } = this._pendingWarmStartKeyMigration;
+		this._pendingWarmStartKeyMigration = void 0;
+		const error = new PKCError("ERR_COMMUNITY_NAME_RESOLVES_TO_DIFFERENT_PUBLIC_KEY", {
+			communityName: this.name,
+			previousPublicKey,
+			newPublicKey
+		});
+		this._clearDataForKeyMigration(newPublicKey);
+		if (this.name) this.nameResolved = true;
+		this.emit("update", this);
+		this.emit("error", error);
 	}
 	async update() {
 		if (this.state !== "stopped") return;
 		logger_default("pkc-js:remote-community:update");
 		this._setState("updating");
-		await this.fetchLatestCommunityOrSubscribeToEvent();
-		if (this.raw.communityIpfs) this.emit("update", this);
+		this._announcePendingWarmStartKeyMigrationIfAny();
+		const hadRecordBeforeFetch = Boolean(this.raw.communityIpfs);
+		const replayEmittedUpdate = await this.fetchLatestCommunityOrSubscribeToEvent();
+		if (this.raw.communityIpfs && hadRecordBeforeFetch && !replayEmittedUpdate) this.emit("update", this);
 	}
 	async _cleanUpUpdatingCommunityInstanceWithListeners() {
 		if (!this._updatingCommunityInstanceWithListeners) throw Error("should be defined at this stage");
@@ -128116,6 +128142,25 @@ function ChallengeFileFactory$4({ challengeSettings }) {
 	};
 }
 //#endregion
+//#region dist/node/runtime/node/community/challenges/pkc-js-challenges/address-list-validation.js
+const splitCommaSeparated = (value) => value.split(",").map((entry) => entry.trim());
+function validateAddressListOptions({ challengeSettings }) {
+	const { addresses, urls } = challengeSettings.options ?? {};
+	if (addresses) {
+		for (const [index, address] of splitCommaSeparated(addresses).entries()) if (!address) throw new Error(`addresses entry ${index} is empty, check for a stray or trailing comma`);
+	}
+	if (urls) for (const [index, url] of splitCommaSeparated(urls).entries()) {
+		if (!url) throw new Error(`urls entry ${index} is empty, check for a stray or trailing comma`);
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch {
+			throw new Error(`urls entry ${index} ('${url}') is not a valid URL`);
+		}
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`urls entry ${index} ('${url}') must use http: or https:, it is fetched over HTTP`);
+	}
+}
+//#endregion
 //#region dist/node/runtime/node/community/challenges/pkc-js-challenges/blacklist.js
 const optionInputs$3 = [
 	{
@@ -128198,7 +128243,8 @@ function ChallengeFileFactory$3({ challengeSettings }) {
 		getChallenge: getChallenge$3,
 		optionInputs: optionInputs$3,
 		type: type$3,
-		description: description$2
+		description: description$2,
+		validateChallengeSettings: validateAddressListOptions
 	};
 }
 //#endregion
@@ -128284,7 +128330,8 @@ function ChallengeFileFactory$2({ challengeSettings }) {
 		getChallenge: getChallenge$2,
 		optionInputs: optionInputs$2,
 		type: type$2,
-		description: description$1
+		description: description$1,
+		validateChallengeSettings: validateAddressListOptions
 	};
 }
 //#endregion
@@ -128327,13 +128374,17 @@ const getChallenge$1 = async ({ challengeSettings, challengeRequestMessage, chal
 	};
 	return { success: true };
 };
+const validateChallengeSettings$1 = ({ challengeSettings }) => {
+	if (challengeSettings.publicOptions?.includes("answer")) throw new Error("answer cannot be listed in publicOptions: publishing the answer means anyone can pass the challenge");
+};
 function ChallengeFileFactory$1({ challengeSettings }) {
 	return {
 		getChallenge: getChallenge$1,
 		optionInputs: optionInputs$1,
 		type: type$1,
 		challenge: challengeSettings?.options?.question,
-		description
+		description,
+		validateChallengeSettings: validateChallengeSettings$1
 	};
 }
 //#endregion
@@ -128434,12 +128485,35 @@ const getChallenge = async ({ challengeSettings, challengeRequestMessage }) => {
 		error
 	};
 };
+const validateChallengeSettings = ({ challengeSettings }) => {
+	const matchesStr = challengeSettings.options?.matches;
+	if (!matchesStr) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(matchesStr);
+	} catch (e) {
+		throw new Error(`matches is not valid JSON: ${e.message}`);
+	}
+	if (!Array.isArray(parsed)) throw new Error("matches must be a JSON array of {propertyName, regexp} objects");
+	for (const [index, match] of parsed.entries()) {
+		if (typeof match !== "object" || match === null || Array.isArray(match)) throw new Error(`matches[${index}] must be an object with propertyName and regexp`);
+		const { propertyName, regexp } = match;
+		if (typeof propertyName !== "string" || !propertyName) throw new Error(`matches[${index}].propertyName must be a non-empty string`);
+		if (typeof regexp !== "string" || !regexp) throw new Error(`matches[${index}].regexp must be a non-empty string`);
+		try {
+			new RegExp(regexp);
+		} catch (e) {
+			throw new Error(`matches[${index}].regexp ('${regexp}') is not a valid regular expression: ${e.message}`);
+		}
+	}
+};
 function ChallengeFileFactory({ challengeSettings }) {
 	return {
 		getChallenge,
 		optionInputs,
 		type,
-		description: challengeSettings?.options?.description || defaultDescription
+		description: challengeSettings?.options?.description || defaultDescription,
+		validateChallengeSettings
 	};
 }
 //#endregion
@@ -128974,8 +129048,14 @@ const getChallengeVerification = async ({ challengeRequestMessage, community, ge
 	};
 	return challengeVerification;
 };
-const getCommunityChallengeFromCommunityChallengeSettings = async ({ communityChallengeSettings, pkc }) => {
-	communityChallengeSettings = CommunityChallengeSettingSchema.parse(communityChallengeSettings);
+const derivePublicOptions = (communityChallengeSettings) => {
+	const { publicOptions, options } = communityChallengeSettings;
+	if (!publicOptions?.length || !options) return void 0;
+	const published = {};
+	for (const optionName of publicOptions) if (typeof options[optionName] === "string") published[optionName] = options[optionName];
+	return e$5(published) ? void 0 : published;
+};
+const loadChallengeFileFromCommunityChallengeSettings = async ({ communityChallengeSettings, pkc }) => {
 	let challengeFile = void 0;
 	if (communityChallengeSettings.path) try {
 		const importedFile = await import(pathToFileURL(communityChallengeSettings.path).href);
@@ -128998,6 +129078,14 @@ const getCommunityChallengeFromCommunityChallengeSettings = async ({ communityCh
 		challengeFile = ChallengeFileSchema.parse(ChallengeFileFactory({ challengeSettings: communityChallengeSettings }));
 	}
 	if (!challengeFile) throw Error("Failed to load challenge file");
+	return challengeFile;
+};
+const getCommunityChallengeFromCommunityChallengeSettings = async ({ communityChallengeSettings, pkc }) => {
+	communityChallengeSettings = CommunityChallengeSettingSchema.parse(communityChallengeSettings);
+	const challengeFile = await loadChallengeFileFromCommunityChallengeSettings({
+		communityChallengeSettings,
+		pkc
+	});
 	const { challenge, type } = challengeFile;
 	return { communityChallenge: {
 		exclude: communityChallengeSettings.exclude,
@@ -129005,7 +129093,8 @@ const getCommunityChallengeFromCommunityChallengeSettings = async ({ communityCh
 		challenge,
 		type,
 		caseInsensitive: challengeFile.caseInsensitive,
-		pendingApproval: communityChallengeSettings.pendingApproval
+		pendingApproval: communityChallengeSettings.pendingApproval,
+		publicOptions: derivePublicOptions(communityChallengeSettings)
 	} };
 };
 //#endregion
@@ -129599,4 +129688,4 @@ var RpcLocalCommunity = class extends RpcRemoteCommunity {
 	}
 };
 //#endregion
-export { applyNameResolvedCacheToCrosspost as $, crosspostChainDepthUpTo as $n, createSchemaRowParser as $t, deriveDbReplies as A, parseVoteChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as An, verifyCommentModeration as At, tryToDeleteCommunitiesThatFailedToBeDeletedBefore as B, RpcExportCommunityModLogsParamSchema as Bn, normalizeCreatePublicationAuthor as Bt, backupCommunityDb as C, parseDecryptedChallengeVerification as Cn, signVote as Ct, deleteOldCommunityInWindows as D, parseRpcCommentEventWithPKCErrorIfItFails as Dn, verifyChallengeVerification as Dt, createKuboRpcClient as E, parsePKCUserOptionsSchemaWithPKCErrorIfItFails as En, verifyChallengeRequest as Et, listCommunitiesSync as F, RpcCidParamSchema as Fn, verifyVote as Ft, TIMEFRAMES_TO_SECONDS as G, RpcFetchCidResultSchema as Gn, normalizeCommunityInputFromCommunity as Gt, POSTS_SORT_TYPES as H, RpcExportCommunityParamSchema as Hn, getCommunityAddressFromRecord as Ht, monitorCommunitiesDirectory as I, RpcCommentRepliesPageParamSchema as In, buildRuntimeAuthor as It, extractCommunityRuntimeFieldsFromParsedPages as J, RpcPublishedAnchorRecordResultSchema as Jn, getBufferedPKCAddressFromPublicKey as Jt, buildPageRuntimeFields as K, RpcPublishAnchorRecordParamSchema as Kn, decode as Kt, moveCommunityDbToDeletedDirectory as L, RpcCommunityIdentifierParamSchema as Ln, cleanWireAuthor as Lt, getDefaultDataPath as M, RpcAnchorPublishPreparationResultSchema as Mn, verifyCommentUpdate as Mt, getThumbnailPropsOfLink as N, RpcAuthorNameParamSchema as Nn, verifyCommunity as Nt, deriveCommentIpfsFromCommentTableRow as O, parseRpcCommentUpdateEventWithPKCErrorIfItFails as On, verifyCommentEdit as Ot, importSignerIntoKuboNode as P, RpcCancelExportParamSchema as Pn, verifyCommunityEdit as Pt, RepliesPages as Q, RpcUnsubscribeParamSchema as Qn, getPublicKeyFromPrivateKey as Qt, resolveDbPostsCidRefs as R, RpcCommunityPageParamSchema as Rn, getAuthorNameFromRuntime as Rt, BackupAbortError as S, parseDecryptedChallengeAnswerWithPKCErrorIfItFails as Sn, signCommunityEdit as St, calculateInlineRepliesBudget as T, parseJsonWithPKCErrorIfFails as Tn, verifyChallengeMessage as Tt, POST_REPLIES_SORT_TYPES as U, RpcExportCommunityResultSchema as Un, getCommunityNameFromWire$1 as Ut, CommentClientsManager as V, RpcExportCommunityModLogsResultSchema as Vn, buildRuntimeCommunityFields as Vt, REPLY_REPLIES_SORT_TYPES as W, RpcFetchCidParamSchema as Wn, getCommunityPublicKeyFromWire as Wt, iterateOverPageCidsToFindAllCids as X, RpcSubscriptionIdResultSchema as Xn, getPKCAddressFromPublicKey as Xt, findCommentInPageInstanceRecursively as Y, RpcResolveAuthorNameResultSchema as Yn, getIpfsKeyFromPrivateKey as Yt, parseRawPages as Z, RpcSuccessResultSchema as Zn, getPKCAddressFromPublicKeySync as Zt, createAnchorIpnsRecord as _, parseCreateNewLocalCommunityUserOptionsSchemaWithPKCErrorIfItFails as _n, signCommentEdit as _t, pkcJsChallenges as a, parseCommentModerationChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as an, n$5 as ar, PKCClientsManager as at, encryptEd25519AesGcm as b, parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as bn, signCommentUpdateForChallengeVerification as bt, RemoteCommunity as c, parseCommunityAddressWithPKCErrorIfItFails as cn, t$8 as cr, pLimit as ct, decodeRpcChallengeAnswerPubsubMsg as d, parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as dn, require_lodash_merge as dr, cleanUpBeforePublishing as dt, parseCidStringSchemaWithPKCErrorIfItFails as en, effectiveMaxCrosspostDepth as er, cloneCrosspostForRuntime as et, decodeRpcChallengePubsubMsg as f, parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails as fn, nativeFunctions$1 as fr, signChallengeAnswer as ft, createSigner as g, parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails as gn, signComment as gt, SignerWithPublicKeyAddress as h, parseCreateCommentOptionsSchemaWithPKCErrorIfItFails as hn, signChallengeVerification as ht, getCommunityChallengeFromCommunityChallengeSettings as i, parseCommentIpfsSchemaWithPKCErrorIfItFails as in, t$5 as ir, PublicationClientsManager as it, getDefaultCommunityDbConfig as j, parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails as jn, verifyCommentPubsubMessage as jt, deriveDbPosts as k, parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails as kn, verifyCommentIpfs as kt, MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS as l, parseCommunityEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as ln, stringify as lr, PKCTypedEmitter as lt, decodeRpcChallengeVerificationPubsubMsg as m, parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails as mn, signChallengeRequest as mt, RpcRemoteCommunity as n, parseCommentEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as nn, t$4 as nr, extractCrosspostRuntimeFields as nt, TrackedInstanceRegistry as o, parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails as on, n$6 as or, InflightFetchManager as ot, decodeRpcChallengeRequestPubsubMsg as p, parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails as pn, require_undici as pr, signChallengeMessage as pt, buildPagesRuntimeFields as q, RpcPublishChallengeAnswersParamSchema as qn, encode as qt, getChallengeVerification as r, parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as rn, r as rr, stripNameResolvedFromCrosspost as rt, LRUCache as s, parseCommentPubsubMessagePublicationWithPKCErrorIfItFails as sn, t$7 as sr, pRetry as st, RpcLocalCommunity as t, parseCommentChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as tn, t$2 as tr, collectCrosspostAuthorsToResolve as tt, KeyvBetterSqlite3 as u, parseCommunityEditOptionsSchemaWithPKCErrorIfItFails as un, STORAGE_KEYS as ur, require_lib$1 as ut, decryptEd25519AesGcm as v, parseCreatePKCWsServerOptionsSchemaWithPKCErrorIfItFails as vn, signCommentModeration as vt, calculateExpectedSignatureSize as w, parseDecryptedChallengeWithPKCErrorIfItFails as wn, verifyChallengeAnswer as wt, encryptEd25519AesGcmPublicKeyBuffer as x, parseCreateVoteOptionsSchemaWithPKCErrorIfItFails as xn, signCommunity as xt, decryptEd25519AesGcmPublicKeyBuffer as y, parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as yn, signCommentUpdate as yt, setNativeFunctions as z, RpcEditCommunityParamSchema as zn, getAuthorNameFromWire as zt };
+export { RepliesPages as $, RpcUnsubscribeParamSchema as $n, getPublicKeyFromPrivateKey as $t, deriveDbPosts as A, parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails as An, verifyCommentIpfs as At, setNativeFunctions as B, RpcEditCommunityParamSchema as Bn, getAuthorNameFromWire as Bt, BackupAbortError as C, parseDecryptedChallengeAnswerWithPKCErrorIfItFails as Cn, signCommunityEdit as Ct, createKuboRpcClient as D, parsePKCUserOptionsSchemaWithPKCErrorIfItFails as Dn, verifyChallengeRequest as Dt, calculateInlineRepliesBudget as E, parseJsonWithPKCErrorIfFails as En, verifyChallengeMessage as Et, importSignerIntoKuboNode as F, RpcCancelExportParamSchema as Fn, verifyCommunityEdit as Ft, REPLY_REPLIES_SORT_TYPES as G, RpcFetchCidParamSchema as Gn, getCommunityPublicKeyFromWire as Gt, CommentClientsManager as H, RpcExportCommunityModLogsResultSchema as Hn, buildRuntimeCommunityFields as Ht, listCommunitiesSync as I, RpcCidParamSchema as In, verifyVote as It, buildPagesRuntimeFields as J, RpcPublishChallengeAnswersParamSchema as Jn, encode as Jt, TIMEFRAMES_TO_SECONDS as K, RpcFetchCidResultSchema as Kn, normalizeCommunityInputFromCommunity as Kt, monitorCommunitiesDirectory as L, RpcCommentRepliesPageParamSchema as Ln, buildRuntimeAuthor as Lt, getDefaultCommunityDbConfig as M, parseVotePubsubMessagePublicationSchemaWithPKCErrorIfItFails as Mn, verifyCommentPubsubMessage as Mt, getDefaultDataPath as N, RpcAnchorPublishPreparationResultSchema as Nn, verifyCommentUpdate as Nt, deleteOldCommunityInWindows as O, parseRpcCommentEventWithPKCErrorIfItFails as On, verifyChallengeVerification as Ot, getThumbnailPropsOfLink as P, RpcAuthorNameParamSchema as Pn, verifyCommunity as Pt, parseRawPages as Q, RpcSuccessResultSchema as Qn, getPKCAddressFromPublicKeySync as Qt, moveCommunityDbToDeletedDirectory as R, RpcCommunityIdentifierParamSchema as Rn, cleanWireAuthor as Rt, encryptEd25519AesGcmPublicKeyBuffer as S, parseCreateVoteOptionsSchemaWithPKCErrorIfItFails as Sn, signCommunity as St, calculateExpectedSignatureSize as T, parseDecryptedChallengeWithPKCErrorIfItFails as Tn, verifyChallengeAnswer as Tt, POSTS_SORT_TYPES as U, RpcExportCommunityParamSchema as Un, getCommunityAddressFromRecord as Ut, tryToDeleteCommunitiesThatFailedToBeDeletedBefore as V, RpcExportCommunityModLogsParamSchema as Vn, normalizeCreatePublicationAuthor as Vt, POST_REPLIES_SORT_TYPES as W, RpcExportCommunityResultSchema as Wn, getCommunityNameFromWire$1 as Wt, findCommentInPageInstanceRecursively as X, RpcResolveAuthorNameResultSchema as Xn, getIpfsKeyFromPrivateKey as Xt, extractCommunityRuntimeFieldsFromParsedPages as Y, RpcPublishedAnchorRecordResultSchema as Yn, getBufferedPKCAddressFromPublicKey as Yt, iterateOverPageCidsToFindAllCids as Z, RpcSubscriptionIdResultSchema as Zn, getPKCAddressFromPublicKey as Zt, createSigner as _, parseCreateCommunityEditPublicationOptionsSchemaWithPKCErrorIfItFails as _n, signComment as _t, loadChallengeFileFromCommunityChallengeSettings as a, parseCommentIpfsSchemaWithPKCErrorIfItFails as an, t$5 as ar, PublicationClientsManager as at, decryptEd25519AesGcmPublicKeyBuffer as b, parseCreateRemoteCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as bn, signCommentUpdate as bt, LRUCache as c, parseCommentPubsubMessagePublicationWithPKCErrorIfItFails as cn, t$7 as cr, pRetry as ct, KeyvBetterSqlite3 as d, parseCommunityEditOptionsSchemaWithPKCErrorIfItFails as dn, STORAGE_KEYS as dr, require_lib$1 as dt, createSchemaRowParser as en, crosspostChainDepthUpTo as er, applyNameResolvedCacheToCrosspost as et, decodeRpcChallengeAnswerPubsubMsg as f, parseCommunityEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as fn, require_lodash_merge as fr, cleanUpBeforePublishing as ft, SignerWithPublicKeyAddress as g, parseCreateCommentOptionsSchemaWithPKCErrorIfItFails as gn, signChallengeVerification as gt, decodeRpcChallengeVerificationPubsubMsg as h, parseCreateCommentModerationOptionsSchemaWithPKCErrorIfItFails as hn, signChallengeRequest as ht, getCommunityChallengeFromCommunityChallengeSettings as i, parseCommentEditPubsubMessagePublicationSchemaWithPKCErrorIfItFails as in, r as ir, stripNameResolvedFromCrosspost as it, deriveDbReplies as j, parseVoteChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as jn, verifyCommentModeration as jt, deriveCommentIpfsFromCommentTableRow as k, parseRpcCommentUpdateEventWithPKCErrorIfItFails as kn, verifyCommentEdit as kt, RemoteCommunity as l, parseCommunityAddressWithPKCErrorIfItFails as ln, t$8 as lr, pLimit as lt, decodeRpcChallengeRequestPubsubMsg as m, parseCreateCommentEditOptionsSchemaWithPKCErrorIfItFails as mn, require_undici as mr, signChallengeMessage as mt, RpcRemoteCommunity as n, parseCommentChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as nn, t$2 as nr, collectCrosspostAuthorsToResolve as nt, pkcJsChallenges as o, parseCommentModerationChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as on, n$5 as or, PKCClientsManager as ot, decodeRpcChallengePubsubMsg as p, parseCommunityIpfsSchemaPassthroughWithPKCErrorIfItFails as pn, nativeFunctions$1 as pr, signChallengeAnswer as pt, buildPageRuntimeFields as q, RpcPublishAnchorRecordParamSchema as qn, decode as qt, getChallengeVerification as r, parseCommentEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as rn, t$4 as rr, extractCrosspostRuntimeFields as rt, TrackedInstanceRegistry as s, parseCommentModerationPubsubMessagePublicationSchemaWithPKCErrorIfItFails as sn, n$6 as sr, InflightFetchManager as st, RpcLocalCommunity as t, parseCidStringSchemaWithPKCErrorIfItFails as tn, effectiveMaxCrosspostDepth as tr, cloneCrosspostForRuntime as tt, MAX_FILE_SIZE_BYTES_FOR_COMMUNITY_IPFS as u, parseCommunityEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails as un, stringify as ur, PKCTypedEmitter as ut, createAnchorIpnsRecord as v, parseCreateNewLocalCommunityUserOptionsSchemaWithPKCErrorIfItFails as vn, signCommentEdit as vt, backupCommunityDb as w, parseDecryptedChallengeVerification as wn, signVote as wt, encryptEd25519AesGcm as x, parseCreateRpcCommunityFunctionArgumentSchemaWithPKCErrorIfItFails as xn, signCommentUpdateForChallengeVerification as xt, decryptEd25519AesGcm as y, parseCreatePKCWsServerOptionsSchemaWithPKCErrorIfItFails as yn, signCommentModeration as yt, resolveDbPostsCidRefs as z, RpcCommunityPageParamSchema as zn, getAuthorNameFromRuntime as zt };

package/dist/bundled/chunks/{schema-AXrL86Q4.js → schema-BT0023M6.js}

@@ -1429,6 +1429,20 @@ const $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def) => {
 		return payload;
 	};
 });
+const $ZodVoid = /*@__PURE__*/ $constructor("$ZodVoid", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (typeof input === "undefined") return payload;
+		payload.issues.push({
+			expected: "void",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 function handleArrayResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
@@ -2681,6 +2695,13 @@ function _never(Class, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
+function _void$1(Class, params) {
+	return new Class({
+		type: "void",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _lt(value, params) {
 	return new $ZodCheckLessThan({
 		check: "less_than",
@@ -3229,6 +3250,9 @@ const booleanProcessor = (_schema, _ctx, json, _params) => {
 const undefinedProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Undefined cannot be represented in JSON Schema");
 };
+const voidProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Void cannot be represented in JSON Schema");
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -3845,6 +3869,14 @@ const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def) => {
 function never(params) {
 	return /* @__PURE__ */ _never(ZodNever, params);
 }
+const ZodVoid = /*@__PURE__*/ $constructor("ZodVoid", (inst, def) => {
+	$ZodVoid.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => voidProcessor(inst, ctx, json, params);
+});
+function _void(params) {
+	return /* @__PURE__ */ _void$1(ZodVoid, params);
+}
 const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def) => {
 	$ZodArray.init(inst, def);
 	ZodType.init(inst, def);
@@ -5520,6 +5552,11 @@ var messages;
 	messages["ERR_CHALLENGE_RESULT_OVERRIDES_RESERVED_COMMENT_UPDATE_FIELD"] = "A challenge result attempted to set commentUpdate.<field> that is in CommentUpdateChallengeReservedFieldNames (community-computed field)";
 	messages["ERR_CHALLENGE_RESULT_OVERRIDES_NON_COMMUNITY_AUTHOR_KEY"] = "A challenge result attempted to set commentUpdate.author.<field> with a key other than 'community' — challenges may only extend commentUpdate.author.community";
 	messages["ERR_CHALLENGE_RESULT_OVERRIDES_RESERVED_COMMUNITY_AUTHOR_FIELD"] = "A challenge result attempted to set commentUpdate.author.community.<field> that is in CommunityAuthorChallengeReservedFieldNames (community-computed or mod-settable field)";
+	messages["ERR_CHALLENGE_OPTION_NOT_DECLARED_IN_OPTION_INPUTS"] = "settings.challenges[i].options has a key that no optionInputs entry of the challenge declares, so it is never read";
+	messages["ERR_CHALLENGE_REQUIRED_OPTION_MISSING"] = "settings.challenges[i].options is missing an option whose optionInputs entry is required";
+	messages["ERR_CHALLENGE_PUBLIC_OPTION_NOT_DECLARED_IN_OPTION_INPUTS"] = "settings.challenges[i].publicOptions names an option that no optionInputs entry of the challenge declares";
+	messages["ERR_CHALLENGE_SETTINGS_VALIDATION_FAILED"] = "The challenge's validateChallengeSettings hook rejected settings.challenges[i]";
+	messages["ERR_CHALLENGE_SETTINGS_VALIDATION_FAILED_FOR_CHALLENGES"] = "One or more challenges in settings.challenges failed validation";
 })(messages || (messages = {}));
 //#endregion
 //#region dist/node/pkc-error.js
@@ -6649,6 +6686,7 @@ const CommunityChallengeSettingSchema = object({
 	path: string().optional(),
 	name: string().optional(),
 	options: record(string(), string()).optional(),
+	publicOptions: string().array().optional(),
 	exclude: ChallengeExcludeSchema.array().nonempty().optional(),
 	description: string().optional(),
 	pendingApproval: boolean().optional()
@@ -6659,7 +6697,7 @@ const GetChallengeArgsSchema = object({
 	challengeIndex: number().int().nonnegative(),
 	community: custom()
 });
-const ChallengeFileSchema = object({
+const ChallengeFileSchema = looseObject({
 	optionInputs: ChallengeOptionInputSchema.array().optional(),
 	type: ChallengeFromGetChallengeSchema.shape.type,
 	challenge: ChallengeFromGetChallengeSchema.shape.challenge.optional(),
@@ -6668,15 +6706,20 @@ const ChallengeFileSchema = object({
 	getChallenge: _function({
 		input: [GetChallengeArgsSchema],
 		output: promise(ResultOfGetChallengeSchema)
-	})
-}).strict();
+	}),
+	validateChallengeSettings: _function({
+		input: [object({ challengeSettings: CommunityChallengeSettingSchema })],
+		output: _void()
+	}).optional()
+});
 const CommunityChallengeSchema = looseObject({
 	exclude: ChallengeExcludeSchema.array().nonempty().optional(),
 	description: ChallengeFileSchema.shape.description,
 	challenge: ChallengeFileSchema.shape.challenge,
 	type: ChallengeFileSchema.shape.type,
 	caseInsensitive: ChallengeFileSchema.shape.caseInsensitive,
-	pendingApproval: boolean().optional()
+	pendingApproval: boolean().optional(),
+	publicOptions: record(string(), string()).optional()
 });
 const ChallengeFileFactorySchema = _function({
 	input: [object({ challengeSettings: CommunityChallengeSettingSchema })],
@@ -6822,7 +6865,8 @@ const CommunityIpfsReservedFields = r$2([
 	"updatingState",
 	"started",
 	"exports",
-	"abortSignal"
+	"abortSignal",
+	"_pendingWarmStartKeyMigration"
 ], t$3(CommunityIpfsSchema.shape));
 //#endregion
 //#region dist/node/publications/comment-moderation/schema.js
@@ -16151,7 +16195,7 @@ function extractNetworkErrorDetails(err, depth = 0) {
 }
 //#endregion
 //#region dist/node/generated-version.js
-const version = "0.0.84";
+const version = "0.0.86";
 //#endregion
 //#region dist/node/version.js
 const protocolVersion = ProtocolVersionSchema.parse("1.0.0");

package/dist/bundled/chunks/{util-CwzCEPKs.js → util-BmT_84kq.js}

@@ -1,4 +1,4 @@
-import { br as PKCError, et as pubsubTopicToDhtKeyCid } from "./schema-AXrL86Q4.js";
+import { br as PKCError, et as pubsubTopicToDhtKeyCid } from "./schema-BT0023M6.js";
 import { ipnsSelector } from "ipns/selector";
 import { equals } from "uint8arrays/equals";
 //#region dist/node/helia/util.js

package/dist/bundled/index.js

@@ -1,2 +1,2 @@
-import { a as getShortCid, i as getShortAddress, n as challenges, o as nativeFunctions, r as createAnchorIpnsRecord, s as setNativeFunctions, t as PKC } from "./chunks/node-B7GkmuSc.js";
+import { a as getShortCid, i as getShortAddress, n as challenges, o as nativeFunctions, r as createAnchorIpnsRecord, s as setNativeFunctions, t as PKC } from "./chunks/node-BbvETZ1u.js";
 export { challenges, createAnchorIpnsRecord, PKC as default, getShortAddress, getShortCid, nativeFunctions, setNativeFunctions };

package/dist/bundled/rpc/src/index.js

@@ -1,7 +1,7 @@
-import { Ct as findStartedCommunity, L as hideClassPrivateProps, Sr as logger_default, br as PKCError, lt as replaceXWithY, rr as t, tr as n } from "../../chunks/schema-AXrL86Q4.js";
-import { _ as parseRpcPublishAnchorRecordParam, c as parseRpcAuthorNameParam, d as parseRpcCommentRepliesPageParam, f as parseRpcCommunityIdentifierParam, g as parseRpcExportCommunityParam, h as parseRpcExportCommunityModLogsParam, l as parseRpcCancelExportParam, m as parseRpcEditCommunityParam, p as parseRpcCommunityPageParam, t as PKC, u as parseRpcCidParam, v as parseRpcPublishChallengeAnswersParam, y as parseRpcUnsubscribeParam } from "../../chunks/node-B7GkmuSc.js";
-import { An as parseVoteChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, K as buildPageRuntimeFields, Sn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, _n as parseCreateNewLocalCommunityUserOptionsSchemaWithPKCErrorIfItFails, an as parseCommentModerationChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, ct as pLimit, kn as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, ln as parseCommunityEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, lr as stringify, nn as parseCommentEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, nr as t$1, nt as extractCrosspostRuntimeFields, q as buildPagesRuntimeFields, st as pRetry, tn as parseCommentChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, un as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, ut as require_lib, vn as parseCreatePKCWsServerOptionsSchemaWithPKCErrorIfItFails } from "../../chunks/rpc-local-community-r51cTBYd.js";
-import { t as LocalCommunity } from "../../chunks/local-community-5PMI-TDB.js";
+import { Ct as findStartedCommunity, L as hideClassPrivateProps, Sr as logger_default, br as PKCError, lt as replaceXWithY, rr as t, tr as n } from "../../chunks/schema-BT0023M6.js";
+import { _ as parseRpcPublishAnchorRecordParam, c as parseRpcAuthorNameParam, d as parseRpcCommentRepliesPageParam, f as parseRpcCommunityIdentifierParam, g as parseRpcExportCommunityParam, h as parseRpcExportCommunityModLogsParam, l as parseRpcCancelExportParam, m as parseRpcEditCommunityParam, p as parseRpcCommunityPageParam, t as PKC, u as parseRpcCidParam, v as parseRpcPublishChallengeAnswersParam, y as parseRpcUnsubscribeParam } from "../../chunks/node-BbvETZ1u.js";
+import { An as parseSetNewSettingsPKCWsServerSchemaWithPKCErrorIfItFails, Cn as parseDecryptedChallengeAnswerWithPKCErrorIfItFails, J as buildPagesRuntimeFields, ct as pRetry, dn as parseCommunityEditOptionsSchemaWithPKCErrorIfItFails, dt as require_lib, jn as parseVoteChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, lt as pLimit, nn as parseCommentChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, on as parseCommentModerationChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, q as buildPageRuntimeFields, rn as parseCommentEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, rr as t$1, rt as extractCrosspostRuntimeFields, un as parseCommunityEditChallengeRequestToEncryptSchemaWithPKCErrorIfItFails, ur as stringify, vn as parseCreateNewLocalCommunityUserOptionsSchemaWithPKCErrorIfItFails, yn as parseCreatePKCWsServerOptionsSchemaWithPKCErrorIfItFails } from "../../chunks/rpc-local-community-Cpw9_Nuo.js";
+import { t as LocalCommunity } from "../../chunks/local-community-NUwjwbZz.js";
 import { fileURLToPath } from "node:url";
 import path from "path";
 import assert from "assert";
@@ -744,7 +744,7 @@ var PKCWsServer = class extends import_lib.TypedEmitter {
 			challenges: t$1({
 				...PKCJs.PKC.challenges || {},
 				...pkc.settings?.challenges || {}
-			}, (challengeFactory) => n(challengeFactory({ challengeSettings: {} }), ["getChallenge"]))
+			}, (challengeFactory) => n(challengeFactory({ challengeSettings: {} }), ["getChallenge", "validateChallengeSettings"]))
 		};
 	}
 	async settingsSubscribe(params, connectionId) {

package/dist/node/clients/rpc-client/rpc-schema-util.d.ts

@@ -105,6 +105,7 @@ export declare const parseRpcEditCommunityParam: (params: unknown) => {
                 path?: string | undefined;
                 name?: string | undefined;
                 options?: Record<string, string> | undefined;
+                publicOptions?: string[] | undefined;
                 exclude?: {
                     [x: string]: unknown;
                     community?: {

package/dist/node/clients/rpc-client/schema.d.ts

@@ -377,6 +377,7 @@ export declare const RpcEditCommunityParamSchema: z.ZodObject<{
                 path: z.ZodOptional<z.ZodString>;
                 name: z.ZodOptional<z.ZodString>;
                 options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                publicOptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 exclude: z.ZodOptional<z.ZodArray<z.ZodObject<{
                     community: z.ZodOptional<z.ZodObject<{
                         addresses: z.ZodArray<z.ZodString>;

package/dist/node/community/remote-community.d.ts

@@ -61,6 +61,10 @@ export declare class RemoteCommunity extends TypedEmitter<CommunityEvents> imple
     protected _ipnsPubsubTopic?: string;
     protected _ipnsPubsubTopicRoutingCid?: string;
     protected _stopAbortController?: AbortController;
+    protected _pendingWarmStartKeyMigration?: {
+        previousPublicKey: string;
+        newPublicKey: string;
+    };
     protected _updatingState: CommunityUpdatingState;
     constructor(pkc: PKC);
     _createStopAbortController(): AbortController;
@@ -112,6 +116,7 @@ export declare class RemoteCommunity extends TypedEmitter<CommunityEvents> imple
     }, nameResolvedBeforeMirror: boolean | undefined): void;
     private _initCommunityInstanceWithListeners;
     private fetchLatestCommunityOrSubscribeToEvent;
+    private _announcePendingWarmStartKeyMigrationIfAny;
     update(): Promise<void>;
     private _cleanUpUpdatingCommunityInstanceWithListeners;
     stop(): Promise<void>;