smoodly 0.0.9 → 0.0.10

package/dist/admin/editor/useCanvasBridge.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from "react";
+import type { BridgeRect, ToBridge, ZoneRect } from "./protocol.ts";
+export type Geometry = "waiting" | "ok" | "missing";
+export declare function useCanvasBridge({ iframeRef, iframeSrc, onSelect, onHover }: {
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    iframeSrc: string | null;
+    onSelect(id: string | null): void;
+    onHover(id: string | null): void;
+}): {
+    rects: BridgeRect[];
+    emptyZones: ZoneRect[];
+    docH: number;
+    geometry: Geometry;
+    postToCanvas: (m: ToBridge) => void;
+};

package/dist/admin/editor/useCanvasBridge.js

@@ -0,0 +1,53 @@
+// The admin side of the editor⇄canvas protocol: the geometry the bridge
+// reports (node rects, empty zones, document height), select/hover
+// forwarded from the iframe, and `postToCanvas` for refresh/scroll.
+// Geometry silence is survivable — after GEOMETRY_TIMEOUT_MS the overlay
+// goes dark, the iframe and the outline keep working.
+import { useCallback, useEffect, useRef, useState } from "react";
+const GEOMETRY_TIMEOUT_MS = 4000;
+export function useCanvasBridge({ iframeRef, iframeSrc, onSelect, onHover }) {
+    const [rects, setRects] = useState([]);
+    const [emptyZones, setEmptyZones] = useState([]);
+    const [docH, setDocH] = useState(900);
+    const [geometry, setGeometry] = useState("waiting");
+    // The listener registers once; the handlers are read through refs.
+    const handlers = useRef({ onSelect, onHover });
+    handlers.current = { onSelect, onHover };
+    // A new canvas URL (a locale switch, a rename) means new geometry — the
+    // previous page's rects are stale the instant the iframe starts loading
+    // a different route, so clear them alongside resetting geometry.
+    useEffect(() => { setGeometry("waiting"); setRects([]); setEmptyZones([]); }, [iframeSrc]);
+    const postToCanvas = useCallback((m) => {
+        iframeRef.current?.contentWindow?.postMessage(m, "*");
+    }, [iframeRef]);
+    useEffect(() => {
+        const onMessage = (e) => {
+            const m = e.data;
+            if (m?.source !== "smoodly")
+                return;
+            if (e.source !== iframeRef.current?.contentWindow)
+                return;
+            if (m.kind === "rects") {
+                setRects(m.nodes);
+                setEmptyZones(m.emptyZones);
+                setDocH(m.docH);
+                setGeometry("ok");
+            }
+            else if (m.kind === "select") {
+                handlers.current.onSelect(m.id);
+            }
+            else if (m.kind === "hover") {
+                handlers.current.onHover(m.id);
+            }
+        };
+        window.addEventListener("message", onMessage);
+        return () => window.removeEventListener("message", onMessage);
+    }, [iframeRef]);
+    useEffect(() => {
+        if (!iframeSrc || geometry !== "waiting")
+            return;
+        const t = setTimeout(() => setGeometry((g) => (g === "waiting" ? "missing" : g)), GEOMETRY_TIMEOUT_MS);
+        return () => clearTimeout(t);
+    }, [iframeSrc, geometry]);
+    return { rects, emptyZones, docH, geometry, postToCanvas };
+}

package/dist/admin/editor/usePageLocale.d.ts

@@ -0,0 +1,23 @@
+import type { PageRecord } from "../../store.ts";
+import type { AdminOps } from "../ops.ts";
+import type { AdminRegistry } from "../serialize.ts";
+export declare function usePageLocale({ registry, ops, id, record, setRecord, flush, fail, clearBanner, reload }: {
+    registry: AdminRegistry;
+    ops: AdminOps;
+    id: string;
+    record: PageRecord | null;
+    setRecord(record: PageRecord): void;
+    /** Flush the pending autosave; false when it could not land. */
+    flush(): Promise<boolean>;
+    /** Show an error banner. */
+    fail(text: string): void;
+    clearBanner(): void;
+    /** Reload the editor for the current locale. */
+    reload(): void;
+}): {
+    locale: string;
+    adding: boolean;
+    switchLocale: (next: string) => Promise<void>;
+    doAddLocale: (target: string) => Promise<void>;
+    doRemoveLocale: () => Promise<void>;
+};

