smoodly 0.0.32 → 0.0.34

package/README.md

@@ -601,6 +601,28 @@ Implemented:
   `cli-transfer`, `space-transfer.supabase`,
   `examples/site/e2e/transfer.spec.ts`.
 
+- Nested addresses (spec 2026-09-29 nested paths, schema v5): a
+  collection `path` or fixed `slug` may have several parts
+  (`company/news`), each checked as a segment, a locale the map omits
+  filled from the default. `src/addresses.ts` turns the registry into
+  code addresses by owner key (`collection:<name>`, `page:<name>`),
+  `config.addresses`; `pages.fixed` names a code-owned record's owner,
+  the record stays a root with the last part as its slug, and its path
+  comes from the config. Anchored paths (spec 2026-09-29 anchored
+  paths): each `paths` row names its anchor (`pages.fixed`'s owner key,
+  `''` for the editors' tree) and stores only the editors' part; the
+  path index (`src/anchors.ts`, both adapters, `config.anchors`) joins
+  the address from the config, so a code change needs no write and the
+  live site does one lookup per request. `ensureFixedNodes` finds
+  records by owner and creates them over an editor's page, never
+  adopting it: code wins the address. The ops refuse a page write onto
+  or below a code address naming the owner; the Pages list flags an
+  editor's page there and a record no longer in code (delete only).
+  Tests: `addresses`, `anchors`, the path index contract,
+  `admin-fixed-nodes`, `admin-ops-addresses`, `admin-pages-tree`,
+  `site`, the page and entry store contracts,
+  `examples/site/e2e/entries.spec.ts`.
+
 Not yet: canvas drag-and-drop (list fields, the outline, manual
 collections and the pages tree drag since 2026-09-09 — spec
 `docs/superpowers/specs/2026-09-09-drag-and-drop-design.md`), undo/redo, sample/placeholder content
@@ -627,6 +649,56 @@ after both are on the registry. From the repo root:
 `prepublishOnly` rebuilds each package. The Claude Code skill
 `.claude/skills/releasing-smoodly` carries the same order with its checks.
 
+## Follow-ups (logged 2026-09-29, nested collection paths)
+
+- `homePageSlug` is compared with a collection's whole default path, so
+  `"home/news"` passes boot with the home page as its middle part: the
+  home record serves `/`, so `/home` is no page while `/home/news` is.
+  Refuse an address whose first part is the home slug if a site trips on
+  it.
+- An owner key that changes in code — a fixed page that becomes a
+  collection's index page (`page:x` → `collection:y`), a collection
+  renamed — leaves the old record "No longer in code" with its
+  sections and history, and a new empty record takes the address.
+  Carry the record over (rewrite `fixed`) when a site asks.
+- An index page registration renamed (`a` → `b`) leaves the record on
+  template `a`: `ensureFixedNodes` only handles a folder gaining an
+  index page, and `setTemplate` refuses a record that has one.
+- The rename/move confirm's code-address line names the addresses in
+  the selected locale only, though a move re-paths every locale; the
+  Pages list's conflict notice is one ellipsized line (the whole text
+  on hover), and an editor's flagged page cannot be moved from the
+  notice itself.
+- An index page removed from code leaves the collection's record with
+  its template (spec amendment 3): the record keeps rendering as that
+  page type's stale name until an editor or a later pass clears it.
+- The code-owned part of a URL is never stored (spec 2026-09-29 anchored
+  paths): a row names its anchor and the index joins the config's
+  address, so an address changed in code moves its URLs at the deploy
+  with no write, and the old URLs need a `next.config.ts` redirect.
+  Rows written before schema v5's anchors (none installed) would sit
+  under `''` and go dark under a code address until re-saved.
+- `listLive` / `listRedirects` on Supabase read at most PostgREST's
+  `max_rows` (1000) per locale, as before, now ordered by (anchor, path)
+  and sorted by URL in JS; page them if a locale's redirect list grows
+  past it.
+- Older than this plan: the Supabase `addLocale` rollback on
+  `alreadyInLocale` (`supabase-store.ts`, the insertLocale catch)
+  deletes the racing WINNER's locale row and versions. Two admins
+  adding one locale at once converge on the next list; fix by rolling
+  back only what this call inserted.
+
+## Follow-ups (logged 2026-09-29, pre-install fixes)
+
+- Content health lists an entry slug outside the grammar, but its link
+  opens an entry form that marks nothing on the slug: drift leaves the
+  slug out on purpose (a marker would flash while it is typed), so only
+  the publish refusal marks it. Mark it in the form once the box has lost
+  focus, if editors miss it.
+- Content health does not check page slugs: pages refuse a bad slug at
+  create and rename, so only an import of older data or a hand edit could
+  hold one.
+
 ## Follow-ups (logged 2026-09-28, export/import spec)
 
 - `import --replace`: delete the space's content and media first, after
@@ -647,9 +719,6 @@ after both are on the registry. From the repo root:
 - Import cannot expire the app's cache tags; it prints a restart note. A
   revalidate call through the app (an op the CLI could reach) would make
   the note unnecessary.
