nodebb-plugin-poll 4.0.14 → 4.1.0

package/languages/ro/poll.json

@@ -1,39 +1,39 @@
-{
-  "poll": "Sondaj",
-  "toggles": "Comutare",
-  "allow_guests": "Oaspeți au acces la rezultate",
-  "limits": "Limite",
-  "max_options": "Opțiuni maxime",
-  "defaults": "Valori implicite",
-  "default_title": "Titlu ",
-  "max_votes": "Voturi maximale per utilizator",
-  "info_choices": "Un număr mai mare de 1 permite selecții multiple.",
-  "settings": "Setări",
-  "save": "Salvează",
-  "reset": "Resetare",
-
-  "creator_title": "Crează sondajul",
-  "poll_title": "Titlul sondajului",
-  "poll_title_placeholder": "Introduceț titlul sondajului",
-  "options_title": "Opțiuni",
-  "options_add": "Adaugă opțiuni",
-  "max_votes_placeholder": "Introduceți numerele",
-  "auto_end_title": "Sfârșitul sondajului",
-  "auto_end_placeholder": "Introduceți data si ora",
-  "auto_end_help": "Lăsați acest câmp liber dacă sondajul nu are termen.",
-
-  "error.max_options": "Puteți introduce un maxim de %d opțiuni.",
-  "error.no_options": "Introduceți ce-l puțin o opțiune.",
-  "error.valid_date": "Vă rog introduceți o dată valabilă.",
-
-  "error.privilege.create": "You're not allowed to create a poll",
-
-  "vote": "Votează",
-  "to_voting": "Sondajul",
-  "to_results": "Rezultate",
-  "voting_unavailable_title": "Sondajul nu este disponibil",
-  "voting_unavailable_message": "Sondajul a fost încheiat sau anulat. Puteți sa va uitați la rezultate.",
-
-  "vote_count": "Utilizatorii au votat pentru aceste opțiuni",
-  "votes": "Voturi"
-}
+{
+  "poll": "Sondaj",
+  "toggles": "Comutare",
+  "allow_guests": "Oaspeți au acces la rezultate",
+  "limits": "Limite",
+  "max_options": "Opțiuni maxime",
+  "defaults": "Valori implicite",
+  "default_title": "Titlu ",
+  "max_votes": "Voturi maximale per utilizator",
+  "info_choices": "Un număr mai mare de 1 permite selecții multiple.",
+  "settings": "Setări",
+  "save": "Salvează",
+  "reset": "Resetare",
+
+  "creator_title": "Crează sondajul",
+  "poll_title": "Titlul sondajului",
+  "poll_title_placeholder": "Introduceț titlul sondajului",
+  "options_title": "Opțiuni",
+  "options_add": "Adaugă opțiuni",
+  "max_votes_placeholder": "Introduceți numerele",
+  "auto_end_title": "Sfârșitul sondajului",
+  "auto_end_placeholder": "Introduceți data si ora",
+  "auto_end_help": "Lăsați acest câmp liber dacă sondajul nu are termen.",
+
+  "error.max_options": "Puteți introduce un maxim de %1 opțiuni.",
+  "error.no_options": "Introduceți ce-l puțin o opțiune.",
+  "error.valid_date": "Vă rog introduceți o dată valabilă.",
+
+  "error.privilege.create": "You're not allowed to create a poll",
+
+  "vote": "Votează",
+  "to_voting": "Sondajul",
+  "to_results": "Rezultate",
+  "voting_unavailable_title": "Sondajul nu este disponibil",
+  "voting_unavailable_message": "Sondajul a fost încheiat sau anulat. Puteți sa va uitați la rezultate.",
+
+  "vote_count": "Utilizatorii au votat pentru aceste opțiuni",
+  "votes": "Voturi"
+}

package/languages/ru/poll.json

@@ -23,7 +23,7 @@
   "auto_end_placeholder": "Нажмите, чтобы ввести дату и время",
   "auto_end_help": "Если оставить данное поле пустым, то опрос будет всегда открыт.",
 
-  "error.max_options": "Вы можете создать только %d опций.",
+  "error.max_options": "Вы можете создать только %1 опций.",
   "error.no_options": "Создайте хотя бы один вариант ответа.",
   "error.valid_date": "Введите корректную дату.",
 