package/dist/admin/editor/usePageLocale.js

@@ -0,0 +1,88 @@
+// The editor's locale lifecycle: which locale is being edited (from the
+// URL), switching, adding this page to a locale, removing it from one.
+// Every transition flushes the pending autosave first — a save landing
+// after the switch would persist THIS tree under the new locale.
+import { useState } from "react";
+import { sourceLocaleOf } from "../shell/pages-tree.js";
+import { localeFromUrl, writeLocaleToUrl } from "./locale-url.js";
+export function usePageLocale({ registry, ops, id, record, setRecord, flush, fail, clearBanner, reload }) {
+    const [locale, setLocale] = useState(() => localeFromUrl(registry));
+    const [adding, setAdding] = useState(false);
+    const switchLocale = async (next) => {
+        if (next === locale)
+            return;
+        const flushed = await flush();
+        if (!flushed) {
+            fail("Couldn't save your latest changes — switch cancelled.");
+            return;
+        }
+        writeLocaleToUrl(next);
+        clearBanner();
+        setLocale(next);
+    };
+    /** Add a locale, copying the tree on screen (or the record's source locale when this one is absent). */
+    const doAddLocale = async (target) => {
+        if (!record || adding)
+            return;
+        const from = record.locales[locale] ? locale : sourceLocaleOf(record, registry);
+        if (from === locale) {
+            const flushed = await flush();
+            if (!flushed) {
+                fail("Couldn't save your latest changes — add cancelled.");
+                return;
+            }
+        }
+        setAdding(true);
+        let result;
+        try {
+            result = await ops.pages.addLocale(id, target, { from });
+        }
+        catch {
+            result = { ok: false, code: "internal", message: "Couldn't reach the server." };
+        }
+        setAdding(false);
+        if (!result.ok) {
+            fail(result.message);
+            return;
+        }
+        // The record now HAS the locale; keep it, or the pane below would go
+        // on offering "doesn't exist yet" until the reload lands.
+        setRecord(result.data);
+        if (target === locale)
+            reload();
+        else
+            void switchLocale(target);
+    };
+    const doRemoveLocale = async () => {
+        if (!record)
+            return;
+        const remaining = Object.keys(record.locales).filter((l) => l !== locale);
+        if (remaining.length === 0)
+            return;
+        if (!window.confirm(`Remove this page from ${locale}? Its ${locale} content and history are deleted.`))
+            return;
+        // Let a pending save land before the row goes, so no save races the
+        // delete — and if it cannot land, stop: a retry mid-flight would
+        // recreate the very draft the removal is deleting.
+        const flushed = await flush();
+        if (!flushed) {
+            fail("Couldn't save your latest changes — removal cancelled.");
+            return;
+        }
+        let result;
+        try {
+            result = await ops.pages.removeLocale(id, locale);
+        }
+        catch {
+            result = { ok: false, code: "internal", message: "Couldn't reach the server." };
+        }
+        if (!result.ok) {
+            fail(result.message);
+            return;
+        }
+        const next = remaining.includes(registry.locales.default) ? registry.locales.default : remaining[0];
+        writeLocaleToUrl(next);
+        setLocale(next);
+    };
+    return { locale, adding, switchLocale, doAddLocale, doRemoveLocale };
+}

package/dist/admin/forms/FieldWidget.js

@@ -6,7 +6,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // Objects and lists recurse through this same component; the list's
 // logic lives in ./list.ts as pure functions.
 import { useState } from "react";
