pi-roundtable-web 0.29.0 → 0.29.1

package/src/app/room-log.ts

@@ -8,7 +8,7 @@ import {
 	type RoomMessage,
 	START_OVER_TEXT,
 } from "../api-types.ts";
-import { storedJson } from "../host/stored-json.ts";
+import { jsonValuesMigration, storedJson } from "../host/stored-json.ts";
 
 /** A message to store; the log numbers it and stamps its time. */
 export interface NewRoomMessage {
@@ -49,6 +49,7 @@ interface Row {
 	edited_at: Date | null;
 	note: boolean | null;
 	intercom?: RoomIntercom | string | null;
+	delivery: "steered" | "cancelled" | null;
 }
 
 /** The most messages one page of history holds. */
@@ -78,6 +79,7 @@ function messageOf(row: Row): RoomMessage {
 		...(row.intercom == null
 			? {}
 			: { intercom: storedJson(row.intercom, "intercom card") }),
+		...(row.delivery === null ? {} : { delivery: row.delivery }),
 	};
 }
 
@@ -94,6 +96,13 @@ export class RoomLog {
 		this.#sql = sql;
 	}
 
+	/** Its jsonb columns stored as the JSON values themselves, not as the text of them. */
+	static readonly jsonValuesMigration: Migration = jsonValuesMigration(
+		"web-room-messages-json-values",
+		"web_room_messages",
+		["files", "picture", "intercom"],
+	);
+
 	/** The log's table. */
 	static readonly migration: Migration = {
 		name: "web-room-messages",
@@ -152,6 +161,14 @@ export class RoomLog {
 		},
 	};
 
