smoodly 0.0.52 → 0.0.54

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

@@ -1,5 +1,5 @@
 import type { TreeNode } from "../../render.tsx";
-type ZoneRows = {
+export type ZoneRows = {
     zone: string;
     locked: boolean;
     canTake: boolean;
@@ -13,7 +13,7 @@ type ZoneRows = {
     /** A zone rule the stored nodes break — "Zone `main` allows 3 sections and has 5." */
     note?: string;
 };
-type Handlers = {
+export type Handlers = {
     selectedId: string | null;
     onSelect(id: string): void;
     /** The empty row of an insertable zone was clicked. */
@@ -27,4 +27,3 @@ type Handlers = {
 export declare function Outline({ zones, ...handlers }: {
     zones: ZoneRows[];
 } & Handlers): import("react").JSX.Element;
-export {};

package/dist/admin/editor/PageInspector.js

@@ -22,5 +22,5 @@ export function PageInspector({ record, locale, registry, tree, path, fixed, red
     useEffect(() => { setTab(pageTabsFor(template)[0]); }, [record.id]); // eslint-disable-line react-hooks/exhaustive-deps
     const active = tabs.includes(tab) ? tab : tabs[0];
     const title = record.locales[locale]?.title ?? "";
-    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "sm-inspector__head", children: _jsxs("span", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [_jsx("span", { className: "sm-pageglyph" }), _jsx("span", { className: "sm-title", style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: title })] }) }), tabs.length > 1 && _jsx(Tabs, { tabs: tabs, value: active, onChange: setTab }), _jsx("div", { className: "sm-inspector__body", children: active === "SEO & Social" ? (_jsx(SeoSettings, { meta: tree?.meta ?? {}, onPatch: (key, value) => onPatch("meta", key, value) })) : (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 14 }, children: [_jsx(PageSettings, { record: record, locale: locale, registry: registry, path: path, fixed: fixed, redirects: redirects, onRename: onRename }), Object.entries(template?.fields ?? {}).map(([key, descriptor]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: descriptor, value: tree?.fields?.[key], errors: misfitErrors(drift, "page.fields"), onChange: (value) => onPatch("fields", key, value) }, key))), onClearPageField && _jsx(OrphanFields, { orphans: drift, strip: "page.fields", onClear: onClearPageField }), onRemoveLocale && _jsxs(Button, { variant: "secondary", onClick: onRemoveLocale, children: ["Remove from ", locale] })] })) })] }));
+    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "sm-inspector__head", children: _jsxs("span", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [_jsx("span", { className: "sm-pageglyph" }), _jsx("span", { className: "sm-title", style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: title })] }) }), tabs.length > 1 && _jsx(Tabs, { tabs: tabs, value: active, onChange: setTab }), _jsx("div", { className: "sm-inspector__body", children: active === "SEO & Social" ? (_jsx("div", { "data-smd-undo": "", style: { display: "contents" }, children: _jsx(SeoSettings, { meta: tree?.meta ?? {}, onPatch: (key, value) => onPatch("meta", key, value) }) })) : (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 14 }, children: [_jsx(PageSettings, { record: record, locale: locale, registry: registry, path: path, fixed: fixed, redirects: redirects, onRename: onRename }), _jsx("div", { "data-smd-undo": "", style: { display: "contents" }, children: Object.entries(template?.fields ?? {}).map(([key, descriptor]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: descriptor, value: tree?.fields?.[key], errors: misfitErrors(drift, "page.fields"), onChange: (value) => onPatch("fields", key, value) }, key))) }), onClearPageField && _jsx(OrphanFields, { orphans: drift, strip: "page.fields", onClear: onClearPageField }), onRemoveLocale && _jsxs(Button, { variant: "secondary", onClick: onRemoveLocale, children: ["Remove from ", locale] })] })) })] }));
 }

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

