@semics-tech/emdash-events-suite 1.0.0-rc.0 → 1.0.0-rc.2

package/README.md

@@ -50,8 +50,12 @@ import { eventsSuite } from "@semics-tech/emdash-events-suite";
 export const suite = eventsSuite({ events: { pluginId: "r_events_id" }, esign: { pluginId: "r_esign_id" } });
 ```
 
-Pair the two cores in the admin: create an integration client in E-sign (Integrations), paste its
-pairing string into the Events settings, and allow `https://<your site>/booking` as a return URL.
+Pair the two cores: sign in to the admin as an administrator, open `/_events/pair` on your site and
+press **Pair with E-sign on this site**. The suite creates the E-sign integration client (and the master
+key, if none is set) and stores the pairing string in the Events settings for you; it is never shown.
+The site needs `EMDASH_ENCRYPTION_KEY` set, as for any secret setting. Pairing by hand still works:
+create an integration client in E-sign (Integrations) and paste its pairing string into the Events
+settings.
 
 ## Book with a waiver
 
@@ -80,4 +84,9 @@ scoped to that page.
 Paid waiver events: when continue answers with a payment step, the browser goes to the
 provider's checkout.
 
+After booking (Events Pro), `/booking` lists every attendee as Signed or Waiting, with **Sign now**
+(that attendee signs on this device), **Resend invitation** for emailed adults, and a form to correct the
+names and emails of attendees who have not signed until `attendeeEditCutoffHours` before the start. It
+needs the integration's `esignPluginId`, which `eventsSuite()` sets.
+
 The suite's own pages are English only for now.

package/dist/ts/index.d.ts

