@acms-subir/core 0.3.53 → 0.3.54

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @acms-subir/core
 
+## 0.3.54
+
+### Patch Changes
+
+- 031e463: Hosts move single dates of their events from My events, and My events speaks the visitor's language.
+
+  - **Move… on each date.** Each upcoming date of a repeating event a host runs now has **Move…**, next to Cancel and Restore. It takes the date, the start and end, the date's rooms and a note for people who come. Hosts pick from the event's own rooms and the ones marked **Anyone can check if it’s free**. A date the host moved also gets **Move back**. People who signed up are emailed the new time, as with staff moves.
+  - **`acms({ members: { hostMoves } })`.** With `'direct'` (the default), a move applies at once while the rooms are free, and staff get the "Date moved" email. If a room is taken, the host sees which one and can **Send as a request** instead. With `'approve'`, every host move is a request.
+  - **Requests.** Host requests wait in Schedule → List → **Requests** under "Date changes from hosts", with what else holds the room at the new time. **Approve** makes the move (a clash only warns) and records it as the host's. **Decline…** keeps the date and sends the host your note. Staff get a "Date move to review" email, and the host hears the answer. The requests are stored on their own rows, in a new `event_requests` table (migration 68). Requests from people without an account will share that table.
+  - **Server API.** `@acms-subir/core/server` adds `moveHostedDate`, `moveHostedDateBack`, `requestDateMove`, `listMyDateRequests`, `withdrawDateRequest`, `approveDateRequest` and `declineDateRequest`. Member errors now carry a `code`.
+  - **My events under `/es`.** The pages, buttons, notices, the request form and their errors follow the address, so `/es/members/events` is in Spanish, including the event's translated title and the dates. The words exist in English, Spanish, French, German and Portuguese.
+
 ## 0.3.53
 
 ### Patch Changes

package/cli/migrations.generated.mjs

@@ -447,6 +447,20 @@ var SCREENS_MIGRATION = {
   ]
 };
 
+// src/lib/calendar/request-migration.ts
+var 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)`
+];
+
 // src/lib/repo/migrations.ts
 var CONTENT_VERSION_COLUMNS = {
   settings: [
@@ -1281,7 +1295,10 @@ var MIGRATIONS = [
   // row, so the triggers on events (content version, event_changes) see a move
   MOVED_DATES_MIGRATION(contentVersionTriggers("events", [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates"])[2]),
   // saved TV screens (Admin → Calendar → Screens, lib/display/store.ts)
-  SCREENS_MIGRATION
+  SCREENS_MIGRATION,
+  // calendar requests on their own rows (RequestRecord): new events and
+  // changes asked for without an account, and hosts' date moves
+  { version: 68, statements: REQUEST_TABLE }
 ];
 var CURRENT_CONTENT_VERSION_COLUMNS = {
   ...CONTENT_VERSION_COLUMNS,

package/docs/calendar.md

@@ -99,8 +99,9 @@ and `moveOccurrenceBack(repo, who, eventId, key, ctx, { quiet? })` check who is
 - **`GOOGLE_SYNC`** is a calendar sync acting with staff rights. A clash only warns,
   since the change already happened in Google.
 - **A host of the event** may move its dates while the rooms are free; a taken room
-  refuses the move (409). Staff (`members.notify`, else the owners) are emailed about
-  each move a host makes.
+  refuses the move (409). They pick rooms among the event's own and the rooms marked
+  **Anyone can check if it’s free** (403 `room-not-allowed` otherwise). Staff
+  (`members.notify`, else the owners) are emailed about each move a host makes.
 - Anyone else gets 404, and nobody signed in gets 401.
 
 `end` defaults to the date's own length. `roomIds`, `location` and `note` replace the
@@ -114,6 +115,22 @@ write, webhook, push or email. A sync can retry, or re-apply what it already app
 safely. Cancelling a date that's already cancelled, or restoring one that isn't, is a
 no-op too, even after the date has passed.
 
+### Hosts on My events
+
+Hosts move dates from **My events** (`/members/events`): each upcoming date has
+**Move…** next to **Cancel**, and a date they moved has **Move back**.
+`acms({ members: { hostMoves } })` decides how a host's move applies:
+
+- `'direct'` (the default): at once while the date's rooms are free, as above. When a
+  room is taken the host sees which one and can **Send as a request** instead.
+- `'approve'`: every host move, and every move back, is a request.
+
+Requests wait in Schedule → List → **Requests** under "Date changes from hosts", with
+what else holds the rooms at the new time. **Approve** makes the move as you (a clash
+only warns) and records it as the host's. **Decline…** keeps the date and sends the host
+your note. Both answers email the host. The server API is `moveHostedDate`,
+`requestDateMove` and `approveDateRequest` in `npx acms docs server`.
+
 Errors carry a `status`, a message safe to show people, and a `code`:
 
 | status | code | when |
@@ -127,6 +144,7 @@ Errors carry a `status`, a message safe to show people, and a `code`:
 | 409 | `cancelled-event` | the whole event is cancelled |
 | 409 | `cancelled-date` | the date is cancelled (restore it first) |
 | 409 | `room-taken` | a host moving into a taken room |
+| 403 | `room-not-allowed` | a host picking a room the event doesn't use and nobody may request |
 | 401, 404 | | who is acting |
 
 ## Rooms

package/docs/server.md

@@ -16,6 +16,8 @@ import {
   eventRoomClashes, roomBusy,
   listMyEvents, listEventRequests, submitEventRequest, updateEventRequest,
   withdrawEventRequest, approveEventRequest, declineEventRequest, setHostedOccurrence,
+  moveHostedDate, moveHostedDateBack, requestDateMove, listMyDateRequests, withdrawDateRequest,
+  approveDateRequest, declineDateRequest,
 } from '@acms-subir/core/server';
 ```
 