@@ -0,0 +1,31 @@
+import { type ReactElement } from "react";
+import type { TreeNode } from "../../page-context.ts";
+import { type ActionMenuItem } from "../ui/ActionMenu.tsx";
+import type { CardPreview } from "./card-preview.ts";
+import type { Handlers, ZoneRows } from "./Outline.tsx";
+/** A card: the outline's row plus the section's icon from the registry (`icon ?? "▤"`), its preview, and whether it is a placed global item. */
+export type StructureNode = ZoneRows["nodes"][number] & {
+    icon: string;
+    preview: CardPreview;
+    global: boolean;
+};
+export type StructureZone = Omit<ZoneRows, "nodes"> & {
+    nodes: StructureNode[];
+};
+export type StructureViewProps = {
+    zones: StructureZone[];
+} & Omit<Handlers, "onAddFirst"> & {
+    /** "+ Add section" at a boundary, or the empty zone's first slot: opens the picker there. */
+    onAdd(zone: string, index: number, clientX: number, clientY: number): void;
+    /** The card's ⋯ entries beyond Remove; plan (c) adds Copy and the Paste entries here. */
+    cardActions?(node: TreeNode, zone: string, index: number): ActionMenuItem[];
+    /** The zone heading's ⋯ entries; plan (c) adds Paste. Absent or empty: no ⋯ on the heading. */
+    zoneActions?(zone: string): ActionMenuItem[];
+};
+/** The card's menu: the given entries, then Remove (danger; disabled in a locked zone). */
+export declare function cardMenu({ locked, onRemove, actions }: {
+    locked: boolean;
+    onRemove(): void;
+    actions: ActionMenuItem[];
+}): ActionMenuItem[];
+export declare function StructureView({ zones, ...rest }: StructureViewProps): ReactElement;

package/dist/admin/editor/StructureView.js