@@ -49,6 +49,8 @@ export interface EventsSuite {
 export declare const WAIVER_ROUTE = "/_events/waiver";
 /** The suite's catalogue page: where the Events panel's Refresh templates link lands (T066). */
 export declare const TEMPLATES_ROUTE = "/_events/templates";
+/** The suite's pairing page: pairs Events with E-sign on this site in one click (T145). */
+export declare const PAIR_ROUTE = "/_events/pair";
 /**
  * Injects `/_events/waiver` (the booking and signing steps of `<BookingWithWaiver>`) and gives it,
  * through a virtual module, the id of each core. `eventsSuite()` adds it for you.

package/dist/ts/index.js

@@ -20,6 +20,8 @@ const RESOLVED = `\0${VIRTUAL}`;
 export const WAIVER_ROUTE = "/_events/waiver";
 /** The suite's catalogue page: where the Events panel's Refresh templates link lands (T066). */
 export const TEMPLATES_ROUTE = "/_events/templates";
+/** The suite's pairing page: pairs Events with E-sign on this site in one click (T145). */
+export const PAIR_ROUTE = "/_events/pair";
 /** What Events' booking page runs for a booking waiting for signatures (T066). */
 const RECONCILE_MODULE = "@semics-tech/emdash-events-suite/astro/lib/reconcile";
 /**
@@ -45,6 +47,11 @@ export function suiteIntegration(ids) {
                     entrypoint: "@semics-tech/emdash-events-suite/astro/TemplatesPage.astro",
                     prerender: false,
                 });
+                injectRoute({
+                    pattern: PAIR_ROUTE,
+                    entrypoint: "@semics-tech/emdash-events-suite/astro/PairPage.astro",
+                    prerender: false,
+                });
                 updateConfig({
                     vite: {
                         plugins: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semics-tech/emdash-events-suite",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.2",
   "type": "module",
   "description": "Links semics Events and E-sign on one EmDash site: one config call and a booking flow with inline waiver signing",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "./astro/BookingWithWaiver.astro": "./src/astro/BookingWithWaiver.astro",
     "./astro/WaiverPage.astro": "./src/astro/WaiverPage.astro",
     "./astro/TemplatesPage.astro": "./src/astro/TemplatesPage.astro",
+    "./astro/PairPage.astro": "./src/astro/PairPage.astro",
     "./astro/lib/*": "./src/astro/lib/*.ts"
   },
   "files": [
@@ -21,8 +22,8 @@
     "src/astro"
   ],
   "dependencies": {
-    "@semics-tech/emdash-esign": "1.0.0-rc.0",
-    "@semics-tech/emdash-events": "1.0.0-rc.0"
+    "@semics-tech/emdash-esign": "1.0.0-rc.2",
+    "@semics-tech/emdash-events": "1.0.0-rc.2"
   },
   "peerDependencies": {
     "emdash": ">=1.2.0 <2"

package/src/astro/BookingWithWaiver.astro

@@ -8,7 +8,15 @@
 // Events Pro (waivers are Pro) the same form makes a plain booking. All text is rendered as text.
 import { eventsPluginId } from "virtual:semics-events-suite/config";
 import { callPublicRoute } from "@semics-tech/emdash-events/astro/lib/call";
-import { formatMoney, newIdempotencyKey, type PublicEvent } from "@semics-tech/emdash-events/astro/lib/widget";
+import {
+	pickerFetchFrom,
+	pickerHref,
+	pickerParam,
+	pickerView,
+	usesPicker,
+} from "@semics-tech/emdash-events/astro/lib/picker";
+import { fieldMessage, formatMoney, newIdempotencyKey, type PublicEvent } from "@semics-tech/emdash-events/astro/lib/widget";
+import { translator } from "@semics-tech/emdash-events/i18n";
 
 import {
 	DEFAULT_SEATS,
@@ -35,10 +43,18 @@ interface Props {
 const { event: eventId, heading = "Book with waiver", locale = "en-GB" } = Astro.props;
 const seats = Math.min(MAX_SEATS, Math.max(1, Math.trunc(Astro.props.seats ?? DEFAULT_SEATS)));
 let data = Astro.props.data;
+// The day-then-time picker's page (T130, T134): this widget's own `booking_from.<eventId>`, as Events' widget reads it.
+const pickerStart = Astro.url.searchParams.get(pickerParam(eventId));
 if (!data) {
-	const result = await callPublicRoute<PublicEvent>(Astro, { path: "public/event", pluginId: eventsPluginId, body: { eventId } });
+	const from = pickerFetchFrom(pickerStart);
+	const result = await callPublicRoute<PublicEvent>(Astro, {
+		path: "public/event",
+		pluginId: eventsPluginId,
+		body: { eventId, ...(from ? { from } : {}) },
+	});
 	if (result.ok) data = result.data;
 }
+const { t } = translator(locale);
 
 const id = waiverAnchor(eventId);
 const state = readWaiverState(Astro.url, eventId);
@@ -50,6 +66,14 @@ const occurrences = data?.occurrences ?? [];
 const onSale = data?.status === "on_sale" && ticketTypes.length > 0;
 const siteKey = data?.turnstileSiteKey ?? "";
 const price = (minor: number) => formatMoney(minor, data?.currency ?? "GBP", locale);
+// A slot schedule (or two starts a day): a month calendar of days, then the day's times. Without
+// JavaScript the same month's dates show as a select grouped by day. Dated events keep the plain select.
+const zone = data?.timezone ?? "UTC";
+const picker = usesPicker(data, zone)
+	? pickerView(occurrences, { zone, locale, start: pickerStart, now: Date.now(), more: data?.more === true })
+	: null;
+const monthId = `${id}-month`;
+const errId = `${id}-occurrence-error`;
 const when = (iso: string) => {
 	const options = { dateStyle: "full", timeStyle: "short" } as const;
 	try {
@@ -77,7 +101,103 @@ const single = ticketTypes.length === 1 ? ticketTypes[0] : undefined;
 				<input type="hidden" name="returnTo" value={returnTo} />
 				<input type="hidden" name="idempotencyKey" value={newIdempotencyKey()} />
 
-				{occurrences.length > 0 && (
+				{picker && (
+					<div class="semics-field semics-picker-field">
+						<input type="hidden" name="needsOccurrence" value="1" />
+						<div class="semics-field" data-picker-fallback>
+							<label for={`${id}-occurrence`}>{t("widget.date")}</label>
+							<select
+								id={`${id}-occurrence`}
+								name="occurrenceId"
+								required
+								aria-invalid={bad("occurrence")}
+								aria-describedby={[monthId, errId].join(" ")}
+							>
+								<option value="">{t("widget.chooseDate")}</option>
+								{picker.days.map((day) => (
+									<optgroup label={day.label}>
+										{day.slots.map((s) => (
+											<option value={s.id} disabled={s.full}>{s.label}</option>
+										))}
+									</optgroup>
+								))}
+							</select>
+						</div>
+						<nav class="semics-picker-nav" aria-labelledby={monthId}>
+							<p id={monthId} class="semics-picker-month">{picker.month.label}</p>
+							{picker.prev && <a href={pickerHref(Astro.url, picker.prev, eventId)} rel="nofollow">{t("widget.picker.earlier")}</a>}
+							{picker.next && <a href={pickerHref(Astro.url, picker.next, eventId)} rel="nofollow">{t("widget.picker.later")}</a>}
+						</nav>
+						{picker.days.length === 0 && <p data-testid="picker-none">{t("widget.picker.none")}</p>}
+						<fieldset
+							class="semics-picker"
+							data-picker
+							data-field="occurrence"
+							data-testid="booking-picker"
+							hidden
+							aria-invalid={bad("occurrence")}
+							aria-describedby={errId}
+						>
+							<legend>{t("widget.date")}</legend>
+							<table role="grid" class="semics-calendar" aria-labelledby={monthId}>
+								<thead>
+									<tr>
+										{picker.weekdays.map((w) => (
+											<th scope="col" abbr={w.long}>{w.short}</th>
+										))}
+									</tr>
+								</thead>
+								<tbody>
+									{picker.weeks.map((week) => (
+										<tr>
+											{week.map((cell) => (
+												<td>
+													{cell && cell.slots.length > 0 ? (
+														<button
+															type="button"
+															class={cell.open ? undefined : "semics-day-full"}
+															data-day={cell.key}
+															data-n={String(cell.day)}
+															aria-label={cell.buttonLabel}
+															aria-pressed="false"
+															tabindex={cell.key === picker.focusDay ? "0" : "-1"}
+														>
+															{cell.day}
+														</button>
+													) : cell ? (
+														<span class="semics-day-none">{cell.day}</span>
+													) : null}
+												</td>
+											))}
+										</tr>
+									))}
+								</tbody>
+							</table>
+							<p class="semics-hint" data-picker-hint>{t("widget.picker.hint")}</p>
+							{picker.days.map((day) => (
+								<div class="semics-times" role="radiogroup" data-times={day.key} aria-label={t("widget.picker.times", { date: day.label })} hidden>
+									{day.slots.map((s, i) => (
+										<button
+											type="button"
+											role="radio"
+											aria-checked="false"
+											aria-disabled={s.full ? "true" : undefined}
+											aria-label={s.label}
+											data-occurrence={s.id}
+											tabindex={i === day.slots.findIndex((x) => !x.full) ? "0" : "-1"}
+										>
+											<span>{s.time}</span>
+											{s.places && <span class="semics-places">{s.places}</span>}
+										</button>
+									))}
+								</div>
+							))}
+						</fieldset>
+						{bad("occurrence") && <p class="semics-field-error" id={errId}>{fieldMessage("occurrence", locale)}</p>}
+					</div>
+				)}
+
+				{!picker && occurrences.length > 0 && (
 					<div class="semics-field">
 						<input type="hidden" name="needsOccurrence" value="1" />
 						<label for={`${id}-occurrence`}>Date</label>
@@ -180,6 +300,10 @@ const single = ticketTypes.length === 1 ? ticketTypes[0] : undefined;
 	}
 </section>
 
+<script>
+	import "@semics-tech/emdash-events/client/picker";
+</script>
+
 <style>
 	.semics-waiver-widget {
 		--_fg: var(--events-fg, #1a1a1a);
@@ -210,6 +334,7 @@ const single = ticketTypes.length === 1 ? ticketTypes[0] : undefined;
 	}
 	.semics-waiver-widget form {
 		display: grid;
+		grid-template-columns: minmax(0, 1fr);
 		gap: 0.75rem;
 	}
 	.semics-waiver-widget fieldset {
@@ -254,6 +379,90 @@ const single = ticketTypes.length === 1 ? ticketTypes[0] : undefined;
 		border-color: var(--_error);
 		outline: 1px solid var(--_error);
 	}
+	.semics-hint {
+		color: var(--_muted);
+	}
+	.semics-picker-nav {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: baseline;
+		gap: 0.25rem 1rem;
+	}
+	.semics-picker-month {
+		margin: 0;
+		margin-inline-end: auto;
+		font-weight: 600;
+	}
+	.semics-picker-nav a {
+		color: var(--_accent);
+		min-block-size: 1.5rem;
+	}
+	.semics-picker {
+		display: grid;
+		gap: 0.5rem;
+		margin: 0;
+		padding: 0.5rem 0.75rem 0.75rem;
+		border: 1px solid var(--_border);
+		border-radius: var(--_radius);
+		min-inline-size: 0;
+	}
+	.semics-picker p {
+		margin: 0;
+	}
+	.semics-calendar {
+		inline-size: 100%;
+		border-collapse: collapse;
+		table-layout: fixed;
+		text-align: center;
+	}
+	.semics-calendar th {
+		padding-block: 0.25rem;
+		font-weight: 400;
+		font-size: 0.875rem;
+		color: var(--_muted);
+	}
+	.semics-calendar td {
+		padding: 1px;
+	}
+	.semics-waiver-widget .semics-calendar button,
+	.semics-waiver-widget .semics-times button {
+		inline-size: 100%;
+		padding: 0.25rem;
+		border: 1px solid var(--_accent);
+		background: var(--_bg);
+		color: var(--_accent);
+	}
+	.semics-waiver-widget .semics-calendar button.semics-day-full,
+	.semics-waiver-widget .semics-times button[aria-disabled="true"] {
+		border-color: var(--_border);
+		color: var(--_muted);
+		text-decoration: line-through;
+	}
+	.semics-waiver-widget .semics-times button[aria-disabled="true"] {
+		cursor: not-allowed;
+	}
+	.semics-waiver-widget .semics-calendar button[aria-pressed="true"],
+	.semics-waiver-widget .semics-times button[aria-checked="true"] {
+		background: var(--_accent);
+		color: var(--_accent-fg);
+	}
+	.semics-day-none {
+		display: block;
+		padding-block: 0.75rem;
+		color: var(--_muted);
+	}
+	.semics-times {
+		display: grid;
+		grid-template-columns: repeat(auto-fill, minmax(7rem, 1fr));
+		gap: 0.5rem;
+	}
+	.semics-waiver-widget .semics-times button {
+		display: grid;
+		justify-items: center;
+	}
+	.semics-places {
+		font-size: 0.875rem;
+	}
 	.semics-note {
 		margin: 0;
 		color: var(--_muted);

package/src/astro/PairPage.astro

@@ -0,0 +1,154 @@
+---
+// Injected at `/_events/pair` by the suite (T145): pairs Events with E-sign on this site in one click.
+// Administrators only (the host's own plugin-settings handler checks `plugins:manage`). The pairing
+// string goes from E-sign to Events' encrypted setting inside this request and is never sent to the
+// browser. The logic is in `lib/pair.ts`; this page only renders the state and posts the button.
+import { esignPluginId, eventsPluginId } from "virtual:semics-events-suite/config";
+import { crossSiteResponse, isCrossSiteRequest } from "@semics-tech/emdash-events/astro/lib/checkout-form";
+import { getPluginSetting } from "emdash";
+import { GET as readSettings, PUT as writeSettings } from "emdash/internal/routes/api/admin/plugins/_id_/settings";
+
+import { PAIR_PATH, type PairContext, type PairView, pairAction, pairingStatus } from "./lib/pair";
+
+export const prerender = false;
+
+Astro.response.headers.set("Referrer-Policy", "no-referrer");
+Astro.response.headers.set("Cache-Control", "private, no-store");
+
+const ids = { eventsPluginId, esignPluginId };
+// The host's handlers for `/_emdash/api/admin/plugins/<id>/settings`, run with this visitor's locals.
+const settingsUrl = (id: string) => new URL(`/_emdash/api/admin/plugins/${encodeURIComponent(id)}/settings`, Astro.url);
+const ctx: PairContext = {
+	locals: Astro.locals,
+	url: Astro.url,
+	// T149: the host's server-side read of Events' pairing (decrypted). `lib/pair.ts` calls it only after
+	// the admin check and keeps just the client id, so E-sign can report a hand-made pairing as it is.
+	readPairing: () => getPluginSetting(eventsPluginId, "esignPairing"),
+	settings: {
+		read: (id) =>
+			readSettings({ params: { id }, locals: Astro.locals, request: new Request(settingsUrl(id)) } as never) as Promise<Response>,
+		write: (id, values) =>
+			writeSettings({
+				params: { id },
+				locals: Astro.locals,
+				request: new Request(settingsUrl(id), {
+					method: "PUT",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ values }),
+				}),
+			} as never) as Promise<Response>,
+	},
+};
+
+if (isCrossSiteRequest(Astro.request, Astro.url)) return crossSiteResponse();
+
+const CODE = /^[A-Z0-9_]{1,64}$/;
+const STATES = new Set(["paired", "unpaired", "revoked", "esign-missing", "forbidden", "error"]);
+
+if (Astro.request.method === "POST") {
+	const form = await Astro.request.formData().catch(() => new FormData());
+	const action = form.get("action");
+	const result = await pairAction(ctx, ids, action);
+	const next = new URLSearchParams({ result: result.state });
+	if (result.code) next.set("code", result.code);
+	// T150: how many templates the action loaded for the panel (a count or an error code, nothing else).
+	if (action === "templates") next.set("did", "templates");
+	if (result.templates !== undefined) next.set("templates", String(result.templates));
+	if (result.templatesCode) next.set("tcode", result.templatesCode);
+	return Astro.redirect(`${PAIR_PATH}?${next}`, 303);
+}
+
+const view: PairView = await pairingStatus(ctx, ids);
+const query = Astro.url.searchParams;
+const result = query.get("result") ?? "";
+const resultCode = query.get("code") ?? "";
+const done = STATES.has(result) ? result : "";
+const doneCode = CODE.test(resultCode) ? resultCode : "";
+const refreshed = query.get("did") === "templates";
+const loaded = /^\d{1,3}$/.test(query.get("templates") ?? "") ? Number(query.get("templates")) : -1;
+const loadCode = CODE.test(query.get("tcode") ?? "") ? (query.get("tcode") as string) : "";
+if (view.state === "forbidden") Astro.response.status = 403;
+
+const templatesText =
+	loaded === 0
+		? "E-sign has no templates Available to integrations yet. Mark one in E-sign, then press Refresh templates here."
+		: loaded > 0
+			? `${loaded === 1 ? "One waiver template" : `${loaded} waiver templates`} loaded. The event panel offers ${loaded === 1 ? "it" : "them"} now (reload it if it is open).`
+			: loadCode === "NOT_FOUND"
+				? "Waiver templates need Events Pro, so there is nothing to load on this site."
+				: loadCode
+					? "The templates could not be loaded. Press Refresh templates to try again."
+					: "";
+
+const ERRORS: Record<string, string> = {
+	ENCRYPTION_KEY_MISSING: "Set EMDASH_ENCRYPTION_KEY in the site environment and restart, then try again.",
+	PLUGIN_SETTING_ENCRYPTION_KEY_MISSING: "Set EMDASH_ENCRYPTION_KEY in the site environment and restart, then try again.",
+	MASTER_KEY_INVALID:
+		"E-sign's integration master key is unreadable or too short. Fix it in E-sign's settings, then try again.",
+};
+const errorText = (code?: string) =>
+	(code && ERRORS[code]) || "Pairing did not finish. Please try again; if it keeps failing, check that E-sign is up to date.";
+---
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<meta name="robots" content="noindex" />
+		<meta name="referrer" content="no-referrer" />
+		<title>Pair Events with E-sign</title>
+	</head>
+	<body>
+		<main data-testid="pair-page" data-state={view.state}>
+			<h1>Pair Events with E-sign</h1>
+			{done === "paired" && !refreshed && <p role="status" data-testid="pair-done">Paired. Events can now ask for signed waivers.</p>}
+			{templatesText && <p role="status" data-testid="pair-templates">{templatesText}</p>}
+			{done === "unpaired" && <p role="status" data-testid="pair-done">Unpaired. Events no longer sends waivers to E-sign.</p>}
+			{done === "error" && <p role="alert" data-testid="pair-error">{errorText(doneCode)}</p>}
+			{view.state === "forbidden" && (
+				<p data-testid="pair-forbidden">
+					Sign in to the admin as an administrator, then open this page again. <a href="/_emdash/admin">Sign in</a>
+				</p>
+			)}
+			{view.state === "error" && <p role="alert" data-testid="pair-error">{errorText(view.code)}</p>}
+			{view.state === "esign-missing" && (
+				<p data-testid="pair-status">
+					E-sign is not installed or not enabled on this site.
+					{view.cleared && " The old pairing was removed, so Events asks for a pairing again."}
+				</p>
+			)}
+			{view.state === "unpaired" && (
+				<>
+					<p data-testid="pair-status">Events and E-sign are both installed but not paired yet.</p>
+					<form method="post" action={PAIR_PATH}>
+						<input type="hidden" name="action" value="pair" />
+						<button type="submit" data-testid="pair-button">Pair with E-sign on this site</button>
+					</form>
+				</>
+			)}
+			{view.state === "revoked" && (
+				<>
+					<p data-testid="pair-status">E-sign revoked this pairing. Pair again to keep using waivers.</p>
+					<form method="post" action={PAIR_PATH}>
+						<input type="hidden" name="action" value="pair" />
+						<button type="submit" data-testid="pair-button">Pair with E-sign on this site</button>
+					</form>
+				</>
+			)}
+			{view.state === "paired" && (
+				<>
+					<p data-testid="pair-status">Events is paired with E-sign on this site.</p>
+					<form method="post" action={PAIR_PATH}>
+						<input type="hidden" name="action" value="templates" />
+						<button type="submit" data-testid="templates-button">Refresh templates</button>
+						<span>Loads templates added in E-sign since, for the event panel's waiver select.</span>
+					</form>
+					<form method="post" action={PAIR_PATH}>
+						<input type="hidden" name="action" value="unpair" />
+						<button type="submit" data-testid="unpair-button">Unpair</button>
+					</form>
+				</>
+			)}
+		</main>
+	</body>
+</html>

package/src/astro/TemplatesPage.astro

@@ -8,8 +8,12 @@
 import { esignPluginId, eventsPluginId } from "virtual:semics-events-suite/config";
 import { crossSiteResponse, isCrossSiteRequest } from "@semics-tech/emdash-events/astro/lib/checkout-form";
 
+import { PAIR_PATH } from "./lib/pair";
 import { refreshCatalogue, TEMPLATES_PATH } from "./lib/templates";
 
+/** The admin's list of events, where the editor panel lives (it is scoped to the `events` collection). */
+const BACK_PATH = "/_emdash/admin/content/events";
+
 export const prerender = false;
 
 Astro.response.headers.set("Referrer-Policy", "no-referrer");
@@ -57,11 +61,15 @@ if (Astro.request.method === "POST") {
 							: count === 1
 								? "One template loaded."
 								: `${count} templates loaded.`}{" "}
-						Reload the event panel to choose one.
+						Step 2: go back to the event and reload its panel to choose one.
 					</p>
 				)
 			}
 			{count < 0 && !error && <p>Fetching the templates…</p>}
