smoodly 0.0.4 → 0.0.6

package/dist/admin/forms/FieldWidget.js

@@ -1,54 +1,54 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { plainToRichtext, richtextToPlain } from "../richtext.js";
+import { Field, IconButton } from "../ui/primitives.js";
 const label = (key) => key.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
-const inputStyle = {
-    width: "100%", boxSizing: "border-box", border: "1px solid #d6d3e0", borderRadius: 8,
-    padding: "9px 10px", fontFamily: "inherit", fontSize: 13.5, background: "#fff", color: "#17141f",
-};
-export function FieldWidget({ descriptor: d, value, onChange, error, refOptions = [], fieldKey, }) {
+export function FieldWidget({ descriptor: d, value, onChange, error, refOptions = [], fieldKey, prefix, }) {
     const optionTitle = (o) => o.status === "draft" ? `${o.title} (draft)` : o.title;
     let control;
     switch (d.type) {
         case "text":
         case "link":
         case "slug":
-        case "date":
-            control = _jsx("input", { style: inputStyle, value: String(value ?? ""), onChange: (e) => onChange(e.target.value) });
+        case "date": {
+            const input = (_jsx("input", { className: d.type === "slug" ? "sm-input sm-input--mono" : "sm-input", value: String(value ?? ""), onChange: (e) => onChange(e.target.value) }));
+            control = d.type === "slug" && prefix
+                ? _jsxs("span", { className: "sm-inputwrap", children: [_jsx("span", { className: "sm-prefix", children: prefix }), input] })
+                : input;
             break;
+        }
         case "number":
-            control = (_jsx("input", { style: inputStyle, type: "number", value: value == null ? "" : String(value), onChange: (e) => onChange(e.target.value === "" ? undefined : Number(e.target.value)) }));
+            control = (_jsx("input", { className: "sm-input", type: "number", value: value == null ? "" : String(value), onChange: (e) => onChange(e.target.value === "" ? undefined : Number(e.target.value)) }));
             break;
         case "select": {
             const options = Array.isArray(d.options) ? d.options : [];
-            control = (_jsxs("select", { style: inputStyle, value: String(value ?? ""), onChange: (e) => onChange(e.target.value), children: [d.optional === true && _jsx("option", { value: "", children: "\u2014" }), options.map((o) => _jsx("option", { value: o, children: o }, o))] }));
+            control = (_jsxs("select", { className: "sm-select", value: String(value ?? ""), onChange: (e) => onChange(e.target.value), children: [d.optional === true && _jsx("option", { value: "", children: "\u2014" }), options.map((o) => _jsx("option", { value: o, children: o }, o))] }));
             break;
         }
         case "richtext":
-            control = (_jsx("textarea", { style: { ...inputStyle, resize: "vertical" }, rows: 4, value: richtextToPlain(value), onChange: (e) => onChange(plainToRichtext(e.target.value)) }));
+            control = (_jsx("textarea", { className: "sm-textarea", rows: 5, value: richtextToPlain(value), onChange: (e) => onChange(plainToRichtext(e.target.value)) }));
             break;
         case "image":
         case "video":
         case "file": {
             const url = value?.url ?? "";
-            control = (_jsx("input", { style: inputStyle, placeholder: "https://\u2026", value: url, onChange: (e) => onChange(e.target.value ? { url: e.target.value } : undefined) }));
+            control = (_jsx("input", { className: "sm-input", placeholder: "https://\u2026", value: url, onChange: (e) => onChange(e.target.value ? { url: e.target.value } : undefined) }));
             break;
         }
         case "ref":
-            control = (_jsxs("select", { style: inputStyle, value: String(value ?? ""), onChange: (e) => onChange(e.target.value || undefined), children: [_jsx("option", { value: "", children: "\u2014" }), refOptions.map((o) => _jsx("option", { value: o.id, children: optionTitle(o) }, o.id))] }));
+            control = (_jsxs("select", { className: "sm-select", value: String(value ?? ""), onChange: (e) => onChange(e.target.value || undefined), children: [_jsx("option", { value: "", children: "\u2014" }), refOptions.map((o) => _jsx("option", { value: o.id, children: optionTitle(o) }, o.id))] }));
             break;
         case "refList": {
             const ids = Array.isArray(value) ? value : [];
             const byId = new Map(refOptions.map((o) => [o.id, o]));
-            control = (_jsxs("div", { children: [ids.map((id, i) => (_jsxs("div", { style: { display: "flex", gap: 6, marginBottom: 6 }, children: [_jsx("span", { style: { ...inputStyle, flex: 1 }, children: byId.get(id) ? optionTitle(byId.get(id)) : id }), _jsx("button", { type: "button", onClick: () => onChange(ids.filter((_, j) => j !== i)), style: { border: 0, background: "#efecf6", borderRadius: 8, cursor: "pointer", padding: "0 10px" }, children: "\u2715" })] }, `${id}-${i}`))), _jsxs("select", { style: inputStyle, value: "", onChange: (e) => e.target.value && onChange([...ids, e.target.value]), children: [_jsx("option", { value: "", children: "Add\u2026" }), refOptions.filter((o) => !ids.includes(o.id)).map((o) => (_jsx("option", { value: o.id, children: optionTitle(o) }, o.id)))] })] }));
+            control = (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: [ids.map((id, i) => (_jsxs("div", { style: { display: "flex", gap: 6, alignItems: "center" }, children: [_jsx("span", { className: "sm-input", style: { display: "flex", alignItems: "center", flex: 1 }, children: byId.get(id) ? optionTitle(byId.get(id)) : id }), _jsx(IconButton, { label: "Remove", size: 28, onClick: () => onChange(ids.filter((_, j) => j !== i)), children: "\u00D7" })] }, `${id}-${i}`))), _jsxs("select", { className: "sm-select", value: "", onChange: (e) => e.target.value && onChange([...ids, e.target.value]), children: [_jsx("option", { value: "", children: "Add\u2026" }), refOptions.filter((o) => !ids.includes(o.id)).map((o) => (_jsx("option", { value: o.id, children: optionTitle(o) }, o.id)))] })] }));
             break;
         }
         default:
-            control = _jsx("textarea", { style: inputStyle, disabled: true, value: JSON.stringify(value ?? null, null, 2), rows: 2 });
+            control = _jsx("textarea", { className: "sm-textarea", disabled: true, value: JSON.stringify(value ?? null, null, 2), rows: 2 });
     }
     // A <label> activates its first labelable descendant, so it may only wrap a
     // single control — around refList's rows it would turn every click into a
     // press of the first row's remove button.
