@bygghammar/cms-platform 0.96.0 → 0.97.0

package/src/popups/runtime.tsx

@@ -25,7 +25,8 @@ import type {
 import { ManagedForm } from "../forms/FormRenderer";
 import { onFormSubmissionSuccess } from "../forms/success-listeners";
 import { siteConfig } from "../config/site-config";
-import { containsBookingTarget, isBookingHref, stripBookingDeep } from "../cms/booking-links";
+import { containsBookingTarget, containsLinkTo, isBookingHref, stripBookingDeep } from "../cms/booking-links";
+import { isHiddenFromDiscovery, type LinkVisibilityPolicy } from "../navigation/visibility";
 import { useLinkVisibility } from "../site/link-visibility";
 import type { PopupPublicHost } from "./host";
 import { popupPublicHost } from "./host";
@@ -111,14 +112,25 @@ export function PopupModuleRuntime(): ReactNode {
    * it found through the same rules, and only the latest read counts, so one
    * begun under the old policy cannot bring booking back. Without a policy
    * provider booking is visible and nothing changes.
+   *
+   * The same goes for a popup that leads to a page hidden from the website
+   * while booking is hidden (a booking-off landing page): not offered, and
+   * retired if it is the one on screen, until the page is shown again.
    */
-  const bookingVisible = useLinkVisibility().bookingVisible;
+  const linkPolicy = useLinkVisibility();
+  const bookingVisible = linkPolicy.bookingVisible;
+  const hiddenKey = hiddenPagesKey(linkPolicy);
   const [loaded, setLoaded] = useState<readonly PopupConfig[] | null>(null);
   const offered = useRef<Offered>(NOTHING_OFFERED);
   const offer = useMemo(
-    () => popupsToOffer(loaded ?? [], offered.current, bookingVisible),
-    // `offered` is what the runtime was last handed, read for identity only.
-    [loaded, bookingVisible],
+    () =>
+      popupsToOffer(loaded ?? [], offered.current, bookingVisible, (href) =>
+        isHiddenFromDiscovery(href, linkPolicy),
+      ),
+    // `offered` is what the runtime was last handed, read for identity only;
+    // the policy matters only through what `hiddenKey` names.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [loaded, bookingVisible, hiddenKey],
   );
   useEffect(() => {
     offered.current = offer;
@@ -126,14 +138,23 @@ export function PopupModuleRuntime(): ReactNode {
 
   // The repository is asked again when the host or the policy changes — and
   // only once the runtime asks for its popups, so never where it does not run.
-  const askedFor = useRef<{ configs: PopupPublicHost["configs"]; bookingVisible: boolean } | null>(null);
+  const askedFor = useRef<{
+    configs: PopupPublicHost["configs"];
+    bookingVisible: boolean;
+    hiddenKey: string;
+  } | null>(null);
   const latestRead = useRef(0);
   const configs = useMemo<RuntimeAdapters["configs"]>(
     () => ({
       listActive: async () => {
         const asked = askedFor.current;
-        if (asked === null || asked.configs !== host.configs || asked.bookingVisible !== bookingVisible) {
-          askedFor.current = { configs: host.configs, bookingVisible };
+        if (
+          asked === null ||
+          asked.configs !== host.configs ||
+          asked.bookingVisible !== bookingVisible ||
+          asked.hiddenKey !== hiddenKey
+        ) {
+          askedFor.current = { configs: host.configs, bookingVisible, hiddenKey };
           const read = ++latestRead.current;
           Promise.resolve()
             .then(() => host.configs.listActive())
@@ -152,7 +173,7 @@ export function PopupModuleRuntime(): ReactNode {
         return offer.list;
       },
     }),
-    [host.configs, bookingVisible, offer],
+    [host.configs, bookingVisible, hiddenKey, offer],
   );
 
   // The argument type comes from the port, not a copy of it: a package that
@@ -189,6 +210,15 @@ type ContentBlock = PopupConfig["steps"][number]["blocks"][number];
 type PopupButton = Extract<ContentBlock, { type: "buttons" }>["buttons"][number];
 type BlockAction = PopupButton["action"];
 
+/** The booking-off pages a policy hides, as one comparable string. */
+function hiddenPagesKey(policy: LinkVisibilityPolicy): string {
+  return Object.entries(policy.hiddenPaths)
+    .filter(([, reason]) => reason === "booking-off")
+    .map(([path]) => path)
+    .sort()
+    .join("\n");
+}
+
 /** The list last handed to the runtime, and each popup's content, by key. */
 type Offered = { list: readonly PopupConfig[]; content: ReadonlyMap<string, string> };
 const NOTHING_OFFERED: Offered = { list: [], content: new Map() };
@@ -197,7 +227,8 @@ const NOTHING_OFFERED: Offered = { list: [], content: new Map() };
  * What the runtime is handed from a load, given what it already holds.
  *
  * - While booking is hidden, a popup that leads to booking is not offered: it
- *   is handed over retired (see {@link retire}).
+ *   is handed over retired (see {@link retire}). So is a popup that leads to
+ *   a page hidden while booking is hidden (`hiddenPage`).
  * - A popup the runtime already holds is never dropped, even when the load no
  *   longer has it (a server that withholds booking popups, a popup paused or
  *   deleted since). The runtime tracks the open popup by key, so dropping the
@@ -213,7 +244,11 @@ function popupsToOffer(
   loaded: readonly PopupConfig[],
   previous: Offered,
   bookingVisible: boolean,
+  hiddenPage: (href: string) => boolean,
 ): Offered {
+  const hideBooking = !bookingVisible;
+  const withheld = (popup: PopupConfig) =>
+    (hideBooking && containsBookingTarget(popup)) || containsLinkTo(popup, hiddenPage);
   const held = new Map(previous.list.map((popup) => [popup.key, popup]));
   const content = new Map<string, string>();
   const list: PopupConfig[] = [];
@@ -224,10 +259,10 @@ function popupsToOffer(
     list.push(same !== undefined && previous.content.get(popup.key) === text ? same : popup);
   };
   for (const popup of loaded) {
-    offer(bookingVisible || !containsBookingTarget(popup) ? popup : retire(popup, true));
+    offer(withheld(popup) ? retire(popup, hideBooking, hiddenPage) : popup);
   }
   for (const popup of previous.list) {
-    if (!content.has(popup.key)) offer(retire(popup, !bookingVisible));
+    if (!content.has(popup.key)) offer(retire(popup, hideBooking, hiddenPage));
   }
   const unchanged =
     list.length === previous.list.length && list.every((popup, index) => popup === previous.list[index]);
@@ -237,43 +272,51 @@ function popupsToOffer(
 /**
  * A popup the runtime keeps but never offers again.
  *
- * Paused, which the runtime neither shows nor reports as suppressed. With
- * `hideBooking`, everything in it that leads to booking is taken out too —
- * links, buttons, an answer or a form that would open the booking site now
- * simply closes — so if it is the one on screen, the visitor keeps what they
- * were reading, cannot reach booking from it, and closes it the usual way.
- * The stored popup is not touched; this is the copy the visitor sees.
+ * Paused, which the runtime neither shows nor reports as suppressed. Every
+ * place in it that leads to booking (with `hideBooking`) or to a page hidden
+ * while booking is hidden (`hiddenPage`) is taken out too: links and
+ * buttons go, an answer or a form that would open it now simply closes. So if
+ * it is the one on screen, the visitor keeps what they were reading, cannot
+ * follow it anywhere it must not lead, and closes it the usual way. The
+ * stored popup is not touched; this is the copy the visitor sees.
  */
-function retire(popup: PopupConfig, hideBooking: boolean): PopupConfig {
+function retire(
+  popup: PopupConfig,
+  hideBooking: boolean,
+  hiddenPage: (href: string) => boolean,
+): PopupConfig {
+  const blocked = (href: string) => (hideBooking && isBookingHref(href)) || hiddenPage(href);
   const paused: PopupConfig = { ...popup, status: "paused" };
-  if (!hideBooking) return paused;
-  return stripBookingDeep({
+  const cleaned: PopupConfig = {
     ...paused,
-    steps: paused.steps.map((step) => ({ ...step, blocks: step.blocks.flatMap(withoutBookingTargets) })),
-  });
+    steps: paused.steps.map((step) => ({
+      ...step,
+      blocks: step.blocks.flatMap((block) => withoutTargets(block, blocked)),
+    })),
+  };
+  // Booking links inside text are removed as before, and only for booking.
+  return hideBooking ? stripBookingDeep(cleaned) : cleaned;
 }
 
-function withoutBookingTargets(block: ContentBlock): ContentBlock[] {
+function withoutTargets(block: ContentBlock, blocked: (href: string) => boolean): ContentBlock[] {
+  const opens = (action: BlockAction) => action.kind === "openUrl" && blocked(action.href);
+  const closingInstead = (button: PopupButton): PopupButton =>
+    opens(button.action) ? { ...button, action: { kind: "close" } } : button;
   switch (block.type) {
     case "link":
-      return isBookingHref(block.href) ? [] : [block];
+      return blocked(block.href) ? [] : [block];
     case "buttons": {
-      const buttons = block.buttons.filter((button) => !opensBooking(button.action));
+      const buttons = block.buttons.filter((button) => !opens(button.action));
       return buttons.length === 0 ? [] : [{ ...block, buttons }];
     }
     case "choice":
       return [{ ...block, yes: closingInstead(block.yes), no: closingInstead(block.no) }];
     case "form":
-      return [opensBooking(block.onSuccess) ? { ...block, onSuccess: { kind: "close" } } : block];
+      return [opens(block.onSuccess) ? { ...block, onSuccess: { kind: "close" } } : block];
     default:
       return [block];
   }
 }
 
-const opensBooking = (action: BlockAction) => action.kind === "openUrl" && isBookingHref(action.href);
-
-const closingInstead = (button: PopupButton): PopupButton =>
-  opensBooking(button.action) ? { ...button, action: { kind: "close" } } : button;
-
 // Default export so the module host can load this file lazily.
 export default PopupModuleRuntime;

package/src/server/page-visibility-core.ts

@@ -11,6 +11,11 @@
  * | `page.listing.<page uuid>`    | `{ "listing": "link-only" }`   | listed         |
  * | `booking`                     | `{ "enabled": false }`         | booking on     |
  * | `booking.exception.<uuid>`    | `{ "exception": true }`        | no exception   |
+ * | `booking.landing.<uuid>`      | `{ "landing": true, "notice"?: … }` | not a landing page |
+ * | `booking.landing.default`     | `{ "notice": … }`              | built-in copy  |
+ *
+ * A landing page leaves the site's menus and page lists while booking is off
+ * and stays live and indexable (see `cms/booking-landing`).
  *
  * Keys use the page's id, never its key or address, so every alias and locale
  * of a page shares one decision, a restored page keeps its own, and a page
@@ -25,6 +30,14 @@
  * None of these rows is an `OVERRIDABLE_SETTING_KEYS` key, so the generic
  * settings save and reset cannot read, overwrite or erase them.
  */
+import {
+  NoticeValidationError,
+  noticeLinkHrefs,
+  normalizeNoticeContent,
+  normalizePageNoticeOverride,
+  type NoticeContent,
+  type PageNoticeOverride,
+} from "../cms/booking-landing";
 import { EDIT_LOCK_TYPES } from "../cms/edit-lock";
 import {
   nextPublicationBoundary,
@@ -49,6 +62,8 @@ export const SITE_SETTINGS = "site_settings";
 export const PAGE_LISTING_PREFIX = "page.listing.";
 export const BOOKING_SETTING_KEY = "booking";
 export const BOOKING_EXCEPTION_PREFIX = "booking.exception.";
+export const BOOKING_LANDING_PREFIX = "booking.landing.";
+export const BOOKING_LANDING_DEFAULT_KEY = "booking.landing.default";
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
@@ -63,8 +78,28 @@ export type VisibilityDeps = {
    * by the browser.
    */
   protectedPageKeys: readonly string[];
+  /**
+   * The host's check of a booking-off notice link against its own routes:
+   * why the link may not be used (it leads to the host's booking page, or to a
+   * page hidden while booking is hidden), or null. Supplied by the host's
+   * server code. Without it only the platform's own rules apply (no booking
+   * site, safe address forms).
+   */
+  noticeTargetProblem?: (href: string) => string | null | Promise<string | null>;
 };
 
+/** Refuse a notice whose link the host says leads to booking or to a hidden page. */
+async function assertNoticeTargets(
+  deps: Pick<VisibilityDeps, "noticeTargetProblem">,
+  notice: NoticeContent | PageNoticeOverride,
+): Promise<void> {
+  if (!deps.noticeTargetProblem) return;
+  for (const href of noticeLinkHrefs(notice)) {
+    const problem = await deps.noticeTargetProblem(href);
+    if (problem) throw new NoticeValidationError(problem);
+  }
+}
+
 /** Someone else changed the same decision since the editor last looked. */
 export class VisibilityConflictError extends Error {
   readonly code = "visibility_conflict";
@@ -96,10 +131,31 @@ export async function readVisibilitySettingsCore(client: any): Promise<Visibilit
     booking: { enabled: true, version: null },
     listings: new Map(),
     exceptions: new Map(),
+    landings: new Map(),
+    landingDefault: { notice: null, version: null },
   };
   for (const row of (data ?? []) as SettingRow[]) {
     const version = row.updated_at ?? null;
-    if (row.key === BOOKING_SETTING_KEY) {
+    if (row.key === BOOKING_LANDING_DEFAULT_KEY) {
+      // Stored copy is read leniently: a field that no longer validates is
+      // left out rather than failing every public page.
+      const notice = record(row.value)["notice"];
+      settings.landingDefault = {
+        notice: notice == null ? null : normalizeNoticeContent(notice, false),
+        version,
+      };
+    } else if (row.key.startsWith(BOOKING_LANDING_PREFIX)) {
+      const pageId = row.key.slice(BOOKING_LANDING_PREFIX.length);
+      if (UUID.test(pageId)) {
+        const value = record(row.value);
+        settings.landings.set(pageId.toLowerCase(), {
+          // Only an explicit `true` makes a landing page.
+          landing: value["landing"] === true,
+          notice: normalizePageNoticeOverride(value["notice"], false),
+          version,
+        });
+      }
+    } else if (row.key === BOOKING_SETTING_KEY) {
       // Only an explicit `false` turns booking off; anything else is today's behaviour.
       settings.booking = { enabled: record(row.value)["enabled"] !== false, version };
     } else if (row.key.startsWith(PAGE_LISTING_PREFIX)) {
@@ -127,6 +183,8 @@ export type VisibilitySettings = {
   booking: { enabled: boolean; version: VersionToken };
   listings: Map<string, { listing: PageListing; version: VersionToken }>;
   exceptions: Map<string, { exception: boolean; version: VersionToken }>;
+  landings: Map<string, { landing: boolean; notice: PageNoticeOverride; version: VersionToken }>;
+  landingDefault: { notice: NoticeContent | null; version: VersionToken };
 };
 
 /**
@@ -304,7 +362,14 @@ export async function setBookingExceptionCore(
   if (!UUID.test(input.pageId)) throw new Error("Page not found");
   // Adding needs a page that exists; removing works even for one in the trash.
   let name = "this page";
-  if (input.exception) name = (await readLivePage(context.supabase, input.pageId)).name;
+  if (input.exception) {
+    name = (await readLivePage(context.supabase, input.pageId)).name;
+    // A page cannot both keep its booking links and be a booking-off landing page.
+    const settings = await readVisibilitySettingsCore(context.supabase);
+    if (settings.landings.get(input.pageId.toLowerCase())?.landing === true) {
+      throw new BookingConflictError(name, "landing");
+    }
+  }
   invalidatePublishedCache();
   const version = await compareAndSwap(
     context.supabase,
@@ -329,6 +394,114 @@ export async function setBookingExceptionCore(
   return { exception: input.exception, version };
 }
 
+/** Thrown when one page would both keep its booking links and be a booking-off landing page. */
+export class BookingConflictError extends Error {
+  readonly code = "booking_conflict";
+  constructor(name: string, already: "exception" | "landing") {
+    super(
+      already === "exception"
+        ? `“${name}” keeps its booking links while booking is hidden, so it cannot also be hidden ` +
+            "from the website. Remove it from “Pages that keep their booking links” first."
+        : `“${name}” is hidden from the website while booking is hidden, so it cannot also keep ` +
+            "its booking links. Remove it from “Pages hidden from the website while booking is hidden” first.",
+    );
+    this.name = "BookingConflictError";
+  }
+}
+
+/**
+ * Add a page to, or remove it from, the booking-off landing pages, or change
+ * its own notice.
+ *
+ * Adding needs a page that exists, is not protected (the start page and the
+ * contact page always stay in the menus) and does not keep its booking links.
+ * Removing works even for a page in the trash, and drops its own notice.
+ * Listing, publication, schedules and indexing are not touched: the page stays
+ * exactly as reachable and indexable as it was.
+ */
+export async function setBookingLandingCore(
+  deps: VisibilityDeps,
+  input: {
+    pageId: string;
+    landing: boolean;
+    notice?: unknown;
+    expectedVersion: VersionToken;
+  },
+): Promise<{ landing: boolean; version: string }> {
+  const { context } = deps;
+  await assertStaff(context);
+  if (!UUID.test(input.pageId)) throw new Error("Page not found");
+  const pageId = input.pageId.toLowerCase();
+  let name = "this page";
+  let value: Record<string, unknown> = { landing: false };
+  if (input.landing) {
+    const page = await readLivePage(context.supabase, pageId);
+    name = page.name;
+    assertNotProtected(deps.protectedPageKeys, page, "hidden from the website while booking is hidden");
+    // Validated here as well as in the request schema: the core is the authority.
+    const notice = normalizePageNoticeOverride(input.notice ?? null, true);
+    await assertNoticeTargets(deps, notice);
+    const settings = await readVisibilitySettingsCore(context.supabase);
+    if (settings.exceptions.get(pageId)?.exception === true) {
+      throw new BookingConflictError(name, "exception");
+    }
+    value = Object.keys(notice).length > 0 ? { landing: true, notice } : { landing: true };
+  }
+  invalidatePublishedCache();
+  const version = await compareAndSwap(
+    context.supabase,
+    `${BOOKING_LANDING_PREFIX}${pageId}`,
+    value,
+    input.expectedVersion,
+    context.userId,
+    `whether ${input.landing ? `“${name}”` : name} is hidden while booking is hidden`,
+  );
+  invalidatePublishedCache();
+  await auditAs(context, {
+    action: "booking.landing",
+    entity: "pages",
+    entityId: pageId,
+    meta: {
+      landing: input.landing,
+      ownNotice: input.landing && "notice" in value,
+      description: input.landing
+        ? `Set "${name}" to leave the website's menus and page lists while booking is hidden; it stays reachable and indexable.`
+        : "Removed a page from the pages hidden from the website while booking is hidden.",
+    },
+  });
+  return { landing: input.landing, version };
+}
+
+/** Save the site-wide booking-off notice. */
+export async function setBookingLandingDefaultCore(
+  deps: Pick<VisibilityDeps, "context" | "noticeTargetProblem">,
+  input: { notice: unknown; expectedVersion: VersionToken },
+): Promise<{ version: string }> {
+  const { context } = deps;
+  await assertStaff(context);
+  const notice = normalizeNoticeContent(input.notice, true);
+  await assertNoticeTargets(deps, notice);
+  invalidatePublishedCache();
+  const version = await compareAndSwap(
+    context.supabase,
+    BOOKING_LANDING_DEFAULT_KEY,
+    { notice },
+    input.expectedVersion,
+    context.userId,
+    "the booking-off notice",
+  );
+  invalidatePublishedCache();
+  await auditAs(context, {
+    action: "booking.landing.default",
+    entity: SITE_SETTINGS,
+    entityId: BOOKING_LANDING_DEFAULT_KEY,
+    meta: {
+      description: "Changed the notice booking-off landing pages show while booking is hidden.",
+    },
+  });
+  return { version };
+}
+
 /** Booking setting and its exception pages, for the settings screen. */
 export type BookingSettingsView = {
   enabled: boolean;
@@ -346,6 +519,28 @@ export type BookingSettingsView = {
    * ones: adding a page back has to send the version of the row it left.
    */
   rowVersions: Record<string, VersionToken>;
+  /** Booking-off landing pages and their notice. */
+  landing: {
+    /** The stored default notice (empty fields use the built-in copy), and its version. */
+    default: { notice: NoticeContent | null; version: VersionToken };
+    pages: Array<{
+      pageId: string;
+      key: string | null;
+      name: string | null;
+      /** The page is in the trash or gone: the setting does nothing until restored. */
+      missing: boolean;
+      notice: PageNoticeOverride;
+      version: VersionToken;
+      /**
+       * Stored as a booking exception too. It is treated as an exception only
+       * — it keeps its booking links and stays in the menus — until somebody
+       * removes it from one of the lists.
+       */
+      conflict: boolean;
+    }>;
+    /** Versions of every stored landing row by page id, removed ones included. */
+    rowVersions: Record<string, VersionToken>;
+  };
 };
 
 export async function readBookingSettingsCore(
@@ -355,17 +550,40 @@ export async function readBookingSettingsCore(
   await assertStaff(context);
   const settings = await readVisibilitySettingsCore(context.supabase);
   const ids = [...settings.exceptions].filter(([, row]) => row.exception).map(([id]) => id);
+  const landingIds = [...settings.landings].filter(([, row]) => row.landing).map(([id]) => id);
   const pages = new Map<string, PageRow>();
-  if (ids.length > 0) {
+  const wanted = [...new Set([...ids, ...landingIds])];
+  if (wanted.length > 0) {
     const { data, error } = await context.supabase
       .from("pages")
       .select("id,key,name")
-      .in("id", ids)
+      .in("id", wanted)
       .is("deleted_at", null);
     if (error) throw new Error(error.message);
     for (const row of (data ?? []) as PageRow[]) pages.set(row.id.toLowerCase(), row);
   }
+  const byName = (a: { name: string | null }, b: { name: string | null }) =>
+    (a.name ?? "~").localeCompare(b.name ?? "~");
   return {
+    landing: {
+      default: settings.landingDefault,
+      pages: landingIds
+        .map((pageId) => {
+          const page = pages.get(pageId);
+          const row = settings.landings.get(pageId)!;
+          return {
+            pageId,
+            key: page?.key ?? null,
+            name: page?.name ?? null,
+            missing: !page,
+            notice: row.notice,
+            version: row.version,
+            conflict: settings.exceptions.get(pageId)?.exception === true,
+          };
+        })
+        .sort(byName),
+      rowVersions: Object.fromEntries([...settings.landings].map(([id, row]) => [id, row.version])),
+    },
     enabled: settings.booking.enabled,
     version: settings.booking.version,
     exceptions: ids
@@ -443,8 +661,16 @@ async function readPublicPolicy(client: any): Promise<PublicPolicySnapshot> {
       live: publicVersionId(byPage.get(row.id) ?? [], now) !== null,
       listing: settings.listings.get(id)?.listing ?? "listed",
       bookingException: settings.exceptions.get(id)?.exception === true,
+      bookingLanding: settings.landings.get(id)?.landing === true,
+      landingNotice: settings.landings.get(id)?.landing ? settings.landings.get(id)!.notice : null,
     };
   });
 
-  return { known: true, bookingEnabled: settings.booking.enabled, pages, revalidateAt };
+  return {
+    known: true,
+    bookingEnabled: settings.booking.enabled,
+    pages,
+    revalidateAt,
+    landingDefault: settings.landingDefault.notice,
+  };
 }

package/src/server/schemas.ts

@@ -11,6 +11,8 @@
  */
 import { z } from "zod";
 
+import { NOTICE_LIMITS, parseNoticeCtaHref } from "../cms/booking-landing";
+
 /* ------------------------------------------------------------------ shared */
 
 export const uuid = z.string().uuid();
@@ -33,6 +35,37 @@ export const cmsKey = z
 
 export const listLimit = z.object({ limit: z.number().min(1).max(500).default(200) });
 
+/* ------------------------------------------------------- booking-off notice */
+
+/** Text per language, bounded. Content rules (limits, links) are re-checked by the core. */
+const noticeText = (max: number) =>
+  z.record(z.string().regex(/^[a-z]{2}(-[a-z0-9]{2,8})?$/i), z.string().max(max)).refine(
+    (value) => Object.keys(value).length <= 8,
+    "Too many languages",
+  );
+
+const noticeCtaSchema = z.object({
+  label: noticeText(NOTICE_LIMITS.ctaLabel),
+  href: z
+    .string()
+    .max(NOTICE_LIMITS.href)
+    .refine((href) => parseNoticeCtaHref(href).ok, {
+      message: "Use an address on this site (/…) or an https:// address that does not lead to booking.",
+    }),
+});
+
+export const noticeSchema = z.object({
+  heading: noticeText(NOTICE_LIMITS.heading).optional(),
+  body: noticeText(NOTICE_LIMITS.body).optional(),
+  cta: noticeCtaSchema.nullable().optional(),
+});
+
+export const noticeOverrideSchema = z.object({
+  heading: noticeText(NOTICE_LIMITS.heading).optional(),
+  body: noticeText(NOTICE_LIMITS.body).optional(),
+  cta: z.union([noticeCtaSchema, z.literal("none")]).optional(),
+});
+
 /* ---------------------------------------------------------------- edit locks */
 
 /**
@@ -148,6 +181,18 @@ export const pageSchemas = {
     exception: z.boolean(),
     expectedVersion: z.string().min(1).max(64).nullable(),
   }),
+  /** A booking-off landing page, added, removed, or given its own notice. */
+  setBookingLanding: z.object({
+    pageId: uuid,
+    landing: z.boolean(),
+    notice: noticeOverrideSchema.nullable().optional(),
+    expectedVersion: z.string().min(1).max(64).nullable(),
+  }),
+  /** The site-wide booking-off notice. */
+  setBookingLandingDefault: z.object({
+    notice: noticeSchema,
+    expectedVersion: z.string().min(1).max(64).nullable(),
+  }),
   duplicatePage: z.object({
     pageId: uuid,
     name: z.string().min(1).max(120),

package/src/site/BookingOffNotice.tsx

@@ -0,0 +1,73 @@
+/**
+ * The notice a booking-off landing page shows while booking is hidden.
+ *
+ * The page keeps its own content, title, H1 and address; this only says,
+ * honestly, that booking is not offered here right now, and offers an
+ * optional link somewhere that is not booking. A titled region with an `h2`,
+ * so it is found by heading and landmark navigation without interrupting a
+ * screen reader the way an alert would. Plain text only: the message is
+ * rendered as text with its line breaks, never as markup.
+ *
+ * Placed after a leading hero, or first. First, it can follow the fixed
+ * header directly (a route with no top padding and no hero): it then keeps
+ * the same offset the site's padded routes use, instead of sitting under the
+ * header. Anywhere else the rule does not match.
+ *
+ * Its link is offered only if the current policy allows it: never to booking
+ * (a booking site, or the host's own booking page in any spelling) and never
+ * to a page hidden while booking is hidden. The host's server already drops
+ * such a link before the notice is sent; this is the same rule where it is
+ * rendered, so a policy that changed since cannot bring one back.
+ */
+import { useId } from "react";
+
+import { useT } from "../i18n";
+import type { ResolvedNotice } from "../cms/booking-landing";
+import { isNoticeLinkAllowed } from "../navigation/visibility";
+import { useLinkVisibility } from "./link-visibility";
+
+export function BookingOffNotice({ notice }: { notice: ResolvedNotice | null | undefined }) {
+  const { t } = useT();
+  const id = useId();
+  const policy = useLinkVisibility();
+  if (!notice) return null;
+  const heading = t(notice.heading);
+  const body = t(notice.body);
+  const cta = notice.cta && isNoticeLinkAllowed(notice.cta.href, policy) ? notice.cta : null;
+  const label = cta ? t(cta.label) : "";
+  if (!heading && !body) return null;
+  const external = cta ? /^https:\/\//i.test(cta.href) : false;
+  return (
+    <section
+      aria-labelledby={heading ? `${id}-title` : undefined}
+      aria-label={heading ? undefined : body}
+      data-booking-off-notice=""
+      className="container-editorial py-8 md:py-10 [header+&]:pt-24 md:[header+&]:pt-32"
+    >
+      <div className="max-w-3xl border-l-4 border-ink/70 bg-paper px-5 py-5 md:px-7 md:py-6">
+        {heading ? (
+          <h2
+            id={`${id}-title`}
+            className="font-serif text-[clamp(1.4rem,2.6vw,2rem)] leading-[1.15] text-ink [overflow-wrap:anywhere]"
+          >
+            {heading}
+          </h2>
+        ) : null}
+        {body ? (
+          <p className="mt-3 whitespace-pre-line text-base leading-relaxed text-ink/80 [overflow-wrap:anywhere]">
+            {body}
+          </p>
+        ) : null}
+        {cta && label ? (
+          <a
+            href={cta.href}
+            {...(external ? { rel: "noopener" } : {})}
+            className="mt-5 inline-flex min-h-11 max-w-full items-center justify-center bg-ink px-6 py-3 text-center text-xs uppercase tracking-[0.22em] text-paper hover:bg-ink/85 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ink [overflow-wrap:anywhere]"
+          >
+            {label}
+          </a>
+        ) : null}
+      </div>
+    </section>
+  );
+}