smoodly 0.0.33 → 0.0.35

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

@@ -64,6 +64,7 @@ import { PublishControl } from "../ui/PublishControl.js";
 import { confirm, DISCARD_CONFIRM } from "../ui/confirm.js";
 import { HistoryModal, historyRows } from "../ui/HistoryModal.js";
 import { draftToken } from "../../draft-token.js";
+import { useUnloadGuard } from "../shell/router.js";
 import { isStale, staleInfoOf } from "../shell/stale.js";
 import { StaleBanner } from "../ui/StaleBanner.js";
 import { DriftNotice } from "../ui/DriftNotice.js";
@@ -150,9 +151,14 @@ export function EditorView({ ops, registry, id }) {
             const r = await ops.pages.saveDraft(id, target, t, token());
             if (r.ok) {
                 // The badge and Publish follow each save without a re-get: saveDraft answers with the version id and the new token.
-                setRecord((rec) => rec?.locales[target]
-                    ? { ...rec, locales: { ...rec.locales, [target]: { ...rec.locales[target], draftVersionId: r.data.versionId, draftSavedAt: r.data.draft?.savedAt ?? null } } }
-                    : rec);
+                // The ref moves with the ack, not with the next render: a save that follows an unmounted view's
+                // (close()) must carry this token, and no render will ever run to refresh it (review I3).
+                const rec = recordRef.current;
+                if (rec?.locales[target]) {
+                    const next = { ...rec, locales: { ...rec.locales, [target]: { ...rec.locales[target], draftVersionId: r.data.versionId, draftSavedAt: r.data.draft?.savedAt ?? null } } };
+                    recordRef.current = next;
+                    setRecord(next);
+                }
                 setDirty(false);
                 presence?.announce(pageTarget(target), r.data.draft?.savedAt ?? null);
             }
@@ -166,6 +172,7 @@ export function EditorView({ ops, registry, id }) {
     // autosave (spec 2026-09-13 §4); the save ack refreshes the canvas
     // through the same inline-session deferral as the page's.
     const globalEdit = useGlobalEdit({ ops, onSaved: (name) => { setGlobalDirty(false); inlineRef.current?.onSaved(); presence?.announce({ kind: "global", id: name, locale }, null); } });
+    useUnloadGuard(dirty || saveState !== "saved" || globalDirty || globalEdit.saveState !== "saved");
     const patchGlobal = (name, path, value) => {
         globalEdit.patch(name, path, value);
         setGlobalDirty(true);
@@ -907,8 +914,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" || 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] ?? [], 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,6 +11,7 @@ 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";
@@ -47,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

@@ -12,6 +12,11 @@ export type DraftAutosave = {
     subscribe(listener: () => void): () => void;
     /** Cancel pending timers; call on unmount. */
     dispose(): void;
+    /** Unmount: save a pending edit now, cancel the timers, and retry nothing
+     *  afterwards (spec 2026-09-29 pre-install fixes §4). */
+    close(): Promise<boolean>;
+    /** Undo `close()` when the hook's effect runs again (React StrictMode mounts, cleans up, mounts). */
+    reopen(): void;
     /** Leave `stale` after the record was reloaded: timers cleared, the reloaded value counts as saved. */
     reset(): void;
 };
@@ -26,7 +31,7 @@ export declare function createDraftAutosave<T>(opts: {
 export type DraftAutosaveOptions<T> = Parameters<typeof createDraftAutosave<T>>[0];
 /** React glue: one controller per mount, always calling the latest
  *  `read`/`persist`/`onSaved` (their identities change on every render —
- *  `ops` and `slug` are props), timers cleared on unmount. */
+ *  `ops` and `slug` are props), a pending edit saved on unmount. */
 export declare function useDraftAutosave<T>(opts: DraftAutosaveOptions<T>): {
     saveState: SaveState;
     mark: () => void;

package/dist/admin/editor/autosave.js

@@ -12,13 +12,24 @@ export function createDraftAutosave(opts) {
     let revision = 0;
     let savedRevision = 0;
     let state = "saved";
+    let closed = false;
+    /** The save on the wire, if any: close() waits for it instead of racing it with a second save. */
+    let inflight = null;
     const listeners = new Set();
     const setState = (next) => {
         state = next;
         for (const l of listeners)
             l();
     };
-    const save = async () => {
+    const save = () => {
+        const run = send();
+        inflight = run;
+        const clear = () => { if (inflight === run)
+            inflight = null; };
+        run.then(clear, clear);
+        return run;
+    };
+    const send = async () => {
         const current = opts.read();
         if (current === null)
             return true;
@@ -60,6 +71,10 @@ export function createDraftAutosave(opts) {
         }
         else {
             // Keep local state; retry with a doubling, capped delay.
+            if (closed) {
+                setState("error");
+                return false;
+            }
             setState("error");
             const delay = retryDelay;
             retryDelay = Math.min(delay * 2, retryCapMs);
@@ -102,6 +117,28 @@ export function createDraftAutosave(opts) {
                 retryTimer = null;
             }
         },
+        close() {
+            closed = true;
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = null;
+            }
+            if (retryTimer) {
+                clearTimeout(retryTimer);
+                retryTimer = null;
+            }
+            // A save in flight holds the token the next one must carry, and only its ack moves it (review I3):
+            // wait, then send whatever the ack did not cover.
+            const remainder = () => {
+                if (state === "stale")
+                    return Promise.resolve(false);
+                if (revision === savedRevision)
+                    return Promise.resolve(true);
+                return save();
+            };
+            return inflight ? inflight.then(remainder) : remainder();
+        },
+        reopen() { closed = false; },
         reset() {
             if (debounceTimer) {
                 clearTimeout(debounceTimer);
@@ -119,7 +156,7 @@ export function createDraftAutosave(opts) {
 }
 /** React glue: one controller per mount, always calling the latest
  *  `read`/`persist`/`onSaved` (their identities change on every render —
- *  `ops` and `slug` are props), timers cleared on unmount. */
+ *  `ops` and `slug` are props), a pending edit saved on unmount. */
 export function useDraftAutosave(opts) {
     const latest = useRef(opts);
     latest.current = opts;
@@ -131,7 +168,10 @@ export function useDraftAutosave(opts) {
         retryBaseMs: opts.retryBaseMs,
         retryCapMs: opts.retryCapMs,
     }));
-    useEffect(() => () => controller.dispose(), [controller]);
+    useEffect(() => {
+        controller.reopen();
+        return () => { void controller.close(); };
+    }, [controller]);
     const saveState = useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
     return { saveState, mark: controller.mark, flush: controller.flush, reset: controller.reset };
 }

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/list.js

@@ -1,3 +1,6 @@
+// The list widget's logic as pure functions over plain arrays and objects,
+// so it is tested without a DOM. FieldWidget renders; this file decides.
+import { optionsOf } from "../../fields.js";
 /** An empty item: an object of its subfields' defaults, else the default. */
 export function emptyValue(d) {
     if (d.type === "object") {
@@ -9,7 +12,13 @@ export function emptyValue(d) {
         }
         return out;
     }
-    return d.default;
+    if (d.default !== undefined)
+        return d.default;
+    // A required choice shows its first option (FieldWidget renders no blank
+    // one), so it stores it too — a new item never looks set while it is empty.
+    if ((d.type === "select" || d.type === "radio") && d.optional !== true)
+        return optionsOf(d.options)[0]?.value;
+    return undefined;
 }
 export function addItem(items, list) {
     if (typeof list.max === "number" && items.length >= list.max)

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 };
 }