-    const Wrapper = d.type === "refList" ? "div" : "label";
-    return (_jsxs(Wrapper, { style: { display: "block", marginBottom: 14 }, children: [_jsx("span", { style: { display: "block", fontSize: 11, letterSpacing: "0.08em", textTransform: "uppercase", opacity: 0.55, marginBottom: 6 }, children: label(fieldKey) }), control, error && _jsx("span", { style: { display: "block", color: "#b91c1c", fontSize: 12, marginTop: 4 }, children: error })] }));
+    return (_jsx(Field, { label: label(fieldKey), error: error, asDiv: d.type === "refList", children: control }));
 }

package/dist/admin/index.d.ts

@@ -1,5 +1,6 @@
-export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError } from "./ops.ts";
+export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult } from "./ops.ts";
 export { createAdminOps, runAdminOp, type AdminEffects } from "./ops-impl.ts";
+export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes, type FixedNode } from "./fixed-nodes.ts";
 export { makeClientOps } from "./client-ops.ts";
 export { gateAdminOp, type AdminAuth } from "./auth.ts";
 export { supabaseAdminAuth } from "./supabase-auth.ts";

package/dist/admin/index.js

@@ -1,4 +1,5 @@
 export { createAdminOps, runAdminOp } from "./ops-impl.js";
+export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes } from "./fixed-nodes.js";
 export { makeClientOps } from "./client-ops.js";
 export { gateAdminOp } from "./auth.js";
 export { supabaseAdminAuth } from "./supabase-auth.js";

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

@@ -1,14 +1,19 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { serializeAdminConfig } from "../serialize.js";
 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 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). */
     function AdminLayout({ children }) {
-        return (_jsx("div", { style: { fontFamily: "system-ui, sans-serif", minHeight: "100vh", background: "#f4f3f8", color: "#17141f" }, children: children }));
+        return (_jsxs("div", { className: "sm-admin", children: [_jsx(AdminStyles, {}), children] }));
     }
     return { AdminPage, AdminLayout };
 }

