smoodly 0.0.27 → 0.0.29

package/dist/admin/shell/health-list.d.ts

@@ -0,0 +1,27 @@
+import type { AdminRegistry } from "../serialize.ts";
+import type { HealthReport } from "../health.ts";
+export type HealthRow = {
+    key: string;
+    title: string;
+    kind: string;
+    locales: string[];
+    draft: boolean;
+    live: boolean;
+    href: string;
+};
+export type HealthGroup = {
+    key: string;
+    headline: string;
+    rows: HealthRow[];
+};
+export type HealthSections = {
+    broken: HealthGroup[];
+    orphan: HealthGroup[];
+    collections: {
+        name: string;
+        headline: string;
+    }[];
+};
+/** A group shows this many rows, then "Show all N". */
+export declare const GROUP_PREVIEW = 10;
+export declare function healthSections(report: HealthReport, registry: AdminRegistry): HealthSections;

package/dist/admin/shell/health-list.js

@@ -0,0 +1,47 @@
+import { SEVERITY, groupKey } from "../drift.js";
+import { driftHeadline } from "../drift-copy.js";
+/** A group shows this many rows, then "Show all N". */
+export const GROUP_PREVIEW = 10;
+const kindLabel = (doc, registry) => doc.kind === "page" ? "Page" : doc.kind === "global" ? "Site" : registry.collections.find((c) => c.name === doc.collection)?.title ?? doc.collection ?? "";
+const href = (doc, locale) => {
+    const q = `?locale=${encodeURIComponent(locale)}`;
+    if (doc.kind === "page")
+        return `/pages/${encodeURIComponent(doc.id)}${q}`;
+    if (doc.kind === "global")
+        return `/globals/${encodeURIComponent(doc.collection ?? "")}${q}`;
+    return `/${doc.collection}/${encodeURIComponent(doc.id)}${q}`;
+};
+export function healthSections(report, registry) {
+    const groups = new Map();
+    for (const doc of report.documents) {
+        for (const f of doc.findings) {
+            const key = groupKey(f);
+            let g = groups.get(key);
+            if (!g)
+                groups.set(key, (g = { severity: SEVERITY[f.kind], headline: driftHeadline(f, registry), rows: new Map() }));
+            const rowKey = `${doc.kind}:${doc.id}`;
+            const row = g.rows.get(rowKey);
+            if (!row) {
+                g.rows.set(rowKey, { key: rowKey, title: doc.title, kind: kindLabel(doc, registry), locales: [f.locale], draft: f.draft, live: f.live, href: href(doc, f.locale) });
+            }
+            else {
+                if (!row.locales.includes(f.locale))
+                    row.locales.push(f.locale);
+                row.draft || (row.draft = f.draft);
+                row.live || (row.live = f.live);
+            }
+        }
+    }
+    const order = registry.locales.supported;
+    const out = (severity) => [...groups].filter(([, g]) => g.severity === severity)
+        .map(([key, g]) => ({ key, headline: g.headline, rows: [...g.rows.values()].map((r) => ({ ...r, locales: [...r.locales].sort((a, b) => order.indexOf(a) - order.indexOf(b)) })) }))
+        .sort((a, b) => b.rows.length - a.rows.length || a.headline.localeCompare(b.headline));
+    return {
+        broken: out("broken"),
+        orphan: out("orphan"),
+        collections: report.collections.map(({ name, count }) => ({
+            name,
+            headline: `Collection \`${name}\` no longer registered · ${count} ${count === 1 ? "entry" : "entries"}. Register it again or delete its ${count} ${count === 1 ? "entry" : "entries"}.`,
+        })),
+    };
+}

package/dist/admin/shell/live-url.d.ts

@@ -1,10 +1,18 @@
 import { type ConfirmOptions, type ConfirmSubject } from "../ui/confirm.ts";
 export declare const LIVE_URL_CONFIRM: Omit<ConfirmOptions, "subject">;
+/** The rider (spec 2026-09-26 redirects §1): on by default, the editor unticks to let the old address go dark. */
+export declare const LIVE_URL_OPTION: {
+    readonly label: "Redirect the old address";
+    readonly checked: true;
+};
 /** `from` null = there was no URL part to change (a new row, a collection without a path). */
 export declare function liveUrlChanges(input: {
     status: "draft" | "published" | undefined;
     from: string | null;
     to: string | null;
 }): boolean;