-- A resumed import that lands nothing still prints the full "Imported …"
-  summary and the member list — accurate (the space holds all of it) but
-  noisy; count what actually landed and say "nothing new" when it is zero.
 
 ## Follow-ups (logged 2026-09-27, shadowed-page detector spec)
 
@@ -798,14 +867,6 @@ after both are on the registry. From the repo root:
 - A Deploying guide (nav lists it, unwritten) should show
   `npx smoodly migrate --check` as a build step.
 
-## Follow-ups (logged 2026-09-25, docs session)
-
-- `f.slug({ from })` stores `from` on the descriptor, but nothing reads it:
-  the admin never derives a slug from the named field. Either wire it (fill
-  the slug from `from` while the slug is untouched, in the entry form) or
-  drop the option. The Fields guide documents the slug as a plain text box
-  with the URL prefix and does not mention `from`.
-
 ## Follow-ups (logged 2026-09-17, admin path spec)
 
 - A robots `Disallow` for the admin path from `next/meta`.
@@ -1144,14 +1205,15 @@ tool — reset and reseed a development database (`supabase db reset`,
 - The Pages list's prompts are dialogs on the same card since the same
   day (`shell/PageDialogs.tsx` over `ui/Dialog.tsx`): New page / New
   path / New subpage / New subpath (title, slug following the title
-  through `slugify` in `shell/page-dialogs.ts`, page type when more than
+  through `slugify` in `paths.ts`, page type when more than
   one open template), Add page here (page type; skipped with one), Rename
   (title and slug; the home page's title alone). Still native: the
   `window.alert`s on a refused list op outside a dialog (`run` in
   PagesList, EntriesList's add/remove) — a notice banner is the follow-up.
-- `slugify` is the admin's first slugifier (title → segment); the slug
-  field widget (`f.slug`) does not use it yet, and neither does the entry
-  create-on-click. OQ 24 (unicode slugs) would relax its grammar.
+- `slugify` (`paths.ts`, exported) is the one slugifier; the slug-box
+  helpers in `admin/forms/slug-field.ts` (`followsTitle`, `tidySlug`,
+  `slugHint`, `withFollowingSlug`) serve the page dialogs, page Settings,
+  the `f.slug` widget and the entry form (spec 2026-09-28 ASCII slugs).
 - The dialog's fields take the tile tone on the white card
   (`.sm-dialog__form .sm-input`), the reverse of fields on tiles.
 - The confirm's copy lives at each call site (`title` / `body` /

package/dist/addresses.d.ts

@@ -0,0 +1,42 @@
+import { type LocaleSet } from "./paths.ts";
+/** owner key → locale → address, without slashes at either end (`company/news`). */
+export type Addresses = Record<string, Record<string, string>>;
+export declare const collectionKey: (name: string) => string;
+export declare const pageKey: (name: string) => string;
+/** The collection an owner key names, or null for a fixed page. */
+export declare const ownerCollection: (key: string) => string | null;
+export declare function assertAddress(address: string, what: string): void;
+/** The address's last part — what a code-owned record keeps in `page_locales.slug`. */
+export declare const lastPart: (address: string) => string;
+export type CodeAddress = {
+    /** The owner key stored in `pages.fixed`. */
+    key: string;
+    /** locale → address, in every supported locale: a locale the slug or path omits takes the default's,
+     *  as the entry derivation does (collectionSegment) — code owns an address in every locale. */
+    segments: Record<string, string>;
+    title: string;
+    /** The fixed page registration rendered at the address; null for a collection with no index page (a folder). */
+    template: string | null;
+    /** The collection whose address this is; null for a plain fixed page. */
+    collection: string | null;
+};
+type PageLike = {
+    schema: {
+        kind: string;
+        name: string;
+        title?: string;
+        slug?: string | Record<string, string>;
+    };
+};
+type CollectionLike = {
+    name: string;
+    title: string;
+    path?: string | Record<string, string>;
+};
+export declare function codeAddresses(input: {
+    locales: LocaleSet;
+    pages: ReadonlyArray<PageLike>;
+    collections: ReadonlyArray<CollectionLike>;
+}): CodeAddress[];
+export declare const addressMap: (list: CodeAddress[]) => Addresses;
+export {};

package/dist/addresses.js

@@ -0,0 +1,51 @@
+// Code-owned addresses (spec 2026-09-29 nested paths): what the registry
+// claims in the URL space, per locale, keyed by the owner a `pages.fixed`
+// column names. A fixed page's slug and a collection's path may have
+// several parts (`company/news`); each part is a segment under the ASCII
+// rule, so SEGMENT_RE stays the only gate. Pure: defineConfig, the
+// materializer, the stores, the site and the admin tree all read it here.
+import { assertSegment, fixedPageSegments } from "./paths.js";
+export const collectionKey = (name) => `collection:${name}`;
+export const pageKey = (name) => `page:${name}`;
+/** The collection an owner key names, or null for a fixed page. */
+export const ownerCollection = (key) => (key.startsWith("collection:") ? key.slice("collection:".length) : null);
+export function assertAddress(address, what) {
+    const parts = address.split("/");
+    if (parts.some((p) => p === "")) {
+        throw new Error(`smoodly: ${what} "${address}" has an empty part — write segments joined by single slashes, like "company/news".`);
+    }
+    for (const part of parts)
+        assertSegment(part, what);
+}
+/** The address's last part — what a code-owned record keeps in `page_locales.slug`. */
+export const lastPart = (address) => address.slice(address.lastIndexOf("/") + 1);
+export function codeAddresses(input) {
+    const def = input.locales.default;
+    const byDefault = new Map();
+    const out = [];
+    for (const p of input.pages) {
+        if (p.schema.kind !== "page" || p.schema.slug === undefined)
+            continue;
+        const segments = fixedPageSegments(p.schema.slug, input.locales);
+        const spec = { key: pageKey(p.schema.name), segments, title: p.schema.title ?? p.schema.name, template: p.schema.name, collection: null };
+        byDefault.set(segments[def], spec);
+        out.push(spec);
+    }
+    for (const c of input.collections) {
+        if (c.path === undefined)
+            continue;
+        const segments = fixedPageSegments(c.path, input.locales);
+        const index = byDefault.get(segments[def]);
+        if (index) {
+            // defineConfig proved the page sits on the collection's address in
+            // every locale: that record is the collection's, owned by it.
+            index.key = collectionKey(c.name);
+            index.collection = c.name;
+            index.title = c.title;
+            continue;
+        }
+        out.push({ key: collectionKey(c.name), segments, title: c.title, template: null, collection: c.name });
+    }
+    return out;
+}
+export const addressMap = (list) => Object.fromEntries(list.map((a) => [a.key, a.segments]));

package/dist/admin/editor/EditorView.js

@@ -891,7 +891,7 @@ export function EditorView({ ops, registry, id }) {
                                 trailing: registry.locales.supported.length > 1 && (_jsx(LocaleSwitcher, { registry: registry, present: record ? registry.locales.supported.filter((l) => record.locales[l]) : [locale], parentLocales: parentLocales, value: locale, adding: adding, onSwitch: (l) => { void switchLocale(l); }, onAdd: (l) => { void doAddLocale(l); } })),
                             },
                             { label },
-                        ] }) }), right: _jsxs(_Fragment, { children: [(touched || saveState === "error") && _jsx(SaveIndicator, { state: saveState, pending: dirty }), ready && (_jsx(LinkButton, { icon: true, href: siteUrl, 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: record?.locales[locale] ? localeStatusOf(record.locales[locale]) : null, pending: dirty || saveState !== "saved", busy: pageBusy, flash: published, onPublish: () => { void doPublish(); }, onDiscard: () => { void doDiscard(); }, onUnpublish: () => { void doUnpublish(); }, onHistory: () => { void doHistory(); } })] }) }), target && _jsx(PresenceLine, { names: editorsOf(others, target), noun: "page" }), stale && _jsx(StaleBanner, { info: stale, onReload: loadTheirs }), _jsx(DriftNotice, { draft: findings, live: liveFindings }), history && record?.locales[locale] && (_jsx(HistoryModal, { rows: history, draftId: record.locales[locale].draftVersionId, onClose: () => setHistory(null), onRestore: doRestore, render: (versionId) => _jsx("iframe", { className: "sm-history__frame", title: "Version preview", src: withVersionParam(siteUrl, versionId) }) })), _jsxs("div", { className: "sm-editor", inert: stale ? true : undefined, children: [_jsxs("div", { className: "sm-canvas", children: [(banner || diagnosis || crashedLines.length > 0) && (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8, padding: "0 20px 10px" }, children: [banner && (_jsxs(BannerBox, { tone: banner.fields && banner.fields.length > 0 ? "warn" : "error", onDismiss: () => setBanner(null), children: [_jsx("p", { children: banner.text }), _jsx(FieldErrorList, { fields: banner.fields ?? [] })] })), diagnosis && _jsx(CanvasWarning, { cause: diagnosis.cause, path: diagnosis.path }), crashedLines.length > 0 && (_jsx(BannerBox, { tone: "warn", children: crashedLines.map((line, i) => _jsx("p", { children: line }, i)) }))] })), _jsx("div", { className: "sm-canvas__scroll", ref: scrollerRef, onClick: (e) => { if (e.target === e.currentTarget)
+                        ] }) }), right: _jsxs(_Fragment, { children: [(touched || saveState === "error" || saveState === "refused") && _jsx(SaveIndicator, { state: saveState, pending: dirty }), ready && (_jsx(LinkButton, { icon: true, href: siteUrl, 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: record?.locales[locale] ? localeStatusOf(record.locales[locale]) : null, pending: dirty || saveState !== "saved", busy: pageBusy, flash: published, onPublish: () => { void doPublish(); }, onDiscard: () => { void doDiscard(); }, onUnpublish: () => { void doUnpublish(); }, onHistory: () => { void doHistory(); } })] }) }), target && _jsx(PresenceLine, { names: editorsOf(others, target), noun: "page" }), stale && _jsx(StaleBanner, { info: stale, onReload: loadTheirs }), _jsx(DriftNotice, { draft: findings, live: liveFindings }), history && record?.locales[locale] && (_jsx(HistoryModal, { rows: history, draftId: record.locales[locale].draftVersionId, onClose: () => setHistory(null), onRestore: doRestore, render: (versionId) => _jsx("iframe", { className: "sm-history__frame", title: "Version preview", src: withVersionParam(siteUrl, versionId) }) })), _jsxs("div", { className: "sm-editor", inert: stale ? true : undefined, children: [_jsxs("div", { className: "sm-canvas", children: [(banner || diagnosis || crashedLines.length > 0) && (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8, padding: "0 20px 10px" }, children: [banner && (_jsxs(BannerBox, { tone: banner.fields && banner.fields.length > 0 ? "warn" : "error", onDismiss: () => setBanner(null), children: [_jsx("p", { children: banner.text }), _jsx(FieldErrorList, { fields: banner.fields ?? [] })] })), diagnosis && _jsx(CanvasWarning, { cause: diagnosis.cause, path: diagnosis.path }), crashedLines.length > 0 && (_jsx(BannerBox, { tone: "warn", children: crashedLines.map((line, i) => _jsx("p", { children: line }, i)) }))] })), _jsx("div", { className: "sm-canvas__scroll", ref: scrollerRef, onClick: (e) => { if (e.target === e.currentTarget)
                                     setSelectedId(null); }, children: _jsxs("div", { className: "sm-page", style: { overflow: "hidden" }, children: [iframeSrc ? (_jsx("iframe", { ref: iframeRef, src: iframeSrc, title: "Page canvas", onLoad: onFrameLoad, style: { width: "100%", height: docH, border: 0, display: "block" } })) : (_jsx("div", { className: "sm-canvas__loading", children: "Loading canvas\u2026" })), _jsx(CanvasOverlay, { emptyZones: emptyZones, hoverRect: hoverRect, hoverGlobal: hoverGlobal, selection: selection, fieldHover: fieldHover, editing: editing, plusButtons: plusButtons, onPlus: (p, x, y) => setPicker({ zone: p.zone, index: p.index, x: x - 150, y: y + 12 }), onMove: doMove, onDuplicate: doDuplicate, onRemove: doRemove }), inline.richtext && (() => {
                                             const { session } = inline.richtext;
                                             const item = globalItemOf(session.node);
@@ -907,8 +907,10 @@ export function EditorView({ ops, registry, id }) {
                                                     else
                                                         mutate((t) => patchNodePath(t, session.node, session.path, doc));
                                                 }, onEscape: inline.end }));
-                                        })()] }) })] }), _jsx(ResizeHandle, {}), _jsxs("aside", { className: "sm-inspector", ref: inspectorRef, children: [_jsxs("div", { className: "sm-card", children: [selected && !selectedSection && !selectedItem ? (_jsx(UnknownNode, { node: selected, label: labelOf(selected), onRemove: () => { void doRemove(selected.id, true); } })) : selectedSection || selectedItem ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "sm-inspector__head", children: [_jsxs("span", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [_jsx("span", { className: "sm-blockglyph" }), _jsx("span", { className: "sm-title", style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: selectedSection?.title ?? (selectedItem ? `${selectedItem.title} · global` : null) }), selectedItem && (globalTouched || globalEdit.saveState === "error") && _jsx(SaveIndicator, { state: globalEdit.saveState, pending: globalDirty })] }), _jsx(IconButton, { label: "Clear selection", onClick: () => setSelectedId(null), children: "\u00D7" })] }), tabs.length > 0 && selectedSection && (_jsx(Tabs, { tabs: tabs.map((t) => t.tab), value: activeTab, onChange: (t) => setTab(t) }))] })) : record ? (_jsx(PageInspector, { record: record, locale: locale, registry: registry, tree: tree, path: paths[locale], redirects: redirects[locale] ?? [], fixed: isFixedNode(record, registry), onRename: onRename, onPatch: doPatchPage, drift: findingsAt.get("page") ?? [], onClearPageField: (key) => mutate((t) => ({ ...t, fields: unsetAtPath(t.fields ?? {}, key) })), onRemoveLocale: Object.keys(record.locales).length > 1 &&
-                                            !isFixedNode(record, registry) &&
+                                        })()] }) })] }), _jsx(ResizeHandle, {}), _jsxs("aside", { className: "sm-inspector", ref: inspectorRef, children: [_jsxs("div", { className: "sm-card", children: [selected && !selectedSection && !selectedItem ? (_jsx(UnknownNode, { node: selected, label: labelOf(selected), onRemove: () => { void doRemove(selected.id, true); } })) : selectedSection || selectedItem ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "sm-inspector__head", children: [_jsxs("span", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [_jsx("span", { className: "sm-blockglyph" }), _jsx("span", { className: "sm-title", style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: selectedSection?.title ?? (selectedItem ? `${selectedItem.title} · global` : null) }), selectedItem && (globalTouched || globalEdit.saveState === "error" || globalEdit.saveState === "refused") && _jsx(SaveIndicator, { state: globalEdit.saveState, pending: globalDirty })] }), _jsx(IconButton, { label: "Clear selection", onClick: () => setSelectedId(null), children: "\u00D7" })] }), tabs.length > 0 && selectedSection && (_jsx(Tabs, { tabs: tabs.map((t) => t.tab), value: activeTab, onChange: (t) => setTab(t) }))] })) : record ? (_jsx(PageInspector, { record: record, locale: locale, registry: registry, tree: tree, path: paths[locale], redirects: redirects[locale] ?? [], 
+                                        // Code-owned, or no longer in code (only deleting is open then): either way the URL is not the editor's.
+                                        fixed: isFixedNode(record, registry) || !!record.fixed, onRename: onRename, onPatch: doPatchPage, drift: findingsAt.get("page") ?? [], onClearPageField: (key) => mutate((t) => ({ ...t, fields: unsetAtPath(t.fields ?? {}, key) })), onRemoveLocale: Object.keys(record.locales).length > 1 &&
+                                            !record.fixed &&
                                             !(record.parentId === null && record.locales[registry.locales.default]?.slug === registry.homePageSlug)
                                             ? () => { void doRemoveLocale(); }
                                             : undefined })) : null, (selectedSection || selectedItem) && (_jsxs("div", { className: "sm-inspector__body", children: [selected && findingsAt.get(selected.id)?.filter((f) => f.kind === "zone-disallowed").map((f) => (_jsx("p", { className: "sm-outline-note", children: driftMessage(f) }, f.path))), selected && selectedSection && (_jsx(InspectorFields, { groups: activeGroups, values: selected, render: ({ key, ns, descriptor }, { emptyLabel, scope }) => (_jsx(FieldWidget, { fieldKey: key, descriptor: descriptor, value: valueOf(selected, { key, ns, descriptor }), emptyLabel: emptyLabel, scope: scope, errors: ns === "css" ? undefined : misfitErrorsIn(findingsAt.get(selected.id) ?? [], selected.id, ns), refOptions: ns === "fields" || ns === "settings" ? refOptionsFor(refOptions, refTargets, selectedSection, ns, key, descriptor) : undefined, inlinePath: ns === "fields" && inline.session?.node === selected.id ? inline.session.path : undefined, onEditHere: () => { const p = inline.session?.path; inline.end(); if (p)

package/dist/admin/editor/PageSettings.js

@@ -11,8 +11,10 @@ import { useEffect, useRef, useState } from "react";
 import { updatedLine } from "../ui/format.js";
 import { Field, InfoRow, SectionLabel } from "../ui/primitives.js";
 import { confirmLiveUrl } from "../shell/live-url.js";
+import { codeAddressNote } from "../shell/pages-tree.js";
 import { RouteLink } from "../shell/RouteLink.js";
 import { useAdminHref } from "../shell/base.js";
+import { tidySlug } from "../forms/slug-field.js";
 export function PageSettings({ record, locale, registry, path, fixed, redirects, onRename }) {
     const row = record.locales[locale];
     const [draft, setDraft] = useState({ title: row?.title ?? "", slug: row?.slug ?? "" });
@@ -33,7 +35,10 @@ export function PageSettings({ record, locale, registry, path, fixed, redirects,
         committing.current = true;
         try {
             setError(null);
-            const next = draft[key];
+            // A slug tidies before it is committed (spec 2026-09-28 ASCII slugs §4).
+            const next = key === "slug" ? tidySlug(draft.slug) : draft[key];
+            if (next !== draft[key])
+                setDraft((d) => ({ ...d, [key]: next }));
             if (next === row[key])
                 return;
             if (next === "") {
@@ -43,7 +48,7 @@ export function PageSettings({ record, locale, registry, path, fixed, redirects,
             // A published slug is a live URL: one confirm with the redirect box, Cancel restores the input (members management §5, redirects §6).
             let redirect = true;
             if (key === "slug") {
-                const live = await confirmLiveUrl({ status: row.status, from: row.slug, to: next }, { name: row.title, path });
+                const live = await confirmLiveUrl({ status: row.status, from: row.slug, to: next }, { name: row.title, path }, codeAddressNote(path ?? null, registry, locale));
                 if (!live.ok) {
                     setDraft((d) => ({ ...d, slug: row.slug }));
                     return;

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

@@ -1,5 +1,6 @@
 import type { OpResult } from "../ops.ts";
-export type SaveState = "saved" | "saving" | "error" | "stale";
+/** `refused`: the op refused the value itself (a validation error) — not retried; the next edit saves. */
+export type SaveState = "saved" | "saving" | "error" | "stale" | "refused";
 export type DraftAutosave = {
     /** Record a local change; a debounced save follows. */
     mark(): void;

package/dist/admin/editor/autosave.js

@@ -52,6 +52,12 @@ export function createDraftAutosave(opts) {
             setState("stale");
             return false;
         }
+        else if (result.code === "validation") {
+            // The same value would be refused again (spec 2026-09-28 ASCII slugs): no
+            // retry — the caller shows the field errors, and the next edit saves.
+            setState("refused");
+            return false;
+        }
         else {
             // Keep local state; retry with a doubling, capped delay.
             setState("error");

package/dist/admin/editor/useCanvasBridge.js

@@ -22,8 +22,24 @@ export function useCanvasBridge({ iframeRef, iframeSrc, onSelect, onHover, onRen
     // A new canvas URL (a locale switch, a rename) means new geometry — the
     // previous page's rects are stale the instant the iframe starts loading
     // a different route, so clear them alongside resetting geometry.
-    useEffect(() => { setGeometry("waiting"); setLoaded(false); setRects([]); setEmptyZones([]); setFields([]); setCrashed([]); }, [iframeSrc]);
+    // A refresh posted before this canvas's bridge has spoken reaches the loading document and is lost, while the
+    // server may have rendered the page before the save it announces (a fill saved as the frame loads): it is sent
+    // again on the bridge's first message.
+    const heard = useRef(false);
+    const missedRefresh = useRef(false);
+    useEffect(() => {
+        setGeometry("waiting");
+        setLoaded(false);
+        setRects([]);
+        setEmptyZones([]);
+        setFields([]);
+        setCrashed([]);
+        heard.current = false;
+        missedRefresh.current = false;
+    }, [iframeSrc]);
     const postToCanvas = useCallback((m) => {
+        if (m.kind === "refresh" && !heard.current)
+            missedRefresh.current = true;
         iframeRef.current?.contentWindow?.postMessage(m, "*");
     }, [iframeRef]);
     useEffect(() => {
@@ -34,6 +50,13 @@ export function useCanvasBridge({ iframeRef, iframeSrc, onSelect, onHover, onRen
             if (e.source !== iframeRef.current?.contentWindow)
                 return;
             setGeometry("ok"); // any bridge message: Smoodly rendered the canvas with its bridge
+            if (!heard.current) {
+                heard.current = true;
+                if (missedRefresh.current) {
+                    missedRefresh.current = false;
+                    postToCanvas({ source: "smoodly", kind: "refresh" });
+                }
+            }
             if (m.kind === "rects") {
                 setRects(m.nodes);
                 setEmptyZones(m.emptyZones);
@@ -53,7 +76,7 @@ export function useCanvasBridge({ iframeRef, iframeSrc, onSelect, onHover, onRen
         };
         window.addEventListener("message", onMessage);
         return () => window.removeEventListener("message", onMessage);
-    }, [iframeRef]);
+    }, [iframeRef, postToCanvas]);
     useEffect(() => {
         if (!iframeSrc || !loaded || geometry !== "waiting")
             return;

package/dist/admin/fixed-nodes.d.ts

@@ -1,29 +1,14 @@
 import type { ResolvedConfig } from "../config.ts";
 import type { PageRecord, PageStore } from "../store.ts";
-export type FixedNode = {
-    /** The node's segment per locale it exists in. A fixed page always
-     *  carries every supported locale — a slug map that omits one falls
-     *  back to the default locale's segment, same as a string slug. A
-     *  collection mount's segments are the collection's path exactly:
-     *  every supported locale for a string path, exactly its keys for a
-     *  per-locale map. */
-    segments: Record<string, string>;
-    title: string;
-    /** The fixed page registration's name; null for a plain mount (a folder). */
-    template: string | null;
-    /** The collection whose `path` this node is; null for a plain fixed page. */
-    collection: string | null;
-};
-export declare function fixedNodeSpecs(config: ResolvedConfig): FixedNode[];
-/** The spec a ROOT record materializes, or null for an editor-owned node.
- *  Judged by the default-locale slug only — a root that exists in Finnish
- *  alone is never a fixed node, whatever its Finnish slug. */
+import { type CodeAddress } from "../addresses.ts";
+export type FixedNode = CodeAddress;
+export declare const fixedNodeSpecs: (config: ResolvedConfig) => FixedNode[];
+/** The spec that owns a record, or null for an editor's page and for a record no registration owns any more. */
 export declare function fixedNodeOf(record: {
-    parentId: string | null;
-    locales: Record<string, {
-        slug: string;
-    }>;
+    fixed?: string | null;
 }, config: ResolvedConfig): FixedNode | null;
-/** Create every fixed node that has no root record yet, give every fixed
- *  node the locales it lacks, then list. */
+/** Create every code-owned record that has none yet and give each the
+ *  locales it lacks, then list. Code wins an address (spec 2026-09-29
+ *  anchored paths §4): an editor's page already there changes nothing
+ *  here — the index serves the record, the Pages list flags the page. */
 export declare function ensureFixedNodes(pages: PageStore, config: ResolvedConfig): Promise<PageRecord[]>;

package/dist/admin/fixed-nodes.js

@@ -1,97 +1,61 @@
-import { fixedPageSegments, perLocaleSegments } from "../paths.js";
-export function fixedNodeSpecs(config) {
-    const { default: def, supported } = config.locales;
-    const perLocale = (v) => perLocaleSegments(v, supported);
-    const specs = new Map();
-    for (const p of config.registry.pages ?? []) {
-        if (p.schema.kind !== "page" || p.schema.slug === undefined)
-            continue;
-        // Fixed pages exist in every supported locale (spec 2026-09-06 §3): a
-        // slug map that omits a locale falls back to the default locale's
-        // segment. One helper fills it for the boot check (config.ts), here
-        // and fixedPathFor (localize.ts), so the three cannot drift.
-        const segments = fixedPageSegments(p.schema.slug, config.locales);
-        specs.set(segments[def], {
-            segments,
-            title: p.schema.title ?? p.schema.name,
-            template: p.schema.name,
-            collection: null,
-        });
-    }
-    for (const c of config.registry.collections ?? []) {
-        if (c.path === undefined)
-            continue;
-        const segments = perLocale(c.path);
-        const indexPage = specs.get(segments[def]);
-        if (indexPage) {
-            // defineConfig proved the page sits at the collection's segment in
-            // every locale: that page IS the mount — the collection's index page.
-            indexPage.collection = c.name;
-            continue;
-        }
-        specs.set(segments[def], { segments, title: c.title, template: null, collection: c.name });
-    }
-    return [...specs.values()];
-}
-/** The spec a ROOT record materializes, or null for an editor-owned node.
- *  Judged by the default-locale slug only — a root that exists in Finnish
- *  alone is never a fixed node, whatever its Finnish slug. */
+import { codeAddresses, lastPart } from "../addresses.js";
+export const fixedNodeSpecs = (config) => codeAddresses({ locales: config.locales, pages: config.registry.pages ?? [], collections: config.registry.collections ?? [] });
+/** The spec that owns a record, or null for an editor's page and for a record no registration owns any more. */
 export function fixedNodeOf(record, config) {
-    if (record.parentId !== null)
-        return null;
-    const def = config.locales.default;
-    const slug = record.locales[def]?.slug;
-    if (slug === undefined)
-        return null;
-    return fixedNodeSpecs(config).find((s) => s.segments[def] === slug) ?? null;
+    return record.fixed ? fixedNodeSpecs(config).find((s) => s.key === record.fixed) ?? null : null;
 }
-/** Create every fixed node that has no root record yet, give every fixed
- *  node the locales it lacks, then list. */
+/** Create every code-owned record that has none yet and give each the
+ *  locales it lacks, then list. Code wins an address (spec 2026-09-29
+ *  anchored paths §4): an editor's page already there changes nothing
+ *  here — the index serves the record, the Pages list flags the page. */
 export async function ensureFixedNodes(pages, config) {
     const def = config.locales.default;
     const all = await pages.listPages();
-    const roots = all.filter((p) => p.parentId === null);
-    let attempted = false;
+    let wrote = false;
     for (const spec of fixedNodeSpecs(config)) {
-        const slug = spec.segments[def];
-        let record = roots.find((p) => p.locales[def]?.slug === slug);
+        let record = all.find((p) => p.fixed === spec.key);
+        const defAddress = spec.segments[def];
         if (!record) {
-            attempted = true;
+            wrote = true;
             try {
-                record = await pages.createPage({ locale: def, slug, template: spec.template, title: spec.title });
+                record = await pages.createPage({ locale: def, slug: lastPart(defAddress), template: spec.template, title: spec.title, fixed: spec.key });
             }
             catch (e) {
                 // Two admins loading at once race on this very create; the loser's
-                // slugTaken is the other one winning, not a failure, so it skips
-                // silently — no warn. Anything else is worth saying out loud.
+                // fixedTaken is the other one winning. Anything else is said out loud.
                 const message = e instanceof Error ? e.message : String(e);
-                if (!message.includes("already exists")) {
-                    console.warn(`smoodly: could not materialize "${slug}": ${message}`);
-                }
+                if (!message.includes("already exists"))
+                    console.warn(`smoodly: could not materialize "${defAddress}": ${message}`);
                 continue;
             }
         }
-        // Every locale the registration names — including one added to the
-        // config after the record was first materialized.
-        for (const [locale, segment] of Object.entries(spec.segments)) {
+        else if (record.template === null && spec.template !== null) {
+            // The collection gained its index page. A racing admin's hasTemplate is that admin winning.
+            wrote = true;
+            try {
+                record = await pages.setTemplate(record.id, spec.template);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                if (!message.includes("already has a page type"))
+                    console.warn(`smoodly: could not give "${defAddress}" its page type: ${message}`);
+            }
+        }
+        // Every locale the registration names — including one added to the config after the record was first materialized.
+        for (const [locale, address] of Object.entries(spec.segments)) {
             if (record.locales[locale])
                 continue;
-            attempted = true;
+            wrote = true;
             try {
-                record = await pages.addLocale(record.id, locale, { from: def, slug: segment });
+                record = await pages.addLocale(record.id, locale, { from: def, slug: lastPart(address) });
             }
             catch (e) {
-                // One locale's row that cannot land — a segment or path an editor
-                // already claimed there — must not take the node or the whole list
-                // down: warn, skip that locale, keep materializing the rest. Only a
-                // concurrent add of the SAME locale is a race, and it skips silently.
+                // Only a concurrent add of the SAME locale is a race; it skips silently.
                 const message = e instanceof Error ? e.message : String(e);
-                if (!message.includes("already exists in locale")) {
-                    console.warn(`smoodly: could not materialize "${slug}" in "${locale}": ${message}`);
-                }
+                if (!message.includes("already exists in locale"))
+                    console.warn(`smoodly: could not materialize "${address}" in "${locale}": ${message}`);
             }
         }
     }
-    // A create was tried, so the pre-race list is stale either way.
-    return attempted ? pages.listPages() : all;
+    return wrote ? pages.listPages() : all;
 }

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

@@ -6,7 +6,7 @@ export type WidgetScope = {
     fields?: Record<string, unknown>;
     settings?: Record<string, unknown>;
 };
-export declare function FieldWidget({ descriptor: d, value: valueProp, onChange, errors, path: pathProp, bare, refOptions, suggestions, fieldKey, prefix, mark, inlinePath, onEditHere, scope, emptyLabel, }: {
+export declare function FieldWidget({ descriptor: d, value: valueProp, onChange, errors, path: pathProp, bare, refOptions, suggestions, fieldKey, prefix, mark, inlinePath, onEditHere, scope, emptyLabel, hint, onBlur, }: {
     descriptor: AdminField;
     value: unknown;
     onChange(value: unknown): void;
@@ -30,6 +30,10 @@ export declare function FieldWidget({ descriptor: d, value: valueProp, onChange,
     scope?: WidgetScope;
     /** An optional radio's empty pill; `None` unless the caller says otherwise (`Default` for a styles step). */
     emptyLabel?: string;
+    /** A line under the field — the slug field's no-letters hint (spec 2026-09-28 ASCII slugs §6). */
+    hint?: string;
+    /** After a slug field's tidy on blur — the entry form commits a held live slug here. */
+    onBlur?(): void;
 }): ReactElement;
 /** The richtext field while it is edited in the canvas (spec 2026-09-10 §5). */
 export declare function InlineNote({ onEditHere }: {

package/dist/admin/forms/FieldWidget.js

@@ -12,9 +12,10 @@ import { isHidden } from "../../conditions.js";
 import { cssProblem } from "../../css.js";
 import { Button, Field, Switch } from "../ui/primitives.js";
 import { patchObject } from "./list.js";
+import { tidySlug } from "./slug-field.js";
 /** A key as a caption, sentence case: `spacingTop` → "Spacing top", `css` → "Custom CSS". */
 const label = (key) => key === "css" ? "Custom CSS" : key.replace(/([A-Z])/g, (c) => ` ${c.toLowerCase()}`).replace(/^./, (c) => c.toUpperCase());
-export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors, path: pathProp, bare, refOptions, suggestions, fieldKey, prefix, mark, inlinePath, onEditHere, scope, emptyLabel, }) {
+export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors, path: pathProp, bare, refOptions, suggestions, fieldKey, prefix, mark, inlinePath, onEditHere, scope, emptyLabel, hint, onBlur, }) {
     const path = pathProp ?? fieldKey;
     // A tags field has no per-chip slot: the first item error shows under the field.
     const below = d.type === "tags" && errors ? Object.keys(errors).find((k) => k.startsWith(`${path}.`)) : undefined;
@@ -33,7 +34,9 @@ export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors,
         case "text":
         case "link":
         case "slug": {
-            const input = (_jsx("input", { className: d.type === "slug" ? "sm-input sm-input--mono" : "sm-input", value: String(value ?? ""), onChange: (e) => onChange(e.target.value) }));
+            // A slug tidies when it loses focus (spec 2026-09-28 ASCII slugs §4).
+            const input = (_jsx("input", { className: d.type === "slug" ? "sm-input sm-input--mono" : "sm-input", value: String(value ?? ""), onChange: (e) => onChange(e.target.value), onBlur: d.type === "slug" ? (e) => { const tidy = tidySlug(e.target.value); if (tidy !== e.target.value)
+                    onChange(tidy); onBlur?.(); } : undefined }));
             control = d.type === "slug" && prefix
                 ? _jsxs("span", { className: "sm-inputwrap", children: [_jsx("span", { className: "sm-prefix", children: prefix }), input] })
                 : input;
@@ -143,7 +146,7 @@ export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors,
     // A <label> activates its first labelable descendant, so it may only wrap a
     // single control — around refList's rows, an object's fieldset or a list's
     // rows it would turn every click into a press of the first button.
-    return (_jsx(Field, { label: label(fieldKey), mark: mark, counter: counter, error: message, asDiv: asDiv, path: path, children: control }));
+    return (_jsx(Field, { label: label(fieldKey), mark: mark, counter: counter, hint: hint, error: message, asDiv: asDiv, path: path, children: control }));
 }
 /** The richtext field while it is edited in the canvas (spec 2026-09-10 §5). */
 export function InlineNote({ onEditHere }) {

package/dist/admin/forms/slug-field.d.ts

@@ -0,0 +1,17 @@
+/** 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 declare function followsTitle(slug: string, previousTitle: string): boolean;
+/** Under a slug box whose source text makes no slug (§6). */
+export declare const NO_LETTERS_HINT = "This title has no letters a slug can use \u2014 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 declare function tidySlug(value: string): string;
+/** NO_LETTERS_HINT when `source` has text but no slug in it (§6). */
+export declare function slugHint(source: unknown): string | 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 declare function withFollowingSlug(fields: Record<string, unknown>, key: string, value: unknown, from: string | undefined, neverPublished: boolean): Record<string, unknown>;