pi-roundtable-web 0.25.0 → 0.26.0

package/src/app/protocol.ts

@@ -1,6 +1,7 @@
 import { QUESTIONNAIRE_LIMITS } from "pi-roundtable";
 import {
 	type ClientFrame,
+	type FormInput,
 	MAX_MESSAGE_FILES,
 	type PromptAnswer,
 } from "../api-types.ts";
@@ -40,6 +41,31 @@ function parseAnswer(value: unknown): PromptAnswer | undefined {
 	};
 }
 
+/** The most fields and the longest value a form's input may carry. */
+const FORM_FIELDS = 40;
+const FORM_VALUE_CHARS = 32_000;
+
+/** A form's input: text, or a list of text, by field name. */
+function parseInput(value: unknown): FormInput | undefined {
+	if (!isRecord(value)) return undefined;
+	const entries = Object.entries(value);
+	if (entries.length > FORM_FIELDS) return undefined;
+	const input: Record<string, string | string[]> = {};
+	for (const [name, field] of entries) {
+		if (name.length === 0 || name.length > ID_CHARS) return undefined;
+		if (typeof field === "string" && field.length <= FORM_VALUE_CHARS)
+			input[name] = field;
+		else if (
+			Array.isArray(field) &&
+			field.length <= FORM_FIELDS &&
+			field.every((one) => isText(one) && one.length <= FORM_VALUE_CHARS)
+		)
+			input[name] = field as string[];
+		else return undefined;
+	}
+	return input;
+}
+
 function parseAnswers(value: Record<string, unknown>): ClientFrame | undefined {
 	const { prompt, answers, note } = value;
 	if (!isId(prompt) || !Array.isArray(answers)) return undefined;
@@ -99,8 +125,10 @@ export function parseClientFrame(
 				...(value.room === undefined ? {} : { room: value.room as string }),
 			};
 		case "send": {
-			const { id, room, text, uploads } = value;
+			const { id, room, text, uploads, mode } = value;
 			if (!isId(id) || !isId(room) || !isText(text)) return undefined;
+			if (mode !== undefined && mode !== "note" && mode !== "turn")
+				return undefined;
 			if (
 				uploads !== undefined &&
 				!(
@@ -118,8 +146,42 @@ export function parseClientFrame(
 				...(uploads === undefined || uploads.length === 0
 					? {}
 					: { uploads: uploads as string[] }),
+				...(mode === undefined ? {} : { mode }),
 			};
 		}
+		case "subscribe":
+		case "unsubscribe":
+			return isId(value.room)
+				? { type: value.type, room: value.room }
+				: undefined;
+		case "act": {
+			const { id, room, page, action, card, input } = value;
+			if (!isId(id) || !isId(action)) return undefined;
+			// One target: a room or a page, never both and never neither.
+			if ((room === undefined) === (page === undefined)) return undefined;
+			if (!optional(room, isId) || !optional(page, isId)) return undefined;
+			if (!optional(card, isId)) return undefined;
+			const parsed = input === undefined ? undefined : parseInput(input);
+			if (input !== undefined && !parsed) return undefined;
+			return {
+				type: "act",
+				id,
+				action,
+				...(room === undefined ? {} : { room: room as string }),
+				...(page === undefined ? {} : { page: page as string }),
+				...(card === undefined ? {} : { card: card as string }),
+				...(parsed ? { input: parsed } : {}),
+			};
+		}
+		case "ack":
+			return isId(value.tag) ? { type: "ack", tag: value.tag } : undefined;
+		case "read":
+			return isId(value.room) &&
+				typeof value.upTo === "number" &&
+				Number.isSafeInteger(value.upTo) &&
+				value.upTo >= 0
+				? { type: "read", room: value.room, upTo: value.upTo }
+				: undefined;
 		case "stop":
 			return isId(value.room) ? { type: "stop", room: value.room } : undefined;
 		case "approval":

package/src/app/room-log.ts

@@ -1,6 +1,12 @@
 import type { SQL } from "bun";
 import type { Migration } from "pi-roundtable";
-import type { RoomFile, RoomMessage } from "../api-types.ts";
+import type {
+	HostAuthorKind,
+	PictureRef,
+	RoomFile,
+	RoomMessage,
+} from "../api-types.ts";
+import { storedJson } from "../host/stored-json.ts";
 
 /** A message to store; the log numbers it and stamps its time. */
 export interface NewRoomMessage {
@@ -11,6 +17,14 @@ export interface NewRoomMessage {
 	author: string;
 	text: string;
 	files?: RoomFile[];
+	/** Host rooms: who wrote it, as the host's kinds of author name them. */
+	authorKind?: HostAuthorKind;
+	authorLabel?: string;
+	picture?: PictureRef;
+	/** Host rooms: the host's own id for the message, unique within the room. */
+	reference?: string;
+	/** When it was written, for an import; the log's clock otherwise. Retention counts from it. */
+	at?: Date;
 }
 
 interface Row {
@@ -23,16 +37,17 @@ interface Row {
 	text: string;
 	files: RoomFile[] | string;
 	created_at: Date;
+	author_kind: HostAuthorKind | null;
+	author_label: string | null;
+	picture: PictureRef | string | null;
+	edited_at: Date | null;
 }
 
 /** The most messages one page of history holds. */
 export const PAGE_LIMIT = 100;
 
 function messageOf(row: Row): RoomMessage {
-	const files =
-		typeof row.files === "string"
-			? (JSON.parse(row.files) as RoomFile[])
-			: row.files;
+	const files = storedJson(row.files, "message files");
 	return {
 		id: Number(row.id),
 		room: row.room,
@@ -43,6 +58,14 @@ function messageOf(row: Row): RoomMessage {
 		text: row.text,
 		files,
 		at: row.created_at.toISOString(),
+		...(row.author_kind === null ? {} : { authorKind: row.author_kind }),
+		...(row.author_label === null ? {} : { authorLabel: row.author_label }),
+		...(row.picture === null
+			? {}
+			: {
+					picture: storedJson(row.picture, "picture"),
+				}),
+		...(row.edited_at === null ? {} : { edited: true as const }),
 	};
 }
 
@@ -79,29 +102,133 @@ export class RoomLog {
 		},
 	};
 
+	/** The columns a host room's messages add: who wrote it, the host's reference, and when it was changed. */
+	static readonly hostMigration: Migration = {
+		name: "web-room-messages-host",
+		up: async (sql) => {
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS author_kind text`;
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS author_label text`;
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS picture jsonb`;
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS reference text`;
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS edited_at timestamptz`;
+			await sql`CREATE UNIQUE INDEX IF NOT EXISTS web_room_messages_reference ON web_room_messages (room, reference) WHERE reference IS NOT NULL`;
+			await sql`CREATE INDEX IF NOT EXISTS web_room_messages_created ON web_room_messages (created_at)`;
+		},
+	};
+
 	async append(message: NewRoomMessage): Promise<RoomMessage> {
-		const files = JSON.stringify(message.files ?? []);
-		const [row]: Row[] = await this.#sql`
-			INSERT INTO web_room_messages (room, kind, principal_id, agent, author_name, text, files)
-			VALUES (${message.room}, ${message.kind}, ${message.principalId ?? null},
-				${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::jsonb)
-			RETURNING *`;
+		const [row] = await this.#insert(message, false);
 		if (!row) throw new Error("the room log stored nothing");
 		return messageOf(row);
 	}
 
-	/** Changes the text of a message stored in the room; undefined when the room holds no such message. */
+	/**
+	 * Stores a host room's message once per `reference`: a second post with the same reference in
+	 * the room stores nothing and answers the message already there, with `created` false.
+	 */
+	async appendOnce(
+		message: NewRoomMessage,
+	): Promise<{ message: RoomMessage; created: boolean }> {
+		const [row] = await this.#insert(message, message.reference !== undefined);
+		if (row) return { message: messageOf(row), created: true };
+		const [existing]: Row[] = await this.#sql`
+			SELECT * FROM web_room_messages
+			WHERE room = ${message.room} AND reference = ${message.reference ?? null}`;
+		if (!existing) throw new Error("the room log stored nothing");
+		return { message: messageOf(existing), created: false };
+	}
+
+	async #insert(message: NewRoomMessage, once: boolean): Promise<Row[]> {
+		const files = JSON.stringify(message.files ?? []);
+		const picture = message.picture ? JSON.stringify(message.picture) : null;
+		const at = message.at ?? new Date();
+		return once
+			? await this.#sql`
+				INSERT INTO web_room_messages (room, kind, principal_id, agent, author_name, text, files,
+					author_kind, author_label, picture, reference, created_at)
+				VALUES (${message.room}, ${message.kind}, ${message.principalId ?? null},
+					${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::jsonb,
+					${message.authorKind ?? null}, ${message.authorLabel ?? null}, ${picture}::jsonb,
+					${message.reference ?? null}, ${at})
+				ON CONFLICT (room, reference) WHERE reference IS NOT NULL DO NOTHING
+				RETURNING *`
+			: await this.#sql`
+				INSERT INTO web_room_messages (room, kind, principal_id, agent, author_name, text, files,
+					author_kind, author_label, picture, reference, created_at)
+				VALUES (${message.room}, ${message.kind}, ${message.principalId ?? null},
+					${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::jsonb,
+					${message.authorKind ?? null}, ${message.authorLabel ?? null}, ${picture}::jsonb,
+					${message.reference ?? null}, ${at})
+				RETURNING *`;
+	}
+
+	/**
+	 * Changes the text of a message stored in the room; undefined when the room holds no such
+	 * message. `mark` shows it as edited, as a host's edit of someone's words does.
+	 */
 	async edit(
 		room: string,
 		id: number,
 		text: string,
+		mark = false,
 	): Promise<RoomMessage | undefined> {
+		const [row]: Row[] = mark
+			? await this.#sql`
+				UPDATE web_room_messages SET text = ${text}, edited_at = now()
+				WHERE id = ${id} AND room = ${room} RETURNING *`
+			: await this.#sql`
+				UPDATE web_room_messages SET text = ${text}
+				WHERE id = ${id} AND room = ${room} RETURNING *`;
+		return row && messageOf(row);
+	}
+
+	/** The message the host's reference names, if the room holds one. */
+	async byReference(
+		room: string,
+		reference: string,
+	): Promise<number | undefined> {
+		const [row]: { id: string | number | bigint }[] = await this.#sql`
+			SELECT id FROM web_room_messages WHERE room = ${room} AND reference = ${reference}`;
+		return row === undefined ? undefined : Number(row.id);
+	}
+
+	/** One stored message of the room, or undefined. */
+	async get(room: string, id: number): Promise<RoomMessage | undefined> {
+		const [row]: Row[] = await this.#sql`
+			SELECT * FROM web_room_messages WHERE room = ${room} AND id = ${id}`;
+		return row && messageOf(row);
+	}
+
+	/** Deletes one message of the room; the message as it was, or undefined when the room held none. */
+	async remove(room: string, id: number): Promise<RoomMessage | undefined> {
 		const [row]: Row[] = await this.#sql`
-			UPDATE web_room_messages SET text = ${text}
-			WHERE id = ${id} AND room = ${room} RETURNING *`;
+			DELETE FROM web_room_messages WHERE room = ${room} AND id = ${id} RETURNING *`;
 		return row && messageOf(row);
 	}
 
+	/**
+	 * Deletes the messages older than `before` of the rooms whose key starts with `prefix`, the
+	 * kind's rooms; the deleted messages, so their files can go too. Age is the message's own time.
+	 */
+	async sweepKind(prefix: string, before: Date): Promise<RoomMessage[]> {
+		const rows: Row[] = await this.#sql`
+			DELETE FROM web_room_messages
+			WHERE starts_with(room, ${prefix}) AND created_at < ${before} RETURNING *`;
+		return rows.map(messageOf);
+	}
+
+	/** The newest message id of each room that has one, for the read cursors. */
+	async newestIds(rooms: readonly string[]): Promise<Map<string, number>> {
+		const found = new Map<string, number>();
+		if (rooms.length === 0) return found;
+		const rows: { room: string; id: string | number | bigint }[] = await this
+			.#sql`
+			SELECT room, max(id) AS id FROM web_room_messages
+			WHERE room IN ${this.#sql(rooms)} GROUP BY room`;
+		for (const row of rows) found.set(row.room, Number(row.id));
+		return found;
+	}
+
 	/** The newest `limit` messages older than `before` (all of them when absent), oldest first. */
 	async page(
 		room: string,

package/src/app/routes.ts

@@ -33,8 +33,14 @@ import type {
 } from "../api-types.ts";
 import type { Authenticated } from "../auth/authenticator.ts";
 import { type ConsolePresentation, message } from "../features.ts";
+import type { Gate } from "../gate.ts";
+import type { HostApp } from "../host/host-app.ts";
+import type { RoomReads } from "../host/reads.ts";
+import { readsOf, withExpiredFiles } from "../host/room-views.ts";
 import { json } from "../http.ts";
+import type { ResolvedOptions } from "../options.ts";
 import type { PushMutes } from "../push/mutes.ts";
+import { viewerOf, type WebAppRegistry } from "../web-app.ts";
 import { bad, bodyOf, HttpError, notFound } from "./api-http.ts";
 import type { CardLog } from "./card-log.ts";
 import { type FileDir, fileResponse, isFileId } from "./files.ts";
@@ -73,9 +79,9 @@ export interface AppApiOptions {
 	/** The owners' shared arrangement of the room list: pins and folders. */
 	layout: LayoutStore;
 	conversations: Pick<ConversationPort, "startFresh">;
-	identity: Pick<IdentityService, "tierOf">;
+	identity: Pick<IdentityService, "principal">;
 	/** Present when the schedules pane is served. */
-	schedules?: Pick<ScheduleStore, "all" | "remove">;
+	schedules?: Pick<ScheduleStore, "all" | "get" | "remove">;
 	directory: Pick<AgentDirectory, "agent" | "agents" | "group" | "groups">;
 	team: Pick<
 		AgentTeam,
@@ -109,12 +115,28 @@ export interface AppApiOptions {
 	/** Present when the host has prompt documents (the prompts plugin): the main prompts the owner edits. */
 	prompts?: PromptApiOptions["prompts"];
 	avatars: Pick<AvatarStudio, "serve">;
+	/** The read cursors, for each room's unread count and who has read what. */
+	reads?: Pick<RoomReads, "unread" | "cursorOf" | "marks">;
+	/** Who may be served a file bound to a host room or a page. */
+	host?: Pick<HostApp, "mayRead">;
+	/** The name the app shows for a person. */
+	nameOf?(principalId: string): Promise<string>;
 	/** Present when the workspace pane is served. */
 	workspace?: WorkspaceFiles;
 	/** The mount, which a room's agent picture hangs under. */
 	mount: string;
 	/** How the console signs the person in, as the session reports it. */
 	authMode: SessionView["auth"];
+	/** Who the app admits; the session reports the person's tier only where it admits more than owners. */
+	admission?: ResolvedOptions["admission"];
+	/** The area handlers the pieces of the app plug in; without it the API is the owners' as in 0.25. */
+	registry?: Pick<WebAppRegistry, "areaFor">;
+	/** The onboarding gate; without it nobody is gated. */
+	gate?: Pick<Gate, "required">;
+	/** The tiers whose people may use push; default owners. */
+	pushTiers?: ResolvedOptions["push"]["tiers"];
+	/** Whether the yolo and long-running switches are served; `PUT rooms/<key>/mode` answers 404 without them. Default true. */
+	modeSwitches?: boolean;
 	/** The quiet hours of push, as the settings page shows them. */
 	quietHours?: NonNullable<SessionView["quietHours"]>;
 	/** Called after a change the other pages should refetch. */
@@ -296,7 +318,12 @@ export class AppApi {
 		const parts = partsOf(rest);
 		if (!parts) return undefined;
 		const [first, second] = parts;
+		const area =
+			first === "api" && second !== undefined
+				? this.#options.registry?.areaFor(second)
+				: undefined;
 		const mine =
+			area !== undefined ||
 			(first === "avatars" && parts.length === 2) ||
 			(first === "api" &&
 				[
@@ -316,6 +343,11 @@ export class AppApi {
 				].includes(second ?? ""));
 		if (!mine) return undefined;
 		try {
+			if (area)
+				return await area.handle(request, parts.slice(2), {
+					visitor: admission.visitor,
+					viewer: viewerOf(admission.visitor),
+				});
 			return await this.#route(request, parts, admission);
 		} catch (error) {
 			if (error instanceof HttpError || error instanceof UploadRefusal)
@@ -338,16 +370,13 @@ export class AppApi {
 		}
 	}
 
-	/** The owner who writes: their tier read again, as a speaker for the calls that need one. */
+	/** The owner who writes: the tier the request was admitted at, as a speaker for the calls that need one. */
 	async #owner(admission: Authenticated): Promise<Speaker> {
-		const { principal } = admission.visitor;
-		const tier = await this.#options.identity.tierOf(principal.id);
+		const { principal, tier, speakerId } = admission.visitor;
 		if (tier !== "owner")
 			throw new HttpError(403, "Only an owner may do this.");
 		return {
-			id: admission.actor
-				? `${admission.actor.provider}:${admission.actor.subject}`
-				: principal.id,
+			id: speakerId,
 			name: principal.displayName,
 			tier,
 			principalId: principal.id,
@@ -368,7 +397,8 @@ export class AppApi {
 				new Response("Not found", { status: 404 })
 			);
 		}
-		if (area === "session" && method === "GET") return this.#session(admission);
+		if (area === "session" && method === "GET")
+			return await this.#session(admission);
 		if (area === "models" && method === "GET")
 			return json({
 				models: await this.#options.team.usableModels(),
@@ -376,20 +406,21 @@ export class AppApi {
 		if (area === "rooms") return this.#rooms(request, parts, admission);
 		if (area === "folders")
 			return this.#layout.folders(request, parts, admission);
-		if (area === "uploads" && method === "POST" && !id) {
-			const owner = await this.#owner(admission);
+		// An upload is the sender's own, whoever they are; a file answers by the room it is bound to.
+		if (area === "uploads" && method === "POST" && !id)
 			return json(
-				await this.#options.uploads.receive(request, owner.principalId),
+				await this.#options.uploads.receive(
+					request,
+					admission.visitor.principal.id,
+				),
 			);
-		}
 		if (area === "uploads" && method === "DELETE" && id && !action) {
-			const owner = await this.#owner(admission);
-			if (!this.#options.uploads.discard(id, owner.principalId))
+			if (!this.#options.uploads.discard(id, admission.visitor.principal.id))
 				throw notFound();
 			return json({ ok: true });
 		}
 		if (area === "files" && method === "GET" && id && !action)
-			return this.#file(id);
+			return await this.#file(id, admission);
 		if (area === "workspace") return this.#workspace(request, parts, admission);
 		if (area === "schedules") return this.#schedules(method, id, admission);
 		const owner = () => this.#owner(admission);
@@ -410,13 +441,21 @@ export class AppApi {
 		throw new HttpError(404, "There is no such API.");
 	}
 
-	#session(admission: Authenticated): Response {
-		const { principal } = admission.visitor;
+	async #session(admission: Authenticated): Promise<Response> {
+		const { principal, tier } = admission.visitor;
+		const { admission: admits = "owners", gate } = this.#options;
+		const pushTiers = this.#options.pushTiers ?? ["owner"];
+		const owed =
+			admits === "access" && gate
+				? await gate.required(viewerOf(admission.visitor))
+				: [];
 		return json({
 			principal: { id: principal.id, name: principal.displayName },
 			surface: this.#options.surface.surface,
 			auth: this.#options.authMode,
-			push: true,
+			...(admits === "access" ? { tier } : {}),
+			...(owed.length > 0 ? { gate: owed } : {}),
+			...(pushTiers.includes(tier) ? { push: true as const } : {}),
 			...(this.#options.prompts ? { prompts: true } : {}),
 			...(this.#options.skills ? { skillEdit: true } : {}),
 			...(this.#options.quietHours
@@ -436,10 +475,22 @@ export class AppApi {
 		const { method } = request;
 		const [, , key, action] = parts;
 		const { rooms, log, cards, modes, mutes, conversations } = this.#options;
+		// The agent rooms are the owners'; to anyone else this API does not exist.
+		if (admission.visitor.tier !== "owner") throw notFound();
 		if (!key) {
 			if (method !== "GET") throw new HttpError(405, "Method not allowed.");
+			const listed = await rooms.list();
+			// What each room holds past this person's cursor; a room they never read starts from what it has now.
+			const unread = await this.#options.reads?.unread(
+				admission.visitor.principal.id,
+				listed.map((one) => one.key),
+				new Set(listed.map((one) => one.key)),
+			);
 			return json({
-				rooms: await rooms.list(),
+				rooms: listed.map((one) => {
+					const count = unread?.get(one.key);
+					return count ? { ...one, unread: count } : one;
+				}),
 				...(await this.#layout.view()),
 			} satisfies RoomsView);
 		}
@@ -461,17 +512,26 @@ export class AppApi {
 			// The cards stand among the messages by the time they opened; a page that has older
 			// messages leaves the cards before its first one to the older page.
 			const first = page.messages[0];
+			const { reads, nameOf } = this.#options;
+			const self = admission.visitor.principal.id;
+			const cursor = await reads?.cursorOf(room.key, self);
 			return json({
 				...page,
+				messages: withExpiredFiles(page.messages, this.#options.files),
 				cards: await cards.during(room.key, {
 					...(page.more && first ? { from: first.at } : {}),
 					...(beforeId === undefined ? {} : { before: beforeId }),
 				}),
+				...(reads && nameOf
+					? { reads: await readsOf(reads, room.key, self, nameOf) }
+					: {}),
+				...(cursor === undefined ? {} : { cursor }),
 			} satisfies MessagesView);
 		}
 		if (action === "mode" && method === "PUT" && parts.length === 4) {
 			// Only an agent's or group's room has modes; a thread runs no turn of the owner's.
-			if (room.readOnly) throw notFound();
+			if (room.readOnly || this.#options.modeSwitches === false)
+				throw notFound();
 			const owner = await this.#owner(admission);
 			const body = await bodyOf(request);
 			const change: ModeChange = {};
@@ -513,10 +573,20 @@ export class AppApi {
 		throw new HttpError(404, "There is no such API.");
 	}
 
-	#file(id: string): Response {
+	async #file(id: string, admission: Authenticated): Promise<Response> {
 		if (!isFileId(id)) throw notFound();
-		const meta = this.#options.files.meta(id);
-		const blob = this.#options.files.blob(id);
+		const { files, host } = this.#options;
+		// A file bound to a host room or page is for the people it is open to, owners too; every other stored file belongs to an agent room, which only owners read.
+		const bound = files.binding(id)?.room;
+		if (bound === undefined) {
+			if (admission.visitor.tier !== "owner") throw notFound();
+		} else if (
+			!host ||
+			!(await host.mayRead(viewerOf(admission.visitor), bound))
+		)
+			throw notFound();
+		const meta = files.meta(id);
+		const blob = files.blob(id);
 		if (!meta || !blob) throw notFound();
 		return fileResponse(meta, blob);
 	}
@@ -636,6 +706,18 @@ export class AppApi {
 		throw new HttpError(404, "There is no such API.");
 	}
 
+	/** Whether a schedule is the visitor's own: its creator id names their principal. */
+	async #ownSchedule(
+		createdById: string,
+		principalId: string,
+	): Promise<boolean> {
+		if (createdById === principalId) return true;
+		// A schedule from 0.8 names its creator by a user id that the backfill made a principal's id.
+		return (
+			(await this.#options.identity.principal(createdById))?.id === principalId
+		);
+	}
+
 	async #schedules(
 		method: string,
 		id: string | undefined,
@@ -643,11 +725,19 @@ export class AppApi {
 	): Promise<Response> {
 		const { schedules, rooms } = this.#options;
 		if (!schedules) throw new HttpError(404, "This pane is not served.");
+		const { tier, principal } = admission.visitor;
+		const owner = tier === "owner";
 		if (method === "GET" && !id) {
 			const all = await schedules.all();
 			const views: ScheduleView[] = [];
 			for (const schedule of all) {
-				const room = await rooms.resolve(schedule.channel);
+				// The owners see every schedule; anyone else sees their own, and no room of the owners.
+				if (
+					!owner &&
+					!(await this.#ownSchedule(schedule.createdById, principal.id))
+				)
+					continue;
+				const room = owner ? await rooms.resolve(schedule.channel) : undefined;
 				views.push({
 					id: schedule.id,
 					...(room ? { room: room.key } : {}),
@@ -667,9 +757,17 @@ export class AppApi {
 			return json({ schedules: views } satisfies SchedulesView);
 		}
 		if (method === "DELETE" && id) {
-			await this.#owner(admission);
 			const number = Number(id);
 			if (!Number.isInteger(number)) throw bad("The schedule id is a number.");
+			// Another person's schedule is not there to remove, for anyone but the owners.
+			if (!owner) {
+				const found = await schedules.get(number);
+				if (
+					!found ||
+					!(await this.#ownSchedule(found.createdById, principal.id))
+				)
+					throw new HttpError(404, "There is no such schedule.");
+			}
 			const removed = await schedules.remove(number);
 			if (!removed) throw new HttpError(404, "There is no such schedule.");
 			this.#options.changed();