package/languages/tr/poll.json

@@ -1,47 +1,47 @@
-{
-  "poll": "Anket",
-  "toggles": "Değişiklikler",
-  "allow_guests": "Ziyaretçilerin anket sonucunu görmelerine izin ver",
-  "limits": "Sınırlamalar",
-  "max_options": "Anketlerdeki maksimum seçenek sayısı",
-  "defaults": "Varsayılanlar",
-  "default_title": "Varsayılan Anket Başlığı",
-  "max_votes": "Kişi başı maksimum oy sayısı",
-  "disallow_vote_update": "Kişilerin oylarını değiştirmelerine izin verme",
-  "info_choices": "1'den büyük bir sayı çoktan seçmeli anket oluşturacak.",
-  "settings": "Ayarlar",
-  "save": "Kaydet",
-  "reset": "Sıfırla",
-
-  "creator_title": "Anket Oluştur",
-  "poll_title": "Anket Başlığı",
-  "poll_title_placeholder": "Anket başlığını buraya girin",
-  "options_title": "Seçenekler",
-  "options_add": "Seçenek ekle",
-  "max_votes_placeholder": "Bir sayı girin",
-  "auto_end_title": "Anketi otomatik olarak bitir",
-  "auto_end_placeholder": "Tarih ve saat bilgisini buraya girin",
-  "auto_end_help": "Burayı boş bırakırsanız anket hiç sonlanmayacak.",
-
-  "error.max_options": "Sadece %d seçenek oluşturabilirsiniz.",
-  "error.no_options": "En az bir seçenek oluşturmalısınız",
-  "error.valid_date": "Lütfen geçerli bir tarih girin",
-
-  "error.not_main": "Anketi sadece ilk iletiye ekleyebilirsiniz.",
-  "error.privilege.create": "Anket oluşturmaya yetkiniz yok",
-
-  "warning.redactor": "Redactor kullanıyorsunuz. Markup'ı manuel olarak <strong>değiştirmeyin</strong>. Bunun yerine anket oluşturucuyu yeniden açın.",
-
-  "vote": "Oy ver",
-  "update_vote": "Oyu güncelle",
-  "remove_vote": "Oyu kaldır",
-  "to_voting": "Seçeneklere geri dön",
-  "to_results": "Sonuçlar",
-  "voting_unavailable_title": "Oy vermek artık mümkün değil",
-  "voting_unavailable_message": "Bu anket bitti veya silindi. Sonuçları hala görmeniz mümkün",
-  "voting_update_disallowed_message": "Daha önce oy verdiniz. Bu anket için oyunuzu değiştiremezsiniz",
-  "vote_is_final": "Bu ankette oy değiştirmeniz mümkün değildir, o nedenle seçiminiz son karardır",
-
-  "vote_count": "kişi bu seçenek için oy kullandı",
-  "votes": "oy"
-}
+{
+  "poll": "Anket",
+  "toggles": "Değişiklikler",
+  "allow_guests": "Ziyaretçilerin anket sonucunu görmelerine izin ver",
+  "limits": "Sınırlamalar",
+  "max_options": "Anketlerdeki maksimum seçenek sayısı",
+  "defaults": "Varsayılanlar",
+  "default_title": "Varsayılan Anket Başlığı",
+  "max_votes": "Kişi başı maksimum oy sayısı",
+  "disallow_vote_update": "Kişilerin oylarını değiştirmelerine izin verme",
+  "info_choices": "1'den büyük bir sayı çoktan seçmeli anket oluşturacak.",
+  "settings": "Ayarlar",
+  "save": "Kaydet",
+  "reset": "Sıfırla",
+
+  "creator_title": "Anket Oluştur",
+  "poll_title": "Anket Başlığı",
+  "poll_title_placeholder": "Anket başlığını buraya girin",
+  "options_title": "Seçenekler",
+  "options_add": "Seçenek ekle",
+  "max_votes_placeholder": "Bir sayı girin",
+  "auto_end_title": "Anketi otomatik olarak bitir",
+  "auto_end_placeholder": "Tarih ve saat bilgisini buraya girin",
+  "auto_end_help": "Burayı boş bırakırsanız anket hiç sonlanmayacak.",
+
+  "error.max_options": "Sadece %1 seçenek oluşturabilirsiniz.",
+  "error.no_options": "En az bir seçenek oluşturmalısınız",
+  "error.valid_date": "Lütfen geçerli bir tarih girin",
+
+  "error.not_main": "Anketi sadece ilk iletiye ekleyebilirsiniz.",
+  "error.privilege.create": "Anket oluşturmaya yetkiniz yok",
+
+  "warning.redactor": "Redactor kullanıyorsunuz. Markup'ı manuel olarak <strong>değiştirmeyin</strong>. Bunun yerine anket oluşturucuyu yeniden açın.",
+
+  "vote": "Oy ver",
+  "update_vote": "Oyu güncelle",
+  "remove_vote": "Oyu kaldır",
+  "to_voting": "Seçeneklere geri dön",
+  "to_results": "Sonuçlar",
+  "voting_unavailable_title": "Oy vermek artık mümkün değil",
+  "voting_unavailable_message": "Bu anket bitti veya silindi. Sonuçları hala görmeniz mümkün",
+  "voting_update_disallowed_message": "Daha önce oy verdiniz. Bu anket için oyunuzu değiştiremezsiniz",
+  "vote_is_final": "Bu ankette oy değiştirmeniz mümkün değildir, o nedenle seçiminiz son karardır",
+
+  "vote_count": "kişi bu seçenek için oy kullandı",
+  "votes": "oy"
+}

