smoodly 0.0.15 → 0.0.17

package/dist/admin/tree-ops.js

@@ -1,4 +1,4 @@
-import { SHARED_NODE_TYPE } from "../shared.js";
+import { GLOBAL_NODE_TYPE } from "../global.js";
 import { setAtPath } from "./field-paths.js";
 export function zoneOf(tree, id) {
     for (const [zone, nodes] of Object.entries(tree.zones)) {
@@ -64,6 +64,18 @@ export function patchNode(tree, id, ns, key, value) {
         return tree;
     return withZone(tree, zone, tree.zones[zone].map((n) => (n.id === id ? { ...n, [ns]: { ...(n[ns] ?? {}), [key]: value } } : n)));
 }
+/** The node's custom CSS (spec 2026-09-14 §4); undefined or "" removes the key. */
+export function patchNodeCss(tree, id, css) {
+    const zone = zoneOf(tree, id);
+    if (!zone)
+        return tree;
+    return withZone(tree, zone, tree.zones[zone].map((n) => {
+        if (n.id !== id)
+            return n;
+        const { css: _old, ...rest } = n;
+        return css === undefined || css === "" ? rest : { ...rest, css };
+    }));
+}
 /** patchNode for a dotted path inside `fields` (spec 2026-09-10 §1):
  *  `points.2.heading` sets one item's heading and copies only the spine. */
 export function patchNodePath(tree, id, path, value) {
@@ -89,11 +101,11 @@ export function allowedSections(policy, all) {
 }
 /** The visual items the picker offers in a zone: materialized (an id is
  *  known) and rendering a section the zone's policy allows. */
-export function allowedShared(policy, shared, sharedIds) {
+export function allowedGlobals(policy, globals, globalIds) {
     if (!policy || policy.kind === "locked")
         return [];
-    return shared.filter((s) => {
-        if (s.section === undefined || sharedIds[s.name] === undefined)
+    return globals.filter((s) => {
+        if (s.section === undefined || globalIds[s.name] === undefined)
             return false;
         return policy.allow === "*" || policy.allow.includes(s.section);
     });
@@ -101,7 +113,7 @@ export function allowedShared(policy, shared, sharedIds) {
 /** A page places a visual item as this node (spec 2026-09-07 §6): `item`
  *  names the registration, `ref` is the item's row id. */
 export function placementNode(item, ref, id) {
-    return { id, type: SHARED_NODE_TYPE, fields: { item: item.name, ref } };
+    return { id, type: GLOBAL_NODE_TYPE, fields: { item: item.name, ref } };
 }
 /** The empty value a fresh node's field starts at, by descriptor type.
  * Shape matters: a list-valued field seeded with "" is a type lie that
@@ -111,10 +123,10 @@ const EMPTY_BY_TYPE = { refList: [], object: {} };
  * broken-image icon or a stray zero, worse than nothing at all. With no
  * sample, leave the key out of `fields` entirely rather than seed a lie. */
 const ABSENT_WHEN_UNSAMPLED = new Set(["image", "video", "file", "number"]);
-/** Also fills an element node (an `AdminElement` is a section shape plus contexts). */
+/** Also fills an element node (an `AdminElement` is a section shape plus contexts). Never seeds `styles` or `css`: Default stores nothing (spec 2026-09-14 §2). */
 export function nodeFromSample(section, id) {
     const fields = {};
-    const styles = {};
+    const settings = {};
     for (const [key, d] of Object.entries(section.fields)) {
         const sampled = section.sample?.[key] ?? d.default ?? (d.type === "boolean" ? false : undefined);
         if (sampled !== undefined)
@@ -124,20 +136,20 @@ export function nodeFromSample(section, id) {
         else
             fields[key] = EMPTY_BY_TYPE[d.type] ?? "";
     }
-    for (const [key, d] of Object.entries(section.styles)) {
+    for (const [key, d] of Object.entries(section.settings)) {
         const v = section.sample?.[key] ?? d.default;
         if (v !== undefined)
-            styles[key] = v;
+            settings[key] = v;
     }
-    return { id, type: section.name, fields, styles };
+    return { id, type: section.name, fields, settings };
 }
 /** A locked zone holds exactly one node the editor can never insert or
  * remove — so someone has to put it there. This does, from the component's
- * sample (or, for a zone bound to a shared item, a placement), for every
+ * sample (or, for a zone bound to a global item, a placement), for every
  * locked zone that is empty or missing. Runs when the editor loads a draft,
  * which also covers pages that predate a locked zone being added to their
  * schema. Returns the same tree when nothing changed. */
-export function fillLockedZones(tree, policies, sections, sharedIds = {}) {
+export function fillLockedZones(tree, policies, sections, globalIds = {}) {
     let next = null;
     for (const [zone, policy] of Object.entries(policies)) {
         if (policy.kind !== "locked")
@@ -145,14 +157,14 @@ export function fillLockedZones(tree, policies, sections, sharedIds = {}) {
         if ((tree.zones[zone] ?? []).length > 0)
             continue;
         let node = null;
-        if (policy.shared !== undefined) {
-            // Bound to a shared item (spec 2026-09-07 §4): a placement, once
+        if (policy.global !== undefined) {
+            // Bound to a global item (spec 2026-09-07 §4): a placement, once
             // the editor has loaded the item's row id; until then leave the
             // zone empty rather than seed a plain section there.
-            const ref = sharedIds[policy.shared];
+            const ref = globalIds[policy.global];
             if (ref === undefined)
                 continue;
-            node = placementNode({ name: policy.shared }, ref, newNodeId(SHARED_NODE_TYPE));
+            node = placementNode({ name: policy.global }, ref, newNodeId(GLOBAL_NODE_TYPE));
         }
         else {
             const section = sections.find((s) => s.name === policy.component);

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

@@ -0,0 +1,11 @@
+export type ActionMenuItem = {
+    label: string;
+    run(): void;
+    disabled?: boolean;
+    danger?: boolean;
+};
+export declare function ActionMenu({ label, items, disabled }: {
+    label: string;
+    items: ActionMenuItem[];
+    disabled?: boolean;
+}): import("react").JSX.Element;

package/dist/admin/ui/ActionMenu.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A round three-dot button and its popover of actions (spec 2026-09-13
+// publish flow §2). Items are always rendered and disabled when they do
+// not apply — the layout never shifts and the editor learns what exists.
+// The popover is the Pages list's row menu shape (`.sm-picker`), anchored
+// under the button instead of at the pointer.
+import { useEffect, useRef, useState } from "react";
+import { cx } from "./primitives.js";
+export function ActionMenu({ label, items, disabled }) {
+    const [open, setOpen] = useState(false);
+    const ref = useRef(null);
+    useEffect(() => {
+        if (!open)
+            return;
+        const onDown = (e) => { if (!ref.current?.contains(e.target))
+            setOpen(false); };
+        const onKey = (e) => { if (e.key === "Escape")
+            setOpen(false); };
+        document.addEventListener("pointerdown", onDown);
+        document.addEventListener("keydown", onKey);
+        return () => { document.removeEventListener("pointerdown", onDown); document.removeEventListener("keydown", onKey); };
+    }, [open]);
+    return (_jsxs("div", { ref: ref, style: { position: "relative", flex: "none" }, children: [_jsx("button", { type: "button", className: "sm-dotmenu", "aria-label": label, title: label, "aria-haspopup": "menu", "aria-expanded": open, disabled: disabled, onClick: () => setOpen((o) => !o), children: "\u00B7\u00B7\u00B7" }), open && (_jsx("div", { role: "menu", className: "sm-picker sm-picker--menu", children: items.map((item) => (_jsx("button", { type: "button", role: "menuitem", className: cx("sm-picker__item", item.danger && "sm-picker__item--danger"), disabled: item.disabled, onClick: () => { setOpen(false); item.run(); }, children: item.label }, item.label))) }))] }));
+}

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

@@ -0,0 +1,23 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { PageLocale } from "../../store.ts";
+import type { VersionSummary } from "../ops.ts";
+export type HistoryTag = "Draft" | "Live" | null;
+export type HistoryRow = VersionSummary & {
+    tag: HistoryTag;
+};
+export declare const RESTORE_CONFIRM = "Restore this version? The current draft will be replaced. Nothing goes live until you publish.";
+/** The rows for a locale's versions: the unpublished draft is Draft, the
+ *  row the site serves Live, an older publish carries nothing. */
+export declare function historyRows(versions: VersionSummary[], row: Pick<PageLocale, "status" | "draftVersionId" | "publishedVersionId">): HistoryRow[];
+export declare function HistoryModal({ rows, draftId, render, onSelect, onRestore, onClose }: {
+    rows: HistoryRow[];
+    /** The current draft's version id: Restore is disabled on it. */
+    draftId: string | null;
+    /** The main area for the selected version. */
+    render(versionId: string): ReactNode;
+    /** The selection changed — fired once for the initial row too; the entry screens load the snapshot here. */
+    onSelect?(versionId: string): void;
+    /** Resolves true when the restore landed; the modal then closes itself. */
+    onRestore(versionId: string): Promise<boolean>;
+    onClose(): void;
+}): ReactElement;

package/dist/admin/ui/HistoryModal.js

@@ -0,0 +1,40 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// The History modal (spec 2026-09-13 history §5): the locale's versions on
+// the left — newest first, the unpublished draft tagged Draft and the row
+// the site serves Live — and the selected version on the right, rendered
+// by the screen that opened it (an iframe of the site's draft route for a
+// page, a disabled form for an entry or a global item). Restore confirms,
+// hands the id to the screen, and closes once the restore landed.
+import { useEffect, useState } from "react";
+import { versionTime } from "./format.js";
+import { Modal } from "./Modal.js";
+import { Button, cx } from "./primitives.js";
+export const RESTORE_CONFIRM = "Restore this version? The current draft will be replaced. Nothing goes live until you publish.";
+/** The rows for a locale's versions: the unpublished draft is Draft, the
+ *  row the site serves Live, an older publish carries nothing. */
+export function historyRows(versions, row) {
+    const live = row.status === "published";
+    return versions.map((v) => ({
+        ...v,
+        tag: v.id === row.draftVersionId && (v.id !== row.publishedVersionId || !live) ? "Draft"
+            : v.id === row.publishedVersionId && live ? "Live"
+                : null,
+    }));
+}
+export function HistoryModal({ rows, draftId, render, onSelect, onRestore, onClose }) {
+    const [selected, setSelected] = useState(rows[0]?.id ?? null);
+    const [busy, setBusy] = useState(false);
+    useEffect(() => { if (selected)
+        onSelect?.(selected); }, [selected]); // eslint-disable-line react-hooks/exhaustive-deps
+    const restore = async () => {
+        if (!selected || !window.confirm(RESTORE_CONFIRM))
+            return;
+        setBusy(true);
+        const landed = await onRestore(selected);
+        setBusy(false);
+        if (landed)
+            onClose();
+    };
+    return (_jsx(Modal, { title: "History", width: 1200, height: "85vh", flush: true, onClose: onClose, footer: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "secondary", onClick: onClose, children: "Close" }), _jsx(Button, { disabled: busy || !selected || selected === draftId, onClick: () => { void restore(); }, children: busy ? "Restoring…" : "Restore" })] }), children: _jsxs("div", { className: "sm-history", children: [_jsxs("div", { className: "sm-history__list", role: "listbox", "aria-label": "Versions", children: [rows.length === 0 && _jsx("span", { className: "sm-hint", style: { padding: 12 }, children: "No versions yet." }), rows.map((r) => (_jsxs("button", { type: "button", role: "option", "aria-selected": r.id === selected, className: cx("sm-history__row", r.id === selected && "sm-history__row--active"), onClick: () => setSelected(r.id), children: [_jsx("span", { children: versionTime(r.savedAt) }), r.tag && _jsx("span", { className: cx("sm-history__tag", r.tag === "Live" && "sm-history__tag--live"), children: r.tag })] }, r.id)))] }), _jsx("div", { className: "sm-history__main", children: selected ? render(selected) : null })] }) }));
+}

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

@@ -1,7 +1,11 @@
 import { type ReactElement, type ReactNode } from "react";
-export declare function Modal({ title, width, onClose, children, footer }: {
+export declare function Modal({ title, width, height, flush, onClose, children, footer }: {
     title: string;
     width?: number;
+    /** A fixed panel height (e.g. `"85vh"`) for a modal whose body must fill it; default: the content's. */
+    height?: number | string;
+    /** Drops the body padding for a modal whose body is a two-pane layout (History). */
+    flush?: boolean;
     onClose(): void;
     children: ReactNode;
     footer?: ReactNode;

package/dist/admin/ui/Modal.js

@@ -8,13 +8,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // overflow the same way. Static rendering (no document) keeps it inline.
 import { useEffect, useState } from "react";
 import { createPortal } from "react-dom";
-import { IconButton } from "./primitives.js";
+import { cx, IconButton } from "./primitives.js";
 function adminRoot() {
     if (typeof document === "undefined")
         return null;
     return document.querySelector(".sm-admin") ?? document.body;
 }
-export function Modal({ title, width = 720, onClose, children, footer }) {
+export function Modal({ title, width = 720, height, flush = false, onClose, children, footer }) {
     const [root] = useState(adminRoot);
     useEffect(() => {
         const onKey = (e) => { if (e.key === "Escape")
@@ -22,6 +22,6 @@ export function Modal({ title, width = 720, onClose, children, footer }) {
         window.addEventListener("keydown", onKey);
         return () => window.removeEventListener("keydown", onKey);
     }, [onClose]);
-    const modal = (_jsx("div", { className: "sm-modal", onClick: onClose, children: _jsxs("div", { className: "sm-modal__panel", role: "dialog", "aria-label": title, style: { width }, onClick: (e) => e.stopPropagation(), children: [_jsxs("div", { className: "sm-modal__head", children: [_jsx("span", { className: "sm-title", children: title }), _jsx(IconButton, { label: "Close", onClick: onClose, children: "\u00D7" })] }), _jsx("div", { className: "sm-modal__body", children: children }), footer && _jsx("div", { className: "sm-modal__foot", children: footer })] }) }));
+    const modal = (_jsx("div", { className: "sm-modal", onClick: onClose, children: _jsxs("div", { className: "sm-modal__panel", role: "dialog", "aria-label": title, style: { width, ...(height !== undefined ? { height } : {}) }, onClick: (e) => e.stopPropagation(), children: [_jsxs("div", { className: "sm-modal__head", children: [_jsx("span", { className: "sm-title", children: title }), _jsx(IconButton, { label: "Close", onClick: onClose, children: "\u00D7" })] }), _jsx("div", { className: cx("sm-modal__body", flush && "sm-modal__body--flush"), children: children }), footer && _jsx("div", { className: "sm-modal__foot", children: footer })] }) }));
     return root ? createPortal(modal, root) : modal;
 }

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

@@ -0,0 +1,31 @@
+import type { LocaleStatus } from "../shell/pages-tree.ts";
+import { type ActionMenuItem } from "./ActionMenu.tsx";
+export type PublishBusy = "publish" | "discard" | "unpublish" | null;
+/** The three-dot menu's items: History first when the screen offers it (spec 2026-09-13 history §5;
+ *  every collection since 2026-09-14), then the two publish-flow actions — always rendered,
+ *  disabled when they do not apply. */
+export declare function publishMenu(opts: {
+    can: {
+        discard: boolean;
+        unpublish: boolean;
+    };
+    onDiscard(): void;
+    onUnpublish(): void;
+    onHistory?(): void;
+}): ActionMenuItem[];
+export declare function PublishControl({ status, pending, busy, flash, disabled, onPublish, onDiscard, onUnpublish, onHistory, }: {
+    /** The locale's stored state; null while the document loads or before it exists. */
+    status: LocaleStatus | null;
+    /** The editor holds a change the store has not confirmed (dirty, or a save pending / in flight / failed). */
+    pending?: boolean;
+    busy?: PublishBusy;
+    /** The moment after a publish: the button reads "Published ✓". */
+    flash?: boolean;
+    /** No document to act on (loading, a new unsaved entry). */
+    disabled?: boolean;
+    onPublish(): void;
+    onDiscard(): void;
+    onUnpublish(): void;
+    /** Opens History (spec 2026-09-13 history §5). Absent = no History item (the canvas card). */
+    onHistory?(): void;
+}): import("react").JSX.Element;

package/dist/admin/ui/PublishControl.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ActionMenu } from "./ActionMenu.js";
+import { Button, StatusBadge } from "./primitives.js";
+import { publishActions, statusLabel } from "./status-label.js";
+const BUSY_WORD = {
+    publish: "Publishing…", discard: "Discarding…", unpublish: "Unpublishing…",
+};
+/** The three-dot menu's items: History first when the screen offers it (spec 2026-09-13 history §5;
+ *  every collection since 2026-09-14), then the two publish-flow actions — always rendered,
+ *  disabled when they do not apply. */
+export function publishMenu(opts) {
+    return [
+        ...(opts.onHistory ? [{ label: "History", run: opts.onHistory }] : []),
+        { label: "Discard changes", danger: true, disabled: !opts.can.discard, run: opts.onDiscard },
+        { label: "Unpublish", disabled: !opts.can.unpublish, run: opts.onUnpublish },
+    ];
+}
+export function PublishControl({ status, pending = false, busy = null, flash = false, disabled = false, onPublish, onDiscard, onUnpublish, onHistory, }) {
+    const can = publishActions(status, pending);
+    const inert = disabled || busy !== null;
+    const word = busy ? BUSY_WORD[busy] : flash ? "Published ✓" : "Publish";
+    return (_jsxs("span", { style: { display: "inline-flex", alignItems: "center", gap: 8 }, children: [status && _jsx(StatusBadge, { status: statusLabel(status) }), _jsx(Button, { variant: flash && !busy ? "ok" : "primary", disabled: inert || !can.publish, onClick: onPublish, children: word }), _jsx(ActionMenu, { label: "More actions", disabled: inert || status === null, items: publishMenu({ can, onDiscard, onUnpublish, onHistory }) })] }));
+}

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

@@ -1 +1,5 @@
 export declare function relativeTime(ms: number, now?: number): string;
+/** A version's saved time: an absolute date and time — History compares moments, not distances. */
+export declare function versionTime(ms: number): string;
+/** The "Updated" info line: the relative time, then who, when the row knows (spec 2026-09-13 history §2). */
+export declare function updatedLine(updatedAt: number, updatedBy: string | null, now?: number): string;

package/dist/admin/ui/format.js

@@ -23,3 +23,12 @@ export function relativeTime(ms, now = Date.now()) {
         month: "short", day: "numeric", ...(sameYear ? {} : { year: "numeric" }),
     });
 }
+/** A version's saved time: an absolute date and time — History compares moments, not distances. */
+export function versionTime(ms) {
+    return new Date(ms).toLocaleString(undefined, { day: "numeric", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" });
+}
+/** The "Updated" info line: the relative time, then who, when the row knows (spec 2026-09-13 history §2). */
+export function updatedLine(updatedAt, updatedBy, now = Date.now()) {
+    const when = relativeTime(updatedAt, now);
+    return updatedBy ? `${when} · ${updatedBy}` : when;
+}

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

@@ -1,5 +1,6 @@
 import type { AnchorHTMLAttributes, ButtonHTMLAttributes, CSSProperties, ReactNode } from "react";
 import type { SaveState } from "../editor/autosave.ts";
+import type { FieldError } from "../validate.ts";
 /** The wordmark, inlined: a package can't ship a file into the host app's
  *  /public. Its colour is the --logo-color token (accent in the warm look). */
 export declare function Logo({ height }: {
@@ -43,11 +44,13 @@ export declare function Grip(props: ButtonHTMLAttributes<HTMLButtonElement>): im
 /** Label + optional counter above a control — the handoff's Input/Textarea head.
  *  `asDiv` for groups holding more than one control: an implicit <label>
  *  activates its first labelable descendant, so wrapping several is a trap. */
-export declare function Field({ label, mark, counter, hint, error, asDiv, children, style, className, path }: {
+export declare function Field({ label, mark, counter, action, hint, error, asDiv, children, style, className, path }: {
     label?: ReactNode;
     /** A small glyph after the label — the field's "same in every language" mark. */
     mark?: ReactNode;
     counter?: ReactNode;
+    /** A small text action at the head's right end, after the counter (a list's Collapse all). */
+    action?: ReactNode;
     hint?: ReactNode;
     error?: ReactNode;
     asDiv?: boolean;
@@ -115,10 +118,22 @@ export declare function SectionLabel({ children, action, mono, style }: {
 export declare function Divider({ bleed }: {
     bleed?: number;
 }): import("react").JSX.Element;
+/** The lines under a publish-validation banner: one per field, each focusing its widget
+ *  when the screen can reveal it (spec 2026-09-14 §2). */
+export declare function FieldErrorList({ fields, onReveal }: {
+    fields: FieldError[];
+    onReveal?(path: string): void;
+}): import("react").JSX.Element | null;
 export declare function Banner({ tone, children, onDismiss }: {
     tone: "ok" | "error" | "warn";
     children: ReactNode;
     onDismiss?: () => void;
 }): import("react").JSX.Element;
 export declare function cx(...parts: (string | false | null | undefined)[]): string;
+/** One line of a form's info block: a muted label, the value right-aligned and clipped. */
+export declare function InfoRow({ label, value, mono }: {
+    label: string;
+    value: string;
+    mono?: boolean;
+}): import("react").JSX.Element;
 export {};

package/dist/admin/ui/primitives.js

@@ -66,9 +66,9 @@ export function Grip(props) {
 /** Label + optional counter above a control — the handoff's Input/Textarea head.
  *  `asDiv` for groups holding more than one control: an implicit <label>
  *  activates its first labelable descendant, so wrapping several is a trap. */
-export function Field({ label, mark, counter, hint, error, asDiv, children, style, className, path }) {
+export function Field({ label, mark, counter, action, hint, error, asDiv, children, style, className, path }) {
     const Tag = asDiv ? "div" : "label";
-    return (_jsxs(Tag, { className: cx("sm-field", className), style: style, "data-sm-path": path, children: [(label || counter) && (_jsxs("span", { className: "sm-field__head", children: [_jsxs("span", { className: "sm-label", children: [label, mark] }), counter && _jsx("span", { className: "sm-counter", children: counter })] })), children, hint && _jsx("span", { className: "sm-hint", children: hint }), error && _jsx("span", { className: "sm-error", children: error })] }));
+    return (_jsxs(Tag, { className: cx("sm-field", className), style: style, "data-sm-path": path, children: [(label || counter || action) && (_jsxs("span", { className: "sm-field__head", children: [_jsxs("span", { className: "sm-label", children: [label, mark] }), (counter || action) && (_jsxs("span", { className: "sm-field__aside", children: [counter && _jsx("span", { className: "sm-counter", children: counter }), action] }))] })), children, hint && _jsx("span", { className: "sm-hint", children: hint }), error && _jsx("span", { className: "sm-error", children: error })] }));
 }
 /** The mark beside a field that is NOT `.localized()`: a globe-off, so a
  *  multilingual form needs no "shared across languages" grouping. */
@@ -106,11 +106,11 @@ export function Segmented({ options, value, onChange, stretch, disabled, label,
         }) }));
 }
 /* ── data ────────────────────────────────────────────────────────────── */
+// Keyed by the product labels of ui/status-label.ts (lowercased by StatusBadge).
 const STATUS_TONE = {
     published: "published",
+    "unpublished changes": "changes",
     draft: "draft",
-    "draft edits": "scheduled",
-    scheduled: "scheduled",
 };
 export function StatusBadge({ status }) {
     const tone = STATUS_TONE[status.toLowerCase()] ?? "draft";
@@ -134,9 +134,25 @@ export function SectionLabel({ children, action, mono, style }) {
 export function Divider({ bleed = 0 }) {
     return _jsx("div", { className: "sm-divider", style: { margin: `0 -${bleed}px` } });
 }
+/** The lines under a publish-validation banner: one per field, each focusing its widget
+ *  when the screen can reveal it (spec 2026-09-14 §2). */
+export function FieldErrorList({ fields, onReveal }) {
+    if (fields.length === 0)
+        return null;
+    return (_jsx("ul", { className: "sm-fielderr", children: fields.map((f) => (_jsxs("li", { children: [onReveal
+                    ? _jsx("button", { type: "button", className: "sm-fielderr__field", onClick: () => onReveal(f.field), children: f.field })
+                    : f.field, ": ", f.message] }, f.field))) }));
+}
 export function Banner({ tone, children, onDismiss }) {
     return (_jsxs("div", { className: `sm-banner sm-banner--${tone}`, role: tone === "error" ? "alert" : undefined, children: [_jsx("div", { style: { flex: 1, minWidth: 0 }, children: children }), onDismiss && (_jsx("button", { type: "button", onClick: onDismiss, "aria-label": "Dismiss", style: { background: "transparent", border: 0, color: "inherit", cursor: "pointer", font: "inherit", padding: 0 }, children: "\u00D7" }))] }));
 }
 export function cx(...parts) {
     return parts.filter(Boolean).join(" ");
 }
+/** One line of a form's info block: a muted label, the value right-aligned and clipped. */
+export function InfoRow({ label, value, mono }) {
+    return (_jsxs("div", { style: { display: "flex", justifyContent: "space-between", gap: 10, fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: [_jsx("span", { children: label }), _jsx("span", { style: {
+                    color: "var(--text)", fontFamily: mono ? "var(--font-mono)" : undefined,
+                    overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap",
+                }, children: value })] }));
+}

package/dist/admin/ui/status-label.d.ts

@@ -0,0 +1,10 @@
+import type { LocaleStatus } from "../shell/pages-tree.ts";
+export type StatusLabel = "Published" | "Unpublished changes" | "Draft";
+export declare function statusLabel(status: LocaleStatus): StatusLabel;
+/** Which of the three actions apply (spec §2). `pending`: the editor holds a change
+ *  the store has not confirmed yet — Publish wakes on the first keystroke, not on the ack. */
+export declare function publishActions(status: LocaleStatus | null, pending: boolean): {
+    publish: boolean;
+    discard: boolean;
+    unpublish: boolean;
+};

package/dist/admin/ui/status-label.js

@@ -0,0 +1,14 @@
+export function statusLabel(status) {
+    return status === "published" ? "Published" : status === "draft edits" ? "Unpublished changes" : "Draft";
+}
+/** Which of the three actions apply (spec §2). `pending`: the editor holds a change
+ *  the store has not confirmed yet — Publish wakes on the first keystroke, not on the ack. */
+export function publishActions(status, pending) {
+    if (status === null)
+        return { publish: false, discard: false, unpublish: false };
+    return {
+        publish: status !== "published" || pending,
+        discard: status === "draft edits",
+        unpublish: status === "published" || status === "draft edits",
+    };
+}