@@ -0,0 +1,58 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The structure view (spec 2026-10-19 editor at launch §1): the canvas
+// column's second renderer of the same tree — every zone a heading row
+// and its sections as cards (grip, icon, title, a line of preview, a
+// thumbnail, the ⋯ menu), dragged within the zone by the outline's
+// `useSortable`. Every gesture lands on the editor's existing handlers;
+// nothing here touches the tree. A card is a `div[role=button]`, not a
+// <button>: it holds the grip and the menu, and a button inside a button
+// is invalid HTML. The outline's marks carry over: broken red, orphan
+// muted, a removed zone as one row with Clear zone.
+import { useEffect, useState } from "react";
+import { ActionMenu } from "../ui/ActionMenu.js";
+import { Button, Grip, SectionLabel, cx } from "../ui/primitives.js";
+import { useSortable } from "../ui/useSortable.js";
+import { AssetThumb } from "../forms/MediaGrid.js";
+import { useAssets } from "../forms/assets-context.js";
+/** The card's menu: the given entries, then Remove (danger; disabled in a locked zone). */
+export function cardMenu({ locked, onRemove, actions }) {
+    return [...actions, { label: "Remove", run: onRemove, danger: true, disabled: locked }];
+}
+export function StructureView({ zones, ...rest }) {
+    return (_jsx("div", { className: "sm-structure", "data-testid": "structure", children: zones.map((z) => _jsx(StructureZoneView, { ...z, ...rest }, z.zone)) }));
+}
+const stop = (e) => e.stopPropagation();
+/** The ⋯'s Enter and Space must not select the card; every other key (the editor's Cmd+Z) bubbles on. */
+const stopActivation = (e) => { if (e.key === "Enter" || e.key === " ")
+    e.stopPropagation(); };
+function StructureZoneView({ zone, locked, canTake, nodes, removed, note, selectedId, onSelect, onMoveTo, onRemove, onClearZone, onAdd, cardActions, zoneActions, }) {
+    const sortable = useSortable({
+        count: locked || removed ? 0 : nodes.length,
+        onDrop: (from, to) => onMoveTo(nodes[from].node.id, to),
+    });
+    if (removed) {
+        return (_jsx("div", { className: "sm-structure__group", "data-testid": "removed-zone", children: _jsxs("div", { className: "sm-outline-row sm-outline-row--orphan sm-outline-row--removed", children: [_jsxs("span", { className: "sm-outline-row__label", children: ["Removed zone `", zone, "` \u00B7 ", nodes.length, " ", nodes.length === 1 ? "section" : "sections"] }), _jsx(Button, { variant: "danger", size: "sm", onClick: () => onClearZone?.(zone), children: "Clear zone" })] }) }));
+    }
+    const actions = zoneActions?.(zone) ?? [];
+    const add = (index) => (_jsx("span", { className: "sm-structure__slot", children: _jsxs("button", { type: "button", className: "sm-structure__add", "aria-label": `Add to ${zone}`, title: `Add to ${zone}`, onClick: (e) => { e.stopPropagation(); onAdd(zone, index, e.clientX, e.clientY); }, children: [_jsx("span", { className: "sm-structure__add-icon", "aria-hidden": "true", children: "+" }), "Add section"] }) }));
+    return (_jsxs("div", { className: "sm-structure__group", children: [_jsxs("div", { className: "sm-structure__zone", children: [_jsxs(SectionLabel, { caps: true, children: [zone, locked && " · locked"] }), actions.length > 0 && _jsx(ActionMenu, { small: true, label: "Zone actions", items: actions })] }), note && _jsx("p", { className: "sm-outline-note", children: note }), nodes.length === 0 && (_jsxs("div", { className: "sm-structure__empty", children: [_jsx("span", { children: "Empty" }), canTake && add(0)] })), nodes.length > 0 && canTake && add(0), nodes.length > 0 && (_jsx("div", { ref: sortable.containerRef, className: "sm-structure__rows", children: nodes.map(({ node, label, mark, icon, preview, global }, i) => (_jsxs("div", { className: cx("sm-structure__row", sortable.rowClass(i)), style: sortable.rowStyle(i), children: [_jsxs("div", { role: "button", tabIndex: 0, "data-testid": "structure-card", "data-node": node.id, className: cx("sm-structure__card", node.id === selectedId && "sm-structure__card--selected", locked && "sm-structure__card--locked", mark && `sm-structure__card--${mark}`), onClick: () => onSelect(node.id), onKeyDown: (e) => { if (e.key === "Enter" || e.key === " ") {
+                                e.preventDefault();
+                                onSelect(node.id);
+                            } }, children: [locked ? _jsx("span", { className: "sm-structure__gripslot", "aria-hidden": "true" }) : _jsx(Grip, { ...sortable.handleProps(i) }), _jsx("span", { className: "sm-structure__icon", "aria-hidden": "true", children: icon }), _jsxs("span", { className: "sm-structure__text", children: [_jsxs("span", { className: "sm-structure__title", children: [label, global && _jsx("span", { className: "sm-structure__badge", children: "global" })] }), global
+                                            ? _jsx("span", { className: "sm-structure__preview", children: "Global \u00B7 edited in one place" })
+                                            : preview.text !== null && _jsx("span", { className: "sm-structure__preview", children: preview.text })] }), !global && preview.image && _jsx(Thumb, { image: preview.image }), _jsx("span", { className: "sm-structure__menu", onClick: stop, onKeyDown: stopActivation, children: _jsx(ActionMenu, { small: true, label: "Section actions", items: cardMenu({ locked, onRemove: () => onRemove(node.id), actions: cardActions?.(node, zone, i) ?? [] }) }) })] }), canTake && add(i + 1)] }, node.id))) }))] }));
+}
+/** The thumbnail: the asset record fetched through the assets context (cached per shell lifetime), the box drawn at once. */
+function Thumb({ image }) {
+    const assets = useAssets();
+    const [asset, setAsset] = useState(null);
+    useEffect(() => {
+        let live = true;
+        setAsset(null);
+        assets.get(image.asset).then((r) => { if (live)
+            setAsset(r); });
+        return () => { live = false; };
+    }, [assets, image.asset]);
+    return (_jsx("span", { className: "sm-structure__thumb", children: asset && asset.status !== "pending" && _jsx(AssetThumb, { asset: asset, className: "sm-structure__img" }) }));
+}

package/dist/admin/editor/card-preview.d.ts

