smoodly 0.0.32 → 0.0.34

package/dist/admin/forms/slug-field.js

@@ -0,0 +1,39 @@
+// What a slug box does (spec 2026-09-28 ASCII slugs §4–§6): pure, shared
+// by the page dialogs, page Settings, the slug field widget and the entry
+// form. The grammar and the slugifier live in paths.ts.
+import { slugify } from "../../paths.js";
+/** The slug follows its title until the editor types a slug of their
+ *  own; a slug equal to what the previous title produced is still
+ *  "following". */
+export function followsTitle(slug, previousTitle) {
+    return slug === "" || slug === slugify(previousTitle);
+}
+/** Under a slug box whose source text makes no slug (§6). */
+export const NO_LETTERS_HINT = "This title has no letters a slug can use — type one, like novosti.";
+/** What a slug box holds after blur (§4): the slugified text; when
+ *  nothing survives, the text as typed if it has letters (Новости), so
+ *  publish can name the problem, and "" if it had none ("  ", "---"). */
+export function tidySlug(value) {
+    const tidy = slugify(value);
+    if (tidy !== "")
+        return tidy;
+    return /[\p{L}\p{N}]/u.test(value) ? value : "";
+}
+/** NO_LETTERS_HINT when `source` has text but no slug in it (§6). */
+export function slugHint(source) {
+    return typeof source === "string" && source.trim() !== "" && slugify(source) === "" ? NO_LETTERS_HINT : undefined;
+}
+/** The entry form's fields after `key` changed to `value` (§5): while the
+ *  row has never been published, an `f.slug({ from })` slug that still
+ *  follows the previous `from` value follows the new one. A published
+ *  row's slug is a live URL and never moves on its own. */
+export function withFollowingSlug(fields, key, value, from, neverPublished) {
+    const next = { ...fields, [key]: value };
+    if (from === undefined || key !== from || !neverPublished)
+        return next;
+    const slug = typeof fields.slug === "string" ? fields.slug : "";
+    const previous = typeof fields[from] === "string" ? fields[from] : "";
+    if (!followsTitle(slug, previous))
+        return next;
+    return { ...next, slug: slugify(typeof value === "string" ? value : "") };
+}

package/dist/admin/health.js

@@ -1,5 +1,6 @@
 import { entryFieldsIn } from "../entry-store.js";
 import { entryDrift, mergeVersions, pageDrift } from "./drift.js";
+import { isSegment } from "../paths.js";
 export function buildHealthReport(registry, pages, entries) {
     const documents = [];
     const def = registry.locales.default;
@@ -30,6 +31,14 @@ export function buildHealthReport(registry, pages, entries) {
             const lived = live[locale] ? entryDrift(registry, record.collection, { fields: live[locale] }) : [];
             for (const f of mergeVersions(draft, lived))
                 findings.push({ ...f, locale });
+            // The slug is the row's column, never versioned: one value, live once published. Drift
+            // leaves it out (a marker would flash while it is typed); publish checks the grammar.
+            if (collection?.fields.slug?.type === "slug" && row.slug !== null && row.slug !== "" && !isSegment(row.slug)) {
+                findings.push({
+                    kind: "misfit", path: "slug", subject: { scope: "collection", name: record.collection, field: "slug" },
+                    value: row.slug, detail: { type: "slug" }, draft: true, live: row.status === "published", locale,
+                });
+            }
         }
         if (findings.length === 0)
             continue;

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

@@ -4,15 +4,16 @@ import type { AdminOpAction } from "../ops.ts";
 import type { AuthConfig } from "../shell/session.ts";
 import type { ContentConfig } from "../../env.ts";
 /** `content` (optional) is the content project's public config for editing presence (spec 2026-09-26
- *  concurrency §5); absent — an app wired before it — presence is off and everything else works. */
+ *  concurrency §5), async because its space is asked of the database; absent or failed, presence
+ *  is off and everything else works. */
 export declare function createSmoodlyAdmin(input: {
     config: ResolvedConfig;
     op: AdminOpAction;
     auth: () => AuthConfig;
-    content?: () => ContentConfig;
+    content?: () => ContentConfig | Promise<ContentConfig>;
 }): {
     AdminPage: () => null;
     AdminLayout: ({ children }: {
         children: ReactNode;
-    }) => import("react").JSX.Element;
+    }) => Promise<import("react").JSX.Element>;
 };

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

