@headless-lms/core 0.3.0 → 0.5.0

package/dist/discussion/chats.js

@@ -1,45 +1,76 @@
-import { genId } from "../shared/id.js";
-import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError } from "../shared/errors.js";
 import { noopLogger } from "../shared/logger.js";
-import { isStaffRole } from "../organizations/roles.js";
+import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError, UnavailableError } from "../shared/errors.js";
+import { genId } from "../shared/id.js";
 import { discussionEvents } from "./events.js";
-import { authorView } from "./authors.js";
+import { authorName, authorView } from "./authors.js";
+import { keepAllowed, mentionTokens, mentionViews } from "./mentions.js";
+import { isTeam, teamBadge } from "./rules.js";
+import { activeSubscription } from "./subscriptions.js";
 import "./ports.js";
+import { ChatHub, TYPING, publishChange } from "./live.js";
 //#region src/discussion/chats.ts
+const TYPING_FOR_MS = 5e3;
+const TYPING_REPEAT_MS = 2e3;
+function eventMessage(message) {
+	const { clientId: _clientId, ...rest } = message;
+	return rest;
+}
 var ChatServiceImpl = class {
+	/** This process's live chat hub; null without a PubSub. */
+	hub;
 	repo;
 	access;
 	content;
 	authors;
 	profiles;
+	subscriptions;
+	mentions;
 	images;
 	fileUrls;
 	uow;
+	pubsub;
 	logger;
+	typed = /* @__PURE__ */ new Map();
 	constructor(params) {
 		this.repo = params.repo;
 		this.access = params.access;
 		this.content = params.content;
 		this.authors = params.authors;
 		this.profiles = params.profiles;
+		this.subscriptions = params.subscriptions;
+		this.mentions = params.mentions;
 		this.images = params.images;
 		this.fileUrls = params.fileUrls;
 		this.uow = params.uow;
+		this.pubsub = params.pubsub ?? null;
 		this.logger = params.logger ?? noopLogger;
+		this.hub = this.pubsub ? new ChatHub({
+			pubsub: this.pubsub,
+			reads: this,
+			logger: this.logger,
+			...params.live
+		}) : null;
 	}
-	async startDirect(orgId, actor, input) {
+	async startDirect(input, actor) {
+		const orgId = actor.orgId;
 		if (actor.id === input.orgUserId) throw new InvalidInputError("You cannot message yourself");
 		if (input.body === null && input.assetIds.length > 0) throw new InvalidInputError("An attachment needs a message");
 		const settings = await this.requireSettings(orgId, input.communityId);
-		await this.requireActor(orgId, actor, input.communityId);
-		const role = await this.requirePerson(orgId, input.communityId, input.orgUserId);
-		this.assertMayMessage(settings, actor, role);
+		await this.requireActor(actor, input.communityId);
+		const targetTeam = await this.requirePerson(orgId, input.communityId, input.orgUserId);
+		const actorTeam = isTeam(actor.permissions, input.communityId);
+		this.assertMayMessage(settings, actorTeam, targetTeam);
 		const first = input.body === null ? null : {
 			body: input.body,
 			replyToId: null,
 			assetIds: input.assetIds
 		};
-		const saved = await this.uow.run(async ({ chats, outbox }) => {
+		await this.requireOwnedImages(orgId, actor.id, input.assetIds);
+		const teams = {
+			asked: /* @__PURE__ */ new Set([input.orgUserId]),
+			team: /* @__PURE__ */ new Map([[input.orgUserId, targetTeam]])
+		};
+		const saved = await this.uow.run(async ({ chats, mentions, outbox }) => {
 			await chats.lockDirectPair(orgId, input.communityId, actor.id, input.orgUserId);
 			const existing = await chats.findDirect(orgId, input.communityId, actor.id, input.orgUserId);
 			if (existing) {
@@ -49,22 +80,21 @@ var ChatServiceImpl = class {
 					...user,
 					leftAt: null
 				} : user);
-				if (first) await this.assertMaySend(chats, orgId, actor, existing, present, settings, first);
+				if (first) await this.assertMaySend(chats, orgId, actor, existing, present, settings, first, teams);
 				if (rejoin) await chats.join(orgId, this.memberRow(orgId, existing.communityId, existing.id, actor.id, /* @__PURE__ */ new Date()));
-				const written = first ? await this.writeMessage(chats, orgId, actor, existing, first) : null;
+				const written = first ? await this.writeMessage(chats, mentions, orgId, actor, existing, present, first) : null;
 				const chat = written?.chat ?? existing;
 				const events = [];
 				if (rejoin || written?.opened) events.push(this.updatedEvent(orgId, actor, chat, present));
-				if (written) events.push(this.sentEvent(orgId, actor, written.chat, written.message));
+				if (written) events.push(this.sentEvent(orgId, actor, written.chat, written.message, written.mentioned));
 				if (events.length > 0) await outbox.append(events);
 				return {
 					chat,
 					created: false
 				};
 			}
-			await this.requireOwnedImages(orgId, actor.id, input.assetIds);
 			if (await chats.isBlocked(orgId, input.communityId, actor.id, input.orgUserId)) throw new ForbiddenError("You cannot message this person");
-			const request = settings.firstMessageIsRequest && !isStaffRole(actor.role) && !isStaffRole(role);
+			const request = settings.firstMessageIsRequest && !actorTeam && !targetTeam;
 			if (request && !first) throw new InvalidInputError("A message request needs a message");
 			const now = /* @__PURE__ */ new Date();
 			const chat = await chats.insertChat(orgId, {
@@ -83,8 +113,8 @@ var ChatServiceImpl = class {
 			for (const user of users) await chats.join(orgId, user);
 			const events = [this.createdEvent(orgId, actor, chat, users)];
 			if (first) {
-				const written = await this.writeMessage(chats, orgId, actor, chat, first);
-				events.push(this.sentEvent(orgId, actor, written.chat, written.message));
+				const written = await this.writeMessage(chats, mentions, orgId, actor, chat, users, first);
+				events.push(this.sentEvent(orgId, actor, written.chat, written.message, written.mentioned));
 			}
 			await outbox.append(events);
 			return {
@@ -106,16 +136,18 @@ var ChatServiceImpl = class {
 		});
 		return saved.chat;
 	}
-	async startGroup(orgId, actor, input) {
+	async startGroup(input, actor) {
+		const orgId = actor.orgId;
 		const settings = await this.requireSettings(orgId, input.communityId);
 		this.assertGroup(settings);
-		await this.requireActor(orgId, actor, input.communityId);
+		await this.requireActor(actor, input.communityId);
 		const others = [...new Set(input.orgUserIds.filter((id) => id !== actor.id))].sort();
 		if (others.length < 2) throw new InvalidInputError("A group chat needs three people");
 		if (others.length + 1 > settings.groupSize) throw new ConflictError("This group is full");
+		const actorTeam = isTeam(actor.permissions, input.communityId);
 		for (const orgUserId of others) {
-			const role = await this.requirePerson(orgId, input.communityId, orgUserId);
-			this.assertMayMessage(settings, actor, role);
+			const targetTeam = await this.requirePerson(orgId, input.communityId, orgUserId);
+			this.assertMayMessage(settings, actorTeam, targetTeam);
 		}
 		const saved = await this.uow.run(async ({ chats, outbox }) => {
 			if (await chats.anyBlockedAmong(orgId, input.communityId, [actor.id, ...others])) throw new ForbiddenError("You cannot message this person");
@@ -146,15 +178,16 @@ var ChatServiceImpl = class {
 		});
 		return saved;
 	}
-	async addParticipant(orgId, actor, chatId, orgUserId) {
+	async addParticipant(chatId, orgUserId, actor) {
+		const orgId = actor.orgId;
 		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActor(actor, chat.communityId);
 		await this.requireActive(this.repo, orgId, chat.id, actor.id);
 		if (chat.kind !== "group") throw new ConflictError("This chat is not a group");
 		const settings = await this.requireSettings(orgId, chat.communityId);
 		this.assertGroup(settings);
-		const role = await this.requirePerson(orgId, chat.communityId, orgUserId);
-		this.assertMayMessage(settings, actor, role);
+		const targetTeam = await this.requirePerson(orgId, chat.communityId, orgUserId);
+		this.assertMayMessage(settings, isTeam(actor.permissions, chat.communityId), targetTeam);
 		const saved = await this.uow.run(async ({ chats, outbox }) => {
 			const current = await this.mustChat(chats, orgId, chatId);
 			const users = await chats.participants(orgId, chatId);
@@ -177,9 +210,10 @@ var ChatServiceImpl = class {
 		});
 		return saved;
 	}
-	async leave(orgId, actor, chatId) {
+	async leave(chatId, actor) {
+		const orgId = actor.orgId;
 		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActor(actor, chat.communityId);
 		await this.requireActive(this.repo, orgId, chat.id, actor.id);
 		const saved = await this.uow.run(async ({ chats, outbox }) => {
 			const current = await this.mustChat(chats, orgId, chatId);
@@ -201,9 +235,10 @@ var ChatServiceImpl = class {
 		});
 		return saved;
 	}
-	async accept(orgId, actor, chatId) {
+	async accept(chatId, actor) {
+		const orgId = actor.orgId;
 		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActor(actor, chat.communityId);
 		await this.requireActive(this.repo, orgId, chat.id, actor.id);
 		if (chat.createdBy === actor.id) throw new ForbiddenError("You cannot accept this request");
 		if (chat.kind !== "direct" || chat.status !== "pending") throw new ConflictError("This chat is not a request");
@@ -222,60 +257,119 @@ var ChatServiceImpl = class {
 		});
 		return saved;
 	}
-	async send(orgId, actor, chatId, input) {
+	async send(chatId, input, actor) {
+		const orgId = actor.orgId;
 		const preview = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, preview.communityId);
+		await this.requireActor(actor, preview.communityId);
 		const settings = await this.requireSettings(orgId, preview.communityId);
 		if (!settings.enabled) throw new ForbiddenError("Direct messages are off");
-		const saved = await this.uow.run(async ({ chats, outbox }) => {
-			const chat = await this.mustChat(chats, orgId, chatId);
-			const users = await chats.participants(orgId, chatId);
-			await this.assertMaySend(chats, orgId, actor, chat, users, settings, input);
-			const written = await this.writeMessage(chats, orgId, actor, chat, input);
-			const events = [];
-			if (written.opened) events.push(this.updatedEvent(orgId, actor, written.chat, users));
-			events.push(this.sentEvent(orgId, actor, written.chat, written.message));
-			await outbox.append(events);
-			return written.message;
+		const clientId = input.clientId;
+		const before = await this.repo.participants(orgId, chatId);
+		const teams = await this.teamsOf(orgId, preview.communityId, before.map((user) => user.orgUserId).filter((orgUserId) => orgUserId !== actor.id));
+		await this.requireOwnedImages(orgId, actor.id, input.assetIds);
+		let saved;
+		try {
+			saved = await this.uow.run(async ({ chats, mentions, outbox }) => {
+				const chat = await this.mustChat(chats, orgId, chatId);
+				if (clientId) {
+					const stored = await chats.findByClientId(orgId, chatId, actor.id, clientId);
+					if (stored) return {
+						message: stored,
+						repeat: true
+					};
+				}
+				const users = await chats.participants(orgId, chatId);
+				await this.assertMaySend(chats, orgId, actor, chat, users, settings, input, teams);
+				const written = await this.writeMessage(chats, mentions, orgId, actor, chat, users, input);
+				const events = [];
+				if (written.opened) events.push(this.updatedEvent(orgId, actor, written.chat, users));
+				events.push(this.sentEvent(orgId, actor, written.chat, written.message, written.mentioned));
+				await outbox.append(events);
+				return {
+					message: written.message,
+					repeat: false
+				};
+			});
+		} catch (error) {
+			const stored = clientId && error instanceof ConflictError ? await this.repo.findByClientId(orgId, chatId, actor.id, clientId) : null;
+			if (!stored) throw error;
+			saved = {
+				message: stored,
+				repeat: true
+			};
+		}
+		if (saved.repeat) this.logger.debug("message send repeated", {
+			orgId,
+			chatId,
+			messageId: saved.message.id
 		});
-		this.logger.info("message sent", {
+		else this.logger.info("message sent", {
 			orgId,
 			chatId,
-			messageId: saved.id,
+			messageId: saved.message.id,
 			actorId: actor.id
 		});
-		return this.viewOf(orgId, actor, saved);
+		return this.viewOf(actor, saved.message);
 	}
-	async editMessage(orgId, actor, messageId, body) {
+	async editMessage(messageId, body, actor) {
+		const orgId = actor.orgId;
 		const message = await this.mustMessage(this.repo, orgId, messageId);
-		await this.requireWritableChat(orgId, actor, message.chatId);
+		await this.requireWritableChat(actor, message.chatId);
 		if (message.orgUserId !== actor.id) throw new ForbiddenError("You can change only your own message");
 		if (message.deletedAt) throw new ConflictError("This message was deleted");
-		if (message.body === body) return this.viewOf(orgId, actor, message);
-		const saved = await this.repo.updateMessage(orgId, messageId, {
-			body,
-			editedAt: /* @__PURE__ */ new Date()
+		if (message.body === body) return this.viewOf(actor, message);
+		const now = /* @__PURE__ */ new Date();
+		const saved = await this.uow.run(async ({ chats, mentions, outbox }) => {
+			const next = await chats.updateMessage(orgId, messageId, {
+				body,
+				editedAt: now
+			});
+			if (!next) throw new NotFoundError("Message", messageId);
+			const chat = await this.mustChat(chats, orgId, next.chatId);
+			const users = await chats.participants(orgId, next.chatId);
+			const candidates = this.mentionable(body, users);
+			const added = await mentions.sync(orgId, "message", messageId, candidates, now);
+			await outbox.append([discussionEvents.messageUpdated.make({
+				orgId,
+				data: {
+					...eventMessage(next),
+					mentionedOrgUserIds: keepAllowed(candidates, added)
+				},
+				metadata: {
+					...this.meta(actor),
+					chatStatus: chat.status
+				}
+			})]);
+			return next;
 		});
-		if (!saved) throw new NotFoundError("Message", messageId);
 		this.logger.info("message edited", {
 			orgId,
 			messageId,
 			actorId: actor.id
 		});
-		return this.viewOf(orgId, actor, saved);
+		return this.viewOf(actor, saved);
 	}
-	async deleteMessage(orgId, actor, messageId) {
+	async deleteMessage(messageId, actor) {
+		const orgId = actor.orgId;
 		const message = await this.mustMessage(this.repo, orgId, messageId);
-		await this.requireActor(orgId, actor, message.communityId);
-		if (!isStaffRole(actor.role)) {
-			if (message.orgUserId !== actor.id) throw new ForbiddenError("You cannot delete this message");
-			await this.requireWritableChat(orgId, actor, message.chatId);
+		await this.requireActor(actor, message.communityId);
+		if (!actor.permissions.has("communities:moderate", message.communityId)) {
+			if (message.orgUserId !== actor.id) {
+				this.logger.warn("message delete refused — not the sender or a moderator", {
+					orgId,
+					messageId,
+					actorId: actor.id
+				});
+				throw new ForbiddenError("You cannot delete this message");
+			}
+			await this.requireWritableChat(actor, message.chatId);
 		}
 		if (message.deletedAt) throw new ConflictError("This message was deleted");
 		const now = /* @__PURE__ */ new Date();
-		const saved = await this.uow.run(async ({ chats, outbox }) => {
+		const saved = await this.uow.run(async ({ chats, mentions, outbox }) => {
 			const next = await chats.updateMessage(orgId, messageId, { deletedAt: now });
 			if (!next) throw new NotFoundError("Message", messageId);
+			await mentions.removeItem(orgId, "message", messageId);
 			await chats.resolveFlags(orgId, messageId, {
 				resolvedAt: now,
 				resolvedBy: actor.id,
@@ -283,7 +377,7 @@ var ChatServiceImpl = class {
 			});
 			await outbox.append([discussionEvents.messageDeleted.make({
 				orgId,
-				data: next,
+				data: eventMessage(next),
 				metadata: this.meta(actor)
 			})]);
 			return next;
@@ -293,55 +387,78 @@ var ChatServiceImpl = class {
 			messageId,
 			actorId: actor.id
 		});
-		return this.viewOf(orgId, actor, saved);
+		return this.viewOf(actor, saved);
 	}
-	async setReaction(orgId, actor, messageId, emoji) {
+	async setReaction(messageId, emoji, actor) {
+		const orgId = actor.orgId;
 		const message = await this.mustMessage(this.repo, orgId, messageId);
-		await this.requireActor(orgId, actor, message.communityId);
+		await this.requireActor(actor, message.communityId);
 		await this.requireActive(this.repo, orgId, message.chatId, actor.id);
-		await this.repo.setReaction(orgId, message.communityId, messageId, actor.id, emoji);
+		await this.uow.run(async ({ chats, outbox }) => {
+			const change = await chats.setReaction(orgId, message.communityId, messageId, actor.id, emoji);
+			if (!change.changed) return;
+			const where = {
+				messageId,
+				chatId: message.chatId,
+				communityId: message.communityId,
+				orgUserId: actor.id
+			};
+			const events = [];
+			if (change.inserted && emoji !== null) events.push(discussionEvents.messageReactionAdded.make({
+				orgId,
+				data: {
+					...where,
+					reaction: emoji
+				},
+				metadata: this.meta(actor)
+			}));
+			events.push(discussionEvents.messageReactionsChanged.make({
+				orgId,
+				data: {
+					...where,
+					reaction: emoji
+				},
+				metadata: this.meta(actor)
+			}));
+			await outbox.append(events);
+		});
 		this.logger.debug("message reaction set", {
 			orgId,
 			messageId
 		});
 		return (await this.repo.reactionsOf(orgId, [messageId], actor.id))[messageId] ?? { reactions: {} };
 	}
-	async markRead(orgId, actor, chatId, messageId) {
+	async markRead(chatId, messageId, actor) {
+		const orgId = actor.orgId;
 		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActor(actor, chat.communityId);
 		await this.requireActive(this.repo, orgId, chat.id, actor.id);
 		if ((await this.mustMessage(this.repo, orgId, messageId)).chatId !== chatId) throw new NotFoundError("Message", messageId);
-		await this.repo.setRead(orgId, chatId, actor.id, messageId);
-		this.logger.debug("chat marked read", {
+		const moved = await this.uow.run(async ({ chats, outbox }) => {
+			if (!await chats.setRead(orgId, chatId, actor.id, messageId)) return false;
+			await outbox.append([discussionEvents.chatRead.make({
+				orgId,
+				data: {
+					chatId,
+					communityId: chat.communityId,
+					orgUserId: actor.id,
+					lastReadMessageId: messageId
+				},
+				metadata: this.meta(actor)
+			})]);
+			return true;
+		});
+		this.logger.debug(moved ? "chat marked read" : "chat read mark kept", {
 			orgId,
 			chatId,
 			messageId
 		});
 	}
-	async mute(orgId, actor, chatId, until) {
-		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
-		await this.requireActive(this.repo, orgId, chat.id, actor.id);
-		await this.repo.setMuted(orgId, chatId, actor.id, true, until ?? null);
-		this.logger.debug("chat muted", {
-			orgId,
-			chatId
-		});
-	}
-	async unmute(orgId, actor, chatId) {
-		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
-		await this.requireActive(this.repo, orgId, chat.id, actor.id);
-		await this.repo.setMuted(orgId, chatId, actor.id, false, null);
-		this.logger.debug("chat unmuted", {
-			orgId,
-			chatId
-		});
-	}
-	async block(orgId, actor, communityId, orgUserId) {
+	async block(communityId, orgUserId, actor) {
+		const orgId = actor.orgId;
 		if (actor.id === orgUserId) throw new InvalidInputError("You cannot block yourself");
 		await this.requireSettings(orgId, communityId);
-		await this.requireActor(orgId, actor, communityId);
+		await this.requireActor(actor, communityId);
 		await this.requirePerson(orgId, communityId, orgUserId);
 		await this.uow.run(async ({ chats }) => {
 			await chats.lockDirectPair(orgId, communityId, actor.id, orgUserId);
@@ -353,10 +470,11 @@ var ChatServiceImpl = class {
 			actorId: actor.id
 		});
 	}
-	async unblock(orgId, actor, communityId, orgUserId) {
+	async unblock(communityId, orgUserId, actor) {
+		const orgId = actor.orgId;
 		if (actor.id === orgUserId) throw new InvalidInputError("You cannot block yourself");
 		await this.requireSettings(orgId, communityId);
-		await this.requireActor(orgId, actor, communityId);
+		await this.requireActor(actor, communityId);
 		await this.uow.run(async ({ chats }) => {
 			await chats.lockDirectPair(orgId, communityId, actor.id, orgUserId);
 			await chats.unblock(orgId, communityId, actor.id, orgUserId);
@@ -367,9 +485,10 @@ var ChatServiceImpl = class {
 			actorId: actor.id
 		});
 	}
-	async flagMessage(orgId, actor, messageId, reason) {
+	async flagMessage(messageId, reason, actor) {
+		const orgId = actor.orgId;
 		const message = await this.mustMessage(this.repo, orgId, messageId);
-		await this.requireActor(orgId, actor, message.communityId);
+		await this.requireActor(actor, message.communityId);
 		await this.requireActive(this.repo, orgId, message.chatId, actor.id);
 		const now = /* @__PURE__ */ new Date();
 		const saved = await this.uow.run(async ({ chats, outbox }) => {
@@ -405,11 +524,12 @@ var ChatServiceImpl = class {
 		});
 		return saved;
 	}
-	async resolveMessageFlags(orgId, actor, messageId, resolution, communityId) {
-		if (!isStaffRole(actor.role)) throw new ForbiddenError("You cannot work this queue");
+	async resolveMessageFlags(messageId, resolution, communityId, actor) {
+		const orgId = actor.orgId;
 		const message = await this.mustMessage(this.repo, orgId, messageId);
-		if (communityId !== void 0 && message.communityId !== communityId) throw new NotFoundError("Message", messageId);
-		await this.requireActor(orgId, actor, message.communityId);
+		if (communityId !== null && message.communityId !== communityId) throw new NotFoundError("Message", messageId);
+		this.requireModerator(actor, message.communityId, "resolve message flags");
+		await this.requireActor(actor, message.communityId);
 		await this.repo.resolveFlags(orgId, messageId, {
 			resolvedAt: /* @__PURE__ */ new Date(),
 			resolvedBy: actor.id,
@@ -423,28 +543,18 @@ var ChatServiceImpl = class {
 			actorId: actor.id
 		});
 	}
-	async lock(orgId, actor, chatId, communityId) {
-		return this.setLock(orgId, actor, chatId, true, communityId);
+	async lock(chatId, communityId, actor) {
+		return this.setLock(actor, chatId, true, communityId);
 	}
-	async unlock(orgId, actor, chatId, communityId) {
-		return this.setLock(orgId, actor, chatId, false, communityId);
+	async unlock(chatId, communityId, actor) {
+		return this.setLock(actor, chatId, false, communityId);
 	}
-	async listChats(orgId, actor, communityId, query) {
+	async listChats(communityId, query, actor) {
+		const orgId = actor.orgId;
 		await this.requireSettings(orgId, communityId);
-		await this.requireActor(orgId, actor, communityId);
-		const now = /* @__PURE__ */ new Date();
+		await this.requireActor(actor, communityId);
 		const page = await this.repo.listForUser(orgId, communityId, actor.id, query);
-		const items = page.rows.map((item) => ({
-			...item,
-			...item.muted && item.mutedUntil !== null && item.mutedUntil <= now ? {
-				muted: false,
-				mutedUntil: null
-			} : {},
-			lastMessage: item.lastMessage && item.lastMessage.deletedAt !== null && !isStaffRole(actor.role) ? {
-				...item.lastMessage,
-				body: ""
-			} : item.lastMessage
-		}));
+		const items = await this.listItems(actor, communityId, page.rows);
 		this.logger.debug("chats listed", {
 			orgId,
 			communityId,
@@ -455,9 +565,100 @@ var ChatServiceImpl = class {
 			rows: items
 		};
 	}
-	async messages(orgId, actor, chatId, query) {
+	async chat(chatId, actor) {
+		const orgId = actor.orgId;
 		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActor(actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		const row = await this.repo.inboxRow(orgId, chatId, actor.id);
+		if (!row) throw new NotFoundError("Chat", chatId);
+		const [item] = await this.listItems(actor, chat.communityId, [row]);
+		this.logger.debug("chat read", {
+			orgId,
+			chatId
+		});
+		return item;
+	}
+	async directChat(communityId, orgUserId, actor) {
+		const orgId = actor.orgId;
+		await this.requireSettings(orgId, communityId);
+		await this.requireActor(actor, communityId);
+		const chat = orgUserId === actor.id ? null : await this.repo.findDirect(orgId, communityId, actor.id, orgUserId);
+		const row = chat ? await this.repo.inboxRow(orgId, chat.id, actor.id) : null;
+		if (!row) throw new NotFoundError("Chat", orgUserId);
+		const [item] = await this.listItems(actor, communityId, [row]);
+		this.logger.debug("direct chat read", {
+			orgId,
+			communityId,
+			chatId: row.chat.id
+		});
+		return item;
+	}
+	async unreadSummary(communityId, actor) {
+		const orgId = actor.orgId;
+		await this.requireSettings(orgId, communityId);
+		await this.requireActor(actor, communityId);
+		return this.repo.unreadSummary(orgId, communityId, actor.id, /* @__PURE__ */ new Date());
+	}
+	async typing(chatId, actor) {
+		const orgId = actor.orgId;
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		if (chat.lockedAt || chat.status === "closed") throw new ForbiddenError("You cannot send in this chat");
+		if (!this.pubsub) return;
+		const now = Date.now();
+		const key = `${orgId}:${chatId}:${actor.id}`;
+		const last = this.typed.get(key);
+		if (last !== void 0 && now - last < TYPING_REPEAT_MS) return;
+		this.typed.set(key, now);
+		for (const [seen, at] of this.typed) if (now - at >= TYPING_REPEAT_MS) this.typed.delete(seen);
+		await publishChange(this.pubsub, {
+			event: TYPING,
+			orgId,
+			communityId: chat.communityId,
+			chatId,
+			orgUserId: actor.id,
+			until: new Date(now + TYPING_FOR_MS).toISOString()
+		}, this.logger);
+	}
+	async watch(communityId, actor) {
+		if (!this.hub) throw new UnavailableError("Live chat is not available");
+		await this.requireSettings(actor.orgId, communityId);
+		await this.requireActor(actor, communityId);
+		return this.hub.open({
+			communityId,
+			actor
+		});
+	}
+	async messageViews(orgId, messageIds) {
+		const messages = await this.repo.messagesByIds(orgId, [...new Set(messageIds)]);
+		return (await this.withSenders(orgId, null, messages)).map(({ viewerReaction: _viewerReaction, ...view }) => view);
+	}
+	activeParticipants(orgId, chatId) {
+		return this.repo.activeParticipants(orgId, chatId);
+	}
+	async messageReactions(orgId, messageId) {
+		return (await this.repo.reactionsOf(orgId, [messageId], ""))[messageId]?.reactions ?? {};
+	}
+	async liveChat(orgId, chatId) {
+		const chat = await this.repo.findChat(orgId, chatId);
+		if (!chat) return null;
+		const participantIds = await this.repo.activeParticipants(orgId, chatId);
+		const profiles = await this.participantsOf(orgId, chat.communityId, participantIds);
+		return {
+			chat,
+			participantIds,
+			participants: participantIds.flatMap((id) => profiles.get(id) ?? [])
+		};
+	}
+	memberStates(orgId, communityId, orgUserIds) {
+		return this.repo.memberStates(orgId, communityId, orgUserIds, /* @__PURE__ */ new Date());
+	}
+	async messages(chatId, query, actor) {
+		const orgId = actor.orgId;
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(actor, chat.communityId);
 		await this.requireActive(this.repo, orgId, chat.id, actor.id);
 		const page = await this.repo.listMessages(orgId, chatId, query);
 		this.logger.debug("chat messages read", {
@@ -469,18 +670,23 @@ var ChatServiceImpl = class {
 			rows: await this.withSenders(orgId, actor, page.rows)
 		};
 	}
-	async attachmentFile(orgId, actor, chatId, messageId, assetId) {
+	async attachmentFile(chatId, messageId, assetId, actor) {
+		const orgId = actor.orgId;
 		const chat = await this.repo.findChat(orgId, chatId);
 		const message = await this.repo.findMessage(orgId, messageId);
-		if (!chat || !message || message.chatId !== chatId) return null;
-		if (!((await this.repo.attachmentsOf(orgId, [messageId]))[messageId] ?? []).includes(assetId)) return null;
-		if (!await this.access.isCommunityMember(orgId, actor, chat.communityId)) return null;
-		if (!((await this.repo.participants(orgId, chatId)).some((user) => user.orgUserId === actor.id && user.leftAt === null) ? message.deletedAt === null || isStaffRole(actor.role) : isStaffRole(actor.role) && (await this.repo.listOpenFlags(orgId, chat.communityId)).some((flag) => flag.messageId === messageId))) return null;
-		return this.images.signFile(orgId, assetId);
-	}
-	async messageQueue(orgId, actor, communityId) {
-		if (!isStaffRole(actor.role)) throw new ForbiddenError("You cannot work this queue");
-		await this.requireActor(orgId, actor, communityId);
+		if (!chat || !message || message.chatId !== chatId) throw new NotFoundError("Message attachment", assetId);
+		if (!((await this.repo.attachmentsOf(orgId, [messageId]))[messageId] ?? []).includes(assetId)) throw new NotFoundError("Message attachment", assetId);
+		if (!await this.access.isCommunityMember(chat.communityId, actor)) throw new NotFoundError("Message attachment", assetId);
+		const moderates = actor.permissions.has("communities:moderate", chat.communityId);
+		if (!((await this.repo.participants(orgId, chatId)).some((user) => user.orgUserId === actor.id && user.leftAt === null) ? message.deletedAt === null || moderates : moderates && (await this.repo.listOpenFlags(orgId, chat.communityId)).some((flag) => flag.messageId === messageId))) throw new NotFoundError("Message attachment", assetId);
+		const url = await this.images.signFile(orgId, assetId);
+		if (!url) throw new NotFoundError("Message attachment", assetId);
+		return url;
+	}
+	async messageQueue(communityId, actor) {
+		const orgId = actor.orgId;
+		this.requireModerator(actor, communityId, "message queue");
+		await this.requireActor(actor, communityId);
 		await this.requireSettings(orgId, communityId);
 		const flags = await this.repo.listOpenFlags(orgId, communityId, 100);
 		const messages = await this.repo.messagesByIds(orgId, [...new Set(flags.map((flag) => flag.messageId))]);
@@ -511,14 +717,15 @@ var ChatServiceImpl = class {
 			participants: await this.repo.participants(orgId, chatId)
 		};
 	}
-	async titlesFor(orgId, actor, chatIds) {
+	async titlesFor(chatIds, actor) {
+		const orgId = actor.orgId;
 		if (chatIds.length === 0) return {};
 		const summaries = (await this.repo.chatSummaries(orgId, [...new Set(chatIds)])).filter((summary) => summary.participantIds.includes(actor.id));
 		const others = [...new Set(summaries.flatMap((summary) => summary.participantIds.filter((id) => id !== actor.id)))];
 		const records = others.length > 0 ? await this.profiles.authorsOf(orgId, others) : {};
 		const nameOf = (id) => {
 			const record = records[id];
-			return record && authorView(orgId, record, null).displayName || "A member";
+			return record && authorName(record) || "A member";
 		};
 		return Object.fromEntries(summaries.flatMap((summary) => {
 			const names = summary.participantIds.filter((id) => id !== actor.id).map(nameOf);
@@ -526,6 +733,12 @@ var ChatServiceImpl = class {
 			return summary.chat.kind === "group" ? [[summary.chat.id, "Group chat"]] : [];
 		}));
 	}
+	unreadInChat(orgId, chatId, orgUserId) {
+		return this.repo.unreadFor(orgId, chatId, orgUserId);
+	}
+	findMessage(orgId, messageId) {
+		return this.repo.findMessage(orgId, messageId);
+	}
 	async latestMessageBody(orgId, chatId) {
 		return (await this.repo.listMessages(orgId, chatId, {
 			page: 1,
@@ -535,11 +748,12 @@ var ChatServiceImpl = class {
 	isBlocked(orgId, communityId, a, b) {
 		return this.repo.isBlocked(orgId, communityId, a, b);
 	}
-	async setLock(orgId, actor, chatId, locked, communityId) {
-		if (!isStaffRole(actor.role)) throw new ForbiddenError("You cannot lock this chat");
+	async setLock(actor, chatId, locked, communityId) {
+		const orgId = actor.orgId;
 		const chat = await this.mustChat(this.repo, orgId, chatId);
-		if (communityId !== void 0 && chat.communityId !== communityId) throw new NotFoundError("Chat", chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
+		if (communityId !== null && chat.communityId !== communityId) throw new NotFoundError("Chat", chatId);
+		this.requireModerator(actor, chat.communityId, locked ? "lock chat" : "unlock chat");
+		await this.requireActor(actor, chat.communityId);
 		if (Boolean(chat.lockedAt) === locked) return chat;
 		const now = /* @__PURE__ */ new Date();
 		const saved = await this.uow.run(async ({ chats, outbox }) => {
@@ -563,44 +777,62 @@ var ChatServiceImpl = class {
 		});
 		return saved;
 	}
+	requireModerator(actor, communityId, action) {
+		if (!actor.permissions.has("communities:moderate", communityId)) {
+			this.logger.warn("chat moderation refused — not a moderator", {
+				orgId: actor.orgId,
+				communityId,
+				action,
+				actorId: actor.id
+			});
+			throw new ForbiddenError("You need communities:moderate");
+		}
+	}
 	async requireSettings(orgId, communityId) {
-		const settings = await this.content.getDmSettings(orgId, communityId);
+		const settings = await this.content.getDmSettings(communityId, this.authors.systemActor(orgId));
 		if (!settings) throw new NotFoundError("Community", communityId);
 		return settings;
 	}
-	async requireActor(orgId, actor, communityId) {
-		if (!await this.access.isCommunityMember(orgId, actor, communityId)) throw new ForbiddenError("You are not a member of this community");
+	async requireActor(actor, communityId) {
+		if (!await this.access.isCommunityMember(communityId, actor)) throw new ForbiddenError("You are not a member of this community");
 	}
+	/** Whether the person is team in the community; throws when they are not a
+	*  member of it. */
 	async requirePerson(orgId, communityId, orgUserId) {
-		const role = await this.personRole(orgId, communityId, orgUserId);
-		if (!role) throw new ForbiddenError("That person is not a member of this community");
-		return role;
-	}
-	async personRole(orgId, communityId, orgUserId) {
-		const role = await this.authors.roleOf(orgId, orgUserId);
-		if (!role) return null;
-		return await this.access.isCommunityMember(orgId, {
-			id: orgUserId,
-			role
-		}, communityId) ? role : null;
-	}
-	async personRoles(orgId, communityId, orgUserIds) {
-		const roles = await this.authors.rolesOf(orgId, orgUserIds);
-		const members = new Set(await this.access.communityMembersAmong(orgId, communityId, Object.keys(roles)));
-		return Object.fromEntries(Object.entries(roles).filter(([orgUserId]) => members.has(orgUserId)));
-	}
-	async assertMaySend(chats, orgId, actor, chat, users, settings, input) {
+		const team = (await this.membersTeam(orgId, communityId, [orgUserId])).get(orgUserId);
+		if (team === void 0) throw new ForbiddenError("That person is not a member of this community");
+		return team;
+	}
+	/** Each member of the community among the given people, with whether they
+	*  are team there. People who are not members are left out. */
+	async membersTeam(orgId, communityId, orgUserIds) {
+		const members = await this.access.communityMembersAmong(orgId, communityId, orgUserIds);
+		if (members.length === 0) return /* @__PURE__ */ new Map();
+		const permissions = await this.authors.permissionsOfMany(orgId, members);
+		return new Map(members.map((orgUserId) => {
+			const held = permissions.get(orgUserId);
+			return [orgUserId, held !== void 0 && isTeam(held, communityId)];
+		}));
+	}
+	async teamsOf(orgId, communityId, orgUserIds) {
+		return {
+			asked: new Set(orgUserIds),
+			team: await this.membersTeam(orgId, communityId, orgUserIds)
+		};
+	}
+	async assertMaySend(chats, orgId, actor, chat, users, settings, input, teams) {
 		this.assertActive(users, actor.id);
 		if (chat.lockedAt) throw new ForbiddenError("This chat is locked");
 		if (chat.status === "closed") throw new ForbiddenError("You cannot send in this chat");
 		if (this.pendingCreator(chat, actor)) throw new ForbiddenError("You cannot send in this chat");
 		const others = users.filter((other) => other.orgUserId !== actor.id && (chat.kind === "direct" || other.leftAt === null)).map((other) => other.orgUserId);
+		if (others.some((other) => !teams.asked.has(other))) throw new ConflictError("This chat changed while you were sending; send again");
 		if (others.length > 0) {
-			const roles = await this.personRoles(orgId, chat.communityId, others);
-			const recipients = chat.kind === "group" ? others.filter((other) => roles[other]) : others;
+			const recipients = chat.kind === "group" ? others.filter((other) => teams.team.has(other)) : others;
+			const actorTeam = isTeam(actor.permissions, chat.communityId);
 			for (const other of recipients) {
-				const role = roles[other];
-				if (!role || !this.mayMessage(settings, actor, role)) throw new ForbiddenError("You cannot send in this chat");
+				const team = teams.team.get(other);
+				if (team === void 0 || !this.mayMessage(settings, actorTeam, team)) throw new ForbiddenError("You cannot send in this chat");
 			}
 			if (recipients.length > 0) {
 				if ((await chats.blockedWith(orgId, chat.communityId, actor.id, recipients)).length > 0) throw new ForbiddenError("You cannot send in this chat");
@@ -610,30 +842,35 @@ var ChatServiceImpl = class {
 			const reply = await chats.findMessage(orgId, input.replyToId);
 			if (!reply || reply.chatId !== chat.id) throw new NotFoundError("Message", input.replyToId);
 		}
-		await this.requireOwnedImages(orgId, actor.id, input.assetIds);
 	}
-	async writeMessage(chats, orgId, actor, chat, input) {
+	mentionable(body, users) {
+		return keepAllowed(mentionTokens(body), users.filter((user) => user.leftAt === null).map((user) => user.orgUserId));
+	}
+	async writeMessage(chats, mentions, orgId, actor, chat, users, input) {
 		const opened = chat.kind === "direct" && chat.status === "pending" && chat.createdBy !== actor.id;
 		const current = opened ? await this.mustUpdate(chats, orgId, chat.id, { status: "open" }) : chat;
 		const message = await chats.insertMessage(orgId, this.newMessage(orgId, current, actor, input, /* @__PURE__ */ new Date()));
 		if (input.assetIds.length > 0) await chats.attach(orgId, current.communityId, message.id, input.assetIds);
+		const mentioned = this.mentionable(input.body, users);
+		await mentions.sync(orgId, "message", message.id, mentioned, message.createdAt);
 		return {
 			chat: current,
 			message,
-			opened
+			opened,
+			mentioned
 		};
 	}
-	assertMayMessage(settings, actor, role) {
+	assertMayMessage(settings, actorTeam, targetTeam) {
 		if (!settings.enabled) throw new ForbiddenError("Direct messages are off");
-		if (!this.mayMessage(settings, actor, role)) throw new ForbiddenError("You cannot message this person");
+		if (!this.mayMessage(settings, actorTeam, targetTeam)) throw new ForbiddenError("You cannot message this person");
 	}
 	assertGroup(settings) {
 		if (!settings.enabled) throw new ForbiddenError("Direct messages are off");
 		if (!settings.groupChats) throw new ForbiddenError("Group chats are off");
 	}
-	mayMessage(settings, actor, target) {
-		if (isStaffRole(actor.role)) return settings.staffToAnyone;
-		if (isStaffRole(target)) return settings.memberToStaff;
+	mayMessage(settings, actorTeam, targetTeam) {
+		if (actorTeam) return settings.teamToAnyone;
+		if (targetTeam) return settings.memberToTeam;
 		return settings.memberToMember;
 	}
 	async requireActive(repo, orgId, chatId, orgUserId) {
@@ -653,10 +890,10 @@ var ChatServiceImpl = class {
 			throw new NotFoundError("Asset", assetId);
 		}
 	}
-	async requireWritableChat(orgId, actor, chatId) {
-		const chat = await this.mustChat(this.repo, orgId, chatId);
-		await this.requireActor(orgId, actor, chat.communityId);
-		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+	async requireWritableChat(actor, chatId) {
+		const chat = await this.mustChat(this.repo, actor.orgId, chatId);
+		await this.requireActor(actor, chat.communityId);
+		await this.requireActive(this.repo, actor.orgId, chat.id, actor.id);
 		if (chat.lockedAt || chat.status === "closed") throw new ForbiddenError("You cannot send in this chat");
 	}
 	pendingCreator(chat, actor) {
@@ -686,8 +923,6 @@ var ChatServiceImpl = class {
 			joinedAt: now,
 			leftAt: null,
 			lastReadMessageId: null,
-			muted: false,
-			mutedUntil: null,
 			createdAt: now,
 			updatedAt: now
 		};
@@ -701,6 +936,7 @@ var ChatServiceImpl = class {
 			orgUserId: actor.id,
 			body: input.body,
 			replyToId: input.replyToId,
+			clientId: input.clientId ?? null,
 			editedAt: null,
 			deletedAt: null,
 			createdAt: now,
@@ -717,7 +953,7 @@ var ChatServiceImpl = class {
 		};
 	}
 	meta(actor) {
-		return { actorOrgUserId: actor.id };
+		return { actorId: actor.id };
 	}
 	createdEvent(orgId, actor, chat, users) {
 		return discussionEvents.chatCreated.make({
@@ -745,51 +981,80 @@ var ChatServiceImpl = class {
 			metadata: this.meta(actor)
 		});
 	}
-	sentEvent(orgId, actor, chat, message) {
+	sentEvent(orgId, actor, chat, message, mentionedOrgUserIds) {
 		return discussionEvents.messageSent.make({
 			orgId,
-			data: message,
+			data: {
+				...eventMessage(message),
+				mentionedOrgUserIds
+			},
 			metadata: {
 				...this.meta(actor),
 				chatStatus: chat.status
 			}
 		});
 	}
-	async viewOf(orgId, actor, message) {
-		const [view] = await this.withSenders(orgId, actor, [message]);
+	async viewOf(actor, message) {
+		const [view] = await this.withSenders(actor.orgId, actor, [message]);
 		return view;
 	}
-	async withSenders(orgId, actor, messages) {
+	async withSenders(orgId, viewer, messages) {
 		if (messages.length === 0) return [];
 		const messageIds = messages.map((message) => message.id);
-		const [records, attached, reactions] = await Promise.all([
-			this.profiles.authorsOf(orgId, [...new Set(messages.map((message) => message.orgUserId))]),
+		const senderIds = [...new Set(messages.map((message) => message.orgUserId))];
+		const [records, permissions, attached, reactions, mentioned] = await Promise.all([
+			this.profiles.authorsOf(orgId, senderIds),
+			this.authors.permissionsOfMany(orgId, senderIds),
 			this.repo.attachmentsOf(orgId, messageIds),
-			this.repo.reactionsOf(orgId, messageIds, actor.id)
+			this.repo.reactionsOf(orgId, messageIds, viewer?.id ?? ""),
+			mentionViews(this.mentions, this.profiles, orgId, "message", messageIds)
 		]);
-		const shown = (message) => message.deletedAt !== null && !isStaffRole(actor.role) ? [] : attached[message.id] ?? [];
+		const hidden = (message) => message.deletedAt !== null && !viewer?.permissions.has("communities:moderate", message.communityId);
+		const shown = (message) => hidden(message) ? [] : attached[message.id] ?? [];
 		return messages.map((message) => {
 			const record = records[message.orgUserId];
 			if (!record) throw new NotFoundError("Member", message.orgUserId);
 			const counts = reactions[message.id];
 			return {
-				...this.present(message, actor),
-				sender: authorView(orgId, record, this.fileUrls),
+				...hidden(message) ? {
+					...message,
+					body: ""
+				} : message,
+				sender: authorView(orgId, record, this.fileUrls, teamBadge(permissions.get(message.orgUserId), message.communityId)),
 				attachments: shown(message).map((assetId) => ({
 					assetId,
 					url: this.fileUrls.messageAttachment(message.chatId, message.id, assetId)
 				})),
 				reactions: counts?.reactions ?? {},
-				viewerReaction: counts?.viewerReaction ?? null
+				viewerReaction: counts?.viewerReaction ?? null,
+				mentions: hidden(message) ? [] : mentioned[message.id] ?? []
 			};
 		});
 	}
-	present(message, actor) {
-		if (message.deletedAt !== null && !isStaffRole(actor.role)) return {
-			...message,
-			body: ""
-		};
-		return message;
+	async listItems(actor, communityId, rows) {
+		const orgId = actor.orgId;
+		const seesDeleted = actor.permissions.has("communities:moderate", communityId);
+		const now = /* @__PURE__ */ new Date();
+		const [subscribed, profiles] = await Promise.all([this.subscriptions.forViewer(orgId, actor.id, "chat", rows.map((item) => item.chat.id)), this.participantsOf(orgId, communityId, rows.flatMap((item) => item.participantIds))]);
+		const subscriptionOf = new Map(subscribed.map((row) => [row.itemId, row]));
+		return rows.map((item) => ({
+			...item,
+			participants: item.participantIds.flatMap((id) => profiles.get(id) ?? []),
+			subscription: activeSubscription(subscriptionOf.get(item.chat.id), now),
+			lastMessage: item.lastMessage && item.lastMessage.deletedAt !== null && !seesDeleted ? {
+				...item.lastMessage,
+				body: ""
+			} : item.lastMessage
+		}));
+	}
+	async participantsOf(orgId, communityId, orgUserIds) {
+		const ids = [...new Set(orgUserIds)];
+		if (ids.length === 0) return /* @__PURE__ */ new Map();
+		const [records, permissions] = await Promise.all([this.profiles.authorsOf(orgId, ids), this.authors.permissionsOfMany(orgId, ids)]);
+		return new Map(ids.flatMap((id) => {
+			const record = records[id];
+			return record ? [[id, authorView(orgId, record, this.fileUrls, teamBadge(permissions.get(id), communityId))]] : [];
+		}));
 	}
 };
 //#endregion