@@ -0,0 +1,10 @@
+import type { TreeNode } from "../../page-context.ts";
+import type { ImageValue } from "../../media.ts";
+import type { AdminSection } from "../serialize.ts";
+export type CardPreview = {
+    text: string | null;
+    image: ImageValue | null;
+};
+/** Every text node's text joined by spaces, whitespace collapsed, cut at `max` with an ellipsis. */
+export declare function richtextPlainText(doc: unknown, max?: number): string;
+export declare function cardPreview(node: TreeNode, section: Pick<AdminSection, "fields"> | null): CardPreview;

package/dist/admin/editor/card-preview.js

@@ -0,0 +1,50 @@
+import { fieldLabel } from "../field-label.js";
+import { hasText } from "../richtext-doc.js";
+/** Every text node's text joined by spaces, whitespace collapsed, cut at `max` with an ellipsis. */
+export function richtextPlainText(doc, max = 120) {
+    const parts = [];
+    const walk = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        const o = n;
+        if (typeof o.text === "string")
+            parts.push(o.text);
+        if (Array.isArray(o.content))
+            o.content.forEach(walk);
+    };
+    walk(doc);
+    const text = parts.join(" ").replace(/\s+/g, " ").trim();
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+const isSetImage = (v) => !!v && typeof v === "object" && typeof v.asset === "string" && v.asset !== "";
+export function cardPreview(node, section) {
+    if (!section)
+        return { text: null, image: null };
+    const values = node.fields ?? {};
+    let text = null;
+    let richtext = null;
+    let list = null;
+    let image = null;
+    for (const [key, descriptor] of Object.entries(section.fields)) {
+        const v = values[key];
+        switch (descriptor.type) {
+            case "text":
+                if (text === null && typeof v === "string" && v.trim() !== "")
+                    text = v.trim();
+                break;
+            case "richtext":
+                if (richtext === null && hasText(v))
+                    richtext = richtextPlainText(v);
+                break;
+            case "list":
+                if (list === null && Array.isArray(v) && v.length > 0)
+                    list = `${v.length} · ${fieldLabel(key)}`;
+                break;
+            case "image":
+                if (image === null && isSetImage(v))
+                    image = v;
+                break;
+        }
+    }
+    return { text: text ?? richtext ?? list, image };
+}

package/dist/admin/editor/global-edit.js

