@bygghammar/cms-platform 0.93.0 → 0.95.0

package/src/backoffice/media/ConfirmDialog.tsx

@@ -13,6 +13,7 @@ export function ConfirmDialog({
   title,
   description,
   details,
+  consequences,
   confirmLabel = "Confirm",
   cancelLabel = "Cancel",
   danger = false,
@@ -23,7 +24,13 @@ export function ConfirmDialog({
 }: {
   title: string;
   description?: string;
+  /** Short items (names, paths), one line each; long ones are truncated with a tooltip. */
   details?: string[];
+  /**
+   * What confirming will do, in full sentences. Never truncated, and read out
+   * with the description, because a warning cut off at "…" is not a warning.
+   */
+  consequences?: string[];
   confirmLabel?: string;
   cancelLabel?: string;
   danger?: boolean;
@@ -82,7 +89,11 @@ export function ConfirmDialog({
         role="dialog"
         aria-modal="true"
         aria-labelledby={`${id}-title`}
-        aria-describedby={description ? `${id}-description` : undefined}
+        aria-describedby={
+          [description ? `${id}-description` : "", consequences?.length ? `${id}-consequences` : ""]
+            .filter(Boolean)
+            .join(" ") || undefined
+        }
         className="w-full max-w-md border border-ink/15 bg-white"
         onClick={(e) => e.stopPropagation()}
       >
@@ -98,6 +109,13 @@ export function ConfirmDialog({
             </p>
           ) : null}
           {children}
+          {consequences?.length ? (
+            <ul id={`${id}-consequences`} className="list-disc space-y-1.5 pl-5 text-sm text-ink/80">
+              {consequences.map((line) => (
+                <li key={line}>{line}</li>
+              ))}
+            </ul>
+          ) : null}
           {details?.length ? (
             <ul className="max-h-40 space-y-1 overflow-auto border border-ink/10 bg-ice/30 p-2 text-[0.72rem] text-ink/70">
               {details.map((d) => (

package/src/backoffice/routes/host.ts

@@ -10,6 +10,7 @@ import type { ReactNode } from "react";
 
 import type { SiteConfig } from "../../config/site-config";
 import type { SecretsLocation } from "../../server/provider-secrets";
+import type { LinkVisibilityPolicy } from "../../navigation/visibility";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /** Media field component as the reviews editor consumes it. */
@@ -233,6 +234,11 @@ export type BackofficeHost = {
        */
       setPageStatus?: HostServerFn;
       duplicatePage?: HostServerFn;
+      /**
+       * Optional: make a page link-only or list it again (listing only, never a
+       * publish). Without it neither screen offers the action.
+       */
+      setPageListing?: HostServerFn;
       /**
        * The site's pages, listed.
        *
@@ -303,6 +309,24 @@ export type BackofficeHost = {
     translateTarget?: string;
     translate?: HostServerFn;
   };
+  /**
+   * Site settings → Booking: the site-wide switch for booking links and the
+   * pages that keep theirs while it is off. Optional: without it the card is
+   * not shown.
+   */
+  booking?: {
+    fns: {
+      getBookingSettings: HostServerFn;
+      setBookingEnabled: HostServerFn;
+      setBookingException: HostServerFn;
+    };
+  };
+  /**
+   * The public link policy as the site currently applies it, so the navigation
+   * editor can say why a saved item is not shown. A hook, so a site can read it
+   * however it serves it. Optional: without it the editor explains nothing.
+   */
+  useLinkVisibility?: () => LinkVisibilityPolicy | undefined;
   /** Browser auth adapters used by the password-reset screen. */
   authAdapters?: {
     /** Subscribes to the recovery session; returns an unsubscribe function. */

package/src/backoffice/routes/index.tsx

@@ -26,7 +26,7 @@ import {
   Users,
 } from "lucide-react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useCallback, useRef } from "react";
+import { useCallback, useRef, useState } from "react";
 import { useServerFn } from "@tanstack/react-start";
 
 import { MISSING_CREATED_ID } from "../../tracking/injections";
@@ -37,6 +37,7 @@ import { BackupView } from "../BackupView";
 import { DomainsView } from "../DomainsView";
 import { EmailSettingsView } from "../EmailSettingsView";
 import { NavigationView } from "../NavigationView";
+import { BookingSettingsCard, type BookingSettingsData } from "../BookingSettingsCard";
 import { ReviewsView, type ReviewsSection } from "../ReviewsView";
 import { ContactDetailsView } from "../ContactDetailsView";
 import { EmailLogsView } from "../EmailLogsView";
@@ -48,13 +49,16 @@ import { SitemapView, type SitemapCheck } from "../SitemapView";
 import { SiteSettingsView } from "../SiteSettingsView";
 import { TrackingView, type TrackingDeps } from "../TrackingView";
 import { UsersView } from "../UsersView";
-import { VersionView } from "../VersionView";
+import { VersionView, type PlatformBuildInfo, type PlatformRelease } from "../VersionView";
+import { moduleInventory, type ModuleSettingsRead } from "../../admin/module-inventory";
+import type { VersionReport } from "../../admin/version-report";
 import { parseEffectiveAdminHost } from "../../site/locale-domains";
 import {
   useFeatureEnabled,
   useFeatureGate,
   useModuleGate,
   useMyRoles,
+  useResolvedSiteConfig,
 } from "../shell/use-resolved-config";
 import { backofficeHost, backofficePaths } from "./host";
 
@@ -127,14 +131,143 @@ export function UsersRoute() {
   );
 }
 
-/** CMS build and platform version screen. */
+type SystemVersionPayload = {
+  build?: PlatformBuildInfo;
+  releases?: PlatformRelease[];
+  /** Present from hosts that build it with `buildVersionReport`. */
+  report?: VersionReport;
+};
+
+const SYSTEM_VERSION_QUERY_KEY = ["admin", "system-version"] as const;
+
+/**
+ * Release, package and module screen.
+ *
+ * Read-only: it shows the module switches, it never changes them. The version
+ * read is not polled — no refetch on focus, a five-minute stale time — and a
+ * manual check goes through the server, which applies its own minimum
+ * interval before asking the registry again.
+ */
 export function VersionRoute() {
-  const { fns } = backofficeHost();
-  const fetchVersion = useServerFn(fns.getSystemVersion);
-  const q = useQuery({ queryKey: ["admin", "system-version"], queryFn: () => fetchVersion() });
+  const host = backofficeHost();
+  const paths = backofficePaths(host);
+  const fetchVersion = useServerFn(host.fns.getSystemVersion);
+  const queryClient = useQueryClient();
+  const q = useQuery({
+    queryKey: SYSTEM_VERSION_QUERY_KEY,
+    queryFn: () => fetchVersion({ data: { refresh: false } }) as Promise<SystemVersionPayload>,
+    staleTime: 5 * 60_000,
+    refetchOnWindowFocus: false,
+    retry: 1,
+  });
+  const refreshing = useRef(false);
+  const [isRefreshing, setRefreshing] = useState(false);
+  // The `dataUpdatedAt` of the answer that was on screen when a "Check again"
+  // failed. The failure notice shows while that same answer is still shown, so
+  // any later successful answer (a retry or a re-read) clears it.
+  const [refreshFailedFor, setRefreshFailedFor] = useState<number | null>(null);
+  const refresh = useCallback(async () => {
+    if (refreshing.current) return;
+    refreshing.current = true;
+    setRefreshing(true);
+    try {
+      const next = (await fetchVersion({ data: { refresh: true } })) as SystemVersionPayload;
+      queryClient.setQueryData(SYSTEM_VERSION_QUERY_KEY, next);
+      setRefreshFailedFor(null);
+    } catch {
+      // Keep the last answer on screen, but say the check failed. The error
+      // itself (an expired session, a network failure) is not shown.
+      setRefreshFailedFor(queryClient.getQueryState(SYSTEM_VERSION_QUERY_KEY)?.dataUpdatedAt ?? 0);
+    } finally {
+      refreshing.current = false;
+      setRefreshing(false);
+    }
+  }, [fetchVersion, queryClient]);
+
+  const settings = useResolvedSiteConfig();
+  const settingsRead: ModuleSettingsRead =
+    settings.status === "loading"
+      ? { state: "loading" }
+      : settings.status === "error"
+        ? { state: "error" }
+        : { state: "ready", features: settings.config.features, stale: settings.status === "stale" };
+  const report = q.data?.report && q.data.report.schemaVersion === 1 ? q.data.report : null;
+  const cmsVersion =
+    report?.packages.find((p) => p.role === "cms")?.installed ?? q.data?.build?.platformVersion ?? null;
+  // The latest request failed while an earlier answer is still on screen:
+  // a failed "Check again", or a failed re-read of cached data.
+  const latestCheckFailed =
+    q.data !== undefined &&
+    ((refreshFailedFor !== null && refreshFailedFor === q.dataUpdatedAt) || q.isError);
+
   return (
     <VersionView
-      deps={{ build: q.data?.build, releases: q.data?.releases ?? [], loading: q.isLoading }}
+      deps={{
+        build: q.data?.build,
+        releases: q.data?.releases ?? [],
+        loading: q.isLoading,
+        error: q.isError && !q.data,
+        latestCheckFailed,
+        onRetry: () => void q.refetch(),
+        report,
+        modules: moduleInventory(settingsRead, report?.packages, q.isLoading ? null : cmsVersion),
+        onRefresh: report ? () => void refresh() : undefined,
+        refreshing: isRefreshing,
+        siteName: host.siteConfig.name,
+        settingsHref: paths.settings,
+        renderLink: ({ href, className, children }) => (
+          <Link to={href} className={className}>
+            {children}
+          </Link>
+        ),
+      }}
+    />
+  );
+}
+
+/** Stand-in for unregistered optional functions; the queries using it stay disabled. */
+const notRegistered = async () => {
+  throw new Error("This site has not registered that backoffice function.");
+};
+
+/** Site settings → Booking, when the host registered the booking functions. */
+function BookingSettingsSection() {
+  const host = backofficeHost();
+  const booking = host.booking;
+  const qc = useQueryClient();
+  const load = useServerFn(booking?.fns.getBookingSettings ?? notRegistered);
+  const setEnabled = useServerFn(booking?.fns.setBookingEnabled ?? notRegistered);
+  const setException = useServerFn(booking?.fns.setBookingException ?? notRegistered);
+  const listPages = useServerFn(host.pages?.fns.listPages ?? notRegistered);
+  const q = useQuery({
+    queryKey: ["admin", "booking-settings"],
+    queryFn: () => load(),
+    enabled: Boolean(booking),
+  });
+  const pagesQ = useQuery({
+    queryKey: ["cms", "pages-list"],
+    queryFn: () => listPages(),
+    enabled: Boolean(booking && host.pages?.fns.listPages),
+  });
+  const resolveUrl = host.pages?.usePageUrl?.();
+  if (!booking) return null;
+  return (
+    <BookingSettingsCard
+      deps={{
+        settings: q.data as BookingSettingsData | undefined,
+        error: (q.error as Error | null) ?? null,
+        pages: (pagesQ.data as Array<{ id: string; key: string; name: string }> | undefined)?.map(
+          (page) => ({ id: page.id, key: page.key, name: page.name }),
+        ),
+        pathFor: (key) =>
+          resolveUrl ? resolveUrl(key, host.siteConfig.defaultLocale).path : `/${key}`,
+        setEnabled: (input) => setEnabled({ data: input } as never),
+        setException: (input) => setException({ data: input } as never),
+        refresh: () => {
+          void q.refetch();
+          void qc.invalidateQueries({ queryKey: ["admin", "link-visibility"] });
+        },
+      }}
     />
   );
 }
@@ -174,6 +307,7 @@ export function SiteSettingsRoute() {
           window.location.href = contactPath;
         },
         MediaField: host.components.MediaField,
+        bookingSection: <BookingSettingsSection />,
       }}
     />
   );
@@ -466,8 +600,8 @@ export function AdminOverviewRoute() {
     },
     {
       to: paths.version,
-      title: "CMS & platform version",
-      body: "Current CMS build, shared platform package version and release history with dates.",
+      title: "Version & modules",
+      body: "The live site release, installed CMS and module packages, module status and available updates.",
       icon: Package,
     },
     ...(isSuper && host.siteConfig.features.backup
@@ -630,10 +764,12 @@ export function NavigationRoute() {
     queryFn: () => loadSettings(),
   });
   const settingOverrides = (settingsQ.data?.overrides ?? {}) as SiteSettingOverrides;
+  const linkPolicy = (host.useLinkVisibility ?? noLinkVisibility)();
 
   return (
     <NavigationView
       deps={{
+        linkPolicy,
         overrides,
         site,
         defaults: host.content.defaults,
@@ -664,6 +800,9 @@ export function NavigationRoute() {
  */
 const noEffectiveAdminHost = async () => null;
 
+/** A host without a link policy: the navigation editor explains nothing. */
+const noLinkVisibility = () => undefined;
+
 /** Per-locale domain mapping. */
 function DomainsRouteInner() {
   const host = backofficeHost();

package/src/backoffice/routes/pages.tsx

@@ -21,6 +21,11 @@ import { useResolvedSiteConfig } from "../shell/use-resolved-config";
 import { ResetPasswordView } from "../ResetPasswordView";
 import { backofficeHost, backofficePaths, requireHostGroup } from "./host";
 
+/** Stand-in for unregistered optional functions; never called (the action is not offered). */
+const notRegistered = async () => {
+  throw new Error("This site has not registered that page function.");
+};
+
 const notify = {
   success: (m: string) => toast.success(m),
   error: (m: string) => toast.error(m),
@@ -47,6 +52,8 @@ export function PageBuilderRoute() {
   const listPubs = useServerFn(pages.fns.listPagePublications);
   const cancelPub = useServerFn(pages.fns.cancelPagePublication);
   const rename = useServerFn(pages.fns.renamePage);
+  const setStatus = useServerFn(pages.fns.setPageStatus ?? notRegistered);
+  const setListing = useServerFn(pages.fns.setPageListing ?? notRegistered);
 
   const pageQ = useQuery({
     queryKey: ["cms", "page-edit", key],
@@ -127,6 +134,12 @@ export function PageBuilderRoute() {
         restoreVersion: (versionId, editSessionId) =>
           restore({ data: { versionId, editSessionId } }),
         rename: (input) => rename({ data: input }),
+        setPageStatus: pages.fns.setPageStatus
+          ? (input) => setStatus({ data: input } as never)
+          : undefined,
+        setPageListing: pages.fns.setPageListing
+          ? (input) => setListing({ data: input } as never)
+          : undefined,
         refetchPage: () => void pageQ.refetch(),
         refetchVersions: () => void versionsQ.refetch(),
         refetchPublications: () => void pubsQ.refetch(),

package/src/backoffice/shell/use-resolved-config.tsx

@@ -21,11 +21,27 @@ import { backofficeNav, type BackofficeNavItem, type BackofficeNavOptions } from
 /** Query key shared with the site-settings screen. */
 export const SITE_SETTINGS_QUERY_KEY = ["admin", "site-settings"] as const;
 
+/**
+ * Where the resolved configuration came from:
+ *
+ * - `loading`: no answer yet; `config` is the compiled code config.
+ * - `error`: the read failed (or answered without settings) and no earlier
+ *   answer is held; `config` is the compiled code config, not the live one.
+ * - `ready`: `config` includes the saved overrides.
+ * - `stale`: a re-read failed; `config` is from the last successful read.
+ */
+export type SiteSettingsStatus = "loading" | "error" | "ready" | "stale";
+
 /**
  * Code config merged with the stored overrides. While loading, the code config
- * is returned so the shell renders without a flash of empty navigation.
+ * is returned so the shell renders without a flash of empty navigation; a
+ * caller that must not present that fallback as the live answer reads `status`.
  */
-export function useResolvedSiteConfig(): { config: SiteConfig; isLoading: boolean } {
+export function useResolvedSiteConfig(): {
+  config: SiteConfig;
+  isLoading: boolean;
+  status: SiteSettingsStatus;
+} {
   const host = backofficeHost();
   const load = useServerFn(host.fns.getSiteSettings);
   const q = useQuery({
@@ -34,13 +50,22 @@ export function useResolvedSiteConfig(): { config: SiteConfig; isLoading: boolea
     staleTime: 30_000,
   });
 
-  const resolved =
+  const fromSettings =
     (q.data?.config as SiteConfig | undefined) ??
     (q.data?.overrides
       ? resolveSiteConfig(host.siteConfig, q.data.overrides as never)
-      : host.siteConfig);
+      : undefined);
+  const resolved = fromSettings ?? host.siteConfig;
+
+  const status: SiteSettingsStatus = q.isLoading
+    ? "loading"
+    : !fromSettings
+      ? "error"
+      : q.isError
+        ? "stale"
+        : "ready";
 
-  return { config: resolved, isLoading: q.isLoading };
+  return { config: resolved, isLoading: q.isLoading, status };
 }
 
 /** Sidebar model built from the live (override-aware) configuration. */

package/src/cms/booking-links.ts

@@ -0,0 +1,176 @@
+/**
+ * Booking links: which addresses count as one, and how they are taken out of
+ * public content while a site has booking switched off.
+ *
+ * A booking link is an `https:` address whose host starts with `booking` —
+ * `https://booking.voyara.se/…`, `https://booking.example.com`. That is the
+ * whole rule. The address is read the way a browser reads it (character
+ * references decoded, tabs and line breaks dropped, the ends trimmed, a
+ * protocol-relative `//booking…` taken as `https:`), and only the scheme and
+ * host decide. A link to another site whose query string happens to contain a
+ * booking address is not a booking link, and neither is plain text that
+ * mentions one.
+ *
+ * Removal is applied to a copy of the content on its way out of the server,
+ * never to what is stored: switching booking back on restores every link
+ * exactly as it was written.
+ */
+import { decodeAttr, sanitizeHtml } from "../html/sanitize-html";
+
+/** A browser drops these anywhere inside a URL before parsing it. */
+const DROPPED_INSIDE = /[\t\n\r]/g;
+/** And trims C0 controls and spaces from both ends. */
+const TRIMMED_ENDS = /^[\u0000- ]+|[\u0000- ]+$/g;
+
+/** True when `raw` is an address that leads to a booking site. */
+export function isBookingHref(raw: unknown): boolean {
+  if (typeof raw !== "string" || raw === "") return false;
+  let value = decodeAttr(raw).replace(DROPPED_INSIDE, "").replace(TRIMMED_ENDS, "");
+  if (!value) return false;
+  if (value.startsWith("//")) value = `https:${value}`;
+  let url: URL;
+  try {
+    // No base: a relative address ("/boka", "boka") is never a booking site.
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" && url.hostname.startsWith("booking");
+}
+
+/** Every tag, as the sanitizer reads them (quoted `>` included). */
+const TAG = /<\s*(\/)?\s*([a-zA-Z][a-zA-Z0-9-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+const HREF = /(?:^|\s)href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i;
+
+/** Placeholder for a removed link while emptied containers are collapsed. */
+const REMOVED = "\u0000booking-link\u0000";
+
+/**
+ * Containers that existed only to hold a removed link and are dropped with it:
+ * a paragraph, list item or heading that contained the "Boka" button and
+ * nothing else would otherwise leave an empty line behind.
+ */
+const COLLAPSIBLE =
+  "p|li|ul|ol|div|span|strong|b|em|i|u|s|small|mark|h1|h2|h3|h4|h5|h6|figure|figcaption|blockquote";
+const FILLER = `(?:\\s|&nbsp;|\\u00a0|<br\\s*\\/?>|${REMOVED})`;
+const EMPTIED = new RegExp(
+  `<(${COLLAPSIBLE})(?:\\s[^>]*)?>${FILLER}*${REMOVED}${FILLER}*<\\/\\1>`,
+  "gi",
+);
+
+function anchorLeadsToBooking(attributes: string): boolean {
+  const match = HREF.exec(attributes);
+  if (!match) return false;
+  return isBookingHref(match[1] ?? match[2] ?? match[3] ?? "");
+}
+
+/**
+ * The same HTML with every booking link removed, link text included.
+ *
+ * Everything else — the prose around the link, other links, images, styling —
+ * is left exactly as it was. Input with no booking link comes back unchanged
+ * (the same string); input with one comes back sanitized, which is what every
+ * renderer does to it anyway.
+ */
+export function stripBookingFromHtml(html: string): string {
+  if (!/<\s*a\b/i.test(html)) return html;
+  const clean = sanitizeHtml(html);
+  let out = "";
+  let last = 0;
+  let depth = 0;
+  let removed = false;
+  TAG.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = TAG.exec(clean))) {
+    const closing = Boolean(match[1]);
+    const tag = match[2]!.toLowerCase();
+    if (depth > 0) {
+      if (tag === "a") depth += closing ? -1 : 1;
+      if (depth === 0) {
+        out += REMOVED;
+        last = match.index + match[0].length;
+      }
+      continue;
+    }
+    if (!closing && tag === "a" && anchorLeadsToBooking(match[3] ?? "")) {
+      out += clean.slice(last, match.index);
+      depth = 1;
+      removed = true;
+    }
+  }
+  if (!removed) return html;
+  out += depth > 0 ? REMOVED : clean.slice(last);
+  let previous: string;
+  do {
+    previous = out;
+    out = out.replace(EMPTIED, REMOVED);
+  } while (out !== previous);
+  return out.split(REMOVED).join("");
+}
+
+/**
+ * A copy of any JSON-shaped value with booking links taken out.
+ *
+ * A string that *is* a booking address becomes empty — every block treats an
+ * empty link as "no button", so a hero keeps its picture and heading and loses
+ * only the button — and booking links inside HTML strings are removed with
+ * {@link stripBookingFromHtml}. Objects and arrays are rebuilt only where
+ * something changed, so untouched content keeps its identity.
+ */
+export function stripBookingDeep<T>(value: T): T {
+  return strip(value) as T;
+}
+
+function strip(value: unknown): unknown {
+  if (typeof value === "string") {
+    if (isBookingHref(value)) return "";
+    return value.includes("<") ? stripBookingFromHtml(value) : value;
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((item) => {
+      const out = strip(item);
+      if (out !== item) changed = true;
+      return out;
+    });
+    return changed ? next : value;
+  }
+  if (value !== null && typeof value === "object") {
+    let changed = false;
+    const next: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
+      const out = strip(item);
+      if (out !== item) changed = true;
+      next[key] = out;
+    }
+    return changed ? next : value;
+  }
+  return value;
+}
+
+/** True when any string anywhere inside `value` leads to a booking site. */
+export function containsBookingTarget(value: unknown): boolean {
+  if (typeof value === "string") {
+    if (isBookingHref(value)) return true;
+    return value.includes("<") && stripBookingFromHtml(value) !== value;
+  }
+  if (Array.isArray(value)) return value.some(containsBookingTarget);
+  if (value !== null && typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some(containsBookingTarget);
+  }
+  return false;
+}
+
+/**
+ * Popups to show while booking is off: every popup that links to a booking
+ * site is withheld whole.
+ *
+ * A popup is one short message with one purpose. Taking only the button out of
+ * one that says "Book your cabin now" leaves a promise with no way to act on
+ * it, and an answer or a form that ends by opening the booking site cannot be
+ * removed without changing what the popup does — so the popup is simply not
+ * offered until booking is back.
+ */
+export function withoutBookingPopups<T>(configs: readonly T[]): T[] {
+  return configs.filter((config) => !containsBookingTarget(config));
+}

package/src/cms/page-publication.ts

@@ -155,21 +155,26 @@ export function isPubliclyVisible(state: PublicationState): boolean {
   return state === "published" || state === "ending";
 }
 
+/*
+ * "Offline" rather than "Hidden": a page can also be link-only — online, but
+ * left out of menus and the sitemap — and two different states must not share
+ * the word "hidden".
+ */
 export const PUBLICATION_STATE_LABELS: Record<PublicationState, string> = {
-  draft: "Hidden",
+  draft: "Offline",
   scheduled: "Scheduled to publish",
   published: "Published",
-  ending: "Scheduled to hide",
-  expired: "Hidden after expiry",
+  ending: "Scheduled to go offline",
+  expired: "Offline after expiry",
 };
 
 /** Longer wording for tooltips and screen-reader descriptions. */
 export const PUBLICATION_STATE_DESCRIPTIONS: Record<PublicationState, string> = {
-  draft: "Not visible on the public website. Staff can still edit and preview it.",
+  draft: "Not on the public website; visitors get “page not found”. Staff can still edit and preview it.",
   scheduled: "Not visible yet. It appears by itself when its publication window opens.",
   published: "Visible on the public website right now.",
-  ending: "Visible now, and scheduled to disappear when its window closes.",
-  expired: "Not visible any more — its publication window has closed.",
+  ending: "Visible now, and scheduled to go offline when its window closes.",
+  expired: "Offline — its publication window has closed.",
 };
 
 /**