@@ -49,11 +51,23 @@ approveEventRequest(repo: Repo, who: ServerUser | null, eventId: string, ctx: Wr
 declineEventRequest(repo: Repo, who: ServerUser | null, eventId: string, reply: string, ctx: WriteContext, seen?: number): Promise<CalEvent>
 setHostedOccurrence(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, cancelled: boolean, ctx: WriteContext): Promise<CalEvent>
 
+// hosts moving dates (acms({ members: { hostMoves } }))
+moveHostedDate(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, input: MoveInput, ctx: WriteContext): Promise<HostMoveResult>
+moveHostedDateBack(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<HostMoveResult>
+requestDateMove(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, input: MoveInput | null, message: string, ctx: WriteContext): Promise<RequestRecord>
+listMyDateRequests(repo: Repo, who: ServerUser | null, eventId?: string): Promise<RequestRecord[]>
+withdrawDateRequest(repo: Repo, who: ServerUser | null, requestId: string): Promise<void>
+approveDateRequest(repo: Repo, who: ServerUser | null, requestId: string, ctx: WriteContext, seen?: number): Promise<{ request: RequestRecord; moved: MoveResult }>
+declineDateRequest(repo: Repo, who: ServerUser | null, requestId: string, reply: string, ctx: WriteContext, seen?: number): Promise<RequestRecord>
+
 type Role = 'owner' | 'administrator' | 'editor' | 'author' | 'contributor' | (string & {})
 interface ServerUser { id: string; email: string; name: string; role: Role; staff: boolean; can(permission: string): boolean }
 interface Occurrence { event: CalEvent; start: number; end: number; allDay: boolean; days: number; key: string; cancelled: boolean; roomIds: string[]; moved?: { from: { start: number; end: number }; note: string; location?: EventLocation } }
 interface MoveInput { start: string; end?: string; roomIds?: string[]; location?: Partial<EventLocation> | null; note?: string }
 interface MoveResult { event: CalEvent; clashes: BusySlot[]; changed: boolean }
+type HostMoveResult = { moved: MoveResult } | { request: RequestRecord }
+interface RequestRecord { id: string; kind: 'new' | 'change' | 'move' | 'from-date'; state: 'pending' | 'approved' | 'declined' | 'withdrawn'; source: 'member' | 'web' | 'app'; userId: string; requester: { name: string; email: string; phone: string; locale: string } | null; eventId: string; key: string; data: Record<string, unknown>; note: string; reply: string; reviewedBy: string; reviewedAt: number; createdAt: number; updatedAt: number }
+interface MoveRequestData { start: string; end: string; roomIds?: string[]; note: string; back?: boolean }
 interface Hold { resourceId: string; eventId: string; key: string; title: string; start: number; end: number; eventStart: number; eventEnd: number }
 interface EventClash { hold: Hold; other: Hold }
 interface BusySlot { resourceId: string; start: number; end: number; kind: 'event' | 'booking' | 'block' | 'calendar'; title: string; eventId?: string; key?: string; bookingId?: string }
@@ -145,6 +159,9 @@ error.
   emailed. `opts.quiet` skips the app notice and that staff email.
 - **`moveOccurrenceBack(...)`**: puts it back where the series has it. Idempotent.
 
+A host picks rooms only among the ones the event already uses and the rooms marked
+**Anyone can check if it’s free** (403, code `room-not-allowed`, otherwise).
+
 Moving a date to where it already is returns `changed: false` without writing or
 sending anything, so retries are safe. Errors carry `status` and `code` (`one-off`,
 `not-a-date`, `started`, `past`, `bad-time`, `cancelled-date`, `room-taken`…; the
@@ -300,6 +317,42 @@ The functions take the person acting (`currentUser(ctx)`) and check them on ever
   (`true`) or restores (`false`) one date of an event they host, at once. No permission
   needed beyond being in `hostIds`. Same rules and errors as `cancelOccurrence`.
 
+### Hosts moving dates
+
+A host moves one date of an event they host from My events, or from your own page with
+these. Being in `hostIds` is enough; no permission is needed. Staff who host an event
+always move at once.
+
+- **`moveHostedDate(repo, who, eventId, key, input, ctx)`**: with
+  `acms({ members: { hostMoves: 'direct' } })` (the default) the move applies at once
+  while the date's rooms are free: `{ moved }`, and staff get the "Date moved" email. A
+  taken room answers 409 with code `room-taken`, and the same move can then go to staff
+  with `requestDateMove`. With `hostMoves: 'approve'` every host move becomes a request:
+  `{ request }`.
+- **`moveHostedDateBack(repo, who, eventId, key, ctx)`**: puts a moved date back, at once
+  or as a request, the same way.
+- **`requestDateMove(repo, who, eventId, key, input, message, ctx)`**: asks staff to move
+  the date (`input`), or to move it back (`null`). It's checked like the move itself, but
+  a taken room is allowed, since staff decide. `message` is for staff only. Asking again
+  about the same date replaces the waiting request. Staff (`members.notify`, else the
+  owners) get a "Date move to review" email.
+- **`listMyDateRequests(repo, who, eventId?)`**, **`withdrawDateRequest(repo, who, requestId)`**:
+  the host's own requests, newest first, and taking one back.
+- **`approveDateRequest(repo, who, requestId, ctx, seen?)`**: needs **Publish content**.
+  The move runs as the approver, so room clashes are warnings in `moved.clashes`. It is
+  recorded as the host's move (`movedDates[key].by`), so they can move it back later. The
+  host is emailed. Pass `seen`, the request's `updatedAt` you showed, to get 409 if the
+  host changed it since.
+- **`declineDateRequest(repo, who, requestId, reply, ctx, seen?)`**: the date stays as it
+  is, and the host is emailed `reply`.
+
+These requests are `RequestRecord`s with `kind: 'move'` and `data: MoveRequestData`,
+stored on their own rows (the same table as requests from people without an account).
+Approved, declined and withdrawn ones stay listed until they're deleted after the
+retention period. Errors carry a `code` as well as a `status`, so your page can word
+them in its own language. The built-in pages use the codes in
+`lib/calendar/member-words.ts` (English, Spanish, French, German and Portuguese).
+
 `EventRequestInput` is what a member may fill in. Staff can change anything else in the
 admin.
 
@@ -340,7 +393,14 @@ With the calendar on, `acms({ members })` adds "My events" in the site's theme:
 | `/members/events/new` | the request form |
 | `/members/events/[id]` | one of their events and its request |
 
-`/members` itself redirects to `/members/events`.
+`/members` itself redirects to `/members/events`. With more than one site language the
+pages follow the address, like the rest of the site: `/es/members/events` is My events in
+Spanish (words, dates and the event's translated title). Its buttons and errors exist in
+English, Spanish, French, German and Portuguese; other languages show English.
+
+Each upcoming date of a repeating event a host runs has **Cancel** (or **Restore**),
+**Move…** (date, times, rooms and a note for people who come) and, for a date they
+moved, **Move back**. A taken room shows the clash with **Send as a request**.
 
 `members: { base: '/club' }` moves them. A file at the same path in your `src/pages/`
 replaces that one page. `members: false` removes them all; the functions above keep

package/integration.mjs

@@ -428,10 +428,13 @@ const unknownKeys = (label, value, known) => {
 const isSitePath = (p) => typeof p === 'string' && p.startsWith('/') && !p.startsWith('//') && !/[\\\s\u0000-\u001f]/.test(p);
 const isAdminPath = (p) => /^\/(admin|api|_actions)(\/|$|\?|#)/.test(p);
 function resolveMembers(members, calendar) {
-  if (members === false) return { enabled: false, base: '/members', notify: [] };
+  if (members === false) return { enabled: false, base: '/members', notify: [], hostMoves: 'direct' };
   if (members === undefined || members === true) members = {};
   if (!members || typeof members !== 'object' || Array.isArray(members)) throw new Error('acms: members must be an object (or false to turn off the built-in member pages)');
-  unknownKeys('members', members, ['base', 'notify']);
+  unknownKeys('members', members, ['base', 'notify', 'hostMoves']);
+  // a host moving one date: at once while its rooms are free, or always as a request for staff
+  const hostMoves = members.hostMoves ?? 'direct';
+  if (hostMoves !== 'direct' && hostMoves !== 'approve') throw new Error(`acms: members.hostMoves must be 'direct' or 'approve' — got ${JSON.stringify(hostMoves)}`);
   // who hears about new event requests (default: the owners)
   const notify = members.notify ?? [];
   if (!Array.isArray(notify) || notify.length > 20 || notify.some((e) => typeof e !== 'string' || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(e))) {
@@ -443,7 +446,7 @@ function resolveMembers(members, calendar) {
   }
   if (RESERVED_BASES.has(base) || base === '/account') throw new Error(`acms: members.base "${base}" collides with a built-in route — pick another path`);
   // the built-in pages are "My events": they need the calendar
-  return { enabled: calendar.enabled, base, notify: notify.map((e) => e.trim().toLowerCase()) };
+  return { enabled: calendar.enabled, base, notify: notify.map((e) => e.trim().toLowerCase()), hostMoves };
 }
 function resolveAnnouncements(announcements, reserved) {
   if (announcements === undefined || announcements === false) return { enabled: false, base: '/announcements', pages: true, topics: {} };
@@ -689,13 +692,16 @@ function acmsVitePlugin(userConfig) {
  *   'Cancel any class', defaults: ['administrator'] }`. They show on Team →
  *   Roles under "This site" and answer `currentUser().can(key)`. Owners hold
  *   every permission; `defaults` lists the other roles that start with it.
- * @param {false | {base?: string, notify?: string[]}} [options.members]
+ * @param {false | {base?: string, notify?: string[], hostMoves?: 'direct' | 'approve'}} [options.members]
  *   Built-in "My events" pages for signed-in members (default base
  *   '/members', needs the calendar): the events they host, their event
  *   requests and a request form. `false` turns the pages off (the server API
  *   in @acms-subir/core/server still works, so a site can build its own); a
  *   site file at the same path replaces any one page. `notify` lists who is
- *   emailed about new event requests (default: the owners).
+ *   emailed about new event requests (default: the owners). `hostMoves`:
+ *   'direct' (default) lets a host move one date at once while its rooms are
+ *   free (a taken room can be sent as a request instead); 'approve' sends
+ *   every host move to staff as a request.
  * @param {boolean | {base?: string, pages?: boolean, topics?: {event?: string, registration?: string, help?: string, info?: string}}} [options.announcements]
  *   Announcements (off by default): Admin → Announcements stores messages for
  *   members (event, registration, help needed, good to know, urgent) in each

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.53",
+  "version": "0.3.54",
   "publishConfig": {
     "access": "public"
   },

package/src/lib/api.ts

@@ -8,6 +8,9 @@ export class ApiError extends Error {
   /** retryAfter: seconds a 429 should wait (mobile API Retry-After; default 60) */
   constructor(public status: number, message: string, public retryAfter?: number) { super(message); }
 }
+/** An ApiError with a `code` saying why, for pages that word errors themselves (the member pages' words look them up). */
+export const coded = (status: number, code: string, message: string, retryAfter?: number): ApiError & { code: string } =>
+  Object.assign(new ApiError(status, message, retryAfter), { code });
 export const json = (body: unknown, status = 200) => Response.json(body, {
   status, headers: { 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' },
 });

package/src/lib/backup/content.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { SavedForm, FormSubmission } from '../forms/schema';
 import { AnnouncementRecord } from '../announcements/types';
-import { Page, Post, Media, Link, Tag, User, NavItem, Redirect, Settings, Calendar, CalEvent, Resource, BookingLink, Booking, Place } from '../schema';
+import { Page, Post, Media, Link, Tag, User, NavItem, Redirect, Settings, Calendar, CalEvent, Resource, BookingLink, Booking, Place, RequestRecord } from '../schema';
 import type { ContentRepository } from '../repo/types';
 
 // backups from before booking approval modes: a link that didn't confirm on
@@ -29,6 +29,7 @@ export const BackupContent = z.object({
   // optional (no version bump): older cores restore such a backup and skip them
   announcements: z.array(AnnouncementRecord).optional(),
   screens: z.array(ScreenRecord).optional(),
+  eventRequests: z.array(RequestRecord).optional(),
 }).superRefine((data, ctx) => {
   if (data.version >= 6 && (!data.forms || !data.formSubmissions)) ctx.addIssue({ code: 'custom', message: 'Version 6 requires forms and their submissions.' });
   if (data.version >= 5 && !data.bookingRequests) ctx.addIssue({ code: 'custom', message: 'Version 5 requires booking retry records.' });
@@ -48,12 +49,13 @@ export async function exportContent(repo: ContentRepository, now = Date.now()) {
     repo.listPlaces(), repo.forms.list(), repo.forms.submissions(undefined, -1),
   ]);
   const [announcements, screens] = await Promise.all([repo.announcements.list(-1), repo.screens.list()]);
+  const eventRequests = await repo.requests.list({ order: 'oldest', limit: -1 });
   return {
     format: 'acms-backup' as const, version: 6, exportedAt: new Date(now).toISOString(),
     settings: { ...settings, live: { ...settings.live, mode: 'off' as const, manual: { watchUrl: '', title: 'We’re live', until: 0 } }, ai: { ...settings.ai, enabled: false, encryptedKey: '' }, agent: { ...settings.agent, enabled: false, keyHash: '', keyPrefix: '', allowPublish: false }, monitoring: { ...settings.monitoring, pushUrl: '' } },
     pages, posts, media, links, tags, navItems, users, redirects,
     calendars: calendars.map(c => ({ ...c, feedToken: '' })), events,
-    resources: resources.map(r => ({ ...r, feedToken: '' })), bookingLinks, ...bookingState, places, forms, formSubmissions, announcements,
+    resources: resources.map(r => ({ ...r, feedToken: '' })), bookingLinks, ...bookingState, places, forms, formSubmissions, announcements, eventRequests,
     screens: screens.map(s => ({ ...s, key: '', lastSeenAt: null })),
   };
 }

package/src/lib/calendar/host-requests.ts

@@ -0,0 +1,247 @@
+// Hosts moving single dates of the events they host (C3), on top of
+// lib/calendar/moves.ts. acms({ members: { hostMoves } }) decides how:
+// - 'direct' (default): the move applies at once while the date's rooms are
+//   free, and staff get the "Date moved" email. A taken room refuses it
+//   (409 room-taken); the host can send that same move as a request instead;
+// - 'approve': every host move, and every move back, is a request.
+// Requests are rows in event_requests (repo.requests, RequestRecord kind
+// 'move', data: MoveRequestData) that staff who can publish approve (the move
+// runs as them, recorded as the host's) or decline with a note.
+//
+// Like requests.ts, everything checks who is acting, so the built-in My
+// events page and a site's own pages share the rules. Hosts need no
+// permission beyond being in hostIds; staff ("Create and edit content") who
+// host an event always move at once.
+import type { ContentRepository } from '../repo/types';
+import type { CalEvent, RequestRecord } from '../schema';
+import { ApiError, coded } from '../api';
+import type { SaveHooks } from '../content-service';
+import { GOOGLE_SYNC, checkMove, moveOccurrence, moveOccurrenceBack, type MoveInput, type MoveResult } from './moves';
+import { eventTimeZone, findOccurrence, type Occurrence } from './events';
+import { MEMBERS } from './members-config';
+import { siteLocale } from '../dates';
+import { kickEmail } from '../email/service';
+import { waitUntilFrom } from '../webhooks';
+import type { BusySlot } from '../booking/holds';
+
+/** who is acting: currentUser() from @acms-subir/core/server fits */
+export interface HostActor { id: string; can(permission: string): boolean }
+
+/** RequestRecord.data of a 'move' request: the move to make (MoveInput), or `back` to put the date back */
+export interface MoveRequestData {
+  start: string;
+  end: string;
+  roomIds?: string[];
+  /** the public note shown with the moved date */
+  note: string;
+  /** put a moved date back where the series has it (start and end are '') */
+  back?: boolean;
+}
+
+/** What a host's move did: moved at once (`moved`), or became a request (`request`). */
+export type HostMoveResult = { moved: MoveResult; request?: undefined } | { request: RequestRecord; moved?: undefined };
+
+const DAY = 86_400_000;
+const LIMITS = { note: 1000, pending: 20 };
+const text = (v: unknown, max: number) => String(v ?? '').replace(/\r\n?/g, '\n').replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, '').trim().slice(0, max);
+
+const staff = (who: HostActor) => who.can('content.edit');
+
+async function hosted(repo: ContentRepository, who: HostActor | null, id: string): Promise<CalEvent> {
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
+  const e = await repo.getEvent(id);
+  if (!e || e.status === 'archived' || (!e.hostIds.includes(who.id) && !staff(who))) throw coded(404, 'not-found', 'Event not found.');
+  return e;
+}
+
+/**
+ * A host moves one date of an event they host. With hostMoves 'direct' (or
+ * when they're staff) it applies at once and refuses a taken room (409,
+ * code room-taken); with 'approve' it's sent to staff as a request.
+ */
+export async function moveHostedDate(repo: ContentRepository, who: HostActor | null, id: string, key: string, input: MoveInput, hooks: SaveHooks): Promise<HostMoveResult> {
+  await hosted(repo, who, id);
+  if (MEMBERS.hostMoves === 'approve' && !staff(who!)) return { request: await requestDateMove(repo, who, id, key, input, '', hooks) };
+  const moved = await moveOccurrence(repo, who, id, key, input, hooks);
+  await settleWaiting(repo, who!, id, key);
+  return { moved };
+}
+
+// a move the host made at once replaces any move of that date they asked staff for
+async function settleWaiting(repo: ContentRepository, who: HostActor, eventId: string, key: string) {
+  for (const r of await repo.requests.list({ eventId, userId: who.id, kinds: ['move'], states: ['pending'], limit: -1 })) {
+    if (r.key === key) await repo.requests.update(r.id, { state: 'withdrawn', reviewedAt: Date.now() }, { state: 'pending' });
+  }
+}
+
+/** A host puts back a date they moved: at once ('direct') or as a request ('approve'). */
+export async function moveHostedDateBack(repo: ContentRepository, who: HostActor | null, id: string, key: string, hooks: SaveHooks): Promise<HostMoveResult> {
+  await hosted(repo, who, id);
+  if (MEMBERS.hostMoves === 'approve' && !staff(who!)) return { request: await requestDateMove(repo, who, id, key, null, '', hooks) };
+  const moved = await moveOccurrenceBack(repo, who, id, key, hooks);
+  await settleWaiting(repo, who!, id, key);
+  return { moved };
+}
+
+/**
+ * A host asks staff to move one date (`input`), or to put it back (null):
+ * checked like the move itself, then saved as a pending request. A taken
+ * room is fine here: staff decide. Asking again about the same date replaces
+ * the waiting request. `message` is for staff only.
+ */
+export async function requestDateMove(repo: ContentRepository, who: HostActor | null, id: string, key: string, input: MoveInput | null, message: string, hooks: SaveHooks): Promise<RequestRecord> {
+  const e = await hosted(repo, who, id);
+  if (!e.hostIds.includes(who!.id)) throw coded(404, 'not-found', 'Event not found.');
+  // as the host: the same refusals a move gets, except the taken room (a request carries no place of its own)
+  const check = await checkMove(repo, who, id, key, input ? { ...input, location: undefined } : null);
+  if (!check.changed) throw coded(400, 'unchanged', input ? 'That date is already there.' : 'That date isn’t moved.');
+  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);
+  // moving it to where the series has it is asking to move it back
+  const data: MoveRequestData = input && !check.back
+    ? { start: check.start!, end: check.end!, ...(input.roomIds !== undefined ? { roomIds: [...new Set(input.roomIds)] } : {}), note: check.note ?? '' }
+    : { start: '', end: '', note: '', back: true };
+  const note = text(message, LIMITS.note);
+  const waiting = (await repo.requests.list({ eventId: id, userId: who!.id, kinds: ['move'], states: ['pending'], limit: -1 })).find((r) => r.key === key);
+  let saved: RequestRecord | null;
+  if (waiting) saved = await repo.requests.update(waiting.id, { data: { ...data }, note }, { state: 'pending' });
+  else {
+    if (await repo.requests.count({ userId: who!.id, states: ['pending'] }) >= LIMITS.pending) throw coded(429, 'too-many-waiting', 'You have many requests waiting already. Wait for the team to answer them first.');
+    const now = Date.now();
+    saved = await repo.requests.create({ id: crypto.randomUUID(), kind: 'move', state: 'pending', source: 'member', userId: who!.id, requester: null,
+      eventId: id, key, data: { ...data }, note, reply: '', reviewedBy: '', reviewedAt: 0, createdAt: now, updatedAt: now });
+  }
+  if (!saved) throw coded(409, 'answered', 'That request was just answered. Look at My events again.');
+  await alertStaff(repo, saved, hooks);
+  return saved;
+}
+
+/** A host's own move requests (all states, newest first): `eventId` narrows to one event. */
+export async function myDateRequests(repo: ContentRepository, userId: string, eventId?: string): Promise<RequestRecord[]> {
+  return repo.requests.list({ userId, kinds: ['move', 'from-date'], ...(eventId ? { eventId } : {}), limit: 200 });
+}
+
+/** A host takes back a waiting request of theirs. */
+export async function withdrawDateRequest(repo: ContentRepository, who: HostActor | null, requestId: string): Promise<void> {
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
+  const r = await repo.requests.get(requestId);
+  if (!r || r.userId !== who.id || (r.kind !== 'move' && r.kind !== 'from-date')) throw coded(404, 'request-not-found', 'Request not found.');
+  if (r.state !== 'pending') return;
+  await repo.requests.update(requestId, { state: 'withdrawn', reviewedAt: Date.now() }, { state: 'pending' });
+}
+
+/** A host clears an answered request from My events (it's deleted with the others later anyway). */
+export async function dismissDateRequest(repo: ContentRepository, who: HostActor | null, requestId: string): Promise<void> {
+  if (!who) throw coded(401, 'sign-in', 'Sign in to continue.');
+  const r = await repo.requests.get(requestId);
+  if (!r || r.userId !== who.id || (r.kind !== 'move' && r.kind !== 'from-date')) throw coded(404, 'request-not-found', 'Request not found.');
+  if (r.state === 'declined' || r.state === 'approved') await repo.requests.delete(requestId);
+}
+
+/** What else takes the rooms of a waiting move request at its new time (names included: staff only). */
+export async function dateRequestClashes(repo: ContentRepository, r: RequestRecord): Promise<BusySlot[]> {
+  if (r.kind !== 'move' || r.state !== 'pending') return [];
+  const d = r.data as MoveRequestData;
+  try {
+    return (await checkMove(repo, GOOGLE_SYNC, r.eventId, r.key, d.back ? null : { start: d.start, end: d.end, roomIds: d.roomIds, note: d.note })).clashes;
+  } catch { return []; }
+}
+
+// ---- answering (staff who can publish) ---------------------------------------
+
+function requireApprover(who: HostActor | null): asserts who is HostActor {
+  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.');
+}
+
+async function answerable(repo: ContentRepository, id: string, seen?: number): Promise<RequestRecord> {
+  const r = await repo.requests.get(id);
+  if (!r || (r.kind !== 'move' && r.kind !== 'from-date')) throw coded(404, 'request-not-found', 'Request not found.');
+  if (r.state !== 'pending') throw coded(409, 'answered', 'This request was already answered or withdrawn.');
+  if (seen !== undefined && r.updatedAt !== seen) throw coded(409, 'changed', 'This request changed after you opened it. Look at it again, then answer.');
+  return r;
+}
+
+/** Staff approve a host's move request: the move runs as them (room clashes warn), recorded as the host's, and the host is emailed. Pass `seen` (the request's updatedAt they reviewed). */
+export async function approveDateRequest(repo: ContentRepository, who: HostActor | null, id: string, hooks: SaveHooks, seen?: number): Promise<{ request: RequestRecord; moved: MoveResult }> {
+  requireApprover(who);
+  const r = await answerable(repo, id, seen);
+  if (r.kind !== 'move') throw coded(400, 'unavailable', 'Open the event to apply this change.');
+  const d = r.data as MoveRequestData;
+  // worded before it moves: "where it was → where it goes"
+  const when = await dateRequestWhen(repo, r);
+  const request = await claim(repo, r, who);
+  let moved: MoveResult;
+  try {
+    moved = d.back
+      ? await moveOccurrenceBack(repo, who, r.eventId, r.key, hooks)
+      : await moveOccurrence(repo, who, r.eventId, r.key, { start: d.start, end: d.end, roomIds: d.roomIds, note: d.note }, hooks, { by: r.userId });
+  } catch (err) { await release(repo, id); throw err; }
+  await tellHost(repo, request, 'move-approved', '', when, hooks);
+  return { request, moved };
+}
+
+// Approving claims the request first (only as staff saw it, and only once),
+// so two approvals at once, or a host's edit meanwhile, can't both go
+// through; a change that then fails puts it back to waiting.
+async function claim(repo: ContentRepository, r: RequestRecord, who: HostActor): Promise<RequestRecord> {
+  const claimed = await repo.requests.update(r.id, { state: 'approved', reviewedBy: who.id, reviewedAt: Date.now() }, { state: 'pending', updatedAt: r.updatedAt });
+  if (!claimed) throw coded(409, 'changed', 'This request was just answered or changed. Look at it again, then answer.');
+  return claimed;
+}
+const release = (repo: ContentRepository, id: string) => repo.requests.update(id, { state: 'pending', reviewedBy: '', reviewedAt: 0 }, { state: 'approved' });
+
+/** Staff decline a host's request, with an optional note the host reads. */
+export async function declineDateRequest(repo: ContentRepository, who: HostActor | null, id: string, reply: string, hooks: SaveHooks, seen?: number): Promise<RequestRecord> {
+  requireApprover(who);
+  const r = await answerable(repo, id, seen);
+  const answer = text(reply, LIMITS.note);
+  const request = await repo.requests.update(id, { state: 'declined', reply: answer, reviewedBy: who.id, reviewedAt: Date.now() }, { state: 'pending', updatedAt: r.updatedAt });
+  if (!request) throw coded(409, 'changed', 'This request changed after you opened it. Look at it again, then answer.');
+  await tellHost(repo, request, r.kind === 'move' ? 'move-declined' : 'from-date-declined', answer, await dateRequestWhen(repo, r), hooks);
+  return request;
+}
+
+// ---- email ------------------------------------------------------------
+
+/** Where a move request's date is now and where it would go ("Thu, Jan 10, 6:00 PM", "Wed, Jan 9, 5:00 PM"), in the site's language; '' when it isn't a date any more. */
+export async function dateRequestTimes(repo: ContentRepository, r: RequestRecord): Promise<{ from: string; to: string }> {
+  const e = await repo.getEvent(r.eventId);
+  if (!e) return { from: '', to: '' };
+  const settings = await repo.getSettings();
+  const d = r.data as MoveRequestData;
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const fmt = (o: Occurrence | null) => {
+    if (!o) return '';
+    try { return new Intl.DateTimeFormat(siteLocale(settings), e.allDay ? { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz } : { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZone: tz }).format(o.start); }
+    catch { return new Date(o.start).toISOString(); }
+  };
+  const to = d.back ? findOccurrence({ ...e, movedDates: {} }, r.key, settings)
+    : findOccurrence({ ...e, movedDates: { ...e.movedDates, [r.key]: { start: d.start, end: d.end, note: d.note, by: '', at: 0, ...(d.roomIds ? { roomIds: d.roomIds } : {}) } } }, r.key, settings);
+  return { from: fmt(findOccurrence(e, r.key, settings)), to: fmt(to) };
+}
+
+/** "Thu, Jan 10, 6:00 PM → Wed, Jan 9, 5:00 PM" for a move request (dateRequestTimes) */
+export async function dateRequestWhen(repo: ContentRepository, r: RequestRecord): Promise<string> {
+  const t = await dateRequestTimes(repo, r);
+  return t.from && t.to ? `${t.from} → ${t.to}` : t.from || t.to;
+}
+
+// staff: "Date move to review" (members.notify, else the owners)
+async function alertStaff(repo: ContentRepository, r: RequestRecord, hooks: SaveHooks) {
+  const to = MEMBERS.notify.length ? MEMBERS.notify : (await repo.listUsers()).filter((u) => u.role === 'owner' && u.email).map((u) => u.email);
+  await queue(repo, r, to, r.kind === 'move' ? 'staff-move-request' : 'staff-from-date-request', '', await dateRequestWhen(repo, r), hooks);
+}
+async function tellHost(repo: ContentRepository, r: RequestRecord, kind: string, reply: string, when: string, hooks: SaveHooks) {
+  const host = r.userId ? await repo.getUser(r.userId) : null;
+  if (host?.email) await queue(repo, r, [host.email], kind, reply, when, hooks);
+}
+// `when` is worded now: by the time it's sent the date may have moved
+async function queue(repo: ContentRepository, r: RequestRecord, to: string[], kind: string, reply: string, when: string, hooks: SaveHooks) {
+  if (!to.length) return;
+  const version = (await repo.email.config().catch(() => null))?.version ?? 0;
+  for (const recipient of to) {
+    await repo.email.enqueue({ dedupe: `date-request:${r.id}:${r.updatedAt}:${kind}:${recipient}`, kind: 'event-request', recipient,
+      payload: JSON.stringify({ eventId: r.eventId, requestId: r.id, kind, at: r.updatedAt, reply, when }), configVersion: version, expiresAt: Date.now() + 7 * DAY });
+  }
+  await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals)).catch(() => {});
+}

package/src/lib/calendar/member-form.ts

@@ -1,7 +1,8 @@
-import type { CalEvent, EventRequest } from '../schema';
+import type { CalEvent, EventRequest, RequestRecord } from '../schema';
 import type { EventRequestInput } from './requests';
 import { CALENDAR, type EventFieldConfig } from './config';
 import { describeRepeat } from './rrule';
+import { memberStrings, type MemberStrings } from './member-words';
 
 // The event request form on the built-in "My events" pages, as pure
 // functions: the HTML form's fields → EventRequestInput (requests.ts checks
@@ -30,7 +31,7 @@ export interface MemberEventForm {
   note: string;
 }
 
-/** the request form's "Repeats" choices */
+/** the request form's "Repeats" choices (labels in English; repeatChoices words them in the page's language) */
 export const REPEAT_CHOICES: readonly { value: string; label: string }[] = [
   { value: '', label: 'Does not repeat' },
   { value: 'FREQ=DAILY', label: 'Every day' },
@@ -38,6 +39,7 @@ export const REPEAT_CHOICES: readonly { value: string; label: string }[] = [
   { value: 'FREQ=WEEKLY;INTERVAL=2', label: 'Every 2 weeks' },
   { value: 'FREQ=MONTHLY', label: 'Every month' },
 ];
+const CHOICE_WORD = ['none', 'daily', 'weekly', 'biweekly', 'monthly'] as const;
 
 /** the patterns requests.ts accepts from members (kept in step with its REPEAT) */
 const MEMBER_REPEAT = /^FREQ=(DAILY|WEEKLY|MONTHLY)(;INTERVAL=[1-9]\d?)?(;COUNT=[1-9]\d{0,2})?$/;
@@ -134,19 +136,23 @@ export function eventFormValues(e: FormEvent, opts: { description: string; calen
 /**
  * The "Repeats" select for a value: the standard choices, plus the event's
  * own pattern (e.g. every 3 weeks, or one only the admin can set, like weekly
- * on two days), selected, so sending the form unchanged keeps it.
+ * on two days), selected, so sending the form unchanged keeps it. `lang`
+ * words them (memberStrings; English by default).
  */
-export function repeatChoices(current: string, start: string): { options: { value: string; label: string }[]; value: string; note: string } {
+export function repeatChoices(current: string, start: string, lang?: string): { options: { value: string; label: string }[]; value: string; note: string } {
+  const w = memberStrings(lang).form;
   const rule = current.trim().replace(/^RRULE:/i, '').toUpperCase();
-  const options = [...REPEAT_CHOICES];
+  const options = REPEAT_CHOICES.map((o, i) => ({ value: o.value, label: w.repeat[CHOICE_WORD[i]] }));
   if (!rule || options.some((o) => o.value === rule)) return { options, value: rule, note: '' };
-  if (MEMBER_REPEAT.test(rule)) return { options: [...options, { value: rule, label: describeRepeat(rule, start) }], value: rule, note: '' };
+  if (MEMBER_REPEAT.test(rule)) return { options: [...options, { value: rule, label: describeRepeat(rule, start, undefined, lang) }], value: rule, note: '' };
   // set up by the team: members can keep it (requests.ts accepts an unchanged rule) or pick another
-  return { options: [...options, { value: rule, label: `${describeRepeat(rule, start)} (as set by the team)` }], value: rule, note: '' };
+  return { options: [...options, { value: rule, label: w.asSetByTeam.replace('{repeat}', describeRepeat(rule, start, undefined, lang)) }], value: rule, note: '' };
 }
 
-/** how a request reads on "My events" */
-export function requestLabel(r: Pick<EventRequest, 'kind' | 'state'>): string {
-  if (r.kind === 'changes') return r.state === 'pending' ? 'Changes waiting for approval' : 'Changes declined';
-  return r.state === 'pending' ? 'Waiting for approval' : 'Declined';
+/** how a request reads on "My events": a member's request on its event (EventRequest), or a host's date request (RequestRecord 'move' / 'from-date') */
+export function requestLabel(r: Pick<EventRequest, 'kind' | 'state'> | Pick<RequestRecord, 'kind' | 'state'>, w: MemberStrings = memberStrings('en')): string {
+  if (r.kind === 'changes') return r.state === 'pending' ? w.changesWaiting : w.changesDeclined;
+  if (r.kind === 'move') return r.state === 'pending' ? w.moveWaiting : r.state === 'approved' ? w.moveApproved : w.moveDeclined;
+  if (r.kind === 'from-date') return r.state === 'pending' ? w.fromDateWaiting : r.state === 'approved' ? w.fromDateApproved : w.fromDateDeclined;
+  return r.state === 'pending' ? w.waiting : w.declined;
 }