-/** Resolves true when the change may go ahead: not a live change, or confirmed. */
-export declare function confirmLiveUrl(input: Parameters<typeof liveUrlChanges>[0], subject?: ConfirmSubject): Promise<boolean>;
+/** `ok` false = cancelled. `redirect` is the checkbox (true when no question was asked: the store's default). */
+export declare function confirmLiveUrl(input: Parameters<typeof liveUrlChanges>[0], subject?: ConfirmSubject): Promise<{
+    ok: boolean;
+    redirect: boolean;
+}>;

package/dist/admin/shell/live-url.js

@@ -3,17 +3,22 @@
 // published page's parent. Whoever the role — the mistake is the same.
 // Asked in the admin's own dialog (ui/confirm.ts); the subject chip names
 // the record and the URL part that is about to change.
-import { confirm } from "../ui/confirm.js";
+import { confirmWithOption } from "../ui/confirm.js";
 export const LIVE_URL_CONFIRM = {
     title: "Change the live URL?",
-    body: "This is published. Old links to it stop working until a redirect exists, and Smoodly has none yet.",
+    body: "This is published. With a redirect, visitors and search engines who open the old address are sent to the new one.",
     confirmLabel: "Change URL",
 };
+/** The rider (spec 2026-09-26 redirects §1): on by default, the editor unticks to let the old address go dark. */
+export const LIVE_URL_OPTION = { label: "Redirect the old address", checked: true };
 /** `from` null = there was no URL part to change (a new row, a collection without a path). */
 export function liveUrlChanges(input) {
     return input.status === "published" && input.from !== null && input.to !== input.from;
 }
-/** Resolves true when the change may go ahead: not a live change, or confirmed. */
+/** `ok` false = cancelled. `redirect` is the checkbox (true when no question was asked: the store's default). */
 export async function confirmLiveUrl(input, subject) {
-    return !liveUrlChanges(input) || confirm({ ...LIVE_URL_CONFIRM, subject });
+    if (!liveUrlChanges(input))
+        return { ok: true, redirect: true };
+    const { yes, checked } = await confirmWithOption({ ...LIVE_URL_CONFIRM, option: { ...LIVE_URL_OPTION }, subject });
+    return { ok: yes, redirect: checked };
 }

package/dist/admin/shell/members-list.js