package/lib/config.js

@@ -28,9 +28,20 @@ Config.defaults = {
 
 Config.getSettings = async function () {
 	const settings = await meta.settings.get(Config.plugin.id);
-	return {
+	const merged = {
 		...Config.defaults,
 		...settings,
 	};
+	// NodeBB's settings helper stores checkboxes as 'on'/'off'; normalize to a boolean
+	// so parseInt(...) === 1 checks don't silently fail.
+	merged.allowGuestsToViewResults = ['1', 1, 'on', true].includes(merged.allowGuestsToViewResults);
+	// NodeBB's settings helper stores blank number fields as ''; fall back to defaults
+	// so an empty ACP field doesn't override the configured default.
+	merged.maxOptions = parseInt(merged.maxOptions, 10) || Config.defaults.maxOptions;
+	merged.maximumVotesPerUser = parseInt(merged.maximumVotesPerUser, 10) || Config.defaults.maximumVotesPerUser;
+	// NodeBB's settings helper stores blank text fields as ''; fall back to the
+	// configured default so an empty ACP field doesn't override the built-in default.
+	merged.defaultTitle = merged.defaultTitle || Config.defaults.defaultTitle;
+	return merged;
 };
 

package/lib/hooks.js

@@ -44,12 +44,19 @@ Hooks.filter.postCreate = async function (hookData) {
 	// post is going to be saved to db, data is what is submitted by user
 	const { post, data } = hookData;
 	if (Array.isArray(data?.polls) && data.polls.length) {
-		await checkMaxOptions(data.polls);
 		const savedPolls = await Poll.add(post, data.polls);
 		if (savedPolls.length) {
 			post.pollIds = JSON.stringify(savedPolls.map(p => String(p.pollId)));
 		}
 	}
+
+	// Federated Question (FEP-9967): build a remote poll from the AP data
+	const ap = data?._activitypub;
+	if (ap && (Array.isArray(ap.oneOf) || Array.isArray(ap.anyOf))) {
+		const saved = await Poll.createFromQuestion(post, ap);
+		const existing = post.pollIds ? JSON.parse(post.pollIds) : [];
+		post.pollIds = JSON.stringify([...existing, String(saved.pollId)]);
+	}
 	return hookData;
 };
 
@@ -68,13 +75,39 @@ Hooks.filter.postGetFields = async function (hookData) {
 };
 
 Hooks.filter.postEdit = async function (hookData) {
+	// Federated Question update (FEP-9967): refresh the existing remote poll
+	const ap = hookData.data?._activitypub;
+	if (ap && (Array.isArray(ap.oneOf) || Array.isArray(ap.anyOf))) {
+		const currentPollIds = await Poll.getPollIdsByPid(hookData.data.pid);
+		let remotePollId = null;
+		for (const pid of currentPollIds) {
+			// eslint-disable-next-line no-await-in-loop
+			if (await Poll.isRemote(pid)) {
+				remotePollId = pid;
+				break;
+			}
+		}
+		if (remotePollId) {
+			await Poll.updateFromQuestion(remotePollId, ap);
+		} else {
+			// No existing poll (e.g. the initial Create was missed); create one
+			const saved = await Poll.createFromQuestion({
+				uid: hookData.data.uid,
+				pid: hookData.data.pid,
+				timestamp: hookData.data.timestamp,
+				edited: hookData.data.edited,
+			}, ap);
+			hookData.post.pollIds = JSON.stringify([String(saved.pollId)]);
+		}
+		return hookData;
+	}
+
 	const currentPollIds = await Poll.getPollIdsByPid(hookData.data.pid);
 	if (!currentPollIds.length && (!Array.isArray(hookData.data.polls) || !hookData.data.polls.length)) {
 		// no polls before or after, nothing to do
 		return hookData;
 	}
 	const pollData = hookData.data.polls || [];
-	await checkMaxOptions(pollData);
 	const toAdd = pollData.filter(p => !currentPollIds.includes(String(p.pollId)));
 
 	if (toAdd.length) {
@@ -91,6 +124,71 @@ Hooks.filter.postEdit = async function (hookData) {
 	return hookData;
 };
 
+// FEP-9967 outbound: transform a local post with a poll into a `Question`
+// object. Fired at the end of `Mocks.notes.public` (core), which has already
+// built a `Note`/`Article`. Only the first poll on a post is federated.
+Hooks.filter.activitypubMocksNote = async function (hookData) {
+	const { object, post } = hookData;
+	if (!object || !post || !post.pid) {
+		return hookData;
+	}
+
+	const pollIds = await Poll.getPollIdsByPid(post.pid);
+	if (!pollIds.length) {
+		return hookData;
+	}
+
+	const pollId = pollIds[0];
+	const [info, votersCount] = await Promise.all([
+		Poll.getInfo(pollId),
+		Poll.getVotersCount(pollId),
+	]);
+	if (!info || !Array.isArray(info.options) || !info.options.length) {
+		return hookData;
+	}
+
+	const options = info.options
+		.filter(opt => opt && typeof opt.title === 'string')
+		.map(opt => ({
+			type: 'Note',
+			name: opt.title,
+			replies: { type: 'Collection', totalItems: opt.voteCount || 0 },
+		}));
+
+	const isMulti = parseInt(info.maximumVotesPerUser, 10) > 1;
+	const end = parseInt(info.end, 10);
+	const ended = end > 0 && Date.now() > end;
+
+	object.type = 'Question';
+	// Embed the poll title in the content so it renders as the question text
+	// on Mastodon (which displays `content` above the options).
+	if (info.title) {
+		object.content = `<p>${info.title}</p>${object.content || ''}`;
+	}
+	if (isMulti) {
+		object.anyOf = options;
+	} else {
+		object.oneOf = options;
+	}
+	if (end > 0) {
+		object.endTime = new Date(end).toISOString();
+	}
+	if (ended) {
+		object.closed = true;
+	}
+	if (votersCount > 0) {
+		object.votersCount = votersCount;
+	}
+
+	// A poll post is a Note, not an Article — drop the Article-only fields.
+	// `name` (topic title) is kept: harmless and non-conflicting.
+	delete object.preview;
+	delete object.summary;
+	delete object.sensitive;
+
+	return hookData;
+};
+
 Hooks.filter.topicPost = async function (data) {
 	if (Array.isArray(data.polls) && data.polls.length) {
 		await canCreate(data.cid, data.uid);
@@ -106,6 +204,137 @@ Hooks.filter.topicReply = async function (data) {
 	return data;
 };
 
+// FEP-9967 inbound: detect a remote vote on a local poll and apply it.
+// A vote is a Create(Note) where the Note has `name` + `inReplyTo` and no
+// `content`, and `inReplyTo` resolves to a local post that has a poll.
+Hooks.filter.activitypubCreate = async function (hookData) {
+	const { activity } = hookData;
+	if (!activity || activity.type !== 'Create' || !activity.object) {
+		return hookData;
+	}
+
+	const { object } = activity;
+	// FEP-9967 vote shape: Note with name + inReplyTo, no content
+	if (object.type !== 'Note' || !object.name || !object.inReplyTo || object.content) {
+		return hookData;
+	}
+
+	// Resolve inReplyTo to a local post (e.g. https://example.org/post/123)
+	const match = object.inReplyTo.match(/\/post\/(\d+)/);
+	if (!match) return hookData;
+	const pid = parseInt(match[1], 10);
+	if (!(await posts.exists(pid))) return hookData;
+
+	const pollIds = await Poll.getPollIdsByPid(pid);
+	if (!pollIds.length) return hookData;
+
+	const pollId = pollIds[0];
+	const info = await Poll.getInfo(pollId);
+	if (!info) return hookData;
+
+	// Poll must be active
+	if (await Poll.hasEnded(pollId) || await Poll.isDeleted(pollId)) {
+		return hookData;
+	}
+
+	// Match name to a poll option
+	const option = info.options.find(opt => opt && opt.title === object.name);
+	if (!option) return hookData;
+
+	const remoteActorUrl = activity.actor;
+	if (!remoteActorUrl) return hookData;
+	const isMulti = parseInt(info.maximumVotesPerUser, 10) > 1;
+
+	// Idempotency: check if the actor has already voted
+	if (isMulti) {
+		const alreadyVoted = await db.sortedSetScore(`poll:${pollId}:options:${option.id}:votes`, remoteActorUrl);
+		if (alreadyVoted) return hookData;
+	} else {
+		const alreadyVoted = await db.sortedSetScore(`poll:${pollId}:voters`, remoteActorUrl);
+		if (alreadyVoted) return hookData;
+	}
+
+	// Apply the vote (remote actor URL as the uid — sorted sets handle strings)
+	const Vote = require('./vote');
+	await Vote.add({
+		pollId,
+		options: [option.id],
+		uid: remoteActorUrl,
+		voteAnon: false,
+	});
+
+	// Claim the activity so it is not processed as a regular post
+	hookData.claimed = true;
+
+	// Publish Update(Question) with refreshed results back to the voter
+	const activitypub = nodebb.require('./src/activitypub');
+	const [votersCount, refreshedOptions] = await Promise.all([
+		Poll.getVotersCount(pollId),
+		Poll.getOptions(pollId, false),
+	]);
+	const questionObject = {
+		id: object.inReplyTo,
+		type: 'Question',
+		attributedTo: await posts.getPostField(pid, 'uid'),
+		to: ['https://www.w3.org/ns/activitystreams#Public'],
+		content: await posts.getPostField(pid, 'content'),
+	};
+	const isMultiChoice = parseInt(info.maximumVotesPerUser, 10) > 1;
+	const optionsPayload = refreshedOptions
+		.filter(opt => opt && typeof opt.title === 'string')
+		.map(opt => ({
+			type: 'Note',
+			name: opt.title,
+			replies: { type: 'Collection', totalItems: opt.voteCount || 0 },
+		}));
+	if (isMultiChoice) {
+		questionObject.anyOf = optionsPayload;
+	} else {
+		questionObject.oneOf = optionsPayload;
+	}
+	if (votersCount > 0) {
+		questionObject.votersCount = votersCount;
+	}
+	const end = parseInt(info.end, 10);
+	if (end > 0) {
+		questionObject.endTime = new Date(end).toISOString();
+	}
+	if (end > 0 && Date.now() > end) {
+		questionObject.closed = true;
+	}
+
+	// Publish Update(Question) to all recipients (public, followers, voters)
+	setImmediate(async () => {
+		try {
+			const utils = nodebb.require('./src/utils');
+			const authorUid = parseInt(await posts.getPostField(pid, 'uid'), 10);
+			const remoteVoters = (await db.getSortedSetMembers(`poll:${pollId}:voters`))
+				.filter(v => !utils.isNumber(v));
+
+			const { to, cc, targets } = await activitypub.buildRecipients(
+				{ to: ['https://www.w3.org/ns/activitystreams#Public'], cc: remoteVoters },
+				{ pid, uid: authorUid }
+			);
+
+			questionObject.to = to;
+			questionObject.cc = cc;
+
+			await activitypub.send('uid', authorUid, Array.from(targets), {
+				id: `${object.id || object.inReplyTo}#update/${Date.now()}`,
+				type: 'Update',
+				actor: questionObject.attributedTo,
+				to,
+				cc,
+				object: questionObject,
+			});
+		} catch (e) {
+			// Non-fatal: log and move on
+		}
+	});
+
+	return hookData;
+};
+
 Hooks.action.postDelete = async function (data) {
 	const pollIds = await Poll.getPollIdsByPid(data.post.pid);
 	if (pollIds.length) {
@@ -136,15 +365,3 @@ async function canCreate(cid, uid) {
 	}
 }
 
-async function checkMaxOptions(polls) {
-	if (!Array.isArray(polls) || !polls.length) {
-		return;
-	}
-	const { maxOptions } = await Config.getSettings();
-	polls.forEach((poll) => {
-		if (poll && poll.options.length > maxOptions) {
-			throw new Error(`[[poll:error.max_options, ${maxOptions}]]`);
-		}
-	});
-}
-

package/lib/poll.js

@@ -1,8 +1,11 @@
 'use strict';
 
+const crypto = require('crypto');
+
 const db = nodebb.require('./src/database');
 const privileges = nodebb.require('./src/privileges');
 
+const Config = require('./config');
 const Vote = require('./vote');
 
 const Poll = exports;
@@ -10,6 +13,7 @@ const Poll = exports;
 Poll.add = async function (postData, polls) {
 	// postData is what is being saved to db
 	// polls is submited by user
+	await validateMaxOptions(polls);
 	const savePolls = [];
 	for (const pollData of polls) {
 		// eslint-disable-next-line no-await-in-loop
@@ -44,6 +48,92 @@ Poll.add = async function (postData, polls) {
 	return savePolls;
 };
 
+// ---------------------------------------------------------------------------
+// Federated (remote) polls — FEP-9967 `Question` objects
+// ---------------------------------------------------------------------------
+
+// Stable option id derived from the option name (the FEP guarantees name
+// uniqueness within a poll), so ids survive `Update`s even if order changes.
+function hashOptionId(name) {
+	return crypto.createHash('sha256').update(String(name)).digest('hex').slice(0, 12);
+}
+
+// Parse a Question's `_activitypub` poll data into the plugin's option shape.
+function parseQuestion(ap) {
+	const rawOptions = Array.isArray(ap.anyOf) ? ap.anyOf : (Array.isArray(ap.oneOf) ? ap.oneOf : []);
+	const isMulti = Array.isArray(ap.anyOf);
+	const options = [];
+	const remoteVotes = {};
+	rawOptions.forEach((opt) => {
+		if (!opt || typeof opt.name !== 'string') {
+			return;
+		}
+		const id = hashOptionId(opt.name);
+		options.push({ id, title: opt.name });
+		remoteVotes[id] = (opt.replies && opt.replies.totalItems) || 0;
+	});
+	return {
+		options,
+		remoteVotes,
+		maximumVotesPerUser: isMulti ? Math.max(options.length, 1) : 1,
+	};
+}
+
+function tryParseRemoteVotes(json) {
+	if (!json) {
+		return {};
+	}
+	try {
+		const obj = JSON.parse(json);
+		return obj && typeof obj === 'object' && !Array.isArray(obj) ? obj : {};
+	} catch (err) {
+		return {};
+	}
+}
+
+// Create a poll from a federated Question. Bypasses the local `maxOptions`
+// limit (that cap applies to locally-authored polls, not ingested ones).
+Poll.createFromQuestion = async function (postData, ap) {
+	const { options, remoteVotes, maximumVotesPerUser } = parseQuestion(ap);
+	const pollId = await db.incrObjectField('global', 'nextPollId');
+	const poll = {
+		pollId,
+		title: 'Poll',
+		uid: postData.editor || postData.uid,
+		pid: postData.pid,
+		deleted: 0,
+		end: ap.endTime ? new Date(ap.endTime).getTime() : 0,
+		maximumVotesPerUser,
+		timestamp: postData.edited || postData.timestamp,
+		remote: 1,
+		remoteVotes: JSON.stringify(remoteVotes),
+		options: JSON.stringify(options),
+		...(ap.votersCount !== undefined && { remoteVotersCount: ap.votersCount }),
+	};
+	await Promise.all([
+		db.setObject(`poll:${pollId}`, poll),
+		db.sortedSetAdd('polls:createtime', poll.timestamp, pollId),
+	]);
+	return poll;
+};
+
+// Refresh an existing remote poll from an updated Question (FEP-9967 `Update`).
+Poll.updateFromQuestion = async function (pollId, ap) {
+	const { options, remoteVotes, maximumVotesPerUser } = parseQuestion(ap);
+	await db.setObject(`poll:${pollId}`, {
+		options: JSON.stringify(options),
+		remoteVotes: JSON.stringify(remoteVotes),
+		end: ap.endTime ? new Date(ap.endTime).getTime() : 0,
+		maximumVotesPerUser,
+		...(ap.votersCount !== undefined && { remoteVotersCount: ap.votersCount }),
+	});
+};
+
+Poll.isRemote = async function (pollId) {
+	const result = await Poll.getField(pollId, 'remote');
+	return parseInt(result, 10) === 1;
+};
+
 Poll.deletePolls = async function (pollIds) {
 	if (!pollIds.length) return;
 	const polls = await db.getObjects(pollIds.map(pollId => `poll:${pollId}`));
@@ -75,6 +165,9 @@ Poll.edit = async function (postData, newPolls) {
 	const toDelete = currentPollIds.filter(pollId => !newPollIds.includes(String(pollId)));
 	const currentPolls = await db.getObjects(currentPollIds.map(pollId => `poll:${pollId}`));
 
+	await validateMaxOptions(toAdd);
+	await validateMaxOptionsForEdit(toUpdate, currentPolls);
+
 	await Poll.deletePolls(toDelete);
 
 	const savedPolls = await Poll.add(postData, toAdd);
@@ -206,6 +299,20 @@ Poll.getInfo = async function (pollId, withVotes = false) {
 	const end = parseInt(poll.end, 10);
 	poll.ended = end > 0 && Date.now() > end;
 	poll.options = await loadOptions(pollId, poll.options, withVotes);
+
+	// Federated (remote) polls: displayed count = ingested baseline + local votes.
+	// (v1 reconciliation: a local voter sees their vote reflect immediately; a small
+	// over-count is accepted until the next remote Update refreshes the baseline.)
+	if (parseInt(poll.remote, 10) === 1) {
+		const remoteVotes = tryParseRemoteVotes(poll.remoteVotes);
+		poll.options.forEach((option) => {
+			if (option) {
+				const baseline = remoteVotes[option.id] || 0;
+				option.voteCount = baseline + (option.voteCount || 0);
+			}
+		});
+		poll.voteCount = poll.options.reduce((sum, o) => sum + (o ? (o.voteCount || 0) : 0), 0);
+	}
 	return poll;
 };
 
@@ -245,6 +352,46 @@ function tryParseOptions(optionsJson) {
 	}
 }
 
+async function validateMaxOptions(polls) {
+	if (!Array.isArray(polls) || !polls.length) {
+		return;
+	}
+	const settings = await Config.getSettings();
+	const { maxOptions } = settings;
+	polls.forEach((poll) => {
+		if (!poll) {
+			return;
+		}
+		const optionCount = Array.isArray(poll.options) ? poll.options.length : 0;
+		if (optionCount > maxOptions) {
+			throw new Error(`[[poll:error.max_options, ${maxOptions}]]`);
+		}
+	});
+}
+
+async function validateMaxOptionsForEdit(updatedPolls, currentPolls) {
+	if (!Array.isArray(updatedPolls) || !updatedPolls.length) {
+		return;
+	}
+	const settings = await Config.getSettings();
+	const { maxOptions } = settings;
+	updatedPolls.forEach((poll) => {
+		if (!poll) {
+			return;
+		}
+		const newOptionCount = Array.isArray(poll.options) ? poll.options.length : 0;
+		if (newOptionCount <= maxOptions) {
+			return;
+		}
+		const currentPoll = currentPolls.find(p => p && String(p.pollId) === String(poll.pollId));
+		const currentOptions = currentPoll ? tryParseOptions(currentPoll.options) : [];
+		const currentOptionCount = Array.isArray(currentOptions) ? currentOptions.length : 0;
+		if (newOptionCount > currentOptionCount) {
+			throw new Error(`[[poll:error.max_options, ${maxOptions}]]`);
+		}
+	});
+}
+
 Poll.getOption = async function (pollId, option, withVotes = false) {
 	const [optionsJson, votes, voteCount] = await Promise.all([
 		db.getObjectField(`poll:${pollId}`, 'options'),