@@ -7,7 +7,8 @@ export function createGlobalEdit(opts) {
     let loadError = null;
     let stale = null;
     let generation = 0;
-    const loading = new Set();
+    /** In-flight loads by `name/locale`: a repeat while one runs awaits it (an undone global step patches a loaded item). */
+    const loading = new Map();
     const rev = new Map();
     const savedRev = new Map();
     const listeners = new Set();
@@ -59,30 +60,36 @@ export function createGlobalEdit(opts) {
             listeners.add(listener);
             return () => { listeners.delete(listener); };
         },
-        async load(name, locale) {
+        load(name, locale) {
             const key = `${name}/${locale}`;
-            if (items[name]?.locale === locale || loading.has(key))
-                return;
-            loading.add(key);
+            if (items[name]?.locale === locale)
+                return Promise.resolve();
+            const pending = loading.get(key);
+            if (pending)
+                return pending;
             const gen = generation;
-            let r;
-            try {
-                r = await opts.ops.globals.get(name, locale);
-            }
-            catch {
-                r = { ok: false, code: "internal", message: "Couldn't reach the server." };
-            }
-            loading.delete(key);
-            if (gen !== generation)
-                return; // reset() ran meanwhile — this canvas is gone
-            if (!r.ok) {
-                loadError = r.message;
+            const run = (async () => {
+                let r;
+                try {
+                    r = await opts.ops.globals.get(name, locale);
+                }
+                catch {
+                    r = { ok: false, code: "internal", message: "Couldn't reach the server." };
+                }
+                loading.delete(key);
+                if (gen !== generation)
+                    return; // reset() ran meanwhile — this canvas is gone
+                if (!r.ok) {
+                    loadError = r.message;
+                    emit();
+                    return;
+                }
+                items = { ...items, [name]: { name, locale, record: r.data.record, fields: r.data.fields, usage: r.data.usage, errors: {} } };
+                loadError = null;
                 emit();
-                return;
-            }
-            items = { ...items, [name]: { name, locale, record: r.data.record, fields: r.data.fields, usage: r.data.usage, errors: {} } };
-            loadError = null;
-            emit();
+            })();
+            loading.set(key, run);
+            return run;
         },
         patch(name, path, value) {
             const item = items[name];

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

@@ -0,0 +1,39 @@
+import type { PageTree } from "../../page-context.ts";
+export type TreeStep = {
+    kind: "tree";
+    before: PageTree;
+    after: PageTree;
+    key?: string;
+    at: number;
+    focus?: string;
+};
+export type GlobalStep = {
+    kind: "global";
+    name: string;
+    path: string;
+    before: unknown;
+    after: unknown;
+    key: string;
+    at: number;
+    focus?: string;
+};
+export type Step = TreeStep | GlobalStep;
+export type History = {
+    /** Pushes a step (or merges it into the last one of the same key) and drops the redo stack. */
+    record(step: Step): void;
+    /** The step to reverse, moved onto redo; null when there is none. */
+    undo(): Step | null;
+    redo(): Step | null;
+    /** Keeps `key` merging whatever the timing until every release returned for it was called. */
+    group(key: string): () => void;
+    clear(): void;
+    /** Drops the matching steps from both stacks (a global item's Discard). */
+    forget(match: (step: Step) => boolean): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    subscribe(fn: () => void): () => void;
+};
+export declare function createHistory({ coalesceMs, max }?: {
+    coalesceMs?: number;
+    max?: number;
+}): History;

package/dist/admin/editor/history.js

@@ -0,0 +1,64 @@
+export function createHistory({ coalesceMs = 1000, max = 100 } = {}) {
+    let undo = [];
+    let redo = [];
+    const groups = new Map();
+    /** Keys whose next step must start fresh: a group just opened (a new inline session never merges into the last one's step). */
+    const fresh = new Set();
+    const listeners = new Set();
+    const notify = () => { for (const fn of listeners)
+        fn(); };
+    const merges = (last, step) => !!last && step.key !== undefined && last.key === step.key &&
+        (step.at - last.at <= coalesceMs || (groups.get(step.key) ?? 0) > 0);
+    return {
+        record(step) {
+            redo = [];
+            const last = undo[undo.length - 1];
+            const boundary = step.key !== undefined && fresh.delete(step.key);
+            if (!boundary && merges(last, step)) {
+                undo[undo.length - 1] = { ...last, after: step.after, at: step.at, focus: step.focus ?? last.focus };
+            }
+            else {
+                undo.push(step);
+                if (undo.length > max)
+                    undo = undo.slice(undo.length - max);
+            }
+            notify();
+        },
+        undo() {
+            const step = undo.pop() ?? null;
+            if (step) {
+                redo.push(step);
+                notify();
+            }
+            return step;
+        },
+        redo() {
+            const step = redo.pop() ?? null;
+            if (step) {
+                undo.push(step);
+                notify();
+            }
+            return step;
+        },
+        group(key) {
+            groups.set(key, (groups.get(key) ?? 0) + 1);
+            fresh.add(key);
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                const n = (groups.get(key) ?? 1) - 1;
+                if (n <= 0)
+                    groups.delete(key);
+                else
+                    groups.set(key, n);
+            };
+        },
+        clear() { undo = []; redo = []; notify(); },
+        forget(match) { undo = undo.filter((s) => !match(s)); redo = redo.filter((s) => !match(s)); notify(); },
+        canUndo: () => undo.length > 0,
+        canRedo: () => redo.length > 0,
+        subscribe(fn) { listeners.add(fn); return () => { listeners.delete(fn); }; },
+    };
+}

package/dist/admin/editor/section-clipboard.d.ts

@@ -0,0 +1,40 @@
+import type { TreeNode } from "../../page-context.ts";
+import type { ZonePolicy } from "../../zones.ts";
+import type { AdminRegistry } from "../serialize.ts";
+export declare const CLIPBOARD_KEY = "smoodly-clipboard";
+export type Clip = {
+    v: 1;
+    space: string;
+    title: string;
+    node: Omit<TreeNode, "id">;
+    copiedAt: number;
+};
+export type ClipStorage = {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+};
+export type PasteCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The space this admin serves, from the entry's payload (admin/browser/main.tsx). */
+export declare function setClipboardSpace(s: string): void;
+export declare function clipboardSpace(): string;
+/** The clip of a node: its deep clone without the id, titled as the outline labels it. A placement copies as its placement. */
+export declare function clipOf(node: TreeNode, title: string, forSpace: string, now?: number): Clip;
+/** False when the storage throws (private mode, blocked site data). */
+export declare function writeClip(storage: ClipStorage, clip: Clip): boolean;
+/** The clip for this space, or null: another space, another version, bad JSON and a throwing storage all read as empty. */
+export declare function readClip(storage: ClipStorage, forSpace: string): Clip | null;
+/** A fresh node from the clip: a new id, a fresh deep clone (a clip pasted twice never shares a list). A placement takes the
+ *  item's current row id when `globalIds` knows it: the copied one may be dead after a reseed of the space. */
+export declare function pastedNode(clip: Clip, globalIds?: Record<string, string>): TreeNode;
+/** Whether the target zone takes the clip, with the reason when not — the picker's own rules (spec §3). */
+export declare function canPaste(clip: Clip, policy: ZonePolicy | undefined, count: number, registry: Pick<AdminRegistry, "sections" | "globals" | "custom">, globalIds: Record<string, string>): PasteCheck;
+/** The `storage` event for the key (another tab wrote the clip, or the storage was cleared); the release removes the listener. */
+export declare function subscribeClip(win: {
+    addEventListener: Window["addEventListener"];
+    removeEventListener: Window["removeEventListener"];
+}, fn: () => void): () => void;

package/dist/admin/editor/section-clipboard.js

@@ -0,0 +1,106 @@
+import { GLOBAL_NODE_TYPE } from "../../global.js";
+import { CUSTOM_NODE_TYPE } from "../../custom/index.js";
+import { allowedGlobals, canInsert, newNodeId } from "../tree-ops.js";
+import { allowsCustom } from "../custom-section.js";
+export const CLIPBOARD_KEY = "smoodly-clipboard";
+let space = "";
+/** The space this admin serves, from the entry's payload (admin/browser/main.tsx). */
+export function setClipboardSpace(s) { space = s; }
+export function clipboardSpace() { return space; }
+/** Deep copies as Duplicate does: a shared list (a custom section's rows) would edit both pages. */
+const cloneNode = (node) => {
+    const out = { type: node.type, fields: structuredClone(node.fields) };
+    if (node.settings)
+        out.settings = structuredClone(node.settings);
+    if (node.styles)
+        out.styles = structuredClone(node.styles);
+    if (node.css !== undefined)
+        out.css = node.css;
+    return out;
+};
+/** The clip of a node: its deep clone without the id, titled as the outline labels it. A placement copies as its placement. */
+export function clipOf(node, title, forSpace, now = Date.now()) {
+    return { v: 1, space: forSpace, title, node: cloneNode(node), copiedAt: now };
+}
+/** False when the storage throws (private mode, blocked site data). */
+export function writeClip(storage, clip) {
+    try {
+        storage.setItem(CLIPBOARD_KEY, JSON.stringify(clip));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The clip for this space, or null: another space, another version, bad JSON and a throwing storage all read as empty. */
+export function readClip(storage, forSpace) {
+    let raw;
+    try {
+        raw = storage.getItem(CLIPBOARD_KEY);
+    }
+    catch {
+        return null;
+    }
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const c = parsed;
+    if (c.v !== 1 || c.space !== forSpace || typeof c.title !== "string" || typeof c.copiedAt !== "number")
+        return null;
+    if (!c.node || typeof c.node !== "object" || typeof c.node.type !== "string" || !c.node.fields || typeof c.node.fields !== "object")
+        return null;
+    return { v: 1, space: c.space, title: c.title, node: c.node, copiedAt: c.copiedAt };
+}
+/** A fresh node from the clip: a new id, a fresh deep clone (a clip pasted twice never shares a list). A placement takes the
+ *  item's current row id when `globalIds` knows it: the copied one may be dead after a reseed of the space. */
+export function pastedNode(clip, globalIds = {}) {
+    const node = { id: newNodeId(clip.node.type), ...cloneNode(clip.node) };
+    if (node.type === GLOBAL_NODE_TYPE && typeof node.fields.item === "string" && globalIds[node.fields.item]) {
+        node.fields = { ...node.fields, ref: globalIds[node.fields.item] };
+    }
+    return node;
+}
+const refuse = (reason) => ({ ok: false, reason });
+/** Whether the target zone takes the clip, with the reason when not — the picker's own rules (spec §3). */
+export function canPaste(clip, policy, count, registry, globalIds) {
+    const { type } = clip.node;
+    const notTaken = refuse(`This zone doesn't take “${clip.title}”`);
+    if (type === GLOBAL_NODE_TYPE) {
+        const name = clip.node.fields.item;
+        const item = typeof name === "string" ? registry.globals.find((g) => g.name === name) : undefined;
+        if (!item)
+            return refuse(`“${clip.title}” is no longer registered on this site`);
+        if (!allowedGlobals(policy, [item], globalIds).length)
+            return notTaken;
+    }
+    else if (type === CUSTOM_NODE_TYPE) {
+        if (!allowsCustom(policy))
+            return notTaken;
+    }
+    else {
+        if (!registry.sections.some((s) => s.name === type))
+            return refuse(`“${clip.title}” is no longer registered on this site`);
+        if (!policy || policy.kind === "locked")
+            return notTaken;
+        if (policy.allow !== "*" && !policy.allow.includes(type))
+            return notTaken;
+    }
+    if (!canInsert(policy, count))
+        return policy && policy.kind !== "locked" ? refuse("This zone is full") : notTaken;
+    return { ok: true };
+}
+/** The `storage` event for the key (another tab wrote the clip, or the storage was cleared); the release removes the listener. */
+export function subscribeClip(win, fn) {
+    const onStorage = (e) => { if (e.key === null || e.key === CLIPBOARD_KEY)
+        fn(); };
+    win.addEventListener("storage", onStorage);
+    return () => win.removeEventListener("storage", onStorage);
+}

package/dist/admin/editor/undo-keys.d.ts

@@ -0,0 +1,19 @@
+export type UndoKey = "undo" | "redo" | null;
+type KeyLike = {
+    key: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+};
+export declare function undoKeyOf(e: KeyLike, platformMac: boolean): UndoKey;
+type TargetLike = {
+    tagName: string;
+    isContentEditable: boolean;
+    closest(selector: string): unknown;
+    getAttribute?(name: string): string | null;
+};
+/** Inside the field widgets, a plain input, textarea or select is the editor's; a contentEditable there is the sidebar richtext
+ *  (ProseMirror keeps its own undo) and a combobox keeps its search text — both as the spec lists them. */
+export declare function takesUndoKeys(target: TargetLike | null | undefined): boolean;
+export {};

package/dist/admin/editor/undo-keys.js

@@ -0,0 +1,27 @@
+export function undoKeyOf(e, platformMac) {
+    if (e.altKey)
+        return null;
+    const primary = platformMac ? e.metaKey && !e.ctrlKey : e.ctrlKey && !e.metaKey;
+    if (!primary)
+        return null;
+    const k = e.key.toLowerCase();
+    if (k === "z")
+        return e.shiftKey ? "redo" : "undo";
+    if (k === "y" && !platformMac && !e.shiftKey)
+        return "redo";
+    return null;
+}
+const TEXT_CONTROLS = new Set(["INPUT", "TEXTAREA", "SELECT"]);
+/** Inside the field widgets, a plain input, textarea or select is the editor's; a contentEditable there is the sidebar richtext
+ *  (ProseMirror keeps its own undo) and a combobox keeps its search text — both as the spec lists them. */
+export function takesUndoKeys(target) {
+    if (!target)
+        return true;
+    if (target.isContentEditable)
+        return false;
+    if (!TEXT_CONTROLS.has(target.tagName.toUpperCase()))
+        return true;
+    if (target.getAttribute?.("role") === "combobox")
+        return false;
+    return target.closest("[data-smd-undo]") !== null;
+}

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

@@ -26,11 +26,14 @@ type Point = {
     x: number;
     y: number;
 } | null;
-export declare function useInlineSession({ iframeRef, postToCanvas, patch }: {
+export declare function useInlineSession({ iframeRef, postToCanvas, patch, onSession }: {
     iframeRef: RefObject<HTMLIFrameElement | null>;
     postToCanvas(m: ToBridge): void;
     /** Write a field value into the tree by node id and dotted path. */
     patch(node: string, path: string, value: unknown): void;
+    /** A session opened: returns its release, called when the session ends or the canvas changes (the undo group,
+     *  spec 2026-10-19 editor at launch §2: an inline session is one step). */
+    onSession?(session: Session): () => void;
 }): {
     session: Session | null;
     richtext: RichtextMount | null;

package/dist/admin/editor/useInlineSession.js

@@ -17,7 +17,7 @@ import { INITIAL_INLINE, reduceInline } from "./inline-session.js";
 const CLOSE_FALLBACK_MS = 4000;
 /** On a hidden child: its inline display before the session, restored after. */
 const HIDDEN_ATTR = "data-smd-hidden";
-export function useInlineSession({ iframeRef, postToCanvas, patch }) {
+export function useInlineSession({ iframeRef, postToCanvas, patch, onSession }) {
     const [state, setState] = useState(INITIAL_INLINE);
     const stateRef = useRef(state);
     const [richtext, setRichtext] = useState(null);
@@ -27,6 +27,11 @@ export function useInlineSession({ iframeRef, postToCanvas, patch }) {
     const closeTimer = useRef(null);
     const patchRef = useRef(patch);
     patchRef.current = patch;
+    const onSessionRef = useRef(onSession);
+    onSessionRef.current = onSession;
+    /** The open session's release from `onSession`. */
+    const releaseSessionRef = useRef(null);
+    const releaseSession = () => { const r = releaseSessionRef.current; releaseSessionRef.current = null; r?.(); };
     const dispatch = useCallback((event) => {
         const { state: next, refresh } = reduceInline(stateRef.current, event);
         stateRef.current = next;
@@ -137,6 +142,7 @@ export function useInlineSession({ iframeRef, postToCanvas, patch }) {
         const changed = changedRef.current;
         // The reducer first: the blur that removing contenteditable fires re-enters here and must see no session.
         dispatch({ type: "end" });
+        releaseSession();
         if (text) {
             textRef.current = null;
             text.teardown();
@@ -169,8 +175,10 @@ export function useInlineSession({ iframeRef, postToCanvas, patch }) {
         }
         end();
         const ok = session.kind === "text" ? mountText(d, session, at) : mountRichtext(d, session, at);
-        if (ok)
+        if (ok) {
             dispatch({ type: "start", session });
+            releaseSessionRef.current = onSessionRef.current?.(session) ?? null;
+        }
         return ok;
     }, [iframeRef, dispatch, end, release, mountText, mountRichtext]);
     // ── the instant write (spec §7) ─────────────────────────────────────────
@@ -210,6 +218,7 @@ export function useInlineSession({ iframeRef, postToCanvas, patch }) {
         const mount = richtextRef.current;
         if (mount)
             release(mount);
+        releaseSession();
         dispatch({ type: "canvas" });
     }, [dispatch, release]);
     useEffect(() => () => { if (closeTimer.current)

package/dist/admin/editor/view-memory.d.ts

@@ -0,0 +1,9 @@
+export type EditorViewMode = "canvas" | "structure";
+export declare const VIEW_KEY = "smoodly-editor-view";
+type Storage = {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+};
+export declare function rememberedView(storage?: Storage): EditorViewMode;
+export declare function rememberView(view: EditorViewMode, storage?: Storage): void;
+export {};