@acms-subir/core 0.3.55 → 0.3.57

package/src/pages/request/index.astro

@@ -0,0 +1,182 @@
+---
+import Site from '../../layouts/Site.astro';
+import { getRepo } from '../../lib/repo';
+import { ApiError } from '../../lib/api';
+import { readForm } from '../../lib/forms/http';
+import { I18N, localePath, requestLocale as pageLocale } from '../../lib/i18n';
+import { siteLang, siteLocale } from '../../lib/dates';
+import { LEGAL } from '../../lib/legal/config';
+import { fill } from '../../lib/live/words';
+import { REQUESTS } from '../../lib/calendar/request-config';
+import { requestOptions, submitRequest, requestLocale, type RequestRefusal } from '../../lib/calendar/request-service';
+import { requestStrings } from '../../lib/calendar/request-words';
+import { formRequest, sentSummary } from '../../lib/calendar/request-page';
+
+// Request an event (acms({ requests })): the same request as the app's
+// screen, for anyone, without an account, at /request and under each
+// language's prefix (/es/request). The page posts to itself; the rules,
+// limits and emails are lib/calendar/request-service.ts. Themed through the
+// site's tokens (the booking form's pc-bk-* fields); a site file at this path
+// replaces it, and acms({ requests: { page: false } }) drops it.
+if (!REQUESTS.enabled) return new Response(null, { status: 404 });
+Astro.response.headers.set('Cache-Control', 'private, no-store');
+
+const repo = await getRepo(Astro.locals);
+const settings = await repo.getSettings();
+const locale = I18N.enabled ? requestLocale(pageLocale(Astro.url, Astro.locals)) : '';
+const lang = locale || (I18N.enabled && I18N.defaultLocale) || siteLang(settings);
+const dateLocale = lang.split('-')[0] === siteLang(settings) ? siteLocale(settings) : lang;
+const w = requestStrings(lang);
+const options = await requestOptions(repo, locale);
+
+let error = '';
+let field = '';
+let values: Record<string, string | string[]> = { kind: 'new', repeat: 'once' };
+let key: string = crypto.randomUUID();
+let sent: { email: string; title: string; line: string } | null = null;
+if (Astro.request.method === 'POST') {
+  try {
+    const data = await readForm(Astro.request);
+    values = Object.fromEntries([...new Set(data.keys())].map((k) => [k, k === 'rooms' ? data.getAll(k).map(String) : String(data.get(k) ?? '')]));
+    key = String(data.get('requestId') ?? '');
+    const { request } = await submitRequest(repo, formRequest(data, locale), { source: 'web', key, address: Astro.clientAddress, locals: Astro.locals });
+    sent = { email: request.requester?.email ?? '', ...await sentSummary(repo, request, settings, lang, dateLocale) };
+  } catch (e) {
+    const code = (e as { code?: RequestRefusal }).code;
+    field = code ?? '';
+    error = code ? w.errors[code] : e instanceof ApiError && e.status !== 500 ? e.message : w.errors.failed;
+    Astro.response.status = e instanceof ApiError ? e.status : 500;
+    // a refused request can be fixed and sent again with the same key; one that went through can't
+    if (code === 'changed') key = crypto.randomUUID();
+  }
+}
+const v = (k: string) => { const x = values[k]; return Array.isArray(x) ? x[0] ?? '' : x ?? ''; };
+const chosenRooms = Array.isArray(values.rooms) ? values.rooms : values.rooms ? [values.rooms] : [];
+const today = new Intl.DateTimeFormat('en-CA', { timeZone: settings.timezone || 'UTC', year: 'numeric', month: '2-digit', day: '2-digit' }).format(Date.now());
+const privacy = LEGAL.enabled ? localePath('/privacy', locale) : '';
+const self = localePath(REQUESTS.path, locale);
+const tel = (p: string) => 'tel:' + p.replace(/[^\d+]/g, '');
+const invalid = (...codes: string[]) => (codes.includes(field) ? 'true' : undefined);
+const fieldWords = { free: w.free, taken: w.taken };
+---
+<Site title={w.heading}>
+  <section class="pc-simple-form pc-rq">
+    <h1>{sent ? w.sent : w.heading}</h1>
+    {sent ? (
+      <div class="pc-rq-sent" role="status">
+        <p>{options.replyTime ? fill(w.answerWithin, { time: options.replyTime, email: sent.email }) : fill(w.answerBy, { email: sent.email })}</p>
+        <div class="pc-rq-card"><small>{w.yours}</small><b>{sent.title}</b><span>{sent.line}</span></div>
+        <p class="pc-bk-hint">{w.notYet}{options.phone && <> <a href={tel(options.phone)}>{fill(w.sooner, { phone: options.phone })}</a></>}</p>
+        <p><a href={self}>{w.another}</a></p>
+      </div>
+    ) : !options.open ? (
+      <div class="pc-rq-closed" role="status">
+        <p>{w.closed}</p>
+        {options.phone && <p><a href={tel(options.phone)}>{fill(w.call, { phone: options.phone })}</a></p>}
+      </div>
+    ) : (
+      <form method="post" action={self} class="pc-rq-form" data-tz={options.timezone} data-words={JSON.stringify(fieldWords)}>
+        <p class="pc-rq-notice">{options.notice || w.notice}</p>
+        {error && <p class="pc-bk-error" role="alert">{error}</p>}
+        <input type="hidden" name="requestId" value={key} />
+        <div class="pc-form-trap" aria-hidden="true"><label>Leave empty<input name="website" tabindex="-1" autocomplete="off" /></label></div>
+        <fieldset class="pc-rq-kind">
+          <legend class="pc-rq-sr">{w.heading}</legend>
+          <label><input type="radio" name="kind" value="new" checked={v('kind') !== 'change'} /><span>{w.somethingNew}</span></label>
+          <label><input type="radio" name="kind" value="change" checked={v('kind') === 'change'} /><span>{w.change}</span></label>
+        </fieldset>
+
+        <div class="pc-rq-new">
+          <label class="pc-bk-field"><span>{w.what}</span><input name="title" maxlength="200" value={v('title')} aria-invalid={invalid('title')} /></label>
+          {options.types.length > 0 && (
+            <fieldset class="pc-bk-field pc-bk-choices"><legend>{w.type}</legend>
+              <div class="pc-rq-chips">{options.types.map((t) => <label class="pc-bk-option"><input type="radio" name="type" value={t.id} checked={v('type') === t.id} /><span>{t.label}</span></label>)}</div>
+            </fieldset>
+          )}
+          <div class="pc-rq-when">
+            <label class="pc-bk-field"><span>{w.date}</span><input type="date" name="date" min={today} value={v('date')} aria-invalid={invalid('start', 'past', 'far')} /></label>
+            <label class="pc-bk-field"><span>{w.starts}</span><input type="time" name="start" step="300" value={v('start')} aria-invalid={invalid('start', 'past')} /></label>
+            <label class="pc-bk-field"><span>{w.ends}</span><input type="time" name="end" step="300" value={v('end')} aria-invalid={invalid('end')} /></label>
+          </div>
+          <fieldset class="pc-bk-field pc-bk-choices"><legend>{w.repeats}</legend>
+            <div class="pc-rq-chips">
+              <label class="pc-bk-option"><input type="radio" name="repeat" value="once" checked={v('repeat') !== 'weekly' && v('repeat') !== 'other'} /><span>{w.once}</span></label>
+              <label class="pc-bk-option"><input type="radio" name="repeat" value="weekly" checked={v('repeat') === 'weekly'} /><span>{w.weekly}</span></label>
+              <label class="pc-bk-option"><input type="radio" name="repeat" value="other" checked={v('repeat') === 'other'} /><span>{w.other}</span></label>
+            </div>
+            <label class="pc-bk-field pc-rq-other"><span>{w.otherHint}</span><input name="repeatText" maxlength="200" value={v('repeatText')} aria-invalid={invalid('repeat')} /></label>
+          </fieldset>
+          {options.rooms.length > 0 && (
+            <fieldset class="pc-bk-field pc-bk-choices"><legend>{w.room}</legend>
+              <div class="pc-rq-chips">
+                {options.rooms.map((r) => <label class="pc-bk-option"><input type="checkbox" name="rooms" value={r.slug} data-name={r.name} checked={chosenRooms.includes(r.slug)} /><span>{r.name}</span></label>)}
+                <label class="pc-bk-option"><input type="checkbox" name="roomsUnsure" value="1" checked={v('roomsUnsure') === '1'} /><span>{w.notSure}</span></label>
+              </div>
+              <p class="pc-rq-free" aria-live="polite"></p>
+            </fieldset>
+          )}
+          <label class="pc-bk-field"><span>{w.people} <em>{w.optional}</em></span><input type="number" name="people" min="1" max="100000" inputmode="numeric" value={v('people')} aria-invalid={invalid('people')} /></label>
+          <label class="pc-bk-field"><span>{w.message} <em>{w.optional}</em></span><textarea name="message" rows="3" maxlength="2000">{v('message')}</textarea></label>
+        </div>
+
+        <div class="pc-rq-change">
+          <label class="pc-bk-field"><span>{w.event}</span>
+            <select name="event" aria-invalid={invalid('event')}>
+              <option value="">{w.pickEvent}</option>
+              {options.events.map((e) => <option value={e.slug} selected={v('event') === e.slug}>{e.title}</option>)}
+            </select>
+          </label>
+          <label class="pc-bk-field"><span>{w.onDate} <em>{w.optional}</em></span><input type="date" name="onDate" min={today} value={v('onDate')} aria-invalid={invalid('date')} /><small>{w.onDateHint}</small></label>
+          <label class="pc-bk-field"><span>{w.whatChange}</span><textarea name="whatChange" rows="3" maxlength="2000" aria-invalid={invalid('what')}>{v('whatChange')}</textarea></label>
+        </div>
+
+        <fieldset class="pc-rq-contact">
+          <legend>{w.contact}</legend>
+          <label class="pc-bk-field"><span>{w.name}</span><input name="name" required maxlength="120" autocomplete="name" value={v('name')} aria-invalid={invalid('name')} /></label>
+          <div class="pc-form-row">
+            <label class="pc-bk-field"><span>{w.email}</span><input type="email" name="email" required maxlength="254" autocomplete="email" value={v('email')} aria-invalid={invalid('email')} /></label>
+            <label class="pc-bk-field"><span>{w.phone} <em>{w.optional}</em></span><input type="tel" name="phone" maxlength="40" autocomplete="tel" value={v('phone')} aria-invalid={invalid('phone')} /></label>
+          </div>
+          <p class="pc-bk-hint">{w.contactWhy}{privacy && <> <a href={privacy}>{w.privacy}</a></>}</p>
+        </fieldset>
+        <button class="pc-bk-submit" type="submit">{w.send}</button>
+      </form>
+    )}
+  </section>
+</Site>
+
+<script>
+  // "Sanctuary looks free then": free or busy for the chosen rooms
+  // (GET /api/v1/rooms/free, no names), in the site's zone
+  const form = document.querySelector<HTMLFormElement>('.pc-rq-form');
+  const out = form?.querySelector<HTMLElement>('.pc-rq-free');
+  if (form && out) {
+    const tz = form.dataset.tz || 'UTC';
+    const words = JSON.parse(form.dataset.words || '{}') as { free: string; taken: string };
+    const wall = (iso: string) => {
+      const p = Object.fromEntries(new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' })
+        .formatToParts(new Date(iso)).map((x) => [x.type, x.value]));
+      return p.year + '-' + p.month + '-' + p.day + 'T' + p.hour + ':' + p.minute;
+    };
+    const next = (day: string) => { const d = new Date(day + 'T12:00:00Z'); d.setUTCDate(d.getUTCDate() + 1); return d.toISOString().slice(0, 10); };
+    let run = 0;
+    const check = async () => {
+      const mine = ++run;
+      const get = (n: string) => (form.elements.namedItem(n) as HTMLInputElement | null)?.value || '';
+      const day = get('date'), start = get('start'), end = get('end');
+      const rooms = [...form.querySelectorAll<HTMLInputElement>('input[name=rooms]:checked')];
+      if (!day || !start || !end || end <= start || !rooms.length) { out.textContent = ''; return; }
+      const from = day + 'T' + start, to = day + 'T' + end;
+      const lines = await Promise.all(rooms.map(async (r) => {
+        const res = await fetch('/api/v1/rooms/free?room=' + encodeURIComponent(r.value) + '&start=' + day + '&end=' + next(day)).catch(() => null);
+        if (!res?.ok) return '';
+        const { data } = await res.json() as { data: { busy: { start: string; end: string }[] } };
+        const taken = data.busy.some((b) => wall(b.start) < to && wall(b.end) > from);
+        return (taken ? words.taken : words.free).replace('{room}', r.dataset.name || r.value);
+      }));
+      if (mine === run) out.textContent = lines.filter(Boolean).join(' ');
+    };
+    form.addEventListener('change', (e) => { if ((e.target as HTMLInputElement).name !== 'roomsUnsure') void check(); });
+    void check();
+  }
+</script>