@@ -3,7 +3,8 @@ import { serializeAdminConfig } from "../serialize.js";
 import { AdminApp } from "../shell/AdminApp.js";
 import { AdminStyles } from "../ui/theme.js";
 /** `content` (optional) is the content project's public config for editing presence (spec 2026-09-26
- *  concurrency §5); absent — an app wired before it — presence is off and everything else works. */
+ *  concurrency §5), async because its space is asked of the database; absent or failed, presence
+ *  is off and everything else works. */
 export function createSmoodlyAdmin(input) {
     const registry = serializeAdminConfig(input.config);
     /** The catch-all page only makes every /admin URL exist. The shell is
@@ -23,8 +24,18 @@ export function createSmoodlyAdmin(input) {
      *  suppressHydrationWarning: the theme boot script sets `data-theme`
      *  on this element before React hydrates, on purpose (no white flash
      *  for a dark-mode editor), so the attribute differs from the server's. */
-    function AdminLayout({ children }) {
-        return (_jsxs("div", { className: "sm-admin", suppressHydrationWarning: true, children: [_jsx(AdminStyles, {}), _jsx(AdminApp, { registry: registry, op: input.op, auth: input.auth(), content: input.content?.() }), children] }));
+    async function AdminLayout({ children }) {
+        // Presence is the one thing that needs it: a failed lookup (an unmigrated project, an
+        // unreachable database) is logged and turns presence off, so the shell still reaches
+        // sign-in, the schema notice or the admin-path ErrorPane.
+        let content;
+        try {
+            content = await input.content?.();
+        }
+        catch (e) {
+            console.error("smoodly: editing presence is off —", e instanceof Error ? e.message : e);
+        }
+        return (_jsxs("div", { className: "sm-admin", suppressHydrationWarning: true, children: [_jsx(AdminStyles, {}), _jsx(AdminApp, { registry: registry, op: input.op, auth: input.auth(), content: content }), children] }));
     }
     return { AdminPage, AdminLayout };
 }

package/dist/admin/ops-impl.js

@@ -1,12 +1,14 @@
-import { entryFieldsIn, entryTitleIn } from "../entry-store.js";
+import { entryErrors, entryFieldsIn, entryTitleIn } from "../entry-store.js";
+import { chainOf, isSegment, pagePathIn } from "../paths.js";
+import { servedAnchor } from "../anchors.js";
 import { distinctTags } from "../tags.js";
 import { can, isMemberRole, normalizeRole } from "../permissions.js";
 import { ASSET_COLLECTION } from "../media.js";
 import { adminHref, adminSlugTaken, isAdminSlug } from "../admin-path.js";
 import { affectedTargets, collectionTag, entryTag, pageTag, pagesTreeTag, globalTag } from "../revalidate.js";
-import { ensureFixedNodes, fixedNodeOf } from "./fixed-nodes.js";
+import { ensureFixedNodes, fixedNodeOf, fixedNodeSpecs } from "./fixed-nodes.js";
 import { ensureGlobalItems } from "./global-items.js";
-import { validateCustomNode, validateFields, validateNode } from "./validate.js";
+import { SLUG_GRAMMAR_MESSAGE, validateCustomNode, validateFields, validateNode } from "./validate.js";
 import { serializeAdminConfig } from "./serialize.js";
 import { entryDrift, pageDrift } from "./drift.js";
 import { publishErrors } from "./drift-copy.js";
@@ -15,7 +17,7 @@ import { CUSTOM_NODE_TYPE, customSchema } from "../custom/index.js";
 import { SETTINGS_KEY, CSS_KEY } from "../global.js";
 import { withDefaults } from "../field-defaults.js";
 import { elementSchemas } from "../richtext-walk.js";
-import { REDIRECT_PATH_MESSAGE, redirectPathProblem } from "./redirect-path.js";
+import { REDIRECT_PATH_MESSAGE, normalizeRedirectPath, redirectPathProblem } from "./redirect-path.js";
 import { SCHEMA_VERSION } from "../schema-version.js";
 import { draftToken, isDraftToken, StaleDraftError } from "../draft-token.js";
 const ok = (data) => ({ ok: true, data });
@@ -305,6 +307,66 @@ export function createAdminOps(deps) {
             ? err("blocked", `smoodly: pages cannot be created under "${nameOf(parent)}" — the "${fixed.collection}" collection owns that URL space.`)
             : null;
     };
+    /** Who wins a path in a locale over a node hanging on `own` — its chain root's owner key, `''` in the editors'
+     *  tree (spec 2026-09-29 anchored paths §5): the longest code address the path is or lies below, as the index
+     *  serves it (§2). Null when that is the node's own anchor, or the editors' tree. */
+    const ownerOf = (path, locale, own = "") => {
+        const served = servedAnchor(config.anchors, locale, path);
+        return served === "" || served === own ? null : fixedNodeSpecs(config).find((s) => s.key === served) ?? null;
+    };
+    const pathOpts = { locales: config.locales, homePageSlug: config.homePageSlug, addresses: config.addresses };
+    /** A record's own anchor: its chain root's owner key, `''` in the editors' tree. */
+    const anchorOf = async (record) => {
+        let r = record;
+        while (r.parentId !== null) {
+            const up = await pages.getPage(r.parentId);
+            if (!up)
+                break;
+            r = up;
+        }
+        return r.fixed ?? "";
+    };
+    /** The refusal for a write that would put the node or its subtree where another code address wins (spec 2026-09-29
+     *  anchored paths §5): the tree after `change`, derived in memory, checked against the config. Only a path the write
+     *  changes counts: a page already hidden in one locale may still be renamed in another, or off the address. */
+    const landsOnCode = async (id, change) => {
+        const before = await pages.listPages();
+        const was = new Map(before.map((r) => [r.id, r]));
+        const all = before.map((r) => (r.id === id ? change(r) : r));
+        const byId = new Map(all.map((r) => [r.id, r]));
+        // A move into its own subtree is a cycle here; the store refuses it with its own message.
+        for (let up = byId.get(id).parentId; up !== null; up = byId.get(up)?.parentId ?? null)
+            if (up === id)
+                return null;
+        const inSubtree = (r) => r.id === id || (r.parentId !== null && byId.has(r.parentId) && inSubtree(byId.get(r.parentId)));
+        for (const node of all.filter(inSubtree)) {
+            const own = chainOf(node, (x) => byId.get(x))[0].fixed ?? "";
+            for (const locale of Object.keys(node.locales)) {
+                const path = pagePathIn(node, (x) => byId.get(x), locale, pathOpts);
+                if (path === null || path === pagePathIn(was.get(node.id), (x) => was.get(x), locale, pathOpts))
+                    continue;
+                const owner = ownerOf(path, locale, own);
+                if (owner)
+                    return belongsTo(path, owner);
+            }
+        }
+        return null;
+    };
+    const belongsTo = (path, owner) => err("validation", `smoodly: "${path}" belongs to the ${owner.title} ${owner.collection ? "collection" : "page"}.`);
+    /** A parent where another code address wins — a page that sits there, hidden (§4) — takes no new children. */
+    const insideCode = async (parent) => {
+        const own = await anchorOf(parent);
+        for (const [locale, path] of Object.entries(await pages.pathsOf(parent.id))) {
+            const owner = ownerOf(path, locale, own);
+            if (owner)
+                return belongsTo(`/${owner.segments[locale]}`, owner);
+        }
+        return null;
+    };
+    /** A record whose owner no registration names any more: deleting it is all that is open (§5). */
+    const orphan = (record) => record.fixed && !fixedNodeOf(record, config)
+        ? err("blocked", `smoodly: "${nameOf(record)}" is no longer in code — delete it, or register it again.`)
+        : null;
     const guard = async (work) => {
         try {
             return await work();
@@ -313,6 +375,8 @@ export function createAdminOps(deps) {
             return classify(e);
         }
     };
+    /** Where a new child may not go: a collection's record, a record no longer in code, a page where a code address wins. */
+    const parentGuard = async (parent) => mountGuard(parent) ?? orphan(parent) ?? (await insideCode(parent));
     return {
         pages: {
             list: () => guard(async () => ok(await ensureFixedNodes(pages, config))),
@@ -350,17 +414,26 @@ export function createAdminOps(deps) {
                         return err("validation", `smoodly: page type "${input.template}" is fixed — Smoodly creates that page for you.`);
                     }
                 }
+                let parentPath = "";
+                let own = "";
                 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);
+                    const blocked = await parentGuard(parent);
                     if (blocked)
                         return blocked;
+                    parentPath = (await pages.pathsOf(parent.id))[input.locale];
+                    own = await anchorOf(parent);
                 }
-                else {
-                    // A root create competes with the code-owned slugs: make sure they exist first.
-                    await ensureFixedNodes(pages, config);
+                // A code address is code's whether or not its record has landed yet (spec 2026-09-29 anchored paths §5).
+                if (parentPath !== undefined) {
+                    // A root on the home slug serves "/" (isHomeNode), where a registered home page wins.
+                    const home = input.parentId === null && input.locale === def && input.slug === config.homePageSlug;
+                    const path = home ? "/" : `${parentPath}/${input.slug}`;
+                    const owner = ownerOf(path, input.locale, own);
+                    if (owner)
+                        return belongsTo(path, owner);
                 }
                 const created = await pages.createPage({
                     locale: input.locale, slug: input.slug, template: input.template, parentId: input.parentId,
@@ -445,6 +518,9 @@ export function createAdminOps(deps) {
                     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}".`);
+                const gone = orphan(record);
+                if (gone)
+                    return gone;
                 if (isHomeNode(record))
                     return err("blocked", `smoodly: "${nameOf(record)}" is the site root — it cannot be unpublished.`);
                 if (fixedNodeOf(record, config))
@@ -512,7 +588,8 @@ export function createAdminOps(deps) {
                 if (fixedNodeOf(record, config)) {
                     return err("blocked", `smoodly: "${nameOf(record)}" is owned by code — remove the registration to remove it.`);
                 }
-                if (isHomeNode(record))
+                // A home page no longer in code may go too (§5): the registration that serves "/" now lands after it.
+                if (isHomeNode(record) && !orphan(record))
                     return err("blocked", `smoodly: "${nameOf(record)}" 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
@@ -525,6 +602,9 @@ export function createAdminOps(deps) {
                 const record = await pages.getPage(id);
                 if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
+                const gone = orphan(record);
+                if (gone)
+                    return gone;
                 if (fixedNodeOf(record, config))
                     return owned(record, "rename it in the registration");
                 if (isHomeNode(record) && patch.slug !== undefined) {
@@ -535,6 +615,12 @@ export function createAdminOps(deps) {
                     return unsupported;
                 if (record.parentId === null && patch.slug !== undefined && adminSlug(patch.slug))
                     return slugTaken();
+                if (patch.slug !== undefined) {
+                    const slug = patch.slug;
+                    const lands = await landsOnCode(id, (r) => r.locales[patch.locale] ? { ...r, locales: { ...r.locales, [patch.locale]: { ...r.locales[patch.locale], slug } } } : r);
+                    if (lands)
+                        return lands;
+                }
                 const { redirect, ...rest } = patch;
                 const renamed = await pages.rename(id, rest, by, { redirect: redirect ?? true });
                 // Every descendant's path changed with this segment; the parent
@@ -547,6 +633,9 @@ export function createAdminOps(deps) {
                 const record = await pages.getPage(id);
                 if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
+                const gone = orphan(record);
+                if (gone)
+                    return gone;
                 if (to.parentId === null && Object.values(record.locales).some((row) => adminSlug(row.slug)))
                     return slugTaken();
                 if (to.parentId !== null) {
@@ -559,10 +648,16 @@ export function createAdminOps(deps) {
                     const parent = await pages.getPage(to.parentId);
                     if (!parent)
                         return err("not_found", `smoodly: no page "${to.parentId}".`);
-                    const blocked = mountGuard(parent);
+                    // A reorder among a holding page's children is no new placement.
+                    const blocked = to.parentId === record.parentId ? null : await parentGuard(parent);
                     if (blocked)
                         return blocked;
                 }
+                if (to.parentId !== record.parentId) {
+                    const lands = await landsOnCode(id, (r) => ({ ...r, parentId: to.parentId }));
+                    if (lands)
+                        return lands;
+                }
                 const { redirect, ...dest } = to;
                 const moved = await pages.move(id, dest, { redirect: redirect ?? true });
                 expirePages([...(await subtreeIds(id)), record.parentId, moved.parentId]);
@@ -573,6 +668,9 @@ export function createAdminOps(deps) {
                 const record = await pages.getPage(id);
                 if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
+                const gone = orphan(record);
+                if (gone)
+                    return gone;
                 const fixed = fixedNodeOf(record, config);
                 if (fixed?.collection) {
                     return err("blocked", `smoodly: "${nameOf(record)}" is the "${fixed.collection}" collection's mount — its index page is a fixed registration.`);
@@ -591,8 +689,16 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale) ?? supportedLocale(options?.from);
                 if (unsupported)
                     return unsupported;
-                if (!(await pages.getPage(id)))
+                const record = await pages.getPage(id);
+                if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
+                const gone = orphan(record);
+                if (gone)
+                    return gone;
+                // The new locale copies the source's slug: it may not land where code wins the address (spec 2026-09-29 anchored paths §5).
+                const lands = await landsOnCode(id, (r) => r.locales[options.from] && !r.locales[locale] ? { ...r, locales: { ...r.locales, [locale]: r.locales[options.from] } } : r);
+                if (lands)
+                    return lands;
                 // 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 }, by);
                 expireTree();
@@ -605,6 +711,9 @@ export function createAdminOps(deps) {
                 const record = await pages.getPage(id);
                 if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
+                const gone = orphan(record);
+                if (gone)
+                    return gone;
                 if (fixedNodeOf(record, config))
                     return owned(record, "it exists in every locale");
                 if (isHomeNode(record))
@@ -675,7 +784,27 @@ export function createAdminOps(deps) {
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const entry = await entries.update(collection, id, locale, fields, by, token, { redirect: options?.redirect ?? true });
+                // A published row's slug is its live address and is never versioned, so this
+                // save is its publish: the grammar holds here (spec 2026-09-28 ASCII slugs §3).
+                const slug = typeof fields.slug === "string" && fields.slug !== "" ? fields.slug : null;
+                if (descriptors.slug !== undefined && (slug === null || !isSegment(slug))) {
+                    const row = (await entries.get(collection, id))?.locales[locale];
+                    if (row?.status === "published" && row.slug !== null && row.slug !== slug) {
+                        const message = slug === null ? "Required while the entry is published." : SLUG_GRAMMAR_MESSAGE;
+                        return err("validation", "Some fields need attention.", [{ field: "slug", message }]);
+                    }
+                }
+                let entry;
+                try {
+                    entry = await entries.update(collection, id, locale, fields, by, token, { redirect: options?.redirect ?? true });
+                }
+                catch (e) {
+                    // A sibling's slug is the slug field's problem, not the whole draft's (spec 2026-09-28 ASCII slugs §5).
+                    if (e instanceof Error && e.message === entryErrors.slugTaken(collection).message) {
+                        return err("validation", "Some fields need attention.", [{ field: "slug", message: "Another entry here already uses this slug." }]);
+                    }
+                    throw e;
+                }
                 await fanOut(id);
                 expireCollection(collection);
                 return ok(entry);
@@ -1051,7 +1180,8 @@ export function createAdminOps(deps) {
                 }
                 return ok(out.sort((a, b) => a.path.localeCompare(b.path)));
             }),
-            add: (locale, path, target) => guard(async () => {
+            add: (locale, typed, target) => guard(async () => {
+                const path = normalizeRedirectPath(typed);
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
@@ -1073,7 +1203,7 @@ export function createAdminOps(deps) {
                 const unsupported = supportedLocale(locale);
                 if (unsupported)
                     return unsupported;
-                await pages.removeRedirect(locale, path);
+                await pages.removeRedirect(locale, path); // the stored address, as list gave it
                 return ok(null);
             }),
         },

package/dist/admin/redirect-path.d.ts

@@ -1,3 +1,6 @@
+/** The one stored form of an old address (the renderer decodes a request the same way):
+ *  a pasted `/s%C3%A4%C3%A4` and a typed `/sää` are one row. Checked after this. */
+export declare const normalizeRedirectPath: (path: string) => string;
 export type RedirectPathProblem = "empty" | "leading-slash" | "root" | "trailing-slash" | "double-slash" | "whitespace" | "query-or-hash" | "admin" | "extension";
 export declare const REDIRECT_PATH_MESSAGE: Record<RedirectPathProblem, string>;
 export declare function redirectPathProblem(path: string, opts: {

package/dist/admin/redirect-path.js

@@ -1,3 +1,12 @@
+// The old-address check for a redirect by hand (spec 2026-09-26
+// redirects §5). Pure: the Add dialog asks it for instant feedback and
+// the op asks it again. The shape is "a path the catch-all will see":
+// segments need not be slugs — old sites had capitals, dots and
+// underscores — but nothing here may be unreachable by construction.
+import { decodeSegment } from "../paths.js";
+/** The one stored form of an old address (the renderer decodes a request the same way):
+ *  a pasted `/s%C3%A4%C3%A4` and a typed `/sää` are one row. Checked after this. */
+export const normalizeRedirectPath = (path) => path.split("/").map(decodeSegment).join("/");
 export const REDIRECT_PATH_MESSAGE = {
     empty: "Enter the old address.",
     "leading-slash": "Start with a slash: /old-address.",

package/dist/admin/serialize.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedConfig } from "../config.ts";
+import type { Addresses } from "../addresses.ts";
 import type { Descriptor } from "../fields.ts";
 import type { ZonePolicy } from "../zones.ts";
 export type AdminField = Record<string, unknown> & {
@@ -80,6 +81,8 @@ export type AdminRegistry = {
     css: boolean;
     /** Which slug the site root serves. */
     homePageSlug: string;
+    /** Code-owned addresses by owner key (spec 2026-09-29 nested paths §3). */
+    addresses: Addresses;
     /** How deep editors may nest pages; 1 = flat. */
     pageDepth: number;
     /** Upload limits, so a widget can refuse a file before the round trip. */

package/dist/admin/serialize.js

@@ -106,6 +106,7 @@ export function serializeAdminConfig(config) {
         locales: config.locales,
         ...(config.timeZone !== undefined ? { timeZone: config.timeZone } : {}),
         homePageSlug: config.homePageSlug,
+        addresses: config.addresses,
         pageDepth: config.pageDepth,
         media: { maxSize: config.media.maxSize, accept: [...config.media.accept] },
         adminPath: config.admin.path,

package/dist/admin/shell/AddRedirectModal.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // before the op repeats the check, and the target — one type-ahead over
 // every page and routed entry live in the locale, "Title · /path".
 import { useState } from "react";
-import { REDIRECT_PATH_MESSAGE, redirectPathProblem } from "../redirect-path.js";
+import { REDIRECT_PATH_MESSAGE, normalizeRedirectPath, redirectPathProblem } from "../redirect-path.js";
 import { Combobox } from "../ui/Combobox.js";
 import { Modal } from "../ui/Modal.js";
 import { Banner, Button, Field } from "../ui/primitives.js";
@@ -15,7 +15,7 @@ export function AddRedirectModal({ locale, registry, targets, onClose, onAdd })
     const [target, setTarget] = useState(null);
     const [error, setError] = useState(null);
     const [busy, setBusy] = useState(false);
-    const problem = redirectPathProblem(path, { adminPath: registry.adminPath, multilingual: registry.locales.supported.length > 1 });
+    const problem = redirectPathProblem(normalizeRedirectPath(path), { adminPath: registry.adminPath, multilingual: registry.locales.supported.length > 1 });
     const picked = target ? targets.find((t) => t.target.kind === target.kind && t.target.id === target.id) : undefined;
     const submit = async (e) => {
         e.preventDefault();

package/dist/admin/shell/EntryForm.js

@@ -48,8 +48,11 @@ import { unsetAtPath } from "../field-paths.js";
 import { usePresence, usePresenceState, useSavedElsewhere, useTrackPresence } from "./presence-context.js";
 import { editorsOf } from "./presence.js";
 import { PresenceLine } from "../ui/PresenceLine.js";
+import { slugHint, tidySlug, withFollowingSlug } from "../forms/slug-field.js";
 /** A stable empty map for the hooks that run before the "no such collection" return. */
 const NO_FIELDS = {};
+/** True while the entry's slug box has focus: its field wrapper carries the path. */
+const slugBoxFocused = () => typeof document !== "undefined" && document.activeElement instanceof HTMLElement && document.activeElement.closest('[data-sm-path="slug"]') !== null;
 export function EntryForm({ ops, registry, collection, id }) {
     const adminHref = useAdminHref();
     const meta = registry.collections.find((c) => c.name === collection);
@@ -62,6 +65,9 @@ export function EntryForm({ ops, registry, collection, id }) {
     const [parentLocales, setParentLocales] = useState(registry.locales.supported);
     const [notice, setNotice] = useState(null);
     const [fieldErrors, setFieldErrors] = useState({});
+    /** A refused save's field errors (spec 2026-09-28 ASCII slugs): kept apart from the publish refusal's, which
+     *  revalidation shrinks — a sibling's slug is no rule the form can check. Cleared by the next save that lands. */
+    const [saveErrors, setSaveErrors] = useState({});
     const [adding, setAdding] = useState(false);
     const [reloadKey, setReloadKey] = useState(0);
     /** An edit since the last save ack — Publish wakes on it, before the autosave runs (spec 2026-09-13 publish flow §2). */
@@ -84,6 +90,8 @@ export function EntryForm({ ops, registry, collection, id }) {
     const confirmedSlug = useRef(null);
     /** The confirm's "Redirect the old address" answer for the save that follows it (spec 2026-09-26 redirects §6). */
     const redirectRef = useRef(true);
+    /** A live slug change the autosave held back while its box had focus (spec 2026-09-28 ASCII slugs §4). */
+    const slugHeld = useRef(false);
     // The page editor's controller: debounced, retrying, flushable (spec 2026-09-14 §3).
     /** The token of the row on screen — what every guarded op sends (spec 2026-09-26 concurrency §1). */
     const token = () => { const row = recordRef.current?.locales[locale]; return row ? draftToken(row) : null; };
@@ -98,7 +106,23 @@ export function EntryForm({ ops, registry, collection, id }) {
             // A published entry's slug is a live URL: one confirm at the save, Cancel restores it (members management §5).
             const row = recordRef.current?.locales[locale];
             const stored = row?.slug ?? null;
-            const next = typeof value.slug === "string" ? value.slug : null;
+            let next = typeof value.slug === "string" ? value.slug : null;
+            // A live slug changes when its box loses focus, never at a pause mid-typing (spec
+            // 2026-09-28 ASCII slugs §4): until then the rest of the draft saves with the live slug.
+            if (liveUrlChanges({ status: row?.status, from: stored, to: next }) && slugBoxFocused()) {
+                slugHeld.current = true;
+                value = { ...value, slug: stored };
+                next = stored;
+            }
+            // Tidied before the question, so the dialog asks about the URL that is saved.
+            if (next !== null && liveUrlChanges({ status: row?.status, from: stored, to: next })) {
+                const tidy = tidySlug(next);
+                if (tidy !== next) {
+                    next = tidy;
+                    value = { ...value, slug: tidy };
+                    setFields((f) => ({ ...(f ?? {}), slug: tidy }));
+                }
+            }
             if (next !== confirmedSlug.current && liveUrlChanges({ status: row?.status, from: stored, to: next })) {
                 const current = recordRef.current;
                 const subject = current && meta ? { name: entryTitle(current, meta, registry, locale), path: slugPrefix && stored ? `${slugPrefix}${stored}` : null } : undefined;
@@ -116,13 +140,19 @@ export function EntryForm({ ops, registry, collection, id }) {
             if (r.ok) {
                 redirectRef.current = true;
                 setRecord(r.data);
+                setSaveErrors({});
                 presence?.announce(target, r.data.locales[locale]?.draftSavedAt ?? null);
             }
             else if (isStale(r))
                 setStale(staleInfoOf(r));
+            // A refused save (a sibling's slug, a live slug outside the grammar) marks its fields until a save lands.
+            else if (r.code === "validation" && r.fields)
+                setSaveErrors(Object.fromEntries(r.fields.map((f) => [f.field, f.message])));
             return r;
         },
-        onSaved: () => setDirty(false),
+        // A held slug is still unsaved: the form stays dirty until its box loses focus.
+        onSaved: () => { if (!slugHeld.current)
+            setDirty(false); },
     });
     // Reload and close ask only while a save is pending or in flight.
     useLeaveGuard(dirty || saveState !== "saved");
@@ -143,6 +173,8 @@ export function EntryForm({ ops, registry, collection, id }) {
         let cancelled = false;
         setFields(null);
         setFieldErrors({});
+        setSaveErrors({});
+        slugHeld.current = false;
         setDirty(false);
         setStale(null);
         setTouched(false);
@@ -167,7 +199,7 @@ export function EntryForm({ ops, registry, collection, id }) {
     const findings = useMemo(() => (fields && record?.locales[locale]
         ? entryDrift(registry, collection, { fields, shared: record.fields, own: record.locales[locale].fields })
         : []), [fields, record, locale, registry, collection]);
-    const markerErrors = useMemo(() => ({ ...misfitErrors(findings), ...fieldErrors }), [findings, fieldErrors]);
+    const markerErrors = useMemo(() => ({ ...misfitErrors(findings), ...fieldErrors, ...saveErrors }), [findings, fieldErrors, saveErrors]);
     if (!meta)
         return _jsx("p", { style: { padding: 32 }, children: "No such collection." });
     const row = record?.locales[locale];
@@ -418,8 +450,16 @@ export function EntryForm({ ops, registry, collection, id }) {
         return record ? { name: heading, path: slugPrefix && slug ? `${slugPrefix}${slug}` : null } : undefined;
     };
     const present = record ? registry.locales.supported.filter((l) => record.locales[l]) : [locale];
-    const widget = ([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: fields?.[key], errors: markerErrors, refOptions: refTargets[key] ? refOptions[refTargets[key]] : undefined, suggestions: tagSuggestions[key], prefix: d.type === "slug" ? slugPrefix : undefined, mark: multilingual && !localeKeys.includes(key) ? _jsx(UnlocalizedMark, {}) : undefined, onChange: (value) => {
-            setFields((f) => ({ ...(f ?? {}), [key]: value }));
+    // f.slug({ from }) (spec 2026-09-28 ASCII slugs §5–§6): the field a never-published slug follows.
+    const declaredFrom = meta.fields.slug?.from;
+    const slugFrom = typeof declaredFrom === "string" ? declaredFrom : undefined;
+    const widget = ([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: fields?.[key], errors: markerErrors, refOptions: refTargets[key] ? refOptions[refTargets[key]] : undefined, suggestions: tagSuggestions[key], prefix: d.type === "slug" ? slugPrefix : undefined, hint: key === "slug" && slugFrom && !fields?.slug ? slugHint(fields?.[slugFrom]) : undefined, onBlur: key === "slug" ? () => { if (slugHeld.current) {
+            slugHeld.current = false;
+            setDirty(true);
+            mark();
+        } } : undefined, mark: multilingual && !localeKeys.includes(key) ? _jsx(UnlocalizedMark, {}) : undefined, onChange: (value) => {
+            const neverPublished = (recordRef.current?.locales[locale]?.publishedVersionId ?? null) === null;
+            setFields((f) => withFollowingSlug(f ?? {}, key, value, slugFrom, neverPublished));
             setDirty(true);
             setTouched(true);
             mark();
@@ -431,7 +471,7 @@ export function EntryForm({ ops, registry, collection, id }) {
                                 trailing: multilingual && (_jsx(LocaleSwitcher, { registry: registry, present: present, parentLocales: parentLocales, value: locale, adding: adding, onSwitch: (l) => { void switchLocale(l); }, onAdd: (l) => void doAddLocale(l) })),
                             },
                             { label: heading },
-                        ] }) }), right: _jsxs(_Fragment, { children: [(touched || saveState === "error") && _jsx(SaveIndicator, { state: saveState, pending: dirty }), urls[locale] && (_jsx(LinkButton, { icon: true, href: urls[locale], target: "_blank", rel: "noreferrer", "aria-label": "View live", title: "View live \u2014 opens the site route. While the admin's draft-mode cookie is on, this shows the DRAFT \u2014 open it in a private window to see what visitors see.", children: _jsx(Eye, { size: 16, strokeWidth: 1.5, "aria-hidden": "true" }) })), _jsx(PublishControl, { status: status, pending: dirty || saveState !== "saved", busy: busy, flash: published, disabled: !row, onPublish: () => { void publish(); }, onUnpublish: () => { void unpublish(); }, onDiscard: () => { void discard(); }, onHistory: () => { void openHistory(); } })] }) }), history && row && (_jsx(HistoryModal, { rows: history, draftId: row.draftVersionId, onSelect: (v) => { void loadSnapshot(v); }, onClose: () => setHistory(null), onRestore: restore, render: (versionId) => snapshot?.id === versionId ? (_jsx("fieldset", { disabled: true, className: "sm-history__form", children: Object.entries(meta.fields).map(([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: snapshot.fields[key], refOptions: refTargets[key] ? refOptions[refTargets[key]] : undefined, prefix: d.type === "slug" ? slugPrefix : undefined, onChange: () => { } }, key))) })) : _jsx("p", { className: "sm-hint", style: { padding: 16 }, children: "Loading\u2026" }) })), _jsx(PresenceLine, { names: editorsOf(others, target), noun: "entry" }), stale && _jsx(StaleBanner, { info: stale, onReload: loadTheirs }), _jsx(DriftNotice, { draft: findings, live: liveFindings }), _jsxs("div", { className: "sm-editor", inert: stale ? true : undefined, children: [_jsxs("div", { className: "sm-form", ref: formRef, children: [notice && (_jsxs(Banner, { tone: notice.tone, onDismiss: () => setNotice(null), children: [_jsx("p", { style: { margin: 0 }, children: notice.text }), _jsx(FieldErrorList, { fields: notice.fields ?? [], onReveal: (path) => { if (formRef.current)
+                        ] }) }), right: _jsxs(_Fragment, { children: [(touched || saveState === "error" || saveState === "refused") && _jsx(SaveIndicator, { state: saveState, pending: dirty }), urls[locale] && (_jsx(LinkButton, { icon: true, href: urls[locale], target: "_blank", rel: "noreferrer", "aria-label": "View live", title: "View live \u2014 opens the site route. While the admin's draft-mode cookie is on, this shows the DRAFT \u2014 open it in a private window to see what visitors see.", children: _jsx(Eye, { size: 16, strokeWidth: 1.5, "aria-hidden": "true" }) })), _jsx(PublishControl, { status: status, pending: dirty || saveState !== "saved", busy: busy, flash: published, disabled: !row, onPublish: () => { void publish(); }, onUnpublish: () => { void unpublish(); }, onDiscard: () => { void discard(); }, onHistory: () => { void openHistory(); } })] }) }), history && row && (_jsx(HistoryModal, { rows: history, draftId: row.draftVersionId, onSelect: (v) => { void loadSnapshot(v); }, onClose: () => setHistory(null), onRestore: restore, render: (versionId) => snapshot?.id === versionId ? (_jsx("fieldset", { disabled: true, className: "sm-history__form", children: Object.entries(meta.fields).map(([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: snapshot.fields[key], refOptions: refTargets[key] ? refOptions[refTargets[key]] : undefined, prefix: d.type === "slug" ? slugPrefix : undefined, onChange: () => { } }, key))) })) : _jsx("p", { className: "sm-hint", style: { padding: 16 }, children: "Loading\u2026" }) })), _jsx(PresenceLine, { names: editorsOf(others, target), noun: "entry" }), stale && _jsx(StaleBanner, { info: stale, onReload: loadTheirs }), _jsx(DriftNotice, { draft: findings, live: liveFindings }), _jsxs("div", { className: "sm-editor", inert: stale ? true : undefined, children: [_jsxs("div", { className: "sm-form", ref: formRef, children: [notice && (_jsxs(Banner, { tone: notice.tone, onDismiss: () => setNotice(null), children: [_jsx("p", { style: { margin: 0 }, children: notice.text }), _jsx(FieldErrorList, { fields: notice.fields ?? [], onReveal: (path) => { if (formRef.current)
                                             revealField(formRef.current, path); } })] })), absent ? (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: [_jsxs("p", { children: ["This entry doesn't exist in ", locale, " yet. Adding it copies the ", entrySourceLocale(record, registry), " fields as the first ", locale, " draft."] }), _jsxs("div", { style: { display: "flex", gap: 8 }, children: [_jsxs(Button, { onClick: () => void doAddLocale(locale), disabled: adding || !parentLocales.includes(locale), title: parentLocales.includes(locale) ? undefined : `add ${locale} to the parent first`, children: ["Add ", locale] }), _jsxs(Button, { variant: "secondary", onClick: () => { void switchLocale(entrySourceLocale(record, registry)); }, children: ["Back to ", entrySourceLocale(record, registry)] })] })] })) : fields !== null ? (_jsxs(_Fragment, { children: [Object.entries(meta.fields).map(widget), _jsx(OrphanFields, { orphans: findings, onClear: (path) => {
                                             setFields((f) => unsetAtPath(f ?? {}, path));
                                             setDirty(true);

package/dist/admin/shell/GlobalForm.js

@@ -318,6 +318,6 @@ export function GlobalForm({ ops, registry, name }) {
                                 trailing: multilingual && (_jsx(LocaleSwitcher, { registry: registry, present: registry.locales.supported, parentLocales: [], value: locale, adding: false, onSwitch: (l) => { void switchLocale(l); }, onAdd: () => undefined })),
                             },
                             { label: item.title },
-                        ] }) }), right: _jsxs(_Fragment, { children: [(touched || saveState === "error") && _jsx(SaveIndicator, { state: saveState, pending: dirty }), _jsx(PublishControl, { status: status, pending: dirty || saveState !== "saved", busy: busy, flash: published, disabled: !row, onPublish: () => { void publish(); }, onUnpublish: () => { void unpublish(); }, onDiscard: () => { void discard(); }, onHistory: () => { void openHistory(); } })] }) }), history && row && (_jsx(HistoryModal, { rows: history, draftId: row.draftVersionId, onSelect: (v) => { void loadSnapshot(v); }, onClose: () => setHistory(null), onRestore: restore, render: (versionId) => snapshot?.id === versionId ? (_jsxs("fieldset", { disabled: true, className: "sm-history__form", children: [_jsx(GlobalFields, { item: item, groups: contentGroups, fields: snapshot.fields, refOptions: refOptions, multilingual: multilingual, onChange: () => { } }), settingGroups.length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionLabel, { children: "Settings" }), _jsx(GlobalFields, { item: item, groups: settingGroups, fields: snapshot.fields, refOptions: refOptions, multilingual: multilingual, onChange: () => { } })] }))] })) : _jsx("p", { className: "sm-hint", style: { padding: 16 }, children: "Loading\u2026" }) })), _jsx(PresenceLine, { names: editorsOf(others, target), noun: "item" }), stale && _jsx(StaleBanner, { info: stale, onReload: loadTheirs }), _jsx(DriftNotice, { draft: findings, live: liveFindings }), _jsxs("div", { className: "sm-editor", inert: stale ? true : undefined, children: [_jsxs("div", { className: "sm-form", ref: formRef, children: [notice && (_jsxs(Banner, { tone: notice.tone, onDismiss: () => setNotice(null), children: [_jsx("p", { style: { margin: 0 }, children: notice.text }), _jsx(FieldErrorList, { fields: notice.fields ?? [], onReveal: (path) => { if (formRef.current)
+                        ] }) }), right: _jsxs(_Fragment, { children: [(touched || saveState === "error" || saveState === "refused") && _jsx(SaveIndicator, { state: saveState, pending: dirty }), _jsx(PublishControl, { status: status, pending: dirty || saveState !== "saved", busy: busy, flash: published, disabled: !row, onPublish: () => { void publish(); }, onUnpublish: () => { void unpublish(); }, onDiscard: () => { void discard(); }, onHistory: () => { void openHistory(); } })] }) }), history && row && (_jsx(HistoryModal, { rows: history, draftId: row.draftVersionId, onSelect: (v) => { void loadSnapshot(v); }, onClose: () => setHistory(null), onRestore: restore, render: (versionId) => snapshot?.id === versionId ? (_jsxs("fieldset", { disabled: true, className: "sm-history__form", children: [_jsx(GlobalFields, { item: item, groups: contentGroups, fields: snapshot.fields, refOptions: refOptions, multilingual: multilingual, onChange: () => { } }), settingGroups.length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionLabel, { children: "Settings" }), _jsx(GlobalFields, { item: item, groups: settingGroups, fields: snapshot.fields, refOptions: refOptions, multilingual: multilingual, onChange: () => { } })] }))] })) : _jsx("p", { className: "sm-hint", style: { padding: 16 }, children: "Loading\u2026" }) })), _jsx(PresenceLine, { names: editorsOf(others, target), noun: "item" }), stale && _jsx(StaleBanner, { info: stale, onReload: loadTheirs }), _jsx(DriftNotice, { draft: findings, live: liveFindings }), _jsxs("div", { className: "sm-editor", inert: stale ? true : undefined, children: [_jsxs("div", { className: "sm-form", ref: formRef, children: [notice && (_jsxs(Banner, { tone: notice.tone, onDismiss: () => setNotice(null), children: [_jsx("p", { style: { margin: 0 }, children: notice.text }), _jsx(FieldErrorList, { fields: notice.fields ?? [], onReveal: (path) => { if (formRef.current)
                                             revealField(formRef.current, path); } })] })), record && (_jsxs("p", { className: "sm-hint", children: [pages.size === 0 ? "Not placed on any page yet." : `Used on ${pages.size} page${pages.size === 1 ? "" : "s"}: `, [...pages].map((id, i) => (_jsxs("span", { children: [i > 0 && ", ", _jsx("a", { href: adminHref(`/pages/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`), children: id })] }, id)))] })), fields !== null ? (_jsxs(_Fragment, { children: [_jsx(GlobalFields, { item: item, groups: contentGroups, fields: fields, errors: markerErrors, refOptions: refOptions, multilingual: multilingual, onChange: onChange }), settingGroups.length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionLabel, { children: "Settings" }), _jsx(GlobalFields, { item: item, groups: settingGroups, fields: fields, errors: markerErrors, refOptions: refOptions, multilingual: multilingual, onChange: onChange })] })), _jsx(OrphanFields, { orphans: findings, onClear: clearOrphan })] })) : !notice && _jsx("p", { style: { color: "var(--text-muted)" }, children: "Loading\u2026" })] }), _jsx(ResizeHandle, {}), _jsx("aside", { className: "sm-inspector", children: record && row && (_jsxs("div", { className: "sm-card", children: [_jsx(SectionLabel, { children: "Document info" }), _jsx(InfoRow, { label: "Kind", value: item.section !== undefined ? `Visual · ${item.section}` : "Fields" }), _jsx(InfoRow, { label: "Updated", value: updatedLine(row.updatedAt, row.updatedBy) }), _jsx(InfoRow, { label: "ID", value: record.id, mono: true })] })) })] })] }));
 }