@senguoyun/dsh-arkme 0.1.79 → 0.1.80

package/lib/{persistent-runtime-CB7mEj3E.js → persistent-runtime-CGclHTN1.js}

@@ -1951,6 +1951,372 @@ var ServiceRuntime = class {
 	}
 };
 //#endregion
+//#region src/services/reaction-service.ts
+function invalid$11() {
+	throw new ArkmePluginError("reaction-response-invalid", "表态数据不完整，请重试", true);
+}
+function integer$4(value, min = 0) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= min ? value : invalid$11();
+}
+function expression(raw) {
+	const value = objectValue$2(raw);
+	if (typeof value.text !== "string" || Array.from(value.text).length > 20) return invalid$11();
+	const result = { text: value.text };
+	for (const key of [
+		"emoji",
+		"hand",
+		"color"
+	]) if (value[key] !== void 0) {
+		if (typeof value[key] !== "string" || value[key].length > 64) return invalid$11();
+		result[key] = value[key];
+	}
+	return result;
+}
+function array(raw, max) {
+	return Array.isArray(raw) && raw.length <= max ? raw : invalid$11();
+}
+function key(raw) {
+	return typeof raw === "string" && /^[a-f0-9]{64}$/.test(raw) ? raw : invalid$11();
+}
+function group(raw) {
+	const value = objectValue$2(raw);
+	return {
+		key: key(value.key),
+		expression: expression(value.expression),
+		count: integer$4(value.count, 1),
+		actorIds: array(value.actor_user_ids ?? [], 3).map((id) => integer$4(id, 1))
+	};
+}
+function state(raw) {
+	const value = objectValue$2(raw);
+	return {
+		revision: integer$4(value.revision),
+		selections: array(value.selections, 56).map((raw) => {
+			const item = objectValue$2(raw);
+			return {
+				key: key(item.key),
+				expression: expression(item.expression),
+				at: integer$4(item.at)
+			};
+		})
+	};
+}
+function library(raw) {
+	const value = objectValue$2(raw);
+	return {
+		revision: integer$4(value.revision),
+		items: array(value.items, 58).map(expression)
+	};
+}
+function boolean(raw) {
+	return typeof raw === "boolean" ? raw : invalid$11();
+}
+function targetKey(target) {
+	return JSON.stringify([
+		target.chat_session_uid ?? "",
+		target.rel_uid ?? "",
+		target.record_uid ?? "",
+		target.owned === true
+	]);
+}
+/** One Host owner for Browser, SDK and granted Tools; identities are resolved from signed message references. */
+var ReactionService = class {
+	runtime;
+	resolve;
+	worldReference;
+	chatSourceKey;
+	historyContext;
+	constructor(runtime, resolve, worldReference, chatSourceKey, historyContext) {
+		this.runtime = runtime;
+		this.resolve = resolve;
+		this.worldReference = worldReference;
+		this.chatSourceKey = chatSourceKey;
+		this.historyContext = historyContext;
+	}
+	async request(input, signal) {
+		const session = await this.runtime.requireSession();
+		const accountKey = `${this.runtime.config.environment}:${session.userId}`;
+		if (!input || input.accountKey !== accountKey) throw new ArkmePluginError("reaction-account-changed", "账号已变化，请重新打开表态", false);
+		let path, body;
+		const ids = /* @__PURE__ */ new Map();
+		const resolve = async (target) => {
+			if (!target || typeof target.id !== "string" || !target.id || target.id.length > 1024 || !(typeof target.worldRecordRef === "string" && !target.sourceRef && !target.messageActionRef || !target.worldRecordRef && typeof target.sourceRef === "string" && typeof target.messageActionRef === "string")) throw new ArkmePluginError("reaction-target-invalid", "表态目标无效", false);
+			return await this.resolve(target);
+		};
+		switch (input.action) {
+			case "notifications":
+				path = "notifications/query";
+				body = {
+					after_id: input.after_id ?? "",
+					limit: input.limit
+				};
+				break;
+			case "notifications-read":
+				if (!Array.isArray(input.items) || input.items.length < 1 || input.items.length > 50) return invalid$11();
+				path = "notifications/read";
+				body = { items: input.items.map((item) => ({
+					id: key(item.id),
+					revision: integer$4(item.revision, 1)
+				})) };
+				break;
+			case "query": {
+				if (!Array.isArray(input.targets) || input.targets.length < 1 || input.targets.length > 50) throw new ArkmePluginError("reaction-query-invalid", "表态查询数量无效", false);
+				const targets = [], seenIDs = /* @__PURE__ */ new Set();
+				for (const target of input.targets) {
+					const wire = await resolve(target), key = targetKey(wire);
+					if (seenIDs.has(target.id)) throw new ArkmePluginError("reaction-query-duplicate", "表态目标重复", false);
+					seenIDs.add(target.id);
+					const aliases = ids.get(key);
+					if (aliases) aliases.push(target.id);
+					else {
+						ids.set(key, [target.id]);
+						targets.push(wire);
+					}
+				}
+				path = "query";
+				body = { targets };
+				break;
+			}
+			case "set":
+				if (typeof input.active !== "boolean") throw new ArkmePluginError("reaction-state-invalid", "缺少表态状态", false);
+				path = "set";
+				body = {
+					target: await resolve(input.target),
+					expression: input.expression,
+					active: input.active,
+					expected_revision: input.expected_revision,
+					request_id: input.request_id
+				};
+				break;
+			case "actors":
+				path = "actors/query";
+				body = {
+					target: await resolve(input.target),
+					key: input.key,
+					after_user_id: input.after_user_id,
+					limit: input.limit
+				};
+				break;
+			case "groups":
+				path = "groups/query";
+				body = {
+					target: await resolve(input.target),
+					after_key: input.after_key,
+					limit: input.limit
+				};
+				break;
+			case "history":
+				path = "history/query";
+				body = {
+					start_at: input.start_at,
+					end_at: input.end_at,
+					limit: input.limit,
+					...input.before_at === void 0 ? {} : {
+						before_at: input.before_at,
+						before_id: input.before_id
+					}
+				};
+				break;
+			case "received":
+				path = "received/query";
+				body = {
+					limit: input.limit,
+					world_only: input.world_only,
+					...input.before_at === void 0 ? {} : {
+						before_at: input.before_at,
+						before_id: input.before_id
+					}
+				};
+				break;
+			case "history-policy-query":
+				path = "history-policy/query";
+				body = {};
+				break;
+			case "history-policy-set":
+				path = "history-policy/set";
+				body = {
+					expected_revision: input.expected_revision,
+					locked: input.locked
+				};
+				break;
+			case "library-query":
+				path = "library/query";
+				body = {};
+				break;
+			case "library-set":
+				path = "library/set";
+				body = {
+					items: input.items,
+					expected_revision: input.expected_revision,
+					request_id: input.request_id
+				};
+				break;
+			default: throw new ArkmePluginError("reaction-operation-invalid", "不支持的表态操作", false);
+		}
+		const before = await this.runtime.requireSession();
+		if (`${this.runtime.config.environment}:${before.userId}` !== accountKey) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+		const result = objectValue$2(await this.runtime.authenticatedPost(`/api/v1/reactions/${path}`, body, session, signal));
+		const current = await this.runtime.requireSession();
+		if (signal?.aborted || `${this.runtime.config.environment}:${current.userId}` !== accountKey) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+		if (input.action === "query") {
+			if (!Array.isArray(result.items)) throw new ArkmePluginError("reaction-response-invalid", "表态数据不完整", true);
+			const seen = /* @__PURE__ */ new Set();
+			return { items: array(result.items, 50).flatMap((raw) => {
+				const item = objectValue$2(raw), wireKey = targetKey(objectValue$2(item.target)), aliases = ids.get(wireKey);
+				if (!aliases || seen.has(wireKey)) return invalid$11();
+				seen.add(wireKey);
+				const snapshot = {
+					mine: state(item.mine),
+					groups: array(item.groups, 100).map(group),
+					has_more: boolean(item.has_more),
+					actors_visible: boolean(item.actors_visible),
+					private: boolean(item.private)
+				};
+				return aliases.map((id) => ({
+					target_id: id,
+					...snapshot
+				}));
+			}) };
+		}
+		if (input.action === "notifications-read") return { ok: boolean(result.ok) };
+		if (input.action === "notifications") {
+			if (!this.chatSourceKey) return invalid$11();
+			const items = await Promise.all(array(result.items, 50).map(async (raw) => {
+				const item = objectValue$2(raw), target = objectValue$2(item.target);
+				if (typeof target.chat_session_uid !== "string" || !target.chat_session_uid || typeof item.record_uid !== "string" || !item.record_uid) return invalid$11();
+				return {
+					id: key(item.id),
+					revision: integer$4(item.revision, 1),
+					actorUserId: integer$4(item.actor_user_id, 1),
+					sourceKey: await this.chatSourceKey(session.userId, target.chat_session_uid),
+					itemUid: item.record_uid,
+					recordOwnerUserId: integer$4(item.record_owner_user_id, 1),
+					sendAtMillis: integer$4(item.attach_at),
+					text: typeof item.text === "string" ? item.text.slice(0, 320) : "",
+					selections: array(item.selections, 56).map((raw) => {
+						const selected = objectValue$2(raw);
+						return {
+							key: key(selected.key),
+							expression: expression(selected.expression),
+							at: integer$4(selected.at)
+						};
+					})
+				};
+			}));
+			if (signal?.aborted || `${this.runtime.config.environment}:${(await this.runtime.requireSession()).userId}` !== accountKey) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+			return {
+				items,
+				after_id: result.after_id === "" ? "" : key(result.after_id),
+				has_more: boolean(result.has_more)
+			};
+		}
+		if (input.action === "library-query") return library(result);
+		if (input.action === "history-policy-query") return {
+			revision: integer$4(result.revision),
+			locked: boolean(result.locked)
+		};
+		if (input.action === "history-policy-set") {
+			if (![
+				"updated",
+				"unchanged",
+				"revision_conflict"
+			].includes(String(result.outcome))) return invalid$11();
+			const policy = objectValue$2(result.policy);
+			return {
+				outcome: result.outcome,
+				policy: {
+					revision: integer$4(policy.revision),
+					locked: boolean(policy.locked)
+				}
+			};
+		}
+		if (input.action === "library-set") {
+			if (![
+				"updated",
+				"idempotent",
+				"revision_conflict"
+			].includes(String(result.outcome))) return invalid$11();
+			return {
+				outcome: result.outcome,
+				library: library(result.library)
+			};
+		}
+		if (input.action === "set") {
+			if (![
+				"updated",
+				"unchanged",
+				"idempotent",
+				"revision_conflict"
+			].includes(String(result.outcome))) return invalid$11();
+			return {
+				outcome: result.outcome,
+				state: state(result.state)
+			};
+		}
+		if (input.action === "actors") return {
+			user_ids: array(result.user_ids, 100).map((id) => integer$4(id, 1)),
+			has_more: boolean(result.has_more)
+		};
+		if (input.action === "groups") return {
+			items: array(result.items, 100).map(group),
+			has_more: boolean(result.has_more)
+		};
+		if (input.action === "history" || input.action === "received") {
+			const rows = array(result.items, 100).map(objectValue$2);
+			const contextRows = rows.filter((item) => item.restricted === false);
+			const contexts = input.action === "history" && this.historyContext ? await this.historyContext(contextRows.map((item) => {
+				const original = objectValue$2(item.original_message);
+				return {
+					sessionUID: String(objectValue$2(item.target).chat_session_uid ?? ""),
+					senderID: integer$4(item.sender_user_id ?? 0),
+					sourceKind: String(item.source_kind ?? ""),
+					...typeof original.record_uid === "string" && original.record_uid ? { message: {
+						recordUID: original.record_uid,
+						ownerUserID: integer$4(original.owner_user_id, 1),
+						sendAtMillis: integer$4(original.send_at, 1)
+					} } : {}
+				};
+			}), signal) : [];
+			if (signal?.aborted || `${this.runtime.config.environment}:${(await this.runtime.requireSession()).userId}` !== accountKey) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+			const contextByRow = new Map(contextRows.map((row, index) => [row, contexts[index]]));
+			return {
+				items: await Promise.all(rows.map(async (item) => {
+					const target = objectValue$2(item.target);
+					if (typeof target.chat_session_uid !== "string" || typeof target.rel_uid !== "string") return invalid$11();
+					const targetID = createHash("sha256").update(JSON.stringify([session.userId, targetKey(target)])).digest("hex");
+					const received = input.action === "received" ? {
+						actor_user_id: integer$4(item.actor_user_id, 1),
+						private: boolean(item.private),
+						...input.world_only && typeof target.record_uid === "string" && this.worldReference ? { target: {
+							id: targetID,
+							worldRecordRef: await this.worldReference(target.record_uid)
+						} } : {}
+					} : {};
+					const restricted = boolean(item.restricted);
+					return {
+						...received,
+						...!restricted ? contextByRow.get(item) : {},
+						event_uid: key(item.event_uid),
+						target_id: targetID,
+						expression: expression(item.expression),
+						active: boolean(item.active),
+						at: integer$4(item.at),
+						restricted,
+						...!restricted && typeof item.source_kind === "string" ? { source_kind: item.source_kind } : {},
+						...!restricted && typeof item.text === "string" ? { text: item.text.slice(0, 320) } : {}
+					};
+				})),
+				has_more: boolean(result.has_more),
+				...result.has_more ? {
+					before_at: integer$4(result.before_at),
+					before_id: key(result.before_id)
+				} : {}
+			};
+		}
+		return invalid$11();
+	}
+};
+//#endregion
 //#region src/managed-ai/image-preparer.ts
 const MAXIMUM_DECODED_IMAGE_PIXELS = 4e7;
 const MAXIMUM_SOURCE_IMAGE_BYTES = 64 << 20;
