@teamscala/service-boot 0.23.481 → 0.23.493

package/src/fn-routers/assessment-scoring.ts

@@ -1,105 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Public assessment (quiz) scoring: the stored-question shape, the scale/choice
- * earned-vs-max rules, per-category + total scores, and the stable stage-band
- * slug derivation.
- *
- * Scoring (recovered from live data, 2026-06-13): each scale answer contributes
- * (scaleValue - 1) earned out of 4 max (1–5 scale → 0–4); choice answers
- * contribute the selected option's points out of the question's max option
- * points. A category's score is round(100 * earned / max) over that category's
- * questions; the overall total is the same over all questions. Unanswered
- * questions count toward the denominator (contribute 0) — matches the historical
- * rows (e.g. Σ(v-1)=78 over 36 questions → 78/144 = 54).
- *
- * Split out of fn-routers/public-assessment-router.ts (591 lines) —
- * byte-for-byte move; import paths adjusted only.
- */
-
-export interface StoredQuestion {
-	id: string;
-	category?: string | null;
-	type?: string | null;
-	weight?: number | null;
-	options?: Array<{ value: string; points: number }> | null;
-}
-
-/** Scale answers are 1–5; earned = value-1, max = 4. */
-const SCALE_MAX = 4;
-
-/**
- * A stage band names itself; the event tag needs a stable slug. Derived from
- * the authored name rather than stored beside it, so the two cannot drift.
- */
-export function toBandSlug(name: string): string {
-	return name
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "");
-}
-
-export function scoreAnswers(
-	questions: StoredQuestion[],
-	answers: Array<{
-		questionId: string;
-		scaleValue?: number;
-		choiceValue?: string;
-		choiceValues?: string[];
-	}>,
-): { totalScore: number; categoryScores: Record<string, number> } {
-	const answerByQ = new Map(answers.map((a) => [a.questionId, a]));
-	// Per-category and overall earned/max accumulators.
-	const cat = new Map<string, { earned: number; max: number }>();
-	let totalEarned = 0;
-	let totalMax = 0;
-
-	for (const q of questions) {
-		if (q.type === "text") continue; // text questions are qualitative — never scored
-		const category = q.category || "General";
-		const a = answerByQ.get(q.id);
-		let earned = 0;
-		let max = 0;
-
-		if (q.options && q.options.length > 0) {
-			// Choice question: max is the highest single option's points; earned is
-			// the selected option(s)' points (capped at max).
-			max = Math.max(0, ...q.options.map((o) => o.points || 0));
-			if (a?.choiceValue) {
-				earned = q.options.find((o) => o.value === a.choiceValue)?.points ?? 0;
-			} else if (a?.choiceValues?.length) {
-				earned = Math.min(
-					max,
-					a.choiceValues.reduce(
-						(s, val) =>
-							s + (q.options?.find((o) => o.value === val)?.points ?? 0),
-						0,
-					),
-				);
-			}
-		} else {
-			// Scale question (the common case): 1–5 → earned 0–4.
-			max = SCALE_MAX;
-			if (typeof a?.scaleValue === "number") {
-				earned = Math.max(0, Math.min(SCALE_MAX, a.scaleValue - 1));
-			}
-		}
-
-		if (max <= 0) continue; // text/unscored questions don't affect the score
-		const entry = cat.get(category) ?? { earned: 0, max: 0 };
-		entry.earned += earned;
-		entry.max += max;
-		cat.set(category, entry);
-		totalEarned += earned;
-		totalMax += max;
-	}
-
-	const categoryScores: Record<string, number> = {};
-	for (const [name, { earned, max }] of cat) {
-		categoryScores[name] = max > 0 ? Math.round((100 * earned) / max) : 0;
-	}
-	const totalScore = totalMax > 0 ? Math.round((100 * totalEarned) / totalMax) : 0;
-	return { totalScore, categoryScores };
-}

package/src/fn-routers/auth-router.ts

