@acms-subir/core 0.3.52 → 0.3.54

package/src/lib/calendar/moves.ts

@@ -18,9 +18,9 @@
 // RSVP emails always go, because those people's own booking changed.
 import type { ContentRepository } from '../repo/types';
 import { EventLocation, type CalEvent, type MovedDate } from '../schema';
-import { ApiError } from '../api';
+import { ApiError, coded } from '../api';
 import { eventSideEffects, type SaveHooks } from '../content-service';
-import { addWallDays, addWallMinutes, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
+import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
 import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
 import { kickEmail } from '../email/service';
 import { waitUntilFrom } from '../webhooks';
@@ -47,6 +47,8 @@ export interface MoveInput {
 export interface MoveOptions {
   /** no app notice and no staff email (a sync catching up); RSVP emails still go */
   quiet?: boolean;
+  /** who to record as having moved it (MovedDate.by), when not the actor: the host whose request staff approved */
+  by?: string;
   now?: number;
 }
 export interface MoveResult {
@@ -62,10 +64,11 @@ export interface MoveResult {
  * repeating event), cancelled-event, not-a-date (the key isn't one of its
  * dates), cancelled-date, started (the date has started or passed),
  * original-passed (moving back to a time that has passed), past (the new time
- * has passed), bad-time, room-taken (a host, 409).
+ * has passed), bad-time, room-taken (a host, 409), room-not-allowed (a host
+ * picking a room the event doesn't use and nobody may request, 403).
  */
-export type MoveRefusal = 'one-off' | 'cancelled-event' | 'not-a-date' | 'cancelled-date' | 'started' | 'original-passed' | 'past' | 'bad-time' | 'room-taken';
-const refuse = (status: number, code: MoveRefusal, message: string) => Object.assign(new ApiError(status, message), { code });
+export type MoveRefusal = 'one-off' | 'cancelled-event' | 'not-a-date' | 'cancelled-date' | 'started' | 'original-passed' | 'past' | 'bad-time' | 'room-taken' | 'room-not-allowed';
+const refuse = (status: number, code: MoveRefusal, message: string) => coded(status, code, message);
 
 const DAY = 86_400_000;
 const NOTE_MAX = 500;
@@ -73,16 +76,16 @@ const NOTE_MAX = 500;
 type Role = 'staff' | 'host';
 function roleOf(actor: MoveActor | null, e: CalEvent): Role {
   if (actor === GOOGLE_SYNC) return 'staff';
-  if (!actor) throw new ApiError(401, 'Sign in to continue.');
+  if (!actor) throw coded(401, 'sign-in', 'Sign in to continue.');
   if (actor.can('content.edit')) return 'staff';
   if (e.hostIds.includes(actor.id)) return 'host';
-  throw new ApiError(404, 'Event not found.');
+  throw coded(404, 'not-found', 'Event not found.');
 }
 const actorId = (actor: MoveActor) => (actor === GOOGLE_SYNC ? GOOGLE_SYNC : actor.id);
 
 async function load(repo: ContentRepository, id: string) {
   const e = await repo.getEvent(id);
-  if (!e || e.status === 'archived') throw new ApiError(404, 'Event not found.');
+  if (!e || e.status === 'archived') throw coded(404, 'not-found', 'Event not found.');
   return e;
 }
 
@@ -137,7 +140,7 @@ async function refuseForHost(repo: ContentRepository, clashes: BusySlot[]) {
   const names = new Map((await repo.listResources()).map((r) => [r.id, r.name]));
   const rooms = [...new Set(clashes.map((c) => names.get(c.resourceId) ?? 'The room'))];
   const list = rooms.length > 1 ? `${rooms.slice(0, -1).join(', ')} and ${rooms[rooms.length - 1]}` : rooms[0];
-  throw refuse(409, 'room-taken', `${list} ${rooms.length > 1 ? 'are' : 'is'} taken at that time. Pick another time${rooms.length ? ' or room' : ''}, or ask the team.`);
+  throw Object.assign(refuse(409, 'room-taken', `${list} ${rooms.length > 1 ? 'are' : 'is'} taken at that time. Pick another time${rooms.length ? ' or room' : ''}, or ask the team.`), { rooms });
 }
 
 const sameRooms = (a: string[] | undefined, b: string[]) => a !== undefined && a.length === b.length && a.every((x, i) => x === b[i]);
@@ -145,14 +148,15 @@ const sameRooms = (a: string[] | undefined, b: string[]) => a !== undefined && a
 const sameMove = (a: MovedDate, b: MovedDate) => a.start === b.start && a.end === b.end && a.note === b.note
   && JSON.stringify(a.roomIds ?? null) === JSON.stringify(b.roomIds ?? null) && JSON.stringify(a.location ?? null) === JSON.stringify(b.location ?? null);
 
-/**
- * Move one date of a repeating event to a new time (and maybe other rooms or
- * another place). Moving an already moved date replaces its move; moving it
- * back to exactly where it was is moveOccurrenceBack. Moving it to where it
- * already is changes nothing (`changed: false`): retries never email twice.
- */
-export async function moveOccurrence(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, input: MoveInput, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
-  const now = opts.now ?? Date.now();
+// What a move would do, checked but not written: the same refusals as
+// moveOccurrence, except a host's taken room, which comes back as clashes
+type MovePlan =
+  | { kind: 'same'; e: CalEvent }
+  | { kind: 'isBack' }
+  | { kind: 'move'; e: CalEvent; role: Role; settings: Settings; current: Occurrence; next: CalEvent; note: string; clashes: BusySlot[] };
+type Settings = Awaited<ReturnType<ContentRepository['getSettings']>>;
+
+async function planMove(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, input: MoveInput, now: number, by?: string): Promise<MovePlan> {
   const e = await load(repo, id);
   const role = roleOf(actor, e);
   const settings = await repo.getSettings();
@@ -162,8 +166,14 @@ export async function moveOccurrence(repo: ContentRepository, actor: MoveActor |
 
   let roomIds = input.roomIds === undefined ? prior?.roomIds : [...new Set(input.roomIds)];
   if (roomIds !== undefined) {
-    const known = new Set((await repo.listResources()).map((r) => r.id));
+    const resources = await repo.listResources();
+    const known = new Set(resources.map((r) => r.id));
     roomIds = roomIds.filter((r) => known.has(r));
+    // hosts pick among the rooms the series already uses and the ones anyone may ask for
+    if (role === 'host') {
+      const allowed = new Set([...eventRoomIds(e), ...resources.filter((r) => r.requestable).map((r) => r.id)]);
+      if (roomIds.some((r) => !allowed.has(r))) throw refuse(403, 'room-not-allowed', 'Pick from the rooms this event uses, or ask the team for another room.');
+    }
     // the event's own rooms aren't an override
     if (sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
   }
@@ -172,34 +182,29 @@ export async function moveOccurrence(repo: ContentRepository, actor: MoveActor |
   if (location && JSON.stringify(location) === JSON.stringify(e.location)) location = undefined;
   const note = input.note === undefined ? prior?.note ?? '' : String(input.note).replace(/\s+/g, ' ').trim().slice(0, NOTE_MAX);
 
-  const entry: MovedDate = { start: times.start, end: times.end, ...(roomIds ? { roomIds } : {}), ...(location ? { location } : {}), note, by: actorId(actor!), at: now };
-  if (prior && sameMove(prior, entry)) return { event: e, clashes: [], changed: false };
+  const entry: MovedDate = { start: times.start, end: times.end, ...(roomIds ? { roomIds } : {}), ...(location ? { location } : {}), note, by: by || actorId(actor!), at: now };
+  if (prior && sameMove(prior, entry)) return { kind: 'same', e };
   const at = movedInstants(e, entry, settings);
   if (!at) throw refuse(400, 'bad-time', 'Pick a valid time.');
 
   // back where the series puts it, with nothing else different: that's moving it back
   const series = findOccurrence({ ...e, movedDates: {} }, key, settings)!;
-  if (at.start === series.start && at.end === series.end && !roomIds && !location) return moveOccurrenceBack(repo, actor, id, key, hooks, opts);
+  if (at.start === series.start && at.end === series.end && !roomIds && !location) return { kind: 'isBack' };
   if (current.start <= now) throw started();
   if (at.start <= now) throw refuse(400, 'past', 'Pick a time that hasn’t passed yet.');
 
   const next: CalEvent = { ...e, movedDates: { ...e.movedDates, [key]: entry } };
-  const clashes = await clashesFor(repo, next, key, at, settings);
-  if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
-
-  await repo.setEventMovedDates(id, next.movedDates, undefined, { quiet: opts.quiet });
-  const after = (await repo.getEvent(id))!;
-  const moved = findOccurrence(after, key, settings)!;
-  await afterChange(repo, after, current, moved, { role, actor: actor!, note, hooks, opts, settings });
-  return { event: after, clashes, changed: true };
+  return { kind: 'move', e, role, settings, current, next, note, clashes: await clashesFor(repo, next, key, at, settings) };
 }
 
-/** Put a moved date back where the series has it (idempotent: a date that isn't moved is `changed: false`). Hosts are refused if its rooms are taken there now. */
-export async function moveOccurrenceBack(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
-  const now = opts.now ?? Date.now();
+type BackPlan =
+  | { kind: 'same'; e: CalEvent }
+  | { kind: 'back'; e: CalEvent; role: Role; settings: Settings; rest: CalEvent['movedDates']; current: Occurrence | null; back: Occurrence | null; clashes: BusySlot[] };
+
+async function planBack(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, now: number): Promise<BackPlan> {
   const e = await load(repo, id);
   const role = roleOf(actor, e);
-  if (!Object.hasOwn(e.movedDates, key)) return { event: e, clashes: [], changed: false };
+  if (!Object.hasOwn(e.movedDates, key)) return { kind: 'same', e };
   const settings = await repo.getSettings();
   const { [key]: _gone, ...rest } = e.movedDates;
   const next: CalEvent = { ...e, movedDates: rest };
@@ -211,6 +216,49 @@ export async function moveOccurrenceBack(repo: ContentRepository, actor: MoveAct
     if (back.start <= now) throw refuse(400, 'original-passed', 'Its original time has already passed.');
   }
   const clashes = back ? await clashesFor(repo, next, key, back, settings) : [];
+  return { kind: 'back', e, role, settings, rest, current, back, clashes };
+}
+
+/** What moveOccurrence (or, `input` null, moveOccurrenceBack) would do, without doing it: the same refusals, except that a host's taken room comes back in `clashes` instead of a 409. A move gives the date's new wall times and note too. */
+export async function checkMove(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, input: MoveInput | null, opts: Pick<MoveOptions, 'now'> = {}): Promise<{ clashes: BusySlot[]; changed: boolean; back?: boolean; start?: string; end?: string; note?: string }> {
+  const now = opts.now ?? Date.now();
+  const plan = input ? await planMove(repo, actor, id, key, input, now) : await planBack(repo, actor, id, key, now);
+  if (plan.kind === 'same') return { clashes: [], changed: false };
+  // a move to where the series has it is a move back
+  if (plan.kind === 'isBack') return { ...(await checkMove(repo, actor, id, key, null, opts)), back: true };
+  if (plan.kind === 'move') {
+    const m = plan.next.movedDates[key];
+    return { clashes: plan.clashes, changed: true, start: m.start, end: m.end, note: m.note };
+  }
+  return { clashes: plan.clashes, changed: true };
+}
+
+/**
+ * Move one date of a repeating event to a new time (and maybe other rooms or
+ * another place). Moving an already moved date replaces its move; moving it
+ * back to exactly where it was is moveOccurrenceBack. Moving it to where it
+ * already is changes nothing (`changed: false`): retries never email twice.
+ * Hosts pick rooms among the event's own and the requestable ones.
+ */
+export async function moveOccurrence(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, input: MoveInput, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
+  const plan = await planMove(repo, actor, id, key, input, opts.now ?? Date.now(), opts.by);
+  if (plan.kind === 'same') return { event: plan.e, clashes: [], changed: false };
+  if (plan.kind === 'isBack') return moveOccurrenceBack(repo, actor, id, key, hooks, opts);
+  const { role, settings, current, next, note, clashes } = plan;
+  if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
+
+  await repo.setEventMovedDates(id, next.movedDates, undefined, { quiet: opts.quiet });
+  const after = (await repo.getEvent(id))!;
+  const moved = findOccurrence(after, key, settings)!;
+  await afterChange(repo, after, current, moved, { role, actor: actor!, note, hooks, opts, settings });
+  return { event: after, clashes, changed: true };
+}
+
+/** Put a moved date back where the series has it (idempotent: a date that isn't moved is `changed: false`). Hosts are refused if its rooms are taken there now. */
+export async function moveOccurrenceBack(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
+  const plan = await planBack(repo, actor, id, key, opts.now ?? Date.now());
+  if (plan.kind === 'same') return { event: plan.e, clashes: [], changed: false };
+  const { role, settings, rest, current, back, clashes } = plan;
   if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
   await repo.setEventMovedDates(id, rest, undefined, { quiet: opts.quiet });
   const after = (await repo.getEvent(id))!;

package/src/lib/calendar/request-migration.ts

@@ -0,0 +1,17 @@
+// v67: calendar requests on their own rows (RequestRecord in schema.ts,
+// stored by lib/calendar/request-store.ts). Not public (nothing here reaches
+// pages or the public API), so no content version or event_changes
+// triggers; included in backups. No imports: the CLI's migrate runner
+// bundles this file.
+export const REQUEST_TABLE = [
+  `CREATE TABLE event_requests (
+    id TEXT PRIMARY KEY, kind TEXT NOT NULL, state TEXT NOT NULL, source TEXT NOT NULL,
+    user_id TEXT NOT NULL DEFAULT '', requester TEXT,
+    event_id TEXT NOT NULL DEFAULT '', occurrence_key TEXT NOT NULL DEFAULT '',
+    data TEXT NOT NULL DEFAULT '{}', note TEXT NOT NULL DEFAULT '', reply TEXT NOT NULL DEFAULT '',
+    reviewed_by TEXT NOT NULL DEFAULT '', reviewed_at INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+  )`,
+  `CREATE INDEX event_requests_state ON event_requests (state, created_at)`,
+  `CREATE INDEX event_requests_event ON event_requests (event_id)`,
+];

package/src/lib/calendar/request-store.ts

@@ -0,0 +1,104 @@
+import type { SqlDriver, SqlStatement } from '../repo/sql';
+import { RequestRecord, type RequestKind, type RequestSource, type RequestState } from '../schema';
+
+// Storage for calendar requests kept on their own rows (RequestRecord in
+// schema.ts). Shared by the D1 and libSQL adapters (plain SQLite). The rules
+// (who may ask, approve or decline) live in lib/calendar/requests.ts.
+
+type Row = Record<string, unknown>;
+const json = (raw: unknown) => { try { return raw == null ? null : JSON.parse(String(raw)); } catch { return null; } };
+const record = (r: Row): RequestRecord => RequestRecord.parse({
+  id: r.id, kind: r.kind, state: r.state, source: r.source, userId: r.user_id, requester: json(r.requester),
+  eventId: r.event_id, key: r.occurrence_key, data: json(r.data) ?? {}, note: r.note, reply: r.reply,
+  reviewedBy: r.reviewed_by, reviewedAt: Number(r.reviewed_at), createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
+});
+
+/** The INSERT for one request (create and backup restore). */
+export const requestInsert = (q: RequestRecord): SqlStatement => ({
+  sql: `INSERT INTO event_requests (id,kind,state,source,user_id,requester,event_id,occurrence_key,data,note,reply,reviewed_by,reviewed_at,created_at,updated_at)
+    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+  args: [q.id, q.kind, q.state, q.source, q.userId, q.requester ? JSON.stringify(q.requester) : null, q.eventId, q.key,
+    JSON.stringify(q.data), q.note, q.reply, q.reviewedBy, q.reviewedAt, q.createdAt, q.updatedAt],
+});
+
+export interface RequestQuery {
+  states?: RequestState[];
+  kinds?: RequestKind[];
+  sources?: RequestSource[];
+  eventId?: string;
+  userId?: string;
+  /** 'oldest' / 'newest' by when they were sent; 'decided' = latest answer first */
+  order?: 'oldest' | 'newest' | 'decided';
+  /** -1 = all (backups) */
+  limit?: number;
+  offset?: number;
+}
+/** what changes when someone answers, withdraws or edits a request */
+export type RequestPatch = Partial<Pick<RequestRecord, 'state' | 'reply' | 'reviewedBy' | 'reviewedAt' | 'eventId' | 'data' | 'note'>>;
+const PATCH: [keyof RequestPatch, string][] = [
+  ['state', 'state'], ['reply', 'reply'], ['reviewedBy', 'reviewed_by'], ['reviewedAt', 'reviewed_at'], ['eventId', 'event_id'], ['data', 'data'], ['note', 'note'],
+];
+
+function where(q: RequestQuery) {
+  const sql: string[] = [], args: unknown[] = [];
+  const any = (col: string, values?: string[]) => {
+    if (values === undefined) return;
+    // an empty list matches nothing
+    sql.push(values.length ? `${col} IN (${values.map(() => '?').join(',')})` : '0');
+    args.push(...values);
+  };
+  any('state', q.states); any('kind', q.kinds); any('source', q.sources);
+  if (q.eventId !== undefined) { sql.push('event_id=?'); args.push(q.eventId); }
+  if (q.userId !== undefined) { sql.push('user_id=?'); args.push(q.userId); }
+  return { sql: sql.length ? `WHERE ${sql.join(' AND ')}` : '', args };
+}
+const ORDER = { oldest: 'created_at ASC, id', newest: 'created_at DESC, id', decided: 'reviewed_at DESC, created_at DESC, id' };
+
+export class RequestStore {
+  constructor(private driver: () => Promise<SqlDriver>) {}
+  private async all(sql: string, args: unknown[] = []) { return (await this.driver()).all(sql, args); }
+
+  /** Saves a new request; null when one with this id exists already (an idempotent retry: read it with get). */
+  async create(q: RequestRecord): Promise<RequestRecord | null> {
+    const insert = requestInsert(RequestRecord.parse(q));
+    const rows = await this.all(`${insert.sql} ON CONFLICT(id) DO NOTHING RETURNING *`, insert.args);
+    return rows[0] ? record(rows[0]) : null;
+  }
+  async get(id: string): Promise<RequestRecord | null> {
+    const r = await this.all('SELECT * FROM event_requests WHERE id=?', [id]);
+    return r[0] ? record(r[0]) : null;
+  }
+  async list(q: RequestQuery = {}): Promise<RequestRecord[]> {
+    const w = where(q);
+    return (await this.all(`SELECT * FROM event_requests ${w.sql} ORDER BY ${ORDER[q.order ?? 'newest']} LIMIT ? OFFSET ?`,
+      [...w.args, q.limit ?? 100, q.offset ?? 0])).map(record);
+  }
+  async count(q: Pick<RequestQuery, 'states' | 'kinds' | 'sources' | 'eventId' | 'userId'> = {}): Promise<number> {
+    const w = where(q);
+    return Number((await this.all(`SELECT COUNT(*) AS n FROM event_requests ${w.sql}`, w.args))[0]?.n ?? 0);
+  }
+  /**
+   * Writes the given fields and bumps updatedAt (so a reviewer's `seen` guard
+   * notices an edit). `onlyIf` makes it a compare-and-set: null when the row
+   * is no longer in that state or was changed since `updatedAt`.
+   */
+  async update(id: string, patch: RequestPatch, onlyIf: { state?: RequestState; updatedAt?: number } = {}): Promise<RequestRecord | null> {
+    const set = PATCH.filter(([k]) => patch[k] !== undefined);
+    const args: unknown[] = set.map(([k]) => (k === 'data' ? JSON.stringify(patch.data) : patch[k]));
+    // strictly later than before, so two writes in one millisecond still differ
+    const sql = [...set.map(([, c]) => `${c}=?`), 'updated_at=MAX(?, updated_at + 1)'];
+    args.push(Date.now(), id);
+    const guard: string[] = [];
+    if (onlyIf.state) { guard.push('state=?'); args.push(onlyIf.state); }
+    if (onlyIf.updatedAt !== undefined) { guard.push('updated_at=?'); args.push(onlyIf.updatedAt); }
+    const rows = await this.all(`UPDATE event_requests SET ${sql.join(',')} WHERE id=?${guard.map((g) => ` AND ${g}`).join('')} RETURNING *`, args);
+    return rows[0] ? record(rows[0]) : null;
+  }
+  async delete(id: string): Promise<boolean> {
+    return (await this.all('DELETE FROM event_requests WHERE id=? RETURNING id', [id])).length > 0;
+  }
+  /** Deletes requests answered or withdrawn before `before` (ms); pending ones stay. Returns how many went. */
+  async prune(before: number): Promise<number> {
+    return (await this.all(`DELETE FROM event_requests WHERE state<>'pending' AND reviewed_at>0 AND reviewed_at<? RETURNING id`, [before])).length;
+  }
+}

package/src/lib/calendar/requests.ts

@@ -1,7 +1,7 @@
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent, EventRequest } from '../schema';
 import { EventLocation } from '../schema';
-import { ApiError } from '../api';
+import { ApiError, coded } from '../api';
 import { applyEventUpdate, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
 import { CALENDAR } from './config';
 import { cancelOccurrence, restoreOccurrence, uniqueSlug } from './schedule';
@@ -74,38 +74,38 @@ export function bodyToText(e: Pick<CalEvent, 'bodyHtml'>): string {
 }
 
 function requireMember(who: Actor | null): asserts who is Actor {
-  if (!who) throw new ApiError(401, 'Sign in to continue.');
-  if (!who.can('events.request')) throw new ApiError(403, 'Your role doesn’t include “Request events”. Ask the site’s team if you need it.');
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
+  if (!who.can('events.request')) throw coded(403, 'no-request-role', 'Your role doesn’t include “Request events”. Ask the site’s team if you need it.');
 }
 function requireApprover(who: Actor | null): asserts who is Actor {
-  if (!who) throw new ApiError(401, 'Sign in to continue.');
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
   if (!who.can('content.publish')) throw new ApiError(403, 'Your role doesn’t include “Publish content”, which approving requests needs.');
 }
 /** a host of this event, or the member who asked for it */
 export const isHost = (e: CalEvent, userId: string) => e.hostIds.includes(userId) || (e.request?.by === userId && e.request.kind === 'new');
 async function hostedEvent(repo: ContentRepository, who: Actor, id: string) {
   const e = await repo.getEvent(id);
-  if (!e || e.status === 'archived' || !isHost(e, who.id)) throw new ApiError(404, 'Event not found.');
+  if (!e || e.status === 'archived' || !isHost(e, who.id)) throw coded(404, 'not-found', 'Event not found.');
   return e;
 }
 
 /** the request form's input → event fields, validated (`current`: the event being edited, whose own values may be kept) */
 async function clean(repo: ContentRepository, input: EventRequestInput, current?: CalEvent) {
   const title = line(input.title, LIMITS.title);
-  if (!title) throw new ApiError(400, 'Give the event a title.');
+  if (!title) throw coded(400, 'title', 'Give the event a title.');
   const start = text(input.start, 16), allDay = input.allDay === true;
-  if (!(allDay ? /^\d{4}-\d{2}-\d{2}$/ : /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/).test(start)) throw new ApiError(400, 'Pick a date and start time.');
+  if (!(allDay ? /^\d{4}-\d{2}-\d{2}$/ : /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/).test(start)) throw coded(400, 'start', 'Pick a date and start time.');
   const end = text(input.end, 16);
-  if (end && !(allDay ? /^\d{4}-\d{2}-\d{2}$/ : /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/).test(end)) throw new ApiError(400, 'Pick a valid end time.');
-  if (end && end < start) throw new ApiError(400, 'The end has to come after the start.');
+  if (end && !(allDay ? /^\d{4}-\d{2}-\d{2}$/ : /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/).test(end)) throw coded(400, 'end', 'Pick a valid end time.');
+  if (end && end < start) throw coded(400, 'end-before-start', 'The end has to come after the start.');
   const rrule = text(input.repeat, 80).toUpperCase();
   // a pattern staff set (weekly on two days, yearly…) may be kept as it is
-  if (rrule && !REPEAT.test(rrule) && rrule !== current?.rrule.toUpperCase()) throw new ApiError(400, 'Choose how often it repeats from the list.');
+  if (rrule && !REPEAT.test(rrule) && rrule !== current?.rrule.toUpperCase()) throw coded(400, 'repeat', 'Choose how often it repeats from the list.');
   // members pick among the public calendars; any other calendars staff put it in stay
   const calendars = await repo.listCalendars();
   const open = new Set(calendars.filter((c) => c.kind === 'native' && c.visibility === 'public').map((c) => c.id));
   const chosen = input.calendarId ? String(input.calendarId) : '';
-  if (chosen && !open.has(chosen) && !current?.calendarIds.includes(chosen)) throw new ApiError(400, 'Choose a calendar from the list.');
+  if (chosen && !open.has(chosen) && !current?.calendarIds.includes(chosen)) throw coded(400, 'calendar', 'Choose a calendar from the list.');
   const calendarIds = current && (!chosen || current.calendarIds.includes(chosen))
     ? current.calendarIds
     : [...(current?.calendarIds ?? []).filter((id) => !open.has(id)), ...(chosen ? [chosen] : [])];
@@ -113,7 +113,7 @@ async function clean(repo: ContentRepository, input: EventRequestInput, current?
   for (const f of CALENDAR.eventFields) {
     if (f.private || input.fields?.[f.key] === undefined) continue;
     const value = text(input.fields[f.key], LIMITS.field);
-    if (f.type === 'select' && value && !f.options.includes(value)) throw new ApiError(400, `Choose ${f.label} from the list.`);
+    if (f.type === 'select' && value && !f.options.includes(value)) throw Object.assign(coded(400, 'field', `Choose ${f.label} from the list.`), { label: f.label });
     fields[f.key] = value; // '' clears it
   }
   return { title, start, end: end || undefined, allDay, rrule, calendarIds, fields, description: text(input.description, LIMITS.description), where: line(input.where, LIMITS.where) };
@@ -139,9 +139,9 @@ export async function pendingRequests(repo: ContentRepository): Promise<CalEvent
 /** a member asks for a new event: a draft they host, waiting for approval */
 export async function submitEventRequest(repo: ContentRepository, who: Actor | null, input: EventRequestInput, hooks: SaveHooks): Promise<CalEvent> {
   requireMember(who);
-  if (!await repo.email.rateLimit(`event-request:${who.id}`, 20, 3_600_000)) throw new ApiError(429, 'That’s a lot of requests in an hour. Try again later.', 3600);
+  if (!await repo.email.rateLimit(`event-request:${who.id}`, 20, 3_600_000)) throw coded(429, 'rate-limit', 'That’s a lot of requests in an hour. Try again later.', 3600);
   const open = (await hostedEvents(repo, who.id)).filter((e) => e.request?.state === 'pending').length;
-  if (open >= LIMITS.pending) throw new ApiError(429, 'You have many requests waiting already. Wait for the team to answer them first.');
+  if (open >= LIMITS.pending) throw coded(429, 'too-many-waiting', 'You have many requests waiting already. Wait for the team to answer them first.');
   const c = await clean(repo, input);
   const created = await repo.createEvent({
     title: c.title, slug: await uniqueSlug(repo, c.title), start: c.start, allDay: c.allDay, status: 'draft',
@@ -165,8 +165,8 @@ export async function updateEventRequest(repo: ContentRepository, who: Actor | n
   const e = await hostedEvent(repo, who, id);
   // staff have unpublished edits of their own on this live event: don't mix a
   // host's suggestion into them (declining it would throw both away)
-  if (live(e) && e.draft && !hostChanges(e)) throw new ApiError(409, 'The team is editing this event right now. Try again later.');
-  if (!await repo.email.rateLimit(`event-request:${who.id}`, 20, 3_600_000)) throw new ApiError(429, 'That’s a lot of changes in an hour. Try again later.', 3600);
+  if (live(e) && e.draft && !hostChanges(e)) throw coded(409, 'staff-editing', 'The team is editing this event right now. Try again later.');
+  if (!await repo.email.rateLimit(`event-request:${who.id}`, 20, 3_600_000)) throw coded(429, 'rate-limit', 'That’s a lot of changes in an hour. Try again later.', 3600);
   // what the host sees is the event with their own waiting changes on top
   const current = (hostChanges(e) ? { ...e, ...(e.draft ?? {}) } : e) as CalEvent;
   const c = await clean(repo, input, current);
@@ -186,7 +186,7 @@ export async function updateEventRequest(repo: ContentRepository, who: Actor | n
 export async function withdrawEventRequest(repo: ContentRepository, who: Actor | null, id: string, hooks: SaveHooks): Promise<{ deleted: boolean }> {
   requireMember(who);
   const e = await hostedEvent(repo, who, id);
-  if (!e.request) throw new ApiError(400, 'There’s no request on this event to withdraw.');
+  if (!e.request) throw coded(400, 'nothing-to-withdraw', 'There’s no request on this event to withdraw.');
   // only an event the member's own request made is deleted; a draft staff wrote stays
   if (e.request.kind === 'new' && e.request.created && !live(e) && !e.publishedAt) {
     await repo.deleteEvent(id);
@@ -201,8 +201,8 @@ export async function withdrawEventRequest(repo: ContentRepository, who: Actor |
 /** the request staff are answering, unchanged since they opened it (`seen`: its `at`) */
 async function answerable(repo: ContentRepository, id: string, seen?: number) {
   const e = await repo.getEvent(id);
-  if (!e?.request || e.request.state !== 'pending') throw new ApiError(409, 'This request was already answered or withdrawn.');
-  if (seen !== undefined && e.request.at !== seen) throw new ApiError(409, 'This request changed after you opened it. Look at it again, then answer.');
+  if (!e?.request || e.request.state !== 'pending') throw coded(409, 'answered', 'This request was already answered or withdrawn.');
+  if (seen !== undefined && e.request.at !== seen) throw coded(409, 'changed', 'This request changed after you opened it. Look at it again, then answer.');
   return e as CalEvent & { request: EventRequest };
 }
 
@@ -231,25 +231,25 @@ export async function declineEventRequest(repo: ContentRepository, who: Actor |
 
 /** a host clears a declined answer they've read (a declined new request stays as a draft) */
 export async function dismissEventRequest(repo: ContentRepository, who: Actor | null, id: string): Promise<void> {
-  if (!who) throw new ApiError(401, 'Sign in to continue.');
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
   const e = await hostedEvent(repo, who, id);
   if (e.request?.state === 'declined' && e.request.kind === 'changes') await repo.setEventRequest(id, null);
 }
 
 /** hosts cancel or restore one date of their own event at once (no permission needed beyond hosting it) */
 export async function setHostedOccurrence(repo: ContentRepository, who: Actor | null, id: string, key: string, cancelled: boolean, hooks: SaveHooks): Promise<CalEvent> {
-  if (!who) throw new ApiError(401, 'Sign in to continue.');
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
   const e = await hostedEvent(repo, who, id);
-  if (!e.hostIds.includes(who.id)) throw new ApiError(404, 'Event not found.');
+  if (!e.hostIds.includes(who.id)) throw coded(404, 'not-found', 'Event not found.');
   return (cancelled ? cancelOccurrence : restoreOccurrence)(repo, id, key, hooksFor(hooks));
 }
 
 /** staff set who hosts an event (Team members only) */
 export async function setEventHosts(repo: ContentRepository, who: Actor | null, id: string, hostIds: string[]): Promise<CalEvent> {
-  if (!who) throw new ApiError(401, 'Sign in to continue.');
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
   if (!who.can('content.edit')) throw new ApiError(403, 'Your role doesn’t include “Create and edit content”.');
   const e = await repo.getEvent(id);
-  if (!e) throw new ApiError(404, 'Event not found.');
+  if (!e) throw coded(404, 'not-found', 'Event not found.');
   const known = new Set((await repo.listUsers()).map((u) => u.id));
   const ids = [...new Set(hostIds)].filter((h) => known.has(h)).slice(0, 10);
   await repo.setEventHosts(id, ids);

package/src/lib/dynamicBlocks.ts

@@ -5,6 +5,7 @@ import { formatDate } from './dates';
 import { CONTENT, collectionUrl } from './content';
 import { renderCalendarBlock, isNativeSource } from './calendar/render';
 import { renderEventCards, type EventCardAttrs } from './calendar/cards';
+import { localePath } from './i18n';
 
 // Dynamic blocks: bodyHtml is a save-time cache, so cards whose content must
 // stay fresh (post lists, calendars) serialize as placeholder divs and get
@@ -131,7 +132,8 @@ function eventCardAttrs(tag: string): EventCardAttrs {
   };
 }
 
-export async function expandDynamicBlocks(html: string, repo: ContentRepository): Promise<string> {
+// locale: the page's language; a form block opens the form in it (/es/forms/<id>)
+export async function expandDynamicBlocks(html: string, repo: ContentRepository, locale = ''): Promise<string> {
   html = stampHeadingAnchors(html);
   const hasForms = html.includes('data-dyn="form"');
   const hasPostList = html.includes('data-dyn="post-list"');
@@ -168,7 +170,7 @@ export async function expandDynamicBlocks(html: string, repo: ContentRepository)
       // A same-origin frame gives each visitor an uncached form/receipt even
       // when the containing content page is served from a shared cache.
       calendarHtml.set(tag, form?.kind === 'form' && form.purpose === 'general' && form.status === 'published'
-        ? `<iframe class="pc-form-embed" src="/forms/${encodeURIComponent(form.id)}?embed=1" title="${esc(form.definition.title || form.name)}" loading="lazy"></iframe>` : '');
+        ? `<iframe class="pc-form-embed" src="${localePath(`/forms/${encodeURIComponent(form.id)}`, locale)}?embed=1" title="${esc(form.definition.title || form.name)}" loading="lazy"></iframe>` : '');
     }));
   }
   const anchored = html;

package/src/lib/email/service.ts

@@ -1,7 +1,7 @@
 import type { ContentRepository } from '../repo/types';
 import { resolveConfig, decrypt, encrypt, runtimeValue } from './config';
 import { sendWithProvider } from './providers';
-import { accountMail, canonicalOrigin, eventRequestMail, guestCodeMail, phoneLinkedMail, EmailLinkError } from './templates';
+import { accountMail, canonicalOrigin, eventRequestMail, guestCodeMail, phoneLinkedMail, EmailLinkError, type EventRequestMailKind } from './templates';
 import { formatDate, siteLang } from '../dates';
 import { I18N } from '../i18n';
 import { bookingMail } from '../booking/service';
@@ -47,9 +47,19 @@ async function render(repo: ContentRepository, job: EmailJob, locals?: unknown,
     return accountMail(payload.purpose, job.recipient, settings.siteTitle, `${origin}/account/${payload.purpose}?token=${encodeURIComponent(raw)}`);
   }
   if (job.kind === 'event-request') {
-    const p = JSON.parse(job.payload) as { eventId: string; kind: 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined'; at: number; reply: string; by?: string; note?: string; when?: string };
+    const p = JSON.parse(job.payload) as { eventId: string; requestId?: string; kind: EventRequestMailKind; at: number; reply: string; by?: string; note?: string; when?: string };
     const e = await repo.getEvent(p.eventId);
     if (!e) return null;
+    // a host's date request (lib/calendar/host-requests.ts): staff hear about it while it waits unchanged, the host about its answer
+    if (p.requestId) {
+      const r = await repo.requests.get(p.requestId);
+      const staff = p.kind.startsWith('staff');
+      if (!r || (staff ? r.state !== 'pending' || r.updatedAt !== p.at : r.state === 'pending' || r.state === 'withdrawn')) return null;
+      const by = r.userId ? await repo.getUser(r.userId) : null;
+      const { memberEventsPath, MEMBERS } = await import('../calendar/requests');
+      const url = staff ? `${origin}/admin/calendar/events?scope=requests` : `${origin}${MEMBERS.enabled ? memberEventsPath() : '/'}`;
+      return eventRequestMail(p.kind, job.recipient, settings.siteTitle, { title: e.title, when: p.when ?? '', by: by?.name ?? '', note: r.note }, p.reply, url);
+    }
     // a host moved one date (lib/calendar/moves.ts): the words were fixed when it happened
     if (p.kind === 'staff-moved') {
       const by = p.by ? await repo.getUser(p.by) : null;

package/src/lib/email/templates.ts

@@ -12,17 +12,27 @@ export function accountMail(kind: 'invite'|'reset'|'welcome'|'password-changed'|
   return { to, subject: `${copy[0]} · ${site}`, text: [copy[0], '', copy[1], ...(url ? ['',`${copy[2]}: ${url}`] : [])].join('\n'),
     html: `<!doctype html><html><body style="margin:0;background:#f6f5f2;color:#24211c;font:16px/1.6 system-ui,sans-serif"><div style="max-width:520px;margin:auto;padding:32px 24px"><p style="color:#7d776e">${escape(site)}</p><h1 style="font-size:24px">${escape(copy[0])}</h1><p>${escape(copy[1])}</p>${url ? `<p><a style="display:inline-block;background:#ee5d20;color:#fff;padding:10px 18px;border-radius:8px;text-decoration:none" href="${escape(url)}">${escape(copy[2])}</a></p>` : ''}</div></body></html>` };
 }
+/** the kinds of eventRequestMail */
+export type EventRequestMailKind = 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined'
+  | 'staff-move-request' | 'move-approved' | 'move-declined' | 'staff-from-date-request' | 'from-date-approved' | 'from-date-declined';
 /**
  * members' event requests (lib/calendar/requests.ts): to staff when one arrives, to the member when it's answered;
- * staff-moved: a host moved one date (lib/calendar/moves.ts), `when` = "old → new"
+ * staff-moved: a host moved one date (lib/calendar/moves.ts), `when` = "old → new";
+ * a host's date move or "from this date on" request (lib/calendar/host-requests.ts): to staff, then its answer to the host
  */
-export function eventRequestMail(kind: 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined', to: string, site: string, event: { title: string; when: string; by: string; note: string }, reply: string, url: string): Mail {
+export function eventRequestMail(kind: EventRequestMailKind, to: string, site: string, event: { title: string; when: string; by: string; note: string }, reply: string, url: string): Mail {
   const copy = {
     'staff-new': [`New event request: ${event.title}`, `${event.by || 'A member'} asked for “${event.title}” (${event.when}). It stays a draft until someone approves it.`, 'Review it'],
     'staff-changes': [`Changes to review: ${event.title}`, `${event.by || 'A host'} suggested changes to “${event.title}” (${event.when}). The live event stays as it is until someone approves them.`, 'Review the changes'],
     'staff-moved': [`Date moved: ${event.title}`, `${event.by || 'A host'} moved one date of “${event.title}”: ${event.when}. People who signed up for it were emailed the new time.`, 'Open the event'],
     approved: [`Approved: ${event.title}`, `Your event “${event.title}” (${event.when}) was approved and is now on the calendar.`, 'See your events'],
     declined: [`Not approved: ${event.title}`, `Your request for “${event.title}” (${event.when}) wasn’t approved.`, 'See your events'],
+    'staff-move-request': [`Date move to review: ${event.title}`, `${event.by || 'A host'} asked to move one date of “${event.title}”: ${event.when}. Nothing changes until someone approves it.`, 'Review it'],
+    'move-approved': [`Date moved: ${event.title}`, `Your request to move one date of “${event.title}” (${event.when}) was approved. People who signed up were emailed the new time.`, 'See your events'],
+    'move-declined': [`Date not moved: ${event.title}`, `Your request to move one date of “${event.title}” (${event.when}) wasn’t approved. The date stays as it was.`, 'See your events'],
+    'staff-from-date-request': [`Schedule change to review: ${event.title}`, `${event.by || 'A host'} asked to change “${event.title}” from one date on: ${event.when}. Nothing changes until someone applies it.`, 'Review it'],
+    'from-date-approved': [`Schedule changed: ${event.title}`, `Your request to change “${event.title}” from one date on (${event.when}) was applied. People who signed up were emailed their new dates.`, 'See your events'],
+    'from-date-declined': [`Schedule not changed: ${event.title}`, `Your request to change “${event.title}” from one date on (${event.when}) wasn’t approved. The schedule stays as it was.`, 'See your events'],
   }[kind];
   const extra = kind.startsWith('staff') ? (event.note ? `Their note: “${event.note}”` : '') : reply ? `From the team: “${reply}”` : '';
   return { to, subject: `${copy[0]} · ${site}`, text: [copy[0], '', copy[1], ...(extra ? ['', extra] : []), '', `${copy[2]}: ${url}`].join('\n'),