+			<p>
+				<a href={BACK_PATH} data-testid="templates-back">Back to your events</a>
+				{" "}(Refresh templates on <a href={PAIR_PATH}>{PAIR_PATH}</a> loads them in one step.)
+			</p>
 			<form method="post" action={TEMPLATES_PATH} data-semics-fragment="catalog" hidden>
 				<input type="hidden" name="catalog" value="" />
 			</form>

package/src/astro/WaiverPage.astro

@@ -12,6 +12,7 @@ import { crossSiteResponse } from "@semics-tech/emdash-events/astro/lib/checkout
 
 import { handleWaiverRequest } from "./lib/flow";
 import { WAIVER_MESSAGES, WAIVER_PATH } from "./lib/form";
+import { waiverSlot } from "./lib/slot";
 
 export const prerender = false;
 
@@ -31,6 +32,19 @@ Astro.response.headers.set("Content-Security-Policy", await ceremonyCsp());
 const render = outcome.type === "render" ? outcome : undefined;
 const ref = outcome.type === "render" || outcome.type === "error" ? (outcome.ref ?? "") : "";
 const error = outcome.type === "error" ? (WAIVER_MESSAGES[outcome.code] ?? WAIVER_MESSAGES.INTERNAL) : "";
+// The event and the booked date and time, so the signer can confirm what they sign for (T148).
+const slot = render
+	? await waiverSlot(
+			{ locals: Astro.locals, url: Astro.url, request: Astro.request, cookie: (name) => Astro.cookies.get(name)?.value },
+			{ eventsPluginId, esignPluginId },
+			ref,
+			undefined,
+			render.booking,
+		)
+	: undefined;
+// An expired or cancelled booking (T151): the message, a link back to the event, and no form.
+const expired = outcome.type === "error" && outcome.code === "BOOKING_EXPIRED";
+const eventLink = outcome.type === "error" ? outcome.href : undefined;
 const signer = render?.view.kind === "ready" ? render.view.session.signer : undefined;
 ---
 <!doctype html>