-import { plainToRichtext, richtextToPlain } from "../richtext.js";
+import { RichtextWidget } from "./RichtextWidget.js";
 import { Button, Field, IconButton } from "../ui/primitives.js";
 import { addItem, itemSummary, moveIndex, moveItem, patchObject, removeIndex, removeItem } from "./list.js";
 const label = (key) => key.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
@@ -41,7 +41,9 @@ export function FieldWidget({ descriptor: d, value, onChange, errors, path: path
             break;
         }
         case "richtext":
-            control = _jsx(RichtextArea, { value: value, onChange: onChange });
+            // The toolbar holds buttons, so this control can never sit in a <label>.
+            asDiv = true;
+            control = _jsx(RichtextWidget, { value: value, toolset: d.toolset, onChange: onChange });
             break;
         case "image":
         case "video":
@@ -110,23 +112,3 @@ export function FieldWidget({ descriptor: d, value, onChange, errors, path: path
 function ListRow({ index, count, summary, open, onToggle, onMove, onRemove, children }) {
     return (_jsxs("div", { className: "sm-listrow", children: [_jsxs("div", { className: "sm-listrow__head", children: [_jsxs("button", { type: "button", className: "sm-listrow__toggle", "aria-expanded": open, onClick: onToggle, children: [_jsx("span", { "aria-hidden": "true", children: open ? "▾" : "▸" }), _jsx("span", { className: "sm-listrow__summary", children: summary })] }), _jsx(IconButton, { label: "Move up", disabled: index === 0, onClick: () => onMove(index - 1), children: "\u2191" }), _jsx(IconButton, { label: "Move down", disabled: index === count - 1, onClick: () => onMove(index + 1), children: "\u2193" }), _jsx(IconButton, { label: "Remove", onClick: onRemove, children: "\u00D7" })] }), open && _jsx("div", { className: "sm-listrow__body", children: children })] }));
 }
-/** The interim richtext widget owns its text: the line syntax drops a trailing
- *  newline on the round trip, so deriving the value from the document each
- *  render would snap the caret back after Enter at the end of the text. Re-seeds
- *  when the document changes underneath it (load, locale switch). The parent must
- *  store the emitted document by reference — a clone or a server copy handed back
- *  would re-seed the text and bring the caret snap back. */
-function RichtextArea({ value, onChange }) {
-    const [text, setText] = useState(() => richtextToPlain(value));
-    const [seen, setSeen] = useState(value);
-    if (value !== seen) {
-        setSeen(value);
-        setText(richtextToPlain(value));
-    }
-    return (_jsx("textarea", { className: "sm-textarea", rows: 5, value: text, onChange: (e) => {
-            const doc = plainToRichtext(e.target.value);
-            setText(e.target.value);
-            setSeen(doc);
-            onChange(doc);
-        } }));
-}

package/dist/admin/forms/RichtextToolbar.d.ts

@@ -0,0 +1,20 @@
+import type { Allowed } from "../../toolset.ts";
+export type ToolbarCommand = "bold" | "italic" | "link" | "bulletList" | "orderedList" | "blockquote" | {
+    heading: number;
+};
+export type ActiveState = {
+    bold: boolean;
+    italic: boolean;
+    link: boolean;
+    bulletList: boolean;
+    orderedList: boolean;
+    blockquote: boolean;
+    /** The active heading level, or null in a paragraph. */
+    heading: number | null;
+};
+export declare const INACTIVE: ActiveState;
+export declare function RichtextToolbar({ allowed, active, onCommand }: {
+    allowed: Allowed;
+    active: ActiveState;
+    onCommand(command: ToolbarCommand): void;
+}): import("react").JSX.Element | null;

package/dist/admin/forms/RichtextToolbar.js

@@ -0,0 +1,37 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Bold, Heading1, Heading2, Heading3, Heading4, Heading5, Heading6, Italic, Link, List, ListOrdered, Quote } from "lucide-react";
+import { IconButton } from "../ui/primitives.js";
+export const INACTIVE = {
+    bold: false, italic: false, link: false, bulletList: false, orderedList: false, blockquote: false, heading: null,
+};
+const HEADING_ICONS = { 1: Heading1, 2: Heading2, 3: Heading3, 4: Heading4, 5: Heading5, 6: Heading6 };
+const ICON = 14;
+/** Keep the editor's selection: a toolbar press must not blur the content. */
+const keepFocus = (e) => e.preventDefault();
+export function RichtextToolbar({ allowed, active, onCommand }) {
+    const button = (label, pressed, command, Icon) => (_jsx(IconButton, { label: label, "aria-pressed": pressed, onMouseDown: keepFocus, onClick: () => onCommand(command), children: _jsx(Icon, { size: ICON, "aria-hidden": "true" }) }, label));
+    const groups = [];
+    const marks = [
+        allowed.marks.has("bold") && button("Bold", active.bold, "bold", Bold),
+        allowed.marks.has("italic") && button("Italic", active.italic, "italic", Italic),
+        allowed.marks.has("link") && button("Link", active.link, "link", Link),
+    ].filter(Boolean);
+    if (marks.length > 0)
+        groups.push(marks);
+    const headings = allowed.headingLevels
+        .filter((l) => l >= 1 && l <= 6)
+        .map((l) => button(`Heading ${l}`, active.heading === l, { heading: l }, HEADING_ICONS[l]));
+    if (headings.length > 0)
+        groups.push(headings);
+    const blocks = [
+        allowed.nodes.has("bulletList") && button("Bullet list", active.bulletList, "bulletList", List),
+        allowed.nodes.has("orderedList") && button("Numbered list", active.orderedList, "orderedList", ListOrdered),
+        allowed.nodes.has("blockquote") && button("Quote", active.blockquote, "blockquote", Quote),
+    ].filter(Boolean);
+    if (blocks.length > 0)
+        groups.push(blocks);
+    if (groups.length === 0)
+        return null;
+    return (_jsx("div", { className: "sm-richtext__bar", role: "toolbar", "aria-label": "Formatting", children: groups.map((group, i) => (_jsxs("span", { style: { display: "contents" }, children: [i > 0 && _jsx("span", { className: "sm-richtext__sep", "aria-hidden": "true" }), group] }, i))) }));
+}

package/dist/admin/forms/RichtextWidget.d.ts

@@ -0,0 +1,5 @@
+export declare function RichtextWidget({ value, toolset, onChange }: {
+    value: unknown;
+    toolset: unknown;
+    onChange(doc: unknown): void;
+}): import("react").JSX.Element;

package/dist/admin/forms/RichtextWidget.js

@@ -0,0 +1,123 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The richtext field widget (spec 2026-09-08 §3): a TipTap editor under a
+// fixed toolbar. The editor owns its document and emits TipTap JSON on
+// every change; the parent stores the emitted document by reference, so
+// a value that is not the last emitted document is a change from outside
+// (load, locale switch, a list row moving) and re-seeds the editor. The
+// schema is always full; `allowed` gates creation (extensions, paste,
+// toolbar). Only this file and richtext-extensions.ts import TipTap.
+import { useEffect, useMemo, useRef, useState } from "react";
+import { EditorContent, useEditor, useEditorState } from "@tiptap/react";
+import { Slice } from "@tiptap/pm/model";
+import { allowedOf } from "../../toolset.js";
+import { plainDoc } from "../richtext-doc.js";
+import { Button } from "../ui/primitives.js";
+import { richtextExtensions } from "./richtext-extensions.js";
+import { gatePastedSlice } from "./richtext-paste.js";
+import { INACTIVE, RichtextToolbar } from "./RichtextToolbar.js";
+const EMPTY = { type: "doc", content: [{ type: "paragraph" }] };
+const LEVELS = [1, 2, 3, 4, 5, 6];
+const isDoc = (v) => !!v && typeof v === "object" && v.type === "doc";
+export function RichtextWidget({ value, toolset, onChange }) {
+    const allowed = useMemo(() => allowedOf(toolset), [toolset]);
+    // The parent's onChange closes over its render; the editor's onUpdate is
+    // created once, so read the latest through a ref.
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    // The last document this widget emitted — anything else arriving as
+    // `value` came from outside and re-seeds the editor.
+    const emitted = useRef(value);
+    const [link, setLink] = useState({ open: false, href: "" });
+    const openLinkRef = useRef(() => { });
+    const editor = useEditor({
+        immediatelyRender: false,
+        extensions: richtextExtensions(allowed, { onLink: () => openLinkRef.current() }),
+        content: isDoc(value) ? value : EMPTY,
+        editorProps: {
+            attributes: { class: "sm-richtext__content" },
+            transformPasted: (slice, view) => Slice.fromJSON(view.state.schema, gatePastedSlice(slice.toJSON(), allowed)),
+        },
+        onUpdate: ({ editor }) => {
+            const doc = plainDoc(editor.getJSON());
+            emitted.current = doc;
+            onChangeRef.current(doc);
+        },
+    }, [allowed]);
+    useEffect(() => {
+        if (!editor || value === emitted.current)
+            return;
+        emitted.current = value;
+        editor.commands.setContent(isDoc(value) ? value : EMPTY, { emitUpdate: false });
+    }, [editor, value]);
+    const active = useEditorState({
+        editor,
+        selector: ({ editor }) => editor
+            ? {
+                bold: editor.isActive("bold"),
+                italic: editor.isActive("italic"),
+                link: editor.isActive("link"),
+                bulletList: editor.isActive("bulletList"),
+                orderedList: editor.isActive("orderedList"),
+                blockquote: editor.isActive("blockquote"),
+                heading: LEVELS.find((level) => editor.isActive("heading", { level })) ?? null,
+            }
+            : INACTIVE,
+    });
+    // Read the caret's link from the editor at open time, not from the last
+    // render: a selection change and the press can land in the same tick.
+    const openLink = () => setLink({ open: true, href: editor?.getAttributes("link").href ?? "" });
+    openLinkRef.current = openLink;
+    const closeLink = () => {
+        setLink({ open: false, href: "" });
+        editor?.commands.focus();
+    };
+    const applyLink = () => {
+        if (!editor)
+            return;
+        const href = link.href.trim();
+        const chain = editor.chain().focus().extendMarkRange("link");
+        if (href === "")
+            chain.unsetLink().run();
+        else
+            chain.setLink({ href }).run();
+        setLink({ open: false, href: "" });
+    };
+    const removeLink = () => {
+        editor?.chain().focus().extendMarkRange("link").unsetLink().run();
+        setLink({ open: false, href: "" });
+    };
+    const run = (command) => {
+        if (!editor)
+            return;
+        if (command === "link") {
+            openLink();
+            return;
+        }
+        const chain = editor.chain().focus();
+        if (typeof command === "object")
+            chain.toggleHeading({ level: command.heading }).run();
+        else if (command === "bold")
+            chain.toggleBold().run();
+        else if (command === "italic")
+            chain.toggleItalic().run();
+        else if (command === "bulletList")
+            chain.toggleBulletList().run();
+        else if (command === "orderedList")
+            chain.toggleOrderedList().run();
+        else if (command === "blockquote")
+            chain.toggleBlockquote().run();
+    };
+    return (_jsxs("div", { className: "sm-richtext", children: [_jsx(RichtextToolbar, { allowed: allowed, active: active ?? INACTIVE, onCommand: run }), link.open && (_jsxs("div", { className: "sm-richtext__link", children: [_jsx("input", { className: "sm-input", placeholder: "https://\u2026 or /path", value: link.href, autoFocus: true, "aria-label": "Link URL", onChange: (e) => setLink({ open: true, href: e.target.value }), onKeyDown: (e) => {
+                            // Escape must not reach the editor's window handler, which clears the block selection.
+                            if (e.key === "Enter") {
+                                e.preventDefault();
+                                applyLink();
+                            }
+                            if (e.key === "Escape") {
+                                e.preventDefault();
+                                e.stopPropagation();
+                                closeLink();
+                            }
+                        } }), _jsx(Button, { onClick: applyLink, children: "Apply" }), _jsx(Button, { variant: "secondary", onClick: removeLink, children: "Remove" })] })), _jsx(EditorContent, { editor: editor })] }));
+}

package/dist/admin/forms/richtext-extensions.d.ts

@@ -0,0 +1,5 @@
+import { type AnyExtension } from "@tiptap/core";
+import type { Allowed } from "../../toolset.ts";
+export declare function richtextExtensions(allowed: Allowed, hooks: {
+    onLink(): void;
+}): AnyExtension[];

package/dist/admin/forms/richtext-extensions.js

@@ -0,0 +1,74 @@
+// The editor's extension set (spec 2026-09-08 §2): always the FULL schema
+// of what `RichText` draws, so content a toolset forbids survives the
+// round trip; the toolset gates only creation — input rules, paste rules
+// and keyboard shortcuts here, the toolbar in RichtextToolbar, paste in
+// richtext-paste. StarterKit supplies document, paragraph, text, hard
+// break, list item, list keymap and undo/redo; every gated node or mark
+// is switched off there and added back extended.
+import { Extension, textblockTypeInputRule } from "@tiptap/core";
+import StarterKit from "@tiptap/starter-kit";
+import Heading from "@tiptap/extension-heading";
+import Bold from "@tiptap/extension-bold";
+import Italic from "@tiptap/extension-italic";
+import Link from "@tiptap/extension-link";
+import Blockquote from "@tiptap/extension-blockquote";
+import { BulletList, OrderedList } from "@tiptap/extension-list";
+/** Keep the mark in the schema; add no way to create it when `on` is false. */
+function gateMarkConfig(on) {
+    return {
+        addInputRules() { return on ? this.parent?.() ?? [] : []; },
+        addPasteRules() { return on ? this.parent?.() ?? [] : []; },
+        addKeyboardShortcuts() { return on ? this.parent?.() ?? {} : {}; },
+    };
+}
+function gateNodeConfig(on) {
+    return {
+        addInputRules() { return on ? this.parent?.() ?? [] : []; },
+        addPasteRules() { return on ? this.parent?.() ?? [] : []; },
+        addKeyboardShortcuts() { return on ? this.parent?.() ?? {} : {}; },
+    };
+}
+const ALL_LEVELS = [1, 2, 3, 4, 5, 6];
+export function richtextExtensions(allowed, hooks) {
+    const link = allowed.marks.has("link");
+    const levels = allowed.headingLevels;
+    return [
+        StarterKit.configure({
+            heading: false, bold: false, italic: false, link: false, blockquote: false,
+            bulletList: false, orderedList: false,
+            code: false, codeBlock: false, strike: false, underline: false, horizontalRule: false,
+            dropcursor: false, gapcursor: false, trailingNode: false,
+        }),
+        Heading.extend({
+            // Exact `#` counts, and only the allowed levels; `# ` does nothing when h1 is forbidden.
+            addInputRules() {
+                return levels.map((level) => textblockTypeInputRule({ find: new RegExp(`^(#{${level}})\\s$`), type: this.type, getAttributes: { level } }));
+            },
+            addKeyboardShortcuts() {
+                return Object.fromEntries(levels.map((level) => [`Mod-Alt-${level}`, () => this.editor.commands.toggleHeading({ level })]));
+            },
+        }).configure({ levels: ALL_LEVELS }),
+        Bold.extend(gateMarkConfig(allowed.marks.has("bold"))),
+        Italic.extend(gateMarkConfig(allowed.marks.has("italic"))),
+        Link.extend({
+            ...gateMarkConfig(link),
+            // href only (spec §3): no target, rel or class in the stored JSON.
+            addAttributes() { return { href: { default: null } }; },
+        }).configure({
+            openOnClick: false,
+            autolink: link,
+            linkOnPaste: link,
+            // Site-relative targets are links too; the site renderer's scheme filter is the safety net.
+            isAllowedUri: (url, ctx) => /^[/#?.]/.test(url) || ctx.defaultValidate(url),
+        }),
+        Blockquote.extend(gateNodeConfig(allowed.nodes.has("blockquote"))),
+        BulletList.extend(gateNodeConfig(allowed.nodes.has("bulletList"))),
+        OrderedList.extend(gateNodeConfig(allowed.nodes.has("orderedList"))),
+        Extension.create({
+            name: "smoodlyLinkShortcut",
+            addKeyboardShortcuts() {
+                return link ? { "Mod-k": () => { hooks.onLink(); return true; } } : {};
+            },
+        }),
+    ];
+}

package/dist/admin/forms/richtext-paste.d.ts

@@ -0,0 +1,22 @@
+import type { Allowed } from "../../toolset.ts";
+export type PmJSON = {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: PmJSON[];
+    text?: string;
+    marks?: {
+        type: string;
+        attrs?: Record<string, unknown>;
+    }[];
+};
+/** ProseMirror's Slice.toJSON() shape. */
+export type SliceJSON = {
+    content?: PmJSON[] | null;
+    openStart?: number;
+    openEnd?: number;
+};
+/** The allowed level closest to `level`; the smaller number on a tie;
+ *  null when no heading is allowed. */
+export declare function clampLevel(level: number, levels: number[]): number | null;
+export declare function gateNodes(nodes: PmJSON[], allowed: Allowed): PmJSON[];
+export declare function gatePastedSlice(slice: SliceJSON, allowed: Allowed): SliceJSON;

package/dist/admin/forms/richtext-paste.js

@@ -0,0 +1,59 @@
+/** The allowed level closest to `level`; the smaller number on a tie;
+ *  null when no heading is allowed. */
+export function clampLevel(level, levels) {
+    if (levels.length === 0)
+        return null;
+    let best = levels[0];
+    for (const l of levels) {
+        const d = Math.abs(l - level);
+        const bd = Math.abs(best - level);
+        if (d < bd || (d === bd && l < best))
+            best = l;
+    }
+    return best;
+}
+export function gateNodes(nodes, allowed) {
+    return nodes.flatMap((n) => gateNode(n, allowed));
+}
+function gateNode(n, allowed) {
+    if (n.type === "text") {
+        const marks = (n.marks ?? []).filter((m) => allowed.marks.has(m.type));
+        const { marks: _drop, ...rest } = n;
+        return [marks.length > 0 ? { ...rest, marks } : rest];
+    }
+    const content = n.content ? gateNodes(n.content, allowed) : undefined;
+    const withContent = (node) => (content ? { ...node, content } : node);
+    if (n.type === "heading") {
+        const level = clampLevel(Number(n.attrs?.level ?? 1), allowed.headingLevels);
+        if (level === null)
+            return [withContent({ type: "paragraph" })];
+        return [withContent({ ...n, attrs: { ...n.attrs, level } })];
+    }
+    if (n.type === "blockquote" && !allowed.nodes.has("blockquote"))
+        return content ?? [];
+    if ((n.type === "bulletList" && !allowed.nodes.has("bulletList")) || (n.type === "orderedList" && !allowed.nodes.has("orderedList"))) {
+        return (content ?? []).flatMap((item) => item.content ?? []);
+    }
+    return [withContent(n)];
+}
+/** Depth of the first (or last) child chain, counting every non-text node. */
+function edgeDepth(nodes, side) {
+    let depth = 0;
+    let list = nodes;
+    while (list.length > 0) {
+        const n = side === "first" ? list[0] : list[list.length - 1];
+        if (n.type === "text")
+            break;
+        depth++;
+        list = n.content ?? [];
+    }
+    return depth;
+}
+export function gatePastedSlice(slice, allowed) {
+    const content = gateNodes(slice.content ?? [], allowed);
+    return {
+        content,
+        openStart: Math.min(slice.openStart ?? 0, edgeDepth(content, "first")),
+        openEnd: Math.min(slice.openEnd ?? 0, edgeDepth(content, "last")),
+    };
+}

package/dist/admin/index.d.ts

@@ -9,4 +9,3 @@ export { serializeAdminConfig } from "./serialize.ts";
 export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminShared, AdminField } from "./serialize.ts";
 export * from "./tree-ops.ts";
 export { validateFields, type FieldError } from "./validate.ts";
-export { plainToRichtext, richtextToPlain } from "./richtext.ts";

package/dist/admin/index.js

@@ -7,4 +7,3 @@ export { supabaseAdminAuth } from "./supabase-auth.js";
 export { serializeAdminConfig } from "./serialize.js";
 export * from "./tree-ops.js";
 export { validateFields } from "./validate.js";
-export { plainToRichtext, richtextToPlain } from "./richtext.js";

package/dist/admin/next/create-admin.d.ts

@@ -1,4 +1,4 @@
-import type { ReactElement, ReactNode } from "react";
+import type { ReactNode } from "react";
 import type { ResolvedConfig } from "../../config.ts";
 import type { AdminOpAction } from "../ops.ts";
 import type { AuthConfig } from "../shell/session.ts";
@@ -7,12 +7,8 @@ export declare function createSmoodlyAdmin(input: {
     op: AdminOpAction;
     auth: () => AuthConfig;
 }): {
-    AdminPage: ({ params }: {
-        params: Promise<{
-            segments?: string[];
-        }>;
-    }) => Promise<ReactElement>;
+    AdminPage: () => null;
     AdminLayout: ({ children }: {
         children: ReactNode;
-    }) => ReactElement;
+    }) => import("react").JSX.Element;
 };