@@ -1,65 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * ORPC `authed` middleware shared by the fn-routers NOT YET row-composed:
- * session resolve → UNAUTHORIZED → setRlsContext → orgId injection. The same
- * logic the generated fn.ts renders per service (orpc-bundle emits fn.ts
- * from api_route rows; consult that file when adding a procedure). This
- * handwritten copy will vanish with the last remaining family.
- *
- * isOrgAdmin + resolveAdminOverride moved to @teamscala/db/org-admin and are
- * ROW-composed as fn.auth.* procedures now.
- */
-
-import { os } from "@orpc/server";
-import type { PrismaClient } from "@teamscala/db/client";
-import { resetRlsContext, setRlsContext } from "@teamscala/db/rls-context";
-
-interface User {
-	id: string;
-	name?: string | null;
-	email?: string;
-	organisationId: string | null;
-}
-
-interface Context {
-	user: User | null | undefined;
-	headers: Headers;
-	resolveUser?: (headers: Headers, prisma: PrismaClient) => Promise<User | null>;
-	prisma: PrismaClient;
-	orgId?: string | null;
-}
-
-const authed = os.$context<Context>().use(async (opt) => {
-	const { context } = opt;
-	let user: User | null | undefined = context.user;
-	if (!user && context.headers && context.resolveUser) {
-		user = await context.resolveUser(context.headers, context.prisma);
-	}
-	if (!user) {
-		const { ORPCError } = await import("@orpc/server");
-		throw new ORPCError("UNAUTHORIZED", { message: "Authentication required" });
-	}
-	const orgId = user.organisationId || context.orgId;
-	// Audit attribution: fn procedures are custom-named writes/actions
-	// (deleteEmpty, etc.), so detecting "is write" by method name is unreliable —
-	// set the audit session context (app.current_user_name) for every authed call
-	// so the DB audit trigger records the actor. Same bridge the generated CRUD
-	// protectedProcedure uses; reset in finally to avoid leaking onto the pooled
-	// connection. Without this, fn.* writes record an empty actor ("by .").
-	await setRlsContext(context.prisma, {
-		userId: user.id,
-		userName: user.name || user.email,
-		organisationId: orgId,
-	});
-	try {
-		return await opt.next({ context: { ...context, user, orgId } });
-	} finally {
-		await resetRlsContext(context.prisma);
-	}
-});
-
-export type { Context, User };
-export { authed };

package/src/fn-routers/chat-session-router-shared.ts