+	/** The column that records how an owner message sent during a turn went: steered into it, or cancelled while it waited. */
+	static readonly deliveryMigration: Migration = {
+		name: "web-room-messages-delivery",
+		up: async (sql) => {
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS delivery text`;
+		},
+	};
+
 	async append(message: NewRoomMessage): Promise<RoomMessage> {
 		const [row] = await this.#insert(message, false);
 		if (!row) throw new Error("the room log stored nothing");
@@ -184,18 +201,18 @@ export class RoomLog {
 				INSERT INTO web_room_messages (room, kind, principal_id, agent, author_name, text, files,
 					author_kind, author_label, picture, reference, created_at, note, intercom)
 				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}, ${message.note === true}, ${intercom}::jsonb)
+					${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::text::jsonb,
+					${message.authorKind ?? null}, ${message.authorLabel ?? null}, ${picture}::text::jsonb,
+					${message.reference ?? null}, ${at}, ${message.note === true}, ${intercom}::text::jsonb)
 				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, note, intercom)
 				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}, ${message.note === true}, ${intercom}::jsonb)
+					${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::text::jsonb,
+					${message.authorKind ?? null}, ${message.authorLabel ?? null}, ${picture}::text::jsonb,
+					${message.reference ?? null}, ${at}, ${message.note === true}, ${intercom}::text::jsonb)
 				RETURNING *`;
 	}
 
@@ -219,6 +236,21 @@ export class RoomLog {
 		return row && messageOf(row);
 	}
 
+	/**
+	 * Records how a message sent during a turn went (`steered`, `cancelled`), or clears it; the
+	 * message as it is now, or undefined when the room holds none.
+	 */
+	async setDelivery(
+		room: string,
+		id: number,
+		delivery: "steered" | "cancelled" | null,
+	): Promise<RoomMessage | undefined> {
+		const [row]: Row[] = await this.#sql`
+			UPDATE web_room_messages SET delivery = ${delivery}
+			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,

package/src/app/routes.ts

@@ -71,15 +71,40 @@ import {
 	type WorkspaceFiles,
 	WorkspaceRefusal,
 } from "./workspace-files.ts";
+import { uniqueNames, zipStore } from "./zip.ts";
 
 /** The most threads one request puts back on the room list: more than the list ever shows. */
 const MAX_RESTORED = 100;
+/** The most bytes a message's files may add up to and still be zipped together: 200 MB. */
+const MAX_ZIP_BYTES = 200 * 1024 * 1024;
+
+/** A message's zip, named after when it was sent on the host's clock: `attachments-20261031-2030.zip`. */
+export const zipName = (at: Date, timeZone = "UTC"): string => {
+	if (Number.isNaN(at.getTime())) return "attachments.zip";
+	const part = Object.fromEntries(
+		new Intl.DateTimeFormat("en-CA", {
+			timeZone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23",
+		})
+			.formatToParts(at)
+			.map(({ type, value }) => [type, value]),
+	);
+	return `attachments-${part.year}${part.month}${part.day}-${part.hour}${part.minute}.zip`;
+};
+
 /** The most rooms one bulk request names. */
 const MAX_BULK_ROOMS = MAX_READ_ALL;
 
 export interface AppApiOptions {
 	/** The host's wording: a refusal reaches a client of the API in this locale when the catalog has it. */
 	presentation?: ConsolePresentation;
+	/** The host's IANA time zone, for the date in a zip's name; absent = UTC. */
+	timeZone?: string;
 	surface: AppSurface;
 	rooms: Rooms;
 	log: Pick<RoomLog, "page" | "lastOf" | "removeRoom" | "get" | "startOver">;
@@ -489,6 +514,8 @@ export class AppApi {
 				throw notFound();
 			return json({ ok: true });
 		}
+		if (area === "files" && method === "GET" && id === "zip" && !action)
+			return await this.#messageZip(request, admission);
 		if (area === "files" && method === "GET" && id && !action)
 			return await this.#file(id, admission);
 		if (area === "workspace") return this.#workspace(request, parts, admission);
@@ -633,7 +660,10 @@ export class AppApi {
 			const cursor = await reads?.cursorOf(room.key, self);
 			return json({
 				...page,
-				messages: withExpiredFiles(page.messages, this.#options.files),
+				messages: withExpiredFiles(
+					page.messages.map((one) => this.#options.surface.delivery.shown(one)),
+					this.#options.files,
+				),
 				cards: await cards.during(room.key, {
 					...(first && (page.more || isStartOver(first))
 						? { from: first.at }
@@ -867,6 +897,16 @@ export class AppApi {
 
 	async #file(id: string, admission: Authenticated): Promise<Response> {
 		if (!isFileId(id)) throw notFound();
+		await this.#mayServe(id, admission);
+		const { files } = this.#options;
+		const meta = files.meta(id);
+		const blob = files.blob(id);
+		if (!meta || !blob) throw notFound();
+		return fileResponse(meta, blob);
+	}
+
+	/** Refuses, as a missing file, a stored file the visitor may not be served. */
+	async #mayServe(id: string, admission: Authenticated): Promise<void> {
 		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;
@@ -877,10 +917,62 @@ export class AppApi {
 			!(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);
+	}
+
+	/**
+	 * `GET api/files/zip?room=<room>&message=<id>`: the message's files still kept, as one zip.
+	 * The room and every file answer as the single file does; a refusal is a missing message.
+	 */
+	async #messageZip(
+		request: Request,
+		admission: Authenticated,
+	): Promise<Response> {
+		const params = new URL(request.url).searchParams;
+		const room = params.get("room") ?? "";
+		const id = Number(params.get("message"));
+		if (room === "" || !Number.isSafeInteger(id) || id <= 0) throw notFound();
+		const { files, host, log } = this.#options;
+		const mayReadRoom =
+			admission.visitor.tier === "owner" ||
+			(host !== undefined &&
+				(await host.mayRead(viewerOf(admission.visitor), room)));
+		if (!mayReadRoom) throw notFound();
+		const message = await log.get(room, id);
+		if (!message) throw notFound();
+		// Only the files still kept: a swept file has no binding left to check it by.
+		const kept = message.files.flatMap((file) => {
+			const meta = isFileId(file.id) ? files.meta(file.id) : undefined;
+			const blob = meta && files.blob(file.id);
+			return meta && blob ? [{ id: file.id, meta, blob }] : [];
+		});
+		for (const file of kept) await this.#mayServe(file.id, admission);
+		if (kept.length === 0)
+			throw new HttpError(
+				404,
+				"None of this message's files are kept any more.",
+			);
+		const total = kept.reduce((sum, { blob }) => sum + blob.size, 0);
+		if (total > MAX_ZIP_BYTES)
+			throw new HttpError(
+				413,
+				"These files are too large to download together; download them one by one.",
+			);
+		const names = uniqueNames(kept.map(({ meta }) => meta.name));
+		const entries = await Promise.all(
+			kept.map(async ({ blob }, i) => ({
+				name: names[i] ?? "file",
+				data: new Uint8Array(await blob.arrayBuffer()),
+			})),
+		);
+		const at = new Date(message.at);
+		return new Response(zipStore(entries, at), {
+			headers: {
+				"content-type": "application/zip",
+				"content-disposition": `attachment; filename="${zipName(at, this.#options.timeZone)}"`,
+				"cache-control": "private, no-store",
+				"x-content-type-options": "nosniff",
+			},
+		});
 	}
 
 	/** The workspace files pane's API; every call, a read too, is an owner's. */

package/src/app/socket.ts

@@ -26,6 +26,8 @@ import type { PluggedFrames, Viewer, WebAppRegistry } from "../web-app.ts";
 import type { Answerer, OwnerDesk } from "./desk.ts";
 import type { Presence } from "./presence.ts";
 import { parseClientFrame } from "./protocol.ts";
+import { coreMessageId } from "./queued-delivery.ts";
+import { changeQueued } from "./queued-frames.ts";
 import type { Rooms } from "./rooms.ts";
 import type { AppSocket, Audience, Sockets } from "./sockets.ts";
 import type { AppSurface } from "./surface.ts";
@@ -65,7 +67,7 @@ export interface SocketRouteOptions {
 	 * not: the pieces of the app send what is per person there, such as the notices and the badge.
 	 */
 	opened?(connection: AppSocket): Promise<void>;
-	conversations: Pick<ConversationPort, "stop">;
+	conversations: Pick<ConversationPort, "stop" | "cancelQueued" | "editQueued">;
 	logger: Logger;
 	/**
 	 * The longest a socket stays open, whatever its credential says. A password session lives for
@@ -443,6 +445,14 @@ export class SocketRoute {
 				else conversations.stop(room.key);
 				break;
 			}
+			case "edit_queued":
+			case "cancel_queued":
+				refused = await changeQueued(frame, who, {
+					rooms,
+					surface: this.#options.surface,
+					conversations,
+				});
+				break;
 			case "approval":
 			case "answer":
 			case "answers":
@@ -658,7 +668,7 @@ export class SocketRoute {
 		stored?.(message);
 		const inbound: InboundMessage = {
 			channel: room,
-			messageId: `app-${message.id}`,
+			messageId: coreMessageId(message.id),
 			actor: who.actor,
 			authorId: who.principalId,
 			authorName: who.name,

package/src/app/surface.ts

@@ -22,6 +22,7 @@ import {
 } from "../api-types.ts";
 import type { OwnerDesk } from "./desk.ts";
 import { type FileBinding, type FileDir, typeByName } from "./files.ts";
+import { QueuedDelivery } from "./queued-delivery.ts";
 import type { NewRoomMessage, RoomLog } from "./room-log.ts";
 import type { AppSocket, Audience, Sockets } from "./sockets.ts";
 import { AppSurfaceThreads } from "./surface-threads.ts";
@@ -118,6 +119,8 @@ export class AppSurface implements ChatSurface {
 	/** Present on a surface with host rooms: what was said in one since the assistant last posted. */
 	channelContext?: ChatSurface["channelContext"];
 	readonly threads: AppSurfaceThreads;
+	/** How the messages sent during a turn stand: steered, queued, cancelled. */
+	readonly delivery: QueuedDelivery;
 	readonly #options: AppSurfaceOptions;
 	readonly #activity = new Map<ChannelKey, Activity>();
 	/** The round each group room runs now; an ended round is dropped, since the page keeps what it was told. */
@@ -132,6 +135,11 @@ export class AppSurface implements ChatSurface {
 		this.surface = options.surface;
 		this.maxAttachmentBytes = options.uploads.maxBytes;
 		this.#options = options;
+		this.delivery = new QueuedDelivery({
+			log: options.log,
+			isHostRoom: options.isHostRoom,
+			show: (stored) => this.#showChange(stored),
+		});
 		if (options.channelContext) this.channelContext = options.channelContext;
 		this.threads = new AppSurfaceThreads({
 			surface: options.surface,
@@ -168,7 +176,7 @@ export class AppSurface implements ChatSurface {
 
 	/** Stores a message of a room and shows it to the sockets that may have the room, except `except`. */
 	async publish(row: NewRoomMessage, except?: AppSocket): Promise<RoomMessage> {
-		const message = await this.#options.log.append(row);
+		const message = this.delivery.shown(await this.#options.log.append(row));
 		this.#options.sockets.deliver(
 			this.#options.isHostRoom(row.room)
 				? { type: "host_message", room: row.room, message }
@@ -180,17 +188,40 @@ export class AppSurface implements ChatSurface {
 	}
 
 	/** Changes the text of a stored message and shows the change to the sockets that may have the room. */
-	async edit(room: ChannelKey, id: number, text: string): Promise<void> {
-		const message = await this.#options.log.edit(room, id, text);
-		if (!message) return;
+	async edit(
+		room: ChannelKey,
+		id: number,
+		text: string,
+		mark = false,
+	): Promise<void> {
+		const stored = await this.#options.log.edit(room, id, text, mark);
+		if (stored) this.#showChange(stored);
+	}
+
+	/** Shows a stored message as it is now to the sockets that may have its room. */
+	#showChange(stored: RoomMessage): void {
+		const { room } = stored;
+		const message = this.delivery.shown(stored);
 		this.#options.sockets.deliver(
 			this.#options.isHostRoom(room)
-				? { type: "host_edited", room: message.room, message }
-				: { type: "edited", room: message.room, message },
+				? { type: "host_edited", room, message }
+				: { type: "edited", room, message },
 			this.#options.audienceOf(room),
 		);
 	}
 
+	react(channel: ChannelKey, messageId: string, emoji: string): Promise<void> {
+		return this.delivery.react(channel, messageId, emoji);
+	}
+
+	unreact(
+		channel: ChannelKey,
+		messageId: string,
+		emoji: string,
+	): Promise<void> {
+		return this.delivery.unreact(channel, messageId, emoji);
+	}
+
 	/** Whether a turn works in the room and whether Stop applies, as `activity` frames say. */
 	activityOf(room: ChannelKey): RoomActivity {
 		const found = this.#activity.get(room);

package/src/app/zip.ts

@@ -0,0 +1,124 @@
+/** One file of a zip: the name it is stored under and its bytes. */
+export interface ZipEntry {
+	name: string;
+	data: Uint8Array;
+}
+
+/** General purpose flag bit 11: the entry's name is UTF-8. */
+const UTF8_NAME = 0x0800;
+/** The version a store-only, UTF-8-named entry needs: 2.0. */
+const VERSION = 20;
+/** "Made by" Unix, spec 2.0: unzip then reads names as they are instead of as a DOS code page. */
+const MADE_BY = (3 << 8) | VERSION;
+/** A regular file readable by all, writable by its owner, in the Unix half of the attributes. */
+const FILE_MODE = 0o100644 << 16;
+/** The most bytes or entries a zip without the 64-bit extension can describe. */
+const MAX_BYTES = 0xffff_ffff;
+const MAX_ENTRIES = 0xffff;
+
+/** The DOS date and time of `at`, as zip headers keep them, in UTC. */
+function dosTime(at: Date): { time: number; date: number } {
+	const year = Math.max(at.getUTCFullYear(), 1980);
+	return {
+		time:
+			(at.getUTCHours() << 11) |
+			(at.getUTCMinutes() << 5) |
+			Math.floor(at.getUTCSeconds() / 2),
+		date:
+			((year - 1980) << 9) | ((at.getUTCMonth() + 1) << 5) | at.getUTCDate(),
+	};
+}
+
+/**
+ * Packs the entries into one zip, stored without compression: a local header and the bytes of
+ * each entry, then the central directory that lists them. Throws past what a zip without the
+ * 64-bit extension holds; the caller caps the total well below that.
+ */
+export function zipStore(
+	entries: readonly ZipEntry[],
+	at = new Date(),
+): Uint8Array {
+	if (entries.length > MAX_ENTRIES)
+		throw new Error("too many files for one zip");
+	const encoder = new TextEncoder();
+	const { time, date } = dosTime(at);
+	const locals: Uint8Array[] = [];
+	const centrals: Uint8Array[] = [];
+	let offset = 0;
+	for (const entry of entries) {
+		const name = encoder.encode(entry.name);
+		const crc = Bun.hash.crc32(entry.data);
+		const size = entry.data.byteLength;
+		if (size > MAX_BYTES || offset > MAX_BYTES)
+			throw new Error("the files are too large for one zip");
+		const local = new Uint8Array(30 + name.byteLength);
+		const l = new DataView(local.buffer);
+		l.setUint32(0, 0x04034b50, true);
+		l.setUint16(4, VERSION, true);
+		l.setUint16(6, UTF8_NAME, true);
+		l.setUint16(8, 0, true);
+		l.setUint16(10, time, true);
+		l.setUint16(12, date, true);
+		l.setUint32(14, crc, true);
+		l.setUint32(18, size, true);
+		l.setUint32(22, size, true);
+		l.setUint16(26, name.byteLength, true);
+		l.setUint16(28, 0, true);
+		local.set(name, 30);
+		const central = new Uint8Array(46 + name.byteLength);
+		const c = new DataView(central.buffer);
+		c.setUint32(0, 0x02014b50, true);
+		c.setUint16(4, MADE_BY, true);
+		c.setUint16(6, VERSION, true);
+		c.setUint16(8, UTF8_NAME, true);
+		c.setUint16(10, 0, true);
+		c.setUint16(12, time, true);
+		c.setUint16(14, date, true);
+		c.setUint32(16, crc, true);
+		c.setUint32(20, size, true);
+		c.setUint32(24, size, true);
+		c.setUint16(28, name.byteLength, true);
+		// Extra and comment lengths, disk number and internal attributes stay 0.
+		c.setUint32(38, FILE_MODE >>> 0, true);
+		c.setUint32(42, offset, true);
+		central.set(name, 46);
+		locals.push(local, entry.data);
+		centrals.push(central);
+		offset += local.byteLength + size;
+	}
+	const directorySize = centrals.reduce(
+		(sum, part) => sum + part.byteLength,
+		0,
+	);
+	if (offset + directorySize > MAX_BYTES)
+		throw new Error("the files are too large for one zip");
+	const end = new Uint8Array(22);
+	const e = new DataView(end.buffer);
+	e.setUint32(0, 0x06054b50, true);
+	e.setUint16(8, entries.length, true);
+	e.setUint16(10, entries.length, true);
+	e.setUint32(12, directorySize, true);
+	e.setUint32(16, offset, true);
+	const out = new Uint8Array(offset + directorySize + end.byteLength);
+	let cursor = 0;
+	for (const part of [...locals, ...centrals, end]) {
+		out.set(part, cursor);
+		cursor += part.byteLength;
+	}
+	return out;
+}
+
+/** The names made unique the way a download folder does: `a.pdf`, `a-2.pdf`, `a-3.pdf`. */
+export function uniqueNames(names: readonly string[]): string[] {
+	const taken = new Set<string>();
+	return names.map((name) => {
+		const dot = name.lastIndexOf(".");
+		const [stem, ext] =
+			dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+		let candidate = name;
+		for (let n = 2; taken.has(candidate.toLowerCase()); n++)
+			candidate = `${stem}-${n}${ext}`;
+		taken.add(candidate.toLowerCase());
+		return candidate;
+	});
+}

package/src/auth/sessions.ts

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import type { SQL } from "bun";
 import type { ActorFacts, Migration } from "pi-roundtable";
+import { jsonValuesMigration } from "../host/stored-json.ts";
 
 /** A session's idle limit slides at most this often, so a busy page costs no write per request. */
 const SLIDE_AFTER_MS = 3_600_000;
@@ -84,6 +85,13 @@ export class WebSessions {
 		this.#options = options;
 	}
 
+	/** Its jsonb columns stored as the JSON values themselves, not as the text of them. */
+	static readonly jsonValuesMigration: Migration = jsonValuesMigration(
+		"web-sessions-json-values",
+		"web_sessions",
+		["actor"],
+	);
+
 	static readonly migration: Migration = {
 		name: "web-sessions",
 		up: async (sql) => {
@@ -120,7 +128,7 @@ export class WebSessions {
 		const expires = this.#limit(now);
 		await this.#sql`
 			INSERT INTO web_sessions (id_hash, principal_id, actor, created_at, last_seen_at, verified_at, expires_at)
-			VALUES (${hashOf(token)}, ${principalId}, ${JSON.stringify(actor)}::jsonb, ${now}, ${now}, ${now}, ${expires})`;
+			VALUES (${hashOf(token)}, ${principalId}, ${JSON.stringify(actor)}::text::jsonb, ${now}, ${now}, ${now}, ${expires})`;
 		return {
 			token,
 			session: {

package/src/host/cards.ts

@@ -1,7 +1,7 @@
 import type { SQL } from "bun";
 import type { Migration } from "pi-roundtable";
 import type { HostCard, StoredHostCard } from "../web-app.ts";
-import { storedJson } from "./stored-json.ts";
+import { jsonValuesMigration, storedJson } from "./stored-json.ts";
 
 interface Row {
 	id: string;
@@ -33,6 +33,13 @@ export class HostCardLog {
 		this.#sql = sql;
 	}
 
+	/** Its jsonb columns stored as the JSON values themselves, not as the text of them. */
+	static readonly jsonValuesMigration: Migration = jsonValuesMigration(
+		"web-host-cards-json-values",
+		"web_host_cards",
+		["card"],
+	);
+
 	static readonly migration: Migration = {
 		name: "web-host-cards",
 		up: async (sql) => {
@@ -62,7 +69,7 @@ export class HostCardLog {
 		const id = crypto.randomUUID();
 		const [row]: Row[] = await this.#sql`
 			INSERT INTO web_host_cards (id, room, card, state, keep)
-			VALUES (${id}, ${room}, ${JSON.stringify(card)}::jsonb, ${card.state ?? null}, ${card.keep === true})
+			VALUES (${id}, ${room}, ${JSON.stringify(card)}::text::jsonb, ${card.state ?? null}, ${card.keep === true})
 			RETURNING *`;
 		if (!row) throw new Error("the card log stored nothing");
 		return cardOf(row);
@@ -76,7 +83,7 @@ export class HostCardLog {
 	): Promise<StoredHostCard | undefined> {
 		const [row]: Row[] = await this.#sql`
 			UPDATE web_host_cards
-			SET card = ${JSON.stringify(card)}::jsonb, state = ${card.state ?? null}, keep = ${card.keep === true}, updated_at = now()
+			SET card = ${JSON.stringify(card)}::text::jsonb, state = ${card.state ?? null}, keep = ${card.keep === true}, updated_at = now()
 			WHERE id = ${id} AND room = ${room} RETURNING *`;
 		return row && cardOf(row);
 	}

package/src/host/stored-json.ts

@@ -1,3 +1,5 @@
+import type { Migration } from "pi-roundtable";
+
 /**
  * A jsonb value as the driver returned it: already an object, or the text of one when the
  * driver left it as text. Anything else the database holds here is a stored value gone wrong,
@@ -11,3 +13,24 @@ export function storedJson<T>(value: T | string, what: string): T {
 		throw new Error(`the stored ${what} is not valid JSON`);
 	}
 }
+
+/**
+ * Turns the jsonb columns that hold the text of a value, as a JSON string, into the value
+ * itself. Inserts once bound `${JSON.stringify(x)}::jsonb`, which Postgres stores as a jsonb
+ * string; none of these columns holds a string on purpose.
+ */
+export function jsonValuesMigration(
+	name: string,
+	table: string,
+	columns: readonly string[],
+): Migration {
+	return {
+		name,
+		up: async (sql) => {
+			for (const column of columns)
+				await sql.unsafe(
+					`UPDATE ${table} SET ${column} = (${column} #>> '{}')::jsonb WHERE jsonb_typeof(${column}) = 'string'`,
+				);
+		},
+	};
+}

package/src/i18n/zh-tw.ts

@@ -601,6 +601,10 @@ export const ZH_TW: Readonly<Record<string, string>> = {
 	"Quote reply": "引用回覆",
 	"Select text": "選取文字",
 	"Copy all": "全部複製",
+	"Its turn has already started, so it can no longer be changed.":
+		"這一輪已經開始，無法再更改。",
+	"Added to this turn": "已插入這一輪",
+	Queued: "排隊中",
 	Share: "分享",
 	"Knight profile": "騎士資料",
 	"Copy details": "複製細節",
@@ -675,6 +679,8 @@ export const ZH_TW: Readonly<Record<string, string>> = {
 	"Next room with unread messages": "下一個有未讀訊息的聊天室",
 	"Close the open menu or sheet, or leave the message box":
 		"關閉開啟的選單或面板；都沒有時離開訊息輸入框",
+	"Edit your latest message that is still waiting, from an empty message box":
+		"在空的訊息輸入框編輯你最新一則還在排隊的訊息",
 	"Show these shortcuts": "顯示這份快速鍵清單",
 	"In a message box the arrow shortcuts switch rooms only when it is empty or the caret is at its very start (up) or very end (down).":
 		"在訊息輸入框裡，方向鍵快速鍵只在框內沒有文字，或游標在最開頭（上）、最結尾（下）時才會切換聊天室。",
@@ -835,6 +841,10 @@ export const ZH_TW: Readonly<Record<string, string>> = {
 	// 伺服器回應
 	"There is no such room, knight or file.": "找不到這個聊天室、騎士或檔案。",
 	"The body is too large.": "內容太大。",
+	"None of this message's files are kept any more.":
+		"這則訊息的檔案都已不再保留。",
+	"These files are too large to download together; download them one by one.":
+		"這些檔案太大，無法一起下載；請逐一下載。",
 	"The body is not JSON.": "內容不是 JSON。",
 	"The body is not an object.": "內容不是物件。",
 	"Only an owner may do this.": "只有擁有者可以這麼做。",
@@ -1265,6 +1275,10 @@ export const ZH_TW: Readonly<Record<string, string>> = {
 	edited: "已編輯",
 	"{count} file was removed": "已移除 {count} 個檔案",
 	"{count} files were removed": "已移除 {count} 個檔案",
+	"Attachments ({count})": "附件（{count}）",
+	"Download all": "全部下載",
+	"{count} attachment": "{count} 個附件",
+	"{count} attachments": "{count} 個附件",
 	"{count} unread message": "{count} 則未讀訊息",
 	"{count} unread messages": "{count} 則未讀訊息",
 	"New messages": "新訊息",

package/src/notices/mount.ts

@@ -37,6 +37,7 @@ import { NoticeStore } from "./store.ts";
 /** The tables of notices, push delivery, preferences and waivers. */
 export const NOTICE_MIGRATIONS: readonly Migration[] = [
 	NoticeStore.migration,
+	NoticeStore.jsonValuesMigration,
 	PushOutbox.migration,
 	PushPrefsStore.migration,
 	OnboardingWaivers.migration,

package/src/notices/store.ts

@@ -1,5 +1,6 @@
 import type { SQL } from "bun";
 import type { Migration } from "pi-roundtable";
+import { jsonValuesMigration } from "../host/stored-json.ts";
 import type { OpenTarget } from "../web-app.ts";
 
 /** Where a tap on a notice goes. */
@@ -85,6 +86,13 @@ export class NoticeStore {
 		this.#sql = sql;
 	}
 
+	/** Its jsonb columns stored as the JSON values themselves, not as the text of them. */
+	static readonly jsonValuesMigration: Migration = jsonValuesMigration(
+		"web-notices-json-values",
+		"web_notices",
+		["open"],
+	);
+
 	static readonly migration: Migration = {
 		name: "web-notices",
 		up: async (sql) => {
@@ -130,7 +138,7 @@ export class NoticeStore {
 			await tx`
 				INSERT INTO web_notices (tag, title, body, open, urgency, ackable)
 				VALUES (${notice.tag}, ${notice.title}, ${notice.body ?? null},
-					${notice.open ? JSON.stringify(notice.open) : null}::jsonb,
+					${notice.open ? JSON.stringify(notice.open) : null}::text::jsonb,
 					${notice.urgency}, ${notice.ackable})
 				ON CONFLICT (tag) DO UPDATE SET
 					title = EXCLUDED.title, body = EXCLUDED.body, open = EXCLUDED.open,