package/dist/admin/next/create-admin.js

@@ -4,16 +4,25 @@ import { AdminApp } from "../shell/AdminApp.js";
 import { AdminStyles } from "../ui/theme.js";
 export function createSmoodlyAdmin(input) {
     const registry = serializeAdminConfig(input.config);
-    async function AdminPage({ params }) {
-        const { segments = [] } = await params;
-        return _jsx(AdminApp, { registry: registry, segments: segments, op: input.op, auth: input.auth() });
+    /** The catch-all page only makes every /admin URL exist. The shell is
+     *  mounted by the layout, not here: a server action that revalidates
+     *  (publish, delete, a save of published content) answers with a
+     *  re-rendered tree for the URL it was posted to, and Next remounts a
+     *  page whose dynamic segment changed since the document load, while a
+     *  layout persists (spec 2026-09-08 client routing, §1 amendment). */
+    function AdminPage() {
+        return null;
     }
     /** The admin owns the viewport: the whole UI is a fixed three-column
      *  shell that scrolls internally, never the host document. The design
      *  system's tokens ride along in one <style> — the host app imports
-     *  nothing (see ui/theme.tsx). */
+     *  nothing (see ui/theme.tsx). The shell reads its route from the URL
+     *  on mount (shell/router.ts); `children` is the page's nothing.
+     *  suppressHydrationWarning: the theme boot script sets `data-theme`
+     *  on this element before React hydrates, on purpose (no white flash
+     *  for a dark-mode editor), so the attribute differs from the server's. */
     function AdminLayout({ children }) {
-        return (_jsxs("div", { className: "sm-admin", children: [_jsx(AdminStyles, {}), children] }));
+        return (_jsxs("div", { className: "sm-admin", suppressHydrationWarning: true, children: [_jsx(AdminStyles, {}), _jsx(AdminApp, { registry: registry, op: input.op, auth: input.auth() }), children] }));
     }
     return { AdminPage, AdminLayout };
 }