@@ -2,7 +2,7 @@ import { normalizeRole } from "../../permissions.js";
 export const roleLabel = (role) => (role ? role[0].toUpperCase() + role.slice(1) : "");
 /** What each role may do, in one line — the invite modal's radio descriptions (permissions.ts decides). */
 export const ROLE_DESCRIPTION = {
-    editor: "Edits, publishes and deletes content and media.",
+    editor: "Edits, publishes and deletes content and media, and manages redirects.",
     admin: "Everything an editor can, and Settings: invites, re-roles and removes members.",
 };
 export function memberRows(members, opts) {

package/dist/admin/shell/redirects-list.d.ts

@@ -0,0 +1,12 @@
+import type { PathTarget } from "../../paths.ts";
+import type { RedirectTargetItem } from "../ops.ts";
+import type { ComboOption } from "../ui/combo-box.ts";
+import type { ConfirmOptions } from "../ui/confirm.ts";
+export declare const targetOptions: (targets: RedirectTargetItem[]) => ComboOption[];
+export declare function parseTargetValue(value: string): PathTarget | null;
+/** Admin-relative (the caller applies adminHref). */
+export declare const editorHref: (item: {
+    target: PathTarget;
+    collection: string | null;
+}, locale: string) => string;
+export declare const REMOVE_REDIRECT_CONFIRM: Omit<ConfirmOptions, "subject">;

package/dist/admin/shell/redirects-list.js

@@ -0,0 +1,15 @@
+export const targetOptions = (targets) => targets.map((t) => ({ value: `${t.target.kind}:${t.target.id}`, label: `${t.title} · ${t.path}` }));
+export function parseTargetValue(value) {
+    const m = /^(page|entry):(.+)$/.exec(value);
+    return m ? { kind: m[1], id: m[2] } : null;
+}
+/** Admin-relative (the caller applies adminHref). */
+export const editorHref = (item, locale) => item.target.kind === "page"
+    ? `/pages/${encodeURIComponent(item.target.id)}?locale=${encodeURIComponent(locale)}`
+    : `/${item.collection}/${encodeURIComponent(item.target.id)}?locale=${encodeURIComponent(locale)}`;
+export const REMOVE_REDIRECT_CONFIRM = {
+    title: "Remove this redirect?",
+    body: "Visitors who open the old address get a Not found page. Browsers that already followed the redirect may keep going to the new address for a while.",
+    confirmLabel: "Remove redirect",
+    destructive: true,
+};

package/dist/admin/shell/settings.d.ts

@@ -1,9 +1,22 @@
+import { type MemberRole } from "../../permissions.ts";
 export declare const SETTINGS_PAGES: readonly [{
     readonly id: "members";
     readonly title: "Members";
+    readonly capability: "settings";
+}, {
+    readonly id: "redirects";
+    readonly title: "Redirects";
+    readonly capability: "content.write";
+}, {
+    readonly id: "health";
+    readonly title: "Content health";
+    readonly capability: "content.write";
 }];
-export type SettingsPageId = (typeof SETTINGS_PAGES)[number]["id"];
-export declare const DEFAULT_SETTINGS_PAGE: SettingsPageId;
-/** The page for the segment after /settings: the default for none, null for an unknown one. */
+export type SettingsPage = (typeof SETTINGS_PAGES)[number];
+export type SettingsPageId = SettingsPage["id"];
+/** The pages this role may open, in nav order. Every member has content.write, so the area is never empty. */
+export declare const visibleSettingsPages: (role: MemberRole) => readonly SettingsPage[];
+export declare const defaultSettingsPage: (role: MemberRole) => SettingsPageId;
+/** The page for the segment after /settings; null for none or an unknown one. */
 export declare function settingsPage(tail: string | undefined): SettingsPageId | null;
 export declare function settingsTitle(page: SettingsPageId): string;

package/dist/admin/shell/settings.js

@@ -1,15 +1,22 @@
-// The Settings area's pages (spec 2026-09-25 §5; narrowed 2026-09-25 to
-// Members alone — Roles and API Keys dropped, see DESIGN.md §2): ids are
-// URL segments under /settings, titles are what the secondary nav and
-// each top bar show. Pure, so routing is testable without React.
+// The Settings area's pages (spec 2026-09-25 §5; Roles and API Keys
+// dropped 2026-09-25, Redirects added 2026-09-26 §6, Content health added
+// 2026-09-27, editor safety §4): ids are URL
+// segments under /settings, titles are what the secondary nav and each
+// top bar show, and each page names the capability that opens it —
+// Members for admins, Redirects for every member, as renaming is,
+// Content health for every member (editors do most of the fixing). Pure,
+// so routing is testable without React.
+import { can } from "../../permissions.js";
 export const SETTINGS_PAGES = [
-    { id: "members", title: "Members" },
+    { id: "members", title: "Members", capability: "settings" },
+    { id: "redirects", title: "Redirects", capability: "content.write" },
+    { id: "health", title: "Content health", capability: "content.write" },
 ];
-export const DEFAULT_SETTINGS_PAGE = "members";
-/** The page for the segment after /settings: the default for none, null for an unknown one. */
+/** The pages this role may open, in nav order. Every member has content.write, so the area is never empty. */
+export const visibleSettingsPages = (role) => SETTINGS_PAGES.filter((p) => can(role, p.capability));
+export const defaultSettingsPage = (role) => visibleSettingsPages(role)[0].id;
+/** The page for the segment after /settings; null for none or an unknown one. */
 export function settingsPage(tail) {
-    if (tail === undefined)
-        return DEFAULT_SETTINGS_PAGE;
     return SETTINGS_PAGES.some((p) => p.id === tail) ? tail : null;
 }
 export function settingsTitle(page) {

package/dist/admin/tree-ops.d.ts

@@ -36,3 +36,7 @@ export declare function fillLockedZones(tree: PageTree, policies: Record<string,
 export declare function newNodeId(type: string): string;
 /** A page-level value — the template's page fields or the SEO meta (spec 2026-09-10 page fields §5). */
 export declare function patchPage(tree: PageTree, ns: "fields" | "meta", key: string, value: unknown): PageTree;
+/** A zone the page type no longer declares, dropped from the draft (spec 2026-09-27 editor safety §5: Clear zone). */
+export declare function clearZone(tree: PageTree, zone: string): PageTree;
+/** A key removed from a node: `x` / `a.b` in fields, `settings.x`, `styles.x` (§5: an orphan's Clear). */
+export declare function unsetNodePath(tree: PageTree, id: string, path: string): PageTree;

package/dist/admin/tree-ops.js

@@ -1,5 +1,5 @@
 import { GLOBAL_NODE_TYPE } from "../global.js";
-import { setAtPath } from "./field-paths.js";
+import { setAtPath, unsetAtPath } from "./field-paths.js";
 export function zoneOf(tree, id) {
     for (const [zone, nodes] of Object.entries(tree.zones)) {
         if (nodes.some((n) => n.id === id))
@@ -187,3 +187,17 @@ export function newNodeId(type) {
 export function patchPage(tree, ns, key, value) {
     return { ...tree, [ns]: { ...(tree[ns] ?? {}), [key]: value } };
 }
+/** A zone the page type no longer declares, dropped from the draft (spec 2026-09-27 editor safety §5: Clear zone). */
+export function clearZone(tree, zone) {
+    const { [zone]: _gone, ...zones } = tree.zones;
+    return { ...tree, zones };
+}
+/** A key removed from a node: `x` / `a.b` in fields, `settings.x`, `styles.x` (§5: an orphan's Clear). */
+export function unsetNodePath(tree, id, path) {
+    const zone = zoneOf(tree, id);
+    if (!zone)
+        return tree;
+    const ns = path.startsWith("settings.") ? "settings" : path.startsWith("styles.") ? "styles" : "fields";
+    const rest = ns === "fields" ? path : path.slice(ns.length + 1);
+    return withZone(tree, zone, tree.zones[zone].map((n) => (n.id === id ? { ...n, [ns]: unsetAtPath((n[ns] ?? {}), rest) } : n)));
+}

package/dist/admin/ui/Combobox.d.ts

@@ -18,6 +18,12 @@ export type ComboboxProps = {
     createRow?: boolean;
     /** Every query change passes through; the return value is the query kept. */
     onQueryChange?(next: string): string;
+    /** A single select's pick: shown in the input until the editor types. */
+    selected?: string;
+    /** Inside the control, left of the chevron (a single ref's status, open and remove). */
+    suffix?: ReactNode;
+    /** A modifier for the floating list, which is not inside the root (the tags input's width). */
+    listClassName?: string;
     /** Keys the owner wants first; return true when handled. */
     onInputKey?(e: KeyboardEvent<HTMLInputElement>, query: string): boolean;
     /** Escape, or focus leaving the control; `query` is what was typed and not picked. */
@@ -27,9 +33,9 @@ export type ComboboxProps = {
     initialOpen?: boolean;
     className?: string;
 };
-/** The vertical band the list may occupy: the nearest clipping ancestor's box, cut to the viewport. */
+/** The vertical band a popover may occupy: the nearest clipping ancestor's box, cut to the viewport. */
 export declare function clipBand(el: HTMLElement): {
     top: number;
     bottom: number;
 };
-export declare function Combobox({ options, onPick, label, placeholder, disabled, keepOpen, emptyText, renderOption, onSubmit, createRow, onQueryChange, onInputKey, onClose, autoFocus, initialOpen, className, }: ComboboxProps): import("react").JSX.Element;
+export declare function Combobox({ options, onPick, label, placeholder, disabled, keepOpen, emptyText, renderOption, onSubmit, createRow, onQueryChange, onInputKey, onClose, autoFocus, initialOpen, className, selected, suffix, listClassName, }: ComboboxProps): import("react").JSX.Element;

package/dist/admin/ui/Combobox.js

@@ -4,13 +4,16 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // picker and the tags input are both this. It knows nothing about entries
 // or tags — options in, a pick out. Decisions live in ./combo-box.ts.
 // Rows keep the input focused (mousedown is swallowed), so "focus left the
-// control" is the one close signal besides Escape.
-import { useId, useLayoutEffect, useRef, useState } from "react";
+// control" is the one close signal besides Escape. The list is portaled
+// into the admin wrapper and fixed to the viewport, so no scrolling form or
+// modal body clips it (2026-09-27); static rendering keeps it inline.
+import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
 import { ChevronDown } from "lucide-react";
 import { cx } from "./primitives.js";
-import { filterOptions, opensUp, showsCreate, stepActive } from "./combo-box.js";
+import { filterOptions, listPlacement, showsCreate, stepActive } from "./combo-box.js";
 const keepFocus = (e) => e.preventDefault();
-/** The vertical band the list may occupy: the nearest clipping ancestor's box, cut to the viewport. */
+/** The vertical band a popover may occupy: the nearest clipping ancestor's box, cut to the viewport. */
 export function clipBand(el) {
     let top = 0;
     let bottom = window.innerHeight;
@@ -24,29 +27,53 @@ export function clipBand(el) {
     }
     return { top, bottom };
 }
-export function Combobox({ options, onPick, label, placeholder, disabled, keepOpen, emptyText, renderOption, onSubmit, createRow, onQueryChange, onInputKey, onClose, autoFocus, initialOpen = false, className, }) {
+export function Combobox({ options, onPick, label, placeholder, disabled, keepOpen, emptyText, renderOption, onSubmit, createRow, onQueryChange, onInputKey, onClose, autoFocus, initialOpen = false, className, selected, suffix, listClassName, }) {
     const rest = onSubmit ? -1 : 0; // the active row a fresh query starts from
-    const [query, setQuery] = useState("");
+    // null: nothing typed since the last pick, so the input shows `selected`.
+    const [typed, setTyped] = useState(null);
+    const query = typed ?? "";
     const [open, setOpen] = useState(initialOpen);
     const [active, setActive] = useState(rest);
     const root = useRef(null);
     const list = useRef(null);
-    const [up, setUp] = useState(false);
+    const [host, setHost] = useState(null);
+    const [place, setPlace] = useState(null);
     const id = useId();
+    useLayoutEffect(() => {
+        const el = root.current;
+        if (el)
+            setHost(el.closest(".sm-admin") ?? el.ownerDocument.body);
+    }, []);
     const shown = filterOptions(options, query);
     const create = onSubmit !== undefined && createRow === true && showsCreate(options, query);
     const count = shown.length + (create ? 1 : 0);
     // Free text with nothing to offer shows no popover; a picker says why it is empty.
     const popover = open && !disabled && (count > 0 || !onSubmit);
-    // A field at the bottom of a scrolling form has no room under it: the list hangs above instead.
+    // Under the input, or above it when the viewport has no room below; it follows the input on scroll.
+    const measure = useCallback(() => {
+        const el = root.current;
+        if (!el || !list.current)
+            return;
+        const box = el.getBoundingClientRect();
+        setPlace(listPlacement(box, el.ownerDocument.defaultView?.innerHeight ?? 0, list.current.offsetHeight));
+    }, []);
     useLayoutEffect(() => {
-        if (!popover || !root.current || !list.current)
+        if (popover && host)
+            measure();
+        else
+            setPlace(null);
+    }, [popover, host, count, measure]);
+    useEffect(() => {
+        const view = root.current?.ownerDocument.defaultView;
+        if (!popover || !view)
             return;
-        const box = root.current.getBoundingClientRect();
-        const band = clipBand(root.current);
-        setUp(opensUp({ below: band.bottom - box.bottom - 4, above: box.top - band.top - 4, height: list.current.offsetHeight }));
-    }, [popover, count]);
-    const reset = () => { setQuery(""); setActive(rest); };
+        const onScroll = (e) => { if (e.target !== list.current)
+            measure(); };
+        view.addEventListener("scroll", onScroll, true);
+        view.addEventListener("resize", measure);
+        return () => { view.removeEventListener("scroll", onScroll, true); view.removeEventListener("resize", measure); };
+    }, [popover, measure]);
+    const reset = () => { setTyped(null); setActive(rest); };
     const close = (reason) => {
         setOpen(false);
         onClose?.(query, reason);
@@ -84,6 +111,11 @@ export function Combobox({ options, onPick, label, placeholder, disabled, keepOp
             close("escape");
         }
     };
-    return (_jsxs("div", { ref: root, className: cx("sm-combo", className), children: [_jsx("input", { className: "sm-input", role: "combobox", "aria-label": label, "aria-autocomplete": "list", "aria-expanded": popover, "aria-controls": `${id}-list`, "aria-activedescendant": popover && active >= 0 ? `${id}-opt-${active}` : undefined, placeholder: placeholder, disabled: disabled, autoFocus: autoFocus, value: query, onFocus: () => setOpen(true), onClick: () => setOpen(true), onChange: (e) => { setQuery(onQueryChange ? onQueryChange(e.target.value) : e.target.value); setActive(rest); setOpen(true); }, onKeyDown: onKeyDown, onBlur: (e) => { if (open && !root.current?.contains(e.relatedTarget))
-                    close("blur"); } }), _jsx(ChevronDown, { className: "sm-combo__chevron", size: 14, strokeWidth: 1.75, "aria-hidden": "true" }), popover && (_jsxs("div", { ref: list, id: `${id}-list`, role: "listbox", "aria-label": label, className: cx("sm-picker sm-combo__list", up && "sm-combo__list--up"), children: [count === 0 && _jsx("div", { className: "sm-combo__empty", children: options.length === 0 ? emptyText ?? "No matches" : "No matches" }), shown.map((o, i) => (_jsx("button", { id: `${id}-opt-${i}`, type: "button", role: "option", "aria-selected": i === active, className: cx("sm-picker__item", i === active && "sm-picker__item--active"), onMouseDown: keepFocus, onClick: () => pick(i), children: renderOption ? renderOption(o) : o.label }, o.value))), create && (_jsxs("button", { id: `${id}-opt-${shown.length}`, type: "button", role: "option", "aria-selected": active === shown.length, className: cx("sm-picker__item", active === shown.length && "sm-picker__item--active"), onMouseDown: keepFocus, onClick: () => pick(shown.length), children: ["Create \u201C", query.trim(), "\u201D"] }))] }))] }));
+    const floating = host
+        ? { left: place?.left, top: place?.top, bottom: place?.bottom, ["--combo-w"]: place ? `${place.width}px` : undefined, visibility: place ? undefined : "hidden" }
+        : undefined;
+    const listbox = popover && (_jsxs("div", { ref: list, id: `${id}-list`, role: "listbox", "aria-label": label, onMouseDown: keepFocus, className: cx("sm-picker sm-combo__list", host && "sm-combo__list--floating", listClassName), style: floating, children: [count === 0 && _jsx("div", { className: "sm-combo__empty", children: options.length === 0 ? emptyText ?? "No matches" : "No matches" }), shown.map((o, i) => (_jsx("button", { id: `${id}-opt-${i}`, type: "button", role: "option", "aria-selected": i === active, className: cx("sm-picker__item", i === active && "sm-picker__item--active"), onMouseDown: keepFocus, onClick: () => pick(i), children: renderOption ? renderOption(o) : o.label }, o.value))), create && (_jsxs("button", { id: `${id}-opt-${shown.length}`, type: "button", role: "option", "aria-selected": active === shown.length, className: cx("sm-picker__item", active === shown.length && "sm-picker__item--active"), onMouseDown: keepFocus, onClick: () => pick(shown.length), children: ["Create \u201C", query.trim(), "\u201D"] }))] }));
+    return (_jsxs("div", { ref: root, className: cx("sm-combo", suffix != null && "sm-combo--suffix", className), children: [_jsx("input", { className: "sm-input", role: "combobox", "aria-label": label, "aria-autocomplete": "list", "aria-expanded": popover, "aria-controls": `${id}-list`, "aria-activedescendant": popover && active >= 0 ? `${id}-opt-${active}` : undefined, placeholder: placeholder, disabled: disabled, autoFocus: autoFocus, value: typed ?? selected ?? "", onFocus: (e) => { setOpen(true); if (typed === null && selected)
+                    e.currentTarget.select(); }, onClick: () => setOpen(true), onChange: (e) => { setTyped(onQueryChange ? onQueryChange(e.target.value) : e.target.value); setActive(rest); setOpen(true); }, onKeyDown: onKeyDown, onBlur: (e) => { if (open && !root.current?.contains(e.relatedTarget))
+                    close("blur"); } }), suffix != null && _jsx("span", { className: "sm-combo__suffix", children: suffix }), _jsx(ChevronDown, { className: "sm-combo__chevron", size: 14, strokeWidth: 1.75, "aria-hidden": "true" }), listbox && host ? createPortal(listbox, host) : listbox] }));
 }

package/dist/admin/ui/ConfirmDialog.d.ts

@@ -2,7 +2,7 @@ import { type ReactElement } from "react";
 import { type ConfirmOptions } from "./confirm.ts";
 export declare function ConfirmDialog({ options, onAnswer }: {
     options: ConfirmOptions;
-    onAnswer(yes: boolean): void;
+    onAnswer(yes: boolean, checked?: boolean): void;
 }): ReactElement;
 /** Renders the pending question, once, from the shell. */
 export declare function ConfirmHost(): ReactElement | null;

package/dist/admin/ui/ConfirmDialog.js

@@ -5,21 +5,22 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // the consequence, an optional context chip naming the subject, then
 // Cancel and the action verb. Focus opens on Cancel for a destructive
 // action and on the primary otherwise, so Enter runs the primary only
-// when it is safe.
+// when it is safe. A `single` dialog (notify) has the primary alone.
 //
 // <ConfirmHost/> renders the pending question from ui/confirm.ts, once,
 // from the shell; the dialog itself is a plain component so a test can
 // render it statically.
-import { useId, useSyncExternalStore } from "react";
+import { useId, useState, useSyncExternalStore } from "react";
 import { DialogCard } from "./Dialog.js";
 import { Button } from "./primitives.js";
 import { pendingConfirm, subscribeConfirm } from "./confirm.js";
 export function ConfirmDialog({ options, onAnswer }) {
-    const { title, body, confirmLabel, cancelLabel = "Cancel", destructive = false, subject } = options;
+    const { title, body, confirmLabel, cancelLabel = "Cancel", destructive = false, subject, option, single = false } = options;
+    const [checked, setChecked] = useState(option?.checked ?? false);
     const uid = useId();
     const bodyId = `sm-confirm-body${uid}`;
     const cancel = () => onAnswer(false);
-    return (_jsxs(DialogCard, { title: title, role: "alertdialog", describedBy: body ? bodyId : undefined, onClose: cancel, className: "sm-confirm", actions: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "secondary", autoFocus: destructive, onClick: cancel, children: cancelLabel }), _jsx(Button, { variant: destructive ? "destructive" : "primary", autoFocus: !destructive, onClick: () => onAnswer(true), children: confirmLabel })] }), children: [body && _jsx("p", { className: "sm-dialog__body", id: bodyId, children: body }), subject && (_jsxs("div", { className: "sm-dialog__context", children: [_jsx("strong", { children: subject.name }), subject.path && _jsx("code", { children: subject.path })] }))] }));
+    return (_jsxs(DialogCard, { title: title, role: "alertdialog", describedBy: body ? bodyId : undefined, onClose: cancel, className: "sm-confirm", actions: _jsxs(_Fragment, { children: [!single && _jsx(Button, { variant: "secondary", autoFocus: destructive, onClick: cancel, children: cancelLabel }), _jsx(Button, { variant: destructive ? "destructive" : "primary", autoFocus: !destructive, onClick: () => onAnswer(true, checked), children: confirmLabel })] }), children: [body && _jsx("p", { className: "sm-dialog__body", id: bodyId, children: body }), option && (_jsxs("label", { className: "sm-choice sm-confirm__option", children: [_jsx("input", { type: "checkbox", checked: checked, onChange: (e) => setChecked(e.target.checked) }), _jsx("span", { children: option.label })] })), subject && (_jsxs("div", { className: "sm-dialog__context", children: [_jsx("strong", { children: subject.name }), subject.path && _jsx("code", { children: subject.path })] }))] }));
 }
 /** Renders the pending question, once, from the shell. */
 export function ConfirmHost() {

package/dist/admin/ui/DriftNotice.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+import type { Finding } from "../drift.ts";
+export declare function DriftNotice({ draft, live }: {
+    draft: Finding[];
+    live: Finding[];
+}): ReactElement | null;

package/dist/admin/ui/DriftNotice.js

@@ -0,0 +1,10 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { driftNotice } from "../drift-copy.js";
+import { Banner } from "./primitives.js";
+export function DriftNotice({ draft, live }) {
+    const { summary, liveOnly, sentences } = driftNotice(draft, live);
+    if (!summary && !liveOnly && sentences.length === 0)
+        return null;
+    return (_jsx("div", { className: "sm-drift", "data-testid": "drift-notice", children: _jsxs(Banner, { tone: "warn", children: [summary && _jsx("p", { style: { margin: 0 }, children: summary }), liveOnly && _jsx("p", { style: { margin: 0 }, children: liveOnly }), sentences.map((s) => _jsx("p", { style: { margin: 0 }, children: s }, s))] }) }));
+}

package/dist/admin/ui/combo-box.d.ts

@@ -14,3 +14,16 @@ export declare const opensUp: (room: {
     above: number;
     height: number;
 }) => boolean;
+/** Where the floating list sits (fixed, in viewport pixels): under the input at its width,
+ *  or above it, anchored by its bottom edge, when opensUp says so. */
+export declare function listPlacement(box: {
+    top: number;
+    bottom: number;
+    left: number;
+    width: number;
+}, viewport: number, height: number): {
+    left: number;
+    width: number;
+    top?: number;
+    bottom?: number;
+};

package/dist/admin/ui/combo-box.js

@@ -19,3 +19,11 @@ export function stepActive(active, count, dir) {
 }
 /** Whether the list hangs above the input: only when it does not fit below and there is more room above. */
 export const opensUp = (room) => room.height > room.below && room.above > room.below;
+/** Where the floating list sits (fixed, in viewport pixels): under the input at its width,
+ *  or above it, anchored by its bottom edge, when opensUp says so. */
+export function listPlacement(box, viewport, height) {
+    const at = { left: box.left, width: box.width };
+    return opensUp({ below: viewport - box.bottom - 4, above: box.top - 4, height })
+        ? { ...at, bottom: viewport - box.top + 4 }
+        : { ...at, top: box.bottom + 4 };
+}

package/dist/admin/ui/confirm.d.ts

@@ -17,19 +17,38 @@ export type ConfirmOptions = {
     destructive?: boolean;
     /** The context chip repeating the subject; omit when there is no single subject. */
     subject?: ConfirmSubject;
+    /** A yes/no rider under the body — "Redirect the old address" (spec 2026-09-26 redirects §6); `checked` is its initial state. */
+    option?: {
+        label: string;
+        checked: boolean;
+    };
+    /** One OK button, no Cancel — notify's dialog (spec 2026-09-27 editor safety §7). */
+    single?: boolean;
+};
+export type ConfirmAnswer = {
+    yes: boolean;
+    checked: boolean;
 };
 export type ConfirmRequest = {
     id: number;
     options: ConfirmOptions;
-    answer(yes: boolean): void;
+    answer(yes: boolean, checked?: boolean): void;
 };
 /** The Discard changes question, shared by the page editor and the entry and global forms (publish flow §4). */
 export declare const DISCARD_CONFIRM: Omit<ConfirmOptions, "subject">;
+/** Ask; resolves with the answer and the option's final state once the dialog closes. */
+export declare function confirmWithOption(options: ConfirmOptions): Promise<ConfirmAnswer>;
 /** Ask; resolves with the answer once the dialog closes. */
-export declare function confirm(options: ConfirmOptions): Promise<boolean>;
+export declare const confirm: (options: ConfirmOptions) => Promise<boolean>;
 /** The question being asked, if any — the head of the queue. */
 export declare const pendingConfirm: () => ConfirmRequest | null;
 /** For useSyncExternalStore: fires on every queue change. */
 export declare function subscribeConfirm(fn: () => void): () => void;
 /** Test seam: drop every pending question unanswered. */
 export declare function resetConfirms(): void;
+/** Tell, don't ask (spec 2026-09-27 editor safety §7): a one-button dialog in place of window.alert,
+ *  resolved once it is dismissed; with no host mounted, the native alert. */
+export declare function notify(options: {
+    title: string;
+    message: string;
+}): Promise<void>;

package/dist/admin/ui/confirm.js

@@ -8,6 +8,9 @@
 // One question at a time; a second request waits for the first answer.
 // Without a mounted host (a test, a stray render outside the shell) the
 // question falls back to window.confirm so no caller can hang.
+//
+// `notify` tells rather than asks (spec 2026-09-27 editor safety §7): the
+// same host, one OK button, window.alert as its no-host fallback.
 /** The Discard changes question, shared by the page editor and the entry and global forms (publish flow §4). */
 export const DISCARD_CONFIRM = {
     title: "Discard unsaved changes?",
@@ -18,31 +21,35 @@ export const DISCARD_CONFIRM = {
 const listeners = new Set();
 let queue = [];
 let seq = 0;
-const notify = () => { for (const fn of listeners)
+const emit = () => { for (const fn of listeners)
     fn(); };
-/** Ask; resolves with the answer once the dialog closes. */
-export function confirm(options) {
+/** Ask; resolves with the answer and the option's final state once the dialog closes. */
+export function confirmWithOption(options) {
+    const initial = options.option?.checked ?? false;
     if (listeners.size === 0) {
         const text = [options.title, options.body].filter(Boolean).join("\n\n");
-        return Promise.resolve(typeof window !== "undefined" && typeof window.confirm === "function" ? window.confirm(text) : false);
+        const yes = typeof window !== "undefined" && typeof window.confirm === "function" ? window.confirm(text) : false;
+        return Promise.resolve({ yes, checked: initial });
     }
     return new Promise((resolve) => {
         const id = ++seq;
         const request = {
             id,
             options,
-            answer(yes) {
+            answer(yes, checked = initial) {
                 if (!queue.some((r) => r.id === id))
                     return; // answered already
                 queue = queue.filter((r) => r.id !== id);
-                notify();
-                resolve(yes);
+                emit();
+                resolve({ yes, checked });
             },
         };
         queue = [...queue, request];
-        notify();
+        emit();
     });
 }
+/** Ask; resolves with the answer once the dialog closes. */
+export const confirm = (options) => confirmWithOption(options).then((a) => a.yes);
 /** The question being asked, if any — the head of the queue. */
 export const pendingConfirm = () => queue[0] ?? null;
 /** For useSyncExternalStore: fires on every queue change. */
@@ -53,5 +60,15 @@ export function subscribeConfirm(fn) {
 /** Test seam: drop every pending question unanswered. */
 export function resetConfirms() {
     queue = [];
-    notify();
+    emit();
+}
+/** Tell, don't ask (spec 2026-09-27 editor safety §7): a one-button dialog in place of window.alert,
+ *  resolved once it is dismissed; with no host mounted, the native alert. */
+export function notify(options) {
+    if (listeners.size === 0) {
+        if (typeof window !== "undefined" && typeof window.alert === "function")
+            window.alert(`${options.title}\n\n${options.message}`);
+        return Promise.resolve();
+    }
+    return confirmWithOption({ title: options.title, body: options.message, confirmLabel: "OK", single: true }).then(() => undefined);
 }