@@ -44298,7 +44664,6 @@ var ArkmeChatRealtimeRuntime = class {
 //#region src/services/chat-realtime-service.ts
 const MAX_PROJECTION_RETRIES = 5;
 const MAX_ATTENTION_SUMMARY_RETRY_DELAY_MS = 3e4;
-const MAX_NATIVE_NOTIFICATION_DELIVERY_CONCURRENCY = 3;
 const MAX_NOTIFICATION_HINTS_PER_TIMELINE_READ = 50;
 const NOTIFICATION_EXPIRY_MILLIS = 5 * 6e4;
 const CHAT_NOTIFICATION_DIAGNOSTICS = process.env.ARKME_CHAT_NOTIFICATION_DIAGNOSTICS === "1";
@@ -44410,6 +44775,7 @@ var ChatRealtimeService = class {
 	}
 	dispose() {
 		this.disposed = true;
+		this.attentionOwnerGeneration += 1;
 		this.attentionController.abort();
 		if (this.projectionTimer !== void 0) clearTimeout(this.projectionTimer);
 		if (this.connectionBaselineRetryTimer !== void 0) clearTimeout(this.connectionBaselineRetryTimer);
@@ -45018,7 +45384,7 @@ var ChatRealtimeService = class {
 			accountUserId: notificationHint?.accountUserId ?? current?.accountUserId,
 			accountOwnerGeneration: notificationHint?.accountOwnerGeneration ?? current?.accountOwnerGeneration
 		});
-		this.scheduleProjectionFlush(200);
+		this.scheduleProjectionFlush(0);
 	}
 	scheduleProjectionFlush(delayMillis) {
 		if (this.projectionInFlight || this.disposed) return;
@@ -45037,7 +45403,7 @@ var ChatRealtimeService = class {
 		const now = Date.now();
 		let delay = Number.POSITIVE_INFINITY;
 		for (const projection of this.pendingChatProjections.values()) {
-			if (projection.refreshSource !== false) delay = Math.min(delay, 200);
+			if (projection.refreshSource !== false) delay = 0;
 			for (const candidate of projection.notificationHints) {
 				const dueAtMillis = candidate.nextAttemptAtMillis ?? now + notificationRetryDelay(candidate.attempts);
 				delay = Math.min(delay, Math.max(0, dueAtMillis - now));
@@ -45175,26 +45541,29 @@ var ChatRealtimeService = class {
 		if (pending.length === 0) return [];
 		for (const [uid, projection] of pending) if (projection.refreshSource === false && this.source.cachedChatSourceByKey(`${String(session.userId)}:${uid}`) === void 0) projection.refreshSource = true;
 		const sourcePending = pending.filter(([, projection]) => projection.refreshSource !== false);
-		const bundles = /* @__PURE__ */ new Map();
-		if (sourcePending.length > 0) {
-			const sessionUids = sourcePending.map(([uid]) => uid).sort();
-			const projectionBatchKey = sessionUids.join("|");
-			const displayData = await this.runtime.authenticatedChatPost("/api/v1/chats/display-snapshots", { chat_session_uids: sessionUids }, session, void 0, {
-				lane: sourcePending.some(([, projection]) => projection.notificationHints.length > 0) ? "interactive-read" : "background-read",
-				key: `projection:display:${projectionBatchKey}`
-			});
-			for (const raw of listValue$18(displayData.items)) {
-				const bundle = objectValue$2(raw);
-				const uid = stringValue$2(objectValue$2(bundle.session).chat_session_uid).trim();
-				if (uid !== "") bundles.set(uid, bundle);
+		const displayReady = (async () => {
+			const bundles = /* @__PURE__ */ new Map();
+			if (sourcePending.length > 0) {
+				const sessionUids = sourcePending.map(([uid]) => uid).sort();
+				const projectionBatchKey = sessionUids.join("|");
+				const displayData = await this.runtime.authenticatedChatPost("/api/v1/chats/display-snapshots", { chat_session_uids: sessionUids }, session, void 0, {
+					lane: sourcePending.some(([, projection]) => projection.notificationHints.length > 0) ? "interactive-read" : "background-read",
+					key: `projection:display:${projectionBatchKey}`
+				});
+				for (const raw of listValue$18(displayData.items)) {
+					const bundle = objectValue$2(raw);
+					const uid = stringValue$2(objectValue$2(bundle.session).chat_session_uid).trim();
+					if (uid !== "") bundles.set(uid, bundle);
+				}
 			}
-		}
-		const tailItemsByUid = /* @__PURE__ */ new Map();
-		const failedUids = /* @__PURE__ */ new Set();
-		const timelinePending = pending.filter(([, projection]) => projection.refreshSource !== false || projection.notificationHints.some((candidate) => candidate.resolvedNotification === void 0));
-		for (let offset = 0; offset < timelinePending.length; offset += 3) {
-			const chunk = timelinePending.slice(offset, offset + 3);
-			(await Promise.allSettled(chunk.map(async ([uid, projection]) => {
+			return bundles;
+		})().catch(() => void 0);
+		const failed = [];
+		const notificationLanes = Array.from({ length: 3 }, () => Promise.resolve());
+		let nextNotificationLane = 0;
+		const project = async ([uid, projection]) => {
+			let timelineProjection;
+			if (projection.refreshSource !== false || projection.notificationHints.some((candidate) => candidate.resolvedNotification === void 0)) {
 				const cached = this.source.cachedChatSourceByKey(`${String(session.userId)}:${uid}`);
 				const unresolvedHints = projection.notificationHints.filter((candidate) => candidate.resolvedNotification === void 0);
 				const firstHintSequence = unresolvedHints.reduce((minimum, item) => Math.min(minimum, item.hint.latestSequence), projection.latestSequence);
@@ -45209,32 +45578,24 @@ var ChatRealtimeService = class {
 					lane: projection.notificationHints.length > 0 ? "interactive-read" : "background-read",
 					key: `projection:tail:${uid}:${String(afterSequence)}:${String(notificationAttempt)}`
 				});
-				const bundle = bundles.get(uid);
+				const bundles = await displayReady;
+				if (bundles === void 0 && projection.refreshSource !== false) throw new Error("Chat display projection failed");
+				const bundle = bundles?.get(uid);
 				const sessionKind = numberValue$21(objectValue$2(bundle).session_kind ?? objectValue$2(objectValue$2(bundle).session).session_kind);
 				const sourceKind = sessionKind === 2 ? "group_chat" : sessionKind === 1 || sessionKind === 3 ? "private_chat" : cached?.kind === "group_chat" || cached?.kind === "private_chat" ? cached.kind : void 0;
-				return [uid, {
+				timelineProjection = {
 					items: await this.projectionReader.chatTimelineItems(data, session, uid, sourceKind, bundle),
 					notificationIdentities: timelineNotificationIdentities(data)
-				}];
-			}))).forEach((result, index) => {
-				const uid = chunk[index]?.[0];
-				if (uid === void 0) return;
-				if (result.status === "fulfilled") tailItemsByUid.set(result.value[0], result.value[1]);
-				else failedUids.add(uid);
-			});
-		}
-		if (ownerGeneration !== this.attentionOwnerGeneration) return [];
-		const updates = [];
-		const sidebarNotificationHints = [];
-		const notifications = [];
-		for (const [uid, projection] of pending) {
-			const bundle = bundles.get(uid);
-			if (projection.refreshSource !== false && bundle === void 0 || failedUids.has(uid)) {
-				failedUids.add(uid);
-				continue;
+				};
 			}
+			if (ownerGeneration !== this.attentionOwnerGeneration) return [];
+			const bundles = await displayReady;
+			const updates = [];
+			const sidebarNotificationHints = [];
+			const notifications = [];
+			const bundle = bundles?.get(uid);
+			if (projection.refreshSource !== false && bundle === void 0) return [[uid, projection]];
 			const cacheKey = `${String(session.userId)}:${uid}`;
-			const timelineProjection = tailItemsByUid.get(uid);
 			const timelineItems = timelineProjection?.items ?? [];
 			try {
 				const cachedSource = this.source.cachedChatSourceByKey(cacheKey);
@@ -45244,8 +45605,7 @@ var ChatRealtimeService = class {
 						...projection,
 						refreshSource: true
 					});
-					failedUids.add(uid);
-					continue;
+					return [[uid, projection]];
 				}
 				if (ownerGeneration !== this.attentionOwnerGeneration) return [];
 				if (projection.refreshSource !== false) this.source.setChatSourceByKey(cacheKey, source);
@@ -45335,117 +45695,137 @@ var ChatRealtimeService = class {
 					});
 				}
 			} catch {
-				failedUids.add(uid);
+				return [[uid, projection]];
 			}
-		}
-		if (ownerGeneration !== this.attentionOwnerGeneration) return [];
-		if (updates.length > 0) {
-			this.source.invalidateSourceListCache(session.userId, "root");
-			this.runtime.invalidateCalendarDates(this.runtime.requestScope(session.userId), updates.flatMap((update) => [update.source.activeAtMillis, ...update.timelineItems.map((item) => item.sendAtMillis)]));
-			this.emitChatClientEvent({
-				type: "sessions-delta",
-				revision: this.nextChatClientRevision(),
-				updates
-			});
-			const emittedAtMillis = Date.now();
-			for (const { candidate } of sidebarNotificationHints) notificationDiagnostic("notification_sidebar_delta_emitted", {
-				eventUid: candidate.hint.eventUid,
-				connectionGeneration: candidate.connectionGeneration,
-				attempt: candidate.attempts,
-				emittedAtMillis,
-				...candidate.receivedAtMillis === void 0 ? {} : { durationFromHintMillis: Math.max(0, emittedAtMillis - candidate.receivedAtMillis) }
-			});
-			this.refreshAttentionSummary();
-		}
-		const deliveries = [];
-		for (let offset = 0; offset < notifications.length; offset += MAX_NATIVE_NOTIFICATION_DELIVERY_CONCURRENCY) {
-			const chunk = notifications.slice(offset, offset + MAX_NATIVE_NOTIFICATION_DELIVERY_CONCURRENCY);
-			deliveries.push(...await Promise.all(chunk.map(async (entry) => {
-				const { notification, candidate } = entry;
-				if (ownerGeneration !== this.attentionOwnerGeneration) return {
-					entry,
-					fallbackToBrowser: false,
-					outcome: "exception"
-				};
-				const dispatchStartedAtMillis = Date.now();
-				try {
-					const outcome = await this.nativeAttention.showNotification({
-						idempotencyKey: notification.eventUid,
-						kind: "chat.message",
-						occurredAtMillis: notification.eventAtMillis,
-						expiresAtMillis: notification.eventAtMillis + NOTIFICATION_EXPIRY_MILLIS,
-						presentation: {
-							title: notification.title,
-							body: notification.body
-						},
-						activation: {
-							kind: "chat-source",
-							sourceRef: notification.sourceRef,
-							sourceKey: notification.sourceKey
+			if (ownerGeneration !== this.attentionOwnerGeneration) return [];
+			if (updates.length > 0) {
+				this.source.invalidateSourceListCache(session.userId, "root");
+				this.runtime.invalidateCalendarDates(this.runtime.requestScope(session.userId), updates.flatMap((update) => [update.source.activeAtMillis, ...update.timelineItems.map((item) => item.sendAtMillis)]));
+				this.emitChatClientEvent({
+					type: "sessions-delta",
+					revision: this.nextChatClientRevision(),
+					updates
+				});
+				const emittedAtMillis = Date.now();
+				for (const { candidate } of sidebarNotificationHints) notificationDiagnostic("notification_sidebar_delta_emitted", {
+					eventUid: candidate.hint.eventUid,
+					connectionGeneration: candidate.connectionGeneration,
+					attempt: candidate.attempts,
+					emittedAtMillis,
+					...candidate.receivedAtMillis === void 0 ? {} : { durationFromHintMillis: Math.max(0, emittedAtMillis - candidate.receivedAtMillis) }
+				});
+				this.refreshAttentionSummary();
+			}
+			if (notifications.length > 0) {
+				const lane = nextNotificationLane++ % notificationLanes.length;
+				notificationLanes[lane] = notificationLanes[lane].then(async () => {
+					const deliveries = [];
+					for (let offset = 0; offset < notifications.length; offset += 1) {
+						const chunk = notifications.slice(offset, offset + 1);
+						deliveries.push(...await Promise.all(chunk.map(async (entry) => {
+							const { notification, candidate } = entry;
+							if (ownerGeneration !== this.attentionOwnerGeneration) return {
+								entry,
+								fallbackToBrowser: false,
+								outcome: "exception"
+							};
+							const dispatchStartedAtMillis = Date.now();
+							try {
+								const outcome = await this.nativeAttention.showNotification({
+									idempotencyKey: notification.eventUid,
+									kind: "chat.message",
+									occurredAtMillis: notification.eventAtMillis,
+									expiresAtMillis: notification.eventAtMillis + NOTIFICATION_EXPIRY_MILLIS,
+									presentation: {
+										title: notification.title,
+										body: notification.body
+									},
+									activation: {
+										kind: "chat-source",
+										sourceRef: notification.sourceRef,
+										sourceKey: notification.sourceKey
+									}
+								});
+								const completedAtMillis = Date.now();
+								notificationDiagnostic("notification_native_dispatch_completed", {
+									eventUid: notification.eventUid,
+									connectionGeneration: candidate.connectionGeneration,
+									attempt: candidate.attempts,
+									outcome: outcome.outcome,
+									completedAtMillis,
+									dispatchDurationMillis: Math.max(0, completedAtMillis - dispatchStartedAtMillis),
+									...candidate.receivedAtMillis === void 0 ? {} : { durationFromHintMillis: Math.max(0, completedAtMillis - candidate.receivedAtMillis) }
+								});
+								return {
+									entry,
+									fallbackToBrowser: outcome.fallbackToBrowser,
+									outcome: outcome.outcome
+								};
+							} catch {
+								const completedAtMillis = Date.now();
+								notificationDiagnostic("notification_native_dispatch_completed", {
+									eventUid: notification.eventUid,
+									connectionGeneration: candidate.connectionGeneration,
+									attempt: candidate.attempts,
+									outcome: "exception",
+									completedAtMillis,
+									dispatchDurationMillis: Math.max(0, completedAtMillis - dispatchStartedAtMillis),
+									...candidate.receivedAtMillis === void 0 ? {} : { durationFromHintMillis: Math.max(0, completedAtMillis - candidate.receivedAtMillis) }
+								});
+								return {
+									entry,
+									fallbackToBrowser: false,
+									outcome: "exception"
+								};
+							}
+						})));
+					}
+					if (ownerGeneration !== this.attentionOwnerGeneration) return [];
+					for (const { entry, fallbackToBrowser, outcome } of deliveries) {
+						const { notification, candidate, uid, latestSequence } = entry;
+						if (outcome === "native-failed" || outcome === "rate-limited" || outcome === "exception") {
+							if (!notificationExpired(candidate)) {
+								const attempts = candidate.attempts + 1;
+								this.mergePendingChatProjection(uid, {
+									latestSequence,
+									notificationHints: [{
+										...candidate,
+										attempts,
+										nextAttemptAtMillis: Date.now() + notificationRetryDelay(attempts)
+									}],
+									refreshSource: false,
+									accountUserId: session.userId,
+									accountOwnerGeneration: ownerGeneration
+								});
+							}
+							continue;
 						}
-					});
-					const completedAtMillis = Date.now();
-					notificationDiagnostic("notification_native_dispatch_completed", {
-						eventUid: notification.eventUid,
-						connectionGeneration: candidate.connectionGeneration,
-						attempt: candidate.attempts,
-						outcome: outcome.outcome,
-						completedAtMillis,
-						dispatchDurationMillis: Math.max(0, completedAtMillis - dispatchStartedAtMillis),
-						...candidate.receivedAtMillis === void 0 ? {} : { durationFromHintMillis: Math.max(0, completedAtMillis - candidate.receivedAtMillis) }
-					});
-					return {
-						entry,
-						fallbackToBrowser: outcome.fallbackToBrowser,
-						outcome: outcome.outcome
-					};
+						if (!fallbackToBrowser) continue;
+						this.emitChatClientEvent({
+							type: "message-notification",
+							revision: this.nextChatClientRevision(),
+							notification
+						});
+					}
+				}).then(() => void 0).catch(() => {
+					failed.push([uid, projection]);
+				});
+			}
+			return [];
+		};
+		let next = 0;
+		await Promise.all(Array.from({ length: Math.min(3, pending.length) }, async () => {
+			while (next < pending.length && ownerGeneration === this.attentionOwnerGeneration) {
+				const entry = pending[next++];
+				try {
+					failed.push(...await project(entry));
 				} catch {
-					const completedAtMillis = Date.now();
-					notificationDiagnostic("notification_native_dispatch_completed", {
-						eventUid: notification.eventUid,
-						connectionGeneration: candidate.connectionGeneration,
-						attempt: candidate.attempts,
-						outcome: "exception",
-						completedAtMillis,
-						dispatchDurationMillis: Math.max(0, completedAtMillis - dispatchStartedAtMillis),
-						...candidate.receivedAtMillis === void 0 ? {} : { durationFromHintMillis: Math.max(0, completedAtMillis - candidate.receivedAtMillis) }
-					});
-					return {
-						entry,
-						fallbackToBrowser: false,
-						outcome: "exception"
-					};
-				}
-			})));
-		}
-		if (ownerGeneration !== this.attentionOwnerGeneration) return [];
-		for (const { entry, fallbackToBrowser, outcome } of deliveries) {
-			const { notification, candidate, uid, latestSequence } = entry;
-			if (outcome === "native-failed" || outcome === "rate-limited" || outcome === "exception") {
-				if (!notificationExpired(candidate)) {
-					const attempts = candidate.attempts + 1;
-					this.mergePendingChatProjection(uid, {
-						latestSequence,
-						notificationHints: [{
-							...candidate,
-							attempts,
-							nextAttemptAtMillis: Date.now() + notificationRetryDelay(attempts)
-						}],
-						refreshSource: false,
-						accountUserId: session.userId,
-						accountOwnerGeneration: ownerGeneration
-					});
+					failed.push(entry);
 				}
-				continue;
 			}
-			if (!fallbackToBrowser) continue;
-			this.emitChatClientEvent({
-				type: "message-notification",
-				revision: this.nextChatClientRevision(),
-				notification
-			});
-		}
-		return pending.filter(([uid]) => failedUids.has(uid));
+		}));
+		await Promise.all(notificationLanes);
+		return failed;
 	}
 	emitChatClientEvent(event) {
 		for (const listener of [...this.chatClientListeners]) listener(event);
@@ -49428,12 +49808,13 @@ var ChatService = class {
 		if (!options.signal?.aborted && cacheEpoch === (this.runtime.memberCacheEpoch?.() ?? 0)) await this.runtime.stateStore.mergeConversationMembers?.(session.userId, source.ownerRef, result).catch(() => void 0);
 		return result;
 	}
-	async memberRead(session, group, path, body, signal) {
+	async memberRead(session, group, path, body, signal, cacheMs) {
 		try {
 			return await this.runtime.authenticatedChatPost(path, body, session, signal, {
 				lane: path.endsWith("/members/page") ? "interactive-read" : "background-read",
 				key: `members:${this.runtime.memberCacheEpoch?.() ?? 0}:${path}:${JSON.stringify(body)}`,
-				failureCooldownMs: 2e3
+				failureCooldownMs: 2e3,
+				...cacheMs === void 0 ? {} : { cacheMs }
 			});
 		} catch (error) {
 			if (invalidatesMemberSnapshot(error)) {
@@ -50555,6 +50936,49 @@ var ChatService = class {
 			recordOwnerUserId: reference.recordOwnerUserId
 		};
 	}
+	async reactionTarget(sourceRef, messageActionRef) {
+		const session = await this.runtime.requireSession();
+		const source = await this.source.openSourceRef(sourceRef.trim(), session.userId);
+		const reference = await this.openMessageActionRef(messageActionRef, session.userId, source);
+		if (reference.sourceKind === "record") return {
+			record_uid: reference.recordUid,
+			owned: true
+		};
+		return {
+			chat_session_uid: reference.chatSessionUid,
+			rel_uid: reference.relationUid
+		};
+	}
+	/** Keep viewer-owned remarks separate from group nicknames and public profiles. */
+	async reactionActorLabels(sourceRef, userIds, signal) {
+		const session = await this.runtime.requireSession();
+		const source = await this.source.openSourceRef(sourceRef.trim(), session.userId);
+		const names = /* @__PURE__ */ new Map();
+		if (source.kind !== "group_chat" && source.kind !== "private_chat") return names;
+		const ids = [...new Set(userIds)].sort((left, right) => left - right);
+		for (let offset = 0; offset < ids.length; offset += 50) {
+			signal?.throwIfAborted();
+			const batch = ids.slice(offset, offset + 50);
+			const data = await this.memberRead(session, source.ownerRef, "/api/v1/chats/members/by-user-ids", {
+				chat_session_uid: source.ownerRef,
+				user_ids: batch,
+				active_only: true,
+				include_stats: false
+			}, signal, 5e3);
+			const items = listValue$16(data.items).map(objectValue$2);
+			if (stringValue$2(data.chat_session_uid) !== source.ownerRef || !Array.isArray(data.items) || items.length > batch.length || items.some((item) => !batch.includes(numberValue$19(item.user_id)) || numberValue$19(item.status) !== 1)) throw new ArkmePluginError("member-presentation-invalid-response", "成员资料响应无效", true, 502);
+			for (const item of items) {
+				const userId = numberValue$19(item.user_id);
+				const groupNickname = source.kind === "group_chat" ? firstUsableChatMemberName([item.display_name_snapshot], userId) : "";
+				const remark = userId === session.userId ? "" : normalizedJoinDisplayName(item.remark);
+				names.set(userId, {
+					remark,
+					groupNickname
+				});
+			}
+		}
+		return names;
+	}
 	async sourceMessageExtensionContext(sourceRef, messageActionRef, options = {}) {
 		const session = await this.runtime.requireSession();
 		const source = await this.source.openSourceRef(sourceRef.trim(), session.userId);
@@ -87358,7 +87782,7 @@ var ProfileService = class {
 	async userCard(userId, signal) {
 		const session = await this.runtime.requireSession();
 		if (!Number.isSafeInteger(userId) || userId <= 0) throw new ArkmePluginError("user-card-target-invalid", "用户信息参数无效", false);
-		const profile = (await this.publicProfileSummariesByUserIds([userId], session, signal)).get(userId);
+		const profile = (await this.publicProfileSummariesByUserIds([userId], session, signal, 0)).get(userId);
 		return {
 			displayName: profile?.displayName ?? "群成员",
 			...profile?.avatarUrl === void 0 ? {} : { avatarRef: await this.sealProfileImageRef(session.userId, userId) }
@@ -87508,7 +87932,7 @@ var ProfileService = class {
 		const avatarRef = profile.avatarRef.trim();
 		return /^https?:\/\//i.test(avatarRef) || fileAssetAvatarRef(avatarRef) !== void 0;
 	}
-	async publicProfileSummariesByUserIds(userIds, session, signal) {
+	async publicProfileSummariesByUserIds(userIds, session, signal, maxAgeMillis = PUBLIC_PROFILE_CACHE_TTL_MS) {
 		const normalized = [...new Set(userIds.filter((userId) => Number.isSafeInteger(userId) && userId > 0))].sort((left, right) => left - right);
 		const profiles = /* @__PURE__ */ new Map();
 		const missing = [];
@@ -87516,7 +87940,7 @@ var ProfileService = class {
 		for (const [key, cached] of this.publicProfileCache) if (cached.expiresAtMillis <= now) this.publicProfileCache.delete(key);
 		for (const userId of normalized) {
 			const cached = this.publicProfileCache.get(`${String(session.userId)}:${String(userId)}`);
-			if (cached === void 0 || cached.expiresAtMillis <= now) {
+			if (cached === void 0 || cached.expiresAtMillis <= now || cached.expiresAtMillis - (cached.value === null ? PUBLIC_PROFILE_NEGATIVE_CACHE_TTL_MS : PUBLIC_PROFILE_CACHE_TTL_MS) + maxAgeMillis <= now) {
 				missing.push(userId);
 				continue;
 			}
@@ -90219,6 +90643,68 @@ var RecordingService = class {
 	}
 };
 //#endregion
+//#region src/services/recording-import-upload-retry.ts
+const RECORDING_UPLOAD_RETRY_DELAYS = [
+	1e3,
+	2e3,
+	4e3,
+	8e3,
+	16e3
+];
+const RECORDING_UPLOAD_REQUEST_TIMEOUT = 300 * 1e3;
+const transientStatuses = /* @__PURE__ */ new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const transientNames = /* @__PURE__ */ new Set([
+	"ResponseTimeoutError",
+	"ConnectionTimeoutError",
+	"SocketAssignTimeoutError"
+]);
+const transientCodes = /* @__PURE__ */ new Set([
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"ECONNABORTED",
+	"ETIMEDOUT",
+	"EPIPE",
+	"EAI_AGAIN",
+	"ENOTFOUND",
+	"ENETUNREACH",
+	"EHOSTUNREACH"
+]);
+function isRetryableRecordingUploadError(error) {
+	if (error === null || typeof error !== "object" || error instanceof RecordingImportContractError) return false;
+	const { status, name, code } = error;
+	if (name === "cancel" || name === "abort" || name === "AbortError") return false;
+	if (typeof status === "number" && status >= 400) return transientStatuses.has(status);
+	if (typeof code === "string" && code !== "" && transientCodes.has(code)) return true;
+	if ((status === -1 || status === -2) && code === name && typeof name === "string" && (transientNames.has(name) || name === "RequestError" || name === "ResponseError")) return true;
+	if (typeof code === "string" && code !== "") return false;
+	return typeof name === "string" && transientNames.has(name);
+}
+function throwIfRecordingUploadAborted(signal) {
+	if (signal?.aborted === true) throw new RecordingImportContractError("recording-import-cancelled", "录音导入已取消");
+}
+function waitForRecordingUploadRetry(delay, signal) {
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+			reject(new RecordingImportContractError("recording-import-cancelled", "录音导入已取消"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		}, Math.round(delay * (1 + Math.random() * .3)));
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted === true) abort();
+	});
+}
+//#endregion
 //#region src/services/recording-import-gateway.ts
 const AUDIO_SESSION_RECOVERY_LIMIT = 500;
 const AUDIO_IMPORT_DUPLICATE_BATCH_SIZE = 100;
@@ -90572,6 +91058,8 @@ var AudioRecordingImportGateway = class {
 			accessKeyId: credentials.accessKeyId,
 			accessKeySecret: credentials.accessKeySecret,
 			stsToken: credentials.stsToken,
+			timeout: RECORDING_UPLOAD_REQUEST_TIMEOUT,
+			retryMax: 0,
 			refreshSTSTokenInterval: 300 * 1e3,
 			refreshSTSToken: async () => {
 				await this.requireJobSession(job);
@@ -90602,17 +91090,40 @@ var AudioRecordingImportGateway = class {
 		signal?.addEventListener("abort", abort, { once: true });
 		try {
 			const objectPath = `pc_upload/${String(job.userId)}/${job.sessionId}/${remoteFileName(job)}`;
-			const upload = client.multipartUpload(objectPath, job.sourceHandle, {
-				parallel: 1,
-				partSize: 5 * 1024 * 1024,
-				checkpoint: job.uploadCheckpoint,
-				mime: job.mimeType,
-				progress: async (percentage, checkpoint) => {
-					if (signal?.aborted === true) throw new RecordingImportContractError("recording-import-cancelled", "录音导入已取消");
-					const bounded = Math.min(1, Math.max(0, percentage));
-					await onProgress(Math.round(job.fileSize * bounded), checkpoint);
+			let latestCheckpoint = job.uploadCheckpoint;
+			const upload = (async () => {
+				for (let attempt = 0;; attempt += 1) {
+					throwIfRecordingUploadAborted(signal);
+					if (attempt > 0) await this.requireJobSession(job);
+					throwIfRecordingUploadAborted(signal);
+					let progressFailed = false;
+					try {
+						await client.multipartUpload(objectPath, job.sourceHandle, {
+							parallel: 1,
+							partSize: 5 * 1024 * 1024,
+							checkpoint: latestCheckpoint,
+							mime: job.mimeType,
+							progress: async (percentage, checkpoint) => {
+								try {
+									if (signal?.aborted === true) throw new RecordingImportContractError("recording-import-cancelled", "录音导入已取消");
+									const bounded = Math.min(1, Math.max(0, percentage));
+									await onProgress(Math.round(job.fileSize * bounded), checkpoint);
+									if (checkpoint !== void 0) latestCheckpoint = checkpoint;
+								} catch (error) {
+									progressFailed = true;
+									throw error;
+								}
+							}
+						});
+						return;
+					} catch (error) {
+						const delay = RECORDING_UPLOAD_RETRY_DELAYS[attempt];
+						if (signal?.aborted === true || progressFailed || !isRetryableRecordingUploadError(error)) throw error;
+						if (delay === void 0) throw new ArkmePluginError("recording-import-upload-failed", error instanceof Error ? error.message : "录音上传失败", true, 503, { cause: error });
+						await waitForRecordingUploadRetry(delay, signal);
+					}
 				}
-			});
+			})();
 			await (signal === void 0 ? upload : Promise.race([upload, aborted]));
 		} finally {
 			signal?.removeEventListener("abort", abort);
@@ -94504,6 +95015,15 @@ var WorldService = class {
 	media;
 	record;
 	viewerLabels;
+	/** Called only for a Record-owner-authorized received-reaction response. */
+	async reactionReference(recordUid) {
+		const session = await this.runtime.requireSession();
+		return this.worldRecordRef(session.userId, recordUid, { ownerUserId: session.userId });
+	}
+	async reactionTarget(recordRef) {
+		const session = await this.runtime.requireSession();
+		return { record_uid: this.openWorldRecordRef(recordRef, session.userId).recordUid };
+	}
 	worldImageRefs = /* @__PURE__ */ new Map();
 	worldAvatarResolutionCache = /* @__PURE__ */ new Map();
 	extensionPublicationShareCache = /* @__PURE__ */ new Map();
@@ -96050,6 +96570,7 @@ var ArkmeService = class {
 				messageReport: true,
 				userBanManagement: true,
 				directMessageAdmission: true,
+				reactionsV1: true,
 				groupOwnerGovernance: true,
 				...this.config.markdownQuickNotesEnabled === true ? { markdownQuickNotes: true } : {},
 				...this.config.markdownLongArticlesEnabled === true ? { markdownLongArticles: true } : {},
@@ -96841,6 +97362,112 @@ var ArkmeService = class {
 	async favoriteStickers(signal) {
 		return await this.chat.favoriteStickers(signal);
 	}
+	async reactions(input, signal) {
+		const result = await new ReactionService(this.runtime, (target) => target.worldRecordRef !== void 0 ? this.world.reactionTarget(target.worldRecordRef) : this.chat.reactionTarget(target.sourceRef, target.messageActionRef), (uid) => this.world.reactionReference(uid), (viewer, uid) => this.source.chatDirectorySourceKey(viewer, uid), async (items, signal) => {
+			const session = await this.runtime.requireSession();
+			const [sources, profiles] = await Promise.all([this.source.chatSourcesBySessionUids([...new Set(items.map((item) => item.sessionUID).filter(Boolean))], signal), this.profile.publicProfileSummariesByUserIds([...new Set(items.map((item) => item.senderID).filter((id) => id > 0))], session, signal, 5e3)]);
+			const missingAvatars = [...sources].filter(([, source]) => !source.avatarRef && !source.avatarRefs?.length && !source.groupAvatar);
+			if (missingAvatars.length > 0) try {
+				const hydrated = await this.source.hydrateDirectoryPage(missingAvatars.map(([, source]) => source), signal ?? new AbortController().signal);
+				missingAvatars.forEach(([uid], index) => {
+					if (hydrated[index]) sources.set(uid, hydrated[index]);
+				});
+			} catch {
+				signal?.throwIfAborted();
+			}
+			const selfSource = items.some((item) => item.sourceKind === "send_to_self" && item.message) ? {
+				sourceRef: await this.source.sealSourceRef(session.userId, "send_to_self", "all", "发给自己"),
+				kind: "send_to_self",
+				displayName: "发给自己",
+				activeAtMillis: 0,
+				unreadCount: 0
+			} : void 0;
+			return items.map((item) => {
+				const source = item.sourceKind === "send_to_self" ? selfSource : sources.get(item.sessionUID);
+				return {
+					sourceName: item.sourceKind === "send_to_self" ? "发给自己" : source?.displayName,
+					authorName: item.senderID === session.userId ? "我" : profiles.get(item.senderID)?.displayName,
+					...source && item.message ? { originalMessage: {
+						source,
+						itemUid: item.message.recordUID,
+						recordOwnerUserId: item.message.ownerUserID,
+						sendAtMillis: item.message.sendAtMillis
+					} } : {},
+					...source ? { avatar: {
+						...source.avatarRef ? { avatarRef: source.avatarRef } : {},
+						...source.avatarRefs ? { avatarRefs: source.avatarRefs } : {},
+						...source.groupAvatar ? { groupAvatar: source.groupAvatar } : {}
+					} } : {}
+				};
+			});
+		}).request(input, signal);
+		if (`${this.config.environment}:${(await this.runtime.requireSession()).userId}` !== input.accountKey || signal?.aborted) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+		const actorLabels = async (sourceRef, ids) => {
+			if (!sourceRef || !ids.length) return /* @__PURE__ */ new Map();
+			try {
+				return await this.chat.reactionActorLabels(sourceRef, ids, signal);
+			} catch (error) {
+				if (signal?.aborted) throw error;
+				return /* @__PURE__ */ new Map();
+			}
+		};
+		const actorAvatars = async (viewer, profiles) => new Map(await Promise.all([...profiles].filter(([, profile]) => profile.avatarUrl).map(async ([id]) => [id, await this.profile.sealProfileImageRef(viewer, id)])));
+		const presentActor = (userId, profileName, label, avatarRef) => ({
+			userId,
+			displayName: label?.remark || profileName?.trim() || "用户",
+			...label?.groupNickname ? { groupNickname: label.groupNickname } : {},
+			...avatarRef ? { avatarRef } : {}
+		});
+		if (input.action === "query" || input.action === "groups") {
+			const page = result;
+			const groupPage = result;
+			const groups = input.action === "query" ? page.items.flatMap((item) => item.actors_visible ? item.groups : []) : groupPage.items;
+			const ids = [...new Set(groups.flatMap((group) => group.actorIds))];
+			const session = await this.runtime.requireSession();
+			const sourceByTarget = new Map(input.action === "query" ? input.targets.map((target) => [target.id, target.sourceRef]) : []);
+			const sourceIds = /* @__PURE__ */ new Map();
+			const include = (sourceRef, actorIds) => {
+				if (!sourceRef || !actorIds.length) return;
+				const users = sourceIds.get(sourceRef) ?? /* @__PURE__ */ new Set();
+				actorIds.forEach((id) => users.add(id));
+				sourceIds.set(sourceRef, users);
+			};
+			if (input.action === "query") {
+				for (const item of page.items) if (item.actors_visible) include(sourceByTarget.get(item.target_id), item.groups.flatMap((group) => group.actorIds));
+			} else include(input.target.sourceRef, ids);
+			const [profiles, labels] = await Promise.all([this.profile.publicProfileSummariesByUserIds(ids, session, signal, 5e3), (async () => {
+				const labels = /* @__PURE__ */ new Map();
+				for (const [sourceRef, users] of sourceIds) labels.set(sourceRef, await actorLabels(sourceRef, [...users]));
+				return labels;
+			})()]);
+			const avatars = await actorAvatars(session.userId, profiles);
+			if (`${this.config.environment}:${(await this.runtime.requireSession()).userId}` !== input.accountKey || signal?.aborted) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+			const present = ({ actorIds, ...group }, sourceRef, visible = true) => ({
+				...group,
+				actors: visible ? actorIds.map((userId) => presentActor(userId, profiles.get(userId)?.displayName, labels.get(sourceRef ?? "")?.get(userId), avatars.get(userId))) : []
+			});
+			return input.action === "query" ? {
+				...page,
+				items: page.items.map((item) => ({
+					...item,
+					groups: item.groups.map((group) => present(group, sourceByTarget.get(item.target_id), item.actors_visible))
+				}))
+			} : {
+				...groupPage,
+				items: groupPage.items.map((group) => present(group, input.target.sourceRef))
+			};
+		}
+		if (input.action !== "actors") return result;
+		const page = result;
+		const session = await this.runtime.requireSession();
+		const [profiles, labels] = await Promise.all([this.profile.publicProfileSummariesByUserIds(page.user_ids, session, signal, 5e3), actorLabels(input.target.sourceRef, page.user_ids)]);
+		const avatars = await actorAvatars(session.userId, profiles);
+		if (`${this.config.environment}:${(await this.runtime.requireSession()).userId}` !== input.accountKey || signal?.aborted) throw new ArkmePluginError("reaction-account-changed", "账号已变化", false);
+		return {
+			items: page.user_ids.map((userId) => presentActor(userId, profiles.get(userId)?.displayName, labels.get(userId), avatars.get(userId))),
+			has_more: page.has_more
+		};
+	}
 	async addFavoriteSticker(item, signal) {
 		return await this.chat.addFavoriteSticker(item, signal);
 	}