smoodly 0.0.14 → 0.0.16

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

@@ -0,0 +1,124 @@
+import { setAtPath } from "../field-paths.js";
+import { createDraftAutosave } from "./autosave.js";
+export function createSharedEdit(opts) {
+    let items = {};
+    let loadError = null;
+    let generation = 0;
+    const loading = new Set();
+    const rev = new Map();
+    const savedRev = new Map();
+    const listeners = new Set();
+    let snapshot = null;
+    const emit = () => { snapshot = null; for (const l of listeners)
+        l(); };
+    const dirty = () => Object.values(items).filter((i) => (rev.get(i.name) ?? 0) > (savedRev.get(i.name) ?? 0));
+    const autosave = createDraftAutosave({
+        read: () => { const d = dirty(); return d.length > 0 ? d : null; },
+        persist: async (list) => {
+            let failed = null;
+            for (const item of list) {
+                const at = rev.get(item.name) ?? 0;
+                let r;
+                try {
+                    r = await opts.ops.shared.save(item.name, item.locale, item.fields);
+                }
+                catch {
+                    r = { ok: false, code: "internal", message: "Couldn't reach the server." };
+                }
+                const current = items[item.name];
+                if (r.ok) {
+                    savedRev.set(item.name, at);
+                    if (current)
+                        items = { ...items, [item.name]: { ...current, record: r.data, errors: {} } };
+                }
+                else {
+                    failed ?? (failed = r);
+                    if (current) {
+                        items = { ...items, [item.name]: { ...current, errors: Object.fromEntries((r.fields ?? []).map((f) => [f.field, f.message])) } };
+                    }
+                }
+            }
+            emit();
+            return failed ?? { ok: true, data: null };
+        },
+        onSaved: opts.onSaved,
+        debounceMs: opts.debounceMs,
+        retryBaseMs: opts.retryBaseMs,
+        retryCapMs: opts.retryCapMs,
+    });
+    autosave.subscribe(emit);
+    const getState = () => (snapshot ?? (snapshot = { items, saveState: autosave.getState(), loadError }));
+    return {
+        getState,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+        async load(name, locale) {
+            const key = `${name}/${locale}`;
+            if (items[name]?.locale === locale || loading.has(key))
+                return;
+            loading.add(key);
+            const gen = generation;
+            let r;
+            try {
+                r = await opts.ops.shared.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();
+        },
+        patch(name, path, value) {
+            const item = items[name];
+            if (!item)
+                return;
+            items = { ...items, [name]: { ...item, fields: setAtPath(item.fields, path, value) } };
+            rev.set(name, (rev.get(name) ?? 0) + 1);
+            emit();
+            autosave.mark();
+        },
+        flush: autosave.flush,
+        async setStatus(name, status) {
+            const item = items[name];
+            if (!item)
+                return { ok: false, code: "not_found", message: "This item hasn't loaded yet." };
+            if (!(await autosave.flush())) {
+                return { ok: false, code: "internal", message: "Couldn't save your latest changes — publish cancelled." };
+            }
+            let r;
+            try {
+                r = await opts.ops.shared.setStatus(name, item.locale, status);
+            }
+            catch {
+                r = { ok: false, code: "internal", message: "Couldn't reach the server." };
+            }
+            if (r.ok && items[name]) {
+                items = { ...items, [name]: { ...items[name], record: r.data } };
+                emit();
+            }
+            return r;
+        },
+        reset() {
+            generation += 1;
+            items = {};
+            rev.clear();
+            savedRev.clear();
+            loading.clear();
+            loadError = null;
+            autosave.dispose();
+            emit();
+        },
+        dispose: autosave.dispose,
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { AdminOps } from "../ops.ts";
+import { type SharedEdit, type SharedEditState } from "./shared-edit.ts";
+export declare function useSharedEdit({ ops, onSaved }: {
+    ops: Pick<AdminOps, "shared">;
+    onSaved?: () => void;
+}): SharedEditState & Pick<SharedEdit, "load" | "patch" | "flush" | "setStatus" | "reset">;

package/dist/admin/editor/useSharedEdit.js

@@ -0,0 +1,18 @@
+// React glue for `createSharedEdit`: one controller per editor mount, the
+// latest `onSaved` through a ref (it closes over the inline session), the
+// state through useSyncExternalStore. On unmount a pending save is
+// flushed first — the server call outlives the view — then the timers stop.
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { createSharedEdit } from "./shared-edit.js";
+export function useSharedEdit({ ops, onSaved }) {
+    const latest = useRef(onSaved);
+    latest.current = onSaved;
+    const [controller] = useState(() => createSharedEdit({ ops, onSaved: () => latest.current?.() }));
+    useEffect(() => () => { void controller.flush(); controller.dispose(); }, [controller]);
+    const state = useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
+    return {
+        ...state,
+        load: controller.load, patch: controller.patch, flush: controller.flush,
+        setStatus: controller.setStatus, reset: controller.reset,
+    };
+}

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

@@ -1,14 +1,20 @@
-import type { AdminField, AdminSection } from "../serialize.ts";
+import type { AdminField } from "../serialize.ts";
 export type TabName = "Content" | "Styles" | "Media" | "Meta";
 export type TabEntry = {
     key: string;
     ns: "fields" | "styles" | "meta";
     descriptor: AdminField;
 };
-export declare function tabsFor(section: AdminSection): {
+/** Anything with namespaced descriptors: a section, or a shared item (fields + styles, no meta). */
+export type FieldsHolder = {
+    fields: Record<string, AdminField>;
+    styles?: Record<string, AdminField>;
+    meta?: Record<string, AdminField>;
+};
+export declare function tabsFor(section: FieldsHolder): {
     tab: TabName;
     entries: TabEntry[];
 }[];
 /** The tab holding a content field, by its dotted path's top-level key — a canvas
  *  click on a marked image reveals it on Media, where the projection put it. */
-export declare function tabOf(section: AdminSection, path: string): TabName | undefined;
+export declare function tabOf(section: FieldsHolder, path: string): TabName | undefined;

package/dist/admin/next/op-handler.js

@@ -7,7 +7,7 @@ import { draftMode } from "next/headers";
 import { gateAdminOp } from "../auth.js";
 import { createAdminOps, runAdminOp } from "../ops-impl.js";
 export function createAdminOpHandler(deps) {
-    const ops = createAdminOps({
+    const base = {
         config: deps.config,
         pages: deps.pages,
         entries: deps.entries,
@@ -24,6 +24,7 @@ export function createAdminOpHandler(deps) {
                 disable: async () => (await draftMode()).disable(),
             },
         },
-    });
-    return (call) => gateAdminOp(deps.auth, call, (c) => runAdminOp(ops, c));
+    };
+    // Ops are built per call so the verified session rides into every store write as `by` (spec 2026-09-13 history §2).
+    return (call) => gateAdminOp(deps.auth, call, (c, session) => runAdminOp(createAdminOps({ ...base, actor: session }), c));
 }

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

@@ -3,6 +3,7 @@ import type { EntryStore } from "../entry-store.ts";
 import type { AssetStore } from "../asset-store.ts";
 import type { PageStore } from "../store.ts";
 import type { AdminOpCall, AdminOps, OpResult } from "./ops.ts";
+import type { AdminSession } from "./auth.ts";
 export type AdminEffects = {
     /** Expire one cache tag (`pageTag(id)` / `entryTag(id)`). */
     revalidate?(tag: string): void;
@@ -20,6 +21,8 @@ export declare function createAdminOps(deps: {
     href?: (path: string, locale: string) => string;
     /** The media library; absent = every assets op answers "no media store". */
     assets?: AssetStore;
+    /** The verified editor; their email is every write's `by`. Absent for the seed and tests (spec 2026-09-13 history §2). */
+    actor?: AdminSession;
 }): AdminOps;
 /** Path-dispatch for the one-server-action seam. Own-property checks only —
  * "constructor.constructor" and prototype paths must not resolve. */

package/dist/admin/ops-impl.js

@@ -5,8 +5,11 @@ import { affectedTargets, collectionTag, entryTag, pageTag, pagesTreeTag, shared
 import { ensureFixedNodes, fixedNodeOf } from "./fixed-nodes.js";
 import { ensureSharedItems } from "./shared-items.js";
 import { validateFields } from "./validate.js";
+import { withDefaults } from "../field-defaults.js";
 import { elementSchemas } from "../richtext-walk.js";
 const ok = (data) => ({ ok: true, data });
+/** A history row without its content (spec 2026-09-13 history §6). */
+const summary = ({ id, savedAt }) => ({ id, savedAt });
 const err = (code, message, fields) => ({ ok: false, code, message, ...(fields ? { fields } : {}) });
 /** Own-property, non-array plain object — same shape guard the tree checks
  * below and `runAdminOp`'s envelope check both lean on. */
@@ -62,6 +65,8 @@ const classify = (e) => {
         return err("blocked", message);
     if (message.includes("cannot publish"))
         return err("blocked", message);
+    if (message.includes("nothing published"))
+        return err("blocked", message);
     if (message.includes("already taken"))
         return err("conflict", message);
     if (message.includes("already has a template"))
@@ -88,6 +93,7 @@ const classify = (e) => {
 export function createAdminOps(deps) {
     const { config, pages, entries, effects } = deps;
     const href = deps.href ?? ((path) => path);
+    const by = deps.actor?.email ?? undefined;
     const collectionFields = (name) => config.registry.collections?.find((c) => c.name === name)?.fields ?? null;
     // Element nodes inside richtext validate against these (spec 2026-09-08 block nodes §2).
     const elementDescs = elementSchemas((config.registry.elements ?? []).map((e) => ({ name: e.schema.name, fields: e.schema.fields ?? {}, styles: e.schema.styles })));
@@ -281,7 +287,7 @@ export function createAdminOps(deps) {
                 const created = await pages.createPage({
                     locale: input.locale, slug: input.slug, template: input.template, parentId: input.parentId,
                     ...(input.title !== undefined ? { title: input.title } : {}),
-                });
+                }, by);
                 expireTree();
                 return ok(created);
             }),
@@ -293,7 +299,7 @@ export function createAdminOps(deps) {
                     return err("validation", "smoodly: malformed page tree.");
                 if (!(await pages.getPage(id)))
                     return err("not_found", `smoodly: no page "${id}".`);
-                return ok({ versionId: (await pages.saveDraft(id, locale, tree)).id });
+                return ok({ versionId: (await pages.saveDraft(id, locale, tree, by)).id });
             }),
             publish: (id, locale) => guard(async () => {
                 const unsupported = supportedLocale(locale);
@@ -330,12 +336,75 @@ export function createAdminOps(deps) {
                 if (fieldErrors.length > 0) {
                     return err("validation", `smoodly: cannot publish "${row.slug}" — fix the listed fields first.`, fieldErrors);
                 }
-                const published = await pages.publish(id, locale);
+                const published = await pages.publish(id, locale, by);
                 // The parent's cached unit lists its published children.
                 expirePages([published.id, published.parentId]);
                 expireTree();
                 return ok(published);
             }),
+            unpublish: (id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                if (!record.locales[locale])
+                    return err("not_found", `smoodly: page "${id}" does not exist in locale "${locale}".`);
+                if (isHomeNode(record))
+                    return err("blocked", `smoodly: "${nameOf(record)}" is the site root — it cannot be unpublished.`);
+                if (fixedNodeOf(record, config))
+                    return owned(record, "it stays published");
+                const off = await pages.unpublish(id, locale, by);
+                // The parent's cached unit lists its published children; the tree listing shows status.
+                expirePages([off.id, off.parentId]);
+                expireTree();
+                return ok(off);
+            }),
+            discardDraft: (id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                const row = record.locales[locale];
+                if (!row)
+                    return err("not_found", `smoodly: page "${id}" does not exist in locale "${locale}".`);
+                if (!row.publishedVersionId) {
+                    return err("blocked", `smoodly: "${nameOf(record)}" has nothing published in ${locale} — there is no version to restore.`);
+                }
+                const restored = await pages.discardDraft(id, locale, by);
+                expirePages([restored.id]); // the draft-mode render of this page changed
+                return ok(restored);
+            }),
+            listVersions: (id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                if (!(await pages.getPage(id)))
+                    return err("not_found", `smoodly: no page "${id}".`);
+                return ok((await pages.listVersions(id, locale)).map(summary));
+            }),
+            restore: (id, locale, versionId) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                if (!record.locales[locale])
+                    return err("not_found", `smoodly: page "${id}" does not exist in locale "${locale}".`);
+                if (record.template === null)
+                    return err("blocked", `smoodly: "${nameOf(record)}" is a folder — it has no versions.`);
+                const version = typeof versionId === "string" ? await pages.getVersion(versionId) : null;
+                if (!version || version.pageId !== id || version.locale !== locale) {
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of this page in ${locale}.`);
+                }
+                const restored = await pages.restore(id, locale, versionId, by);
+                expirePages([restored.id]); // the draft-mode render of this page changed
+                return ok(restored);
+            }),
             delete: (id) => guard(async () => {
                 const record = await pages.getPage(id);
                 if (!record)
@@ -364,7 +433,7 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(patch.locale);
                 if (unsupported)
                     return unsupported;
-                const renamed = await pages.rename(id, patch);
+                const renamed = await pages.rename(id, patch, by);
                 // Every descendant's path changed with this segment; the parent
                 // lists this node's title and path.
                 expirePages([...(await subtreeIds(id)), record.parentId]);
@@ -408,7 +477,7 @@ export function createAdminOps(deps) {
                 if (registration.schema.slug !== undefined) {
                     return err("validation", `smoodly: page template "${template}" is fixed — Smoodly creates that page for you.`);
                 }
-                const withTemplate = await pages.setTemplate(id, template);
+                const withTemplate = await pages.setTemplate(id, template, by);
                 expireTree();
                 return ok(withTemplate);
             }),
@@ -419,7 +488,7 @@ export function createAdminOps(deps) {
                 if (!(await pages.getPage(id)))
                     return err("not_found", `smoodly: no page "${id}".`);
                 // A new locale is a draft: nothing public changes but the tree listing (spec 2026-09-11 §2).
-                const added = await pages.addLocale(id, locale, { from: options.from });
+                const added = await pages.addLocale(id, locale, { from: options.from }, by);
                 expireTree();
                 return ok(added);
             }),
@@ -455,7 +524,9 @@ export function createAdminOps(deps) {
                 const parentLocales = record.parentId === null
                     ? config.locales.supported
                     : Object.keys((await entries.get(collection, record.parentId))?.locales ?? {});
-                return ok({ record, locale, fields, parentLocales });
+                const paths = await entries.pathsOf(collection, id);
+                const urls = Object.fromEntries(Object.entries(paths).map(([l, p]) => [l, href(p, l)]));
+                return ok({ record, locale, fields, parentLocales, urls });
             }),
             create: (collection, input) => guard(async () => {
                 const unsupported = supportedLocale(input.locale);
@@ -464,10 +535,7 @@ export function createAdminOps(deps) {
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const fieldErrors = validateFields(input.fields, descriptors, elementDescs);
-                if (fieldErrors.length > 0)
-                    return err("validation", "Some fields need attention.", fieldErrors);
-                const created = await entries.create(collection, input.fields, { locale: input.locale, parentId: input.parentId ?? null });
+                const created = await entries.create(collection, withDefaults(input.fields, descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
                 expireCollection(collection);
                 return ok(created);
             }),
@@ -478,10 +546,7 @@ export function createAdminOps(deps) {
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const fieldErrors = validateFields(fields, descriptors, elementDescs);
-                if (fieldErrors.length > 0)
-                    return err("validation", "Some fields need attention.", fieldErrors);
-                const entry = await entries.update(collection, id, locale, fields);
+                const entry = await entries.update(collection, id, locale, fields, by);
                 await fanOut(id);
                 expireCollection(collection);
                 return ok(entry);
@@ -490,11 +555,62 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                const entry = await entries.setStatus(collection, id, locale, status);
+                if (status === "published") {
+                    // A draft may be incomplete; what goes live may not (spec 2026-09-14 §2).
+                    const descriptors = collectionFields(collection);
+                    if (!descriptors)
+                        return err("not_found", `smoodly: no collection named "${collection}".`);
+                    const record = await entries.get(collection, id);
+                    if (!record)
+                        return err("not_found", `smoodly: no entry "${id}" in "${collection}".`);
+                    if (!record.locales[locale])
+                        return err("not_found", `smoodly: entry "${id}" does not exist in locale "${locale}".`);
+                    const fieldErrors = validateFields(entryFieldsIn(record, locale), descriptors, elementDescs);
+                    if (fieldErrors.length > 0)
+                        return err("validation", "Some fields need attention.", fieldErrors);
+                }
+                const entry = await entries.setStatus(collection, id, locale, status, by);
                 await fanOut(id);
                 expireCollection(collection);
                 return ok(entry);
             }),
+            discardDraft: (collection, id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const restored = await entries.discardDraft(collection, id, locale, by);
+                await fanOut(id);
+                expireCollection(collection);
+                return ok(restored);
+            }),
+            listVersions: (collection, id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                if (!(await entries.get(collection, id)))
+                    return err("not_found", `smoodly: no entry "${id}" in "${collection}".`);
+                return ok((await entries.listVersions(collection, id, locale)).map(summary));
+            }),
+            getVersion: (collection, id, versionId) => guard(async () => {
+                const version = typeof versionId === "string" ? await entries.getVersion(collection, versionId) : null;
+                if (!version || version.entryId !== id) {
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of entry "${id}" in "${collection}".`);
+                }
+                return ok({ ...summary(version), fields: version.fields });
+            }),
+            restore: (collection, id, locale, versionId) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const version = typeof versionId === "string" ? await entries.getVersion(collection, versionId) : null;
+                if (!version || version.entryId !== id || version.locale !== locale) {
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of entry "${id}" in "${collection}", locale ${locale}.`);
+                }
+                const restored = await entries.restore(collection, id, locale, versionId, by);
+                await fanOut(id);
+                expireCollection(collection);
+                return ok(restored);
+            }),
             // The tag expires only after the delete succeeded; a blocked delete expires nothing.
             delete: (collection, id) => guard(async () => (await entries.delete(collection, id), await fanOut(id), expireCollection(collection), ok(null))),
             move: (collection, id, to) => guard(async () => {
@@ -512,7 +628,7 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                const added = await entries.addLocale(collection, id, locale, { from: options.from });
+                const added = await entries.addLocale(collection, id, locale, { from: options.from }, by);
                 expireCollection(collection);
                 return ok(added);
             }),
@@ -552,13 +668,10 @@ export function createAdminOps(deps) {
                 const item = sharedItem(name);
                 if (!item)
                     return err("not_found", `smoodly: no shared item named "${name}".`);
-                const fieldErrors = validateFields(fields, item.fields, elementDescs);
-                if (fieldErrors.length > 0)
-                    return err("validation", "Some fields need attention.", fieldErrors);
                 const record = await sharedRecord(name);
                 if (!record)
                     return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
-                const saved = await entries.update(name, record.id, locale, fields);
+                const saved = await entries.update(name, record.id, locale, fields, by);
                 // fanOut expires `shared:<name>` itself — this row IS the item's.
                 await fanOut(record.id);
                 return ok(saved);
@@ -567,16 +680,78 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                if (!sharedItem(name))
+                const item = sharedItem(name);
+                if (!item)
                     return err("not_found", `smoodly: no shared item named "${name}".`);
                 const record = await sharedRecord(name);
                 if (!record)
                     return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
-                const changed = await entries.setStatus(name, record.id, locale, status);
+                if (status === "published") {
+                    // A draft may be incomplete; what goes live may not (spec 2026-09-14 §2).
+                    if (!record.locales[locale])
+                        return err("not_found", `smoodly: shared item "${name}" does not exist in locale "${locale}".`);
+                    const fieldErrors = validateFields(entryFieldsIn(record, locale), item.fields, elementDescs);
+                    if (fieldErrors.length > 0)
+                        return err("validation", "Some fields need attention.", fieldErrors);
+                }
+                const changed = await entries.setStatus(name, record.id, locale, status, by);
                 // see save: the fan-out carries the item's own tag.
                 await fanOut(record.id);
                 return ok(changed);
             }),
+            discardDraft: (name, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                if (!sharedItem(name))
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                const record = await sharedRecord(name);
+                if (!record)
+                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                const restored = await entries.discardDraft(name, record.id, locale, by);
+                await fanOut(record.id);
+                return ok(restored);
+            }),
+            listVersions: (name, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                if (!sharedItem(name))
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                const record = await sharedRecord(name);
+                if (!record)
+                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                return ok((await entries.listVersions(name, record.id, locale)).map(summary));
+            }),
+            getVersion: (name, versionId) => guard(async () => {
+                if (!sharedItem(name))
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                const record = await sharedRecord(name);
+                if (!record)
+                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                const version = typeof versionId === "string" ? await entries.getVersion(name, versionId) : null;
+                if (!version || version.entryId !== record.id) {
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of shared item "${name}".`);
+                }
+                return ok({ ...summary(version), fields: version.fields });
+            }),
+            restore: (name, locale, versionId) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                if (!sharedItem(name))
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                const record = await sharedRecord(name);
+                if (!record)
+                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                const version = typeof versionId === "string" ? await entries.getVersion(name, versionId) : null;
+                if (!version || version.entryId !== record.id || version.locale !== locale) {
+                    return err("not_found", `smoodly: no version "${String(versionId)}" of shared item "${name}" in ${locale}.`);
+                }
+                const restored = await entries.restore(name, record.id, locale, versionId, by);
+                await fanOut(record.id);
+                return ok(restored);
+            }),
         },
         assets: {
             list: (query) => guard(async () => (assets ? ok(await assets.list(query)) : noMedia())),

package/dist/admin/ops.d.ts

@@ -55,6 +55,8 @@ export type EntryGetResult = {
     locale: string;
     /** That locale's merged draft fields; null when the entry has no row in `locale`. */
     fields: Record<string, unknown> | null;
+    /** locale → site URL (`href` applied server-side) for the locales the entry has a path in; empty for a collection without a path. */
+    urls: Record<string, string>;
     /** The locales the PARENT exists in (every supported locale for a root) — the form disables the rest with a reason. */
     parentLocales: string[];
 };
@@ -72,6 +74,15 @@ export type SharedGetResult = {
     /** Who links it: "used on N pages". */
     usage: EntryUsage[];
 };
+/** A history row: the version id and when its content last changed (spec 2026-09-13 history §5). */
+export type VersionSummary = {
+    id: string;
+    savedAt: number;
+};
+/** A stored entry snapshot for the disabled form. */
+export type EntryVersionResult = VersionSummary & {
+    fields: Record<string, unknown>;
+};
 /** One place an asset is used: the source row, the field, a label and an admin link. */
 export type AssetUsageItem = {
     sourceKind: string;
@@ -91,6 +102,10 @@ export type AdminOps = {
             versionId: string;
         }>>;
         publish(id: string, locale: string): Promise<OpResult<PageRecord>>;
+        /** Takes the locale off the site; status draft, pointers kept. Never the site root or a fixed node (spec 2026-09-13 publish flow §5). */
+        unpublish(id: string, locale: string): Promise<OpResult<PageRecord>>;
+        /** The draft back to the published version (§4); `blocked` when nothing is published in the locale. */
+        discardDraft(id: string, locale: string): Promise<OpResult<PageRecord>>;
         delete(id: string): Promise<OpResult<null>>;
         rename(id: string, patch: {
             locale: string;
@@ -109,6 +124,10 @@ export type AdminOps = {
         }): Promise<OpResult<PageRecord>>;
         /** Deletes the locale's row, versions and paths. Never on fixed nodes or the site root. */
         removeLocale(id: string, locale: string): Promise<OpResult<PageRecord>>;
+        /** The locale's versions newest first, without their trees. */
+        listVersions(id: string, locale: string): Promise<OpResult<VersionSummary[]>>;
+        /** The version's tree becomes the draft (spec 2026-09-13 history §6); `not_found` for a version of another page or locale, `blocked` on a folder. */
+        restore(id: string, locale: string, versionId: string): Promise<OpResult<PageRecord>>;
     };
     entries: {
         list(collection: string): Promise<OpResult<EntryRecord[]>>;
@@ -117,6 +136,8 @@ export type AdminOps = {
         create(collection: string, input: EntryCreateInput): Promise<OpResult<EntryRecord>>;
         save(collection: string, id: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
         setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
+        /** The live row back to the published snapshot (§4); `blocked` when the locale has no published version. */
+        discardDraft(collection: string, id: string, locale: string): Promise<OpResult<EntryRecord>>;
         delete(collection: string, id: string): Promise<OpResult<null>>;
         move(collection: string, id: string, to: {
             parentId: string | null;
@@ -128,6 +149,12 @@ export type AdminOps = {
         }): Promise<OpResult<EntryRecord>>;
         /** Deletes the locale's row, versions and paths; fans out like a save. */
         removeLocale(collection: string, id: string, locale: string): Promise<OpResult<EntryRecord>>;
+        /** Newest first; empty for a collection without `versions`. */
+        listVersions(collection: string, id: string, locale: string): Promise<OpResult<VersionSummary[]>>;
+        /** One snapshot's fields; `not_found` unless it belongs to `id`. */
+        getVersion(collection: string, id: string, versionId: string): Promise<OpResult<EntryVersionResult>>;
+        /** The snapshot becomes the draft (§6); `not_found` for a foreign version. Fans out like a save. */
+        restore(collection: string, id: string, locale: string, versionId: string): Promise<OpResult<EntryRecord>>;
     };
     shared: {
         /** Materializes every registered item in every supported locale, then lists them in registry order. */
@@ -135,6 +162,11 @@ export type AdminOps = {
         get(name: string, locale: string): Promise<OpResult<SharedGetResult>>;
         save(name: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
         setStatus(name: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
+        /** The item's live row back to its published snapshot (§4); `blocked` before the first publish. */
+        discardDraft(name: string, locale: string): Promise<OpResult<EntryRecord>>;
+        listVersions(name: string, locale: string): Promise<OpResult<VersionSummary[]>>;
+        getVersion(name: string, versionId: string): Promise<OpResult<EntryVersionResult>>;
+        restore(name: string, locale: string, versionId: string): Promise<OpResult<EntryRecord>>;
     };
     assets: {
         /** Ready assets, newest first, paged by cursor; `kind` and `search` filter. */

package/dist/admin/serialize.d.ts

@@ -48,7 +48,6 @@ export type AdminShared = {
     title: string;
     /** The section a visual item renders through; absent = an object item. */
     section?: string;
-    versions: boolean;
     fields: Record<string, AdminField>;
     /** Resolved (the config's standard set merged in) for a visual item; empty for an object item. */
     styles: Record<string, AdminField>;