@@ -1,122 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * The valibot schemas + row helpers of the chatSession ORPC router: procedure
- * input schemas, and the stored-row → wire message mapping.
- *
- * Split out of fn-routers/chat-session-router.ts (455 lines) — byte-for-byte
- * move; import paths adjusted only. Conversation ownership lives in its own
- * sibling, ./conversation-ownership.ts (single-canonical-unit).
- */
-
-import * as v from "valibot";
-
-/** channel_data discriminator carrying the agent this thread belongs to. */
-export const assistantType = (agentId: string) => `chat:${agentId}`;
-
-/**
- * How many recent messages createOrRestore returns. The full history was
- * previously loaded (unbounded) — a heavy thread paid ~2.5s + ~460KB on every
- * open/prefetch. Older messages paginate via `loadEarlier`. Adjustable; when a
- * tunable, lift to a registry config row (config-constants-db-driven).
- */
-export const RECENT_MESSAGE_LIMIT = 50;
-
-export const createOrRestoreSchema = v.object({
-	agentId: v.string(),
-	organisationId: v.string(),
-	/**
-	 * SSR-only: the real user's id, passed by the AiChat serverLoader. The
-	 * in-process server client is system-authed (context.user.id === "system"),
-	 * so without this the conversation is created under user_id="system" and
-	 * the real user's saveMessages hits assertOwns → FORBIDDEN. Only honoured
-	 * when the caller is the system user (server-side SSR), never from a
-	 * client-side ORPC call.
-	 */
-	userId: v.optional(v.string()),
-});
-export const loadSchema = v.object({
-	conversationId: v.string(),
-});
-export const saveMessagesSchema = v.object({
-	conversationId: v.string(),
-	messages: v.array(
-		v.object({
-			// The SDK UIMessage id — persisted AS the row PK so a reload/retry/
-			// dual-write upserts the SAME row instead of inserting a duplicate
-			// (chat-message-ids-server-stable). The duplicate truncated-assistant
-			// rows came from create-without-id: each save inserted a fresh row the
-			// next save could never reconcile against.
-			id: v.optional(v.string()),
-			role: v.string(),
-			content: v.string(),
-			// Verbatim UIMessage parts (messages-stored-as-uimessage-verbatim).
-			parts: v.optional(v.array(v.any())),
-			// UIMessage metadata — per-message token usage (inputTokens/
-			// outputTokens/contextWindow) the stream attaches; persisted so the
-			// context-usage gauge rehydrates on reload (was dropped before).
-			metadata: v.optional(v.record(v.string(), v.any())),
-		}),
-	),
-});
-export const clearSchema = v.object({
-	conversationId: v.string(),
-});
-export const listSchema = v.object({
-	agentId: v.string(),
-	organisationId: v.string(),
-});
-export const loadEarlierSchema = v.object({
-	conversationId: v.string(),
-	/** Cursor: the occurred_at (ISO) of the oldest currently-loaded message. */
-	before: v.pipe(
-		v.string(),
-		v.isoTimestamp(),
-	),
-	/** Cap; defaults to RECENT_MESSAGE_LIMIT, clamped to it. */
-	limit: v.optional(v.number()),
-});
-
-export interface SessionUser {
-	id: string;
-	name?: string | null;
-	email?: string;
-}
-
-export async function throwForbidden(message: string): Promise<never> {
-	const { ORPCError } = await import("@orpc/server");
-	throw new ORPCError("FORBIDDEN", { message });
-}
-
-/** Map stored message rows to the wire shape the chat client restores. */
-export function mapMessages(
-	msgs: Array<{
-		id: string;
-		role: string | null;
-		content: string | null;
-		channel_data: unknown;
-		created_at: Date | null;
-		occurred_at: Date | null;
-	}>,
-) {
-	return msgs
-		.filter((m) => m.role === "user" || m.role === "assistant")
-		.map((m) => ({
-			// Restore the stable row id so the client re-seeds useChat with the
-			// SAME ids it persisted — a later re-save then upserts instead of
-			// duplicating (chat-message-ids-server-stable).
-			id: m.id,
-			role: m.role,
-			content: m.content,
-			parts: (m.channel_data as { parts?: unknown[] } | null)?.parts,
-			// Restore the per-message token usage so the context-usage gauge can
-			// recompute on reload (the stream attaches it as UIMessage metadata).
-			metadata: (m.channel_data as { metadata?: Record<string, unknown> } | null)?.metadata,
-			created_at: m.created_at,
-			// The ordering field — exposed so the client can pass the oldest
-			// loaded message's occurred_at as the loadEarlier cursor.
-			occurred_at: m.occurred_at,
-		}));
-}

package/src/fn-routers/chat-session-router.ts