@@ -46,6 +60,7 @@ const signer = render?.view.kind === "ready" ? render.view.session.signer : unde
 		<main class="semics-esign semics-sign" data-testid="waiver-page" data-step={render ? "sign" : "error"}>
 			<h1>Sign the waiver</h1>
 			{error && <p role="alert" data-testid="waiver-error">{error}</p>}
+			{expired && eventLink && <p><a href={eventLink} data-testid="waiver-book-again">Book again</a></p>}
 			{
 				outcome.type === "error" && outcome.code === "SIGNING_UNAVAILABLE" && ref && (
 					<form method="post" action={`${WAIVER_PATH}?ref=${ref}`} data-testid="waiver-retry">
@@ -56,6 +71,13 @@ const signer = render?.view.kind === "ready" ? render.view.session.signer : unde
 			}
 			{render && (
 				<>
+					{slot && (
+						<p data-testid="waiver-slot">
+							{slot.title && <strong data-testid="waiver-event">{slot.title}</strong>}
+							{slot.title && slot.when && <br />}
+							{slot.when && <time datetime={slot.startsAt} data-testid="waiver-when">{slot.when}</time>}
+						</p>
+					)}
 					{signer?.participant && <p data-testid="waiver-for">Signing as guardian for <strong>{signer.participant}</strong>.</p>}
 					{render.remaining > 0 && (
 						<p data-testid="waiver-remaining">

package/src/astro/lib/flow.ts

@@ -26,6 +26,7 @@ import {
 	bookingCookieOptions,
 	isCrossSiteRequest,
 } from "@semics-tech/emdash-events/astro/lib/checkout-form";
+import { eventHref } from "@semics-tech/emdash-events/astro/lib/list";
 import { isPayUrl } from "@semics-tech/emdash-events/astro/lib/payment";
 import { forwardReceipt } from "@semics-tech/emdash-events/astro/lib/receipt";
 import { newIdempotencyKey } from "@semics-tech/emdash-events/astro/lib/widget";
@@ -39,6 +40,7 @@ import {
 	type WaiverOrder,
 	waiverErrorLocation,
 } from "./form.ts";
+import { voidEnvelopes } from "./reconcile.ts";
 
 /** The steps of the flow. `pay` is the Phase 4 slot: continue's `pay` answer is followed as it is. */
 export const FLOW_STEPS = ["book", "sign", "pay", "done"] as const;
@@ -65,13 +67,63 @@ export interface CookieOp {
 export type WaiverOutcome =
 	| { type: "redirect"; location: string; cookies: CookieOp[] }
 	/** Show `view` in `<SigningCeremony>`; `remaining` signers follow this one. */
-	| { type: "render"; ref: string; token: string; remaining: number; view: SignView; cookies: CookieOp[] }
-	| { type: "error"; code: string; ref?: string }
+	| {
+			type: "render";
+			ref: string;
+			token: string;
+			remaining: number;
+			view: SignView;
+			cookies: CookieOp[];
+			/** The booking as `public/booking` answered it, when this page could read it (T151). */
+			booking?: BookingAnswer;
+	  }
+	/** `href`: the event's page, for "book again" (`BOOKING_EXPIRED`, T151). */
+	| { type: "error"; code: string; ref?: string; href?: string }
 	| { type: "forbidden" };
 
 export interface FlowDeps {
 	/** Injected for tests: the idempotency key when the form carries none. */
 	newKey?: () => string;
+	/** Injected for tests: epoch milliseconds. */
+	now?: () => number;
+}
+
+/** What this page reads from Events `public/booking` (only the event's public details, T148/T151). */
+export interface BookingAnswer {
+	status?: string;
+	holdExpiresAt?: string;
+	eventId?: string;
+	occurrenceId?: string;
+	/** The event's public info; `startsAt` is the booked date's. Kept after the event leaves sale. */
+	event?: { title?: string; startsAt?: string; timezone?: string | null; slug?: string | null };
+	/** Pro, once the booking has ended: a void intent per seat not signed (T152). */
+	waiver?: { refs: string[]; voids?: Record<string, string> };
+}
+
+/** Booking statuses with nothing left to sign for: the places are gone (T151). */
+const ENDED = ["expired", "cancelled", "declined", "refunded", "refunded_unavailable"];
+
+/** The booking `ref`, read with this page's access token; undefined without one or when Events refuses. */
+export async function readBooking(
+	ctx: WaiverRequestContext,
+	ids: SuiteIds,
+	ref: string,
+): Promise<BookingAnswer | undefined> {
+	const accessToken = ctx.cookie(retryCookieName(ref)) || ctx.cookie(bookingCookieName(ref));
+	if (!accessToken) return undefined;
+	const call = { locals: ctx.locals, url: ctx.url, request: ctx.request };
+	const answer = await post<BookingAnswer>(call, ids.eventsPluginId, "public/booking", {
+		bookingRef: ref,
+		accessToken,
+	}).catch(() => undefined);
+	return answer?.ok ? answer.data : undefined;
+}
+
+/** Expired, cancelled, or a hold that lapsed before the sweeper got to it. */
+function ended(booking: BookingAnswer, now: number): boolean {
+	if (booking.status && ENDED.includes(booking.status)) return true;
+	const until = booking.holdExpiresAt ? Date.parse(booking.holdExpiresAt) : Number.NaN;
+	return Number.isFinite(until) && until <= now;
 }
 
 const BOOKING_REF = /^[0-9A-HJKMNP-TV-Z]{10}$/;
@@ -330,7 +382,12 @@ async function payOrLand(ctx: WaiverRequestContext, ids: SuiteIds, ref: string,
 	return next?.type === "pay" && isPayUrl(next.url) ? next.url : landed;
 }
 
-async function sign(ctx: WaiverRequestContext, ids: SuiteIds, form: FormData | null): Promise<WaiverOutcome> {
+async function sign(
+	ctx: WaiverRequestContext,
+	ids: SuiteIds,
+	form: FormData | null,
+	deps: FlowDeps,
+): Promise<WaiverOutcome> {
 	const ref = ctx.url.searchParams.get("ref") ?? "";
 	if (!BOOKING_REF.test(ref)) return redirect(BOOKING_PATH);
 	const error = ctx.url.searchParams.get("error");
@@ -340,6 +397,24 @@ async function sign(ctx: WaiverRequestContext, ids: SuiteIds, form: FormData | n
 	if (tokens.length === 0 || !tokens.every((t) => SIGNING_TOKEN.test(t))) {
 		return redirect(bookingPage(ref), tokens.length ? [flowCookie(ctx.url, ref, [])] : []);
 	}
+	// A booking whose places are gone has nothing to sign for (T151): no ceremony, and a post is refused
+	// before e-sign is asked, so no signature is captured for it. When Events cannot answer, signing goes on
+	// (its receipt step still confirms nothing for an ended booking).
+	const booking = await readBooking(ctx, ids, ref);
+	if (booking && ended(booking, (deps.now ?? Date.now)())) {
+		// T152: with Pro the answer carries void intents for the seats not signed; e-sign voids their
+		// envelopes, so the cookie's tokens sign nothing. A failure never changes the page.
+		if (booking.waiver?.voids) {
+			const call = { locals: ctx.locals, url: ctx.url, request: ctx.request };
+			await voidEnvelopes(call, {
+				booking: { bookingRef: ref, waiver: booking.waiver },
+				esignPluginId: ids.esignPluginId,
+			});
+		}
+		const href = booking.event?.slug ? eventHref({ slug: booking.event.slug }) : undefined;
+		return { type: "error", ref, code: "BOOKING_EXPIRED", ...(href ? { href } : {}) };
+	}
+	const withBooking = booking ? { booking } : {};
 	const call = { locals: ctx.locals, url: ctx.url, request: ctx.request };
 	const signCtx = { ...call, pluginId: ids.esignPluginId };
 	const forward = (receipt: string) =>
@@ -350,7 +425,7 @@ async function sign(ctx: WaiverRequestContext, ids: SuiteIds, form: FormData | n
 		const [token = "", ...after] = rest;
 		const view = await handleSign(signCtx, token, form);
 		if (view.kind === "ready" || view.kind === "error") {
-			return { type: "render", ref, token, remaining: after.length, view, cookies: [] };
+			return { type: "render", ref, token, remaining: after.length, view, cookies: [], ...withBooking };
 		}
 		// Signed, declined, or closed meanwhile (another tab): record the outcome with Events.
 		const receipt = receiptOf(view);
@@ -371,7 +446,7 @@ async function sign(ctx: WaiverRequestContext, ids: SuiteIds, form: FormData | n
 		const view = await handleSign(signCtx, token, null);
 		if (view.kind !== "closed") {
 			const cookies = rest.length === tokens.length ? [] : [flowCookie(ctx.url, ref, rest)];
-			return { type: "render", ref, token, remaining: after.length, view, cookies };
+			return { type: "render", ref, token, remaining: after.length, view, cookies, ...withBooking };
 		}
 		const receipt = receiptOf(view);
 		if (receipt) landed = (await forward(receipt)).location;
@@ -394,5 +469,5 @@ export async function handleWaiverRequest(
 	const form = ctx.request.method === "POST" ? await ctx.request.formData().catch(() => new FormData()) : null;
 	if (form?.get("intent") === "book") return book(ctx, form, ids, deps);
 	if (form?.get("intent") === "retry") return retry(ctx, ids);
-	return sign(ctx, ids, form);
+	return sign(ctx, ids, form, deps);
 }

package/src/astro/lib/form.ts

@@ -133,6 +133,7 @@ export const WAIVER_MESSAGES: Record<string, string> = {
 	RATE_LIMITED: "Too many bookings from this connection. Please wait a few minutes and try again.",
 	TURNSTILE_FAILED: "The security check did not pass. Please try again.",
 	HOLD_EXPIRED: "Your hold on these tickets expired. Please start again.",
+	BOOKING_EXPIRED: "This booking has expired. Please book again.",
 	NOT_FOUND: "This event is not taking bookings.",
 	SIGNING_UNAVAILABLE:
 		"The waiver could not be opened for signing just now. Your tickets are still held for a short time: try again, or contact the organiser.",

package/src/astro/lib/pair.ts

@@ -0,0 +1,203 @@
+/**
+ * Automatic pairing of Events with E-sign on one site (T145), behind `/_events/pair`.
+ *
+ * Sandbox facts this rests on (EmDash 1.2):
+ * - A sandboxed core reaches only its own settings, storage and KV (all scoped by
+ *   plugin id) and cannot call another plugin's routes, so neither core can pair the other.
+ * - Site pages run as native code. For a signed-in visitor `locals.emdash` carries
+ *   `handlePluginApiRoute`, which runs any route of a plugin (private ones too) in process with the
+ *   caller we pass; anonymous visitors only get `handlePublicPluginApiRoute`.
+ * - Plugin settings are written by the host's own handler (`PUT /_emdash/api/admin/plugins/<id>/settings`),
+ *   which checks `plugins:manage` on `locals.user`, validates against the manifest, encrypts secrets
+ *   and merges (only the keys sent; `null` deletes). Its answers mask secrets (`secretsSet`).
+ *
+ * So: the host's settings read checks the visitor is an administrator; E-sign's private
+ * `integrations/pair` (called as that administrator, with a fresh server-side `Request`) returns the
+ * pairing string for one reusable site client; the host's settings write stores it in Events
+ * (`esignPairing`, encrypted). The string lives only in this function's memory: it is never in a
+ * response, URL, cookie or log. Glue only: no rules, no tokens, no `@semics-tech/shared` (R35).
+ */
+
+import { loadCatalogue } from "./templates";
+
+/** The page (injected by `suiteIntegration`). */
+export const PAIR_PATH = "/_events/pair";
+const ESIGN_ROUTE = "integrations/pair";
+const SETTING = "esignPairing";
+
+export interface PairIds {
+	eventsPluginId: string;
+	esignPluginId: string;
+}
+
+/** The host's plugin-settings handlers, run in process with the visitor's `locals`. */
+export interface SettingsHandlers {
+	read(pluginId: string): Promise<Response>;
+	write(pluginId: string, values: Record<string, unknown>): Promise<Response>;
+}
+
+export interface PairContext {
+	locals: unknown;
+	url: URL;
+	settings: SettingsHandlers;
+	/**
+	 * Events' stored pairing string, decrypted on the server (`getPluginSetting` in the page). Only its
+	 * client id is used, so the page can tell E-sign which client Events holds (T149); the secret half
+	 * is dropped here and never leaves this process.
+	 */
+	readPairing?: () => Promise<unknown>;
+}
+
+export type PairState = "paired" | "unpaired" | "revoked" | "esign-missing" | "forbidden" | "error";
+export interface PairView {
+	state: PairState;
+	/** T150: templates loaded into Events Pro's catalogue by this action; absent when none could be. */
+	templates?: number;
+	/** T150: why the templates could not be loaded (an error code; `NOT_FOUND` on Free Events). */
+	templatesCode?: string;
+	/** An error code (never a message that could carry a value). */
+	code?: string;
+	/** The page removed a pairing left behind by an uninstalled E-sign. */
+	cleared?: true;
+}
+
+interface HandlerResponse {
+	success?: boolean;
+	data?: unknown;
+	error?: { code?: unknown; message?: unknown };
+}
+type RouteHandler = (
+	pluginId: string,
+	method: string,
+	path: string,
+	request: Request,
+	user?: unknown,
+) => Promise<HandlerResponse>;
+
+interface Admin {
+	call: RouteHandler;
+	user: unknown;
+}
+
+function adminOf(locals: unknown): Admin | null {
+	const l = (locals ?? {}) as { user?: unknown; emdash?: { handlePluginApiRoute?: unknown } };
+	const call = l.emdash?.handlePluginApiRoute;
+	return typeof call === "function" && l.user ? { call: call as RouteHandler, user: l.user } : null;
+}
+
+type EsignAnswer =
+	| { kind: "missing" }
+	| { kind: "error"; code: string }
+	| { kind: "ok"; data: Record<string, unknown> };
+
+const PAIRING_ID = /^esign1\.([A-Za-z0-9_-]{4,64})\.[A-Za-z0-9_-]{43}$/;
+
+/** The client id of the pairing Events holds (a hand-made one too), or undefined. Never the secret. */
+async function heldClientId(ctx: PairContext): Promise<string | undefined> {
+	const value = await ctx.readPairing?.().catch(() => undefined);
+	return typeof value === "string" ? PAIRING_ID.exec(value)?.[1] : undefined;
+}
+
+/** E-sign's `integrations/pair`, in process. "missing" only when the host says the plugin is not there. */
+async function esign(
+	ctx: PairContext,
+	admin: Admin,
+	ids: PairIds,
+	action: string,
+	clientId?: string,
+): Promise<EsignAnswer> {
+	const request = new Request(new URL(`/_emdash/api/plugins/${ids.esignPluginId}/${ESIGN_ROUTE}`, ctx.url), {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(clientId ? { action, clientId } : { action }),
+	});
+	const res = await admin.call(ids.esignPluginId, "POST", ESIGN_ROUTE, request, admin.user).catch(() => null);
+	if (!res) return { kind: "error", code: "INTERNAL" };
+	if (!res.success) {
+		const message = typeof res.error?.message === "string" ? res.error.message : "";
+		if (res.error?.code === "NOT_FOUND" && /^Plugin not (enabled|found)/.test(message)) return { kind: "missing" };
+		return { kind: "error", code: typeof res.error?.code === "string" ? res.error.code : "INTERNAL" };
+	}
+	const data = (res.data ?? {}) as Record<string, unknown>;
+	if (data.ok !== true) {
+		const code = (data.error as { code?: unknown } | undefined)?.code;
+		return { kind: "error", code: typeof code === "string" ? code : "INTERNAL" };
+	}
+	return { kind: "ok", data };
+}
+
+/** Whether Events holds a pairing string, or null when the visitor may not manage plugins. */
+async function eventsPaired(ctx: PairContext, ids: PairIds): Promise<boolean | null> {
+	const res = await ctx.settings.read(ids.eventsPluginId).catch(() => null);
+	if (!res?.ok) return null;
+	const body = (await res.json().catch(() => ({}))) as { data?: { secretsSet?: Record<string, unknown> } };
+	return body.data?.secretsSet?.[SETTING] === true;
+}
+
+/** Writes Events' pairing setting (`null` removes it); the error code on failure. */
+async function writePairing(ctx: PairContext, ids: PairIds, value: string | null): Promise<string | null> {
+	const res = await ctx.settings.write(ids.eventsPluginId, { [SETTING]: value }).catch(() => null);
+	if (res?.ok) return null;
+	const body = (await res?.json().catch(() => ({}))) as { error?: { code?: unknown } } | undefined;
+	return typeof body?.error?.code === "string" ? body.error.code : "INTERNAL";
+}
+
+/**
+ * The page's state for a GET. A pairing left in Events after E-sign was removed is cleared here, so
+ * Events goes back to asking for one (the "pairing" waiver state) instead of minting intents nobody
+ * can redeem; that write only ever removes a pairing that cannot work.
+ */
+export async function pairingStatus(ctx: PairContext, ids: PairIds): Promise<PairView> {
+	const admin = adminOf(ctx.locals);
+	if (!admin) return { state: "forbidden" };
+	const paired = await eventsPaired(ctx, ids);
+	if (paired === null) return { state: "forbidden" };
+	const status = await esign(ctx, admin, ids, "status", paired ? await heldClientId(ctx) : undefined);
+	if (status.kind === "missing") {
+		if (!paired) return { state: "esign-missing" };
+		const failed = await writePairing(ctx, ids, null);
+		return failed ? { state: "error", code: failed } : { state: "esign-missing", cleared: true };
+	}
+	if (status.kind === "error") return { state: "error", code: status.code };
+	if (!paired) return { state: "unpaired" };
+	return { state: status.data.client === "active" ? "paired" : "revoked" };
+}
+
+/**
+ * T150: loads E-sign's templates into Events Pro's catalogue (`loadCatalogue`, in process), so the
+ * panel offers them without its Refresh link. Free has no catalogue: no count, the paired state stands.
+ */
+async function withTemplates(ctx: PairContext, ids: PairIds, view: PairView, report: boolean): Promise<PairView> {
+	const loaded = await loadCatalogue({ locals: ctx.locals as never, url: ctx.url }, ids);
+	if (loaded.ok) return { ...view, templates: loaded.count };
+	return report ? { ...view, templatesCode: loaded.code } : view;
+}
+
+/** The page's POST: `pair` (idempotent), `unpair`, or `templates` (fetch the catalogue again, T150). */
+export async function pairAction(ctx: PairContext, ids: PairIds, action: unknown): Promise<PairView> {
+	if (action !== "pair" && action !== "unpair" && action !== "templates")
+		return { state: "error", code: "BAD_REQUEST" };
+	const admin = adminOf(ctx.locals);
+	if (!admin) return { state: "forbidden" };
+	const paired = await eventsPaired(ctx, ids);
+	if (paired === null) return { state: "forbidden" };
+	const held = paired ? await heldClientId(ctx) : undefined;
+
+	if (action === "templates") {
+		return paired ? withTemplates(ctx, ids, { state: "paired" }, true) : { state: "unpaired" };
+	}
+	if (action === "unpair") {
+		const revoked = await esign(ctx, admin, ids, "unpair", held);
+		if (revoked.kind === "error") return { state: "error", code: revoked.code };
+		const failed = await writePairing(ctx, ids, null);
+		return failed ? { state: "error", code: failed } : { state: "unpaired" };
+	}
+
+	const made = await esign(ctx, admin, ids, "pair", held);
+	if (made.kind === "missing") return { state: "esign-missing" };
+	if (made.kind === "error") return { state: "error", code: made.code };
+	const pairing = made.data.pairing;
+	if (typeof pairing !== "string" || !pairing.startsWith("esign1.")) return { state: "error", code: "INTERNAL" };
+	const failed = await writePairing(ctx, ids, pairing);
+	return failed ? { state: "error", code: failed } : withTemplates(ctx, ids, { state: "paired" }, false);
+}

package/src/astro/lib/reconcile.ts

@@ -33,8 +33,41 @@ const RECEIPT_MAX = 2048;
 const tokenOf = (value: unknown, max: number): string | null =>
 	typeof value === "string" && value.length <= max && TOKEN.test(value) ? value : null;
 
+const INTENT_MAX = 4096;
+
+/**
+ * T152: an ended booking (expired, cancelled) carries, with Pro, a `replace` intent per seat not signed.
+ * Each goes to e-sign's `from-intent`, which voids the seat's open envelope and creates nothing, so a
+ * signing token lifted from the waiver cookie signs nothing any more. Idempotent (a voided or completed
+ * envelope is left alone), so every visit may send them again. Resolves with how many e-sign accepted.
+ */
+export async function voidEnvelopes(
+	ctx: PublicRouteContext,
+	input: Pick<ReconcileInput, "booking" | "esignPluginId">,
+): Promise<number> {
+	const intents = Object.values(input.booking.waiver?.voids ?? {})
+		.slice(0, MAX_LOOKUPS)
+		.map((intent) => tokenOf(intent, INTENT_MAX))
+		.filter((token): token is string => token !== null);
+	const answers = await Promise.all(
+		intents.map((intent) =>
+			callPublicRoute(ctx, {
+				method: "POST",
+				path: "public/envelopes/from-intent",
+				pluginId: input.esignPluginId,
+				body: { intent },
+			}).catch(() => null),
+		),
+	);
+	return answers.filter((a) => a?.ok).length;
+}
+
 /** Forwards the receipts e-sign already holds for the booking's unsigned refs; resolves with how many Events took. */
-export async function reconcileBooking(ctx: PublicRouteContext, input: ReconcileInput): Promise<{ forwarded: number }> {
+export async function reconcileBooking(
+	ctx: PublicRouteContext,
+	input: ReconcileInput,
+): Promise<{ forwarded: number; voided?: number }> {
+	if (input.booking.waiver?.voids) return { forwarded: 0, voided: await voidEnvelopes(ctx, input) };
 	const { refs = [], lookups = {} } = input.booking.waiver ?? {};
 	const requests = refs
 		.slice(0, MAX_LOOKUPS)

package/src/astro/lib/slot.ts

@@ -0,0 +1,98 @@
+/**
+ * What the waiver page says about the booking it is signing for (T148): the event's title and the
+ * booked date and time, in the event's own zone and in the format of the booking widget's date list.
+ * Read through Events' public routes: `public/booking` carries the event's public info with the
+ * booked date's start (T151), so a booking made while on sale keeps its line after the event moves
+ * to draft or paused, when `public/event` answers nothing. An Events build without it falls back to
+ * `public/event`. Only the event's own public details: no personal data. Any failure shows nothing extra.
+ */
+import { callPublicRoute, type PublicRouteContext } from "@semics-tech/emdash-events/astro/lib/call";
+
+import { type BookingAnswer, readBooking, type SuiteIds } from "./flow.ts";
+
+export interface WaiverSlot {
+	title?: string;
+	/** "Wednesday 4 November 2026 at 13:30" in the event's zone; absent when the date is unknown. */
+	when?: string;
+	/** The ISO start, for a `<time datetime>`. */
+	startsAt?: string;
+}
+
+interface EventAnswer {
+	title?: string;
+	timezone?: string;
+	startsAt?: string;
+	occurrences?: Array<{ id: string; startsAt: string }>;
+}
+
+/** The widget's date format (full date, short time) in `zone`; UTC when the zone is unknown. */
+export function formatSlot(iso: string, zone: string | undefined, locale = "en-GB"): string {
+	const options = { dateStyle: "full", timeStyle: "short" } as const;
+	const date = new Date(iso);
+	try {
+		return new Intl.DateTimeFormat(locale, { ...options, timeZone: zone ?? "UTC" }).format(date);
+	} catch {
+		return new Intl.DateTimeFormat(locale, { ...options, timeZone: "UTC" }).format(date);
+	}
+}
+
+/** The booked start and the event's title and zone, from the booking or else from `public/event`. */
+async function slotInfo(
+	ctx: PublicRouteContext,
+	ids: SuiteIds,
+	booking: BookingAnswer,
+): Promise<{ title?: string; startsAt?: string; timezone?: string } | undefined> {
+	const own = booking.event;
+	if (own) {
+		return {
+			...(own.title ? { title: own.title } : {}),
+			...(own.startsAt ? { startsAt: own.startsAt } : {}),
+			...(own.timezone ? { timezone: own.timezone } : {}),
+		};
+	}
+	if (!booking.eventId) return undefined;
+	const event = await callPublicRoute<EventAnswer>(ctx, {
+		path: "public/event",
+		pluginId: ids.eventsPluginId,
+		body: { eventId: booking.eventId },
+	});
+	if (!event.ok) return undefined;
+	const { occurrenceId } = booking;
+	const startsAt = occurrenceId
+		? event.data.occurrences?.find((o) => o.id === occurrenceId)?.startsAt
+		: event.data.startsAt;
+	return {
+		...(event.data.title ? { title: event.data.title } : {}),
+		...(startsAt ? { startsAt } : {}),
+		...(event.data.timezone ? { timezone: event.data.timezone } : {}),
+	};
+}
+
+/**
+ * The slot line for booking `ref`. `booking` is the `public/booking` answer the page already read
+ * (the flow's render outcome carries it); without it the booking is read here.
+ */
+export async function waiverSlot(
+	ctx: { locals: PublicRouteContext["locals"]; url: URL; request: Request; cookie(name: string): string | undefined },
+	ids: SuiteIds,
+	ref: string,
+	locale?: string,
+	booking?: BookingAnswer,
+): Promise<WaiverSlot | undefined> {
+	const call = { locals: ctx.locals, url: ctx.url, request: ctx.request };
+	try {
+		const answer = booking ?? (await readBooking(ctx, ids, ref));
+		const info = answer && (await slotInfo(call, ids, answer));
+		if (!info) return undefined;
+		const { startsAt } = info;
+		const slot: WaiverSlot = {
+			...(info.title ? { title: info.title } : {}),
+			...(startsAt && Number.isFinite(Date.parse(startsAt))
+				? { startsAt, when: formatSlot(startsAt, info.timezone, locale) }
+				: {}),
+		};
+		return slot.title || slot.when ? slot : undefined;
+	} catch {
+		return undefined;
+	}
+}

package/src/astro/lib/templates.ts

@@ -74,3 +74,41 @@ export async function refreshCatalogue(
 	if (!cached) return { ok: false, code: "INTERNAL" };
 	return cached.ok ? { ok: true, count: templates.length } : { ok: false, code: cached.error.code };
 }
+
+const REQUEST_ROUTE = "esign/catalog-request";
+
+type PrivateRoute = (
+	pluginId: string,
+	method: string,
+	path: string,
+	request: Request,
+	user?: unknown,
+) => Promise<{ success?: boolean; data?: unknown; error?: { code?: unknown; message?: unknown } }>;
+
+/**
+ * The catalogue fetch without a link (T150): asks Events Pro's private `esign/catalog-request` in
+ * process, as the signed-in administrator in `ctx.locals`, for a fresh request, then runs
+ * `refreshCatalogue` with it. The request never leaves the server. Free Events has no such route:
+ * `NOT_FOUND`. Never throws.
+ */
+export async function loadCatalogue(ctx: PublicRouteContext, ids: CatalogueIds): Promise<CatalogueResult> {
+	const l = (ctx.locals ?? {}) as { user?: unknown; emdash?: { handlePluginApiRoute?: unknown } };
+	const call = l.emdash?.handlePluginApiRoute;
+	if (typeof call !== "function" || !l.user) return { ok: false, code: "FORBIDDEN" };
+	const asked = new Request(new URL(`/_emdash/api/plugins/${ids.eventsPluginId}/${REQUEST_ROUTE}`, ctx.url), {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: "{}",
+	});
+	const res = await (call as PrivateRoute)(ids.eventsPluginId, "POST", REQUEST_ROUTE, asked, l.user).catch(() => null);
+	const data = (res?.success ? res.data : null) as {
+		ok?: unknown;
+		request?: unknown;
+		error?: { code?: unknown };
+	} | null;
+	if (data?.ok === true) return refreshCatalogue(ctx, data.request, ids);
+	// A sandboxed core without the route (Free): the host answers ROUTE_ERROR "… Route not found …".
+	const missing = typeof res?.error?.message === "string" && /\bRoute not found\b/.test(res.error.message);
+	const code = missing ? "NOT_FOUND" : (data?.error?.code ?? res?.error?.code);
+	return { ok: false, code: typeof code === "string" ? code : "INTERNAL" };
+}