package/dist/admin/next/op-handler.d.ts

@@ -8,4 +8,5 @@ export declare function createAdminOpHandler(deps: {
     pages: PageStore;
     entries: EntryStore;
     auth: AdminAuth;
+    href?: (path: string, locale: string) => string;
 }): AdminOpAction;

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

@@ -2,7 +2,7 @@
 // The Next face of the ops seam: ONE server-action body, gated by
 // AdminAuth. The app's 'use server' file wraps this in its single
 // exported async function.
-import { revalidateTag } from "next/cache";
+import { updateTag } from "next/cache";
 import { draftMode } from "next/headers";
 import { gateAdminOp } from "../auth.js";
 import { createAdminOps, runAdminOp } from "../ops-impl.js";
@@ -11,8 +11,13 @@ export function createAdminOpHandler(deps) {
         config: deps.config,
         pages: deps.pages,
         entries: deps.entries,
+        href: deps.href,
         effects: {
-            revalidatePage: (slug) => revalidateTag(`page:${slug}`, "max"),
+            // updateTag, not revalidateTag(tag, profile): the profile form is
+            // stale-while-revalidate, so the first request after publish still
+            // served the cached null (a 404) and only the second saw the page.
+            // updateTag expires now — Server Actions only, which this is.
+            revalidate: (tag) => updateTag(tag),
             draft: {
                 enable: async () => (await draftMode()).enable(),
                 disable: async () => (await draftMode()).disable(),

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

@@ -3,7 +3,8 @@ import type { EntryStore } from "../entry-store.ts";
 import type { PageStore } from "../store.ts";
 import type { AdminOpCall, AdminOps, OpResult } from "./ops.ts";
 export type AdminEffects = {
-    revalidatePage?(slug: string): void;
+    /** Expire one cache tag (`pageTag(id)` / `entryTag(id)`). */
+    revalidate?(tag: string): void;
     draft?: {
         enable(): void | Promise<void>;
         disable(): void | Promise<void>;
@@ -14,6 +15,8 @@ export declare function createAdminOps(deps: {
     pages: PageStore;
     entries: EntryStore;
     effects?: AdminEffects;
+    /** Locale-relative CMS path → site URL (the renderer's seam, applied here for the admin). Default: identity. */
+    href?: (path: string, locale: string) => string;
 }): 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

@@ -1,4 +1,5 @@
-import { affectedPageSlugs } from "../revalidate.js";
+import { affectedTargets, entryTag, pageTag } from "../revalidate.js";
+import { ensureFixedNodes, fixedNodeOf } from "./fixed-nodes.js";
 import { validateFields } from "./validate.js";
 const ok = (data) => ({ ok: true, data });
 const err = (code, message, fields) => ({ ok: false, code, message, ...(fields ? { fields } : {}) });
@@ -35,20 +36,80 @@ const classify = (e) => {
         return err("blocked", message);
     if (message.includes("cannot publish"))
         return err("blocked", message);
+    if (message.includes("already taken"))
+        return err("conflict", message);
+    if (message.includes("already has a template"))
+        return err("conflict", message);
+    if (message.includes("exceed the tree depth") || message.includes("has child"))
+        return err("blocked", message);
+    // The tree guards: editing a folder as a page, moving a node into its
+    // own subtree, and the home page's no-children invariant.
+    if (message.includes("is a folder") ||
+        message.includes("cannot be moved under itself") ||
+        message.includes("cannot have child pages")) {
+        return err("blocked", message);
+    }
+    if (message.includes("must be in the same collection"))
+        return err("validation", message);
+    if (message.includes("not a valid slug"))
+        return err("validation", message);
     if (message.includes("no page") || message.includes("no entry") || message.includes("no collection"))
         return err("not_found", message);
     return err("internal", message);
 };
 export function createAdminOps(deps) {
     const { config, pages, entries, effects } = deps;
+    const href = deps.href ?? ((path) => path);
     const collectionFields = (name) => config.registry.collections?.find((c) => c.name === name)?.fields ?? null;
     const sectionFields = (type) => config.registry.sections?.find((s) => s.schema.name === type)?.schema;
     const fanOut = async (entryId) => {
-        if (!effects?.revalidatePage)
+        if (!effects?.revalidate)
+            return;
+        const { pageIds, entryIds } = await affectedTargets({ pages, entries }, entryId);
+        for (const id of entryIds)
+            effects.revalidate(entryTag(id));
+        for (const id of pageIds)
+            effects.revalidate(pageTag(id));
+    };
+    /** Expire the cached units a tree change touched, in order, once each. */
+    const expirePages = (ids) => {
+        if (!effects?.revalidate)
             return;
-        for (const slug of await affectedPageSlugs({ pages, entries }, entryId)) {
-            effects.revalidatePage(slug);
+        for (const id of new Set(ids.filter((x) => typeof x === "string")))
+            effects.revalidate(pageTag(id));
+    };
+    /** A node and every descendant, node first, in listPages() order. */
+    const subtreeIds = async (id) => {
+        const all = await pages.listPages();
+        const out = [id];
+        for (let i = 0; i < out.length; i++) {
+            for (const p of all)
+                if (p.parentId === out[i])
+                    out.push(p.id);
+        }
+        return out;
+    };
+    /** Same walk over one collection's entries. */
+    const entrySubtreeIds = async (collection, id) => {
+        const all = await entries.list(collection);
+        const out = [id];
+        for (let i = 0; i < out.length; i++) {
+            for (const e of all)
+                if (e.parentId === out[i])
+                    out.push(e.id);
         }
+        return out;
+    };
+    const owned = (record, verb) => err("blocked", `smoodly: "${record.slug}" is owned by code — ${verb}.`);
+    /** The record serving "/" — guarded whether or not a registration claims
+     *  its slug: the config's homePageSlug is what routes it. */
+    const isHomeNode = (r) => r.parentId === null && r.slug === config.homePageSlug;
+    const openTemplate = (name) => config.registry.pages?.find((p) => p.schema.kind === "page" && p.schema.name === name);
+    const mountGuard = (parent) => {
+        const fixed = fixedNodeOf(parent, config);
+        return fixed?.collection
+            ? err("blocked", `smoodly: pages cannot be created under "${parent.slug}" — the "${fixed.collection}" collection owns that URL space.`)
+            : null;
     };
     const guard = async (work) => {
         try {
@@ -60,42 +121,59 @@ export function createAdminOps(deps) {
     };
     return {
         pages: {
-            list: () => guard(async () => ok(await pages.listPages())),
-            get: (slug) => guard(async () => {
-                const record = await pages.getPage(slug);
-                const draft = record ? await pages.getDraftTree(slug) : null;
-                if (!record || !draft)
-                    return err("not_found", `smoodly: no page with slug "${slug}".`);
-                return ok({ record, draft });
+            list: () => guard(async () => ok(await ensureFixedNodes(pages, config))),
+            get: (id) => guard(async () => {
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                const draft = record.template === null ? null : await pages.getDraftTree(id);
+                const paths = await pages.pathsOf(id);
+                const urls = Object.fromEntries(Object.entries(paths).map(([locale, path]) => [locale, href(path, locale)]));
+                return ok({ record, draft, paths, urls });
             }),
             create: (input) => guard(async () => {
-                const registration = config.registry.pages?.find((p) => p.schema.name === input.template);
-                if (!registration) {
-                    return err("validation", `smoodly: no page template named "${input.template}".`);
+                if (input.template !== null) {
+                    const registration = openTemplate(input.template);
+                    if (!registration)
+                        return err("validation", `smoodly: no page template named "${input.template}".`);
+                    if (registration.schema.slug !== undefined) {
+                        return err("validation", `smoodly: page template "${input.template}" is fixed — Smoodly creates that page for you.`);
+                    }
                 }
-                const fixed = registration.schema.slug;
-                if (fixed !== undefined && fixed !== input.slug) {
-                    return err("validation", `smoodly: page template "${input.template}" is fixed to the slug "${fixed}" and cannot be created at "${input.slug}".`);
+                if (input.parentId !== null) {
+                    const parent = await pages.getPage(input.parentId);
+                    if (!parent)
+                        return err("not_found", `smoodly: no page "${input.parentId}".`);
+                    const blocked = mountGuard(parent);
+                    if (blocked)
+                        return blocked;
                 }
-                if (fixed === undefined) {
-                    // An open page here would be shadowed forever by the fixed
-                    // registration's own route file.
-                    const owner = config.registry.pages?.find((p) => p.schema.slug === input.slug);
-                    if (owner) {
-                        return err("validation", `smoodly: the slug "${input.slug}" belongs to the page template "${owner.schema.name}" and its own route file.`);
-                    }
+                else {
+                    // A root create competes with the code-owned slugs: make sure they exist first.
+                    await ensureFixedNodes(pages, config);
                 }
-                return ok(await pages.createPage(input));
+                return ok(await pages.createPage({
+                    slug: input.slug, template: input.template, parentId: input.parentId,
+                    ...(input.title !== undefined ? { title: input.title } : {}),
+                }));
             }),
-            saveDraft: (slug, tree) => guard(async () => {
+            saveDraft: (id, tree) => guard(async () => {
                 if (!isPageTree(tree))
                     return err("validation", "smoodly: malformed page tree.");
-                return ok({ versionId: (await pages.saveDraft(slug, tree)).id });
+                if (!(await pages.getPage(id)))
+                    return err("not_found", `smoodly: no page "${id}".`);
+                return ok({ versionId: (await pages.saveDraft(id, tree)).id });
             }),
-            publish: (slug) => guard(async () => {
-                const draft = await pages.getDraftTree(slug);
-                if (!draft)
-                    return err("not_found", `smoodly: no page with slug "${slug}".`);
+            publish: (id) => guard(async () => {
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                const draft = record.template === null ? null : await pages.getDraftTree(id);
+                if (!draft) {
+                    return record.template === null
+                        ? err("blocked", `smoodly: "${record.slug}" is a folder — give it a template first.`)
+                        : err("blocked", `smoodly: "${record.slug}" has no draft to publish.`);
+                }
                 const fieldErrors = [];
                 for (const nodes of Object.values(draft.zones)) {
                     for (const node of nodes) {
@@ -108,27 +186,82 @@ export function createAdminOps(deps) {
                     }
                 }
                 if (fieldErrors.length > 0) {
-                    return err("validation", `smoodly: cannot publish "${slug}" — fix the listed fields first.`, fieldErrors);
+                    return err("validation", `smoodly: cannot publish "${record.slug}" — fix the listed fields first.`, fieldErrors);
                 }
-                const record = await pages.publish(slug);
-                effects?.revalidatePage?.(slug);
-                return ok(record);
+                const published = await pages.publish(id);
+                // The parent's cached unit lists its published children.
+                expirePages([published.id, published.parentId]);
+                return ok(published);
             }),
-            delete: (slug) => guard(async () => {
-                const record = await pages.getPage(slug);
-                if (record) {
-                    // Blocked only when this record IS the registration's singleton.
-                    // A record whose template is fixed but which sits at another slug
-                    // (the route file's slug was renamed under it) is reachable at no
-                    // URL — blocking it would strand it forever.
-                    const registration = config.registry.pages?.find((p) => p.schema.name === record.template);
-                    if (registration && registration.schema.slug === record.slug) {
-                        return err("blocked", `smoodly: "${slug}" is a fixed page owned by the "${record.template}" route file — remove the route file to remove it.`);
-                    }
+            delete: (id) => guard(async () => {
+                const record = await pages.getPage(id);
+                if (!record)
+                    return ok(null); // nothing to delete is not a failure
+                if (fixedNodeOf(record, config)) {
+                    return err("blocked", `smoodly: "${record.slug}" is owned by code — remove the registration to remove it.`);
                 }
-                await pages.deletePage(slug);
+                if (isHomeNode(record))
+                    return err("blocked", `smoodly: "${record.slug}" is the site root — it cannot be deleted.`);
+                await pages.deletePage(id);
+                // The cached unit is keyed by (locale, path) but tagged by the id
+                // found at the first miss; the parent's unit lists its children.
+                expirePages([id, record.parentId]);
                 return ok(null);
             }),
+            rename: (id, patch) => guard(async () => {
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                if (fixedNodeOf(record, config))
+                    return owned(record, "rename it in the registration");
+                if (isHomeNode(record) && patch.slug !== undefined) {
+                    return err("blocked", `smoodly: "${record.slug}" is the site root — its slug is the config's homePageSlug.`);
+                }
+                if (!config.locales.supported.includes(patch.locale)) {
+                    return err("validation", `smoodly: "${patch.locale}" is not a supported locale.`);
+                }
+                const renamed = await pages.rename(id, patch);
+                // Every descendant's path changed with this segment; the parent
+                // lists this node's title and path.
+                expirePages([...(await subtreeIds(id)), record.parentId]);
+                return ok(renamed);
+            }),
+            move: (id, to) => guard(async () => {
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                if (fixedNodeOf(record, config))
+                    return owned(record, "it stays at the root");
+                if (isHomeNode(record))
+                    return err("blocked", `smoodly: "${record.slug}" is the site root — it stays at the root.`);
+                if (to.parentId !== null) {
+                    const parent = await pages.getPage(to.parentId);
+                    if (!parent)
+                        return err("not_found", `smoodly: no page "${to.parentId}".`);
+                    const blocked = mountGuard(parent);
+                    if (blocked)
+                        return blocked;
+                }
+                const moved = await pages.move(id, to);
+                expirePages([...(await subtreeIds(id)), record.parentId, moved.parentId]);
+                return ok(moved);
+            }),
+            setTemplate: (id, template) => guard(async () => {
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                const fixed = fixedNodeOf(record, config);
+                if (fixed?.collection) {
+                    return err("blocked", `smoodly: "${record.slug}" is the "${fixed.collection}" collection's mount — its index page is a fixed registration.`);
+                }
+                const registration = openTemplate(template);
+                if (!registration)
+                    return err("validation", `smoodly: no page template named "${template}".`);
+                if (registration.schema.slug !== undefined) {
+                    return err("validation", `smoodly: page template "${template}" is fixed — Smoodly creates that page for you.`);
+                }
+                return ok(await pages.setTemplate(id, template));
+            }),
         },
         entries: {
             list: (collection) => guard(async () => ok(await entries.list(collection))),
@@ -161,7 +294,16 @@ export function createAdminOps(deps) {
                 await fanOut(id);
                 return ok(entry);
             }),
-            delete: (collection, id) => guard(async () => (await entries.delete(collection, id), ok(null))),
+            // 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), ok(null))),
+            move: (collection, id, to) => guard(async () => {
+                const moved = await entries.move(collection, id, to);
+                if (effects?.revalidate) {
+                    for (const entryId of await entrySubtreeIds(collection, id))
+                        effects.revalidate(entryTag(entryId));
+                }
+                return ok(moved);
+            }),
         },
         preview: {
             enable: () => guard(async () => (await effects?.draft?.enable(), ok(null))),

package/dist/admin/ops.d.ts

@@ -12,22 +12,46 @@ export type OpResult<T> = {
     ok: true;
     data: T;
 } | OpError;
+export type PageCreateInput = {
+    parentId: string | null;
+    /** The default-locale segment. */
+    slug: string;
+    /** Defaults to the slug. */
+    title?: string;
+    /** null = a folder. Only OPEN registrations may be named — fixed pages are materialized. */
+    template: string | null;
+};
+export type PageGetResult = {
+    record: PageRecord;
+    /** null for a folder. */
+    draft: PageTree | null;
+    /** locale → locale-relative CMS path (the `paths` index). */
+    paths: Record<string, string>;
+    /** locale → site URL, `href` applied server-side (the canvas and "View live" use these). */
+    urls: Record<string, string>;
+};
 export type AdminOps = {
     pages: {
+        /** Lists every node, materializing fixed pages and collection mounts first. */
         list(): Promise<OpResult<PageRecord[]>>;
-        get(slug: string): Promise<OpResult<{
-            record: PageRecord;
-            draft: PageTree;
-        }>>;
-        create(input: {
-            slug: string;
-            template: string;
-        }): Promise<OpResult<PageRecord>>;
-        saveDraft(slug: string, tree: PageTree): Promise<OpResult<{
+        get(id: string): Promise<OpResult<PageGetResult>>;
+        create(input: PageCreateInput): Promise<OpResult<PageRecord>>;
+        saveDraft(id: string, tree: PageTree): Promise<OpResult<{
             versionId: string;
         }>>;
-        publish(slug: string): Promise<OpResult<PageRecord>>;
-        delete(slug: string): Promise<OpResult<null>>;
+        publish(id: string): Promise<OpResult<PageRecord>>;
+        delete(id: string): Promise<OpResult<null>>;
+        rename(id: string, patch: {
+            locale: string;
+            slug?: string;
+            title?: string;
+        }): Promise<OpResult<PageRecord>>;
+        move(id: string, to: {
+            parentId: string | null;
+            index?: number;
+        }): Promise<OpResult<PageRecord>>;
+        /** "Add page here": a folder becomes a page. */
+        setTemplate(id: string, template: string): Promise<OpResult<PageRecord>>;
     };
     entries: {
         list(collection: string): Promise<OpResult<EntryRecord[]>>;
@@ -36,6 +60,10 @@ export type AdminOps = {
         save(collection: string, id: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
         setStatus(collection: string, id: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
         delete(collection: string, id: string): Promise<OpResult<null>>;
+        move(collection: string, id: string, to: {
+            parentId: string | null;
+            index?: number;
+        }): Promise<OpResult<EntryRecord>>;
     };
     preview: {
         enable(): Promise<OpResult<null>>;

package/dist/admin/serialize.d.ts

@@ -19,11 +19,18 @@ export type AdminCollection = {
     title: string;
     titleField?: string;
     fields: Record<string, AdminField>;
+    /** The mount's segment per supported locale (spec 2026-09-05 §3); absent = entries have no URL. */
+    path?: Record<string, string>;
+    /** How deep entries may nest; 1 = flat. */
+    depth: number;
 };
 export type AdminPageTemplate = {
     name: string;
     title: string;
+    /** The default-locale segment of a fixed registration; absent = open. */
     slug?: string;
+    /** The per-locale segments, only when the registration declares an object. */
+    slugs?: Record<string, string>;
     zones: Record<string, ZonePolicy>;
 };
 export type AdminRegistry = {
@@ -34,7 +41,9 @@ export type AdminRegistry = {
         default: string;
         supported: string[];
     };
-    /** Which slug the site root serves — see pagePath(). */
+    /** Which slug the site root serves. */
     homePageSlug: string;
+    /** How deep editors may nest pages; 1 = flat. */
+    pageDepth: number;
 };
 export declare function serializeAdminConfig(config: ResolvedConfig): AdminRegistry;

package/dist/admin/serialize.js

@@ -1,3 +1,6 @@
+import { fixedSlug } from "../page.js";
+import { collectionDepth } from "../collections.js";
+import { perLocaleSegments } from "../paths.js";
 function serializeDescriptor(d) {
     const out = { type: d.type };
     for (const [key, value] of Object.entries(d)) {
@@ -17,6 +20,7 @@ function serializeMap(map) {
     return Object.fromEntries(Object.entries(map ?? {}).map(([k, d]) => [k, serializeDescriptor(d)]));
 }
 export function serializeAdminConfig(config) {
+    const perLocale = (v) => perLocaleSegments(v, config.locales.supported);
     return {
         sections: (config.registry.sections ?? []).map(({ schema }) => {
             const s = schema;
@@ -33,17 +37,24 @@ export function serializeAdminConfig(config) {
         }),
         collections: (config.registry.collections ?? []).map((c) => ({
             name: c.name, title: c.title, titleField: c.titleField, fields: serializeMap(c.fields),
+            ...(c.path !== undefined ? { path: perLocale(c.path) } : {}),
+            depth: collectionDepth(c),
         })),
-        pages: (config.registry.pages ?? []).map(({ schema }) => {
+        pages: (config.registry.pages ?? [])
+            .filter(({ schema }) => schema.kind === "page")
+            .map(({ schema }) => {
             const p = schema;
+            const slug = fixedSlug(p, config.locales.default);
             return {
                 name: p.name,
                 title: p.title ?? p.name,
-                ...(p.slug !== undefined ? { slug: p.slug } : {}),
+                ...(slug !== undefined ? { slug } : {}),
+                ...(typeof p.slug === "object" && p.slug !== null ? { slugs: { ...p.slug } } : {}),
                 zones: p.zones ?? {},
             };
         }),
         locales: config.locales,
         homePageSlug: config.homePageSlug,
+        pageDepth: config.pageDepth,
     };
 }