@@ -1,356 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * ORPC procedures for the AUTHENTICATED AI-chat conversation lifecycle —
- * the org+user-keyed sibling of publicGptSessionRouter (which is contact-
- * linked for anonymous public GPT visitors). One signed-in user chatting
- * with one agent in one org owns a thread of `conversations` rows; this
- * router createOrRestore-s the active one, saves turns, archives+news on
- * clear, lists past threads, and loads a specific thread.
- *
- * Identity: the USER is resolved from the ORPC session context (`authed`
- * middleware → `context.user.id`); the ORGANISATION is supplied by the
- * client (it is the URL :orgId for org-scoped apps like scala-projects —
- * the session does not carry it) and VERIFIED — the caller must be a
- * member of that organisation, else FORBIDDEN. A caller cannot read or
- * write another user's threads (ownership is user_id) or another org's
- * (createOrRestore/list are membership-scoped to the supplied org).
- *
- * This restores the capability the portal AI chat lost when the June
- * chat-engine migration severed `usePortalConversationId` + the
- * `portalConversation` router (capability-named `chatSession` here per
- * name-by-capability; the host-named orphan was deleted in the same change).
- *
- * Persistence model: the chat client owns writes via onMessagesPersist →
- * saveMessages, and sends clientPersists:true so handle-chat-stream skips its
- * own persistChatRun (single writer, no double-persist). Verbatim UIMessage
- * parts are stored in messages.channel_data.parts so multi-step (tool-using)
- * turns round-trip losslessly (apps/chat.md messages-stored-as-uimessage-verbatim).
- */
-
-import { os } from "@orpc/server";
-import * as v from "valibot";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-import { authed, type Context } from "./auth-router.ts";
-import { persistChatMessages } from "./persist-chat-messages.ts";
-
-import {
-	assistantType,
-	clearSchema,
-	createOrRestoreSchema,
-	listSchema,
-	loadEarlierSchema,
-	loadSchema,
-	mapMessages,
-	RECENT_MESSAGE_LIMIT,
-	saveMessagesSchema,
-	SessionUser,
-	throwForbidden,
-} from "./chat-session-router-shared.ts";
-import { assertOwns } from "./conversation-ownership.ts";
-
-export const chatSessionRouter = {
-	// createOrRestore — resume the caller's most-recent ACTIVE thread for this
-	// agent in the supplied (membership-verified) org, else reactivate the
-	// most-recent archived one, else create a new empty thread. Mirrors
-	// publicGptSession.createOrRestore's restore logic but keyed on
-	// (org, user_id, assistant_type) instead of contact_email.
-	createOrRestore: authed
-		.input(createOrRestoreSchema)
-		.handler(async ({ input, context }) => {
-			const { agentId, organisationId: orgId, userId: overrideUserId } = input;
-			const prisma = (context as Context).prisma;
-			const ctxUser = context.user as SessionUser;
-			// SSR serverLoader override: when the caller is the system user AND a
-			// real userId is provided, use that instead — so the conversation is
-			// created under the real user's identity, not "system".
-			const effectiveUserId =
-				ctxUser.id === "system" && overrideUserId ? overrideUserId : ctxUser.id;
-			const user = { ...ctxUser, id: effectiveUserId };
-			const log = getAppLogger();
-			const aType = assistantType(agentId);
-
-			try {
-				// Resolve the agent's configured model so the chat footer can show
-				// it next to the session ID ("Session ID · <model>"). ai_model is
-				// the agent's model key (e.g. "FLASH"), mapped to an llm_model row.
-				const agent = await prisma.ai_agents.findUnique({
-					where: { id: agentId },
-					select: { ai_model: true },
-				});
-				const model = agent?.ai_model ?? null;
-				const candidates = await prisma.conversations.findMany({
-					where: {
-						channel: "ai",
-						organisation_id: orgId,
-						user_id: user.id,
-						channel_data: { path: ["assistant_type"], equals: aType },
-					},
-					orderBy: { created_at: "desc" },
-				});
-
-				let existing =
-					candidates.find((c) => c.status === "active") ?? null;
-				// A returning user whose only thread is archived → reactivate the
-					// most-recent one so their history continues (matches the GPT
-					// "session gone" fix).
-				if (!existing && candidates.length > 0) {
-					existing = candidates[0];
-					await prisma.conversations.update({
-						where: { id: existing.id },
-						data: { status: "active" },
-					});
-				}
-
-				if (existing) {
-					// Bound to the most-recent RECENT_MESSAGE_LIMIT messages so a heavy
-					// thread doesn't pay ~2.5s + ~460KB on every open/prefetch (the
-					// prior unbounded load). Older messages paginate via `loadEarlier`.
-					// desc+take N+1, then reverse → asc for display; take N+1 detects
-					// whether older rows exist (hasMore drives the load-more control).
-					const recentRows = await prisma.messages.findMany({
-						where: { conversation_id: existing.id },
-						orderBy: { occurred_at: "desc" },
-						take: RECENT_MESSAGE_LIMIT + 1,
-					});
-					const hasMore = recentRows.length > RECENT_MESSAGE_LIMIT;
-					const windowRows = hasMore
-						? recentRows.slice(0, RECENT_MESSAGE_LIMIT)
-						: recentRows;
-					const msgs = windowRows.reverse();
-					const cd = (existing.channel_data ?? {}) as Record<
-						string,
-						unknown
-					>;
-					return {
-						conversationId: existing.id,
-						model,
-						messages: mapMessages(msgs),
-						tokenTotals: {
-							inputTokens: (cd.total_input_tokens as number) ?? 0,
-							outputTokens: (cd.total_output_tokens as number) ?? 0,
-						},
-						hasMore,
-					};
-				}
-
-				const conversation = await prisma.conversations.create({
-					data: {
-						channel: "ai",
-						organisation_id: orgId,
-						user_id: user.id,
-						title: "New chat",
-						status: "active",
-						channel_data: {
-							assistant_type: aType,
-							source: "authed-chat",
-							total_input_tokens: 0,
-							total_output_tokens: 0,
-						},
-						...(user.name || user.email
-							? {
-									members: {
-										name: user.name ?? null,
-										email: user.email ?? null,
-									},
-								}
-							: {}),
-					},
-				});
-
-				return {
-					conversationId: conversation.id,
-					model,
-					messages: [],
-					tokenTotals: { inputTokens: 0, outputTokens: 0 },
-					hasMore: false,
-				};
-			} catch (err) {
-				log.error(
-					`[chatSession.createOrRestore] failed: ${err instanceof Error ? err.message : String(err)}`,
-				);
-				throw err;
-			}
-		}),
-
-	// loadEarlier — paginate OLDER messages for a thread (the recent-N window
-	// createOrRestore returns is complemented by this). Cursor-based on
-	// occurred_at (the ordering field) so a new message appended at the tail
-	// never shifts the older window. Ownership is user_id (assertOwns).
-	loadEarlier: authed
-		.input(loadEarlierSchema)
-		.handler(async ({ input, context }) => {
-			const prisma = (context as Context).prisma;
-			const user = context.user as SessionUser;
-			const limit = Math.min(
-				input.limit ?? RECENT_MESSAGE_LIMIT,
-				RECENT_MESSAGE_LIMIT,
-			);
-			await assertOwns(prisma, input.conversationId, user);
-			const olderRows = await prisma.messages.findMany({
-				where: {
-					conversation_id: input.conversationId,
-					occurred_at: { lt: new Date(input.before) },
-				},
-				orderBy: { occurred_at: "desc" },
-				take: limit + 1,
-			});
-			const hasMore = olderRows.length > limit;
-			const windowRows = hasMore ? olderRows.slice(0, limit) : olderRows;
-			const msgs = windowRows.reverse();
-			return { messages: mapMessages(msgs), hasMore };
-		}),
-
-	// saveMessages — the onMessagesPersist writer. Stamps occurred_at with a
-	// 1ms step preserving array order (created_at is the DB backstop) and
-	// stores verbatim UIMessage parts in channel_data.parts. Reuses the GPT
-	// saveMessages shape. Ownership is user_id (assertOwns).
-	saveMessages: authed
-		.input(saveMessagesSchema)
-		.handler(async ({ input, context }) => {
-			const prisma = (context as Context).prisma;
-			const user = context.user as SessionUser;
-			const conv = await assertOwns(prisma, input.conversationId, user);
-			const orgId = conv.organisation_id;
-
-			// The write itself lives in ONE shared surface (persist-chat-messages);
-			// this router only resolves identity (assertOwns by user_id) above.
-			await persistChatMessages(prisma, {
-				conversationId: input.conversationId,
-				organisationId: orgId,
-				messages: input.messages,
-			});
-			return { success: true };
-		}),
-
-	// clear = START FRESH. Archive the old thread + drop its (now-cleared)
-	// messages so it never auto-restores, AND create a brand-new empty thread
-	// for the same user+org+agent with a NEW id (deterministic, no reload).
-	// Mirrors publicGptSession.clear. Ownership is user_id (assertOwns).
-	clear: authed.input(clearSchema).handler(async ({ input, context }) => {
-		const prisma = (context as Context).prisma;
-		const user = context.user as SessionUser;
-		const log = getAppLogger();
-
-		const old = await assertOwns(prisma, input.conversationId, user);
-
-		await prisma.messages.deleteMany({
-			where: { conversation_id: input.conversationId },
-		});
-		await prisma.conversations.update({
-			where: { id: input.conversationId },
-			data: { status: "archived" },
-		});
-
-		const cd = (old.channel_data ?? {}) as {
-			assistant_type?: string;
-		};
-		const conversation = await prisma.conversations.create({
-			data: {
-				channel: "ai",
-				organisation_id: old.organisation_id,
-				user_id: old.user_id,
-				title: "New chat",
-				status: "active",
-				channel_data: {
-					assistant_type: cd.assistant_type,
-					source: "authed-chat",
-					total_input_tokens: 0,
-					total_output_tokens: 0,
-				},
-				...(old.members ?? undefined ? { members: old.members } : {}),
-			},
-		});
-
-		log.info("[chatSession.clear] archived + created fresh", {
-			oldId: input.conversationId,
-			newId: conversation.id,
-		});
-		return {
-			conversationId: conversation.id,
-			messages: [],
-			tokenTotals: { inputTokens: 0, outputTokens: 0 },
-		};
-	}),
-
-	// list — the user's threads for this agent in the supplied (membership-
-	// verified) org, most-recent first. Powers the conversation history list.
-	// Includes a short preview from the latest user message in each thread.
-	list: authed.input(listSchema).handler(async ({ input, context }) => {
-		const prisma = (context as Context).prisma;
-		const user = context.user as SessionUser;
-		const { agentId, organisationId: orgId } = input;
-		const aType = assistantType(agentId);
-
-		const conversations = await prisma.conversations.findMany({
-			where: {
-				channel: "ai",
-				organisation_id: orgId,
-				user_id: user.id,
-				channel_data: { path: ["assistant_type"], equals: aType },
-			},
-			orderBy: { last_message_at: "desc" },
-			select: {
-				id: true,
-				title: true,
-				status: true,
-				last_message_at: true,
-				created_at: true,
-			},
-		});
-
-		if (conversations.length === 0) return { conversations: [] };
-
-		// One grouped fetch for the latest user message per thread (preview),
-		// mapped in JS — avoids an N+1.
-		const ids = conversations.map((c) => c.id);
-		const lastMsgs = await prisma.messages.findMany({
-			where: { conversation_id: { in: ids }, role: "user" },
-			orderBy: { occurred_at: "desc" },
-			select: { conversation_id: true, content: true },
-		});
-		const previewById = new Map<string, string>();
-		for (const m of lastMsgs) {
-			if (m.conversation_id && !previewById.has(m.conversation_id)) {
-				previewById.set(
-					m.conversation_id,
-					(m.content ?? "").slice(0, 120),
-				);
-			}
-		}
-
-		return {
-			conversations: conversations.map((c) => ({
-				id: c.id,
-				title: c.title,
-				status: c.status,
-				last_message_at: c.last_message_at ?? c.created_at,
-				preview: previewById.get(c.id) ?? "",
-			})),
-		};
-	}),
-
-	// load — switch to a past thread from the history list. Returns its full
-	// message history (verbatim parts). Ownership is user_id (assertOwns).
-	load: authed.input(loadSchema).handler(async ({ input, context }) => {
-		const prisma = (context as Context).prisma;
-		const user = context.user as SessionUser;
-		const conv = await assertOwns(prisma, input.conversationId, user);
-
-		const msgs = await prisma.messages.findMany({
-			where: { conversation_id: input.conversationId },
-			orderBy: { occurred_at: "asc" },
-		});
-		const cd = (conv.channel_data ?? {}) as Record<string, unknown>;
-		return {
-			conversationId: conv.id,
-			messages: mapMessages(msgs),
-			tokenTotals: {
-				inputTokens: (cd.total_input_tokens as number) ?? 0,
-				outputTokens: (cd.total_output_tokens as number) ?? 0,
-			},
-		};
-	}),
-};

package/src/fn-routers/conversation-ownership.ts

@@ -1,24 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Conversation ownership assertion for the chatSession ORPC router — the
- * reject-if-not-yours gate every mutating procedure runs before touching rows.
- */
-
-import { throwForbidden, type SessionUser } from "./chat-session-router-shared.ts";
-
-import type { PrismaClient } from "@teamscala/db/client";
-
-export async function assertOwns(
-	prisma: PrismaClient,
-	conversationId: string,
-	user: SessionUser,
-): Promise<unknown> {
-	const conv = await prisma.conversations.findUnique({
-		where: { id: conversationId },
-	});
-	if (!conv || conv.user_id !== user.id) await throwForbidden("Conversation not found.");
-	return conv;
-}