package/src/server/index.ts

@@ -38,6 +38,8 @@ export type { CalEvent, Occurrence };
 export type { EventRequestInput } from '../lib/calendar/requests';
 export type { EventClash, BusySlot, Hold } from '../lib/booking/holds';
 export type { MoveInput, MoveResult } from '../lib/calendar/moves';
+export type { RequestRecord, RequestKind, RequestState, RequestSource, Requester } from '../lib/schema';
+export type { RequestInput, RequestRefusal, NewEventDetails, Answered, RequestClash } from '../lib/calendar/request-service';
 
 export interface ListEventsOptions {
   /** only published events (default: every event except archived ones) */
@@ -254,6 +256,39 @@ export async function syncGoogleCalendar(repo: Repo, context: Pick<WriteContext,
   return syncGoogle(internal(repo), context.locals);
 }
 
+// ---- from this date on -------------------------------------------------------
+// A repeating event changed from one of its dates on (new times, weekday,
+// rule, rooms or place), the dates before it kept as they were. It stays one
+// event; the change is a segment on its row (CalEvent.segments). RSVPs,
+// cancelled and moved dates follow to the new date nearest them within half
+// a week (`npx acms docs calendar`). Staff and GOOGLE_SYNC only (room clashes
+// warn); hosts send requestFromDate. All are idempotent (`changed: false`);
+// `quiet` skips the member push, and RSVP emails still go.
+
+const segments = () => import('../lib/calendar/segments');
+export type { ChangeFromInput, ChangeFromResult } from '../lib/calendar/segments';
+export type { SeriesSegment } from '../lib/schema';
+
+/** Change the series from `fromKey` (an occurrence key) on: `input.start` is the new first date (wall-clock in the event's zone), `rrule` omitted = the rule in effect on the new weekday. */
+export async function changeFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, fromKey: string, input: import('../lib/calendar/segments').ChangeFromInput, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).changeFromDate(internal(repo), who, eventId, fromKey, input, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Cancel every date from `fromKey` on: listed, struck through, holding no room; their RSVPs are cancelled (emailed). */
+export async function cancelFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, fromKey: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).cancelFromDate(internal(repo), who, eventId, fromKey, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Undo cancelFromDate (from any date it covers). The dates are back; their RSVPs stay cancelled. */
+export async function restoreFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, fromKey: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).restoreFromDate(internal(repo), who, eventId, fromKey, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Remove the change that took over at `from`: the rule before it carries on, RSVPs and dates following back. */
+export async function revertFromDate(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, from: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/segments').ChangeFromResult> {
+  return (await segments()).revertFromDate(internal(repo), who, eventId, from, { url: context.url, locals: context.locals }, opts);
+}
+
 // ---- rooms -----------------------------------------------------------------
 // Events hold rooms (CalEvent.roomHold) while they happen. These find where
 // two things want the same room. They don't check permissions, and their
@@ -359,8 +394,7 @@ export async function setHostedOccurrence(repo: Repo, who: Who, eventId: string,
 // that staff who can publish approve or decline; both sides are emailed.
 
 const hostRequests = () => import('../lib/calendar/host-requests');
-export type { HostMoveResult, MoveRequestData } from '../lib/calendar/host-requests';
-export type { RequestRecord } from '../lib/schema';
+export type { HostMoveResult, MoveRequestData, FromDateRequestData } from '../lib/calendar/host-requests';
 
 /** A host moves one date: `{ moved }` at once, or `{ request }` when moves need approval. Errors as moveOccurrence's, plus `code` room-not-allowed (a room the event doesn't use and nobody may request). */
 export async function moveHostedDate(repo: Repo, who: Who, eventId: string, occurrenceKey: string, input: import('../lib/calendar/moves').MoveInput, context: WriteContext): Promise<import('../lib/calendar/host-requests').HostMoveResult> {
@@ -382,6 +416,11 @@ export async function requestDateMove(repo: Repo, who: Who, eventId: string, occ
   return (await hostRequests()).requestDateMove(internal(repo), who, eventId, occurrenceKey, input, message, context);
 }
 
+/** A host asks staff to change their event from one date on (checked like changeFromDate; rooms among the event's and the requestable ones). Staff are emailed. */
+export async function requestFromDate(repo: Repo, who: Who, eventId: string, fromKey: string, input: Omit<import('../lib/calendar/segments').ChangeFromInput, 'location'>, message: string, context: WriteContext): Promise<import('../lib/schema').RequestRecord> {
+  return (await hostRequests()).requestFromDate(internal(repo), who, eventId, fromKey, input, message, context);
+}
+
 /** A host's own date requests (waiting, approved, declined and withdrawn), newest first. */
 export async function listMyDateRequests(repo: Repo, who: Who, eventId?: string): Promise<import('../lib/schema').RequestRecord[]> {
   if (!who) return [];
@@ -393,8 +432,13 @@ export async function withdrawDateRequest(repo: Repo, who: Who, requestId: strin
   return (await hostRequests()).withdrawDateRequest(internal(repo), who, requestId);
 }
 
-/** Staff ("Publish content"): approve a host's date move. It runs as them (room clashes come back as warnings) and is recorded as the host's. Pass `seen`, the request's `updatedAt` you showed. */
-export async function approveDateRequest(repo: Repo, who: Who, requestId: string, context: WriteContext, seen?: number): Promise<{ request: import('../lib/schema').RequestRecord; moved: import('../lib/calendar/moves').MoveResult }> {
+/**
+ * Staff ("Publish content"): approve a host's date request. A move runs as
+ * them (room clashes come back as warnings) and is recorded as the host's
+ * (`moved`); a change from a date on runs changeFromDate (`changed`). Pass
+ * `seen`, the request's `updatedAt` you showed.
+ */
+export async function approveDateRequest(repo: Repo, who: Who, requestId: string, context: WriteContext, seen?: number): Promise<{ request: import('../lib/schema').RequestRecord; moved?: import('../lib/calendar/moves').MoveResult; changed?: import('../lib/calendar/segments').ChangeFromResult }> {
   return (await hostRequests()).approveDateRequest(internal(repo), who, requestId, context, seen);
 }
 
@@ -402,3 +446,57 @@ export async function approveDateRequest(repo: Repo, who: Who, requestId: string
 export async function declineDateRequest(repo: Repo, who: Who, requestId: string, reply: string, context: WriteContext, seen?: number): Promise<import('../lib/schema').RequestRecord> {
   return (await hostRequests()).declineDateRequest(internal(repo), who, requestId, reply, context, seen);
 }
+
+// ---- event requests without an account ---------------------------------------
+// The rules behind the built-in /request form, POST /api/v1/requests and
+// Calendar → Requests (acms({ requests })), for a site that builds its own
+// form or list. Asking needs no account; reading the list needs "Create and
+// edit content", answering "Publish content". Refusals carry a `status` and a
+// `code` (RequestRefusal: which field, closed, busy…) with an English message;
+// the built-in form shows each code in the visitor's language.
+
+const asks = () => import('../lib/calendar/request-service');
+
+/** What the request form offers: open or closed, the types and requestable rooms, and the site's words in this language. */
+export async function requestOptions(repo: Repo, locale = '') {
+  return (await asks()).requestOptions(internal(repo), locale);
+}
+
+/**
+ * Send a request from the site's own form. `key` is a random UUID v4 the page
+ * kept for this form (a retry with it never makes a second request); `address`
+ * is the client address (Astro.clientAddress) for the rate limit. The person
+ * is emailed that it arrived, and staff get an alert.
+ */
+export async function submitRequest(repo: Repo, input: import('../lib/calendar/request-service').RequestInput, opts: { key: string; address: string; context: WriteContext }): Promise<{ id: string; created: boolean }> {
+  const { id, created } = await (await asks()).submitRequest(internal(repo), input, { source: 'web', key: opts.key, address: opts.address, locals: opts.context.locals });
+  return { id, created };
+}
+
+/** Requests for staff ("Create and edit content"): filter by state, kind, event or member; pending ones oldest first, the rest newest first. */
+export async function listRequests(repo: Repo, who: Who, q: import('../lib/calendar/request-store').RequestQuery = {}): Promise<import('../lib/schema').RequestRecord[]> {
+  if (!who) throw Object.assign(new Error('Sign in to continue.'), { status: 401 });
+  if (!who.can('content.edit')) throw Object.assign(new Error('Your role doesn’t include “Create and edit content”.'), { status: 403 });
+  const pending = q.states?.length === 1 && q.states[0] === 'pending';
+  return internal(repo).requests.list({ order: pending ? 'oldest' : 'newest', ...q });
+}
+
+/** Staff approve: a new event becomes a filled-in draft; a change points at its event. `next` is where to go in the admin. */
+export async function approveRequest(repo: Repo, who: Who, id: string, context: WriteContext, seen?: number, opts: { message?: string; email?: boolean } = {}) {
+  return (await asks()).approveRequest(internal(repo), who, id, context, seen, opts);
+}
+
+/** Staff decline, with an optional reason emailed to the person in their language (`email: false` sends nothing). */
+export async function declineRequest(repo: Repo, who: Who, id: string, reason: string, context: WriteContext, seen?: number, opts: { email?: boolean } = {}) {
+  return (await asks()).declineRequest(internal(repo), who, id, reason, context, seen, opts);
+}
+
+/** Staff delete a request from the app or the website as spam, without emailing anyone. */
+export async function deleteRequest(repo: Repo, who: Who, id: string): Promise<void> {
+  return (await asks()).deleteRequest(internal(repo), who, id);
+}
+
+/** Staff email the person about their request (it stays as it is). */
+export async function replyToRequest(repo: Repo, who: Who, id: string, message: string, context: WriteContext) {
+  return (await asks()).replyToRequest(internal(repo), who, id, message, context);
+}

package/src/styles/editor.css

@@ -1346,4 +1346,6 @@ html.pe-evr-lock { overflow: hidden; }
 .pe-evd-rooms legend { font-size: 12px; color: var(--text-2); margin-bottom: 4px; padding: 0; }
 .pe-evd-room { display: inline-flex; align-items: center; gap: 6px; cursor: pointer; }
 .pe-evd-formacts { display: flex; gap: 8px; }
+.pe-evd-segs { margin-bottom: 8px; padding-bottom: 4px; border-bottom: 1px solid var(--line); }
+.pe-evd-hint { margin: 0; font-size: 12.5px; color: var(--text-2); }
 .pe-ev-note.is-error { color: var(--red); }

package/src/styles/site.css

@@ -1226,6 +1226,35 @@ li::marker { color: var(--muted); }
 .pc-simple-form form { display: grid; gap: 16px; }
 .pc-simple-form .pc-bk-field { margin: 0; }
 .pc-form-trap { position: absolute; left: -10000px; width: 1px; height: 1px; overflow: hidden; }
+/* Request an event (pages/request/index.astro). The kind toggle shows one set
+   of fields; without :has() both show and the server reads the chosen kind's. */
+.pc-rq .pc-rq-notice { color: var(--muted); margin: 0; }
+.pc-rq-sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
+.pc-rq-kind { display: grid; grid-template-columns: 1fr 1fr; gap: 4px; border: 1px solid var(--line-2, var(--line)); border-radius: 12px; padding: 4px; margin: 0; background: var(--soft); }
+.pc-rq-kind label { display: block; position: relative; }
+.pc-rq-kind input { position: absolute; opacity: 0; pointer-events: none; }
+.pc-rq-kind span { display: block; text-align: center; padding: 8px 10px; border-radius: 9px; font-size: 14.5px; font-weight: 550; cursor: pointer; color: var(--muted); }
+.pc-rq-kind input:checked + span { background: var(--panel); color: var(--ink); box-shadow: var(--sh-1); }
+.pc-rq-kind input:focus-visible + span { box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 22%, transparent); }
+.pc-rq-new, .pc-rq-change { display: grid; gap: 16px; }
+.pc-rq-form:has(input[name=kind][value=change]:checked) .pc-rq-new,
+.pc-rq-form:has(input[name=kind][value=new]:checked) .pc-rq-change { display: none; }
+.pc-rq-when { display: grid; grid-template-columns: 2fr 1fr 1fr; gap: 12px; }
+.pc-rq-when .pc-bk-field { margin: 0; }
+@media (max-width: 520px) { .pc-rq-when { grid-template-columns: 1fr 1fr; } .pc-rq-when > :first-child { grid-column: 1 / -1; } }
+.pc-rq-chips { display: flex; flex-wrap: wrap; gap: 6px; }
+.pc-rq-chips .pc-bk-option { min-height: 38px; padding: 6px 12px; }
+.pc-rq .pc-rq-other { margin: 8px 0 0; }
+.pc-rq-form:not(:has(input[name=repeat][value=other]:checked)) .pc-rq-other { display: none; }
+.pc-rq-free { margin: 8px 0 0; font-size: 14px; color: var(--muted); }
+.pc-rq-free:empty { display: none; }
+.pc-rq-contact { border: 0; padding: 0; margin: 0; display: grid; gap: 12px; min-width: 0; }
+.pc-rq-contact legend { font-weight: 650; font-size: 17px; padding: 0; margin-bottom: 8px; }
+.pc-rq-contact .pc-bk-hint { margin: 0; }
+.pc-rq-card { display: grid; gap: 2px; border: 1px solid var(--line); border-radius: var(--r); background: var(--panel); padding: 14px 16px; margin: 16px 0; }
+.pc-rq-card small { color: var(--muted); font-size: 12.5px; }
+.pc-rq-card span { color: var(--muted); font-size: 14.5px; }
+.pc-rq [aria-invalid=true] { border-color: var(--danger); }
 .pc-bk-check { display: flex; gap: 8px; align-items: start; margin-block: 12px; }
 .pc-bk-check input { width: auto; margin-top: 5px; }
 .pc-bk-check small, .pc-bk-field small { display: block; font-size: .85em; opacity: .8; }

package/src/virtual.d.ts

@@ -24,6 +24,7 @@ declare module 'virtual:acms-config' {
     permissions?: { key: string; label: string; description: string; defaults: string[]; sensitive: boolean }[];
     members?: { enabled: boolean; base: string; notify: string[]; hostMoves?: 'direct' | 'approve' };
     announcements?: { enabled: boolean; base: string; pages: boolean; topics: Partial<Record<'event' | 'registration' | 'help' | 'info', string>> };
+    requests?: { enabled: boolean; path: string; page: boolean };
     // set in astro:config:setup (lib/origin-check.ts): off only when the site turned security.checkOrigin off
     originCheck?: { enabled: boolean; signedRoutes: string[] };
     // resolved by integration.mjs (lib/calendar/config.ts documents the shape)